CodeDweller/networking.cpp

// networking.cpp
// Copyright (C) 2006-2009 MicroNeil Research Corporation.
//
// This program is part of the MicroNeil Research Open Library Project. For
// more information go to http://www.microneil.com/OpenLibrary/index.html
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at your
// option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
// more details.
//
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 59 Temple
// Place, Suite 330, Boston, MA 02111-1307 USA
//==============================================================================

// See networking.hpp for notes.
// See networking.inline.hpp for inlined methods & functions.

#include "networking.hpp"

Networking Network;                                                             // Finally creating the Network instance.

//// Platform Specific Stuff ///////////////////////////////////////////////////

#if defined(WIN32) || defined(WIN64)

////////////////////////////////////////////////////////////////////////////////
//// Being Windows specific code

WSADATA WSSTartData;                                                            // Socket library data structure.

// Error description handling for humans.

string Networking::DescriptiveError(string Msg, int Errno) {                    // Form a descriptive error w/ errno.
        string s = "";                                                          // Message string.

        switch(Errno) {                                                         // Assign the appropriate message.
            case WSA_INVALID_HANDLE: s = "WSA_INVALID_HANDLE"; break;
            case WSA_NOT_ENOUGH_MEMORY: s = "WSA_NOT_ENOUGH_MEMORY"; break;
            case WSA_INVALID_PARAMETER: s = "WSA_INVALID_PARAMETER"; break;
            case WSA_OPERATION_ABORTED: s = "WSA_OPERATION_ABORTED"; break;
            case WSA_IO_INCOMPLETE: s = "WSA_IO_INCOMPLETE"; break;
            case WSA_IO_PENDING: s = "WSA_IO_PENDING"; break;
            case WSAEINTR: s = "WSAEINTR"; break;
            case WSAEBADF: s = "WSAEBADF"; break;
            case WSAEACCES: s = "WSAEACCES"; break;
            case WSAEFAULT: s = "WSAEFAULT"; break;
            case WSAEINVAL: s = "WSAEINVAL"; break;
            case WSAEMFILE: s = "WSAEMFILE"; break;
            case WSAEWOULDBLOCK: s = "WSAEWOULDBLOCK"; break;
            case WSAEINPROGRESS: s = "WSAEINPROGRESS"; break;
            case WSAEALREADY: s = "WSAEALREADY"; break;
            case WSAENOTSOCK: s = "WSAENOTSOCK"; break;
            case WSAEDESTADDRREQ: s = "WSAEDESTADDRREQ"; break;
            case WSAEMSGSIZE: s = "WSAEMSGSIZE"; break;
            case WSAEPROTOTYPE: s = "WSAEPROTOTYPE"; break;
            case WSAENOPROTOOPT: s = "WSAENOPROTOOPT"; break;
            case WSAEPROTONOSUPPORT: s = "WSAEPROTONOSUPPORT"; break;
            case WSAESOCKTNOSUPPORT: s = "WSAESOCKTNOSUPPORT"; break;
            case WSAEOPNOTSUPP: s = "WSAEOPNOTSUPP"; break;
            case WSAEPFNOSUPPORT: s = "WSAEPFNOSUPPORT"; break;
            case WSAEAFNOSUPPORT: s = "WSAEAFNOSUPPORT"; break;
            case WSAEADDRINUSE: s = "WSAEADDRINUSE"; break;
            case WSAEADDRNOTAVAIL: s = "WSAEADDRNOTAVAIL"; break;
            case WSAENETDOWN: s = "WSAENETDOWN"; break;
            case WSAENETUNREACH: s = "WSAENETUNREACH"; break;
            case WSAENETRESET: s = "WSAENETRESET"; break;
            case WSAECONNABORTED: s = "WSAECONNABORTED"; break;
            case WSAECONNRESET: s = "WSAECONNRESET"; break;
            case WSAENOBUFS: s = "WSAENOBUFS"; break;
            case WSAEISCONN: s = "WSAEISCONN"; break;
            case WSAENOTCONN: s = "WSAENOTCONN"; break;
            case WSAESHUTDOWN: s = "WSAESHUTDOWN"; break;
            case WSAETOOMANYREFS: s = "WSAETOOMANYREFS"; break;
            case WSAETIMEDOUT: s = "WSAETIMEDOUT"; break;
            case WSAECONNREFUSED: s = "WSAECONNREFUSED"; break;
            case WSAELOOP: s = "WSAELOOP"; break;
            case WSAENAMETOOLONG: s = "WSAENAMETOOLONG"; break;
            case WSAEHOSTDOWN: s = "WSAEHOSTDOWN"; break;
            case WSAEHOSTUNREACH: s = "WSAEHOSTUNREACH"; break;
            case WSAENOTEMPTY: s = "WSAENOTEMPTY"; break;
            case WSAEPROCLIM: s = "WSAEPROCLIM"; break;
            case WSAEUSERS: s = "WSAEUSERS"; break;
            case WSAEDQUOT: s = "WSAEDQUOT"; break;
            case WSAESTALE: s = "WSAESTALE"; break;
            case WSAEREMOTE: s = "WSAEREMOTE"; break;
            case WSASYSNOTREADY: s = "WSASYSNOTREADY"; break;
            case WSAVERNOTSUPPORTED: s = "WSAVERNOTSUPPORTED"; break;
            case WSANOTINITIALISED: s = "WSANOTINITIALISED"; break;
            case WSAEDISCON: s = "WSAEDISCON"; break;
            case WSAENOMORE: s = "WSAENOMORE"; break;
            case WSAECANCELLED: s = "WSAECANCELLED"; break;
            case WSAEINVALIDPROCTABLE: s = "WSAEINVALIDPROCTABLE"; break;
            case WSAEINVALIDPROVIDER: s = "WSAEINVALIDPROVIDER"; break;
            case WSAEPROVIDERFAILEDINIT: s = "WSAEPROVIDERFAILEDINIT"; break;
            case WSASYSCALLFAILURE: s = "WSASYSCALLFAILURE"; break;
            case WSASERVICE_NOT_FOUND: s = "WSASERVICE_NOT_FOUND"; break;
            case WSATYPE_NOT_FOUND: s = "WSATYPE_NOT_FOUND"; break;
            case WSA_E_NO_MORE: s = "WSA_E_NO_MORE"; break;
            case WSA_E_CANCELLED: s = "WSA_E_CANCELLED"; break;
            case WSAEREFUSED: s = "WSAEREFUSED"; break;
            case WSAHOST_NOT_FOUND: s = "WSAHOST_NOT_FOUND"; break;
            case WSATRY_AGAIN: s = "WSATRY_AGAIN"; break;
            case WSANO_RECOVERY: s = "WSANO_RECOVERY"; break;
            case WSANO_DATA: s = "WSANO_DATA"; break;
            case WSA_QOS_RECEIVERS: s = "WSA_QOS_RECEIVERS"; break;
            case WSA_QOS_SENDERS: s = "WSA_QOS_SENDERS"; break;
            case WSA_QOS_NO_SENDERS: s = "WSA_QOS_NO_SENDERS"; break;
            case WSA_QOS_NO_RECEIVERS: s = "WSA_QOS_NO_RECEIVERS"; break;
            case WSA_QOS_REQUEST_CONFIRMED: s = "WSA_QOS_REQUEST_CONFIRMED"; break;
            case WSA_QOS_ADMISSION_FAILURE: s = "WSA_QOS_ADMISSION_FAILURE"; break;
            case WSA_QOS_POLICY_FAILURE: s = "WSA_QOS_POLICY_FAILURE"; break;
            case WSA_QOS_BAD_STYLE: s = "WSA_QOS_BAD_STYLE"; break;
            case WSA_QOS_BAD_OBJECT: s = "WSA_QOS_BAD_OBJECT"; break;
            case WSA_QOS_TRAFFIC_CTRL_ERROR: s = "WSA_QOS_TRAFFIC_CTRL_ERROR"; break;
            case WSA_QOS_GENERIC_ERROR: s = "WSA_QOS_GENERIC_ERROR"; break;
            case WSA_QOS_ESERVICETYPE: s = "WSA_QOS_ESERVICETYPE"; break;
            case WSA_QOS_EFLOWSPEC: s = "WSA_QOS_EFLOWSPEC"; break;
            case WSA_QOS_EPROVSPECBUF: s = "WSA_QOS_EPROVSPECBUF"; break;
            case WSA_QOS_EFILTERSTYLE: s = "WSA_QOS_EFILTERSTYLE"; break;
            case WSA_QOS_EFILTERTYPE: s = "WSA_QOS_EFILTERTYPE"; break;
            case WSA_QOS_EFILTERCOUNT: s = "WSA_QOS_EFILTERCOUNT"; break;
            case WSA_QOS_EOBJLENGTH: s = "WSA_QOS_EOBJLENGTH"; break;
            case WSA_QOS_EFLOWCOUNT: s = "WSA_QOS_EFLOWCOUNT"; break;
            case WSA_QOS_EPOLICYOBJ: s = "WSA_QOS_EPOLICYOBJ"; break;
            case WSA_QOS_EFLOWDESC: s = "WSA_QOS_EFLOWDESC"; break;
            case WSA_QOS_EPSFLOWSPEC: s = "WSA_QOS_EPSFLOWSPEC"; break;
            case WSA_QOS_EPSFILTERSPEC: s = "WSA_QOS_EPSFILTERSPEC"; break;
            case WSA_QOS_ESDMODEOBJ: s = "WSA_QOS_ESDMODEOBJ"; break;
            case WSA_QOS_ESHAPERATEOBJ: s = "WSA_QOS_ESHAPERATEOBJ"; break;
            case WSA_QOS_RESERVED_PETYPE: s = "WSA_QOS_RESERVED_PETYPE"; break;

#ifdef WSA_QOS_EUNKOWNPSOBJ
            case WSA_QOS_EUNKOWNPSOBJ: s = "WSA_QOS_EUNKOWNPSOBJ"; break;
#endif
        }

        Msg.append(" ");                                                        // Add a space to the existing message.
        if(0 < s.length()) {                                                    // If we know the message for Errno
            Msg.append(s);                                                      // then append it.
        }
        else  {                                                                 // If we don't know what Errno means
            ostringstream ErrNoMsg;                                             // then say so and pass on Errno as
            ErrNoMsg << " UNKNOWN ErrorNumber = " << Errno;                     // well so someone can figure it out.
            Msg.append(ErrNoMsg.str());
        }
        return Msg;
};

