[T106][ZXW-22]7520V3SCV2.01.01.02P42U09_VEC_V0.8_AP_VEC origin source commit
Change-Id: Ic6e05d89ecd62fc34f82b23dcf306c93764aec4b
diff --git a/ap/lib/libatext/ext_socket_func.c b/ap/lib/libatext/ext_socket_func.c
new file mode 100755
index 0000000..1019216
--- /dev/null
+++ b/ap/lib/libatext/ext_socket_func.c
@@ -0,0 +1,1635 @@
+#ifndef CONFIG_MIN_8M_VERSION
+#include "softap_api.h"
+#include "ext_socket_func.h"
+#include <math.h>
+#include "at_com.h"
+
+struct netsrv_msg netsrv = {0};
+
+//IPµØÖ·¸ñʽ¼ì²é
+int check_ipaddr_legal(char* ipaddr)
+{
+ char* pointer_tmp_start = NULL;
+ char* pointer_tmp_end = NULL;
+ char str_tmp[64] = {0};
+ int ipaddr_len = strlen(ipaddr);
+ int num = 0;
+ int i = 0;
+
+ pointer_tmp_end = strchr(ipaddr, '.');
+ if (pointer_tmp_end == NULL) {
+ return 0;
+ }
+ if((int)(pointer_tmp_end - ipaddr) < sizeof(str_tmp))
+ snprintf(str_tmp,(int)(pointer_tmp_end - ipaddr)+1,"%s",ipaddr);
+ //strncpy(str_tmp, ipaddr, (int)(pointer_tmp_end - ipaddr));
+ num = atoi(str_tmp);
+
+ if (num < 0 || num > 255) {
+ return 0;
+ }
+ for (i = 0; i < 2; i++) {
+ pointer_tmp_start = pointer_tmp_end + 1;
+ if (pointer_tmp_start >= ipaddr + ipaddr_len) {
+ return 0;
+ }
+ pointer_tmp_end = strchr(pointer_tmp_start, '.');
+ if (pointer_tmp_end == NULL) {
+ return 0;
+ }
+ memset(str_tmp, 0, sizeof(str_tmp));
+ if((int)(pointer_tmp_end - pointer_tmp_start) < sizeof(str_tmp))
+ snprintf(str_tmp,(int)(pointer_tmp_end - pointer_tmp_start)+1,"%s",pointer_tmp_start);
+ //strncpy(str_tmp, pointer_tmp_start, (int)(pointer_tmp_end - pointer_tmp_start));
+ num = atoi(str_tmp);
+ if (num < 0 || num > 255) {
+ return 0;
+ }
+ }
+ pointer_tmp_start = pointer_tmp_end + 1;
+ if (pointer_tmp_start >= ipaddr + ipaddr_len) {
+ return 0;
+ }
+ pointer_tmp_end = ipaddr + ipaddr_len;
+ memset(str_tmp, 0, sizeof(str_tmp));
+ if((int)(ipaddr + ipaddr_len - pointer_tmp_start) < sizeof(str_tmp))
+ snprintf(str_tmp,(int)(ipaddr + ipaddr_len - pointer_tmp_start)+1,"%s",pointer_tmp_start);
+ //strncpy(str_tmp, pointer_tmp_start, (int)(ipaddr + ipaddr_len - pointer_tmp_start));
+ num = atoi(str_tmp);
+ if (num < 0 || num > 255) {
+ return 0;
+ }
+ return 1;
+}
+
+//========================================================================================================//
+//¹úµçsocket·½°¸º¯ÊýʵÏÖÇø
+//========================================================================================================//
+/*
+ at+mynetsrv=1,2,2,0,"192.168.30.201:5100¡±
+*/
+int ext_netsrv_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct netsrv_msg *srv = malloc(sizeof(struct netsrv_msg));
+ assert(srv);
+ char * pos_colon = NULL;
+ char * port = NULL;
+ char *at_str = NULL;
+ char *p[5] = {&srv->ch_id, &srv->socketid, &srv->conn_type, &srv->viewMode, srv->ipport};
+ char *c = NULL;
+ char ipport[128];
+ memset(srv, 0x00, sizeof(struct netsrv_msg));
+ if(5 != parse_param2("%d,%d,%d,%d,%s", at_paras, p)){
+ goto error;
+ }
+ //²ÎÊý¼ì²é
+ memcpy(ipport, srv->ipport, sizeof(ipport));
+ pos_colon = strchr(ipport, ':');
+ port = pos_colon + 1;
+ if ((srv->socketid < 0 || srv->socketid >= 6)
+ || (srv->viewMode != 0 && srv->viewMode != 1)
+ || (srv->conn_type < 0 || srv->conn_type > 2)
+ || (srv->ch_id < 0 || srv->ch_id >= 6)
+ || pos_colon == NULL
+ || (atoi(port) < 0 || atoi(port) > 65535)) {
+ goto error;
+ }
+ *pos_colon = '\0';
+ c = ipport;
+ //°´×Ö½ÚÑ»·¼ì²éÊÇ·ñº¬ÓÐ×Öĸ£¬ÈçÓÐÔòbreak
+ while (*c) {
+ if (isalpha(*c))
+ break;
+ c++;
+ }
+ if (!*c) {
+ if (check_ipaddr_legal(ipport) == 0) {
+ goto error;
+ }
+ }
+ netsrv = *srv;//Ϊ²éѯÓÃ
+ *res_msg = srv;
+ *res_msglen = sizeof(struct netsrv_msg);
+ return AT_CONTINUE;
+
+error:
+ free(srv);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+}
+int ext_netsrv_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct comm_rspmsg *msg = (struct comm_rspmsg*)rsp_msg;
+ char *at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+
+ if (msg->ret < 0) {
+ sprintf(at_str, "\r\nERROR: %d\r\n", msg->err);
+ } else {
+ sprintf(at_str, "\r\nOK\r\n");
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_netopen_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct comm_reqmsg *reqmsg = malloc(sizeof(struct comm_reqmsg));
+ assert(reqmsg);
+ char *at_str = NULL;
+ char *p[1] = {&reqmsg->socketid};
+ memset(reqmsg, 0x00, sizeof(struct comm_reqmsg));
+ if(1 != parse_param2("%d", at_paras, p)){
+ free(reqmsg);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+ }
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct comm_reqmsg);
+ return AT_CONTINUE;
+}
+int ext_netopen_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct comm_rspmsg *msg = (struct comm_rspmsg*)rsp_msg;
+ char *at_str = malloc(64);
+ assert(at_str);
+ char param[10] = {0};
+ int offset = 0;
+ memset(at_str, 0x00, 64);
+
+ if (msg->ret < 0) {
+ sprintf(at_str, "\r\nERROR: %d\r\n", msg->err);
+ } else {
+ if (msg->remote_mss) {
+ offset += sprintf(at_str + offset, "\r\n$MYNETOPEN: %d,%d\r\n", msg->socketid, msg->remote_mss);
+ } else {
+ offset += sprintf(at_str + offset, "\r\n$MYNETOPEN: %d\r\n", msg->socketid);
+ }
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+
+}
+int ext_netread_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct comm_reqmsg *reqmsg = malloc(sizeof(struct comm_reqmsg));
+ assert(reqmsg);
+ char *at_str = NULL;
+ char *p[2] = {&reqmsg->socketid, &reqmsg->len};
+ memset(reqmsg, 0x00, sizeof(struct comm_reqmsg));
+ if(2 != parse_param2("%d,%d", at_paras, p)){
+ free(reqmsg);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+ }
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct comm_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_netread_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct comm_rspmsg *msg = (struct comm_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+ int offset = 0;
+
+ if (msg->ret < 0) {
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: %d\r\n", msg->err);
+ offset = strlen(at_str);
+ } else if (msg->len == 0) {
+ at_str = malloc(64);
+ assert(at_str);
+ memset(at_str, 0x00, 64);
+ sprintf(at_str, "\r\n$MYNETREAD: %d,0\r\n\r\nOK\r\n", msg->socketid);
+ offset = strlen(at_str);
+ } else {
+ int viewmode = msg->viewmode;
+ char *data = ((char *)rsp_msg + sizeof(struct comm_rspmsg));
+ if (viewmode == 0) { //hexģʽ
+ int i = 0;
+ at_str = malloc(64 + msg->len);
+ assert(at_str);
+ memset(at_str, 0x00, 64 + msg->len);
+ offset += sprintf(at_str + offset, "\r\n$MYNETREAD: %d,%d\r\n", msg->socketid, msg->len);
+ memcpy(at_str + offset, data, msg->len);
+ offset += msg->len;
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ } else { //textģʽ
+ //int i = 0;
+ at_str = malloc(64 + msg->len * 2);
+ assert(at_str);
+ memset(at_str, 0x00, 64 + msg->len * 2);
+ offset += sprintf(at_str + offset, "\r\n$MYNETREAD: %d,%d\r\n", msg->socketid, msg->len);
+ memcpy(at_str + offset, data, msg->len);
+ offset += msg->len;
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ }
+ }
+ *ret = at_str;
+ *retlen = offset;
+ return AT_END;
+
+}
+
+int ext_sendbuf_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct comm_reqmsg *reqmsg = malloc(sizeof(struct comm_reqmsg));
+ assert(reqmsg);
+ char *at_str = NULL;
+ char *p[2] = {&reqmsg->socketid, &reqmsg->len};
+ memset(reqmsg, 0x00, sizeof(struct comm_reqmsg));
+ if(2 != parse_param2("%d,%d", at_paras, p)){
+ free(reqmsg);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+ }
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct comm_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_sendbuf_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct comm_rspmsg *msg = (struct comm_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ if (msg->ret < 0) {
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: %d\r\n", msg->err);
+ } else {
+ at_str = malloc(64);
+ assert(at_str);
+ memset(at_str, 0x00, 64);
+ sprintf(at_str, "\r\n$MYNETWRITE: %d,%d\r\n", msg->socketid, msg->len);
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+
+int ext_netwrite_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct comm_rspmsg *msg = (struct comm_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+
+ if (msg->ret < 0) {
+ sprintf(at_str, "\r\nERROR:%d\r\n", msg->err);
+ } else {
+ sprintf(at_str, "\r\nOK\r\n");
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+
+}
+
+int ext_netclose_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct comm_reqmsg *reqmsg = malloc(sizeof(struct comm_reqmsg));
+ assert(reqmsg);
+ char *at_str = NULL;
+ char *p[1] = {&reqmsg->socketid};
+ memset(reqmsg, 0x00, sizeof(struct comm_reqmsg));
+ if(1 != parse_param2("%d", at_paras, p)){
+ free(reqmsg);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+ }
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct comm_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_netclose_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct comm_rspmsg *msg = (struct comm_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ if (msg->ret < 0) {
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: %d\r\n", msg->err);
+ } else {
+ at_str = malloc(64);
+ assert(at_str);
+ memset(at_str, 0x00, 64);
+ sprintf(at_str, "\r\n$MYNETCLOSE: %d\r\n\r\nOK\r\n", msg->socketid);
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+/*
+ at+mynetping="192.168.30.201",5,40
+*/
+int ext_netping_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct netping_reqmsg *ping = malloc(sizeof(struct netping_reqmsg));
+ assert(ping);
+ char *p[3] = {&ping->remote_ip, &ping->try_count, &ping->packet_size};
+ memset(ping, 0x00, sizeof(struct netping_reqmsg));
+ parse_param2("%s,%d,%d", at_paras, p);
+ ping->try_count = ping->try_count == 0 ? 4 : ping->try_count;
+ ping->packet_size = ping->packet_size == 0 ? 32 : ping->packet_size;
+ *res_msg = ping;
+ *res_msglen = sizeof(struct netping_reqmsg);
+ return AT_CONTINUE;
+}
+int ext_netping_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct netping_rspmsg *msg = (struct netping_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ if (msg->ret < 0) {
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR:%d\r\n", msg->err);
+ } else {
+ at_str = malloc(64);
+ assert(at_str);
+ memset(at_str, 0x00, 64);
+ snprintf(at_str, 64,"\r\n$MYNETPING:%d,%d,\"%s\"\r\n",
+ msg->total_recv, msg->echo_rep_ttl, msg->round_trip_sta);
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_netaccept_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct netaccept_reqmsg *reqmsg = malloc(sizeof(struct netaccept_reqmsg));
+ assert(reqmsg);
+ char *at_str = NULL;
+ memset(reqmsg, 0x00, sizeof(struct netaccept_reqmsg));
+ char *p[3] = {&reqmsg->socketid, &reqmsg->action, &reqmsg->transportMode};
+ char *p1[2] = {&reqmsg->socketid, &reqmsg->action};
+ if (g_customer_type == CUSTOMER_GUODIAN){
+ if(3 != parse_param2("%d,%d,%d", at_paras, p)){
+ free(reqmsg);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+ }
+ }
+ else if (g_customer_type == CUSTOMER_NANDIAN){
+ if(2 != parse_param2("%d,%d", at_paras, p1)){
+ free(reqmsg);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+ }
+ }
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct netaccept_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_netaccept_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct netaccept_rspmsg *msg = (struct netaccept_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ if (msg->ret < 0) {
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: %d\r\n", msg->err);
+ } else {
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ if (msg->transportMode == NON_TRANSPARENT_MODE) {
+ sprintf(at_str, "\r\nOK\r\n");
+ } else {
+ sprintf(at_str, "\r\nCONNECT\r\n");
+ }
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_netcreate_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct netcreate_msg *netcreate = malloc(sizeof(struct netcreate_msg));
+ assert(netcreate);
+ char *at_str = NULL;
+ char *p[6] = {&netcreate->ch_id, &netcreate->mode, &netcreate->socketid, netcreate->remote_ip, &netcreate->remote_port, &netcreate->local_port};
+ memset(netcreate, 0x00, sizeof(struct netcreate_msg));
+ if(5 > parse_param2("%d,%d,%d,%s,%d,%d", at_paras, p)){
+ free(netcreate);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+ }
+ *res_msg = netcreate;
+ *res_msglen = sizeof(struct netcreate_msg);
+ return AT_CONTINUE;
+}
+int ext_netcreate_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct netcreate_rspmsg *msg = (struct netcreate_rspmsg*)rsp_msg;
+ char *at_str = malloc(64);
+ assert(at_str);
+ char param[10] = {0};
+ int offset = 0;
+
+ memset(at_str, 0x00, 64);
+
+ if (msg->ret < 0) {
+ sprintf(at_str, "\r\nERROR:%d\r\n", msg->err);
+ } else {
+ if (msg->mode == CONN_TYPE_TCP_S) {
+ sprintf(at_str, "\r\nOK\r\n");
+ } else {
+ sprintf(at_str, "\r\nCONNECT\r\n");
+ }
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+
+}
+
+int ext_neturc_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct neturc_reqmsg *reqmsg = malloc(sizeof(struct neturc_reqmsg));
+ assert(reqmsg);
+ char *at_str = NULL;
+ memset(reqmsg, 0x00, sizeof(struct neturc_reqmsg));
+ char *p[1] = {&reqmsg->on_off};
+ if(1 != parse_param2("%d", at_paras, p)){
+ free(reqmsg);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+ }
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct neturc_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_neturc_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct comm_rspmsg *msg = (struct comm_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ if (msg->ret < 0) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ } else {
+ sprintf(at_str, "\r\nOK\r\n");
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_ipfilter_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct ipfilter_reqmsg *reqmsg = malloc(sizeof(struct ipfilter_reqmsg));
+ assert(reqmsg);
+ char *at_str = NULL;
+ memset(reqmsg, 0x00, sizeof(struct ipfilter_reqmsg));
+ char *p[4] = {&reqmsg->id, &reqmsg->action, reqmsg->ip_address, reqmsg->net_mask};
+ if(2 > parse_param2("%d,%d,%s,%s", at_paras, p)){
+ free(reqmsg);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+ }
+ //ipfilter = *reqmsg;
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct ipfilter_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_ipfilter_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct comm_rspmsg *msg = (struct comm_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ if (msg->ret < 0) {
+ sprintf(at_str, "\r\nERROR: %d\r\n", msg->err);
+ } else {
+ sprintf(at_str, "\r\nOK\r\n");
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_netack_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct comm_reqmsg *reqmsg = malloc(sizeof(struct comm_reqmsg));
+ assert(reqmsg);
+ char *at_str = NULL;
+ memset(reqmsg, 0x00, sizeof(struct comm_reqmsg));
+ char *p[1] = {&reqmsg->socketid};
+ if(1 != parse_param2("%d", at_paras, p)){
+ free(reqmsg);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+ }
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct comm_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_netack_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct netack_rspmsg *msg = (struct netack_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+
+ if (msg->ret < 0) {
+ snprintf(at_str, 32,"\r\nERROR: %d\r\n", msg->err);
+ } else {
+ snprintf(at_str, 32,"\r\n$MYNETACK: %d,%d,%d\r\n\r\nOK\r\n", msg->socketid, msg->unacked_datalen, msg->rest_bufferlen);
+ }
+
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_type_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ *res_msg = NULL;
+ *res_msglen = 0;
+ return AT_CONTINUE;
+
+}
+int ext_type_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct type_rspmsg *msg = (struct type_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ if (g_customer_type == CUSTOMER_GUODIAN)
+ snprintf(at_str, 32,"\r\n$MYTYPE:%.2x,%.2x,%.2x\r\n\r\nOK\r\n", msg->mode, msg->network_type, msg->extended_feature);
+ else if (g_customer_type == CUSTOMER_NANDIAN)
+ snprintf(at_str, 32,"\r\n$MYMODEM: %.2x,%.4x\r\n\r\nOK\r\n", msg->mode, msg->network_type);
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_netact_query_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ *res_msg = NULL;
+ *res_msglen = 0;
+ return AT_CONTINUE;
+
+}
+
+int ext_netact_query_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct netact_query_rspmsg *msg = (struct netact_query_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ at_str = malloc(64);
+ assert(at_str);
+ memset(at_str, 0x00, 64);
+
+ snprintf(at_str, 64,"\r\n$MYNETACT: %d,%d,\"%s\"\r\n\r\nOK\r\n", msg->channel, msg->status, msg->ip);
+
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+
+int ext_netact_equal_query_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ char *at_str = NULL;
+
+ at_str = malloc(64);
+ assert(at_str);
+ memset(at_str, 0, 64);
+ sprintf((char*)at_str, "\r\n$MYNETACT: (0-1),(0-5)\r\nOK\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(*res_msg);
+ return AT_END;
+
+}
+
+int ext_neturc_query_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ *res_msg = NULL;
+ *res_msglen = 0;
+ return AT_CONTINUE;
+
+}
+int ext_neturc_query_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct neturc_query_rspmsg *msg = (struct neturc_query_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+
+ sprintf(at_str, "\r\n$MYNETURC: %d\r\nOK\r\n", msg->on_off);
+
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_ipfilter_query_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ *res_msg = NULL;
+ *res_msglen = 0;
+ return AT_CONTINUE;
+
+}
+int ext_ipfilter_query_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct ipfilter_query_rspmsg *msg = (struct ipfilter_query_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+ int i,j = 0;
+ int offset = 0;
+
+ at_str = malloc(32 + IP_FILTER_NUM*sizeof(struct ipfilter_query_rspmsg));
+ assert(at_str);
+ memset(at_str, 0x00, 32 + IP_FILTER_NUM*sizeof(struct ipfilter_query_rspmsg));
+
+ for (i = 0; i < IP_FILTER_NUM; i++) {
+ for(j = 0; j < msg->num; j++) {
+ if(i == msg->ipfilter_info[j].id){
+ break;
+ }
+ }
+ if(j == msg->num){
+ offset += sprintf(at_str + offset, "\r\n$MYIPFILTER: %d,\"\",\"\"", i);
+ }else{
+ offset += sprintf(at_str + offset, "\r\n$MYIPFILTER: %d,\"%s\",\"%s\"", msg->ipfilter_info[j].id, msg->ipfilter_info[j].ip_address, msg->ipfilter_info[j].net_mask);
+ }
+ }
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+
+ *ret = at_str;
+ *retlen = offset;
+ return AT_END;
+}
+int ext_netsrv_query_rsp(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ char *at_str = NULL;
+ int offset = 0;
+
+ at_str = malloc(32 + sizeof(netsrv));
+ assert(at_str);
+ memset(at_str, 0, 32 + sizeof(netsrv));
+ offset += snprintf(at_str, 32 + sizeof(netsrv),"\r\n$MYNETSRV: %d,%d,%d,%d,\"%s\"", netsrv.ch_id, netsrv.socketid, netsrv.conn_type, netsrv.viewMode, netsrv.ipport);
+ offset += snprintf(at_str + offset,32 + sizeof(netsrv)-offset, "\r\nOK\r\n");
+ *res_msg = at_str;
+ *res_msglen = offset;
+ return AT_END;
+
+}
+int ext_ipfilter_equal_query_rsp(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ char *at_str = NULL;
+ int offset = 0;
+
+ at_str = malloc(64);
+ assert(at_str);
+ memset(at_str, 0, 64);
+ offset += sprintf(at_str, "\r\n$MYIPFILTER: (0-4),(0-2),\"\",\"\"");
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ *res_msg = at_str;
+ *res_msglen = offset;
+ return AT_END;
+
+}
+int ext_netopen_query_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ *res_msg = NULL;
+ *res_msglen = 0;
+ return AT_CONTINUE;
+
+}
+int ext_netopen_query_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct netopen_query_rspmsg *msg = (struct netopen_query_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ if (msg->ret == -1) {
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR\r\n");
+ } else {
+ at_str = malloc(32 + sizeof(struct netopen_query_rspmsg));
+ assert(at_str);
+ memset(at_str, 0x00, 32 + sizeof(struct netopen_query_rspmsg));
+
+ snprintf(at_str,32 + sizeof(struct netopen_query_rspmsg), "\r\n$MYNETOPEN: %d,\"%s\",%d,\"%s\",\"%s\",\"%s\",%d,\"%s\",%d\r\nOK\r\n",
+ msg->socket_id, msg->local_ip, msg->local_port, msg->gate, msg->dns1, msg->dns2, msg->type, msg->dest_ip, msg->dest_prot);
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_ok_rsp(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ char *at_str = NULL;
+
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0, 32);
+ sprintf((char*)at_str, "\r\nOK\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(*res_msg);
+ return AT_END;
+
+}
+
+char * csq_format(char *at_str)
+{
+ int rssi = 0, ber = 0, act = 0;
+ char *at_new = malloc(strlen(at_str) + 1);
+ assert(at_new);
+ void *p[3] = {&rssi, &ber, &act};
+ char str_tmp[64] = {0};
+ char *pchrstart = NULL;
+
+ pchrstart = at_str + 1;
+
+ char *pchrend = strstr(pchrstart, "\r\n");
+ if(pchrend && (pchrend - pchrstart) < sizeof(str_tmp))
+ snprintf(str_tmp,(pchrend - pchrstart)+1, "%s",pchrstart);
+ //strncpy(str_tmp, pchrstart, (int)(pchrend - pchrstart));
+
+ //if (at_new == NULL)
+ // softap_assert("");
+
+ parse_param2("%d,%d,%d", str_tmp, p);
+
+ if (act == 5 || act == 15) { //W TD
+ if (rssi == 199) {
+ rssi = rssi - 100;
+ } else {
+ rssi = floor((((rssi - 100 - 116) * (100.0 / 91.0) + 127.4) * 31) / 100 + 0.1);
+ }
+ } else if (act == 17) { //LTE
+ if (rssi == 199) {
+ rssi = rssi - 100;
+ } else {
+ rssi = floor((((rssi - 100 - 141) * (100.0 / 97.0) + 145.3) * 31) / 100 + 0.1);
+ }
+ }
+
+
+ memset(at_new, 0, strlen(at_str) + 1);
+ sprintf(at_new, ": %ld,%ld", rssi, ber);
+ printf("csq_format at_new = %s\n", at_new);
+ return at_new;
+}
+
+char * xreg_format(char *at_str)
+{
+ char *at_new = malloc(strlen(at_str) + 1);
+ assert(at_new);
+ char str_tmp[64] = {0};
+ char *pchrstart = NULL;
+ int offset = 0;
+
+ //if (at_new == NULL)
+ // softap_assert("");
+ memset(at_new, 0, strlen(at_str) + 1);
+
+ pchrstart = at_str + 2;
+ char *pchrend = strstr(pchrstart, "\r\n");
+ if (pchrend == NULL){
+ softap_assert("");
+ return at_new;
+ }
+ if (strstr(pchrstart, "OK") == NULL) {
+ memcpy(at_new, at_str, pchrend - at_str);
+ } else if (strchr(pchrstart, '(') != NULL) {
+ memcpy(at_new, at_str, pchrend - at_str);
+ } else {
+ int n = 0;
+ int stat = 0;
+ char cereg_stat[20] = {0};
+
+ offset += sprintf(at_new, ": %d", 0);
+
+ get_at_cmd_param_int(pchrstart, &n, &pchrstart);
+
+ move_to_next_param(pchrstart, &pchrstart);
+
+ get_at_cmd_param_int(pchrstart, &stat, &pchrstart);
+
+ sc_cfg_get("cereg_stat", cereg_stat, sizeof(cereg_stat));
+ if (stat != 1 && stat != 5 && (1 == atoi(cereg_stat) || 5 == atoi(cereg_stat))) {
+ offset += sprintf(at_new + offset, ",%d", 1);
+ } else {
+ offset += sprintf(at_new + offset, ",%d", stat);
+ }
+
+ //ºóÃ滹ÓвÎÊý
+ if (!is_at_cmd_end(pchrstart)) {
+ strncpy(at_new + offset, pchrstart - 1, (int)(pchrend - pchrstart + 1));
+ }
+ }
+
+ //printf("xreg_format at_new = %s\n", at_new);
+ return at_new;
+}
+
+char * cgatt_format(char *at_str)
+{
+ char *at_new = malloc(strlen(at_str) + 1);
+ assert(at_new);
+ //if (at_new == NULL)
+ // softap_assert("");
+
+ memset(at_new, 0, strlen(at_str) + 1);
+ sprintf(at_new, ": %d", 1);
+
+ printf("cgatt_format at_new = %s\n", at_new);
+ return at_new;
+}
+
+char * cgsn_format(char *at_str)
+{
+ char *at_new = malloc(strlen(at_str) + 3);
+ assert(at_new);
+ char str_tmp[32] = {0};
+ char *pchrstart = NULL;
+
+ pchrstart = at_str + 2;
+
+ char *pchrend = strstr(pchrstart, "\r\n");
+ if(pchrend && (pchrend - pchrstart) < sizeof(str_tmp))
+ snprintf(str_tmp,(pchrend - pchrstart)+1, "%s",pchrstart);
+ //strncpy(str_tmp, pchrstart, (int)(pchrend - pchrstart));
+ //if (at_new == NULL)
+ // softap_assert("");
+
+ memset(at_new, 0, strlen(at_str) + 1);
+ sprintf(at_new, ": \"%s\"", str_tmp);
+
+ printf("cgsn_format at_new = %s\n", at_new);
+ return at_new;
+}
+
+#ifdef AT_QUECTEL
+//========================================================================================================//
+//quectel socket·½°¸º¯ÊýʵÏÖÇø
+//========================================================================================================//
+/*
+ at+qiopen=1,0,"TCP","192.168.30.201",5100,0,0
+*/
+int ext_qiopen_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct quectel_qiopen_msg *qiopen = malloc(sizeof(struct quectel_qiopen_msg));
+ char *p[7] = {&qiopen->context_id, &qiopen->connect_id, qiopen->service_type, qiopen->ip_addr, qiopen->remote_port, qiopen->local_port, qiopen->access_mode};
+ memset(qiopen, 0x00, sizeof(struct quectel_qiopen_msg));
+ parse_param2("%d,%d,%s,%s,%d,%d,%d", at_paras, p);
+ *res_msg = qiopen;
+ *res_msglen = sizeof(struct quectel_qiopen_msg);
+ return AT_CONTINUE;
+}
+int ext_qiopen_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct quectel_comm_rspmsg *msg = (struct quectel_comm_rspmsg*)rsp_msg;
+ char *at_str = malloc(32);
+ memset(at_str, 0x00, 32);
+
+ if (msg->access_mode == BUFFER_ACCESS_MODE || msg->access_mode == DIRECT_PUSH_MODE) {
+ sprintf(at_str, "\r\nOK\r\n+QIOPEN: %d,%d\r\n", msg->connect_id, msg->err);
+ } else if (msg->access_mode == TRANSPARENT_ACCESS_MODE) {
+ if (msg->ret < 0) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ } else {
+ sprintf(at_str, "\r\nCONNECT\r\n");
+ }
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_qiclose_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct quectel_qiclose_reqmsg *reqmsg = malloc(sizeof(struct quectel_qiclose_reqmsg));
+ char *p[2] = {&reqmsg->connect_id, &reqmsg->timeout};
+ memset(reqmsg, 0x00, sizeof(struct quectel_qiclose_reqmsg));
+ parse_param2("%d,%d", at_paras, p);
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct quectel_qiclose_reqmsg);
+ return AT_CONTINUE;
+}
+int ext_qiclose_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct quectel_comm_rspmsg *msg = (struct quectel_comm_rspmsg*)rsp_msg;
+ char *at_str = malloc(32);
+ memset(at_str, 0x00, 32);
+
+ if (msg->ret < 0) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ } else {
+ sprintf(at_str, "\r\nOK\r\n");
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+
+}
+int ext_qistate_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct quectel_qistate_reqmsg *reqmsg = malloc(sizeof(struct quectel_qistate_reqmsg));
+ char *p[2] = {&reqmsg->query_type, &reqmsg->query_id};
+ memset(reqmsg, 0x00, sizeof(struct quectel_qistate_reqmsg));
+ parse_param2("%d,%d", at_paras, p);
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct quectel_qistate_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_qistate_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct quectel_qistate_rspmsg *msg = (struct quectel_qistate_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+ int offset = 0;
+ int i = 0;
+
+ if (msg->num == 0) {
+ at_str = malloc(32);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR\r\n");
+ offset = strlen(at_str);
+ } else if (msg->query_type == QUERY_CONNECTION_STATUS_BY_CONNECTID) {
+ at_str = malloc(64 + sizeof(struct quectel_sock_info));
+ memset(at_str, 0x00, 64 + sizeof(struct quectel_sock_info));
+ offset += sprintf(at_str, "\r\n+QISTATE:\n");
+ offset += sprintf(at_str + offset, "%d,%d,%s,%d,%d,%d,%d,%d,%d,%d\r\n",
+ msg->query_status_info[0].connect_id,
+ msg->query_status_info[0].service_type,
+ msg->query_status_info[0].ip_addr,
+ msg->query_status_info[0].remote_port,
+ msg->query_status_info[0].local_port,
+ msg->query_status_info[0].socket_state,
+ msg->query_status_info[0].context_id,
+ msg->query_status_info[0].server_id,
+ msg->query_status_info[0].access_mode,
+ msg->query_status_info[0].at_port);
+ } else {
+ at_str = malloc(64 + msg->num * sizeof(struct quectel_sock_info));
+ memset(at_str, 0x00, 64 + msg->num * sizeof(struct quectel_sock_info));
+ offset += sprintf(at_str, "\r\nList of(+QISTATE:\n");
+ for (i = 0; i < msg->num; i++) {
+ offset += sprintf(at_str + offset, "%d,%d,%s,%d,%d,%d,%d,%d,%d,%d\r\n",
+ msg->query_status_info[i].connect_id,
+ msg->query_status_info[i].service_type,
+ msg->query_status_info[i].ip_addr,
+ msg->query_status_info[i].remote_port,
+ msg->query_status_info[i].local_port,
+ msg->query_status_info[i].socket_state,
+ msg->query_status_info[i].context_id,
+ msg->query_status_info[i].server_id,
+ msg->query_status_info[i].access_mode,
+ msg->query_status_info[i].at_port);
+ }
+ offset += sprintf(at_str + offset, ")\n");
+ }
+ *ret = at_str;
+ *retlen = offset;
+ return AT_END;
+
+}
+int ext_qisend_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ int ret = 0;
+ struct quectel_qisend_reqmsg *reqmsg = malloc(sizeof(struct quectel_qisend_reqmsg));
+ char *p[4] = {&reqmsg->connect_id, &reqmsg->len, reqmsg->ip_addr, &reqmsg->remote_port};
+ memset(reqmsg, 0x00, sizeof(struct quectel_qisend_reqmsg));
+ ret = parse_param2("%d,%d,%s,%d", at_paras, p);
+ if (ret == 1) {
+ reqmsg->send_type = CHANGEABLE_LENGTH;
+ } else if (ret == 2) {
+ if (reqmsg->len == 0) {
+ reqmsg->send_type = QUERY_DATA_INFO;
+ } else {
+ reqmsg->send_type = FIXED_LENGTH;
+ }
+ } else if (ret == 4) {
+ reqmsg->send_type = UDP_DATA;
+ }
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct quectel_qisend_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_qisend_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct quectel_qisend_rspmsg *msg = (struct quectel_qisend_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+ int offset = 0;
+
+ at_str = malloc(32);
+ memset(at_str, 0x00, 32);
+
+ if (msg->send_type == QUERY_DATA_INFO) {
+ if (msg->ret == CONNECTION_EXIST) {
+ offset += sprintf(at_str, "\r\n+QISEND:\n");
+ offset += sprintf(at_str + offset, "%d,%d,%d\r\n", msg->total_send_length, msg->ackedbytes, msg->unackedbytes);
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ } else if (msg->ret == CONNECTION_NOT_EXIST) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ }
+ } else {
+ if (msg->ret == READY_TO_SEND) {
+ sprintf(at_str, "\r\nSEND OK\r\n");
+ } else if (msg->ret == SEND_OK) {
+ sprintf(at_str, "\r\n");
+ } else if (msg->ret == SEND_FAIL) {
+ sprintf(at_str, "\r\nSEND FAIL\r\n");
+ } else if (msg->ret == SEND_ERROR || msg->ret == CONNECTION_NOT_EXIST) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ }
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+
+int ext_qisendex_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct quectel_qisendex_reqmsg *reqmsg = malloc(sizeof(struct quectel_qisendex_reqmsg));
+ char *p[2] = {&reqmsg->connect_id, reqmsg->hex_data};
+ memset(reqmsg, 0x00, sizeof(struct quectel_qisendex_reqmsg));
+ parse_param2("%d,%s", at_paras, p);
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct quectel_qisendex_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_qisendex_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct quectel_comm_rspmsg *msg = (struct quectel_comm_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ at_str = malloc(32);
+ memset(at_str, 0x00, 32);
+
+ if (msg->ret == SEND_OK) {
+ sprintf(at_str, "\r\nSEND OK\r\n");
+ } else if (msg->ret == SEND_FAIL) {
+ sprintf(at_str, "\r\nSEND FAIL\r\n");
+ } else if (msg->ret == SEND_ERROR) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+
+}
+int ext_qird_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ int ret = 0;
+ struct quectel_qird_reqmsg *reqmsg = malloc(sizeof(struct quectel_qird_reqmsg));
+ char *p[2] = {&reqmsg->connect_id, &reqmsg->len};
+ memset(reqmsg, 0x00, sizeof(struct quectel_qird_reqmsg));
+
+ ret = parse_param2("%d,%d", at_paras, p);
+ if (ret == 1) {
+ reqmsg->read_type = CHANGEABLE_LENGTH;
+ } else if (ret == 2) {
+ if (reqmsg->len == 0) {
+ reqmsg->read_type = QUERY_DATA_INFO;
+ } else {
+ reqmsg->read_type = FIXED_LENGTH;
+ }
+ }
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct quectel_qird_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_qird_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ int offset = 0;
+ struct quectel_qird_rspmsg *msg = (struct quectel_qird_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ if (msg->read_type == QUERY_DATA_INFO) {
+ if (msg->ret == CONNECTION_EXIST) {
+ at_str = malloc(32);
+ memset(at_str, 0x00, 32);
+ offset += sprintf(at_str, "\r\n+QIRD:\n");
+ offset += sprintf(at_str + offset, "%d,%d,%d\r\n", msg->total_rcv_length, msg->have_read_length, msg->unread_length);
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ } else if (msg->ret == CONNECTION_NOT_EXIST) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ }
+ } else {
+ if (msg->service_type == TCP || msg->service_type == UDP || msg->service_type == TCP_LISTENER) {
+ if (msg->ret == READ_OK) {
+ at_str = malloc(32 + msg->read_actual_length);
+ memset(at_str, 0x00, 32 + msg->read_actual_length);
+ offset += sprintf(at_str, "\r\n+QIRD:%d\r\n", msg->read_actual_length);
+ memcpy(at_str + offset, msg->data, msg->read_actual_length);
+ offset += msg->read_actual_length;
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ } else if (msg->ret == NODATA_READ) {
+ at_str = malloc(32);
+ memset(at_str, 0x00, 32);
+ offset += sprintf(at_str, "\r\n+QIRD:0\n");
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ } else if (msg->ret == CONNECTION_NOT_EXIST) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ }
+ } else if (msg->service_type == UDP_SERVICE) {
+ if (msg->ret == READ_OK) {
+ at_str = malloc(32 + msg->read_actual_length);
+ memset(at_str, 0x00, 32 + msg->read_actual_length);
+ offset += sprintf(at_str, "\r\n+QIRD:%d,%s,%d\r\n", msg->read_actual_length, msg->remote_ipaddr, msg->remote_port);
+ memcpy(at_str + offset, msg->data, msg->read_actual_length);
+ offset += msg->read_actual_length;
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ } else if (msg->ret == NODATA_READ) {
+ at_str = malloc(32);
+ memset(at_str, 0x00, 32);
+ offset += sprintf(at_str, "\r\n+QIRD:0\n");
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ } else if (msg->ret == CONNECTION_NOT_EXIST) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ }
+ }
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_qiswtmd_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct quectel_qiswtmd_reqmsg *reqmsg = malloc(sizeof(struct quectel_qiswtmd_reqmsg));
+ char *p[2] = {&reqmsg->connect_id, &reqmsg->access_mode};
+ memset(reqmsg, 0x00, sizeof(struct quectel_qiswtmd_reqmsg));
+ parse_param2("%d,%d", at_paras, p);
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct quectel_qiswtmd_reqmsg);
+ return AT_CONTINUE;
+}
+int ext_qiswtmd_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct quectel_qiswtmd_rspmsg *msg = (struct quectel_qiswtmd_rspmsg*)rsp_msg;
+ char *at_str = malloc(32);
+ memset(at_str, 0x00, 32);
+
+ if (msg->ret == SW_SUCC) {
+ if (msg->access_mode == BUFFER_ACCESS_MODE || msg->access_mode == DIRECT_PUSH_MODE) {
+ sprintf(at_str, "\r\nOK\r\n");
+ } else if (msg->access_mode == BUFFER_ACCESS_MODE || msg->access_mode == DIRECT_PUSH_MODE) {
+ sprintf(at_str, "\r\nCONNECT\r\n");
+ }
+ } else if (msg->ret == SW_FAIL) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+ext_qidnscfg_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ int ret = 0;
+ struct quectel_qidnscfg_reqmsg *reqmsg = malloc(sizeof(struct quectel_qidnscfg_reqmsg));
+ char *p[3] = {&reqmsg->context_id, reqmsg->pri_dns_addr, reqmsg->sec_dns_addr};
+ memset(reqmsg, 0x00, sizeof(struct quectel_qidnscfg_reqmsg));
+
+ ret = parse_param2("%d,%d", at_paras, p);
+ if (ret == 1) {
+ reqmsg->action_type = DNS_QUERY;
+ } else if (ret == 2) {
+ reqmsg->action_type = DNS_CFG_NO_SECDNSADDR;
+ } else if (ret == 3) {
+ reqmsg->action_type = DNS_CFG_WITH_SECDNSADDR;
+ }
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct quectel_qird_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_qidnscfg_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ int offset = 0;
+ struct quectel_qidnscfg_rspmsg *msg = (struct quectel_qidnscfg_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ if (msg->action_type == DNS_CFG_WITH_SECDNSADDR || msg->action_type == DNS_CFG_NO_SECDNSADDR) {
+ if (msg->ret == DNS_ACTION_SUCC) {
+ sprintf(at_str, "\r\nOK\r\n");
+ } else if (msg->ret == DNS_ACTION_FAIL) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ }
+ } else if (msg->action_type == DNS_QUERY) {
+ if (msg->ret == DNS_ACTION_SUCC) {
+ at_str = malloc(32 + sizeof(msg->pri_dns_addr) + sizeof(msg->sec_dns_addr));
+ memset(at_str, 0x00, 32 + sizeof(msg->pri_dns_addr) + sizeof(msg->sec_dns_addr));
+ offset += sprintf(at_str, "\r\n+QIDNSCFG:%d,%s,%s\r\n", msg->context_id, msg->pri_dns_addr, msg->sec_dns_addr);
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ } else if (msg->ret == DNS_ACTION_FAIL) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ }
+
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+ext_qidnsgip_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ int ret = 0;
+ struct quectel_qidnsgip_reqmsg *reqmsg = malloc(sizeof(struct quectel_qidnsgip_reqmsg));
+ char *p[2] = {&reqmsg->context_id, reqmsg->host_name};
+ memset(reqmsg, 0x00, sizeof(struct quectel_qidnsgip_reqmsg));
+
+ ret = parse_param2("%d,%s", at_paras, p);
+
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct quectel_qidnsgip_reqmsg);
+ return AT_CONTINUE;
+
+}
+int ext_qidnsgip_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ int offset = 0;
+ struct quectel_qidnscfg_rspmsg *msg = (struct quectel_qidnscfg_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+
+ if (msg->action_type == DNS_CFG_WITH_SECDNSADDR || msg->action_type == DNS_CFG_NO_SECDNSADDR) {
+ if (msg->ret == DNS_ACTION_SUCC) {
+ sprintf(at_str, "\r\nOK\r\n");
+ } else if (msg->ret == DNS_ACTION_FAIL) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ }
+ } else if (msg->action_type == DNS_QUERY) {
+ if (msg->ret == DNS_ACTION_SUCC) {
+ at_str = malloc(32 + sizeof(msg->pri_dns_addr) + sizeof(msg->sec_dns_addr));
+ memset(at_str, 0x00, 32 + sizeof(msg->pri_dns_addr) + sizeof(msg->sec_dns_addr));
+ offset += sprintf(at_str, "\r\n+QIDNSCFG:%d,%s,%s\r\n", msg->context_id, msg->pri_dns_addr, msg->sec_dns_addr);
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ } else if (msg->ret == DNS_ACTION_FAIL) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ }
+
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+int ext_qigeterror_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ *res_msg = NULL;
+ *res_msglen = 0;
+ return AT_CONTINUE;
+}
+int ext_qigeterror_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct quectel_qigeterror_rspmsg *msg = (struct quectel_qigeterror_rspmsg*)rsp_msg;
+ int offset = 0;
+ char *at_str = malloc(64);
+ memset(at_str, 0x00, 64);
+
+ offset += sprintf(at_str, "\r\n+QIGETERROR:%d,%s\r\n", msg->err, msg->errcode_description);
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+
+}
+int ext_qping_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct qping_reqmsg *ping = malloc(sizeof(struct qping_reqmsg));
+ char *p[4] = {&ping->context, ping->remote_ip, &ping->timeout, &ping->ping_num};
+ memset(ping, 0x00, sizeof(struct netping_reqmsg));
+ parse_param2("%d,%s,%d,%d", at_paras, p);
+ ping->timeout = ping->timeout == 0 ? 4 : ping->timeout;
+ ping->ping_num = ping->ping_num == 0 ? 4 : ping->ping_num;
+ *res_msg = ping;
+ *res_msglen = sizeof(struct qping_reqmsg);
+ return AT_CONTINUE;
+}
+int ext_qping_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct qping_rspmsg *msg = (struct qping_rspmsg*)rsp_msg;
+ char *at_str = NULL;
+ int offset = 0;
+ int i = 0;
+
+ if (msg->ret < 0) {
+ at_str = malloc(32);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR\r\n");
+ } else {
+ at_str = malloc(32 + sizeof(struct qping_rspmsg));
+ memset(at_str, 0x00, 32 + sizeof(struct qping_rspmsg));
+ offset += sprintf(at_str + offset, "\r\nOK\r\n");
+ for (i = 0; i < msg->ping_num; i++) {
+ if (msg->each_ping_result[i].result == 0) {
+ offset += sprintf(at_str + offset, "\r\n$QPING:\r\n%d,%s,%d,%d,%d\r\n",
+ msg->each_ping_result[i].result,
+ msg->each_ping_result[i].remote_ip,
+ msg->each_ping_result[i].ping_len,
+ msg->each_ping_result[i].response_time,
+ msg->each_ping_result[i].ttl);
+ } else {
+ offset += sprintf(at_str + offset, "\r\n$QPING:\r\n%d\r\n", msg->each_ping_result[i].result);
+ }
+ }
+ if (msg->finresult == 0) {
+ offset += sprintf(at_str + offset, "\r\n$QPING:\r\n%d,%d,%d,%d,%d,%d,%d\r\n",
+ msg->finresult, msg->sent, msg->rcvd, msg->lost, msg->min, msg->max, msg->avg);
+ } else {
+ offset += sprintf(at_str + offset, "\r\n$QPING:\r\n%d\r\n", msg->finresult);
+ }
+
+ }
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+#endif
+
+/*
+ at$MYSOCKETLED=<ONOFF>
+*/
+static int ext_socketled_req(int at_fd, char *at_paras, void ** res_msg, int *res_msglen)
+{
+ struct zteftp_socketled_reqmsg *reqmsg = malloc(sizeof(struct zteftp_socketled_reqmsg));
+ assert(reqmsg);
+ char *at_str = NULL;
+ char *p[1] = {&reqmsg->iswitch};
+ memset(reqmsg, 0x00, sizeof(struct zteftp_socketled_reqmsg));
+ if(1 != parse_param2("%d", at_paras, p)){
+ free(reqmsg);
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+ sprintf(at_str, "\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ *res_msglen = strlen(at_str);
+ return AT_END;
+ }
+ //at_print(AT_NORMAL,"zteftp_socketled_reqmsg %d\n", reqmsg->iswitch);
+ *res_msg = reqmsg;
+ *res_msglen = sizeof(struct zteftp_socketled_reqmsg);
+ return AT_CONTINUE;
+}
+/*
+ <CR><LF>OK<CR><LF>
+ <CR><LF>ERROR<CR><LF>
+*/
+static int ext_socketled_rsp(void *rsp_msg, void**ret, int *retlen)
+{
+ struct zteftp_socketled_rspmsg *rspmsg = (struct zteftp_socketled_rspmsg*)rsp_msg;
+ char *at_str = malloc(32);
+ assert(at_str);
+ memset(at_str, 0x00, 32);
+
+ if (rspmsg->result < 0) {
+ sprintf(at_str, "\r\nERROR\r\n");
+ } else {
+ sprintf(at_str, "\r\nOK\r\n");
+ }
+
+ *ret = at_str;
+ *retlen = strlen(at_str);
+ return AT_END;
+}
+
+int ext_enpwrsave_set_func(char *at_paras, void ** res_msg)
+{
+ int enpwrsave = 0;
+ void *p[] = {&enpwrsave};
+ int ret = 0;
+ char *at_str = NULL;
+ at_str = malloc(16);
+ assert(at_str);
+ memset(at_str,0,16);
+
+ ret = parse_param("%d",at_paras, p);
+ if(ret != AT_PARSE_OK)
+ {
+ sprintf(at_str,"\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ return AT_END;
+ }
+
+ if(0 == enpwrsave) //²»ÔÊÐí½øÈëÐÝÃßģʽ
+ {
+ set_wake_lock(AP_LOCK);
+ g_ap_lock = 0;
+ }
+ else if(1 == enpwrsave) //ÔÊÐí½øÈëÐÝÃßģʽ
+ {
+ set_wake_unlock(AP_LOCK);
+ g_ap_lock = 1;
+ }
+ else
+ {
+ sprintf(at_str,"\r\nERROR: 980\r\n");
+ *res_msg = at_str;
+ return AT_END;
+ }
+
+ sprintf(at_str,"\r\nOK\r\n");
+ *res_msg = at_str;
+ return AT_END;
+
+}
+
+int ext_enpwrsave_query_func(char *at_paras, void ** res_msg)
+{
+ char *at_str = NULL;
+ at_str = malloc(32);
+ assert(at_str);
+ memset(at_str,0,32);
+
+ sprintf(at_str,"\r\n+ENPWRSAVE: %d\r\nOK\r\n",g_ap_lock);
+ *res_msg = at_str;
+ return AT_END;
+}
+
+
+int ext_socket_regist(void)
+{
+ if (g_customer_type == CUSTOMER_GUODIAN) {
+ //SOCKET´´½¨¡¢Êý¾ÝÊÕ·¢
+ register_serv_func2("MYNETSRV=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETSRV_REQ, MSG_CMD_NETSRV_RSP, ext_netsrv_req, ext_netsrv_rsp);
+ register_serv_func2("MYNETOPEN=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETOPEN_REQ, MSG_CMD_NETOPEN_RSP, ext_netopen_req, ext_netopen_rsp);
+ register_serv_func2("MYNETREAD=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETREAD_REQ, MSG_CMD_NETREAD_RSP, ext_netread_req, ext_netread_rsp);
+ register_serv_func2("MYNETWRITE=", MODULE_ID_SOCKET_PROXY, MSG_CMD_SENDBUF_REQ, MSG_CMD_SENDBUF_RSP, ext_sendbuf_req, ext_sendbuf_rsp);
+ register_serv_func2("MYNETCLOSE=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETCLOSE_REQ, MSG_CMD_NETCLOSE_RSP, ext_netclose_req, ext_netclose_rsp);
+ register_serv_func2("MYNETPING=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETPING_REQ, MSG_CMD_NETPING_RSP, ext_netping_req, ext_netping_rsp);
+ register_serv_func2("MYNETACCEPT=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETACCEPT_REQ, MSG_CMD_NETACCEPT_RSP, ext_netaccept_req, ext_netaccept_rsp);
+ register_serv_func2("MYNETCREATE=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETCREATE_REQ, MSG_CMD_NETCREATE_RSP, ext_netcreate_req, ext_netcreate_rsp);
+ register_serv_func2("MYNETURC=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETURC_REQ, MSG_CMD_NETURC_RSP, ext_neturc_req, ext_neturc_rsp);
+ register_serv_func2("MYIPFILTER=", MODULE_ID_SOCKET_PROXY, MSG_CMD_IPFILTER_REQ, MSG_CMD_IPFILTER_RSP, ext_ipfilter_req, ext_ipfilter_rsp);
+ register_serv_func2("MYNETACK=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETACK_REQ, MSG_CMD_NETACK_RSP, ext_netack_req, ext_netack_rsp);
+ register_serv_func2("MYSOCKETLED=", MODULE_ID_SOCKET_PROXY, MSG_CMD_SOCKETLED_REQ, MSG_CMD_SOCKETLED_RSP, ext_socketled_req, ext_socketled_rsp);
+ register_serv_func2("MYTYPE?", MODULE_ID_SOCKET_PROXY, MSG_CMD_TYPE_REQ, MSG_CMD_TYPE_RSP, ext_type_req, ext_type_rsp);
+ register_serv_func2("MYNETACT?", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETACT_QUERY_REQ, MSG_CMD_NETACT_QUERY_RSP, ext_netact_query_req, ext_netact_query_rsp);
+ register_serv_func2("MYNETURC?", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETURC_QUERY_REQ, MSG_CMD_NETURC_QUERY_RSP, ext_neturc_query_req, ext_neturc_query_rsp);
+ register_serv_func2("MYNETACT=?", 0, 0, 0, ext_netact_equal_query_req, NULL);
+ register_serv_func2("MYIPFILTER?", MODULE_ID_SOCKET_PROXY, MSG_CMD_IPFILTER_QUERY_REQ, MSG_CMD_IPFILTER_QUERY_RSP, ext_ipfilter_query_req, ext_ipfilter_query_rsp);
+ register_serv_func2("MYIPFILTER=?", 0, 0, 0, ext_ipfilter_equal_query_rsp, NULL);
+ register_serv_func2("MYNETSRV?", 0, 0, 0, ext_netsrv_query_rsp, NULL);
+ register_serv_func2("MYNETSRV=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETOPEN?", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETOPEN_QUERY_REQ, MSG_CMD_NETOPEN_QUERY_RSP, ext_netopen_query_req, ext_netopen_query_rsp);
+ register_serv_func2("MYNETOPEN=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETREAD=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETWRITE=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETCLOSE?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETCLOSE=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETACCEPT?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETACCEPT=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETCREATE?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETCREATE=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func("ENPWRSAVE=",0,ext_enpwrsave_set_func);
+ register_serv_func("ENPWRSAVE?",0,ext_enpwrsave_query_func);
+
+ register_formatInform_func("+CSQ", csq_format);
+ register_formatInform_func("+CREG", xreg_format);
+ register_formatInform_func("+CGREG", xreg_format);
+ register_formatInform_func("+CEREG", xreg_format);
+ register_formatInform_func("+CGATT", cgatt_format);
+ register_formatInform_func("+CGSN", cgsn_format);
+ } else if (g_customer_type == CUSTOMER_NANDIAN) {
+ register_serv_func2("MYNETACT?", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETACT_QUERY_REQ, MSG_CMD_NETACT_QUERY_RSP, ext_netact_query_req, ext_netact_query_rsp);
+ register_serv_func2("MYNETACT=?", 0, 0, 0, ext_netact_equal_query_req, NULL);
+ register_serv_func2("MYIPFILTER=", MODULE_ID_SOCKET_PROXY, MSG_CMD_IPFILTER_REQ, MSG_CMD_IPFILTER_RSP, ext_ipfilter_req, ext_ipfilter_rsp);
+ register_serv_func2("MYIPFILTER?", MODULE_ID_SOCKET_PROXY, MSG_CMD_IPFILTER_QUERY_REQ, MSG_CMD_IPFILTER_QUERY_RSP, ext_ipfilter_query_req, ext_ipfilter_query_rsp);
+ register_serv_func2("MYIPFILTER=?", 0, 0, 0, ext_ipfilter_equal_query_rsp, NULL);
+ register_serv_func2("MYNETSRV=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETSRV_REQ, MSG_CMD_NETSRV_RSP, ext_netsrv_req, ext_netsrv_rsp);
+ register_serv_func2("MYNETSRV?", 0, 0, 0, ext_netsrv_query_rsp, NULL);
+ register_serv_func2("MYNETSRV=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETOPEN=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETOPEN_REQ, MSG_CMD_NETOPEN_RSP, ext_netopen_req, ext_netopen_rsp);
+ register_serv_func2("MYNETOPEN?", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETOPEN_QUERY_REQ, MSG_CMD_NETOPEN_QUERY_RSP, ext_netopen_query_req, ext_netopen_query_rsp);
+ register_serv_func2("MYNETOPEN=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETREAD=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETREAD_REQ, MSG_CMD_NETREAD_RSP, ext_netread_req, ext_netread_rsp);
+ register_serv_func2("MYNETREAD=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETWRITE=", MODULE_ID_SOCKET_PROXY, MSG_CMD_SENDBUF_REQ, MSG_CMD_SENDBUF_RSP, ext_sendbuf_req, ext_sendbuf_rsp);
+ register_serv_func2("MYNETWRITE=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETCLOSE=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETCLOSE_REQ, MSG_CMD_NETCLOSE_RSP, ext_netclose_req, ext_netclose_rsp);
+ register_serv_func2("MYNETCLOSE?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETCLOSE=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETACK=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETACK_REQ, MSG_CMD_NETACK_RSP, ext_netack_req, ext_netack_rsp);
+ register_serv_func2("MYNETACCEPT=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETACCEPT_REQ, MSG_CMD_NETACCEPT_RSP, ext_netaccept_req, ext_netaccept_rsp);
+ register_serv_func2("MYNETACCEPT?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETACCEPT=?", 0, 0, 0, ext_ok_rsp, NULL);
+ register_serv_func2("MYNETURC=", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETURC_REQ, MSG_CMD_NETURC_RSP, ext_neturc_req, ext_neturc_rsp);
+ register_serv_func2("MYNETURC?", MODULE_ID_SOCKET_PROXY, MSG_CMD_NETURC_QUERY_REQ, MSG_CMD_NETURC_QUERY_RSP, ext_neturc_query_req, ext_neturc_query_rsp);
+ register_serv_func2("MYMODEM?", MODULE_ID_SOCKET_PROXY, MSG_CMD_TYPE_REQ, MSG_CMD_TYPE_RSP, ext_type_req, ext_type_rsp);
+ register_serv_func("ENPWRSAVE=",0,ext_enpwrsave_set_func);
+ register_serv_func("ENPWRSAVE?",0,ext_enpwrsave_query_func);
+
+ register_formatInform_func("+CSQ", csq_format);
+ register_formatInform_func("+CGATT", cgatt_format);
+ register_formatInform_func("+CGSN", cgsn_format);
+
+ }
+
+#ifdef AT_QUECTEL
+ register_serv_func2("QIOPEN=", MODULE_ID_SOCKET_PROXY, MSG_CMD_QIOPEN_REQ, MSG_CMD_QIOPEN_RSP, ext_qiopen_req, ext_qiopen_rsp);
+ register_serv_func2("QICLOSE=", MODULE_ID_SOCKET_PROXY, MSG_CMD_QICLOSE_REQ, MSG_CMD_QICLOSE_RSP, ext_qiclose_req, ext_qiclose_rsp);
+ register_serv_func2("QISTATE=", MODULE_ID_SOCKET_PROXY, MSG_CMD_QISTATE_REQ, MSG_CMD_QISTATE_RSP, ext_qistate_req, ext_qistate_rsp);
+ register_serv_func2("QISEND=", MODULE_ID_SOCKET_PROXY, MSG_CMD_QISEND_REQ, MSG_CMD_QISEND_RSP, ext_qisend_req, ext_qisend_rsp);
+ register_serv_func2("QIRD=", MODULE_ID_SOCKET_PROXY, MSG_CMD_QIRD_REQ, MSG_CMD_QIRD_RSP, ext_qird_req, ext_qird_rsp);
+ register_serv_func2("QISENDEX=", MODULE_ID_SOCKET_PROXY, MSG_CMD_QISENDEX_REQ, MSG_CMD_QISENDEX_RSP, ext_qisendex_req, ext_qisendex_rsp);
+ register_serv_func2("QISWTMD=", MODULE_ID_SOCKET_PROXY, MSG_CMD_QISWTMD_REQ, MSG_CMD_QISWTMD_RSP, ext_qiswtmd_req, ext_qiswtmd_rsp);
+ register_serv_func2("QIDNSCFG=", MODULE_ID_SOCKET_PROXY, MSG_CMD_QIDNSCFG_REQ, MSG_CMD_QIDNSCFG_RSP, ext_qidnscfg_req, ext_qidnscfg_rsp);
+ register_serv_func2("QIDNSGIP=", MODULE_ID_SOCKET_PROXY, MSG_CMD_QIDNSGIP_REQ, MSG_CMD_QIDNSGIP_RSP, ext_qidnsgip_req, ext_qidnsgip_rsp);
+ register_serv_func2("QIGETERROR=", MODULE_ID_SOCKET_PROXY, MSG_CMD_QIGETERROR_REQ, MSG_CMD_QIGETERROR_RSP, ext_qigeterror_req, ext_qigeterror_rsp);
+ register_serv_func2("QPING=", MODULE_ID_SOCKET_PROXY, MSG_CMD_QPING_REQ, MSG_CMD_QPING_RSP, ext_qping_req, ext_qping_rsp);
+#endif
+
+ return 0;
+}
+
+#endif