--- a/src/error.h	Tue Mar 10 02:34:11 2009 +0200
+++ b/src/error.h	Tue Mar 10 02:51:44 2009 +0200
@@ -40,7 +40,7 @@
     
     /* Network resolver errors */
     _ERROR_CODE( ERR_GETADDRINFO,                   0x000200,   GAI     ),
-    _ERROR_CODE( ERR_GETADDRINFO_EMPTY,             0x000201,   GAI     ),
+    _ERROR_CODE( ERR_GETADDRINFO_EMPTY,             0x000201,   NONE    ),
 
     /* Low-level network errors */
     _ERROR_CODE( ERR_SOCKET,                        0x000301,   ERRNO   ),
@@ -52,6 +52,7 @@
     _ERROR_CODE( ERR_WRITE,                         0x000403,   ERRNO   ),
     _ERROR_CODE( ERR_WRITE_EOF,                     0x000404,   NONE    ),
     _ERROR_CODE( ERR_FCNTL,                         0x000405,   ERRNO   ),
+    _ERROR_CODE( ERR_CLOSE,                         0x000406,   ERRNO   ),
 
     /* GnuTLS errors */
     _ERROR_CODE( ERR_GNUTLS_CERT_ALLOC_CRED,        0x010101,   GNUTLS  ),