// Networking Constructor //////////////////////////////////////////////////////
// Handles any necessary setup of Network Module resources.

Networking::Networking() {                                                      // Upon initialization,
    if(0 != WSAStartup(MAKEWORD (2,0), &WSSTartData)) {                         // startup the Winsock2.0 DLL.
        throw InitializationError(                                              // If that fails then throw!
            "Networking::Networking() if(0 != WSAStartup(MAKEWORD (2,0), &WSSTartData))"
        );
    }
}

// Networking Destructor ///////////////////////////////////////////////////////
// Handles any necessary cleanup of Network Module resources.

Networking::~Networking() {                                                     // Upon shutdown,
    WSACleanup();                                                               // shutdown the Winsock DLL.
}

//// Emd Windows specific code
////////////////////////////////////////////////////////////////////////////////

#else

////////////////////////////////////////////////////////////////////////////////
//// Begin GNU specific code

// Error description handling for humans.

string Networking::DescriptiveError(string Msg, int Errno) {                    // Form a descriptive error w/ errno.
        Msg.append(" "); Msg.append(strerror(Errno));
        return Msg;
};

// Networking Constructor //////////////////////////////////////////////////////
// Handles any necessary setup of Network Module resources.

Networking::Networking() {                                                      // Upon initialization,
    // Nothing So Far...                                                        // nothing special required.
}

