Debian Codegraph @

src/net.c

raw
1 /*
2 * net.c - network interface
3 *
4 * Copyright (c) 2000-2024 Shiro Kawai <[email protected]>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * 3. Neither the name of the authors nor the names of its contributors
18 * may be used to endorse or promote products derived from this
19 * software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #define LIBGAUCHE_BODY
35 #include "gauche.h"
36 #include "gauche/priv/configP.h"
37 #include "gauche/net.h"
38 #include <fcntl.h>
39
40 /*==================================================================
41 * Socket
42 */
43
44 ScmClass *socket_cpl[] = {
45 SCM_CLASS_STATIC_PTR(Scm_ConnectionClass),
46 SCM_CLASS_STATIC_PTR(Scm_TopClass),
47 NULL
48 };
49
50 static void socket_print(ScmObj obj, ScmPort *port, ScmWriteContext *ctx);
51
52 SCM_DEFINE_BUILTIN_CLASS(Scm_SocketClass, socket_print, NULL, NULL, NULL,
53 socket_cpl);
54
55 static void socket_finalize(ScmObj obj, void *data SCM_UNUSED)
56 {
57 ScmSocket *sock = (ScmSocket*)obj;
58 /* NB: at this point, sock->inPort and sock->outPort may already
59 be GC-ed and finalized, so we don't flush them here.
60 Clearing them would help them to be collected earlier, though. */
61 if (!(SOCKET_CLOSED(sock->fd))) {
62 #if defined(GAUCHE_WINDOWS)
63 if (sock->cfd >= 0) { close(sock->cfd); sock->cfd = -1; }
64 #endif /*GAUCHE_WINDOWS*/
65 closeSocket(sock->fd);
66 sock->fd = INVALID_SOCKET;
67 sock->status = SCM_SOCKET_STATUS_CLOSED;
68 sock->inPort = NULL;
69 sock->outPort = NULL;
70 }
71 }
72
73 static void socket_print(ScmObj obj, ScmPort *port,
74 ScmWriteContext *ctx SCM_UNUSED)
75 {
76 ScmSocket *sock = SCM_SOCKET(obj);
77 Scm_Printf(port, "#<socket");
78 switch (sock->status) {
79 case SCM_SOCKET_STATUS_NONE:
80 break;
81 case SCM_SOCKET_STATUS_BOUND:
82 Scm_Printf(port, " (bound %S)", Scm_SockAddrName(sock->address));
83 break;
84 case SCM_SOCKET_STATUS_LISTENING:
85 Scm_Printf(port, " (listen %S)", Scm_SockAddrName(sock->address));
86 break;
87 case SCM_SOCKET_STATUS_CONNECTED:
88 Scm_Printf(port, " (connect %S)", Scm_SockAddrName(sock->address));
89 break;
90 case SCM_SOCKET_STATUS_SHUTDOWN:
91 Scm_Printf(port, " (shutdown)");
92 break;
93 case SCM_SOCKET_STATUS_CLOSED:
94 Scm_Printf(port, " (closed)");
95 break;
96 default:
97 Scm_Printf(port, " (unknown status)");
98 break;
99 }
100 Scm_Printf(port, ">");
101 }
102
103 ScmSocket *make_socket(Socket fd, int type)
104 {
105 ScmSocket *s = SCM_NEW(ScmSocket);
106 SCM_SET_CLASS(s, SCM_CLASS_SOCKET);
107 s->fd = fd;
108 s->status = SCM_SOCKET_STATUS_NONE;
109 s->inPort = s->outPort = NULL;
110 s->address = NULL;
111 s->name = NULL;
112 s->type = type;
113 #if defined(GAUCHE_WINDOWS)
114 s->cfd = -1;
115 #endif /*GAUCHE_WINDOWS*/
116 Scm_RegisterFinalizer(SCM_OBJ(s), socket_finalize, NULL);
117 return s;
118 }
119
120 ScmObj Scm_MakeSocket(int domain, int type, int protocol)
121 {
122 intptr_t sock;
123 #if GAUCHE_WINDOWS
124 /* On Windows, sockets created by socket() call sets
125 WSA_FLAG_OVERLAPPED flag. When used in threads other than
126 primordial thread, I/O to/from such socket fails, since it
127 requires extra OVERLAPPED struct in win32 call (which can't
128 be done with POSIX calls). Directly using WSASocket allows
129 us to not set WSA_FLAG_OVERLAPPED flag. */
130 SCM_SYSCALL(sock, WSASocket(domain, type, protocol, NULL, 0, 0));
131 #else /*!GAUCHE_WINDOWS*/
132 SCM_SYSCALL(sock, socket(domain, type, protocol));
133 #endif /*!GAUCHE_WINDOWS*/
134 if (SOCKET_INVALID(sock)) Scm_SysError("couldn't create socket");
135 return SCM_OBJ(make_socket((Socket)sock, type));
136 }
137
138 ScmObj Scm_SocketShutdown(ScmSocket *s, int how)
139 {
140 int r;
141 if (s->status != SCM_SOCKET_STATUS_CONNECTED) {
142 return SCM_FALSE;
143 }
144 SCM_SYSCALL(r, shutdown(s->fd, how));
145 if (r < 0) {
146 Scm_SysError("socket shutdown failed for %S", SCM_OBJ(s));
147 }
148 s->status = SCM_SOCKET_STATUS_SHUTDOWN;
149 return SCM_TRUE;
150 }
151
152 ScmObj Scm_SocketClose(ScmSocket *s)
153 {
154 if (s->status == SCM_SOCKET_STATUS_CLOSED) {
155 return SCM_FALSE;
156 }
157 /* We don't shutdown the connection; forked process may have
158 reference to the same socket. */
159 /* Clearing inPort/outPort helps them to be collected earlier. */
160 if (s->inPort) {
161 Scm_ClosePort(s->inPort); /* ignore errors */
162 s->inPort = NULL;
163 }
164 if (s->outPort) {
165 Scm_ClosePort(s->outPort); /* ignore errors */
166 s->outPort = NULL;
167 }
168 #if defined(GAUCHE_WINDOWS)
169 if (s->cfd >= 0) { close(s->cfd); s->cfd = -1; }
170 #endif /*GAUCHE_WINDOWS*/
171 closeSocket(s->fd);
172 s->fd = INVALID_SOCKET;
173 s->status = SCM_SOCKET_STATUS_CLOSED;
174 return SCM_TRUE;
175 }
176
177 static void sockport_err(ScmSocket *sock, const char *io)
178 {
179 Scm_Error("attempt to obtain an %s port from unconnected or closed socket: %S",
180 io, sock);
181 }
182
183
184 ScmObj Scm_SocketInputPort(ScmSocket *sock, int buffering)
185 {
186 if (sock->inPort == NULL) {
187 int infd;
188 if (sock->type != SOCK_DGRAM &&
189 sock->status < SCM_SOCKET_STATUS_CONNECTED) {
190 sockport_err(sock, "input");
191 }
192 #ifndef GAUCHE_WINDOWS
193 infd = sock->fd;
194 #else /*GAUCHE_WINDOWS*/
195 /* cfd will be closed when this socket is closed. */
196 if (sock->cfd < 0) {
197 sock->cfd = _open_osfhandle(sock->fd, 0);
198 }
199 infd = sock->cfd;
200 #endif /*GAUCHE_WINDOWS*/
201 if (SOCKET_INVALID(infd)) sockport_err(sock, "input");
202
203 /* NB: I keep the socket itself in the port name, in order to avoid
204 the socket from GCed prematurely if application doesn't keep
205 pointer to the socket. */
206 ScmObj sockname = SCM_LIST2(SCM_MAKE_STR("socket input"),
207 SCM_OBJ(sock));
208 sock->inPort = SCM_PORT(Scm_MakePortWithFd(sockname, SCM_PORT_INPUT,
209 infd, buffering, FALSE));
210 }
211 return SCM_OBJ(sock->inPort);
212 }
213
214 ScmObj Scm_SocketOutputPort(ScmSocket *sock, int buffering)
215 {
216 if (sock->outPort == NULL) {
217 int outfd;
218 if (sock->type != SOCK_DGRAM &&
219 sock->status < SCM_SOCKET_STATUS_CONNECTED) {
220 sockport_err(sock, "output");
221 }
222 #ifndef GAUCHE_WINDOWS
223 outfd = sock->fd;
224 #else /*GAUCHE_WINDOWS*/
225 /* cfd will be closed when this socket is closed. */
226 if (sock->cfd < 0) {
227 sock->cfd = _open_osfhandle(sock->fd, 0);
228 }
229 outfd = sock->cfd;
230 #endif /*GAUCHE_WINDOWS*/
231 if (SOCKET_INVALID(outfd)) sockport_err(sock, "output");
232
233 /* NB: I keep the socket itself in the port name, in order to avoid
234 the socket from GCed prematurely if application doesn't keep
235 pointer to the socket. */
236 ScmObj sockname = SCM_LIST2(SCM_MAKE_STR("socket output"),
237 SCM_OBJ(sock));
238 sock->outPort = SCM_PORT(Scm_MakePortWithFd(sockname, SCM_PORT_OUTPUT,
239 outfd, buffering, FALSE));
240 }
241 return SCM_OBJ(sock->outPort);
242 }
243
244 /*==================================================================
245 * Low-level library
246 */
247
248 #define CLOSE_CHECK(fd, op, s) \
249 do { \
250 if (SOCKET_CLOSED(fd)) { \
251 Scm_Error("attempt to %s a closed socket: %S", op, s); \
252 } \
253 } while (0)
254
255 ScmObj Scm_SocketBind(ScmSocket *sock, ScmSockAddr *addr)
256 {
257 int r;
258 CLOSE_CHECK(sock->fd, "bind", sock);
259 SCM_SYSCALL(r, bind(sock->fd, &addr->addr, addr->addrlen));
260 if (r < 0) {
261 Scm_SysError("bind failed to %S", addr);
262 }
263 /* The system may assign different address than <addr>, especially when
264 <addr> contains some 'wild card' (e.g. port=0). We call getsockname
265 to obtain the exact address. Patch provided by ODA Hideo */
266 ScmSockAddr *naddr = SCM_SOCKADDR(
267 Scm_MakeSockAddr(SCM_CLASS_OF(addr), &addr->addr, addr->addrlen));
268 SCM_SYSCALL(r, getsockname(sock->fd, &naddr->addr, &naddr->addrlen));
269 if (r < 0) {
270 Scm_SysError("getsockname failed to %S", addr);
271 }
272 sock->address = naddr;
273 sock->status = SCM_SOCKET_STATUS_BOUND;
274 return SCM_OBJ(sock);
275 }
276
277 ScmObj Scm_SocketListen(ScmSocket *sock, int backlog)
278 {
279 int r;
280 CLOSE_CHECK(sock->fd, "listen to", sock);
281 SCM_SYSCALL(r, listen(sock->fd, backlog));
282 if (r < 0) {
283 Scm_SysError("listen(2) failed");
284 }
285 sock->status = SCM_SOCKET_STATUS_LISTENING;
286 return SCM_OBJ(sock);
287 }
288
289 ScmObj Scm_SocketAccept(ScmSocket *sock)
290 {
291 Socket newfd;
292 struct sockaddr_storage addrbuf;
293 socklen_t addrlen = sizeof(addrbuf);
294 ScmClass *addrClass = Scm_ClassOf(SCM_OBJ(sock->address));
295
296 CLOSE_CHECK(sock->fd, "accept from", sock);
297 #if defined(GAUCHE_WINDOWS)
298 SCM_SYSCALL3(newfd, accept(sock->fd, (struct sockaddr*)&addrbuf, &addrlen),
299 SOCKET_INVALID(newfd));
300 #else /* !GAUCHE_WINDOWS */
301 SCM_SYSCALL(newfd, accept(sock->fd, (struct sockaddr*)&addrbuf, &addrlen));
302 #endif /* !GAUCHE_WINDOWS */
303 if (SOCKET_INVALID(newfd)) {
304 if (errno == EAGAIN) {
305 return SCM_FALSE;
306 } else {
307 Scm_SysError("accept(2) failed");
308 }
309 }
310 ScmSocket *newsock = make_socket(newfd, sock->type);
311 newsock->address =
312 SCM_SOCKADDR(Scm_MakeSockAddr(addrClass,
313 (struct sockaddr*)&addrbuf,
314 addrlen));
315 newsock->status = SCM_SOCKET_STATUS_CONNECTED;
316 return SCM_OBJ(newsock);
317 }
318
319 ScmObj Scm_SocketConnect(ScmSocket *sock, ScmSockAddr *addr)
320 {
321 int r;
322 CLOSE_CHECK(sock->fd, "connect to", sock);
323 SCM_SYSCALL(r, connect(sock->fd, &addr->addr, addr->addrlen));
324 if (r < 0) {
325 Scm_SysError("connect failed to %S", addr);
326 }
327 sock->address = addr;
328 sock->status = SCM_SOCKET_STATUS_CONNECTED;
329 return SCM_OBJ(sock);
330 }
331
332 ScmObj Scm_GetSockName(int fd)
333 {
334 int r;
335 struct sockaddr_storage addrbuf;
336 socklen_t addrlen = sizeof(addrbuf);
337
338 SCM_SYSCALL(r, getsockname(fd, (struct sockaddr*)&addrbuf, &addrlen));
339 if (r < 0) {
340 Scm_SysError("getsockname(2) failed");
341 }
342 return SCM_OBJ(Scm_MakeSockAddr(NULL, (struct sockaddr*)&addrbuf, addrlen));
343 }
344
345 ScmObj Scm_SocketGetSockName(ScmSocket *sock)
346 {
347 CLOSE_CHECK(sock->fd, "get the name of", sock);
348 return Scm_GetSockName(sock->fd);
349 }
350
351 ScmObj Scm_GetPeerName(int fd)
352 {
353 int r;
354 struct sockaddr_storage addrbuf;
355 socklen_t addrlen = sizeof(addrbuf);
356
357 SCM_SYSCALL(r, getpeername(fd, (struct sockaddr*)&addrbuf, &addrlen));
358 if (r < 0) {
359 Scm_SysError("getpeername(2) failed");
360 }
361 return SCM_OBJ(Scm_MakeSockAddr(NULL, (struct sockaddr*)&addrbuf, addrlen));
362 }
363
364 ScmObj Scm_SocketGetPeerName(ScmSocket *sock)
365 {
366 CLOSE_CHECK(sock->fd, "get the peer name of", sock);
367 return Scm_GetPeerName(sock->fd);
368 }
369
370 static const char *get_message_body(ScmObj msg, ScmSmallInt *size)
371 {
372 if (SCM_UVECTORP(msg)) {
373 *size = Scm_UVectorSizeInBytes(SCM_UVECTOR(msg));
374 return (const char*)SCM_UVECTOR_ELEMENTS(msg);
375 } else if (SCM_STRINGP(msg)) {
376 return Scm_GetStringContent(SCM_STRING(msg), size, NULL, NULL);
377 } else {
378 Scm_TypeError("socket message", "uniform vector or string", msg);
379 *size = 0; /* dummy */
380 return NULL;
381 }
382 }
383
384 ScmObj Scm_SocketSend(ScmSocket *sock, ScmObj msg, int flags)
385 {
386 int r;
387 ScmSmallInt size;
388 CLOSE_CHECK(sock->fd, "send to", sock);
389 const char *cmsg = get_message_body(msg, &size);
390 SCM_SYSCALL(r, send(sock->fd, cmsg, size, flags));
391 if (r < 0) Scm_SysError("send(2) failed");
392 return SCM_MAKE_INT(r);
393 }
394
395 ScmObj Scm_SocketSendTo(ScmSocket *sock, ScmObj msg, ScmSockAddr *to,
396 int flags)
397 {
398 int r;
399 ScmSmallInt size;
400 CLOSE_CHECK(sock->fd, "send to", sock);
401 const char *cmsg = get_message_body(msg, &size);
402 SCM_SYSCALL(r, sendto(sock->fd, cmsg, size, flags,
403 &SCM_SOCKADDR(to)->addr, SCM_SOCKADDR(to)->addrlen));
404 if (r < 0) Scm_SysError("sendto(2) failed");
405 return SCM_MAKE_INT(r);
406 }
407
408 ScmObj Scm_SocketSendMsg(ScmSocket *sock, ScmObj msg, int flags)
409 {
410 #if !GAUCHE_WINDOWS
411 int r;
412 ScmSmallInt size;
413 CLOSE_CHECK(sock->fd, "send to", sock);
414 const char *cmsg = get_message_body(msg, &size);
415 SCM_SYSCALL(r, sendmsg(sock->fd, (struct msghdr*)cmsg, flags));
416 if (r < 0) Scm_SysError("sendmsg(2) failed");
417 return SCM_MAKE_INT(r);
418 #else /*GAUCHE_WINDOWS*/
419 (void)sock; /* suppress unused var warning */
420 (void)msg; /* suppress unused var warning */
421 (void)flags; /* suppress unused var warning */
422 Scm_Error("sendmsg is not implemented on this platform.");
423 return SCM_UNDEFINED; /* dummy */
424 #endif /*GAUCHE_WINDOWS*/
425 }
426
427 ScmObj Scm_SocketRecv(ScmSocket *sock, int bytes, int flags)
428 {
429 int r;
430 CLOSE_CHECK(sock->fd, "recv from", sock);
431 char *buf = SCM_NEW_ATOMIC2(char*, bytes);
432 SCM_SYSCALL(r, recv(sock->fd, buf, bytes, flags));
433 if (r < 0) {
434 Scm_SysError("recv(2) failed");
435 }
436 return Scm_MakeString(buf, r, r, SCM_STRING_INCOMPLETE);
437 }
438
439 static char *get_message_buffer(ScmUVector *v, u_int *size)
440 {
441 if (SCM_UVECTOR_IMMUTABLE_P(v)) {
442 Scm_Error("attempted to use an immutable uniform vector as a buffer");
443 }
444 *size = Scm_UVectorSizeInBytes(v);
445 return (char *)SCM_UVECTOR_ELEMENTS(v);
446 }
447
448 ScmObj Scm_SocketRecvX(ScmSocket *sock, ScmUVector *buf, int flags)
449 {
450 int r;
451 u_int size;
452 CLOSE_CHECK(sock->fd, "recv from", sock);
453 char *z = get_message_buffer(buf, &size);
454 SCM_SYSCALL(r, recv(sock->fd, z, size, flags));
455 if (r < 0) {
456 Scm_SysError("recv(2) failed");
457 }
458 return Scm_MakeInteger(r);
459 }
460
461 ScmObj Scm_SocketRecvFrom(ScmSocket *sock, int bytes, int flags)
462 {
463 int r;
464 struct sockaddr_storage from;
465 socklen_t fromlen = sizeof(from);
466 CLOSE_CHECK(sock->fd, "recv from", sock);
467 char *buf = SCM_NEW_ATOMIC2(char*, bytes);
468 SCM_SYSCALL(r, recvfrom(sock->fd, buf, bytes, flags,
469 (struct sockaddr*)&from, &fromlen));
470 if (r < 0) {
471 Scm_SysError("recvfrom(2) failed");
472 }
473 return Scm_Values2(Scm_MakeString(buf, r, r, SCM_STRING_INCOMPLETE),
474 Scm_MakeSockAddr(NULL, (struct sockaddr*)&from, fromlen));
475 }
476
477 /* ADDRS is a list of socket addresses; if 'from' address type matches
478 one of them, it is used to store the information so that we can avoid
479 allocation. If no addresses match the incoming type, and ADDRS is
480 a complete list, the information of 'from' is discarded. If no addresses
481 match the incoming type, and the last cdr of ADDRS is #t (this case
482 includes ADDRS == #t), a new sockaddr is allocated and returned. */
483 ScmObj Scm_SocketRecvFromX(ScmSocket *sock, ScmUVector *buf,
484 ScmObj addrs, int flags)
485 {
486 int r;
487 u_int size;
488 struct sockaddr_storage from;
489 socklen_t fromlen = sizeof(from);
490 ScmObj addr = SCM_FALSE;
491
492 CLOSE_CHECK(sock->fd, "recv from", sock);
493 char *z = get_message_buffer(buf, &size);
494 SCM_SYSCALL(r, recvfrom(sock->fd, z, size, flags,
495 (struct sockaddr*)&from, &fromlen));
496 if (r < 0) {
497 Scm_SysError("recvfrom(2) failed");
498 }
499 ScmObj cp;
500 SCM_FOR_EACH(cp, addrs) {
501 ScmObj a = SCM_CAR(cp);
502 if (Scm_SockAddrP(a)) {
503 if (SCM_SOCKADDR_FAMILY(a) == from.ss_family) {
504 memcpy(&SCM_SOCKADDR(a)->addr, &from, SCM_SOCKADDR(a)->addrlen);
505 addr = a;
506 break;
507 }
508 }
509 }
510 if (SCM_FALSEP(addr) && SCM_EQ(cp, SCM_TRUE)) {
511 /* Allocate sockaddr */
512 addr = Scm_MakeSockAddr(NULL, (struct sockaddr*)&from, fromlen);
513 }
514 return Scm_Values2(Scm_MakeInteger(r), addr);
515 }
516
517 /* Low level message builder */
518 ScmObj Scm_SocketBuildMsg(ScmSockAddr *name, ScmVector *iov,
519 ScmObj control, int flags,
520 ScmUVector *buf)
521 {
522 #if !GAUCHE_WINDOWS
523 struct msghdr *msg;
524 ScmSize bufsiz = 0;
525 char *bufptr = 0;
526
527 if (buf != NULL) {
528 bufsiz = Scm_UVectorSizeInBytes(buf);
529 bufptr = (char*)SCM_UVECTOR_ELEMENTS(buf);
530 }
531
532 if (bufsiz >= (ScmSize)sizeof(struct msghdr)) {
533 msg = (struct msghdr*)bufptr;
534 bufptr += sizeof(struct msghdr); bufsiz -= sizeof(struct msghdr);
535 } else {
536 msg = SCM_NEW(struct msghdr);
537 }
538
539 if (name != NULL) {
540 msg->msg_name = &name->addr;
541 msg->msg_namelen = name->addrlen;
542 } else {
543 msg->msg_name = NULL;
544 msg->msg_namelen = 0;
545 }
546
547 if (iov != NULL) {
548 int iovsiz = SCM_VECTOR_SIZE(iov) * sizeof(struct iovec);
549 msg->msg_iovlen = SCM_VECTOR_SIZE(iov);
550 if (bufsiz >= iovsiz) {
551 msg->msg_iov = (struct iovec*)bufptr;
552 bufptr += iovsiz; bufsiz -= iovsiz;
553 } else {
554 msg->msg_iov = SCM_NEW_ARRAY(struct iovec, msg->msg_iovlen);
555 }
556 for (ScmSize i=0; i < (ScmSize)msg->msg_iovlen; i++) {
557 ScmObj elt = SCM_VECTOR_ELEMENT(iov, i);
558 ScmSmallInt iovlen;
559 msg->msg_iov[i].iov_base = (char*)get_message_body(elt, &iovlen);
560 msg->msg_iov[i].iov_len = iovlen;
561 }
562 } else {
563 msg->msg_iov = NULL;
564 msg->msg_iovlen = 0;
565 }
566
567 if (SCM_PAIRP(control)) {
568 ScmObj cp;
569 int ctrllen = 0;
570
571 SCM_FOR_EACH(cp, control) {
572 ScmSmallInt clen;
573 ScmObj c = SCM_CAR(cp);
574 if (!(Scm_Length(c) == 3
575 && SCM_INTP(SCM_CAR(c))
576 && SCM_INTP(SCM_CADR(c))
577 && (SCM_STRINGP(SCM_CAR(SCM_CDDR(c)))
578 || SCM_U8VECTORP(SCM_CAR(SCM_CDDR(c)))))) {
579 Scm_Error("socket-buildmsg: invalid control message spec: %S", c);
580 }
581 (void)get_message_body(SCM_CAR(SCM_CDDR(c)), &clen);
582 ctrllen += CMSG_SPACE(clen);
583 }
584 msg->msg_controllen = ctrllen;
585 if (bufsiz >= ctrllen) {
586 msg->msg_control = bufptr;
587 } else {
588 msg->msg_control = SCM_NEW_ATOMIC_ARRAY(char, ctrllen);
589 }
590 struct cmsghdr *cmsg = CMSG_FIRSTHDR(msg);
591 SCM_FOR_EACH(cp, control) {
592 ScmSmallInt clen;
593 ScmObj c = SCM_CAR(cp);
594 const char *cdata = get_message_body(SCM_CAR(SCM_CDDR(c)), &clen);
595 cmsg->cmsg_level = SCM_INT_VALUE(SCM_CAR(c));
596 cmsg->cmsg_type = SCM_INT_VALUE(SCM_CADR(c));
597 cmsg->cmsg_len = CMSG_LEN(clen);
598 memcpy(CMSG_DATA(cmsg), cdata, clen);
599 cmsg = CMSG_NXTHDR(msg, cmsg);
600 }
601 } else {
602 msg->msg_control = NULL;
603 msg->msg_controllen = 0;
604 }
605 msg->msg_flags = flags;
606
607 if (buf != NULL) return SCM_OBJ(buf);
608 else return Scm_MakeUVector(SCM_CLASS_U8VECTOR, sizeof(struct msghdr), msg);
609 #else /*GAUCHE_WINDOWS*/
610 (void)name; /* suppress unused var warning */
611 (void)iov; /* suppress unused var warning */
612 (void)control; /* suppress unused var warning */
613 (void)flags; /* suppress unused var warning */
614 (void)buf; /* suppress unused var warning */
615 Scm_Error("buildmsg is not implemented on this platform.");
616 return SCM_UNDEFINED;
617 #endif /*GAUCHE_WINDOWS*/
618 }
619
620 /* Low-level setsockopt() and getsockopt() interface. */
621 /* for getsockopt(), we need to know the size of the result.
622 if rtype > 0, it is used as the size of result buffer and
623 a string value is returned. if rtype == 0, the result value
624 assumed to be an integer. */
625
626 ScmObj Scm_SocketSetOpt(ScmSocket *s, int level, int option, ScmObj value)
627 {
628 int r = 0;
629 CLOSE_CHECK(s->fd, "set a socket option of", s);
630 if (SCM_STRINGP(value)) {
631 ScmSmallInt size;
632 const char *cvalue = Scm_GetStringContent(SCM_STRING(value), &size,
633 NULL, NULL);
634 SCM_SYSCALL(r, setsockopt(s->fd, level, option, cvalue, size));
635 } else if (SCM_UVECTORP(value)) {
636 u_int size = Scm_UVectorSizeInBytes(SCM_UVECTOR(value));
637 const char *cvalue = (const char*)SCM_UVECTOR_ELEMENTS(value);
638 SCM_SYSCALL(r, setsockopt(s->fd, level, option, cvalue, size));
639 } else if (SCM_INTP(value) || SCM_BIGNUMP(value)) {
640 int v = Scm_GetInteger(value);
641 SCM_SYSCALL(r, setsockopt(s->fd, level, option, (void*)&v, sizeof(int)));
642 } else {
643 Scm_TypeError("socket option value",
644 "an integer, a uvector or a string",
645 value);
646 }
647 if (r < 0) Scm_SysError("setsockopt failed");
648 return SCM_TRUE;
649 }
650
651 ScmObj Scm_SocketGetOpt(ScmSocket *s, int level, int option, int rsize)
652 {
653 int r = 0;
654 socklen_t rrsize = rsize;
655 CLOSE_CHECK(s->fd, "get a socket option of", s);
656 if (rsize > 0) {
657 char *buf = SCM_NEW_ATOMIC2(char *, rrsize);
658 SCM_SYSCALL(r, getsockopt(s->fd, level, option, buf, &rrsize));
659 if (r < 0) Scm_SysError("getsockopt failed");
660 return Scm_MakeString(buf, rrsize, rrsize, SCM_STRING_INCOMPLETE);
661 } else {
662 int val;
663 rrsize = sizeof(int);
664 SCM_SYSCALL(r, getsockopt(s->fd, level, option, (void*)&val, &rrsize));
665 if (r < 0) Scm_SysError("getsockopt failed");
666 return Scm_MakeInteger(val);
667 }
668 }
669
670 #if HAVE_STRUCT_IFREQ
671 static void ioctl_by_ifr_name(int fd, struct ifreq *ifr, ScmObj data,
672 unsigned long req, const char *req_name)
673 {
674 if (!SCM_STRINGP(data)) {
675 Scm_Error("string expected for %s ioctl argument, but got %s",
676 req_name, data);
677 }
678 strncpy(ifr->ifr_name, Scm_GetStringConst(SCM_STRING(data)), IFNAMSIZ-1);
679 int r;
680 SCM_SYSCALL(r, ioctl(fd, req, ifr));
681 if (r < 0) Scm_SysError("ioctl(%s) failed", req_name);
682 }
683 #endif
684
685 /* Low-level ioctl. */
686 ScmObj Scm_SocketIoctl(ScmSocket *s, u_long request, ScmObj data)
687 {
688 #if HAVE_STRUCT_IFREQ
689 struct ifreq ifreq_pkt;
690
691 CLOSE_CHECK(s->fd, "ioctl on", s);
692 memset(&ifreq_pkt, 0, sizeof(ifreq_pkt));
693 switch (request) {
694 #if defined(SIOCGIFNAME)
695 case SIOCGIFNAME:
696 if (!SCM_UINTEGERP(data))
697 Scm_TypeError("SIOCGIFNAME ioctl argument" , "unsigned integer", data);
698 #if HAVE_STRUCT_IFREQ_IFR_IFINDEX
699 ifreq_pkt.ifr_ifindex = Scm_GetIntegerU(data);
700 #elif HAVE_STRUCT_IFREQ_IFR_INDEX
701 ifreq_pkt.ifr_index = Scm_GetIntegerU(data);
702 #endif /*HAVE_STRUCT_IFREQ_IFR_INDEX*/
703 {
704 int r;
705 SCM_SYSCALL(r, ioctl(s->fd, SIOCGIFNAME, &ifreq_pkt));
706 if (r < 0) Scm_SysError("ioctl(SIOCGIFNAME) failed");
707 }
708 return Scm_MakeString(ifreq_pkt.ifr_name, -1, -1, SCM_STRING_COPYING);
709 #endif /*SIOCGIFNAME*/
710 #if defined(SIOCGIFINDEX)
711 case SIOCGIFINDEX:
712 ioctl_by_ifr_name(s->fd, &ifreq_pkt, data,
713 SIOCGIFINDEX, "SIOCGIFINDEX");
714 #if HAVE_STRUCT_IFREQ_IFR_IFINDEX
715 return Scm_MakeInteger(ifreq_pkt.ifr_ifindex);
716 #elif HAVE_STRUCT_IFREQ_IFR_INDEX
717 return Scm_MakeInteger(ifreq_pkt.ifr_index);
718 #endif /*HAVE_STRUCT_IFREQ_IFR_INDEX*/
719 #endif /*SIOCGIFINDEX*/
720 #if defined(SIOCGIFFLAGS)
721 case SIOCGIFFLAGS:
722 ioctl_by_ifr_name(s->fd, &ifreq_pkt, data,
723 SIOCGIFFLAGS, "SIOCGIFFLAGS");
724 return Scm_MakeInteger(ifreq_pkt.ifr_flags);
725 #endif /*SIOCGIFFLAGS*/
726 #if defined(SIOCGIFADDR)
727 case SIOCGIFADDR:
728 ioctl_by_ifr_name(s->fd, &ifreq_pkt, data,
729 SIOCGIFADDR, "SIOCGIFADDR");
730 return Scm_MakeSockAddr(NULL,
731 &ifreq_pkt.ifr_addr,
732 sizeof(ifreq_pkt.ifr_addr));
733 #endif /*SIOCGIFADDR*/
734 #if defined(SIOCGIFDSTADDR)
735 case SIOCGIFDSTADDR:
736 ioctl_by_ifr_name(s->fd, &ifreq_pkt, data,
737 SIOCGIFDSTADDR, "SIOCGIFDSTADDR");
738 return Scm_MakeSockAddr(NULL,
739 &ifreq_pkt.ifr_dstaddr,
740 sizeof(ifreq_pkt.ifr_dstaddr));
741 #endif /*SIOCGIFDSTADDR*/
742 #if defined(SIOCGIFBRDADDR)
743 case SIOCGIFBRDADDR:
744 ioctl_by_ifr_name(s->fd, &ifreq_pkt, data,
745 SIOCGIFBRDADDR, "SIOCGIFBRDADDR");
746 return Scm_MakeSockAddr(NULL,
747 &ifreq_pkt.ifr_broadaddr,
748 sizeof(ifreq_pkt.ifr_broadaddr));
749 #endif /*SIOCGIFBRDADDR*/
750 #if defined(SIOCGIFNETMASK)
751 case SIOCGIFNETMASK:
752 ioctl_by_ifr_name(s->fd, &ifreq_pkt, data,
753 SIOCGIFNETMASK, "SIOCGIFNETMASK");
754 #if defined(HAVE_STRUCT_IFREQ_IFR_NETMASK)
755 return Scm_MakeSockAddr(NULL,
756 &ifreq_pkt.ifr_netmask,
757 sizeof(ifreq_pkt.ifr_netmask));
758 #else
759 return Scm_MakeSockAddr(NULL,
760 &ifreq_pkt.ifr_addr,
761 sizeof(ifreq_pkt.ifr_addr));
762 #endif /*HAVE_STRUCT_IFREQ_IFR_NETMASK*/
763 #endif /*SIOCGIFNETMASK*/
764 #if defined(SIOCGIFMTU)
765 case SIOCGIFMTU:
766 ioctl_by_ifr_name(s->fd, &ifreq_pkt, data,
767 SIOCGIFMTU, "SIOCGIFMTU");
768 return Scm_MakeInteger(ifreq_pkt.ifr_mtu);
769 #endif /*SIOCGIFMTU*/
770 default:
771 Scm_Error("unsupported ioctl operation: %d", request);
772 }
773 #else /*!HAVE_STRUCT_IFREQ*/
774 (void)s; /* suppress unused var warning */
775 (void)data; /* suppress unused var warning */
776 Scm_Error("unsupported ioctl operation: %d", request);
777 #endif /*!HAVE_STRUCT_IFREQ*/
778 return SCM_UNDEFINED; /* dummy */
779 }
780
781 /*==================================================================
782 * Windows/MinGW compatibility layer
783 * Older MinGW lacks inet_pton/ntop.
784 */
785 #if defined(GAUCHE_WINDOWS) && !defined(InetNtopA)
786
787 int inet_pton(int af, const char *src, void *dst)
788 {
789 TCHAR *str = SCM_MBS2WCS(src);
790
791 switch (af) {
792 case AF_INET: {
793 struct sockaddr_in sa;
794 INT addrsize = (INT)sizeof(sa);
795 int r = WSAStringToAddress(str, af, NULL, (LPSOCKADDR)&sa, &addrsize);
796 if (r != 0) return -1;
797 memcpy(dst, &sa.sin_addr, sizeof(struct in_addr));
798 return 1;
799 }
800 case AF_INET6: {
801 struct sockaddr_in6 sa6;
802 INT addrsize = (INT)sizeof(sa6);
803 int r = WSAStringToAddress(str, af, NULL, (LPSOCKADDR)&sa6, &addrsize);
804 if (r != 0) return -1;
805 memcpy(dst, &sa6.sin6_addr, sizeof(struct in6_addr));
806 return 1;
807 }
808 }
809 return -1;
810 }
811
812 const char *inet_ntop(int af, const void *src, char *dst, socklen_t size)
813 {
814 #define ADDR_MAXLEN 64
815 TCHAR buf[ADDR_MAXLEN];
816 DWORD tressize = ADDR_MAXLEN-1;
817 const char *res;
818 int r = 0;
819
820 switch (af) {
821 case AF_INET: {
822 struct sockaddr_in sa;
823 memset(&sa, 0, sizeof(sa));
824 sa.sin_family = AF_INET;
825 memcpy(&sa.sin_addr, src, sizeof(struct in_addr));
826 r = WSAAddressToString((LPSOCKADDR)&sa, (DWORD)sizeof(sa), NULL,
827 buf, &tressize);
828 break;
829 }
830 case AF_INET6: {
831 struct sockaddr_in6 sa6;
832 memset(&sa6, 0, sizeof(sa6));
833 sa6.sin6_family = AF_INET6;
834 memcpy(&sa6.sin6_addr, src, sizeof(struct in6_addr));
835 r = WSAAddressToString((LPSOCKADDR)&sa6, (DWORD)sizeof(sa6), NULL,
836 buf, &tressize);
837 break;
838 }
839 default:
840 return NULL;
841 }
842
843 if (r != 0) return NULL;
844 buf[tressize] = 0;
845 res = SCM_WCS2MBS(buf);
846 size_t ressize = strlen(res);
847 if (size <= (int)ressize) return NULL;
848 memcpy(dst, res, ressize+1);
849 return dst;
850 #undef ADDR_MAXLEN
851 }
852 #endif /*defined(GAUCHE_WINDOWS) && !defined(InetNtopA)*/
853
854 /*==================================================================
855 * Initialization
856 */
857
858 void Scm__InitNet(void)
859 {
860 ScmModule *mod = SCM_FIND_MODULE("gauche.net", SCM_FIND_MODULE_CREATE);
861 Scm_InitStaticClass(&Scm_SocketClass, "<socket>", mod, NULL, 0);
862 }