/src/framework/tcpip/src/tcpip_commands.c

https://github.com/ufanders/wordClock · C · 2009 lines · 1664 code · 285 blank · 60 comment · 335 complexity · 953ba59a5682086cb4df7d625a23936e MD5 · raw file

Large files are truncated click here to view the full file

    

  1. /*******************************************************************************

    2. 

  2.   TCP/IP commands implementation

    3. 

  3. 

    4. 

  4.   Summary:

    5. 

  5.     Module for Microchip TCP/IP Stack

    6. 

  6.     

    7. 

  7.   Description:

    8. 

  8.     TCPIP stack commands entities. 

    9. 

  9.     Note, this module is based on system command parser

    10. 

  10. *******************************************************************************/

    11. 

  11. 

    12. 

  12. /*******************************************************************************

    13. 

  13. File Name:  tcpip_commands.c

    14. 

  14. Copyright Š2012 released Microchip Technology Inc.  All rights

    15. 

  15. reserved.

    16. 

  16. 

    17. 

  17. Microchip licenses to you the right to use, modify, copy and distribute

    18. 

  18. Software only when embedded on a Microchip microcontroller or digital signal

    19. 

  19. controller that is integrated into your product or third party product

    20. 

  20. (pursuant to the sublicense terms in the accompanying license agreement).

    21. 

  21. 

    22. 

  22. You should refer to the license agreement accompanying this Software for

    23. 

  23. additional information regarding your rights and obligations.

    24. 

  24. 

    25. 

  25. SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS?WITHOUT WARRANTY OF ANY KIND,

    26. 

  26. EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF

    27. 

  27. MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.

    28. 

  28. IN NO EVENT SHALL MICROCHIP OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER

    29. 

  29. CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR

    30. 

  30. OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES

    31. 

  31. INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR

    32. 

  32. CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF

    33. 

  33. SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES

    34. 

  34. (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.

    35. 

  35. *******************************************************************************/

    36. 

  36. 

    37. 

  37. #include "tcpip/src/tcpip_private.h"

    38. 

  38. #include "tcpip/tcpip_manager.h"

    39. 

  39. 

    40. 

  40. #include "system/tmr/sys_tmr.h"

    41. 

  41. 

    42. 

  42. #if defined(TCPIP_IF_MRF24W)

    43. 

  43. #include "driver/wifi/mrf24w/drv_wifi.h"

    44. 

  44. #endif  // defined(TCPIP_IF_MRF24W)

    45. 

  45. 

    46. 

  46. #if defined(TCPIP_STACK_COMMAND_ENABLE)

    47. 

  47. 

    48. 

  48. #define TCPIP_THIS_MODULE_ID    TCPIP_MODULE_TCPIP_COMMAND

    49. 

  49. static int  initialNetIfs = 0;    // Backup interfaces number for stack restart

    50. 

  50. static TCPIP_HEAP_HANDLE       initialHeapH = 0;

    51. 

  51. 

    52. 

  52. #if defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    53. 

  53. 

    54. 

  54. typedef struct

    55. 

  55. {

    56. 

  56.     size_t                  stgSize;        // size  + valid flag

    57. 

  57.     TCPIP_STACK_NET_IF_DCPT netDcptStg;     // configuration save

    58. 

  58. #if defined(TCPIP_STACK_USE_IPV6)

    59. 

  59.     uint8_t                 restoreBuff[sizeof(TCPIP_NETWORK_CONFIG) + 170]; // buffer to restore the configuration

    60. 

  60. #else

    61. 

  61.     uint8_t                 restoreBuff[sizeof(TCPIP_NETWORK_CONFIG) + 120]; // buffer to restore the configuration

    62. 

  62. #endif  // defined(TCPIP_STACK_USE_IPV6)

    63. 

  63. }TCPIP_COMMAND_STG_DCPT;

    64. 

  64. 

    65. 

  65. static TCPIP_COMMAND_STG_DCPT*   pCmdStgDcpt = 0;   // store current interface configuration

    66. 

  66. static TCPIP_NETWORK_CONFIG*     pCmdNetConf = 0;   // create the array of configurations needed for stack initialization

    67. 

  67. 

    68. 

  68. static bool                     tcpipCmdPreserveSavedInfo = false; // do not discard the saved data

    69. 

  69. 

    70. 

  70. #endif  // defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    71. 

  71. 

    72. 

  72. #if defined(TCPIP_STACK_USE_DNS_SERVER)

    73. 

  73. typedef enum 

    74. 

  74. {

    75. 

  75. 	DNSS_COMD_ADD=0,

    76. 

  76. 	DNSS_COMD_DEL,

    77. 

  77. 	DNSS_COMD_INFO,

    78. 

  78. 	DNSS_COMD_NONE,

    79. 

  79. }DNSS_COMD_TYPE;

    80. 

  80. typedef struct 

    81. 

  81. {

    82. 

  82. 	char *command;

    83. 

  83. 	DNSS_COMD_TYPE  val;

    84. 

  84. }DNSS_COMMAND_MAP;

    85. 

  85. 

    86. 

  86. #endif

    87. 

  87. static int _Command_AddressService(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv, TCPIP_STACK_ADDRESS_SERVICE_TYPE svcType);

    88. 

  88. 

    89. 

  89. 

    90. 

  90. static int _Command_NetInfo(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    91. 

  91. static int _Command_DefaultInterfaceSet (_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    92. 

  92. static int CommandDhcpOptions(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    93. 

  93. static int _Command_DHCPSOnOff(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    94. 

  94. static int _Command_ZcllOnOff(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    95. 

  95. static int _Command_IPAddressSet(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    96. 

  96. static int _Command_GatewayAddressSet(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    97. 

  97. static int _Command_PrimaryDNSAddressSet(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    98. 

  98. static int _Command_BIOSNameSet(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    99. 

  99. static int _Command_MACAddressSet(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    100. 

  100. static int _Command_NetworkOnOff(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    101. 

  101. static int _Command_StackOnOff(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    102. 

  102. static int _Command_HeapInfo(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    103. 

  103. static int CommandArp(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    104. 

  104. static int _Command_DNSOnOff(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    105. 

  105. static int _Command_DNSSOnOff(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    106. 

  106. static int _Command_MacInfo(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    107. 

  107. 

    108. 

  108. 

    109. 

  109. #if defined(TCPIP_STACK_USE_DHCP_SERVER)

    110. 

  110. static int _Command_DHCPLeaseInfo(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    111. 

  111. #endif  //  defined(TCPIP_STACK_USE_DHCP_SERVER)

    112. 

  112. #if defined(TCPIP_STACK_USE_DNS_SERVER)

    113. 

  113. static int _Command_AddDelDNSSrvAddress(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    114. 

  114. static int _Command_ShowDNDServInfo(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    115. 

  115. #endif

    116. 

  116. #if defined(TCPIP_STACK_USE_ICMP_CLIENT)

    117. 

  117. 

    118. 

  118. #define TCPIP_COMMAND_ICMP_ECHO_REQUEST_MIN_DELAY 5  // minimum delay between successive echo requests

    119. 

  119. 

    120. 

  120. // ping command task status

    121. 

  121. typedef enum

    122. 

  122. {

    123. 

  123.     TCPIP_PING_CMD_IDLE = 0,    // ping task is idle

    124. 

  124.     TCPIP_PING_CMD_DNS_GET,     // get DNS

    125. 

  125.     TCPIP_PING_CMD_DNS_WAIT,    // wait for DNS

    126. 

  126.     TCPIP_PING_CMD_DO_PING,     // send pings

    127. 

  127. }TCPIP_PING_CMD_STAT;

    128. 

  128. 

    129. 

  129. static int                  CommandPing(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv);

    130. 

  130. static void                 CommandPingHandler(TCPIP_NET_HANDLE hNetIf, IPV4_ADDR * remoteIP, void * data);

    131. 

  131. static void                 _PingStop(_CMDIO_DEV_NODE* pCmdIO, const void* cmdIoParam);

    132. 

  132. 

    133. 

  133. static tcpipAsyncHandle       icmptickH = 0;      // tick handle

    134. 

  134. 

    135. 

  135. static char                 icmpTargetHost[31];     // current target host name

    136. 

  136. static char                 icmpTargetAddrStr[17];  // current target address string

    137. 

  137. static IPV4_ADDR            icmpTargetAddr;         // current target address

    138. 

  138. static uint16_t             icmpSequenceNo;         // current sequence number

    139. 

  139. static uint16_t             icmpIdentifier;         // current ID number

    140. 

  140. 

    141. 

  141. static int                  icmpReqNo;              // number of requests to send

    142. 

  142. static int                  icmpReqCount;           // current request counter

    143. 

  143. static int                  icmpAckRecv;            // number of acks

    144. 

  144. static int                  icmpReqDelay;

    145. 

  145. 

    146. 

  146. static ICMP_HANDLE          hIcmp = 0;

    147. 

  147. static _CMDIO_DEV_NODE*     pIcmpCmd = 0;

    148. 

  148. static const void*          icmpCmdIoParam = 0;

    149. 

  149. uint32_t                    icmpStartTick;

    150. 

  150. static TCPIP_NET_HANDLE     icmpNetH = 0;

    151. 

  151. 

    152. 

  152. static TCPIP_PING_CMD_STAT  icmpCmdStat = TCPIP_PING_CMD_IDLE;

    153. 

  153. 

    154. 

  154. 

    155. 

  155. #endif  // defined(TCPIP_STACK_USE_ICMP_CLIENT)

    156. 

  156. 

    157. 

  157. // TCPIP stack command table

    158. 

  158. static const _SYS_CMD_DCPT    tcpipCmdTbl[]=

    159. 

  159. {

    160. 

  160.     {"netinfo",     _Command_NetInfo,              ": Get network information"},

    161. 

  161.     {"defnet",      _Command_DefaultInterfaceSet,  ": Set default network interface"},

    162. 

  162.     {"dhcp",        CommandDhcpOptions,          ": DHCP client commands"},

    163. 

  163.     {"dhcps",       _Command_DHCPSOnOff,           ": Turn DHCP server on/off"},

    164. 

  164.     {"zcll",        _Command_ZcllOnOff,            ": Turn ZCLL on/off"},

    165. 

  165.     {"setip",       _Command_IPAddressSet,         ": Set IP address and mask"},

    166. 

  166.     {"setgw",       _Command_GatewayAddressSet,    ": Set Gateway address"},

    167. 

  167.     {"setdns",      _Command_PrimaryDNSAddressSet,     ": Set DNS address"},

    168. 

  168.     {"setbios",     _Command_BIOSNameSet,          ": Set host's NetBIOS name"},

    169. 

  169.     {"setmac",      _Command_MACAddressSet,        ": Set MAC address"},

    170. 

  170.     {"if",          _Command_NetworkOnOff,         ": Bring an interface up/down"},

    171. 

  171.     {"stack",       _Command_StackOnOff,           ": Stack turn on/off"},

    172. 

  172.     {"heapinfo",    _Command_HeapInfo,             ": Check heap status"},

    173. 

  173. #if defined(TCPIP_STACK_USE_DHCP_SERVER)

    174. 

  174.     {"dhcpsinfo",	_Command_DHCPLeaseInfo, 	     ": Display DHCP Server Lease Details" },

    175. 

  175. #endif  //  defined(TCPIP_STACK_USE_DHCP_SERVER)

    176. 

  176. #if defined(TCPIP_STACK_USE_ICMP_CLIENT)

    177. 

  177.     {"ping",        CommandPing,                 ": Ping an IP address"},

    178. 

  178. #endif  // defined(TCPIP_STACK_USE_ICMP_CLIENT)

    179. 

  179.     {"arp",         CommandArp,                   ": arp commands"},

    180. 

  180.     {"dnsc",       _Command_DNSOnOff,            ": Turn DNS client on/off"},

    181. 

  181.     {"dnss",       _Command_DNSSOnOff,           ": Turn DNS server on/off"},

    182. 

  182. #if defined(TCPIP_STACK_USE_DNS_SERVER)

    183. 

  183.     {"dnsserv",   _Command_AddDelDNSSrvAddress,  ": Add DNS server IP address"},  

    184. 

  184. #endif

    185. 

  185.     {"macinfo",   _Command_MacInfo,             ": Check MAC statistics"},

    186. 

  186. };

    187. 

  187. 

    188. 

  188. bool TCPIP_Commands_Initialize(const TCPIP_STACK_MODULE_CTRL* const stackCtrl, const TCPIPCMD_MODULE_CONFIG* const pCmdInit)

    189. 

  189. {

    190. 

  190.     if(stackCtrl->stackAction == TCPIP_STACK_ACTION_IF_UP)

    191. 

  191.     {   // interface restart

    192. 

  192.         return true;

    193. 

  193.     }

    194. 

  194. 

    195. 

  195. 

    196. 

  196.     // stack init

    197. 

  197.     initialNetIfs = stackCtrl->nIfs;

    198. 

  198.     initialHeapH = stackCtrl->memH;

    199. 

  199. 

    200. 

  200.     // create command group

    201. 

  201.     if (!_SYS_COMMAND_ADDGRP(tcpipCmdTbl, sizeof(tcpipCmdTbl)/sizeof(*tcpipCmdTbl), "tcpip", ": stack commands"))

    202. 

  202.     {

    203. 

  203.         SYS_ERROR(SYS_ERROR_ERROR, "Failed to create TCPIP Commands\r\n");

    204. 

  204.         return false;

    205. 

  205.     }

    206. 

  206. 

    207. 

  207. #if defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    208. 

  208.     // get storage for interfaces configuration

    209. 

  209.     // cannot be taken from the TCPIP-HEAP because we need it persistent after

    210. 

  210.     // TCPIP_STACK_Deinit() is called!

    211. 

  211.     if(pCmdStgDcpt == 0 && pCmdNetConf == 0)

    212. 

  212.     {

    213. 

  213.         pCmdStgDcpt = (TCPIP_COMMAND_STG_DCPT*)SystemCalloc(initialNetIfs, sizeof(*pCmdStgDcpt));

    214. 

  214.         pCmdNetConf = (TCPIP_NETWORK_CONFIG*)SystemCalloc(initialNetIfs, sizeof(*pCmdNetConf));

    215. 

  215.         if(pCmdStgDcpt == 0 || pCmdNetConf == 0)

    216. 

  216.         {   // failure is not considered to be catastrophic

    217. 

  217.             SYS_ERROR(SYS_ERROR_WARN, "Failed to create TCPIP Commands Storage/Config\r\n");

    218. 

  218.         }

    219. 

  219.     }

    220. 

  220. #endif  // defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    221. 

  221. 

    222. 

  222. #if defined(TCPIP_IF_MRF24W) && defined(TCPIP_STACK_COMMANDS_WIFI_ENABLE)

    223. 

  223.     WIFICommandsInit();

    224. 

  224. #endif

    225. 

  225. 

    226. 

  226. #if defined(TCPIP_STACK_USE_ICMP_CLIENT)

    227. 

  227.     hIcmp = 0;

    228. 

  228. 

    229. 

  229.     icmptickH = _TCPIPStackAsyncHandlerRegister(TCPIPCommandsTask, 0, 0);

    230. 

  230.     if(icmptickH == 0)

    231. 

  231.     {   // timer is not active now

    232. 

  232.         SYS_ERROR(SYS_ERROR_ERROR, "ICMP tick registration failed\r\n");

    233. 

  233.         return false;

    234. 

  234.     }

    235. 

  235.     // else the timer will start when we send a query

    236. 

  236.     icmpCmdStat = TCPIP_PING_CMD_IDLE;

    237. 

  237.     icmpAckRecv = 0;

    238. 

  238. 

    239. 

  239. #endif  // defined(TCPIP_STACK_USE_ICMP_CLIENT)

    240. 

  240. 

    241. 

  241.     return true;

    242. 

  242. }

    243. 

  243. 

    244. 

  244. void TCPIP_Commands_Deinitialize(const TCPIP_STACK_MODULE_CTRL* const stackCtrl)

    245. 

  245. {

    246. 

  246.     // if(stackCtrl->stackAction == TCPIP_STACK_ACTION_DEINIT) // stack shut down

    247. 

  247.     // if(stackCtrl->stackAction == TCPIP_STACK_ACTION_IF_DOWN) // interface down

    248. 

  248. 

    249. 

  249.     if(stackCtrl->stackAction == TCPIP_STACK_ACTION_DEINIT)

    250. 

  250.     {   // whole stack is going down

    251. 

  251. #if defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    252. 

  252.         if(tcpipCmdPreserveSavedInfo == false)

    253. 

  253.         {

    254. 

  254.             SystemFree(pCmdStgDcpt);

    255. 

  255.             SystemFree(pCmdNetConf);

    256. 

  256.             pCmdStgDcpt = 0;

    257. 

  257.             pCmdNetConf = 0;

    258. 

  258.         }

    259. 

  259. #endif  // defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    260. 

  260. 

    261. 

  261. #if defined(TCPIP_STACK_USE_ICMP_CLIENT)

    262. 

  262.         if(icmptickH != 0)

    263. 

  263.         {

    264. 

  264.             _TCPIPStackAsyncHandlerDeRegister(icmptickH);

    265. 

  265.             icmptickH = 0;

    266. 

  266.         }

    267. 

  267. #endif  // defined(TCPIP_STACK_USE_ICMP_CLIENT)

    268. 

  268. 

    269. 

  269.     }

    270. 

  270. }

    271. 

  271. 

    272. 

  272. static int _Command_NetInfo(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    273. 

  273. {

    274. 

  274.     int i;

    275. 

  275.     TCPIP_NET_HANDLE netH;

    276. 

  276.     IPV4_ADDR ipAddr;

    277. 

  277.     const TCPIP_MAC_ADDR* pMac;

    278. 

  278.     TCPIP_NET_IF* pNetIf;

    279. 

  279.     TCPIP_STACK_MODULE macID;

    280. 

  280.     const char  *hostName, *msgAdd;

    281. 

  281.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    282. 

  282. #if defined(TCPIP_STACK_USE_IPV6)

    283. 

  283.     IPV6_ADDR_STRUCT currIpv6Add;

    284. 

  284.     IPV6_ADDR_HANDLE prevHandle, nextHandle;

    285. 

  285.     char   addrBuff[44];

    286. 

  286. #else

    287. 

  287.     char   addrBuff[20];

    288. 

  288. #endif  // defined(TCPIP_STACK_USE_IPV6)

    289. 

  289. 

    290. 

  290.     if (argc > 2)

    291. 

  291.     {

    292. 

  292.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: netinfo\r\n");

    293. 

  293.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: netinfo\r\n");

    294. 

  294.         return false;

    295. 

  295.     }

    296. 

  296. 

    297. 

  297.     for (i=0; i<initialNetIfs; i++)

    298. 

  298.     {

    299. 

  299.         netH = TCPIP_STACK_IndexToNet(i);

    300. 

  300.         pNetIf = _TCPIPStackHandleToNet(netH);

    301. 

  301.         macID = TCPIP_STACK_NetMACId(pNetIf);

    302. 

  302.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "---------- Interface <%s> ---------- \r\n", TCPIP_STACK_MACIdToString(macID));

    303. 

  303.         if(!TCPIP_STACK_NetIsUp(netH))

    304. 

  304.         {

    305. 

  305.             (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Interface is down\r\n");

    306. 

  306.             continue;

    307. 

  307.         }

    308. 

  308.         hostName = TCPIP_STACK_NetBIOSName(netH); 

    309. 

  309. #if defined(TCPIP_STACK_USE_NBNS)

    310. 

  310.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Host Name: %s - NBNS enabled\r\n", hostName);

    311. 

  311. #else

    312. 

  312.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Host Name: %s - NBNS disabled \r\n", hostName);

    313. 

  313. #endif  // defined(TCPIP_STACK_USE_NBNS)

    314. 

  314.         ipAddr.Val = TCPIP_STACK_NetAddress(netH);

    315. 

  315.         TCPIP_Helper_IPAddressToString(&ipAddr, addrBuff, sizeof(addrBuff));

    316. 

  316.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "IPv4 Address: %s\r\n", addrBuff);

    317. 

  317. 

    318. 

  318.         ipAddr.Val = TCPIP_STACK_NetMask(netH);

    319. 

  319.         TCPIP_Helper_IPAddressToString(&ipAddr, addrBuff, sizeof(addrBuff));

    320. 

  320.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Mask: %s\r\n", addrBuff);

    321. 

  321. 

    322. 

  322.         ipAddr.Val = TCPIP_STACK_NetAddressGateway(netH);

    323. 

  323.         TCPIP_Helper_IPAddressToString(&ipAddr, addrBuff, sizeof(addrBuff));

    324. 

  324.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Gateway: %s\r\n", addrBuff);

    325. 

  325. 

    326. 

  326.         ipAddr.Val = TCPIP_STACK_NetAddressDnsPrimary(netH);

    327. 

  327.         TCPIP_Helper_IPAddressToString(&ipAddr, addrBuff, sizeof(addrBuff));

    328. 

  328.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "DNS: %s\r\n", addrBuff);

    329. 

  329. 

    330. 

  330.         pMac = (const TCPIP_MAC_ADDR*)TCPIP_STACK_NetAddressMac(netH);

    331. 

  331.         TCPIP_Helper_MACAddressToString(pMac, addrBuff, sizeof(addrBuff));

    332. 

  332.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "MAC Address: %s\r\n", addrBuff);

    333. 

  333. 

    334. 

  334.         // display IPv6 addresses

    335. 

  335. #if defined(TCPIP_STACK_USE_IPV6)

    336. 

  336.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "IPv6 Unicast addresses:\r\n");

    337. 

  337. 

    338. 

  338.         prevHandle = 0;

    339. 

  339.         do

    340. 

  340.         {

    341. 

  341.             nextHandle = TCPIP_STACK_NetIPv6AddressGet(netH, IPV6_ADDR_TYPE_UNICAST, &currIpv6Add, prevHandle);

    342. 

  342.             if(nextHandle)

    343. 

  343.             {   // have a valid address; display it

    344. 

  344.                 TCPIP_Helper_IPv6AddressToString(&currIpv6Add.address, addrBuff, sizeof(addrBuff));

    345. 

  345.                 (*pCmdIO->pCmdApi->print)(cmdIoParam, "    %s\r\n", addrBuff);

    346. 

  346.                 prevHandle = nextHandle;

    347. 

  347.             }

    348. 

  348.         }while(nextHandle != 0);

    349. 

  349. 

    350. 

  350.         if(prevHandle == 0)

    351. 

  351.         {   // no valid address

    352. 

  352.             (*pCmdIO->pCmdApi->msg)(cmdIoParam, "    Unknown\r\n");

    353. 

  353.         }

    354. 

  354.         

    355. 

  355.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "IPv6 Multicast addresses:\r\n");

    356. 

  356.         prevHandle = 0;

    357. 

  357.         do

    358. 

  358.         {

    359. 

  359.             nextHandle = TCPIP_STACK_NetIPv6AddressGet(netH, IPV6_ADDR_TYPE_MULTICAST, &currIpv6Add, prevHandle);

    360. 

  360.             if(nextHandle)

    361. 

  361.             {   // have a valid address; display it

    362. 

  362.                 TCPIP_Helper_IPv6AddressToString(&currIpv6Add.address, addrBuff, sizeof(addrBuff));

    363. 

  363.                 (*pCmdIO->pCmdApi->print)(cmdIoParam, "    %s\r\n", addrBuff);

    364. 

  364.                 prevHandle = nextHandle;

    365. 

  365.             }

    366. 

  366.         }while(nextHandle != 0);

    367. 

  367. 

    368. 

  368.         if(prevHandle == 0)

    369. 

  369.         {   // no valid address

    370. 

  370.             (*pCmdIO->pCmdApi->msg)(cmdIoParam, "    Unknown\r\n");

    371. 

  371.         }

    372. 

  372. 

    373. 

  373. #endif  // defined(TCPIP_STACK_USE_IPV6)

    374. 

  374. 

    375. 

  375.         if(TCPIP_DHCP_IsEnabled(netH))

    376. 

  376.         {

    377. 

  377.             msgAdd = "dhcp";

    378. 

  378.         }

    379. 

  379.         else if(TCPIP_ZCLL_IsEnabled(netH))

    380. 

  380.         {

    381. 

  381.             msgAdd = "zcll";

    382. 

  382.         }

    383. 

  383.         else if(TCPIP_DHCPS_IsEnabled(netH))

    384. 

  384.         {

    385. 

  385.             msgAdd = "dhcps";

    386. 

  386.         }

    387. 

  387.         else

    388. 

  388.         {

    389. 

  389.             msgAdd = "default IP address";

    390. 

  390.         }

    391. 

  391. 

    392. 

  392.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "%s is ON\r\n", msgAdd);

    393. 

  393. 

    394. 

  394.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Link is %s\r\n", TCPIP_STACK_NetIsLinked(netH) ? "UP" : "DOWN");

    395. 

  395. 

    396. 

  396.     }

    397. 

  397.     return true;

    398. 

  398. }

    399. 

  399. 

    400. 

  400. #if defined(TCPIP_STACK_USE_DHCP_SERVER)

    401. 

  401. static int _Command_DHCPLeaseInfo(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    402. 

  402. {

    403. 

  403.     TCPIP_NET_HANDLE netH;

    404. 

  404.     TCPIP_DHCPS_LEASE_HANDLE  prevLease, nextLease;

    405. 

  405.     TCPIP_DHCPS_LEASE_ENTRY leaseEntry;

    406. 

  406.     char   addrBuff[20];

    407. 

  407.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    408. 

  408. 

    409. 

  409.     if (argc != 2)

    410. 

  410.     {

    411. 

  411.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: dhcpsinfo <interface> \r\n");

    412. 

  412.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: dhcpsinfo PIC32INT \r\n");

    413. 

  413.         return false;

    414. 

  414.     }

    415. 

  415. 

    416. 

  416.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    417. 

  417.     if (netH == 0)

    418. 

  418.     {

    419. 

  419.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface specified \r\n");

    420. 

  420.         return false;

    421. 

  421.     }

    422. 

  422. 

    423. 

  423.     (*pCmdIO->pCmdApi->print)(cmdIoParam,"MAC Address		IPAddress		RemainingLeaseTime \r\n",0);

    424. 

  424. 

    425. 

  425.     prevLease = 0;

    426. 

  426.     do

    427. 

  427.     {

    428. 

  428.         nextLease = TCPIP_DHCPS_LeaseEntryGet(netH, &leaseEntry, prevLease);

    429. 

  429.         if(!nextLease)

    430. 

  430.         {

    431. 

  431.             (*pCmdIO->pCmdApi->print)(cmdIoParam, " \n\r No more entry present \r\n", 0);

    432. 

  432.         }

    433. 

  433.         if(nextLease)

    434. 

  434.         {   // valid info

    435. 

  435.             // display info

    436. 

  436.             TCPIP_Helper_MACAddressToString(&leaseEntry.hwAdd, addrBuff, sizeof(addrBuff));

    437. 

  437.             (*pCmdIO->pCmdApi->msg)(cmdIoParam, addrBuff);

    438. 

  438.             TCPIP_Helper_IPAddressToString(&leaseEntry.ipAddress, addrBuff, sizeof(addrBuff));

    439. 

  439.             (*pCmdIO->pCmdApi->print)(cmdIoParam, "	%s ", addrBuff);

    440. 

  440.             (*pCmdIO->pCmdApi->print)(cmdIoParam, "	%d Secs\r\n", leaseEntry.leaseTime/SYS_TMR_TickPerSecond());

    441. 

  441. 

    442. 

  442.             prevLease = nextLease;

    443. 

  443.         }

    444. 

  444.     }while(nextLease != 0);

    445. 

  445. 

    446. 

  446. 

    447. 

  447.     return true;

    448. 

  448. 

    449. 

  449. }

    450. 

  450. #endif  //  defined(TCPIP_STACK_USE_DHCP_SERVER)

    451. 

  451. 

    452. 

  452. static int _Command_DefaultInterfaceSet (_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    453. 

  453. {

    454. 

  454.     TCPIP_NET_HANDLE netH;

    455. 

  455.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    456. 

  456. 

    457. 

  457.     if (argc != 2)

    458. 

  458.     {

    459. 

  459.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: defnet <interface>\r\n");

    460. 

  460.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: defnet PIC32INT\r\n");

    461. 

  461.         return false;

    462. 

  462.     }

    463. 

  463. 

    464. 

  464.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    465. 

  465.     if (netH == 0)

    466. 

  466.     {

    467. 

  467.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface specified \r\n");

    468. 

  468.         return false;

    469. 

  469.     }

    470. 

  470. 

    471. 

  471.     if(TCPIP_STACK_NetDefaultSet(netH))

    472. 

  472.     {

    473. 

  473.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Default interface set successful\r\n");

    474. 

  474.     }

    475. 

  475.     else

    476. 

  476.     {

    477. 

  477.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Operation not accepted\r\n");

    478. 

  478.     }

    479. 

  479. 

    480. 

  480.     return true;

    481. 

  481. }

    482. 

  482. 

    483. 

  483. static int CommandDhcpOptions(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    484. 

  484. {

    485. 

  485.     TCPIP_NET_HANDLE netH;

    486. 

  486.     IPV4_ADDR       reqIpAddr;

    487. 

  487.     bool            dhcpRes;

    488. 

  488.     int             opCode = 0;

    489. 

  489.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    490. 

  490. 

    491. 

  491.     if (argc < 3)

    492. 

  492.     {

    493. 

  493.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Usage: %s <interface> <on/off/renew/request> \r\n", argv[0]);

    494. 

  494.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Ex: %s PIC32INT on \r\n", argv[0]);

    495. 

  495.         return false;

    496. 

  496.     }

    497. 

  497. 

    498. 

  498.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    499. 

  499.     if (netH == 0)

    500. 

  500.     {

    501. 

  501.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface\r\n");

    502. 

  502.         return false;

    503. 

  503.     }

    504. 

  504. 

    505. 

  505.     if (strcmp(argv[2], "on") == 0)

    506. 

  506.     {   // turning on a service

    507. 

  507.         opCode = 1;

    508. 

  508.     }

    509. 

  509.     else if (strcmp(argv[2], "off") == 0)

    510. 

  510.     {   // turning off a service

    511. 

  511.         opCode = 2;

    512. 

  512.     }

    513. 

  513.     else if (strcmp(argv[2], "renew") == 0)

    514. 

  514.     {   // DHCP renew

    515. 

  515.         opCode = 3;

    516. 

  516.     }

    517. 

  517.     else if (strcmp(argv[2], "request") == 0)

    518. 

  518.     {   // DHCP request

    519. 

  519.         opCode = 4;

    520. 

  520.         if(argc < 4)

    521. 

  521.         {

    522. 

  522.             (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Request needs an IP address\r\n");

    523. 

  523.             return false;

    524. 

  524.         }

    525. 

  525. 

    526. 

  526.         if (!TCPIP_Helper_StringToIPAddress(argv[3], &reqIpAddr))

    527. 

  527.         {

    528. 

  528.             (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Invalid IP address string \r\n");

    529. 

  529.             return false;

    530. 

  530.         }

    531. 

  531.     }

    532. 

  532.     else

    533. 

  533.     {

    534. 

  534.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown option\r\n");

    535. 

  535.         return false;

    536. 

  536.     }

    537. 

  537. 

    538. 

  538. 

    539. 

  539.     switch(opCode)

    540. 

  540.     {

    541. 

  541.         case 1:

    542. 

  542.             dhcpRes = TCPIP_DHCP_Enable(netH);

    543. 

  543.             break;

    544. 

  544. 

    545. 

  545.         case 2:

    546. 

  546.             dhcpRes = TCPIP_DHCP_Disable(netH);

    547. 

  547.             break;

    548. 

  548. 

    549. 

  549.         case 3:

    550. 

  550.             dhcpRes = TCPIP_DHCP_Renew(netH);

    551. 

  551.             break;

    552. 

  552. 

    553. 

  553.         case 4:

    554. 

  554.             dhcpRes = TCPIP_DHCP_Request(netH, reqIpAddr);

    555. 

  555.             break;

    556. 

  556. 

    557. 

  557.         default:

    558. 

  558.             dhcpRes = false;

    559. 

  559.             break;

    560. 

  560.     }

    561. 

  561. 

    562. 

  562.     (*pCmdIO->pCmdApi->print)(cmdIoParam, "%s %s %s\r\n", argv[0], argv[2], dhcpRes ? "succes" : "fail");

    563. 

  563. 

    564. 

  564.     return true;

    565. 

  565. }

    566. 

  566. 

    567. 

  567. static int _Command_DHCPSOnOff(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    568. 

  568. {

    569. 

  569.     return _Command_AddressService(pCmdIO, argc, argv, TCPIP_STACK_ADDRESS_SERVICE_DHCPS);

    570. 

  570. }

    571. 

  571. 

    572. 

  572. static int _Command_ZcllOnOff(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    573. 

  573. {

    574. 

  574.     return _Command_AddressService(pCmdIO, argc, argv, TCPIP_STACK_ADDRESS_SERVICE_ZCLL);

    575. 

  575. }

    576. 

  576. 

    577. 

  577. static int _Command_AddressService(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv, TCPIP_STACK_ADDRESS_SERVICE_TYPE svcType)

    578. 

  578. { 

    579. 

  579.     typedef bool(*addSvcFnc)(TCPIP_NET_HANDLE hNet);

    580. 

  580. 

    581. 

  581.     TCPIP_NET_HANDLE netH;

    582. 

  582.     addSvcFnc        addFnc;

    583. 

  583.     bool             addRes, svcEnable;

    584. 

  584.     const char       *msgOK, *msgFail;

    585. 

  585.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    586. 

  586. 

    587. 

  587.     if (argc != 3)

    588. 

  588.     {

    589. 

  589.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Usage: %s <interface> <on/off> \r\n", argv[0]);

    590. 

  590.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Ex: %s PIC32INT on \r\n", argv[0]);

    591. 

  591.         return false;

    592. 

  592.     }

    593. 

  593. 

    594. 

  594.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    595. 

  595.     if (netH == 0)

    596. 

  596.     {

    597. 

  597.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface\r\n");

    598. 

  598.         return false;

    599. 

  599.     }

    600. 

  600. 

    601. 

  601.     if (memcmp(argv[2], "on", 2) == 0)

    602. 

  602.     {   // turning on a service

    603. 

  603.         svcEnable = true;

    604. 

  604.     }

    605. 

  605.     else if (memcmp(argv[2], "off", 2) == 0)

    606. 

  606.     {   // turning off a service

    607. 

  607.         svcEnable = false;

    608. 

  608.     }

    609. 

  609.     else

    610. 

  610.     {

    611. 

  611.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown option\r\n");

    612. 

  612.         return false;

    613. 

  613.     }

    614. 

  614. 

    615. 

  615.     switch(svcType)

    616. 

  616.     {

    617. 

  617.         case TCPIP_STACK_ADDRESS_SERVICE_DHCPC:

    618. 

  618.             addFnc = svcEnable?TCPIP_DHCP_Enable:TCPIP_DHCP_Disable;

    619. 

  619.             break;

    620. 

  620. 

    621. 

  621.         case TCPIP_STACK_ADDRESS_SERVICE_DHCPS:

    622. 

  622.             addFnc = svcEnable?TCPIP_DHCPS_Enable:TCPIP_DHCPS_Disable;

    623. 

  623.             break;

    624. 

  624. 

    625. 

  625.         case TCPIP_STACK_ADDRESS_SERVICE_ZCLL:

    626. 

  626.             addFnc = svcEnable?TCPIP_ZCLL_Enable:TCPIP_ZCLL_Disable;

    627. 

  627.             break;

    628. 

  628. 

    629. 

  629.         default:

    630. 

  630.             addFnc = 0;     // unknown service; shouldn't happen

    631. 

  631.             break;

    632. 

  632.     }

    633. 

  633. 

    634. 

  634.     if(addFnc)

    635. 

  635.     {

    636. 

  636.         msgOK   = svcEnable?"enabled":"disabled";

    637. 

  637.         msgFail = svcEnable?"enable":"disable";

    638. 

  638. 

    639. 

  639.         addRes = (*addFnc)(netH);

    640. 

  640.         

    641. 

  641.         if(addRes)

    642. 

  642.         {

    643. 

  643.             (*pCmdIO->pCmdApi->print)(cmdIoParam, "%s %s\r\n", argv[0], msgOK);

    644. 

  644.         }

    645. 

  645.         else

    646. 

  646.         {

    647. 

  647.             (*pCmdIO->pCmdApi->print)(cmdIoParam, "Failed to %s %s\r\n", msgFail, argv[0]);

    648. 

  648.         }

    649. 

  649.     }

    650. 

  650. 

    651. 

  651.     return true;

    652. 

  652. }

    653. 

  653. 

    654. 

  654. static int _Command_DNSSOnOff(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    655. 

  655. {

    656. 

  656. 	typedef bool(*addSvcFnc)(TCPIP_NET_HANDLE hNet);

    657. 

  657. 

    658. 

  658.     TCPIP_NET_HANDLE netH;

    659. 

  659.     addSvcFnc        addFnc;

    660. 

  660.     bool             addRes, svcEnable;

    661. 

  661.     const char       *msgOK, *msgFail;

    662. 

  662.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    663. 

  663. 

    664. 

  664.     if (argc != 3)

    665. 

  665.     {

    666. 

  666.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Usage: %s <interface> <on/off> \r\n", argv[0]);

    667. 

  667.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Ex: %s PIC32INT on \r\n", argv[0]);

    668. 

  668.         return false;

    669. 

  669.     }

    670. 

  670. 

    671. 

  671.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    672. 

  672.     if (netH == 0)

    673. 

  673.     {

    674. 

  674.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface\r\n");

    675. 

  675.         return false;

    676. 

  676.     }

    677. 

  677. 

    678. 

  678.     if (memcmp(argv[2], "on", 2) == 0)

    679. 

  679.     {   // turning on a service

    680. 

  680.         svcEnable = true;

    681. 

  681.     }

    682. 

  682.     else if (memcmp(argv[2], "off", 2) == 0)

    683. 

  683.     {   // turning off a service

    684. 

  684.         svcEnable = false;

    685. 

  685.     }

    686. 

  686.     else

    687. 

  687.     {

    688. 

  688.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown option\r\n");

    689. 

  689.         return false;

    690. 

  690.     }

    691. 

  691. 	addFnc = svcEnable?TCPIP_DNSS_Enable:TCPIP_DNSS_Disable;

    692. 

  692. 

    693. 

  693.         msgOK   = svcEnable?"enabled":"disabled";

    694. 

  694.         msgFail = svcEnable?"enable":"disable";

    695. 

  695. 

    696. 

  696.     addRes = (*addFnc)(netH);

    697. 

  697. 

    698. 

  698.     if(addRes)

    699. 

  699.     {

    700. 

  700.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "%s %s\r\n", argv[0], msgOK);

    701. 

  701.     }

    702. 

  702.     else

    703. 

  703.     {

    704. 

  704.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Failed to %s %s\r\n", msgFail, argv[0]);

    705. 

  705.     }

    706. 

  706.     return true;

    707. 

  707. }

    708. 

  708. 

    709. 

  709. static int _Command_DNSOnOff(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    710. 

  710. {

    711. 

  711. 	typedef bool(*addSvcFnc)(TCPIP_NET_HANDLE hNet);

    712. 

  712. 

    713. 

  713.     TCPIP_NET_HANDLE netH;

    714. 

  714.     addSvcFnc        addFnc;

    715. 

  715.     bool             addRes, svcEnable;

    716. 

  716.     const char       *msgOK, *msgFail;

    717. 

  717.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    718. 

  718. 

    719. 

  719.     if (argc != 3)

    720. 

  720.     {

    721. 

  721.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Usage: %s <interface> <on/off> \r\n", argv[0]);

    722. 

  722.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Ex: %s PIC32INT on \r\n", argv[0]);

    723. 

  723.         return false;

    724. 

  724.     }

    725. 

  725. 

    726. 

  726.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    727. 

  727.     if (netH == 0)

    728. 

  728.     {

    729. 

  729.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface\r\n");

    730. 

  730.         return false;

    731. 

  731.     }

    732. 

  732. 

    733. 

  733.     if (memcmp(argv[2], "on", 2) == 0)

    734. 

  734.     {   // turning on a service

    735. 

  735.         svcEnable = true;

    736. 

  736.     }

    737. 

  737.     else if (memcmp(argv[2], "off", 2) == 0)

    738. 

  738.     {   // turning off a service

    739. 

  739.         svcEnable = false;

    740. 

  740.     }

    741. 

  741.     else

    742. 

  742.     {

    743. 

  743.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown option\r\n");

    744. 

  744.         return false;

    745. 

  745.     }

    746. 

  746. 

    747. 

  747.     addFnc = svcEnable?TCPIP_DNS_Enable:TCPIP_DNS_Disable;

    748. 

  748. 

    749. 

  749.     msgOK   = svcEnable?"enabled":"disabled";

    750. 

  750.     msgFail = svcEnable?"enable":"disable";

    751. 

  751. 

    752. 

  752.     addRes = (*addFnc)(netH);

    753. 

  753. 

    754. 

  754.     if(addRes)

    755. 

  755.     {

    756. 

  756.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "%s %s\r\n", argv[0], msgOK);

    757. 

  757.     }

    758. 

  758.     else

    759. 

  759.     {

    760. 

  760.         (*pCmdIO->pCmdApi->print)(cmdIoParam, "Failed to %s %s\r\n", msgFail, argv[0]);

    761. 

  761.     }

    762. 

  762.     return true;

    763. 

  763. }

    764. 

  764. 

    765. 

  765. static int _Command_IPAddressSet(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    766. 

  766. {

    767. 

  767.     TCPIP_NET_HANDLE netH;

    768. 

  768.     TCPIP_NET_IF*   pNetIf;

    769. 

  769.     IP_ADDRESS_TYPE addType;

    770. 

  770. 

    771. 

  771. #if defined(TCPIP_STACK_USE_IPV4)

    772. 

  772.     IPV4_ADDR ipAddr, ipMask;

    773. 

  773.     IPV4_ADDR*  pMask;

    774. 

  774. #endif  // defined(TCPIP_STACK_USE_IPV4)

    775. 

  775. #if defined(TCPIP_STACK_USE_IPV6)

    776. 

  776.     IPV6_ADDR  ipv6Addr;

    777. 

  777.     int     prefixLen;

    778. 

  778. #endif  // defined(TCPIP_STACK_USE_IPV6)

    779. 

  779.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    780. 

  780.     bool     success = false;

    781. 

  781. 

    782. 

  782.     if (argc < 3)

    783. 

  783.     {

    784. 

  784.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: setip <interface> <ipv4/6 address> <ipv4mask/ipv6 prefix len>\r\n");

    785. 

  785.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: setip PIC32INT 192.168.0.8 255.255.255.0 \r\n");

    786. 

  786.         return false;

    787. 

  787.     }

    788. 

  788. 

    789. 

  789.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    790. 

  790.     if (netH == 0)

    791. 

  791.     {

    792. 

  792.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface specified \r\n");

    793. 

  793.         return false;

    794. 

  794.     }

    795. 

  795. 

    796. 

  796.     pNetIf = _TCPIPStackHandleToNetUp(netH);

    797. 

  797.     if(pNetIf == 0)

    798. 

  798.     {

    799. 

  799.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "No such interface is up\r\n");

    800. 

  800.         return false;

    801. 

  801.     }

    802. 

  802. 

    803. 

  803. 

    804. 

  804.     addType = IP_ADDRESS_TYPE_ANY;

    805. 

  805. 

    806. 

  806. #if defined(TCPIP_STACK_USE_IPV4)

    807. 

  807.     if (TCPIP_Helper_StringToIPAddress(argv[2], &ipAddr))

    808. 

  808.     {

    809. 

  809.         addType = IP_ADDRESS_TYPE_IPV4;

    810. 

  810.     }

    811. 

  811. #endif  // defined(TCPIP_STACK_USE_IPV4)

    812. 

  812. #if defined(TCPIP_STACK_USE_IPV6)

    813. 

  813.     if(TCPIP_Helper_StringToIPv6Address (argv[2], &ipv6Addr))

    814. 

  814.     {

    815. 

  815.         addType = IP_ADDRESS_TYPE_IPV6;

    816. 

  816.     }

    817. 

  817. #endif  // defined(TCPIP_STACK_USE_IPV6)

    818. 

  818. 

    819. 

  819.     if(addType == IP_ADDRESS_TYPE_ANY)

    820. 

  820.     {

    821. 

  821.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Invalid IP address string \r\n");

    822. 

  822.         return false;

    823. 

  823.     }

    824. 

  824.     

    825. 

  825. 

    826. 

  826. #if defined(TCPIP_STACK_USE_IPV4)

    827. 

  827.     if(addType == IP_ADDRESS_TYPE_IPV4)

    828. 

  828.     {

    829. 

  829.         if(_TCPIPStackAddressServiceIsRunning(pNetIf) != TCPIP_STACK_ADDRESS_SERVICE_NONE)

    830. 

  830.         {

    831. 

  831.             (*pCmdIO->pCmdApi->msg)(cmdIoParam, "An address service is already running. Stop DHCP, ZCLL, etc. first\r\n");

    832. 

  832.             return false;

    833. 

  833.         }

    834. 

  834. 

    835. 

  835.         if(argc > 3)

    836. 

  836.         {   // we have net mask too

    837. 

  837.             if (!TCPIP_Helper_StringToIPAddress(argv[3], &ipMask))

    838. 

  838.             {

    839. 

  839.                 (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Invalid IP mask string \r\n");

    840. 

  840.                 return false;

    841. 

  841.             }

    842. 

  842.             pMask = &ipMask;

    843. 

  843.         }

    844. 

  844.         else

    845. 

  845.         {

    846. 

  846.             pMask = 0;

    847. 

  847.         }

    848. 

  848. 

    849. 

  849.         if(TCPIP_STACK_NetAddressSet(netH, &ipAddr, pMask, true))

    850. 

  850.         {

    851. 

  851.             success = true;

    852. 

  852.         }

    853. 

  853. 

    854. 

  854.     }

    855. 

  855. #endif  // defined(TCPIP_STACK_USE_IPV4)

    856. 

  856. 

    857. 

  857. #if defined(TCPIP_STACK_USE_IPV6)

    858. 

  858. 

    859. 

  859.     if(addType == IP_ADDRESS_TYPE_IPV6)

    860. 

  860.     {

    861. 

  861.         if(argc > 3)

    862. 

  862.         {   // we have prefix length

    863. 

  863.             prefixLen = atoi(argv[3]);

    864. 

  864.         }

    865. 

  865.         else

    866. 

  866.         {

    867. 

  867.             prefixLen = 0;

    868. 

  868.         }

    869. 

  869. 

    870. 

  870.         if(TCPIP_IPV6_UnicastAddressAdd (netH, &ipv6Addr, prefixLen, false) != 0)

    871. 

  871.         {

    872. 

  872.             success = true;

    873. 

  873.         }

    874. 

  874.     }

    875. 

  875. 

    876. 

  876. #endif  // defined(TCPIP_STACK_USE_IPV6)

    877. 

  877. 

    878. 

  878. 

    879. 

  879.     (*pCmdIO->pCmdApi->msg)(cmdIoParam, success ? "Set ip address OK\r\n" : "Set ip address failed\r\n");

    880. 

  880.     return false;

    881. 

  881. }

    882. 

  882. 

    883. 

  883. static int _Command_GatewayAddressSet(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    884. 

  884. {

    885. 

  885.     TCPIP_NET_HANDLE netH;

    886. 

  886.     IP_ADDRESS_TYPE addType;

    887. 

  887. #if defined(TCPIP_STACK_USE_IPV4)

    888. 

  888.     IPV4_ADDR ipGateway;

    889. 

  889. #endif  // defined(TCPIP_STACK_USE_IPV4)

    890. 

  890. #if defined(TCPIP_STACK_USE_IPV6)

    891. 

  891.     IPV6_ADDR  ipv6Gateway;

    892. 

  892.     unsigned long validTime;

    893. 

  893. #endif  // defined(TCPIP_STACK_USE_IPV6)

    894. 

  894.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    895. 

  895.     bool     success = false;

    896. 

  896. 

    897. 

  897.     if (argc != 3)

    898. 

  898.     {

    899. 

  899.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: setgw <interface> <ipv4/6 address> <validTime> \r\n");

    900. 

  900.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: setgw PIC32INT 192.168.0.1 \r\n");

    901. 

  901.         return false;

    902. 

  902.     }

    903. 

  903. 

    904. 

  904.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    905. 

  905.     if (netH == 0)

    906. 

  906.     {

    907. 

  907.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface specified \r\n");

    908. 

  908.         return false;

    909. 

  909.     }

    910. 

  910. 

    911. 

  911.     addType = IP_ADDRESS_TYPE_ANY;

    912. 

  912. 

    913. 

  913. #if defined(TCPIP_STACK_USE_IPV4)

    914. 

  914.     if (TCPIP_Helper_StringToIPAddress(argv[2], &ipGateway))

    915. 

  915.     {

    916. 

  916.         addType = IP_ADDRESS_TYPE_IPV4;

    917. 

  917.     }

    918. 

  918. #endif  // defined(TCPIP_STACK_USE_IPV4)

    919. 

  919. #if defined(TCPIP_STACK_USE_IPV6)

    920. 

  920.     if(TCPIP_Helper_StringToIPv6Address (argv[2], &ipv6Gateway))

    921. 

  921.     {

    922. 

  922.         addType = IP_ADDRESS_TYPE_IPV6;

    923. 

  923.     }

    924. 

  924. #endif  // defined(TCPIP_STACK_USE_IPV6)

    925. 

  925. 

    926. 

  926.     if(addType == IP_ADDRESS_TYPE_ANY)

    927. 

  927.     {

    928. 

  928.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Invalid IP address string \r\n");

    929. 

  929.         return false;

    930. 

  930.     }

    931. 

  931. 

    932. 

  932. 

    933. 

  933. #if defined(TCPIP_STACK_USE_IPV4)

    934. 

  934.     if(addType == IP_ADDRESS_TYPE_IPV4)

    935. 

  935.     {

    936. 

  936.         success = TCPIP_STACK_NetAddressGatewaySet(netH, &ipGateway);

    937. 

  937.     }

    938. 

  938. #endif  // defined(TCPIP_STACK_USE_IPV4)

    939. 

  939. 

    940. 

  940. #if defined(TCPIP_STACK_USE_IPV6)

    941. 

  941.     if(addType == IP_ADDRESS_TYPE_IPV6)

    942. 

  942.     {

    943. 

  943.         if(argc > 3)

    944. 

  944.         {   // we have validity time

    945. 

  945.             validTime = (unsigned long)atoi(argv[3]);

    946. 

  946.         }

    947. 

  947.         else

    948. 

  948.         {

    949. 

  949.             validTime = 0;

    950. 

  950.         }

    951. 

  951.         success = TCPIP_IPV6_RouterAddressAdd(netH, &ipv6Gateway, validTime, 0);

    952. 

  952.     }

    953. 

  953. #endif  // defined(TCPIP_STACK_USE_IPV6)

    954. 

  954. 

    955. 

  955. 

    956. 

  956.     (*pCmdIO->pCmdApi->msg)(cmdIoParam, success ? "Set gateway address OK\r\n" : "Set gateway address failed\r\n");

    957. 

  957.     return false;

    958. 

  958. 

    959. 

  959. }

    960. 

  960. 

    961. 

  961. static int _Command_PrimaryDNSAddressSet(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    962. 

  962. {

    963. 

  963.     TCPIP_NET_HANDLE netH;

    964. 

  964.     IPV4_ADDR ipDNS;

    965. 

  965.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    966. 

  966. 

    967. 

  967.     if (argc != 3) {

    968. 

  968.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: setdns <interface> <x.x.x.x> \r\n");

    969. 

  969.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: setdns PIC32INT 255.255.255.0 \r\n");

    970. 

  970.         return false;

    971. 

  971.     }

    972. 

  972. 

    973. 

  973.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    974. 

  974.     if (netH == 0) {

    975. 

  975.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface specified \r\n");

    976. 

  976.         return false;

    977. 

  977.     }

    978. 

  978. 

    979. 

  979.     if (!TCPIP_Helper_StringToIPAddress(argv[2], &ipDNS)) {

    980. 

  980.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Invalid IP address string \r\n");

    981. 

  981.         return false;

    982. 

  982.     }

    983. 

  983. 

    984. 

  984.     if(!TCPIP_STACK_NetAddressDnsPrimarySet(netH, &ipDNS)) {

    985. 

  985.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Set DNS address failed\r\n");

    986. 

  986.         return false;

    987. 

  987.     }

    988. 

  988. 

    989. 

  989.     return true;

    990. 

  990. }

    991. 

  991. 

    992. 

  992. #if defined(TCPIP_STACK_USE_DNS_SERVER)

    993. 

  993. static int _Command_AddDelDNSSrvAddress(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    994. 

  994. {

    995. 

  995.     uint32_t		validStarttime=0;

    996. 

  996.     IP_MULTI_ADDRESS    ipDNS;

    997. 

  997.     IP_ADDRESS_TYPE     addrType;

    998. 

  998.     uint8_t             *hostName;

    999. 

  999.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    1000. 

  1000.     TCPIP_DNS_RESULT res;

    1001. 

  1001.     DNSS_COMD_TYPE val=DNSS_COMD_NONE;

    1002. 

  1002.     DNSS_COMMAND_MAP dnssComnd[3]=

    1003. 

  1003.             {

    1004. 

  1004.                 {"add", DNSS_COMD_ADD,},

    1005. 

  1005.                 {"del",DNSS_COMD_DEL,},

    1006. 

  1006.                 {"info",DNSS_COMD_INFO,},

    1007. 

  1007.             };

    1008. 

  1008.     int i=0;

    1009. 

  1009. #if defined(TCPIP_STACK_USE_IPV6)

    1010. 

  1010.     uint8_t     addrBuf[44];

    1011. 

  1011. #endif    

    1012. 

  1012. 	

    1013. 

  1013. 	

    1014. 

  1014.     if (argc < 2) {

    1015. 

  1015.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: dnsserv <add/del/info> <hostName> <IPType> <x.x.x.x> <lifeTime> \r\n");

    1016. 

  1016.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Help: hostName - URL , IPType - 4 for Ipv4 address and 6 for Ipv6 address \r\n");

    1017. 

  1017.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Help: LifeTime - The life time in Second for each entry to be used \r\n");

    1018. 

  1018.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Help: One IP address per URL at a time will be added \r\n");       

    1019. 

  1019.         return false;

    1020. 

  1020.     }

    1021. 

  1021. 	for(i=0;i<(sizeof(dnssComnd)/sizeof(DNSS_COMMAND_MAP));i++)

    1022. 

  1022. 	{

    1023. 

  1023.             if(strcmp(argv[1],dnssComnd[i].command) ==0)

    1024. 

  1024.             {

    1025. 

  1025.                 val = dnssComnd[i].val;

    1026. 

  1026.                 break;

    1027. 

  1027.             }

    1028. 

  1028. 	}

    1029. 

  1029. 	switch(val)

    1030. 

  1030. 	{

    1031. 

  1031.             case DNSS_COMD_ADD:

    1032. 

  1032.                 if (argc < 6) {

    1033. 

  1033.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: dnsserv add <hostName> <IPType> <x.x.x.x> <lifeTime> \r\n");

    1034. 

  1034.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Help: hostName - URL , IPType - 4 for Ipv4 address and 6 for Ipv6 address \r\n");

    1035. 

  1035.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Help: LifeTime - The life time in Second for each entry to be used \r\n");

    1036. 

  1036.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Help: One IP address per URL at a time will be added \r\n");

    1037. 

  1037.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: dnss add www.xyz.com 4 10.20.30.40 120 \r\n");

    1038. 

  1038.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: dnss add www.abc.com 6 2001::101 120 \r\n");

    1039. 

  1039.                     return false;

    1040. 

  1040.                 }

    1041. 

  1041. 			

    1042. 

  1042.                 hostName = (uint8_t*)argv[2];

    1043. 

  1043. 

    1044. 

  1044.                 if (memcmp(argv[3], "4", 1) == 0)

    1045. 

  1045.                 {	// turning on a service

    1046. 

  1046.                         addrType = IP_ADDRESS_TYPE_IPV4;

    1047. 

  1047.                 }

    1048. 

  1048. #if defined(TCPIP_STACK_USE_IPV6)     

    1049. 

  1049.                 else if (memcmp(argv[3], "6", 1) == 0)

    1050. 

  1050.                 {	// turning off a service

    1051. 

  1051.                         addrType = IP_ADDRESS_TYPE_IPV6;

    1052. 

  1052.                 }

    1053. 

  1053. #endif    

    1054. 

  1054.                 else

    1055. 

  1055.                 {

    1056. 

  1056.                         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown option\r\n");

    1057. 

  1057.                         return false;

    1058. 

  1058.                 }

    1059. 

  1059.                 if(addrType == IP_ADDRESS_TYPE_IPV4)

    1060. 

  1060.                 {

    1061. 

  1061.                     if (!TCPIP_Helper_StringToIPAddress(argv[4], &ipDNS.v4Add)) {

    1062. 

  1062.                         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Invalid IP address string \r\n");

    1063. 

  1063.                         return false;

    1064. 

  1064.                     }

    1065. 

  1065.                     //dnssCacheEntry.ip4Address.Val = ipDNS.Val;

    1066. 

  1066.                 }

    1067. 

  1067. #if defined(TCPIP_STACK_USE_IPV6)     

    1068. 

  1068.                 if(addrType == IP_ADDRESS_TYPE_IPV6)

    1069. 

  1069.                 {

    1070. 

  1070.                     strncpy((char*)addrBuf,argv[4],strlen(argv[4]));

    1071. 

  1071.                     if (!TCPIP_Helper_StringToIPv6Address((char*)addrBuf,&ipDNS.v6Add)) {

    1072. 

  1072.                         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Invalid IPv6 address string \r\n");

    1073. 

  1073.                         return false;

    1074. 

  1074.                     }

    1075. 

  1075.                 }

    1076. 

  1076. #endif    

    1077. 

  1077.                 validStarttime= (unsigned long)atoi((char*)argv[5]);

    1078. 

  1078. 		

    1079. 

  1079.                 res = TCPIP_DNSS_EntryAdd((const char*)hostName,addrType,&ipDNS,validStarttime);

    1080. 

  1080.                 switch(res)

    1081. 

  1081.                 {

    1082. 

  1082.                     case DNS_RES_DUPLICATE_ENTRY:

    1083. 

  1083.                         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "The Address is already part of the DNS Cache entry \r\n");

    1084. 

  1084.                         return false;

    1085. 

  1085.                     case DNS_RES_MEMORY_FAIL:

    1086. 

  1086.                         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "No memory available \r\n");

    1087. 

  1087.                         return false;

    1088. 

  1088.                     case DNS_RES_CACHE_FULL:

    1089. 

  1089.                         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "No space to add this entry \r\n");

    1090. 

  1090.                         return false;

    1091. 

  1091.                     case DNS_RES_OK:

    1092. 

  1092.                         return true;

    1093. 

  1093.                     default:

    1094. 

  1094.                         return false;

    1095. 

  1095.                 }

    1096. 

  1096.                 break;

    1097. 

  1097.             case DNSS_COMD_DEL:

    1098. 

  1098.                 if (argc != 5) {

    1099. 

  1099.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: dnsserv del <hostName> <IPType> <x.x.x.x>  \r\n");

    1100. 

  1100.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Help: hostName - URL , IPType - 4 for Ipv4 address and 6 for Ipv6 address \r\n");

    1101. 

  1101.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Help: One IP address per URL at a time will be added \r\n");

    1102. 

  1102.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: dnss del www.xyz.com 4 10.20.30.40  \r\n");

    1103. 

  1103.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: dnss del www.abc.com 6 2001::101  \r\n");

    1104. 

  1104.                     return false;

    1105. 

  1105.                 }

    1106. 

  1106. 

    1107. 

  1107.                 hostName = (uint8_t*)argv[1];

    1108. 

  1108. 

    1109. 

  1109.                 if (memcmp(argv[2], "4", 1) == 0)

    1110. 

  1110.                 {   // turning on a service

    1111. 

  1111.                     addrType = IP_ADDRESS_TYPE_IPV4;

    1112. 

  1112.                 }

    1113. 

  1113. #if defined(TCPIP_STACK_USE_IPV6)     

    1114. 

  1114.                 else if (memcmp(argv[2], "6", 1) == 0)

    1115. 

  1115.                 {   // turning off a service

    1116. 

  1116.                     addrType = IP_ADDRESS_TYPE_IPV6;

    1117. 

  1117.                 }

    1118. 

  1118. #endif    

    1119. 

  1119.                 else

    1120. 

  1120.                 {

    1121. 

  1121.                     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown option\r\n");

    1122. 

  1122.                     return false;

    1123. 

  1123.                 }

    1124. 

  1124.                 if(addrType == IP_ADDRESS_TYPE_IPV4)

    1125. 

  1125.                 {

    1126. 

  1126.                     if (!TCPIP_Helper_StringToIPAddress(argv[3], &ipDNS.v4Add)) {

    1127. 

  1127.                         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Invalid IPv4 address string \r\n");

    1128. 

  1128.                         return false;

    1129. 

  1129.                     }

    1130. 

  1130.                 }

    1131. 

  1131. #if defined(TCPIP_STACK_USE_IPV6)     

    1132. 

  1132.                 if(addrType == IP_ADDRESS_TYPE_IPV6)

    1133. 

  1133.                 {

    1134. 

  1134.                     strncpy((char*)addrBuf,argv[3],strlen(argv[3]));

    1135. 

  1135.                     if (!TCPIP_Helper_StringToIPv6Address((char*)addrBuf, &ipDNS.v6Add)) {

    1136. 

  1136.                         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Invalid IPv6 address string \r\n");

    1137. 

  1137.                         return false;

    1138. 

  1138.                     }

    1139. 

  1139.                 }

    1140. 

  1140. #endif    

    1141. 

  1141. 

    1142. 

  1142.                 res = TCPIP_DNSS_CacheEntryRemove((const char*)hostName,addrType,&ipDNS);

    1143. 

  1143.                 switch(res)

    1144. 

  1144.                 {

    1145. 

  1145.                     case DNS_RES_NO_ENTRY:

    1146. 

  1146.                         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "The Address is not part of the DNS Cache entry \r\n");

    1147. 

  1147.                         return false;

    1148. 

  1148.                     case DNS_RES_MEMORY_FAIL:

    1149. 

  1149.                         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "No memory available \r\n");

    1150. 

  1150.                         return false;

    1151. 

  1151.                     case DNS_RES_CACHE_FULL:

    1152. 

  1152.                         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "No space to add this entry \r\n");

    1153. 

  1153.                         return false;

    1154. 

  1154.                     case DNS_RES_OK:

    1155. 

  1155.                         return true;

    1156. 

  1156.                     default:

    1157. 

  1157.                         return false;

    1158. 

  1158.                 }

    1159. 

  1159.                 break;

    1160. 

  1160.             case DNSS_COMD_INFO:

    1161. 

  1161.                 _Command_ShowDNDServInfo(pCmdIO,argc,argv);

    1162. 

  1162.                 break;

    1163. 

  1163.             default:

    1164. 

  1164.                 (*pCmdIO->pCmdApi->print)(cmdIoParam, "Invalid Input Command :[ %s ] \r\n", argv[1]);

    1165. 

  1165.                 return false;

    1166. 

  1166. 	}    

    1167. 

  1167.         return true;

    1168. 

  1168. }

    1169. 

  1169. 

    1170. 

  1170. static int _Command_ShowDNDServInfo(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    1171. 

  1171. {

    1172. 

  1172.     IP_MULTI_ADDRESS ipDNS;

    1173. 

  1173.     IP_ADDRESS_TYPE addrType;

    1174. 

  1174.     uint8_t         *hostName;

    1175. 

  1175.     uint8_t         ipcount=0;

    1176. 

  1176.     int             index=0;

    1177. 

  1177.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    1178. 

  1178.     TCPIP_DNS_RESULT res;

    1179. 

  1179.     uint32_t    ttlTime=0;

    1180. 

  1180.     bool        entryPresent=false;

    1181. 

  1181. #if defined(TCPIP_STACK_USE_IPV6)

    1182. 

  1182.     uint8_t     addrBuf[44];

    1183. 

  1183. #endif    

    1184. 

  1184. 

    1185. 

  1185.     if (argc != 3) {

    1186. 

  1186.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: dnsserv info <hostname> | <all>\r\n");

    1187. 

  1187.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Help: display the DNS cache entry details \r\n");

    1188. 

  1188.         return false;

    1189. 

  1189.     }

    1190. 

  1190.     hostName = (uint8_t*)argv[2];

    1191. 

  1191.     if(strcmp((char*)argv[2],"all")==0)

    1192. 

  1192.     {

    1193. 

  1193.     	index = 0;

    1194. 

  1194.        // memset(dnsHostName,0,sizeof(dnsHostName));		

    1195. 

  1195.         (*pCmdIO->pCmdApi->msg)(cmdIoParam,"HostName        IPv4/IPv6Count\r\n");

    1196. 

  1196. 

    1197. 

  1197.         while(1)

    1198. 

  1198.         {

    1199. 

  1199.             res = TCPIP_DNSS_AddressCntGet(index,(uint8_t*)hostName,&ipcount);

    1200. 

  1200.             if(res == DNS_RES_OK)

    1201. 

  1201.             {

    1202. 

  1202.                 entryPresent = true;

    1203. 

  1203.                 (*pCmdIO->pCmdApi->print)(cmdIoParam, "%s       %d\r\n",hostName,ipcount);

    1204. 

  1204.             }

    1205. 

  1205.             if(res == DNS_RES_NO_SERVICE)

    1206. 

  1206.             {

    1207. 

  1207.                 if(entryPresent == false)

    1208. 

  1208.                 {

    1209. 

  1209.                    (*pCmdIO->pCmdApi->msg)(cmdIoParam, "No DNS Server Cache entry \r\n");

    1210. 

  1210.                 }

    1211. 

  1211.                 entryPresent = false;

    1212. 

  1212.                 break;

    1213. 

  1213.             }

    1214. 

  1214.             index++;

    1215. 

  1215.         }

    1216. 

  1216.         return true;

    1217. 

  1217.     }

    1218. 

  1218.     addrType = IP_ADDRESS_TYPE_IPV4;

    1219. 

  1219.     index = 0;

    1220. 

  1220.     (*pCmdIO->pCmdApi->msg)(cmdIoParam,"HostName        IPv4Address     TTLTime \r\n");

    1221. 

  1221.     while(1)

    1222. 

  1222.     {

    1223. 

  1223.         res = TCPIP_DNSS_EntryGet((uint8_t*)hostName,addrType,index,&ipDNS);

    1224. 

  1224.         if(res == DNS_RES_OK)

    1225. 

  1225.         {

    1226. 

  1226.             (*pCmdIO->pCmdApi->print)(cmdIoParam, "%s   %d.%d.%d.%d     %d\r\n",hostName,ipDNS.v4Add.v[0],ipDNS.v4Add.v[1],

    1227. 

  1227.                 ipDNS.v4Add.v[2],ipDNS.v4Add.v[3],ttlTime);

    1228. 

  1228.             entryPresent = true;

    1229. 

  1229.         }

    1230. 

  1230.         else if((res == DNS_RES_NO_SERVICE)|| (res == DNS_RES_NO_ENTRY))

    1231. 

  1231.         {

    1232. 

  1232.             if(entryPresent == false)

    1233. 

  1233.             {

    1234. 

  1234.                (*pCmdIO->pCmdApi->print)(cmdIoParam, "[%s] No Ipv4 Address with in DNS Cache entry \r\n",hostName);

    1235. 

  1235.             }

    1236. 

  1236.             entryPresent = false;

    1237. 

  1237.             break;

    1238. 

  1238.         }

    1239. 

  1239.         index++;

    1240. 

  1240.     }

    1241. 

  1241.     

    1242. 

  1242.     (*pCmdIO->pCmdApi->msg)(cmdIoParam, "\r\n");

    1243. 

  1243. 

    1244. 

  1244. #if defined(TCPIP_STACK_USE_IPV6)

    1245. 

  1245.     addrType = IP_ADDRESS_TYPE_IPV6;

    1246. 

  1246.     index = 0;

    1247. 

  1247.     (*pCmdIO->pCmdApi->msg)(cmdIoParam,"HostName        IPv6Address             TTLTime \r\n");

    1248. 

  1248.     while(1)

    1249. 

  1249.     {

    1250. 

  1250.         res = TCPIP_DNSS_EntryGet((uint8_t*)hostName,addrType,index,&ipDNS);

    1251. 

  1251.         if(res == DNS_RES_OK)

    1252. 

  1252.         {

    1253. 

  1253.             TCPIP_Helper_IPv6AddressToString(&ipDNS.v6Add,(char*)addrBuf,sizeof(addrBuf));

    1254. 

  1254.             (*pCmdIO->pCmdApi->print)(cmdIoParam, "%s       %s      %d\r\n",hostName,addrBuf,ttlTime);

    1255. 

  1255.             entryPresent = true;

    1256. 

  1256.         }

    1257. 

  1257.         else if((res == DNS_RES_NO_SERVICE)|| (res == DNS_RES_NO_ENTRY))

    1258. 

  1258.         {

    1259. 

  1259.             if(entryPresent == false)

    1260. 

  1260.             {

    1261. 

  1261.                (*pCmdIO->pCmdApi->print)(cmdIoParam, "[%s] No Ipv6 Address DNS Cache entry \r\n",hostName);

    1262. 

  1262.             }

    1263. 

  1263.             entryPresent = false;

    1264. 

  1264.             break;

    1265. 

  1265.         }

    1266. 

  1266.        

    1267. 

  1267.         index++;

    1268. 

  1268.     }

    1269. 

  1269. #endif

    1270. 

  1270.     return true;

    1271. 

  1271. }

    1272. 

  1272. #endif

    1273. 

  1273. 

    1274. 

  1274. static int _Command_BIOSNameSet(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    1275. 

  1275. {

    1276. 

  1276.     TCPIP_NET_HANDLE netH;

    1277. 

  1277.     const char* msg;

    1278. 

  1278.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    1279. 

  1279. 

    1280. 

  1280.     if (argc != 3)

    1281. 

  1281.     {

    1282. 

  1282.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: setbios <interface> <x.x.x.x> \r\n");

    1283. 

  1283.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: setbios PIC32INT MCHPBOARD_29 \r\n");

    1284. 

  1284.         return false;

    1285. 

  1285.     }

    1286. 

  1286. 

    1287. 

  1287.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    1288. 

  1288.     if (netH == 0)

    1289. 

  1289.     {

    1290. 

  1290.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface specified \r\n");

    1291. 

  1291.         return false;

    1292. 

  1292.     }

    1293. 

  1293. 

    1294. 

  1294.     if(TCPIP_STACK_NetBiosNameSet(netH, argv[2]))

    1295. 

  1295.     {

    1296. 

  1296.         msg = "Set BIOS Name OK\r\n";

    1297. 

  1297.     }

    1298. 

  1298.     else

    1299. 

  1299.     {

    1300. 

  1300.         msg = "Set BIOS Name failed\r\n";

    1301. 

  1301.     }

    1302. 

  1302. 

    1303. 

  1303.     (*pCmdIO->pCmdApi->msg)(cmdIoParam, msg);

    1304. 

  1304.     return true;

    1305. 

  1305. }

    1306. 

  1306. 

    1307. 

  1307. static int _Command_MACAddressSet(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    1308. 

  1308. {

    1309. 

  1309.     TCPIP_NET_HANDLE netH;

    1310. 

  1310.     TCPIP_MAC_ADDR macAddr;

    1311. 

  1311.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    1312. 

  1312. 

    1313. 

  1313.     if (argc != 3) {

    1314. 

  1314.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: setmac <interface> <x:x:x:x:x:x> \r\n");

    1315. 

  1315.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: setmac PIC32INT aa:bb:cc:dd:ee:ff \r\n");

    1316. 

  1316.         return false;

    1317. 

  1317.     }

    1318. 

  1318. 

    1319. 

  1319.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    1320. 

  1320.     if (netH == 0) {

    1321. 

  1321.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface specified \r\n");

    1322. 

  1322.         return false;

    1323. 

  1323.     }

    1324. 

  1324. 

    1325. 

  1325.     (*pCmdIO->pCmdApi->print)(cmdIoParam, "argv[2]: %s\r\n", argv[2]);

    1326. 

  1326. 

    1327. 

  1327.     if (!TCPIP_Helper_StringToMACAddress(argv[2], macAddr.v)) {

    1328. 

  1328.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Invalid MAC address string \r\n");

    1329. 

  1329.         return false;

    1330. 

  1330.     }

    1331. 

  1331. 

    1332. 

  1332.     if(!TCPIP_STACK_NetAddressMacSet(netH, &macAddr)) {

    1333. 

  1333.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Set MAC address failed\r\n");

    1334. 

  1334.         return false;

    1335. 

  1335.     }

    1336. 

  1336. 

    1337. 

  1337.     return true;

    1338. 

  1338. }

    1339. 

  1339. 

    1340. 

  1340. 

    1341. 

  1341. static int _Command_NetworkOnOff(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)

    1342. 

  1342. {

    1343. 

  1343.     bool res = false;

    1344. 

  1344.     TCPIP_NET_HANDLE netH;

    1345. 

  1345. #if defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    1346. 

  1346.     TCPIP_COMMAND_STG_DCPT*   pDcpt;

    1347. 

  1347.     TCPIP_NETWORK_CONFIG*     pNetConf;

    1348. 

  1348. #endif  // defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    1349. 

  1349.     uint16_t net_ix = 0;

    1350. 

  1350.     const void* cmdIoParam = pCmdIO->cmdIoParam;

    1351. 

  1351. 

    1352. 

  1352.     if (argc != 3)

    1353. 

  1353.     {

    1354. 

  1354.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: if <interface> <down/up> \r\n");

    1355. 

  1355.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: if PIC32INT down \r\n");

    1356. 

  1356.         return false;

    1357. 

  1357.     }

    1358. 

  1358. 

    1359. 

  1359.     netH = TCPIP_STACK_NetHandleGet(argv[1]);

    1360. 

  1360. 

    1361. 

  1361.     if (netH == 0)

    1362. 

  1362.     {

    1363. 

  1363.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Unknown interface specified \r\n");

    1364. 

  1364.         return false;

    1365. 

  1365.     }

    1366. 

  1366. 

    1367. 

  1367.     net_ix = TCPIP_STACK_NetIndexGet(netH);

    1368. 

  1368. 

    1369. 

  1369.     if (memcmp(argv[2], "up", 2) == 0)

    1370. 

  1370.     {

    1371. 

  1371.         if(TCPIP_STACK_NetIsUp(netH))

    1372. 

  1372.         {

    1373. 

  1373.             (*pCmdIO->pCmdApi->msg)(cmdIoParam, "This interface already up\r\n");

    1374. 

  1374.             return true;

    1375. 

  1375.         }

    1376. 

  1376. 

    1377. 

  1377. #if defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    1378. 

  1378.         pNetConf = 0;

    1379. 

  1379.         if(pCmdStgDcpt) 

    1380. 

  1380.         {

    1381. 

  1381.             // get the saved network configuration

    1382. 

  1382.             pDcpt = pCmdStgDcpt + net_ix;

    1383. 

  1383.             if(pDcpt->stgSize)

    1384. 

  1384.             {   // saved config is valid; restore

    1385. 

  1385.                 pNetConf = TCPIP_STACK_NetConfigSet(&pDcpt->netDcptStg, pDcpt->restoreBuff, sizeof(pDcpt->restoreBuff), 0);

    1386. 

  1386.                 (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Interface up: configuration " );

    1387. 

  1387.                 (*pCmdIO->pCmdApi->msg)(cmdIoParam, pNetConf ? "restored\r\n" : "restore failed!\r\n");

    1388. 

  1388.             }

    1389. 

  1389.         }

    1390. 

  1390.         res = TCPIP_STACK_NetUp(netH, pNetConf);

    1391. 

  1391. #else

    1392. 

  1392.         res = TCPIP_STACK_NetUp(netH, 0);

    1393. 

  1393. #endif  // defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    1394. 

  1394. 

    1395. 

  1395.     }

    1396. 

  1396.     else if (memcmp(argv[2], "down", 4) == 0)

    1397. 

  1397.     {

    1398. 

  1398.         if(TCPIP_STACK_NetIsUp(netH) == 0)

    1399. 

  1399.         {

    1400. 

  1400.             (*pCmdIO->pCmdApi->msg)(cmdIoParam, "This interface already down\r\n");

    1401. 

  1401.             return true;

    1402. 

  1402.         }

    1403. 

  1403. 

    1404. 

  1404. #if defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    1405. 

  1405.         if(pCmdStgDcpt) 

    1406. 

  1406.         {

    1407. 

  1407.             // get the last network configuration so we use it when

    1408. 

  1408.             // restart the stack/interface 

    1409. 

  1409.             pDcpt = pCmdStgDcpt + net_ix;

    1410. 

  1410.             pDcpt->stgSize = TCPIP_STACK_NetConfigGet(netH, &pDcpt->netDcptStg, sizeof(pDcpt->netDcptStg), 0);

    1411. 

  1411. 

    1412. 

  1412.             (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Interface down: configuration saved\r\n");

    1413. 

  1413.         }

    1414. 

  1414. #endif  // defined(TCPIP_STACK_COMMANDS_STORAGE_ENABLE)

    1415. 

  1415. 

    1416. 

  1416.         res = TCPIP_STACK_NetDown(netH);

    1417. 

  1417.     } 

    1418. 

  1418.     else

    1419. 

  1419.     {

    1420. 

  1420.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Wrong parameter specified \r\n");

    1421. 

  1421.         return false;

    1422. 

  1422.     }

    1423. 

  1423. 

    1424. 

  1424.     if (res == true)

    1425. 

  1425.     {

    1426. 

  1426.         (*pCmdIO->pCmdApi->msg)(cmdIoParam, "Operation successful!\r\n");

    1427. 

  1427.     }

    1428. 

  1428.     else…
    1429.