#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 <ws2spi.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>
-#ifndef __MINGW32__
#include <assert.h>
-#endif
#include <io.h>
/* thanks to Beverly Brown (beverly@datacube.com) */
# 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
-#else
-#define StartSockets() \
- STMT_START { \
- if (!wsock_started) { \
- start_sockets(); \
- set_socktype(); \
- } \
- } STMT_END
-#endif
#define SOCKET_TEST(x, y) \
STMT_START { \
StartSockets(); \
if((x) == (y)) \
- errno = CALL(WSAGetLastError)(); \
+ errno = WSAGetLastError(); \
} STMT_END
#define SOCKET_TEST_ERROR(x) SOCKET_TEST(x, SOCKET_ERROR)
static int wsock_started = 0;
-#ifdef PERL_WIN32_SOCK_DLOAD /* we load the socket libraries when needed -- BKS 5-29-2000 */
-#define CALL(x) (*p ## x)
-typedef SOCKET (PASCAL *Paccept)(SOCKET,struct sockaddr*,int*);
-typedef int (PASCAL *Pbind)(SOCKET,const struct sockaddr*,int);
-typedef int (PASCAL *Pclosesocket)(SOCKET);
-typedef int (PASCAL *Pconnect)(SOCKET,const struct sockaddr*,int);
-typedef int (PASCAL *Pioctlsocket)(SOCKET,long,u_long *);
-typedef int (PASCAL *Pgetpeername)(SOCKET,struct sockaddr*,int*);
-typedef int (PASCAL *Pgetsockname)(SOCKET,struct sockaddr*,int*);
-typedef int (PASCAL *Pgetsockopt)(SOCKET,int,int,char*,int*);
-typedef unsigned long (PASCAL *Pinet_addr)(const char*);
-typedef char * (PASCAL *Pinet_ntoa)(struct in_addr);
-typedef int (PASCAL *Plisten)(SOCKET,int);
-typedef int (PASCAL *Precv)(SOCKET,char*,int,int);
-typedef int (PASCAL *Precvfrom)(SOCKET,char*,int,int,struct sockaddr*,int*);
-typedef int (PASCAL *Psend)(SOCKET,const char*,int,int);
-typedef int (PASCAL *Psendto)(SOCKET,const char*,int,int,const struct sockaddr*,int);
-typedef int (PASCAL *Psetsockopt)(SOCKET,int,int,const char*,int);
-typedef int (PASCAL *Pshutdown)(SOCKET,int);
-typedef SOCKET (PASCAL *Psocket)(int,int,int);
-typedef struct hostent* (PASCAL *Pgethostbyaddr)(const char*,int,int);
-typedef struct hostent* (PASCAL *Pgethostbyname)(const char*);
-typedef struct servent* (PASCAL *Pgetservbyport)(int,const char*);
-typedef struct servent* (PASCAL *Pgetservbyname)(const char*,const char*);
-typedef struct protoent* (PASCAL *Pgetprotobynumber)(int);
-typedef struct protoent* (PASCAL *Pgetprotobyname)(const char*);
-typedef int (PASCAL *PWSACleanup)(void);
-typedef int (PASCAL *PWSAStartup)(unsigned short, WSADATA*);
-typedef void (PASCAL *PWSASetLastError)(int);
-typedef int (PASCAL *PWSAGetLastError)(void);
-typedef int (PASCAL *P__WSAFDIsSet)(SOCKET,fd_set*);
-typedef int (PASCAL *Pselect)(int nfds,fd_set*,fd_set*,fd_set*,const struct timeval*);
-typedef int (PASCAL *Pgethostname)(char*,int);
-typedef u_long (PASCAL *Phtonl)(u_long), (PASCAL *Pntohl)(u_long);
-typedef u_short (PASCAL *Phtons)(u_short), (PASCAL *Pntohs)(u_short);
-static Paccept paccept;
-static Pbind pbind;
-static Pclosesocket pclosesocket;
-static Pconnect pconnect;
-static Pioctlsocket pioctlsocket;
-static Pgetpeername pgetpeername;
-static Pgetsockname pgetsockname;
-static Pgetsockopt pgetsockopt;
-static Pinet_addr pinet_addr;
-static Pinet_ntoa pinet_ntoa;
-static Plisten plisten;
-static Precv precv;
-static Precvfrom precvfrom;
-static Psend psend;
-static Psendto psendto;
-static Psetsockopt psetsockopt;
-static Pshutdown pshutdown;
-static Psocket psocket;
-static Pgethostbyaddr pgethostbyaddr;
-static Pgethostbyname pgethostbyname;
-static Pgetservbyport pgetservbyport;
-static Pgetservbyname pgetservbyname;
-static Pgetprotobynumber pgetprotobynumber;
-static Pgetprotobyname pgetprotobyname;
-static PWSAStartup pWSAStartup;
-static PWSACleanup pWSACleanup;
-static PWSASetLastError pWSASetLastError;
-static PWSAGetLastError pWSAGetLastError;
-static P__WSAFDIsSet p__WSAFDIsSet;
-static Pselect pselect;
-static Pgethostname pgethostname;
-#if BYTEORDER != 0x1234
-static Phtons phtons;
-static Pntohs pntohs;
-static Phtonl phtonl;
-static Pntohl pntohl;
-#endif
-void end_sockets(pTHXo_ void *ptr)
+EXTERN_C void
+EndSockets(void)
{
- CALL(WSACleanup)();
- wsock_started = 0;
- FreeLibrary(ptr);
+ if (wsock_started)
+ WSACleanup();
}
-#else
-#define CALL(x) x
-#endif /* PERL_WIN32_SOCK_DLOAD */
+
void
start_sockets(void)
{
- dTHXo;
+ dTHX;
unsigned short version;
WSADATA retdata;
int ret;
-#ifdef PERL_WIN32_SOCK_DLOAD
- HANDLE hDll = LoadLibraryA("wsock32.dll");
/*
* initalize the winsock interface and insure that it is
* cleaned up at exit.
- * Also, only load the DLL when needed -- BKS, 4-2-2000
*/
- if (!(hDll &&
- (paccept = (Paccept)GetProcAddress(hDll, "accept")) &&
- (pbind = (Pbind)GetProcAddress(hDll, "bind")) &&
- (pclosesocket = (Pclosesocket)GetProcAddress(hDll, "closesocket")) &&
- (pconnect = (Pconnect)GetProcAddress(hDll, "connect")) &&
- (pioctlsocket = (Pioctlsocket)GetProcAddress(hDll, "ioctlsocket")) &&
- (pgetpeername = (Pgetpeername)GetProcAddress(hDll, "getpeername")) &&
- (pgetsockname = (Pgetsockname)GetProcAddress(hDll, "getsockname")) &&
- (pgetsockopt = (Pgetsockopt)GetProcAddress(hDll, "getsockopt")) &&
- (pinet_addr = (Pinet_addr)GetProcAddress(hDll, "inet_addr")) &&
- (pinet_ntoa = (Pinet_ntoa)GetProcAddress(hDll, "inet_ntoa")) &&
- (plisten = (Plisten)GetProcAddress(hDll, "listen")) &&
- (precv = (Precv)GetProcAddress(hDll, "recv")) &&
- (precvfrom = (Precvfrom)GetProcAddress(hDll, "recvfrom")) &&
- (psend = (Psend)GetProcAddress(hDll, "send")) &&
- (psendto = (Psendto)GetProcAddress(hDll, "sendto")) &&
- (psetsockopt = (Psetsockopt)GetProcAddress(hDll, "setsockopt")) &&
- (pshutdown = (Pshutdown)GetProcAddress(hDll, "shutdown")) &&
- (psocket = (Psocket)GetProcAddress(hDll, "socket")) &&
- (pgethostbyaddr = (Pgethostbyaddr)GetProcAddress(hDll, "gethostbyaddr")) &&
- (pgethostbyname = (Pgethostbyname)GetProcAddress(hDll, "gethostbyname")) &&
- (pgetservbyport = (Pgetservbyport)GetProcAddress(hDll, "getservbyport")) &&
- (pgetservbyname = (Pgetservbyname)GetProcAddress(hDll, "getservbyname")) &&
- (pgetprotobynumber = (Pgetprotobynumber)GetProcAddress(hDll, "getprotobynumber")) &&
- (pgetprotobyname = (Pgetprotobyname)GetProcAddress(hDll, "getprotobyname")) &&
- (pWSAStartup = (PWSAStartup)GetProcAddress(hDll, "WSAStartup")) &&
- (pWSACleanup = (PWSACleanup)GetProcAddress(hDll, "WSACleanup")) &&
- (pWSASetLastError = (PWSASetLastError)GetProcAddress(hDll, "WSASetLastError")) &&
- (pWSAGetLastError = (PWSAGetLastError)GetProcAddress(hDll, "WSAGetLastError")) &&
- (p__WSAFDIsSet = (P__WSAFDIsSet)GetProcAddress(hDll, "__WSAFDIsSet")) &&
- (pselect = (Pselect)GetProcAddress(hDll, "select")) &&
- (pgethostname = (Pgethostname)GetProcAddress(hDll, "gethostname")) &&
-#if BYTEORDER != 0x1234
- (phtonl = (Phtonl)GetProcAddress(hDll, "htonl")) &&
- (pntohl = (Pntohl)GetProcAddress(hDll, "ntohl")) &&
- (phtons = (Pntohs)GetProcAddress(hDll, "htons")) &&
- (pntohs = (Pntohs)GetProcAddress(hDll, "ntohs")
-#else
- 1
-#endif
- )) {
- Perl_croak(aTHX_ "Unable to load winsock library!\n");
- }
-#endif /* PERL_WIN32_SOCK_DLOAD */
- version = 0x101;
- if(ret = CALL(WSAStartup)(version, &retdata))
- Perl_croak(aTHX_ "Unable to initialize winsock library!\n");
+ version = 0x2;
+ if(ret = WSAStartup(version, &retdata))
+ Perl_croak_nocontext("Unable to locate winsock library!\n");
if(retdata.wVersion != version)
- Perl_croak(aTHX_ "Could not find version 1.1 of winsock dll\n");
+ Perl_croak_nocontext("Could not find version 2.0 of winsock dll\n");
-#ifdef PERL_WIN32_SOCK_DLOAD
- call_atexit(end_sockets, hDll);
-#endif
+ /* atexit((void (*)(void)) EndSockets); */
wsock_started = 1;
}
-void
-set_socktype(void)
-{
-#ifdef USE_SOCKETS_AS_HANDLES
-#ifdef USE_THREADS
- dTHX;
- if (!w32_init_socktype) {
-#endif
- int iSockOpt = SO_SYNCHRONOUS_NONALERT;
- /*
- * Enable the use of sockets as filehandles
- */
- CALL(setsockopt)(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
- (char *)&iSockOpt, sizeof(iSockOpt));
-#ifdef USE_THREADS
- w32_init_socktype = 1;
- }
-#endif
-#endif /* USE_SOCKETS_AS_HANDLES */
-}
-
-
#ifndef USE_SOCKETS_AS_HANDLES
#undef fdopen
FILE *
if (!wsock_started)
return(fdopen(fd, mode));
- retval = CALL(getsockopt)((SOCKET)fd, SOL_SOCKET, SO_TYPE, sockbuf, &optlen);
- if(retval == SOCKET_ERROR && CALL(WSAGetLastError)() == WSAENOTSOCK) {
+ retval = getsockopt((SOCKET)fd, SOL_SOCKET, SO_TYPE, sockbuf, &optlen);
+ if(retval == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK) {
return(fdopen(fd, mode));
}
/*
* If we get here, then fd is actually a socket.
*/
- Newz(1310, fp, 1, FILE);
+ Newxz(fp, 1, FILE); /* XXX leak, good thing this code isn't used */
if(fp == NULL) {
errno = ENOMEM;
return NULL;
}
#endif /* USE_SOCKETS_AS_HANDLES */
-/* ntoh* and hton* are implemented here so that ByteLoader doesn't need to load WinSock;
- these functions are simply copied from util.c */
u_long
-win32_htonl(u_long l)
-{
-#if BYTEORDER == 0x1234
- union { u_long r; char c[4]; } u;
- u.c[0] = (l >> 24) & 255;
- u.c[1] = (l >> 16) & 255;
- u.c[2] = (l >> 8) & 255;
- u.c[3] = l & 255;
- return u.r;
-#else
+win32_htonl(u_long hostlong)
+{
StartSockets();
- return CALL(htonl)(l);
-#endif
+ return htonl(hostlong);
}
u_short
-win32_htons(u_short s)
+win32_htons(u_short hostshort)
{
-#if BYTEORDER == 0x1234
- return (((s >> 8) & 255) | ((s & 255) << 8));
-#else
StartSockets();
- return CALL(htons)(s);
-#endif
+ return htons(hostshort);
}
u_long
-win32_ntohl(u_long l)
-{
-#if BYTEORDER == 0x1234
- union { u_long r; char c[4]; } u;
- u.c[0] = (l >> 24) & 255;
- u.c[1] = (l >> 16) & 255;
- u.c[2] = (l >> 8) & 255;
- u.c[3] = l & 255;
- return u.r;
-#else
+win32_ntohl(u_long netlong)
+{
StartSockets();
- return CALL(ntohl)(l);
-#endif
+ return ntohl(netlong);
}
u_short
-win32_ntohs(u_short s)
+win32_ntohs(u_short netshort)
{
-#if BYTEORDER == 0x1234
- return (((s >> 8) & 255) | ((s & 255) << 8));
-#else
StartSockets();
- return CALL(ntohs)(s);
-#endif
+ return ntohs(netshort);
}
{
SOCKET r;
- SOCKET_TEST((r = CALL(accept)(TO_SOCKET(s), addr, addrlen)), INVALID_SOCKET);
+ SOCKET_TEST((r = accept(TO_SOCKET(s), addr, addrlen)), INVALID_SOCKET);
return OPEN_SOCKET(r);
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(bind)(TO_SOCKET(s), addr, addrlen));
+ SOCKET_TEST_ERROR(r = bind(TO_SOCKET(s), addr, addrlen));
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(connect)(TO_SOCKET(s), addr, addrlen));
+ SOCKET_TEST_ERROR(r = connect(TO_SOCKET(s), addr, addrlen));
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(getpeername)(TO_SOCKET(s), addr, addrlen));
+ SOCKET_TEST_ERROR(r = getpeername(TO_SOCKET(s), addr, addrlen));
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(getsockname)(TO_SOCKET(s), addr, addrlen));
+ SOCKET_TEST_ERROR(r = getsockname(TO_SOCKET(s), addr, addrlen));
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(getsockopt)(TO_SOCKET(s), level, optname, optval, optlen));
+ SOCKET_TEST_ERROR(r = getsockopt(TO_SOCKET(s), level, optname, optval, optlen));
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(ioctlsocket)(TO_SOCKET(s), cmd, argp));
+ SOCKET_TEST_ERROR(r = ioctlsocket(TO_SOCKET(s), cmd, argp));
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(listen)(TO_SOCKET(s), backlog));
+ SOCKET_TEST_ERROR(r = listen(TO_SOCKET(s), backlog));
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(recv)(TO_SOCKET(s), buf, len, flags));
+ SOCKET_TEST_ERROR(r = recv(TO_SOCKET(s), buf, len, flags));
return r;
}
int r;
int frombufsize = *fromlen;
- SOCKET_TEST_ERROR(r = CALL(recvfrom)(TO_SOCKET(s), buf, len, flags, from, 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.
{
int r;
#ifdef USE_SOCKETS_AS_HANDLES
- Perl_fd_set dummy;
- int i, fd, bit, offset;
- FD_SET nrd, nwr, nex, *prd, *pwr, *pex;
+ int i, fd, save_errno = errno;
+ FD_SET nrd, nwr, nex;
/* winsock seems incapable of dealing with all three null fd_sets,
* so do the (millisecond) sleep as a special case
return 0;
}
StartSockets();
- PERL_FD_ZERO(&dummy);
- if (!rd)
- rd = &dummy, prd = NULL;
- else
- prd = &nrd;
- if (!wr)
- wr = &dummy, pwr = NULL;
- else
- pwr = &nwr;
- if (!ex)
- ex = &dummy, pex = NULL;
- else
- pex = &nex;
FD_ZERO(&nrd);
FD_ZERO(&nwr);
FD_ZERO(&nex);
for (i = 0; i < nfds; i++) {
fd = TO_SOCKET(i);
- if (PERL_FD_ISSET(i,rd))
- FD_SET(fd, &nrd);
- if (PERL_FD_ISSET(i,wr))
- FD_SET(fd, &nwr);
- if (PERL_FD_ISSET(i,ex))
- FD_SET(fd, &nex);
+ if (rd && PERL_FD_ISSET(i,rd))
+ FD_SET((unsigned)fd, &nrd);
+ if (wr && PERL_FD_ISSET(i,wr))
+ FD_SET((unsigned)fd, &nwr);
+ if (ex && PERL_FD_ISSET(i,ex))
+ FD_SET((unsigned)fd, &nex);
}
- SOCKET_TEST_ERROR(r = CALL(select)(nfds, prd, pwr, pex, timeout));
+ errno = save_errno;
+ SOCKET_TEST_ERROR(r = select(nfds, &nrd, &nwr, &nex, timeout));
+ save_errno = errno;
for (i = 0; i < nfds; i++) {
fd = TO_SOCKET(i);
- if (PERL_FD_ISSET(i,rd) && !CALL(__WSAFDIsSet)(fd, &nrd))
+ if (rd && PERL_FD_ISSET(i,rd) && !FD_ISSET(fd, &nrd))
PERL_FD_CLR(i,rd);
- if (PERL_FD_ISSET(i,wr) && !CALL(__WSAFDIsSet)(fd, &nwr))
+ if (wr && PERL_FD_ISSET(i,wr) && !FD_ISSET(fd, &nwr))
PERL_FD_CLR(i,wr);
- if (PERL_FD_ISSET(i,ex) && !CALL(__WSAFDIsSet)(fd, &nex))
+ if (ex && PERL_FD_ISSET(i,ex) && !FD_ISSET(fd, &nex))
PERL_FD_CLR(i,ex);
}
+ errno = save_errno;
#else
- SOCKET_TEST_ERROR(r = CALL(select)(nfds, rd, wr, ex, timeout));
+ SOCKET_TEST_ERROR(r = select(nfds, rd, wr, ex, timeout));
#endif
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(send)(TO_SOCKET(s), buf, len, flags));
+ SOCKET_TEST_ERROR(r = send(TO_SOCKET(s), buf, len, flags));
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(sendto)(TO_SOCKET(s), buf, len, flags, to, tolen));
+ SOCKET_TEST_ERROR(r = sendto(TO_SOCKET(s), buf, len, flags, to, tolen));
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(setsockopt)(TO_SOCKET(s), level, optname, optval, optlen));
+ SOCKET_TEST_ERROR(r = setsockopt(TO_SOCKET(s), level, optname, optval, optlen));
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(shutdown)(TO_SOCKET(s), how));
+ SOCKET_TEST_ERROR(r = shutdown(TO_SOCKET(s), how));
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(closesocket)(TO_SOCKET(s)));
+ SOCKET_TEST_ERROR(r = closesocket(TO_SOCKET(s)));
return r;
}
+#ifdef USE_SOCKETS_AS_HANDLES
+#define WIN32_OPEN_SOCKET(af, type, protocol) open_ifs_socket(af, type, protocol)
+
+void
+convert_proto_info_w2a(WSAPROTOCOL_INFOW *in, WSAPROTOCOL_INFOA *out)
+{
+ Copy(in, out, 1, WSAPROTOCOL_INFOA);
+ wcstombs(out->szProtocol, in->szProtocol, sizeof(out->szProtocol));
+}
+
+SOCKET
+open_ifs_socket(int af, int type, int protocol)
+{
+ dTHX;
+ char *s;
+ unsigned long proto_buffers_len = 0;
+ int error_code;
+ SOCKET out = INVALID_SOCKET;
+
+ if ((s = PerlEnv_getenv("PERL_ALLOW_NON_IFS_LSP")) && atoi(s))
+ return WSASocket(af, type, protocol, NULL, 0, 0);
+
+ if (WSCEnumProtocols(NULL, NULL, &proto_buffers_len, &error_code) == SOCKET_ERROR
+ && error_code == WSAENOBUFS)
+ {
+ WSAPROTOCOL_INFOW *proto_buffers;
+ int protocols_available = 0;
+
+ Newx(proto_buffers, proto_buffers_len / sizeof(WSAPROTOCOL_INFOW),
+ WSAPROTOCOL_INFOW);
+
+ if ((protocols_available = WSCEnumProtocols(NULL, proto_buffers,
+ &proto_buffers_len, &error_code)) != SOCKET_ERROR)
+ {
+ int i;
+ for (i = 0; i < protocols_available; i++)
+ {
+ WSAPROTOCOL_INFOA proto_info;
+
+ if ((af != AF_UNSPEC && af != proto_buffers[i].iAddressFamily)
+ || (type != proto_buffers[i].iSocketType)
+ || (protocol != 0 && proto_buffers[i].iProtocol != 0 &&
+ protocol != proto_buffers[i].iProtocol))
+ continue;
+
+ if ((proto_buffers[i].dwServiceFlags1 & XP1_IFS_HANDLES) == 0)
+ continue;
+
+ convert_proto_info_w2a(&(proto_buffers[i]), &proto_info);
+
+ out = WSASocket(af, type, protocol, &proto_info, 0, 0);
+ break;
+ }
+ }
+
+ Safefree(proto_buffers);
+ }
+
+ return out;
+}
+
+#else
+#define WIN32_OPEN_SOCKET(af, type, protocol) socket(af, type, protocol)
+#endif
+
SOCKET
win32_socket(int af, int type, int protocol)
{
SOCKET s;
#ifndef USE_SOCKETS_AS_HANDLES
- SOCKET_TEST(s = CALL(socket)(af, type, protocol), INVALID_SOCKET);
+ SOCKET_TEST(s = socket(af, type, protocol), INVALID_SOCKET);
#else
StartSockets();
- if((s = CALL(socket)(af, type, protocol)) == INVALID_SOCKET)
- errno = CALL(WSAGetLastError)();
+
+ if((s = WIN32_OPEN_SOCKET(af, type, protocol)) == INVALID_SOCKET)
+ errno = WSAGetLastError();
else
s = OPEN_SOCKET(s);
#endif /* USE_SOCKETS_AS_HANDLES */
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
- && CALL(closesocket)(osf) == SOCKET_ERROR
- && CALL(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);
+}
+
+#undef fstat
+int
+my_fstat(int fd, Stat_t *sbufptr)
+{
+ /* This fixes a bug in fstat() on Windows 9x. fstat() uses the
+ * GetFileType() win32 syscall, which will fail on Windows 9x.
+ * So if we recognize a socket on Windows 9x, we return the
+ * same results as on Windows NT/2000.
+ * XXX this should be extended further to set S_IFSOCK on
+ * sbufptr->st_mode.
+ */
+ int osf;
+ if (!wsock_started || IsWinNT()) {
+#if defined(WIN64) || defined(USE_LARGE_FILES)
+#if defined(__BORLANDC__) /* buk */
+ return win32_fstat(fd, sbufptr );
+#else
+ return _fstati64(fd, sbufptr);
+#endif
+#else
+ return fstat(fd, sbufptr);
+#endif
+ }
+
+ osf = TO_SOCKET(fd);
+ if (osf != -1) {
+ char sockbuf[256];
+ int optlen = sizeof(sockbuf);
+ int retval;
+
+ retval = getsockopt((SOCKET)osf, SOL_SOCKET, SO_TYPE, sockbuf, &optlen);
+ if (retval != SOCKET_ERROR || WSAGetLastError() != WSAENOTSOCK) {
+#if defined(__BORLANDC__)&&(__BORLANDC__<=0x520)
+ sbufptr->st_mode = S_IFIFO;
+#else
+ sbufptr->st_mode = _S_IFIFO;
+#endif
+ sbufptr->st_rdev = sbufptr->st_dev = (dev_t)fd;
+ sbufptr->st_nlink = 1;
+ sbufptr->st_uid = sbufptr->st_gid = sbufptr->st_ino = 0;
+ sbufptr->st_atime = sbufptr->st_mtime = sbufptr->st_ctime = 0;
+ sbufptr->st_size = (Off_t)0;
+ return 0;
+ }
+ }
+#if defined(WIN64) || defined(USE_LARGE_FILES)
+#if defined(__BORLANDC__) /* buk */
+ return win32_fstat(fd, sbufptr );
+#else
+ return _fstati64(fd, sbufptr);
+#endif
+#else
+ return fstat(fd, sbufptr);
+#endif
}
struct hostent *
{
struct hostent *r;
- SOCKET_TEST(r = CALL(gethostbyaddr)(addr, len, type), NULL);
+ SOCKET_TEST(r = gethostbyaddr(addr, len, type), NULL);
return r;
}
{
struct hostent *r;
- SOCKET_TEST(r = CALL(gethostbyname)(name), NULL);
+ SOCKET_TEST(r = gethostbyname(name), NULL);
return r;
}
{
int r;
- SOCKET_TEST_ERROR(r = CALL(gethostname)(name, len));
+ SOCKET_TEST_ERROR(r = gethostname(name, len));
return r;
}
{
struct protoent *r;
- SOCKET_TEST(r = CALL(getprotobyname)(name), NULL);
+ SOCKET_TEST(r = getprotobyname(name), NULL);
return r;
}
{
struct protoent *r;
- SOCKET_TEST(r = CALL(getprotobynumber)(num), NULL);
+ SOCKET_TEST(r = getprotobynumber(num), NULL);
return r;
}
struct servent *
win32_getservbyname(const char *name, const char *proto)
{
- dTHXo;
+ dTHX;
struct servent *r;
- SOCKET_TEST(r = CALL(getservbyname)(name, proto), NULL);
+ SOCKET_TEST(r = getservbyname(name, proto), NULL);
if (r) {
r = win32_savecopyservent(&w32_servent, r, proto);
}
struct servent *
win32_getservbyport(int port, const char *proto)
{
- dTHXo;
+ dTHX;
struct servent *r;
- SOCKET_TEST(r = CALL(getservbyport)(port, proto), NULL);
+ SOCKET_TEST(r = getservbyport(port, proto), NULL);
if (r) {
r = win32_savecopyservent(&w32_servent, r, proto);
}
int
win32_ioctl(int i, unsigned int u, char *data)
{
- dTHXo;
- u_long argp = (u_long)data;
+ dTHX;
+ u_long u_long_arg;
int retval;
-
+
if (!wsock_started) {
Perl_croak_nocontext("ioctl implemented only on sockets");
/* NOTREACHED */
}
- retval = CALL(ioctlsocket)(TO_SOCKET(i), (long)u, &argp);
+ /* mauke says using memcpy avoids alignment issues */
+ memcpy(&u_long_arg, data, sizeof u_long_arg);
+ retval = ioctlsocket(TO_SOCKET(i), (long)u, &u_long_arg);
+ memcpy(data, &u_long_arg, sizeof u_long_arg);
+
if (retval == SOCKET_ERROR) {
- if (CALL(WSAGetLastError)() == WSAENOTSOCK) {
+ if (WSAGetLastError() == WSAENOTSOCK) {
Perl_croak_nocontext("ioctl implemented only on sockets");
/* NOTREACHED */
}
- errno = CALL(WSAGetLastError)();
+ errno = WSAGetLastError();
}
return retval;
}
win32_inet_ntoa(struct in_addr in)
{
StartSockets();
- return CALL(inet_ntoa)(in);
+ return inet_ntoa(in);
}
unsigned long
win32_inet_addr(const char FAR *cp)
{
StartSockets();
- return CALL(inet_addr)(cp);
+ return inet_addr(cp);
}
/*
void
win32_endhostent()
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("endhostent not implemented!\n");
}
void
win32_endnetent()
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("endnetent not implemented!\n");
}
void
win32_endprotoent()
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("endprotoent not implemented!\n");
}
void
win32_endservent()
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("endservent not implemented!\n");
}
struct netent *
win32_getnetent(void)
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("getnetent not implemented!\n");
return (struct netent *) NULL;
}
struct netent *
win32_getnetbyname(char *name)
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("getnetbyname not implemented!\n");
return (struct netent *)NULL;
}
struct netent *
win32_getnetbyaddr(long net, int type)
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("getnetbyaddr not implemented!\n");
return (struct netent *)NULL;
}
struct protoent *
win32_getprotoent(void)
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("getprotoent not implemented!\n");
return (struct protoent *) NULL;
}
struct servent *
win32_getservent(void)
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("getservent not implemented!\n");
return (struct servent *) NULL;
}
void
win32_sethostent(int stayopen)
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("sethostent not implemented!\n");
}
void
win32_setnetent(int stayopen)
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("setnetent not implemented!\n");
}
void
win32_setprotoent(int stayopen)
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("setprotoent not implemented!\n");
}
void
win32_setservent(int stayopen)
{
- dTHXo;
+ dTHX;
Perl_croak_nocontext("setservent not implemented!\n");
}
https://perl5.git.perl.org / perl5.git / blobdiff