VC SOCKET

-

.H

 

/* ******************************************
 * winSocket.h - Header file for winSocket * 
 *      Winsock API wrapper class          *
 *    Ryan Lederman [email protected]       *
 *            January 2002                 *
 *          THIS CODE IS FREE              *
 *                                         *
 ****************************************** */

#ifndef _WINSOCKET_H
#define  _WINSOCKET_H

#include  " winsock.h "
#include  " winbase.h "

#define  ERR_SUCCESS  0x00000000     //  Successful
#define  ERR_BADPARAM 0x80000001     //  Bad argument passed
#define  ERR_WSAERROR 0x80000002     //  Need to get_LastError()
#define  ERR_MAXLENGTH 512

class  winSocket     //  Definition of winSocket
{
public :     //  Public Methods
    winSocket::winSocket();         //  Constructor
    winSocket:: ~ winSocket();     //  Destructor

     int  Create(  void  );                                                 //  Creates the socket
     int  Close(  void  );                                                 //  Closes the socket
     int  Connect(  char *  strRemote, unsigned  int  iPort );                 //  Connects the socket to a remote site
     int  Send( SOCKET s,  char *  strData,  int  iLen );                     //  Sends data
     int  Send(  char *  strData,  int  iLen );    
     int  Receive( SOCKET s,  char *  strData,  int  iLen );                 //  Receives data
     int  Receive(  char *  strData,  int  iLen );
     int  Listen(  int  iQueuedConnections );                             //  Listen for connections
     int  Bind(  char *  strIP, unsigned  int  iPort );                     //  Binds to a port
     int  Accept( SOCKET s );                                             //  Accepts a connection
     int  asyncSelect( HWND hWnd,                                         //  Allows calling window to receive 
        unsigned  int  wMsg,  long  lEvent );                             //  notifications (non-blocking sockets)                                        
     int  get_LocalIP(  char *  strIP );                                     //  Returns local IP address            
     int  get_LocalPort(  int *  iPort );                                 //  Returns local Port number
     int  get_RemoteIP(  char *  strIP );                                 //  Returns remote side IP
     int  get_RemotePort(  int *  iPort );                                 //  Returns remote side Port number
     int  get_LocalHost(  char *  strBuffer,  int  iBufLen );                 //  Returns local host name
     int  get_RemoteHost(  char *  strBuffer,  int  iBufLen );                 //  Returns remote host name
     void  get_LastError(  char *  strBuffer,  int *  iErrNum );             //  Returns error information
     int  set_SendTimeout(  int  ms );                                     //  Sets send timeout, in milliseconds
     int  set_RecvTimeout(  int  ms );                                     //  Sets recv timeout, in milliseconds
     void  longToDottedQuad( unsigned  long  ulLong,  char *  cBuffer );     //  32-bit long -> dotted quad
private :     //  Private Methods
     void  winSocket::set_LastError(  char *  newError,  int  errNum );     //  Sets last error information
private :     //  Private Members
     struct  sockaddr_in m_sockaddr;         //  Holds all data associated with socket
     struct  sockaddr_in m_rsockaddr;         //  Holds data associated with remote side
    WORD m_wVersion;                     //  Version to use when calling WSAStartup
     char  m_LastError[ERR_MAXLENGTH + 1 ];     //  Buffer that holds last error
     int      m_ErrorNumber;                     //  Last error number
public :         //  Public Members
    SOCKET m_hSocket;                     //  Underlying SOCKET object
};

#endif  /* _WINSOCKET_H */

 

 

 

.CPP

 

/* ******************************************
 *   winSocket.cpp - Implementation of     * 
 *   winSocket Winsock API wrapper class   *
 *    Ryan Lederman [email protected]       *
 *            January 2002                 *
 *          THIS CODE IS FREE              *
 *                                         *
 ****************************************** */

#include  " winSocket.h "

winSocket::winSocket() : m_hSocket( 0 ),
                         m_wVersion( 0 ),
                         m_ErrorNumber( 0 )        
{
    WSADATA wsaD;     //  Structure initialsed by WSAStartup
    m_wVersion  =  MAKEWORD( 2 , 2 );     //  Version number requested

    memset( m_LastError,  0 , ERR_MAXLENGTH );     //  Nullify last error
    memset(  & m_sockaddr,  0 ,  sizeof ( m_sockaddr ) );     //  Nullify structures
    memset(  & m_rsockaddr,  0 ,  sizeof ( m_rsockaddr ) );

     int  result  =  WSAStartup( m_wVersion,  & wsaD );     //  Initialize Winsock
    
     if ( result  !=   0  )  //  WSAStartup failed
    {
        set_LastError(  " WSAStartup failed! " , WSAGetLastError() );
         return ;
    }
}

