w32sock.cxx

c-smile 一个语法类似与JS 又有点像C++的 编译器

//-< W32SOCK.CXX >---------------------------------------------------*--------*
// SAL                       Version 1.0         (c) 1997  GARRET    *     ?  *
// (System Abstraction Layer)                                        *   /\|  *
//                                                                   *  /  \  *
//                          Created:      8-May-97    K.A. Knizhnik  * / [] \ *
//                          Last update: 19-May-97    K.A. Knizhnik  * GARRET *
//-------------------------------------------------------------------*--------*
// Windows sockets  
//-------------------------------------------------------------------*--------*

#include "w32sock.h"


namespace sal {

#define MAX_HOST_NAME         256
#define MILLISECOND           1000

static HANDLE WatchDogMutex;

class win_socket_library { 
  public:
    win_socket_library() { 
	WSADATA wsa;
	if (WSAStartup(MAKEWORD(1, 1), &wsa) != 0) {
	    fprintf(stderr,"Failed to initialize windows sockets: %d\n",
		    WSAGetLastError());
	}
	//
	// This mutex is used to recognize process termination
	//
	WatchDogMutex = CreateMutex(NULL, TRUE, NULL);
    }
    ~win_socket_library() {
	WSACleanup();
    }
};

static win_socket_library ws32_lib;

boolean win_socket::open(int listen_queue_size)
{
    //unsigned short port;
    char* p;

    //char host_name[256];    

    assert(_address != NULL);

    if ((p = strchr(_address, ':')) == NULL || sscanf(p+1, "%d", &_port) != 1) 
    {
	    errcode = bad_address;
	    return False;
    }

    *p = '\0';
    //printf("host_name:<%s>\n",_address);

    if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) { 
	      errcode = WSAGetLastError();
	      return False;
    }
    struct sockaddr_in insock;
    insock.sin_family = AF_INET;
    insock.sin_addr.s_addr = htonl(INADDR_ANY);
    insock.sin_port = htons(_port);
    
    if (bind(s, (sockaddr*)&insock, sizeof(insock)) != 0) { 
	    errcode = WSAGetLastError();
	    closesocket(s);
	    return False;
    }
    if (listen(s, listen_queue_size) != 0) {
	    errcode = WSAGetLastError();
	    closesocket(s);
	    return False;
    } 

    //if(_port == 0) {
      struct sockaddr_in sa;
      int    namelen = sizeof(sa);
      if(getsockname (s, (struct sockaddr *)&sa, &namelen ) == 0) {
        _port = ntohs(sa.sin_port);
        //char host_name[256];
        //gethostname(host_name,255);
        printf("host_name:<%s>\n",_address);
        struct hostent * phe = gethostbyname(_address);
        if(phe) {
            memcpy(&sa.sin_addr, phe->h_addr, sizeof sa.sin_addr);    
            free(_address);
            _address = strdup(inet_ntoa(sa.sin_addr));

        }
      }
    //}
    

    errcode = ok;
    state = ss_open;
    return True;
}

boolean win_socket::is_ok()
{
    return errcode == ok;
}

void win_socket::get_error_text(char* buf, size_t buf_size)
{
    int   len;
    char  msgbuf[256];
    char* msg = msgbuf; 

    switch(errcode) 
    { 
      case ok:
        msg = "ok";
	break;
      case not_opened:
	msg = "socket not opened";
        break;
      case bad_address: 
	msg = "bad _address";
	break;
      case connection_failed: 
	msg = "exceed limit of attempts of connection to server";
	break;
      case broken_pipe:
	msg = "connection is broken";
	break; 
      case invalid_access_mode:
        msg = "invalid access mode";
	break;
      default: 
        memset(msgbuf,0,sizeof msgbuf);
        if(errcode != 10004) {
	        len = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
		              NULL,
		              errcode,
		              0,
		              msgbuf,
		              sizeof msgbuf,
		              NULL);
	        if (len == 0) 
          { 
              sprintf(msgbuf, "unknown error code %u", errcode);
	        }
        }
    }
    strncpy(buf, msg, buf_size);
}

