ippSocket.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"
// Socket class implementation file
#include "ippdme/Socket/ippSocket.h"
#include "ippdme/assert.h"
#include "ippdme/winsock.h"

#pragma comment(lib,"wsock32.lib")
#pragma comment(lib,"Ws2_32.lib") // because we use W32 WS extensions
#include <iostream>
using  namespace std;

static void getErrorString(int* errCode,std::string& errMsg);

class ippSocketImpVerification
{
public:
  ippSocketImpVerification()
  {
    IPP_ASSERT(ippSocket::SOCKET_OK == 0);
    IPP_ASSERT(ippSocket::SOCKET_WOULD_BLOCK == WSAEWOULDBLOCK);
    IPP_ASSERT(ippSocket::SOCKET_IS_CONNECTED == WSAEISCONN);
  }
} assert;

class ippSocketImp
{
public:
  ippSocketImp();

  LPHOSTENT   _lpHostEntry;
  SOCKET          _theSocket;
  SOCKADDR_IN _saServer;
  int         _portNumber; 
  WSAEVENT    _Event;      
  
  mutable std::string _lastErrorMsg;
  mutable int         _lastError;
  // 
  
  ippSocket::SERROR SetNonBlocking();
  
  ippSocket::SERROR SetHostName(const char *hostName);

  void SetPortNumber(int portNumber);

  ippSocket::SERROR Connect();
  ippSocket::SERROR CanSendData();
  ippSocket::SERROR Read(char* buffer,int nb);
  ippSocket::SERROR Write(const char *sendbuf);
  ippSocket::SERROR Ping();
  bool Listen(int portNumber);
  ippSocket::SERROR Accept(ippSocket& socket);
  void Close();
  bool Create();
private:
  ippSocketImp(const ippSocketImp&);
  void operator=(const ippSocketImp&);

};


/*
 * ippSocket socket contructor
 */
ippSocketImp::ippSocketImp() 
 : _theSocket(INVALID_SOCKET)
 , _lastError(0)
 , _lpHostEntry(0)
 , _portNumber(1294)
 , _Event(WSA_INVALID_EVENT)
{
  memset(&_saServer,0,sizeof(_saServer));
}



ippSocket::ippSocket()
:_imp(new ippSocketImp())
{
}
/*
 * ippSocket socket destructor
 */
ippSocket::~ippSocket()
{  
        Close();
}


/*
 * set the socket non blocking
 */
ippSocket::SERROR ippSocketImp::SetNonBlocking()
{
        unsigned long arg = 1;
  if (ioctlsocket(_theSocket, FIONBIO, &arg)<0) {
          getErrorString(&_lastError,_lastErrorMsg);;
                return (ippSocket::SERROR)_lastError;
  }     else  {
                return (ippSocket::SERROR)0;
  }
        
}

/*
 *  Connect the socket
 */
ippSocket::SERROR ippSocket::Connect(const char* hostname,int port)
{
  IPP_ASSERT(IsValid());

  _imp->SetHostName(hostname);
  _imp->SetPortNumber(port);
  _imp->SetNonBlocking();

  return _imp->Connect();
}

ippSocket::SERROR ippSocketImp::Connect()
{
        int nRet;
  linger lingerOption;
  lingerOption.l_onoff = 0;
  lingerOption.l_linger = 0;
  nRet = setsockopt(_theSocket,SOL_SOCKET,SO_LINGER,(char*)&lingerOption,sizeof(lingerOption));
  if (nRet ==SOCKET_ERROR) {
    getErrorString(&_lastError,_lastErrorMsg);
  }


        nRet = connect(_theSocket,                              // Socket
                                  (LPSOCKADDR)&_saServer,         // Server address
                                  sizeof(struct sockaddr));     // Length of server address structure
        

  if (nRet == SOCKET_ERROR) {
                if (WSAEWOULDBLOCK == WSAGetLastError()){
      return ippSocket::SOCKET_WOULD_BLOCK;
    }
    getErrorString(&_lastError,_lastErrorMsg);
                return ippSocket::SOCKET_OTHER_ERROR;
  } else {
                return ippSocket::SOCKET_OK;
  }
}

/*
 *  check if the socket is capable of sending data.
 */
ippSocket::SERROR ippSocket::CanSendData() 
{
  return _imp->CanSendData();
}

