Debian Codegraph @

src/netaddr.c

raw
1 /*
2 * addr.c - socket address
3 *
4 * Copyright (c) 2001-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
39 static ScmObj key_path = SCM_FALSE;
40 static ScmObj key_host = SCM_FALSE;
41 static ScmObj key_port = SCM_FALSE;
42 static ScmObj key_any = SCM_FALSE;
43 static ScmObj key_broadcast = SCM_FALSE;
44 static ScmObj key_loopback = SCM_FALSE;
45
46 /* NB: built-in socket address structures are allocated as ATOMIC---when
47 you want to extend them, be careful not to introduce sole pointers to
48 allocated objects; GC will collect them prematurely. The only
49 pointer, the tagged pointer to the class, is protected since they're
50 bound to global variables. */
51
52 /*==================================================================
53 * Generic Socket Address
54 */
55
56 static void sockaddr_print(ScmObj obj, ScmPort *port, ScmWriteContext *ctx);
57 static ScmObj sockaddr_allocate(ScmClass *, ScmObj);
58
59 ScmClass *Scm_SockAddrCPL[] = {
60 SCM_CLASS_STATIC_PTR(Scm_SockAddrClass),
61 SCM_CLASS_STATIC_PTR(Scm_TopClass),
62 NULL
63 };
64
65 SCM_DEFINE_BUILTIN_CLASS(Scm_SockAddrClass, sockaddr_print,
66 NULL, NULL, sockaddr_allocate,
67 NULL);
68
69 void sockaddr_print(ScmObj obj, ScmPort *port,
70 ScmWriteContext *ctx SCM_UNUSED)
71 {
72 Scm_Printf(port, "#<sockaddr %S %S>",
73 Scm_SockAddrFamily(SCM_SOCKADDR(obj)),
74 Scm_SockAddrName(SCM_SOCKADDR(obj)));
75 }
76
77 int Scm_SockAddrP(ScmObj obj)
78 {
79 return Scm_SubtypeP(Scm_ClassOf(obj), SCM_CLASS_SOCKADDR);
80 }
81
82 /* C interface of sockaddr-name and sockaddr-family */
83 ScmObj Scm_SockAddrName(ScmSockAddr *addr)
84 {
85 return Scm_ApplyRec(SCM_OBJ(&Scm_GenericSockAddrName),
86 SCM_LIST1(SCM_OBJ(addr)));
87 }
88
89 ScmObj Scm_SockAddrFamily(ScmSockAddr *addr)
90 {
91 return Scm_ApplyRec(SCM_OBJ(&Scm_GenericSockAddrFamily),
92 SCM_LIST1(SCM_OBJ(addr)));
93 }
94
95 /* Fallback of allocation method */
96 static ScmObj sockaddr_allocate(ScmClass *klass SCM_UNUSED,
97 ScmObj initargs SCM_UNUSED)
98 {
99 Scm_Error("you can't directly instantiate the abstract class <sockaddr>");
100 return SCM_UNDEFINED; /* dummy */
101 }
102
103 /* creates sockaddr from struct sockaddr. */
104 ScmObj Scm_MakeSockAddr(ScmClass *klass, struct sockaddr *saddr, int len)
105 {
106 ScmSockAddr *addr = SCM_NEW_ATOMIC2(
107 ScmSockAddr*, sizeof(ScmSockAddr) - sizeof(struct sockaddr) + len);
108 if (klass == NULL) {
109 switch (saddr->sa_family) {
110 case AF_UNIX:
111 klass = SCM_CLASS_SOCKADDR_UN;
112 break;
113 case AF_INET:
114 klass = SCM_CLASS_SOCKADDR_IN;
115 break;
116 #ifdef HAVE_IPV6
117 case AF_INET6:
118 klass = SCM_CLASS_SOCKADDR_IN6;
119 break;
120 #endif
121 default:
122 Scm_Error("unknown address family (%d)", saddr->sa_family);
123 break;
124 }
125 }
126 SCM_SET_CLASS(addr, klass);
127 addr->addrlen = len;
128 memcpy(&addr->addr, saddr, len);
129 return SCM_OBJ(addr);
130 }
131
132 /*==================================================================
133 * Unix domain socket
134 */
135
136 static ScmObj sockaddr_un_allocate(ScmClass *klass SCM_UNUSED,
137 ScmObj initargs)
138 {
139 ScmObj path = Scm_GetKeyword(key_path, initargs, SCM_FALSE);
140 if (!SCM_FALSEP(path) && !SCM_STRINGP(path)) {
141 Scm_Error(":path parameter must be a string, but got %S", path);
142 }
143
144 ScmSockAddrUn *addr = SCM_NEW_ATOMIC(ScmSockAddrUn);
145 SCM_SET_CLASS(addr, SCM_CLASS_SOCKADDR_UN);
146 memset(&addr->addr, 0, sizeof(struct sockaddr_un));
147 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
148 addr->addr.sun_len = sizeof(struct sockaddr_un);
149 #endif
150 addr->addr.sun_family = AF_UNIX;
151 if (SCM_STRINGP(path)) {
152 ScmSmallInt size;
153 const char *cpath = Scm_GetStringContent(SCM_STRING(path), &size,
154 NULL, NULL);
155 if ((size_t)size >= sizeof(addr->addr.sun_path)-1) {
156 Scm_Error("path too long: %S", path);
157 }
158 memcpy(addr->addr.sun_path, cpath, size);
159 addr->addr.sun_path[size] = '\0';
160 }
161 addr->addrlen = sizeof(struct sockaddr_un);
162 return SCM_OBJ(addr);
163 }
164
165 static int sockaddr_un_compare(ScmObj x, ScmObj y, int equalp)
166 {
167 ScmSockAddrUn *xx = (ScmSockAddrUn*)x;
168 ScmSockAddrUn *yy = (ScmSockAddrUn*)y;
169 if (!equalp) Scm_Error("object %S and %S can't be ordered", x, y);
170
171 if (xx->addrlen == yy->addrlen
172 && memcmp(xx->addr.sun_path, yy->addr.sun_path,
173 sizeof(xx->addr.sun_path)) == 0) {
174 return 0; /* (equal? x y) => #t */
175 } else {
176 return -1; /* (equal? x y) => #f */
177 }
178 }
179
180 SCM_DEFINE_BUILTIN_CLASS(Scm_SockAddrUnClass, sockaddr_print,
181 sockaddr_un_compare, NULL,
182 sockaddr_un_allocate, Scm_SockAddrCPL);
183
184 /*==================================================================
185 * Inet domain socket
186 */
187
188 static ScmObj sockaddr_in_allocate(ScmClass *klass SCM_UNUSED, ScmObj initargs)
189 {
190 ScmObj host = Scm_GetKeyword(key_host, initargs, key_any);
191 ScmObj port = Scm_GetKeyword(key_port, initargs, SCM_MAKE_INT(0));
192
193 if (!SCM_INTP(port)) {
194 Scm_Error(":port parameter must be a small exact integer, but got %S",
195 port);
196 }
197 ScmSockAddrIn *addr = SCM_NEW_ATOMIC(ScmSockAddrIn);
198 SCM_SET_CLASS(addr, SCM_CLASS_SOCKADDR_IN);
199 memset(&addr->addr, 0, sizeof(struct sockaddr_in));
200 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
201 addr->addr.sin_len = sizeof(struct sockaddr_in);
202 #endif
203 addr->addr.sin_family = AF_INET;
204 addr->addr.sin_port = htons((short)SCM_INT_VALUE(port));
205 if (SCM_STRINGP(host)) {
206 const char *hname = Scm_GetStringConst(SCM_STRING(host));
207 /* First, see if host is dotted number notation. */
208 if (inet_pton(AF_INET, hname, &addr->addr.sin_addr) <= 0) {
209 /* Now, we need to look up the host name.
210 Call MT-safe Scm_GetHostByName */
211 ScmObj hent = Scm_GetHostByName(hname);
212 if (!SCM_SYS_HOSTENT_P(hent)) {
213 Scm_Error("unknown host: %S", host);
214 }
215 ScmObj ap = SCM_SYS_HOSTENT(hent)->addresses;
216 if (SCM_NULLP(ap) || !SCM_STRINGP(SCM_CAR(ap))) {
217 Scm_Error("host have unknown address type: %S", host);
218 }
219 hname = Scm_GetStringConst(SCM_STRING(SCM_CAR(ap)));
220 if (inet_pton(AF_INET, hname, &addr->addr.sin_addr) == 0) {
221 Scm_Error("host name lookup failure: %S", host);
222 }
223 }
224 } else if (host == key_any) {
225 addr->addr.sin_addr.s_addr = htonl(INADDR_ANY);
226 } else if (host == key_broadcast) {
227 addr->addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
228 } else if (host == key_loopback) {
229 addr->addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
230 } else if (SCM_INTEGERP(host)) {
231 int ov;
232 unsigned long a = Scm_GetIntegerUClamp(host, SCM_CLAMP_NONE, &ov);
233 if (ov) Scm_Error("host address is out of range: %S", host);
234 addr->addr.sin_addr.s_addr = htonl(a);
235 } else if (SCM_U8VECTORP(host)) {
236 if (SCM_U8VECTOR_SIZE(host) < 4) {
237 Scm_Error("host address is too short: %S", host);
238 }
239 const unsigned char *p = SCM_U8VECTOR_ELEMENTS(host);
240 unsigned long a = (p[0]<<24)+(p[1]<<16)+(p[2]<<8)+p[3];
241 addr->addr.sin_addr.s_addr = htonl(a);
242 } else {
243 Scm_Error("bad :host parameter: %S", host);
244 }
245 addr->addrlen = sizeof(struct sockaddr_in);
246 return SCM_OBJ(addr);
247 }
248
249 static int sockaddr_in_compare(ScmObj x, ScmObj y, int equalp)
250 {
251 ScmSockAddrIn *xx = (ScmSockAddrIn*)x;
252 ScmSockAddrIn *yy = (ScmSockAddrIn*)y;
253 if (!equalp) Scm_Error("object %S and %S can't be ordered", x, y);
254
255 if (xx->addrlen == yy->addrlen
256 && xx->addr.sin_family == yy->addr.sin_family
257 && xx->addr.sin_port == yy->addr.sin_port
258 && xx->addr.sin_addr.s_addr == yy->addr.sin_addr.s_addr) {
259 return 0; /* (equal? x y) => #t */
260 } else {
261 return -1; /* (equal? x y) => #f */
262 }
263 }
264
265 SCM_DEFINE_BUILTIN_CLASS(Scm_SockAddrInClass, sockaddr_print,
266 sockaddr_in_compare, NULL,
267 sockaddr_in_allocate, Scm_SockAddrCPL);
268
269 /*==================================================================
270 * Inet6 domain socket
271 */
272
273 #ifdef HAVE_IPV6
274
275 static ScmObj sockaddr_in6_allocate(ScmClass *klass SCM_UNUSED, ScmObj initargs)
276 {
277 ScmObj host = Scm_GetKeyword(key_host, initargs, key_any);
278 ScmObj port = Scm_GetKeyword(key_port, initargs, SCM_MAKE_INT(0));
279
280 if (!SCM_INTP(port)) {
281 Scm_Error(":port parameter must be a small exact integer, but got %S",
282 port);
283 }
284 ScmSockAddrIn6 *addr = SCM_NEW_ATOMIC(ScmSockAddrIn6);
285 SCM_SET_CLASS(addr, SCM_CLASS_SOCKADDR_IN6);
286 memset(&addr->addr, 0, sizeof(struct sockaddr_in6));
287 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN
288 addr->addr.sin6_len = sizeof(struct sockaddr_in6);
289 #endif
290 addr->addr.sin6_family = AF_INET6;
291 addr->addr.sin6_port = htons(SCM_INT_VALUE(port));
292 if (SCM_STRINGP(host)) {
293 const char *hname = Scm_GetStringConst(SCM_STRING(host));
294 struct addrinfo hints, *res;
295 memset(&hints, 0, sizeof(hints));
296 hints.ai_family = AF_INET6;
297 hints.ai_socktype = SOCK_STREAM;
298 int r = getaddrinfo(hname, NULL, &hints, &res);
299 #if !defined(GAUCHE_WINDOWS)
300 if (r) Scm_Error("getaddrinfo failed: %s", gai_strerror(r));
301 #else /*GAUCHE_WINDOWS*/
302 if (r) Scm_SysError("getaddrinfo failed");
303 #endif /*GAUCHE_WINDOWS*/
304 addr->addr.sin6_addr = ((struct sockaddr_in6*)res->ai_addr)->sin6_addr;
305 freeaddrinfo(res);
306 } else if (host == key_any) {
307 addr->addr.sin6_addr = in6addr_any;
308 } else if (host == key_loopback) {
309 addr->addr.sin6_addr = in6addr_loopback;
310 } else if (SCM_INTEGERP(host)) {
311 /* NB: Can we have more efficient way? */
312 for (int i=15; i>=0; i--) {
313 ScmObj u8 = Scm_LogAnd(host, SCM_MAKE_INT(0xff));
314 addr->addr.sin6_addr.s6_addr[i] = SCM_INT_VALUE(u8);
315 host = Scm_Ash(host, -8);
316 }
317 } else if (SCM_U8VECTORP(host)) {
318 if (SCM_U8VECTOR_SIZE(host) < 16) {
319 Scm_Error("host address is too short: %S", host);
320 }
321 const unsigned char *p = SCM_U8VECTOR_ELEMENTS(host);
322 for (int i=0; i<16; i++) {
323 addr->addr.sin6_addr.s6_addr[i] = p[i];
324 }
325 } else {
326 Scm_Error("bad :host parameter: %S", host);
327 }
328 addr->addrlen = sizeof(struct sockaddr_in6);
329 return SCM_OBJ(addr);
330 }
331
332 static int sockaddr_in6_compare(ScmObj x, ScmObj y, int equalp)
333 {
334 ScmSockAddrIn6 *xx = (ScmSockAddrIn6*)x;
335 ScmSockAddrIn6 *yy = (ScmSockAddrIn6*)y;
336 if (!equalp) Scm_Error("object %S and %S can't be ordered", x, y);
337
338 if (xx->addrlen == yy->addrlen
339 && xx->addr.sin6_family == yy->addr.sin6_family
340 && xx->addr.sin6_port == yy->addr.sin6_port
341 && (memcmp(&xx->addr.sin6_addr, &yy->addr.sin6_addr,
342 sizeof(xx->addr.sin6_addr)) == 0)) {
343 return 0; /* (equal? x y) => #t */
344 } else {
345 return -1; /* (equal? x y) => #f */
346 }
347 }
348
349 SCM_DEFINE_BUILTIN_CLASS(Scm_SockAddrIn6Class, sockaddr_print,
350 sockaddr_in6_compare, NULL,
351 sockaddr_in6_allocate, Scm_SockAddrCPL);
352
353 #endif /* HAVE_IPV6 */
354
355 /*==================================================================
356 * Parse internet addresses
357 */
358
359 ScmObj Scm_InetStringToAddress(const char *s,
360 int *proto, /*out*/
361 ScmUVector *buf /*out*/)
362 {
363 struct in_addr in4;
364 #ifdef HAVE_IPV6
365 struct in6_addr in6;
366 #endif
367 if (inet_pton(AF_INET, s, &in4) > 0) {
368 *proto = AF_INET;
369 if (buf) {
370 if (Scm_UVectorSizeInBytes(buf) < 4) {
371 Scm_Error("uniform vector buffer isn't big enough to hold IPv4 address: %S", buf);
372 }
373 ScmU32Vector *u32 = (ScmU32Vector*)buf;
374 SCM_U32VECTOR_ELEMENTS(u32)[0] = in4.s_addr;
375 return SCM_TRUE;
376 } else {
377 return Scm_MakeIntegerU(ntohl(in4.s_addr));
378 }
379 }
380
381 #ifdef HAVE_IPV6
382 if (inet_pton(AF_INET6, s, &in6) > 0) {
383 *proto = AF_INET6;
384 if (buf) {
385 if (Scm_UVectorSizeInBytes(buf) < 16) {
386 Scm_Error("uniform vector buffer isn't big enough to hold IPv6 address: %S", buf);
387 }
388 ScmU8Vector *u8 = (ScmU8Vector*)buf;
389 for (int i=0; i<16; i++) {
390 SCM_U8VECTOR_ELEMENTS(u8)[i] = in6.s6_addr[i];
391 }
392 return SCM_TRUE;
393 } else {
394 ScmObj s = SCM_MAKE_INT(0);
395 for (int i=0; i<16; i++) {
396 s = Scm_Add(Scm_Ash(s, 8),
397 SCM_MAKE_INT(in6.s6_addr[i]));
398 }
399 return s;
400 }
401 }
402 #endif
403 return SCM_FALSE;
404 }
405
406 ScmObj Scm_InetAddressToString(ScmObj addr, /* integer or uvector */
407 int proto)
408 {
409 if (proto == AF_INET) {
410 char buf[INET_ADDRSTRLEN];
411 struct in_addr in4;
412 if (SCM_INTEGERP(addr)) {
413 u_long a = Scm_GetIntegerU(addr);
414 in4.s_addr = htonl(a);
415 } else if (SCM_UVECTORP(addr)) {
416 if (Scm_UVectorSizeInBytes(SCM_UVECTOR(addr)) < 4) {
417 Scm_Error("uvector too short for IPv4 address: %S", addr);
418 }
419 in4.s_addr = SCM_U32VECTOR_ELEMENTS(addr)[0];
420 } else {
421 Scm_TypeError("address", "integer or uvector", addr);
422 }
423 if (inet_ntop(AF_INET, &in4, buf, INET_ADDRSTRLEN) != NULL) {
424 return Scm_MakeString(buf, -1, -1, SCM_STRING_COPYING);
425 } else {
426 Scm_SysError("inet_ntop failed for address %S", addr);
427 }
428 }
429 #ifdef HAVE_IPV6
430 if (proto == AF_INET6) {
431 char buf[INET6_ADDRSTRLEN];
432 struct in6_addr in6;
433 if (SCM_INTEGERP(addr)) {
434 ScmObj mask = SCM_MAKE_INT(0xff);
435 for (int i=0; i<16; i++) {
436 u_long a = Scm_GetIntegerU(Scm_LogAnd(addr, mask));
437 in6.s6_addr[15-i] = a;
438 addr = Scm_Ash(addr, -8);
439 }
440 } else if (SCM_UVECTORP(addr)) {
441 if (Scm_UVectorSizeInBytes(SCM_UVECTOR(addr)) < 16) {
442 Scm_Error("uvector too short for IPv6 address: %S", addr);
443 }
444 ScmU8Vector *u8 = SCM_U8VECTOR(addr);
445 for (int i=0; i<16; i++) {
446 in6.s6_addr[i] = SCM_U8VECTOR_ELEMENTS(u8)[i];
447 }
448 } else {
449 Scm_TypeError("address", "integer or uvector", addr);
450 }
451 if (inet_ntop(AF_INET6, &in6, buf, INET6_ADDRSTRLEN) != NULL) {
452 return Scm_MakeString(buf, -1, -1, SCM_STRING_COPYING);
453 } else {
454 Scm_SysError("inet_ntop failed for address %S", addr);
455 }
456 }
457 #endif
458 Scm_Error("unsupported protocol for inet-address->string: %d", proto);
459 return SCM_UNDEFINED; /* dummy */
460 #undef BUFLEN
461 }
462
463 /*==================================================================
464 * initialization stuff
465 */
466
467 void Scm__InitNetAddr(void)
468 {
469 ScmModule *mod = SCM_FIND_MODULE("gauche.net", 0);
470
471 key_path = SCM_MAKE_KEYWORD("path");
472 key_host = SCM_MAKE_KEYWORD("host");
473 key_port = SCM_MAKE_KEYWORD("port");
474 key_any = SCM_MAKE_KEYWORD("any");
475 key_broadcast = SCM_MAKE_KEYWORD("broadcast");
476 key_loopback = SCM_MAKE_KEYWORD("loopback");
477
478 Scm_InitStaticClass(&Scm_SockAddrClass, "<sockaddr>", mod, NULL, 0);
479 Scm_InitStaticClass(&Scm_SockAddrUnClass, "<sockaddr-un>", mod, NULL, 0);
480 Scm_InitStaticClass(&Scm_SockAddrInClass, "<sockaddr-in>", mod, NULL, 0);
481 #ifdef HAVE_IPV6
482 Scm_InitStaticClass(&Scm_SockAddrIn6Class, "<sockaddr-in6>", mod, NULL, 0);
483 #endif /* HAVE_IPV6 */
484 }