13#if defined(INET6) && (defined(LOOKUP_ORDER_HACK_INET) || defined(LOOKUP_ORDER_HACK_INET6))
14#define LOOKUP_ORDERS (sizeof(lookup_order_table) / sizeof(lookup_order_table[0]))
15static const int lookup_order_table[] = {
16#if defined(LOOKUP_ORDER_HACK_INET)
18#elif defined(LOOKUP_ORDER_HACK_INET6)
26ruby_getaddrinfo(
const char *nodename,
const char *servname,
36 for (i = 0; i < LOOKUP_ORDERS; i++) {
37 af = lookup_order_table[i];
39 tmp_hints.ai_family = af;
53#define getaddrinfo(node,serv,hints,res) ruby_getaddrinfo((node),(serv),(hints),(res))
58ruby_getaddrinfo__aix(
const char *nodename,
const char *servname,
74#define getaddrinfo(node,serv,hints,res) ruby_getaddrinfo__aix((node),(serv),(hints),(res))
76ruby_getnameinfo__aix(
const struct sockaddr *sa,
size_t salen,
77 char *host,
size_t hostlen,
78 char *serv,
size_t servlen,
int flags)
80 struct sockaddr_in6 *sa6;
83 if (sa->sa_family == AF_INET6) {
84 sa6 = (
struct sockaddr_in6 *)sa;
85 a6 = sa6->sin6_addr.u6_addr.u6_addr32;
87 if (a6[0] == 0 && a6[1] == 0 && a6[2] == 0 && a6[3] == 0) {
88 strncpy(host,
"::", hostlen);
89 snprintf(serv, servlen,
"%d", sa6->sin6_port);
93 return getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
96#define getnameinfo(sa, salen, host, hostlen, serv, servlen, flags) \
97 ruby_getnameinfo__aix((sa), (salen), (host), (hostlen), (serv), (servlen), (flags))
100static int str_is_number(
const char *);
102#if defined(__APPLE__)
104ruby_getaddrinfo__darwin(
const char *nodename,
const char *servname,
108 const char *tmp_servname;
112 tmp_servname = servname;
114 if (nodename && servname) {
115 if (str_is_number(tmp_servname) && atoi(servname) == 0) {
118 if (tmp_hints.ai_flags) tmp_hints.ai_flags &= ~AI_NUMERICSERV;
145#define getaddrinfo(node,serv,hints,res) ruby_getaddrinfo__darwin((node),(serv),(hints),(res))
150parse_numeric_port(
const char *service,
int *portp)
159 if (strspn(service,
"0123456789") !=
strlen(service))
176#ifndef GETADDRINFO_EMU
186nogvl_getaddrinfo(
void *arg)
198 return (
void *)(
VALUE)ret;
203numeric_getaddrinfo(
const char *
node,
const char *
service,
208# if defined __MINGW64__
209# define inet_pton(f,s,d) rb_w32_inet_pton(f,s,d)
215 static const struct {
225 int hint_socktype = hints ? hints->
ai_socktype : 0;
226 int hint_protocol = hints ? hints->
ai_protocol : 0;
230 if ((hint_family ==
PF_UNSPEC || hint_family == PF_INET6) &&
231 strspn(node,
"0123456789abcdefABCDEF.:") ==
strlen(node) &&
232 inet_pton(AF_INET6, node, ipv6addr)) {
234 for (i =
numberof(list)-1; 0 <= i; i--) {
235 if ((hint_socktype == 0 || hint_socktype == list[i].socktype) &&
236 (hint_protocol == 0 || list[i].protocol == 0 || hint_protocol == list[i].protocol)) {
238 struct sockaddr_in6 *sa =
xmalloc(
sizeof(
struct sockaddr_in6));
240 memcpy(&sa->sin6_addr, ipv6addr,
sizeof(ipv6addr));
241 sa->sin6_port = htons(port);
244 ai0->
ai_protocol = hint_protocol ? hint_protocol : list[i].protocol;
245 ai0->
ai_addrlen =
sizeof(
struct sockaddr_in6);
246 ai0->
ai_addr = (
struct sockaddr *)sa;
256 strspn(node,
"0123456789.") ==
strlen(node) &&
257 inet_pton(AF_INET, node, ipv4addr)) {
259 for (i =
numberof(list)-1; 0 <= i; i--) {
260 if ((hint_socktype == 0 || hint_socktype == list[i].socktype) &&
261 (hint_protocol == 0 || list[i].protocol == 0 || hint_protocol == list[i].protocol)) {
263 struct sockaddr_in *sa =
xmalloc(
sizeof(
struct sockaddr_in));
265 memcpy(&sa->sin_addr, ipv4addr,
sizeof(ipv4addr));
266 sa->sin_port = htons(port);
269 ai0->
ai_protocol = hint_protocol ? hint_protocol : list[i].protocol;
271 ai0->
ai_addr = (
struct sockaddr *)sa;
294 int allocated_by_malloc = 0;
296 ret = numeric_getaddrinfo(node, service, hints, &ai);
298 allocated_by_malloc = 1;
300#ifdef GETADDRINFO_EMU
324 if (!
ai->allocated_by_malloc)
339#ifndef GETADDRINFO_EMU
342 const struct sockaddr *
sa;
352nogvl_getnameinfo(
void *arg)
367#ifdef GETADDRINFO_EMU
385make_ipaddr0(
struct sockaddr *addr,
socklen_t addrlen,
char *
buf,
size_t buflen)
400 make_ipaddr0(addr, addrlen, hbuf,
sizeof(hbuf));
405make_inetaddr(
unsigned int host,
char *
buf,
size_t buflen)
407 struct sockaddr_in sin;
410 sin.sin_addr.s_addr = host;
411 make_ipaddr0((
struct sockaddr*)&sin,
sizeof(sin),
buf, buflen);
415str_is_number(
const char *p)
419 if (!p || *p ==
'\0')
423 if (ep && *ep ==
'\0')
429#define str_equal(ptr, len, name) \
430 ((ptr)[0] == name[0] && \
431 rb_strlen_lit(name) == (len) && memcmp(ptr, name, len) == 0)
434host_str(
VALUE host,
char *hbuf,
size_t hbuflen,
int *flags_ptr)
442 make_inetaddr(htonl(i), hbuf, hbuflen);
460 else if (
len >= hbuflen) {
473port_str(
VALUE port,
char *pbuf,
size_t pbuflen,
int *flags_ptr)
491 if (
len >= pbuflen) {
508 int additional_flags = 0;
510 hostp = host_str(host, hbuf,
sizeof(hbuf), &additional_flags);
511 portp = port_str(port, pbuf,
sizeof(pbuf), &additional_flags);
513 if (socktype_hack && hints->
ai_socktype == 0 && str_is_number(portp)) {
516 hints->
ai_flags |= additional_flags;
520 if (hostp && hostp[
strlen(hostp)-1] ==
'\n') {
532 struct sockaddr sa = { 0 };
535 if (fd < 0 || getsockname(fd, &sa, &sa_len) != 0 ||
536 (size_t)sa_len <
offsetof(
struct sockaddr, sa_family) +
sizeof(sa.sa_family)) {
557 VALUE family, port, addr1, addr2;
560 char hbuf[1024], pbuf[1024];
568 sprintf(pbuf,
"unknown:%d", sockaddr->sa_family);
597unixsocket_len(
const struct sockaddr_un *su,
socklen_t socklen)
599 const char *s = su->sun_path, *e = (
const char*)su + socklen;
600 while (s < e && *(e-1) ==
'\0')
606rsock_unixpath_str(
struct sockaddr_un *sockaddr,
socklen_t len)
608 long n = unixsocket_len(sockaddr,
len);
616rsock_unixaddr(
struct sockaddr_un *sockaddr,
socklen_t len)
619 rsock_unixpath_str(sockaddr,
len));
623rsock_unix_sockaddr_len(
VALUE path)
639 return (
socklen_t)
sizeof(
struct sockaddr_un);
653make_hostent_internal(
VALUE v)
672 hostp = host_str(host, hbuf,
sizeof(hbuf),
NULL);
679 if (h->h_aliases !=
NULL) {
680 for (pch = h->h_aliases; *pch; pch++) {
690 for (ai = addr; ai; ai = ai->
ai_next) {
728addrinfo_mark(
void *
ptr)
735#define addrinfo_free RUBY_TYPED_DEFAULT_FREE
738addrinfo_memsize(
const void *
ptr)
749addrinfo_s_allocate(
VALUE klass)
754#define IS_ADDRINFO(obj) rb_typeddata_is_kind_of((obj), &addrinfo_type)
756check_addrinfo(
VALUE self)
762get_addrinfo(
VALUE self)
784 int pfamily,
int socktype,
int protocol,
801 int family,
int socktype,
int protocol,
808 DATA_PTR(a) = rai = alloc_addrinfo();
809 init_addrinfo(rai, addr,
len, family, socktype, protocol, canonname, inspectname);
816 int socktype_hack,
VALUE timeout)
824 if (!
NIL_P(socktype)) {
827 if (!
NIL_P(protocol)) {
848 struct rb_addrinfo *res = call_getaddrinfo(node, service, family, socktype, protocol, flags, 1,
Qnil);
850 VALUE inspectname =
rb_str_equal(node, inspectnode) ?
Qnil : make_inspectname(inspectnode, inspectservice, res->
ai);
860 canonname, inspectname);
875 sizeof(hbuf), pbuf,
sizeof(pbuf),
882 else if (RB_TYPE_P(service,
T_FIXNUM) && atoi(pbuf) ==
FIX2INT(service))
891 if (
NIL_P(inspectname))
898 if (
NIL_P(inspectname))
903 if (!
NIL_P(inspectname)) {
916 struct rb_addrinfo *res = call_getaddrinfo(node, service, family, socktype, protocol, flags, 0,
Qnil);
918 inspectname = make_inspectname(node, service, res->
ai);
929 canonname, inspectname);
942 struct rb_addrinfo *res = call_getaddrinfo(node, service, family, socktype, protocol, flags, 0, timeout);
944 inspectname = make_inspectname(node, service, res->
ai);
958 canonname, inspectname);
972 struct sockaddr_un un;
977 if (
sizeof(un.sun_path) < (
size_t)
RSTRING_LEN(path))
979 "too long unix socket path (%"PRIuSIZE" bytes given but %"PRIuSIZE" bytes max)",
982 INIT_SOCKADDR_UN(&un,
sizeof(
struct sockaddr_un));
985 len = rsock_unix_sockaddr_len(path);
986 init_addrinfo(rai, (
struct sockaddr *)&un,
len,
1047 VALUE sockaddr_arg, sockaddr_ary, pfamily, socktype, protocol;
1048 int i_pfamily, i_socktype, i_protocol;
1049 struct sockaddr *sockaddr_ptr;
1053 if (check_addrinfo(self))
1055 DATA_PTR(self) = rai = alloc_addrinfo();
1064 if (!
NIL_P(sockaddr_ary)) {
1082 if (!
NIL_P(nodename))
1086#ifdef AI_NUMERICSERV
1090 init_addrinfo_getaddrinfo(rai, numericnode, service,
1102 init_unix_addrinfo(rai, path, SOCK_STREAM);
1113 sockaddr_ptr = (
struct sockaddr *)
RSTRING_PTR(sockaddr_arg);
1115 init_addrinfo(rai, sockaddr_ptr, sockaddr_len,
1116 i_pfamily, i_socktype, i_protocol,
1117 canonname, inspectname);
1126 if ((
socklen_t)((
const char*)&addr->sa_family +
sizeof(addr->sa_family) - (
char*)addr) <=
len)
1127 return addr->sa_family;
1154 else if ((
long)socklen < ((
char*)&sockaddr->
addr.sa_family +
sizeof(sockaddr->
addr.sa_family)) - (
char*)sockaddr)
1157 switch (sockaddr->
addr.sa_family) {
1166 struct sockaddr_in *addr;
1168 addr = &sockaddr->
in;
1169 if ((
socklen_t)(((
char*)&addr->sin_addr)-(
char*)addr+0+1) <= socklen)
1170 rb_str_catf(ret,
"%d", ((
unsigned char*)&addr->sin_addr)[0]);
1173 if ((
socklen_t)(((
char*)&addr->sin_addr)-(
char*)addr+1+1) <= socklen)
1174 rb_str_catf(ret,
".%d", ((
unsigned char*)&addr->sin_addr)[1]);
1177 if ((
socklen_t)(((
char*)&addr->sin_addr)-(
char*)addr+2+1) <= socklen)
1178 rb_str_catf(ret,
".%d", ((
unsigned char*)&addr->sin_addr)[2]);
1181 if ((
socklen_t)(((
char*)&addr->sin_addr)-(
char*)addr+3+1) <= socklen)
1182 rb_str_catf(ret,
".%d", ((
unsigned char*)&addr->sin_addr)[3]);
1186 if ((
socklen_t)(((
char*)&addr->sin_port)-(
char*)addr+(
int)
sizeof(addr->sin_port)) < socklen) {
1187 port = ntohs(addr->sin_port);
1194 if ((
socklen_t)
sizeof(
struct sockaddr_in) != socklen)
1195 rb_str_catf(ret,
" (%d bytes for %d bytes sockaddr_in)",
1197 (
int)
sizeof(
struct sockaddr_in));
1204 struct sockaddr_in6 *addr;
1208 if (socklen < (
socklen_t)
sizeof(
struct sockaddr_in6)) {
1209 rb_str_catf(ret,
"too-short-AF_INET6-sockaddr %d bytes", (
int)socklen);
1212 addr = &sockaddr->in6;
1223 if (addr->sin6_port == 0) {
1227 port = ntohs(addr->sin6_port);
1230 if ((
socklen_t)
sizeof(
struct sockaddr_in6) < socklen)
1231 rb_str_catf(ret,
"(sockaddr %d bytes too long)", (
int)(socklen -
sizeof(
struct sockaddr_in6)));
1240 struct sockaddr_un *addr = &sockaddr->un;
1242 long len = unixsocket_len(addr, socklen);
1249 int printable_only = 1;
1256 if (printable_only) {
1271#if defined(AF_PACKET) && defined(__linux__)
1275 struct sockaddr_ll *addr;
1276 const char *sep =
"[";
1277#define CATSEP do { rb_str_cat2(ret, sep); sep = " "; } while (0);
1279 addr = (
struct sockaddr_ll *)sockaddr;
1283 if (
offsetof(
struct sockaddr_ll, sll_protocol) +
sizeof(addr->sll_protocol) <= (
size_t)socklen) {
1285 rb_str_catf(ret,
"protocol=%d", ntohs(addr->sll_protocol));
1287 if (
offsetof(
struct sockaddr_ll, sll_ifindex) +
sizeof(addr->sll_ifindex) <= (
size_t)socklen) {
1290 if (if_indextoname(addr->sll_ifindex,
buf) ==
NULL)
1291 rb_str_catf(ret,
"ifindex=%d", addr->sll_ifindex);
1295 if (
offsetof(
struct sockaddr_ll, sll_hatype) +
sizeof(addr->sll_hatype) <= (
size_t)socklen) {
1299 if (
offsetof(
struct sockaddr_ll, sll_pkttype) +
sizeof(addr->sll_pkttype) <= (
size_t)socklen) {
1301 if (addr->sll_pkttype == PACKET_HOST)
1303 else if (addr->sll_pkttype == PACKET_BROADCAST)
1305 else if (addr->sll_pkttype == PACKET_MULTICAST)
1307 else if (addr->sll_pkttype == PACKET_OTHERHOST)
1309 else if (addr->sll_pkttype == PACKET_OUTGOING)
1312 rb_str_catf(ret,
"pkttype=%d", addr->sll_pkttype);
1314 if (socklen != (
socklen_t)(
offsetof(
struct sockaddr_ll, sll_addr) + addr->sll_halen)) {
1316 if (
offsetof(
struct sockaddr_ll, sll_halen) +
sizeof(addr->sll_halen) <= (
size_t)socklen) {
1320 if (
offsetof(
struct sockaddr_ll, sll_addr) < (
size_t)socklen) {
1324 len = addr->sll_halen;
1325 if ((
size_t)socklen <
offsetof(
struct sockaddr_ll, sll_addr) +
len)
1326 len = socklen -
offsetof(
struct sockaddr_ll, sll_addr);
1327 for (i = 0; i <
len; i++) {
1333 if (socklen < (
socklen_t)(
offsetof(
struct sockaddr_ll, sll_halen) +
sizeof(addr->sll_halen)) ||
1334 (
socklen_t)(
offsetof(
struct sockaddr_ll, sll_addr) + addr->sll_halen) != socklen) {
1336 rb_str_catf(ret,
"(%d bytes for %d bytes sockaddr_ll)",
1337 (
int)socklen, (
int)
sizeof(
struct sockaddr_ll));
1347#if defined(AF_LINK) && defined(HAVE_TYPE_STRUCT_SOCKADDR_DL)
1362 struct sockaddr_dl *addr = &sockaddr->dl;
1363 char *np =
NULL, *ap =
NULL, *endp;
1364 int nlen = 0, alen = 0;
1366 const char *sep =
"[";
1367#define CATSEP do { rb_str_cat2(ret, sep); sep = " "; } while (0);
1371 endp = ((
char *)addr) + socklen;
1373 if (
offsetof(
struct sockaddr_dl, sdl_data) < socklen) {
1374 np = addr->sdl_data;
1375 nlen = addr->sdl_nlen;
1376 if (endp - np < nlen)
1377 nlen = (
int)(endp - np);
1379 off = addr->sdl_nlen;
1381 if (
offsetof(
struct sockaddr_dl, sdl_data) + off < socklen) {
1382 ap = addr->sdl_data + off;
1383 alen = addr->sdl_alen;
1384 if (endp - ap < alen)
1385 alen = (
int)(endp - ap);
1394 if (ap && 0 < alen) {
1396 for (i = 0; i < alen; i++)
1397 rb_str_catf(ret,
"%s%02x", i == 0 ?
"" :
":", (
unsigned char)ap[i]);
1400 if (socklen < (
socklen_t)(
offsetof(
struct sockaddr_dl, sdl_nlen) +
sizeof(addr->sdl_nlen)) ||
1401 socklen < (
socklen_t)(
offsetof(
struct sockaddr_dl, sdl_alen) +
sizeof(addr->sdl_alen)) ||
1402 socklen < (
socklen_t)(
offsetof(
struct sockaddr_dl, sdl_slen) +
sizeof(addr->sdl_slen)) ||
1405 socklen < (
socklen_t)(
offsetof(
struct sockaddr_dl, sdl_data) + addr->sdl_nlen + addr->sdl_alen + addr->sdl_slen)) {
1407 rb_str_catf(ret,
"(%d bytes for %d bytes sockaddr_dl)",
1408 (
int)socklen, (
int)
sizeof(
struct sockaddr_dl));
1421 rb_str_catf(ret,
"unknown address family %d", sockaddr->
addr.sa_family);
1443addrinfo_inspect(
VALUE self)
1451 inspect_sockaddr(self, ret);
1463 internet_p = internet_p || rai->
pfamily == PF_INET6;
1465 if (internet_p && rai->
socktype == SOCK_STREAM &&
1469 else if (internet_p && rai->
socktype == SOCK_DGRAM &&
1488 goto unknown_protocol;
1525 return inspect_sockaddr(self,
rb_str_new(
"", 0));
1530addrinfo_mdump(
VALUE self)
1533 VALUE sockaddr, afamily, pfamily, socktype, protocol, canonname, inspectname;
1534 int afamily_int = ai_get_afamily(rai);
1572 switch(afamily_int) {
1576 sockaddr =
rb_str_new(rai->
addr.un.sun_path, rai_unixsocket_len(rai));
1596 return rb_ary_new3(7, afamily, sockaddr, pfamily, socktype, protocol, canonname, inspectname);
1604 VALUE canonname, inspectname;
1605 int afamily, pfamily, socktype, protocol;
1610 if (check_addrinfo(self))
1669 struct sockaddr_un uaddr;
1670 INIT_SOCKADDR_UN(&uaddr,
sizeof(
struct sockaddr_un));
1673 if (
sizeof(uaddr.sun_path) < (
size_t)
RSTRING_LEN(v))
1675 "too long AF_UNIX path (%"PRIuSIZE" bytes given but %"PRIuSIZE" bytes max)",
1689#ifdef AI_NUMERICSERV
1703 DATA_PTR(self) = rai = alloc_addrinfo();
1704 init_addrinfo(rai, &ss.
addr,
len,
1705 pfamily, socktype, protocol,
1706 canonname, inspectname);
1720addrinfo_afamily(
VALUE self)
1723 return INT2NUM(ai_get_afamily(rai));
1736addrinfo_pfamily(
VALUE self)
1752addrinfo_socktype(
VALUE self)
1768addrinfo_protocol(
VALUE self)
1786addrinfo_to_sockaddr(
VALUE self)
1810addrinfo_canonname(
VALUE self)
1829addrinfo_ip_p(
VALUE self)
1832 int family = ai_get_afamily(rai);
1849addrinfo_ipv4_p(
VALUE self)
1852 return ai_get_afamily(rai) == AF_INET ?
Qtrue :
Qfalse;
1868addrinfo_ipv6_p(
VALUE self)
1872 return ai_get_afamily(rai) == AF_INET6 ?
Qtrue :
Qfalse;
1891addrinfo_unix_p(
VALUE self)
1895 return ai_get_afamily(rai) == AF_UNIX ?
Qtrue :
Qfalse;
1921 char hbuf[1024], pbuf[1024];
1951addrinfo_ip_unpack(
VALUE self)
1954 int family = ai_get_afamily(rai);
1962 ret = addrinfo_getnameinfo(1, &vflags, self);
1978addrinfo_ip_address(
VALUE self)
1981 int family = ai_get_afamily(rai);
1989 ret = addrinfo_getnameinfo(1, &vflags, self);
2003addrinfo_ip_port(
VALUE self)
2006 int family = ai_get_afamily(rai);
2022 port = ntohs(rai->
addr.
in.sin_port);
2029 port = ntohs(rai->
addr.in6.sin6_port);
2044 int family = ai_get_afamily(rai);
2045 if (family != AF_INET)
return 0;
2046 *addrp = ntohl(rai->
addr.
in.sin_addr.s_addr);
2055addrinfo_ipv4_private_p(
VALUE self)
2058 if (!extract_in_addr(self, &a))
return Qfalse;
2059 if ((a & 0xff000000) == 0x0a000000 ||
2060 (a & 0xfff00000) == 0xac100000 ||
2061 (a & 0xffff0000) == 0xc0a80000)
2071addrinfo_ipv4_loopback_p(
VALUE self)
2074 if (!extract_in_addr(self, &a))
return Qfalse;
2075 if ((a & 0xff000000) == 0x7f000000)
2085addrinfo_ipv4_multicast_p(
VALUE self)
2088 if (!extract_in_addr(self, &a))
return Qfalse;
2089 if ((a & 0xf0000000) == 0xe0000000)
2096static struct in6_addr *
2097extract_in6_addr(
VALUE self)
2100 int family = ai_get_afamily(rai);
2101 if (family != AF_INET6)
return NULL;
2102 return &rai->
addr.in6.sin6_addr;
2110addrinfo_ipv6_unspecified_p(
VALUE self)
2112 struct in6_addr *addr = extract_in6_addr(self);
2113 if (addr && IN6_IS_ADDR_UNSPECIFIED(addr))
return Qtrue;
2122addrinfo_ipv6_loopback_p(
VALUE self)
2124 struct in6_addr *addr = extract_in6_addr(self);
2125 if (addr && IN6_IS_ADDR_LOOPBACK(addr))
return Qtrue;
2134addrinfo_ipv6_multicast_p(
VALUE self)
2136 struct in6_addr *addr = extract_in6_addr(self);
2137 if (addr && IN6_IS_ADDR_MULTICAST(addr))
return Qtrue;
2146addrinfo_ipv6_linklocal_p(
VALUE self)
2148 struct in6_addr *addr = extract_in6_addr(self);
2149 if (addr && IN6_IS_ADDR_LINKLOCAL(addr))
return Qtrue;
2158addrinfo_ipv6_sitelocal_p(
VALUE self)
2160 struct in6_addr *addr = extract_in6_addr(self);
2161 if (addr && IN6_IS_ADDR_SITELOCAL(addr))
return Qtrue;
2170addrinfo_ipv6_unique_local_p(
VALUE self)
2172 struct in6_addr *addr = extract_in6_addr(self);
2182addrinfo_ipv6_v4mapped_p(
VALUE self)
2184 struct in6_addr *addr = extract_in6_addr(self);
2185 if (addr && IN6_IS_ADDR_V4MAPPED(addr))
return Qtrue;
2194addrinfo_ipv6_v4compat_p(
VALUE self)
2196 struct in6_addr *addr = extract_in6_addr(self);
2197 if (addr && IN6_IS_ADDR_V4COMPAT(addr))
return Qtrue;
2206addrinfo_ipv6_mc_nodelocal_p(
VALUE self)
2208 struct in6_addr *addr = extract_in6_addr(self);
2209 if (addr && IN6_IS_ADDR_MC_NODELOCAL(addr))
return Qtrue;
2218addrinfo_ipv6_mc_linklocal_p(
VALUE self)
2220 struct in6_addr *addr = extract_in6_addr(self);
2221 if (addr && IN6_IS_ADDR_MC_LINKLOCAL(addr))
return Qtrue;
2230addrinfo_ipv6_mc_sitelocal_p(
VALUE self)
2232 struct in6_addr *addr = extract_in6_addr(self);
2233 if (addr && IN6_IS_ADDR_MC_SITELOCAL(addr))
return Qtrue;
2242addrinfo_ipv6_mc_orglocal_p(
VALUE self)
2244 struct in6_addr *addr = extract_in6_addr(self);
2245 if (addr && IN6_IS_ADDR_MC_ORGLOCAL(addr))
return Qtrue;
2254addrinfo_ipv6_mc_global_p(
VALUE self)
2256 struct in6_addr *addr = extract_in6_addr(self);
2257 if (addr && IN6_IS_ADDR_MC_GLOBAL(addr))
return Qtrue;
2272addrinfo_ipv6_to_ipv4(
VALUE self)
2275 struct in6_addr *addr;
2276 int family = ai_get_afamily(rai);
2277 if (family != AF_INET6)
return Qnil;
2278 addr = &rai->
addr.in6.sin6_addr;
2279 if (IN6_IS_ADDR_V4MAPPED(addr) || IN6_IS_ADDR_V4COMPAT(addr)) {
2280 struct sockaddr_in sin4;
2282 memcpy(&sin4.sin_addr, (
char*)addr +
sizeof(*addr) -
sizeof(sin4.sin_addr),
sizeof(sin4.sin_addr));
2304addrinfo_unix_path(
VALUE self)
2307 int family = ai_get_afamily(rai);
2308 struct sockaddr_un *addr;
2311 if (family != AF_UNIX)
2314 addr = &rai->
addr.un;
2316 n = rai_unixsocket_len(rai);
2320 if ((
long)
sizeof(addr->sun_path) < n)
2322 "too long AF_UNIX path (%"PRIuSIZE" bytes given but %"PRIuSIZE" bytes max)",
2323 (
size_t)n,
sizeof(addr->sun_path));
2328static ID id_timeout;
2376 VALUE node, service, family, socktype, protocol, flags, opts, timeout;
2379 &protocol, &flags, &opts);
2385 return addrinfo_list_new(node, service, family, socktype, protocol, flags, timeout);
2404 ret = addrinfo_firstonly_new(host,
Qnil,
2406 rai = get_addrinfo(ret);
2423 return addrinfo_firstonly_new(host, port,
2438 return addrinfo_firstonly_new(host, port,
2459 VALUE path, vsocktype, addr;
2465 if (
NIL_P(vsocktype))
2466 socktype = SOCK_STREAM;
2471 DATA_PTR(addr) = rai = alloc_addrinfo();
2472 init_unix_addrinfo(rai, path, socktype);
2483 *v = addrinfo_to_sockaddr(val);
2495 *v = addrinfo_to_sockaddr(val);
2513 return addrinfo_to_sockaddr(val);
2526 family = get_afamily(addr,
len);
2528 ret = getsockopt(fd, SOL_SOCKET, SO_TYPE, (
void*)&socktype, &optlen);
#define offsetof(p_type, field)
void rb_ary_store(VALUE ary, long idx, VALUE val)
VALUE rb_ary_push(VALUE ary, VALUE item)
VALUE rb_check_array_type(VALUE ary)
VALUE rb_ary_entry(VALUE ary, long offset)
VALUE rb_assoc_new(VALUE car, VALUE cdr)
#define UNREACHABLE_RETURN
int rsock_family_arg(VALUE domain)
int rsock_socktype_arg(VALUE type)
int rsock_family_to_int(const char *str, long len, int *valp)
int rsock_socktype_to_int(const char *str, long len, int *valp)
ID rsock_intern_family(int val)
ID rsock_intern_socktype(int val)
int rsock_ipproto_to_int(const char *str, long len, int *valp)
ID rsock_intern_ipproto(int val)
ID rsock_intern_protocol_family(int val)
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
#define RSTRING_LEN(string)
#define RSTRING_PTR(string)
void rb_gc_mark(VALUE ptr)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
void rb_raise(VALUE exc, const char *fmt,...)
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
VALUE rb_ensure(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*e_proc)(VALUE), VALUE data2)
An equivalent to ensure clause.
void rb_sys_fail(const char *mesg)
VALUE rb_convert_type(VALUE, int, const char *, const char *)
Converts an object into another type.
VALUE rb_cObject
Object class.
VALUE rb_obj_is_kind_of(VALUE, VALUE)
Determines if obj is a kind of c.
#define rb_str_new(str, len)
VALUE rb_str_cat(VALUE, const char *, long)
VALUE rb_check_string_type(VALUE)
VALUE rb_str_equal(VALUE str1, VALUE str2)
#define rb_str_new_cstr(str)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
const char * rb_id2name(ID)
ID rb_intern(const char *)
void * rb_thread_call_without_gvl(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2)
void rsock_raise_socket_error(const char *reason, int error)
typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque
#define MEMCPY(p1, p2, type, n)
#define MEMZERO(p, type, n)
void rb_freeaddrinfo(struct rb_addrinfo *ai)
VALUE rsock_addrinfo_new(struct sockaddr *addr, socklen_t len, int family, int socktype, int protocol, VALUE canonname, VALUE inspectname)
VALUE rsock_sockaddr_string_value(volatile VALUE *v)
VALUE rsock_freeaddrinfo(VALUE arg)
void rsock_init_addrinfo(void)
char * rsock_sockaddr_string_value_ptr(volatile VALUE *v)
struct rb_addrinfo * rsock_getaddrinfo(VALUE host, VALUE port, struct addrinfo *hints, int socktype_hack)
VALUE rsock_make_hostent(VALUE host, struct rb_addrinfo *addr, VALUE(*ipaddr)(struct sockaddr *, socklen_t))
VALUE rsock_make_ipaddr(struct sockaddr *addr, socklen_t addrlen)
VALUE rsock_addrinfo_inspect_sockaddr(VALUE self)
#define str_equal(ptr, len, name)
VALUE rsock_inspect_sockaddr(struct sockaddr *sockaddr_arg, socklen_t socklen, VALUE ret)
VALUE rb_check_sockaddr_string_type(VALUE val)
VALUE rsock_sockaddr_string_value_with_addrinfo(volatile VALUE *v, VALUE *rai_ret)
int rb_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct rb_addrinfo **res)
struct rb_addrinfo * rsock_addrinfo(VALUE host, VALUE port, int family, int socktype, int flags)
VALUE rsock_ipaddr(struct sockaddr *sockaddr, socklen_t sockaddrlen, int norevlookup)
int rsock_fd_family(int fd)
int rb_getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags)
VALUE rsock_fd_socket_addrinfo(int fd, struct sockaddr *addr, socklen_t len)
VALUE rsock_io_socket_addrinfo(VALUE io, struct sockaddr *addr, socklen_t len)
#define RSTRING_GETMEM(str, ptrvar, lenvar)
#define StringValueCStr(v)
#define TypedData_Wrap_Struct(klass, data_type, sval)
const char * rb_obj_classname(VALUE)
#define IN6_IS_ADDR_UNIQUE_LOCAL(a)
#define INIT_SOCKADDR_IN(addr, len)
#define INIT_SOCKADDR_IN6(addr, len)
VALUE rb_str_catf(VALUE, const char *,...)
VALUE rb_sprintf(const char *,...)
size_t strlen(const char *)
struct sockaddr * ai_addr
struct addrinfo * ai_next
const struct addrinfo * hints
const struct sockaddr * sa
VALUE(* ipaddr)(struct sockaddr *, socklen_t)
struct rb_addrinfo * addr
void error(const char *msg)
#define ZALLOC(strm, items, size)