自学教程：C++ FreeRTOS_htons函数代码示例

static uint16_t prvGetPrivatePortNumber( void ){static uint16_t usNextPortToUse = socketAUTO_PORT_ALLOCATION_START_NUMBER - 1;uint16_t usReturn;	/* Assign the next port in the range. */	taskENTER_CRITICAL();	{		usNextPortToUse++;		/* Has it overflowed? */		if( usNextPortToUse == 0U )		{			/* Don't go right back to the start of the dynamic/private port			range numbers as any persistent sockets are likely to have been			create first so the early port numbers may still be in use. */			usNextPortToUse = socketAUTO_PORT_ALLOCATION_RESET_NUMBER;		}		usReturn = FreeRTOS_htons( usNextPortToUse );	}	taskEXIT_CRITICAL();	return usReturn;} /* Tested */

static Socket_t prvOpenTCPServerSocket( uint16_t usPort ){struct freertos_sockaddr xBindAddress;Socket_t xSocket;static const TickType_t xReceiveTimeOut = portMAX_DELAY;const BaseType_t xBacklog = 20;BaseType_t xReuseSocket = pdTRUE;	/* Attempt to open the socket. */	xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_STREAM, FREERTOS_IPPROTO_TCP );	configASSERT( xSocket != FREERTOS_INVALID_SOCKET );	/* Set a time out so accept() will just wait for a connection. */	FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) );	/* Only one connection will be used at a time, so re-use the listening	socket as the connected socket.  See SimpleTCPEchoServer.c for an example	that accepts multiple connections. */	FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_REUSE_LISTEN_SOCKET, &xReuseSocket, sizeof( xReuseSocket ) );	/* NOTE:  The CLI is a low bandwidth interface (typing characters is slow),	so the TCP window properties are left at their default.  See	SimpleTCPEchoServer.c for an example of a higher throughput TCP server that	uses are larger RX and TX buffer. */	/* Bind the socket to the port that the client task will send to, then	listen for incoming connections. */	xBindAddress.sin_port = usPort;	xBindAddress.sin_port = FreeRTOS_htons( xBindAddress.sin_port );	FreeRTOS_bind( xSocket, &xBindAddress, sizeof( xBindAddress ) );	FreeRTOS_listen( xSocket, xBacklog );	return xSocket;}

ssize_t nabto_read( nabto_socket_t socket,                    uint8_t*       buf,                    size_t         len,                    uint32_t*      addr,                    uint16_t*      port ){    int res;    struct freertos_sockaddr xAddress;    socklen_t xAddresslen = sizeof(xAddress);    memset( &xAddress, 0, sizeof( xAddress ) );    res = FreeRTOS_recvfrom( socket, buf, ( int ) len , 0, &xAddress, &xAddresslen );    if( res > 0 )    {        *addr = FreeRTOS_htonl( xAddress.sin_addr );        *port = FreeRTOS_htons( xAddress.sin_port );    }    else    {        res = 0;    }    return res;} 

enum pubnub_res pbpal_resolv_and_connect(pubnub_t *pb){    struct freertos_sockaddr addr;    PUBNUB_ASSERT(pb_valid_ctx_ptr(pb));    PUBNUB_ASSERT_OPT((pb->state == PBS_IDLE) || (pb->state == PBS_WAIT_DNS));        addr.sin_port = FreeRTOS_htons(HTTP_PORT);    addr.sin_addr = FreeRTOS_gethostbyname(PUBNUB_ORIGIN_SETTABLE ? pb->origin : PUBNUB_ORIGIN);    if (addr.sin_addr == 0) {        return PNR_CONNECT_FAILED;    }    pb->pal.socket = FreeRTOS_socket(FREERTOS_AF_INET, FREERTOS_SOCK_STREAM, FREERTOS_IPPROTO_TCP);    if (pb->pal.socket == SOCKET_INVALID) {        return PNR_CONNECT_FAILED;    }    if (FreeRTOS_connect(pb->pal.socket, &addr, sizeof addr) != 0) {        FreeRTOS_closesocket(pb->pal.socket);        pb->pal.socket = SOCKET_INVALID;        return PNR_CONNECT_FAILED;    }    {        TickType_t tmval = pdMS_TO_TICKS(pb->transaction_timeout_ms);        FreeRTOS_setsockopt(pb->pal.socket, 0, FREERTOS_SO_RCVTIMEO, &tmval, sizeof tmval);    }    return PNR_OK;}

static void prvSimpleClientTask( void *pvParameters ){xSocket_t xClientSocket;struct freertos_sockaddr xDestinationAddress;uint8_t cString[ 50 ];portBASE_TYPE lReturned;uint32_t ulCount = 0UL, ulIPAddress;const uint32_t ulLoopsPerSocket = 10UL;const portTickType x150ms = 150UL / portTICK_RATE_MS;	/* Remove compiler warning about unused parameters. */	( void ) pvParameters;	/* It is assumed that this task is not created until the network is up,	so the IP address can be obtained immediately.  store the IP address being	used in ulIPAddress.  This is done so the socket can send to a different	port on the same IP address. */	FreeRTOS_GetAddressConfiguration( &ulIPAddress, NULL, NULL, NULL );	/* This test sends to itself, so data sent from here is received by a server	socket on the same IP address.  Setup the freertos_sockaddr structure with	this nodes IP address, and the port number being sent to.  The strange	casting is to try and remove compiler warnings on 32 bit machines. */	xDestinationAddress.sin_addr = ulIPAddress;	xDestinationAddress.sin_port = ( uint16_t ) ( ( uint32_t ) pvParameters ) & 0xffffUL;	xDestinationAddress.sin_port = FreeRTOS_htons( xDestinationAddress.sin_port );	for( ;; )	{		/* Create the socket. */		xClientSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );		configASSERT( xClientSocket != FREERTOS_INVALID_SOCKET );		/* The count is used to differentiate between different messages sent to		the server, and to break out of the do while loop below. */		ulCount = 0UL;		do		{			/* Create the string that is sent to the server. */			sprintf( ( char * ) cString, "Server received (not zero copy): Message number %lu/r/n", ulCount );			/* Send the string to the socket.  ulFlags is set to 0, so the zero			copy option is not selected.  That means the data from cString[] is			copied into a network buffer inside FreeRTOS_sendto(), and cString[]			can be reused as soon as FreeRTOS_sendto() has returned. */			lReturned = FreeRTOS_sendto( xClientSocket, ( void * ) cString, strlen( ( const char * ) cString ), 0, &xDestinationAddress, sizeof( xDestinationAddress ) );			ulCount++;		} while( ( lReturned != FREERTOS_SOCKET_ERROR ) && ( ulCount < ulLoopsPerSocket ) );		FreeRTOS_closesocket( xClientSocket );		/* A short delay to prevent the messages printed by the server task		scrolling off the screen too quickly, and to prevent reduce the network		loading. */		vTaskDelay( x150ms );	}}

bool nabto_init_socket( uint32_t localAddr, uint16_t* localPort, nabto_socket_t* socketDescriptor ){int to = 0;struct freertos_sockaddr xAddress, *pxAddressToUse;bool bReturn = true;    if (MAX_SOCKETS <= nSockets)    {        bReturn = false;    }    else    {        *socketDescriptor = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );        if( NULL == *socketDescriptor )        {            bReturn = false;        }        else        {            memset( &xAddress, 0, sizeof( xAddress ) );            xAddress.sin_addr = FreeRTOS_htonl( localAddr );            xAddress.sin_port = FreeRTOS_htons( *localPort );            pxAddressToUse = &xAddress;            if( 0 > FreeRTOS_bind(*socketDescriptor, pxAddressToUse, sizeof( xAddress ) ) )            {                FreeRTOS_closesocket( *socketDescriptor );                bReturn = false;            }            else            {                /* Set receive time out to 0.  Timeouts are performed using a                select() call. */                FreeRTOS_setsockopt( *socketDescriptor, 0, FREERTOS_SO_RCVTIMEO, &to, sizeof( to ) );                activeSockets[nSockets++] = *socketDescriptor;            }            *localPort = FreeRTOS_htons( xAddress.sin_port );        }    }    return bReturn;}

