third-party/mruby/mrbgems/mruby-socket/src/socket.c

   1 /*
   2 ** socket.c - Socket module
   3 **
   4 ** See Copyright Notice in mruby.h
   5 */
   6
   7 #ifdef _WIN32
   8   #define _WIN32_WINNT 0x0501
   9
  10   #include <winsock2.h>
  11   #include <ws2tcpip.h>
  12   #include <windows.h>
  13   #include <winerror.h>
  14
  15   #define SHUT_RDWR SD_BOTH
  16   #ifndef _SSIZE_T_DEFINED
  17   typedef int ssize_t;
  18   #endif
  19   typedef int fsize_t;
  20 #else
  21   #include <sys/types.h>
  22   #include <sys/socket.h>
  23   #include <sys/param.h>
  24   #include <sys/un.h>
  25   #include <netinet/in.h>
  26   #include <netinet/tcp.h>
  27   #include <arpa/inet.h>
  28   #include <fcntl.h>
  29   #include <netdb.h>
  30   #include <unistd.h>
  31   typedef size_t fsize_t;
  32 #endif
  33
  34 #include <stddef.h>
  35 #include <string.h>
  36
  37 #include "mruby.h"
  38 #include "mruby/array.h"
  39 #include "mruby/class.h"
  40 #include "mruby/data.h"
  41 #include "mruby/numeric.h"
  42 #include "mruby/string.h"
  43 #include "mruby/variable.h"
  44 #include "mruby/error.h"
  45
  46 #include "mruby/ext/io.h"
  47
  48 #if !defined(HAVE_SA_LEN)
  49 #if (defined(BSD) && (BSD >= 199006))
  50 #define HAVE_SA_LEN  1
  51 #else
  52 #define HAVE_SA_LEN  0
  53 #endif
  54 #endif
  55
  56 #define E_SOCKET_ERROR             (mrb_class_get(mrb, "SocketError"))
  57
  58 #if !defined(mrb_cptr)
  59 #define mrb_cptr_value(m,p) mrb_voidp_value((m),(p))
  60 #define mrb_cptr(o) mrb_voidp(o)
  61 #define mrb_cptr_p(o) mrb_voidp_p(o)
  62 #endif
  63
  64 #ifdef _WIN32
  65 static const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt)
  66 {
  67     if (af == AF_INET)
  68     {
  69         struct sockaddr_in in;
  70         memset(&in, 0, sizeof(in));
  71         in.sin_family = AF_INET;
  72         memcpy(&in.sin_addr, src, sizeof(struct in_addr));
  73         getnameinfo((struct sockaddr *)&in, sizeof(struct
  74                     sockaddr_in), dst, cnt, NULL, 0, NI_NUMERICHOST);
  75         return dst;
  76     }
  77     else if (af == AF_INET6)
  78     {
  79         struct sockaddr_in6 in;
  80         memset(&in, 0, sizeof(in));
  81         in.sin6_family = AF_INET6;
  82         memcpy(&in.sin6_addr, src, sizeof(struct in_addr6));
  83         getnameinfo((struct sockaddr *)&in, sizeof(struct
  84                     sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST);
  85         return dst;
  86     }
  87     return NULL;
  88 }
  89
  90 static int inet_pton(int af, const char *src, void *dst)
  91 {
  92     struct addrinfo hints, *res, *ressave;
  93
  94     memset(&hints, 0, sizeof(struct addrinfo));
  95     hints.ai_family = af;
  96
  97     if (getaddrinfo(src, NULL, &hints, &res) != 0)
  98     {
  99         printf("Couldn't resolve host %s\n", src);
 100         return -1;
 101     }
 102
 103     ressave = res;
 104
 105     while (res)
 106     {
 107         memcpy(dst, res->ai_addr, res->ai_addrlen);
 108         res = res->ai_next;
 109     }
 110
 111     freeaddrinfo(ressave);
 112     return 0;
 113 }
 114
 115 #endif
 116
 117 static mrb_value
 118 mrb_addrinfo_getaddrinfo(mrb_state *mrb, mrb_value klass)
 119 {
 120   struct addrinfo hints, *res0, *res;
 121   mrb_value ai, ary, family, lastai, nodename, protocol, sa, service, socktype;
 122   mrb_int flags;
 123   int arena_idx, error;
 124   const char *hostname = NULL, *servname = NULL;
 125
 126   ary = mrb_ary_new(mrb);
 127   arena_idx = mrb_gc_arena_save(mrb);  /* ary must be on arena! */
 128
 129   family = socktype = protocol = mrb_nil_value();
 130   flags = 0;
 131   mrb_get_args(mrb, "oo|oooi", &nodename, &service, &family, &socktype, &protocol, &flags);
 132
 133   if (mrb_string_p(nodename)) {
 134     hostname = RSTRING_CSTR(mrb, nodename);
 135   } else if (mrb_nil_p(nodename)) {
 136     hostname = NULL;
 137   } else {
 138     mrb_raise(mrb, E_TYPE_ERROR, "nodename must be String or nil");
 139   }
 140
 141   if (mrb_string_p(service)) {
 142     servname = RSTRING_CSTR(mrb, service);
 143   } else if (mrb_fixnum_p(service)) {
 144     servname = RSTRING_PTR(mrb_fixnum_to_str(mrb, service, 10));
 145   } else if (mrb_nil_p(service)) {
 146     servname = NULL;
 147   } else {
 148     mrb_raise(mrb, E_TYPE_ERROR, "service must be String, Fixnum, or nil");
 149   }
 150
 151   memset(&hints, 0, sizeof(hints));
 152   hints.ai_flags = (int)flags;
 153
 154   if (mrb_fixnum_p(family)) {
 155     hints.ai_family = (int)mrb_fixnum(family);
 156   }
 157
 158   if (mrb_fixnum_p(socktype)) {
 159     hints.ai_socktype = (int)mrb_fixnum(socktype);
 160   }
 161
 162   if (mrb_fixnum_p(protocol)) {
 163     hints.ai_protocol = (int)mrb_fixnum(protocol);
 164   }
 165
 166   lastai = mrb_cv_get(mrb, klass, mrb_intern_lit(mrb, "_lastai"));
 167   if (mrb_cptr_p(lastai)) {
 168     freeaddrinfo((struct addrinfo*)mrb_cptr(lastai));
 169     mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
 170   }
 171
 172   error = getaddrinfo(hostname, servname, &hints, &res0);
 173   if (error) {
 174     mrb_raisef(mrb, E_SOCKET_ERROR, "getaddrinfo: %s", gai_strerror(error));
 175   }
 176   mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_cptr_value(mrb, res0));
 177
 178   for (res = res0; res != NULL; res = res->ai_next) {
 179     sa = mrb_str_new(mrb, (char*)res->ai_addr, res->ai_addrlen);
 180     ai = mrb_funcall(mrb, klass, "new", 4, sa, mrb_fixnum_value(res->ai_family), mrb_fixnum_value(res->ai_socktype), mrb_fixnum_value(res->ai_protocol));
 181     mrb_ary_push(mrb, ary, ai);
 182     mrb_gc_arena_restore(mrb, arena_idx);
 183   }
 184
 185   freeaddrinfo(res0);
 186   mrb_cv_set(mrb, klass, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
 187
 188   return ary;
 189 }
 190
 191 static mrb_value
 192 mrb_addrinfo_getnameinfo(mrb_state *mrb, mrb_value self)
 193 {
 194   mrb_int flags;
 195   mrb_value ary, host, sastr, serv;
 196   int error;
 197
 198   flags = 0;
 199   mrb_get_args(mrb, "|i", &flags);
 200   host = mrb_str_buf_new(mrb, NI_MAXHOST);
 201   serv = mrb_str_buf_new(mrb, NI_MAXSERV);
 202
 203   sastr = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@sockaddr"));
 204   if (!mrb_string_p(sastr)) {
 205     mrb_raise(mrb, E_SOCKET_ERROR, "invalid sockaddr");
 206   }
 207   error = getnameinfo((struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr), RSTRING_PTR(host), NI_MAXHOST, RSTRING_PTR(serv), NI_MAXSERV, (int)flags);
 208   if (error) {
 209     mrb_raisef(mrb, E_SOCKET_ERROR, "getnameinfo: %s", gai_strerror(error));
 210   }
 211   ary = mrb_ary_new_capa(mrb, 2);
 212   mrb_str_resize(mrb, host, strlen(RSTRING_PTR(host)));
 213   mrb_ary_push(mrb, ary, host);
 214   mrb_str_resize(mrb, serv, strlen(RSTRING_PTR(serv)));
 215   mrb_ary_push(mrb, ary, serv);
 216   return ary;
 217 }
 218
 219 #ifndef _WIN32
 220 static mrb_value
 221 mrb_addrinfo_unix_path(mrb_state *mrb, mrb_value self)
 222 {
 223   mrb_value sastr;
 224
 225   sastr = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "@sockaddr"));
 226   if (((struct sockaddr *)RSTRING_PTR(sastr))->sa_family != AF_UNIX)
 227     mrb_raise(mrb, E_SOCKET_ERROR, "need AF_UNIX address");
 228   if (RSTRING_LEN(sastr) < (mrb_int)offsetof(struct sockaddr_un, sun_path) + 1) {
 229     return mrb_str_new(mrb, "", 0);
 230   } else {
 231     return mrb_str_new_cstr(mrb, ((struct sockaddr_un *)RSTRING_PTR(sastr))->sun_path);
 232   }
 233 }
 234 #endif
 235
 236 static mrb_value
 237 sa2addrlist(mrb_state *mrb, const struct sockaddr *sa, socklen_t salen)
 238 {
 239   mrb_value ary, host;
 240   unsigned short port;
 241   const char *afstr;
 242
 243   switch (sa->sa_family) {
 244   case AF_INET:
 245     afstr = "AF_INET";
 246     port = ((struct sockaddr_in *)sa)->sin_port;
 247     break;
 248   case AF_INET6:
 249     afstr = "AF_INET6";
 250     port = ((struct sockaddr_in6 *)sa)->sin6_port;
 251     break;
 252   default:
 253     mrb_raise(mrb, E_ARGUMENT_ERROR, "bad af");
 254     return mrb_nil_value();
 255   }
 256   port = ntohs(port);
 257   host = mrb_str_buf_new(mrb, NI_MAXHOST);
 258   if (getnameinfo(sa, salen, RSTRING_PTR(host), NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == -1)
 259     mrb_sys_fail(mrb, "getnameinfo");
 260   mrb_str_resize(mrb, host, strlen(RSTRING_PTR(host)));
 261   ary = mrb_ary_new_capa(mrb, 4);
 262   mrb_ary_push(mrb, ary, mrb_str_new_cstr(mrb, afstr));
 263   mrb_ary_push(mrb, ary, mrb_fixnum_value(port));
 264   mrb_ary_push(mrb, ary, host);
 265   mrb_ary_push(mrb, ary, host);
 266   return ary;
 267 }
 268
 269 static int
 270 socket_fd(mrb_state *mrb, mrb_value sock)
 271 {
 272   return (int)mrb_fixnum(mrb_funcall(mrb, sock, "fileno", 0));
 273 }
 274
 275 static int
 276 socket_family(int s)
 277 {
 278   struct sockaddr_storage ss;
 279   socklen_t salen;
 280
 281   salen = sizeof(ss);
 282   if (getsockname(s, (struct sockaddr *)&ss, &salen) == -1)
 283     return AF_UNSPEC;
 284   return ss.ss_family;
 285 }
 286
 287 static mrb_value
 288 mrb_basicsocket_getpeereid(mrb_state *mrb, mrb_value self)
 289 {
 290 #ifdef HAVE_GETPEEREID
 291   mrb_value ary;
 292   gid_t egid;
 293   uid_t euid;
 294   int s;
 295
 296   s = socket_fd(mrb, self);
 297   if (getpeereid(s, &euid, &egid) != 0)
 298     mrb_sys_fail(mrb, "getpeereid");
 299
 300   ary = mrb_ary_new_capa(mrb, 2);
 301   mrb_ary_push(mrb, ary, mrb_fixnum_value((mrb_int)euid));
 302   mrb_ary_push(mrb, ary, mrb_fixnum_value((mrb_int)egid));
 303   return ary;
 304 #else
 305   mrb_raise(mrb, E_RUNTIME_ERROR, "getpeereid is not available on this system");
 306   return mrb_nil_value();
 307 #endif
 308 }
 309
 310 static mrb_value
 311 mrb_basicsocket_getpeername(mrb_state *mrb, mrb_value self)
 312 {
 313   struct sockaddr_storage ss;
 314   socklen_t salen;
 315
 316   salen = sizeof(ss);
 317   if (getpeername(socket_fd(mrb, self), (struct sockaddr *)&ss, &salen) != 0)
 318     mrb_sys_fail(mrb, "getpeername");
 319
 320   return mrb_str_new(mrb, (char*)&ss, salen);
 321 }
 322
 323 static mrb_value
 324 mrb_basicsocket_getsockname(mrb_state *mrb, mrb_value self)
 325 {
 326   struct sockaddr_storage ss;
 327   socklen_t salen;
 328
 329   salen = sizeof(ss);
 330   if (getsockname(socket_fd(mrb, self), (struct sockaddr *)&ss, &salen) != 0)
 331     mrb_sys_fail(mrb, "getsockname");
 332
 333   return mrb_str_new(mrb, (char*)&ss, salen);
 334 }
 335
 336 static mrb_value
 337 mrb_basicsocket_getsockopt(mrb_state *mrb, mrb_value self)
 338 {
 339   char opt[8];
 340   int s;
 341   mrb_int family, level, optname;
 342   mrb_value c, data;
 343   socklen_t optlen;
 344
 345   mrb_get_args(mrb, "ii", &level, &optname);
 346   s = socket_fd(mrb, self);
 347   optlen = sizeof(opt);
 348   if (getsockopt(s, (int)level, (int)optname, opt, &optlen) == -1)
 349     mrb_sys_fail(mrb, "getsockopt");
 350   c = mrb_const_get(mrb, mrb_obj_value(mrb_class_get(mrb, "Socket")), mrb_intern_lit(mrb, "Option"));
 351   family = socket_family(s);
 352   data = mrb_str_new(mrb, opt, optlen);
 353   return mrb_funcall(mrb, c, "new", 4, mrb_fixnum_value(family), mrb_fixnum_value(level), mrb_fixnum_value(optname), data);
 354 }
 355
 356 static mrb_value
 357 mrb_basicsocket_recv(mrb_state *mrb, mrb_value self)
 358 {
 359   ssize_t n;
 360   mrb_int maxlen, flags = 0;
 361   mrb_value buf;
 362
 363   mrb_get_args(mrb, "i|i", &maxlen, &flags);
 364   buf = mrb_str_buf_new(mrb, maxlen);
 365   n = recv(socket_fd(mrb, self), RSTRING_PTR(buf), (fsize_t)maxlen, (int)flags);
 366   if (n == -1)
 367     mrb_sys_fail(mrb, "recv");
 368   mrb_str_resize(mrb, buf, (mrb_int)n);
 369   return buf;
 370 }
 371
 372 static mrb_value
 373 mrb_basicsocket_recvfrom(mrb_state *mrb, mrb_value self)
 374 {
 375   ssize_t n;
 376   mrb_int maxlen, flags = 0;
 377   mrb_value ary, buf, sa;
 378   socklen_t socklen;
 379
 380   mrb_get_args(mrb, "i|i", &maxlen, &flags);
 381   buf = mrb_str_buf_new(mrb, maxlen);
 382   socklen = sizeof(struct sockaddr_storage);
 383   sa = mrb_str_buf_new(mrb, socklen);
 384   n = recvfrom(socket_fd(mrb, self), RSTRING_PTR(buf), (fsize_t)maxlen, (int)flags, (struct sockaddr *)RSTRING_PTR(sa), &socklen);
 385   if (n == -1)
 386     mrb_sys_fail(mrb, "recvfrom");
 387   mrb_str_resize(mrb, buf, (mrb_int)n);
 388   mrb_str_resize(mrb, sa, (mrb_int)socklen);
 389   ary = mrb_ary_new_capa(mrb, 2);
 390   mrb_ary_push(mrb, ary, buf);
 391   mrb_ary_push(mrb, ary, sa);
 392   return ary;
 393 }
 394
 395 static mrb_value
 396 mrb_basicsocket_send(mrb_state *mrb, mrb_value self)
 397 {
 398   ssize_t n;
 399   mrb_int flags;
 400   mrb_value dest, mesg;
 401
 402   dest = mrb_nil_value();
 403   mrb_get_args(mrb, "Si|S", &mesg, &flags, &dest);
 404   if (mrb_nil_p(dest)) {
 405     n = send(socket_fd(mrb, self), RSTRING_PTR(mesg), (fsize_t)RSTRING_LEN(mesg), (int)flags);
 406   } else {
 407     n = sendto(socket_fd(mrb, self), RSTRING_PTR(mesg), (fsize_t)RSTRING_LEN(mesg), (int)flags, (const struct sockaddr*)RSTRING_PTR(dest), (fsize_t)RSTRING_LEN(dest));
 408   }
 409   if (n == -1)
 410     mrb_sys_fail(mrb, "send");
 411   return mrb_fixnum_value((mrb_int)n);
 412 }
 413
 414 static mrb_value
 415 mrb_basicsocket_setnonblock(mrb_state *mrb, mrb_value self)
 416 {
 417   int fd, flags;
 418   mrb_bool nonblocking;
 419 #ifdef _WIN32
 420   u_long mode = 1;
 421 #endif
 422
 423   mrb_get_args(mrb, "b", &nonblocking);
 424   fd = socket_fd(mrb, self);
 425 #ifdef _WIN32
 426   flags = ioctlsocket(fd, FIONBIO, &mode);
 427   if (flags != NO_ERROR)
 428     mrb_sys_fail(mrb, "ioctlsocket");
 429 #else
 430   flags = fcntl(fd, F_GETFL, 0);
 431   if (flags == 1)
 432     mrb_sys_fail(mrb, "fcntl");
 433   if (nonblocking)
 434     flags |= O_NONBLOCK;
 435   else
 436     flags &= ~O_NONBLOCK;
 437   if (fcntl(fd, F_SETFL, flags) == -1)
 438     mrb_sys_fail(mrb, "fcntl");
 439 #endif
 440   return mrb_nil_value();
 441 }
 442
 443 static mrb_value
 444 mrb_basicsocket_setsockopt(mrb_state *mrb, mrb_value self)
 445 {
 446   int s;
 447   mrb_int argc, level = 0, optname;
 448   mrb_value optval, so;
 449
 450   argc = mrb_get_args(mrb, "o|io", &so, &optname, &optval);
 451   if (argc == 3) {
 452     if (!mrb_fixnum_p(so)) {
 453       mrb_raise(mrb, E_ARGUMENT_ERROR, "level is not an integer");
 454     }
 455     level = mrb_fixnum(so);
 456     if (mrb_string_p(optval)) {
 457       /* that's good */
 458     } else if (mrb_true_p(optval) || mrb_false_p(optval)) {
 459       mrb_int i = mrb_test(optval) ? 1 : 0;
 460       optval = mrb_str_new(mrb, (char*)&i, sizeof(i));
 461     } else if (mrb_fixnum_p(optval)) {
 462       if (optname == IP_MULTICAST_TTL || optname == IP_MULTICAST_LOOP) {
 463         char uc = (char)mrb_fixnum(optval);
 464         optval = mrb_str_new(mrb, &uc, sizeof(uc));
 465       } else {
 466         mrb_int i = mrb_fixnum(optval);
 467         optval = mrb_str_new(mrb, (char*)&i, sizeof(i));
 468       }
 469     } else {
 470       mrb_raise(mrb, E_ARGUMENT_ERROR, "optval should be true, false, an integer, or a string");
 471     }
 472   } else if (argc == 1) {
 473     if (strcmp(mrb_obj_classname(mrb, so), "Socket::Option") != 0)
 474       mrb_raise(mrb, E_ARGUMENT_ERROR, "not an instance of Socket::Option");
 475     level = mrb_fixnum(mrb_funcall(mrb, so, "level", 0));
 476     optname = mrb_fixnum(mrb_funcall(mrb, so, "optname", 0));
 477     optval = mrb_funcall(mrb, so, "data", 0);
 478   } else {
 479     mrb_argnum_error(mrb, argc, 3, 3);
 480   }
 481
 482   s = socket_fd(mrb, self);
 483   if (setsockopt(s, (int)level, (int)optname, RSTRING_PTR(optval), (socklen_t)RSTRING_LEN(optval)) == -1)
 484     mrb_sys_fail(mrb, "setsockopt");
 485   return mrb_fixnum_value(0);
 486 }
 487
 488 static mrb_value
 489 mrb_basicsocket_shutdown(mrb_state *mrb, mrb_value self)
 490 {
 491   mrb_int how = SHUT_RDWR;
 492
 493   mrb_get_args(mrb, "|i", &how);
 494   if (shutdown(socket_fd(mrb, self), (int)how) != 0)
 495     mrb_sys_fail(mrb, "shutdown");
 496   return mrb_fixnum_value(0);
 497 }
 498
 499 static mrb_value
 500 mrb_basicsocket_set_is_socket(mrb_state *mrb, mrb_value self)
 501 {
 502   mrb_bool b;
 503   struct mrb_io *io_p;
 504   mrb_get_args(mrb, "b", &b);
 505
 506   io_p = (struct mrb_io*)DATA_PTR(self);
 507   if (io_p) {
 508     io_p->is_socket = b;
 509   }
 510
 511   return mrb_bool_value(b);
 512 }
 513
 514 static mrb_value
 515 mrb_ipsocket_ntop(mrb_state *mrb, mrb_value klass)
 516 {
 517   mrb_int af, n;
 518   char *addr, buf[50];
 519
 520   mrb_get_args(mrb, "is", &af, &addr, &n);
 521   if ((af == AF_INET && n != 4) || (af == AF_INET6 && n != 16))
 522     mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid address");
 523   if (inet_ntop((int)af, addr, buf, sizeof(buf)) == NULL)
 524     mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid address");
 525   return mrb_str_new_cstr(mrb, buf);
 526 }
 527
 528 static mrb_value
 529 mrb_ipsocket_pton(mrb_state *mrb, mrb_value klass)
 530 {
 531   mrb_int af, n;
 532   char *bp, buf[50];
 533
 534   mrb_get_args(mrb, "is", &af, &bp, &n);
 535   if ((size_t)n > sizeof(buf) - 1)
 536     mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid address");
 537   memcpy(buf, bp, n);
 538   buf[n] = '\0';
 539
 540   if (af == AF_INET) {
 541     struct in_addr in;
 542     if (inet_pton(AF_INET, buf, (void *)&in.s_addr) != 1)
 543       goto invalid;
 544     return mrb_str_new(mrb, (char*)&in.s_addr, 4);
 545   } else if (af == AF_INET6) {
 546     struct in6_addr in6;
 547     if (inet_pton(AF_INET6, buf, (void *)&in6.s6_addr) != 1)
 548       goto invalid;
 549     return mrb_str_new(mrb, (char*)&in6.s6_addr, 16);
 550   } else
 551     mrb_raise(mrb, E_ARGUMENT_ERROR, "unsupported address family");
 552
 553 invalid:
 554   mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid address");
 555   return mrb_nil_value(); /* dummy */
 556 }
 557
 558 static mrb_value
 559 mrb_ipsocket_recvfrom(mrb_state *mrb, mrb_value self)
 560 {
 561   struct sockaddr_storage ss;
 562   socklen_t socklen;
 563   mrb_value a, buf, pair;
 564   mrb_int flags, maxlen;
 565   ssize_t n;
 566   int fd;
 567
 568   fd = socket_fd(mrb, self);
 569   flags = 0;
 570   mrb_get_args(mrb, "i|i", &maxlen, &flags);
 571   buf = mrb_str_buf_new(mrb, maxlen);
 572   socklen = sizeof(ss);
 573   n = recvfrom(fd, RSTRING_PTR(buf), (fsize_t)maxlen, (int)flags,
 574                (struct sockaddr *)&ss, &socklen);
 575   if (n == -1) {
 576     mrb_sys_fail(mrb, "recvfrom");
 577   }
 578   mrb_str_resize(mrb, buf, (mrb_int)n);
 579   a = sa2addrlist(mrb, (struct sockaddr *)&ss, socklen);
 580   pair = mrb_ary_new_capa(mrb, 2);
 581   mrb_ary_push(mrb, pair, buf);
 582   mrb_ary_push(mrb, pair, a);
 583   return pair;
 584 }
 585
 586 static mrb_value
 587 mrb_socket_gethostname(mrb_state *mrb, mrb_value cls)
 588 {
 589   mrb_value buf;
 590   size_t bufsize;
 591
 592 #ifdef HOST_NAME_MAX
 593   bufsize = HOST_NAME_MAX + 1;
 594 #else
 595   bufsize = 256;
 596 #endif
 597   buf = mrb_str_buf_new(mrb, (mrb_int)bufsize);
 598   if (gethostname(RSTRING_PTR(buf), (fsize_t)bufsize) != 0)
 599     mrb_sys_fail(mrb, "gethostname");
 600   mrb_str_resize(mrb, buf, (mrb_int)strlen(RSTRING_PTR(buf)));
 601   return buf;
 602 }
 603
 604 static mrb_value
 605 mrb_socket_accept(mrb_state *mrb, mrb_value klass)
 606 {
 607   int s1;
 608   mrb_int s0;
 609
 610   mrb_get_args(mrb, "i", &s0);
 611   s1 = (int)accept(s0, NULL, NULL);
 612   if (s1 == -1) {
 613     mrb_sys_fail(mrb, "accept");
 614   }
 615   return mrb_fixnum_value(s1);
 616 }
 617
 618 static mrb_value
 619 mrb_socket_accept2(mrb_state *mrb, mrb_value klass)
 620 {
 621   mrb_value ary, sastr;
 622   int s1;
 623   mrb_int s0;
 624   socklen_t socklen;
 625
 626   mrb_get_args(mrb, "i", &s0);
 627   socklen = sizeof(struct sockaddr_storage);
 628   sastr = mrb_str_buf_new(mrb, socklen);
 629   s1 = (int)accept(s0, (struct sockaddr *)RSTRING_PTR(sastr), &socklen);
 630   if (s1 == -1) {
 631     mrb_sys_fail(mrb, "accept");
 632   }
 633   // XXX: possible descriptor leakage here!
 634   mrb_str_resize(mrb, sastr, socklen);
 635   ary = mrb_ary_new_capa(mrb, 2);
 636   mrb_ary_push(mrb, ary, mrb_fixnum_value(s1));
 637   mrb_ary_push(mrb, ary, sastr);
 638   return ary;
 639 }
 640
 641 static mrb_value
 642 mrb_socket_bind(mrb_state *mrb, mrb_value klass)
 643 {
 644   mrb_value sastr;
 645   mrb_int s;
 646
 647   mrb_get_args(mrb, "iS", &s, &sastr);
 648   if (bind((int)s, (struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
 649     mrb_sys_fail(mrb, "bind");
 650   }
 651   return mrb_nil_value();
 652 }
 653
 654 static mrb_value
 655 mrb_socket_connect(mrb_state *mrb, mrb_value klass)
 656 {
 657   mrb_value sastr;
 658   mrb_int s;
 659
 660   mrb_get_args(mrb, "iS", &s, &sastr);
 661   if (connect((int)s, (struct sockaddr *)RSTRING_PTR(sastr), (socklen_t)RSTRING_LEN(sastr)) == -1) {
 662     mrb_sys_fail(mrb, "connect");
 663   }
 664   return mrb_nil_value();
 665 }
 666
 667 static mrb_value
 668 mrb_socket_listen(mrb_state *mrb, mrb_value klass)
 669 {
 670   mrb_int backlog, s;
 671
 672   mrb_get_args(mrb, "ii", &s, &backlog);
 673   if (listen((int)s, (int)backlog) == -1) {
 674     mrb_sys_fail(mrb, "listen");
 675   }
 676   return mrb_nil_value();
 677 }
 678
 679 static mrb_value
 680 mrb_socket_sockaddr_family(mrb_state *mrb, mrb_value klass)
 681 {
 682   const struct sockaddr *sa;
 683   mrb_value str;
 684
 685   mrb_get_args(mrb, "S", &str);
 686   if ((size_t)RSTRING_LEN(str) < offsetof(struct sockaddr, sa_family) + sizeof(sa->sa_family)) {
 687     mrb_raise(mrb, E_SOCKET_ERROR, "invalid sockaddr (too short)");
 688   }
 689   sa = (const struct sockaddr *)RSTRING_PTR(str);
 690   return mrb_fixnum_value(sa->sa_family);
 691 }
 692
 693 static mrb_value
 694 mrb_socket_sockaddr_un(mrb_state *mrb, mrb_value klass)
 695 {
 696 #ifdef _WIN32
 697   mrb_raise(mrb, E_NOTIMP_ERROR, "sockaddr_un unsupported on Windows");
 698   return mrb_nil_value();
 699 #else
 700   struct sockaddr_un *sunp;
 701   mrb_value path, s;
 702
 703   mrb_get_args(mrb, "S", &path);
 704   if ((size_t)RSTRING_LEN(path) > sizeof(sunp->sun_path) - 1) {
 705     mrb_raisef(mrb, E_ARGUMENT_ERROR, "too long unix socket path (max: %d bytes)", (int)sizeof(sunp->sun_path) - 1);
 706   }
 707   s = mrb_str_buf_new(mrb, sizeof(struct sockaddr_un));
 708   sunp = (struct sockaddr_un *)RSTRING_PTR(s);
 709 #if HAVE_SA_LEN
 710   sunp->sun_len = sizeof(struct sockaddr_un);
 711 #endif
 712   sunp->sun_family = AF_UNIX;
 713   memcpy(sunp->sun_path, RSTRING_PTR(path), RSTRING_LEN(path));
 714   sunp->sun_path[RSTRING_LEN(path)] = '\0';
 715   mrb_str_resize(mrb, s, sizeof(struct sockaddr_un));
 716   return s;
 717 #endif
 718 }
 719
 720 static mrb_value
 721 mrb_socket_socketpair(mrb_state *mrb, mrb_value klass)
 722 {
 723 #ifdef _WIN32
 724   mrb_raise(mrb, E_NOTIMP_ERROR, "socketpair unsupported on Windows");
 725   return mrb_nil_value();
 726 #else
 727   mrb_value ary;
 728   mrb_int domain, type, protocol;
 729   int sv[2];
 730
 731   mrb_get_args(mrb, "iii", &domain, &type, &protocol);
 732   if (socketpair(domain, type, protocol, sv) == -1) {
 733     mrb_sys_fail(mrb, "socketpair");
 734   }
 735   // XXX: possible descriptor leakage here!
 736   ary = mrb_ary_new_capa(mrb, 2);
 737   mrb_ary_push(mrb, ary, mrb_fixnum_value(sv[0]));
 738   mrb_ary_push(mrb, ary, mrb_fixnum_value(sv[1]));
 739   return ary;
 740 #endif
 741 }
 742
 743 static mrb_value
 744 mrb_socket_socket(mrb_state *mrb, mrb_value klass)
 745 {
 746   mrb_int domain, type, protocol;
 747   int s;
 748
 749   mrb_get_args(mrb, "iii", &domain, &type, &protocol);
 750   s = (int)socket((int)domain, (int)type, (int)protocol);
 751   if (s == -1)
 752     mrb_sys_fail(mrb, "socket");
 753   return mrb_fixnum_value(s);
 754 }
 755
 756 static mrb_value
 757 mrb_tcpsocket_allocate(mrb_state *mrb, mrb_value klass)
 758 {
 759   struct RClass *c = mrb_class_ptr(klass);
 760   enum mrb_vtype ttype = MRB_INSTANCE_TT(c);
 761
 762   /* copied from mrb_instance_alloc() */
 763   if (ttype == 0) ttype = MRB_TT_OBJECT;
 764   return mrb_obj_value((struct RObject*)mrb_obj_alloc(mrb, ttype, c));
 765 }
 766
 767 /* Windows overrides for IO methods on BasicSocket objects.
 768  * This is because sockets on Windows are not the same as file
 769  * descriptors, and thus functions which operate on file descriptors
 770  * will break on socket descriptors.
 771  */
 772 #ifdef _WIN32
 773 static mrb_value
 774 mrb_win32_basicsocket_close(mrb_state *mrb, mrb_value self)
 775 {
 776   if (closesocket(socket_fd(mrb, self)) != NO_ERROR)
 777     mrb_raise(mrb, E_SOCKET_ERROR, "closesocket unsuccessful");
 778   return mrb_nil_value();
 779 }
 780
 781 #define E_EOF_ERROR                (mrb_class_get(mrb, "EOFError"))
 782 static mrb_value
 783 mrb_win32_basicsocket_sysread(mrb_state *mrb, mrb_value self)
 784 {
 785   int sd, ret;
 786   mrb_value buf = mrb_nil_value();
 787   mrb_int maxlen;
 788
 789   mrb_get_args(mrb, "i|S", &maxlen, &buf);
 790   if (maxlen < 0) {
 791     return mrb_nil_value();
 792   }
 793
 794   if (mrb_nil_p(buf)) {
 795     buf = mrb_str_new(mrb, NULL, maxlen);
 796   }
 797   if (RSTRING_LEN(buf) != maxlen) {
 798     buf = mrb_str_resize(mrb, buf, maxlen);
 799   }
 800
 801   sd = socket_fd(mrb, self);
 802   ret = recv(sd, RSTRING_PTR(buf), (int)maxlen, 0);
 803
 804   switch (ret) {
 805     case 0: /* EOF */
 806       if (maxlen == 0) {
 807         buf = mrb_str_new_cstr(mrb, "");
 808       } else {
 809         mrb_raise(mrb, E_EOF_ERROR, "sysread failed: End of File");
 810       }
 811       break;
 812     case SOCKET_ERROR: /* Error */
 813       mrb_sys_fail(mrb, "recv");
 814       break;
 815     default:
 816       if (RSTRING_LEN(buf) != ret) {
 817         buf = mrb_str_resize(mrb, buf, ret);
 818       }
 819       break;
 820   }
 821
 822   return buf;
 823 }
 824
 825 static mrb_value
 826 mrb_win32_basicsocket_sysseek(mrb_state *mrb, mrb_value self)
 827 {
 828   mrb_raise(mrb, E_NOTIMP_ERROR, "sysseek not implemented for windows sockets");
 829   return mrb_nil_value();
 830 }
 831
 832 static mrb_value
 833 mrb_win32_basicsocket_syswrite(mrb_state *mrb, mrb_value self)
 834 {
 835   int n;
 836   SOCKET sd;
 837   mrb_value str;
 838
 839   sd = socket_fd(mrb, self);
 840   mrb_get_args(mrb, "S", &str);
 841   n = send(sd, RSTRING_PTR(str), (int)RSTRING_LEN(str), 0);
 842   if (n == SOCKET_ERROR)
 843     mrb_sys_fail(mrb, "send");
 844   return mrb_fixnum_value(n);
 845 }
 846
 847 #endif
 848
 849 void
 850 mrb_mruby_socket_gem_init(mrb_state* mrb)
 851 {
 852   struct RClass *io, *ai, *sock, *bsock, *ipsock, *tcpsock;
 853   struct RClass *constants;
 854
 855 #ifdef _WIN32
 856   WSADATA wsaData;
 857   int result;
 858   result = WSAStartup(MAKEWORD(2,2), &wsaData);
 859   if (result != NO_ERROR)
 860     mrb_raise(mrb, E_RUNTIME_ERROR, "WSAStartup failed");
 861 #endif
 862
 863   ai = mrb_define_class(mrb, "Addrinfo", mrb->object_class);
 864   mrb_mod_cv_set(mrb, ai, mrb_intern_lit(mrb, "_lastai"), mrb_nil_value());
 865   mrb_define_class_method(mrb, ai, "getaddrinfo", mrb_addrinfo_getaddrinfo, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(4));
 866   mrb_define_method(mrb, ai, "getnameinfo", mrb_addrinfo_getnameinfo, MRB_ARGS_OPT(1));
 867 #ifndef _WIN32
 868   mrb_define_method(mrb, ai, "unix_path", mrb_addrinfo_unix_path, MRB_ARGS_NONE());
 869 #endif
 870
 871   io = mrb_class_get(mrb, "IO");
 872
 873   bsock = mrb_define_class(mrb, "BasicSocket", io);
 874   mrb_define_method(mrb, bsock, "_recvfrom", mrb_basicsocket_recvfrom, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
 875   mrb_define_method(mrb, bsock, "_setnonblock", mrb_basicsocket_setnonblock, MRB_ARGS_REQ(1));
 876   mrb_define_method(mrb, bsock, "getpeereid", mrb_basicsocket_getpeereid, MRB_ARGS_NONE());
 877   mrb_define_method(mrb, bsock, "getpeername", mrb_basicsocket_getpeername, MRB_ARGS_NONE());
 878   mrb_define_method(mrb, bsock, "getsockname", mrb_basicsocket_getsockname, MRB_ARGS_NONE());
 879   mrb_define_method(mrb, bsock, "getsockopt", mrb_basicsocket_getsockopt, MRB_ARGS_REQ(2));
 880   mrb_define_method(mrb, bsock, "recv", mrb_basicsocket_recv, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
 881   // #recvmsg(maxlen, flags=0)
 882   mrb_define_method(mrb, bsock, "send", mrb_basicsocket_send, MRB_ARGS_REQ(2)|MRB_ARGS_OPT(1));
 883   // #sendmsg
 884   // #sendmsg_nonblock
 885   mrb_define_method(mrb, bsock, "setsockopt", mrb_basicsocket_setsockopt, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(2));
 886   mrb_define_method(mrb, bsock, "shutdown", mrb_basicsocket_shutdown, MRB_ARGS_OPT(1));
 887   mrb_define_method(mrb, bsock, "_is_socket=", mrb_basicsocket_set_is_socket, MRB_ARGS_REQ(1));
 888
 889   ipsock = mrb_define_class(mrb, "IPSocket", bsock);
 890   mrb_define_class_method(mrb, ipsock, "ntop", mrb_ipsocket_ntop, MRB_ARGS_REQ(1));
 891   mrb_define_class_method(mrb, ipsock, "pton", mrb_ipsocket_pton, MRB_ARGS_REQ(2));
 892   mrb_define_method(mrb, ipsock, "recvfrom", mrb_ipsocket_recvfrom, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
 893
 894   tcpsock = mrb_define_class(mrb, "TCPSocket", ipsock);
 895   mrb_define_class_method(mrb, tcpsock, "_allocate", mrb_tcpsocket_allocate, MRB_ARGS_NONE());
 896   mrb_define_class(mrb, "TCPServer", tcpsock);
 897
 898   mrb_define_class(mrb, "UDPSocket", ipsock);
 899   //#recvfrom_nonblock
 900
 901   sock = mrb_define_class(mrb, "Socket", bsock);
 902   mrb_define_class_method(mrb, sock, "_accept", mrb_socket_accept, MRB_ARGS_REQ(1));
 903   mrb_define_class_method(mrb, sock, "_accept2", mrb_socket_accept2, MRB_ARGS_REQ(1));
 904   mrb_define_class_method(mrb, sock, "_bind", mrb_socket_bind, MRB_ARGS_REQ(3));
 905   mrb_define_class_method(mrb, sock, "_connect", mrb_socket_connect, MRB_ARGS_REQ(3));
 906   mrb_define_class_method(mrb, sock, "_listen", mrb_socket_listen, MRB_ARGS_REQ(2));
 907   mrb_define_class_method(mrb, sock, "_sockaddr_family", mrb_socket_sockaddr_family, MRB_ARGS_REQ(1));
 908   mrb_define_class_method(mrb, sock, "_socket", mrb_socket_socket, MRB_ARGS_REQ(3));
 909   //mrb_define_class_method(mrb, sock, "gethostbyaddr", mrb_socket_gethostbyaddr, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
 910   //mrb_define_class_method(mrb, sock, "gethostbyname", mrb_socket_gethostbyname, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
 911   mrb_define_class_method(mrb, sock, "gethostname", mrb_socket_gethostname, MRB_ARGS_NONE());
 912   //mrb_define_class_method(mrb, sock, "getservbyname", mrb_socket_getservbyname, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
 913   //mrb_define_class_method(mrb, sock, "getservbyport", mrb_socket_getservbyport, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
 914   mrb_define_class_method(mrb, sock, "sockaddr_un", mrb_socket_sockaddr_un, MRB_ARGS_REQ(1));
 915   mrb_define_class_method(mrb, sock, "socketpair", mrb_socket_socketpair, MRB_ARGS_REQ(3));
 916   //mrb_define_method(mrb, sock, "sysaccept", mrb_socket_accept, MRB_ARGS_NONE());
 917
 918 #ifndef _WIN32
 919   mrb_define_class(mrb, "UNIXSocket", bsock);
 920   //mrb_define_class_method(mrb, usock, "pair", mrb_unixsocket_open, MRB_ARGS_OPT(2));
 921   //mrb_define_class_method(mrb, usock, "socketpair", mrb_unixsocket_open, MRB_ARGS_OPT(2));
 922
 923   //mrb_define_method(mrb, usock, "recv_io", mrb_unixsocket_peeraddr, MRB_ARGS_NONE());
 924   //mrb_define_method(mrb, usock, "recvfrom", mrb_unixsocket_peeraddr, MRB_ARGS_NONE());
 925   //mrb_define_method(mrb, usock, "send_io", mrb_unixsocket_peeraddr, MRB_ARGS_NONE());
 926 #endif
 927
 928   /* Windows IO Method Overrides on BasicSocket */
 929 #ifdef _WIN32
 930   mrb_define_method(mrb, bsock, "close", mrb_win32_basicsocket_close, MRB_ARGS_NONE());
 931   mrb_define_method(mrb, bsock, "sysread", mrb_win32_basicsocket_sysread, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
 932   mrb_define_method(mrb, bsock, "sysseek", mrb_win32_basicsocket_sysseek, MRB_ARGS_REQ(1));
 933   mrb_define_method(mrb, bsock, "syswrite", mrb_win32_basicsocket_syswrite, MRB_ARGS_REQ(1));
 934 #endif
 935
 936   constants = mrb_define_module_under(mrb, sock, "Constants");
 937
 938 #define define_const(SYM) \
 939   do {                                                          \
 940     mrb_define_const(mrb, constants, #SYM, mrb_fixnum_value(SYM));      \
 941   } while (0)
 942
 943 #include "const.cstub"
 944 }
 945
 946 void
 947 mrb_mruby_socket_gem_final(mrb_state* mrb)
 948 {
 949   mrb_value ai;
 950   ai = mrb_mod_cv_get(mrb, mrb_class_get(mrb, "Addrinfo"), mrb_intern_lit(mrb, "_lastai"));
 951   if (mrb_cptr_p(ai)) {
 952     freeaddrinfo((struct addrinfo*)mrb_cptr(ai));
 953   }
 954 #ifdef _WIN32
 955   WSACleanup();
 956 #endif
 957 }