ippSimpleServer.cpp

Go to the documentation of this file.

// 
// DISCLAIMER: 
//  This software was produced by the National Institute of Standards 
//  and Technology (NIST), an agency of the U.S. government, and by statute is 
//  not subject to copyright in the United States.  Recipients of this 
//  software assume all responsibility associated with its operation,
//  modification,maintenance, and subsequent redistribution. 
//
//  See NIST Administration Manual 4.09.07 b and Appendix I. 
//
// History
// Who When     What
// --- -------- ---------------------------------------------------------------
// ER  09/03/06 Fix handling of error and processing of executor responses
//-----------------------------------------------------------------------------
#include "stdafx.h"

#include "ippdme/Server/ippSimpleServer.h"
#include "ippdme/Server/ippEngine.h"
#include "ippdme/parser/ippCommandParser.h"

#include "ippdme/Executor/ippExecutor.h"
#include "ippdme/Checker/ippCommandChecker.h"

#include "ippdme/Response/ippErrorResponse.h"
#include "ippdme/Response/ippCompleteResponse.h"
#include "ippdme/assert.h"


ippSimpleServer::ippSimpleServer(ippExecutor* executor)
: _portNumber(1294)
, _checker(0)
, _state(uninitialized)
, _inSession(false)
, _tagBeingExecuted(0)
, _executor(executor)
, _inErrorState(false)
{
  ippSocket::Initialize();
}

ippSimpleServer::~ippSimpleServer()
{
  PowerOff();
}

void ippSimpleServer::HeartBeat()
{
  ippSleep(1); // allow context switch
  switch(_state)
  {
  case uninitialized:
    return;
  case listening:
    PerformListening();
    return;
  case connected:
    PerformRead();
    PerformExecute();
    PerformWrite();
    ProbeConnection();
    return;
  }
}


bool ippSimpleServer::InSession() const
{
  return _inSession;
}

bool ippSimpleServer::PowerOn(int portNumber)
{
  _portNumber = portNumber;
  if (_state!=uninitialized ) {
    return false;
  }
  // Create a TCP/IP stream socket to "listen" 
  // incoming client connection
  if (!_listenSocket.Listen(_portNumber)) { 
          return false;
  }
  _state = listening;
  _inSession = false;
  return true;
}

bool ippSimpleServer::PowerOff()
{
  _listenSocket.Close();
  _socket.Close();
  _state = uninitialized;
  _inSession = false;
  return true;
}

bool ippSimpleServer::GetLogDetails() const
{
  return true;
}


void ippSimpleServer::OnConnectionLost()
{
  OnClientDisconnected();

  // when a connection is lost the server goes
  // back to listen mode.
  // Create a TCP/IP stream socket to "listen" with
  if (!_listenSocket.Listen(_portNumber)) { 
    _state=uninitialized;
    _inSession = false;
  } else {
    _state=listening;
    _inSession = false;
  }
}

void ippSimpleServer::OnClientConnected()
{
        // Clear All Queues
  _serverQueues.ClearAllQueues();
  
  if(_executor) {
     _executor->resetExecutor();
  }

  IPP_ASSERT(!_inSession);
}
void ippSimpleServer::OnClientDisconnected()
{
        // Clear All Queues
  _serverQueues.ClearAllQueues(); 
  // a disconnection will require a StartSession to be resent
  _inSession = false;
  LogMessage(" the client has disconnected");
  StopAllDaemons();
}

void ippSimpleServer::StopAllDaemons()
{
  if(_executor) {
    _executor->StopAllDaemons();
  }
}

int ippSimpleServer::DaemonCount() const
{
  if(_executor) {
    return _executor->DaemonCount();
  }
  return 0;
}

void ippSimpleServer::ProcessLine(const char* commandBuffer)
{
  LogMessage(" received :",commandBuffer);
  ProcessCommand(commandBuffer);
}

