[p5sagit/p5-mst-13.2.git] / win32 / ipsock.c

/*

	ipsock.c
	Interface for perl socket functions

*/

#include <ipsock.h>
#include <fcntl.h>

#define USE_SOCKETS_AS_HANDLES

class CPerlSock : public IPerlSock
{
public:
	CPerlSock();
	~CPerlSock();
	virtual u_long Htonl(u_long hostlong);
	virtual u_short Htons(u_short hostshort);
	virtual u_long Ntohl(u_long netlong);
	virtual u_short Ntohs(u_short netshort);
	virtual SOCKET Accept(SOCKET s, struct sockaddr* addr, int* addrlen, int &err);
	virtual int Bind(SOCKET s, const struct sockaddr* name, int namelen, int &err);
	virtual int Connect(SOCKET s, const struct sockaddr* name, int namelen, int &err);
	virtual void Endhostent(int &err);
	virtual void Endnetent(int &err);
	virtual void Endprotoent(int &err);
	virtual void Endservent(int &err);
	virtual struct hostent* Gethostbyaddr(const char* addr, int len, int type, int &err);
	virtual struct hostent* Gethostbyname(const char* name, int &err);
	virtual struct hostent* Gethostent(int &err);
	virtual int Gethostname(char* name, int namelen, int &err);
	virtual struct netent *Getnetbyaddr(long net, int type, int &err);
	virtual struct netent *Getnetbyname(const char *, int &err);
	virtual struct netent *Getnetent(int &err);
 	virtual int Getpeername(SOCKET s, struct sockaddr* name, int* namelen, int &err);
	virtual struct protoent* Getprotobyname(const char* name, int &err);
	virtual struct protoent* Getprotobynumber(int number, int &err);
	virtual struct protoent* Getprotoent(int &err);
	virtual struct servent* Getservbyname(const char* name, const char* proto, int &err);
	virtual struct servent* Getservbyport(int port, const char* proto, int &err);
	virtual struct servent* Getservent(int &err);
	virtual int Getsockname(SOCKET s, struct sockaddr* name, int* namelen, int &err);
	virtual int Getsockopt(SOCKET s, int level, int optname, char* optval, int* optlen, int &err);
	virtual unsigned long InetAddr(const char* cp, int &err);
	virtual char* InetNtoa(struct in_addr in, int &err);
	virtual int IoctlSocket(SOCKET s, long cmd, u_long *argp, int& err);
	virtual int Listen(SOCKET s, int backlog, int &err);
	virtual int Recvfrom(SOCKET s, char* buffer, int len, int flags, struct sockaddr* from, int* fromlen, int &err);
	virtual int Select(int nfds, char* readfds, char* writefds, char* exceptfds, const struct timeval* timeout, int &err);
	virtual int Send(SOCKET s, const char* buffer, int len, int flags, int &err); 
	virtual int Sendto(SOCKET s, const char* buffer, int len, int flags, const struct sockaddr* to, int tolen, int &err);
	virtual void Sethostent(int stayopen, int &err);
	virtual void Setnetent(int stayopen, int &err);
	virtual void Setprotoent(int stayopen, int &err);
	virtual void Setservent(int stayopen, int &err);
	virtual int Setsockopt(SOCKET s, int level, int optname, const char* optval, int optlen, int &err);
	virtual int Shutdown(SOCKET s, int how, int &err);
	virtual SOCKET Socket(int af, int type, int protocol, int &err);
	virtual int Socketpair(int domain, int type, int protocol, int* fds, int &err);

	void CloseSocket(int fh, int& err);
	void* GetAddress(HINSTANCE hInstance, char *lpFunctionName);
	void LoadWinSock(void);

	inline void SetPerlObj(CPerlObj *p) { pPerl = p; };
	inline void SetStdObj(IPerlStdIOWin *p) { pStdIO = p; };
protected:
	void Start(void);

	inline int OpenOSfhandle(long osfhandle)
	{
		return pStdIO->OpenOSfhandle(osfhandle, O_RDWR|O_BINARY);
	};
	int GetOSfhandle(int filenum)
	{
		return pStdIO->GetOSfhandle(filenum);
	};

	inline void StartSockets(void)
	{
		if(!bStarted)
			Start();
	};

	BOOL bStarted;
	CPerlObj *pPerl;
	IPerlStdIOWin *pStdIO;
};


#define SOCKETAPI PASCAL 

typedef SOCKET (SOCKETAPI *LPSOCKACCEPT)(SOCKET, struct sockaddr *, int *);
typedef int (SOCKETAPI *LPSOCKBIND)(SOCKET, const struct sockaddr *, int);
typedef int (SOCKETAPI *LPSOCKCLOSESOCKET)(SOCKET);
typedef int (SOCKETAPI *LPSOCKCONNECT)(SOCKET, const struct sockaddr *, int);
typedef unsigned long (SOCKETAPI *LPINETADDR)(const char *);
typedef char* (SOCKETAPI *LPINETNTOA)(struct in_addr);
typedef int (SOCKETAPI *LPSOCKIOCTLSOCKET)(SOCKET, long, u_long *);
typedef int (SOCKETAPI *LPSOCKGETPEERNAME)(SOCKET, struct sockaddr *, int *);
typedef int (SOCKETAPI *LPSOCKGETSOCKNAME)(SOCKET, struct sockaddr *, int *);
typedef int (SOCKETAPI *LPSOCKGETSOCKOPT)(SOCKET, int, int, char *, int *);
typedef u_long (SOCKETAPI *LPSOCKHTONL)(u_long);
typedef u_short (SOCKETAPI *LPSOCKHTONS)(u_short);
typedef int (SOCKETAPI *LPSOCKLISTEN)(SOCKET, int);
typedef u_long (SOCKETAPI *LPSOCKNTOHL)(u_long);
typedef u_short (SOCKETAPI *LPSOCKNTOHS)(u_short);
typedef int (SOCKETAPI *LPSOCKRECV)(SOCKET, char *, int, int);
typedef int (SOCKETAPI *LPSOCKRECVFROM)(SOCKET, char *, int, int, struct sockaddr *, int *);
typedef int (SOCKETAPI *LPSOCKSELECT)(int, fd_set *, fd_set *, fd_set *, const struct timeval *);
typedef int (SOCKETAPI *LPSOCKSEND)(SOCKET, const char *, int, int);
typedef int (SOCKETAPI *LPSOCKSENDTO)(SOCKET, const char *, int, int, const struct sockaddr *, int);
typedef int (SOCKETAPI *LPSOCKSETSOCKOPT)(SOCKET, int, int, const char *, int);
typedef int (SOCKETAPI *LPSOCKSHUTDOWN)(SOCKET, int);
typedef SOCKET (SOCKETAPI *LPSOCKSOCKET)(int, int, int);