// Networking Destructor ///////////////////////////////////////////////////////
// Handles any necessary cleanup of Network Module resources.

Networking::~Networking() {                                                     // GNU sockets cleanup,
    // Nothing So Far...                                                        // nothing specail to required.
}

//// End GNU specific code
////////////////////////////////////////////////////////////////////////////////

#endif

////////////////////////////////////////////////////////////////////////////////
//// Platform Agnostic Stuff

//// Useful Internal Bits & Pieces /////////////////////////////////////////////

const int LowestOctetMask = 0x000000FF;                                         // The bits to look at.
const int OneOctetInBits = 8;                                                   // The bits to shift.

void splitIP(                                                                   // Split an IP into octets.
  unsigned long A,                                                              // The address in host format.
  int& a0,                                                                      // Reference to the first octet.
  int& a1,                                                                      // Reference to the second octet.
  int& a2,                                                                      // Reference to the third octet.
  int& a3                                                                       // Reference to the forth octet.
  ){
    a3 = A & LowestOctetMask; A >>= OneOctetInBits;                             // Get the lowest order octet & move.
    a2 = A & LowestOctetMask; A >>= OneOctetInBits;                             // Get the next lowest octet & move.
    a1 = A & LowestOctetMask; A >>= OneOctetInBits;                             // Get the next lowest octet & move.
    a0 = A & LowestOctetMask;                                                   // Get the highest octet. That's IT!
}