socket_t* win_socket::accept()
{
    if (state != ss_open) 
    { 
	    errcode = not_opened;
	    return NULL;
    }

    SOCKADDR_IN addr;  
    memset(&addr,0,sizeof(addr));
    int alen = sizeof(addr);
    SOCKET new_sock = ::accept(s, (sockaddr *)&addr, &alen );

    if (new_sock == INVALID_SOCKET) { 
	    errcode = WSAGetLastError();
	    return NULL;
    } 
    else { 
	    static struct linger l = {1, LINGER_TIME};
	    if (setsockopt(s, SOL_SOCKET, SO_LINGER, (char*)&l, sizeof l) != 0) { 
	        errcode = invalid_access_mode; 
	        closesocket(s);
	        return NULL; 
	  }
	  int enabled = 1;
	  if (setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&enabled, 
		         sizeof enabled) != 0)
	  {
	      errcode = WSAGetLastError();
	      closesocket(s);	
	      return NULL;
	  }
	  errcode = ok;

    //return new win_socket(new_sock);
    win_socket *pnew = new win_socket(new_sock);
    pnew->_address = strdup(_address);
    pnew->_port = _port;
    pnew->r_address = strdup(inet_ntoa(addr.sin_addr)); 
    pnew->r_port = addr.sin_port;  
	  return pnew; 
   }
}

boolean win_socket::cancel_accept() 
{
    boolean result = close();
    // Wakeup listener
    delete socket_t::connect(_address, sock_global_domain, 1, 0);
    return result;
}    


boolean win_socket::connect(int max_attempts, time_t timeout)
{
    char hostname[MAX_HOST_NAME];
    char *p;
    unsigned short port;

    assert(_address != NULL);

    if ((p = strchr(_address, ':')) == NULL 
	|| p - _address >= sizeof(hostname) 
	|| sscanf(p+1, "%hd", &port) != 1) 
    {
	errcode = bad_address;
	return False;
    }
    memcpy(hostname, _address, p - _address);
    hostname[p - _address] = '\0';

    struct sockaddr_in insock;  // inet socket _address
    struct hostent*    hp;      // entry in hosts table
    
    unsigned long hostaddr = inet_addr(hostname);

    
    if (  hostaddr != INADDR_NONE ) 
    {
      insock.sin_addr.S_un.S_addr = hostaddr;
    }
    else if ((hp = gethostbyname(hostname)) != NULL && hp->h_addrtype == AF_INET) 
    {
      memcpy(&insock.sin_addr, hp->h_addr, sizeof insock.sin_addr);    
    }
    else 
    {
	    errcode = bad_address;
	    return False;
    }
    insock.sin_family = AF_INET;
    insock.sin_port = htons(port);
    
    
    while (True) {
	if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) { 
	    errcode = WSAGetLastError();
	    return False;
	}
	if (::connect(s, (sockaddr*)&insock, sizeof insock) != 0) { 
	    errcode = WSAGetLastError();
	    closesocket(s);
	    if (errcode == WSAECONNREFUSED) {
		if (--max_attempts > 0) {  
		    Sleep(timeout*MILLISECOND);
		} else { 
		    break;
		}
            } else {
		return False;
	    }
	} else {
	    int enabled = 1;
	    if (setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&enabled, 
			   sizeof enabled) != 0)
	    {
		errcode = WSAGetLastError();
		closesocket(s);	
		return False;
	    }
	    errcode = ok;
	    state = ss_open;
	    return True;
	}
    }
    errcode = connection_failed;
    return False;
}

int win_socket::read(void* buf, size_t min_size, size_t max_size, 
		     time_t timeout)
{ 
    size_t size = 0;
    time_t start = 0;
    if (state != ss_open) { 
	errcode = not_opened;
	return -1;
    }
    if (timeout != WAIT_FOREVER) { 
	start = time(NULL); 
    }

    do { 
	    int rc;
	    if (timeout != WAIT_FOREVER) { 
	        fd_set events;
	        struct timeval tm;
	        FD_ZERO(&events);
	        FD_SET(s, &events);
	        tm.tv_sec = timeout;
	        tm.tv_usec = 0;
	        rc = select(s+1, &events, NULL, NULL, &tm);
	        if (rc < 0) { 
		        errcode = errno;
		        return -1;
	        }
	        if (rc == 0) {
  		      return size;
	        }
	        time_t now = time(NULL);
	        timeout = start + timeout >= now ? 0 : timeout + start - now;  
	    }
	    rc = recv(s, (char*)buf + size, max_size - size, 0);
	    if (rc < 0) { 
	        errcode = WSAGetLastError();
	        return -1;
	    } else if (rc == 0) {
	        errcode = broken_pipe;
	        return -1; 
	    } else { 
	        size += rc; 
	    }
    } while (size < min_size); 

    return (int)size;
}