ippSocket::SERROR ippSocketImp::CanSendData() 
{
  fd_set w;
  FD_ZERO(&w);
  FD_SET(_theSocket,&w);
  fd_set e;
  FD_ZERO(&e);
  FD_SET(_theSocket,&e);
  timeval t;
  t.tv_sec =0;
  t.tv_usec = 0;
  int nRet = select(0,0,&w,&e,&t);
  switch(nRet) {
  case SOCKET_ERROR :
    // an error has occur
    getErrorString(&_lastError,_lastErrorMsg);
    return ippSocket::SOCKET_OTHER_ERROR;
    break;
  case 1:
    // the socket is ready to send data
    nRet = send(_theSocket,"",0,0);
    if (nRet!=0) {
      getErrorString(&_lastError,_lastErrorMsg);
      return ippSocket::SOCKET_OTHER_ERROR;
    }
    return ippSocket::SOCKET_OK;
    break;
  case 0:
    return ippSocket::SOCKET_WOULD_BLOCK;
  }
  getErrorString(&_lastError,_lastErrorMsg);
  return ippSocket::SOCKET_OTHER_ERROR;
}



/*
 *  read some text from the socket  ( up to nb char ) 
 *  returns 0 if the read has been successfull.
 *  
 */
ippSocket::SERROR ippSocket::Read(char* buffer,int nb)
{
  return _imp->Read(buffer,nb);
}

ippSocket::SERROR ippSocketImp::Read(char* buffer,int nb)
{

  buffer[0]=0;
        int nRead = recv(_theSocket,                    // Connected socket
                              buffer,                           // Receive buffer
                                    nb,0
                                    );                                          // Flags

 buffer[nRead]=0;
 if (nRead == 0 ){ 
   // nothing to read 
   return ippSocket::SOCKET_OK;
 }
 if (nRead == SOCKET_ERROR) {
   if ( WSAEWOULDBLOCK == WSAGetLastError() ) {
     _lastError = WSAEWOULDBLOCK;
     return ippSocket::SOCKET_WOULD_BLOCK;
   } 
   getErrorString(&_lastError,_lastErrorMsg);
   Close();
   return ippSocket::SOCKET_OTHER_ERROR;                
  } else {
    return ippSocket::SOCKET_OK;
  }     
}

/*
 *  write some string from the socket  ( null terminated ) 
 *  returns 0 if the write operation has been successfull.
 *  
 */
ippSocket::SERROR ippSocket::Write(const char *sendbuf)
{
  return _imp->Write(sendbuf);
}
ippSocket::SERROR ippSocketImp::Write(const char *sendbuf)
{
  //Write line out socket
        int nRet = send(_theSocket,     // Connected socket
                                          sendbuf,                                  // Data buffer
                                          strlen(sendbuf),              // Length of data
                                          0);                                                 // Flags
        
  if (nRet == SOCKET_ERROR) {
    getErrorString(&_lastError,_lastErrorMsg);
    return ippSocket::SOCKET_OTHER_ERROR;               
  } else {
    return ippSocket::SOCKET_OK;
  }
}

/* 
 * set the hostname 
 */
ippSocket::SERROR ippSocketImp::SetHostName(const char *hostName)
{
        _lpHostEntry = gethostbyname(hostName);
  if (_lpHostEntry == NULL) {
    return ippSocket::SOCKET_OTHER_ERROR;
  }
        else {

          _saServer.sin_family = AF_INET;
          _saServer.sin_addr = *((LPIN_ADDR)*_lpHostEntry->h_addr_list);
                                                                                  // ^ Server's address
    return ippSocket::SOCKET_OK;
        }
}

/* 
 * set the Port Number  
 */
void ippSocketImp::SetPortNumber(int portNumber)
{
        _portNumber = portNumber;
        _saServer.sin_port = htons(_portNumber);        

}

bool ippSocket::Create()
{
  return _imp->Create();
}

bool InitSocket()
{
                // initialize Winsock library
                WSADATA wsaData;
                WORD wVersionRequested = MAKEWORD(1, 1);
                int nResult = WSAStartup(wVersionRequested, &wsaData);
                if (nResult != 0)
                        return false;

                if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
                {
                        WSACleanup();
                        return false;
                }
    return true;
}


