Debian Codegraph @

src/netdb.c

raw
1 /*
2 * netdb.c - obtain information about network
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
39 #define DATA_BUFSIZ 980
40
41 static struct netdb_data_rec {
42 ScmInternalMutex hostent_mutex;
43 ScmInternalMutex protoent_mutex;
44 ScmInternalMutex servent_mutex;
45 } netdb_data;
46
47 #define WITH_GLOBAL_LOCK(mutex, body) \
48 SCM_UNWIND_PROTECT { \
49 SCM_INTERNAL_MUTEX_LOCK(mutex); \
50 body; \
51 } SCM_WHEN_ERROR { \
52 SCM_INTERNAL_MUTEX_UNLOCK(mutex); \
53 SCM_NEXT_HANDLER; \
54 } SCM_END_PROTECT; \
55 SCM_INTERNAL_MUTEX_UNLOCK(mutex)
56
57 /*-------------------------------------------------------------
58 * Hostent
59 */
60
61 SCM_DEFINE_BUILTIN_CLASS_SIMPLE(Scm_SysHostentClass, NULL);
62
63 static ScmSysHostent *make_hostent(struct hostent *he)
64 {
65 ScmSysHostent *entry = SCM_NEW(ScmSysHostent);
66 ScmObj h = SCM_NIL, t = SCM_NIL;
67
68 SCM_SET_CLASS(entry, SCM_CLASS_SYS_HOSTENT);
69 entry->name = SCM_MAKE_STR_COPYING(he->h_name);
70 entry->aliases = Scm_CStringArrayToList((const char**)he->h_aliases, -1,
71 SCM_STRING_COPYING);
72 if (he->h_addrtype == AF_INET) {
73 for (char **p = he->h_addr_list; *p; p++) {
74 char buf[50];
75 struct in_addr *addr = (struct in_addr*)*p;
76 unsigned long addrval = ntohl(addr->s_addr);
77 /* avoid using inet_ntoa, for it is not reentrant */
78 snprintf(buf, 50, "%ld.%ld.%ld.%ld",
79 ((addrval >> 24)& 0xff), ((addrval >> 16) & 0xff),
80 ((addrval >> 8) & 0xff), (addrval & 0xff));
81 SCM_APPEND1(h, t, SCM_MAKE_STR_COPYING(buf));
82 }
83 } else {
84 /* soon AF_INET6 will be supported (hopefully) */
85 Scm_Error("unknown address type (%d)", he->h_addrtype);
86 }
87 entry->addresses = h;
88 return entry;
89 }
90
91 ScmObj Scm_GetHostByName(const char *name)
92 {
93 #if defined(GETHOSTBYNAME_R_NUMARGS)
94 ScmObj entry = SCM_FALSE;
95 {
96 int herr = 0, bufsiz = DATA_BUFSIZ;
97 struct hostent he;
98 char staticbuf[DATA_BUFSIZ], *buf = staticbuf;
99
100 for (;;) {
101 #if GETHOSTBYNAME_R_NUMARGS == 5
102 if (gethostbyname_r(name, &he, buf, bufsiz, &herr) != NULL) break;
103 if (herr != ERANGE) return SCM_FALSE;
104 bufsiz *= 2;
105 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
106 #elif GETHOSTBYNAME_R_NUMARGS == 6
107 struct hostent *rhe;
108 gethostbyname_r(name, &he, buf, bufsiz, &rhe, &herr);
109 if (rhe != 0) break;
110 else if (herr != ERANGE) return SCM_FALSE;
111 bufsiz *= 2;
112 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
113 #else
114 #error unsupported gethostbyname_r variant (configuration error?)
115 #endif
116 }
117 entry = SCM_OBJ(make_hostent(&he));
118 }
119 return entry;
120 #else /* !defined(GETHOSTBYNAME_R_NUMARGS) */
121 /* We don't have thread-safe call. Using global lock. */
122 volatile ScmObj entry = SCM_FALSE;
123 WITH_GLOBAL_LOCK(netdb_data.hostent_mutex,
124 do {
125 struct hostent *he;
126 he = gethostbyname(name);
127 if (he != NULL) entry = SCM_OBJ(make_hostent(he));
128 } while (0));
129 return entry;
130 #endif /* !defined(GETHOSTBYNAME_R_NUMARGS) */
131 }
132
133 ScmObj Scm_GetHostByAddr(const char *addr, int type)
134 {
135 struct in_addr iaddr;
136 if (type != AF_INET) {
137 Scm_Error("unsupported address type: %d", type);
138 }
139 if (inet_pton(AF_INET, addr, &iaddr) <= 0) {
140 Scm_Error("bad inet address format: %s", addr);
141 }
142
143 #if defined(GETHOSTBYADDR_R_NUMARGS)
144 {
145 ScmObj entry = SCM_FALSE;
146 int herr = 0, bufsiz = DATA_BUFSIZ;
147 struct hostent he;
148 char staticbuf[DATA_BUFSIZ], *buf = staticbuf;
149 for (;;) {
150 #if GETHOSTBYADDR_R_NUMARGS == 7
151 if (gethostbyaddr_r((void *)&iaddr, sizeof(struct in_addr),
152 AF_INET, &he, buf, bufsiz, &herr) != NULL) {
153 break;
154 }
155 if (herr != ERANGE) return SCM_FALSE;
156 bufsiz *= 2;
157 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
158 #elif GETHOSTBYADDR_R_NUMARGS == 8
159 struct hostent *rhe;
160 gethostbyaddr_r((void *)&iaddr, sizeof(struct in_addr),
161 AF_INET, &he, buf, bufsiz, &rhe, &herr);
162 if (rhe != NULL) break;
163 if (herr != ERANGE) return SCM_FALSE;
164 bufsiz *= 2;
165 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
166 #else
167 #error unsupported gethostbyaddr_r variant (configuration error?)
168 #endif
169 }
170 entry = SCM_OBJ(make_hostent(&he));
171 return entry;
172 }
173 #else /* !defined(GETHOSTBYADDR_R_NUMARGS) */
174 {
175 volatile ScmObj entry = SCM_FALSE;
176 struct hostent *he;
177
178 WITH_GLOBAL_LOCK(netdb_data.hostent_mutex,
179 do {
180 he = gethostbyaddr((void*)&iaddr,
181 sizeof(struct in_addr),
182 AF_INET);
183 if (he != NULL) {
184 entry = SCM_OBJ(make_hostent(he));
185 }
186 } while (0));
187 return entry;
188 }
189 #endif /* !defined(GETHOSTBYADDR_R_NUMARGS) */
190 }
191
192 static ScmObj hostent_name(ScmSysHostent *entry)
193 {
194 return entry->name;
195 }
196
197 static ScmObj hostent_aliases(ScmSysHostent *entry)
198 {
199 return entry->aliases;
200 }
201
202 static ScmObj hostent_addresses(ScmSysHostent *entry)
203 {
204 return entry->addresses;
205 }
206
207 static ScmClassStaticSlotSpec hostent_slots[] = {
208 SCM_CLASS_SLOT_SPEC("name", hostent_name, NULL),
209 SCM_CLASS_SLOT_SPEC("aliases", hostent_aliases, NULL),
210 SCM_CLASS_SLOT_SPEC("addresses", hostent_addresses, NULL),
211 SCM_CLASS_SLOT_SPEC_END()
212 };
213
214 /*-------------------------------------------------------------
215 * Protoent
216 */
217
218 SCM_DEFINE_BUILTIN_CLASS_SIMPLE(Scm_SysProtoentClass, NULL);
219
220 static ScmSysProtoent *make_protoent(struct protoent *pe)
221 {
222 ScmSysProtoent *entry = SCM_NEW(ScmSysProtoent);
223
224 SCM_SET_CLASS(entry, SCM_CLASS_SYS_PROTOENT);
225 entry->name = SCM_MAKE_STR_COPYING(pe->p_name);
226 entry->aliases = Scm_CStringArrayToList((const char **)pe->p_aliases, -1,
227 SCM_STRING_COPYING);
228 entry->proto = Scm_MakeInteger(pe->p_proto);
229 return entry;
230 }
231
232 ScmObj Scm_GetProtoByName(const char *name)
233 {
234 #if defined(GETPROTOBYNAME_R_NUMARGS)
235 ScmObj entry = SCM_FALSE;
236 {
237 int bufsiz = DATA_BUFSIZ;
238 struct protoent pe;
239 char staticbuf[DATA_BUFSIZ], *buf = staticbuf;
240
241 for (;;) {
242 #if GETPROTOBYNAME_R_NUMARGS == 4
243 if (getprotobyname_r(name, &pe, buf, bufsiz) != NULL) break;
244 if (errno != ERANGE) return SCM_FALSE;
245 bufsiz *= 2;
246 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
247 #elif GETPROTOBYNAME_R_NUMARGS == 5
248 struct protoent *rpe;
249 getprotobyname_r(name, &pe, buf, bufsiz, &rpe);
250 if (rpe != 0) break;
251 else if (errno != ERANGE) return SCM_FALSE;
252 bufsiz *= 2;
253 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
254 #else
255 #error unsupported getprotobyname_r variant (configuration error?)
256 #endif
257 }
258 entry = SCM_OBJ(make_protoent(&pe));
259 }
260 return entry;
261 #else /* !defined(GETPROTOBYNAME_R_NUMARGS) */
262 volatile ScmObj entry = SCM_FALSE;
263 WITH_GLOBAL_LOCK(netdb_data.protoent_mutex,
264 do {
265 struct protoent *pe = getprotobyname(name);
266 if (pe != NULL) entry = SCM_OBJ(make_protoent(pe));
267 } while (0));
268 return entry;
269 #endif /* !defined(GETPROTOBYNAME_R_NUMARGS) */
270 }
271
272 ScmObj Scm_GetProtoByNumber(int number)
273 {
274 #if defined(GETPROTOBYNUMBER_R_NUMARGS)
275 ScmObj entry = SCM_FALSE;
276 {
277 int bufsiz = DATA_BUFSIZ;
278 struct protoent pe;
279 char staticbuf[DATA_BUFSIZ], *buf = staticbuf;
280
281 for (;;) {
282 #if GETPROTOBYNUMBER_R_NUMARGS == 4
283 if (getprotobynumber_r(number, &pe, buf, bufsiz) != NULL) break;
284 if (errno != ERANGE) return SCM_FALSE;
285 bufsiz *= 2;
286 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
287 #elif GETPROTOBYNUMBER_R_NUMARGS == 5
288 struct protoent *rpe;
289 getprotobynumber_r(number, &pe, buf, bufsiz, &rpe);
290 if (rpe != 0) break;
291 else if (errno != ERANGE) return SCM_FALSE;
292 bufsiz *= 2;
293 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
294 #else
295 #error unsupported getprotobyname_r variant (configuration error?)
296 #endif
297 }
298 entry = SCM_OBJ(make_protoent(&pe));
299 }
300 return entry;
301 #else /* !defined(GETPROTOBYNUMBER_R_NUMARGS) */
302 volatile ScmObj entry = SCM_FALSE;
303 WITH_GLOBAL_LOCK(netdb_data.protoent_mutex,
304 do {
305 struct protoent *pe = getprotobynumber(number);
306 if (pe != NULL) entry = SCM_OBJ(make_protoent(pe));
307 } while (0));
308 return entry;
309 #endif /* !defined(GETPROTOBYNUMBER_R_NUMARGS) */
310 }
311
312 static ScmObj protoent_name(ScmSysProtoent *entry)
313 {
314 return entry->name;
315 }
316
317 static ScmObj protoent_aliases(ScmSysProtoent *entry)
318 {
319 return entry->aliases;
320 }
321
322 static ScmObj protoent_proto(ScmSysProtoent *entry)
323 {
324 return entry->proto;
325 }
326
327 static ScmClassStaticSlotSpec protoent_slots[] = {
328 SCM_CLASS_SLOT_SPEC("name", protoent_name, NULL),
329 SCM_CLASS_SLOT_SPEC("aliases", protoent_aliases, NULL),
330 SCM_CLASS_SLOT_SPEC("proto", protoent_proto, NULL),
331 SCM_CLASS_SLOT_SPEC_END()
332 };
333
334 /*-------------------------------------------------------------
335 * Servent
336 */
337
338 SCM_DEFINE_BUILTIN_CLASS_SIMPLE(Scm_SysServentClass, NULL);
339
340 static ScmSysServent *make_servent(struct servent *se)
341 {
342 ScmSysServent *entry = SCM_NEW(ScmSysServent);
343
344 SCM_SET_CLASS(entry, SCM_CLASS_SYS_SERVENT);
345 entry->name = SCM_MAKE_STR_COPYING(se->s_name);
346 entry->aliases = Scm_CStringArrayToList((const char **)se->s_aliases, -1,
347 SCM_STRING_COPYING);
348 entry->port = Scm_MakeInteger(ntohs(se->s_port));
349 entry->proto = SCM_MAKE_STR_COPYING(se->s_proto);
350 return entry;
351 }
352
353 ScmObj Scm_GetServByName(const char *name, const char *proto)
354 {
355 #if defined(GETSERVBYNAME_R_NUMARGS)
356 ScmObj entry = SCM_FALSE;
357 {
358 int bufsiz = DATA_BUFSIZ;
359 struct servent se;
360 char staticbuf[DATA_BUFSIZ], *buf = staticbuf;
361
362 for (;;) {
363 #if GETSERVBYNAME_R_NUMARGS == 5
364 if (getservbyname_r(name, proto, &se, buf, bufsiz) != NULL) break;
365 if (errno != ERANGE) return SCM_FALSE;
366 bufsiz *= 2;
367 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
368 #elif GETSERVBYNAME_R_NUMARGS == 6
369 struct servent *rse;
370 getservbyname_r(name, proto, &se, buf, bufsiz, &rse);
371 if (rse != 0) break;
372 else if (errno != ERANGE) return SCM_FALSE;
373 bufsiz *= 2;
374 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
375 #else
376 #error unsupported getservbyname_r variant (configuration error?)
377 #endif
378 }
379 entry = SCM_OBJ(make_servent(&se));
380 }
381 return entry;
382 #else /* !defined(GETSERVBYNAME_R_NUMARGS) */
383 volatile ScmObj entry = SCM_FALSE;
384 WITH_GLOBAL_LOCK(netdb_data.servent_mutex,
385 do {
386 struct servent *se = getservbyname(name, proto);
387 if (se != NULL) entry = SCM_OBJ(make_servent(se));
388 } while (0));
389 return entry;
390 #endif /* !defined(GETSERVBYNAME_R_NUMARGS) */
391 }
392
393 ScmObj Scm_GetServByPort(int port, const char *proto)
394 {
395 #if defined(GETSERVBYPORT_R_NUMARGS)
396 ScmObj entry = SCM_FALSE;
397 {
398 int bufsiz = DATA_BUFSIZ;
399 struct servent se;
400 char staticbuf[DATA_BUFSIZ], *buf = staticbuf;
401
402 for (;;) {
403 #if GETSERVBYPORT_R_NUMARGS == 5
404 if (getservbyport_r(htons(port), proto, &se, buf, bufsiz) != NULL)
405 break;
406 if (errno != ERANGE) return SCM_FALSE;
407 bufsiz *= 2;
408 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
409 #elif GETSERVBYPORT_R_NUMARGS == 6
410 struct servent *rse;
411 getservbyport_r(htons(port), proto, &se, buf, bufsiz, &rse);
412 if (rse != 0) break;
413 else if (errno != ERANGE) return SCM_FALSE;
414 bufsiz *= 2;
415 buf = SCM_NEW_ATOMIC2(char*, bufsiz);
416 #else
417 #error unsupported getservbyport_r variant (configuration error?)
418 #endif
419 }
420 entry = SCM_OBJ(make_servent(&se));
421 }
422 return entry;
423 #else /* !defined(GETSERVBYPORT_R_NUMARGS) */
424 volatile ScmObj entry = SCM_FALSE;
425 WITH_GLOBAL_LOCK(netdb_data.servent_mutex,
426 do {
427 struct servent *se =
428 getservbyport(htons(port), proto);
429 if (se != NULL) entry = SCM_OBJ(make_servent(se));
430 } while (0));
431 return entry;
432 #endif /* !defined(GETSERVBYPORT_R_NUMARGS) */
433 }
434
435 static ScmObj servent_name(ScmSysServent *entry)
436 {
437 return entry->name;
438 }
439
440 static ScmObj servent_aliases(ScmSysServent *entry)
441 {
442 return entry->aliases;
443 }
444
445 static ScmObj servent_port(ScmSysServent *entry)
446 {
447 return entry->port;
448 }
449
450 static ScmObj servent_proto(ScmSysServent *entry)
451 {
452 return entry->proto;
453 }
454
455 static ScmClassStaticSlotSpec servent_slots[] = {
456 SCM_CLASS_SLOT_SPEC("name", servent_name, NULL),
457 SCM_CLASS_SLOT_SPEC("aliases", servent_aliases, NULL),
458 SCM_CLASS_SLOT_SPEC("port", servent_port, NULL),
459 SCM_CLASS_SLOT_SPEC("proto", servent_proto, NULL),
460 SCM_CLASS_SLOT_SPEC_END()
461 };
462
463 /*-------------------------------------------------------------
464 * Addrinfo
465 */
466
467 #ifdef HAVE_IPV6
468
469 ScmObj addrinfo_allocate(ScmClass *klass, ScmObj initargs SCM_UNUSED)
470 {
471 ScmSysAddrinfo *info = SCM_NEW_INSTANCE(ScmSysAddrinfo, klass);
472 info->canonname = NULL;
473 info->addr = NULL;
474 return SCM_OBJ(info);
475 }
476
477 static ScmSysAddrinfo *make_addrinfo(struct addrinfo *ai)
478 {
479 ScmSysAddrinfo *info = SCM_NEW(ScmSysAddrinfo);
480
481 SCM_SET_CLASS(info, SCM_CLASS_SYS_ADDRINFO);
482 info->flags = ai->ai_flags;
483 info->family = ai->ai_family;
484 info->socktype = ai->ai_socktype;
485 info->protocol = ai->ai_protocol;
486 info->addrlen = ai->ai_addrlen;
487 if (ai->ai_canonname != NULL)
488 info->canonname = SCM_STRING(SCM_MAKE_STR_COPYING(ai->ai_canonname));
489 if (ai->ai_addr != NULL)
490 info->addr = SCM_SOCKADDR(Scm_MakeSockAddr(NULL,
491 ai->ai_addr,
492 ai->ai_addrlen));
493 return info;
494 }
495
496 ScmObj Scm_GetAddrinfo(const char *nodename,
497 const char *servname,
498 struct addrinfo *hints)
499 {
500 ScmObj h = SCM_NIL, t = SCM_NIL;
501 struct addrinfo *res0;
502
503 int r = getaddrinfo(nodename, servname, hints, &res0);
504 #if !defined(GAUCHE_WINDOWS)
505 if (r) {
506 if (r == EAI_SYSTEM) {
507 Scm_SysError("getaddrinfo failed: %s", gai_strerror(r));
508 } else {
509 Scm_Error("getaddrinfo failed: %s", gai_strerror(r));
510 }
511 }
512 #else /*GAUCHE_WINDOWS*/
513 if (r) Scm_SysError("getaddrinfo failed");
514 #endif /*GAUCHE_WINDOWS*/
515
516 for (struct addrinfo *res = res0; res != NULL; res = res->ai_next) {
517 SCM_APPEND1(h, t, SCM_OBJ(make_addrinfo(res)));
518 }
519 freeaddrinfo(res0);
520 return h;
521 }
522
523 ScmObj Scm_GetNameinfo(ScmSockAddr *addr, int flags)
524 {
525 char host[NI_MAXHOST], serv[NI_MAXSERV];
526
527 int r = getnameinfo(&addr->addr, addr->addrlen,
528 host, sizeof(host), serv, sizeof(serv), flags);
529 #if !defined(GAUCHE_WINDOWS)
530 if (r) Scm_Error("getnameinfo failed: %s", gai_strerror(r));
531 #else /*GAUCHE_WINDOWS*/
532 if (r) Scm_SysError("getnameinfo failed");
533 #endif /*GAUCHE_WINDOWS*/
534 return Scm_Values2(SCM_MAKE_STR_COPYING(host), SCM_MAKE_STR_COPYING(serv));
535 }
536
537 #endif /* HAVE_IPV6 */
538
539 /*-------------------------------------------------------------
540 * Initialize
541 */
542
543 void Scm__InitNetDb()
544 {
545 ScmModule *mod = SCM_FIND_MODULE("gauche.net", 0);
546 Scm_InitStaticClass(&Scm_SysHostentClass, "<sys-hostent>", mod,
547 hostent_slots, 0);
548 Scm_InitStaticClass(&Scm_SysProtoentClass, "<sys-protoent>", mod,
549 protoent_slots, 0);
550 Scm_InitStaticClass(&Scm_SysServentClass, "<sys-servent>", mod,
551 servent_slots, 0);
552 SCM_INTERNAL_MUTEX_INIT(netdb_data.hostent_mutex);
553 SCM_INTERNAL_MUTEX_INIT(netdb_data.protoent_mutex);
554 SCM_INTERNAL_MUTEX_INIT(netdb_data.servent_mutex);
555 }