This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Re: Merge WinCE into Win32 directory and remove the the WinCE directory
[perl5.git] / win32 / wincesck.c
1 /* Time-stamp: <01/08/01 21:01:12 keuchel@w2k> */
2
3 /* wincesck.c
4  *
5  * (c) 1995 Microsoft Corporation. All rights reserved.
6  *              Developed by hip communications inc., http://info.hip.com/info/
7  * Portions (c) 1993 Intergraph Corporation. All rights reserved.
8  *
9  *    You may distribute under the terms of either the GNU General Public
10  *    License or the Artistic License, as specified in the README file.
11  */
12
13 /* The socket calls use fd functions from celib... */
14
15 #define WIN32IO_IS_STDIO
16 #define WIN32SCK_IS_STDSCK
17 #define WIN32_LEAN_AND_MEAN
18
19 #ifdef __GNUC__
20 #define Win32_Winsock
21 #endif
22
23 #include <windows.h>
24
25 #define wince_private
26 #include "errno.h"
27
28 #include "EXTERN.h"
29 #include "perl.h"
30
31 #include "Win32iop.h"
32 #include <sys/socket.h>
33
34 #ifndef UNDER_CE
35 #include <fcntl.h>
36 #include <sys/stat.h>
37 #include <assert.h>
38 #include <io.h>
39 #endif
40
41 #ifdef UNDER_CE
42
43 XCE_EXPORT struct servent *xcegetservbyname(const char *sname, const char *sproto);
44 XCE_EXPORT struct servent * xcegetservbyport(int aport, const char *sproto);
45 XCE_EXPORT struct protoent *xcegetprotobyname(const char *name);
46 XCE_EXPORT struct protoent *xcegetprotobynumber(int number);
47
48 #define getservbyname xcegetservbyname
49 #define getservbyport xcegetservbyport
50 #define getprotobyname xcegetprotobyname
51 #define getprotobynumber xcegetprotobynumber
52
53 /* uses fdtab... */
54 #include "cesocket2.h"
55
56 #endif
57
58 #define TO_SOCKET(X) (X)
59
60 #define StartSockets() \
61     STMT_START {                                        \
62         if (!wsock_started) {                           \
63             start_sockets();                            \
64             set_socktype();                             \
65         }                                               \
66     } STMT_END
67
68 #define SOCKET_TEST(x, y) \
69     STMT_START {                                        \
70         StartSockets();                                 \
71         if((x) == (y))                                  \
72             errno = WSAGetLastError();                  \
73     } STMT_END
74
75 #define SOCKET_TEST_ERROR(x) SOCKET_TEST(x, SOCKET_ERROR)
76
77 static struct servent* win32_savecopyservent(struct servent*d,
78                                              struct servent*s,
79                                              const char *proto);
80
81 static int wsock_started = 0;
82
83 EXTERN_C void
84 EndSockets(void)
85 {
86     if (wsock_started)
87         WSACleanup();
88 }
89
90 void
91 start_sockets(void)
92 {
93     dTHX;
94     unsigned short version;
95     WSADATA retdata;
96     int ret;
97
98     /*
99      * initalize the winsock interface and insure that it is
100      * cleaned up at exit.
101      */
102     version = 0x101;
103     if(ret = WSAStartup(version, &retdata))
104         Perl_croak_nocontext("Unable to locate winsock library!\n");
105     if(retdata.wVersion != version)
106         Perl_croak_nocontext("Could not find version 1.1 of winsock dll\n");
107
108     /* atexit((void (*)(void)) EndSockets); */
109     wsock_started = 1;
110 }
111
112 void
113 set_socktype(void)
114 {
115 }
116
117 u_long
118 win32_htonl(u_long hostlong)
119 {
120     StartSockets();
121     return htonl(hostlong);
122 }
123
124 u_short
125 win32_htons(u_short hostshort)
126 {
127     StartSockets();
128     return htons(hostshort);
129 }
130
131 u_long
132 win32_ntohl(u_long netlong)
133 {
134     StartSockets();
135     return ntohl(netlong);
136 }
137
138 u_short
139 win32_ntohs(u_short netshort)
140 {
141     StartSockets();
142     return ntohs(netshort);
143 }
144
145 SOCKET
146 win32_socket(int af, int type, int protocol)
147 {
148   StartSockets();
149   return xcesocket(af, type, protocol);
150 }
151
152 SOCKET
153 win32_accept(SOCKET s, struct sockaddr *addr, int *addrlen)
154 {
155   StartSockets();
156   return xceaccept(s, addr, addrlen);
157 }
158
159 int
160 win32_bind(SOCKET s, const struct sockaddr *addr, int addrlen)
161 {
162   StartSockets();
163   return xcebind(s, addr, addrlen);
164 }
165
166 int
167 win32_connect(SOCKET s, const struct sockaddr *addr, int addrlen)
168 {
169   StartSockets();
170   return xceconnect(s, addr, addrlen);
171 }
172
173
174 int
175 win32_getpeername(SOCKET s, struct sockaddr *addr, int *addrlen)
176 {
177   StartSockets();
178   return xcegetpeername(s, addr, addrlen);
179 }
180
181 int
182 win32_getsockname(SOCKET s, struct sockaddr *addr, int *addrlen)
183 {
184   StartSockets();
185   return xcegetsockname(s, addr, addrlen);
186 }
187
188 int
189 win32_getsockopt(SOCKET s, int level, int optname, char *optval, int *optlen)
190 {
191   StartSockets();
192   return xcegetsockopt(s, level, optname, optval, optlen);
193 }
194
195 int
196 win32_ioctlsocket(SOCKET s, long cmd, u_long *argp)
197 {
198   StartSockets();
199   return xceioctlsocket(s, cmd, argp);
200 }
201
202 int
203 win32_listen(SOCKET s, int backlog)
204 {
205   StartSockets();
206   return xcelisten(s, backlog);
207 }
208
209 int
210 win32_recv(SOCKET s, char *buf, int len, int flags)
211 {
212   StartSockets();
213   return xcerecv(s, buf, len, flags);
214 }
215
216 int
217 win32_recvfrom(SOCKET s, char *buf, int len, int flags,
218                struct sockaddr *from, int *fromlen)
219 {
220   StartSockets();
221   return xcerecvfrom(s, buf, len, flags, from, fromlen);
222 }
223
224 int
225 win32_select(int nfds, Perl_fd_set* rd, Perl_fd_set* wr,
226              Perl_fd_set* ex, const struct timeval* timeout)
227 {
228   StartSockets();
229   /* select not yet fixed */
230   errno = ENOSYS;
231   return -1;
232 }
233
234 int
235 win32_send(SOCKET s, const char *buf, int len, int flags)
236 {
237   StartSockets();
238   return xcesend(s, buf, len, flags);
239 }
240
241 int
242 win32_sendto(SOCKET s, const char *buf, int len, int flags,
243              const struct sockaddr *to, int tolen)
244 {
245   StartSockets();
246   return xcesendto(s, buf, len, flags, to, tolen);
247 }
248
249 int
250 win32_setsockopt(SOCKET s, int level, int optname,
251                  const char *optval, int optlen)
252 {
253   StartSockets();
254   return xcesetsockopt(s, level, optname, optval, optlen);
255 }
256
257 int
258 win32_shutdown(SOCKET s, int how)
259 {
260   StartSockets();
261   return xceshutdown(s, how);
262 }
263
264 int
265 win32_closesocket(SOCKET s)
266 {
267   StartSockets();
268   return xceclosesocket(s);
269 }
270
271 struct hostent *
272 win32_gethostbyaddr(const char *addr, int len, int type)
273 {
274   struct hostent *r;
275
276   SOCKET_TEST(r = gethostbyaddr(addr, len, type), NULL);
277   return r;
278 }
279
280 struct hostent *
281 win32_gethostbyname(const char *name)
282 {
283   struct hostent *r;
284
285   SOCKET_TEST(r = gethostbyname(name), NULL);
286   return r;
287 }
288
289 int
290 win32_gethostname(char *name, int len)
291 {
292   int r;
293
294   SOCKET_TEST_ERROR(r = gethostname(name, len));
295   return r;
296 }
297
298 struct protoent *
299 win32_getprotobyname(const char *name)
300 {
301     struct protoent *r;
302
303     SOCKET_TEST(r = getprotobyname(name), NULL);
304     return r;
305 }
306
307 struct protoent *
308 win32_getprotobynumber(int num)
309 {
310     struct protoent *r;
311
312     SOCKET_TEST(r = getprotobynumber(num), NULL);
313     return r;
314 }
315
316 struct servent *
317 win32_getservbyname(const char *name, const char *proto)
318 {
319     dTHX;
320     struct servent *r;
321
322     SOCKET_TEST(r = getservbyname(name, proto), NULL);
323     if (r) {
324         r = win32_savecopyservent(&w32_servent, r, proto);
325     }
326     return r;
327 }
328
329 struct servent *
330 win32_getservbyport(int port, const char *proto)
331 {
332     dTHX;
333     struct servent *r;
334
335     SOCKET_TEST(r = getservbyport(port, proto), NULL);
336     if (r) {
337         r = win32_savecopyservent(&w32_servent, r, proto);
338     }
339     return r;
340 }
341
342 int
343 win32_ioctl(int i, unsigned int u, char *data)
344 {
345     dTHX;
346     u_long argp = (u_long)data;
347     int retval;
348
349     if (!wsock_started) {
350         Perl_croak_nocontext("ioctl implemented only on sockets");
351         /* NOTREACHED */
352     }
353
354     retval = ioctlsocket(TO_SOCKET(i), (long)u, &argp);
355     if (retval == SOCKET_ERROR) {
356         if (WSAGetLastError() == WSAENOTSOCK) {
357             Perl_croak_nocontext("ioctl implemented only on sockets");
358             /* NOTREACHED */
359         }
360         errno = WSAGetLastError();
361     }
362     return retval;
363 }
364
365 char FAR *
366 win32_inet_ntoa(struct in_addr in)
367 {
368     StartSockets();
369     return inet_ntoa(in);
370 }
371
372 unsigned long
373 win32_inet_addr(const char FAR *cp)
374 {
375     StartSockets();
376     return inet_addr(cp);
377 }
378
379 /*
380  * Networking stubs
381  */
382
383 void
384 win32_endhostent()
385 {
386     dTHX;
387     Perl_croak_nocontext("endhostent not implemented!\n");
388 }
389
390 void
391 win32_endnetent()
392 {
393     dTHX;
394     Perl_croak_nocontext("endnetent not implemented!\n");
395 }
396
397 void
398 win32_endprotoent()
399 {
400     dTHX;
401     Perl_croak_nocontext("endprotoent not implemented!\n");
402 }
403
404 void
405 win32_endservent()
406 {
407     dTHX;
408     Perl_croak_nocontext("endservent not implemented!\n");
409 }
410
411
412 struct netent *
413 win32_getnetent(void)
414 {
415     dTHX;
416     Perl_croak_nocontext("getnetent not implemented!\n");
417     return (struct netent *) NULL;
418 }
419
420 struct netent *
421 win32_getnetbyname(char *name)
422 {
423     dTHX;
424     Perl_croak_nocontext("getnetbyname not implemented!\n");
425     return (struct netent *)NULL;
426 }
427
428 struct netent *
429 win32_getnetbyaddr(long net, int type)
430 {
431     dTHX;
432     Perl_croak_nocontext("getnetbyaddr not implemented!\n");
433     return (struct netent *)NULL;
434 }
435
436 struct protoent *
437 win32_getprotoent(void)
438 {
439     dTHX;
440     Perl_croak_nocontext("getprotoent not implemented!\n");
441     return (struct protoent *) NULL;
442 }
443
444 struct servent *
445 win32_getservent(void)
446 {
447     dTHX;
448     Perl_croak_nocontext("getservent not implemented!\n");
449     return (struct servent *) NULL;
450 }
451
452 void
453 win32_sethostent(int stayopen)
454 {
455     dTHX;
456     Perl_croak_nocontext("sethostent not implemented!\n");
457 }
458
459
460 void
461 win32_setnetent(int stayopen)
462 {
463     dTHX;
464     Perl_croak_nocontext("setnetent not implemented!\n");
465 }
466
467
468 void
469 win32_setprotoent(int stayopen)
470 {
471     dTHX;
472     Perl_croak_nocontext("setprotoent not implemented!\n");
473 }
474
475
476 void
477 win32_setservent(int stayopen)
478 {
479     dTHX;
480     Perl_croak_nocontext("setservent not implemented!\n");
481 }
482
483 static struct servent*
484 win32_savecopyservent(struct servent*d, struct servent*s, const char *proto)
485 {
486     d->s_name = s->s_name;
487     d->s_aliases = s->s_aliases;
488     d->s_port = s->s_port;
489 #ifndef __BORLANDC__    /* Buggy on Win95 and WinNT-with-Borland-WSOCK */
490     if (!IsWin95() && s->s_proto && strlen(s->s_proto))
491         d->s_proto = s->s_proto;
492     else
493 #endif
494     if (proto && strlen(proto))
495         d->s_proto = (char *)proto;
496     else
497         d->s_proto = "tcp";
498
499     return d;
500 }