ippSimpleClient.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. 
#include "stdafx.h"
#include "ippdme/Server/ippSimpleClient.h"
#include "ippdme/Response/ippErrorResponse.h"
#include "ippdme/assert.h"

ippSimpleClient::ippSimpleClient()
:_state(disconnected)
,_ready_to_send(false)
,_in_error_state(false)
,_next_tag(1)
{
  _pending_tag=0;
}

void ippSimpleClient::Connect(
  const char* hostname,
  int port
)
{
  IPP_ASSERT(_state== disconnected);
  
  if(_state != disconnected) {
    return;
  }
  
  
  while(!_pending_commands.empty()) {
    _pending_commands.pop();
  }

  bool bSuccess = _socket.Create();
  IPP_ASSERT(bSuccess);
 

  ippSocket::SERROR nRet =  _socket.Connect(hostname,port);
  if (nRet == ippSocket::SOCKET_WOULD_BLOCK) {
    //
    _state = trying_to_connect;
  } else  if (nRet == ippSocket::SOCKET_IS_CONNECTED) { 
    _state = connected;
    _in_error_state = false;
    _ready_to_send = true;
  } else {
    _state = disconnected;
    _socket.Close();
  }
}

ippSimpleClient::STATE ippSimpleClient::GetState() const
{
  return _state;
}

bool ippSimpleClient::ReadyToSend() const
{
  return _state == connected && _ready_to_send;
}

bool ippSimpleClient::NeedToSendClearAllErrors() const
{
  return _in_error_state;
}

void ippSimpleClient::Disconnect()
{
   ProbeConnection();
  _state = disconnected;
  _socket.Close();
  _ready_to_send = false;
  _in_error_state = false;
  
  LogMessage(" disconnected","");
}


void ippSimpleClient::HeartBeat()
{
  ippSleep(1); // allow context switch
  switch(_state){
  case trying_to_connect:
    {
      switch(_socket.CanSendData()){ 
        case ippSocket::SOCKET_OK: 
          _ready_to_send = true;
          _in_error_state = false;
          _state = connected; 
        break;
        case ippSocket::SOCKET_WOULD_BLOCK:
          // this mean that the server is probably busy
          Disconnect();
          break;
        default:
          _state = disconnected;
          _socket.Close();
        }
      } break;
  case connected:
    {
      PerformRead();
    }
  }
}




#include "ippdme/Parser/ippResponseParser.h"