winSocket:: ~ winSocket() { WSACleanup();     /*  Un-initialise Winsock */  }

int  winSocket::Create(  void  )
{
     /* *************************************
    * FUNCTION: Create                    *
    *                                     *
    * PURPOSE: Initializes the underlying *
    * SOCKET object for the class.        *           
    *                                     * 
    * RETURNS: ERR_WSAERROR upon error,   *                 
    * otherwise ERR_SUCCESS               *   
    *                                     *
    ************************************** */

     if  ( (m_hSocket  =  socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ))  ==  INVALID_SOCKET )
    {
        set_LastError(  " socket() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }

     return  ERR_SUCCESS;    
}

int  winSocket::Close(  void  )
{
     /* ***************************************
    * FUNCTION: Close                       *
    *                                       *
    * PURPOSE: Closes the underlying        *
    * SOCKET object. Does not destroy class *           
    *                                       * 
    * RETURNS: ERR_WSAERROR upon error,     *                  
    * otherwise ERR_SUCCESS                 *   
    *                                       *
    **************************************** */

     if  ( closesocket( m_hSocket )  ==  SOCKET_ERROR )
    {
        set_LastError(  " closesocket() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }

    memset(  & m_sockaddr,  0 ,  sizeof ( sockaddr_in ) );
    memset(  & m_rsockaddr,  0 ,  sizeof ( sockaddr_in ) );

     return  ERR_SUCCESS;
}

int  winSocket::Connect(  char *  strRemote, unsigned  int  iPort )
{
     /* ****************************************
    * FUNCTION: Connect                      *
    *                                        *
    * PURPOSE: Establishes TCP/IP connection *
    * with remote host (strRemote) on port   *     
    * # (iPort)                              *
    *                                        *
    * RETURNS: ERR_BADPARAM for invalid      *
    * parameters, ERR_WSAERROR upon error,   *
    * otherwise ERR_SUCCESS                  *
    *                                        *
    ***************************************** */

     if ( strlen( strRemote )  ==   0   ||  iPort  ==   0  )
         return  ERR_BADPARAM;

    hostent  * hostEnt  =  NULL;
     long  lIPAddress  =   0 ;

    hostEnt  =  gethostbyname( strRemote );

     if ( hostEnt  !=  NULL )
    {
        lIPAddress  =  ((in_addr * )hostEnt -> h_addr) -> s_addr;
        m_sockaddr.sin_addr.s_addr  =  lIPAddress;
    }
     else
    {
        m_sockaddr.sin_addr.s_addr  =  inet_addr( strRemote );
    }

    m_sockaddr.sin_family  =  AF_INET;
    m_sockaddr.sin_port  =  htons( iPort );

     if ( connect( m_hSocket, (SOCKADDR * ) & m_sockaddr,  sizeof ( m_sockaddr ) )  ==  SOCKET_ERROR )
    {
        set_LastError(  " connect() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }

     return  ERR_SUCCESS;
}

int  winSocket::Listen(  int  iQueuedConnections )
{
     /* ****************************************
    * FUNCTION: Listen                       *
    *                                        *
    * PURPOSE: Places the SOCKET in the      *
    * listening state. Requires that Bind()  *
    * be called previously.                  *
    *                                        *
    * RETURNS: ERR_BADPARAM for invalid      *
    * parameters, ERR_WSAERROR upon error,   *
    * otherwise ERR_SUCCESS                  *
    *                                        *
    ***************************************** */

     if ( iQueuedConnections  ==   0  )
         return  ERR_BADPARAM;

     if ( listen( m_hSocket, iQueuedConnections )  ==  SOCKET_ERROR )
    {
        set_LastError(  " listen() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }

     return  ERR_SUCCESS;
}

int  winSocket::Send( SOCKET s,  char *  strData,  int  iLen )
{
     /* *********************************************
    * FUNCTION: Send                              *
    *                                             *
    * PURPOSE: Sends data (strData) to remote     *
    * side on socket s.                           *
    *                                             *
    * RETURNS: ERR_BADPARAM for invalid           *
    * parameters, ERR_WSAERROR upon error,        *
    * otherwise ERR_SUCCESS                       *
    *                                             *
    ********************************************** */

     if ( strData  ==  NULL  ||  iLen  ==   0  )
         return  ERR_BADPARAM;

     if ( send( s, strData, iLen,  0  )  ==  SOCKET_ERROR )
    {
        set_LastError(  " send() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }
    
     return  ERR_SUCCESS;
}

int  winSocket::Send(  char *  strData,  int  iLen )
{
     /* *********************************************
    * FUNCTION: Send                              *
    *                                             *
    * PURPOSE: Sends data (strData) to remote     *
    * side on an established TCP/IP connection.   *
    * Requires that Connect be called previously. *
    *                                             *
    * RETURNS: ERR_BADPARAM for invalid           *
    * parameters, ERR_WSAERROR upon error,        *
    * otherwise ERR_SUCCESS                       *
    *                                             *
    ********************************************** */

     if ( strData  ==  NULL  ||  iLen  ==   0  )
         return  ERR_BADPARAM;

     if ( send( m_hSocket, strData, iLen,  0  )  ==  SOCKET_ERROR )
    {
        set_LastError(  " send() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }
    
     return  ERR_SUCCESS;
}

int  winSocket::Receive( SOCKET s,  char *  strData,  int  iLen )
{
     /* **********************************************
    * FUNCTION: Receive                            *
    *                                              *
    * PURPOSE: Retreives data from incoming queue  *
    * and copies to (strData). (iLen) will contain *
    * the length of data read in bytes             *
    *                                              *
    * RETURNS: ERR_BADPARAM for invalid            *
    * parameters, ERR_WSAERROR upon error,         *
    * otherwise passes what recv() returns.        *
    *                                              *
    ********************************************** */

     if ( strData  ==  NULL )
         return  ERR_BADPARAM;

     int  len  =   0 ;
     int  ret  =   0 ;
    
    ret  =  recv( s, strData, iLen,  0  );

     if  ( ret  ==  SOCKET_ERROR )
    {
        set_LastError(  " recv() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }
     return  ret;
}

int  winSocket::Receive(  char *  strData,  int  iLen )
{
     /* **********************************************
    * FUNCTION: Receive                            *
    *                                              *
    * PURPOSE: Retreives data from incoming queue  *
    * and copies to (strData). (iLen) will contain *
    * the length of data read in bytes             *
    *                                              *
    * RETURNS: ERR_BADPARAM for invalid            *
    * parameters, ERR_WSAERROR upon error,         *
    * otherwise passes what recv() returns.        *
    *                                              *
    ********************************************** */

     if ( strData  ==  NULL )
         return  ERR_BADPARAM;

     int  len  =   0 ;
     int  ret  =   0 ;
    
    ret  =  recv( m_hSocket, strData, iLen,  0  );

     if  ( ret  ==  SOCKET_ERROR )
    {
        set_LastError(  " recv() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }

     return  ret;
}

int  winSocket::Bind(  char *  strIP, unsigned  int  iPort )
{
     /* ***********************************************
    * FUNCTION: Bind                                *
    *                                               *
    * PURPOSE: Associates the SOCKET object with an *
    * IP address (strIP) and port number (iPort)    *
    *                                               *
    * RETURNS: ERR_BADPARAM for invalid             *
    * parameters, ERR_WSAERROR upon error,          *
    * otherwise ERR_SUCCESS                         *
    *                                               *
    *********************************************** */

     if ( strlen( strIP )  ==   0   ||  iPort  ==   0  )
         return  ERR_BADPARAM;

    memset(  & m_sockaddr, 0 ,  sizeof ( m_sockaddr ) );
    m_sockaddr.sin_family  =  AF_INET;
    m_sockaddr.sin_addr.s_addr  =  inet_addr( strIP );
    m_sockaddr.sin_port  =  htons( iPort );

     if  ( bind( m_hSocket, (SOCKADDR * ) & m_sockaddr,  sizeof ( m_sockaddr ) )  ==  SOCKET_ERROR )
    {
        set_LastError(  " bind() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }
     return  ERR_SUCCESS;
}

int  winSocket::Accept( SOCKET s )
{    
     /* **************************************************
    * FUNCTION: Accept                                 *
    *                                                  *
    * PURPOSE: Initializes the SOCKET object (if not   *
    * previously initialized), associates the SOCKET   *
    * object with the IP address and port of the       *
    * remote side, and accepts an incoming connection. *
    * Usually called from a Window Procedure using     *
    * wParam as the argument.                          *
    *                                                  *
    * RETURNS: ERR_WSAERROR upon error,                *
    * otherwise ERR_SUCCESS                            *
    *                                                  *
    *************************************************** */

     int  Len  =   sizeof ( m_rsockaddr );

    memset(  & m_rsockaddr,  0 ,  sizeof ( m_rsockaddr ) );

     if ( ( m_hSocket  =  accept( s, (SOCKADDR * ) & m_rsockaddr,  & Len ) )  ==  INVALID_SOCKET )
    {
        set_LastError(  " accept() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }

     return  ERR_SUCCESS;
}

int  winSocket::asyncSelect( HWND hWnd, unsigned  int  wMsg,  long  lEvent )
{
     /* *************************************************
    * FUNCTION: asyncSelect                           *
    *                                                 *
    * PURPOSE: Enables Windows Messaging notification *
    * for the object. (wMsg) will be sent to the      *
    * Window Procedure of (hWnd) whenever one of the  *
    * events in (lEvent) has occurred. See MSDN docs  *
    * for WSAAsyncSelect() for more information.      *
    *                                                 *
    * RETURNS: ERR_BADPARAM for invalid               *
    * parameters, ERR_WSAERROR upon error,            *
    * otherwise ERR_SUCCESS                           *
    *                                                 *
    ************************************************** */

     if (  ! IsWindow( hWnd )  ||  wMsg  ==   0   ||  lEvent  ==   0  )
         return  ERR_BADPARAM;

     if ( WSAAsyncSelect( m_hSocket, hWnd, wMsg, lEvent )  ==  SOCKET_ERROR )
    {
        set_LastError(  " WSAAsyncSelect() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }
     return  ERR_SUCCESS;
}

int  winSocket::get_RemoteIP(  char *  strIP )
{
     /* ************************************************
    * FUNCTION: get_RemoteIP                         *
    *                                                *
    * PURPOSE: Copies the IP address for the remote  *
    * side on an established TCP/IP connection into  *
    * (strIP).                                       *
    *                                                *
    * RETURNS: ERR_BADPARAM for invalid parameters,  *
    * ERR_WSAERROR upon error, otherwise ERR_SUCCESS *
    *                                                *
    ************************************************* */

     if ( strIP  ==  NULL )
         return  ERR_BADPARAM;

     int  namelen  =   sizeof ( m_rsockaddr );

     if ( getpeername( m_hSocket, (SOCKADDR * ) & m_rsockaddr,  & namelen )  ==  SOCKET_ERROR )
    {
        set_LastError(  " getpeername() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }

    longToDottedQuad( m_rsockaddr.sin_addr.s_addr, strIP );

     return  ERR_SUCCESS;
}

int  winSocket::get_RemotePort(  int *  iPort )
{
     /* ************************************************
    * FUNCTION: get_RemotePort                       *
    *                                                *
    * PURPOSE: Copies the port number for the remote *
    * side on an established TCP/IP connection into  *
    * (iPort).                                       *
    *                                                *
    * RETURNS: ERR_BADPARAM for invalid parameters,  *
    * ERR_WSAERROR upon error, otherwise ERR_SUCCESS *
    *                                                *
    ************************************************* */

     if ( iPort  ==  NULL )
         return  ERR_BADPARAM;

     int  namelen  =   sizeof ( m_rsockaddr );
    
     if ( getpeername( m_hSocket, (SOCKADDR * ) & m_rsockaddr,  & namelen )  ==  SOCKET_ERROR )
    {
        set_LastError(  " getpeername() failed " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }

     * iPort  =  ntohs( m_rsockaddr.sin_port );

     return  ERR_SUCCESS;
}

int  winSocket::get_LocalHost(  char *  strBuffer,  int  iBufLen )
{
     /* ************************************************
    * FUNCTION: get_LocalHost                        *
    *                                                *
    * PURPOSE: Copies the fully qualified host name  *
    * for the local machine into (strBuffer). Will   *
    * fail if returned data is longer than (iBufLen).*
    *                                                *
    * RETURNS: ERR_BADPARAM for invalid parameters,  *
    * ERR_WSAERROR upon error, otherwise ERR_SUCCESS *
    *                                                *
    ************************************************* */

     if ( strBuffer  ==  NULL )
         return  ERR_BADPARAM;

     char  strHost[ 512 ]  =  { 0 };
    hostent *  hostEnt  =  NULL;
     int  iLen  =   0 ;

    gethostname( strHost,  512  );
    hostEnt  =  gethostbyname( strHost );

     if ( hostEnt  ==  NULL )
         return  ERR_WSAERROR;

    iLen  =  strlen( hostEnt -> h_name );

     if ( iLen  >  iBufLen )
         return  ERR_BADPARAM;

    memset( strBuffer,  0 , iBufLen );
    memcpy( strBuffer, hostEnt -> h_name, iLen );

     return  ERR_SUCCESS;
}

int  winSocket::get_RemoteHost(  char *  strBuffer,  int  iBufLen )
{
     /* ************************************************
    * FUNCTION: get_RemoteHost                       *
    *                                                *
    * PURPOSE: Copies the fully qualified host name  *
    * of the remote side (on a connected socket)     *
    * into (strBuffer). Will fail if data returned   *
    * is longer than iBufLen.                        *
    *                                                *
    * RETURNS: ERR_BADPARAM for invalid parameters,  *
    * ERR_WSAERROR upon error, otherwise ERR_SUCCESS *
    *                                                *
    ************************************************* */

     if ( strBuffer  ==  NULL )
         return  ERR_BADPARAM;

    hostent *  hostEnt  =  NULL;
     int  iLen  =   0 ;
     int  namelen  =   sizeof ( m_rsockaddr );

     if ( getpeername( m_hSocket, (SOCKADDR * ) & m_rsockaddr,  & namelen )  ==  SOCKET_ERROR )
         return  ERR_WSAERROR;

    hostEnt  =  gethostbyaddr( ( char * ) & m_rsockaddr.sin_addr.s_addr,  4  ,PF_INET );

     if ( hostEnt  !=  NULL )
    {
        iLen  =  strlen( hostEnt -> h_name );
         if ( iLen  >  iBufLen )
             return  ERR_BADPARAM;

        memcpy( strBuffer, hostEnt -> h_name, iLen );
         return  ERR_SUCCESS;
    }

     return  ERR_WSAERROR;
}

int  winSocket::get_LocalIP(  char *  strIP )
{
     /* ************************************************
    * FUNCTION: get_LocalIP                          *
    *                                                *
    * PURPOSE: Copies the IP address for the local   *
    * machine into (strIP). Requires that Connect or *
    * Bind be called previously                      *
    *                                                *
    * RETURNS: ERR_BADPARAM for invalid parameters,  *
    * otherwise ERR_SUCCESS                          *
    *                                                *
    ************************************************* */

     if ( strIP  ==  NULL )
         return  ERR_BADPARAM;
    
     int   namelen  =   sizeof ( m_sockaddr );
    HOSTENT *  hEnt  =  NULL;
     char  szHostName[ 512 ]  =  { 0 };
     char  szIP[ 16 ]  =  { 0 };
     char  szAddrField[ 4 ]  =  { 0 };
    unsigned  int  ufield  =   0 ;

     if ( getsockname( m_hSocket, (SOCKADDR * ) & m_sockaddr,  & namelen )  ==  SOCKET_ERROR )
         return  ERR_WSAERROR;

    longToDottedQuad( m_sockaddr.sin_addr.s_addr, strIP );

     return  ERR_SUCCESS;
}

int  winSocket::get_LocalPort(  int *  iPort )
{
     /* ****************************************************
    * FUNCTION: get_LocalPort                            *
    *                                                    *
    * PURPOSE: Copies the local port number associated   *
    * with the SOCKET object into (iPort).               *
    * Requires that Connect or Bind be called previously *
    *                                                    *
    * RETURNS: ERR_BADPARAM for invalid parameters,      *
    * otherwise ERR_SUCCESS                              *
    *                                                    *
    ***************************************************** */

     if ( iPort  ==  NULL )
         return  ERR_BADPARAM;

     * iPort  =  ntohs(m_sockaddr.sin_port);

     return  ERR_SUCCESS;
}

int  winSocket::set_SendTimeout(  int  ms )
{
     /* ****************************************************
    * FUNCTION: set_SendTimeout                          *
    *                                                    *
    * PURPOSE: Sets the amount of time the socket will   *
    * wait before returning WSAETIMEDOUT when calling    *
    * Send(). Set to 0 for infinite (default)            *
    *                                                    *
    * RETURNS: ERR_BADPARAM for invalid parameters,      *
    * ERR_WSAERROR for a winsock error,                  *
    * otherwise ERR_SUCCESS                              *
    *                                                    *
    ***************************************************** */
    
     if ( ms  <   0  )
         return  ERR_BADPARAM;

     if ( setsockopt( m_hSocket, SOL_SOCKET, SO_SNDTIMEO, ( char * ) & ms,  sizeof ( ms ) )  ==  SOCKET_ERROR )
    {
        set_LastError(  " setsockopt() failed. " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }

     return  ERR_SUCCESS;
}

int  winSocket::set_RecvTimeout(  int  ms )
{
     /* ****************************************************
    * FUNCTION: set_RecvTimeout                          *
    *                                                    *
    * PURPOSE: Sets the amount of time the socket will   *
    * wait before returning WSAETIMEDOUT when calling    *
    * Receive(). Set to 0 for infinite (default)         *
    *                                                    *
    * RETURNS: ERR_BADPARAM for invalid parameters,      *
    * ERR_WSAERROR for a winsock error,                  *
    * otherwise ERR_SUCCESS                              *
    *                                                    *
    ***************************************************** */
    
     if ( ms  <   0  )
         return  ERR_BADPARAM;

     if ( setsockopt( m_hSocket, SOL_SOCKET, SO_RCVTIMEO, ( char * ) & ms,  sizeof ( ms ) )  ==  SOCKET_ERROR )
    {
        set_LastError(  " setsockopt() failed. " , WSAGetLastError() );
         return  ERR_WSAERROR;
    }

     return  ERR_SUCCESS;
}

void  winSocket::set_LastError(  char *  newError,  int  errNum )
{
     /* *************************************************
    * FUNCTION: set_LastError                         *
    *                                                 *
    * PURPOSE: Sets error information for the object. *
    *                                                 *
    * RETURNS: None.                                  *
    *                                                 *
    ************************************************** */

    memset( m_LastError,  0 , ERR_MAXLENGTH ); 
    memcpy( m_LastError, newError, strlen( newError ) );
    m_LastError[strlen(newError) + 1 ]  =   ' \0 ' ;
    m_ErrorNumber  =  errNum;
}

void  winSocket::get_LastError(  char *  strBuffer,  int *  iErrNum )
{
     /* **************************************************
    * FUNCTION: get_LastError                          *
    *                                                  *
    * PURPOSE: Retreives description and number of the *
    * last error that occurred. Copies into (strBuffer)*
    * and (iErrNum), repsectively.                     *
    *                                                  *
    * RETURNS: None.                                   *
    *                                                  *
    *************************************************** */

     int  len  =  strlen( m_LastError );

     if ( len  >   0  )
    {
        memset( strBuffer,  0 , len );
        memcpy( strBuffer, m_LastError, len );
        strBuffer[len + 1 ]  =   ' \0 ' ;
         * iErrNum  =  m_ErrorNumber;
    }
}

void  winSocket::longToDottedQuad( unsigned  long  ulLong,  char *  cBuffer )
{
     /* ****************************************************
    * FUNCTION: longToDottedQuad                         *
    *                                                    *
    * PURPOSE: Translates an IP address from 32-bit long *
    * to dotted quad form (255.255.255.255). Translates  *
    * (ulLong) and copies results to (cBuffer).          *
    *                                                    *
    * RETURNS: None.                                     *
    *                                                    *
    ***************************************************** */

    wsprintf( cBuffer,  " %d.%d.%d.%d " ,( int )((BYTE * ) & ulLong)[ 0 ],
        ( int )((BYTE * ) & ulLong)[ 1 ],( int )((BYTE * ) & ulLong)[ 2 ],( int )((BYTE * ) & ulLong)[ 3 ] );
}