JSocket_Win32.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library 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
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/



/* This file contains the following OS specific functions

        bool createSocket()

        void dealWithSocketError(int wsaError, JString intro)
        int getLastOSErrorNumber()

*/


#ifdef WIN32
#include "JSocket.h"

namespace cmlabs {

#ifndef CYGWIN
        #define null NULL
#else
        #define null 0
#endif

void JSocket::osCloseSocket(SOCKET thisSocket) {

        if (shutdown(thisSocket, SD_BOTH) < 0)
                connected = connected;

        if (closesocket(thisSocket) < 0)
                connected = connected;
}

bool JSocket::isSocketValid() {
        // Once in a while with multi-threading, 'this' has become NULL
        // so we do the check, can't hurt...
        if (this == NULL)
                return false;
        if (mySocket == null)
                return false;
        else
                return true;
}

bool JSocket::setSocketNotValid() {
        mySocket = 0;
        return true;
}

void JSocket::setNonBlockingMode() {
        unsigned long parm = 1;
        ioctlsocket(mySocket, FIONBIO, &parm);
}

void JSocket::setBlockingMode() {
        unsigned long parm = 0;
        ioctlsocket(mySocket, FIONBIO, &parm);
}


bool JSocket::createSocket() {
        if (mySocket == null) {
                mySocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);        /* create the socket */
                if (mySocket == INVALID_SOCKET) {
                        // We might not have run WSAStartup yet
                        int wsaError = getLastOSErrorNumber();
                        if (wsaError == WSANOTINITIALISED) {
                                WSADATA info;
                                if (WSAStartup(MAKEWORD(1,1), &info) != 0) {
                                        dealWithSocketError(wsaError);
                                        mySocket = null;
                                        return false;
                                }
                                else {
                                        // Now we can retry the socket() function
                                        mySocket = socket(AF_INET, SOCK_STREAM, 0);        /* create the socket */
                                        if (mySocket == INVALID_SOCKET)
                                                wsaError = getLastOSErrorNumber();
                                }
                        }

                        // Do we still have an error
                        if (mySocket == INVALID_SOCKET) {
                                dealWithSocketError(wsaError);
                                mySocket = null;
                                return false;
                        }
                }
        }

        // Always choose non-blocking IO
        setNonBlockingMode();

/*      struct linger tmp = {0, 0};
        setsockopt(mySocket, SOL_SOCKET, SO_LINGER, (char *)&tmp, sizeof(tmp));

        char delay = 0;
        setsockopt(mySocket, IPPROTO_TCP, TCP_NODELAY, (char*) &delay, sizeof(delay));
*/

        struct linger tmp = {1, 0};
        setsockopt(mySocket, SOL_SOCKET, SO_LINGER, (char *)&tmp, sizeof(tmp));

        char delay = 1;
        setsockopt(mySocket, IPPROTO_TCP, TCP_NODELAY, (char*) &delay, sizeof(delay));

        // When we get here the socket is OK
        return true;
}