void ippSimpleClient::ProcessLine(const char* inputline)
{
  
  LogMessage("received:",inputline);

  ippResponseParser parser;
  parser.setInput(inputline);
  parser.parseTag();
  ipp::parserResErrorId         code = parser.getParserErr();                           

  if (code != ipp::OK) {
    // the parsing of the TAG of the received line has failed
    std::string errorMessage = parser.getErrorMessageString();
    char buf[IPPSIZE];
    sprintf(buf,"Response Error: %s", errorMessage.c_str());
    LogMessage("Response Error:",errorMessage.c_str());
  }

  // Check to see if this is an Event tag
  if ( parser.getTagType() == EventTag ) {
    // Event Tag
    // If message is E0000 this is an unsolicited event
    // such as as Error from the server because an illegal
    // tag was sent. 
    //
    // see $4.1 in ippdme spec. the tag E0000 is reserved
    //          for event with no relation to legal tags
    //
    //     $4.4 Server events use tag E0000. They are used to
    //          report manual hits, keystrokes, supported
    //          machine status changes...
    if ( std::string(inputline,7) == "E0000 !") { 
       // illegal tag probably
       ippResponsePtr response = parser.parseResponse();
       if(response) {
          ippErrorResponsePtr e = static_cast<ippErrorResponse*>(response.get());
          ippErrorNameType error= e->getTheError()->getName();    
          if (BufferFull ==error ||IllegalCharacter==error  || IllegalTag==error || NoSpaceAtPos6==error){
            _ready_to_send= true;
          } else {
            OnUnsollicitedEvent(response);
          }
       } else {
         IPP_ASSERT_FAIL("What should we do here ?");
       }
    }
  }
  char  response_char = inputline[6];

  ippResponsePtr response = parser.parseResponse();
 
  int read_tag = parser.getTag();

  // Check for the ACK from previous command
  if (response_char == '&')     {                        // acknowledge           

    if (_pending_tag == read_tag){      
      // we are now allowed to push a new command to the server      
      _ready_to_send= true; 
      
      _next_tag++;            
      // let put this tag to the uncompleted command queue
      if (response->getTag().getTagType() == CommandTag) { 
        _pending_commands.push(_pending_tag); 
      }
      _pending_tag = 0;
    } else {
      LogMessage("Response Error:","Tags do not match");
    }

  }     else if (response_char == '!') { // Error  !
  
    if (_pending_tag==read_tag) {
       // An Error was returned                                 
       _next_tag++;     
    }

    //xx LogMessage("Response Error:","ERROR Returned");

    // Have to parse the error to check severity
    // Anything larger than 1 requires ClearAllErros be sent
    if (inputline[9] != '1') {
      //xx LogMessage("Response Error:","ERROR - Must send ClearAllErrors()");
      _in_error_state = true;
    }
    ippResponsePtr response = parser.parseResponse();
    OnErrorResponse(response);

  } else if (response_char == '%'){
    
    // Transaction complete 
    ippResponsePtr response = parser.parseResponse();
    
    if (parser.getTagType() == EventTag) { 
      // completion of a command of the fast queue
      OnComnmandCompleted(response->getTag().getTagNumber());
    } else {
      
      // completion of a command of the slow queue
      tagIdType type = response->getTag().getTagType();
      if (type == CommandTag) { 
        // verify that the completion tag matches the tag of the currently executed command 
        if ( _pending_commands.size()>0 && _pending_commands.front()== response->getTag().getTagNumber() ) {
           _pending_commands.pop();
           OnComnmandCompleted(response->getTag().getTagNumber());
        } else {
          LogMessage("Unexpected completed command:","Tags do not match");
        }
      } else {
        OnComnmandCompleted(response->getTag().getTagNumber());
      }
    }
  
  }     else if (response_char == '#') { // Data follows

    ippResponsePtr response = parser.parseResponse();
    
    if(response) {
    
      if (response->getTag().getTagType() == CommandTag ) {  
        // process a response that belongs to the currently executed command
        if ( _pending_commands.front()== response->getTag().getTagNumber())  {
          OnResponse(response);
        } else {
          // this is a unexpected tag !
          LogMessage("unexpected response tag number:","Tags do not match");
        }
      } else {
        // process a event response ( from a daemon ) 
        // [TODO] verifies that the tag id must belongs to a existing daemon
        IPP_ASSERT_MSG(response->getTag().getTagNumber()!=0," should not be an unsollicited event");
        OnDaemonResponse(response);
      }
    } else {
      IPP_ASSERT_FAIL(" to do : be smart here ") ;
    }
  }     else {
    IPP_ASSERT_FAIL(" to do : be smart here ") ;
    // Bad value in response character
  }
}

void ippSimpleClient::ProcessMisformedLine(const char* inputline)
{
  LogMessage("received malformed string:",inputline);
  // a malformed string has been received from the client 
  // we do need to disconnect !!!
  Disconnect();
}

bool ippSimpleClient::SendCommand(ippCommandConstPtr command)
{
  SendCommand(command->getCommandString().c_str());
  return true;
}

void ippSimpleClient::OnConnectionLost()
{
  LogMessage(" connection lost","");
  Disconnect();
}

void ippSimpleClient::SendCommand(const char* command)
{
  IPP_ASSERT(_ready_to_send);
  LogMessage("     send :",command);
  
  if(command[0]=='E') {
    sscanf(command+1,"%4d",&_pending_tag);
  } else {
    sscanf(command,"%5d",&_pending_tag);
  }
 
  _socket.Write(command);
  
  // see if we need to send the line termination
  int l = strlen(command);
  if (l > 2 && command[l-1] != '\n' && command[l-2]!='\r') { 
     _socket.Write("\r\n");
  }

  _ready_to_send = false;
  // read the acknowledge tag
}

void ippSimpleClient::ClearAllErrors()
{
  IPP_ASSERT(NeedToSendClearAllErrors());
  _pending_commands.empty(); 
  SendCommand(new ippCommand(_next_tag,ipp::ClearAllErrors));
  _in_error_state = false;
}

int ippSimpleClient::NumberOfUncompletedCommandsInQueue()
{
  return _pending_commands.size();
}

void ippSimpleClient::OnErrorResponse(ippResponsePtr response)
{

}
void ippSimpleClient::OnDaemonResponse(ippResponsePtr response)
{

}
void ippSimpleClient::OnResponse(ippResponsePtr response)
{

}

void ippSimpleClient::OnUnsollicitedEvent(ippResponsePtr response)
{

}
void ippSimpleClient::OnComnmandCompleted(int tagNumber)
{

}

---