//// IP4Address methods ////////////////////////////////////////////////////////

IP4Address::operator unsigned long int() const {                                // Assign to unsigned long int.
    return IP;                                                                  // Return it.
}

IP4Address::operator string() const {                                           // Assign to a string.
    char stringbfr[IPStringBufferSize];                                         // Grab a temporary buffer.
    memset(stringbfr, 0, sizeof(stringbfr));                                    // Null out it's space.
    int a0, a1, a2, a3;                                                         // Grab some integers.
    splitIP(IP, a0, a1, a2, a3);                                                // Split the IP in the IP4Address.
    sprintf(stringbfr, "%d.%d.%d.%d", a0, a1, a2, a3);                          // Format the octets.
    return string(stringbfr);                                                   // Return a string.
}

//// SocketAddress methods /////////////////////////////////////////////////////

// getAddress(str, len)

const char* SocketAddress::getAddress(char* str) {                              // Get the IP address into a cstring.
    if(NULL == str) {                                                           // If the caller did not provide a
        str = IPStringBuffer;                                                   // buffer to use then we will use ours.
    }
    int a0, a1, a2, a3;                                                         // Grab a bunch of handy integers.
    getAddress(a0, a1, a2, a3);                                                 // Get the address as octets.
    sprintf(str, "%d.%d.%d.%d", a0, a1, a2, a3);                                // Format as dotted decimal notation.
    return str;                                                                 // Return the output buffer.
}

// getAddress(int& a0, int& a1, int& a2, int& a3)

void SocketAddress::getAddress(int& a0, int& a1, int& a2, int& a3) {            // Get the IP address into 4 ints
    unsigned long A = getAddress();                                             // Get the address.
    splitIP(A, a0, a1, a2, a3);                                                 // Split it into octets.
}

//// TCPListener methods ///////////////////////////////////////////////////////

TCPListener::TCPListener(unsigned short Port) {                                 // Set up localhost on this Port.
    LocalAddress.setPort(Port);                                                 // Establish the port.
    LocalAddress.setAddress(LOCALHOST);                                         // Set the address to LOCALHOST.
    MaxPending = DefaultMaxPending;                                             // Use the default inbound queue size.
    ReuseAddress = true;                                                        // ReuseAddress on by default.
    OpenStage1Complete = false;                                                 // This stage of open() not yet done.
    OpenStage2Complete = false;                                                 // This stage of open() not yet done.

    // Create a socket...

    LastError = 0;

    Handle = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);                         // Create the socket.
    if(INVALID_SOCKET == Handle) {                                              // If that operation failed then
        LastError = Network.getLastError();                                     // grab the error code and
        throw Networking::SocketCreationError(                                  // throw.
          Network.DescriptiveError(
            "TCPListener::TCPListener().socket()", LastError));
    }
}

TCPListener::TCPListener(SocketAddress& WhereToBind) {                          // Set up specific "name" for listening.
    LocalAddress = WhereToBind;                                                 // Make my Local address as provided.
    MaxPending = DefaultMaxPending;                                             // Use the default inbound queue size.
    ReuseAddress = true;                                                        // ReuseAddress on by default.
    OpenStage1Complete = false;                                                 // This stage of open() not yet done.
    OpenStage2Complete = false;                                                 // This stage of open() not yet done.

    // Create a socket...

    LastError = 0;

    Handle = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);                         // Create the socket.
    if(INVALID_SOCKET == Handle) {                                              // If that operation failed then
        LastError = Network.getLastError();                                     // grab the error code and
        throw Networking::SocketCreationError(                                  // throw.
          Network.DescriptiveError(
            "TCPListener::TCPListener().socket()", LastError));
    }
}

// open()