bool ippSocketImp::Create()
{
  IPP_ASSERT(_theSocket==INVALID_SOCKET && "Socket already created");

  _theSocket = socket(AF_INET,                  // Address family
                                              SOCK_STREAM,              // Socket type
                                              IPPROTO_TCP); // Protocol

  if (_theSocket == INVALID_SOCKET) { 
    // need a startup !
    InitSocket();
    _theSocket = socket(AF_INET,                        // Address family
                                              SOCK_STREAM,              // Socket type
                                              IPPROTO_TCP); // Protocol
  }

  if (_theSocket == INVALID_SOCKET) { 
    return FALSE; // it fails !
  }
  //-------------------------
  // Create a new event
  _Event = WSACreateEvent();
  IPP_ASSERT(_Event!=WSA_INVALID_EVENT);
  //-------------------------
  // Associate event types FD_CLOSE
  // with the listening socket and _Event
  int nRet = WSAEventSelect(_theSocket, _Event, FD_CLOSE);
  IPP_ASSERT(nRet==0 && " SOCKET_ERROR ?");

  return _theSocket != INVALID_SOCKET;

}


void ippSocket::Close()
{
  _imp->Close();
}

void ippSocketImp::Close()
{
  if (_theSocket !=INVALID_SOCKET) { 
    shutdown(_theSocket,2);
    int nRet = closesocket(_theSocket);
    _theSocket =INVALID_SOCKET;
  }
  if (_Event!= WSA_INVALID_EVENT) { 
     BOOL bRet = WSACloseEvent(_Event);
     IPP_ASSERT(bRet);
     _Event = WSA_INVALID_EVENT;
  }
}

ippSocket::SERROR ippSocket::Ping()
{
  return _imp->Ping();
}

ippSocket::SERROR ippSocketImp::Ping()
{
  IPP_ASSERT(_Event!=WSA_INVALID_EVENT);
  UINT nRet =  WSAWaitForMultipleEvents(1,&_Event,TRUE,0,FALSE);
  IPP_ASSERT(nRet!=WSA_WAIT_FAILED);
  if (nRet == WSA_WAIT_TIMEOUT) { 
    return ippSocket::SOCKET_OK;
  }
  getErrorString(&_lastError,_lastErrorMsg);
  return  ippSocket::SOCKET_CONNECTION_ABORTED;
}

bool ippSocket::Initialize() 
{
        WORD wVersionRequested = MAKEWORD(1,1);
        WSADATA wsaData;
        int nRet;
        //
        // Initialize WinSock and check the version
        //
        nRet = WSAStartup(wVersionRequested, &wsaData);
        if (wsaData.wVersion != wVersionRequested){     
          return false;
        }
  return true;
}







bool ippSocket::Listen(int portNumber)
{
  return _imp->Listen(portNumber);
}

bool ippSocketImp::Listen(int portNumber)
{
  IPP_ASSERT(_theSocket == INVALID_SOCKET);
  _theSocket = socket(AF_INET,                  // Address family
                                                     SOCK_STREAM,               // Socket type
                                                     IPPROTO_TCP); // Protocol


  if(_theSocket == INVALID_SOCKET) {
    InitSocket();
    _theSocket = socket(AF_INET,                        // Address family
                                                       SOCK_STREAM,             // Socket type
                                                       IPPROTO_TCP); // Protocol

    if(_theSocket == INVALID_SOCKET) {
      getErrorString(&_lastError,_lastErrorMsg);
      IPP_ASSERT_FAIL("Cannot create socket");
      return false;
    }
  }
  _portNumber = portNumber;
        _saServer.sin_family = AF_INET;
        _saServer.sin_addr.s_addr = INADDR_ANY; // Let WinSock supply address
        _saServer.sin_port = htons(_portNumber); // Use port from GUI
        //
        // bind the name to the socket
        //

        int nRet = bind(_theSocket,                       // Socket 
                                (LPSOCKADDR)&_saServer, // Our address
                                sizeof(struct sockaddr));       // Size of address structure
        
        if (nRet == SOCKET_ERROR)
        {
    getErrorString(&_lastError,_lastErrorMsg);
    Close();
                return false;
        }

        // Set socket to non-blocking
        unsigned long arg = 1;
        if (ioctlsocket(_theSocket, FIONBIO, &arg)<0)
        {
    getErrorString(&_lastError,_lastErrorMsg);
    Close();
                return false;
        }
        // Set the socket to listen
        //
  
  int request_in_queue = 0;
  nRet = ::listen(_theSocket,request_in_queue);
  
        if (nRet == SOCKET_ERROR)       {
    getErrorString(&_lastError,_lastErrorMsg);
    Close();
                return false;
        }
        

        char szBuf[1000] = "";
        nRet = gethostname(szBuf, sizeof(szBuf));
        if (nRet == SOCKET_ERROR)
        {
    int err = WSAGetLastError();
    Close();
    return false;
        }


  return true;
}