void JSocket::dealWithSocketError(int wsaError, JString intro) {

        if (wsaError == WSANOTINITIALISED) {
                lastErrorMessage = "Cannot initialize WinSock!";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAENETDOWN) {
                lastErrorMessage = "The network subsystem or the associated service provider has failed";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEAFNOSUPPORT) {
                lastErrorMessage = "The specified address family is not supported";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEINPROGRESS) {
                lastErrorMessage = "A blocking Windows Sockets 1.1 call is in progress, or the service provider is still processing a callback function";
                lastErrorRecoverable = true;
        }
        else if (wsaError == WSAEMFILE) {
                lastErrorMessage = "No more socket descriptors are available";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAENOBUFS) {
                lastErrorMessage = "No buffer space is available. The socket cannot be created";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEPROTONOSUPPORT) {
                lastErrorMessage = "The specified protocol is not supported";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEPROTOTYPE) {
                lastErrorMessage = "The specified protocol is the wrong type for this socket";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAESOCKTNOSUPPORT) {
                lastErrorMessage = "The specified socket type is not supported in this address family";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEADDRINUSE) {
                lastErrorMessage = "The socket's local address is already in use and the socket was not marked to allow address reuse with SO_REUSEADDR. This error usually occurs during execution of the bind function, but could be delayed until this function if the bind was to a partially wildcard address (involving ADDR_ANY) and if a specific address needs to be committed at the time of this function";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEINVAL) {
                lastErrorMessage = "The socket has not been bound with bind";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEISCONN) {
                lastErrorMessage = "The socket is already connected";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAENOTSOCK) {
                lastErrorMessage = "The descriptor is not a socket";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEOPNOTSUPP) {
                lastErrorMessage = "The referenced socket is not of a type that supports the listen operation";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEADDRNOTAVAIL) {
                lastErrorMessage = "The specified address is not a valid address for this machine";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEFAULT) {
                lastErrorMessage = "The name or namelen parameter is not a valid part of the user address space, the namelen parameter is too small, the name parameter contains an incorrect address format for the associated address family, or the first two bytes of the memory block specified by name does not match the address family associated with the socket descriptor s";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEMFILE) {
                lastErrorMessage = "The queue is nonempty upon entry to accept and there are no descriptors available";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEWOULDBLOCK) {
                lastErrorMessage = "The socket is marked as nonblocking and no connections are present to be accepted";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAETIMEDOUT) {
                lastErrorMessage = "Attempt to connect timed out without establishing a connection";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAENETUNREACH) {
                lastErrorMessage = "The network cannot be reached from this host at this time";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEISCONN) {
                lastErrorMessage = "The socket is already connected (connection-oriented sockets only)";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAECONNREFUSED) {
                lastErrorMessage = "The attempt to connect was forcefully rejected";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEAFNOSUPPORT) {
                lastErrorMessage = "Addresses in the specified family cannot be used with this socket";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEADDRNOTAVAIL) {
                lastErrorMessage = "The remote address is not a valid address (such as ADDR_ANY)";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAEALREADY) {
                lastErrorMessage = "A nonblocking connect call is in progress on the specified socket";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAECONNRESET) {
                lastErrorMessage = "Connection was reset";
                lastErrorRecoverable = false;
        }
        else if (wsaError == WSAECONNABORTED) {
                lastErrorMessage = "Software caused connection abort";
                lastErrorRecoverable = false;
        }
        else {
                lastErrorMessage = JString("TCP error with no description: ") + JString(wsaError);
                lastErrorRecoverable = false;
        }



        if (intro.length() > 0)
                lastErrorMessage = intro + JString(": ") + lastErrorMessage;

        if (DEBUGLEVEL(DEBUG)) {
                printf("Network Error: %s\n", (char*)lastErrorMessage);
        }
}


int JSocket::getLastOSErrorNumber() {
        int err = WSAGetLastError();
        WSASetLastError(0);
        return err;
}







/*
bool JSocket::connectNow() {

        //
        // Store information about the server
        //
        struct hostent* lpHostEntry;

//      lpHostEntry = gethostbyname("www.hal-pc.org");          // Specifying server by its name
        lpHostEntry = gethostbyname(address);                           // Specifying server by its name
        if (lpHostEntry == NULL) {
                dealWithSocketError(getLastOSErrorNumber(), "Hostname invalid in connectNow");
                return false;
        }

        if (!isSocketValid()) {
                if (!createSocket())
                        return false;
        }


        struct sockaddr_in saServer;
        saServer.sin_family = AF_INET;
        saServer.sin_addr = *((struct in_addr*)*lpHostEntry->h_addr_list);
                          // ^ Address of the server being inserted into the address field
        saServer.sin_port = htons(port);

        // For now, set
        connected = true;
        listening = false;

        //
        // Connect to the server
        //
        int res;
        if ((res = connect(mySocket, (struct sockaddr*)&saServer, sizeof(struct sockaddr))) < 0) {
                if (!didConnectionGoThrough(500)) {
                        disconnectNow();
                        connected = false;
                        return false;
                }
        }

        connected = true;
        
        return true;
}
*/

} // namespace cmlabs

#endif // WIN32

---