void TCPListener::open() {                                                      // Open when ready.

    if(OpenSucceeded) return;                                                   // If open already, we're done.

    LastError = 0;                                                              // Clear the last error.
    bool SuccessFlag = true;                                                    // Start optimistically.

    // Set SO_REUSEADDR if turned on

    if(!OpenStage1Complete) {                                                   // Do this stage only once.
        int ReuseAddress_Flag = (ReuseAddress? 1:0);                            // Setup an appropriate integer flag.
        int result =                                                            // Set SO_REUSEADDR before bind().
          setsockopt(
            Handle,
            SOL_SOCKET,
            SO_REUSEADDR,
            (char*) &ReuseAddress_Flag,
            sizeof(ReuseAddress_Flag));

        if(0 > result) {                                                        // If there was an error then
            SuccessFlag = false;                                                // we did not succeed.
            LastError = Network.getLastError();                                 // Capture the error information and
            throw Networking::SocketSetSockOptError(                            // throw.
                Network.DescriptiveError(
                "TCPListener::open().setsockopt(SO_REUSEADDR)", LastError));
        }
        OpenStage1Complete = true;                                              // Stage 1 complete now.
    }                                                                           // End of open() stage 1

    // Next we bind it...

    if(!OpenStage2Complete) {                                                   // Do this stage only once.
        int result =                                                            // Bind our socket to the LocalAddress.
          bind(
            Handle,
            LocalAddress.getPtr_sockaddr(),
            LocalAddress.getAddressSize());

        if(0 > result) {                                                        // If there was an error then
            SuccessFlag = false;                                                // we did not succeed.
            LastError = Network.getLastError();                                 // Capture the error information and
            throw Networking::SocketBindError(                                  // throw.
                Network.DescriptiveError(
                "TCPListener::open().bind()", LastError));
        }
        OpenStage2Complete = true;                                              // Stage 2 complete now.
    }                                                                           // End of open() stage 2

    // Then we put it in a listening state...

    int result = listen(Handle, MaxPending);                                    // Listen for up to MaxPending at once.

    if(0 > result) {                                                            // If an error occurred then
        SuccessFlag = false;                                                    // we did not succeed.
        LastError = Network.getLastError();                                     // Capture the error information and
        throw Networking::SocketListenError(                                    // throw.
          Network.DescriptiveError(
            "TCPListener::open().listen()", LastError));
    }

    OpenSucceeded = SuccessFlag;                                                // So, did we succeed?
}

// acceptClient()

TCPClient* TCPListener::acceptClient() {                                        // Accept a client connection.

    LastError = 0;                                                              // Clear the last error.
    socklen_t rsize = RemoteAddress.getAddressSize();                           // Size as an int for accept().

    hSocket NewHandle =                                                         // Accept a new connection if available.
      accept(
        Handle,                                                                 // use our handle, of course,...
        RemoteAddress.getPtr_sockaddr(),                                        // and store the remote hosts
        &rsize);                                                                // address for us.

    if(INVALID_SOCKET == NewHandle) {                                           // If there was an error then
        LastError = Network.getLastError();                                     // capture the error value.
        if(!Network.WouldBlock(LastError)) {                                    // If it's not a EWOULDBLOCK error
            throw Networking::SocketAcceptError(                                // then we need to throw.
              Network.DescriptiveError(
                "TCPListener::acceptClient().accept()", LastError));
        } else {                                                                // EWOULDBLOCK errors are normal in
            return NULL;                                                        // non blocking mode so we return
        }                                                                       // NULL when we see them.
    }

    // Set SO_NOSIGPIPE if needed

    if(                                                                     // On some systems we may have to
      0 != SO_NOSIGPIPE &&                                                  // use SO_NOSIPIPE but if they offer
      0 == MSG_NOSIGNAL                                                     // MSG_NOSIGNAL we prefer that instead.
      ) {
        int TurnedOn = 1;                                                   // Prepare to turn this option on.
        int result =                                                        // Set SO_NOSIGPIPE.
        setsockopt(
          NewHandle,
          SOL_SOCKET,
          SO_NOSIGPIPE,
          (char*) &TurnedOn,
          sizeof(TurnedOn));

        if(0 > result) {                                                    // If there was an error then
            LastError = Network.getLastError();                             // Capture the error information
            Network.closeSocket(NewHandle);                                 // close the handle (avoid leaks)
            throw Networking::SocketSetSockOptError(                        // and throw a descriptive exception.
              Network.DescriptiveError(
                "TCPListener::acceptClient().setsockopt(SO_NOSIGPIPE)", LastError));
        }
    }

    // If things have gone well we can do what we came for.

    return new TCPClient(*this, NewHandle, RemoteAddress);                      // Create the new TCPClient object.

}

