/***************************************************************************** Function: int bind( SOCKET s, const struct sockaddr* name, int namelen ) Summary: This function assigns a name to the socket descriptor. Description: The bind function assigns a name to an unnamed socket. The name represents the local address of the communication endpoint. For sockets of type SOCK_STREAM, the name of the remote endpoint is assigned when a connect or accept function is executed. Precondition: socket function should be called. Parameters: s - Socket descriptor returned from a previous call to socket. name - pointer to the sockaddr structure containing the local address of the socket. namelen - length of the sockaddr structure. Returns: If bind is successful, a value of 0 is returned. A return value of SOCKET_ERROR indicates an error. (and errno set accordingly). Remarks: None. ***************************************************************************/ int bind( SOCKET s, const struct sockaddr* name, int namelen ) { struct BSDSocket *socket; struct sockaddr_in *local_addr; uint16_t lPort; IPV4_ADDR lAddr; if( s >= BSD_SOCKET_COUNT ) { errno = EBADF; return SOCKET_ERROR; } socket = &BSDSocketArray[s]; if( socket->bsdState != SKT_CREATED ) //only work with recently created socket { errno = EINVAL; return SOCKET_ERROR; } if( (unsigned int)namelen < sizeof(struct sockaddr_in) ) { errno = EFAULT; return SOCKET_ERROR; } local_addr = (struct sockaddr_in *)name; lAddr.Val = local_addr->sin_addr.S_un.S_addr; lPort = local_addr->sin_port; if( lPort == 0u ) //pick a port { lPort = gAutoPortNumber++; if(gAutoPortNumber > 5000u) // reset the port numbers gAutoPortNumber = 1024; } if(socket->SocketType == SOCK_DGRAM) { socket->SocketID = UDPOpenServer(IP_ADDRESS_TYPE_IPV4, lPort, 0); if(socket->SocketID == INVALID_UDP_SOCKET) { errno = ENOBUFS; return SOCKET_ERROR; } UDPSocketSetNet(socket->SocketID, _TCPIPStackIpAddToNet(&lAddr, true)); } socket->localPort = lPort; socket->localIP = lAddr.Val; socket->bsdState = SKT_BOUND; return 0; //success }
/********************************************************************* * Function: void RebootTask(NET_CONFIG* pConfig) * * PreCondition: Stack is initialized() * * Input: pConfig - interface * * Output: None * * Side Effects: None * * Overview: Checks for incomming traffic on port 69. * Resets the PIC if a 'R' is received. * * Note: This module is primarily for use with the * Ethernet bootloader. By resetting, the Ethernet * bootloader can take control for a second and let * a firmware upgrade take place. ********************************************************************/ void RebootTask(NET_CONFIG* pConfig) { struct { uint8_t vMACAddress[6]; uint32_t dwIPAddress; uint16_t wChecksum; } BootloaderAddress; int netIx; netIx = _TCPIPStackNetIx(pConfig); if(MySocket[netIx] == INVALID_UDP_SOCKET) { MySocket[netIx] = UDPOpen(0,UDP_OPEN_SERVER,REBOOT_PORT,INVALID_UDP_PORT); if(MySocket[netIx] == INVALID_UDP_SOCKET) { return; } UDPSocketSetNet(MySocket[netIx], pConfig); } // Do nothing if no data is waiting if(!UDPIsGetReady(MySocket[netIx])) return; #if defined(REBOOT_SAME_SUBNET_ONLY) // Respond only to name requests sent to us from nodes on the same subnet if((remoteNode.IPAddr.Val & pConfig->MyMask.Val) != (pConfig->MyIPAddr.Val & pConfig->MyMask.Val)) { UDPDiscard(pConfig); return; } #endif // Get our MAC address, IP address, and compute a checksum of them memcpy((void*)&BootloaderAddress.vMACAddress[0], (void*)&pConfig->MyMACAddr.v[0], sizeof(pConfig->MyMACAddr)); BootloaderAddress.dwIPAddress = pConfig->MyIPAddr.Val; BootloaderAddress.wChecksum = CalcIPChecksum((uint8_t*)&BootloaderAddress, sizeof(BootloaderAddress) - sizeof(BootloaderAddress.wChecksum)); // To enter the bootloader, we reset the system SYS_OUT_MESSAGE("Bootloader Reset"); SYS_Reboot(); }
/***************************************************************************** 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: 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)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 }
/***************************************************************************** Function: void DHCPServerTask(NET_CONFIG* pConfig) Summary: Performs periodic DHCP server tasks. Description: This function performs any periodic tasks requied by the DHCP server module, such as processing DHCP requests and distributing IP addresses. Precondition: None Parameters: pConfig - interface Returns: None ***************************************************************************/ void DHCPServerTask(NET_CONFIG* pConfig) { uint8_t i; uint8_t Option, Len; BOOTP_HEADER BOOTPHeader; uint32_t dw; bool bAccept; int netIx; UDP_SOCKET s; #if defined(TCPIP_STACK_USE_DHCP_CLIENT) // Make sure we don't clobber anyone else's DHCP server if(DHCPIsServerDetected(pConfig)) return; #endif netIx = _TCPIPStackNetIx(pConfig); if(!bDHCPServerEnabled[netIx]) return; s = MySocket[netIx]; switch(smDHCPServer[netIx]) { case DHCP_OPEN_SOCKET: // Obtain a UDP socket to listen/transmit on MySocket[netIx] = UDPOpen(0,UDP_OPEN_SERVER,DHCP_SERVER_PORT, DHCP_CLIENT_PORT); if(MySocket[netIx] == INVALID_UDP_SOCKET) break; UDPSocketSetNet(MySocket[netIx], pConfig); // Decide which address to lease out // Note that this needs to be changed if we are to // support more than one lease DHCPNextLease[netIx].Val = (pConfig->MyIPAddr.Val & pConfig->MyMask.Val) + 0x02000000; if(DHCPNextLease[netIx].v[3] == 255u) DHCPNextLease[netIx].v[3] += 0x03; if(DHCPNextLease[netIx].v[3] == 0u) DHCPNextLease[netIx].v[3] += 0x02; smDHCPServer[netIx]++; case DHCP_LISTEN: // Check to see if a valid DHCP packet has arrived if(UDPIsGetReady(s) < 241u) break; // Retrieve the BOOTP header UDPGetArray(s, (uint8_t*)&BOOTPHeader, sizeof(BOOTPHeader)); bAccept = (BOOTPHeader.ClientIP.Val == DHCPNextLease[netIx].Val) || (BOOTPHeader.ClientIP.Val == 0x00000000u); // Validate first three fields if(BOOTPHeader.MessageType != 1u) break; if(BOOTPHeader.HardwareType != 1u) break; if(BOOTPHeader.HardwareLen != 6u) break; // Throw away 10 unused bytes of hardware address, // server host name, and boot file name -- unsupported/not needed. for(i = 0; i < 64+128+(16-sizeof(MAC_ADDR)); i++) UDPGet(s, &Option); // Obtain Magic Cookie and verify UDPGetArray(s, (uint8_t*)&dw, sizeof(uint32_t)); if(dw != 0x63538263ul) break; // Obtain options while(1) { // Get option type if(!UDPGet(s, &Option)) break; if(Option == DHCP_END_OPTION) break; // Get option length UDPGet(s, &Len); // Process option switch(Option) { case DHCP_MESSAGE_TYPE: UDPGet(s, &i); switch(i) { case DHCP_DISCOVER_MESSAGE: DHCPReplyToDiscovery(&BOOTPHeader, netIx); break; case DHCP_REQUEST_MESSAGE: // NOTE : This #if section was missing from 5.36 #if defined(TCPIP_STACK_USE_ZEROCONF_LINK_LOCAL) if ( (BOOTPHeader.ClientIP.Val == 0x00000000u) && (bLeaseAvailable[netIx] == false) ) { // Lease available only to the current lease holder break; } #endif DHCPReplyToRequest(&BOOTPHeader, bAccept, netIx); // NOTE : This #if section was missing from 5.36 #if defined(TCPIP_STACK_USE_ZEROCONF_LINK_LOCAL) bLeaseAvailable[netIx] = false; #endif break; // Need to handle these if supporting more than one DHCP lease case DHCP_RELEASE_MESSAGE: case DHCP_DECLINE_MESSAGE: break; } break; case DHCP_PARAM_REQUEST_IP_ADDRESS: if(Len == 4u) { // Get the requested IP address and see if it is the one we have on offer. UDPGetArray(s, (uint8_t*)&dw, 4); Len -= 4; bAccept = (dw == DHCPNextLease[netIx].Val); } break; case DHCP_END_OPTION: UDPDiscard(s); return; } // Remove any unprocessed bytes that we don't care about while(Len--) { UDPGet(s, &i); } } UDPDiscard(s); break; } }
/********************************************************************* * Function: void ANNOUNCE_Task(void) * * Summary: Announce callback task. * * PreCondition: Stack is initialized() * * Input: None * * Output: None * * Side Effects: None * * Overview: Recurring task used to listen for Discovery * messages on the specified ANNOUNCE_PORT. These * messages can be sent using the TCP/IP * Discoverer tool. If one is received, this * function will transmit a reply. * * Note: A UDP socket must be available before this * function is called. It is freed at the end of * the function. UDP_MAX_SOCKETS may need to be * increased if other modules use UDP sockets. ********************************************************************/ void ANNOUNCE_Task(NET_CONFIG * pNetIf) { static enum { DISCOVERY_HOME = 0, DISCOVERY_LISTEN, DISCOVERY_REQUEST_RECEIVED, DISCOVERY_DISABLED } DiscoverySM[TCPIP_NETWORK_INTERFACES] = {DISCOVERY_HOME}; static UDP_SOCKET MySocket[TCPIP_NETWORK_INTERFACES]; uint8_t i; int netIx; UDP_SOCKET s; if(!pNetIf) { return; } else { netIx = _TCPIPStackNetIx(pNetIf); } s = MySocket[netIx]; switch(DiscoverySM[netIx]) { case DISCOVERY_HOME: // Open a UDP socket for inbound and outbound transmission // Since we expect to only receive broadcast packets and // only send unicast packets directly to the node we last // received from, the remote NodeInfo parameter can be anything MySocket[netIx] = UDPOpen(0,UDP_OPEN_SERVER,ANNOUNCE_PORT, ANNOUNCE_PORT); if(MySocket[netIx] == INVALID_UDP_SOCKET) { return; } else { DiscoverySM[netIx]++; UDPSocketSetNet(MySocket[netIx], pNetIf); } break; case DISCOVERY_LISTEN: // Do nothing if no data is waiting if(!UDPIsGetReady(s)) return; // See if this is a discovery query or reply UDPGet(s, &i); UDPDiscard(s); if(i != 'D') return; // We received a discovery request, reply when we can DiscoverySM[netIx]++; // Change the destination to the unicast address of the last received packet TCPIP_IPV4_SetDestAddress(UDPSocketDcpt[s].pTxPkt,remoteNode.IPAddr.Val); memcpy((void*)&UDPSocketDcpt[s].pTxPkt->remoteMACAddr, (const void*)&remoteNode.MACAddr, sizeof(MAC_ADDR)); // No break needed. If we get down here, we are now ready for the DISCOVERY_REQUEST_RECEIVED state case DISCOVERY_REQUEST_RECEIVED: ANNOUNCE_Notify (pNetIf, 0, NULL); // Listen for other discovery requests DiscoverySM[netIx] = DISCOVERY_LISTEN; break; case DISCOVERY_DISABLED: break; } }
void ANNOUNCE_Send(void) { UDP_SOCKET announceSocket; int netIx; uint16_t dataLen; uint16_t minimumDataLen; uint16_t txLen; bool truncated; NET_CONFIG * pNetIf; ANNOUNCE_LIST_NODE * node = (ANNOUNCE_LIST_NODE *)announceEvents.head; ANNOUNCE_FIELD_PAYLOAD payloadType; uint16_t terminatorLen = strlen ((const char *)announceFieldTerminator); #if defined (TCPIP_STACK_USE_IPV6) IPV6_ADDR_STRUCT * addressPointer; #endif while (node != NULL) { pNetIf = (NET_CONFIG *)node->handle; netIx = TCPIP_STACK_NetIx (pNetIf); truncated = false; dataLen = ((terminatorLen + 1) * 4) + sizeof (IPV4_ADDR) + sizeof (MAC_ADDR); dataLen += strlen(TCPIP_HOSTS_CONFIGURATION[netIx].interface); dataLen += strlen((char *)pNetIf->NetBIOSName); minimumDataLen = dataLen + 1 + terminatorLen; if(!MACIsLinked(_TCPIPStackNetToMac(pNetIf))) // Check for link before blindly opening and transmitting (similar to DHCP case) { return; } announceSocket = UDPOpenClient(IP_ADDRESS_TYPE_IPV4, ANNOUNCE_PORT, 0); if (announceSocket == INVALID_UDP_SOCKET) { return; } UDPSocketSetNet (announceSocket, pNetIf); #if defined (TCPIP_STACK_USE_IPV6) addressPointer = (IPV6_ADDR_STRUCT *)ipv6Config[netIx].listIpv6UnicastAddresses.head; while(addressPointer != NULL) { dataLen += sizeof (IPV6_ADDR) + 1 + terminatorLen; addressPointer = addressPointer->next; } addressPointer = (IPV6_ADDR_STRUCT *)ipv6Config[netIx].listIpv6MulticastAddresses.head; while(addressPointer != NULL) { dataLen += sizeof (IPV6_ADDR) + 1 + terminatorLen; addressPointer = addressPointer->next; } #endif if (dataLen > ANNOUNCE_MAX_PAYLOAD) { dataLen = ANNOUNCE_MAX_PAYLOAD; } if ((txLen = UDPIsTxPutReady(announceSocket, dataLen)) < dataLen) { truncated = true; if ((txLen = UDPIsTxPutReady(announceSocket, minimumDataLen)) < minimumDataLen) { UDPClose (announceSocket); return; } } // Put Mac Address payloadType = ANNOUNCE_FIELD_MAC_ADDR; UDPPut (announceSocket, payloadType); UDPPutArray(announceSocket, (const uint8_t *)&pNetIf->MyMACAddr, sizeof (MAC_ADDR)); UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen); if (truncated) { payloadType = ANNOUNCE_FIELD_TRUNCATED; UDPPut (announceSocket, payloadType); UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen); } // Put Mac Type payloadType = ANNOUNCE_FIELD_MAC_TYPE; UDPPut (announceSocket, payloadType); UDPPutArray(announceSocket, (const uint8_t *)TCPIP_HOSTS_CONFIGURATION[netIx].interface, strlen ((const char *)TCPIP_HOSTS_CONFIGURATION[netIx].interface)); UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen); // Put Host Name payloadType = ANNOUNCE_FIELD_HOST_NAME; UDPPut (announceSocket, payloadType); UDPPutArray(announceSocket, (const uint8_t *)&pNetIf->NetBIOSName, strlen((char*)pNetIf->NetBIOSName)); UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen); // Put IPv4 Address payloadType = ANNOUNCE_FIELD_IPV4_ADDRESS; UDPPut (announceSocket, payloadType); UDPPutArray(announceSocket, (const uint8_t *)&pNetIf->MyIPAddr, sizeof (IP_ADDR)); UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen); #if defined (TCPIP_STACK_USE_IPV6) // Put IPv6 unicast addresses minimumDataLen = sizeof (IPV6_ADDR) + 1 + terminatorLen; addressPointer = (IPV6_ADDR_STRUCT *)ipv6Config[netIx].listIpv6UnicastAddresses.head; payloadType = ANNOUNCE_FIELD_IPV6_UNICAST; while(addressPointer != NULL && (UDPIsTxPutReady(announceSocket, minimumDataLen) >= minimumDataLen)) { UDPPut (announceSocket, payloadType); UDPPutArray(announceSocket, (const uint8_t *)&addressPointer->address, sizeof (IPV6_ADDR)); UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen); addressPointer = addressPointer->next; } // Put IPv6 multicast listeners addressPointer = (IPV6_ADDR_STRUCT *)ipv6Config[netIx].listIpv6MulticastAddresses.head; payloadType = ANNOUNCE_FIELD_IPV6_MULTICAST; while(addressPointer != NULL && (UDPIsTxPutReady(announceSocket, minimumDataLen) >= minimumDataLen)) { UDPPut (announceSocket, payloadType); UDPPutArray(announceSocket, (const uint8_t *)&addressPointer->address, sizeof (IPV6_ADDR)); UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen); addressPointer = addressPointer->next; } #endif UDPFlush (announceSocket); UDPClose (announceSocket); SingleListRemoveHead(&announceEvents); TCPIP_HEAP_Free (announceMemH, node); node = (ANNOUNCE_LIST_NODE *)announceEvents.head; if (node == NULL) { announceEventPending = false; } } }
/***************************************************************************** Function: int connect( SOCKET s, struct sockaddr* name, int namelen ) Summary: This function connects to the peer communications end point. Description: The connect function assigns the address of the peer communications endpoint. For stream sockets, connection is established between the endpoints. For datagram sockets, an address filter is established between the endpoints until changed with another connect() function. Precondition: socket function should be called. Parameters: s - Socket descriptor returned from a previous call to socket. name - pointer to the sockaddr structure containing the peer address and port number. namelen - length of the sockaddr structure. Returns: If the connect() function succeeds, it returns 0. Otherwise, the value SOCKET_ERROR is returned to indicate an error condition (and errno set accordingly). For stream based socket, if the connection is not established yet, connect returns SOCKET_ERROR and errno = EINPROGRESS. Remarks: None. ***************************************************************************/ int connect( SOCKET s, struct sockaddr* name, int namelen ) { struct BSDSocket *socket; struct sockaddr_in *addr; uint32_t remoteIP; uint16_t remotePort; uint16_t localPort; IPV4_ADDR localAddr; if( s >= BSD_SOCKET_COUNT ) { errno = EBADF; return SOCKET_ERROR; } socket = &BSDSocketArray[s]; if( socket->bsdState < SKT_CREATED ) { errno = EBADF; return SOCKET_ERROR; } if( (unsigned int)namelen < sizeof(struct sockaddr_in)) { errno = EFAULT; return SOCKET_ERROR; } addr = (struct sockaddr_in *)name; remotePort = addr->sin_port; remoteIP = addr->sin_addr.S_un.S_addr; if( remoteIP == 0u || remotePort == 0u ) { errno = EINVAL; return SOCKET_ERROR; } if( socket->SocketType == SOCK_STREAM ) { switch(socket->bsdState) { case SKT_EST: return 0; // already established case SKT_IN_PROGRESS: if(HandlePossibleTCPDisconnection(s)) { errno = ECONNREFUSED; return SOCKET_ERROR; } if(!TCPIsConnected(socket->SocketID)) { errno = EINPROGRESS; return SOCKET_ERROR; } socket->bsdState = SKT_EST; return 0; //success case SKT_CREATED: case SKT_BOUND: socket->SocketID = TCPOpenClient(IP_ADDRESS_TYPE_IPV4, remotePort, (IP_MULTI_ADDRESS*)&remoteIP); if(socket->SocketID == INVALID_SOCKET) { errno = ENOBUFS; return SOCKET_ERROR; } // Clear the first reset flag TCPWasReset(socket->SocketID); localAddr.Val = socket->localIP; TCPSocketSetNet(socket->SocketID, _TCPIPStackIpAddToNet(&localAddr, true)); socket->isServer = false; socket->bsdState = SKT_IN_PROGRESS; errno = EINPROGRESS; return SOCKET_ERROR; default: errno = ECONNRESET; return SOCKET_ERROR; } } else { // If not explicitly bound to a local port, implicitly do the binding if(socket->bsdState == SKT_CREATED) { IPV4_ADDR addrAny = {IP_ADDR_ANY}; localPort = gAutoPortNumber++; if(gAutoPortNumber > 5000u) // reset the port numbers gAutoPortNumber = 1024; socket->SocketID = UDPOpenServer(IP_ADDRESS_TYPE_IPV4, localPort, 0); if(socket->SocketID == INVALID_UDP_SOCKET) { errno = ENOBUFS; return SOCKET_ERROR; } UDPSocketSetNet(socket->SocketID, _TCPIPStackIpAddToNet(&addrAny, true)); socket->bsdState = SKT_BOUND; } if(socket->bsdState != SKT_BOUND) { errno = EINVAL; return SOCKET_ERROR; } // UDP: remote port is used as a filter. Need to call connect when using // send/recv calls. No need to call 'connect' if using sendto/recvfrom // calls. socket->remotePort = remotePort; socket->remoteIP = remoteIP; return 0; //success } errno = EINVAL; return SOCKET_ERROR; }
/********************************************************************* * Function: void NBNSTask(NET_CONFIG* pConfig) * * PreCondition: None * * Input: pConfig - interface * * Output: None * * Side Effects: None * * Overview: Sends responses to NetBIOS name requests * * Note: None ********************************************************************/ void NBNSTask(NET_CONFIG* pConfig) { uint8_t i; TCPIP_UINT16_VAL Type, Class; NBNS_HEADER NBNSHeader; uint8_t NameString[16]; int netIx; UDP_SOCKET s; netIx = _TCPIPStackNetIx(pConfig); s = MySocket[netIx]; switch(smNBNS[netIx]) { case NBNS_HOME: smNBNS[netIx]++; break; case NBNS_OPEN_SOCKET: MySocket[netIx] = UDPOpen(0,UDP_OPEN_SERVER,NBNS_PORT,NBNS_PORT); if(MySocket[netIx] == INVALID_UDP_SOCKET) break; UDPSocketSetNet(MySocket[netIx], pConfig); smNBNS[netIx]++; case NBNS_LISTEN: if(!UDPIsGetReady(s)) { break; } // Respond only to name requests sent to us from nodes on the same subnet // This prevents us from sending out the wrong IP address information if // we haven't gotten a DHCP lease yet. if((remoteNode.IPAddr.Val & pConfig->MyMask.Val) != (pConfig->MyIPAddr.Val & pConfig->MyMask.Val)) { UDPDiscard(s); break; } // Retrieve the NBNS header and de-big-endian it UDPGet(s, &NBNSHeader.TransactionID.v[1]); UDPGet(s, &NBNSHeader.TransactionID.v[0]); UDPGet(s, &NBNSHeader.Flags.v[1]); UDPGet(s, &NBNSHeader.Flags.v[0]); UDPGet(s, &NBNSHeader.Questions.v[1]); UDPGet(s, &NBNSHeader.Questions.v[0]); UDPGet(s, &NBNSHeader.Answers.v[1]); UDPGet(s, &NBNSHeader.Answers.v[0]); UDPGet(s, &NBNSHeader.AuthoritativeRecords.v[1]); UDPGet(s, &NBNSHeader.AuthoritativeRecords.v[0]); UDPGet(s, &NBNSHeader.AdditionalRecords.v[1]); UDPGet(s, &NBNSHeader.AdditionalRecords.v[0]); // Remove all questions while(NBNSHeader.Questions.Val--) { NBNSGetName(s, NameString); UDPGet(s, &i); // <??> Trailing character on string UDPGet(s, &Type.v[1]); // Question type UDPGet(s, &Type.v[0]); UDPGet(s, &Class.v[1]); // Question class UDPGet(s, &Class.v[0]); if(Type.Val == 0x0020u && Class.Val == 0x0001u && memcmp((void*)NameString, (void*)pConfig->NetBIOSName, sizeof(pConfig->NetBIOSName)) == 0) { if(UDPIsTxPutReady(s, 64)) { NBNSHeader.Flags.Val = 0x8400; UDPPut(s, NBNSHeader.TransactionID.v[1]); UDPPut(s, NBNSHeader.TransactionID.v[0]); UDPPut(s, NBNSHeader.Flags.v[1]); UDPPut(s, NBNSHeader.Flags.v[0]); UDPPut(s, 0x00); // 0x0000 Questions UDPPut(s, 0x00); UDPPut(s, 0x00); // 0x0001 Answers UDPPut(s, 0x01); UDPPut(s, 0x00); // 0x0000 Athoritative records UDPPut(s, 0x00); UDPPut(s, 0x00); // 0x0000 Additional records UDPPut(s, 0x00); NBNSPutName(s, pConfig->NetBIOSName); UDPPut(s, 0x00); // 0x0020 Type: NetBIOS UDPPut(s, 0x20); UDPPut(s, 0x00); // 0x0001 Class: Internet UDPPut(s, 0x01); UDPPut(s, 0x00); // 0x00000000 Time To Live UDPPut(s, 0x00); UDPPut(s, 0x00); UDPPut(s, 0x00); UDPPut(s, 0x00); // 0x0006 Data length UDPPut(s, 0x06); UDPPut(s, 0x60); // 0x6000 Flags: H-node, Unique UDPPut(s, 0x00); UDPPut(s, pConfig->MyIPAddr.v[0]); // Put out IP address UDPPut(s, pConfig->MyIPAddr.v[1]); UDPPut(s, pConfig->MyIPAddr.v[2]); UDPPut(s, pConfig->MyIPAddr.v[3]); // Change the destination address to the unicast address of the last received packet TCPIP_IPV4_SetDestAddress(UDPSocketDcpt[s].pTxPkt,remoteNode.IPAddr.Val); memcpy((void*)&UDPSocketDcpt[s].pTxPkt->remoteMACAddr, (const void*)&remoteNode.MACAddr, sizeof(remoteNode.MACAddr)); UDPFlush(s); } } } UDPDiscard(s); break; } }
/***************************************************************************** Function: void UDPPerformanceTask(NET_CONFIG* pConfig) Summary: Tests the transmit performance of the UDP module. Description: This function tests the transmit performance of the UDP module. At boot, this module will transmit 1024 large UDP broadcast packets of 1024 bytes each. Using a packet sniffer, one can determine how long this process takes and calculate the transmit rate of the stack. This function tests true UDP performance in that it will open a socket, transmit one packet, and close the socket for each loop. After this initial transmission, the module can be re-enabled by holding button 3. This function is particularly useful after development to determine the impact of your application code on the stack's performance. A before and after comparison will indicate if your application is unacceptably blocking the processor or taking too long to execute. Precondition: UDP is initialized. Parameters: pConfig - network to run on Returns: None ***************************************************************************/ void UDPPerformanceTask(NET_CONFIG* pConfig) { UDP_SOCKET MySocket; NODE_INFO Remote; uint16_t wTemp; static uint32_t dwCounter = 1; if((BUTTON3_IO) && (dwCounter > 1024u)) return; // Suppress transmissions if we don't have an Ethernet link so our counter starts correctly at 0x00000001 if(!MACIsLinked(_TCPIPStackNetToMac(pConfig))) return; #if defined(TCPIP_STACK_USE_DHCP_CLIENT) && defined(DELAY_UDP_PERFORMANCE_TEST) { static SYS_TICK dwTimer = 0; // Wait until DHCP module is finished if(!DHCPIsBound(pConfig)) { dwTimer = SYS_TICK_Get(); return; } // Wait an additional half second after DHCP is finished to let the announce module and any other stack state machines to reach normal operation if(SYS_TICK_Get() - dwTimer < SYS_TICK_TicksPerSecondGet()/2) return; } #endif // Set the socket's destination to be a broadcast over our IP // subnet // Set the MAC destination to be a broadcast memset(&Remote, 0xFF, sizeof(Remote)); // Open a UDP socket for outbound transmission MySocket = UDPOpen((uint32_t)&Remote,UDP_OPEN_NODE_INFO,0,PERFORMANCE_PORT); // Abort operation if no UDP sockets are available // If this ever happens, incrementing UDP_MAX_SOCKETS in // udp_config.h may help (at the expense of more global memory // resources). if(MySocket == INVALID_UDP_SOCKET) return; UDPSocketSetNet(MySocket, pConfig); // Make certain the socket can be written to if(!UDPIsPutReady(MySocket)) { UDPClose(MySocket); return; } // Put counter value into first 4 bytes of the packet UDPPutArray(MySocket, (uint8_t*)&dwCounter, sizeof(dwCounter)); dwCounter++; wTemp = UDPPutArray(MySocket, (const uint8_t*) "The quick brown fox tried to jump over the yellow dog. Unfortunately, the yellow dog stood up while the fox was in mid-jump. As a result, the two collided. Then, the dog, being the omnivore that it is, ate the quick brown fox. This line is 256 bytes.\r\n" "The quick brown fox tried to jump over the yellow dog. Unfortunately, the yellow dog stood up while the fox was in mid-jump. As a result, the two collided. Then, the dog, being the omnivore that it is, ate the quick brown fox. This line is 256 bytes.\r\n" "The quick brown fox tried to jump over the yellow dog. Unfortunately, the yellow dog stood up while the fox was in mid-jump. As a result, the two collided. Then, the dog, being the omnivore that it is, ate the quick brown fox. This line is 256 bytes.\r\n" "The quick brown fox tried to jump over the yellow dog. Unfortunately, the yellow dog stood up while the fox was in mid-jump. As a result, the two collided. Then, the dog, being the omnivore that it is, ate the quick brown fox. This line is 252b. \r\n", 1020); // Send the packet UDPFlush(MySocket); // Close the socket so it can be used by other modules UDPClose(MySocket); }
/********************************************************************* * Function: void DNSServerTask(NET_CONFIG* pNet) * * PreCondition: None * * Input: None * * Output: None * * Side Effects: None * * Overview: Sends dummy responses that point to ourself for DNS requests * * Note: None ********************************************************************/ void DNSServerTask(NET_CONFIG* pNet) { static UDP_SOCKET MySocket = INVALID_UDP_SOCKET; static struct { uint16_t wTransactionID; uint16_t wFlags; uint16_t wQuestions; uint16_t wAnswerRRs; uint16_t wAuthorityRRs; uint16_t wAdditionalRRs; } DNSHeader; switch(dnssState) { case DNSS_STATE_START: // Create a socket to listen on if this is the first time calling this function if(MySocket == INVALID_UDP_SOCKET) { MySocket = UDPOpen(0,UDP_OPEN_SERVER,DNS_PORT,0); if(MySocket == INVALID_UDP_SOCKET) break; } UDPSocketSetNet(MySocket, pNet); dnssState = DNSS_STATE_WAIT_REQUEST; break; case DNSS_STATE_WAIT_REQUEST: // See if a DNS query packet has arrived if(UDPIsGetReady(MySocket) < sizeof(DNSHeader)) break; // Read DNS header UDPGetArray(MySocket, (uint8_t*)&DNSHeader, sizeof(DNSHeader)); // Ignore this packet if it isn't a query if((DNSHeader.wFlags & 0x8000) == 0x8000u) break; // Ignore this packet if there are no questions in it if(DNSHeader.wQuestions == 0u) break; dnssState = DNSS_STATE_PUT_REQUEST; break; case DNSS_STATE_PUT_REQUEST: // check that we can transmit a DNS response packet if(!UDPIsPutReady(MySocket)) { break; } // Write DNS response packet UDPPutArray(MySocket, (uint8_t*)&DNSHeader.wTransactionID, 2); // 2 byte Transaction ID if(DNSHeader.wFlags & 0x0100) UDPPut(MySocket, 0x81); // Message is a response with recursion desired else UDPPut(MySocket, 0x80); // Message is a response without recursion desired flag set UDPPut(MySocket, 0x80); // Recursion available UDPPut(MySocket, 0x00); // 0x0000 Questions UDPPut(MySocket, 0x00); UDPPut(MySocket, 0x00); // 0x0001 Answers RRs UDPPut(MySocket, 0x01); UDPPut(MySocket, 0x00); // 0x0000 Authority RRs UDPPut(MySocket, 0x00); UDPPut(MySocket, 0x00); // 0x0000 Additional RRs UDPPut(MySocket, 0x00); DNSCopyRXNameToTX(MySocket, pNet); // Copy hostname of first question over to TX packet UDPPut(MySocket, 0x00); // Type A Host address UDPPut(MySocket, 0x01); UDPPut(MySocket, 0x00); // Class INternet UDPPut(MySocket, 0x01); UDPPut(MySocket, 0x00); // Time to Live 10 seconds UDPPut(MySocket, 0x00); UDPPut(MySocket, 0x00); UDPPut(MySocket, 0x0A); UDPPut(MySocket, 0x00); // Data Length 4 bytes UDPPut(MySocket, 0x04); UDPPutArray(MySocket, (uint8_t*)&pNet->MyIPAddr.Val, 4); // Our IP address UDPFlush(MySocket); dnssState = DNSS_STATE_DONE; break; case DNSS_STATE_DONE: break; } }