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