void vStartNTPTask( uint16_t usTaskStackSize, UBaseType_t uxTaskPriority ){	/* The only public function in this module: start a task to contact	some NTP server. */	if( xNTPTaskhandle != NULL )	{		switch( xStatus )		{		case EStatusPause:			xStatus = EStatusAsking;			vSignalTask();			break;		case EStatusLookup:			FreeRTOS_printf( ( "NTP looking up server/n" ) );			break;		case EStatusAsking:			FreeRTOS_printf( ( "NTP still asking/n" ) );			break;		case EStatusFailed:			FreeRTOS_printf( ( "NTP failed somehow/n" ) );			ulIPAddressFound = 0ul;			xStatus = EStatusLookup;			vSignalTask();			break;		}	}	else	{		xUDPSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );		if( xUDPSocket != NULL )		{		struct freertos_sockaddr xAddress;		#if( ipconfigUSE_CALLBACKS != 0 )			BaseType_t xReceiveTimeOut = pdMS_TO_TICKS( 0 );		#else			BaseType_t xReceiveTimeOut = pdMS_TO_TICKS( 5000 );		#endif			xAddress.sin_addr = 0ul;			xAddress.sin_port = FreeRTOS_htons( NTP_PORT );			FreeRTOS_bind( xUDPSocket, &xAddress, sizeof( xAddress ) );			FreeRTOS_setsockopt( xUDPSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) );			xTaskCreate( 	prvNTPTask,						/* The function that implements the task. */							( const char * ) "NTP client",	/* Just a text name for the task to aid debugging. */							usTaskStackSize,				/* The stack size is defined in FreeRTOSIPConfig.h. */							NULL,							/* The task parameter, not used in this case. */							uxTaskPriority,					/* The priority assigned to the task is defined in FreeRTOSConfig.h. */							&xNTPTaskhandle );				/* The task handle. */		}		else		{			FreeRTOS_printf( ( "Creating socket failed/n" ) );		}	}}

static void prvMultipleSocketTxTask( void *pvParameters ){uint32_t ulTxValue = 0;struct freertos_sockaddr xDestinationAddress;uint32_t ulIPAddress, ulFirstDestinationPortNumber, xPortNumber;xSocket_t xTxSocket;const TickType_t xShortDelay = 100 / portTICK_RATE_MS, xSendBlockTime = 500 / portTICK_RATE_MS;	srand( ( unsigned int ) &xPortNumber );	/* The first destination port number is passed in as the task parameter.	Other destination port numbers used are consecutive from this. */	ulFirstDestinationPortNumber = ( uint32_t ) pvParameters;	/* Create the socket used to send to the sockets created by the Rx task.	Let the IP stack select a port to bind to. */	xTxSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );	FreeRTOS_bind( xTxSocket, NULL, sizeof( struct freertos_sockaddr ) );	/* The Rx and Tx tasks execute at the same priority so it is possible that	the Tx task will fill up the send queue - set a Tx block time to ensure	flow control is managed if this happens. */	FreeRTOS_setsockopt( xTxSocket, 0, FREERTOS_SO_SNDTIMEO, &xSendBlockTime, sizeof( xSendBlockTime ) );	/* It is assumed that this task is not created until the network is up,	so the IP address can be obtained immediately.  Store the IP address being	used in ulIPAddress.  This is done so the socket can send to a different	port on the same IP address. */	FreeRTOS_GetAddressConfiguration( &ulIPAddress, NULL, NULL, NULL );	/* This test sends to itself, so data sent from here is received by a server	socket on the same IP address.  Setup the freertos_sockaddr structure with	this nodes IP address. */	xDestinationAddress.sin_addr = ulIPAddress;	/* Block for a short time to ensure the task implemented by the	prvMultipleSocketRxTask() function has finished creating the Rx sockets. */	vTaskDelay( xShortDelay );	for( ;; )	{		/* Pseudo randomly select the destination port number from the range of		valid destination port numbers. */		xPortNumber = rand() % selNUMBER_OF_SOCKETS;		xDestinationAddress.sin_port = ( uint16_t ) ( ulFirstDestinationPortNumber + xPortNumber );		xDestinationAddress.sin_port = FreeRTOS_htons( xDestinationAddress.sin_port );		/* Send an incrementing value. */		FreeRTOS_sendto( xTxSocket, &ulTxValue, sizeof( ulTxValue ), 0, &xDestinationAddress, sizeof( xDestinationAddress ) );		ulTxValue++;		/* Delay here because in the Windows simulator the MAC interrupt		simulator delays, so network trafic cannot be received any faster		than this. */		vTaskDelay( configWINDOWS_MAC_INTERRUPT_SIMULATOR_DELAY );	}}

static void prvSimpleZeroCopyServerTask( void *pvParameters ){int32_t lBytes;uint8_t *pucUDPPayloadBuffer;struct freertos_sockaddr xClient, xBindAddress;uint32_t xClientLength = sizeof( xClient ), ulIPAddress;xSocket_t xListeningSocket;	/* Just to prevent compiler warnings. */	( void ) pvParameters;	/* Attempt to open the socket. */	xListeningSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );	configASSERT( xListeningSocket != FREERTOS_INVALID_SOCKET );	/* This test receives data sent from a different port on the same IP address.	Obtain the nodes IP address.  Configure the freertos_sockaddr structure with	the address being bound to.  The strange casting is to try and remove	compiler warnings on 32 bit machines.  Note that this task is only created	after the network is up, so the IP address is valid here. */	FreeRTOS_GetAddressConfiguration( &ulIPAddress, NULL, NULL, NULL );	xBindAddress.sin_addr = ulIPAddress;	xBindAddress.sin_port = ( uint16_t ) ( ( uint32_t ) pvParameters ) & 0xffffUL;	xBindAddress.sin_port = FreeRTOS_htons( xBindAddress.sin_port );	/* Bind the socket to the port that the client task will send to. */	FreeRTOS_bind( xListeningSocket, &xBindAddress, sizeof( xBindAddress ) );	for( ;; )	{		/* Receive data on the socket.  ulFlags has the zero copy bit set		(FREERTOS_ZERO_COPY) indicating to the stack that a reference to the		received data should be passed out to this task using the second		parameter to the FreeRTOS_recvfrom() call.  When this is done the		IP stack is no longer responsible for releasing the buffer, and		the task *must* return the buffer to the stack when it is no longer		needed.  By default the block time is portMAX_DELAY. */		lBytes = FreeRTOS_recvfrom( xListeningSocket, ( void * ) &pucUDPPayloadBuffer, 0, FREERTOS_ZERO_COPY, &xClient, &xClientLength );		/* It is expected to receive one more byte than the string length as		the NULL terminator is also transmitted. */		configASSERT( lBytes == ( ( portBASE_TYPE ) strlen( ( const char * ) pucUDPPayloadBuffer ) + 1 ) );		/* Print the received characters. */		if( lBytes > 0 )		{			vOutputString( ( char * ) pucUDPPayloadBuffer );		}		if( lBytes >= 0 )		{			/* The buffer *must* be freed once it is no longer needed. */			FreeRTOS_ReleaseUDPPayloadBuffer( pucUDPPayloadBuffer );		}	}}

	static void prvReplyDNSMessage( NetworkBufferDescriptor_t *pxNetworkBuffer, BaseType_t lNetLength )	{	UDPPacket_t *pxUDPPacket;	IPHeader_t *pxIPHeader;	UDPHeader_t *pxUDPHeader;		pxUDPPacket = (UDPPacket_t *) pxNetworkBuffer->pucEthernetBuffer;		pxIPHeader = &pxUDPPacket->xIPHeader;		pxUDPHeader = &pxUDPPacket->xUDPHeader;		/* HT: started using defines like 'ipSIZE_OF_xxx' */		pxIPHeader->usLength               = FreeRTOS_htons( lNetLength + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_UDP_HEADER );		/* HT:endian: should not be translated, copying from packet to packet */		pxIPHeader->ulDestinationIPAddress = pxIPHeader->ulSourceIPAddress;		pxIPHeader->ulSourceIPAddress      = *ipLOCAL_IP_ADDRESS_POINTER;		pxIPHeader->ucTimeToLive           = ipconfigUDP_TIME_TO_LIVE;		pxIPHeader->usIdentification       = FreeRTOS_htons( usPacketIdentifier );		usPacketIdentifier++;		pxUDPHeader->usLength              = FreeRTOS_htons( lNetLength + ipSIZE_OF_UDP_HEADER );		vFlip_16( pxUDPPacket->xUDPHeader.usSourcePort, pxUDPPacket->xUDPHeader.usDestinationPort );		#if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )		{			/* calculate the IP header checksum */			pxIPHeader->usHeaderChecksum       = 0x00;			pxIPHeader->usHeaderChecksum       = usGenerateChecksum( 0UL, ( uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ipSIZE_OF_IPv4_HEADER );			pxIPHeader->usHeaderChecksum       = ~FreeRTOS_htons( pxIPHeader->usHeaderChecksum );			/* calculate the UDP checksum for outgoing package */			usGenerateProtocolChecksum( ( uint8_t* ) pxUDPPacket, pdTRUE );		}		#endif		/* Important: tell NIC driver how many bytes must be sent */		pxNetworkBuffer->xDataLength = ( size_t ) ( lNetLength + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_UDP_HEADER + ipSIZE_OF_ETH_HEADER );		/* This function will fill in the eth addresses and send the packet */		vReturnEthernetFrame( pxNetworkBuffer, pdFALSE );	}

static void prvSimpleServerTask( void *pvParameters ){long lBytes;uint8_t cReceivedString[ 60 ];struct freertos_sockaddr xClient, xBindAddress;uint32_t xClientLength = sizeof( xClient );xSocket_t xListeningSocket;	/* Just to prevent compiler warnings. */	( void ) pvParameters;	/* Attempt to open the socket. */	xListeningSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );	configASSERT( xListeningSocket != FREERTOS_INVALID_SOCKET );	/* This test receives data sent from a different port on the same IP	address.  Configure the freertos_sockaddr structure with the address being	bound to.  The strange casting is to try and remove	compiler warnings on 32	bit machines.  Note that this task is only created after the network is up,	so the IP address is valid here. */	xBindAddress.sin_port = ( uint16_t ) ( ( uint32_t ) pvParameters ) & 0xffffUL;	xBindAddress.sin_port = FreeRTOS_htons( xBindAddress.sin_port );	/* Bind the socket to the port that the client task will send to. */	FreeRTOS_bind( xListeningSocket, &xBindAddress, sizeof( xBindAddress ) );	for( ;; )	{		/* Zero out the receive array so there is NULL at the end of the string		when it is printed out. */		memset( cReceivedString, 0x00, sizeof( cReceivedString ) );		/* Receive data on the socket.  ulFlags is zero, so the zero copy option		is not set and the received data is copied into the buffer pointed to by		cReceivedString.  By default the block time is portMAX_DELAY.		xClientLength is not actually used by FreeRTOS_recvfrom(), but is set		appropriately in case future versions do use it. */		lBytes = FreeRTOS_recvfrom( xListeningSocket, cReceivedString, sizeof( cReceivedString ), 0, &xClient, &xClientLength );		/* Print the received characters. */		if( lBytes > 0 )		{			vOutputString( ( char * ) cReceivedString );		}		/* Error check. */		configASSERT( lBytes == ( portBASE_TYPE ) strlen( ( const char * ) cReceivedString ) );	}}