void ippSimpleServer::ProcessMisformedLine(const char* commandBuffer)
{
  
  // although the string is malformed it may contain a valid 
  // tag. let try to extract it so we can send the ACK packet back

  ippCommandParser parser;
  parser.setInput(commandBuffer); // Set the parser input string         
        parser.parseTag();                                     // Parse the tag
        int parser_tag = parser.getTag();
  if(parser.getIsEvent()) {
    parser_tag = parser_tag * (-1);
  }
  // Determining if Event or Command Tag
  tagIdType tt = (parser.getIsEvent()) ?  EventTag : CommandTag;

        // Build Ack Response
  SendAcknowledge(ippTag(parser.getTag(),tt));

  
  // the line contains some illegal characters
  ippErrorResponsePtr resp =
    new ippErrorResponse(0000, EventTag,IllegalCharacter, commandBuffer);

  SendError(resp,"misformed input ");           
  
  IPP_ASSERT(_tagBeingExecuted == 0);
  _tagBeingExecuted = parser.getTag();
  SendComplete(ippTag(parser.getTag(),tt));   


}


void ippSimpleServer::ProcessCommand(const char* commandBuffer)
{

  ippCommandParser parser1;
  parser1.setInput(commandBuffer); // Set the parser input string        
        parser1.parseTag();                                    // Parse the tag
        int parser1_tag = parser1.getTag();
  if(parser1.getIsEvent()) {
    parser1_tag = parser1_tag * (-1);
  }

  // Determining if Event or Command Tag
  tagIdType tt = (parser1.getIsEvent()) ?  EventTag : CommandTag;

        ippParserCmdErrorId  parser1_code = parser1.getParserErr();

        // If parser error (i.e. bad tag), produce error Response
        if(parser1_code != OK)
        {
    char errorCauseMethod[IPPSIZE] = "";
                if(GetLogDetails()) {
      std::string errorMessage = parser1.getErrorMessageString();
                        sprintf(errorCauseMethod,"%s : %s",commandBuffer, errorMessage.c_str());
                }
    else{
      sprintf(errorCauseMethod,"%s",commandBuffer);
    }
    ippErrorResponsePtr resp =
        new ippErrorResponse(0000, EventTag,IllegalTag, errorCauseMethod);
    
    std::string errorMessage = parser1.getErrorMessageString();
    SendError(resp,errorMessage.c_str());               
    return; 
  }

  // tag is well formed , but it might be already in use !

        // Build Ack Response
  SendAcknowledge(ippTag(parser1.getTag(),tt));


  if(_serverQueues.tagInList(parser1_tag))  // Check the tag in session list
        {
                // If tag in session, produce an IllegalTag Response
                char errorCauseMethod[IPPSIZE]="";
    if(GetLogDetails()) {
                         sprintf(errorCauseMethod,"%s : TAG NUMBER IN USE",commandBuffer);
    } else {
       sprintf(errorCauseMethod,"%s",commandBuffer);
    }
    
    ippErrorResponsePtr resp =
      new ippErrorResponse(0000, EventTag,IllegalTag, errorCauseMethod);

    SendError(resp,"TAG NUMBER IN USE");                
    return; 
  }

  
  _serverQueues.addTag(parser1_tag);// Add tag # to active tag list
                                        
        /****************************************************************/
        /*                                                              */
        /*    If Command tag, place command on "slow queue"             */
        /*                                                              */
        /*    Else If Event tag, place command on "fast" queue          */
        /*                                                              */
        /****************************************************************/

  if (tt==CommandTag) {
    _serverQueues.EnqueueCommand(commandBuffer);                                                
        }       else if (tt==EventTag){                                         
    // put on fast queue
                _serverQueues.EnqueueEvent(commandBuffer);
        }

                                        
}



void ippSimpleServer::SendAcknowledge(const ippTag& tag)
{
  SendResponse(new ippResponse(tag.getTagNumber(), tag.getTagType(), Ack));
}


void ippSimpleServer::WriteToSocket(const char* line)
{
        LogMessage("  sent : ",line);
  int nRet = _socket.Write(line);
  if (nRet)  {
    OnConnectionLost();
  }
}
void ippSimpleServer::SendResponse(ippResponsePtr response)
{
  std::string responseStr = response->getResponseString();

  // special treatment for Ack Response, which is not queued,
  // we send it directly to the socket stream.
  if (response->getResponseName() == Ack) {
    // acknowledge the response, this time 
    WriteToSocket(response->getResponseString().c_str());

  }  else {
    if ( response->getResponseName() == Complete) {
      if (response->getTag().getTagType() == CommandTag) { 
        IPP_ASSERT(_tagBeingExecuted  == response->getTag().getTagNumber());
        _tagBeingExecuted = 0;
      }
    }
          //Log the Response
    // LogMessage("     pushing to queue :",responseStr.c_str());
          
    // send response buffer to the response queue
          _serverQueues.EnqueueResponse(responseStr.c_str());
    // Send to response queue
  }
}

