audk/AppPkg/Applications/Sockets/WebServer/WebServer.c

/*++
  This file contains an 'Intel UEFI Application' and is        
  licensed for Intel CPUs and chipsets under the terms of your  
  license agreement with Intel or your vendor.  This file may   
  be modified by the user, subject to additional terms of the   
  license agreement                                             
--*/
/*++

Copyright (c)  2011 Intel Corporation. All rights reserved
This software and associated documentation (if any) is furnished
under a license and may only be used or copied in accordance
with the terms of the license. Except as permitted by such
license, no part of this software or documentation may be
reproduced, stored in a retrieval system, or transmitted in any
form or by any means without the express written consent of
Intel Corporation.

--*/

/** @file
  This is a simple shell application

  This should be executed with "/Param2 Val1" and "/Param1" as the 2 command line options!

**/

#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 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 ) {
      //
      //  Handle connection attempts
      //  Accepts arrive as read events
      //
      RemoteAddressLength = sizeof ( RemoteAddress );
      NewSocket = accept ( SocketFD,
                           &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 the HTTP port for the web server

  This routine polls 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.

  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.

**/
VOID
WebServerTimer (
  IN DT_WEB_SERVER * pWebServer
  )
{
  UINT16 HttpPort;
  struct sockaddr_in WebServerAddress;
  int SocketStatus;
  EFI_STATUS Status;

  DEBUG (( DEBUG_SERVER_TIMER, "Entering WebServerTimer\r\n" ));

  //
  //  Open the HTTP port on the server
  //
  do {
    do {
      //
      //  Complete the client operations
      //
      SocketPoll ( pWebServer );

      //
      //  Wait for a while
      //
      Status = gBS->CheckEvent ( pWebServer->TimerEvent );
    } while ( EFI_SUCCESS != Status );

    //
    //  Attempt to create the socket for the web server
    //
    pWebServer->HttpListenPort = socket ( AF_INET,
                                          SOCK_STREAM,
                                          IPPROTO_TCP );
    if ( -1 != pWebServer->HttpListenPort ) {
      //
      //  Set the socket address
      //
      ZeroMem ( &WebServerAddress, sizeof ( WebServerAddress ));
      HttpPort = PcdGet16 ( WebServer_HttpPort );
      DEBUG (( DEBUG_HTTP_PORT,
                "HTTP Port: %d\r\n",
                HttpPort ));
      WebServerAddress.sin_len = sizeof ( WebServerAddress );
      WebServerAddress.sin_family = AF_INET;
      WebServerAddress.sin_addr.s_addr = INADDR_ANY;
      WebServerAddress.sin_port = htons ( HttpPort );

      //
      //  Bind the socket to the HTTP port
      //
      SocketStatus = bind ( pWebServer->HttpListenPort,
                            (struct sockaddr *) &WebServerAddress,
                            WebServerAddress.sin_len );
      if ( -1 != SocketStatus ) {
        //
        //  Enable connections to the HTTP port
        //
        SocketStatus = listen ( pWebServer->HttpListenPort,
                                SOMAXCONN );
      }
  
      //
      //  Release the socket if necessary
      //
      if ( -1 == SocketStatus ) {
        close ( pWebServer->HttpListenPort );
        pWebServer->HttpListenPort = -1;
      }
    }

    //
    //  Wait until the socket is open
    //
  }while ( -1 == pWebServer->HttpListenPort );

  DEBUG (( DEBUG_SERVER_TIMER, "Exiting WebServerTimer\r\n" ));
}


/**
  Start the web server port creation timer

  @param [in] pWebServer  The web server control structure address.

  @retval EFI_SUCCESS         The timer was successfully started.
  @retval EFI_ALREADY_STARTED The timer is already running.
  @retval Other               The timer failed to start.

**/
EFI_STATUS
WebServerTimerStart (
  IN DT_WEB_SERVER * pWebServer
  )
{
  EFI_STATUS Status;
  UINT64 TriggerTime;

  DBG_ENTER ( );

  //
  //  Assume the timer is already running
  //
  Status = EFI_ALREADY_STARTED;
  if ( !pWebServer->bTimerRunning ) {
    //
    //  Compute the poll interval
    //
    TriggerTime = HTTP_PORT_POLL_DELAY * ( 1000 * 10 );
    Status = gBS->SetTimer ( pWebServer->TimerEvent,
                             TimerPeriodic,
                             TriggerTime );
    if ( !EFI_ERROR ( Status )) {
      DEBUG (( DEBUG_HTTP_PORT, "HTTP port timer started\r\n" ));

      //
      //  Mark the timer running
      //
      pWebServer->bTimerRunning = TRUE;
    }
    else {
      DEBUG (( DEBUG_ERROR | DEBUG_HTTP_PORT,
                "ERROR - Failed to start HTTP port timer, Status: %r\r\n",
                Status ));
    }
  }

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}


/**
  Stop the web server port creation timer

  @param [in] pWebServer  The web server control structure address.

  @retval EFI_SUCCESS   The HTTP port timer is stopped
  @retval Other         Failed to stop the HTTP port timer

**/
EFI_STATUS
WebServerTimerStop (
  IN DT_WEB_SERVER * pWebServer
  )
{
  EFI_STATUS Status;

  DBG_ENTER ( );

  //
  //  Assume the timer is stopped
  //
  Status = EFI_SUCCESS;
  if ( pWebServer->bTimerRunning ) {
    //
    //  Stop the port creation polling
    //
    Status = gBS->SetTimer ( pWebServer->TimerEvent,
                             TimerCancel,
                             0 );
    if ( !EFI_ERROR ( Status )) {
      DEBUG (( DEBUG_HTTP_PORT, "HTTP port timer stopped\r\n" ));

      //
      //  Mark the timer stopped
      //
      pWebServer->bTimerRunning = FALSE;
    }
    else {
      DEBUG (( DEBUG_ERROR | DEBUG_HTTP_PORT,
                "ERROR - Failed to stop HTTP port timer, Status: %r\r\n",
                Status ));
    }
  }

  //
  //  Return the operation status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}

/**
  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
  )
{
  DT_WEB_SERVER * pWebServer;
  EFI_STATUS Status;

  //
  //  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 )) {
    Status = WebServerTimerStart ( pWebServer );
    if ( !EFI_ERROR ( Status )) {
      //
      //  Run the web server forever
      //
      for ( ; ; ) {
        //
        //  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.
        //
        WebServerTimer ( pWebServer );

        //
        //  Add the HTTP port to the list of ports
        //
        Status = PortAdd ( pWebServer, pWebServer->HttpListenPort );
        if ( !EFI_ERROR ( Status )) {
          //
          //  Poll the sockets for activity
          //
          do {
            SocketPoll ( pWebServer );
          } while ( -1 != pWebServer->HttpListenPort );

          //
          //  The HTTP port failed the accept and was closed
          //
        }

        //
        //  Close the HTTP port if necessary
        //
        if ( -1 != pWebServer->HttpListenPort ) {
          close ( pWebServer->HttpListenPort );
          pWebServer->HttpListenPort = -1;
        }
//
// TODO: Remove the following test code
//  Exit when the network connection is broken
//
break;
      }

      //
      //  Done with the timer event
      //
      WebServerTimerStop ( pWebServer );
      Status = gBS->CloseEvent ( pWebServer->TimerEvent );
    }
  }

  //
  //  Return the final status
  //
  DBG_EXIT_STATUS ( Status );
  return Status;
}