boolean win_socket::read(void* buf, size_t size,size_t *size_read)
{ 
    if (state != ss_open) { 
	    errcode = not_opened;
	    return False;
    }
    size_t sz = size;
    do { 
	    int rc = recv(s, (char*)buf, size, 0);
	    if (rc < 0) { 
	        errcode = WSAGetLastError();
	        break;
	    } else if (rc == 0) {
	        errcode = broken_pipe;
	        break; 
	    } else { 
	        buf = (char*)buf + rc; 
	        size -= rc; 
	    }
    } while (size != 0); 
    if(size_read) *size_read = sz - size;
    return (size == 0);
}
	

boolean win_socket::write(void const* buf, size_t size)
{ 
    if (state != ss_open) { 
	errcode = not_opened;
	return False;
    }
    
    do { 
	int rc = send(s, (char*)buf, size, 0);
	if (rc < 0) { 
	    errcode = WSAGetLastError();
	    return False;
	} else if (rc == 0) {
	    errcode = broken_pipe;
	    return False; 
	} else { 
	    buf = (char*)buf + rc; 
	    size -= rc; 
	}
    } while (size != 0); 

    return True;
}
	
boolean win_socket::shutdown()
{
    if (state == ss_open) { 
	state = ss_shutdown;
        int rc = ::shutdown(s, 2);
        if (rc != 0) {
	    errcode = WSAGetLastError();
	    return False;
	} 
    } 
    errcode = ok;
    return True;
}


boolean win_socket::close()
{
    if (state != ss_close) { 
	    state = ss_close;

      if (_address) free(_address);
      if (r_address) free(r_address);

	    if (closesocket(s) == 0) { 
	        errcode = ok;
	        return True;
	    } else { 
	        errcode = WSAGetLastError();
	        return False;
	    }
    }
    return True;
}

win_socket::~win_socket()
{
    close();
}

win_socket::win_socket(const char* addr)
{ 
    _address = strdup(addr); 
    r_address = NULL;
    r_port = 0;
    errcode = ok;
    s = INVALID_SOCKET;
}

win_socket::win_socket(SOCKET new_sock) 
{ 
    s = new_sock; 
    _address = NULL; 
    r_address = NULL;
    r_port = 0;
    state = ss_open;
    errcode = ok;
}

socket_t* socket_t::create_local(char const* _address, int listen_queue_size)
{
    local_win_socket* sock = new local_win_socket(_address);
    sock->open(listen_queue_size);
    return sock;
}

socket_t* socket_t::create_global(char const* _address, int listen_queue_size)
{
    win_socket* sock = new win_socket(_address);
    sock->open(listen_queue_size); 
    return sock;
}

socket_t* socket_t::connect(char const* _address, 
			    socket_domain domain, 
			    int max_attempts,
			    time_t timeout)
{
    char   hostname[MAX_HOST_NAME];
    size_t hostname_len;
    char*  port;
    
    if (domain == sock_local_domain 
	  || (domain == sock_any_domain 
	    && ((port = strchr(_address, ':')) == NULL 
		|| ((hostname_len = port - _address) == 9 
		    && strncmp(_address, "localhost", hostname_len) == 0)
		|| (gethostname(hostname, sizeof hostname) != 0 
		    && strlen(hostname) == hostname_len 
		    && strncmp(_address, hostname, hostname_len) == 0))))
     {
        local_win_socket* s = new local_win_socket(_address);
        s->connect(max_attempts, timeout); 
	return s;
     } else { 
        win_socket* s = new win_socket(_address);
        s->connect(max_attempts, timeout); 
        return s;
    }  
}
    
char const* get_process_name() 
{ 
    static char name[MAX_HOST_NAME+8];
    gethostname(name, MAX_HOST_NAME); 
    sprintf(name + strlen(name), ":%x", GetCurrentProcessId());
    return name;
}

//
// Local windows sockets
//

int local_win_socket::read(void* buf, size_t min_size, size_t max_size, 
			   time_t timeout)
{
    time_t start = 0;
    char* dst = (char*)buf;
    size_t size = 0;
    Error = ok;
    if (timeout != WAIT_FOREVER) { 
	start = time(NULL); 
	timeout *= 1000; // convert seconds to miliseconds
    }
    while (size < min_size && state == ss_open) {	
        RcvBuf->RcvWaitFlag = true;