void ippSimpleServer::SendError(
 ippErrorResponsePtr errResponse,
 const char* errorMessage
)
{
  std::string   responseStr = errResponse->getResponseString();

        if (errResponse->getTheError()->getSeverity() > '1'){
    _inErrorState = true;
                //xx _world1.setReadiness(erred);
                //xx _serverQueues.ClearAllQueues();
        }  
  // If set by user, write detailed parser errors to the log file.
        if(GetLogDetails()){
      //Log Ipp error response
      LogMessage("     pushing to queue :",responseStr.c_str());
      LogMessage("   parser :",errorMessage);
  }
  // send tag syntax error response buffer to the world response queue
  _serverQueues.EnqueueResponse(responseStr.c_str()); // Send to response queue

}
void ippSimpleServer::SendComplete(const ippTag& tag)
{
  ippResponsePtr _CompletedResponse = new ippCompleteResponse(tag.getTagNumber(), tag.getTagType());

        //Remove current tag from list
  if(tag.getTagType() == EventTag)   {
                _serverQueues.delTag(tag.getTagNumber()*(-1));
  }     else {
    _serverQueues.delTag(tag.getTagNumber());           
  }                     
  SendResponse(_CompletedResponse);
}


void ippSimpleServer::PerformWrite()
{
  // flush pending responses, and write them to the socket
  while(_serverQueues.ResponseQueueHasData()){
    std::string  resp = _serverQueues.DequeueResponse(); //get msg from response queue  
    IPP_ASSERT(resp.length()!=0);
    WriteToSocket(resp.c_str());
  } // end while

}


void ippSimpleServer::ProcessResponseList(const ippResponseList& responseList)
{
                for (size_t i=0; i<responseList.size(); i++) {
                        
                        // Get the response name
                        ippResponseNameType rnt = responseList[i]->getResponseName();

                        // Cast response to specific response
                        switch (rnt) {
                          case ErrorError: 
          {
            ippErrorResponsePtr er= static_cast<ippErrorResponse*>(responseList[i].get());
            SendError(er,"");
          } break;
        case Complete:
          {
            const ippTag& tag = responseList[i]->getTag();
            SendComplete(tag);
          } break;                      
                          default:
        {
          SendResponse(responseList[i]);                                                                                          
        }
                        }
    }
}


