This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
integrate cfgperl contents into mainline; merge conflicts
[perl5.git] / win32 / win32sck.c
1 /* win32sck.c
2  *
3  * (c) 1995 Microsoft Corporation. All rights reserved. 
4  *              Developed by hip communications inc., http://info.hip.com/info/
5  * Portions (c) 1993 Intergraph Corporation. All rights reserved.
6  *
7  *    You may distribute under the terms of either the GNU General Public
8  *    License or the Artistic License, as specified in the README file.
9  */
10
11 #define WIN32IO_IS_STDIO
12 #define WIN32SCK_IS_STDSCK
13 #define WIN32_LEAN_AND_MEAN
14 #ifdef __GNUC__
15 #define Win32_Winsock
16 #endif
17 #include <windows.h>
18 #include "EXTERN.h"
19 #include "perl.h"
20
21 #if defined(PERL_OBJECT)
22 #define NO_XSLOCKS
23 #include "XSUB.h"
24 #endif
25
26 #include "Win32iop.h"
27 #include <sys/socket.h>
28 #include <fcntl.h>
29 #include <sys/stat.h>
30 #include <assert.h>
31 #include <io.h>
32
33 /* thanks to Beverly Brown      (beverly@datacube.com) */
34 #ifdef USE_SOCKETS_AS_HANDLES
35 #       define OPEN_SOCKET(x)   win32_open_osfhandle(x,O_RDWR|O_BINARY)
36 #       define TO_SOCKET(x)     _get_osfhandle(x)
37 #else
38 #       define OPEN_SOCKET(x)   (x)
39 #       define TO_SOCKET(x)     (x)
40 #endif  /* USE_SOCKETS_AS_HANDLES */
41
42 #ifdef USE_THREADS
43 #define StartSockets() \
44     STMT_START {                                        \
45         if (!wsock_started)                             \
46             start_sockets();                            \
47        set_socktype();                         \
48     } STMT_END
49 #else
50 #define StartSockets() \
51     STMT_START {                                        \
52         if (!wsock_started) {                           \
53             start_sockets();                            \
54             set_socktype();                             \
55         }                                               \
56     } STMT_END
57 #endif
58
59 #define EndSockets() \
60     STMT_START {                                        \
61         if (wsock_started)                              \
62             WSACleanup();                               \
63     } STMT_END
64
65 #define SOCKET_TEST(x, y) \
66     STMT_START {                                        \
67         StartSockets();                                 \
68         if((x) == (y))                                  \
69             errno = WSAGetLastError();                  \
70     } STMT_END
71
72 #define SOCKET_TEST_ERROR(x) SOCKET_TEST(x, SOCKET_ERROR)
73
74 static struct servent* win32_savecopyservent(struct servent*d,
75                                              struct servent*s,
76                                              const char *proto);
77
78 #ifdef USE_THREADS
79 #ifdef USE_DECLSPEC_THREAD
80 __declspec(thread) struct servent myservent;
81 __declspec(thread) int init_socktype;
82 #else
83 #define myservent (thr->i.Wservent)
84 #define init_socktype (thr->i.Winit_socktype)
85 #endif
86 #else
87 static struct servent myservent;
88 #endif
89
90 static int wsock_started = 0;
91
92 void
93 start_sockets(void) 
94 {
95     dTHXo;
96     unsigned short version;
97     WSADATA retdata;
98     int ret;
99
100     /*
101      * initalize the winsock interface and insure that it is
102      * cleaned up at exit.
103      */
104     version = 0x101;
105     if(ret = WSAStartup(version, &retdata))
106         Perl_croak_nocontext("Unable to locate winsock library!\n");
107     if(retdata.wVersion != version)
108         Perl_croak_nocontext("Could not find version 1.1 of winsock dll\n");
109
110     /* atexit((void (*)(void)) EndSockets); */
111     wsock_started = 1;
112 }
113
114 void
115 set_socktype(void)
116 {
117 #ifdef USE_SOCKETS_AS_HANDLES
118 #ifdef USE_THREADS
119     dTHX;
120     if(!init_socktype) {
121 #endif
122     int iSockOpt = SO_SYNCHRONOUS_NONALERT;
123     /*
124      * Enable the use of sockets as filehandles
125      */
126     setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
127                 (char *)&iSockOpt, sizeof(iSockOpt));
128 #ifdef USE_THREADS
129     init_socktype = 1;
130     }
131 #endif
132 #endif  /* USE_SOCKETS_AS_HANDLES */
133 }
134
135
136 #ifndef USE_SOCKETS_AS_HANDLES
137 #undef fdopen
138 FILE *
139 my_fdopen(int fd, char *mode)
140 {
141     FILE *fp;
142     char sockbuf[256];
143     int optlen = sizeof(sockbuf);
144     int retval;
145
146     if (!wsock_started)
147         return(fdopen(fd, mode));
148
149     retval = getsockopt((SOCKET)fd, SOL_SOCKET, SO_TYPE, sockbuf, &optlen);
150     if(retval == SOCKET_ERROR && WSAGetLastError() == WSAENOTSOCK) {
151         return(fdopen(fd, mode));
152     }
153
154     /*
155      * If we get here, then fd is actually a socket.
156      */
157     Newz(1310, fp, 1, FILE);
158     if(fp == NULL) {
159         errno = ENOMEM;
160         return NULL;
161     }
162
163     fp->_file = fd;
164     if(*mode == 'r')
165         fp->_flag = _IOREAD;
166     else
167         fp->_flag = _IOWRT;
168    
169     return fp;
170 }
171 #endif  /* USE_SOCKETS_AS_HANDLES */
172
173
174 u_long
175 win32_htonl(u_long hostlong)
176 {
177     StartSockets();
178     return htonl(hostlong);
179 }
180
181 u_short
182 win32_htons(u_short hostshort)
183 {
184     StartSockets();
185     return htons(hostshort);
186 }
187
188 u_long
189 win32_ntohl(u_long netlong)
190 {
191     StartSockets();
192     return ntohl(netlong);
193 }
194
195 u_short
196 win32_ntohs(u_short netshort)
197 {
198     StartSockets();
199     return ntohs(netshort);
200 }
201
202
203
204 SOCKET
205 win32_accept(SOCKET s, struct sockaddr *addr, int *addrlen)
206 {
207     SOCKET r;
208
209     SOCKET_TEST((r = accept(TO_SOCKET(s), addr, addrlen)), INVALID_SOCKET);
210     return OPEN_SOCKET(r);
211 }
212
213 int
214 win32_bind(SOCKET s, const struct sockaddr *addr, int addrlen)
215 {
216     int r;
217
218     SOCKET_TEST_ERROR(r = bind(TO_SOCKET(s), addr, addrlen));
219     return r;
220 }
221
222 int
223 win32_connect(SOCKET s, const struct sockaddr *addr, int addrlen)
224 {
225     int r;
226
227     SOCKET_TEST_ERROR(r = connect(TO_SOCKET(s), addr, addrlen));
228     return r;
229 }
230
231
232 int
233 win32_getpeername(SOCKET s, struct sockaddr *addr, int *addrlen)
234 {
235     int r;
236
237     SOCKET_TEST_ERROR(r = getpeername(TO_SOCKET(s), addr, addrlen));
238     return r;
239 }
240
241 int
242 win32_getsockname(SOCKET s, struct sockaddr *addr, int *addrlen)
243 {
244     int r;
245
246     SOCKET_TEST_ERROR(r = getsockname(TO_SOCKET(s), addr, addrlen));
247     return r;
248 }
249
250 int
251 win32_getsockopt(SOCKET s, int level, int optname, char *optval, int *optlen)
252 {
253     int r;
254
255     SOCKET_TEST_ERROR(r = getsockopt(TO_SOCKET(s), level, optname, optval, optlen));
256     return r;
257 }
258
259 int
260 win32_ioctlsocket(SOCKET s, long cmd, u_long *argp)
261 {
262     int r;
263
264     SOCKET_TEST_ERROR(r = ioctlsocket(TO_SOCKET(s), cmd, argp));
265     return r;
266 }
267
268 int
269 win32_listen(SOCKET s, int backlog)
270 {
271     int r;
272
273     SOCKET_TEST_ERROR(r = listen(TO_SOCKET(s), backlog));
274     return r;
275 }
276
277 int
278 win32_recv(SOCKET s, char *buf, int len, int flags)
279 {
280     int r;
281
282     SOCKET_TEST_ERROR(r = recv(TO_SOCKET(s), buf, len, flags));
283     return r;
284 }
285
286 int
287 win32_recvfrom(SOCKET s, char *buf, int len, int flags, struct sockaddr *from, int *fromlen)
288 {
289     int r;
290     int frombufsize = *fromlen;
291
292     SOCKET_TEST_ERROR(r = recvfrom(TO_SOCKET(s), buf, len, flags, from, fromlen));
293     /* Winsock's recvfrom() only returns a valid 'from' when the socket
294      * is connectionless.  Perl expects a valid 'from' for all types
295      * of sockets, so go the extra mile.
296      */
297     if (r != SOCKET_ERROR && frombufsize == *fromlen)
298         (void)win32_getpeername(s, from, fromlen);
299     return r;
300 }
301
302 /* select contributed by Vincent R. Slyngstad (vrs@ibeam.intel.com) */
303 int
304 win32_select(int nfds, Perl_fd_set* rd, Perl_fd_set* wr, Perl_fd_set* ex, const struct timeval* timeout)
305 {
306     int r;
307 #ifdef USE_SOCKETS_AS_HANDLES
308     Perl_fd_set dummy;
309     int i, fd, bit, offset;
310     FD_SET nrd, nwr, nex, *prd, *pwr, *pex;
311
312     /* winsock seems incapable of dealing with all three null fd_sets,
313      * so do the (millisecond) sleep as a special case
314      */
315     if (!(rd || wr || ex)) {
316         if (timeout)
317             Sleep(timeout->tv_sec  * 1000 +
318                   timeout->tv_usec / 1000);     /* do the best we can */
319         else
320             Sleep(UINT_MAX);
321         return 0;
322     }
323     StartSockets();
324     PERL_FD_ZERO(&dummy);
325     if (!rd)
326         rd = &dummy, prd = NULL;
327     else
328         prd = &nrd;
329     if (!wr)
330         wr = &dummy, pwr = NULL;
331     else
332         pwr = &nwr;
333     if (!ex)
334         ex = &dummy, pex = NULL;
335     else
336         pex = &nex;
337
338     FD_ZERO(&nrd);
339     FD_ZERO(&nwr);
340     FD_ZERO(&nex);
341     for (i = 0; i < nfds; i++) {
342         fd = TO_SOCKET(i);
343         if (PERL_FD_ISSET(i,rd))
344             FD_SET(fd, &nrd);
345         if (PERL_FD_ISSET(i,wr))
346             FD_SET(fd, &nwr);
347         if (PERL_FD_ISSET(i,ex))
348             FD_SET(fd, &nex);
349     }
350
351     SOCKET_TEST_ERROR(r = select(nfds, prd, pwr, pex, timeout));
352
353     for (i = 0; i < nfds; i++) {
354         fd = TO_SOCKET(i);
355         if (PERL_FD_ISSET(i,rd) && !FD_ISSET(fd, &nrd))
356             PERL_FD_CLR(i,rd);
357         if (PERL_FD_ISSET(i,wr) && !FD_ISSET(fd, &nwr))
358             PERL_FD_CLR(i,wr);
359         if (PERL_FD_ISSET(i,ex) && !FD_ISSET(fd, &nex))
360             PERL_FD_CLR(i,ex);
361     }
362 #else
363     SOCKET_TEST_ERROR(r = select(nfds, rd, wr, ex, timeout));
364 #endif
365     return r;
366 }
367
368 int
369 win32_send(SOCKET s, const char *buf, int len, int flags)
370 {
371     int r;
372
373     SOCKET_TEST_ERROR(r = send(TO_SOCKET(s), buf, len, flags));
374     return r;
375 }
376
377 int
378 win32_sendto(SOCKET s, const char *buf, int len, int flags,
379              const struct sockaddr *to, int tolen)
380 {
381     int r;
382
383     SOCKET_TEST_ERROR(r = sendto(TO_SOCKET(s), buf, len, flags, to, tolen));
384     return r;
385 }
386
387 int
388 win32_setsockopt(SOCKET s, int level, int optname, const char *optval, int optlen)
389 {
390     int r;
391
392     SOCKET_TEST_ERROR(r = setsockopt(TO_SOCKET(s), level, optname, optval, optlen));
393     return r;
394 }
395     
396 int
397 win32_shutdown(SOCKET s, int how)
398 {
399     int r;
400
401     SOCKET_TEST_ERROR(r = shutdown(TO_SOCKET(s), how));
402     return r;
403 }
404
405 int
406 win32_closesocket(SOCKET s)
407 {
408     int r;
409
410     SOCKET_TEST_ERROR(r = closesocket(TO_SOCKET(s)));
411     return r;
412 }
413
414 SOCKET
415 win32_socket(int af, int type, int protocol)
416 {
417     SOCKET s;
418
419 #ifndef USE_SOCKETS_AS_HANDLES
420     SOCKET_TEST(s = socket(af, type, protocol), INVALID_SOCKET);
421 #else
422     StartSockets();
423     if((s = socket(af, type, protocol)) == INVALID_SOCKET)
424         errno = WSAGetLastError();
425     else
426         s = OPEN_SOCKET(s);
427 #endif  /* USE_SOCKETS_AS_HANDLES */
428
429     return s;
430 }
431
432 #undef fclose
433 int
434 my_fclose (FILE *pf)
435 {
436     int osf, retval;
437     if (!wsock_started)         /* No WinSock? */
438         return(fclose(pf));     /* Then not a socket. */
439     osf = TO_SOCKET(fileno(pf));/* Get it now before it's gone! */
440     retval = fclose(pf);        /* Must fclose() before closesocket() */
441     if (osf != -1
442         && closesocket(osf) == SOCKET_ERROR
443         && WSAGetLastError() != WSAENOTSOCK)
444     {
445         return EOF;
446     }
447     return retval;
448 }
449
450 struct hostent *
451 win32_gethostbyaddr(const char *addr, int len, int type)
452 {
453     struct hostent *r;
454
455     SOCKET_TEST(r = gethostbyaddr(addr, len, type), NULL);
456     return r;
457 }
458
459 struct hostent *
460 win32_gethostbyname(const char *name)
461 {
462     struct hostent *r;
463
464     SOCKET_TEST(r = gethostbyname(name), NULL);
465     return r;
466 }
467
468 int
469 win32_gethostname(char *name, int len)
470 {
471     int r;
472
473     SOCKET_TEST_ERROR(r = gethostname(name, len));
474     return r;
475 }
476
477 struct protoent *
478 win32_getprotobyname(const char *name)
479 {
480     struct protoent *r;
481
482     SOCKET_TEST(r = getprotobyname(name), NULL);
483     return r;
484 }
485
486 struct protoent *
487 win32_getprotobynumber(int num)
488 {
489     struct protoent *r;
490
491     SOCKET_TEST(r = getprotobynumber(num), NULL);
492     return r;
493 }
494
495 struct servent *
496 win32_getservbyname(const char *name, const char *proto)
497 {
498     dTHXo;    
499     struct servent *r;
500
501     SOCKET_TEST(r = getservbyname(name, proto), NULL);
502     if (r) {
503         r = win32_savecopyservent(&myservent, r, proto);
504     }
505     return r;
506 }
507
508 struct servent *
509 win32_getservbyport(int port, const char *proto)
510 {
511     dTHXo; 
512     struct servent *r;
513
514     SOCKET_TEST(r = getservbyport(port, proto), NULL);
515     if (r) {
516         r = win32_savecopyservent(&myservent, r, proto);
517     }
518     return r;
519 }
520
521 int
522 win32_ioctl(int i, unsigned int u, char *data)
523 {
524     dTHXo;
525     u_long argp = (u_long)data;
526     int retval;
527
528     if (!wsock_started) {
529         Perl_croak_nocontext("ioctl implemented only on sockets");
530         /* NOTREACHED */
531     }
532
533     retval = ioctlsocket(TO_SOCKET(i), (long)u, &argp);
534     if (retval == SOCKET_ERROR) {
535         if (WSAGetLastError() == WSAENOTSOCK) {
536             Perl_croak_nocontext("ioctl implemented only on sockets");
537             /* NOTREACHED */
538         }
539         errno = WSAGetLastError();
540     }
541     return retval;
542 }
543
544 char FAR *
545 win32_inet_ntoa(struct in_addr in)
546 {
547     StartSockets();
548     return inet_ntoa(in);
549 }
550
551 unsigned long
552 win32_inet_addr(const char FAR *cp)
553 {
554     StartSockets();
555     return inet_addr(cp);
556 }
557
558 /*
559  * Networking stubs
560  */
561
562 void
563 win32_endhostent() 
564 {
565     dTHXo;
566     Perl_croak_nocontext("endhostent not implemented!\n");
567 }
568
569 void
570 win32_endnetent()
571 {
572     dTHXo;
573     Perl_croak_nocontext("endnetent not implemented!\n");
574 }
575
576 void
577 win32_endprotoent()
578 {
579     dTHXo;
580     Perl_croak_nocontext("endprotoent not implemented!\n");
581 }
582
583 void
584 win32_endservent()
585 {
586     dTHXo;
587     Perl_croak_nocontext("endservent not implemented!\n");
588 }
589
590
591 struct netent *
592 win32_getnetent(void) 
593 {
594     dTHXo;
595     Perl_croak_nocontext("getnetent not implemented!\n");
596     return (struct netent *) NULL;
597 }
598
599 struct netent *
600 win32_getnetbyname(char *name) 
601 {
602     dTHXo;
603     Perl_croak_nocontext("getnetbyname not implemented!\n");
604     return (struct netent *)NULL;
605 }
606
607 struct netent *
608 win32_getnetbyaddr(long net, int type) 
609 {
610     dTHXo;
611     Perl_croak_nocontext("getnetbyaddr not implemented!\n");
612     return (struct netent *)NULL;
613 }
614
615 struct protoent *
616 win32_getprotoent(void) 
617 {
618     dTHXo;
619     Perl_croak_nocontext("getprotoent not implemented!\n");
620     return (struct protoent *) NULL;
621 }
622
623 struct servent *
624 win32_getservent(void) 
625 {
626     dTHXo;
627     Perl_croak_nocontext("getservent not implemented!\n");
628     return (struct servent *) NULL;
629 }
630
631 void
632 win32_sethostent(int stayopen)
633 {
634     dTHXo;
635     Perl_croak_nocontext("sethostent not implemented!\n");
636 }
637
638
639 void
640 win32_setnetent(int stayopen)
641 {
642     dTHXo;
643     Perl_croak_nocontext("setnetent not implemented!\n");
644 }
645
646
647 void
648 win32_setprotoent(int stayopen)
649 {
650     dTHXo;
651     Perl_croak_nocontext("setprotoent not implemented!\n");
652 }
653
654
655 void
656 win32_setservent(int stayopen)
657 {
658     dTHXo;
659     Perl_croak_nocontext("setservent not implemented!\n");
660 }
661
662 static struct servent*
663 win32_savecopyservent(struct servent*d, struct servent*s, const char *proto)
664 {
665     d->s_name = s->s_name;
666     d->s_aliases = s->s_aliases;
667     d->s_port = s->s_port;
668 #ifndef __BORLANDC__    /* Buggy on Win95 and WinNT-with-Borland-WSOCK */
669     if (!IsWin95() && s->s_proto && strlen(s->s_proto))
670         d->s_proto = s->s_proto;
671     else
672 #endif
673     if (proto && strlen(proto))
674         d->s_proto = (char *)proto;
675     else
676         d->s_proto = "tcp";
677    
678     return d;
679 }
680
681