ssize_t nabto_write( nabto_socket_t socket,                     const uint8_t* buf,                     size_t         len,                     uint32_t       addr,                     uint16_t       port ){    int res;    struct freertos_sockaddr xAddress;    memset( &xAddress, 0, sizeof( xAddress ) );    xAddress.sin_addr = FreeRTOS_htonl( addr );    xAddress.sin_port = FreeRTOS_htons( port );    res = FreeRTOS_sendto( socket, buf, ( int )len, 0, ( struct freertos_sockaddr * ) &xAddress, sizeof( xAddress ) );    return res;} 

static void prvConnectionListeningTask( void *pvParameters ){struct freertos_sockaddr xClient, xBindAddress;xSocket_t xListeningSocket, xConnectedSocket;socklen_t xSize = sizeof( xClient );static const TickType_t xReceiveTimeOut = portMAX_DELAY;const BaseType_t xBacklog = 20;xWinProperties_t xWinProps;	/* Just to prevent compiler warnings. */	( void ) pvParameters;	/* Attempt to open the socket. */	xListeningSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_STREAM, FREERTOS_IPPROTO_TCP );	configASSERT( xListeningSocket != FREERTOS_INVALID_SOCKET );	/* Set a time out so accept() will just wait for a connection. */	FreeRTOS_setsockopt( xListeningSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) );	/* Fill in the buffer and window sizes that will be used by the socket. */	xWinProps.lTxBufSize = 6 * ipconfigTCP_MSS;	xWinProps.lTxWinSize = 3;	xWinProps.lRxBufSize = 6 * ipconfigTCP_MSS;	xWinProps.lRxWinSize = 3;	/* Set the window and buffer sizes. */	FreeRTOS_setsockopt( xListeningSocket, 0, FREERTOS_SO_WIN_PROPERTIES, ( void * ) &xWinProps, sizeof( xWinProps ) );	/* Bind the socket to the port that the client task will send to, then	listen for incoming connections. */	xBindAddress.sin_port = tcpechoPORT_NUMBER;	xBindAddress.sin_port = FreeRTOS_htons( xBindAddress.sin_port );	FreeRTOS_bind( xListeningSocket, &xBindAddress, sizeof( xBindAddress ) );	FreeRTOS_listen( xListeningSocket, xBacklog );	/* Create the clients that will connect to the listening socket. */	prvCreateWindowsThreadClients();	for( ;; )	{		/* Wait for a client to connect. */		xConnectedSocket = FreeRTOS_accept( xListeningSocket, &xClient, &xSize );		configASSERT( xConnectedSocket != FREERTOS_INVALID_SOCKET );		/* Spawn a task to handle the connection. */		xTaskCreate( prvServerConnectionInstance, "EchoServer", usUsedStackSize, ( void * ) xConnectedSocket, tskIDLE_PRIORITY, NULL );	}}

static xSocket_t prvOpenUDPServerSocket( uint16_t usPort ){    struct freertos_sockaddr xServer;    xSocket_t xSocket = FREERTOS_INVALID_SOCKET;    xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );    if( xSocket != FREERTOS_INVALID_SOCKET) {        /* Zero out the server structure. */        memset( ( void * ) &xServer, 0x00, sizeof( xServer ) );        /* Set family and port. */        xServer.sin_port = FreeRTOS_htons( usPort );        /* Bind the address to the socket. */        if( FreeRTOS_bind( xSocket, &xServer, sizeof( xServer ) ) == -1 ) {            FreeRTOS_closesocket( xSocket );            xSocket = FREERTOS_INVALID_SOCKET;        }    }    return xSocket;}