/* Database function prototypes */
typedef struct hostent *(SOCKETAPI *LPSOCKGETHOSTBYADDR)(const char *, int, int);
typedef struct hostent *(SOCKETAPI *LPSOCKGETHOSTBYNAME)(const char *);
typedef int (SOCKETAPI *LPSOCKGETHOSTNAME)(char *, int);
typedef struct servent *(SOCKETAPI *LPSOCKGETSERVBYPORT)(int, const char *);
typedef struct servent *(SOCKETAPI *LPSOCKGETSERVBYNAME)(const char *, const char *);
typedef struct protoent *(SOCKETAPI *LPSOCKGETPROTOBYNUMBER)(int);
typedef struct protoent *(SOCKETAPI *LPSOCKGETPROTOBYNAME)(const char *);

/* Microsoft Windows Extension function prototypes */
typedef int (SOCKETAPI *LPSOCKWSASTARTUP)(unsigned short, LPWSADATA);
typedef int (SOCKETAPI *LPSOCKWSACLEANUP)(void);
typedef int (SOCKETAPI *LPSOCKWSAGETLASTERROR)(void);
typedef int (SOCKETAPI *LPWSAFDIsSet)(SOCKET, fd_set *);

static HINSTANCE hWinSockDll = 0;

static LPSOCKACCEPT paccept = 0;
static LPSOCKBIND pbind = 0;
static LPSOCKCLOSESOCKET pclosesocket = 0;
static LPSOCKCONNECT pconnect = 0;
static LPINETADDR pinet_addr = 0;
static LPINETNTOA pinet_ntoa = 0;
static LPSOCKIOCTLSOCKET pioctlsocket = 0;
static LPSOCKGETPEERNAME pgetpeername = 0;
static LPSOCKGETSOCKNAME pgetsockname = 0;
static LPSOCKGETSOCKOPT pgetsockopt = 0;
static LPSOCKHTONL phtonl = 0;
static LPSOCKHTONS phtons = 0;
static LPSOCKLISTEN plisten = 0;
static LPSOCKNTOHL pntohl = 0;
static LPSOCKNTOHS pntohs = 0;
static LPSOCKRECV precv = 0;
static LPSOCKRECVFROM precvfrom = 0;
static LPSOCKSELECT pselect = 0;
static LPSOCKSEND psend = 0;
static LPSOCKSENDTO psendto = 0;
static LPSOCKSETSOCKOPT psetsockopt = 0;
static LPSOCKSHUTDOWN pshutdown = 0;
static LPSOCKSOCKET psocket = 0;
static LPSOCKGETHOSTBYADDR pgethostbyaddr = 0;
static LPSOCKGETHOSTBYNAME pgethostbyname = 0;
static LPSOCKGETHOSTNAME pgethostname = 0;
static LPSOCKGETSERVBYPORT pgetservbyport = 0;
static LPSOCKGETSERVBYNAME pgetservbyname = 0;
static LPSOCKGETPROTOBYNUMBER pgetprotobynumber = 0;
static LPSOCKGETPROTOBYNAME pgetprotobyname = 0;
static LPSOCKWSASTARTUP pWSAStartup = 0;
static LPSOCKWSACLEANUP pWSACleanup = 0;
static LPSOCKWSAGETLASTERROR pWSAGetLastError = 0;
static LPWSAFDIsSet pWSAFDIsSet = 0;

void* CPerlSock::GetAddress(HINSTANCE hInstance, char *lpFunctionName)
{
	char buffer[512];
	FARPROC proc = GetProcAddress(hInstance, lpFunctionName);
	if(proc == 0)
	{
		sprintf(buffer, "Unable to get address of %s in WSock32.dll", lpFunctionName);
		croak(buffer);
	}
	return proc;
}

void CPerlSock::LoadWinSock(void)
{
	if(hWinSockDll == NULL)
	{
		HINSTANCE hLib = LoadLibrary("WSock32.DLL");
		if(hLib == NULL)
			croak("Could not load WSock32.dll\n");

		paccept = (LPSOCKACCEPT)GetAddress(hLib, "accept");
		pbind = (LPSOCKBIND)GetAddress(hLib, "bind");
		pclosesocket = (LPSOCKCLOSESOCKET)GetAddress(hLib, "closesocket");
		pconnect = (LPSOCKCONNECT)GetAddress(hLib, "connect");
		pinet_addr = (LPINETADDR)GetAddress(hLib, "inet_addr");
		pinet_ntoa = (LPINETNTOA)GetAddress(hLib, "inet_ntoa");
		pioctlsocket = (LPSOCKIOCTLSOCKET)GetAddress(hLib, "ioctlsocket");
		pgetpeername = (LPSOCKGETPEERNAME)GetAddress(hLib, "getpeername");
		pgetsockname = (LPSOCKGETSOCKNAME)GetAddress(hLib, "getsockname");
		pgetsockopt = (LPSOCKGETSOCKOPT)GetAddress(hLib, "getsockopt");
		phtonl = (LPSOCKHTONL)GetAddress(hLib, "htonl");
		phtons = (LPSOCKHTONS)GetAddress(hLib, "htons");
		plisten = (LPSOCKLISTEN)GetAddress(hLib, "listen");
		pntohl = (LPSOCKNTOHL)GetAddress(hLib, "ntohl");
		pntohs = (LPSOCKNTOHS)GetAddress(hLib, "ntohs");
		precv = (LPSOCKRECV)GetAddress(hLib, "recv");
		precvfrom = (LPSOCKRECVFROM)GetAddress(hLib, "recvfrom");
		pselect = (LPSOCKSELECT)GetAddress(hLib, "select");
		psend = (LPSOCKSEND)GetAddress(hLib, "send");
		psendto = (LPSOCKSENDTO)GetAddress(hLib, "sendto");
		psetsockopt = (LPSOCKSETSOCKOPT)GetAddress(hLib, "setsockopt");
		pshutdown = (LPSOCKSHUTDOWN)GetAddress(hLib, "shutdown");
		psocket = (LPSOCKSOCKET)GetAddress(hLib, "socket");
		pgethostbyaddr = (LPSOCKGETHOSTBYADDR)GetAddress(hLib, "gethostbyaddr");
		pgethostbyname = (LPSOCKGETHOSTBYNAME)GetAddress(hLib, "gethostbyname");
		pgethostname = (LPSOCKGETHOSTNAME)GetAddress(hLib, "gethostname");
		pgetservbyport = (LPSOCKGETSERVBYPORT)GetAddress(hLib, "getservbyport");
		pgetservbyname = (LPSOCKGETSERVBYNAME)GetAddress(hLib, "getservbyname");
		pgetprotobynumber = (LPSOCKGETPROTOBYNUMBER)GetAddress(hLib, "getprotobynumber");
		pgetprotobyname = (LPSOCKGETPROTOBYNAME)GetAddress(hLib, "getprotobyname");
		pWSAStartup = (LPSOCKWSASTARTUP)GetAddress(hLib, "WSAStartup");
		pWSACleanup = (LPSOCKWSACLEANUP)GetAddress(hLib, "WSACleanup");
		pWSAGetLastError = (LPSOCKWSAGETLASTERROR)GetAddress(hLib, "WSAGetLastError");
		pWSAFDIsSet = (LPWSAFDIsSet)GetAddress(hLib, "__WSAFDIsSet");
		hWinSockDll = hLib;
	}
}


