* License or the Artistic License, as specified in the README file.
*/
-#include <windows.h>
+#define WIN32IO_IS_STDIO
+#define WIN32SCK_IS_STDSCK
#define WIN32_LEAN_AND_MEAN
+#define PERLIO_NOT_STDIO 0
+#ifdef __GNUC__
+#define Win32_Winsock
+#endif
+#include <windows.h>
#include "EXTERN.h"
#include "perl.h"
+
+#if defined(PERL_OBJECT)
+#define NO_XSLOCKS
+#include "XSUB.h"
+#endif
+
+#include "Win32iop.h"
#include <sys/socket.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <assert.h>
-
-#undef htonl
-#undef htons
-#undef ntohl
-#undef ntohs
-#undef inet_addr
-#undef inet_ntoa
-#undef socket
-#undef bind
-#undef listen
-#undef accept
-#undef connect
-#undef send
-#undef sendto
-#undef recv
-#undef recvfrom
-#undef shutdown
-#undef ioctlsocket
-#undef setsockopt
-#undef getsockopt
-#undef getpeername
-#undef getsockname
-#undef gethostname
-#undef gethostbyname
-#undef gethostbyaddr
-#undef getprotobyname
-#undef getprotobynumber
-#undef getservbyname
-#undef getservbyport
-#undef select
-#undef endhostent
-#undef endnetent
-#undef endprotoent
-#undef endservent
-#undef getnetent
-#undef getnetbyname
-#undef getnetbyaddr
-#undef getprotoent
-#undef getservent
-#undef sethostent
-#undef setnetent
-#undef setprotoent
-#undef setservent
+#include <io.h>
/* thanks to Beverly Brown (beverly@datacube.com) */
#ifdef USE_SOCKETS_AS_HANDLES
-# define OPEN_SOCKET(x) _open_osfhandle(x,O_RDWR|O_BINARY)
+# define OPEN_SOCKET(x) win32_open_osfhandle(x,O_RDWR|O_BINARY)
# define TO_SOCKET(x) _get_osfhandle(x)
#else
# define OPEN_SOCKET(x) (x)
# define TO_SOCKET(x) (x)
#endif /* USE_SOCKETS_AS_HANDLES */
+#if defined(USE_THREADS) || defined(USE_ITHREADS)
#define StartSockets() \
STMT_START { \
if (!wsock_started) \
start_sockets(); \
+ set_socktype(); \
} STMT_END
-
-#define EndSockets() \
+#else
+#define StartSockets() \
STMT_START { \
- if (wsock_started) \
- WSACleanup(); \
+ if (!wsock_started) { \
+ start_sockets(); \
+ set_socktype(); \
+ } \
} STMT_END
+#endif
#define SOCKET_TEST(x, y) \
STMT_START { \
struct servent*s,
const char *proto);
-__declspec(thread) struct servent myservent;
static int wsock_started = 0;
+EXTERN_C void
+EndSockets(void)
+{
+ if (wsock_started)
+ WSACleanup();
+}
+
void
start_sockets(void)
{
+ dTHXo;
unsigned short version;
WSADATA retdata;
int ret;
- int iSockOpt = SO_SYNCHRONOUS_NONALERT;
/*
* initalize the winsock interface and insure that it is
*/
version = 0x101;
if(ret = WSAStartup(version, &retdata))
- croak("Unable to locate winsock library!\n");
+ Perl_croak_nocontext("Unable to locate winsock library!\n");
if(retdata.wVersion != version)
- croak("Could not find version 1.1 of winsock dll\n");
+ Perl_croak_nocontext("Could not find version 1.1 of winsock dll\n");
/* atexit((void (*)(void)) EndSockets); */
+ wsock_started = 1;
+}
+void
+set_socktype(void)
+{
#ifdef USE_SOCKETS_AS_HANDLES
- /*
- * Enable the use of sockets as filehandles
- */
- setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
- (char *)&iSockOpt, sizeof(iSockOpt));
+#if defined(USE_THREADS) || defined(USE_ITHREADS)
+ dTHXo;
+ if (!w32_init_socktype) {
+#endif
+ int iSockOpt = SO_SYNCHRONOUS_NONALERT;
+ /*
+ * Enable the use of sockets as filehandles
+ */
+ setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
+ (char *)&iSockOpt, sizeof(iSockOpt));
+#if defined(USE_THREADS) || defined(USE_ITHREADS)
+ w32_init_socktype = 1;
+ }
+#endif
#endif /* USE_SOCKETS_AS_HANDLES */
- wsock_started = 1;
}
#ifndef USE_SOCKETS_AS_HANDLES
+#undef fdopen
FILE *
-myfdopen(int fd, char *mode)
+my_fdopen(int fd, char *mode)
{
FILE *fp;
char sockbuf[256];
/*
* If we get here, then fd is actually a socket.
*/
- Newz(1310, fp, 1, FILE);
+ Newz(1310, fp, 1, FILE); /* XXX leak, good thing this code isn't used */
if(fp == NULL) {
errno = ENOMEM;
return NULL;
win32_recvfrom(SOCKET s, char *buf, int len, int flags, struct sockaddr *from, int *fromlen)
{
int r;
+ int frombufsize = *fromlen;
SOCKET_TEST_ERROR(r = recvfrom(TO_SOCKET(s), buf, len, flags, from, fromlen));
+ /* Winsock's recvfrom() only returns a valid 'from' when the socket
+ * is connectionless. Perl expects a valid 'from' for all types
+ * of sockets, so go the extra mile.
+ */
+ if (r != SOCKET_ERROR && frombufsize == *fromlen)
+ (void)win32_getpeername(s, from, fromlen);
return r;
}
/* select contributed by Vincent R. Slyngstad (vrs@ibeam.intel.com) */
int
-win32_select(int nfds, int* rd, int* wr, int* ex, const struct timeval* timeout)
+win32_select(int nfds, Perl_fd_set* rd, Perl_fd_set* wr, Perl_fd_set* ex, const struct timeval* timeout)
{
- long r;
- int dummy = 0;
+ int r;
+#ifdef USE_SOCKETS_AS_HANDLES
+ Perl_fd_set dummy;
int i, fd, bit, offset;
- FD_SET nrd, nwr, nex,*prd,*pwr,*pex;
+ FD_SET nrd, nwr, nex, *prd, *pwr, *pex;
+ /* winsock seems incapable of dealing with all three null fd_sets,
+ * so do the (millisecond) sleep as a special case
+ */
+ if (!(rd || wr || ex)) {
+ if (timeout)
+ Sleep(timeout->tv_sec * 1000 +
+ timeout->tv_usec / 1000); /* do the best we can */
+ else
+ Sleep(UINT_MAX);
+ return 0;
+ }
+ StartSockets();
+ PERL_FD_ZERO(&dummy);
if (!rd)
rd = &dummy, prd = NULL;
else
FD_ZERO(&nex);
for (i = 0; i < nfds; i++) {
fd = TO_SOCKET(i);
- bit = 1L<<(i % (sizeof(int)*8));
- offset = i / (sizeof(int)*8);
- if (rd[offset] & bit)
+ if (PERL_FD_ISSET(i,rd))
FD_SET(fd, &nrd);
- if (wr[offset] & bit)
+ if (PERL_FD_ISSET(i,wr))
FD_SET(fd, &nwr);
- if (ex[offset] & bit)
+ if (PERL_FD_ISSET(i,ex))
FD_SET(fd, &nex);
}
for (i = 0; i < nfds; i++) {
fd = TO_SOCKET(i);
- bit = 1L<<(i % (sizeof(int)*8));
- offset = i / (sizeof(int)*8);
- if (rd[offset] & bit) {
- if (!__WSAFDIsSet(fd, &nrd))
- rd[offset] &= ~bit;
- }
- if (wr[offset] & bit) {
- if (!__WSAFDIsSet(fd, &nwr))
- wr[offset] &= ~bit;
- }
- if (ex[offset] & bit) {
- if (!__WSAFDIsSet(fd, &nex))
- ex[offset] &= ~bit;
- }
+ if (PERL_FD_ISSET(i,rd) && !FD_ISSET(fd, &nrd))
+ PERL_FD_CLR(i,rd);
+ if (PERL_FD_ISSET(i,wr) && !FD_ISSET(fd, &nwr))
+ PERL_FD_CLR(i,wr);
+ if (PERL_FD_ISSET(i,ex) && !FD_ISSET(fd, &nex))
+ PERL_FD_CLR(i,ex);
}
+#else
+ SOCKET_TEST_ERROR(r = select(nfds, rd, wr, ex, timeout));
+#endif
return r;
}
return r;
}
+int
+win32_closesocket(SOCKET s)
+{
+ int r;
+
+ SOCKET_TEST_ERROR(r = closesocket(TO_SOCKET(s)));
+ return r;
+}
+
SOCKET
win32_socket(int af, int type, int protocol)
{
SOCKET s;
- StartSockets();
#ifndef USE_SOCKETS_AS_HANDLES
SOCKET_TEST(s = socket(af, type, protocol), INVALID_SOCKET);
#else
+ StartSockets();
if((s = socket(af, type, protocol)) == INVALID_SOCKET)
errno = WSAGetLastError();
else
return s;
}
+/*
+ * close RTL fd while respecting sockets
+ * added as temporary measure until PerlIO has real
+ * Win32 native layer
+ * -- BKS, 11-11-2000
+*/
+
+int my_close(int fd)
+{
+ int osf;
+ if (!wsock_started) /* No WinSock? */
+ return(close(fd)); /* Then not a socket. */
+ osf = TO_SOCKET(fd);/* Get it now before it's gone! */
+ if (osf != -1) {
+ int err;
+ err = closesocket(osf);
+ if (err == 0) {
+#if defined(USE_FIXED_OSFHANDLE) || defined(PERL_MSVCRT_READFIX)
+ _set_osfhnd(fd, INVALID_HANDLE_VALUE);
+#endif
+ (void)close(fd); /* handle already closed, ignore error */
+ return 0;
+ }
+ else if (err == SOCKET_ERROR) {
+ err = WSAGetLastError();
+ if (err != WSAENOTSOCK) {
+ (void)close(fd);
+ errno = err;
+ return EOF;
+ }
+ }
+ }
+ return close(fd);
+}
+
#undef fclose
int
my_fclose (FILE *pf)
{
- int osf, retval;
+ int osf;
if (!wsock_started) /* No WinSock? */
return(fclose(pf)); /* Then not a socket. */
- osf = TO_SOCKET(fileno(pf));/* Get it now before it's gone! */
- retval = fclose(pf); /* Must fclose() before closesocket() */
- if (osf != -1
- && closesocket(osf) == SOCKET_ERROR
- && WSAGetLastError() != WSAENOTSOCK)
- {
- return EOF;
+ osf = TO_SOCKET(win32_fileno(pf));/* Get it now before it's gone! */
+ if (osf != -1) {
+ int err;
+ win32_fflush(pf);
+ err = closesocket(osf);
+ if (err == 0) {
+#if defined(USE_FIXED_OSFHANDLE) || defined(PERL_MSVCRT_READFIX)
+ _set_osfhnd(win32_fileno(pf), INVALID_HANDLE_VALUE);
+#endif
+ (void)fclose(pf); /* handle already closed, ignore error */
+ return 0;
+ }
+ else if (err == SOCKET_ERROR) {
+ err = WSAGetLastError();
+ if (err != WSAENOTSOCK) {
+ (void)fclose(pf);
+ errno = err;
+ return EOF;
+ }
+ }
}
- return retval;
+ return fclose(pf);
}
struct hostent *
struct servent *
win32_getservbyname(const char *name, const char *proto)
{
+ dTHXo;
struct servent *r;
-
+
SOCKET_TEST(r = getservbyname(name, proto), NULL);
if (r) {
- r = win32_savecopyservent(&myservent, r, proto);
+ r = win32_savecopyservent(&w32_servent, r, proto);
}
return r;
}
struct servent *
win32_getservbyport(int port, const char *proto)
{
+ dTHXo;
struct servent *r;
SOCKET_TEST(r = getservbyport(port, proto), NULL);
if (r) {
- r = win32_savecopyservent(&myservent, r, proto);
+ r = win32_savecopyservent(&w32_servent, r, proto);
}
return r;
}
+int
+win32_ioctl(int i, unsigned int u, char *data)
+{
+ dTHXo;
+ u_long argp = (u_long)data;
+ int retval;
+
+ if (!wsock_started) {
+ Perl_croak_nocontext("ioctl implemented only on sockets");
+ /* NOTREACHED */
+ }
+
+ retval = ioctlsocket(TO_SOCKET(i), (long)u, &argp);
+ if (retval == SOCKET_ERROR) {
+ if (WSAGetLastError() == WSAENOTSOCK) {
+ Perl_croak_nocontext("ioctl implemented only on sockets");
+ /* NOTREACHED */
+ }
+ errno = WSAGetLastError();
+ }
+ return retval;
+}
+
char FAR *
win32_inet_ntoa(struct in_addr in)
{
void
win32_endhostent()
{
- croak("endhostent not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("endhostent not implemented!\n");
}
void
win32_endnetent()
{
- croak("endnetent not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("endnetent not implemented!\n");
}
void
win32_endprotoent()
{
- croak("endprotoent not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("endprotoent not implemented!\n");
}
void
win32_endservent()
{
- croak("endservent not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("endservent not implemented!\n");
}
struct netent *
win32_getnetent(void)
{
- croak("getnetent not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("getnetent not implemented!\n");
return (struct netent *) NULL;
}
struct netent *
win32_getnetbyname(char *name)
{
- croak("getnetbyname not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("getnetbyname not implemented!\n");
return (struct netent *)NULL;
}
struct netent *
win32_getnetbyaddr(long net, int type)
{
- croak("getnetbyaddr not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("getnetbyaddr not implemented!\n");
return (struct netent *)NULL;
}
struct protoent *
win32_getprotoent(void)
{
- croak("getprotoent not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("getprotoent not implemented!\n");
return (struct protoent *) NULL;
}
struct servent *
win32_getservent(void)
{
- croak("getservent not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("getservent not implemented!\n");
return (struct servent *) NULL;
}
void
win32_sethostent(int stayopen)
{
- croak("sethostent not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("sethostent not implemented!\n");
}
void
win32_setnetent(int stayopen)
{
- croak("setnetent not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("setnetent not implemented!\n");
}
void
win32_setprotoent(int stayopen)
{
- croak("setprotoent not implemented!\n");
+ dTHXo;
+ Perl_croak_nocontext("setprotoent not implemented!\n");
}
void
win32_setservent(int stayopen)
{
- croak("setservent not implemented!\n");
-}
-
-#define WIN32IO_IS_STDIO
-#include <io.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "win32iop.h"
-#ifdef __cplusplus
+ dTHXo;
+ Perl_croak_nocontext("setservent not implemented!\n");
}
-#endif
static struct servent*
win32_savecopyservent(struct servent*d, struct servent*s, const char *proto)
d->s_proto = s->s_proto;
else
#endif
- if (proto && strlen(proto))
+ if (proto && strlen(proto))
d->s_proto = (char *)proto;
else
d->s_proto = "tcp";