| /** |
| @file |
| Web server application |
| |
| Copyright (c) 2011-2012, Intel Corporation |
| All rights reserved. This program and the accompanying materials |
| are licensed and made available under the terms and conditions of the BSD License |
| which accompanies this distribution. The full text of the license may be found at |
| http://opensource.org/licenses/bsd-license.php |
| |
| THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, |
| WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. |
| |
| **/ |
| |
| #include <WebServer.h> |
| |
| DT_WEB_SERVER mWebServer; ///< Web server's control structure |
| |
| |
| /** |
| Add a port to the list of ports to be polled. |
| |
| @param [in] pWebServer The web server control structure address. |
| |
| @param [in] SocketFD The socket's file descriptor to add to the list. |
| |
| @retval EFI_SUCCESS The port was successfully added |
| @retval EFI_NO_RESOURCES Insufficient memory to add the port |
| |
| **/ |
| EFI_STATUS |
| PortAdd ( |
| IN DT_WEB_SERVER * pWebServer, |
| IN int SocketFD |
| ) |
| { |
| nfds_t Index; |
| size_t LengthInBytes; |
| nfds_t MaxEntries; |
| nfds_t MaxEntriesNew; |
| struct pollfd * pFdList; |
| struct pollfd * pFdListNew; |
| WSDT_PORT ** ppPortListNew; |
| WSDT_PORT * pPort; |
| EFI_STATUS Status; |
| |
| DBG_ENTER ( ); |
| |
| // |
| // Use for/break instead of goto |
| // |
| for ( ; ; ) { |
| // |
| // Assume success |
| // |
| Status = EFI_SUCCESS; |
| |
| // |
| // Create a new list if necessary |
| // |
| pFdList = pWebServer->pFdList; |
| MaxEntries = pWebServer->MaxEntries; |
| if ( pWebServer->Entries >= MaxEntries ) { |
| MaxEntriesNew = 16 + MaxEntries; |
| |
| // |
| // The current FD list is full |
| // Allocate a new FD list |
| // |
| LengthInBytes = sizeof ( *pFdList ) * MaxEntriesNew; |
| Status = gBS->AllocatePool ( EfiRuntimeServicesData, |
| LengthInBytes, |
| (VOID **)&pFdListNew ); |
| if ( EFI_ERROR ( Status )) { |
| DEBUG (( DEBUG_ERROR | DEBUG_POOL, |
| "ERROR - Failed to allocate the FD list, Status: %r\r\n", |
| Status )); |
| break; |
| } |
| |
| // |
| // Allocate a new port list |
| // |
| LengthInBytes = sizeof ( *ppPortListNew ) * MaxEntriesNew; |
| Status = gBS->AllocatePool ( EfiRuntimeServicesData, |
| LengthInBytes, |
| (VOID **) &ppPortListNew ); |
| if ( EFI_ERROR ( Status )) { |
| DEBUG (( DEBUG_ERROR | DEBUG_POOL, |
| "ERROR - Failed to allocate the port list, Status: %r\r\n", |
| Status )); |
| |
| // |
| // Free the new FD list |
| // |
| gBS->FreePool ( pFdListNew ); |
| break; |
| } |
| |
| // |
| // Duplicate the FD list |
| // |
| Index = MaxEntries; |
| if ( NULL != pFdList ) { |
| CopyMem ( pFdListNew, |
| pFdList, |
| Index * sizeof ( *pFdList )); |
| } |
| |
| // |
| // Initialize the new entries in the FD list |
| // |
| for ( ; MaxEntriesNew > Index; Index++ ) { |
| pFdListNew[ Index ].fd = -1; |
| pFdListNew[ Index ].events = 0; |
| pFdListNew[ Index ].revents = 0; |
| } |
| |
| // |
| // Free the old FD list |
| // |
| if ( NULL != pFdList ) { |
| gBS->FreePool ( pFdList ); |
| } |
| |
| // |
| // Switch to the new FD list |
| // |
| pWebServer->pFdList = pFdListNew; |
| pFdList = pWebServer->pFdList; |
| |
| // |
| // Duplicate the port list |
| // |
| Index = MaxEntries; |
| if ( NULL != pWebServer->ppPortList ) { |
| CopyMem ( ppPortListNew, |
| pWebServer->ppPortList, |
| Index * sizeof ( *ppPortListNew )); |
| } |
| |
| // |
| // Initialize the new entries in the port list |
| // |
| for ( ; MaxEntriesNew > Index; Index++ ) { |
| ppPortListNew[ Index ] = NULL; |
| } |
| |
| // |
| // Free the old port list |
| // |
| if ( NULL != pWebServer->ppPortList ) { |
| gBS->FreePool ( pWebServer->ppPortList ); |
| } |
| |
| // |
| // Switch to the new port list |
| // |
| pWebServer->ppPortList = ppPortListNew; |
| |
| // |
| // Update the list size |
| // |
| pWebServer->MaxEntries = MaxEntriesNew; |
| } |
| |
| // |
| // Allocate a new port |
| // |
| LengthInBytes = sizeof ( *pPort ); |
| Status = gBS->AllocatePool ( EfiRuntimeServicesData, |
| LengthInBytes, |
| (VOID **)&pPort ); |
| if ( EFI_ERROR ( Status )) { |
| DEBUG (( DEBUG_ERROR | DEBUG_POOL, |
| "ERROR - Failed to allocate the port, Status: %r\r\n", |
| Status )); |
| break; |
| } |
| |
| // |
| // Initialize the port |
| // |
| pPort->RequestLength = 0; |
| pPort->TxBytes = 0; |
| |
| // |
| // Add the socket to the FD list |
| // |
| pFdList[ pWebServer->Entries ].fd = SocketFD; |
| pFdList[ pWebServer->Entries ].events = POLLRDNORM |
| | POLLHUP; |
| pFdList[ pWebServer->Entries ].revents = 0; |
| |
| // |
| // Add the port to the port list |
| // |
| pWebServer->ppPortList[ pWebServer->Entries ] = pPort; |
| |
| // |
| // Account for the new entry |
| // |
| pWebServer->Entries += 1; |
| DEBUG (( DEBUG_PORT_WORK | DEBUG_INFO, |
| "WebServer handling %d ports\r\n", |
| pWebServer->Entries )); |
| |
| // |
| // All done |
| // |
| break; |
| } |
| |
| // |
| // Return the operation status |
| // |
| DBG_EXIT_STATUS ( Status ); |
| return Status; |
| } |
| |
| |
| /** |
| Remove a port from the list of ports to be polled. |
| |
| @param [in] pWebServer The web server control structure address. |
| |
| @param [in] SocketFD The socket's file descriptor to add to the list. |
| |
| **/ |
| VOID |
| PortRemove ( |
| IN DT_WEB_SERVER * pWebServer, |
| IN int SocketFD |
| ) |
| { |
| nfds_t Entries; |
| nfds_t Index; |
| struct pollfd * pFdList; |
| WSDT_PORT ** ppPortList; |
| |
| DBG_ENTER ( ); |
| |
| // |
| // Attempt to remove the entry from the list |
| // |
| Entries = pWebServer->Entries; |
| pFdList = pWebServer->pFdList; |
| ppPortList = pWebServer->ppPortList; |
| for ( Index = 0; Entries > Index; Index++ ) { |
| // |
| // Locate the specified socket file descriptor |
| // |
| if ( SocketFD == pFdList[ Index ].fd ) { |
| // |
| // Determine if this is the listen port |
| // |
| if ( SocketFD == pWebServer->HttpListenPort ) { |
| pWebServer->HttpListenPort = -1; |
| } |
| |
| // |
| // Close the socket |
| // |
| close ( SocketFD ); |
| |
| // |
| // Free the port structure |
| // |
| gBS->FreePool ( ppPortList[ Index ]); |
| |
| // |
| // Remove this port from the list by copying |
| // the rest of the list down one entry |
| // |
| Entries -= 1; |
| for ( ; Entries > Index; Index++ ) { |
| pFdList[ Index ] = pFdList[ Index + 1 ]; |
| ppPortList[ Index ] = ppPortList[ Index + 1 ]; |
| } |
| pFdList[ Index ].fd = -1; |
| pFdList[ Index ].events = 0; |
| pFdList[ Index ].revents = 0; |
| ppPortList[ Index ] = NULL; |
| |
| // |
| // Update the number of entries in the list |
| // |
| pWebServer->Entries = Entries; |
| DEBUG (( DEBUG_PORT_WORK | DEBUG_INFO, |
| "WebServer handling %d ports\r\n", |
| pWebServer->Entries )); |
| break; |
| } |
| } |
| |
| DBG_EXIT ( ); |
| } |
| |
| |
| /** |
| Process the work for the sockets. |
| |
| @param [in] pWebServer The web server control structure address. |
| |
| @param [in] SocketFD The socket's file descriptor to add to the list. |
| |
| @param [in] events everts is a bitmask of the work to be done |
| |
| @param [in] pPort The address of a WSDT_PORT structure |
| |
| @retval EFI_SUCCESS The operation was successful |
| @retval EFI_DEVICE_ERROR Error, close the port |
| |
| **/ |
| EFI_STATUS |
| PortWork ( |
| IN DT_WEB_SERVER * pWebServer, |
| IN int SocketFD, |
| IN INTN events, |
| IN WSDT_PORT * pPort |
| ) |
| { |
| BOOLEAN bDone; |
| size_t LengthInBytes; |
| int NewSocket; |
| EFI_STATUS OpStatus; |
| struct sockaddr_in6 RemoteAddress; |
| socklen_t RemoteAddressLength; |
| EFI_STATUS Status; |
| |
| DEBUG (( DEBUG_PORT_WORK, "Entering PortWork\r\n" )); |
| |
| // |
| // Assume success |
| // |
| OpStatus = EFI_SUCCESS; |
| |
| // |
| // Handle input events |
| // |
| if ( 0 != ( events & POLLRDNORM )) { |
| // |
| // Determine if this is a connection attempt |
| // |
| if (( SocketFD == pWebServer->HttpListenPort ) |
| || ( SocketFD == pWebServer->HttpListenPort6 )) { |
| // |
| // Handle connection attempts |
| // Accepts arrive as read events |
| // |
| RemoteAddressLength = sizeof ( RemoteAddress ); |
| NewSocket = accept ( SocketFD, |
| (struct sockaddr *)&RemoteAddress, |
| &RemoteAddressLength ); |
| if ( -1 != NewSocket ) { |
| if ( 0 != NewSocket ) { |
| // |
| // Add this port to the list monitored by the web server |
| // |
| Status = PortAdd ( pWebServer, NewSocket ); |
| if ( EFI_ERROR ( Status )) { |
| DEBUG (( DEBUG_ERROR, |
| "ERROR - Failed to add the port 0x%08x, Status: %r\r\n", |
| NewSocket, |
| Status )); |
| |
| // |
| // Done with the new socket |
| // |
| close ( NewSocket ); |
| } |
| } |
| else { |
| DEBUG (( DEBUG_ERROR, |
| "ERROR - Socket not available!\r\n" )); |
| } |
| |
| // |
| // Leave the listen port open |
| // |
| } |
| else { |
| // |
| // Listen port error |
| // Close the listen port by returning error status |
| // |
| OpStatus = EFI_DEVICE_ERROR; |
| DEBUG (( DEBUG_ERROR, |
| "ERROR - Failed to accept new connection, errno: 0x%08x\r\n", |
| errno )); |
| } |
| } |
| else { |
| // |
| // Handle the data received event |
| // |
| if ( 0 == pPort->RequestLength ) { |
| // |
| // Receive the page request |
| // |
| pPort->RequestLength = recv ( SocketFD, |
| &pPort->Request[0], |
| DIM ( pPort->Request ), |
| 0 ); |
| if ( -1 == pPort->RequestLength ) { |
| // |
| // Receive error detected |
| // Close the port |
| // |
| OpStatus = EFI_DEVICE_ERROR; |
| } |
| else { |
| DEBUG (( DEBUG_REQUEST, |
| "0x%08x: Socket - Received %d bytes of HTTP request\r\n", |
| SocketFD, |
| pPort->RequestLength )); |
| |
| // |
| // Process the request |
| // |
| OpStatus = HttpRequest ( SocketFD, pPort, &bDone ); |
| if ( bDone ) { |
| // |
| // Notify the upper layer to close the socket |
| // |
| OpStatus = EFI_DEVICE_ERROR; |
| } |
| } |
| } |
| else { |
| // |
| // Receive the file data |
| // |
| LengthInBytes = recv ( SocketFD, |
| &pPort->RxBuffer[0], |
| DIM ( pPort->RxBuffer ), |
| 0 ); |
| if ( -1 == LengthInBytes ) { |
| // |
| // Receive error detected |
| // Close the port |
| // |
| OpStatus = EFI_DEVICE_ERROR; |
| } |
| else { |
| DEBUG (( DEBUG_REQUEST, |
| "0x%08x: Socket - Received %d bytes of file data\r\n", |
| SocketFD, |
| LengthInBytes )); |
| |
| // |
| // TODO: Process the file data |
| // |
| } |
| } |
| } |
| } |
| |
| // |
| // Handle the close event |
| // |
| if ( 0 != ( events & POLLHUP )) { |
| // |
| // Close the port |
| // |
| OpStatus = EFI_DEVICE_ERROR; |
| } |
| |
| // |
| // Return the operation status |
| // |
| DEBUG (( DEBUG_PORT_WORK, |
| "Exiting PortWork, Status: %r\r\n", |
| OpStatus )); |
| return OpStatus; |
| } |
| |
| |
| /** |
| Scan the list of sockets and process any pending work |
| |
| @param [in] pWebServer The web server control structure address. |
| |
| **/ |
| VOID |
| SocketPoll ( |
| IN DT_WEB_SERVER * pWebServer |
| ) |
| { |
| int FDCount; |
| struct pollfd * pPoll; |
| WSDT_PORT ** ppPort; |
| EFI_STATUS Status; |
| |
| DEBUG (( DEBUG_SOCKET_POLL, "Entering SocketPoll\r\n" )); |
| |
| // |
| // Determine if any ports are active |
| // |
| FDCount = poll ( pWebServer->pFdList, |
| pWebServer->Entries, |
| CLIENT_POLL_DELAY ); |
| if ( -1 == FDCount ) { |
| DEBUG (( DEBUG_ERROR | DEBUG_SOCKET_POLL, |
| "ERROR - errno: %d\r\n", |
| errno )); |
| } |
| |
| pPoll = pWebServer->pFdList; |
| ppPort = pWebServer->ppPortList; |
| while ( 0 < FDCount ) { |
| // |
| // Walk the list of ports to determine what work needs to be done |
| // |
| if ( 0 != pPoll->revents ) { |
| // |
| // Process this port |
| // |
| Status = PortWork ( pWebServer, |
| pPoll->fd, |
| pPoll->revents, |
| *ppPort ); |
| pPoll->revents = 0; |
| |
| // |
| // Close the port if necessary |
| // |
| if ( EFI_ERROR ( Status )) { |
| PortRemove ( pWebServer, pPoll->fd ); |
| pPoll -= 1; |
| ppPort -= 1; |
| } |
| |
| // |
| // Account for this file descriptor |
| // |
| FDCount -= 1; |
| } |
| |
| // |
| // Set the next port |
| // |
| pPoll += 1; |
| ppPort += 1; |
| } |
| |
| DEBUG (( DEBUG_SOCKET_POLL, "Exiting SocketPoll\r\n" )); |
| } |
| |
| |
| /** |
| Create an HTTP port for the web server |
| |
| This routine polls the network layer to create an HTTP port for the |
| web server. More than one attempt may be necessary since it may take |
| some time to get the IP address and initialize the upper layers of |
| the network stack. |
| |
| After the HTTP port is created, the socket layer will manage the |
| coming and going of the network connections until the last network |
| connection is broken. |
| |
| @param [in] pWebServer The web server control structure address. |
| @param [in] AddressFamily Address family for the network connection |
| @param [in] Protocol Protocol to use for the network connection |
| @param [in] HttpPort Port number for the HTTP connection |
| @param [out] pPort Address of the port |
| |
| **/ |
| VOID |
| WebServerListen ( |
| IN DT_WEB_SERVER * pWebServer, |
| IN sa_family_t AddressFamily, |
| IN int Protocol, |
| IN UINT16 HttpPort, |
| OUT int * pPort |
| ) |
| { |
| union { |
| struct sockaddr_in v4; |
| struct sockaddr_in6 v6; |
| } WebServerAddress; |
| int SocketStatus; |
| EFI_STATUS Status; |
| |
| DEBUG (( DEBUG_SERVER_LISTEN, "Entering WebServerListen\r\n" )); |
| |
| // |
| // Attempt to create the socket for the web server |
| // |
| * pPort = socket ( AddressFamily, SOCK_STREAM, Protocol ); |
| if ( -1 != *pPort ) { |
| // |
| // Build the socket address |
| // |
| ZeroMem ( &WebServerAddress, sizeof ( WebServerAddress )); |
| if ( AF_INET == AddressFamily ) { |
| WebServerAddress.v4.sin_len = sizeof ( WebServerAddress.v4 ); |
| WebServerAddress.v4.sin_family = AddressFamily; |
| WebServerAddress.v4.sin_port = htons ( HttpPort ); |
| } |
| else { |
| WebServerAddress.v6.sin6_len = sizeof ( WebServerAddress.v6 ); |
| WebServerAddress.v6.sin6_family = AddressFamily; |
| WebServerAddress.v6.sin6_port = htons ( HttpPort ); |
| WebServerAddress.v6.sin6_scope_id = __IPV6_ADDR_SCOPE_GLOBAL; |
| } |
| |
| // |
| // Bind the socket to the HTTP port |
| // |
| SocketStatus = bind ( *pPort, |
| (struct sockaddr *) &WebServerAddress, |
| WebServerAddress.v4.sin_len ); |
| if ( -1 != SocketStatus ) { |
| // |
| // Enable connections to the HTTP port |
| // |
| SocketStatus = listen ( *pPort, SOMAXCONN ); |
| if ( -1 != SocketStatus ) { |
| // |
| // Add the HTTP port to the list of ports to poll |
| // |
| Status = PortAdd ( pWebServer, *pPort ); |
| if ( EFI_ERROR ( Status )) { |
| SocketStatus = -1; |
| } |
| else { |
| DEBUG (( DEBUG_PORT_WORK, |
| "Listening on Tcp%d:%d\r\n", |
| ( AF_INET == AddressFamily ) ? 4 : 6, |
| HttpPort )); |
| } |
| } |
| } |
| |
| // |
| // Release the socket if necessary |
| // |
| if ( -1 == SocketStatus ) { |
| close ( *pPort ); |
| *pPort = -1; |
| } |
| } |
| |
| DEBUG (( DEBUG_SERVER_LISTEN, "Exiting WebServerListen\r\n" )); |
| } |
| |
| |
| /** |
| Entry point for the web server application. |
| |
| @param [in] Argc The number of arguments |
| @param [in] Argv The argument value array |
| |
| @retval 0 The application exited normally. |
| @retval Other An error occurred. |
| **/ |
| int |
| main ( |
| IN int Argc, |
| IN char **Argv |
| ) |
| { |
| UINT16 HttpPort; |
| UINTN Index; |
| DT_WEB_SERVER * pWebServer; |
| EFI_STATUS Status; |
| UINT64 TriggerTime; |
| |
| // |
| // Get the HTTP port |
| // |
| HttpPort = PcdGet16 ( WebServer_HttpPort ); |
| DEBUG (( DEBUG_HTTP_PORT, |
| "HTTP Port: %d\r\n", |
| HttpPort )); |
| |
| // |
| // Create a timer event to start HTTP port |
| // |
| pWebServer = &mWebServer; |
| Status = gBS->CreateEvent ( EVT_TIMER, |
| TPL_WEB_SERVER, |
| NULL, |
| NULL, |
| &pWebServer->TimerEvent ); |
| if ( !EFI_ERROR ( Status )) { |
| TriggerTime = HTTP_PORT_POLL_DELAY * ( 1000 * 10 ); |
| Status = gBS->SetTimer ( pWebServer->TimerEvent, |
| TimerPeriodic, |
| TriggerTime ); |
| if ( !EFI_ERROR ( Status )) { |
| // |
| // Run the web server forever |
| // |
| pWebServer->HttpListenPort = -1; |
| pWebServer->HttpListenPort6 = -1; |
| pWebServer->bRunning = TRUE; |
| do { |
| // |
| // Poll the network layer to create the HTTP port |
| // for the web server. More than one attempt may |
| // be necessary since it may take some time to get |
| // the IP address and initialize the upper layers |
| // of the network stack. |
| // |
| if (( -1 == pWebServer->HttpListenPort ) |
| || ( -1 == pWebServer->HttpListenPort6 )) { |
| do { |
| // |
| // Wait a while before polling for a connection |
| // |
| if ( EFI_SUCCESS != gBS->CheckEvent ( pWebServer->TimerEvent )) { |
| if ( 0 != pWebServer->Entries ) { |
| break; |
| } |
| gBS->WaitForEvent ( 1, &pWebServer->TimerEvent, &Index ); |
| } |
| |
| // |
| // Poll for a network connection |
| // |
| if ( -1 == pWebServer->HttpListenPort ) { |
| WebServerListen ( pWebServer, |
| AF_INET, |
| IPPROTO_TCP, |
| HttpPort, |
| &pWebServer->HttpListenPort ); |
| } |
| if ( -1 == pWebServer->HttpListenPort6 ) { |
| WebServerListen ( pWebServer, |
| AF_INET6, |
| IPPROTO_TCP, |
| HttpPort, |
| &pWebServer->HttpListenPort6 ); |
| } |
| |
| // |
| // Continue polling while both network connections are |
| // not present |
| // |
| } while ( 0 == pWebServer->Entries ); |
| } |
| |
| // |
| // Poll the sockets for activity while both network |
| // connections are connected |
| // |
| do { |
| SocketPoll ( pWebServer ); |
| } while ( pWebServer->bRunning |
| && ( -1 != pWebServer->HttpListenPort ) |
| && ( -1 != pWebServer->HttpListenPort6 )); |
| |
| // |
| // Continue polling the network connections until both |
| // TCP4 and TCP6 are connected |
| // |
| } while ( pWebServer->bRunning ); |
| |
| // |
| // Stop the timer |
| // |
| gBS->SetTimer ( pWebServer->TimerEvent, |
| TimerCancel, |
| 0 ); |
| } |
| |
| // |
| // Done with the timer event |
| // |
| gBS->CloseEvent ( pWebServer->TimerEvent ); |
| } |
| |
| // |
| // Return the final status |
| // |
| DBG_EXIT_STATUS ( Status ); |
| return Status; |
| } |