--- a/src/irc_conn.c	Tue Mar 10 02:34:11 2009 +0200
+++ b/src/irc_conn.c	Tue Mar 10 02:51:44 2009 +0200
@@ -225,7 +225,7 @@
 err_t irc_conn_PONG (struct irc_conn *conn, const char *target)
 {
     // PONG <server> [ <server2> ]
-    // XXX: params are actually the wrong way around now, but nobody cares
+    // params are actually the wrong way around now, but nobody cares
     struct irc_line line = {
         NULL, "PONG", { target, NULL }
     };

--- a/src/irc_conn.h	Tue Mar 10 02:34:11 2009 +0200
+++ b/src/irc_conn.h	Tue Mar 10 02:51:44 2009 +0200
@@ -19,9 +19,7 @@
 #include <stdbool.h>
 
 /**
- * The configuration info for an IRC connection.
- *
- * XXX: this should probably be reworked, maybe as a separate irc_conn_register function?
+ * The info required to register with irc_conn_register
  */
 struct irc_conn_register_info {
     /* Nickname to use on that server */

--- a/src/irc_log.c	Tue Mar 10 02:34:11 2009 +0200
+++ b/src/irc_log.c	Tue Mar 10 02:51:44 2009 +0200
@@ -48,7 +48,7 @@
     }
 
     // register for events
-    // XXX: need irc_chan API
+    // XXX: need irc_chan API for this
     if ((err = irc_conn_register_handler_chain(info->channel->net->conn, _cmd_handlers, ctx)))
         return err;
 

--- a/src/sock_gnutls.c	Tue Mar 10 02:34:11 2009 +0200
+++ b/src/sock_gnutls.c	Tue Mar 10 02:51:44 2009 +0200
@@ -4,7 +4,6 @@
 #include <stdlib.h>
 #include <err.h>
 
-// XXX: errors
 static err_t sock_gnutls_read (struct sock_stream *base_sock, void *buf, size_t *len)
 {
     struct sock_gnutls *sock = SOCK_FROM_BASE(base_sock, struct sock_gnutls);
@@ -128,16 +127,9 @@
 static void sock_gnutls_release (struct sock_stream *base_sock)
 {
     struct sock_gnutls *sock = SOCK_FROM_BASE(base_sock, struct sock_gnutls);
-
-    // close the session rudely
-    // XXX: does this actually do everything we need it to? Don't want to call gnutls_bye here, since we're void...
-    gnutls_deinit(sock->session);
     
-    // terminate the TCP transport
-    sock_tcp_close(SOCK_GNUTLS_TCP(sock));
-
-    // free
-    free(sock);
+    // DIEEEE
+    sock_gnutls_destroy(sock);
 }
 
 /*
@@ -195,7 +187,6 @@
     return SUCCESS;
 }
 
-
 err_t sock_ssl_connect (struct sock_stream **sock_ptr, const char *host, const char *service, struct error_info *err)
 {
     struct sock_gnutls *sock = NULL;
@@ -237,8 +228,23 @@
     return SUCCESS;
 
 error:
-    // XXX: cleanup
+    // cleanup
+    sock_gnutls_destroy(sock);
 
     return ERROR_CODE(err);    
 }
 
+void sock_gnutls_destroy (struct sock_gnutls *sock)
+{
+    // terminate the TCP transport
+    sock_tcp_close(SOCK_GNUTLS_TCP(sock));
+
+    // close the session rudely
+    // XXX: does this actually do everything we need it to? Don't want to call gnutls_bye here, since we're void...
+    gnutls_deinit(sock->session);
+    
+    // free
+    free(sock);
+}
+
+

--- a/src/sock_gnutls.h	Tue Mar 10 02:34:11 2009 +0200
+++ b/src/sock_gnutls.h	Tue Mar 10 02:51:44 2009 +0200
@@ -45,4 +45,9 @@
  */
 err_t sock_gnutls_global_init (struct error_info *err);
 
+/**
+ * Release the connection destructively, i.e. do not close it cleanly, just abort.
+ */
+void sock_gnutls_destroy (struct sock_gnutls *sock);
+
 #endif /* SOCK_GNUTLS_H */

--- a/src/sock_tcp.c	Tue Mar 10 02:34:11 2009 +0200
+++ b/src/sock_tcp.c	Tue Mar 10 02:51:44 2009 +0200
@@ -149,7 +149,7 @@
 
 err_t sock_tcp_init_fd (struct sock_tcp *sock, int fd)
 {
-    // valid fd -XXX: err instead?
+    // valid fd
     assert(fd >= 0);
 
     // initialize
@@ -194,8 +194,11 @@
 err_t sock_tcp_init_connect (struct sock_tcp *sock, const char *hostname, const char *service)
 {
     struct addrinfo hints, *res, *r;
-    int err;
-    RESET_ERROR(SOCK_TCP_ERR(sock));
+    int ret;
+    struct error_info *err = SOCK_TCP_ERR(sock);
+    
+    // zero error code
+    RESET_ERROR(err);
     
     // hints
     memset(&hints, 0, sizeof(hints));
@@ -203,15 +206,15 @@
     hints.ai_socktype = SOCK_STREAM;
 
     // resolve
-    if ((err = getaddrinfo(hostname, service, &hints, &res)))
-        RETURN_SET_ERROR_EXTRA(SOCK_TCP_ERR(sock), ERR_GETADDRINFO, err);
+    if ((ret = getaddrinfo(hostname, service, &hints, &res)))
+        RETURN_SET_ERROR_EXTRA(err, ERR_GETADDRINFO, ret);
 
     // try each result in turn
     for (r = res; r; r = r->ai_next) {
         // create the socket
         if ((sock->fd = socket(r->ai_family, r->ai_socktype, r->ai_protocol)) < 0) {
             // remember error
-            SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_SOCKET);
+            SET_ERROR_ERRNO(err, ERR_SOCKET);
 
             // skip to next one
             continue;
@@ -220,7 +223,7 @@
         // connect to remote address
         if (connect(sock->fd, r->ai_addr, r->ai_addrlen)) {
             // remember error
-            SET_ERROR_ERRNO(SOCK_TCP_ERR(sock), ERR_CONNECT);
+            SET_ERROR_ERRNO(err, ERR_CONNECT);
             
             // close/invalidate socket
             close(sock->fd);
@@ -237,13 +240,13 @@
     // ensure we got some valid socket, else return last error code
     if (sock->fd < 0) {
         // did we hit some error?
-        if (IS_ERROR(SOCK_TCP_ERR(sock)))
+        if (IS_ERROR(err))
             // return last error
-            return ERROR_CODE(SOCK_TCP_ERR(sock));
+            return ERROR_CODE(err);
         
         else
             // no results
-            return SET_ERROR(SOCK_TCP_ERR(sock), ERR_GETADDRINFO_EMPTY);
+            return SET_ERROR(err, ERR_GETADDRINFO_EMPTY);
     }
     
     // ok, done
@@ -261,8 +264,13 @@
     return SUCCESS;
 }
 
-void sock_tcp_close (struct sock_tcp *sock)
+err_t sock_tcp_close (struct sock_tcp *sock)
 {
+    struct error_info *err = SOCK_TCP_ERR(sock);
+    
+    // no errors yet
+    RESET_ERROR(err);
+
     // must be connected
     assert(sock->fd >= 0);
 
@@ -274,11 +282,13 @@
         event_del(sock->ev_write);
 
     // close the socket itself
-    // XXX: errors?
-    close(sock->fd);
+    if (close(sock->fd))
+        SET_ERROR_ERRNO(err, ERR_CLOSE);
 
     // invalidate
     sock->fd = -1;
+
+    return ERROR_CODE(err);
 }
 
 void sock_tcp_free (struct sock_tcp *sock)

--- a/src/sock_tcp.h	Tue Mar 10 02:34:11 2009 +0200
+++ b/src/sock_tcp.h	Tue Mar 10 02:51:44 2009 +0200
@@ -65,7 +65,7 @@
 /**
  * Close a connected sock_tcp
  */
-void sock_tcp_close (struct sock_tcp *sock);
+err_t sock_tcp_close (struct sock_tcp *sock);
 
 /**
  * Free a non-connected sock_tcp