ippEngine.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 Allow multiline transaction
//-----------------------------------------------------------------------------
#include "stdafx.h"
#include "ippdme/Server/ippEngine.h"
#include "ippdme/Server/ippLogger.h"
#include "ippdme/assert.h"

ippEngine::ippEngine()
:_logger(0)
{
        memset(_assemblyBuffer, 0, sizeof(_assemblyBuffer));
}


ippEngine::~ippEngine()
{
  _socket.Close();
}

void ippEngine::setLogger(ippLogger* logger)
{
  _logger = logger;
}

void ippEngine::LogMessage(const char* data1,const char* data2)
{
  if(_logger) { 
    std::string str(data1);
    if (data2) {
      str+=data2;
    }
    _logger->WriteLine(str.c_str());
  }
}


void ippEngine::PerformRead()
// History
// Who When     What
// --- -------- ---------------------------------------------------------------
// ER  08/03/06 Account for multiple lines to be parsed in one packet
//-----------------------------------------------------------------------------
{  
  
  static char _data[IPPSIZE];
  memset(_data,0,sizeof(_data));

  if (!readdata(_data,sizeof(_data)))  {
    return; // no data ready or in error state
  }
  
  if(_data[0] == 0 ) { 
    return; // we read a empty string
  }

        // concatenate with existing data in buffer
  strcat(_assemblyBuffer, _data);
  

        int lastChar = strlen(_assemblyBuffer);
  int endLine = 0;

  while (endLine == 0 ) {
    //Scan the buffer for carriage returns and line feeds
          int crCount=0; 
          int lfCount=0;
    int invalidCount = 0;

          for (int i=0; i<lastChar; i++) {
      char c = _assemblyBuffer[i];
                  if(c==13) { crCount++; }
                  else if(c==10) { lfCount++; }
      else if ( c<' ' || c>'~') {
        invalidCount++; // character must be >32 and <126 except for CR and LF
      }
      if (_assemblyBuffer[i-1]=='\r' && _assemblyBuffer[i]=='\n') {
        endLine=i;
        break;
      }
    }   
           
          if (endLine>0)
    {
       // marks the string end after \r\n 
       // but remember old character to restore it later
       int old = _assemblyBuffer[endLine+1];
       _assemblyBuffer[endLine+1] = 0;

      IPP_ASSERT(_assemblyBuffer[endLine-1]==13 && _assemblyBuffer[endLine]==10);
      if (crCount==1 && lfCount==1 && invalidCount ==0) {
        // we must have only one \r\n
              ProcessLine(_assemblyBuffer);
      } else {
        ProcessMisformedLine(_assemblyBuffer);
      }
      
      // restore old char that we previouslt set to 0
      _assemblyBuffer[endLine+1] = old;
      
      // prepare for next portion of the string
      memmove(_assemblyBuffer,_assemblyBuffer+endLine+1,lastChar-endLine+1);
      lastChar-=endLine+1;
      endLine = 0;

      //xx memset(_assemblyBuffer,0,sizeof(_assemblyBuffer));

    } else {
      break;
    }
  }
}



bool ippEngine::readdata(char* buffer,int sizebuffer)
{
  if (!_socket.IsValid()){
    return false;
  }
  buffer[0]=0;
  int  nRet = _socket.Read(buffer,sizebuffer);
  if (nRet != 0 ) {    
    if (nRet == ippSocket::SOCKET_WOULD_BLOCK) { 
      // no data ready to read yet
      return true;    
    } else {
      // the socket has disconnected
      _socket.Close();
      OnConnectionLost();
      return false;    
    }
  }
  return true;
}
void ippEngine::OnConnectionLost()
{
}

void ippEngine::ProbeConnection()
{
  if (_socket.IsValid()) { 
   
    if (_socket.Ping() != ippSocket::SOCKET_OK) { 
      _socket.Close();
      OnConnectionLost();
      return;

    }
  }
}



ippLogger* ippEngine::GetLogger() const
{
  return _logger;
}

---