static int CommandPing(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)
{
const void* cmdIoParam = pCmdIO->cmdIoParam;
if (argc < 2)
{
(*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ping Usage: ping <stop> <name/address> <n> <msDelay>\r\n");
return true;
}
if(strcmp(argv[1], "stop") == 0)
{
if(icmpCmdStat != TCPIP_PING_CMD_IDLE)
{
_PingStop(pCmdIO, cmdIoParam);
}
return true;
}
if(icmpCmdStat != TCPIP_PING_CMD_IDLE)
{
(*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ping: command in progress. Retry later.\r\n");
return true;
}
if(TCPIP_Helper_StringToIPAddress(argv[1], &icmpTargetAddr))
{
strncpy(icmpTargetAddrStr, argv[1], sizeof(icmpTargetAddrStr));
icmpTargetHost[0] = '\0';
icmpCmdStat = TCPIP_PING_CMD_DO_PING;
}
else
{ // assume host address
if(strlen(argv[1]) > sizeof(icmpTargetHost) - 1)
{
(*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ping: Host name too long. Retry.\r\n");
return true;
}
strcpy(icmpTargetHost, argv[1]);
icmpCmdStat = TCPIP_PING_CMD_DNS_GET;
(*pCmdIO->pCmdApi->print)(cmdIoParam, "Ping: resolving host: %s\r\n", icmpTargetHost);
}
if(hIcmp == 0)
{
if((hIcmp = TCPIP_ICMP_CallbackRegister(CommandPingHandler)) == 0)
{
(*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ping: Failed to register ICMP handler\r\n");
return true;
}
}
icmpSequenceNo = SYS_Rand();
icmpIdentifier = SYS_Rand();
icmpReqNo = 0;
icmpReqDelay = 0;
if(argc >= 3)
{
icmpReqNo = atoi(argv[2]);
}
if(argc >= 4)
{
icmpReqDelay = atoi(argv[3]);
}
if(icmpReqNo == 0)
{
icmpReqNo = TCPIP_STACK_COMMANDS_ICMP_ECHO_REQUESTS;
}
if(icmpReqDelay == 0)
{
icmpReqDelay = TCPIP_STACK_COMMANDS_ICMP_ECHO_REQUEST_DELAY;
}
// convert to ticks
if(icmpReqDelay < TCPIP_COMMAND_ICMP_ECHO_REQUEST_MIN_DELAY)
{
icmpReqDelay = TCPIP_COMMAND_ICMP_ECHO_REQUEST_MIN_DELAY;
}
pIcmpCmd = pCmdIO;
icmpCmdIoParam = cmdIoParam;
icmpAckRecv = 0;
icmpReqCount = 0;
_TCPIPStackAsyncHandlerSetParams(icmptickH, 0, icmpReqDelay);
return true;
}
/*****************************************************************************
Function:
void DNSClientTask(void)
Summary:
DNS client state machine
Description:
Process the DNS client state machine
Precondition:
DNSClientInit has been called.
Parameters:
None
Return Values:
None
***************************************************************************/
void DNSClientTask(void)
{
uint8_t i;
TCPIP_UINT16_VAL w;
DNS_HEADER DNSHeader;
DNS_ANSWER_HEADER DNSAnswerHeader;
switch(smDNS)
{
case DNS_IDLE:
break; // nothing to do
case DNS_START:
smDNS = DNSRetry(DNS_START);
stateStartTime = 0; // flag the first Open try
break;
case DNS_OPEN_SOCKET:
DNSSocket = UDPOpenClient(IP_ADDRESS_TYPE_IPV4, DNS_CLIENT_PORT, (IP_MULTI_ADDRESS*)(DNSServers + vDNSServerIx));
if(DNSSocket == INVALID_UDP_SOCKET)
{
if(stateStartTime == 0)
{
stateStartTime = SYS_TICK_Get();
}
else if(SYS_TICK_Get() - stateStartTime > (DNS_CLIENT_OPEN_TMO * SYS_TICK_TicksPerSecondGet()))
{
smDNS = DNS_FAIL_OPEN_TMO;
}
break;
}
// got a valid UDP socket
UDPSocketSetNet(DNSSocket, pDNSNet);
stateStartTime = SYS_TICK_Get();
smDNS = DNS_QUERY;
// no break, start sending the query;
case DNS_QUERY:
// since we don't do ARP here anymore we have to wait for the UDP to do it!
if(!UDPIsOpened(DNSSocket) || (UDPIsTxPutReady(DNSSocket, 18 + strlen (DNSHostName)) < (18 + strlen (DNSHostName))))
{
if(SYS_TICK_Get() - stateStartTime > (DNS_CLIENT_OPEN_TMO * SYS_TICK_TicksPerSecondGet()))
{
smDNS = DNS_FAIL_OPEN_TMO;
}
break; // wait some more
}
// Put DNS query here
SentTransactionID.Val = (uint16_t)SYS_Rand();
UDPPut(DNSSocket, SentTransactionID.v[1]);// User chosen transaction ID
UDPPut(DNSSocket, SentTransactionID.v[0]);
UDPPut(DNSSocket, 0x01); // Standard query with recursion
UDPPut(DNSSocket, 0x00);
UDPPut(DNSSocket, 0x00); // 0x0001 questions
UDPPut(DNSSocket, 0x01);
UDPPut(DNSSocket, 0x00); // 0x0000 answers
UDPPut(DNSSocket, 0x00);
UDPPut(DNSSocket, 0x00); // 0x0000 name server resource records
UDPPut(DNSSocket, 0x00);
UDPPut(DNSSocket, 0x00); // 0x0000 additional records
UDPPut(DNSSocket, 0x00);
// Put hostname string to resolve
DNSPutString(DNSSocket, DNSHostName);
UDPPut(DNSSocket, 0x00); // Type: DNS_TYPE_A A (host address) or DNS_TYPE_MX for mail exchange
UDPPut(DNSSocket, RecordType);
UDPPut(DNSSocket, 0x00); // Class: IN (Internet)
UDPPut(DNSSocket, 0x01);
UDPFlush(DNSSocket);
stateStartTime = SYS_TICK_Get();
smDNS = DNS_GET_RESULT;
break;
case DNS_GET_RESULT:
if(!UDPIsGetReady(DNSSocket))
{
if(SYS_TICK_Get() - stateStartTime > (DNS_CLIENT_SERVER_TMO * SYS_TICK_TicksPerSecondGet()))
{
smDNS = DNS_FAIL_SERVER;
}
break;
}
// Retrieve the DNS header and de-big-endian it
UDPGet(DNSSocket, &DNSHeader.TransactionID.v[1]);
UDPGet(DNSSocket, &DNSHeader.TransactionID.v[0]);
// Throw this packet away if it isn't in response to our last query
if(DNSHeader.TransactionID.Val != SentTransactionID.Val)
{
UDPDiscard(DNSSocket);
break;
}
UDPGet(DNSSocket, &DNSHeader.Flags.v[1]);
UDPGet(DNSSocket, &DNSHeader.Flags.v[0]);
UDPGet(DNSSocket, &DNSHeader.Questions.v[1]);
UDPGet(DNSSocket, &DNSHeader.Questions.v[0]);
UDPGet(DNSSocket, &DNSHeader.Answers.v[1]);
UDPGet(DNSSocket, &DNSHeader.Answers.v[0]);
UDPGet(DNSSocket, &DNSHeader.AuthoritativeRecords.v[1]);
UDPGet(DNSSocket, &DNSHeader.AuthoritativeRecords.v[0]);
UDPGet(DNSSocket, &DNSHeader.AdditionalRecords.v[1]);
UDPGet(DNSSocket, &DNSHeader.AdditionalRecords.v[0]);
// Remove all questions (queries)
while(DNSHeader.Questions.Val--)
{
DNSDiscardName(DNSSocket);
UDPGet(DNSSocket, &w.v[1]); // Question type
UDPGet(DNSSocket, &w.v[0]);
UDPGet(DNSSocket, &w.v[1]); // Question class
UDPGet(DNSSocket, &w.v[0]);
}
// Scan through answers
while(DNSHeader.Answers.Val--)
{
DNSDiscardName(DNSSocket); // Throw away response name
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseType.v[1]); // Response type
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseType.v[0]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseClass.v[1]); // Response class
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseClass.v[0]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[3]); // Time to live
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[2]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[1]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[0]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseLen.v[1]); // Response length
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseLen.v[0]);
// Make sure that this is a 4 byte IP address, response type A or MX, class 1
// Check if this is Type A, MX, or AAAA
if( DNSAnswerHeader.ResponseClass.Val == 0x0001u) // Internet class
{
if (DNSAnswerHeader.ResponseType.Val == 0x0001u &&
DNSAnswerHeader.ResponseLen.Val == 0x0004u)
{
Flags.bits.AddressValid = true;
Flags.bits.AddressType = IP_ADDRESS_TYPE_IPV4;
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[0]);
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[1]);
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[2]);
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[3]);
goto DoneSearchingRecords;
}
else if (DNSAnswerHeader.ResponseType.Val == 0x001Cu &&
DNSAnswerHeader.ResponseLen.Val == 0x0010u)
{
if (RecordType != DNS_TYPE_AAAA)
{
while(DNSAnswerHeader.ResponseLen.Val--)
{
UDPGet(DNSSocket, &i);
}
break;
}
Flags.bits.AddressValid = true;
Flags.bits.AddressType = IP_ADDRESS_TYPE_IPV6;
UDPGetArray (DNSSocket, (void *)&ResolvedAddress.ipv6Address, sizeof (IPV6_ADDR));
goto DoneSearchingRecords;
}
else
{
while(DNSAnswerHeader.ResponseLen.Val--)
{
UDPGet(DNSSocket, &i);
}
}
}
else
{
while(DNSAnswerHeader.ResponseLen.Val--)
{
UDPGet(DNSSocket, &i);
}
}
}
// Remove all Authoritative Records
while(DNSHeader.AuthoritativeRecords.Val--)
{
DNSDiscardName(DNSSocket); // Throw away response name
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseType.v[1]); // Response type
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseType.v[0]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseClass.v[1]); // Response class
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseClass.v[0]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[3]); // Time to live
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[2]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[1]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[0]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseLen.v[1]); // Response length
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseLen.v[0]);
// Make sure that this is a 4 byte IP address, response type A or MX, class 1
// Check if this is Type A
if( DNSAnswerHeader.ResponseClass.Val == 0x0001u) // Internet class
{
if (DNSAnswerHeader.ResponseType.Val == 0x0001u &&
DNSAnswerHeader.ResponseLen.Val == 0x0004u)
{
Flags.bits.AddressValid = true;
Flags.bits.AddressType = IP_ADDRESS_TYPE_IPV4;
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[0]);
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[1]);
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[2]);
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[3]);
goto DoneSearchingRecords;
}
else if (DNSAnswerHeader.ResponseType.Val == 0x001Cu &&
DNSAnswerHeader.ResponseLen.Val == 0x0010u)
{
if (RecordType != DNS_TYPE_AAAA)
{
while(DNSAnswerHeader.ResponseLen.Val--)
{
UDPGet(DNSSocket, &i);
}
break;
}
Flags.bits.AddressValid = true;
Flags.bits.AddressType = IP_ADDRESS_TYPE_IPV6;
UDPGetArray (DNSSocket, (void *)&ResolvedAddress.ipv6Address, sizeof (IPV6_ADDR));
goto DoneSearchingRecords;
}
else
{
while(DNSAnswerHeader.ResponseLen.Val--)
{
UDPGet(DNSSocket, &i);
}
}
}
else
{
while(DNSAnswerHeader.ResponseLen.Val--)
{
UDPGet(DNSSocket, &i);
}
}
}
// Remove all Additional Records
while(DNSHeader.AdditionalRecords.Val--)
{
DNSDiscardName(DNSSocket); // Throw away response name
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseType.v[1]); // Response type
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseType.v[0]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseClass.v[1]); // Response class
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseClass.v[0]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[3]); // Time to live
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[2]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[1]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseTTL.v[0]);
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseLen.v[1]); // Response length
UDPGet(DNSSocket, &DNSAnswerHeader.ResponseLen.v[0]);
// Make sure that this is a 4 byte IP address, response type A or MX, class 1
// Check if this is Type A
if( DNSAnswerHeader.ResponseClass.Val == 0x0001u) // Internet class
{
if (DNSAnswerHeader.ResponseType.Val == 0x0001u &&
DNSAnswerHeader.ResponseLen.Val == 0x0004u)
{
Flags.bits.AddressValid = true;
Flags.bits.AddressType = IP_ADDRESS_TYPE_IPV4;
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[0]);
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[1]);
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[2]);
UDPGet(DNSSocket, &ResolvedAddress.ipv4Address.v[3]);
goto DoneSearchingRecords;
}
else if (DNSAnswerHeader.ResponseType.Val == 0x001Cu &&
DNSAnswerHeader.ResponseLen.Val == 0x0010u)
{
if (RecordType != DNS_TYPE_AAAA)
{
while(DNSAnswerHeader.ResponseLen.Val--)
{
UDPGet(DNSSocket, &i);
}
break;
}
Flags.bits.AddressValid = true;
Flags.bits.AddressType = IP_ADDRESS_TYPE_IPV6;
UDPGetArray (DNSSocket, (void *)&ResolvedAddress.ipv6Address, sizeof (IPV6_ADDR));
goto DoneSearchingRecords;
}
else
{
while(DNSAnswerHeader.ResponseLen.Val--)
{
UDPGet(DNSSocket, &i);
}
}
}
else
{
while(DNSAnswerHeader.ResponseLen.Val--)
{
UDPGet(DNSSocket, &i);
}
}
}
DoneSearchingRecords:
UDPDiscard(DNSSocket);
_DNSReleaseSocket();
if(Flags.bits.AddressValid)
{
smDNS = DNS_DONE;
}
else
{
smDNS = DNSRetry(DNS_FAIL_SERVER);
}
break; // done
case DNS_FAIL_ARP:
// see if there is other server we may try
smDNS = DNSRetry(DNS_FAIL_ARP);
break;
case DNS_FAIL_SERVER:
smDNS = DNSRetry(DNS_FAIL_SERVER);
break;
default: // DNS_DONE, DNS_FAIL_ARP_TMO, DNS_FAIL_OPEN_TMO, DNS_FAIL_SERVER_TMO
// either done or some error state
break;
}
#if DNS_CLIENT_VERSION_NO >= 2
dnsTickPending = 0;
#endif // DNS_CLIENT_VERSION_NO >= 2
}