| 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 |
} |