sctp-socket 0.1.3 → 0.2.0

data/ext/sctp/socket.c

@@ -39,14 +39,57 @@ VALUE v_sctp_initmsg_struct;
 #endif
 #endif
 
-// TODO: Yes, I know I need to update the signature.
+// Memory safety and error handling macros
+#define CHECK_FILENO_VALID(fileno) do { \
+  if ((fileno) < 0) { \
+    rb_raise(rb_eSystemCallError, "invalid file descriptor"); \
+  } \
+} while(0)
+
+#define SAFE_FREE(ptr) do { \
+  if ((ptr) != NULL) { \
+    free(ptr); \
+      (ptr) = NULL; \
+  } \
+} while(0)
+
+#define CHECK_SOCKET_CLOSED(self) do { \
+  VALUE v_fileno = rb_iv_get((self), "@fileno"); \
+  if (NIL_P(v_fileno) || NUM2INT(v_fileno) < 0) { \
+    rb_raise(rb_eIOError, "socket is closed"); \
+  } \
+} while(0)
+
+#define MAX_IP_ADDRESSES 8
+#define DEFAULT_BUFFER_SIZE 1024
+#define IP_BUFFER_SIZE INET6_ADDRSTRLEN
+
+/*
+ * Convert a sockaddr_in structure to a Ruby struct.
+ * Handles both IPv4 and IPv6 addresses properly.
+ *
+ * @param addr Pointer to sockaddr_in structure
+ * @return Ruby struct representing the socket address
+ */
 VALUE convert_sockaddr_in_to_struct(struct sockaddr_in* addr){
-  char ipbuf[INET6_ADDRSTRLEN];
+  char ipbuf[IP_BUFFER_SIZE];
+  const char* result;
+
+  if(addr == NULL)
+    rb_raise(rb_eArgError, "null address pointer");
+
+  if((addr->sin_family != AF_INET) && (addr->sin_family != AF_INET6))
+    rb_raise(rb_eArgError, "unsupported address family");
+
+  bzero(ipbuf, sizeof(ipbuf));
 
   if(addr->sin_family == AF_INET6)
-    inet_ntop(addr->sin_family, &(((struct sockaddr_in6 *)addr)->sin6_addr), ipbuf, sizeof(ipbuf));
+    result = inet_ntop(addr->sin_family, &(((struct sockaddr_in6 *)addr)->sin6_addr), ipbuf, sizeof(ipbuf));
   else
-    inet_ntop(addr->sin_family, &(((struct sockaddr_in *)addr)->sin_addr), ipbuf, sizeof(ipbuf));
+    result = inet_ntop(addr->sin_family, &(((struct sockaddr_in *)addr)->sin_addr), ipbuf, sizeof(ipbuf));
+
+  if(result == NULL)
+    rb_raise(rb_eSystemCallError, "inet_ntop: %s", strerror(errno));
 
   return rb_struct_new(v_sockaddr_in_struct,
     INT2NUM(addr->sin_family),
@@ -55,27 +98,49 @@ VALUE convert_sockaddr_in_to_struct(struct sockaddr_in* addr){
   );
 }
 
-// Helper function to get a hash value via string or symbol.
+/*
+* Helper function to get a hash value via string or symbol key.
+* This provides Ruby's flexible hash access pattern.
+*
+* @param v_hash Ruby hash object
+* @param key String key to look up
+* @return Ruby value or Qnil if not found
+*/
 VALUE rb_hash_aref2(VALUE v_hash, const char* key){
   VALUE v_key, v_val;
 
+  if(key == NULL)
+    return Qnil;
+
+  // Try a string key first
   v_key = rb_str_new2(key);
   v_val = rb_hash_aref(v_hash, v_key);
 
+  // If not found, try a symbol key
   if(NIL_P(v_val))
     v_val = rb_hash_aref(v_hash, ID2SYM(rb_intern(key)));
 
   return v_val;
 }
 
+/*
+* Parse and convert SCTP notification messages into Ruby structures.
+* This function handles various types of SCTP notifications.
+*
+* @param buffer Raw notification buffer from SCTP
+* @return Ruby struct representing the notification
+*/
 VALUE get_notification_info(char* buffer){
   uint32_t i;
-  char str[16];
+  char str[IP_BUFFER_SIZE];
   union sctp_notification* snp;
   VALUE v_notification = Qnil;
   VALUE v_str = Qnil;
   VALUE* v_temp;
 
+  if(buffer == NULL)
+    rb_raise(rb_eArgError, "notification buffer is null");
+
   snp = (union sctp_notification*)buffer;
 
   switch(snp->sn_header.sn_type){
@@ -310,11 +375,24 @@ static VALUE rsctp_init(int argc, VALUE* argv, VALUE self){
 
   rb_scan_args(argc, argv, "02", &v_domain, &v_type);
 
-  if(NIL_P(v_domain))
+  // Set defaults with validation
+  if(NIL_P(v_domain)){
     v_domain = INT2NUM(AF_INET);
-  
-  if(NIL_P(v_type))
+  }
+  else{
+    int domain = NUM2INT(v_domain);
+    if((domain != AF_INET) && (domain != AF_INET6))
+      rb_raise(rb_eArgError, "unsupported domain family: %d", domain);
+  }
+
+  if(NIL_P(v_type)){
     v_type = INT2NUM(SOCK_SEQPACKET);
+  }
+  else{
+    int type = NUM2INT(v_type);
+    if (type != SOCK_SEQPACKET && type != SOCK_STREAM)
+      rb_raise(rb_eArgError, "unsupported socket type: %d", type);
+  }
 
   fileno = socket(NUM2INT(v_domain), NUM2INT(v_type), IPPROTO_SCTP);
 
@@ -373,7 +451,7 @@ 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[8];
+  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;
 
@@ -404,7 +482,7 @@ static VALUE rsctp_bindx(int argc, VALUE* argv, VALUE self){
   else
     num_ip = (int)RARRAY_LEN(v_addresses);
 
-  if(num_ip > 8)
+  if(num_ip > MAX_IP_ADDRESSES)
     rb_raise(rb_eArgError, "too many IP addresses to bind, maximum is eight");
 
   domain = NUM2INT(rb_iv_get(self, "@domain"));
@@ -472,7 +550,7 @@ 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[8];
+  struct sockaddr_in addrs[MAX_IP_ADDRESSES];
   int i, num_ip, fileno;
   sctp_assoc_t assoc;
   VALUE v_address, v_domain, v_options, v_addresses, v_port;
@@ -540,7 +618,7 @@ static VALUE rsctp_connectx(int argc, VALUE* argv, VALUE self){
  *   socket.close(linger: 5)
  */
 static VALUE rsctp_close(int argc, VALUE* argv, VALUE self){
-  VALUE v_options, v_linger;
+  VALUE v_options, v_linger, v_fileno;
   int fileno;
 
   rb_scan_args(argc, argv, "01", &v_options);
@@ -551,27 +629,56 @@ static VALUE rsctp_close(int argc, VALUE* argv, VALUE self){
   Check_Type(v_options, T_HASH);
 
   v_linger = rb_hash_aref2(v_options, "linger");
+  v_fileno = rb_iv_get(self, "@fileno");
 
-  fileno = NUM2INT(rb_iv_get(self, "@fileno"));
+  if(NIL_P(v_fileno)) // Already closed
+    return self;
+
+  fileno = NUM2INT(v_fileno);
 
   if(!NIL_P(v_linger)){
     struct linger lin;
+    int linger_time = NUM2INT(v_linger);
+
+    if(linger_time < 0)
+      rb_raise(rb_eArgError, "linger time must be non-negative");
+
     lin.l_onoff = 1;
-    lin.l_linger = NUM2INT(v_linger);
+    lin.l_linger = linger_time;
 
     if(setsockopt(fileno, SOL_SOCKET, SO_LINGER, &lin, sizeof(struct linger)) < 0)
       rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
   }
 
-  if(close(fileno))
+  if(close(fileno) < 0)
     rb_raise(rb_eSystemCallError, "close: %s", strerror(errno));
 
+  // Mark socket as closed
+  rb_iv_set(self, "@fileno", Qnil);
+
   return self;
 }
 
 /*
  * call-seq:
- *    SCTP::Socket#getpeernames 
+ *    SCTP::Socket#closed?
+ *
+ * Returns true if the socket is closed, false otherwise.
+ *
+ * Example:
+ *   socket = SCTP::Socket.new
+ *   socket.closed? # => false
+ *   socket.close
+ *   socket.closed? # => true
+ */
+static VALUE rsctp_closed_p(VALUE self){
+  VALUE v_fileno = rb_iv_get(self, "@fileno");
+  return NIL_P(v_fileno) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *    SCTP::Socket#getpeernames
  *
  * Return an array of all addresses of a peer of the current socket
  * and association number.
@@ -584,7 +691,7 @@ static VALUE rsctp_close(int argc, VALUE* argv, VALUE self){
  *   socket = SCTP::Socket.new
  *   # ...
  *   p socket.getpeernames
- * 
+ *
  *   info = socket.recvmsg
  *   association_fileno = socket.peeloff(info.association_id)
  *
@@ -592,20 +699,22 @@ static VALUE rsctp_close(int argc, VALUE* argv, VALUE self){
  */
 static VALUE rsctp_getpeernames(int argc, VALUE* argv, VALUE self){
   sctp_assoc_t assoc_id;
-  struct sockaddr* addrs;
+  struct sockaddr* addrs = NULL;
   int i, fileno, num_addrs;
-  char str[16];
+  char str[IP_BUFFER_SIZE];
   VALUE v_fileno, v_association_id;
   VALUE v_array = rb_ary_new();
 
-  bzero(&addrs, sizeof(addrs));
-
   rb_scan_args(argc, argv, "02", &v_fileno, &v_association_id);
 
-  if(NIL_P(v_fileno))
+  if(NIL_P(v_fileno)){
+    CHECK_SOCKET_CLOSED(self);
     fileno = NUM2INT(rb_iv_get(self, "@fileno"));
-  else
+  }
+  else{
     fileno = NUM2INT(v_fileno);
+    CHECK_FILENO_VALID(fileno);
+  }
 
   if(NIL_P(v_association_id))
     assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
@@ -615,14 +724,16 @@ static VALUE rsctp_getpeernames(int argc, VALUE* argv, VALUE self){
   num_addrs = sctp_getpaddrs(fileno, assoc_id, &addrs);
 
   if(num_addrs < 0){
-    sctp_freepaddrs(addrs);
+    if(addrs != NULL)
+      sctp_freepaddrs(addrs);
+
     rb_raise(rb_eSystemCallError, "sctp_getpaddrs: %s", strerror(errno));
   }
 
   for(i = 0; i < num_addrs; i++){
+    bzero(&str, sizeof(str));
     inet_ntop(AF_INET, &(((struct sockaddr_in *)&addrs[i])->sin_addr), str, sizeof(str));
     rb_ary_push(v_array, rb_str_new2(str));
-    bzero(&str, sizeof(str));
   }
 
   sctp_freepaddrs(addrs);
@@ -649,20 +760,22 @@ static VALUE rsctp_getpeernames(int argc, VALUE* argv, VALUE self){
  */
 static VALUE rsctp_getlocalnames(int argc, VALUE* argv, VALUE self){
   sctp_assoc_t assoc_id;
-  struct sockaddr* addrs;
+  struct sockaddr* addrs = NULL;
   int i, fileno, num_addrs;
-  char str[16];
+  char str[IP_BUFFER_SIZE];
   VALUE v_assoc_fileno, v_assoc_id;
   VALUE v_array = rb_ary_new();
 
-  bzero(&addrs, sizeof(addrs));
-
   rb_scan_args(argc, argv, "02", &v_assoc_fileno, &v_assoc_id);
 
-  if(NIL_P(v_assoc_fileno))
+  if(NIL_P(v_assoc_fileno)){
+    CHECK_SOCKET_CLOSED(self);
     fileno = NUM2INT(rb_iv_get(self, "@fileno"));
-  else
+  }
+  else{
     fileno = NUM2INT(v_assoc_fileno);
+    CHECK_FILENO_VALID(fileno);
+  }
 
   if(NIL_P(v_assoc_id))
     assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
@@ -672,14 +785,16 @@ static VALUE rsctp_getlocalnames(int argc, VALUE* argv, VALUE self){
   num_addrs = sctp_getladdrs(fileno, assoc_id, &addrs);
 
   if(num_addrs < 0){
-    sctp_freeladdrs(addrs);
+    if(addrs != NULL)
+      sctp_freeladdrs(addrs);
+
     rb_raise(rb_eSystemCallError, "sctp_getladdrs: %s", strerror(errno));
   }
 
   for(i = 0; i < num_addrs; i++){
+    bzero(&str, sizeof(str));
     inet_ntop(AF_INET, &(((struct sockaddr_in *)&addrs[i])->sin_addr), str, sizeof(str));
     rb_ary_push(v_array, rb_str_new2(str));
-    bzero(&str, sizeof(str));
   }
 
   sctp_freeladdrs(addrs);
@@ -704,11 +819,11 @@ static VALUE rsctp_getlocalnames(int argc, VALUE* argv, VALUE self){
  *    socket = SCTP::Socket.new
  *
  *    # You can specify addresses here or in an earlier connectx call.
- *    socket.sendv
+ *    socket.sendv({
  *      :message   => ['Hello ', 'World.'],
  *      :addresses => ['10.0.5.4', '10.0.6.4'],
  *      :info_type => SCTP::Socket:::SCTP_SENDV_SNDINFO
- *    )
+ *    })
  *
  *  CAVEAT: Currently info_type is not yet supported.
  *
@@ -730,8 +845,11 @@ static VALUE rsctp_sendv(VALUE self, VALUE v_options){
   v_message   = rb_hash_aref2(v_options, "message");
   v_addresses = rb_hash_aref2(v_options, "addresses");
 
-  if(!NIL_P(v_message))
-    Check_Type(v_message, T_ARRAY);
+  // Validate required message parameter
+  if(NIL_P(v_message))
+    rb_raise(rb_eArgError, "message parameter is required");
+
+  Check_Type(v_message, T_ARRAY);
 
   if(!NIL_P(v_addresses)){
     Check_Type(v_addresses, T_ARRAY);
@@ -982,7 +1100,7 @@ static VALUE rsctp_send(VALUE self, VALUE v_options){
  *  :stream    -> The SCTP stream number you wish to send the message on.
  *  :addresses -> An array of addresses to send the message to.
  *  :context   -> The default context used for the sendmsg call if the send fails.
- *  :ppid      -> The payload protocol identifier that is passed to the peer endpoint. 
+ *  :ppid      -> The payload protocol identifier that is passed to the peer endpoint.
  *  :flags     -> A bitwise integer that contain one or more values that control behavior.
  *
  *  Note that the :addresses option is not mandatory in a one-to-one (SOCK_STREAM)
@@ -1008,7 +1126,7 @@ 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[8];
+  struct sockaddr_in addrs[MAX_IP_ADDRESSES];
   int fileno, size, num_ip;
 
   Check_Type(v_options, T_HASH);
@@ -1023,6 +1141,9 @@ static VALUE rsctp_sendmsg(VALUE self, VALUE v_options){
   v_ttl       = rb_hash_aref2(v_options, "ttl");
   v_addresses = rb_hash_aref2(v_options, "addresses");
 
+  if(NIL_P(v_msg))
+    rb_raise(rb_eArgError, "message parameter is required");
+
   if(NIL_P(v_stream))
     stream = 0;
   else
@@ -1055,6 +1176,7 @@ static VALUE rsctp_sendmsg(VALUE self, VALUE v_options){
     int i, port;
     VALUE v_address, v_port;
 
+    Check_Type(v_addresses, T_ARRAY);
     num_ip = (int)RARRAY_LEN(v_addresses);
     v_port = rb_hash_aref2(v_options, "port");
 
@@ -1176,7 +1298,7 @@ static VALUE rsctp_recvmsg(int argc, VALUE* argv, VALUE self){
   if(NIL_P(v_flags))
     flags = 0;
   else
-    flags = NUM2INT(v_flags);  
+    flags = NUM2INT(v_flags);
 
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   length = sizeof(struct sockaddr_in);
@@ -1305,7 +1427,7 @@ static VALUE rsctp_set_initmsg(VALUE self, VALUE v_options){
  *   :peer_error (aka remote error)
  *
  * Example:
- * 
+ *
  *   socket = SCTP::Socket.new
  *
  *   socket.bind(:port => port, :addresses => ['127.0.0.1'])
@@ -1402,7 +1524,7 @@ static VALUE rsctp_listen(int argc, VALUE* argv, VALUE self){
 
   if(listen(fileno, backlog) < 0)
     rb_raise(rb_eSystemCallError, "listen: %s", strerror(errno));
-  
+
   return self;
 }
 
@@ -1427,7 +1549,7 @@ static VALUE rsctp_listen(int argc, VALUE* argv, VALUE self){
 static VALUE rsctp_peeloff(VALUE self, VALUE v_assoc_id){
   int fileno, assoc_fileno;
   sctp_assoc_t assoc_id;
-    
+
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
   assoc_id = NUM2INT(v_assoc_id);
 
@@ -1528,6 +1650,75 @@ static VALUE rsctp_get_association_info(VALUE self){
   );
 }
 
+/*
+ * call-seq:
+ *    SCTP::Socket#set_association_info(options)
+ *
+ * Sets the association specific parameters. The +options+ parameter
+ * is a hash that accepts the following keywords:
+ *
+ *  * association_id
+ *  * max_retransmission_count
+ *  * number_peer_destinations
+ *  * peer_receive_window
+ *  * local_receive_window
+ *  * cookie_life
+ *
+ *  All values that refer to time values are measured in milliseconds.
+ */
+static VALUE rsctp_set_association_info(VALUE self, VALUE v_options){
+  VALUE v_assoc_id, v_max_rxt, v_nbr_peer, v_peer_rw, v_local_rw, v_cookie;
+  int fileno;
+  sctp_assoc_t assoc_id;
+  struct sctp_assocparams assoc;
+
+  bzero(&assoc, sizeof(assoc));
+
+  fileno = NUM2INT(rb_iv_get(self, "@fileno"));
+
+  v_assoc_id = rb_hash_aref2(v_options, "association_id");
+  v_max_rxt  = rb_hash_aref2(v_options, "max_retransmission_count");
+  v_nbr_peer = rb_hash_aref2(v_options, "number_peer_destinations");
+  v_peer_rw  = rb_hash_aref2(v_options, "peer_receive_window");
+  v_local_rw = rb_hash_aref2(v_options, "local_receive_window");
+  v_cookie   = rb_hash_aref2(v_options, "cookie_life");
+
+  if(NIL_P(v_assoc_id))
+    assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
+  else
+    assoc_id = NUM2INT(v_assoc_id);
+
+  assoc.sasoc_assoc_id = assoc_id;
+
+  if(!NIL_P(v_max_rxt))
+    assoc.sasoc_asocmaxrxt = NUM2INT(v_max_rxt);
+
+  if(!NIL_P(v_nbr_peer))
+    assoc.sasoc_number_peer_destinations = NUM2INT(v_nbr_peer);
+
+  if(!NIL_P(v_peer_rw))
+    assoc.sasoc_peer_rwnd = NUM2INT(v_peer_rw);
+
+  if(!NIL_P(v_local_rw))
+    assoc.sasoc_local_rwnd = NUM2INT(v_local_rw);
+
+  if(!NIL_P(v_cookie))
+    assoc.sasoc_cookie_life = NUM2INT(v_cookie);
+
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_ASSOCINFO, &assoc, sizeof(assoc)) < 0)
+    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
+
+  return rb_struct_new(
+    v_sctp_associnfo_struct,
+    INT2NUM(assoc.sasoc_assoc_id),
+    INT2NUM(assoc.sasoc_asocmaxrxt),
+    INT2NUM(assoc.sasoc_number_peer_destinations),
+    INT2NUM(assoc.sasoc_peer_rwnd),
+    INT2NUM(assoc.sasoc_local_rwnd),
+    INT2NUM(assoc.sasoc_cookie_life)
+  );
+}
+
 /*
  * call-seq:
  *    SCTP::Socket#shutdown
@@ -1602,6 +1793,64 @@ static VALUE rsctp_get_retransmission_info(VALUE self){
   );
 }
 
+/*
+ * call-seq:
+ *    SCTP::Socket#set_retransmission_info(options)
+ *
+ * Sets the protocol parameters that are used to initialize and bind the
+ * retransmission timeout (RTO) tunable. The method accepts a hash with
+ * the following possible keys:
+ *
+ *  * association_id
+ *  * initial
+ *  * max
+ *  * min
+ *
+ *  The +initial+, +max+ and +min+ options default to zero (unchanged).
+ */
+static VALUE rsctp_set_retransmission_info(VALUE self, VALUE v_options){
+  VALUE v_assoc_id, v_initial, v_max, v_min;
+  int fileno;
+  sctp_assoc_t assoc_id;
+  struct sctp_rtoinfo rto;
+
+  bzero(&rto, sizeof(rto));
+
+  fileno = NUM2INT(rb_iv_get(self, "@fileno"));
+
+  v_assoc_id = rb_hash_aref2(v_options, "association_id");
+  v_initial = rb_hash_aref2(v_options, "initial");
+  v_max = rb_hash_aref2(v_options, "max");
+  v_min = rb_hash_aref2(v_options, "min");
+
+  if(NIL_P(v_assoc_id))
+    v_assoc_id = rb_iv_get(self, "@association_id");
+
+  assoc_id = NUM2INT(v_assoc_id);
+
+  rto.srto_assoc_id = assoc_id;
+
+  if(!NIL_P(v_initial))
+    rto.srto_initial = NUM2INT(v_initial);
+
+  if(!NIL_P(v_max))
+    rto.srto_max = NUM2INT(v_max);
+
+  if(!NIL_P(v_min))
+    rto.srto_min = NUM2INT(v_min);
+
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_RTOINFO, &rto, sizeof(rto)) < 0)
+    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
+
+  return rb_struct_new(
+    v_sctp_rtoinfo_struct,
+    v_assoc_id,
+    v_initial,
+    v_max,
+    v_min
+  );
+}
+
 /*
  * call-seq:
  *    SCTP::Socket#get_status
@@ -1757,7 +2006,7 @@ static VALUE rsctp_get_subscriptions(VALUE self){
  */
 static VALUE rsctp_get_peer_address_params(VALUE self){
   int fileno;
-  char str[16];
+  char str[IP_BUFFER_SIZE];
   socklen_t size;
   sctp_assoc_t assoc_id;
   struct sctp_paddrparams paddr;
@@ -1864,11 +2113,9 @@ static VALUE rsctp_get_nodelay(VALUE self){
 static VALUE rsctp_set_nodelay(VALUE self, VALUE v_bool){
   int fileno;
   socklen_t size;
-  sctp_assoc_t assoc_id;
   int value;
 
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
-  assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
   size = sizeof(int);
 
   if(NIL_P(v_bool) || v_bool == Qfalse)
@@ -1876,8 +2123,8 @@ static VALUE rsctp_set_nodelay(VALUE self, VALUE v_bool){
   else
     value = 1;
 
-  if(sctp_opt_info(fileno, assoc_id, SCTP_NODELAY, (void*)&value, &size) < 0)
-    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_NODELAY, &value, size) < 0)
+    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
 
   if(value)
     return Qtrue;
@@ -1888,7 +2135,7 @@ static VALUE rsctp_set_nodelay(VALUE self, VALUE v_bool){
 /*
  * call-seq:
  *    SCTP::Socket#disable_fragments=(bool)
- * 
+ *
  * This option is a on/off flag and is passed an integer where a non-
  * zero is on and a zero is off.  If enabled no SCTP message
  * fragmentation will be performed.  Instead if a message being sent
@@ -1966,19 +2213,15 @@ static VALUE rsctp_get_autoclose(VALUE self){
  */
 static VALUE rsctp_set_autoclose(VALUE self, VALUE v_seconds){
   int fileno;
-  socklen_t size;
-  sctp_assoc_t assoc_id;
   int value;
 
   value = NUM2INT(v_seconds);
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
-  assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
-  size = sizeof(int);
 
-  if(sctp_opt_info(fileno, assoc_id, SCTP_AUTOCLOSE, (void*)&value, &size) < 0)
-    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_AUTOCLOSE, &value, sizeof(value)) < 0)
+    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
 
-  return v_seconds;
+  return INT2NUM(value);
 }
 
 /*
@@ -2013,6 +2256,43 @@ static VALUE rsctp_enable_auth_support(int argc, VALUE* argv, VALUE self){
   return self;
 }
 
+/*
+ * call-seq:
+ *    SCTP::Socket#auth_support?(association_id=nil)
+ *
+ * Returns whether or not authentication support is enabled for the association.
+ * Returns true if auth support is enabled, false otherwise.
+ */
+static VALUE rsctp_get_auth_support(int argc, VALUE* argv, VALUE self){
+  int fileno;
+  socklen_t size;
+  sctp_assoc_t assoc_id;
+  struct sctp_assoc_value assoc_value;
+  VALUE v_assoc_id;
+
+  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);
+
+  if(NIL_P(v_assoc_id))
+    assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
+  else
+    assoc_id = NUM2INT(v_assoc_id);
+
+  assoc_value.assoc_id = assoc_id;
+
+  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(assoc_value.assoc_value)
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
 /*
  * call-seq:
  *    SCTP::Socket#set_shared_key(key, keynum, association_id=nil)
@@ -2076,7 +2356,7 @@ static VALUE rsctp_set_shared_key(int argc, VALUE* argv, VALUE self){
 
   auth_key->sca_assoc_id = assoc_id;
   auth_key->sca_keynumber = keynum;
-  auth_key->sca_keylength = strlen(key); 
+  auth_key->sca_keylength = strlen(key);
   memcpy(auth_key->sca_key, byte_array, sizeof(byte_array));
 
   if(sctp_opt_info(fileno, assoc_id, SCTP_AUTH_KEY, (void*)auth_key, &size) < 0)
@@ -2239,22 +2519,228 @@ static VALUE rsctp_delete_shared_key(int argc, VALUE* argv, VALUE self){
  */
 static VALUE rsctp_map_ipv4(VALUE self, VALUE v_bool){
   int fileno, boolean;
-  sctp_assoc_t assoc_id;
-  socklen_t size;
 
   boolean = 0;
   fileno = NUM2INT(rb_iv_get(self, "@fileno"));
-  assoc_id = NUM2INT(rb_iv_get(self, "@association_id"));
 
   if(v_bool == Qtrue)
     boolean = 1;
 
-  if(sctp_opt_info(fileno, assoc_id, SCTP_I_WANT_MAPPED_V4_ADDR, (void*)&boolean, &size) < 0)
-    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_I_WANT_MAPPED_V4_ADDR, (void*)&boolean, sizeof(boolean)) < 0)
+    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
 
   return v_bool;
 }
 
+/*
+ * call-seq:
+ *    SCTP::Socket#map_ipv4?
+ *
+ * Returns whether or not IPv4 addresses will be mapped to V6 representation
+ * for PF_INET6 sockets. Returns true if mapping is enabled, false otherwise.
+ */
+static VALUE rsctp_get_map_ipv4(VALUE self){
+  int fileno;
+  socklen_t size;
+  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);
+
+  if(sctp_opt_info(fileno, assoc_id, SCTP_I_WANT_MAPPED_V4_ADDR, (void*)&value, &size) < 0)
+    rb_raise(rb_eSystemCallError, "sctp_opt_info: %s", strerror(errno));
+
+  if(value)
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+/*
+ * call-seq:
+ *    SCTP::Socket#set_default_send_params(options)
+ *
+ * Sets the default parameters that will be used by the sendmsg() call
+ * when it is invoked with a null parameter.
+ *
+ * The +options+ hash may contain the following keys:
+ *
+ * * stream: A number indicating the stream number within the association
+ * * ssn: Not used by applications. Ignored for one-to-many style sockets.
+ * * flags: Indicates various options for sending. See SCTP_* constants.
+ * * ppid: The payload protocol identifier
+ * * context: User-specified context information
+ * * ttl: The time to live (in milliseconds)
+ * * tsn: Not used by applications
+ * * cumtsn: Not used by applications
+ * * association_id: The association identification (ignored for one-to-one sockets)
+ *
+ * Example:
+ *
+ *   socket.set_default_send_params(:stream => 1, :flags => SCTP::Socket::SCTP_UNORDERED)
+ */
+static VALUE rsctp_set_default_send_params(VALUE self, VALUE v_options){
+  VALUE v_stream, v_ssn, v_flags, v_ppid, v_context, v_ttl, v_tsn, v_cumtsn, v_assoc_id;
+  int fileno;
+  sctp_assoc_t assoc_id;
+  struct sctp_sndrcvinfo sndrcv;
+
+  if(!RB_TYPE_P(v_options, T_HASH))
+    rb_raise(rb_eTypeError, "options must be a hash");
+
+  bzero(&sndrcv, sizeof(sndrcv));
+
+  fileno = NUM2INT(rb_iv_get(self, "@fileno"));
+
+  v_stream = rb_hash_aref2(v_options, "stream");
+  v_ssn = rb_hash_aref2(v_options, "ssn");
+  v_flags = rb_hash_aref2(v_options, "flags");
+  v_ppid = rb_hash_aref2(v_options, "ppid");
+  v_context = rb_hash_aref2(v_options, "context");
+  v_ttl = rb_hash_aref2(v_options, "ttl");
+  v_tsn = rb_hash_aref2(v_options, "tsn");
+  v_cumtsn = rb_hash_aref2(v_options, "cumtsn");
+  v_assoc_id = rb_hash_aref2(v_options, "association_id");
+
+  if(NIL_P(v_assoc_id))
+    v_assoc_id = rb_iv_get(self, "@association_id");
+
+  assoc_id = NUM2INT(v_assoc_id);
+  sndrcv.sinfo_assoc_id = assoc_id;
+
+  if(!NIL_P(v_stream))
+    sndrcv.sinfo_stream = NUM2INT(v_stream);
+
+  if(!NIL_P(v_ssn))
+    sndrcv.sinfo_ssn = NUM2INT(v_ssn);
+
+  if(!NIL_P(v_flags))
+    sndrcv.sinfo_flags = NUM2INT(v_flags);
+
+  if(!NIL_P(v_ppid))
+    sndrcv.sinfo_ppid = NUM2INT(v_ppid);
+
+  if(!NIL_P(v_context))
+    sndrcv.sinfo_context = NUM2INT(v_context);
+
+  if(!NIL_P(v_ttl))
+    sndrcv.sinfo_timetolive = NUM2INT(v_ttl);
+
+  if(!NIL_P(v_tsn))
+    sndrcv.sinfo_tsn = NUM2INT(v_tsn);
+
+  if(!NIL_P(v_cumtsn))
+    sndrcv.sinfo_cumtsn = NUM2INT(v_cumtsn);
+
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_DEFAULT_SEND_PARAM, &sndrcv, sizeof(sndrcv)) < 0)
+    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
+
+  return rb_struct_new(
+    v_sctp_default_send_params_struct,
+    v_stream,
+    v_ssn,
+    v_flags,
+    v_ppid,
+    v_context,
+    v_ttl,
+    v_tsn,
+    v_cumtsn,
+    v_assoc_id
+  );
+}
+
+/*
+ * call-seq:
+ *    SCTP::Socket#set_peer_address_params(options)
+ *
+ * Sets the peer address parameters. This allows applications to enable or
+ * disable heartbeats for any peer address of an association, set the maximum
+ * number of retransmissions to a destination address, and set the path MTU.
+ *
+ * The +options+ hash may contain the following keys:
+ *
+ * * association_id: The association identification
+ * * address: The address of the remote peer
+ * * hbinterval: The heartbeat interval (in milliseconds)
+ * * pathmaxrxt: The maximum number of retransmissions
+ * * pathmtu: The path MTU
+ * * flags: Flags to control heartbeats, etc.
+ * * ipv6_flowlabel: IPv6 flow label (only for IPv6 addresses)
+ *
+ * Example:
+ *
+ *   socket.set_peer_address_params(:hbinterval => 5000, :pathmaxrxt => 5)
+ */
+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;
+  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));
+
+  fileno = NUM2INT(rb_iv_get(self, "@fileno"));
+
+  v_assoc_id = rb_hash_aref2(v_options, "association_id");
+  v_address = rb_hash_aref2(v_options, "address");
+  v_hbinterval = rb_hash_aref2(v_options, "hbinterval");
+  v_pathmaxrxt = rb_hash_aref2(v_options, "pathmaxrxt");
+  v_pathmtu = rb_hash_aref2(v_options, "pathmtu");
+  v_flags = rb_hash_aref2(v_options, "flags");
+  v_ipv6_flowlabel = rb_hash_aref2(v_options, "ipv6_flowlabel");
+
+  if(NIL_P(v_assoc_id))
+    v_assoc_id = rb_iv_get(self, "@association_id");
+
+  assoc_id = NUM2INT(v_assoc_id);
+  paddr.spp_assoc_id = assoc_id;
+
+  // If address is provided, set up the sockaddr structure
+  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");
+  }
+
+  if(!NIL_P(v_hbinterval))
+    paddr.spp_hbinterval = NUM2INT(v_hbinterval);
+
+  if(!NIL_P(v_pathmaxrxt))
+    paddr.spp_pathmaxrxt = NUM2INT(v_pathmaxrxt);
+
+  if(!NIL_P(v_pathmtu))
+    paddr.spp_pathmtu = NUM2INT(v_pathmtu);
+
+  if(!NIL_P(v_flags))
+    paddr.spp_flags = NUM2INT(v_flags);
+
+  if(!NIL_P(v_ipv6_flowlabel))
+    paddr.spp_ipv6_flowlabel = NUM2INT(v_ipv6_flowlabel);
+
+  if(setsockopt(fileno, IPPROTO_SCTP, SCTP_PEER_ADDR_PARAMS, &paddr, sizeof(paddr)) < 0)
+    rb_raise(rb_eSystemCallError, "setsockopt: %s", strerror(errno));
+
+  return rb_struct_new(
+    v_sctp_peer_addr_params_struct,
+    v_assoc_id,
+    v_address,
+    v_hbinterval,
+    v_pathmaxrxt,
+    v_pathmtu,
+    v_flags,
+    v_ipv6_flowlabel
+  );
+}
+
 void Init_socket(void){
   mSCTP   = rb_define_module("SCTP");
   cSocket = rb_define_class_under(mSCTP, "Socket", rb_cObject);
@@ -2358,23 +2844,26 @@ void Init_socket(void){
   rb_define_method(cSocket, "autoclose=", rsctp_set_autoclose, 1);
   rb_define_method(cSocket, "bindx", rsctp_bindx, -1);
   rb_define_method(cSocket, "close", rsctp_close, -1);
+  rb_define_method(cSocket, "closed?", rsctp_closed_p, 0);
   rb_define_method(cSocket, "connectx", rsctp_connectx, -1);
   rb_define_method(cSocket, "delete_shared_key", rsctp_delete_shared_key, -1);
   rb_define_method(cSocket, "disable_fragments=", rsctp_disable_fragments, 1);
   rb_define_method(cSocket, "enable_auth_support", rsctp_enable_auth_support, -1);
+  rb_define_method(cSocket, "auth_support?", rsctp_get_auth_support, -1);
   rb_define_method(cSocket, "getpeernames", rsctp_getpeernames, -1);
   rb_define_method(cSocket, "getlocalnames", rsctp_getlocalnames, -1);
   rb_define_method(cSocket, "get_active_shared_key", rsctp_get_active_shared_key, -1);
   rb_define_method(cSocket, "get_association_info", rsctp_get_association_info, 0);
   rb_define_method(cSocket, "get_autoclose", rsctp_get_autoclose, 0);
   rb_define_method(cSocket, "get_default_send_params", rsctp_get_default_send_params, 0);
-  rb_define_method(cSocket, "get_initmsg", rsctp_get_init_msg, 0);
+  rb_define_method(cSocket, "get_init_msg", rsctp_get_init_msg, 0);
   rb_define_method(cSocket, "get_peer_address_params", rsctp_get_peer_address_params, 0);
   rb_define_method(cSocket, "get_retransmission_info", rsctp_get_retransmission_info, 0);
   rb_define_method(cSocket, "get_status", rsctp_get_status, 0);
   rb_define_method(cSocket, "get_subscriptions", rsctp_get_subscriptions, 0);
   rb_define_method(cSocket, "listen", rsctp_listen, -1);
   rb_define_method(cSocket, "map_ipv4=", rsctp_map_ipv4, 1);
+  rb_define_method(cSocket, "map_ipv4?", rsctp_get_map_ipv4, 0);
   rb_define_method(cSocket, "nodelay?", rsctp_get_nodelay, 0);
   rb_define_method(cSocket, "nodelay=", rsctp_set_nodelay, 1);
   rb_define_method(cSocket, "peeloff", rsctp_peeloff, 1);
@@ -2391,20 +2880,27 @@ void Init_socket(void){
 
   rb_define_method(cSocket, "sendmsg", rsctp_sendmsg, 1);
   rb_define_method(cSocket, "set_active_shared_key", rsctp_set_active_shared_key, -1);
+  rb_define_method(cSocket, "set_association_info", rsctp_set_association_info, 1);
   rb_define_method(cSocket, "set_initmsg", rsctp_set_initmsg, 1);
-  //rb_define_method(cSocket, "set_retransmission_info", rsctp_set_retransmission_info, -1);
+  rb_define_method(cSocket, "set_retransmission_info", rsctp_set_retransmission_info, 1);
+  rb_define_method(cSocket, "set_default_send_params", rsctp_set_default_send_params, 1);
+  rb_define_method(cSocket, "set_peer_address_params", rsctp_set_peer_address_params, 1);
   rb_define_method(cSocket, "set_shared_key", rsctp_set_shared_key, -1);
   rb_define_method(cSocket, "shutdown", rsctp_shutdown, -1);
   rb_define_method(cSocket, "subscribe", rsctp_subscribe, 1);
 
+  rb_define_alias(cSocket, "get_rto_info", "get_retransmission_info");
+  rb_define_alias(cSocket, "set_rto_info", "set_retransmission_info");
+  rb_define_alias(cSocket, "get_initmsg", "get_init_msg");
+
   rb_define_attr(cSocket, "domain", 1, 1);
   rb_define_attr(cSocket, "type", 1, 1);
   rb_define_attr(cSocket, "fileno", 1, 1);
   rb_define_attr(cSocket, "association_id", 1, 1);
   rb_define_attr(cSocket, "port", 1, 1);
 
-  /* 0.1.3: The version of this library */
-  rb_define_const(cSocket, "VERSION", rb_str_new2("0.1.3"));
+  /* 0.1.4: The version of this library */
+  rb_define_const(cSocket, "VERSION", rb_str_new2("0.2.0"));
 
   /* send flags */
 
@@ -2443,4 +2939,34 @@ void Init_socket(void){
 
   rb_define_const(cSocket, "SCTP_BINDX_ADD_ADDR", INT2NUM(SCTP_BINDX_ADD_ADDR));
   rb_define_const(cSocket, "SCTP_BINDX_REM_ADDR", INT2NUM(SCTP_BINDX_REM_ADDR));
+
+  // PEER ADDRESS PARAMETER FLAGS //
+
+#ifdef SPP_HB_ENABLE
+  rb_define_const(cSocket, "SPP_HB_ENABLE", INT2NUM(SPP_HB_ENABLE));
+#endif
+#ifdef SPP_HB_DISABLE
+  rb_define_const(cSocket, "SPP_HB_DISABLE", INT2NUM(SPP_HB_DISABLE));
+#endif
+#ifdef SPP_HB_DEMAND
+  rb_define_const(cSocket, "SPP_HB_DEMAND", INT2NUM(SPP_HB_DEMAND));
+#endif
+#ifdef SPP_PMTUD_ENABLE
+  rb_define_const(cSocket, "SPP_PMTUD_ENABLE", INT2NUM(SPP_PMTUD_ENABLE));
+#endif
+#ifdef SPP_PMTUD_DISABLE
+  rb_define_const(cSocket, "SPP_PMTUD_DISABLE", INT2NUM(SPP_PMTUD_DISABLE));
+#endif
+
+  // PARTIAL RELIABILITY SCTP POLICY CONSTANTS //
+
+#ifdef SCTP_PR_SCTP_TTL
+  rb_define_const(cSocket, "SCTP_PR_SCTP_TTL", INT2NUM(SCTP_PR_SCTP_TTL));
+#endif
+#ifdef SCTP_PR_SCTP_RTX
+  rb_define_const(cSocket, "SCTP_PR_SCTP_RTX", INT2NUM(SCTP_PR_SCTP_RTX));
+#endif
+#ifdef SCTP_PR_SCTP_BUF
+  rb_define_const(cSocket, "SCTP_PR_SCTP_BUF", INT2NUM(SCTP_PR_SCTP_BUF));
+#endif
 }