SimpleLink CC32xx ATCommands Library
Simplifies the implementation of Internet connectivity
atcmd_netapp.c
1 /*
2  * Copyright (c) 2016, Texas Instruments Incorporated
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *
12  * * Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  *
16  * * Neither the name of Texas Instruments Incorporated nor the names of
17  * its contributors may be used to endorse or promote products derived
18  * from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32 
33 //*****************************************************************************
34 // includes
35 //*****************************************************************************
36 #include <stdlib.h>
37 #include <stdio.h>
38 
39 /* TI-DRIVERS Header files */
40 #include <ti/drivers/net/wifi/simplelink.h>
41 
42 #include <ti/net/utils/str_mpl.h>
43 
44 #include <ti/net/atcmd/atcmd_netapp.h>
45 #include <ti/net/atcmd/atcmd_defs.h>
46 #include <ti/net/atcmd/atcmd_event.h>
47 #include <ti/net/atcmd/atcmd_gen.h>
48 #include <ti/net/atcmd/atcmd.h>
49 
50 //*****************************************************************************
51 // defines
52 //*****************************************************************************
53 #define ATCMDNETAPP_MAX_BUFFER_LEN (1480)
54 #define ATCMDNETAPP_MAX_SECURITY_FILE_NAME_SIZE (96)
55 #define ATCMDNETAPP_MAX_DOMAIN_NAME_LEN (63)
56 #define ATCMDNETAPP_MAX_SIZE_OF_DEVICE_NAME (80)
57 
58 
59 const uint16_t ATCmdNetapp_serviceSize[] =
60 {
61  0, /* 0 - Default value */
62  (uint16_t)sizeof(SlNetAppGetFullServiceWithTextIpv4List_t), /* 1 - SL_NETAPP_FULL_SERVICE_WITH_TEXT_IPV4_TYPE */
63  (uint16_t)sizeof(SlNetAppGetFullServiceIpv4List_t), /* 2 - SL_NETAPP_FULL_SERVICE_IPV4_TYPE */
64  (uint16_t)sizeof(SlNetAppGetShortServiceIpv4List_t), /* 3 - SL_NETAPP_SHORT_SERVICE_IPV4_TYPE */
65  (uint16_t)sizeof(SlNetAppGetFullServiceWithTextIpv6List_t), /* 4 - SL_NETAPP_FULL_SERVICE_WITH_TEXT_IPV6_TYPE */
66  (uint16_t)sizeof(SlNetAppGetFullServiceIpv6List_t), /* 5 - SL_NETAPP_FULL_SERVICE_IPV6_TYPE */
67  (uint16_t)sizeof(SlNetAppGetShortServiceIpv6List_t) /* 6 - SL_NETAPP_SHORT_SERVICE_IPV6_TYPE */
68 };
69 
70 //*****************************************************************************
71 // typedefs
72 //*****************************************************************************
73 
74 typedef struct _ATCmdNetapp_t_
75 {
76  uint16_t handle;
77  uint16_t len;
78  uint32_t flags;
79  uint8_t format;
80  uint8_t *data;
81 }ATCmdNetapp_t;
82 
83 typedef struct _ATCmdNetapp_GetHostByName_t_
84 {
85  int8_t *hostName;
86  uint16_t nameLen;
87  uint8_t family;
88  uint32_t addr[4];
89 }ATCmdNetapp_GetHostByName_t;
90 
91 typedef struct _ATCmdNetapp_GetHostByService_t_
92 {
93  int8_t *serviceName;
94  uint8_t serviceLen;
95  uint8_t family;
96  uint32_t addr[4];
97  uint32_t port;
98  uint16_t textLen;
99  int8_t *text;
100 }ATCmdNetapp_GetHostByService_t;
101 
102 typedef struct _ATCmdNetapp_Ping_t_
103 {
104  SlNetAppPingCommand_t pingParams;
105  uint8_t family;
106  SlNetAppPingReport_t report;
107 }ATCmdNetapp_Ping_t;
108 
109 typedef struct _ATCmdNetapp_GetServiceList_t_
110 {
111  uint8_t offest;
112  uint8_t maxCount;
113  uint8_t flags;
114  int16_t count;
115  int8_t *buffer;
116  uint32_t bufferLen;
117 }ATCmdNetapp_GetServiceList_t;
118 
119 typedef struct _ATCmdNetapp_RegisterService_t_
120 {
121  int8_t *serviceName;
122  uint8_t serviceNameLen;
123  int8_t *text;
124  uint8_t textLen;
125  uint16_t port;
126  uint32_t ttl;
127  uint32_t options;
128 }ATCmdNetapp_RegisterService_t;
129 
130 typedef struct _ATCmdNetapp_UnregisterService_t_
131 {
132  int8_t *serviceName;
133  uint8_t serviceNameLen;
134  uint32_t options;
135 }ATCmdNetapp_UnregisterService_t;
136 
137 typedef struct _ATCmdNetapp_Set_t_
138 {
139  uint8_t id;
140  uint8_t option;
141  uint8_t len;
142  uint8_t *value;
143 }ATCmdNetapp_Set_t;
144 
145 
146 //*****************************************************************************
147 // AT Command Netapp Routines
148 //*****************************************************************************
149 
150 
162 int32_t ATCmdNetapp_startCallback(void *arg)
163 {
164  int32_t ret = 0;
165  uint32_t appBitMap;
166 
167  appBitMap = 0x0;
168 
169  /* Call the command parser */
170  if ((ret = StrMpl_getBitmaskListVal(ATCmd_netappType, sizeof(ATCmd_netappType)/sizeof(StrMpl_List_t), (char **)&arg, &appBitMap, ATCMD_DELIM_TRM,ATCMD_DELIM_BIT, ATCmd_excludeDelimArray, STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
171  {
172  ATCmd_errorResult(ATCmd_errorParseStr,ret);
173  return -1;
174  }
175 
176  /* app ID should exclude the SL_NETAPP_DEVICE_ID and SL_NETAPP_DNS_CLIENT_ID */
177  if (appBitMap > 0x0F)
178  {
179  ATCmd_errorResult(ATCmd_errorParseStr,0);
180  return -1;
181  }
182  /* start netapp */
183  ret = sl_NetAppStart(appBitMap);
184 
185  if (ret < 0)
186  {
187  ATCmd_errorResult(ATCmd_errorCmdStr,ret);
188  }
189  else
190  {
191  ATCmd_okResult();
192  }
193 
194  return ret;
195 }
196 
208 int32_t ATCmdNetapp_stopCallback(void *arg)
209 {
210  int32_t ret = 0;
211  uint32_t appBitMap;
212 
213  appBitMap = 0x0;
214 
215  /* Call the command parser */
216  if ((ret = StrMpl_getBitmaskListVal(ATCmd_netappType, sizeof(ATCmd_netappType)/sizeof(StrMpl_List_t), (char **)&arg, &appBitMap, ATCMD_DELIM_TRM,ATCMD_DELIM_BIT, ATCmd_excludeDelimArray, STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
217  {
218  ATCmd_errorResult(ATCmd_errorParseStr,ret);
219  return -1;
220  }
221  /* app ID should exclude the SL_NETAPP_DEVICE_ID and SL_NETAPP_DNS_CLIENT_ID */
222  if (appBitMap > 0x0F)
223  {
224  ATCmd_errorResult(ATCmd_errorParseStr,0);
225  return -1;
226  }
227 
228  /* stop netapp */
229  ret = sl_NetAppStop(appBitMap);
230 
231  if (ret < 0)
232  {
233  ATCmd_errorResult(ATCmd_errorCmdStr,ret);
234  }
235  else
236  {
237  ATCmd_okResult();
238  }
239 
240  return ret;
241 }
242 
251 int32_t ATCmdNetapp_getHostByNameFree(ATCmdNetapp_GetHostByName_t *params)
252 {
253  if (params != NULL)
254  {
255  if (params->hostName != NULL)
256  {
257  free(params->hostName);
258  }
259  free(params);
260  }
261  return 0;
262 }
263 
274 int32_t ATCmdNetapp_getHostByNameParse(char *buff, ATCmdNetapp_GetHostByName_t *params)
275 {
276  int32_t ret = 0;
277 
278  /* host name */
279  if ((ret = StrMpl_getAllocStr(&buff, (char **)&params->hostName, ATCMD_DELIM_ARG, 0xFF ,ATCmd_excludeDelimStr)) < 0)
280  {
281  return ret;
282  }
283  params->nameLen = strlen((char *)params->hostName);
284 
285  /* family */
286  if ((ret = StrMpl_getListVal(ATCmd_sockDomain, sizeof(ATCmd_sockDomain)/sizeof(StrMpl_List_t), &buff, &params->family, ATCMD_DELIM_TRM, STRMPL_FLAG_PARAM_SIZE_16) ) < 0)
287  {
288  return ret;
289  }
290 
291  return ret;
292 }
293 
304 int32_t ATCmdNetapp_getHostByNameResult(void *args, int32_t num, char *buff)
305 {
306  ATCmdNetapp_GetHostByName_t *params = (ATCmdNetapp_GetHostByName_t *)args;
307  uint8_t ip[4];
308 
309  StrMpl_setStr(ATCmd_netappGetHostByNameStr,&buff,ATCMD_DELIM_EVENT);
310  StrMpl_setStr((char *)params->hostName,&buff,ATCMD_DELIM_ARG);
311 
312  if (params->family == SL_AF_INET)
313  {
314  /* address */
315  ATCmd_valToIPv4(params->addr[0], ip);
316  StrMpl_setArrayVal(ip,&buff,4,ATCMD_DELIM_TRM,ATCMD_DELIM_INTER,STRMPL_FLAG_PARAM_DEC | STRMPL_FLAG_PARAM_SIZE_8 | STRMPL_FLAG_PARAM_UNSIGNED);
317  }
318  else if (params->family == SL_AF_INET6)
319  {
320  /* address */
321  StrMpl_setArrayVal(params->addr,&buff,4,ATCMD_DELIM_TRM,ATCMD_DELIM_ARRAY,STRMPL_FLAG_PARAM_HEX | STRMPL_FLAG_PARAM_SIZE_32 | STRMPL_FLAG_PARAM_UNSIGNED);
322  }
323  ATCmdNetapp_getHostByNameFree(params);
324 
325  return 0;
326 }
327 
339 int32_t ATCmdNetapp_getHostByNameCallback(void *arg)
340 {
341  int32_t ret = 0;
342  ATCmdNetapp_GetHostByName_t *params;
343 
344  params = malloc(sizeof(ATCmdNetapp_GetHostByName_t));
345 
346  if (params == NULL)
347  {
348  ATCmd_errorResult(ATCmd_errorAllocStr,0);
349  return -1;
350  }
351  memset(params, 0x0, sizeof(ATCmdNetapp_GetHostByName_t));
352 
353  /* Call the command parser */
354  ret = ATCmdNetapp_getHostByNameParse((char *)arg, params);
355 
356  if (ret < 0)
357  {
358  ATCmd_errorResult(ATCmd_errorParseStr,ret);
359  ATCmdNetapp_getHostByNameFree(params);
360  return -1;
361  }
362 
363  /* Get host by name */
364  ret = sl_NetAppDnsGetHostByName(params->hostName, params->nameLen, (_u32 *)params->addr, params->family);
365 
366  if (ret < 0)
367  {
368  ATCmd_errorResult(ATCmd_errorCmdStr,ret);
369  ATCmdNetapp_getHostByNameFree(params);
370  }
371  else
372  {
373  ATCmd_commandResult(ATCmdNetapp_getHostByNameResult,params,0);
374  ATCmd_okResult();
375  }
376 
377  return ret;
378 }
379 
388 int32_t ATCmdNetapp_getHostByServiceFree(ATCmdNetapp_GetHostByService_t *params)
389 {
390  if (params != NULL)
391  {
392  if (params->serviceName != NULL)
393  {
394  free(params->serviceName);
395  }
396  if (params->text != NULL)
397  {
398  free(params->text);
399  }
400  free(params);
401  }
402  return 0;
403 }
404 
415 int32_t ATCmdNetapp_getHostByServiceParse(char *buff, ATCmdNetapp_GetHostByService_t *params)
416 {
417  int32_t ret = 0;
418 
419  /* service name */
420  if ((ret = StrMpl_getAllocStr(&buff, (char **)&params->serviceName, ATCMD_DELIM_ARG, SL_NETAPP_MAX_SERVICE_NAME_SIZE ,ATCmd_excludeDelimStr)) < 0)
421  {
422  return ret;
423  }
424  params->serviceLen = strlen((char *)params->serviceName);
425 
426  /* family */
427  if ((ret = StrMpl_getListVal(ATCmd_sockDomain, sizeof(ATCmd_sockDomain)/sizeof(StrMpl_List_t), &buff, &params->family, ATCMD_DELIM_TRM, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
428  {
429  return ret;
430  }
431 
432  return ret;
433 }
434 
445 int32_t ATCmdNetapp_getHostByServiceResult(void *args, int32_t num, char *buff)
446 {
447  ATCmdNetapp_GetHostByService_t *params = (ATCmdNetapp_GetHostByService_t *)args;
448  uint8_t ip[4];
449 
450  StrMpl_setStr(ATCmd_netappGetHostByServiceStr,&buff,ATCMD_DELIM_EVENT);
451  StrMpl_setStr((char *)params->serviceName,&buff,ATCMD_DELIM_ARG);
452 
453  /* port */
454  StrMpl_setVal(&params->port,&buff,ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32 |STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
455  if (params->family == SL_AF_INET)
456  {
457  /* address */
458  ATCmd_valToIPv4(params->addr[0], ip);
459  StrMpl_setArrayVal(ip,&buff,4,ATCMD_DELIM_ARG,ATCMD_DELIM_INTER,STRMPL_FLAG_PARAM_DEC | STRMPL_FLAG_PARAM_SIZE_8 | STRMPL_FLAG_PARAM_UNSIGNED);
460  }
461  else if (params->family == SL_AF_INET6)
462  {
463  /* address */
464  StrMpl_setArrayVal(params->addr,&buff,4,ATCMD_DELIM_ARG,ATCMD_DELIM_ARRAY,STRMPL_FLAG_PARAM_HEX | STRMPL_FLAG_PARAM_SIZE_32 | STRMPL_FLAG_PARAM_UNSIGNED);
465  }
466  StrMpl_setStr((char *)params->text,&buff,ATCMD_DELIM_TRM);
467  ATCmdNetapp_getHostByServiceFree(params);
468 
469  return 0;
470 }
471 
483 int32_t ATCmdNetapp_getHostByServiceCallback(void *arg)
484 {
485  int32_t ret = 0;
486  ATCmdNetapp_GetHostByService_t *params;
487 
488  params = malloc(sizeof(ATCmdNetapp_GetHostByService_t));
489 
490  if (params == NULL)
491  {
492  ATCmd_errorResult(ATCmd_errorAllocStr,0);
493  return -1;
494  }
495  memset(params, 0x0, sizeof(ATCmdNetapp_GetHostByService_t));
496 
497  /* Call the command parser */
498  ret = ATCmdNetapp_getHostByServiceParse((char *)arg, params);
499 
500  if (ret < 0)
501  {
502  ATCmd_errorResult(ATCmd_errorParseStr,ret);
503  ATCmdNetapp_getHostByServiceFree(params);
504  return -1;
505  }
506 
507  params->textLen = SL_NETAPP_MAX_SERVICE_TEXT_SIZE;
508  params->text = malloc(params->textLen);
509  if (params->text == NULL)
510  {
511  ATCmd_errorResult(ATCmd_errorAllocStr,0);
512  ATCmdNetapp_getHostByServiceFree(params);
513  return -1;
514  }
515  /* Get host by service */
516  ret = sl_NetAppDnsGetHostByService(params->serviceName, params->serviceLen, params->family,(_u32 *)params->addr,(_u32 *)&params->port,&params->textLen,params->text);
517 
518  if (ret < 0)
519  {
520  ATCmd_errorResult(ATCmd_errorCmdStr,ret);
521  ATCmdNetapp_getHostByServiceFree(params);
522  }
523  else
524  {
525  ATCmd_commandResult(ATCmdNetapp_getHostByServiceResult,params,0);
526  ATCmd_okResult();
527  }
528 
529  return ret;
530 }
531 
532 
541 int32_t ATCmdNetapp_sendFree(ATCmdNetapp_t *params)
542 {
543  if (params->data != NULL)
544  {
545  free(params->data);
546  }
547  return 0;
548 }
549 
560 int32_t ATCmdNetapp_sendParse(char *buff, ATCmdNetapp_t *params)
561 {
562  int32_t ret = 0;
563  uint16_t outputLen;
564 
565  /* handle */
566  if ((ret = StrMpl_getVal(&buff, &params->handle, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_16 )) < 0)
567  {
568  return ret;
569  }
570 
571  /* flags */
572  if ((ret = StrMpl_getBitmaskListVal(ATCmd_netappFlags, sizeof(ATCmd_netappFlags)/sizeof(StrMpl_List_t), &buff, &params->flags, ATCMD_DELIM_ARG,ATCMD_DELIM_BIT, ATCmd_excludeDelimArray, STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
573  {
574  return ret;
575  }
576  /* data format */
577  if ((ret = StrMpl_getVal(&buff, &params->format , ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_8)) < 0)
578  {
579  return ret;
580  }
581 
582  /* data length */
583  if ((ret = StrMpl_getVal(&buff, &params->len, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_16 )) < 0)
584  {
585  return ret;
586  }
587  /* data */
588  if (params->format == ATCMD_DATA_FORMAT_BASE64)
589  {
590  /* convert length to binary length */
591  outputLen = StrMpl_getBase64DecBufSize((uint8_t *)buff,params->len);
592  params->data = malloc(outputLen);
593  if (params->data == NULL)
594  {
595  return -1;
596  }
597  if (StrMpl_decodeBase64((uint8_t *)buff, params->len, params->data, (uint32_t *)&outputLen) < 0)
598  {
599  return -1;
600  }
601  params->len = outputLen;
602  }
603  else
604  {
605  params->data = malloc(params->len);
606  if (params->data == NULL)
607  {
608  return -1;
609  }
610 
611  memcpy(params->data, buff, params->len);
612  }
613 
614  return ret;
615 }
616 
617 
629 int32_t ATCmdNetapp_sendCallback(void *arg)
630 {
631  int32_t ret = 0;
632  ATCmdNetapp_t params;
633 
634  memset(&params, 0x0, sizeof(ATCmdNetapp_t));
635 
636  /* Call the command parser */
637  ret = ATCmdNetapp_sendParse((char *)arg, &params);
638 
639  if (ret < 0)
640  {
641  ATCmd_errorResult(ATCmd_errorParseStr,ret);
642  ATCmdNetapp_sendFree(&params);
643  return -1;
644  }
645 
646  /* netapp send */
647  ret = sl_NetAppSend(params.handle, params.len, params.data,params.flags);
648 
649  if (ret < 0)
650  {
651  ATCmd_errorResult(ATCmd_errorCmdStr,ret);
652  }
653  else
654  {
655  ATCmd_okResult();
656  }
657 
658  ATCmdNetapp_sendFree(&params);
659  return ret;
660 }
661 
670 int32_t ATCmdNetapp_recvFree(ATCmdNetapp_t *params)
671 {
672  if (params != NULL)
673  {
674  if (params->data != NULL)
675  {
676  free(params->data);
677  }
678  free(params);
679  }
680  return 0;
681 }
682 
693 int32_t ATCmdNetapp_recvParse(char *buff, ATCmdNetapp_t *params)
694 {
695  int32_t ret = 0;
696 
697  /* handle */
698  if ((ret = StrMpl_getVal(&buff, &params->handle, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_16 )) < 0)
699  {
700  return ret;
701  }
702 
703  /* data format */
704  if ((ret = StrMpl_getVal(&buff, &params->format , ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_8)) < 0)
705  {
706  return ret;
707  }
708 
709  /* data length */
710  if ((ret = StrMpl_getVal(&buff, &params->len, ATCMD_DELIM_TRM,STRMPL_FLAG_PARAM_SIZE_16 )) < 0)
711  {
712  return ret;
713  }
714 
715  return ret;
716 }
717 
728 int32_t ATCmdNetapp_recvResult(void *args, int32_t num, char *buff)
729 {
730  ATCmdNetapp_t *params = (ATCmdNetapp_t *)args;
731  uint32_t outputLen;
732 
733  StrMpl_setStr(ATCmd_netappRecvStr,&buff,ATCMD_DELIM_EVENT);
734  /* handle */
735  StrMpl_setVal(&params->handle, &buff,ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_16 |STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
736  /* flags */
737  StrMpl_setBitmaskListStr(ATCmd_netappFlags, sizeof(ATCmd_netappFlags)/sizeof(StrMpl_List_t),&params->flags, &buff, ATCMD_DELIM_ARG, ATCMD_DELIM_BIT, STRMPL_FLAG_PARAM_SIZE_32);
738  /* format */
739  StrMpl_setVal(&params->format, &buff,ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_8 |STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
740  /* length */
741  outputLen = params->len;
742  if (params->format == ATCMD_DATA_FORMAT_BASE64)
743  {
744  /* convert length from binary to base64 */
745  outputLen = StrMpl_getBase64EncBufSize(params->len);
746  }
747  StrMpl_setVal(&outputLen, &buff,ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_16 |STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
748  /* data */
749  if (params->format == ATCMD_DATA_FORMAT_BASE64)
750  {
751  /* convert data to base64 */
752  StrMpl_encodeBase64(params->data, params->len, (uint8_t *)buff, &outputLen);
753  }
754  else
755  {
756  memcpy(buff,params->data,params->len);
757  }
758  ATCmdNetapp_recvFree(params);
759 
760  return 0;
761 }
762 
774 int32_t ATCmdNetapp_recvCallback(void *arg)
775 {
776  int32_t ret = 0;
777  ATCmdNetapp_t *params;
778 
779  params = malloc(sizeof(ATCmdNetapp_t));
780 
781  if (params == NULL)
782  {
783  ATCmd_errorResult(ATCmd_errorAllocStr,0);
784  return -1;
785  }
786 
787  memset(params, 0x0, sizeof(ATCmdNetapp_t));
788 
789  /* Call the command parser */
790  ret = ATCmdNetapp_recvParse((char *)arg, params);
791 
792  if (ret < 0)
793  {
794  ATCmd_errorResult(ATCmd_errorParseStr,ret);
795  ATCmdNetapp_recvFree(params);
796  return -1;
797  }
798 
799  /* netapp recv */
800  ret = sl_NetAppRecv(params->handle, &params->len, params->data,(_u32 *)&params->flags);
801 
802  if (ret < 0)
803  {
804  ATCmd_errorResult(ATCmd_errorCmdStr,ret);
805  ATCmdNetapp_recvFree(params);
806  }
807  else
808  {
809  ATCmd_commandResult(ATCmdNetapp_recvResult,params,0);
810  ATCmd_okResult();
811  }
812 
813  return ret;
814 }
815 
816 
827 int32_t ATCmdNetapp_pingParse(char *buff, ATCmdNetapp_Ping_t *params)
828 {
829  int32_t ret = 0;
830  uint8_t ip[4];
831 
832  /* family */
833  if ((ret = StrMpl_getListVal(ATCmd_sockDomain, sizeof(ATCmd_sockDomain)/sizeof(StrMpl_List_t), &buff, &params->family, ATCMD_DELIM_ARG, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
834  {
835  return ret;
836  }
837  if (params->family == SL_AF_INET)
838  {
839  /* address */
840  if ((ret = StrMpl_getArrayVal(&buff,(void *)ip,4,ATCMD_DELIM_ARG,ATCMD_DELIM_INTER, STRMPL_FLAG_PARAM_SIZE_8,ATCmd_excludeDelimArray )) < 0)
841  {
842  return ret;
843  }
844  params->pingParams.Ip = SL_IPV4_VAL(ip[0],ip[1],ip[2],ip[3]);
845  }
846  else if (params->family == SL_AF_INET6)
847  {
848  /* address */
849  if ((ret = StrMpl_getArrayVal(&buff, (void *)&params->pingParams.Ip,4,ATCMD_DELIM_ARG,ATCMD_DELIM_ARRAY,STRMPL_FLAG_PARAM_SIZE_32,ATCmd_excludeDelimArray)) < 0)
850  {
851  return ret;
852  }
853  }
854  else
855  {
856  return -1;
857  }
858 
859  /* size */
860  if ((ret = StrMpl_getVal(&buff, &params->pingParams.PingSize, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_16 )) < 0)
861  {
862  return ret;
863  }
864 
865  /* delay */
866  if ((ret = StrMpl_getVal(&buff, &params->pingParams.PingIntervalTime , ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32)) < 0)
867  {
868  return ret;
869  }
870 
871  /* timeout */
872  if ((ret = StrMpl_getVal(&buff, &params->pingParams.PingRequestTimeout, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_16 )) < 0)
873  {
874  return ret;
875  }
876 
877  /* max attempts */
878  if ((ret = StrMpl_getVal(&buff, &params->pingParams.TotalNumberOfAttempts , ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32)) < 0)
879  {
880  return ret;
881  }
882 
883  /* flags */
884  if ((ret = StrMpl_getVal(&buff, &params->pingParams.Flags, ATCMD_DELIM_TRM,STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
885  {
886  return ret;
887  }
888  return ret;
889 }
890 
901 int32_t ATCmdNetapp_pingResult(void *args, int32_t num, char *buff)
902 {
903  SlNetAppPingReport_t *params = (SlNetAppPingReport_t *)args;
904 
905  StrMpl_setStr(ATCmd_netappPingStr,&buff,ATCMD_DELIM_EVENT);
906 
907  /* packets send */
908  StrMpl_setVal(&params->PacketsSent, &buff,ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32 |STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
909  /* packets receive */
910  StrMpl_setVal(&params->PacketsReceived, &buff,ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32 |STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
911  /* time */
912  StrMpl_setVal(&params->AvgRoundTime, &buff,ATCMD_DELIM_TRM,STRMPL_FLAG_PARAM_SIZE_16 |STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
913 
914  free(params);
915 
916  return 0;
917 }
918 
919 void ATCmdNetapp_pingReport(SlNetAppPingReport_t *report)
920 {
921  SlNetAppPingReport_t *params = malloc(sizeof(SlNetAppPingReport_t));
922 
923  if (params == NULL)
924  {
925  return;
926  }
927  memcpy(params,report,sizeof(SlNetAppPingReport_t));
928  ATCmd_commandResult(ATCmdNetapp_pingResult,params,0);
929 }
930 
942 int32_t ATCmdNetapp_pingCallback(void *arg)
943 {
944  int32_t ret = 0;
945  ATCmdNetapp_Ping_t params;
946 
947  memset(&params, 0x0, sizeof(ATCmdNetapp_Ping_t));
948 
949  /* Call the command parser */
950  ret = ATCmdNetapp_pingParse((char *)arg, &params);
951 
952  if (ret < 0)
953  {
954  ATCmd_errorResult(ATCmd_errorParseStr,ret);
955  return -1;
956  }
957 
958  /* netapp ping */
959  ret = sl_NetAppPing(&params.pingParams, params.family,&params.report,ATCmdNetapp_pingReport);
960 
961  if (ret < 0)
962  {
963  ATCmd_errorResult(ATCmd_errorCmdStr,ret);
964  }
965  else
966  {
967  ATCmd_okResult();
968  }
969 
970  return ret;
971 }
980 int32_t ATCmdNetapp_getServiceListFree(ATCmdNetapp_GetServiceList_t *params)
981 {
982  if (params != NULL)
983  {
984  if (params->buffer != NULL)
985  {
986  free(params->buffer);
987  }
988  free(params);
989  }
990  return 0;
991 }
992 
1003 int32_t ATCmdNetapp_getServiceListParse(char *buff, ATCmdNetapp_GetServiceList_t *params)
1004 {
1005  int32_t ret = 0;
1006 
1007  /* offset */
1008  if ((ret = StrMpl_getVal(&buff, &params->offest, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1009  {
1010  return ret;
1011  }
1012 
1013  /* max services count */
1014  if ((ret = StrMpl_getVal(&buff, &params->maxCount , ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_8)) < 0)
1015  {
1016  return ret;
1017  }
1018 
1019  /* flags */
1020  if ((ret = StrMpl_getListVal(ATCmd_netappServiceListFlags, sizeof(ATCmd_netappServiceListFlags)/sizeof(StrMpl_List_t), &buff, &params->flags, ATCMD_DELIM_TRM, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1021  {
1022  return ret;
1023  }
1024 
1025  return ret;
1026 }
1027 
1038 int32_t ATCmdNetapp_getServiceListResult(void *args, int32_t num, char *buff)
1039 {
1040  ATCmdNetapp_GetServiceList_t *params = (ATCmdNetapp_GetServiceList_t *)args;
1041  uint8_t ip[4],i;
1042  char delimiter;
1043  uint8_t numParams = ((params->flags == SL_NETAPP_SHORT_SERVICE_IPV4_TYPE) || (params->flags == SL_NETAPP_SHORT_SERVICE_IPV6_TYPE))? 2:
1044  ((params->flags == SL_NETAPP_FULL_SERVICE_IPV4_TYPE) || (params->flags == SL_NETAPP_FULL_SERVICE_IPV6_TYPE))?4:5;
1045 
1046  StrMpl_setStr(ATCmd_netappGetServiceListStr,&buff,ATCMD_DELIM_EVENT);
1047 
1048  for (i=0;i < params->count;i++)
1049  {
1050  delimiter = ATCMD_DELIM_ARG;
1051  if ((params->flags == SL_NETAPP_FULL_SERVICE_WITH_TEXT_IPV4_TYPE) ||
1052  (params->flags == SL_NETAPP_FULL_SERVICE_IPV4_TYPE) ||
1053  (params->flags == SL_NETAPP_SHORT_SERVICE_IPV4_TYPE))
1054  {
1055  /* ip */
1056  ATCmd_valToIPv4(((SlNetAppGetShortServiceIpv4List_t *)(params->buffer))->service_ipv4, ip);
1057  StrMpl_setArrayVal(ip,&buff,4,ATCMD_DELIM_ARG,ATCMD_DELIM_INTER,STRMPL_FLAG_PARAM_DEC | STRMPL_FLAG_PARAM_SIZE_8 | STRMPL_FLAG_PARAM_UNSIGNED);
1058  if (numParams == 2)
1059  {
1060  delimiter = (i == (params->count - 1))?ATCMD_DELIM_TRM:ATCMD_DELIM_LIST;
1061  }
1062  /* port */
1063  StrMpl_setVal(&(((SlNetAppGetShortServiceIpv4List_t *)(params->buffer))->service_port), &buff,delimiter,STRMPL_FLAG_PARAM_SIZE_16 |STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
1064  if (numParams > 2)
1065  {
1066  /* service name */
1067  StrMpl_setStr((char *)(((SlNetAppGetFullServiceIpv4List_t *)(params->buffer))->service_name),&buff,ATCMD_DELIM_ARG);
1068 
1069  if (numParams == 4)
1070  {
1071  delimiter = (i == (params->count - 1))?ATCMD_DELIM_TRM:ATCMD_DELIM_LIST;
1072  }
1073  /* service host name */
1074  StrMpl_setStr((char *)(((SlNetAppGetFullServiceIpv4List_t *)(params->buffer))->service_host),&buff,delimiter);
1075 
1076  if (numParams > 4)
1077  {
1078  delimiter = (i == (params->count - 1))?ATCMD_DELIM_TRM:ATCMD_DELIM_LIST;
1079  /* service text */
1080  StrMpl_setStr((char *)(((SlNetAppGetFullServiceWithTextIpv4List_t *)(params->buffer))->service_text),&buff,delimiter);
1081  }
1082  }
1083  }
1084  else
1085  {
1086  /* ip */
1087  StrMpl_setArrayVal(((SlNetAppGetShortServiceIpv6List_t *)(params->buffer))->service_ipv6,&buff,4,ATCMD_DELIM_TRM,ATCMD_DELIM_ARRAY,STRMPL_FLAG_PARAM_HEX | STRMPL_FLAG_PARAM_SIZE_32 | STRMPL_FLAG_PARAM_UNSIGNED);
1088 
1089 
1090  if (numParams == 2)
1091  {
1092  delimiter = (i == (params->count - 1))?ATCMD_DELIM_TRM:ATCMD_DELIM_LIST;
1093  }
1094  /* port */
1095  StrMpl_setVal(&(((SlNetAppGetShortServiceIpv6List_t *)(params->buffer))->service_port),&buff,delimiter,STRMPL_FLAG_PARAM_SIZE_16 |STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
1096  if (numParams > 2)
1097  {
1098  /* service name */
1099  StrMpl_setStr((char *)(((SlNetAppGetFullServiceIpv6List_t *)(params->buffer))->service_name),&buff,ATCMD_DELIM_ARG);
1100 
1101  if (numParams == 4)
1102  {
1103  delimiter = (i == (params->count - 1))?ATCMD_DELIM_TRM:ATCMD_DELIM_LIST;
1104  }
1105  /* service host name */
1106  StrMpl_setStr((char *)(((SlNetAppGetFullServiceIpv6List_t *)(params->buffer))->service_host),&buff,delimiter);
1107 
1108  if (numParams > 4)
1109  {
1110  delimiter = (i == (params->count - 1))?ATCMD_DELIM_TRM:ATCMD_DELIM_LIST;
1111  /* service text */
1112  StrMpl_setStr((char *)(((SlNetAppGetFullServiceWithTextIpv6List_t *)(params->buffer))->service_text),&buff,delimiter);
1113  }
1114  }
1115  }
1116  }
1117 
1118  ATCmdNetapp_getServiceListFree(params);
1119 
1120  return 0;
1121 }
1122 
1123 
1135 int32_t ATCmdNetapp_getServiceListCallback(void *arg)
1136 {
1137  int32_t ret = 0;
1138  ATCmdNetapp_GetServiceList_t *params;
1139 
1140  params = malloc(sizeof(ATCmdNetapp_GetServiceList_t));
1141 
1142  if (params == NULL)
1143  {
1144  ATCmd_errorResult(ATCmd_errorAllocStr,0);
1145  return -1;
1146  }
1147  memset(params, 0x0, sizeof(ATCmdNetapp_GetServiceList_t));
1148 
1149  /* Call the command parser */
1150  ret = ATCmdNetapp_getServiceListParse((char *)arg, params);
1151 
1152  if (ret < 0)
1153  {
1154  ATCmd_errorResult(ATCmd_errorParseStr,ret);
1155  ATCmdNetapp_getServiceListFree(params);
1156  return -1;
1157  }
1158  params->bufferLen = params->maxCount * ATCmdNetapp_serviceSize[params->flags];
1159  if (params->bufferLen > ATCMDNETAPP_MAX_BUFFER_LEN)
1160  {
1161  params->bufferLen = ATCMDNETAPP_MAX_BUFFER_LEN;
1162  }
1163  params->buffer = malloc(params->bufferLen);
1164  if (params->buffer == NULL)
1165  {
1166  ATCmd_errorResult(ATCmd_errorAllocStr,0);
1167  ATCmdNetapp_getServiceListFree(params);
1168  return -1;
1169  }
1170  /* netapp GetServiceList */
1171  params->count = sl_NetAppGetServiceList(params->offest, params->maxCount, params->flags,params->buffer,params->bufferLen);
1172 
1173  if (params->count < 0)
1174  {
1175  ATCmd_errorResult(ATCmd_errorCmdStr,params->count);
1176  ATCmdNetapp_getServiceListFree(params);
1177  return -1;
1178  }
1179  else
1180  {
1181  ATCmd_commandResult(ATCmdNetapp_getServiceListResult,params,0);
1182  ATCmd_okResult();
1183  }
1184 
1185  return ret;
1186 }
1187 
1196 int32_t ATCmdNetapp_registerServiceFree(ATCmdNetapp_RegisterService_t *params)
1197 {
1198  if (params->serviceName != NULL)
1199  {
1200  free(params->serviceName);
1201  }
1202  if (params->text!= NULL)
1203  {
1204  free(params->text);
1205  }
1206  return 0;
1207 }
1208 
1219 int32_t ATCmdNetapp_registerServiceParse(char *buff, ATCmdNetapp_RegisterService_t *params)
1220 {
1221  int32_t ret = 0;
1222 
1223  /* service name */
1224  if ((ret = StrMpl_getAllocStr(&buff, (char **)&params->serviceName, ATCMD_DELIM_ARG, SL_NETAPP_MAX_SERVICE_NAME_SIZE ,ATCmd_excludeDelimStr)) < 0)
1225  {
1226  return ret;
1227  }
1228  params->serviceNameLen = strlen((char *)params->serviceName);
1229 
1230  /* text name */
1231  if ((ret = StrMpl_getAllocStr(&buff, (char **)&params->text, ATCMD_DELIM_ARG, SL_NETAPP_MAX_SERVICE_TEXT_SIZE ,ATCmd_excludeDelimStr)) < 0)
1232  {
1233  return ret;
1234  }
1235  params->textLen = strlen((char *)params->text);
1236 
1237  /* port */
1238  if ((ret = StrMpl_getVal(&buff, &params->port, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_16 )) < 0)
1239  {
1240  return ret;
1241  }
1242 
1243  /* ttl */
1244  if ((ret = StrMpl_getVal(&buff, &params->ttl , ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32)) < 0)
1245  {
1246  return ret;
1247  }
1248 
1249  /* options */
1250  if ((ret = StrMpl_getBitmaskListVal(ATCmd_netappRegServiceOptions, sizeof(ATCmd_netappRegServiceOptions)/sizeof(StrMpl_List_t), &buff, &params->options, ATCMD_DELIM_TRM , ATCMD_DELIM_BIT, ATCmd_excludeDelimArray, STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
1251  {
1252  return ret;
1253  }
1254 
1255  return ret;
1256 }
1257 
1269 int32_t ATCmdNetapp_registerServiceCallback(void *arg)
1270 {
1271  int32_t ret = 0;
1272  ATCmdNetapp_RegisterService_t params;
1273 
1274  memset(&params, 0x0, sizeof(ATCmdNetapp_RegisterService_t));
1275 
1276  /* Call the command parser */
1277  ret = ATCmdNetapp_registerServiceParse((char *)arg, &params);
1278 
1279  if (ret < 0)
1280  {
1281  ATCmd_errorResult(ATCmd_errorParseStr,ret);
1282  ATCmdNetapp_registerServiceFree(&params);
1283  return -1;
1284  }
1285 
1286  if ((params.serviceNameLen + params.textLen) > SL_NETAPP_MDNS_MAX_SERVICE_NAME_AND_TEXT_LENGTH)
1287  {
1288  ATCmd_errorResult(ATCmd_errorParseStr,0);
1289  ATCmdNetapp_registerServiceFree(&params);
1290  return -1;
1291  }
1292 
1293  /* netapp MDNSRegisterService */
1294  ret = sl_NetAppMDNSRegisterService(params.serviceName, params.serviceNameLen, params.text,params.textLen,params.port,params.ttl,params.options);
1295 
1296  if (ret < 0)
1297  {
1298  ATCmd_errorResult(ATCmd_errorCmdStr,ret);
1299  }
1300  else
1301  {
1302  ATCmd_okResult();
1303  }
1304  ATCmdNetapp_registerServiceFree(&params);
1305 
1306  return ret;
1307 }
1308 
1317 int32_t ATCmdNetapp_unregisterServiceFree(ATCmdNetapp_UnregisterService_t *params)
1318 {
1319  if (params->serviceName != NULL)
1320  {
1321  free(params->serviceName);
1322  }
1323  return 0;
1324 }
1325 
1336 int32_t ATCmdNetapp_unregisterServiceParse(char *buff, ATCmdNetapp_UnregisterService_t *params)
1337 {
1338  int32_t ret = 0;
1339 
1340  /* service name */
1341  if ((ret = StrMpl_getAllocStr(&buff, (char **)&params->serviceName, ATCMD_DELIM_ARG, SL_NETAPP_MAX_SERVICE_NAME_SIZE ,ATCmd_excludeDelimStr)) < 0)
1342  {
1343  if (ret != STRMPL_ERROR_PARAM_MISSING)
1344  {
1345  return ret;
1346  }
1347  }
1348  params->serviceNameLen = strlen((char *)params->serviceName);
1349 
1350  /* options */
1351  if ((ret = StrMpl_getBitmaskListVal(ATCmd_netappRegServiceOptions, sizeof(ATCmd_netappRegServiceOptions)/sizeof(StrMpl_List_t), &buff, &params->options, ATCMD_DELIM_TRM , ATCMD_DELIM_BIT, ATCmd_excludeDelimArray, STRMPL_FLAG_PARAM_SIZE_32)) < 0)
1352  {
1353  if (ret != STRMPL_ERROR_PARAM_MISSING)
1354  {
1355  return ret;
1356  }
1357  ret = 0;
1358  }
1359 
1360  return ret;
1361 }
1362 
1374 int32_t ATCmdNetapp_unregisterServiceCallback(void *arg)
1375 {
1376  int32_t ret = 0;
1377  ATCmdNetapp_UnregisterService_t params;
1378 
1379  memset(&params, 0x0, sizeof(ATCmdNetapp_UnregisterService_t));
1380 
1381  /* Call the command parser */
1382  ret = ATCmdNetapp_unregisterServiceParse((char *)arg, &params);
1383 
1384  if (ret < 0)
1385  {
1386  ATCmd_errorResult(ATCmd_errorParseStr,ret);
1387  ATCmdNetapp_unregisterServiceFree(&params);
1388  return -1;
1389  }
1390 
1391  /* netapp MDNSUnRegisterService */
1392  ret = sl_NetAppMDNSUnRegisterService(params.serviceName, params.serviceNameLen, params.options);
1393 
1394  if (ret < 0)
1395  {
1396  ATCmd_errorResult(ATCmd_errorCmdStr,ret);
1397  }
1398  else
1399  {
1400  ATCmd_okResult();
1401  }
1402  ATCmdNetapp_unregisterServiceFree(&params);
1403 
1404  return ret;
1405 }
1406 
1407 
1416 int32_t ATCmdNetapp_setFree(ATCmdNetapp_Set_t *params)
1417 {
1418  if (params->value != NULL)
1419  {
1420  free(params->value);
1421  }
1422  return 0;
1423 }
1424 
1435 int32_t ATCmdNetapp_setParse(char *buff, ATCmdNetapp_Set_t *params)
1436 {
1437  int32_t ret = 0;
1438  uint8_t ip[4];
1439 
1440  /* App ID */
1441  if ((ret = StrMpl_getListVal(ATCmd_netappType, sizeof(ATCmd_netappType)/sizeof(StrMpl_List_t), &buff, &params->id, ATCMD_DELIM_ARG, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1442  {
1443  return ret;
1444  }
1445 
1446  /* option */
1447  switch (params->id)
1448  {
1449  case SL_NETAPP_HTTP_SERVER_ID:
1450  if ((ret = StrMpl_getListVal(ATCmd_netappHttpSrvOptions, sizeof(ATCmd_netappHttpSrvOptions)/sizeof(StrMpl_List_t), &buff, &params->option, ATCMD_DELIM_ARG, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1451  {
1452  return ret;
1453  }
1454  /* value */
1455  switch (params->option)
1456  {
1457  case SL_NETAPP_HTTP_AUTH_CHECK:
1458  case SL_NETAPP_HTTP_ROM_PAGES_ACCESS:
1459  case SL_NETAPP_HTTP_SECONDARY_PORT_ENABLE:
1460  case SL_NETAPP_HTTP_PRIMARY_PORT_SECURITY_MODE:
1461  params->len = sizeof(uint8_t);
1462  params->value = malloc(params->len);
1463  if (params->value == NULL)
1464  {
1465  return -1;
1466  }
1467  if ((ret = StrMpl_getVal(&buff, (void *)params->value , ATCMD_DELIM_TRM,STRMPL_FLAG_PARAM_SIZE_8)) < 0)
1468  {
1469  return ret;
1470  }
1471  break;
1472  case SL_NETAPP_HTTP_PRIMARY_PORT_NUMBER:
1473  case SL_NETAPP_HTTP_SECONDARY_PORT_NUMBER:
1474  params->len = sizeof(uint16_t);
1475  params->value = malloc(params->len);
1476  if (params->value == NULL)
1477  {
1478  return -1;
1479  }
1480  if ((ret = StrMpl_getVal(&buff, (void *)params->value , ATCMD_DELIM_TRM,STRMPL_FLAG_PARAM_SIZE_16)) < 0)
1481  {
1482  return ret;
1483  }
1484  break;
1485  case SL_NETAPP_HTTP_AUTH_NAME:
1486  case SL_NETAPP_HTTP_AUTH_PASSWORD:
1487  case SL_NETAPP_HTTP_AUTH_REALM:
1488  if ((ret = StrMpl_getAllocStr(&buff, (char **)&params->value, ATCMD_DELIM_TRM, SL_NETAPP_MAX_AUTH_NAME_LEN ,ATCmd_excludeDelimStr)) < 0)
1489  {
1490  return ret;
1491  }
1492  params->len = strlen((char *)params->value);
1493  break;
1494 
1495  case SL_NETAPP_HTTP_PRIVATE_KEY_FILENAME:
1496  case SL_NETAPP_HTTP_DEVICE_CERTIFICATE_FILENAME:
1497  case SL_NETAPP_HTTP_CA_CERTIFICATE_FILE_NAME:
1498  if ((ret = StrMpl_getAllocStr(&buff, (char **)&params->value, ATCMD_DELIM_TRM, ATCMDNETAPP_MAX_SECURITY_FILE_NAME_SIZE ,ATCmd_excludeDelimStr)) < 0)
1499  {
1500  return ret;
1501  }
1502  params->len = strlen((char *)params->value);
1503  break;
1504 
1505  case SL_NETAPP_HTTP_TEMP_REGISTER_MDNS_SERVICE_NAME:
1506  case SL_NETAPP_HTTP_TEMP_UNREGISTER_MDNS_SERVICE_NAME:
1507  if ((ret = StrMpl_getAllocStr(&buff, (char **)&params->value, ATCMD_DELIM_TRM, ATCMDNETAPP_MAX_SIZE_OF_DEVICE_NAME ,ATCmd_excludeDelimStr)) < 0)
1508  {
1509  return ret;
1510  }
1511  params->len = strlen((char *)params->value);
1512  break;
1513 
1514  default:
1515  return -1;
1516  }
1517  break;
1518 
1519  case SL_NETAPP_DHCP_SERVER_ID:
1520  if ((ret = StrMpl_getListVal(ATCmd_netappDhcpSrvOptions, sizeof(ATCmd_netappDhcpSrvOptions)/sizeof(StrMpl_List_t), &buff, &params->option, ATCMD_DELIM_ARG, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1521  {
1522  return ret;
1523  }
1524  /* value */
1525  switch (params->option)
1526  {
1527  case SL_NETAPP_DHCP_SRV_BASIC_OPT:
1528  params->len = sizeof(SlNetAppDhcpServerBasicOpt_t);
1529  params->value = malloc(params->len);
1530  if (params->value == NULL)
1531  {
1532  return -1;
1533  }
1534  if ((ret = StrMpl_getVal(&buff, &(((SlNetAppDhcpServerBasicOpt_t *)(params->value))->lease_time), ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
1535  {
1536  return ret;
1537  }
1538  if ((ret = StrMpl_getArrayVal(&buff,(void *)ip,4,ATCMD_DELIM_ARG,ATCMD_DELIM_INTER, STRMPL_FLAG_PARAM_SIZE_8 ,ATCmd_excludeDelimArray)) < 0)
1539  {
1540  return ret;
1541  }
1542  ((SlNetAppDhcpServerBasicOpt_t *)(params->value))->ipv4_addr_start = SL_IPV4_VAL(ip[0],ip[1],ip[2],ip[3]);
1543  if ((ret = StrMpl_getArrayVal(&buff,(void *)ip,4,ATCMD_DELIM_TRM,ATCMD_DELIM_INTER, STRMPL_FLAG_PARAM_SIZE_8 ,ATCmd_excludeDelimArray)) < 0)
1544  {
1545  return ret;
1546  }
1547  ((SlNetAppDhcpServerBasicOpt_t *)(params->value))->ipv4_addr_last = SL_IPV4_VAL(ip[0],ip[1],ip[2],ip[3]);
1548 
1549  break;
1550  default:
1551  return -1;
1552  }
1553  break;
1554 
1555  case SL_NETAPP_MDNS_ID:
1556  if ((ret = StrMpl_getListVal(ATCmd_netappMdnsOptions, sizeof(ATCmd_netappMdnsOptions)/sizeof(StrMpl_List_t), &buff, &params->option, ATCMD_DELIM_ARG, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1557  {
1558  return ret;
1559  }
1560  /* value */
1561  switch (params->option)
1562  {
1563  case SL_NETAPP_MDNS_CONT_QUERY_OPT:
1564  if ((ret = StrMpl_getAllocStr(&buff, (char **)&params->value, ATCMD_DELIM_TRM, ATCMDNETAPP_MAX_SIZE_OF_DEVICE_NAME ,ATCmd_excludeDelimStr)) < 0)
1565  {
1566  return ret;
1567  }
1568  params->len = strlen((char *)params->value);
1569  break;
1570  case SL_NETAPP_MDNS_QEVETN_MASK_OPT:
1571  params->len = sizeof(uint32_t);
1572  params->value = malloc(params->len);
1573  if (params->value == NULL)
1574  {
1575  return -1;
1576  }
1577  if ((ret = StrMpl_getBitmaskListVal(ATCmd_netappMdnsTypes, sizeof(ATCmd_netappMdnsTypes)/sizeof(StrMpl_List_t), &buff, (void *)params->value, ATCMD_DELIM_TRM, ATCMD_DELIM_BIT, ATCmd_excludeDelimArray, STRMPL_FLAG_PARAM_SIZE_32)) < 0)
1578  {
1579  return ret;
1580  }
1581  break;
1582 
1583  case SL_NETAPP_MDNS_TIMING_PARAMS_OPT:
1584  params->len = sizeof(SlNetAppServiceAdvertiseTimingParameters_t);
1585  params->value = malloc(params->len);
1586  if (params->value == NULL)
1587  {
1588  return -1;
1589  }
1590  if ((ret = StrMpl_getVal(&buff, &(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->t), ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
1591  {
1592  return ret;
1593  }
1594  if ((ret = StrMpl_getVal(&buff, &(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->p), ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
1595  {
1596  return ret;
1597  }
1598  if ((ret = StrMpl_getVal(&buff, &(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->k), ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
1599  {
1600  return ret;
1601  }
1602  if ((ret = StrMpl_getVal(&buff, &(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->RetransInterval), ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
1603  {
1604  return ret;
1605  }
1606  if ((ret = StrMpl_getVal(&buff, &(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->Maxinterval), ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
1607  {
1608  return ret;
1609  }
1610  if ((ret = StrMpl_getVal(&buff, &(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->max_time), ATCMD_DELIM_TRM,STRMPL_FLAG_PARAM_SIZE_32 )) < 0)
1611  {
1612  return ret;
1613  }
1614 
1615  break;
1616 
1617  default:
1618  return -1;
1619  }
1620  break;
1621 
1622  case SL_NETAPP_DEVICE_ID:
1623  if ((ret = StrMpl_getListVal(ATCmd_netappDevOptions, sizeof(ATCmd_netappDevOptions)/sizeof(StrMpl_List_t), &buff, &params->option, ATCMD_DELIM_ARG, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1624  {
1625  return ret;
1626  }
1627  /* value */
1628  switch (params->option)
1629  {
1630  case SL_NETAPP_DEVICE_URN:
1631  if ((ret = StrMpl_getAllocStr(&buff, (char **)&params->value, ATCMD_DELIM_TRM, SL_NETAPP_MAX_DEVICE_URN_LEN ,ATCmd_excludeDelimStr)) < 0)
1632  {
1633  return ret;
1634  }
1635  params->len = strlen((char *)params->value);
1636  break;
1637 
1638  case SL_NETAPP_DEVICE_DOMAIN:
1639  if ((ret = StrMpl_getAllocStr(&buff, (char **)&params->value, ATCMD_DELIM_TRM, ATCMDNETAPP_MAX_DOMAIN_NAME_LEN ,ATCmd_excludeDelimStr)) < 0)
1640  {
1641  return ret;
1642  }
1643  params->len = strlen((char *)params->value);
1644  break;
1645  default:
1646  return -1;
1647  }
1648  break;
1649 
1650  case SL_NETAPP_DNS_CLIENT_ID:
1651  if ((ret = StrMpl_getListVal(ATCmd_netappDnsClientOptions, sizeof(ATCmd_netappDnsClientOptions)/sizeof(StrMpl_List_t), &buff, &params->option, ATCMD_DELIM_ARG, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1652  {
1653  return ret;
1654  }
1655  /* value */
1656  switch (params->option)
1657  {
1658  case SL_NETAPP_DNS_CLIENT_TIME:
1659  params->value = malloc(sizeof(SlNetAppDnsClientTime_t));
1660  if (params->value == NULL)
1661  {
1662  return -1;
1663  }
1664  if ((ret = StrMpl_getVal(&buff, &(((SlNetAppDnsClientTime_t *)(params->value))->MaxResponseTime), ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_16 )) < 0)
1665  {
1666  return ret;
1667  }
1668  if ((ret = StrMpl_getVal(&buff, &(((SlNetAppDnsClientTime_t *)(params->value))->NumOfRetries), ATCMD_DELIM_TRM,STRMPL_FLAG_PARAM_SIZE_16 )) < 0)
1669  {
1670  return ret;
1671  }
1672  params->len = sizeof(SlNetAppDnsClientTime_t);
1673  break;
1674  default:
1675  return -1;
1676  }
1677  break;
1678 
1679  default:
1680  return -1;
1681  }
1682 
1683  return ret;
1684 }
1685 
1686 
1698 int32_t ATCmdNetapp_setCallback(void *arg)
1699 {
1700  int32_t ret = 0;
1701  ATCmdNetapp_Set_t params;
1702 
1703  memset(&params, 0x0, sizeof(ATCmdNetapp_Set_t));
1704 
1705  /* Call the command parser */
1706  ret = ATCmdNetapp_setParse((char *)arg, &params);
1707 
1708  if (ret < 0)
1709  {
1710  ATCmd_errorResult(ATCmd_errorParseStr,ret);
1711  ATCmdNetapp_setFree(&params);
1712  return -1;
1713  }
1714 
1715  /* set netapp option */
1716  ret = sl_NetAppSet(params.id,params.option,params.len,params.value);
1717 
1718  if (ret < 0)
1719  {
1720  ATCmd_errorResult(ATCmd_errorCmdStr,ret);
1721  }
1722  else
1723  {
1724  ATCmd_okResult();
1725  }
1726 
1727  ATCmdNetapp_setFree(&params);
1728  return ret;
1729 }
1730 
1731 
1740 int32_t ATCmdNetapp_getFree(ATCmdNetapp_Set_t *params)
1741 {
1742  if (params != NULL)
1743  {
1744  if (params->value != NULL)
1745  {
1746  free(params->value);
1747  }
1748  free(params);
1749  }
1750  return 0;
1751 }
1752 
1763 int32_t ATCmdNetapp_getParse(char *buff, ATCmdNetapp_Set_t *params)
1764 {
1765  int32_t ret = 0;
1766 
1767  /* App ID */
1768  if ((ret = StrMpl_getListVal(ATCmd_netappType, sizeof(ATCmd_netappType)/sizeof(StrMpl_List_t), &buff, &params->id, ATCMD_DELIM_ARG, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1769  {
1770  return ret;
1771  }
1772 
1773  /* option */
1774  switch (params->id)
1775  {
1776  case SL_NETAPP_HTTP_SERVER_ID:
1777  if ((ret = StrMpl_getListVal(ATCmd_netappHttpSrvOptions, sizeof(ATCmd_netappHttpSrvOptions)/sizeof(StrMpl_List_t), &buff, &params->option, ATCMD_DELIM_TRM, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1778  {
1779  return ret;
1780  }
1781  /* value */
1782  switch (params->option)
1783  {
1784  case SL_NETAPP_HTTP_AUTH_CHECK:
1785  case SL_NETAPP_HTTP_ROM_PAGES_ACCESS:
1786  case SL_NETAPP_HTTP_SECONDARY_PORT_ENABLE:
1787  case SL_NETAPP_HTTP_PRIMARY_PORT_SECURITY_MODE:
1788  params->len = sizeof(uint8_t);
1789  break;
1790  case SL_NETAPP_HTTP_PRIMARY_PORT_NUMBER:
1791  case SL_NETAPP_HTTP_SECONDARY_PORT_NUMBER:
1792  params->len = sizeof(uint16_t);
1793  break;
1794  case SL_NETAPP_HTTP_AUTH_NAME:
1795  case SL_NETAPP_HTTP_AUTH_PASSWORD:
1796  case SL_NETAPP_HTTP_AUTH_REALM:
1797  params->len = SL_NETAPP_MAX_AUTH_NAME_LEN;
1798  break;
1799 
1800  case SL_NETAPP_HTTP_PRIVATE_KEY_FILENAME:
1801  case SL_NETAPP_HTTP_DEVICE_CERTIFICATE_FILENAME:
1802  case SL_NETAPP_HTTP_CA_CERTIFICATE_FILE_NAME:
1803  params->len = ATCMDNETAPP_MAX_SECURITY_FILE_NAME_SIZE;
1804  break;
1805 
1806  case SL_NETAPP_HTTP_TEMP_REGISTER_MDNS_SERVICE_NAME:
1807  case SL_NETAPP_HTTP_TEMP_UNREGISTER_MDNS_SERVICE_NAME:
1808  params->len = ATCMDNETAPP_MAX_SIZE_OF_DEVICE_NAME;
1809  break;
1810 
1811  default:
1812  return -1;
1813  }
1814  break;
1815 
1816  case SL_NETAPP_DHCP_SERVER_ID:
1817  if ((ret = StrMpl_getListVal(ATCmd_netappDhcpSrvOptions, sizeof(ATCmd_netappDhcpSrvOptions)/sizeof(StrMpl_List_t), &buff, &params->option, ATCMD_DELIM_TRM, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1818  {
1819  return ret;
1820  }
1821  /* value */
1822  switch (params->option)
1823  {
1824  case SL_NETAPP_DHCP_SRV_BASIC_OPT:
1825  params->len = sizeof(SlNetAppDhcpServerBasicOpt_t);
1826  break;
1827  default:
1828  return -1;
1829  }
1830  break;
1831 
1832  case SL_NETAPP_MDNS_ID:
1833  if ((ret = StrMpl_getListVal(ATCmd_netappMdnsOptions, sizeof(ATCmd_netappMdnsOptions)/sizeof(StrMpl_List_t), &buff, &params->option, ATCMD_DELIM_TRM, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1834  {
1835  return ret;
1836  }
1837  /* value */
1838  switch (params->option)
1839  {
1840  case SL_NETAPP_MDNS_CONT_QUERY_OPT:
1841  params->len = ATCMDNETAPP_MAX_SIZE_OF_DEVICE_NAME;
1842  break;
1843  case SL_NETAPP_MDNS_QEVETN_MASK_OPT:
1844  params->len = sizeof(uint32_t);
1845  break;
1846 
1847  case SL_NETAPP_MDNS_TIMING_PARAMS_OPT:
1848  params->len = sizeof(SlNetAppServiceAdvertiseTimingParameters_t);
1849  break;
1850 
1851  default:
1852  return -1;
1853  }
1854  break;
1855 
1856  case SL_NETAPP_DEVICE_ID:
1857  if ((ret = StrMpl_getListVal(ATCmd_netappDevOptions, sizeof(ATCmd_netappDevOptions)/sizeof(StrMpl_List_t), &buff, &params->option, ATCMD_DELIM_TRM, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1858  {
1859  return ret;
1860  }
1861  /* value */
1862  switch (params->option)
1863  {
1864  case SL_NETAPP_DEVICE_URN:
1865  params->len = SL_NETAPP_MAX_DEVICE_URN_LEN;
1866  break;
1867 
1868  case SL_NETAPP_DEVICE_DOMAIN:
1869  params->len = ATCMDNETAPP_MAX_DOMAIN_NAME_LEN;
1870  break;
1871  default:
1872  return -1;
1873  }
1874  break;
1875 
1876  case SL_NETAPP_DNS_CLIENT_ID:
1877  if ((ret = StrMpl_getListVal(ATCmd_netappDnsClientOptions, sizeof(ATCmd_netappDnsClientOptions)/sizeof(StrMpl_List_t), &buff, &params->option, ATCMD_DELIM_TRM, STRMPL_FLAG_PARAM_SIZE_8 )) < 0)
1878  {
1879  return ret;
1880  }
1881  /* value */
1882  switch (params->option)
1883  {
1884  case SL_NETAPP_DNS_CLIENT_TIME:
1885  params->len = sizeof(SlNetAppDnsClientTime_t);
1886  break;
1887  default:
1888  return -1;
1889  }
1890  break;
1891 
1892  default:
1893  return -1;
1894  }
1895 
1896  params->value = malloc(params->len);
1897  if (params->value == NULL)
1898  {
1899  return -1;
1900  }
1901 
1902  return ret;
1903 }
1904 
1915 int32_t ATCmdNetapp_getResult(void *args, int32_t num, char *buff)
1916 {
1917  int32_t ret = 0;
1918  ATCmdNetapp_Set_t *params = (ATCmdNetapp_Set_t *)args;
1919  uint8_t ip[4];
1920 
1921  StrMpl_setStr(ATCmd_netappGetStr,&buff,ATCMD_DELIM_EVENT);
1922 
1923  switch (params->id)
1924  {
1925  case SL_NETAPP_HTTP_SERVER_ID:
1926  /* value */
1927  switch (params->option)
1928  {
1929  case SL_NETAPP_HTTP_AUTH_CHECK:
1930  case SL_NETAPP_HTTP_ROM_PAGES_ACCESS:
1931  case SL_NETAPP_HTTP_SECONDARY_PORT_ENABLE:
1932  case SL_NETAPP_HTTP_PRIMARY_PORT_SECURITY_MODE:
1933  StrMpl_setVal(params->value, &buff, ATCMD_DELIM_TRM,STRMPL_FLAG_PARAM_SIZE_8 |STRMPL_FLAG_PARAM_UNSIGNED | STRMPL_FLAG_PARAM_DEC);
1934  break;
1935  case SL_NETAPP_HTTP_PRIMARY_PORT_NUMBER:
1936  case SL_NETAPP_HTTP_SECONDARY_PORT_NUMBER:
1937  StrMpl_setVal(params->value, &buff, ATCMD_DELIM_TRM,STRMPL_FLAG_PARAM_SIZE_16 |STRMPL_FLAG_PARAM_UNSIGNED | STRMPL_FLAG_PARAM_DEC);
1938  break;
1939  case SL_NETAPP_HTTP_AUTH_NAME:
1940  case SL_NETAPP_HTTP_AUTH_PASSWORD:
1941  case SL_NETAPP_HTTP_AUTH_REALM:
1942  StrMpl_setStr((char *)params->value, &buff, ATCMD_DELIM_TRM);
1943  break;
1944 
1945  default:
1946  ret = -1;
1947  }
1948  break;
1949 
1950  case SL_NETAPP_DHCP_SERVER_ID:
1951  /* value */
1952  switch (params->option)
1953  {
1954  case SL_NETAPP_DHCP_SRV_BASIC_OPT:
1955  StrMpl_setVal(&(((SlNetAppDhcpServerBasicOpt_t *)(params->value))->lease_time), &buff, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32|STRMPL_FLAG_PARAM_UNSIGNED | STRMPL_FLAG_PARAM_DEC);
1956  ATCmd_valToIPv4(((SlNetAppDhcpServerBasicOpt_t *)(params->value))->ipv4_addr_start, ip);
1957  StrMpl_setArrayVal(ip,&buff,4,ATCMD_DELIM_ARG,ATCMD_DELIM_INTER,STRMPL_FLAG_PARAM_DEC | STRMPL_FLAG_PARAM_SIZE_8 | STRMPL_FLAG_PARAM_UNSIGNED);
1958  ATCmd_valToIPv4(((SlNetAppDhcpServerBasicOpt_t *)(params->value))->ipv4_addr_last, ip);
1959  StrMpl_setArrayVal(ip,&buff,4,ATCMD_DELIM_ARG,ATCMD_DELIM_INTER,STRMPL_FLAG_PARAM_DEC | STRMPL_FLAG_PARAM_SIZE_8 | STRMPL_FLAG_PARAM_UNSIGNED);
1960  break;
1961  default:
1962  ret = -1;
1963  }
1964  break;
1965 
1966  case SL_NETAPP_MDNS_ID:
1967  /* value */
1968  switch (params->option)
1969  {
1970  case SL_NETAPP_MDNS_CONT_QUERY_OPT:
1971  StrMpl_setStr((char *)params->value, &buff, ATCMD_DELIM_TRM);
1972  break;
1973  case SL_NETAPP_MDNS_QEVETN_MASK_OPT:
1974  StrMpl_setBitmaskListStr(ATCmd_netappMdnsTypes, sizeof(ATCmd_netappMdnsTypes)/sizeof(StrMpl_List_t), params->value, &buff, ATCMD_DELIM_TRM, ATCMD_DELIM_BIT, STRMPL_FLAG_PARAM_SIZE_32);
1975  break;
1976 
1977  case SL_NETAPP_MDNS_TIMING_PARAMS_OPT:
1978  StrMpl_setVal(&(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->t), &buff, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32|STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
1979  StrMpl_setVal(&(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->p), &buff, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32|STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
1980  StrMpl_setVal(&(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->k), &buff, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32|STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
1981  StrMpl_setVal(&(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->RetransInterval), &buff, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32|STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
1982  StrMpl_setVal(&(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->Maxinterval), &buff, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_32|STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
1983  StrMpl_setVal(&(((SlNetAppServiceAdvertiseTimingParameters_t *)(params->value))->max_time), &buff, ATCMD_DELIM_TRM,STRMPL_FLAG_PARAM_SIZE_32|STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
1984 
1985  break;
1986 
1987  default:
1988  ret = -1;
1989  }
1990  break;
1991 
1992  case SL_NETAPP_DEVICE_ID:
1993  /* value */
1994  switch (params->option)
1995  {
1996  case SL_NETAPP_DEVICE_URN:
1997  case SL_NETAPP_DEVICE_DOMAIN:
1998  StrMpl_setStr((char *)params->value, &buff, ATCMD_DELIM_TRM);
1999  break;
2000  default:
2001  ret = -1;
2002  }
2003  break;
2004 
2005  case SL_NETAPP_DNS_CLIENT_ID:
2006  /* value */
2007  switch (params->option)
2008  {
2009  case SL_NETAPP_DNS_CLIENT_TIME:
2010  StrMpl_setVal(&(((SlNetAppDnsClientTime_t *)(params->value))->MaxResponseTime), &buff, ATCMD_DELIM_ARG,STRMPL_FLAG_PARAM_SIZE_16|STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
2011  StrMpl_setVal(&(((SlNetAppDnsClientTime_t *)(params->value))->NumOfRetries), &buff, ATCMD_DELIM_TRM,STRMPL_FLAG_PARAM_SIZE_16|STRMPL_FLAG_PARAM_UNSIGNED|STRMPL_FLAG_PARAM_DEC);
2012  break;
2013  default:
2014  ret = -1;
2015  }
2016  break;
2017 
2018  default:
2019  ret = -1;
2020  }
2021  ATCmdNetapp_getFree(params);
2022 
2023  return ret;
2024 }
2025 
2037 int32_t ATCmdNetapp_getCallback(void *arg)
2038 {
2039  int32_t ret = 0;
2040  ATCmdNetapp_Set_t *params;
2041 
2042  params = malloc(sizeof(ATCmdNetapp_Set_t));
2043 
2044  if (params == NULL)
2045  {
2046  ATCmd_errorResult(ATCmd_errorAllocStr,0);
2047  return -1;
2048  }
2049  memset(params, 0x0, sizeof(ATCmdNetapp_Set_t));
2050 
2051  /* Call the command parser */
2052  ret = ATCmdNetapp_getParse((char *)arg, params);
2053 
2054  if (ret < 0)
2055  {
2056  ATCmd_errorResult(ATCmd_errorParseStr,ret);
2057  ATCmdNetapp_getFree(params);
2058  return -1;
2059  }
2060 
2061  /* set netapp option */
2062  ret = sl_NetAppGet(params->id,params->option,&params->len,params->value);
2063 
2064  if (ret < 0)
2065  {
2066  ATCmd_errorResult(ATCmd_errorCmdStr,ret);
2067  ATCmdNetapp_getFree(params);
2068  }
2069  else
2070  {
2071  ATCmd_commandResult(ATCmdNetapp_getResult,params,0);
2072  ATCmd_okResult();
2073  }
2074 
2075  return ret;
2076 }
2077 
ATCmdNetapp_pingCallback
int32_t ATCmdNetapp_pingCallback(void *arg)
Netapp Ping callback.
Definition: atcmd_netapp.c:942
ATCmdNetapp_startCallback
int32_t ATCmdNetapp_startCallback(void *arg)
Netapp start callback.
Definition: atcmd_netapp.c:162
ATCmdNetapp_getServiceListCallback
int32_t ATCmdNetapp_getServiceListCallback(void *arg)
Netapp GetServiceList callback.
Definition: atcmd_netapp.c:1135
ATCmdNetapp_getHostByServiceCallback
int32_t ATCmdNetapp_getHostByServiceCallback(void *arg)
Netapp Get Host By Service callback.
Definition: atcmd_netapp.c:483
ATCmdNetapp_stopCallback
int32_t ATCmdNetapp_stopCallback(void *arg)
Netapp stop callback.
Definition: atcmd_netapp.c:208
ATCmdNetapp_getHostByNameCallback
int32_t ATCmdNetapp_getHostByNameCallback(void *arg)
Netapp Get Host By Name callback.
Definition: atcmd_netapp.c:339
ATCmdNetapp_sendCallback
int32_t ATCmdNetapp_sendCallback(void *arg)
Netapp Send callback.
Definition: atcmd_netapp.c:629
ATCmdNetapp_registerServiceCallback
int32_t ATCmdNetapp_registerServiceCallback(void *arg)
Netapp RegisterMDNS callback.
Definition: atcmd_netapp.c:1269
ATCmdNetapp_getCallback
int32_t ATCmdNetapp_getCallback(void *arg)
Netapp Get callback.
Definition: atcmd_netapp.c:2037
ATCmdNetapp_unregisterServiceCallback
int32_t ATCmdNetapp_unregisterServiceCallback(void *arg)
Netapp UnregisterMDNS callback.
Definition: atcmd_netapp.c:1374
ATCmdNetapp_setCallback
int32_t ATCmdNetapp_setCallback(void *arg)
Netapp Set callback.
Definition: atcmd_netapp.c:1698
ATCmdNetapp_recvCallback
int32_t ATCmdNetapp_recvCallback(void *arg)
Netapp Recv callback.
Definition: atcmd_netapp.c:774