ippSocket::SERROR ippSocket::Accept(ippSocket& socket)
{
  return _imp->Accept(socket);
}

ippSocket::SERROR ippSocketImp::Accept(ippSocket& socket)
{
  IPP_ASSERT(!socket.IsValid());

        SOCKET  sock = accept(_theSocket,       // Listening socket
                                                          NULL,                           // Optional client address
                                                                NULL);  
                
        if (sock == INVALID_SOCKET){
    _lastError = WSAGetLastError();
                if (WSAEWOULDBLOCK == _lastError ){
      return ippSocket::SOCKET_WOULD_BLOCK;                     
                }       else {
                        getErrorString(&_lastError,_lastErrorMsg);;
      Close();
      return ippSocket::SOCKET_OTHER_ERROR;
                }
        }
  socket._imp->_theSocket = sock;
  IPP_ASSERT(socket._imp->_Event==WSA_INVALID_EVENT);
  socket._imp->_Event = WSACreateEvent();

  //-------------------------
  // Associate event types FD_CLOSE
  // with the listening socket and _Event
  WSAEventSelect(socket._imp->_theSocket, socket._imp->_Event, FD_CLOSE);  
  
  return ippSocket::SOCKET_OK;
}


bool ippSocket::IsValid() const
{
  return _imp->_theSocket!= INVALID_SOCKET;
}


void getErrorString(int* errCode,string& errMsg)
{
        *errCode = WSAGetLastError();
  errMsg ="";
  switch(*errCode) {
         case WSANOTINITIALISED:
                errMsg.append("Successful WSAStartup must occur before using this function."); 
    break;
   case WSAENETDOWN:
                errMsg.append("The network subsystem or the associated service provider has failed.");
    break;
   case WSAEAFNOSUPPORT:
                errMsg.append("The specified address family is not supported.");
    break;
   case WSAEINPROGRESS:
                errMsg.append("A blocking Windows Sockets 1.1 call is in progress, or the service provider is still processing a callback function.");
    break;
   case WSAEMFILE:
                errMsg.append("No more socket descriptors are available.");
    break;
   case WSAENOBUFS:
                errMsg.append("No buffer space is available. The socket cannot be created.");
    break;
   case  WSAEPROTONOSUPPORT:
                errMsg.append("The specified protocol is not supported.");
    break;
   case WSAEPROTOTYPE:
                errMsg.append("The specified protocol is the wrong type for this socket.");
    break;
   case WSAESOCKTNOSUPPORT:
                errMsg.append("The specified socket type is not supported in this address family.");
    break;
   case WSAEINVAL:
                errMsg.append("level is not valid, or the information in optval is not valid.");
    break;
   case WSAENETRESET:
                errMsg.append("Connection has timed out when SO_KEEPALIVE is set.");
    break;
   case WSAENOPROTOOPT:
                errMsg.append("The option is unknown or unsupported for the specified provider or socket (see SO_GROUP_PRIORITY limitations).");
    break;
   case WSAENOTCONN:
                errMsg.append("Connection has been reset when SO_KEEPALIVE is set.");
    break;
   case WSAENOTSOCK:
                errMsg.append("The descriptor is not a socket.");
    break;
   case WSAEADDRINUSE:
                errMsg.append("A process on the machine is already bound to the same\n");
                errMsg.append("fully-qualified address and the socket has not been marked\n"); 
                errMsg.append("to allow address re-use with SO_REUSEADDR. For example,\n");
                errMsg.append("IP address and port are bound in the af_inet case");
    break;
   case WSAEWOULDBLOCK:
     errMsg.append("WSAEWOULDBLOCK");
    break;
   case WSAECONNABORTED:
     errMsg.append("Connection aborted");
    break;
        default:
          errMsg.append("unknown problems!");
  }
}


IPPDME_EXT_CLASS void ippSleep(int time_in_milisecond)
{
  ::Sleep(time_in_milisecond);
}

---