void ippSimpleServer::ExecuteCommand(ippCommandPtr aCommand)
{
 
  if (aCommand->getTag().getTagType()== CommandTag ) {
    IPP_ASSERT_MSG( _tagBeingExecuted ==0,
       " Should not be already executing a command, except a fast queue command");
    _tagBeingExecuted = aCommand->getTag().getTagNumber();
  }

  // two special commands are specifically handler by the 
  // simple server  start session / end session ....

  // 6.3.1 Server Methods
  // If no session is active, the server will accept only StartSession()
  // and EndSession() commands.

  if (aCommand->getCommandName() == StartSession)
  {
    if (!_inSession) { 
     
     _inSession = true;
     if (_executor) { 
       // delegate to the executor
       _executor->executeCommand(aCommand);
       ProcessResponseList(_executor->checkStatus());

     } else {
       // in absence of a dedicated executor , we simply generate a complete command
       // ( useful for testing ) 
       SendComplete(aCommand->getTag());
     }
     
     // 6.3.1.1 the client can be sure that no event nor daemon are pending
     //         from the session before.
     IPP_ASSERT(DaemonCount() == 0);

     // 6.3.1.1 : StartSession() implicitly executes ClearAllErrors()
     ClearAllErrors();

   
    } else {
      // already in session 
      // 6.3.1.1 : The client should not send a StartSession() command while a session is in progress.
      ippErrorResponsePtr resp =
        new ippErrorResponse(aCommand->getTag(),ProtocolError, "StartSession already called");

      SendError(resp,"");       
      SendComplete(aCommand->getTag());
      
    }

    return ;

  } else if (aCommand->getCommandName() == EndSession) {
    if (!_inSession) { 
       // 6.3.1: If an EndSession is received while no session is active, this command will do nothing.
      //        This handling will guarantee that sending an EndSession() followed by a 
      //        StartSession will start a new session in any case.
      SendComplete(aCommand->getTag());   
      return ;
    } else {

       // stop all daemon etc...      
       // 6.3.1.1 The method must make sure that all daemons are stopped and no events are sent
       //         after it completes.
       StopAllDaemons();
       IPP_ASSERT(DaemonCount() == 0);
    
       // delegate to the executor
       if (_executor) { 

         // delegate to the executor
         _executor->executeCommand(aCommand);
         ProcessResponseList(_executor->checkStatus());

       } else {
         // in absence of a dedicated executor , we simply generate a complete command
         // ( useful for testing ) 
         SendComplete(aCommand->getTag());
       }       

       _inSession =false;
    }
    return ;
  }


  if (!_inSession) {
    ippErrorResponsePtr resp =
        new ippErrorResponse(aCommand->getTag(),IllegalCommand, "StartSession not received");
    SendError(resp,"StartSession not received");
    SendComplete(aCommand->getTag());
    return;
  }



  if (_checker) {
    _checker->checkCommand(aCommand);   // Test command via the checker
        ippCheckerErrorId checker_code = _checker->getCheckerErr();
    
    if (checker_code != CHECKER_OK) {

                          char errorCauseMethod[IPPSIZE]="";

        std::string errorMessage = _checker->getErrorMessageString();
        std::string cmd = aCommand->getCommandString();
                          if(GetLogDetails()){
                                  sprintf(errorCauseMethod,"%s : %s",cmd.c_str(), errorMessage.c_str());
        }       else {
          sprintf(errorCauseMethod,"%s",cmd.c_str());
        }
       // the checker has failed
                 ippErrorNameType errType =  _checker->getIppErr(checker_code);

        SendError(
          new ippErrorResponse(aCommand->getTag(),errType,errorCauseMethod),errorMessage.c_str());        
        SendComplete(aCommand->getTag());                       
       return ;
    }
  }

  if (aCommand->getCommandName() == AbortE) {
    ExecuteAbortE(aCommand->getTag());
    return; // 
  }

  if (_inErrorState) { 
    // only ClearAllErrors / GetErrStatusE(), GetXtdErrStatus() can be called 
    // when the server is in error State
    if (aCommand->getCommandName() != ipp::ClearAllErrors && 
        aCommand->getCommandName() != ipp::GetErrStatusE && 
        aCommand->getCommandName() != ipp::GetXtdErrStatus 
      ) { 

        SendError(
          new ippErrorResponse(
          aCommand->getTag().getTagNumber(),aCommand->getTag().getTagType(),
          UseClearAllErrorsToCont,aCommand->getCommandString().c_str()),"");        
        SendComplete(aCommand->getTag());                       
        return;

    } 
  }

  if (aCommand->getCommandName() == ipp::ClearAllErrors) { 
    ClearAllErrors();
  }

  if (_executor) { 

    _executor->executeCommand(aCommand);
    ProcessResponseList(_executor->checkStatus());

  } else {

    // in absence of a dedicated executor , we simply generate a complete command
    // ( useful for testing ) 
    SendComplete(aCommand->getTag());
  }
}

void ippSimpleServer::ExecuteAbortE(const ippTag& tag)
{
  // we must complete all pending command first
  if (_executor) { 
     // delegate to the executor
     _executor->AbortCurrentCommand();
     ProcessResponseList(_executor->checkStatus());
  } else {
    IPP_ASSERT(_tagBeingExecuted==0);
    //xx SendError(new ippErrorResponse(aCommand->getTag(),TransactionAborted,""),"");        
    //xx SendComplete(aCommand->getTag());                      

  }
  // flush all pending command in the slow queue
  AbortPendingCommands();
  SendComplete(tag);
  
}
void ippSimpleServer::AbortPendingCommands()
{
  IPP_ASSERT(!IsProcessingSlowCommand());
  ippCommandParser parser;
  while(_serverQueues.CommandQueueHasData() ) { 
    std::string cmd = _serverQueues.DequeueCommand(); // get cmd from slow queue
    parser.setInput(cmd.c_str());
    parser.parseTag();// parse the tag
                ippParserCmdErrorId     parser_code = parser.getParserErr();
    if (parser_code == OK) {
                                _tagBeingExecuted = parser.getTag();
        ippErrorResponsePtr _ErrorResponse= 
          new ippErrorResponse(parser.getTag(),CommandTag,TransactionAborted,"");
                        SendError(_ErrorResponse,"some error");
        SendComplete(ippTag(parser.getTag(),CommandTag));
    }
  }
}
//
//
// return true if the server is still processing a slow command
// i.e the completion of the command being run has not yet been sent
//
bool ippSimpleServer::IsProcessingSlowCommand() const
{
   if (_tagBeingExecuted) { 
     return true;
   } 
   if(_executor) {
     return !_executor->readyToProcessSlowQueueCommand();
   } 
   return  (_tagBeingExecuted != 0);
}

