sctp-socket 0.2.0 → 0.2.2

data/ext/sctp/socket.c

@@ -63,6 +63,65 @@ VALUE v_sctp_initmsg_struct;
 #define MAX_IP_ADDRESSES 8
 #define DEFAULT_BUFFER_SIZE 1024
 #define IP_BUFFER_SIZE INET6_ADDRSTRLEN
+#define MAX_NOTIFICATION_DATA 8192
+
+/*
+ * Helper function to parse an IP address string and fill a sockaddr_in or sockaddr_in6 structure.
+ * Supports both IPv4 and IPv6 addresses.
+ *
+ * @param addr_str The IP address string to parse
+ * @param port The port number (in host byte order)
+ * @param sin Pointer to sockaddr_in to fill (for IPv4)
+ * @param sin6 Pointer to sockaddr_in6 to fill (for IPv6)
+ * @param domain The address family (AF_INET or AF_INET6)
+ */
+static void parse_ip_address_v4(const char* addr_str, int port, struct sockaddr_in* sin){
+  bzero(sin, sizeof(*sin));
+  sin->sin_family = AF_INET;
+  sin->sin_port = htons(port);
+  if(inet_pton(AF_INET, addr_str, &sin->sin_addr) != 1)
+    rb_raise(rb_eArgError, "invalid IPv4 address: %s", addr_str);
+#ifdef BSD
+  sin->sin_len = sizeof(struct sockaddr_in);
+#endif
+}
+
+static void parse_ip_address_v6(const char* addr_str, int port, struct sockaddr_in6* sin6){
+  bzero(sin6, sizeof(*sin6));
+  sin6->sin6_family = AF_INET6;
+  sin6->sin6_port = htons(port);
+  if(inet_pton(AF_INET6, addr_str, &sin6->sin6_addr) != 1)
+    rb_raise(rb_eArgError, "invalid IPv6 address: %s", addr_str);
+#ifdef BSD
+  sin6->sin6_len = sizeof(struct sockaddr_in6);
+#endif
+}
+
+/*
+ * Helper function to set INADDR_ANY for IPv4.
+ */
+static void set_any_address_v4(int port, struct sockaddr_in* sin){
+  bzero(sin, sizeof(*sin));
+  sin->sin_family = AF_INET;
+  sin->sin_port = htons(port);
+  sin->sin_addr.s_addr = htonl(INADDR_ANY);
+#ifdef BSD
+  sin->sin_len = sizeof(struct sockaddr_in);
+#endif
+}
+
+/*
+ * Helper function to set IN6ADDR_ANY for IPv6.
+ */
+static void set_any_address_v6(int port, struct sockaddr_in6* sin6){
+  bzero(sin6, sizeof(*sin6));
+  sin6->sin6_family = AF_INET6;
+  sin6->sin6_port = htons(port);
+  sin6->sin6_addr = in6addr_any;
+#ifdef BSD
+  sin6->sin6_len = sizeof(struct sockaddr_in6);
+#endif
+}
 
 /*
  * Convert a sockaddr_in structure to a Ruby struct.
@@ -197,12 +256,18 @@ VALUE get_notification_info(char* buffer){
           v_str = rb_str_new2("unknown");
       }
 
-      inet_ntop(
-        ((struct sockaddr_in *)&snp->sn_paddr_change.spc_aaddr)->sin_family,
-        &(((struct sockaddr_in *)&snp->sn_paddr_change.spc_aaddr)->sin_addr),
-        str,
-        sizeof(str)
-      );
+      {
+        struct sockaddr* sa = (struct sockaddr*)&snp->sn_paddr_change.spc_aaddr;
+
+        if(sa->sa_family == AF_INET6){
+          struct sockaddr_in6* sin6 = (struct sockaddr_in6*)sa;
+          inet_ntop(AF_INET6, &sin6->sin6_addr, str, sizeof(str));
+        }
+        else{
+          struct sockaddr_in* sin = (struct sockaddr_in*)sa;
+          inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str));
+        }
+      }
 
       v_notification = rb_struct_new(v_peeraddr_change_struct,
         UINT2NUM(snp->sn_paddr_change.spc_type),
@@ -215,83 +280,150 @@ VALUE get_notification_info(char* buffer){
       );
       break;
     case SCTP_REMOTE_ERROR:
-      v_temp = ALLOCA_N(VALUE, snp->sn_remote_error.sre_length);
-
-      for(i = 0; i < snp->sn_remote_error.sre_length; i++){
-        v_temp[i] = UINT2NUM(snp->sn_remote_error.sre_data[i]);
+      {
+        size_t data_len = 0;
+        VALUE v_data_ary;
+
+        // Calculate actual data length (total length minus fixed header)
+        if(snp->sn_remote_error.sre_length > offsetof(struct sctp_remote_error, sre_data))
+          data_len = snp->sn_remote_error.sre_length - offsetof(struct sctp_remote_error, sre_data);
+
+        // Bounds check to prevent stack overflow
+        if(data_len > MAX_NOTIFICATION_DATA)
+          data_len = MAX_NOTIFICATION_DATA;
+
+        if(data_len > 0){
+          v_temp = ALLOCA_N(VALUE, data_len);
+          for(i = 0; i < data_len; i++){
+            v_temp[i] = UINT2NUM(snp->sn_remote_error.sre_data[i]);
+          }
+          v_data_ary = rb_ary_new4(data_len, v_temp);
+        }
+        else{
+          v_data_ary = rb_ary_new();
+        }
+
+        v_notification = rb_struct_new(v_remote_error_struct,
+          UINT2NUM(snp->sn_remote_error.sre_type),
+          UINT2NUM(snp->sn_remote_error.sre_flags),
+          UINT2NUM(snp->sn_remote_error.sre_length),
+          UINT2NUM(snp->sn_remote_error.sre_error),
+          UINT2NUM(snp->sn_remote_error.sre_assoc_id),
+          v_data_ary
+        );
       }
-
-      v_notification = rb_struct_new(v_remote_error_struct,
-        UINT2NUM(snp->sn_remote_error.sre_type),
-        UINT2NUM(snp->sn_remote_error.sre_flags),
-        UINT2NUM(snp->sn_remote_error.sre_length),
-        UINT2NUM(snp->sn_remote_error.sre_error),
-        UINT2NUM(snp->sn_remote_error.sre_assoc_id),
-        rb_ary_new4(snp->sn_remote_error.sre_length, v_temp)
-      );
       break;
 #ifdef SCTP_SEND_FAILED_EVENT
     case SCTP_SEND_FAILED_EVENT:
-#ifdef HAVE_STRUCT_SCTP_SEND_FAILED_EVENT_SSFE_LENGTH
-      v_temp = ALLOCA_N(VALUE, snp->sn_send_failed_event.ssfe_length);
-
-      for(i = 0; i < snp->sn_send_failed_event.ssfe_length; i++){
-        v_temp[i] = UINT2NUM(snp->sn_send_failed_event.ssfe_data[i]);
-      }
+      {
+        size_t data_len = 0;
+        VALUE v_data_ary;
 
-      v_notification = rb_struct_new(v_send_failed_event_struct,
-        UINT2NUM(snp->sn_send_failed_event.ssfe_type),
-        UINT2NUM(snp->sn_send_failed_event.ssfe_length),
-        UINT2NUM(snp->sn_send_failed_event.ssfe_error),
-        rb_struct_new(v_sndinfo_struct,
-          UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_sid),
-          UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_flags),
-          UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_ppid),
-          UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_context),
-          UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_assoc_id)
-        ),
-        UINT2NUM(snp->sn_send_failed_event.ssfe_assoc_id),
-        rb_ary_new4(snp->sn_send_failed_event.ssfe_length, v_temp)
-      );
+#ifdef HAVE_STRUCT_SCTP_SEND_FAILED_EVENT_SSFE_LENGTH
+        // Calculate actual data length (total length minus fixed header)
+        if(snp->sn_send_failed_event.ssfe_length > offsetof(struct sctp_send_failed_event, ssfe_data))
+          data_len = snp->sn_send_failed_event.ssfe_length - offsetof(struct sctp_send_failed_event, ssfe_data);
+
+        // Bounds check to prevent stack overflow
+        if(data_len > MAX_NOTIFICATION_DATA)
+          data_len = MAX_NOTIFICATION_DATA;
+
+        if(data_len > 0){
+          v_temp = ALLOCA_N(VALUE, data_len);
+          for(i = 0; i < data_len; i++){
+            v_temp[i] = UINT2NUM(snp->sn_send_failed_event.ssfe_data[i]);
+          }
+          v_data_ary = rb_ary_new4(data_len, v_temp);
+        }
+        else{
+          v_data_ary = rb_ary_new();
+        }
+
+        v_notification = rb_struct_new(v_send_failed_event_struct,
+          UINT2NUM(snp->sn_send_failed_event.ssfe_type),
+          UINT2NUM(snp->sn_send_failed_event.ssfe_length),
+          UINT2NUM(snp->sn_send_failed_event.ssfe_error),
+          rb_struct_new(v_sndinfo_struct,
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_sid),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_flags),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_ppid),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_context),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_assoc_id)
+          ),
+          UINT2NUM(snp->sn_send_failed_event.ssfe_assoc_id),
+          v_data_ary
+        );
 #else
-      v_temp = ALLOCA_N(VALUE, snp->sn_send_failed_event.ssf_length);
-
-      for(i = 0; i < snp->sn_send_failed_event.ssf_length; i++){
-        v_temp[i] = UINT2NUM(snp->sn_send_failed_event.ssf_data[i]);
-      }
-
-      v_notification = rb_struct_new(v_send_failed_event_struct,
-        UINT2NUM(snp->sn_send_failed_event.ssf_type),
-        UINT2NUM(snp->sn_send_failed_event.ssf_length),
-        UINT2NUM(snp->sn_send_failed_event.ssf_error),
-        rb_struct_new(v_sndinfo_struct,
-          UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_sid),
-          UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_flags),
-          UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_ppid),
-          UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_context),
-          UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_assoc_id)
-        ),
-        UINT2NUM(snp->sn_send_failed_event.ssf_assoc_id),
-        rb_ary_new4(snp->sn_send_failed_event.ssf_length, v_temp)
-      );
+        // Calculate actual data length (total length minus fixed header)
+        if(snp->sn_send_failed_event.ssf_length > offsetof(struct sctp_send_failed_event, ssf_data))
+          data_len = snp->sn_send_failed_event.ssf_length - offsetof(struct sctp_send_failed_event, ssf_data);
+
+        // Bounds check to prevent stack overflow
+        if(data_len > MAX_NOTIFICATION_DATA)
+          data_len = MAX_NOTIFICATION_DATA;
+
+        if(data_len > 0){
+          v_temp = ALLOCA_N(VALUE, data_len);
+          for(i = 0; i < data_len; i++){
+            v_temp[i] = UINT2NUM(snp->sn_send_failed_event.ssf_data[i]);
+          }
+          v_data_ary = rb_ary_new4(data_len, v_temp);
+        }
+        else{
+          v_data_ary = rb_ary_new();
+        }
+
+        v_notification = rb_struct_new(v_send_failed_event_struct,
+          UINT2NUM(snp->sn_send_failed_event.ssf_type),
+          UINT2NUM(snp->sn_send_failed_event.ssf_length),
+          UINT2NUM(snp->sn_send_failed_event.ssf_error),
+          rb_struct_new(v_sndinfo_struct,
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_sid),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_flags),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_ppid),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_context),
+            UINT2NUM(snp->sn_send_failed_event.ssfe_info.snd_assoc_id)
+          ),
+          UINT2NUM(snp->sn_send_failed_event.ssf_assoc_id),
+          v_data_ary
+        );
 #endif
+      }
       break;
 #else
     case SCTP_SEND_FAILED:
-      v_temp = ALLOCA_N(VALUE, snp->sn_send_failed.ssf_length);
-
-      for(i = 0; i < snp->sn_send_failed.ssf_length; i++){
-        v_temp[i] = UINT2NUM(snp->sn_send_failed.ssf_data[i]);
+      {
+        size_t data_len = 0;
+        VALUE v_data_ary;
+
+        // Calculate actual data length (total length minus fixed header)
+        if(snp->sn_send_failed.ssf_length > offsetof(struct sctp_send_failed, ssf_data))
+          data_len = snp->sn_send_failed.ssf_length - offsetof(struct sctp_send_failed, ssf_data);
+
+        // Bounds check to prevent stack overflow
+        if(data_len > MAX_NOTIFICATION_DATA)
+          data_len = MAX_NOTIFICATION_DATA;
+
+        if(data_len > 0){
+          v_temp = ALLOCA_N(VALUE, data_len);
+          for(i = 0; i < data_len; i++){
+            v_temp[i] = UINT2NUM(snp->sn_send_failed.ssf_data[i]);
+          }
+          v_data_ary = rb_ary_new4(data_len, v_temp);
+        }
+        else{
+          v_data_ary = rb_ary_new();
+        }
+
+        v_notification = rb_struct_new(v_send_failed_event_struct,
+          UINT2NUM(snp->sn_send_failed.ssf_type),
+          UINT2NUM(snp->sn_send_failed.ssf_length),
+          UINT2NUM(snp->sn_send_failed.ssf_error),
+          Qnil,
+          UINT2NUM(snp->sn_send_failed.ssf_assoc_id),
+          v_data_ary
+        );
       }
-
-      v_notification = rb_struct_new(v_send_failed_event_struct,
-        UINT2NUM(snp->sn_send_failed.ssf_type),
-        UINT2NUM(snp->sn_send_failed.ssf_length),
-        UINT2NUM(snp->sn_send_failed.ssf_error),
-        Qnil,
-        UINT2NUM(snp->sn_send_failed.ssf_assoc_id),
-        rb_ary_new4(snp->sn_send_failed.ssf_length, v_temp)
-      );
       break;
 #endif
     case SCTP_SHUTDOWN_EVENT:
@@ -451,14 +583,11 @@ static VALUE rsctp_init(int argc, VALUE* argv, VALUE self){
  * Returns the port that it was bound to.
  */
 static VALUE rsctp_bindx(int argc, VALUE* argv, VALUE self){
-  struct sockaddr_in addrs[MAX_IP_ADDRESSES];
   int i, fileno, num_ip, flags, domain, port, on;
   VALUE v_addresses, v_port, v_flags, v_address, v_reuse_addr, v_options;
 
   rb_scan_args(argc, argv, "01", &v_options);
 
-  bzero(&addrs, sizeof(addrs));
-
   if(NIL_P(v_options))
     v_options = rb_hash_new();
 
@@ -485,37 +614,51 @@ static VALUE rsctp_bindx(int argc, VALUE* argv, VALUE self){
   if(num_ip > MAX_IP_ADDRESSES)
     rb_raise(rb_eArgError, "too many IP addresses to bind, maximum is eight");
 
+  CHECK_SOCKET_CLOSED(self);
+
   domain = NUM2INT(rb_iv_get(self, "@domain"));
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
-  if(!NIL_P(v_addresses)){
-    for(i = 0; i < num_ip; i++){
-      v_address = RARRAY_PTR(v_addresses)[i];
-      addrs[i].sin_family = domain;
-      addrs[i].sin_port = htons(port);
-      addrs[i].sin_addr.s_addr = inet_addr(StringValueCStr(v_address));
-#ifdef BSD
-      addrs[i].sin_len = sizeof(struct sockaddr_in);
-#endif
-    }
-  }
-  else{
-    addrs[0].sin_family = domain;
-    addrs[0].sin_port = htons(port);
-    addrs[0].sin_addr.s_addr = htonl(INADDR_ANY);
-#ifdef BSD
-    addrs[0].sin_len = sizeof(struct sockaddr_in);
-#endif
-  }
-
   if(v_reuse_addr == Qtrue){
     on = 1;
     if(setsockopt(fileno, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
       rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
   }
 
-  if(sctp_bindx(fileno, (struct sockaddr *) addrs, num_ip, flags) != 0)
-    rb_raise(rb_eSystemCallError, "sctp_bindx: %s", strerror(errno));
+  if(domain == AF_INET6){
+    struct sockaddr_in6 addrs6[MAX_IP_ADDRESSES];
+    bzero(&addrs6, sizeof(addrs6));
+
+    if(!NIL_P(v_addresses)){
+      for(i = 0; i < num_ip; i++){
+        v_address = RARRAY_AREF(v_addresses, i);
+        parse_ip_address_v6(StringValueCStr(v_address), port, &addrs6[i]);
+      }
+    }
+    else{
+      set_any_address_v6(port, &addrs6[0]);
+    }
+
+    if(sctp_bindx(fileno, (struct sockaddr *)addrs6, num_ip, flags) != 0)
+      rb_raise(rb_eSystemCallError, "sctp_bindx: %s", strerror(errno));
+  }
+  else{
+    struct sockaddr_in addrs[MAX_IP_ADDRESSES];
+    bzero(&addrs, sizeof(addrs));
+
+    if(!NIL_P(v_addresses)){
+      for(i = 0; i < num_ip; i++){
+        v_address = RARRAY_AREF(v_addresses, i);
+        parse_ip_address_v4(StringValueCStr(v_address), port, &addrs[i]);
+      }
+    }
+    else{
+      set_any_address_v4(port, &addrs[0]);
+    }
+
+    if(sctp_bindx(fileno, (struct sockaddr *)addrs, num_ip, flags) != 0)
+      rb_raise(rb_eSystemCallError, "sctp_bindx: %s", strerror(errno));
+  }
 
   if(port == 0){
     struct sockaddr_in sin;
@@ -550,10 +693,9 @@ static VALUE rsctp_bindx(int argc, VALUE* argv, VALUE self){
  * methods will automatically establish associations.
  */
 static VALUE rsctp_connectx(int argc, VALUE* argv, VALUE self){
-  struct sockaddr_in addrs[MAX_IP_ADDRESSES];
-  int i, num_ip, fileno;
+  int i, num_ip, fileno, domain, port;
   sctp_assoc_t assoc;
-  VALUE v_address, v_domain, v_options, v_addresses, v_port;
+  VALUE v_address, v_options, v_addresses, v_port;
 
   rb_scan_args(argc, argv, "01", &v_options);
 
@@ -571,25 +713,41 @@ static VALUE rsctp_connectx(int argc, VALUE* argv, VALUE self){
   if(NIL_P(v_port))
     rb_raise(rb_eArgError, "you must specify a port");
 
-  v_domain = rb_iv_get(self, "@domain");
+  CHECK_SOCKET_CLOSED(self);
+
+  domain = NUM2INT(rb_iv_get(self, "@domain"));
+  port = NUM2INT(v_port);
+  fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
   num_ip = (int)RARRAY_LEN(v_addresses);
-  bzero(&addrs, sizeof(addrs));
 
-  for(i = 0; i < num_ip; i++){
-    v_address = RARRAY_PTR(v_addresses)[i];
-    addrs[i].sin_family = NUM2INT(v_domain);
-    addrs[i].sin_port = htons(NUM2INT(v_port));
-    addrs[i].sin_addr.s_addr = inet_addr(StringValueCStr(v_address));
-#ifdef BSD
-    addrs[i].sin_len = sizeof(struct sockaddr_in);
-#endif
+  if(num_ip > MAX_IP_ADDRESSES)
+    rb_raise(rb_eArgError, "too many IP addresses, maximum is eight");
+
+  if(domain == AF_INET6){
+    struct sockaddr_in6 addrs6[MAX_IP_ADDRESSES];
+    bzero(&addrs6, sizeof(addrs6));
+
+    for(i = 0; i < num_ip; i++){
+      v_address = RARRAY_AREF(v_addresses, i);
+      parse_ip_address_v6(StringValueCStr(v_address), port, &addrs6[i]);
+    }
+
+    if(sctp_connectx(fileno, (struct sockaddr *)addrs6, num_ip, &assoc) < 0)
+      rb_raise(rb_eSystemCallError, "sctp_connectx: %s", strerror(errno));
   }
+  else{
+    struct sockaddr_in addrs[MAX_IP_ADDRESSES];
+    bzero(&addrs, sizeof(addrs));
 
-  fileno = NUM2INT(rb_iv_get(self, "@fileno"));
+    for(i = 0; i < num_ip; i++){
+      v_address = RARRAY_AREF(v_addresses, i);
+      parse_ip_address_v4(StringValueCStr(v_address), port, &addrs[i]);
+    }
 
-  if(sctp_connectx(fileno, (struct sockaddr *) addrs, num_ip, &assoc) < 0)
-    rb_raise(rb_eSystemCallError, "sctp_connectx: %s", strerror(errno));
+    if(sctp_connectx(fileno, (struct sockaddr *)addrs, num_ip, &assoc) < 0)
+      rb_raise(rb_eSystemCallError, "sctp_connectx: %s", strerror(errno));
+  }
 
   rb_iv_set(self, "@association_id", INT2NUM(assoc));
 
@@ -731,8 +889,18 @@ static VALUE rsctp_getpeernames(int argc, VALUE* argv, VALUE self){
   }
 
   for(i = 0; i < num_addrs; i++){
+    struct sockaddr* sa = &addrs[i];
     bzero(&str, sizeof(str));
-    inet_ntop(AF_INET, &(((struct sockaddr_in *)&addrs[i])->sin_addr), str, sizeof(str));
+
+    if(sa->sa_family == AF_INET6){
+      struct sockaddr_in6* sin6 = (struct sockaddr_in6*)sa;
+      inet_ntop(AF_INET6, &sin6->sin6_addr, str, sizeof(str));
+    }
+    else{
+      struct sockaddr_in* sin = (struct sockaddr_in*)sa;
+      inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str));
+    }
+
     rb_ary_push(v_array, rb_str_new2(str));
   }
 
@@ -792,8 +960,18 @@ static VALUE rsctp_getlocalnames(int argc, VALUE* argv, VALUE self){
   }
 
   for(i = 0; i < num_addrs; i++){
+    struct sockaddr* sa = &addrs[i];
     bzero(&str, sizeof(str));
-    inet_ntop(AF_INET, &(((struct sockaddr_in *)&addrs[i])->sin_addr), str, sizeof(str));
+
+    if(sa->sa_family == AF_INET6){
+      struct sockaddr_in6* sin6 = (struct sockaddr_in6*)sa;
+      inet_ntop(AF_INET6, &sin6->sin6_addr, str, sizeof(str));
+    }
+    else{
+      struct sockaddr_in* sin = (struct sockaddr_in*)sa;
+      inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str));
+    }
+
     rb_ary_push(v_array, rb_str_new2(str));
   }
 
@@ -832,9 +1010,8 @@ static VALUE rsctp_getlocalnames(int argc, VALUE* argv, VALUE self){
 static VALUE rsctp_sendv(VALUE self, VALUE v_options){
   VALUE v_msg, v_message, v_addresses;
   struct iovec iov[IOV_MAX];
-  struct sockaddr_in* addrs;
   struct sctp_sendv_spa spa;
-  int i, fileno, size, num_ip;
+  int i, fileno, size, num_ip, domain, port;
   ssize_t num_bytes;
 
   Check_Type(v_options, T_HASH);
@@ -851,13 +1028,16 @@ static VALUE rsctp_sendv(VALUE self, VALUE v_options){
 
   Check_Type(v_message, T_ARRAY);
 
+  CHECK_SOCKET_CLOSED(self);
+
   if(!NIL_P(v_addresses)){
     Check_Type(v_addresses, T_ARRAY);
     num_ip = (int)RARRAY_LEN(v_addresses);
-    addrs = (struct sockaddr_in*)alloca(num_ip * sizeof(*addrs));
+
+    if(num_ip > MAX_IP_ADDRESSES)
+      rb_raise(rb_eArgError, "too many IP addresses, maximum is eight");
   }
   else{
-    addrs = NULL;
     num_ip = 0;
   }
 
@@ -875,8 +1055,15 @@ static VALUE rsctp_sendv(VALUE self, VALUE v_options){
   spa.sendv_sndinfo.snd_flags = SCTP_UNORDERED;
   spa.sendv_sndinfo.snd_assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
 
-  if(!NIL_P(v_addresses)){
-    int i, port, domain;
+  for(i = 0; i < size; i++){
+    v_msg = RARRAY_AREF(v_message, i);
+    iov[i].iov_base = StringValueCStr(v_msg);
+    iov[i].iov_len = RSTRING_LEN(v_msg);
+  }
+
+  domain = NUM2INT(rb_iv_get(self, "@domain"));
+
+  if(num_ip > 0){
     VALUE v_address, v_port;
 
     v_port = rb_iv_get(self, "@port");
@@ -886,36 +1073,62 @@ static VALUE rsctp_sendv(VALUE self, VALUE v_options){
     else
       port = NUM2INT(v_port);
 
-    domain = NUM2INT(rb_iv_get(self, "@domain"));
+    if(domain == AF_INET6){
+      struct sockaddr_in6* addrs6 = (struct sockaddr_in6*)alloca(num_ip * sizeof(struct sockaddr_in6));
+      bzero(addrs6, num_ip * sizeof(struct sockaddr_in6));
 
-    for(i = 0; i < num_ip; i++){
-      v_address = RARRAY_PTR(v_addresses)[i];
-      addrs[i].sin_family = domain;
-      addrs[i].sin_port = htons(port);
-      addrs[i].sin_addr.s_addr = inet_addr(StringValueCStr(v_address));
-#ifdef BSD
-      addrs[i].sin_len = sizeof(struct sockaddr_in);
-#endif
+      for(i = 0; i < num_ip; i++){
+        v_address = RARRAY_AREF(v_addresses, i);
+        parse_ip_address_v6(StringValueCStr(v_address), port, &addrs6[i]);
+      }
+
+      num_bytes = (ssize_t)sctp_sendv(
+        fileno,
+        iov,
+        size,
+        (struct sockaddr*)addrs6,
+        num_ip,
+        &spa,
+        sizeof(spa),
+        SCTP_SENDV_SPA,
+        0
+      );
     }
-  }
+    else{
+      struct sockaddr_in* addrs = (struct sockaddr_in*)alloca(num_ip * sizeof(struct sockaddr_in));
+      bzero(addrs, num_ip * sizeof(struct sockaddr_in));
 
-  for(i = 0; i < size; i++){
-    v_msg = RARRAY_PTR(v_message)[i];
-    iov[i].iov_base = StringValueCStr(v_msg);
-    iov[i].iov_len = RSTRING_LEN(v_msg);
-  }
+      for(i = 0; i < num_ip; i++){
+        v_address = RARRAY_AREF(v_addresses, i);
+        parse_ip_address_v4(StringValueCStr(v_address), port, &addrs[i]);
+      }
 
-  num_bytes = (ssize_t)sctp_sendv(
-    fileno,
-    iov,
-    size,
-    (struct sockaddr*)addrs,
-    num_ip,
-    &spa,
-    sizeof(spa),
-    SCTP_SENDV_SPA,
-    0
-  );
+      num_bytes = (ssize_t)sctp_sendv(
+        fileno,
+        iov,
+        size,
+        (struct sockaddr*)addrs,
+        num_ip,
+        &spa,
+        sizeof(spa),
+        SCTP_SENDV_SPA,
+        0
+      );
+    }
+  }
+  else{
+    num_bytes = (ssize_t)sctp_sendv(
+      fileno,
+      iov,
+      size,
+      NULL,
+      0,
+      &spa,
+      sizeof(spa),
+      SCTP_SENDV_SPA,
+      0
+    );
+  }
 
   if(num_bytes < 0)
     rb_raise(rb_eSystemCallError, "sctp_sendv: %s", strerror(errno));
@@ -925,24 +1138,50 @@ static VALUE rsctp_sendv(VALUE self, VALUE v_options){
 #endif
 
 #ifdef HAVE_SCTP_RECVV
+/*
+ * call-seq:
+ *    SCTP::Socket#recvv(flags=0, buffer_size=1024)
+ *
+ * Receive a message using sctp_recvv from another SCTP endpoint.
+ *
+ * The optional buffer_size parameter specifies the size of the receive buffer
+ * in bytes. Defaults to 1024 bytes if not specified.
+ *
+ * Example:
+ *
+ *   begin
+ *     socket = SCTP::Socket.new
+ *     socket.bind(:port => 62534, :addresses => ['10.0.4.5', '10.0.5.5'])
+ *     socket.listen
+ *
+ *     while true
+ *       info = socket.recvv
+ *       puts "Received message: #{info.message}"
+ *
+ *       # Or with custom buffer size
+ *       info = socket.recvv(0, 4096)
+ *       puts "Received message: #{info.message}"
+ *     end
+ *   ensure
+ *     socket.close
+ *   end
+ */
 static VALUE rsctp_recvv(int argc, VALUE* argv, VALUE self){
-  VALUE v_flags;
-  int fileno, flags, on;
+  VALUE v_flags, v_buffer_size;
+  int fileno, flags, on, buffer_size;
   ssize_t bytes;
   uint infotype;
   socklen_t infolen;
   struct iovec iov[1];
   struct sctp_rcvinfo info;
-  char buffer[1024];
+  char *buffer;
 
   bzero(&iov, sizeof(iov));
   bzero(&info, sizeof(info));
-  bzero(&buffer, sizeof(buffer));
 
-	iov->iov_base = buffer;
-	iov->iov_len = sizeof(buffer);
+  rb_scan_args(argc, argv, "02", &v_flags, &v_buffer_size);
 
-  rb_scan_args(argc, argv, "01", &v_flags);
+  CHECK_SOCKET_CLOSED(self);
 
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
@@ -951,9 +1190,28 @@ static VALUE rsctp_recvv(int argc, VALUE* argv, VALUE self){
   else
     flags = NUM2INT(v_flags);
 
+  if(NIL_P(v_buffer_size))
+    buffer_size = 1024;
+  else
+    buffer_size = NUM2INT(v_buffer_size);
+
+  if(buffer_size <= 0)
+    rb_raise(rb_eArgError, "buffer size must be positive");
+
+  buffer = (char*)malloc(buffer_size);
+  if(buffer == NULL)
+    rb_raise(rb_eNoMemError, "failed to allocate buffer");
+
+  bzero(buffer, buffer_size);
+
+	iov->iov_base = buffer;
+	iov->iov_len = buffer_size;
+
   on = 1;
-  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_RECVRCVINFO, &on, sizeof(on)) < 0)
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_RECVRCVINFO, &on, sizeof(on)) < 0){
+    free(buffer);
     rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
+  }
 
   infolen = sizeof(struct sctp_rcvinfo);
   infotype = 0;
@@ -970,16 +1228,19 @@ static VALUE rsctp_recvv(int argc, VALUE* argv, VALUE self){
     &flags
   );
 
-  if(bytes < 0)
+  if(bytes < 0){
+    free(buffer);
     rb_raise(rb_eSystemCallError, "sctp_recvv: %s", strerror(errno));
+  }
 
   if(infotype != SCTP_RECVV_RCVINFO){
+    free(buffer);
     return Qnil;
   }
   else{
-    return rb_struct_new(
+    VALUE result = rb_struct_new(
       v_sctp_receive_info_struct,
-      rb_str_new2(iov->iov_base),
+      rb_str_new(iov->iov_base, bytes),
       UINT2NUM(info.rcv_sid),
       UINT2NUM(info.rcv_ssn),
       UINT2NUM(info.rcv_flags),
@@ -989,6 +1250,8 @@ static VALUE rsctp_recvv(int argc, VALUE* argv, VALUE self){
       UINT2NUM(info.rcv_context),
       UINT2NUM(info.rcv_assoc_id)
     );
+    free(buffer);
+    return result;
   }
 }
 #endif
@@ -1066,6 +1329,8 @@ static VALUE rsctp_send(VALUE self, VALUE v_options){
   else
     assoc_id = NUM2INT(v_assoc_id);
 
+  CHECK_SOCKET_CLOSED(self);
+
   info.sinfo_stream = stream;
   info.sinfo_flags = send_flags;
   info.sinfo_ppid = ppid;
@@ -1126,13 +1391,10 @@ static VALUE rsctp_sendmsg(VALUE self, VALUE v_options){
   uint16_t stream;
   uint32_t ppid, flags, ttl, context;
   ssize_t num_bytes;
-  struct sockaddr_in addrs[MAX_IP_ADDRESSES];
-  int fileno, size, num_ip;
+  int fileno, num_ip, domain;
 
   Check_Type(v_options, T_HASH);
 
-  bzero(&addrs, sizeof(addrs));
-
   v_msg       = rb_hash_aref2(v_options, "message");
   v_stream    = rb_hash_aref2(v_options, "stream");
   v_ppid      = rb_hash_aref2(v_options, "ppid");
@@ -1172,12 +1434,21 @@ static VALUE rsctp_sendmsg(VALUE self, VALUE v_options){
   else
     context = NUM2INT(v_context);
 
+  CHECK_SOCKET_CLOSED(self);
+
+  fileno = NUM2INT(rb_iv_get(self, "@fileno"));
+  domain = NUM2INT(rb_iv_get(self, "@domain"));
+
   if(!NIL_P(v_addresses)){
     int i, port;
     VALUE v_address, v_port;
 
     Check_Type(v_addresses, T_ARRAY);
     num_ip = (int)RARRAY_LEN(v_addresses);
+
+    if(num_ip > MAX_IP_ADDRESSES)
+      rb_raise(rb_eArgError, "too many IP addresses, maximum is eight");
+
     v_port = rb_hash_aref2(v_options, "port");
 
     if(NIL_P(v_port))
@@ -1185,47 +1456,92 @@ static VALUE rsctp_sendmsg(VALUE self, VALUE v_options){
     else
       port = NUM2INT(v_port);
 
-    for(i = 0; i < num_ip; i++){
-      v_address = RARRAY_PTR(v_addresses)[i];
-      addrs[i].sin_family = NUM2INT(rb_iv_get(self, "@domain"));
-      addrs[i].sin_port = htons(port);
-      addrs[i].sin_addr.s_addr = inet_addr(StringValueCStr(v_address));
+    if(domain == AF_INET6){
+      struct sockaddr_in6 addrs6[MAX_IP_ADDRESSES];
+
+      bzero(&addrs6, sizeof(addrs6));
+
+      for(i = 0; i < num_ip; i++){
+        v_address = RARRAY_AREF(v_addresses, i);
+        parse_ip_address_v6(StringValueCStr(v_address), port, &addrs6[i]);
+      }
+
 #ifdef BSD
-      addrs[i].sin_len = sizeof(struct sockaddr_in);
+      num_bytes = (ssize_t)sctp_sendmsgx(
+        fileno,
+        StringValueCStr(v_msg),
+        RSTRING_LEN(v_msg),
+        (struct sockaddr*)addrs6,
+        num_ip,
+        ppid,
+        flags,
+        stream,
+        ttl,
+        context
+      );
+#else
+      num_bytes = (ssize_t)sctp_sendmsg(
+        fileno,
+        StringValueCStr(v_msg),
+        RSTRING_LEN(v_msg),
+        (struct sockaddr*)addrs6,
+        num_ip * sizeof(struct sockaddr_in6),
+        ppid,
+        flags,
+        stream,
+        ttl,
+        context
+      );
 #endif
     }
+    else{
+      struct sockaddr_in addrs[MAX_IP_ADDRESSES];
 
-    size = sizeof(addrs);
-  }
-  else{
-    num_ip = 0;
-    size = 0;
-  }
+      bzero(&addrs, sizeof(addrs));
 
-  fileno = NUM2INT(rb_iv_get(self, "@fileno"));
+      for(i = 0; i < num_ip; i++){
+        v_address = RARRAY_AREF(v_addresses, i);
+        parse_ip_address_v4(StringValueCStr(v_address), port, &addrs[i]);
+      }
 
 #ifdef BSD
-  if(num_ip){
-    num_bytes = (ssize_t)sctp_sendmsgx(
-      fileno,
-      StringValueCStr(v_msg),
-      RSTRING_LEN(v_msg),
-      (struct sockaddr*)addrs,
-      num_ip,
-      ppid,
-      flags,
-      stream,
-      ttl,
-      context
-    );
+      num_bytes = (ssize_t)sctp_sendmsgx(
+        fileno,
+        StringValueCStr(v_msg),
+        RSTRING_LEN(v_msg),
+        (struct sockaddr*)addrs,
+        num_ip,
+        ppid,
+        flags,
+        stream,
+        ttl,
+        context
+      );
+#else
+      num_bytes = (ssize_t)sctp_sendmsg(
+        fileno,
+        StringValueCStr(v_msg),
+        RSTRING_LEN(v_msg),
+        (struct sockaddr*)addrs,
+        num_ip * sizeof(struct sockaddr_in),
+        ppid,
+        flags,
+        stream,
+        ttl,
+        context
+      );
+#endif
+    }
   }
   else{
+    // No addresses - use empty addrs
+    num_ip = 0;
     num_bytes = (ssize_t)sctp_sendmsg(
       fileno,
       StringValueCStr(v_msg),
       RSTRING_LEN(v_msg),
-      (struct sockaddr*)addrs,
-      size,
+      NULL,
+      0,
       ppid,
       flags,
       stream,
@@ -1233,20 +1549,6 @@ static VALUE rsctp_sendmsg(VALUE self, VALUE v_options){
       context
     );
   }
-#else
-  num_bytes = (ssize_t)sctp_sendmsg(
-    fileno,
-    StringValueCStr(v_msg),
-    RSTRING_LEN(v_msg),
-    (struct sockaddr*)addrs,
-    size,
-    ppid,
-    flags,
-    stream,
-    ttl,
-    context
-  );
-#endif
 
   if(num_bytes < 0){
 #ifdef BSD
@@ -1264,10 +1566,13 @@ static VALUE rsctp_sendmsg(VALUE self, VALUE v_options){
 
 /*
  * call-seq:
- *    SCTP::Socket#recvmsg(flags=0)
+ *    SCTP::Socket#recvmsg(flags=0, buffer_size=1024)
  *
  * Receive a message from another SCTP endpoint.
  *
+ * The optional buffer_size parameter specifies the size of the receive buffer
+ * in bytes. Defaults to 1024 bytes if not specified.
+ *
  * Example:
  *
  *   begin
@@ -1279,46 +1584,66 @@ static VALUE rsctp_sendmsg(VALUE self, VALUE v_options){
  *     while true
  *       info = socket.recvmsg
  *       puts "Received message: #{info.message}"
+ *
+ *       # Or with custom buffer size
+ *       info = socket.recvmsg(0, 4096)
+ *       puts "Received message: #{info.message}"
  *     end
  *   ensure
  *     socket.close
  *   end
  */
 static VALUE rsctp_recvmsg(int argc, VALUE* argv, VALUE self){
-  VALUE v_flags, v_notification, v_message;
+  VALUE v_flags, v_buffer_size, v_notification, v_message;
   struct sctp_sndrcvinfo sndrcvinfo;
   struct sockaddr_in clientaddr;
-  int flags, fileno;
+  int flags, fileno, buffer_size;
   ssize_t bytes;
-  char buffer[1024]; // TODO: Let this be configurable?
+  char *buffer;
   socklen_t length;
 
-  rb_scan_args(argc, argv, "01", &v_flags);
+  rb_scan_args(argc, argv, "02", &v_flags, &v_buffer_size);
 
   if(NIL_P(v_flags))
     flags = 0;
   else
     flags = NUM2INT(v_flags);
 
+  if(NIL_P(v_buffer_size))
+    buffer_size = 1024;
+  else
+    buffer_size = NUM2INT(v_buffer_size);
+
+  if(buffer_size <= 0)
+    rb_raise(rb_eArgError, "buffer size must be positive");
+
+  buffer = (char*)malloc(buffer_size);
+  if(buffer == NULL)
+    rb_raise(rb_eNoMemError, "failed to allocate buffer");
+
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   length = sizeof(struct sockaddr_in);
 
-  bzero(buffer, sizeof(buffer));
+  bzero(buffer, buffer_size);
   bzero(&clientaddr, sizeof(clientaddr));
   bzero(&sndrcvinfo, sizeof(sndrcvinfo));
 
   bytes = (ssize_t)sctp_recvmsg(
     fileno,
     buffer,
-    sizeof(buffer),
+    buffer_size,
     (struct sockaddr*)&clientaddr,
     &length,
     &sndrcvinfo,
     &flags
   );
 
-  if(bytes < 0)
+  if(bytes < 0){
+    free(buffer);
     rb_raise(rb_eSystemCallError, "sctp_recvmsg: %s", strerror(errno));
+  }
 
   v_notification = Qnil;
 
@@ -1330,6 +1655,8 @@ static VALUE rsctp_recvmsg(int argc, VALUE* argv, VALUE self){
   else
     v_message = Qnil;
 
+  free(buffer);
+
   return rb_struct_new(v_sndrcv_struct,
     v_message,
     UINT2NUM(sndrcvinfo.sinfo_stream),
@@ -1370,6 +1697,8 @@ static VALUE rsctp_set_initmsg(VALUE self, VALUE v_options){
 
   bzero(&initmsg, sizeof(initmsg));
 
+  CHECK_SOCKET_CLOSED(self);
+
   v_output   = rb_hash_aref2(v_options, "output_streams");
   v_input    = rb_hash_aref2(v_options, "input_streams");
   v_attempts = rb_hash_aref2(v_options, "max_attempts");
@@ -1440,6 +1769,8 @@ static VALUE rsctp_subscribe(VALUE self, VALUE v_options){
   bzero(&events, sizeof(events));
   Check_Type(v_options, T_HASH);
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
   if(RTEST(rb_hash_aref2(v_options, "data_io")))
@@ -1520,6 +1851,8 @@ static VALUE rsctp_listen(int argc, VALUE* argv, VALUE self){
   if(backlog > SOMAXCONN)
     rb_raise(rb_eArgError, "backlog value exceeds maximum value of: %i", SOMAXCONN);
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
   if(listen(fileno, backlog) < 0)
@@ -1550,6 +1883,8 @@ static VALUE rsctp_peeloff(VALUE self, VALUE v_assoc_id){
   int fileno, assoc_fileno;
   sctp_assoc_t assoc_id;
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(v_assoc_id);
 
@@ -1587,6 +1922,8 @@ static VALUE rsctp_get_default_send_params(VALUE self){
 
   bzero(&sndrcv, sizeof(sndrcv));
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
   size = sizeof(struct sctp_sndrcvinfo);
@@ -1632,6 +1969,8 @@ static VALUE rsctp_get_association_info(VALUE self){
 
   bzero(&assoc, sizeof(assoc));
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
   size = sizeof(struct sctp_assocparams);
@@ -1674,6 +2013,8 @@ static VALUE rsctp_set_association_info(VALUE self, VALUE v_options){
 
   bzero(&assoc, sizeof(assoc));
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
   v_assoc_id = rb_hash_aref2(v_options, "association_id");
@@ -1738,6 +2079,8 @@ static VALUE rsctp_shutdown(int argc, VALUE* argv, VALUE self){
   int how, fileno;
   VALUE v_how;
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
   rb_scan_args(argc, argv, "01", &v_how);
@@ -1777,6 +2120,8 @@ static VALUE rsctp_get_retransmission_info(VALUE self){
 
   bzero(&rto, sizeof(rto));
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
   size = sizeof(struct sctp_rtoinfo);
@@ -1816,6 +2161,8 @@ static VALUE rsctp_set_retransmission_info(VALUE self, VALUE v_options){
 
   bzero(&rto, sizeof(rto));
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
   v_assoc_id = rb_hash_aref2(v_options, "association_id");
@@ -1881,10 +2228,12 @@ static VALUE rsctp_get_status(VALUE self){
   sctp_assoc_t assoc_id;
   struct sctp_status status;
   struct sctp_paddrinfo* spinfo;
-  char tmpname[INET_ADDRSTRLEN];
+  char tmpname[INET6_ADDRSTRLEN];
 
   bzero(&status, sizeof(status));
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
   size = sizeof(struct sctp_status);
@@ -1949,6 +2298,8 @@ static VALUE rsctp_get_subscriptions(VALUE self){
 
   bzero(&events, sizeof(events));
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
   size = sizeof(struct sctp_event_subscribe);
@@ -2014,6 +2365,8 @@ static VALUE rsctp_get_peer_address_params(VALUE self){
   bzero(&paddr, sizeof(paddr));
   bzero(&str, sizeof(str));
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
   size = sizeof(struct sctp_paddrparams);
@@ -2021,7 +2374,18 @@ static VALUE rsctp_get_peer_address_params(VALUE self){
   if(sctp_opt_info(fileno, assoc_id, SCTP_PEER_ADDR_PARAMS, (void*)&paddr, &size) < 0)
     rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
 
-  inet_ntop(AF_INET, ((struct sockaddr_in*)&paddr.spp_address), str, sizeof(str));
+  {
+    struct sockaddr* sa = (struct sockaddr*)&paddr.spp_address;
+
+    if(sa->sa_family == AF_INET6){
+      struct sockaddr_in6* sin6 = (struct sockaddr_in6*)sa;
+      inet_ntop(AF_INET6, &sin6->sin6_addr, str, sizeof(str));
+    }
+    else{
+      struct sockaddr_in* sin = (struct sockaddr_in*)sa;
+      inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str));
+    }
+  }
 
   return rb_struct_new(
     v_sctp_peer_addr_params_struct,
@@ -2061,6 +2425,8 @@ static VALUE rsctp_get_init_msg(VALUE self){
 
   bzero(&initmsg, sizeof(initmsg));
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
   size = sizeof(struct sctp_initmsg);
@@ -2089,6 +2455,8 @@ static VALUE rsctp_get_nodelay(VALUE self){
   sctp_assoc_t assoc_id;
   int value;
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
   size = sizeof(int);
@@ -2115,6 +2483,8 @@ static VALUE rsctp_set_nodelay(VALUE self, VALUE v_bool){
   socklen_t size;
   int value;
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   size = sizeof(int);
 
@@ -2148,6 +2518,8 @@ static VALUE rsctp_disable_fragments(VALUE self, VALUE v_bool){
   sctp_assoc_t assoc_id;
   int value;
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
   size = sizeof(int);
@@ -2179,6 +2551,8 @@ static VALUE rsctp_get_autoclose(VALUE self){
   sctp_assoc_t assoc_id;
   int value;
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
   size = sizeof(int);
@@ -2215,6 +2589,8 @@ static VALUE rsctp_set_autoclose(VALUE self, VALUE v_seconds){
   int fileno;
   int value;
 
+  CHECK_SOCKET_CLOSED(self);
+
   value = NUM2INT(v_seconds);
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
@@ -2239,6 +2615,8 @@ static VALUE rsctp_enable_auth_support(int argc, VALUE* argv, VALUE self){
 
   rb_scan_args(argc, argv, "01", &v_assoc_id);
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   size = sizeof(struct sctp_assoc_value);
 
@@ -2250,8 +2628,8 @@ static VALUE rsctp_enable_auth_support(int argc, VALUE* argv, VALUE self){
   assoc_value.assoc_id = assoc_id;
   assoc_value.assoc_value = 1;
 
-  if(sctp_opt_info(fileno, assoc_id, SCTP_AUTH_SUPPORTED, (void*)&assoc_value, &size) < 0)
-    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_AUTH_SUPPORTED, (void*)&assoc_value, size) < 0)
+    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
 
   return self;
 }
@@ -2295,7 +2673,7 @@ static VALUE rsctp_get_auth_support(int argc, VALUE* argv, VALUE self){
 
 /*
  * call-seq:
- *    SCTP::Socket#set_shared_key(key, keynum, association_id=nil)
+ *    SCTP::Socket#set_shared_key(key, keynum=1, association_id=nil)
  *
  *  This option will set a shared secret key which is used to build an
  *  association shared key.
@@ -2324,25 +2702,18 @@ static VALUE rsctp_set_shared_key(int argc, VALUE* argv, VALUE self){
   size_t len;
   char* key;
   uint keynum;
-  socklen_t size;
+  size_t size;
   sctp_assoc_t assoc_id;
   struct sctp_authkey* auth_key;
   VALUE v_key, v_keynumber, v_assoc_id;
 
   rb_scan_args(argc, argv, "12", &v_key, &v_keynumber, &v_assoc_id);
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   key = StringValuePtr(v_key);
-  len = strlen(key);
-  unsigned char byte_array[len+1];
-
-  for(size_t i = 0; i < len; i++)
-    byte_array[i] = key[i];
-
-  byte_array[len] = '\0';
-
-  auth_key = malloc(sizeof(auth_key) + sizeof(char[strlen(key)+1]));
-  size = sizeof(auth_key);
+  len = RSTRING_LEN(v_key); // Use Ruby's string length, not strlen
 
   if(NIL_P(v_assoc_id))
     assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
@@ -2354,14 +2725,25 @@ static VALUE rsctp_set_shared_key(int argc, VALUE* argv, VALUE self){
   else
     keynum = NUM2INT(v_keynumber);
 
+  // Allocate the structure with space for the key
+  size = sizeof(struct sctp_authkey) + len;
+  auth_key = malloc(size);
+
+  if (auth_key == NULL)
+    rb_raise(rb_eNoMemError, "Failed to allocate memory for auth key");
+
   auth_key->sca_assoc_id = assoc_id;
   auth_key->sca_keynumber = keynum;
-  auth_key->sca_keylength = strlen(key);
-  memcpy(auth_key->sca_key, byte_array, sizeof(byte_array));
+  auth_key->sca_keylength = len;
+  memcpy(auth_key->sca_key, key, len);
 
-  if(sctp_opt_info(fileno, assoc_id, SCTP_AUTH_KEY, (void*)auth_key, &size) < 0)
-    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_AUTH_KEY, (void*)auth_key, size) < 0) {
+    int err = errno;
+    free(auth_key);
+    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(err));
+  }
 
+  free(auth_key);
   return self;
 }
 
@@ -2377,14 +2759,21 @@ static VALUE rsctp_get_active_shared_key(int argc, VALUE* argv, VALUE self){
   struct sctp_authkeyid authkey;
   sctp_assoc_t assoc_id;
   VALUE v_assoc_id, v_keynum;
-  uint keynum;
+  int keynum;
 
   rb_scan_args(argc, argv, "11", &v_keynum, &v_assoc_id);
 
+  CHECK_SOCKET_CLOSED(self);
+
   bzero(&authkey, sizeof(authkey));
 
+  // Cast it later, we want to force a validity check.
+  keynum = FIX2INT(v_keynum);
+
+  if(keynum < 0)
+    rb_raise(rb_eArgError, "invalid keynum value");
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
-  keynum = NUM2UINT(v_keynum);
 
   if(NIL_P(v_assoc_id))
     assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
@@ -2392,7 +2781,7 @@ static VALUE rsctp_get_active_shared_key(int argc, VALUE* argv, VALUE self){
     assoc_id = NUM2INT(v_assoc_id);
 
   authkey.scact_assoc_id = assoc_id;
-  authkey.scact_keynumber = keynum;
+  authkey.scact_keynumber = (uint)keynum;
 
   size = sizeof(struct sctp_authkeyid);
 
@@ -2413,7 +2802,7 @@ static VALUE rsctp_get_active_shared_key(int argc, VALUE* argv, VALUE self){
  * authenticated chunks. The key identifier MUST correspond to an existing
  * shared key. Note that shared key identifier '0' defaults to a null key.
  *
- * The association_idparameter, if non-zero, indicates what association that
+ * The association_id parameter, if non-zero, indicates what association that
  * the shared key identifier is being set active upon. If this element contains
  * zero, then the activation applies to the endpoint and all future
  * associations will use the specified shared key identifier.
@@ -2430,11 +2819,17 @@ static VALUE rsctp_set_active_shared_key(int argc, VALUE* argv, VALUE self){
   struct sctp_authkeyid authkey;
   sctp_assoc_t assoc_id;
   VALUE v_assoc_id, v_keynum;
-  uint keynum;
+  int keynum;
 
   rb_scan_args(argc, argv, "11", &v_keynum, &v_assoc_id);
 
-  keynum = NUM2UINT(v_keynum);
+  CHECK_SOCKET_CLOSED(self);
+
+  keynum = FIX2INT(v_keynum);
+
+  if(keynum < 0)
+    rb_raise(rb_eArgError, "invalid keynum value");
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
   if(NIL_P(v_assoc_id))
@@ -2443,11 +2838,11 @@ static VALUE rsctp_set_active_shared_key(int argc, VALUE* argv, VALUE self){
     assoc_id = NUM2INT(v_assoc_id);
 
   authkey.scact_assoc_id = assoc_id;
-  authkey.scact_keynumber = keynum;
+  authkey.scact_keynumber = (uint)keynum;
   size = sizeof(struct sctp_authkeyid);
 
-  if(sctp_opt_info(fileno, assoc_id, SCTP_AUTH_ACTIVE_KEY, (void*)&authkey, &size) < 0)
-    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_AUTH_ACTIVE_KEY, (void*)&authkey, size) < 0)
+    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
 
   return self;
 }
@@ -2487,6 +2882,8 @@ static VALUE rsctp_delete_shared_key(int argc, VALUE* argv, VALUE self){
 
   rb_scan_args(argc, argv, "11", &v_keynum, &v_assoc_id);
 
+  CHECK_SOCKET_CLOSED(self);
+
   bzero(&authkey, sizeof(authkey));
 
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
@@ -2502,8 +2899,8 @@ static VALUE rsctp_delete_shared_key(int argc, VALUE* argv, VALUE self){
 
   size = sizeof(struct sctp_authkeyid);
 
-  if(sctp_opt_info(fileno, assoc_id, SCTP_AUTH_DELETE_KEY, (void*)&authkey, &size) < 0)
-    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_AUTH_DELETE_KEY, (void*)&authkey, size) < 0)
+    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
 
   return INT2NUM(authkey.scact_keynumber);
 }
@@ -2512,14 +2909,20 @@ static VALUE rsctp_delete_shared_key(int argc, VALUE* argv, VALUE self){
  * call-seq:
  *    SCTP::Socket#map_ipv4=(bool)
  *
- * If set to true and the socket is type PF_INET6, then IPv4 addresses will be
+ * If set to true and the socket is type xF_INET6, then IPv4 addresses will be
  * mapped to V6 representation. If set to false (the default), then no mapping
- * will be done of V4 addresses and a user will receive both PF_INET6 and
- * PF_INET type addresses on the socket.
+ * will be done of V4 addresses and a user will receive both xF_INET6 and
+ * xF_INET type addresses on the socket.
+ *
+ * Note that setting this to true on a socket that is not type xF_INET6 is
+ * undefined behavior, and may raise an error on your platform. Otherwise it's
+ * a no-op.
  */
 static VALUE rsctp_map_ipv4(VALUE self, VALUE v_bool){
   int fileno, boolean;
 
+  CHECK_SOCKET_CLOSED(self);
+
   boolean = 0;
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
@@ -2594,6 +2997,8 @@ static VALUE rsctp_set_default_send_params(VALUE self, VALUE v_options){
 
   bzero(&sndrcv, sizeof(sndrcv));
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
 
   v_stream = rb_hash_aref2(v_options, "stream");
@@ -2677,17 +3082,19 @@ static VALUE rsctp_set_default_send_params(VALUE self, VALUE v_options){
  */
 static VALUE rsctp_set_peer_address_params(VALUE self, VALUE v_options){
   VALUE v_assoc_id, v_address, v_hbinterval, v_pathmaxrxt, v_pathmtu, v_flags, v_ipv6_flowlabel;
-  int fileno;
+  int fileno, domain;
   sctp_assoc_t assoc_id;
   struct sctp_paddrparams paddr;
-  struct sockaddr_in* sin;
 
   if(!RB_TYPE_P(v_options, T_HASH))
     rb_raise(rb_eTypeError, "options must be a hash");
 
   bzero(&paddr, sizeof(paddr));
 
+  CHECK_SOCKET_CLOSED(self);
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
+  domain = NUM2INT(rb_iv_get(self, "@domain"));
 
   v_assoc_id = rb_hash_aref2(v_options, "association_id");
   v_address = rb_hash_aref2(v_options, "address");
@@ -2703,12 +3110,28 @@ static VALUE rsctp_set_peer_address_params(VALUE self, VALUE v_options){
   assoc_id = NUM2INT(v_assoc_id);
   paddr.spp_assoc_id = assoc_id;
 
-  // If address is provided, set up the sockaddr structure
+  // If address is provided, set up the sockaddr structure based on domain
   if(!NIL_P(v_address)){
-    sin = (struct sockaddr_in*)&paddr.spp_address;
-    sin->sin_family = AF_INET;
-    if(inet_pton(AF_INET, StringValueCStr(v_address), &sin->sin_addr) <= 0)
-      rb_raise(rb_eArgError, "invalid IP address");
+    const char* addr_str = StringValueCStr(v_address);
+
+    if(domain == AF_INET6){
+      struct sockaddr_in6* sin6 = (struct sockaddr_in6*)&paddr.spp_address;
+      sin6->sin6_family = AF_INET6;
+      if(inet_pton(AF_INET6, addr_str, &sin6->sin6_addr) <= 0)
+        rb_raise(rb_eArgError, "invalid IPv6 address: %s", addr_str);
+#ifdef BSD
+      sin6->sin6_len = sizeof(struct sockaddr_in6);
+#endif
+    }
+    else{
+      struct sockaddr_in* sin = (struct sockaddr_in*)&paddr.spp_address;
+      sin->sin_family = AF_INET;
+      if(inet_pton(AF_INET, addr_str, &sin->sin_addr) <= 0)
+        rb_raise(rb_eArgError, "invalid IPv4 address: %s", addr_str);
+#ifdef BSD
+      sin->sin_len = sizeof(struct sockaddr_in);
+#endif
+    }
   }
 
   if(!NIL_P(v_hbinterval))
@@ -2826,7 +3249,7 @@ void Init_socket(void){
 
   v_sctp_receive_info_struct = rb_struct_define(
     "ReceiveInfo", "message", "sid", "ssn", "flags", "ppid", "tsn",
-    "cumtsn", "context", "assocation_id", NULL
+    "cumtsn", "context", "association_id", NULL
   );
 
   v_sctp_peer_addr_params_struct = rb_struct_define(
@@ -2899,8 +3322,8 @@ void Init_socket(void){
   rb_define_attr(cSocket, "association_id", 1, 1);
   rb_define_attr(cSocket, "port", 1, 1);
 
-  /* 0.1.4: The version of this library */
-  rb_define_const(cSocket, "VERSION", rb_str_new2("0.2.0"));
+  /* 0.2.2: The version of this library */
+  rb_define_const(cSocket, "VERSION", rb_str_new2("0.2.2"));
 
   /* send flags */