//// TCPClient methods /////////////////////////////////////////////////////////

int TCPClient::transmit(const char* bfr, int size) {                            // How to send a buffer of data.
    if(0 == size) return 0;                                                     // Nothing to send, send nothing.
    if(0 == bfr)                                                                // Watch out for null buffers.
      throw Networking::SocketWriteError("TCPClient::transmit() NULL Bfr!");
    if(0 > size)                                                                // Watch out for bad sizes.
      throw Networking::SocketWriteError("TCPClient::transmit() 0 > size!");

    LastError = 0;                                                              // No errors yet.
    int ByteCount = 0;                                                          // No bytes sent yet this pass.
    ByteCount = send(Handle, bfr, size, MSG_NOSIGNAL);                          // Try to send and capture the count.
    LastError = Network.getLastError();                                         // Grab any error code.

    bool AnErrorOccurred = (0 > ByteCount);                                     // How to know if an error occurred.
    const int NoBytesSent = 0;                                                  // This is our "Would Block" result.

    if(AnErrorOccurred) {                                                       // If there was an error check it out.
        if(Network.WouldBlock(LastError)) {                                     // If the error was "Would Block" then
            return NoBytesSent;                                                 // return no bytes sent (try again).
        } else {                                                                // If this was a different kind of error
            throw Networking::SocketWriteError(                                 // then throw!
              Network.DescriptiveError(
                "TCPClient::transmit().send()", LastError));
        }
    }

    return ByteCount;                                                           // Usually: return the sent byte count.
}

int TCPClient::receive(char* bfr, int size) {                                   // How to receive a buffer of data.
    if(ReadBufferIsEmpty()) {                                                   // If the read buffer is empty then
        fillReadBuffer();                                                       // fill it first.
    }                                                                           // Optimize our transfer to the smaller
    if(DataLength < size) {                                                     // of what we have or the size of the
        size = DataLength;                                                      // provided buffer. This way we ony check
    }                                                                           // one value in our copy loop ;-)
    int RemainingDataLength = size;                                             // Capture the length of data to xfer.
    while(0 < RemainingDataLength) {                                            // While we have work to do
        *bfr = *ReadPointer;                                                    // copy each byte from our ReadBuffer,
        bfr++; ReadPointer++;                                                   // move the pointers to the next byte,
        DataLength--;                                                           // update our ReadBuffers's DataLength,
        RemainingDataLength--;                                                  // and count down the bytes left to xfer.
    }
    return size;                                                                // When done, say how much we moved.
}

int TCPClient::delimited_receive(char* bfr, int size, char delimiter) {         // How to receive delimited data.
    if(ReadBufferIsEmpty()) {                                                   // If the read buffer is empty then
        fillReadBuffer();                                                       // fill it first.
    }                                                                           // Optimize our transfer to the smaller
    if(DataLength < size) {                                                     // of what we have or the size of the
        size = DataLength;                                                      // provided buffer. This way we ony check
    }                                                                           // one value in our copy loop ;-)
    int Count = 0;                                                              // Keep our byte count in scope.
    bool DelimiterNotReached = true;                                            // Watching for our deliimiter.
    while((Count < size) && DelimiterNotReached) {                              // While there is work to do...
        *bfr = *ReadPointer;                                                    // copy each byte from our ReadBuffer,
        DelimiterNotReached = (delimiter != (*bfr));                            // check for the delimiter character,
        bfr++; ReadPointer++;                                                   // move the pointers to the next byte,
        DataLength--;                                                           // update our ReadBuffers's DataLength,
        Count++;                                                                // and count up the bytes we have moved.
    }
    return Count;                                                               // When done, say how much we moved.
}

//// TCPHost methods ///////////////////////////////////////////////////////////

// Constructors...