CPerlSock::CPerlSock()
{
	bStarted = FALSE;
	pPerl = NULL;
	pStdIO = NULL;
}

CPerlSock::~CPerlSock()
{
	if(bStarted)
		pWSACleanup();
}

void
CPerlSock::Start(void) 
{
    unsigned short version;
    WSADATA retdata;
    int ret;
    int iSockOpt = SO_SYNCHRONOUS_NONALERT;

	LoadWinSock();
    /*
     * initalize the winsock interface and insure that it is
     * cleaned up at exit.
     */
    version = 0x101;
    if(ret = pWSAStartup(version, &retdata))
	croak("Unable to locate winsock library!\n");
    if(retdata.wVersion != version)
	croak("Could not find version 1.1 of winsock dll\n");

    /* atexit((void (*)(void)) EndSockets); */

#ifdef USE_SOCKETS_AS_HANDLES
    /*
     * Enable the use of sockets as filehandles
     */
    psetsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
		(char *)&iSockOpt, sizeof(iSockOpt));
#endif	/* USE_SOCKETS_AS_HANDLES */
    bStarted = TRUE;
}


u_long 
CPerlSock::Htonl(u_long hostlong)
{
	StartSockets();
	return phtonl(hostlong);
}

u_short 
CPerlSock::Htons(u_short hostshort)
{
	StartSockets();
	return phtons(hostshort);
}

u_long 
CPerlSock::Ntohl(u_long netlong)
{
	StartSockets();
	return pntohl(netlong);
}

u_short 
CPerlSock::Ntohs(u_short netshort)
{
	StartSockets();
	return pntohs(netshort);
}


/* thanks to Beverly Brown	(beverly@datacube.com) */
#ifdef USE_SOCKETS_AS_HANDLES
#	define OPEN_SOCKET(x)	OpenOSfhandle(x)
#	define TO_SOCKET(x)	GetOSfhandle(x)
#else
#	define OPEN_SOCKET(x)	(x)
#	define TO_SOCKET(x)	(x)
#endif	/* USE_SOCKETS_AS_HANDLES */

#define SOCKET_TEST(x, y) \
	STMT_START {					\
	StartSockets();					\
	if((x) == (y))					\
		err = pWSAGetLastError();	\
	} STMT_END

#define SOCKET_TEST_ERROR(x) SOCKET_TEST(x, SOCKET_ERROR)

SOCKET 
CPerlSock::Accept(SOCKET s, struct sockaddr* addr, int* addrlen, int &err)
{
	SOCKET r;

	SOCKET_TEST((r = paccept(TO_SOCKET(s), addr, addrlen)), INVALID_SOCKET);
	return OPEN_SOCKET(r);
}

int
CPerlSock::Bind(SOCKET s, const struct sockaddr* addr, int addrlen, int &err)
{
	int r;

	SOCKET_TEST_ERROR(r = pbind(TO_SOCKET(s), addr, addrlen));
	return r;
}

void
CPerlSock::CloseSocket(int fh, int& err)
{
	SOCKET_TEST_ERROR(pclosesocket(TO_SOCKET(fh)));
}

int 
CPerlSock::Connect(SOCKET s, const struct sockaddr* addr, int addrlen, int &err)
{
	int r;

	SOCKET_TEST_ERROR(r = pconnect(TO_SOCKET(s), addr, addrlen));
	return r;
}

void CPerlSock::Endhostent(int &err)
{
	croak("endhostent not implemented!\n");
}

void CPerlSock::Endnetent(int &err)
{
	croak("endnetent not implemented!\n");
}

void CPerlSock::Endprotoent(int &err)
{
	croak("endprotoent not implemented!\n");
}

void CPerlSock::Endservent(int &err)
{
	croak("endservent not implemented!\n");
}

struct hostent* 
CPerlSock::Gethostbyaddr(const char* addr, int len, int type, int &err)
{
    struct hostent *r;

    SOCKET_TEST(r = pgethostbyaddr(addr, len, type), NULL);
    return r;
}

struct hostent* 
CPerlSock::Gethostbyname(const char* name, int &err)
{
    struct hostent *r;

    SOCKET_TEST(r = pgethostbyname(name), NULL);
    return r;
}

struct hostent* CPerlSock::Gethostent(int &err)
{
	croak("gethostent not implemented!\n");
	return NULL;
}

int 
CPerlSock::Gethostname(char* name, int len, int &err)
{
    int r;

    SOCKET_TEST_ERROR(r = pgethostname(name, len));
    return r;
}

struct netent *CPerlSock::Getnetbyaddr(long net, int type, int &err)
{
	croak("getnetbyaddr not implemented!\n");
	return NULL;
}

struct netent *CPerlSock::Getnetbyname(const char *, int &err)
{
	croak("getnetbyname not implemented!\n");
	return NULL;
}

struct netent *CPerlSock::Getnetent(int &err)
{
	croak("getnetent not implemented!\n");
	return NULL;
}

int 
CPerlSock::Getpeername(SOCKET s, struct sockaddr* addr, int* addrlen, int &err)
{
	int r;

	SOCKET_TEST_ERROR(r = pgetpeername(TO_SOCKET(s), addr, addrlen));
	return r;
}

struct protoent* 
CPerlSock::Getprotobyname(const char* name, int &err)
{
    struct protoent *r;

    SOCKET_TEST(r = pgetprotobyname(name), NULL);
    return r;
}

struct protoent* 
CPerlSock::Getprotobynumber(int number, int &err)
{
    struct protoent *r;

    SOCKET_TEST(r = pgetprotobynumber(number), NULL);
    return r;
}

struct protoent* CPerlSock::Getprotoent(int &err)
{
	croak("getprotoent not implemented!\n");
	return NULL;
}

struct servent* 
CPerlSock::Getservbyname(const char* name, const char* proto, int &err)
{
    struct servent *r;
    dTHR;    

    SOCKET_TEST(r = pgetservbyname(name, proto), NULL);
//    if (r) {
//	r = win32_savecopyservent(&myservent, r, proto);
//    }
    return r;
}

struct servent* 
CPerlSock::Getservbyport(int port, const char* proto, int &err)
{
    struct servent *r;
    dTHR; 

    SOCKET_TEST(r = pgetservbyport(port, proto), NULL);
//    if (r) {
//	r = win32_savecopyservent(&myservent, r, proto);
//    }
    return r;
}

