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 ); } }
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 ); } }
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; } rc = prvTcpWork( pxThisServer ); if( rc < 0) { FreeRTOS_FD_CLR( pxThisServer->xSocket, xSocketSet, eSELECT_ALL ); if( pxServerList = pxThisServer ) { pxServerList = pxThisServer->pxNext; } else { struct xTCP_SERVER *pxOther; for( pxOther = pxServerList; pxOther->pxNext != NULL; pxOther = pxOther->pxNext ) { if( pxOther->pxNext == pxThisServer ) { pxOther->pxNext == pxThisServer->pxNext; break; } } } /* Close the socket and free the space */ prvTcpClose( pxThisServer ); } else { pxThisServer->bHasSendRequest = prvTcpHasSendData( pxThisServer ); if( pxThisServer->bHasSendRequest ) FreeRTOS_FD_SET( pxThisServer->xSocket, xSocketSet, eSELECT_WRITE ); else FreeRTOS_FD_CLR( pxThisServer->xSocket, xSocketSet, eSELECT_WRITE ); //FreeRTOS_debug_printf( ( "SET_FD WRITE %d\n", pxServerFound->bHasSendRequest != 0 ) ); } } } if( ( xTaskGetTickCount () - lastTickTime ) > 30000 ) { lastTickTime = xTaskGetTickCount (); //plusPrintf( "ListeningTask %ld,%ld tasks\n", xTaskCount, xConfirmedCount ); } } }