Rooba
/
boinc
mirror of https://github.com/BOINC/boinc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
boinc/lib/network.C

326 lines
9.3 KiB
C
Raw Blame History

// Berkeley Open Infrastructure for Network Computing
// http://boinc.berkeley.edu
// Copyright (C) 2005 University of California
//
// This 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 software 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.
//
// To view the GNU Lesser General Public License visit
// http://www.gnu.org/copyleft/lesser.html
// or write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#ifdef _WIN32
#include "boinc_win.h"
#else
#include <unistd.h>
#include <cstdio>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <fcntl.h>
#endif
#include "error_numbers.h"
#include "network.h"
char* socket_error_str() {
static char buf[80];
#ifdef _WIN32
int e = WSAGetLastError();
switch (e) {
case WSANOTINITIALISED:
return "WSA not initialized";
case WSAENETDOWN:
return "the network subsystem has failed";
case WSAHOST_NOT_FOUND:
return "host name not found";
case WSATRY_AGAIN:
return "no response from server";
case WSANO_RECOVERY:
return "a nonrecoverable error occurred";
case WSANO_DATA:
return "valid name, no data record of requested type";
case WSAEINPROGRESS:
return "a blocking socket call in progress";
case WSAEFAULT:
return "invalid part of user address space";
case WSAEINTR:
return "a blocking socket call was canceled";
case WSAENOTSOCK:
return "not a socket";
}
sprintf(buf, "error %d", e);
return buf;
#else
switch (h_errno) {
case HOST_NOT_FOUND:
return "host not found";
case NO_DATA:
return "valid name, no data record of requested type";
case NO_RECOVERY:
return "a nonrecoverable error occurred";
case TRY_AGAIN:
return "host not found or server failure";
}
sprintf(buf, "error %d", h_errno);
return buf;
#endif
}
int resolve_hostname(char* hostname, int &ip_addr, char* msg) {
// if the hostname is in Internet Standard dotted notation,
// return that address.
//
ip_addr = inet_addr(hostname);
if (ip_addr != -1) {
return 0;
}
// else resolve the name
//
hostent* hep;
hep = gethostbyname(hostname);
if (!hep) {
sprintf(msg, "Can't resolve hostname [%s] %s", hostname, socket_error_str());
#ifdef WIN32
NetClose();
#endif
return ERR_GETHOSTBYNAME;
}
ip_addr = *(int*)hep->h_addr_list[0];
return 0;
}
int boinc_socket(int& fd) {
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) {
perror("socket");
#ifdef WIN32
NetClose();
#endif
return ERR_SOCKET;
}
return 0;
}
int boinc_socket_asynch(int fd, bool asynch) {
if (asynch) {
#ifdef WIN32
unsigned long one = 1;
ioctlsocket(fd, FIONBIO, &one);
#else
int flags;
flags = fcntl(fd, F_GETFL, 0);
if (flags < 0) {
return ERR_FCNTL;
}
if (fcntl(fd, F_SETFL, flags|O_NONBLOCK) < 0 ) {
return ERR_FCNTL;
}
#endif
} else {
#ifdef WIN32
unsigned long zero = 0;
ioctlsocket(fd, FIONBIO, &zero);
#else
int flags;
flags = fcntl(fd, F_GETFL, 0);
if (flags < 0) {
return ERR_FCNTL;
}
if (fcntl(fd, F_SETFL, flags&(~O_NONBLOCK)) < 0 ) {
return ERR_FCNTL;
}
#endif
}
return 0;
}
void boinc_close_socket(int sock) {
#ifdef _WIN32
closesocket(sock);
#else
close(sock);
#endif
}
int get_socket_error(int fd) {
boinc_socklen_t intsize = sizeof(int);
int n;
#ifdef WIN32
getsockopt(fd, SOL_SOCKET, SO_ERROR, (char *)&n, &intsize);
#elif defined(__APPLE__)
getsockopt(fd, SOL_SOCKET, SO_ERROR, &n, (int *)&intsize);
#elif defined(__FreeBSD__)
// workaround for FreeBSD. I don't understand this.
struct sockaddr_in sin;
socklen_t sinsz = sizeof(sin);
n = getpeername(fd, (struct sockaddr *)&sin, &sinsz);
#else
getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)&n, &intsize);
#endif
return n;
}
#ifdef _WIN32
#define DIAL_WAIT 60 // seconds after dial to wait (in case of cancel)
#define CONFIRM_WAIT 60 // seconds after user says not to connect to ask again
#define CLOSE_WAIT 5 // seconds after last call to close that the connection should be terminated
int net_ref_count = -1; // -1 closed, 0 open but not used, >0 number of users
double net_last_req_time = 0; // last time user was requested to connect in seconds
double net_last_dial_time = 0; // last time modem was dialed
double net_close_time = 0; // 0 don't close, >0 time when network connection should be terminated in seconds
bool dialed = false;
int WinsockInitialize() {
WSADATA wsdata;
return WSAStartup( MAKEWORD( 1, 1 ), &wsdata);
}
int WinsockCleanup() {
return WSACleanup();
}
typedef BOOL (WINAPI *GetStateProc)( OUT LPDWORD lpdwFlags, IN DWORD dwReserved);
int get_connected_state( ) {
int online = 0;
static bool first=true;
static HMODULE libmodule;
static GetStateProc GetState;
DWORD connectionFlags;
if (first) {
libmodule = LoadLibrary("wininet.dll");
if (libmodule) {
GetState = (GetStateProc) GetProcAddress(libmodule, "InternetGetConnectedState");
}
first = false;
}
if (libmodule && GetState) {
online = (*GetState)(&connectionFlags, 0);
if (online) {
return CONNECTED_STATE_CONNECTED;
} else {
return CONNECTED_STATE_NOT_CONNECTED;
}
}
return CONNECTED_STATE_UNKNOWN;
}
int NetOpen() {
int rc;
typedef BOOL (WINAPI *GetStateProc)( OUT LPDWORD lpdwFlags, IN DWORD dwReserved);
typedef BOOL (WINAPI *AutoDialProc)( IN DWORD dwFlags, IN DWORD dwReserved);
if (net_ref_count >= 0) {
net_ref_count ++;
return 0;
}
GetStateProc GetState = NULL;
AutoDialProc AutoDial = NULL;
DWORD connectionFlags;
HMODULE libmodule = NULL;
libmodule = LoadLibrary("wininet.dll");
if (libmodule) {
GetState = (GetStateProc)GetProcAddress(libmodule, "InternetGetConnectedState");
AutoDial = (AutoDialProc)GetProcAddress(libmodule, "InternetAutodial");
if (GetState && AutoDial) {
rc = (*GetState)(&connectionFlags, 0);
// Don't Autodial if already connected to Internet by Modem or LAN
if (!rc) {
if((double)time(NULL) < net_last_dial_time + CONFIRM_WAIT) {
return ERR_USER_PERMISSION;
}
#if !defined(_WIN32) && !defined(_CONSOLE)
if(gstate.global_prefs.confirm_before_connecting) {
net_last_req_time = (double)time(NULL);
if(!RequestNetConnect()) {
return ERR_USER_PERMISSION;
}
}
#endif
net_last_dial_time = (double)time(NULL);
rc = (*AutoDial)(INTERNET_AUTODIAL_FORCE_UNATTENDED, 0);
if (rc) {
dialed = true;
} else {
// InternetAutodial() returns error 86 for some users
// and 668 for some other users, but a subsequent call
// to gethostbyname() or connect() autodials successfully.
// So (with one exception) we ignore failure returns
// from InternetAutodial() to work around this problem.
// Error 86 is "The specified Network Password is not correct."
// Error 668 is RAS Error "The connection dropped."
rc = GetLastError();
// Don't continue if busy signal, no answer or user cancelled
if (rc == ERROR_USER_DISCONNECTION) {
return ERR_USER_PERMISSION;
}
}
}
}
}
net_ref_count = 1;
return 0;
}
void NetClose() {
if (net_ref_count > 0) net_ref_count --;
if (net_ref_count == 0) {
net_close_time = (double)time(NULL) + CLOSE_WAIT;
}
}
void NetCheck(bool hangup_if_dialed) {
if (net_ref_count == 0 && net_close_time > 0 && net_close_time < (double)time(NULL)) {
typedef BOOL (WINAPI *HangupProc)(IN DWORD dwReserved);
HangupProc HangUp = NULL;
HMODULE libmodule = NULL;
// Hang up the modem if we dialed it
if (dialed && hangup_if_dialed) {
libmodule = LoadLibrary("wininet.dll");
if (libmodule) {
HangUp = (HangupProc)GetProcAddress(libmodule, "InternetAutodialHangup");
if (HangUp) int rc = (* HangUp)(0);
}
}
dialed = false;
net_ref_count = -1;
net_close_time = 0;
}
}
#else
// anyone know how to see if this host has physical network connection?
//
int get_connected_state() {
return CONNECTED_STATE_UNKNOWN;
}
#endif
Reference in New Issue View Git Blame Copy Permalink