Ejemplo n.º 1
0
NetAddress Socket::getsockname()
{
    char buf[sizeof(sockaddr_in) + 1];
    memset(buf, 0, sizeof(buf));
    socklen_t len = sizeof(buf);

    int ret = ::getsockname(fd(), (sockaddr*)buf, &len);

    setStatus();

    return NetAddress(buf, len);
}
Ejemplo n.º 2
0
NetListener::NetListener(uint16 port) {
    NetworkDevice* nd = NetworkDevice::instance();

    // Start the listener socket
    Log::common()->print("Creating a listener            ");
    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    
    if (sock == SOCKET_ERROR) {
        Log::common()->printf("FAIL");
        Log::common()->println(socketErrorCode());
        return;
    }
    Log::common()->println("Ok");

    const int T = true;

    // Set reuse address so that a new server can start up soon after
    // an old one has closed.
    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, 
                   (const char*)&T, sizeof(T)) == SOCKET_ERROR) {
        
        Log::common()->println("WARNING: Setting socket reuseaddr failed.");
        Log::common()->println(socketErrorCode());
    } else {
        Log::common()->println("Set socket option reuseaddr.");
    }

    
    if (! nd->bind(sock, NetAddress(0, port))) {
        Log::common()->printf("Unable to bind!\n");
        nd->closesocket(sock);
        sock = (SOCKET)SOCKET_ERROR;
        return;
    }

    Log::common()->printf("Listening on port %5d        ", port);

    // listen is supposed to return 0 when there is no error.
    // The 2nd argument is the number of connections to allow pending
    // at any time.
    int L = listen(sock, 100);
    if (L == SOCKET_ERROR) {
        Log::common()->println("FAIL");
        Log::common()->println(socketErrorCode());
        nd->closesocket(sock);
        sock = (SOCKET)SOCKET_ERROR;
        return;
    }
    Log::common()->println("Ok");
    Log::common()->printf("Now listening on socket %d.\n\n", sock);
}
Ejemplo n.º 3
0
NetAddress Socket::getpeername()
{
    char buf[sizeof(sockaddr_in) + 1];
    memset(buf, 0, sizeof(buf));

    socklen_t len = sizeof(buf);

    int ret = ::getpeername(fd(), (sockaddr*)&buf, &len);

    /// Fix a fatal bug
    /// setStatus();

    return NetAddress(buf, len);
}
Ejemplo n.º 4
0
ReliableConduitRef NetListener::waitForConnection() {

    // The address of the connecting host
    SOCKADDR_IN    remote_addr;
    int iAddrLen = sizeof(remote_addr);

    if (nd->debugLog) {
        nd->debugLog->println("Blocking in NetListener::waitForConnection().");
    }

    SOCKET sClient = accept(sock, (struct sockaddr*) &remote_addr, 
                            (socklen_t*)&iAddrLen);

    if (sClient == SOCKET_ERROR) {
        if (nd->debugLog) {
            nd->debugLog->println("Error in NetListener::acceptConnection.");
            nd->debugLog->println(socketErrorCode());
        }
        nd->closesocket(sock);
        return NULL;
    }

    if (nd->debugLog) {
        nd->debugLog->printf("%s connected, transferred to socket %d.\n", 
                             inet_ntoa(remote_addr.sin_addr), sClient);
    }

    #ifndef G3D_WIN32
        return new ReliableConduit(nd, sClient, 
                     NetAddress(htonl(remote_addr.sin_addr.s_addr), 
                                ntohs(remote_addr.sin_port)));
    #else
        return new ReliableConduit(nd, sClient, 
                    NetAddress(ntohl(remote_addr.sin_addr.S_un.S_addr), 
                               ntohs(remote_addr.sin_port)));
    #endif
}
Ejemplo n.º 5
0
LightweightConduit::LightweightConduit(
    NetworkDevice* _nd, 
    uint16 port,
    bool enableReceive, 
    bool enableBroadcast) : Conduit(_nd) {

    if (nd->debugLog) {nd->debugLog->print("Creating a UDP socket        ");}
    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    
    if (sock == SOCKET_ERROR) {
        sock = 0;
        if (nd->debugLog) {
            nd->debugLog->println("FAIL");
            nd->debugLog->println(socketErrorCode());
        }
        return;
    }
    if (nd->debugLog) {nd->debugLog->println("Ok");}

    if (enableReceive) {
        debugAssert(port != 0);
        nd->bind(sock, NetAddress(0, port));
    }

    // Figuring out the MTU seems very complicated, so we just set it to 1000,
    // which is likely to be safe.  See IP_MTU for more information.
    MTU = 1000;

    increaseBufferSize(sock, nd->debugLog);

    if (enableBroadcast) {
        int TR = true;
        if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, 
                       (const char*)&TR, sizeof(TR)) != 0) {
            if (nd->debugLog) {
                nd->debugLog->println("Call to setsockopt failed");
                nd->debugLog->println(socketErrorCode());
            }
            nd->closesocket(sock);
            return;
        }
    }

    if (nd->debugLog) {
        nd->debugLog->printf("Done creating UDP socket %d\n", sock);
    }

    alreadyReadMessage = false;
}
Ejemplo n.º 6
0
Server::Server(const ServerDescription& description, const Settings& settings) :
    m_settings(settings),
    m_description(description) {

    const Array<uint32> ipArray = NetworkDevice::instance()->broadcastAddressArray();
    m_broadcastAddressArray.resize(ipArray.size());
    for (int i = 0; i < m_broadcastAddressArray.size(); ++i) {
        m_broadcastAddressArray[i] = NetAddress(ipArray[i], m_settings.serverBroadcastPort);
    }

    m_net = LightweightConduit::create(m_settings.clientBroadcastPort, true, true);
    
    debugAssert(m_settings.serverAdvertisementPeriod > 0);
    
    sendAdvertisement();
}
Ejemplo n.º 7
0
void NetworkDevice::localHostAddresses(Array<NetAddress>& array) const {
    array.resize(0);

    char ac[256];

    if (gethostname(ac, sizeof(ac)) == SOCKET_ERROR) {
        Log::common()->printf("Error while getting local host name\n");
        return;
    }

    struct hostent* phe = gethostbyname(ac);
    if (phe == 0) {
        Log::common()->printf("Error while getting local host address\n");
        return;
    }

    for (int i = 0; (phe->h_addr_list[i] != 0); ++i) {
        struct in_addr addr;
        memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr));
        array.append(NetAddress(addr));
    }    
}
Ejemplo n.º 8
0
void runServer() {
    NetworkDevice* nd = NetworkDevice::instance();
    alwaysAssertM(nd->adapterArray().size() > 0, "No network adapters.");

    Discovery::ServerDescription description;
    description.applicationName = "My Game";
    description.maxClients = 10;
    description.serverName = "My Server (" + nd->localHostName() + ")";
    description.applicationAddress = 
        NetAddress(nd->adapterArray()[0].ip, GAME_PORT);

    Discovery::Server::Ref discoveryServer = Discovery::Server::create(description);
    
    // DiscoverServer is a Widget, so in a GApp you can just call
    // GApp::addWidget() instead of explicitly running the following
    // loop.
    debugPrintf("Running server (press any key to exit)\n");
    while (! System::consoleKeyPressed()) {
        discoveryServer->onNetwork();
        System::sleep(1.0f / 30.0f);
    }
}
Ejemplo n.º 9
0
bool NetworkDevice::init() {
    debugAssert(! initialized);

    logPrintf("Network Startup");
    logPrintf("Starting WinSock networking.\n");

//    G3D now initializes winsock through ENet
//    WSADATA wsda;            
//    WSAStartup(MAKEWORD(G3D_WINSOCK_MAJOR_VERSION, G3D_WINSOCK_MINOR_VERSION), &wsda);
        
    std::string hostname = "localhost";
    {
        char ac[128];
        if (gethostname(ac, sizeof(ac)) == -1) {
            logPrintf("Warning: Error while getting local host name\n");
        } else {
            hostname = gethostbyname(ac)->h_name;
        }
    }
    
    EthernetAdapter a;
    a.hostname = hostname;
    a.name = "";
    a.ip = NetAddress(hostname, 0).ip();

    // TODO: Find subnet on Win32
    a.subnet = 0x0000FFFF;
    
    // TODO: Find broadcast on Win32
    a.broadcast = 0xFFFFFFFF;

    // TODO: find MAC on Win32
    
    addAdapter(a);
    
    std::string machine = localHostName();
    std::string addr    = NetAddress(machine, 0).ipString();
    /*
    logPrintf(

              "Network:\n"
              "  Status: %s\n"
              "  Loaded winsock specification version %d (%d is "
              "the highest available)\n"
              "  %d sockets available\n"
              "  Largest UDP datagram packet size is %d bytes\n\n",
              wsda.szDescription,
              wsda.szSystemStatus,
              wsda.wVersion,
              wsda.wHighVersion,
              wsda.iMaxSockets,
              wsda.iMaxUdpDg);
    */
    
    // TODO: WSAIoctl for subnet and broadcast addresses
    // http://msdn.microsoft.com/en-us/library/ms741621(VS.85).aspx
    // 
    // TODO: SIO_GET_INTERFACE_LIST 

    initialized = true;

    return true;
}
Ejemplo n.º 10
0
bool NetworkDevice::init(G3D::Log* _log) {
    debugAssert(!initialized);
    debugLog = _log;

    #ifdef G3D_WIN32
        if (debugLog) {
            debugLog->section("Network Startup");
            debugLog->println("Starting WinSock networking.\n");
        }
        WSADATA wsda;		    
        WSAStartup(MAKEWORD(G3D_WINSOCK_MAJOR_VERSION, G3D_WINSOCK_MINOR_VERSION), &wsda);

        if (debugLog) {
            std::string machine = localHostName();
            std::string addr    = NetAddress(machine, 0).ipString();
            debugLog->printf(
                "Network:\n"
                "  localhost = %s (%s)\n"
                "  %s\n"
                "  Status: %s\n"
                "  Loaded winsock specification version %d (%d is "
                "the highest available)\n"
                "  %d sockets available\n"
                "  Largest UDP datagram packet size is %d bytes\n\n",
                machine.c_str(), addr.c_str(),
                wsda.szDescription,
                wsda.szSystemStatus,
                wsda.wVersion,
                wsda.wHighVersion,
                wsda.iMaxSockets,
                wsda.iMaxUdpDg);
        }
    #endif


    if (debugLog) {debugLog->section("Testing Network");}

    SOCKET sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    
    if (debugLog) {debugLog->print("Open Socket                  ");}
    if (sock == SOCKET_ERROR) {
        if (debugLog) {
            debugLog->println("FAIL");
            debugLog->println(socketErrorCode());
        }
        return false;
    }
    if (debugLog) { debugLog->println("Ok"); }

    int TR = true;
    int ret = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, 
                         (const char*)&TR, sizeof(TR));

    if (debugLog) {debugLog->print("Enable UDP Broadcast         ");}
    if (ret != 0) {
        if (debugLog) {
            debugLog->println("FAIL");
            debugLog->println(socketErrorCode());
        }
        return false;
    }
    if (debugLog) {debugLog->println("Ok");}

    if (debugLog) {debugLog->print("Testing UDP Broadcast        ");}
    SOCKADDR_IN addr;
    int32 x;
    addr = NetAddress(0xFFFFFFFF, 23).addr;
    ret = sendto(sock, (const char*)&x, sizeof(x), 0, 
                 (struct sockaddr *) &addr, sizeof(addr));
    if (ret == SOCKET_ERROR) {
        if (debugLog) {
            debugLog->println("FAIL");
            debugLog->println(socketErrorCode());
        }
        return false;
    }
    if (debugLog) {debugLog->println("Ok");}

    if (debugLog) {debugLog->section("");}
    initialized = true;

    return true;
}
Ejemplo n.º 11
0
NetAddress NetAddress::broadcastAddress(uint16 port) {
    return NetAddress(NetworkDevice::instance()->broadcastAddressArray()[0], port);
}