1 files changed, 156 insertions, 29 deletions

diff --git a/erts/emulator/nifs/common/socket_nif.c b/erts/emulator/nifs/common/socket_nif.c
index 25bc712949..adecbb3b6e 100644
--- a/erts/emulator/nifs/common/socket_nif.c
+++ b/erts/emulator/nifs/common/socket_nif.c
@@ -429,6 +429,7 @@ static void (*esock_sctp_freepaddrs)(struct sockaddr *addrs) = NULL;
 #define SOCKET_STATE_CONNECTING      (SOCKET_STATE_OPEN      | SOCKET_FLAG_CON)
 #define SOCKET_STATE_ACCEPTING       (SOCKET_STATE_LISTENING | SOCKET_FLAG_ACC)
 #define SOCKET_STATE_CLOSING         (SOCKET_FLAG_CLOSE)
+#define SOCKET_STATE_DTOR            (0xFFFF)
 
 #define IS_CLOSED(d)                            \
     ((d)->state == SOCKET_STATE_CLOSED)
@@ -485,6 +486,9 @@ static void (*esock_sctp_freepaddrs)(struct sockaddr *addrs) = NULL;
 #define SOCKET_OPT_VALUE_TYPE_INT    1
 #define SOCKET_OPT_VALUE_TYPE_BOOL   2
 