struct servent* CPerlSock::Getservent(int &err)
{
	croak("getservent not implemented!\n");
	return NULL;
}

int 
CPerlSock::Getsockname(SOCKET s, struct sockaddr* addr, int* addrlen, int &err)
{
	int r;

	SOCKET_TEST_ERROR(r = pgetsockname(TO_SOCKET(s), addr, addrlen));
	return r;
}

int 
CPerlSock::Getsockopt(SOCKET s, int level, int optname, char* optval, int* optlen, int &err)
{
	int r;

	SOCKET_TEST_ERROR(r = pgetsockopt(TO_SOCKET(s), level, optname, optval, optlen));
	return r;
}

unsigned long
CPerlSock::InetAddr(const char* cp, int &err)
{
	unsigned long r;

	SOCKET_TEST(r = pinet_addr(cp), INADDR_NONE);
	return r;
}

char*
CPerlSock::InetNtoa(struct in_addr in, int &err)
{
	char* r;

	SOCKET_TEST(r = pinet_ntoa(in), NULL);
	return r;
}

int
CPerlSock::IoctlSocket(SOCKET s, long cmd, u_long *argp, int& err)
{
    int r;

    SOCKET_TEST_ERROR(r = pioctlsocket(TO_SOCKET(s), cmd, argp));
    return r;
}

int 
CPerlSock::Listen(SOCKET s, int backlog, int &err)
{
	int r;

	SOCKET_TEST_ERROR(r = plisten(TO_SOCKET(s), backlog));
	return r;
}

int 
CPerlSock::Recvfrom(SOCKET s, char* buffer, int len, int flags, struct sockaddr* from, int* fromlen, int &err)
{
	int r;

	SOCKET_TEST_ERROR(r = precvfrom(TO_SOCKET(s), buffer, len, flags, from, fromlen));
	return r;
}

int 
CPerlSock::Select(int nfds, char* rd, char* wr, char* ex, const struct timeval* timeout, int &err)
{
	long r;
	int i, fd, bit, offset;
	FD_SET nrd, nwr, nex;

	FD_ZERO(&nrd);
	FD_ZERO(&nwr);
	FD_ZERO(&nex);
	for (i = 0; i < nfds; i++)
	{
		fd = TO_SOCKET(i);
		bit = 1L<<(i % (sizeof(char)*8));
		offset = i / (sizeof(char)*8);
		if(rd != NULL && (rd[offset] & bit))
			FD_SET(fd, &nrd);
		if(wr != NULL && (wr[offset] & bit))
			FD_SET(fd, &nwr);
		if(ex != NULL && (ex[offset] & bit))
			FD_SET(fd, &nex);
	}
	SOCKET_TEST_ERROR(r = pselect(nfds, &nrd, &nwr, &nex, timeout));

	for(i = 0; i < nfds; i++)
	{
		fd = TO_SOCKET(i);
		bit = 1L<<(i % (sizeof(char)*8));
		offset = i / (sizeof(char)*8);
		if(rd != NULL && (rd[offset] & bit))
		{
			if(!pWSAFDIsSet(fd, &nrd))
				rd[offset] &= ~bit;
		}
		if(wr != NULL && (wr[offset] & bit))
		{
			if(!pWSAFDIsSet(fd, &nwr))
				wr[offset] &= ~bit;
		}
		if(ex != NULL && (ex[offset] & bit))
		{
			if(!pWSAFDIsSet(fd, &nex))
				ex[offset] &= ~bit;
		}
	}
	return r;
}

int 
CPerlSock::Send(SOCKET s, const char* buffer, int len, int flags, int &err)
{
    int r;

    SOCKET_TEST_ERROR(r = psend(TO_SOCKET(s), buffer, len, flags));
    return r;
}

int 
CPerlSock::Sendto(SOCKET s, const char* buffer, int len, int flags, const struct sockaddr* to, int tolen, int &err)
{
    int r;

    SOCKET_TEST_ERROR(r = psendto(TO_SOCKET(s), buffer, len, flags, to, tolen));
    return r;
}

void CPerlSock::Sethostent(int stayopen, int &err)
{
	croak("sethostent not implemented!\n");
}

void CPerlSock::Setnetent(int stayopen, int &err)
{
	croak("setnetent not implemented!\n");
}

void CPerlSock::Setprotoent(int stayopen, int &err)
{
	croak("setprotoent not implemented!\n");
}

void CPerlSock::Setservent(int stayopen, int &err)
{
	croak("setservent not implemented!\n");
}

int 
CPerlSock::Setsockopt(SOCKET s, int level, int optname, const char* optval, int optlen, int &err)
{
    int r;

    SOCKET_TEST_ERROR(r = psetsockopt(TO_SOCKET(s), level, optname, optval, optlen));
    return r;
}

int 
CPerlSock::Shutdown(SOCKET s, int how, int &err)
{
    int r;

    SOCKET_TEST_ERROR(r = pshutdown(TO_SOCKET(s), how));
    return r;
}

SOCKET 
CPerlSock::Socket(int af, int type, int protocol, int &err)
{
    SOCKET s;

#ifdef USE_SOCKETS_AS_HANDLES
    StartSockets();
    if((s = psocket(af, type, protocol)) == INVALID_SOCKET)
	err = pWSAGetLastError();
    else
	s = OPEN_SOCKET(s);
#else
    SOCKET_TEST(s = psocket(af, type, protocol), INVALID_SOCKET);
#endif	/* USE_SOCKETS_AS_HANDLES */

    return s;
}