void ippSimpleServer::PerformExecute()
{

  if (this->_executor) {
    // purge the executor from any pending responses
    ProcessResponseList(_executor->checkStatus());
  }


  bool command_exists = false;

  ippCommandParser parser;
  std::string cmd;
        /*******************************************************************************/
        /*                                                                             */
        /*                          Check for data on fast queue first                 */
        /*                                                                             */
        /*******************************************************************************/
        if(_serverQueues.EventQueueHasData()) { 

    command_exists = true;
                cmd = _serverQueues.DequeueEvent(); //get cmd from fast queue
                parser.setInput(cmd.c_str());      // feed the cmd to the parser        

  } 
        /*******************************************************************************/
        /*                                                                             */
        /*      If no fast queue data and there is no multi cycle command currently    */
        /*      running then check for data on the slow queue                          */
        /*                                                                             */
        /*******************************************************************************/
  else  if(_serverQueues.CommandQueueHasData() && !IsProcessingSlowCommand()) { 

    command_exists = true;
                cmd = _serverQueues.DequeueCommand(); // get cmd from slow queue
                parser.setInput(cmd.c_str());        // feed the cmd to the parser

  }

  /********************************************/
        /*                                          */
        /*  if a command was successfully dequeued  */
        /*                                          */
        /********************************************/
        if(command_exists) {
    
    parser.parseTag();// parse the tag

    //Check and record if event or command
    tagIdType tt = (parser.getIsEvent()) ?  EventTag : CommandTag;

          const ippCommandPtr aCommand = parser.parseCommand();// parse the command

                ippParserCmdErrorId     parser_code = parser.getParserErr();

                if (parser_code == OK) {// If the command parses OK
      ExecuteCommand(aCommand);
    }
                /************************************************************************/
                /*                                                                      */
                /*   The command  failed the parser              :                      */
                /*                                                                      */
                /*   1. Get the error code from the parser                              */
                /*   2. Generate an error response                                      */
                /*   3. Check error severity and update world if required               */
                /*   4. Put error response on the response queue                        */
                /*                                                                      */
                /************************************************************************/
    else { 

                                char errorCauseMethod[IPPSIZE]="";

                                if(GetLogDetails()){
          std::string errorMessage = parser.getErrorMessageString();
                                  sprintf(errorCauseMethod,"%s : %s",cmd.c_str(), errorMessage.c_str());
        }       else {
          sprintf(errorCauseMethod,"%s",cmd.c_str());
        }

                                ippErrorResponsePtr _ErrorResponse= 
          new ippErrorResponse(parser.getTag(),tt, 
                                                         getIppErr(parser_code),errorCauseMethod);
                        SendError(_ErrorResponse,"some error");
        
        IPP_ASSERT(_tagBeingExecuted ==0);
        _tagBeingExecuted = parser.getTag();
        SendComplete(ippTag(parser.getTag(),tt));

                        }
    }
}

//
//
//
//
void ippSimpleServer::PerformListening()
{
  IPP_ASSERT(_state == listening);
  IPP_ASSERT(!_socket.IsValid());
  IPP_ASSERT(_listenSocket.IsValid());
 
  ippSocket::SERROR nRet = _listenSocket.Accept(_socket);
  
  switch(nRet) {
  case ippSocket::SOCKET_WOULD_BLOCK:
                // xx PRINTSTATUS("Waiting for connection ...");
    break;
  case ippSocket::SOCKET_OK:
    // we don't want to accept new connection 
    _listenSocket.Close();
    _state = connected;
    OnClientConnected();
    break;
  default:
    // a major problem has occur ...
    _listenSocket.Close();
    _state = uninitialized;
    break;
  }
}

void ippSimpleServer::ClearAllErrors()
{
  _inErrorState = false;
}

---