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]))
15 static const int lookup_order_table[] = {
16 #if defined(LOOKUP_ORDER_HACK_INET)
18 #elif defined(LOOKUP_ORDER_HACK_INET6)
26 ruby_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;
40 error =
getaddrinfo(nodename, servname, &tmp_hints, res);
53 #define getaddrinfo(node,serv,hints,res) ruby_getaddrinfo((node),(serv),(hints),(res))
58 ruby_getaddrinfo__aix(
const char *nodename,
const char *servname,
61 int error =
getaddrinfo(nodename, servname, hints, res);
74 #define getaddrinfo(node,serv,hints,res) ruby_getaddrinfo__aix((node),(serv),(hints),(res))
76 ruby_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))
102 #if defined(__APPLE__)
104 ruby_getaddrinfo__darwin(
const char *nodename,
const char *servname,
108 const char *tmp_servname;
112 tmp_servname = servname;
114 if (nodename && servname) {
117 #ifdef AI_NUMERICSERV
123 error =
getaddrinfo(nodename, tmp_servname, &tmp_hints, res);
145 #define getaddrinfo(node,serv,hints,res) ruby_getaddrinfo__darwin((node),(serv),(hints),(res))
148 #ifndef GETADDRINFO_EMU
170 return (
void *)(
VALUE)ret;
179 #ifdef GETADDRINFO_EMU
194 #ifndef GETADDRINFO_EMU
197 const struct sockaddr *
sa;
219 char *host,
size_t hostlen,
220 char *serv,
size_t servlen,
int flags)
222 #ifdef GETADDRINFO_EMU
223 return getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
262 struct sockaddr_in sin;
264 MEMZERO(&sin,
struct sockaddr_in, 1);
265 sin.sin_family = AF_INET;
267 sin.sin_addr.s_addr = host;
268 make_ipaddr0((
struct sockaddr*)&sin,
sizeof(sin), buf, buflen);
276 if (!p || *p ==
'\0')
280 if (ep && *ep ==
'\0')
304 if (!name || *name == 0 || (name[0] ==
'<' && strcmp(name,
"<any>") == 0)) {
308 else if (name[0] ==
'<' && strcmp(name,
"<broadcast>") == 0) {
312 else if (
strlen(name) >= hbuflen) {
331 #ifdef AI_NUMERICSERV
341 if (
strlen(serv) >= pbuflen) {
357 int additional_flags = 0;
359 hostp =
host_str(host, hbuf,
sizeof(hbuf), &additional_flags);
360 portp =
port_str(port, pbuf,
sizeof(pbuf), &additional_flags);
365 hints->
ai_flags |= additional_flags;
369 if (hostp && hostp[
strlen(hostp)-1] ==
'\n') {
391 rsock_ipaddr(
struct sockaddr *sockaddr, socklen_t sockaddrlen,
int norevlookup)
393 VALUE family, port, addr1, addr2;
396 char hbuf[1024], pbuf[1024];
404 sprintf(pbuf,
"unknown:%d", sockaddr->sa_family);
433 rsock_unixpath_str(
struct sockaddr_un *sockaddr, socklen_t len)
436 s = sockaddr->sun_path;
437 e = (
char *)sockaddr + len;
438 while (s < e && *(e-1) ==
'\0')
447 rsock_unixaddr(
struct sockaddr_un *sockaddr, socklen_t len)
450 rsock_unixpath_str(sockaddr, len));
454 rsock_unix_sockaddr_len(
VALUE path)
459 return (socklen_t)
sizeof(sa_family_t);
463 return (socklen_t)
offsetof(
struct sockaddr_un, sun_path) +
468 return (socklen_t)
sizeof(
struct sockaddr_un);
486 VALUE (*ipaddr)(
struct sockaddr*, size_t) = arg->
ipaddr;
507 if (h->h_aliases !=
NULL) {
508 for (pch = h->h_aliases; *pch; pch++) {
518 for (ai = addr; ai; ai = ai->
ai_next) {
519 rb_ary_push(ary, (*ipaddr)(ai->ai_addr, ai->ai_addrlen));
564 #define addrinfo_free RUBY_TYPED_DEFAULT_FREE
583 #define IS_ADDRINFO(obj) rb_typeddata_is_kind_of((obj), &addrinfo_type)
614 int pfamily,
int socktype,
int protocol,
617 if ((socklen_t)
sizeof(rai->
addr) < len)
619 memcpy((
void *)&rai->
addr, (
void *)sa, len);
631 int family,
int socktype,
int protocol,
639 init_addrinfo(rai, addr, len, family, socktype, protocol, canonname, inspectname);
653 if (!
NIL_P(socktype)) {
656 if (!
NIL_P(protocol)) {
688 canonname, inspectname);
703 sizeof(hbuf), pbuf,
sizeof(pbuf),
719 if (
NIL_P(inspectname))
726 if (
NIL_P(inspectname))
731 if (!
NIL_P(inspectname)) {
758 canonname, inspectname);
776 for (r = res; r; r = r->
ai_next) {
787 canonname, inspectname);
801 struct sockaddr_un un;
806 if (
sizeof(un.sun_path) < (
size_t)
RSTRING_LEN(path))
808 "too long unix socket path (%"PRIuSIZE" bytes given but %"PRIuSIZE" bytes max)",
811 MEMZERO(&un,
struct sockaddr_un, 1);
813 un.sun_family = AF_UNIX;
816 len = rsock_unix_sockaddr_len(path);
872 VALUE sockaddr_arg, sockaddr_ary, pfamily, socktype, protocol;
873 int i_pfamily, i_socktype, i_protocol;
874 struct sockaddr *sockaddr_ptr;
875 socklen_t sockaddr_len;
882 rb_scan_args(argc, argv,
"13", &sockaddr_arg, &pfamily, &socktype, &protocol);
889 if (!
NIL_P(sockaddr_ary)) {
907 if (!
NIL_P(nodename))
911 #ifdef AI_NUMERICSERV
927 init_unix_addrinfo(rai, path, SOCK_STREAM);
938 sockaddr_ptr = (
struct sockaddr *)
RSTRING_PTR(sockaddr_arg);
941 i_pfamily, i_socktype, i_protocol,
942 canonname, inspectname);
951 if ((socklen_t)((
char*)&addr->sa_family +
sizeof(addr->sa_family) - (
char*)addr) <= len)
952 return addr->sa_family;
977 struct sockaddr_in *addr;
979 if (rai->
sockaddr_len < (socklen_t)
sizeof(
struct sockaddr_in)) {
983 addr = (
struct sockaddr_in *)&rai->
addr;
985 ((
unsigned char*)&addr->sin_addr)[0],
986 ((
unsigned char*)&addr->sin_addr)[1],
987 ((
unsigned char*)&addr->sin_addr)[2],
988 ((
unsigned char*)&addr->sin_addr)[3]);
989 port = ntohs(addr->sin_port);
992 if ((socklen_t)
sizeof(
struct sockaddr_in) < rai->
sockaddr_len)
1001 struct sockaddr_in6 *addr;
1005 if (rai->
sockaddr_len < (socklen_t)
sizeof(
struct sockaddr_in6)) {
1009 addr = (
struct sockaddr_in6 *)&rai->
addr;
1015 hbuf, (socklen_t)
sizeof(hbuf),
NULL, 0,
1020 if (addr->sin6_port == 0) {
1024 port = ntohs(addr->sin6_port);
1027 if ((socklen_t)
sizeof(
struct sockaddr_in6) < rai->
sockaddr_len)
1034 #ifdef HAVE_SYS_UN_H
1037 struct sockaddr_un *addr = (
struct sockaddr_un *)&rai->
addr;
1041 while (s < e && *(e-1) ==
'\0')
1048 int printable_only = 1;
1054 if (printable_only) {
1064 if (addr->sun_path +
sizeof(addr->sun_path) < (
char*)&rai->
addr + rai->
sockaddr_len)
1066 (
int)(rai->
sockaddr_len - (addr->sun_path +
sizeof(addr->sun_path) - (
char*)&rai->
addr)));
1118 internet_p = internet_p || rai->
pfamily == PF_INET6;
1120 if (internet_p && rai->
socktype == SOCK_STREAM &&
1124 else if (internet_p && rai->
socktype == SOCK_DGRAM &&
1143 goto unknown_protocol;
1188 VALUE sockaddr, afamily, pfamily, socktype, protocol, canonname, inspectname;
1227 switch(afamily_int) {
1228 #ifdef HAVE_SYS_UN_H
1231 struct sockaddr_un *su = (
struct sockaddr_un *)&rai->
addr;
1235 while (s < e && *(e-1) ==
'\0')
1247 hbuf, (socklen_t)
sizeof(hbuf), pbuf, (socklen_t)
sizeof(pbuf),
1257 return rb_ary_new3(7, afamily, sockaddr, pfamily, socktype, protocol, canonname, inspectname);
1265 VALUE canonname, inspectname;
1266 int afamily, pfamily, socktype, protocol;
1327 #ifdef HAVE_SYS_UN_H
1330 struct sockaddr_un uaddr;
1331 MEMZERO(&uaddr,
struct sockaddr_un, 1);
1332 uaddr.sun_family = AF_UNIX;
1335 if (
sizeof(uaddr.sun_path) < (
size_t)
RSTRING_LEN(v))
1337 "too long AF_UNIX path (%"PRIuSIZE
" bytes given but %"PRIuSIZE
" bytes max)",
1340 len = (socklen_t)
sizeof(uaddr);
1341 memcpy(&ss, &uaddr, len);
1351 #ifdef AI_NUMERICSERV
1366 pfamily, socktype, protocol,
1367 canonname, inspectname);
1583 char hbuf[1024], pbuf[1024];
1594 hbuf, (socklen_t)
sizeof(hbuf), pbuf, (socklen_t)
sizeof(pbuf),
1684 port = ntohs(((
struct sockaddr_in *)&rai->
addr)->sin_port);
1691 port = ntohs(((
struct sockaddr_in6 *)&rai->
addr)->sin6_port);
1707 if (family != AF_INET)
return 0;
1708 *addrp = ntohl(((
struct sockaddr_in *)&rai->
addr)->sin_addr.s_addr);
1721 if ((a & 0xff000000) == 0x0a000000 ||
1722 (a & 0xfff00000) == 0xac100000 ||
1723 (a & 0xffff0000) == 0xc0a80000)
1737 if ((a & 0xff000000) == 0x7f000000)
1751 if ((a & 0xf0000000) == 0xe0000000)
1758 static struct in6_addr *
1759 extract_in6_addr(
VALUE self)
1763 if (family != AF_INET6)
return NULL;
1764 return &((
struct sockaddr_in6 *)&rai->
addr)->sin6_addr;
1772 addrinfo_ipv6_unspecified_p(
VALUE self)
1774 struct in6_addr *addr = extract_in6_addr(
self);
1775 if (addr && IN6_IS_ADDR_UNSPECIFIED(addr))
return Qtrue;
1784 addrinfo_ipv6_loopback_p(
VALUE self)
1786 struct in6_addr *addr = extract_in6_addr(
self);
1787 if (addr && IN6_IS_ADDR_LOOPBACK(addr))
return Qtrue;
1796 addrinfo_ipv6_multicast_p(
VALUE self)
1798 struct in6_addr *addr = extract_in6_addr(
self);
1799 if (addr && IN6_IS_ADDR_MULTICAST(addr))
return Qtrue;
1808 addrinfo_ipv6_linklocal_p(
VALUE self)
1810 struct in6_addr *addr = extract_in6_addr(
self);
1811 if (addr && IN6_IS_ADDR_LINKLOCAL(addr))
return Qtrue;
1820 addrinfo_ipv6_sitelocal_p(
VALUE self)
1822 struct in6_addr *addr = extract_in6_addr(
self);
1823 if (addr && IN6_IS_ADDR_SITELOCAL(addr))
return Qtrue;
1832 addrinfo_ipv6_unique_local_p(
VALUE self)
1834 struct in6_addr *addr = extract_in6_addr(
self);
1844 addrinfo_ipv6_v4mapped_p(
VALUE self)
1846 struct in6_addr *addr = extract_in6_addr(
self);
1847 if (addr && IN6_IS_ADDR_V4MAPPED(addr))
return Qtrue;
1856 addrinfo_ipv6_v4compat_p(
VALUE self)
1858 struct in6_addr *addr = extract_in6_addr(
self);
1859 if (addr && IN6_IS_ADDR_V4COMPAT(addr))
return Qtrue;
1868 addrinfo_ipv6_mc_nodelocal_p(
VALUE self)
1870 struct in6_addr *addr = extract_in6_addr(
self);
1871 if (addr && IN6_IS_ADDR_MC_NODELOCAL(addr))
return Qtrue;
1880 addrinfo_ipv6_mc_linklocal_p(
VALUE self)
1882 struct in6_addr *addr = extract_in6_addr(
self);
1883 if (addr && IN6_IS_ADDR_MC_LINKLOCAL(addr))
return Qtrue;
1892 addrinfo_ipv6_mc_sitelocal_p(
VALUE self)
1894 struct in6_addr *addr = extract_in6_addr(
self);
1895 if (addr && IN6_IS_ADDR_MC_SITELOCAL(addr))
return Qtrue;
1904 addrinfo_ipv6_mc_orglocal_p(
VALUE self)
1906 struct in6_addr *addr = extract_in6_addr(
self);
1907 if (addr && IN6_IS_ADDR_MC_ORGLOCAL(addr))
return Qtrue;
1916 addrinfo_ipv6_mc_global_p(
VALUE self)
1918 struct in6_addr *addr = extract_in6_addr(
self);
1919 if (addr && IN6_IS_ADDR_MC_GLOBAL(addr))
return Qtrue;
1934 addrinfo_ipv6_to_ipv4(
VALUE self)
1937 struct in6_addr *addr;
1939 if (family != AF_INET6)
return Qnil;
1940 addr = &((
struct sockaddr_in6 *)&rai->
addr)->sin6_addr;
1941 if (IN6_IS_ADDR_V4MAPPED(addr) || IN6_IS_ADDR_V4COMPAT(addr)) {
1942 struct sockaddr_in sin4;
1943 MEMZERO(&sin4,
struct sockaddr_in, 1);
1944 sin4.sin_family = AF_INET;
1946 memcpy(&sin4.sin_addr, (
char*)addr +
sizeof(*addr) -
sizeof(sin4.sin_addr),
sizeof(sin4.sin_addr));
1958 #ifdef HAVE_SYS_UN_H
1968 addrinfo_unix_path(
VALUE self)
1972 struct sockaddr_un *addr;
1975 if (family != AF_UNIX)
1978 addr = (
struct sockaddr_un *)&rai->
addr;
1983 rb_raise(
rb_eSocket,
"too short AF_UNIX address: %"PRIuSIZE
" bytes given for minimum %"PRIuSIZE
" bytes.",
1984 (
size_t)rai->
sockaddr_len, (
size_t)(s - (
char *)addr));
1985 if (addr->sun_path +
sizeof(addr->sun_path) < e)
1987 "too long AF_UNIX path (%"PRIuSIZE
" bytes given but %"PRIuSIZE
" bytes max)",
1988 (
size_t)(e - addr->sun_path),
sizeof(addr->sun_path));
1989 while (s < e && *(e-1) ==
'\0')
2041 VALUE node, service, family, socktype, protocol, flags;
2043 rb_scan_args(argc, argv,
"24", &node, &service, &family, &socktype, &protocol, &flags);
2101 #ifdef HAVE_SYS_UN_H
2118 VALUE path, vsocktype, addr;
2124 if (
NIL_P(vsocktype))
2125 socktype = SOCK_STREAM;
2131 init_unix_addrinfo(rai, path, socktype);
2170 socklen_t optlen = (socklen_t)
sizeof(socktype);
2175 ret = getsockopt(fd, SOL_SOCKET, SO_TYPE, (
void*)&socktype, &optlen);
2225 #ifdef HAVE_SYS_UN_H
2266 #ifdef HAVE_SYS_UN_H
RUBY_EXTERN VALUE rb_cData
struct addrinfo * rsock_addrinfo(VALUE host, VALUE port, int socktype, int flags)
VALUE rb_ary_entry(VALUE ary, long offset)
VALUE rb_str_equal(VALUE str1, VALUE str2)
static int str_is_number(const char *)
size_t strlen(const char *)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
static rb_addrinfo_t * check_addrinfo(VALUE self)
static struct addrinfo * call_getaddrinfo(VALUE node, VALUE service, VALUE family, VALUE socktype, VALUE protocol, VALUE flags, int socktype_hack)
VALUE rb_str_cat(VALUE, const char *, long)
struct sockaddr_storage addr
static VALUE addrinfo_ipv6_p(VALUE self)
#define SET_SIN_LEN(si, len)
VALUE rsock_make_ipaddr(struct sockaddr *addr, socklen_t addrlen)
#define TypedData_Wrap_Struct(klass, data_type, sval)
int rsock_socktype_arg(VALUE type)
static VALUE addrinfo_list_new(VALUE node, VALUE service, VALUE family, VALUE socktype, VALUE protocol, VALUE flags)
const struct sockaddr * sa
VALUE rb_ary_push(VALUE ary, VALUE item)
static void * nogvl_getaddrinfo(void *arg)
static VALUE addrinfo_ipv4_loopback_p(VALUE self)
void rb_raise(VALUE exc, const char *fmt,...)
ID rsock_intern_ipproto(int val)
#define IN6_IS_ADDR_UNIQUE_LOCAL(a)
static VALUE addrinfo_protocol(VALUE self)
VALUE rb_convert_type(VALUE, int, const char *, const char *)
static void make_inetaddr(unsigned int host, char *buf, size_t buflen)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
VALUE rb_obj_is_kind_of(VALUE, VALUE)
VALUE rb_check_sockaddr_string_type(VALUE val)
VALUE rb_ary_new3(long n,...)
void rb_gc_mark(VALUE ptr)
static VALUE addrinfo_ipv4_p(VALUE self)
VALUE rb_tainted_str_new_cstr(const char *)
static size_t addrinfo_memsize(const void *ptr)
VALUE rsock_ipaddr(struct sockaddr *sockaddr, socklen_t sockaddrlen, int norevlookup)
const struct addrinfo * hints
#define GetOpenFile(obj, fp)
void rsock_init_addrinfo(void)
VALUE rsock_io_socket_addrinfo(VALUE io, struct sockaddr *addr, socklen_t len)
const char * rb_obj_classname(VALUE)
static VALUE addrinfo_ipv4_multicast_p(VALUE self)
static VALUE addrinfo_inspect_sockaddr(VALUE self)
VALUE rsock_make_hostent(VALUE host, struct addrinfo *addr, VALUE(*ipaddr)(struct sockaddr *, size_t))
static VALUE addrinfo_to_sockaddr(VALUE self)
#define RB_TYPE_P(obj, type)
VALUE rsock_addrinfo_new(struct sockaddr *addr, socklen_t len, int family, int socktype, int protocol, VALUE canonname, VALUE inspectname)
#define MEMZERO(p, type, n)
int rsock_ipproto_to_int(const char *str, long len, int *valp)
int rsock_family_arg(VALUE domain)
VALUE rb_str_cat2(VALUE, const char *)
static int ai_get_afamily(rb_addrinfo_t *rai)
VALUE rb_str_buf_cat2(VALUE, const char *)
static VALUE addrinfo_initialize(int argc, VALUE *argv, VALUE self)
#define STRTOUL(str, endptr, base)
static VALUE addrinfo_ip_unpack(VALUE self)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
static VALUE addrinfo_getnameinfo(int argc, VALUE *argv, VALUE self)
static char * host_str(VALUE host, char *hbuf, size_t hbuflen, int *flags_ptr)
void rb_ary_store(VALUE ary, long idx, VALUE val)
#define offsetof(p_type, field)
static const rb_data_type_t addrinfo_type
int getaddrinfo(const char *hostname, const char *servname, const struct addrinfo *hints, struct addrinfo **res)
ID rsock_intern_protocol_family(int val)
#define MEMCPY(p1, p2, type, n)
int rsock_family_to_int(const char *str, long len, int *valp)
static VALUE addrinfo_s_udp(VALUE self, VALUE host, VALUE port)
void * rb_thread_call_without_gvl(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2)
static int get_afamily(struct sockaddr *addr, socklen_t len)
static VALUE addrinfo_unix_p(VALUE self)
static void init_addrinfo_getaddrinfo(rb_addrinfo_t *rai, VALUE node, VALUE service, VALUE family, VALUE socktype, VALUE protocol, VALUE flags, VALUE inspectnode, VALUE inspectservice)
int rsock_socktype_to_int(const char *str, long len, int *valp)
char * rsock_sockaddr_string_value_ptr(volatile VALUE *v)
VALUE rb_sprintf(const char *format,...)
static void * nogvl_getnameinfo(void *arg)
VALUE rsock_freeaddrinfo(struct addrinfo *addr)
static VALUE addrinfo_firstonly_new(VALUE node, VALUE service, VALUE family, VALUE socktype, VALUE protocol, VALUE flags)
static VALUE addrinfo_s_getaddrinfo(int argc, VALUE *argv, VALUE self)
void freeaddrinfo(struct addrinfo *ai)
static rb_addrinfo_t * alloc_addrinfo()
VALUE rsock_fd_socket_addrinfo(int fd, struct sockaddr *addr, socklen_t len)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
static VALUE addrinfo_mload(VALUE self, VALUE ary)
unsigned char buf[MIME_BUF_SIZE]
VALUE rb_assoc_new(VALUE car, VALUE cdr)
static VALUE addrinfo_pfamily(VALUE self)
static VALUE addrinfo_ip_address(VALUE self)
ID rsock_intern_family(int val)
static VALUE addrinfo_s_ip(VALUE self, VALUE host)
static char * port_str(VALUE port, char *pbuf, size_t pbuflen, int *flags_ptr)
RUBY_EXTERN VALUE rb_cInteger
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
VALUE rb_str_new_cstr(const char *)
ID rsock_intern_socktype(int val)
static VALUE addrinfo_ip_p(VALUE self)
void rb_sys_fail(const char *mesg)
static VALUE addrinfo_s_allocate(VALUE klass)
static void init_addrinfo(rb_addrinfo_t *rai, struct sockaddr *sa, socklen_t len, int pfamily, int socktype, int protocol, VALUE canonname, VALUE inspectname)
static void make_ipaddr0(struct sockaddr *addr, socklen_t addrlen, char *buf, size_t buflen)
static VALUE make_hostent_internal(struct hostent_arg *arg)
static VALUE addrinfo_afamily(VALUE self)
#define StringValueCStr(v)
int rb_getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags)
static VALUE inspect_sockaddr(VALUE addrinfo, VALUE ret)
static VALUE addrinfo_canonname(VALUE self)
static VALUE addrinfo_ipv4_private_p(VALUE self)
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
VALUE rb_check_array_type(VALUE ary)
void rsock_raise_socket_error(const char *reason, int error)
VALUE rb_str_catf(VALUE str, const char *format,...)
VALUE rb_check_string_type(VALUE)
static VALUE addrinfo_s_tcp(VALUE self, VALUE host, VALUE port)
struct addrinfo * rsock_getaddrinfo(VALUE host, VALUE port, struct addrinfo *hints, int socktype_hack)
int getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags)
struct addrinfo * ai_next
#define SafeStringValue(v)
static VALUE addrinfo_socktype(VALUE self)
VALUE rb_ary_new2(long capa)
const char * rb_id2name(ID id)
static void addrinfo_mark(void *ptr)
#define RSTRING_LENINT(str)
static VALUE make_inspectname(VALUE node, VALUE service, struct addrinfo *res)
static VALUE addrinfo_ip_port(VALUE self)
int rb_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res)
VALUE(* ipaddr)(struct sockaddr *, size_t)
static VALUE addrinfo_mdump(VALUE self)
static rb_addrinfo_t * get_addrinfo(VALUE self)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
static VALUE addrinfo_inspect(VALUE self)
VALUE rb_str_new2(const char *)
struct sockaddr * ai_addr
static int extract_in_addr(VALUE self, uint32_t *addrp)
VALUE rsock_sockaddr_string_value(volatile VALUE *v)
VALUE rb_str_new(const char *, long)