TCPHost::TCPHost(unsigned short Port) {                                         // Will connect to localhost on Port.
    RemoteAddress.setPort(Port);                                                // Connect to Port on
    RemoteAddress.setAddress(LOCALHOST);                                        // Localhost.
    ReadPointer = ReadBuffer;                                                   // Set the read position to zero.
    DataLength = 0;                                                             // There is no data yet.
    ReuseAddress = false;                                                       // ReuseAddress off by default.
    OpenStage1Complete = false;                                                 // Stage 1 of open() not done yet.

    // Create a socket to use.

    LastError = 0;                                                              // Clear our last error value.

    Handle = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);                         // Create the socket.
    if(0 > Handle) {                                                            // If that operation failed then
        LastError = Network.getLastError();                                     // grab the error code and
        throw Networking::SocketCreationError(                                  // throw.
          Network.DescriptiveError(
            "TCPHost::TCPHost().socket()", LastError));
    }
}

TCPHost::TCPHost(SocketAddress& Remote) {                                       // Will connect to Remote address/port.
    RemoteAddress = Remote;                                                     // Capture the provided address.
    ReadPointer = ReadBuffer;                                                   // Set the read position to zero.
    DataLength = 0;                                                             // There is no data yet.
    ReuseAddress = false;                                                       // ReuseAddress off by default.
    OpenStage1Complete = false;                                                 // Stage 1 of open() not done yet.

    // Create a socket to use.

    LastError = 0;                                                              // Clear our last error value.

    Handle = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);                         // Create the socket.
    if(0 > Handle) {                                                            // If that operation failed then
        LastError = Network.getLastError();                                     // grab the error code and
        throw Networking::SocketCreationError(                                  // throw.
          Network.DescriptiveError(
            "TCPHost::TCPHost().socket()", LastError));
    }
}

// Methods...

void TCPHost::open() {                                                          // We provide open().

    if(OpenSucceeded) return;                                                   // If open already, we're done.

    LastError = 0;                                                              // Clear our LastError value.
    bool SuccessFlag = true;                                                    // Begin optimistically.

    // Set Socket Options

    if(!OpenStage1Complete) {                                                   // If we haven't done this yet:

        // Set SO_REUSEADDR if turned on

        int ReuseAddress_Flag = (ReuseAddress? 1:0);                            // Setup an appropriate integer flag.
        int result =                                                            // Set SO_REUSEADDR before bind().
          setsockopt(
            Handle,
            SOL_SOCKET,
            SO_REUSEADDR,
            (char*) &ReuseAddress_Flag,
            sizeof(ReuseAddress_Flag));

        if(0 > result) {                                                        // If there was an error then
            SuccessFlag = false;                                                // we did not succeed.
            LastError = Network.getLastError();                                 // Capture the error information and
            throw Networking::SocketSetSockOptError(                            // throw.
              Network.DescriptiveError(
                "TCPHost::open().setsockopt(SO_REUSEADDR)", LastError));
        }

        // Set SO_NOSIGPIPE if needed

        if(                                                                     // On some systems we may have to
          0 != SO_NOSIGPIPE &&                                                  // use SO_NOSIPIPE but if they offer
          0 == MSG_NOSIGNAL                                                     // MSG_NOSIGNAL we prefer that instead.
          ) {
            int TurnedOn = 1;                                                   // Prepare to turn this option on.
            int result =                                                        // Set SO_NOSIGPIPE.
            setsockopt(
              Handle,
              SOL_SOCKET,
              SO_NOSIGPIPE,
              (char*) &TurnedOn,
              sizeof(TurnedOn));

            if(0 > result) {                                                    // If there was an error then
                SuccessFlag = false;                                            // we did not succeed.
                LastError = Network.getLastError();                             // Capture the error information and
                throw Networking::SocketSetSockOptError(                        // throw.
                  Network.DescriptiveError(
                    "TCPHost::open().setsockopt(SO_NOSIGPIPE)", LastError));
            }
        }

        OpenStage1Complete = true;                                              // Skip this section from now on.
    }                                                                           // Done with stage 1.

    // Connect the socekt to the Host.

    int result =                                                                // Connect to the remote host
      connect(                                                                  // using the socket we just
        Handle,                                                                 // stored in Handle and
        RemoteAddress.getPtr_sockaddr(),                                        // the Remote address.
        RemoteAddress.getAddressSize());

    if(0 > result) {                                                            // If there was an error then
        SuccessFlag = false;                                                    // we did not succeed.
        LastError = Network.getLastError();                                     // Record the error data.
        if(Network.IsConnected(LastError)) {                                    // If we actually did succeed then
            SuccessFlag = true;                                                 // say so. (Silly Winsock!)
        } else                                                                  // But if that's not the case check
        if(                                                                     // to see if something bad happened -
          !Network.WouldBlock(LastError) &&                                     // not just would-block, or
          !Network.InProgress(LastError)                                        // in progress...
          ) {                                                                   // If it was something other than
            throw Networking::SocketConnectError(                               // WouldBlock or InProgress then
              Network.DescriptiveError(                                         // throw!
                "TCPHost::open().connect()", LastError));
        }                                                                       // If it was WouldBlock then it's
    }                                                                           // considered to be ok.

    OpenSucceeded = SuccessFlag;                                                // So, are we open now?
}