int CPerlSock::Socketpair(int domain, int type, int protocol, int* fds, int &err)
{
	croak("socketpair not implemented!\n");
	return 0;
}
Commit	Line	Data
76e3520e	1	/*
	2
	3	ipsock.c
	4	Interface for perl socket functions
	5
	6	*/
	7
	8	#include <ipsock.h>
	9	#include <fcntl.h>
	10
	11	#define USE_SOCKETS_AS_HANDLES
	12
	13	class CPerlSock : public IPerlSock
	14	{
	15	public:
	16	CPerlSock();
	17	~CPerlSock();
	18	virtual u_long Htonl(u_long hostlong);
	19	virtual u_short Htons(u_short hostshort);
	20	virtual u_long Ntohl(u_long netlong);
	21	virtual u_short Ntohs(u_short netshort);
	22	virtual SOCKET Accept(SOCKET s, struct sockaddr* addr, int* addrlen, int &err);
	23	virtual int Bind(SOCKET s, const struct sockaddr* name, int namelen, int &err);
	24	virtual int Connect(SOCKET s, const struct sockaddr* name, int namelen, int &err);
	25	virtual void Endhostent(int &err);
	26	virtual void Endnetent(int &err);
	27	virtual void Endprotoent(int &err);
	28	virtual void Endservent(int &err);
	29	virtual struct hostent* Gethostbyaddr(const char* addr, int len, int type, int &err);
	30	virtual struct hostent* Gethostbyname(const char* name, int &err);
	31	virtual struct hostent* Gethostent(int &err);
	32	virtual int Gethostname(char* name, int namelen, int &err);
	33	virtual struct netent *Getnetbyaddr(long net, int type, int &err);
	34	virtual struct netent Getnetbyname(const char , int &err);
	35	virtual struct netent *Getnetent(int &err);
	36	virtual int Getpeername(SOCKET s, struct sockaddr* name, int* namelen, int &err);
	37	virtual struct protoent* Getprotobyname(const char* name, int &err);
	38	virtual struct protoent* Getprotobynumber(int number, int &err);
	39	virtual struct protoent* Getprotoent(int &err);
	40	virtual struct servent* Getservbyname(const char* name, const char* proto, int &err);
	41	virtual struct servent* Getservbyport(int port, const char* proto, int &err);
	42	virtual struct servent* Getservent(int &err);
	43	virtual int Getsockname(SOCKET s, struct sockaddr* name, int* namelen, int &err);
	44	virtual int Getsockopt(SOCKET s, int level, int optname, char* optval, int* optlen, int &err);
	45	virtual unsigned long InetAddr(const char* cp, int &err);
	46	virtual char* InetNtoa(struct in_addr in, int &err);
	47	virtual int IoctlSocket(SOCKET s, long cmd, u_long *argp, int& err);
	48	virtual int Listen(SOCKET s, int backlog, int &err);
	49	virtual int Recvfrom(SOCKET s, char* buffer, int len, int flags, struct sockaddr* from, int* fromlen, int &err);
	50	virtual int Select(int nfds, char* readfds, char* writefds, char* exceptfds, const struct timeval* timeout, int &err);
	51	virtual int Send(SOCKET s, const char* buffer, int len, int flags, int &err);
	52	virtual int Sendto(SOCKET s, const char* buffer, int len, int flags, const struct sockaddr* to, int tolen, int &err);
	53	virtual void Sethostent(int stayopen, int &err);
	54	virtual void Setnetent(int stayopen, int &err);
	55	virtual void Setprotoent(int stayopen, int &err);
	56	virtual void Setservent(int stayopen, int &err);
	57	virtual int Setsockopt(SOCKET s, int level, int optname, const char* optval, int optlen, int &err);
	58	virtual int Shutdown(SOCKET s, int how, int &err);
	59	virtual SOCKET Socket(int af, int type, int protocol, int &err);
	60	virtual int Socketpair(int domain, int type, int protocol, int* fds, int &err);
	61
	62	void CloseSocket(int fh, int& err);
	63	void* GetAddress(HINSTANCE hInstance, char *lpFunctionName);
	64	void LoadWinSock(void);
65
66	inline void SetPerlObj(CPerlObj *p) { pPerl = p; };
67	inline void SetStdObj(IPerlStdIOWin *p) { pStdIO = p; };
68	protected:
69	void Start(void);
70
71	inline int OpenOSfhandle(long osfhandle)
72	{
73	return pStdIO->OpenOSfhandle(osfhandle, O_RDWR\|O_BINARY);
74	};
75	int GetOSfhandle(int filenum)
76	{
77	return pStdIO->GetOSfhandle(filenum);
78	};
79
80	inline void StartSockets(void)
81	{
82	if(!bStarted)
83	Start();
84	};
85
86	BOOL bStarted;
87	CPerlObj *pPerl;
88	IPerlStdIOWin *pStdIO;
89	};
90
91
92	#define SOCKETAPI PASCAL
93
94	typedef SOCKET (SOCKETAPI LPSOCKACCEPT)(SOCKET, struct sockaddr , int *);
95	typedef int (SOCKETAPI LPSOCKBIND)(SOCKET, const struct sockaddr , int);
96	typedef int (SOCKETAPI *LPSOCKCLOSESOCKET)(SOCKET);
97	typedef int (SOCKETAPI LPSOCKCONNECT)(SOCKET, const struct sockaddr , int);
98	typedef unsigned long (SOCKETAPI LPINETADDR)(const char );
99	typedef char* (SOCKETAPI *LPINETNTOA)(struct in_addr);
100	typedef int (SOCKETAPI LPSOCKIOCTLSOCKET)(SOCKET, long, u_long );
101	typedef int (SOCKETAPI LPSOCKGETPEERNAME)(SOCKET, struct sockaddr , int *);
102	typedef int (SOCKETAPI LPSOCKGETSOCKNAME)(SOCKET, struct sockaddr , int *);
103	typedef int (SOCKETAPI LPSOCKGETSOCKOPT)(SOCKET, int, int, char , int *);
104	typedef u_long (SOCKETAPI *LPSOCKHTONL)(u_long);
105	typedef u_short (SOCKETAPI *LPSOCKHTONS)(u_short);
106	typedef int (SOCKETAPI *LPSOCKLISTEN)(SOCKET, int);
107	typedef u_long (SOCKETAPI *LPSOCKNTOHL)(u_long);
108	typedef u_short (SOCKETAPI *LPSOCKNTOHS)(u_short);
109	typedef int (SOCKETAPI LPSOCKRECV)(SOCKET, char , int, int);
110	typedef int (SOCKETAPI LPSOCKRECVFROM)(SOCKET, char , int, int, struct sockaddr , int );
111	typedef int (SOCKETAPI LPSOCKSELECT)(int, fd_set , fd_set , fd_set , const struct timeval *);
112	typedef int (SOCKETAPI LPSOCKSEND)(SOCKET, const char , int, int);
113	typedef int (SOCKETAPI LPSOCKSENDTO)(SOCKET, const char , int, int, const struct sockaddr *, int);
114	typedef int (SOCKETAPI LPSOCKSETSOCKOPT)(SOCKET, int, int, const char , int);
115	typedef int (SOCKETAPI *LPSOCKSHUTDOWN)(SOCKET, int);
116	typedef SOCKET (SOCKETAPI *LPSOCKSOCKET)(int, int, int);
117
118	/* Database function prototypes */
119	typedef struct hostent (SOCKETAPI LPSOCKGETHOSTBYADDR)(const char *, int, int);
120	typedef struct hostent (SOCKETAPI LPSOCKGETHOSTBYNAME)(const char *);
121	typedef int (SOCKETAPI LPSOCKGETHOSTNAME)(char , int);
122	typedef struct servent (SOCKETAPI LPSOCKGETSERVBYPORT)(int, const char *);
123	typedef struct servent (SOCKETAPI LPSOCKGETSERVBYNAME)(const char , const char );
124	typedef struct protoent (SOCKETAPI LPSOCKGETPROTOBYNUMBER)(int);
125	typedef struct protoent (SOCKETAPI LPSOCKGETPROTOBYNAME)(const char *);
126
127	/* Microsoft Windows Extension function prototypes */
128	typedef int (SOCKETAPI *LPSOCKWSASTARTUP)(unsigned short, LPWSADATA);
129	typedef int (SOCKETAPI *LPSOCKWSACLEANUP)(void);
130	typedef int (SOCKETAPI *LPSOCKWSAGETLASTERROR)(void);
131	typedef int (SOCKETAPI LPWSAFDIsSet)(SOCKET, fd_set );
132
133	static HINSTANCE hWinSockDll = 0;
134
135	static LPSOCKACCEPT paccept = 0;
136	static LPSOCKBIND pbind = 0;
137	static LPSOCKCLOSESOCKET pclosesocket = 0;
138	static LPSOCKCONNECT pconnect = 0;
139	static LPINETADDR pinet_addr = 0;
140	static LPINETNTOA pinet_ntoa = 0;
141	static LPSOCKIOCTLSOCKET pioctlsocket = 0;
142	static LPSOCKGETPEERNAME pgetpeername = 0;
143	static LPSOCKGETSOCKNAME pgetsockname = 0;
144	static LPSOCKGETSOCKOPT pgetsockopt = 0;
145	static LPSOCKHTONL phtonl = 0;
146	static LPSOCKHTONS phtons = 0;
147	static LPSOCKLISTEN plisten = 0;
148	static LPSOCKNTOHL pntohl = 0;
149	static LPSOCKNTOHS pntohs = 0;
150	static LPSOCKRECV precv = 0;
151	static LPSOCKRECVFROM precvfrom = 0;
152	static LPSOCKSELECT pselect = 0;
153	static LPSOCKSEND psend = 0;
154	static LPSOCKSENDTO psendto = 0;
155	static LPSOCKSETSOCKOPT psetsockopt = 0;
156	static LPSOCKSHUTDOWN pshutdown = 0;
157	static LPSOCKSOCKET psocket = 0;
158	static LPSOCKGETHOSTBYADDR pgethostbyaddr = 0;
159	static LPSOCKGETHOSTBYNAME pgethostbyname = 0;
160	static LPSOCKGETHOSTNAME pgethostname = 0;
161	static LPSOCKGETSERVBYPORT pgetservbyport = 0;
162	static LPSOCKGETSERVBYNAME pgetservbyname = 0;
163	static LPSOCKGETPROTOBYNUMBER pgetprotobynumber = 0;
164	static LPSOCKGETPROTOBYNAME pgetprotobyname = 0;
165	static LPSOCKWSASTARTUP pWSAStartup = 0;
166	static LPSOCKWSACLEANUP pWSACleanup = 0;
167	static LPSOCKWSAGETLASTERROR pWSAGetLastError = 0;
168	static LPWSAFDIsSet pWSAFDIsSet = 0;
169
170	void* CPerlSock::GetAddress(HINSTANCE hInstance, char *lpFunctionName)
171	{
172	char buffer[512];
173	FARPROC proc = GetProcAddress(hInstance, lpFunctionName);
174	if(proc == 0)
175	{
176	sprintf(buffer, "Unable to get address of %s in WSock32.dll", lpFunctionName);
177	croak(buffer);
178	}
179	return proc;
180	}
181
182	void CPerlSock::LoadWinSock(void)
183	{
184	if(hWinSockDll == NULL)
185	{
186	HINSTANCE hLib = LoadLibrary("WSock32.DLL");
187	if(hLib == NULL)
188	croak("Could not load WSock32.dll\n");
189
190	paccept = (LPSOCKACCEPT)GetAddress(hLib, "accept");
191	pbind = (LPSOCKBIND)GetAddress(hLib, "bind");
192	pclosesocket = (LPSOCKCLOSESOCKET)GetAddress(hLib, "closesocket");
193	pconnect = (LPSOCKCONNECT)GetAddress(hLib, "connect");
194	pinet_addr = (LPINETADDR)GetAddress(hLib, "inet_addr");
195	pinet_ntoa = (LPINETNTOA)GetAddress(hLib, "inet_ntoa");
196	pioctlsocket = (LPSOCKIOCTLSOCKET)GetAddress(hLib, "ioctlsocket");
197	pgetpeername = (LPSOCKGETPEERNAME)GetAddress(hLib, "getpeername");
198	pgetsockname = (LPSOCKGETSOCKNAME)GetAddress(hLib, "getsockname");
199	pgetsockopt = (LPSOCKGETSOCKOPT)GetAddress(hLib, "getsockopt");
200	phtonl = (LPSOCKHTONL)GetAddress(hLib, "htonl");
201	phtons = (LPSOCKHTONS)GetAddress(hLib, "htons");
202	plisten = (LPSOCKLISTEN)GetAddress(hLib, "listen");
203	pntohl = (LPSOCKNTOHL)GetAddress(hLib, "ntohl");
204	pntohs = (LPSOCKNTOHS)GetAddress(hLib, "ntohs");
205	precv = (LPSOCKRECV)GetAddress(hLib, "recv");
206	precvfrom = (LPSOCKRECVFROM)GetAddress(hLib, "recvfrom");
207	pselect = (LPSOCKSELECT)GetAddress(hLib, "select");
208	psend = (LPSOCKSEND)GetAddress(hLib, "send");
209	psendto = (LPSOCKSENDTO)GetAddress(hLib, "sendto");
210	psetsockopt = (LPSOCKSETSOCKOPT)GetAddress(hLib, "setsockopt");
211	pshutdown = (LPSOCKSHUTDOWN)GetAddress(hLib, "shutdown");
212	psocket = (LPSOCKSOCKET)GetAddress(hLib, "socket");
213	pgethostbyaddr = (LPSOCKGETHOSTBYADDR)GetAddress(hLib, "gethostbyaddr");
214	pgethostbyname = (LPSOCKGETHOSTBYNAME)GetAddress(hLib, "gethostbyname");
215	pgethostname = (LPSOCKGETHOSTNAME)GetAddress(hLib, "gethostname");
216	pgetservbyport = (LPSOCKGETSERVBYPORT)GetAddress(hLib, "getservbyport");
217	pgetservbyname = (LPSOCKGETSERVBYNAME)GetAddress(hLib, "getservbyname");
218	pgetprotobynumber = (LPSOCKGETPROTOBYNUMBER)GetAddress(hLib, "getprotobynumber");
219	pgetprotobyname = (LPSOCKGETPROTOBYNAME)GetAddress(hLib, "getprotobyname");
220	pWSAStartup = (LPSOCKWSASTARTUP)GetAddress(hLib, "WSAStartup");
221	pWSACleanup = (LPSOCKWSACLEANUP)GetAddress(hLib, "WSACleanup");
222	pWSAGetLastError = (LPSOCKWSAGETLASTERROR)GetAddress(hLib, "WSAGetLastError");
223	pWSAFDIsSet = (LPWSAFDIsSet)GetAddress(hLib, "__WSAFDIsSet");
224	hWinSockDll = hLib;
225	}
226	}
227
228
229	CPerlSock::CPerlSock()
230	{
231	bStarted = FALSE;
232	pPerl = NULL;
233	pStdIO = NULL;
234	}
235
236	CPerlSock::~CPerlSock()
237	{
238	if(bStarted)
239	pWSACleanup();
240	}
241
242	void
243	CPerlSock::Start(void)
244	{
245	unsigned short version;
246	WSADATA retdata;
247	int ret;
248	int iSockOpt = SO_SYNCHRONOUS_NONALERT;
249
250	LoadWinSock();
251	/*
252	* initalize the winsock interface and insure that it is
253	* cleaned up at exit.
254	*/
255	version = 0x101;
256	if(ret = pWSAStartup(version, &retdata))
257	croak("Unable to locate winsock library!\n");
258	if(retdata.wVersion != version)
259	croak("Could not find version 1.1 of winsock dll\n");
260
261	/* atexit((void ()(void)) EndSockets); /
262
263	#ifdef USE_SOCKETS_AS_HANDLES
264	/*
265	* Enable the use of sockets as filehandles
266	*/
267	psetsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
268	(char *)&iSockOpt, sizeof(iSockOpt));
269	#endif /* USE_SOCKETS_AS_HANDLES */
270	bStarted = TRUE;
271	}
272
273
274	u_long
275	CPerlSock::Htonl(u_long hostlong)
276	{
277	StartSockets();
278	return phtonl(hostlong);
279	}
280
281	u_short
282	CPerlSock::Htons(u_short hostshort)
283	{
284	StartSockets();
285	return phtons(hostshort);
286	}
287
288	u_long
289	CPerlSock::Ntohl(u_long netlong)
290	{
291	StartSockets();
292	return pntohl(netlong);
293	}
294
295	u_short
296	CPerlSock::Ntohs(u_short netshort)
297	{
298	StartSockets();
299	return pntohs(netshort);
300	}
301
302
303	/* thanks to Beverly Brown (beverly@datacube.com) */
304	#ifdef USE_SOCKETS_AS_HANDLES
305	# define OPEN_SOCKET(x) OpenOSfhandle(x)
306	# define TO_SOCKET(x) GetOSfhandle(x)
307	#else
308	# define OPEN_SOCKET(x) (x)
309	# define TO_SOCKET(x) (x)
310	#endif /* USE_SOCKETS_AS_HANDLES */
311
312	#define SOCKET_TEST(x, y) \
313	STMT_START { \
314	StartSockets(); \
315	if((x) == (y)) \
316	err = pWSAGetLastError(); \
317	} STMT_END
318
319	#define SOCKET_TEST_ERROR(x) SOCKET_TEST(x, SOCKET_ERROR)
320
321	SOCKET
322	CPerlSock::Accept(SOCKET s, struct sockaddr* addr, int* addrlen, int &err)
323	{
324	SOCKET r;
325
326	SOCKET_TEST((r = paccept(TO_SOCKET(s), addr, addrlen)), INVALID_SOCKET);
327	return OPEN_SOCKET(r);
328	}
329
330	int
331	CPerlSock::Bind(SOCKET s, const struct sockaddr* addr, int addrlen, int &err)
332	{
333	int r;
334
335	SOCKET_TEST_ERROR(r = pbind(TO_SOCKET(s), addr, addrlen));
336	return r;
337	}
338
339	void
340	CPerlSock::CloseSocket(int fh, int& err)
341	{
342	SOCKET_TEST_ERROR(pclosesocket(TO_SOCKET(fh)));
343	}
344
345	int
346	CPerlSock::Connect(SOCKET s, const struct sockaddr* addr, int addrlen, int &err)
347	{
348	int r;
349
350	SOCKET_TEST_ERROR(r = pconnect(TO_SOCKET(s), addr, addrlen));
351	return r;
352	}
353
354	void CPerlSock::Endhostent(int &err)
355	{
356	croak("endhostent not implemented!\n");
357	}
358
359	void CPerlSock::Endnetent(int &err)
360	{
361	croak("endnetent not implemented!\n");
362	}
363
364	void CPerlSock::Endprotoent(int &err)
365	{
366	croak("endprotoent not implemented!\n");
367	}
368
369	void CPerlSock::Endservent(int &err)
370	{
371	croak("endservent not implemented!\n");
372	}
373
374	struct hostent*
375	CPerlSock::Gethostbyaddr(const char* addr, int len, int type, int &err)
376	{
377	struct hostent *r;
378
379	SOCKET_TEST(r = pgethostbyaddr(addr, len, type), NULL);
380	return r;
381	}
382
383	struct hostent*
384	CPerlSock::Gethostbyname(const char* name, int &err)
385	{
386	struct hostent *r;
387
388	SOCKET_TEST(r = pgethostbyname(name), NULL);
389	return r;
390	}
391
392	struct hostent* CPerlSock::Gethostent(int &err)
393	{
394	croak("gethostent not implemented!\n");
395	return NULL;
396	}
397
398	int
399	CPerlSock::Gethostname(char* name, int len, int &err)
400	{
401	int r;
402
403	SOCKET_TEST_ERROR(r = pgethostname(name, len));
404	return r;
405	}
406
407	struct netent *CPerlSock::Getnetbyaddr(long net, int type, int &err)
408	{
409	croak("getnetbyaddr not implemented!\n");
410	return NULL;
411	}
412
413	struct netent CPerlSock::Getnetbyname(const char , int &err)
414	{
415	croak("getnetbyname not implemented!\n");
416	return NULL;
417	}
418
419	struct netent *CPerlSock::Getnetent(int &err)
420	{
421	croak("getnetent not implemented!\n");
422	return NULL;
423	}
424
425	int
426	CPerlSock::Getpeername(SOCKET s, struct sockaddr* addr, int* addrlen, int &err)
427	{
428	int r;
429
430	SOCKET_TEST_ERROR(r = pgetpeername(TO_SOCKET(s), addr, addrlen));
431	return r;
432	}
433
434	struct protoent*
435	CPerlSock::Getprotobyname(const char* name, int &err)
436	{
437	struct protoent *r;
438
439	SOCKET_TEST(r = pgetprotobyname(name), NULL);
440	return r;
441	}
442
443	struct protoent*
444	CPerlSock::Getprotobynumber(int number, int &err)
445	{
446	struct protoent *r;
447
448	SOCKET_TEST(r = pgetprotobynumber(number), NULL);
449	return r;
450	}
451
452	struct protoent* CPerlSock::Getprotoent(int &err)
453	{
454	croak("getprotoent not implemented!\n");
455	return NULL;
456	}
457
458	struct servent*
459	CPerlSock::Getservbyname(const char* name, const char* proto, int &err)
460	{
461	struct servent *r;
462	dTHR;
463
464	SOCKET_TEST(r = pgetservbyname(name, proto), NULL);
465	// if (r) {
466	// r = win32_savecopyservent(&myservent, r, proto);
467	// }
468	return r;
469	}
470
471	struct servent*
472	CPerlSock::Getservbyport(int port, const char* proto, int &err)
473	{
474	struct servent *r;
475	dTHR;
476
477	SOCKET_TEST(r = pgetservbyport(port, proto), NULL);
478	// if (r) {
479	// r = win32_savecopyservent(&myservent, r, proto);
480	// }
481	return r;
482	}
483
484	struct servent* CPerlSock::Getservent(int &err)
485	{
486	croak("getservent not implemented!\n");
487	return NULL;
488	}
489
490	int
491	CPerlSock::Getsockname(SOCKET s, struct sockaddr* addr, int* addrlen, int &err)
492	{
493	int r;
494
495	SOCKET_TEST_ERROR(r = pgetsockname(TO_SOCKET(s), addr, addrlen));
496	return r;
497	}
498
499	int
500	CPerlSock::Getsockopt(SOCKET s, int level, int optname, char* optval, int* optlen, int &err)
501	{
502	int r;
503
504	SOCKET_TEST_ERROR(r = pgetsockopt(TO_SOCKET(s), level, optname, optval, optlen));
505	return r;
506	}
507
508	unsigned long
509	CPerlSock::InetAddr(const char* cp, int &err)
510	{
511	unsigned long r;
512
513	SOCKET_TEST(r = pinet_addr(cp), INADDR_NONE);
514	return r;
515	}
516
517	char*
518	CPerlSock::InetNtoa(struct in_addr in, int &err)
519	{
520	char* r;
521
522	SOCKET_TEST(r = pinet_ntoa(in), NULL);
523	return r;
524	}
525
526	int
527	CPerlSock::IoctlSocket(SOCKET s, long cmd, u_long *argp, int& err)
528	{
529	int r;
530
531	SOCKET_TEST_ERROR(r = pioctlsocket(TO_SOCKET(s), cmd, argp));
532	return r;
533	}
534
535	int
536	CPerlSock::Listen(SOCKET s, int backlog, int &err)
537	{
538	int r;
539
540	SOCKET_TEST_ERROR(r = plisten(TO_SOCKET(s), backlog));
541	return r;
542	}
543
544	int
545	CPerlSock::Recvfrom(SOCKET s, char* buffer, int len, int flags, struct sockaddr* from, int* fromlen, int &err)
546	{
547	int r;
548
549	SOCKET_TEST_ERROR(r = precvfrom(TO_SOCKET(s), buffer, len, flags, from, fromlen));
550	return r;
551	}
552
553	int
554	CPerlSock::Select(int nfds, char* rd, char* wr, char* ex, const struct timeval* timeout, int &err)
555	{
556	long r;
557	int i, fd, bit, offset;
558	FD_SET nrd, nwr, nex;
559
560	FD_ZERO(&nrd);
561	FD_ZERO(&nwr);
562	FD_ZERO(&nex);
563	for (i = 0; i < nfds; i++)
564	{
565	fd = TO_SOCKET(i);
566	bit = 1L<<(i % (sizeof(char)*8));
567	offset = i / (sizeof(char)*8);
568	if(rd != NULL && (rd[offset] & bit))
569	FD_SET(fd, &nrd);
570	if(wr != NULL && (wr[offset] & bit))
571	FD_SET(fd, &nwr);
572	if(ex != NULL && (ex[offset] & bit))
573	FD_SET(fd, &nex);
574	}
575	SOCKET_TEST_ERROR(r = pselect(nfds, &nrd, &nwr, &nex, timeout));
576
577	for(i = 0; i < nfds; i++)
578	{
579	fd = TO_SOCKET(i);
580	bit = 1L<<(i % (sizeof(char)*8));
581	offset = i / (sizeof(char)*8);
582	if(rd != NULL && (rd[offset] & bit))
583	{
584	if(!pWSAFDIsSet(fd, &nrd))
585	rd[offset] &= ~bit;
586	}
587	if(wr != NULL && (wr[offset] & bit))
588	{
589	if(!pWSAFDIsSet(fd, &nwr))
590	wr[offset] &= ~bit;
591	}
592	if(ex != NULL && (ex[offset] & bit))
593	{
594	if(!pWSAFDIsSet(fd, &nex))
595	ex[offset] &= ~bit;
596	}
597	}
598	return r;
599	}
600
601	int
602	CPerlSock::Send(SOCKET s, const char* buffer, int len, int flags, int &err)
603	{
604	int r;
605
606	SOCKET_TEST_ERROR(r = psend(TO_SOCKET(s), buffer, len, flags));
607	return r;
608	}
609
610	int
611	CPerlSock::Sendto(SOCKET s, const char* buffer, int len, int flags, const struct sockaddr* to, int tolen, int &err)
612	{
613	int r;
614
615	SOCKET_TEST_ERROR(r = psendto(TO_SOCKET(s), buffer, len, flags, to, tolen));
616	return r;
617	}
618
619	void CPerlSock::Sethostent(int stayopen, int &err)
620	{
621	croak("sethostent not implemented!\n");
622	}
623
624	void CPerlSock::Setnetent(int stayopen, int &err)
625	{
626	croak("setnetent not implemented!\n");
627	}
628
629	void CPerlSock::Setprotoent(int stayopen, int &err)
630	{
631	croak("setprotoent not implemented!\n");
632	}
633
634	void CPerlSock::Setservent(int stayopen, int &err)
635	{
636	croak("setservent not implemented!\n");
637	}
638
639	int
640	CPerlSock::Setsockopt(SOCKET s, int level, int optname, const char* optval, int optlen, int &err)
641	{
642	int r;
643
644	SOCKET_TEST_ERROR(r = psetsockopt(TO_SOCKET(s), level, optname, optval, optlen));
645	return r;
646	}
647
648	int
649	CPerlSock::Shutdown(SOCKET s, int how, int &err)
650	{
651	int r;
652
653	SOCKET_TEST_ERROR(r = pshutdown(TO_SOCKET(s), how));
654	return r;
655	}
656
657	SOCKET
658	CPerlSock::Socket(int af, int type, int protocol, int &err)
659	{
660	SOCKET s;
661
662	#ifdef USE_SOCKETS_AS_HANDLES
663	StartSockets();
664	if((s = psocket(af, type, protocol)) == INVALID_SOCKET)
665	err = pWSAGetLastError();
666	else
667	s = OPEN_SOCKET(s);
668	#else
669	SOCKET_TEST(s = psocket(af, type, protocol), INVALID_SOCKET);
670	#endif /* USE_SOCKETS_AS_HANDLES */
671
672	return s;
673	}
674
675	int CPerlSock::Socketpair(int domain, int type, int protocol, int* fds, int &err)
676	{
677	croak("socketpair not implemented!\n");
678	return 0;
679	}
680
681