static void prvNTPTask( void *pvParameters ){BaseType_t xServerIndex = 3;struct freertos_sockaddr xAddress;#if( ipconfigUSE_CALLBACKS != 0 )	F_TCP_UDP_Handler_t xHandler;#endif /* ipconfigUSE_CALLBACKS != 0 */	xStatus = EStatusLookup;	#if( ipconfigSOCKET_HAS_USER_SEMAPHORE != 0 ) || ( ipconfigUSE_CALLBACKS != 0 )	{		xNTPWakeupSem = xSemaphoreCreateBinary();	}	#endif	#if( ipconfigUSE_CALLBACKS != 0 )	{		memset( &xHandler, '/0', sizeof ( xHandler ) );		xHandler.pOnUdpReceive = xOnUdpReceive;		FreeRTOS_setsockopt( xUDPSocket, 0, FREERTOS_SO_UDP_RECV_HANDLER, ( void * ) &xHandler, sizeof( xHandler ) );	}	#endif	#if( ipconfigSOCKET_HAS_USER_SEMAPHORE != 0 )	{		FreeRTOS_setsockopt( xUDPSocket, 0, FREERTOS_SO_SET_SEMAPHORE, ( void * ) &xNTPWakeupSem, sizeof( xNTPWakeupSem ) );	}	#endif	for( ; ; )	{		switch( xStatus )		{		case EStatusLookup:			if( ( ulIPAddressFound == 0ul ) || ( ulIPAddressFound == ~0ul ) )			{				if( ++xServerIndex == sizeof pcTimeServers / sizeof pcTimeServers[ 0 ] )				{					xServerIndex = 0;				}				FreeRTOS_printf( ( "Looking up server '%s'/n", pcTimeServers[ xServerIndex ] ) );				FreeRTOS_gethostbyname_a( pcTimeServers[ xServerIndex ], vDNS_callback, (void *)NULL, 1200 );			}			else			{				xStatus = EStatusAsking;			}			break;		case EStatusAsking:			{			char pcBuf[16];				prvNTPPacketInit( );				xAddress.sin_addr = ulIPAddressFound;				xAddress.sin_port = FreeRTOS_htons( NTP_PORT );				FreeRTOS_inet_ntoa( xAddress.sin_addr, pcBuf );				FreeRTOS_printf( ( "Sending UDP message to %s:%u/n",					pcBuf,					FreeRTOS_ntohs( xAddress.sin_port ) ) );				uxSendTime = xTaskGetTickCount( );				FreeRTOS_sendto( xUDPSocket, ( void * )&xNTPPacket, sizeof( xNTPPacket ), 0, &xAddress, sizeof( xAddress ) );			}			break;		case EStatusPause:			break;		case EStatusFailed:			break;		}		#if( ipconfigUSE_CALLBACKS != 0 )		{			xSemaphoreTake( xNTPWakeupSem, 5000 );		}		#else		{		uint32_t xAddressSize;		BaseType_t xReturned;			xAddressSize = sizeof( xAddress );			xReturned = FreeRTOS_recvfrom( xUDPSocket, ( void * ) cRecvBuffer, sizeof( cRecvBuffer ), 0, &xAddress, &xAddressSize );			switch( xReturned )			{			case 0:			case -pdFREERTOS_ERRNO_EAGAIN:			case -pdFREERTOS_ERRNO_EINTR:				break;			default:				if( xReturned < sizeof( xNTPPacket ) )				{					FreeRTOS_printf( ( "FreeRTOS_recvfrom: returns %ld/n", xReturned ) );				}				else				{					prvReadTime( ( struct SNtpPacket *)cRecvBuffer );					if( xStatus != EStatusPause )					{						xStatus = EStatusPause;					}//.........这里部分代码省略.........

static void prvZeroCopyEchoClientTask( void *pvParameters ){xSocket_t xSocket;struct freertos_sockaddr xEchoServerAddress;static char cTxString[ 40 ];int32_t lLoopCount = 0UL;volatile uint32_t ulRxCount = 0UL, ulTxCount = 0UL;uint32_t xAddressLength = sizeof( xEchoServerAddress );int32_t lReturned;uint8_t *pucUDPPayloadBuffer;const int32_t lMaxLoopCount = 50;const char * const pcStringToSend = "Zero copy message number";/* The buffer is large enough to hold the string, a number, and the string terminator. */const size_t xBufferLength = strlen( pcStringToSend ) + 15;	#if ipconfigINCLUDE_EXAMPLE_FREERTOS_PLUS_TRACE_CALLS == 1	{		/* When the trace recorder code is included user events are generated to		mark the sending and receiving of the echoed data (only in the zero copy		task). */		xZeroCopySendEvent = xTraceOpenLabel( "ZeroCopyTx" );		xZeroCopyReceiveEvent = xTraceOpenLabel( "ZeroCopyRx" );	}	#endif /* ipconfigINCLUDE_EXAMPLE_FREERTOS_PLUS_TRACE_CALLS */	/* Remove compiler warning about unused parameters. */	( void ) pvParameters;	/* Delay for a little while to ensure the task is out of synch with the	other echo task implemented above. */	vTaskDelay( echoLOOP_DELAY >> 1 );	/* Echo requests are sent to the echo server.  The address of the echo	server is configured by the constants configECHO_SERVER_ADDR0 to	configECHO_SERVER_ADDR3 in FreeRTOSConfig.h. */	xEchoServerAddress.sin_port = FreeRTOS_htons( echoECHO_PORT );	xEchoServerAddress.sin_addr = FreeRTOS_inet_addr_quick( configECHO_SERVER_ADDR0,															configECHO_SERVER_ADDR1,															configECHO_SERVER_ADDR2,															configECHO_SERVER_ADDR3 );	for( ;; )	{		/* Create a socket. */		xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );		configASSERT( xSocket != FREERTOS_INVALID_SOCKET );		/* Set a time out so a missing reply does not cause the task to block		indefinitely. */		FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) );		/* Send a number of echo requests. */		for( lLoopCount = 0; lLoopCount < lMaxLoopCount; lLoopCount++ )		{			/* This task is going to send using the zero copy interface.  The			data being sent is therefore written directly into a buffer that is			passed by reference into the FreeRTOS_sendto() function.  First			obtain a buffer of adequate size from the IP stack.  Although a max			delay is used, the actual delay will be capped to			ipconfigMAX_SEND_BLOCK_TIME_TICKS, hence the test to ensure a buffer			was actually obtained. */			pucUDPPayloadBuffer = ( uint8_t * ) FreeRTOS_GetUDPPayloadBuffer( xBufferLength, portMAX_DELAY );			if( pucUDPPayloadBuffer != NULL )			{				/* A buffer was successfully obtained.  Create the string that is				sent to the echo server.  Note the string is written directly				into the buffer obtained from the IP stack. */				sprintf( ( char * ) pucUDPPayloadBuffer, "%s %u/r/n", "Zero copy message number", ( unsigned int ) ulTxCount );				/* Also copy the string into a local buffer so it can be compared				with the string that is later received back from the echo server. */				strcpy( cTxString, ( char * ) pucUDPPayloadBuffer );				/* Pass the buffer into the send function.  ulFlags has the				FREERTOS_ZERO_COPY bit set so the IP stack will take control of				the	buffer, rather than copy data out of the buffer. */				echoMARK_SEND_IN_TRACE_BUFFER( xZeroCopySendEvent );				lReturned = FreeRTOS_sendto( 	xSocket,					/* The socket being sent to. */												( void * ) pucUDPPayloadBuffer,	/* The buffer being passed into the IP stack. */												strlen( cTxString ) + 1, 	/* The length of the data being sent.  Plus 1 to ensure the null terminator is part of the data. */												FREERTOS_ZERO_COPY,			/* ulFlags with the zero copy bit is set. */												&xEchoServerAddress,		/* Where the data is being sent. */												sizeof( xEchoServerAddress ) );				if( lReturned == 0 )				{					/* The send operation failed, so this task is still					responsible	for the buffer obtained from the IP stack.  To					ensure the buffer is not lost it must either be used again,					or, as in this case, returned to the IP stack using					FreeRTOS_ReleaseUDPPayloadBuffer().  pucUDPPayloadBuffer can					be safely re-used to receive from the socket below once the					buffer has been returned to the stack. */					FreeRTOS_ReleaseUDPPayloadBuffer( ( void * ) pucUDPPayloadBuffer );				}				else				{					/* The send was successful so the IP stack is now managing//.........这里部分代码省略.........

static void prvEchoClientTask( void *pvParameters ){xSocket_t xSocket;struct freertos_sockaddr xEchoServerAddress;char cTxString[ 25 ], cRxString[ 25 ]; /* Make sure the stack is large enough to hold these.  Turn on stack overflow checking during debug to be sure. */int32_t lLoopCount = 0UL;const int32_t lMaxLoopCount = 50;volatile uint32_t ulRxCount = 0UL, ulTxCount = 0UL;uint32_t xAddressLength = sizeof( xEchoServerAddress );	/* Remove compiler warning about unused parameters. */	( void ) pvParameters;	/* Echo requests are sent to the echo server.  The address of the echo	server is configured by the constants configECHO_SERVER_ADDR0 to	configECHO_SERVER_ADDR3 in FreeRTOSConfig.h. */	xEchoServerAddress.sin_port = FreeRTOS_htons( echoECHO_PORT );	xEchoServerAddress.sin_addr = FreeRTOS_inet_addr_quick( configECHO_SERVER_ADDR0,															configECHO_SERVER_ADDR1,															configECHO_SERVER_ADDR2,															configECHO_SERVER_ADDR3 );	for( ;; )	{		/* Create a socket. */		xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );		configASSERT( xSocket != FREERTOS_INVALID_SOCKET );		/* Set a time out so a missing reply does not cause the task to block		indefinitely. */		FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) );		/* Send a number of echo requests. */		for( lLoopCount = 0; lLoopCount < lMaxLoopCount; lLoopCount++ )		{			/* Create the string that is sent to the echo server. */			sprintf( cTxString, "Message number %u/r/n", ( unsigned int ) ulTxCount );			/* Send the string to the socket.  ulFlags is set to 0, so the zero			copy interface is not used.  That means the data from cTxString is			copied into a network buffer inside FreeRTOS_sendto(), and cTxString			can be reused as soon as FreeRTOS_sendto() has returned.  1 is added			to ensure the NULL string terminator is sent as part of the message. */			FreeRTOS_sendto( xSocket,				/* The socket being sent to. */							( void * ) cTxString,	/* The data being sent. */							strlen( cTxString ) + 1,/* The length of the data being sent. */							0,						/* ulFlags with the FREERTOS_ZERO_COPY bit clear. */							&xEchoServerAddress,	/* The destination address. */							sizeof( xEchoServerAddress ) );			/* Keep a count of how many echo requests have been transmitted so			it can be compared to the number of echo replies received.  It would			be expected to loose at least one to an ARP message the first time			the	connection is created. */			ulTxCount++;			/* Receive data echoed back to the socket.  ulFlags is zero, so the			zero copy option is not being used and the received data will be			copied into the buffer pointed to by cRxString.  xAddressLength is			not actually used (at the time of writing this comment, anyway) by			FreeRTOS_recvfrom(), but is set appropriately in case future			versions do use it. */			memset( ( void * ) cRxString, 0x00, sizeof( cRxString ) );			FreeRTOS_recvfrom(	xSocket,				/* The socket being received from. */								cRxString,				/* The buffer into which the received data will be written. */								sizeof( cRxString ),	/* The size of the buffer provided to receive the data. */								0,						/* ulFlags with the FREERTOS_ZERO_COPY bit clear. */								&xEchoServerAddress,	/* The address from where the data was sent (the source address). */								&xAddressLength );			/* Compare the transmitted string to the received string. */			if( strcmp( cRxString, cTxString ) == 0 )			{				/* The echo reply was received without error. */				ulRxCount++;			}		};		/* Pause for a short while to ensure the network is not too		congested. */		vTaskDelay( echoLOOP_DELAY );		/* Close this socket before looping back to create another. */		FreeRTOS_closesocket( xSocket );	}}