int TCPHost::transmit(const char* bfr, int size) {                              // How to send a buffer of data.
    LastError = 0;                                                              // No errors yet.
    if(0 == size) return 0;                                                     // Nothing to send, send nothing.
    if(0 == bfr)                                                                // Watch out for null buffers.
      throw Networking::SocketWriteError("TCPHost::transmit() NULL Bfr!");
    if(0 > size)                                                                // Watch out for bad sizes.
      throw Networking::SocketWriteError("TCPHost::transmit() 0 > size!");

    int ByteCount = send(Handle, bfr, size, MSG_NOSIGNAL);                      // Try to send and capture the count.
    if(0 > ByteCount) ByteCount = 0;                                            // Mask error results as 0 bytes sent.

    if(size > ByteCount) {                                                      // If we didn't send it all check it out.
        LastError = Network.getLastError();                                     // Grab the error code.
        if(Network.WouldBlock(LastError)) {                                     // If the error was WouldBlock then
            return ByteCount;                                                   // it was a partial snd - return.
        } else {                                                                // If this was a different kind of error
            throw Networking::SocketWriteError(                                 // then throw!
              Network.DescriptiveError(
                "TCPHost::transmit().send()", LastError));
        }
    }
    return ByteCount;                                                           // Ultimately return the byte count.
}

int TCPHost::receive(char* bfr, int size) {                                     // How to receive a buffer of data.
    if(ReadBufferIsEmpty()) {                                                   // If the read buffer is empty then
        fillReadBuffer();                                                       // fill it first.
    }                                                                           // Optimize our transfer to the smaller
    if(DataLength < size) {                                                     // of what we have or the size of the
        size = DataLength;                                                      // provided buffer. This way we ony check
    }                                                                           // one value in our copy loop ;-)
    int RemainingDataLength = size;                                             // Capture the length of data to xfer.
    while(0 < RemainingDataLength) {                                            // While we have work to do
        *bfr = *ReadPointer;                                                    // copy each byte from our ReadBuffer,
        bfr++; ReadPointer++;                                                   // move the pointers to the next byte,
        DataLength--;                                                           // update our ReadBuffers's DataLength,
        RemainingDataLength--;                                                  // and count down the bytes left to xfer.
    }
    return size;                                                                // When done, say how much we moved.
}

int TCPHost::delimited_receive(char* bfr, int size, char delimiter) {           // How to receive delimited data.
    if(ReadBufferIsEmpty()) {                                                   // If the read buffer is empty then
        fillReadBuffer();                                                       // fill it first.
    }                                                                           // Optimize our transfer to the smaller
    if(DataLength < size) {                                                     // of what we have or the size of the
        size = DataLength;                                                      // provided buffer. This way we ony check
    }                                                                           // one value in our copy loop ;-)
    int Count = 0;                                                              // Keep our byte count in scope.
    bool DelimiterNotReached = true;                                            // Watching for our deliimiter.
    while((Count < size) && DelimiterNotReached) {                              // While there is work to do...
        *bfr = *ReadPointer;                                                    // copy each byte from our ReadBuffer,
        DelimiterNotReached = (delimiter != (*bfr));                            // check for the delimiter character,
        bfr++; ReadPointer++;                                                   // move the pointers to the next byte,
        DataLength--;                                                           // update our ReadBuffers's DataLength,
        Count++;                                                                // and count up the bytes we have moved.
    }
    return Count;                                                               // When done, say how much we moved.
}


// End Platform Agnostic Stuff
////////////////////////////////////////////////////////////////////////////////