+#define ESOCK_DESC_PATTERN_CREATED 0x03030303
+#define ESOCK_DESC_PATTERN_DTOR    0xC0C0C0C0
+
 typedef union {
     struct {
         // 0 = not open, 1 = open
@@ -808,6 +812,14 @@ typedef struct {
 
 
 typedef struct {
+    /* 
+     * +++ This is a way to, possibly, detect memory overrides "and stuff" +++
+     *
+     * We have two patterns. One is set when the descriptor is created (allocated)
+     * and one is set when the descriptor is dtor'ed.
+     */
+    Uint32             pattern;
+
     /* +++ The actual socket +++ */
     SOCKET             sock;
     HANDLE             event;
@@ -825,6 +837,10 @@ typedef struct {
     ErlNifPid          ctrlPid;
     ESockMonitor       ctrlMon;
 
+    /* +++ Connector process +++ */
+    ErlNifPid          connPid;
+    ESockMonitor       connMon;
+
     /* +++ Write stuff +++ */
     ErlNifMutex*       writeMtx;
     ESockRequestor     currentWriter;
@@ -2377,6 +2393,8 @@ static int socket_setopt(int             sock,
                          const void*     optVal,
                          const socklen_t optLen);
 
+static BOOLEAN_T is_connector(ErlNifEnv*       env,
+                              ESockDescriptor* descP);
 static BOOLEAN_T verify_is_connected(ESockDescriptor* descP, int* err);
 
 static ESockDescriptor* alloc_descriptor(SOCKET sock, HANDLE event);
@@ -4895,17 +4913,17 @@ ERL_NIF_TERM nconnect(ErlNifEnv*       env,
         return esock_make_error(env, atom_closed);
     
     if (!IS_OPEN(descP)) {
-        SSDBG( descP, ("SOCKET", "nif_connect -> not open\r\n") );
+        SSDBG( descP, ("SOCKET", "nconnect -> not open\r\n") );
         return esock_make_error(env, atom_exbadstate);
     }
 
     if (IS_CONNECTED(descP)) {
-        SSDBG( descP, ("SOCKET", "nif_connect -> already connected\r\n") );
+        SSDBG( descP, ("SOCKET", "nconnect -> already connected\r\n") );
         return esock_make_error(env, atom_eisconn);
     }
 
-    if (IS_CONNECTING(descP)) {
-        SSDBG( descP, ("SOCKET", "nif_connect -> already connecting\r\n") );
+    if (IS_CONNECTING(descP) && !is_connector(env, descP)) {
+        SSDBG( descP, ("SOCKET", "nconnect -> already connecting\r\n") );
         return esock_make_error(env, esock_atom_einval);
     }
     
@@ -4919,31 +4937,93 @@ ERL_NIF_TERM nconnect(ErlNifEnv*       env,
                         descP->addrLen);
     save_errno = sock_errno();
 
-    SSDBG( descP, ("SOCKET", "nif_connect -> connect result: %d, %d\r\n",
+    SSDBG( descP, ("SOCKET", "nconnect -> connect result: %d, %d\r\n",
                    code, save_errno) );
 
-    if (IS_SOCKET_ERROR(code) &&
-        ((save_errno == ERRNO_BLOCK) ||   /* Winsock2            */
-         (save_errno == EINPROGRESS))) {  /* Unix & OSE!!        */
-        ref = MKREF(env);
-        descP->state = SOCKET_STATE_CONNECTING;
-        if ((sres = esock_select_write(env, descP->sock, descP, NULL,
-                                       sockRef, ref)) < 0) {
-            res = esock_make_error(env,
-                                   MKT2(env,
-                                        esock_atom_select_failed,
-                                        MKI(env, sres)));
-        } else {
-            res = esock_make_ok2(env, ref);
+    if (IS_SOCKET_ERROR(code)) {
+        switch (save_errno) {
+        case ERRNO_BLOCK:   /* Winsock2            */
+        case EINPROGRESS:   /* Unix & OSE!!        */
+            SSDBG( descP, ("SOCKET", "nconnect -> would block => select\r\n") );
+
+            ref = MKREF(env);
+
+            if (IS_CONNECTING(descP)) {
+                /* Glitch */
+                res = esock_make_ok2(env, ref);
+            } else {
+
+                /* First time here */
+
+                if (enif_self(env, &descP->connPid) == NULL)
+                    return esock_make_error(env, atom_exself);
+
+                if (MONP("nconnect -> conn",
+                         env, descP,
+                         &descP->connPid,
+                         &descP->connMon) != 0)
+                    return esock_make_error(env, atom_exmon);
+
+                descP->state = SOCKET_STATE_CONNECTING;
+
+                if ((sres = esock_select_write(env, descP->sock, descP, NULL,
+                                               sockRef, ref)) < 0) {
+                    res = esock_make_error(env,
+                                           MKT2(env,
+                                                esock_atom_select_failed,
+                                                MKI(env, sres)));
+                } else {
+                    res = esock_make_ok2(env, ref);
+                }
+            }
+            break;
+
+        case EISCONN:
+            SSDBG( descP, ("SOCKET", "nconnect -> *already* connected\r\n") );
+            {
+                /* This is ***strange*** so make sure */
+                int err = 0;
+                if (!verify_is_connected(descP, &err)) {
+                    descP->state = SOCKET_STATE_OPEN;  /* restore state */
+                    res = esock_make_error_errno(env, err);
+                } else {
+                    descP->state = SOCKET_STATE_CONNECTED;
+                    /* And just to be on the safe side, reset these */
+                    enif_set_pid_undefined(&descP->connPid);
+                    DEMONP("nconnect -> connected",
+                           env, descP, &descP->connMon);
+                    descP->isReadable = TRUE;
+                    descP->isWritable = TRUE;
+                    res = esock_atom_ok;
+                }
+            }
+            break;
+
+        default:
+            SSDBG( descP, ("SOCKET", "nconnect -> other error(1): %d\r\n",
+                           save_errno) );
+            res = esock_make_error_errno(env, save_errno);
+            break;
         }
+
     } else if (code == 0) {                 /* ok we are connected */
 
+        SSDBG( descP, ("SOCKET", "nconnect -> connected\r\n") );
+
         descP->state      = SOCKET_STATE_CONNECTED;
+        enif_set_pid_undefined(&descP->connPid);
+        DEMONP("nconnect -> connected", env, descP, &descP->connMon);
         descP->isReadable = TRUE;
         descP->isWritable = TRUE;
 
         res = esock_atom_ok;
+
     } else {
+        /* Do we really need this case? */
+
+        SSDBG( descP, ("SOCKET", "nconnect -> other error(2): %d\r\n",
+                       save_errno) );
+
         res = esock_make_error_errno(env, save_errno);
     }
 
@@ -4998,7 +5078,7 @@ ERL_NIF_TERM nfinalize_connection(ErlNifEnv*       env,
 {
     int error;
 
-    if (descP->state != SOCKET_STATE_CONNECTING)
+    if (!IS_CONNECTING(descP))
         return esock_make_error(env, atom_enotconn);
 
     if (!verify_is_connected(descP, &error)) {
@@ -5007,6 +5087,8 @@ ERL_NIF_TERM nfinalize_connection(ErlNifEnv*       env,
     }
 
     descP->state      = SOCKET_STATE_CONNECTED;
+    enif_set_pid_undefined(&descP->connPid);
+    DEMONP("nfinalize_connection -> connected", env, descP, &descP->connMon);
     descP->isReadable = TRUE;
     descP->isWritable = TRUE;
 
@@ -5069,6 +5151,29 @@ BOOLEAN_T verify_is_connected(ESockDescriptor* descP, int* err)
 
 
 
+/* *** is_connector ***
+ * Check if the current process is the connector process.
+ */
+#if !defined(__WIN32__)
+static
+BOOLEAN_T is_connector(ErlNifEnv*       env,
+                       ESockDescriptor* descP)
+{
+    ErlNifPid caller;
+
+    if (enif_self(env, &caller) == NULL)
+        return FALSE;
+
+    if (COMPARE_PIDS(&descP->connPid, &caller) == 0)
+        return TRUE;
+    else
+        return FALSE;
+    
+}
+#endif
+
+
+
 /* ----------------------------------------------------------------------
  * nif_listen
  *
@@ -16872,8 +16977,10 @@ ESockDescriptor* alloc_descriptor(SOCKET sock, HANDLE event)
     if ((descP = enif_alloc_resource(sockets, sizeof(ESockDescriptor))) != NULL) {
         char buf[64]; /* Buffer used for building the mutex name */
 
-        // This needs to be released when the socket is closed!
-        // descP->env            = enif_alloc_env();
+        descP->pattern        = ESOCK_DESC_PATTERN_CREATED;
+
+        enif_set_pid_undefined(&descP->connPid);
+        MON_INIT(&descP->connMon);
 
         sprintf(buf, "esock[w,%d]", sock);
         descP->writeMtx       = MCREATE(buf);
@@ -18214,21 +18321,30 @@ void socket_dtor(ErlNifEnv* env, void* obj)
 #if !defined(__WIN32__)    
   ESockDescriptor* descP = (ESockDescriptor*) obj;
 
-  MDESTROY(descP->writeMtx);
-  MDESTROY(descP->readMtx);
-  MDESTROY(descP->accMtx);
-  MDESTROY(descP->closeMtx);
-  MDESTROY(descP->cfgMtx);
+  MDESTROY(descP->writeMtx); descP->writeMtx = NULL;
+  MDESTROY(descP->readMtx);  descP->readMtx  = NULL;
+  MDESTROY(descP->accMtx);   descP->accMtx   = NULL;
+  MDESTROY(descP->closeMtx); descP->closeMtx = NULL;
+  MDESTROY(descP->cfgMtx);   descP->cfgMtx   = NULL;
 
-  if (descP->currentReader.env)
+  if (descP->currentReader.env) {
       esock_free_env("dtor reader", descP->currentReader.env);
-  if (descP->currentWriter.env)
+      descP->currentReader.env = NULL;
+  }
+  if (descP->currentWriter.env) {
       esock_free_env("dtor writer", descP->currentWriter.env);
-  if (descP->currentAcceptor.env)
+      descP->currentWriter.env = NULL;
+  }
+  if (descP->currentAcceptor.env) {
       esock_free_env("dtor acceptor", descP->currentAcceptor.env);
+      descP->currentAcceptor.env = NULL;
+  }
   free_request_queue(&descP->readersQ);
   free_request_queue(&descP->writersQ);
   free_request_queue(&descP->acceptorsQ);
+
+  descP->state   = SOCKET_STATE_DTOR;
+  descP->pattern = ESOCK_DESC_PATTERN_DTOR;  
 #endif
 }
 
@@ -18652,6 +18768,17 @@ void socket_down(ErlNifEnv*           env,
                                   MON2T(env, mon));
             }
 
+        } else if (COMPARE_PIDS(&descP->connPid, pid) == 0) {
+
+            /* The connPid is only set during the connection.
+             * The same goes for the monitor (connMon).
+             */
+
+            descP->state = SOCKET_STATE_OPEN;  /* restore state */
+            enif_set_pid_undefined(&descP->connPid);
+            DEMONP("socket_down -> connector",
+                   env, descP, &descP->connMon);
+
         } else {
 
             /* check all operation queue(s): acceptor, writer and reader.