static void SNTP_thread(void* pvp){	struct sntp_c 		params;	const TickType_t 	xReceiveTimeOut = 500;	uint32_t			ntp_addr=0;	struct sntp_msg		sntpmsg,sntpresponse;	uint16_t			usBytes;	uint32_t			addr_len = sizeof(params.xClient);	sys_time.timezone = 1;	params.poll_interval = SNTP_POLL_INTERVAL;    /* Attempt to open the socket. */    params.socket = FreeRTOS_socket( FREERTOS_AF_INET,    									 FREERTOS_SOCK_DGRAM,			 	 	 	 	 	 	 	 FREERTOS_IPPROTO_UDP );    /* Set a time out so connect() will try connect over and over */    FreeRTOS_setsockopt( params.socket,                         0,                         FREERTOS_SO_RCVTIMEO,                         &xReceiveTimeOut,                         sizeof( xReceiveTimeOut ) );    params.xClient.sin_port = FreeRTOS_htons(SNTP_PORT_NR);    memset(&sntpmsg,0,sizeof(sntpmsg));    sntpmsg.li_vn_mode = SNTP_LI_NO_WARNING | SNTP_VERSION | SNTP_MODE_CLIENT;    for(;;)    {        while(ntp_addr==0)        {        	ntp_addr=FreeRTOS_gethostbyname(SNTP_SERVER_ADDRESS_NAME); // try to connect 5 times after that returns 0        	params.xClient.sin_addr = ntp_addr;        }        FreeRTOS_sendto(params.socket,&sntpmsg,sizeof(sntpmsg),0,&params.xClient,sizeof(params.xClient)); // send request        usBytes=FreeRTOS_recvfrom(params.socket,&sntpresponse,sizeof(sntpresponse),0,&params.xClient,&addr_len); // wait for NTP's server response,blocking        if(usBytes == SNTP_MSG_LEN)        {        	/* Kiss-of-death packet. Use another server or increase SNTP_POLL_INTERVAL. */        	if(sntpresponse.stratum == SNTP_STRATUM_KOD)        	{        		print_gen(s_KOD);        		params.poll_interval +=1000;        	}        	else if (((sntpresponse.li_vn_mode & SNTP_MODE_MASK) == SNTP_MODE_SERVER) ||                    ((sntpresponse.li_vn_mode & SNTP_MODE_MASK) == SNTP_MODE_BROADCAST))        	{        		getDate(FreeRTOS_ntohl(sntpresponse.receive_timestamp[0]),&sys_time);				#if SNTP_PRINT_LOG        			PRINT_SYSTIME;				#endif        	}        }        else //error        {        }        vTaskDelay(params.poll_interval);    }}

int ICACHE_FLASH_ATTR NetworkConnect(Network* n, char* addr, int port) {    struct sockaddr_in sAddr;    int retVal = -1;    bzero(&sAddr, sizeof(struct sockaddr_in));    if (!getIpForHost(addr, &sAddr)) {        printf("get ip by hostname fail/n");        return -1;    }    sAddr.sin_port = FreeRTOS_htons(port);    if ((n->my_socket = FreeRTOS_socket(PF_INET, FREERTOS_SOCK_STREAM, 0)) < 0)        goto exit;//	printf("Connecting to server %s.../n", ipaddr_ntoa((const ip_addr_t*)&sAddr.sin_addr.s_addr));    if ((retVal = FreeRTOS_connect(n->my_socket, (struct sockaddr * )(&sAddr),                                   sizeof(struct sockaddr))) < 0) {        FreeRTOS_closesocket(n->my_socket);        goto exit;    }exit://	printf("------------>connect init: %d, sock:%d /n", retVal, n->my_socket);    return retVal;#if 0    struct freertos_sockaddr sAddr;    int retVal = -1;    uint32_t ipAddress;    struct sockaddr_in *name_in;    struct ip_addr *ad;    struct hostent *pHost;    if ((pHost = FreeRTOS_gethostbyname(addr)) == 0)        goto exit;    ad = (struct ip_addr *)&pHost->h_addr_list[0];    ipAddress = ad->addr;    sAddr.sa_family = AF_INET;    name_in = (struct sockaddr_in *)(void*)(&sAddr);    name_in->sin_port = FreeRTOS_htons(port);    name_in->sin_addr.s_addr = ipAddress;    printf("----->get ip: %08x, %08x, %08x/n", ipAddress, port, FreeRTOS_htons(port));    if ((n->my_socket = FreeRTOS_socket(FREERTOS_AF_INET, FREERTOS_SOCK_STREAM, FREERTOS_IPPROTO_TCP)) < 0)        goto exit;    printf("++++++++++>get ip: %s/n", addr);    if ((retVal = FreeRTOS_connect(n->my_socket, &sAddr, sizeof(sAddr))) < 0)    {        FreeRTOS_closesocket(n->my_socket);        goto exit;    }exit:    printf("------------>connect init fail /n");    return retVal;#endif#if 0    int type = SOCK_STREAM;    struct sockaddr_in address;    int retVal = -1;    sa_family_t family = AF_INET;    struct addrinfo *result = NULL;    struct addrinfo hints = {0, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, 0, NULL, NULL, NULL};    if ((retVal = getaddrinfo(addr, NULL, &hints, &result)) == 0)    {        printf("------------------->1/n");        struct addrinfo* res = result;        /* prefer ip4 addresses */        while (res)        {            if (res->ai_family == AF_INET)            {                result = res;                break;            }            res = res->ai_next;        }        if (result->ai_family == AF_INET)        {            address.sin_port = htons(port);            address.sin_family = family = AF_INET;            address.sin_addr = ((struct sockaddr_in*)(result->ai_addr))->sin_addr;            printf("------------------->2, %08x, %08x/n", address.sin_port, address.sin_addr);        }        else            retVal = -1;        freeaddrinfo(result);    }    if (retVal == 0) {        printf("------------------->3/n");//.........这里部分代码省略.........

static void prvEchoClientTask( void *pvParameters ){Socket_t xSocket;struct freertos_sockaddr xEchoServerAddress;int32_t lLoopCount = 0UL;const int32_t lMaxLoopCount = 1;volatile uint32_t ulTxCount = 0UL;BaseType_t xReceivedBytes, xReturned, xInstance;BaseType_t lTransmitted, lStringLength;char *pcTransmittedString, *pcReceivedString;WinProperties_t xWinProps;TickType_t xTimeOnEntering;	/* Fill in the buffer and window sizes that will be used by the socket. */	xWinProps.lTxBufSize = 6 * ipconfigTCP_MSS;	xWinProps.lTxWinSize = 3;	xWinProps.lRxBufSize = 6 * ipconfigTCP_MSS;	xWinProps.lRxWinSize = 3;	/* This task can be created a number of times.  Each instance is numbered	to enable each instance to use a different Rx and Tx buffer.  The number is	passed in as the task's parameter. */	xInstance = ( BaseType_t ) pvParameters;	/* Point to the buffers to be used by this instance of this task. */	pcTransmittedString = &( cTxBuffers[ xInstance ][ 0 ] );	pcReceivedString = &( cRxBuffers[ xInstance ][ 0 ] );	/* Echo requests are sent to the echo server.  The address of the echo	server is configured by the constants configECHO_SERVER_ADDR0 to	configECHO_SERVER_ADDR3 in FreeRTOSConfig.h. */	xEchoServerAddress.sin_port = FreeRTOS_htons( echoECHO_PORT );	xEchoServerAddress.sin_addr = FreeRTOS_inet_addr_quick( configECHO_SERVER_ADDR0,															configECHO_SERVER_ADDR1,															configECHO_SERVER_ADDR2,															configECHO_SERVER_ADDR3 );	for( ;; )	{		/* Create a TCP socket. */		xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_STREAM, FREERTOS_IPPROTO_TCP );		configASSERT( xSocket != FREERTOS_INVALID_SOCKET );		/* Set a time out so a missing reply does not cause the task to block		indefinitely. */		FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) );		FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_SNDTIMEO, &xSendTimeOut, sizeof( xSendTimeOut ) );		/* Set the window and buffer sizes. */		FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_WIN_PROPERTIES, ( void * ) &xWinProps,	sizeof( xWinProps ) );		/* Connect to the echo server. */		if( FreeRTOS_connect( xSocket, &xEchoServerAddress, sizeof( xEchoServerAddress ) ) == 0 )		{			ulConnections[ xInstance ]++;			/* Send a number of echo requests. */			for( lLoopCount = 0; lLoopCount < lMaxLoopCount; lLoopCount++ )			{				/* Create the string that is sent to the echo server. */				lStringLength = prvCreateTxData( pcTransmittedString, echoBUFFER_SIZES );				/* Add in some unique text at the front of the string. */				sprintf( pcTransmittedString, "TxRx message number %u", ulTxCount );				ulTxCount++;				/* Send the string to the socket. */				lTransmitted = FreeRTOS_send(	xSocket,						/* The socket being sent to. */												( void * ) pcTransmittedString,	/* The data being sent. */												lStringLength,					/* The length of the data being sent. */												0 );							/* No flags. */				if( lTransmitted < 0 )				{					/* Error? */					break;				}				/* Clear the buffer into which the echoed string will be				placed. */				memset( ( void * ) pcReceivedString, 0x00, echoBUFFER_SIZES );				xReceivedBytes = 0;				/* Receive data echoed back to the socket. */				while( xReceivedBytes < lTransmitted )				{					xReturned = FreeRTOS_recv( xSocket,								/* The socket being received from. */											&( pcReceivedString[ xReceivedBytes ] ),/* The buffer into which the received data will be written. */											 lStringLength - xReceivedBytes,		/* The size of the buffer provided to receive the data. */											 0 );									/* No flags. */					if( xReturned < 0 )					{						/* Error occurred.  Latch it so it can be detected						below. */						xReceivedBytes = xReturned;						break;					}					else if( xReturned == 0 )					{//.........这里部分代码省略.........

static void prvMultipleSocketRxTask( void *pvParameters ){xSocketSet_t xFD_Set;xSocket_t xSocket;struct freertos_sockaddr xAddress;uint32_t xClientLength = sizeof( struct freertos_sockaddr ), ulFirstRxPortNumber, x;uint32_t ulReceivedValue = 0, ulCount;uint8_t ucReceivedValues[ selMAX_TX_VALUE ]; /* If the array position is pdTRUE then the corresponding value has been received. */int32_t lBytes;const TickType_t xRxBlockTime = 0;BaseType_t xResult;	/* The number of the port the first Rx socket will be bound to is passed in	as the task parameter.  Other port numbers used are consecutive from this. */	ulFirstRxPortNumber = ( uint32_t ) pvParameters;	/* Create the set for sockets that will be passed into FreeRTOS_select(). */	xFD_Set = FreeRTOS_CreateSocketSet();	/* Create the sockets and add them to the set. */	for( x = 0; x < selNUMBER_OF_SOCKETS; x++ )	{		/* Create the next Rx socket. */		xRxSockets[ x ] = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );		configASSERT( xRxSockets[ x ] != FREERTOS_INVALID_SOCKET );		/* Bind to the next port number. */		xAddress.sin_port = FreeRTOS_htons( ( uint16_t ) ( ulFirstRxPortNumber + x ) );		FreeRTOS_bind( xRxSockets[ x ], &xAddress, sizeof( struct freertos_sockaddr ) );		/* There should always be data available after FreeRTOS_select() so		blocking on a read should not be necessary. */		FreeRTOS_setsockopt( xRxSockets[ x ], 0, FREERTOS_SO_RCVTIMEO, &xRxBlockTime, sizeof( xRxBlockTime ) );		/* Add the created socket to the set. */		FreeRTOS_FD_SET( xRxSockets[ x ], xFD_Set, eSELECT_ALL );	}	for( ;; )	{		/* No values have yet been received so set each array position to		pdFALSE.  Each expected Rx value has a corresponding array position. */		memset( ( void * ) ucReceivedValues, pdFALSE, sizeof( ucReceivedValues ) );		/* Wait for the other task to resume this task - indicating that it is		about to start sending. */		vTaskSuspend( NULL );		/* Expect to receive selMAX_TX_VALUE values. */		ulCount = 0;		while( ulCount < selMAX_TX_VALUE )		{			/* Wait for a socket from the set to become available for			reading. */			xResult = FreeRTOS_select( xFD_Set, xReceiveBlockTime );			if( xResult != 0 )			{				/* See which sockets have data waiting to be read. */				for( x = 0; x < selNUMBER_OF_SOCKETS; x++ )				{					xSocket = xRxSockets[ x ];					/* Find the expected value for this socket */					if( FreeRTOS_FD_ISSET( xSocket, xFD_Set ) != 0 )					{						while( ( lBytes = FreeRTOS_recvfrom( xSocket, &( ulReceivedValue ), sizeof( uint32_t ), 0, &xAddress, &xClientLength ) ) > 0 )						{							/* Received another message. */							ulCount++;							/* It is always expected that the read will pass. */							configASSERT( ( size_t ) lBytes == ( sizeof( uint32_t ) ) );							/* Don't expect to receive anything greater than							selMAX_TX_VALUE - 1. */							configASSERT( ulReceivedValue < selMAX_TX_VALUE );							/* Don't expect to receive any value twice. */							configASSERT( ucReceivedValues[ ulReceivedValue ] != pdTRUE );							if( ucReceivedValues[ ulReceivedValue ] != pdTRUE )							{								/* Mark the value as received by setting its								index in the received array to pdTRUE. */								ucReceivedValues[ ulReceivedValue ] = pdTRUE;							}							else							{								ulErrorOccurred = pdTRUE;							}						}					}				}			}			else			{				/* No value was received in time. */				break;			}//.........这里部分代码省略.........

static void prvSimpleZeroCopyUDPClientTask( void *pvParameters ){xSocket_t xClientSocket;uint8_t *pucUDPPayloadBuffer;struct freertos_sockaddr xDestinationAddress;portBASE_TYPE lReturned;uint32_t ulCount = 0UL, ulIPAddress;const uint32_t ulLoopsPerSocket = 10UL;const uint8_t *pucStringToSend = ( const uint8_t * ) "Server received (using zero copy): Message number ";const portTickType x150ms = 150UL / portTICK_RATE_MS;/* 15 is added to ensure the number, /r/n and terminating zero fit. */const size_t xStringLength = strlen( ( char * ) pucStringToSend ) + 15;	/* Remove compiler warning about unused parameters. */	( void ) pvParameters;	/* It is assumed that this task is not created until the network is up,	so the IP address can be obtained immediately.  store the IP address being	used in ulIPAddress.  This is done so the socket can send to a different	port on the same IP address. */	FreeRTOS_GetAddressConfiguration( &ulIPAddress, NULL, NULL, NULL );	/* This test sends to itself, so data sent from here is received by a server	socket on the same IP address.  Setup the freertos_sockaddr structure with	this nodes IP address, and the port number being sent to.  The strange	casting is to try and remove compiler warnings on 32 bit machines. */	xDestinationAddress.sin_addr = ulIPAddress;	xDestinationAddress.sin_port = ( uint16_t ) ( ( uint32_t ) pvParameters ) & 0xffffUL;	xDestinationAddress.sin_port = FreeRTOS_htons( xDestinationAddress.sin_port );	for( ;; )	{		/* Create the socket. */		xClientSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );		configASSERT( xClientSocket != FREERTOS_INVALID_SOCKET );		/* The count is used to differentiate between different messages sent to		the server, and to break out of the do while loop below. */		ulCount = 0UL;		do		{			/* This task is going to send using the zero copy interface.  The			data being sent is therefore written directly into a buffer that is			passed into, rather than copied into, the FreeRTOS_sendto()			function.			First obtain a buffer of adequate length from the IP stack into which			the string will be written.  Although a max delay is used, the actual			delay will be capped to ipconfigMAX_SEND_BLOCK_TIME_TICKS, hence			the do while loop is used to ensure a buffer is obtained. */			do			{			} while( ( pucUDPPayloadBuffer = ( uint8_t * ) FreeRTOS_GetUDPPayloadBuffer( xStringLength, portMAX_DELAY ) ) == NULL );			/* A buffer was successfully obtained.  Create the string that is			sent to the server.  First the string is filled with zeros as this will			effectively be the null terminator when the string is received at the other			end.  Note that the string is being written directly into the buffer			obtained from the IP stack above. */			memset( ( void * ) pucUDPPayloadBuffer, 0x00, xStringLength );			sprintf( ( char * ) pucUDPPayloadBuffer, "%s%lu/r/n", ( char * ) pucStringToSend, ulCount );			/* Pass the buffer into the send function.  ulFlags has the			FREERTOS_ZERO_COPY bit set so the IP stack will take control of the			buffer rather than copy data out of the buffer. */			lReturned = FreeRTOS_sendto( xClientSocket,  				/* The socket being sent to. */										( void * ) pucUDPPayloadBuffer, /* A pointer to the the data being sent. */										strlen( ( const char * ) pucUDPPayloadBuffer ) + 1, /* The length of the data being sent - including the string's null terminator. */										FREERTOS_ZERO_COPY, 			/* ulFlags with the FREERTOS_ZERO_COPY bit set. */										&xDestinationAddress, 			/* Where the data is being sent. */										sizeof( xDestinationAddress ) );			if( lReturned == 0 )			{				/* The send operation failed, so this task is still responsible				for the buffer obtained from the IP stack.  To ensure the buffer				is not lost it must either be used again, or, as in this case,				returned to the IP stack using FreeRTOS_ReleaseUDPPayloadBuffer().				pucUDPPayloadBuffer can be safely re-used after this call. */				FreeRTOS_ReleaseUDPPayloadBuffer( ( void * ) pucUDPPayloadBuffer );			}			else			{				/* The send was successful so the IP stack is now managing the				buffer pointed to by pucUDPPayloadBuffer, and the IP stack will				return the buffer once it has been sent.  pucUDPPayloadBuffer can				be safely re-used. */			}			ulCount++;		} while( ( lReturned != FREERTOS_SOCKET_ERROR ) && ( ulCount < ulLoopsPerSocket ) );		FreeRTOS_closesocket( xClientSocket );		/* A short delay to prevent the messages scrolling off the screen too		quickly. */		vTaskDelay( x150ms );	}//.........这里部分代码省略.........

static void prvMultipleSocketTxTask( void *pvParameters ){uint32_t ulTxValue = 0;struct freertos_sockaddr xDestinationAddress;uint32_t ulIPAddress, ulFirstDestinationPortNumber, xPortNumber;xSocket_t xTxSocket;uint32_t ulSendCount[ selNUMBER_OF_SOCKETS ];	memset( ulSendCount, '/0', sizeof( ulSendCount ) );	/* The first destination port number is passed in as the task parameter.	Other destination port numbers used are consecutive from this. */	ulFirstDestinationPortNumber = ( uint32_t ) pvParameters;	/* Create the socket used to send to the sockets created by the Rx task.	Let the IP stack select a port to bind to. */	xTxSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );	FreeRTOS_bind( xTxSocket, NULL, sizeof( struct freertos_sockaddr ) );	/* The Rx and Tx tasks execute at the same priority so it is possible that	the Tx task will fill up the send queue - set a Tx block time to ensure	flow control is managed if this happens. */	FreeRTOS_setsockopt( xTxSocket, 0, FREERTOS_SO_SNDTIMEO, &xSendBlockTime, sizeof( xSendBlockTime ) );	/* It is assumed that this task is not created until the network is up,	so the IP address can be obtained immediately.  Store the IP address being	used in ulIPAddress.  This is done so the socket can send to a different	port on the same IP address. */	FreeRTOS_GetAddressConfiguration( &ulIPAddress, NULL, NULL, NULL );	/* This test sends to itself, so data sent from here is received by a server	socket on the same IP address.  Setup the freertos_sockaddr structure with	this nodes IP address. */	xDestinationAddress.sin_addr = ulIPAddress;	/* Block for a short time to ensure the task implemented by the	prvMultipleSocketRxTask() function has finished creating the Rx sockets. */	while( eTaskGetState( xRxTaskHandle ) != eSuspended )	{		vTaskDelay( xSendBlockTime );	}	vTaskResume( xRxTaskHandle );	for( ;; )	{		/* Pseudo randomly select the destination port number from the range of		valid destination port numbers. */		xPortNumber = ipconfigRAND32() % selNUMBER_OF_SOCKETS;		ulSendCount[ xPortNumber ]++;		xDestinationAddress.sin_port = ( uint16_t ) ( ulFirstDestinationPortNumber + xPortNumber );		xDestinationAddress.sin_port = FreeRTOS_htons( xDestinationAddress.sin_port );		/* Send an incrementing value to the pseudo randomly selected port. */		FreeRTOS_sendto( xTxSocket, &ulTxValue, sizeof( ulTxValue ), 0, &xDestinationAddress, sizeof( xDestinationAddress ) );		ulTxValue++;		if( ulTxValue >= selMAX_TX_VALUE )		{			/* Start over. */			ulTxValue = 0;			/* As a sanity check that this demo is valid, ensure each socket has			been used at least once. */			for( xPortNumber = 0; xPortNumber < selNUMBER_OF_SOCKETS; xPortNumber++ )			{				if( ulSendCount[ xPortNumber ] == 0 )				{					ulErrorOccurred = pdTRUE;				}				ulSendCount[ xPortNumber ] = 0;			}			/* Allow the Rx task to check it has received all the values. */			while( eTaskGetState( xRxTaskHandle ) != eSuspended )			{				vTaskDelay( xSendBlockTime );			}			vTaskResume( xRxTaskHandle );			/* Increment to show this task is still executing. */			ulTxCycles++;		}		/* Delay here because in the Windows simulator the MAC interrupt		simulator delays, so network traffic cannot be received any faster than		this. */		vTaskDelay( configWINDOWS_MAC_INTERRUPT_SIMULATOR_DELAY << 2 );	}}

static void prvMultipleSocketRxTask( void *pvParameters ){xSocketSet_t xFD_Set;xSocket_t xSocket;struct freertos_sockaddr xAddress;uint32_t xClientLength = sizeof( struct freertos_sockaddr ), ulFirstRxPortNumber, x;uint32_t ulReceivedValue = 0, ulExpectedValue = 0UL, ulReceivedCount[ selNUMBER_OF_SOCKETS ] = { 0 };int32_t lBytes;const TickType_t xRxBlockTime = 0;	/* The number of the port the first Rx socket will be bound to is passed in	as the task parameter.  Other port numbers used are consecutive from this. */	ulFirstRxPortNumber = ( uint32_t ) pvParameters;	/* Create the set of sockets that will be passed into FreeRTOS_select(). */	xFD_Set = FreeRTOS_CreateSocketSet( selSELECT_QUEUE_SIZE );	for( x = 0; x < selNUMBER_OF_SOCKETS; x++ )	{		/* Create the next Rx socket. */		xRxSockets[ x ] = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );		configASSERT( xRxSockets[ x ] );		/* Bind to the next port number. */		xAddress.sin_port = FreeRTOS_htons( ( uint16_t ) ( ulFirstRxPortNumber + x ) );		FreeRTOS_bind( xRxSockets[ x ], &xAddress, sizeof( struct freertos_sockaddr ) );		/* There should always be data available on the socket returned from		FreeRTOS_select() so blocking on a read should not be necessary. */		FreeRTOS_setsockopt( xRxSockets[ x ], 0, FREERTOS_SO_RCVTIMEO, &xRxBlockTime, sizeof( xRxBlockTime ) );		/* Add the created socket to the set. */		FreeRTOS_FD_SET( xRxSockets[ x ], xFD_Set );	}	for( ;; )	{		/* Wait for a socket from the set to become available for reading. */		xSocket = FreeRTOS_select( xFD_Set, portMAX_DELAY );		/* xSocket should never be NULL because FreeRTOS_select() was called		with an indefinite delay (assuming INCLUDE_vTaskSuspend is set to 1). */		configASSERT( xSocket );		lBytes = FreeRTOS_recvfrom( xSocket, &( ulReceivedValue ), sizeof( uint32_t ), 0, &xAddress, &xClientLength );		/* It is possible that the first value received will not be zero		because the first few transmitted packets may have been dropped to		send an ARP and then wait the ARP reply. */		if( ulExpectedValue == 0 )		{			if( ulExpectedValue != ulReceivedValue )			{				/* Correct for packets lost to ARP traffic. */				ulExpectedValue = ulReceivedValue;			}		}		/* Data should always be available even though the block time was set		to zero because the socket was returned from FreeRTOS_select(). */		configASSERT( lBytes == 4 );		configASSERT( ulReceivedValue == ulExpectedValue );		ulExpectedValue++;		/* Keep a record of the number of times each socket has been used so it		can be verified (using the debugger) that they all get used. */		for( x= 0; x < selNUMBER_OF_SOCKETS; x++ )		{			if( xSocket == xRxSockets[ x ] )			{				( ulReceivedCount[ x ] )++;				break;			}		}	}}

static void prvConnectionListeningTask( void *pvParameters ){struct freertos_sockaddr xClient, xBindAddress;xSocket_t xListeningSocket;socklen_t xSize = sizeof( xClient );static const TickType_t xReceiveTimeOut = 0; //portMAX_DELAY;const BaseType_t xBacklog = 10;xSocketSet_t xSocketSet;struct xTCP_SERVER *pxServerList = NULL;struct xTCP_SERVER *pxIterator;xWinProperties_t winProps;	/* Just to prevent compiler warnings. */	( void ) pvParameters;	/* Attempt to open the socket. */	xListeningSocket = FreeRTOS_socket( PF_INET, SOCK_STREAM, IPPROTO_TCP );	configASSERT( xListeningSocket != FREERTOS_INVALID_SOCKET );	/* Set a time out so accept() will just wait for a connection. */	FreeRTOS_setsockopt( xListeningSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) );	memset(&winProps, '/0', sizeof( winProps ) );	// Size in units of MSS	winProps.lTxBufSize   = 1 * 1460;//1000;	winProps.lTxWinSize   = 2;	winProps.lRxBufSize   = 2 * 1460;	winProps.lRxWinSize   =  2;	FreeRTOS_setsockopt( xListeningSocket, 0, FREERTOS_SO_WIN_PROPERTIES, ( void * ) &winProps, sizeof( winProps ) );	/* The strange casting is to remove compiler errors. */	xBindAddress.sin_port = ( uint16_t ) ( ( uint32_t ) pvParameters ) & 0xffffUL;	xBindAddress.sin_port = FreeRTOS_htons( xBindAddress.sin_port );	/* Bind the socket to the port that the client task will send to, then	listen for incoming connections. */	while( FreeRTOS_bind( xListeningSocket, &xBindAddress, sizeof( xBindAddress ) ) != 0 );	FreeRTOS_listen( xListeningSocket, xBacklog );	lastTickTime = xTaskGetTickCount ();	pxServerList = NULL;	xSocketSet = FreeRTOS_createsocketset( );	configASSERT( xSocketSet != NULL );	FreeRTOS_FD_SET( xListeningSocket, xSocketSet, eSELECT_READ );	for( ;; )	{		TickType_t xMask = FreeRTOS_select( xSocketSet, 3000 );		if( FreeRTOS_FD_ISSET( xListeningSocket, xSocketSet ) )		{			xSocket_t xNewSocket;			xNewSocket = FreeRTOS_accept( xListeningSocket, &xClient, &xSize );			if ( xNewSocket && xNewSocket != FREERTOS_INVALID_SOCKET )			{				xTcpServer_t *pxServer;				FreeRTOS_debug_printf( ( "prvConnectionListeningTask: new connection %xip:%u/n",					FreeRTOS_ntohl( xClient.sin_addr ), FreeRTOS_ntohs( xClient.sin_port ) ) );				pxServer = (xTcpServer_t *)pvPortMalloc( sizeof( *pxServer ) );				memset( pxServer, '/0', sizeof( *pxServer ));				pxServer->xSocket = xNewSocket;				FreeRTOS_FD_SET( xNewSocket, xSocketSet, eSELECT_READ | eSELECT_EXCEPT );				if( pxServerList == NULL )				{					/* This is the first server */					pxServerList = pxServer;				}				else				{					/* Attach it to the end of the list */					for( pxIterator = pxServerList; pxIterator->pxNext != NULL; pxIterator = pxIterator->pxNext )					{					}					pxIterator->pxNext = pxServer;				}				prvTcpInit( pxServer );			}		}		{			xTcpServer_t *pxThisServer = NULL;			for( pxIterator = pxServerList; pxIterator != NULL;  )			{				BaseType_t rc;				pxThisServer = pxIterator;				/* Move to the next one before the current gets deleted */				pxIterator = pxIterator->pxNext;				if( FreeRTOS_FD_ISSET( pxThisServer->xSocket, xSocketSet )  == 0 )				{					continue;//.........这里部分代码省略.........

void prvTCPCpmIOTask( void *ram ){	BaseType_t iosize;	char cRxedChar, cInputIndex = 0;	struct freertos_sockaddr xClient;	Socket_t xListeningSocket;	socklen_t xSize = sizeof( xClient );	cpminq = xQueueCreate(81, sizeof( CHAR));		while(FreeRTOS_IsNetworkUp() == pdFALSE)		vTaskDelay(3000); 	/* Create the socket. */	xSocketRDisk = FreeRTOS_socket( FREERTOS_AF_INET,                              FREERTOS_SOCK_DGRAM,                              FREERTOS_IPPROTO_UDP );    /* Check the socket was created. */   configASSERT( xSocketRDisk != FREERTOS_INVALID_SOCKET );		for( ;; )	{		/* Attempt to open the socket.  The port number is passed in the task		parameter.  The strange casting is to remove compiler warnings on 32-bit		machines.  NOTE:  The FREERTOS_SO_REUSE_LISTEN_SOCKET option is used,		so the listening and connecting socket are the same - meaning only one		connection will be accepted at a time, and that xListeningSocket must		be created on each iteration. */		xListeningSocket = prvOpenTCPServerSocket( RDSK_PORT);		/* Nothing for this task to do if the socket cannot be created. */		if( xListeningSocket == FREERTOS_INVALID_SOCKET )		{			vTaskDelete( NULL );		}		/* Wait for an incoming connection. */		xConnectedSocket = FreeRTOS_accept( xListeningSocket, &xClient, &xSize );		/* The FREERTOS_SO_REUSE_LISTEN_SOCKET option is set, so the		connected and listening socket should be the same socket. */		configASSERT( xConnectedSocket == xListeningSocket );		xRDiskAddress.sin_addr = xClient.sin_addr;		xRDiskAddress.sin_port = FreeRTOS_htons( RDSK_PORT );				iosize = xTaskCreate( CPM22Task, "CPM22Task", configMINIMAL_STACK_SIZE*5, ram, PRIO_CPM22,&thcpm);		if(iosize != pdPASS)		{			prvGracefulShutdown( xListeningSocket );			vTaskDelete( NULL );		}				/* Send the welcome message. */		iosize = FreeRTOS_send( xConnectedSocket,  ( void * ) pcWelcomeMessage,  strlen( pcWelcomeMessage ), 0 );		xQueueReset(cpminq);						/* Process the socket as long as it remains connected. */		while( iosize >= 0 )		{			char c;			/* Receive data on the socket. */			iosize = FreeRTOS_recv( xConnectedSocket, &c, 1, 0 );						if( iosize >= 0 )			{				xQueueSend(cpminq,&c,0);					}			else			{				/* Socket closed? */				break;			}		}		/* Close the socket correctly. */		prvGracefulShutdown( xListeningSocket );	}}

void vProcessGeneratedUDPPacket( xNetworkBufferDescriptor_t * const pxNetworkBuffer ){xUDPPacket_t *pxUDPPacket;xIPHeader_t *pxIPHeader;eARPLookupResult_t eReturned;uint32_t ulIPAddress = pxNetworkBuffer->ulIPAddress;	/* Map the UDP packet onto the start of the frame. */	pxUDPPacket = ( xUDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;	/* Determine the ARP cache status for the requested IP address. */	eReturned = eARPGetCacheEntry( &( ulIPAddress ), &( pxUDPPacket->xEthernetHeader.xDestinationAddress ) );	if( eReturned != eCantSendPacket )	{		if( eReturned == eARPCacheHit )		{			#if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )				uint8_t xSocketOptions;			#endif			iptraceSENDING_UDP_PACKET( pxNetworkBuffer->ulIPAddress );			/* Create short cuts to the data within the packet. */			pxIPHeader = &( pxUDPPacket->xIPHeader );		#if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )			/* Is it possible that the packet is not actually a UDP packet			after all, but an ICMP packet. */			if( pxNetworkBuffer->usPort != ipPACKET_CONTAINS_ICMP_DATA )		#endif /* ipconfigSUPPORT_OUTGOING_PINGS */			{			xUDPHeader_t *pxUDPHeader;				pxUDPHeader = &( pxUDPPacket->xUDPHeader );				pxUDPHeader->usDestinationPort = pxNetworkBuffer->usPort;				pxUDPHeader->usSourcePort = pxNetworkBuffer->usBoundPort;				pxUDPHeader->usLength = ( uint16_t ) ( pxNetworkBuffer->xDataLength + sizeof( xUDPHeader_t ) );				pxUDPHeader->usLength = FreeRTOS_htons( pxUDPHeader->usLength );				pxUDPHeader->usChecksum = 0;			}			/* memcpy() the constant parts of the header information into			the	correct location within the packet.  This fills in:				xEthernetHeader.xSourceAddress				xEthernetHeader.usFrameType				xIPHeader.ucVersionHeaderLength				xIPHeader.ucDifferentiatedServicesCode				xIPHeader.usLength				xIPHeader.usIdentification				xIPHeader.usFragmentOffset				xIPHeader.ucTimeToLive				xIPHeader.ucProtocol			and				xIPHeader.usHeaderChecksum			*/			/* Save options now, as they will be overwritten by memcpy */			#if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )				xSocketOptions = pxNetworkBuffer->pucEthernetBuffer[ ipSOCKET_OPTIONS_OFFSET ];			#endif			memcpy( ( void *) &( pxUDPPacket->xEthernetHeader.xSourceAddress ), ( void * ) xDefaultPartUDPPacketHeader.ucBytes, sizeof( xDefaultPartUDPPacketHeader ) );		#if ipconfigSUPPORT_OUTGOING_PINGS == 1			if( pxNetworkBuffer->usPort == ipPACKET_CONTAINS_ICMP_DATA )			{				pxIPHeader->ucProtocol = ipPROTOCOL_ICMP;				pxIPHeader->usLength = ( uint16_t ) ( pxNetworkBuffer->xDataLength + sizeof( xIPHeader_t ) );			}			else		#endif /* ipconfigSUPPORT_OUTGOING_PINGS */			{				pxIPHeader->usLength = ( uint16_t ) ( pxNetworkBuffer->xDataLength + sizeof( xIPHeader_t ) + sizeof( xUDPHeader_t ) );			}			/* The total transmit size adds on the Ethernet header. */			pxNetworkBuffer->xDataLength = pxIPHeader->usLength + sizeof( xEthernetHeader_t );			pxIPHeader->usLength = FreeRTOS_htons( pxIPHeader->usLength );			/* HT:endian: changed back to network endian */			pxIPHeader->ulDestinationIPAddress = pxNetworkBuffer->ulIPAddress;			#if( ipconfigUSE_LLMNR == 1 )			{				/* LLMNR messages are typically used on a LAN and they're				 * not supposed to cross routers */				if( pxNetworkBuffer->ulIPAddress == ipLLMNR_IP_ADDR )				{					pxIPHeader->ucTimeToLive = 0x01;				}			}			#endif			#if( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )			{				pxIPHeader->usHeaderChecksum = 0;				pxIPHeader->usHeaderChecksum = usGenerateChecksum( 0UL, ( uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ipSIZE_OF_IP_HEADER );				pxIPHeader->usHeaderChecksum = ~FreeRTOS_htons( pxIPHeader->usHeaderChecksum );				if( ( xSocketOptions & FREERTOS_SO_UDPCKSUM_OUT ) != 0 )				{					usGenerateProtocolChecksum( (uint8_t*)pxUDPPacket, pdTRUE );				}//.........这里部分代码省略.........