socket.cpp

swain-0.5.2.zip的源代码,比较好用,希望大家喜欢.

/*
This file is part of SWAIN (http://sourceforge.net/projects/swain).
Copyright (C) 2006  Daniel Lindstr鰉 and Daniel Nilsson

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., 51 Franklin Street, Fifth Floor,
Boston, MA  02110-1301, USA.
*/
#include "StdAfx.h"
#include "Socket.h"

#define VER_MAJ 1
#define VER_MIN 1

int Socket::sock_count = 0;

Socket::Socket(void) {
	if (sock_count == 0) {
		initWinSock();
	}
	sock_count++;

	sock = INVALID_SOCKET;
	state = STATE_NEW;
}

Socket::~Socket(void) {
	if (state != STATE_CLOSED) {
		close();
	}

	sock_count--;
	if (sock_count == 0) {
		exitWinSock();
	}
	if (sock_count < 0) {
		throw "Whooa! More sockets are destroyed than created!";
	}
}

void Socket::initWinSock() {
	WORD wVersionRequested;
	WSADATA wsaData;
	int err;

	wVersionRequested = MAKEWORD(VER_MAJ, VER_MIN);

	err = WSAStartup( wVersionRequested, &wsaData );
	if (err != 0) {
		return;
	}

	if (LOBYTE( wsaData.wVersion ) != VER_MAJ ||
        HIBYTE( wsaData.wVersion ) != VER_MIN) {
	    WSACleanup();
		throw "You need a new version of WinSock";
		return; 
	}
}

void Socket::exitWinSock(void) {
	WSACleanup();
}

void Socket::setSocket(SOCKET s) {
	sock = s;
	state = STATE_CONNECTED;
}

bool Socket::createSocket(void) {
	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock == INVALID_SOCKET) {
		return false;
	}
	int val = 1;
	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val));
	return true;
}

bool Socket::connectTo(const char *host, short port) {
	struct hostent *hostentry;
	sockaddr_in addr;

	if (state != STATE_NEW) {
		return false;
	}

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

	hostentry = gethostbyname(host);
	if (!hostentry) {
		close();
		return false;
	}
	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr.sin_addr = *((struct in_addr *)hostentry->h_addr);

	if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) == SOCKET_ERROR) {
		close();
		return false;
	}
	state = STATE_CONNECTED;
	return true;
}

bool Socket::startListen(short port) {
	sockaddr_in addr;

	if (state != STATE_NEW) {
		return false;
	}

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

	addr.sin_port = htons(port);
	addr.sin_family = AF_INET;
	addr.sin_addr.S_un.S_addr = INADDR_ANY;

	if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == SOCKET_ERROR) {
		close();
		return false;
	}
	
	if (listen(sock, 1) == SOCKET_ERROR) {
		close();
		return false;
	}
	state = STATE_LISTEN;
	return true;
}

Socket *Socket::acceptConnection(void) {
	int len;
	sockaddr_in address;
	//SOCKET newsock = accept(sock, NULL, NULL);
	len = sizeof(addr);
	SOCKET newsock = accept(sock, (sockaddr *)&address, &len);
	Socket *newsocket;

	if (newsock == INVALID_SOCKET) {
		return NULL;
	}
	
	newsocket = new Socket();
	newsocket->setSocket(newsock);
	newsocket->addr = address;
	return newsocket;
}

bool Socket::close(void) {
	state = STATE_CLOSED;
	if (closesocket(sock))
		return false;
	return true;
}

bool Socket::sendByte(char b) {
	return (sendData(&b, 1) == 1);
}

bool Socket::sendShort(short s) {
	s = htons(s);
	return (sendData(&s, 2) == 2);
}

bool Socket::sendInt(int i) {
	i = htonl(i);
	return (sendData(&i, 4) == 4);
}

bool Socket::sendFloat(float f) {
	return (sendData(&f, 4) == 4);
}

bool Socket::sendString(char *s) {
	int l = (int)strlen(s);		// FIXME: Extremly long strings will wrap varable l
	return (sendInt(l) && (sendData(s, l) == l));
}

bool Socket::sendString(WCHAR *s) {
	int l = (int)wcslen(s);		// FIXME: Extremly long strings will wrap varable l
	return (sendInt(l) && (sendData(s, 2 * l) == 2 * l));
}

bool Socket::receiveByte(char *b) {
	return (receiveData(b, 1) == 1);
}

bool Socket::receiveShort(short *s) {
	bool ret = (receiveData(s, 2) == 2);
	*s = ntohs(*s);
	return ret;
}

bool Socket::receiveInt(int *i) {
	bool ret = (receiveData(i, 4) == 4);
	*i = ntohl(*i);
	return ret;
}

bool Socket::receiveFloat(float *f) {
	return (receiveData(f, 4) == 4);
}

// Returns length of string, but write max bufSize chars to buf.
int Socket::receiveString(char *buf, int bufSize) {
	int len;
	if (!receiveInt(&len)) {
		return -1;
	}
	int n = min(len, bufSize-1);
	int ret = receiveData(buf, n);
	if (ret < 0) {		// IO Error
		return ret;
	}
	if (ret < n) {		// Unexpected EOF
		return -1;
	}
	if (n < len) {
		discardData(len - n);
	}
	buf[n] = '\0';
	return len;
}

// Returns length of string, but writes max bufSize wchars to buf.
int Socket::receiveString(WCHAR *buf, int bufSize) {
	int len;
	if (!receiveInt(&len)) {
		return -1;
	}
	int n = min(len, bufSize-1);
	int ret = receiveData(buf, 2 * n);
	if (ret < 0) {		// IO Error
		return ret;
	}
	if (ret < 2 * n) {	// Unxepected EOF
		return -1;
	}
	if (n < len) {
		discardData(2 * (len - n));
	}
	buf[n] = '\0';
	return len;
}

int Socket::sendData(void *buf, int len) {
	int i = 0, n;
	do {
		n = send(sock, (char *)buf + i, len - i, 0);
		if (n < 0) {
			return n;	// An error occured
		}
		i += n;
	} while (i < len);
	return i;
}

int Socket::receiveData(void *buf, int len) {
	int i = 0, n;
	do {
		n = recv(sock, (char *)buf + i, len - i, 0);
		if (n < 0) {
			return n;	// An error occured
		}
		if (n == 0) {
			return i;	// End of stream, return how much was read
		}
		i += n;
	} while (i < len);
	return i;
}

int Socket::discardData(int len) {
	const int BUFSIZE = 64;
	int i = 0, n;
	char buf[BUFSIZE];
	do {
		n = recv(sock, buf, min(BUFSIZE, len - i), 0);
		if (n < 0) {
			return n;	// An error occured
		}
		if (n == 0) {
			return i;	// End of stream, return how much was read
		}
		i += n;
	} while (i < len);
	return i;
}


int Socket::getInetAddr(){
	return((int)this->addr.sin_addr.S_un.S_addr);
}