File 5902-erts-inet-drv-kernel-Add-support-for-inet-... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 5902-erts-inet-drv-kernel-Add-support-for-inet-drv-debug.patch of Package erlang (Revision fb8f015ac8ccbb72d49ed8284e9f5df5)

Currently displaying revision fb8f015ac8ccbb72d49ed8284e9f5df5 , Show latest

From 6dab4c8153aa86dc7ba9e3c44fd74f8393a30694 Mon Sep 17 00:00:00 2001
From: Micael Karlberg <bmk@erlang.org>
Date: Tue, 3 May 2022 10:36:52 +0200
Subject: [PATCH 2/7] [erts|inet-drv,kernel] Add support for inet-drv debug

Make it possible to use the debug option (for inet
driver debug) in gen_tcp (both when creating sockets
(listen and connect) and after they have been created
(using inet:setopts/2)), gen_udp and gen_sctp).

OTP-18032
---
 erts/emulator/drivers/common/inet_drv.c | 1292 ++++++++++++++++++-----
 lib/kernel/src/inet.erl                 |    9 +-
 2 files changed, 1044 insertions(+), 257 deletions(-)

diff --git a/erts/emulator/drivers/common/inet_drv.c b/erts/emulator/drivers/common/inet_drv.c
index b0e8d5ee30..136debcc7a 100644
--- a/erts/emulator/drivers/common/inet_drv.c
+++ b/erts/emulator/drivers/common/inet_drv.c
@@ -111,6 +111,46 @@
 
 #include "erl_driver.h"
 
+
+#if !defined(TRUE)
+#define TRUE  1
+#endif
+#if !defined(FALSE)
+#define FALSE 0
+#endif
+
+/* Descriptor debug */
+#ifdef INET_DRV_DEBUG
+#define DDBG_DEFAULT TRUE
+#else
+#define DDBG_DEFAULT FALSE
+#endif
+#define DDBG(__D__, __ARG__) if ( (__D__)->debug ) erts_printf __ARG__
+
+#define B2S(__B__)   ((__B__) ? "true" : "false")
+#define SH2S(__H__)  (((__H__) == TCP_SHUT_WR) ? "write" :          \
+                      (((__H__) == TCP_SHUT_RD) ? "read" :          \
+                       (((__H__) == TCP_SHUT_RDWR) ? "read-write" : \
+                        "undefined")))
+#define A2S(__A__)   (((__A__) == INET_PASSIVE) ? "passive" : \
+                      (((__A__) == INET_ACTIVE) ? "active" :  \
+                       (((__A__) == INET_ONCE) ? "once" :     \
+                        (((__A__) == INET_MULTI) ? "multi" :  \
+                         "undefined"))))
+#define M2S(__M__)   (((__M__) == INET_MODE_LIST) ? "list" :      \
+                      (((__M__) == INET_MODE_BINARY) ? "binary" : \
+                       "undefined"))
+#define D2S(__D__)   (((__D__) == INET_DELIVER_PORT) ? "port" :  \
+                      (((__D__) == INET_DELIVER_TERM) ? "term" : \
+                       "undefined"))
+
+#if defined(__WIN32__)
+#define SOCKET_FSTR "%lld"
+#else
+#define SOCKET_FSTR "%d"
+#endif
+
+
 /* The IS_SOCKET_ERROR macro below is used for portability reasons. While
    POSIX specifies that errors from socket-related system calls should be
    indicated with a -1 return value, some users have experienced non-Windows
@@ -847,6 +887,8 @@ static size_t my_strnlen(const char *s, size_t maxlen)
 #define INET_OPT_TTL                46  /* IP_TTL */
 #define INET_OPT_RECVTTL            47  /* IP_RECVTTL ancillary data */
 #define TCP_OPT_NOPUSH              48  /* super-Nagle, aka TCP_CORK */
+#define INET_LOPT_DEBUG             99  /* Enable/disable DEBUG for a socket */
+
 /* SCTP options: a separate range, from 100: */
 #define SCTP_OPT_RTOINFO		100
 #define SCTP_OPT_ASSOCINFO		101
@@ -1174,6 +1216,7 @@ typedef struct {
 				   as full file path */
 #endif
     int recv_cmsgflags;         /* Which ancillary data to expect */
+    int debug;                  /* debug enabled or not */
 } inet_descriptor;
 
 
@@ -4923,6 +4966,18 @@ static ErlDrvSSizeT inet_ctl_fdopen(inet_descriptor* desc, int domain, int type,
     inet_address name;
     SOCKLEN_T sz;
 
+    DDBG(desc,
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+          "inet_ctl_fdopen -> entry with"
+          "\r\n   socket:  %d"
+          "\r\n   bound:   %s"
+          "\r\n   domain:  %d"
+          "\r\n   type:    %d"
+          "\r\n",
+          __LINE__,
+          desc->s, driver_caller(desc->port),
+          s, B2S(bound), domain, type) );
+
     if (bound) {
         /* check that it is a socket and that the socket is bound */
         sz = sizeof(name);
@@ -4956,6 +5011,12 @@ static ErlDrvSSizeT inet_ctl_fdopen(inet_descriptor* desc, int domain, int type,
 			 * not certain that we can open it again */
     desc->stype = type;
     desc->sfamily = domain;
+
+    DDBG(desc,
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+          "inet_ctl_fdopen -> done\r\n",
+          __LINE__, desc->s, driver_caller(desc->port)) );
+
     return ctl_reply(INET_REP_OK, NULL, 0, rbuf, rsize);
 }
 
@@ -6501,7 +6562,6 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
     if (IS_SCTP(desc))
 	return sctp_set_opts(desc, ptr, len);
 #endif
-    /* XXX { int i; for(i=0;i<len;++i) fprintf(stderr,"0x%02X, ", (unsigned) ptr[i]); fprintf(stderr,"\r\n");} */
 
     while(len >= 5) {
         int recv_cmsgflags;
@@ -6516,47 +6576,74 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 	propagate = 0;
         recv_cmsgflags = desc->recv_cmsgflags;
 
-	switch(opt) {
+	DDBG(desc,
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "inet_set_opts -> opt: %d\r\n",
+	      __LINE__, desc->s, driver_caller(desc->port), opt) );
+
+ 	switch(opt) {
 	case INET_LOPT_HEADER:
-	    DEBUGF(("inet_set_opts(%p): s=%d, HEADER=%d\r\n",
-		    desc->port, desc->s,ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(header) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    desc->hsz = ival;
 	    continue;
 
 	case INET_LOPT_MODE:
 	    /* List or Binary: */
-	    DEBUGF(("inet_set_opts(%p): s=%d, MODE=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(mode) -> %s (%d)\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port),
+                  M2S(ival), ival) );
 	    desc->mode = ival;
 	    continue;
 
 	case INET_LOPT_DELIVER:
-	    DEBUGF(("inet_set_opts(%p): s=%d, DELIVER=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(deliver) -> %s (%d)\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port),
+                  D2S(ival), ival) );
 	    desc->deliver = ival;
 	    continue;
 	    
 	case INET_LOPT_BUFFER:
-	    DEBUGF(("inet_set_opts(%p): s=%d, BUFFER=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(buffer) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    if (ival < INET_MIN_BUFFER) ival = INET_MIN_BUFFER;
 	    desc->bufsz = ival;
             desc->flags |= INET_FLG_BUFFER_SET;
 	    continue;
 
 	case INET_LOPT_ACTIVE:
-	    DEBUGF(("inet_set_opts(%p): s=%d, ACTIVE=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(active) -> active (ival): %s (%d)\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port),
+                  A2S(ival), ival) );
 	    desc->active = ival;
             if (desc->active == INET_MULTI) {
-                long ac = desc->active_count;
+                long   ac   = desc->active_count;
                 Sint16 nval = get_int16(ptr);
                 ptr += 2;
                 len -= 2;
+                DDBG(desc,
+                     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                      "inet_set_opts(active) -> nval: %d\r\n",
+                      __LINE__, desc->s, driver_caller(desc->port), nval) );
                 ac += nval;
                 if (ac > INT16_MAX || ac < INT16_MIN)
                     return -1;
                 desc->active_count += nval;
+                DDBG(desc,
+                     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                      "inet_set_opts(active) -> count => %d\r\n",
+                      __LINE__, desc->s, driver_caller(desc->port),
+                      desc->active_count) );
                 if (desc->active_count < 0)
                     desc->active_count = 0;
                 if (desc->active_count == 0) {
@@ -6583,24 +6670,35 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    continue;
 
 	case INET_LOPT_PACKET:
-	    DEBUGF(("inet_set_opts(%p): s=%d, PACKET=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(packet) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    desc->htype = ival;
 	    continue;
 
 	case INET_LOPT_PACKET_SIZE:
-	    DEBUGF(("inet_set_opts(%p): s=%d, PACKET_SIZE=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(packet-size) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    desc->psize = (unsigned int)ival;
 	    continue;
 
 	case INET_LOPT_EXITONCLOSE:
-	    DEBUGF(("inet_set_opts(%p): s=%d, EXITONCLOSE=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(exit-on-close) -> %d (%s)\r\n",
+                  __LINE__,
+                  desc->s, driver_caller(desc->port), ival, B2S(ival)) );
 	    desc->exitf = ival;
 	    continue;
 
 	case INET_LOPT_TCP_HIWTRMRK:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(hiwtrmrk) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    if (desc->stype == SOCK_STREAM) {
 		tcp_descriptor* tdesc = (tcp_descriptor*) desc;
 		if (ival < 0) ival = 0;
@@ -6611,6 +6709,10 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    continue;
 
 	case INET_LOPT_TCP_LOWTRMRK:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(lowtrmrk) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    if (desc->stype == SOCK_STREAM) {
 		tcp_descriptor* tdesc = (tcp_descriptor*) desc;
 		if (ival < 0) ival = 0;
@@ -6622,6 +6724,10 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 
 	case INET_LOPT_MSGQ_HIWTRMRK: {
 	    ErlDrvSizeT high;
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(msgq-hiwtrmrk) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    if (ival < ERL_DRV_BUSY_MSGQ_LIM_MIN
 		|| ERL_DRV_BUSY_MSGQ_LIM_MAX < ival)
 		return -1;
@@ -6632,6 +6738,10 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 
 	case INET_LOPT_MSGQ_LOWTRMRK: {
 	    ErlDrvSizeT low;
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(msgq-lowtrmrk) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    if (ival < ERL_DRV_BUSY_MSGQ_LIM_MIN
 		|| ERL_DRV_BUSY_MSGQ_LIM_MAX < ival)
 		return -1;
@@ -6641,6 +6751,10 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 	}
 
 	case INET_LOPT_TCP_SEND_TIMEOUT:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(send-timeout) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    if (desc->stype == SOCK_STREAM) {
 		tcp_descriptor* tdesc = (tcp_descriptor*) desc;
 		tdesc->send_timeout = ival;
@@ -6648,6 +6762,10 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    continue;
 
 	case INET_LOPT_TCP_SEND_TIMEOUT_CLOSE:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(send-timeout-close) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    if (desc->stype == SOCK_STREAM) {
 		tcp_descriptor* tdesc = (tcp_descriptor*) desc;
 		tdesc->send_timeout_close = ival;
@@ -6656,6 +6774,11 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    
 
 	case INET_LOPT_TCP_DELAY_SEND:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(delay-send) -> %d (%s)\r\n",
+                  __LINE__,
+                  desc->s, driver_caller(desc->port), ival, B2S(ival)) );
 	    if (desc->stype == SOCK_STREAM) {
 		tcp_descriptor* tdesc = (tcp_descriptor*) desc;
 		if (ival)
@@ -6667,6 +6790,10 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 
 #ifdef HAVE_UDP
 	case INET_LOPT_UDP_READ_PACKETS:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(read-packets) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    if (desc->stype == SOCK_DGRAM) {
 		udp_descriptor* udesc = (udp_descriptor*) desc;
 		if (ival <= 0) return -1;
@@ -6677,6 +6804,10 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 
 #ifdef HAVE_SETNS
 	case INET_LOPT_NETNS:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(netns) -> %d, %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival, len) );
 	    /* It is annoying that ival and len are both (signed) int */
 	    if (ival < 0) return -1;
 	    if (len < ival) return -1;
@@ -6690,6 +6821,11 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 #endif
 
 	case INET_LOPT_TCP_SHOW_ECONNRESET:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(show-econnreset) -> %d (%s)\r\n",
+                  __LINE__,
+                  desc->s, driver_caller(desc->port), ival, B2S(ival)) );
 	    if (desc->sprotocol == IPPROTO_TCP) {
 		tcp_descriptor* tdesc = (tcp_descriptor*) desc;
 		if (ival)
@@ -6700,8 +6836,11 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    continue;
 
 	case INET_LOPT_LINE_DELIM:
-	    DEBUGF(("inet_set_opts(%p): s=%d, LINE_DELIM=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(line-delimiter) -> %c (%d)\r\n",
+                  __LINE__,
+                  desc->s, driver_caller(desc->port), (char) ival, ival) );
 	    desc->delimiter = (char)ival;
 	    continue;
 
@@ -6712,32 +6851,51 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
              * which we don't support anymore!
              */
 	case INET_OPT_REUSEADDR: type = SO_REUSEADDR;
-	    DEBUGF(("inet_set_opts(%p): s=%d, SO_REUSEADDR=%d\r\n",
-		    desc->port, desc->s,ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(reuseaddr) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
 	    break;
+
 	case INET_OPT_KEEPALIVE: type = SO_KEEPALIVE;
-	    DEBUGF(("inet_set_opts(%p): s=%d, SO_KEEPALIVE=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(keepalive) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
 	    break;
+
 	case INET_OPT_DONTROUTE: type = SO_DONTROUTE;
-	    DEBUGF(("inet_set_opts(%p): s=%d, SO_DONTROUTE=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(dontroute) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
 	    break;
+
 	case INET_OPT_BROADCAST: type = SO_BROADCAST;
-	    DEBUGF(("inet_set_opts(%p): s=%d, SO_BROADCAST=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(broadcast) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
 	    break;
+
 	case INET_OPT_OOBINLINE: type = SO_OOBINLINE; 
-	    DEBUGF(("inet_set_opts(%p): s=%d, SO_OOBINLINE=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(oobinline) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
 	    break;
-	case INET_OPT_SNDBUF:    type = SO_SNDBUF; 
-	    DEBUGF(("inet_set_opts(%p): s=%d, SO_SNDBUF=%d\r\n",
-		    desc->port, desc->s, ival));
+
+	case INET_OPT_SNDBUF:    type = SO_SNDBUF;             DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(sndbuf) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    break;
+
 	case INET_OPT_RCVBUF:    type = SO_RCVBUF; 
-	    DEBUGF(("inet_set_opts(%p): s=%d, SO_RCVBUF=%d\r\n",
-		    desc->port, desc->s, ival));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(rcvbuf) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
             if (!(desc->flags & INET_FLG_BUFFER_SET)) {
                 /* make sure we have desc->bufsz >= SO_RCVBUF */
                 if (ival > (1 << 16) && desc->stype == SOCK_DGRAM && !IS_SCTP(desc))
@@ -6749,6 +6907,7 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
                     desc->bufsz = ival;
             }
 	    break;
+
 	case INET_OPT_LINGER:    type = SO_LINGER; 
 	    if (len < 4)
 		return -1;
@@ -6758,9 +6917,14 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    len -= 4;
 	    arg_ptr = (char*) &li_val;
 	    arg_sz = sizeof(li_val);
-	    DEBUGF(("inet_set_opts(%p): s=%d, SO_LINGER=%d,%d",
-		    desc->port, desc->s,
-                    li_val.l_onoff,li_val.l_linger));
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(linger) -> %d, %d\r\n",
+                  __LINE__,
+                  desc->s, driver_caller(desc->port),
+                  li_val.l_onoff, li_val.l_linger) );
+
 	    if (desc->sprotocol == IPPROTO_TCP) {
 		tcp_descriptor* tdesc = (tcp_descriptor*) desc;
 		if (li_val.l_onoff && li_val.l_linger == 0)
@@ -6772,49 +6936,72 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 
 	case INET_OPT_PRIORITY: 
 #ifdef SO_PRIORITY
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(prio) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    type = SO_PRIORITY;
 	    propagate = 1; /* We do want to know if this fails */
-	    DEBUGF(("inet_set_opts(%p): s=%d, SO_PRIORITY=%d\r\n",
-		    desc->port, desc->s, ival));
 	    break;
 #else
             /* inet_fill_opts always returns a value for this option,
              * so we need to ignore it if not implemented */
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(prio) -> SKIP\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
 	    continue;
 #endif
+
 	case INET_OPT_TOS:
 #if defined(IP_TOS) && defined(IPPROTO_IP)
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(tos) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    proto = IPPROTO_IP;
 	    type = IP_TOS;
 	    propagate = 1;
-	    DEBUGF(("inet_set_opts(%p): s=%d, IP_TOS=%d\r\n",
-		    desc->port, desc->s, ival));
 	    break;
 #else
             /* inet_fill_opts always returns a value for this option,
              * so we need to ignore it if not implemented. */
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(tos) -> SKIP\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
 	    continue;
 #endif
+
 #if defined(IPV6_TCLASS) && defined(IPPROTO_IPV6)
 	case INET_OPT_TCLASS:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(tclass) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    proto = IPPROTO_IPV6;
 	    type = IPV6_TCLASS;
 	    propagate = 1;
-	    DEBUGF(("inet_set_opts(%p): s=%d, IPV6_TCLASS=%d\r\n",
-		    desc->port, desc->s, ival));
 	    break;
 #endif
+
 #if defined(IP_TTL) && defined(IPPROTO_IP)
 	case INET_OPT_TTL:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(ttl) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    proto = IPPROTO_IP;
 	    type = IP_TTL;
 	    propagate = 1;
-	    DEBUGF(("inet_set_opts(%p): s=%d, IP_TTL=%d\r\n",
-		    desc->port, desc->s, ival));
 	    break;
 #endif
 #if defined(IP_RECVTOS) && defined(IPPROTO_IP)
 	case INET_OPT_RECVTOS:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(recvtos) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    proto = IPPROTO_IP;
 	    type = IP_RECVTOS;
 	    propagate = 1;
@@ -6822,12 +7009,14 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
                 ival ?
                 (desc->recv_cmsgflags | INET_CMSG_RECVTOS) :
                 (desc->recv_cmsgflags & ~INET_CMSG_RECVTOS);
-	    DEBUGF(("inet_set_opts(%p): s=%d, IP_RECVTOS=%d\r\n",
-		    desc->port, desc->s, ival));
 	    break;
 #endif
 #if defined(IPV6_RECVTCLASS) && defined(IPPROTO_IPV6)
 	case INET_OPT_RECVTCLASS:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(recvtclass) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    proto = IPPROTO_IPV6;
 	    type = IPV6_RECVTCLASS;
 	    propagate = 1;
@@ -6835,12 +7024,14 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
                 ival ?
                 (desc->recv_cmsgflags | INET_CMSG_RECVTCLASS) :
                 (desc->recv_cmsgflags & ~INET_CMSG_RECVTCLASS);
-	    DEBUGF(("inet_set_opts(%p): s=%d, IPV6_RECVTCLASS=%d\r\n",
-		    desc->port, desc->s, ival));
 	    break;
 #endif
 #if defined(IP_RECVTTL) && defined(IPPROTO_IP)
 	case INET_OPT_RECVTTL:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(recvttl) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    proto = IPPROTO_IP;
 	    type = IP_RECVTTL;
 	    propagate = 1;
@@ -6848,68 +7039,84 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
                 ival ?
                 (desc->recv_cmsgflags | INET_CMSG_RECVTTL) :
                 (desc->recv_cmsgflags & ~INET_CMSG_RECVTTL);
-	    DEBUGF(("inet_set_opts(%p): s=%d, IP_RECVTTL=%d\r\n",
-		    desc->port, desc->s, ival));
 	    break;
 #endif
 
 	case TCP_OPT_NODELAY:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(nodelay) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
 	    proto = IPPROTO_TCP; 
 	    type = TCP_NODELAY; 
-	    DEBUGF(("inet_set_opts(%p): s=%d, TCP_NODELAY=%d\r\n",
-		    desc->port, desc->s, ival));
 	    break;
 
 	case TCP_OPT_NOPUSH:
 #if defined(INET_TCP_NOPUSH)
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(nopush) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    proto = IPPROTO_TCP;
 	    type = INET_TCP_NOPUSH;
-	    DEBUGF(("inet_set_opts(%p): s=%d, t=%d TCP_NOPUSH=%d\r\n",
-	            desc->port, desc->s, type, ival));
 	    break;
 #else
 	    /* inet_fill_opts always returns a value for this option,
 	     * so we need to ignore it if not implemented, just in case */
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(nopush) -> SKIP\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
 	    continue;
 #endif
 
 #if defined(HAVE_MULTICAST_SUPPORT) && defined(IPPROTO_IP)
 
 	case UDP_OPT_MULTICAST_TTL:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(multicast-ttl) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    proto = IPPROTO_IP;
 	    type = IP_MULTICAST_TTL;
-	    DEBUGF(("inet_set_opts(%p): s=%d, IP_MULTICAST_TTL=%d\r\n",
-		    desc->port, desc->s,ival));
 	    break;
 
 	case UDP_OPT_MULTICAST_LOOP:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(multicast-loop) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
 	    proto = IPPROTO_IP;
 	    type = IP_MULTICAST_LOOP;
-	    DEBUGF(("inet_set_opts(%p): s=%d, IP_MULTICAST_LOOP=%d\r\n",
-		    desc->port, desc->s,ival));
 	    break;
 
 	case UDP_OPT_MULTICAST_IF:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(multicast-if) -> %d (%d)\r\n",
+                  __LINE__,
+                  desc->s, driver_caller(desc->port), ival, sock_htonl(ival)) );
 	    proto = IPPROTO_IP;
 	    type = IP_MULTICAST_IF;
-	    DEBUGF(("inet_set_opts(%p): s=%d, IP_MULTICAST_IF=%x\r\n",
-		    desc->port, desc->s, ival));
 	    ival = sock_htonl(ival);
 	    break;
 
 	case UDP_OPT_ADD_MEMBERSHIP:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(add-membership) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    proto = IPPROTO_IP;
 	    type = IP_ADD_MEMBERSHIP;
-	    DEBUGF(("inet_set_opts(%p): s=%d, IP_ADD_MEMBERSHIP=%d\r\n",
-		    desc->port, desc->s,ival));
 	    goto L_set_mreq;
 	    
 	case UDP_OPT_DROP_MEMBERSHIP:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(drop-membership) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    proto = IPPROTO_IP;
 	    type = IP_DROP_MEMBERSHIP;
-	    DEBUGF(("inet_set_opts(%p): s=%d, "
-                    "IP_DROP_MEMBERSHIP=%x\r\n",
-		    desc->port, desc->s, ival));
 	L_set_mreq:
 	    mreq_val.imr_multiaddr.s_addr = sock_htonl(ival);
 	    ival = get_int32(ptr);
@@ -6923,12 +7130,14 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 #endif /* defined(HAVE_MULTICAST_SUPPORT) && defined(IPPROTO_IP) */
 
 	case INET_OPT_IPV6_V6ONLY:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(ipv6-v6only) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
 #if HAVE_DECL_IPV6_V6ONLY && defined(IPPROTO_IPV6)
 	    proto = IPPROTO_IPV6;
 	    type = IPV6_V6ONLY;
 	    propagate = 1;
-	    DEBUGF(("inet_set_opts(%p): s=%d, IPV6_V6ONLY=%d\r\n",
-		    desc->port, desc->s, ival));
 	    break;
 #elif defined(__WIN32__) && defined(HAVE_IN6) && defined(AF_INET6)
 	    /* Fake a'la OpenBSD; set to 'true' is fine but 'false' invalid. */
@@ -6940,6 +7149,10 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 #endif
 
 	case INET_OPT_RAW:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(raw) -> %d, %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival, len) );
 	    if (len < 8) {
 		return -1;
 	    }
@@ -6959,6 +7172,10 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 
 #ifdef SO_BINDTODEVICE
 	case INET_OPT_BIND_TO_DEVICE:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(bindtodevice) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
 	    if (ival < 0) return -1;
 	    if (len < ival) return -1;
 	    if (ival > sizeof(ifname)) {
@@ -6974,27 +7191,49 @@ static int inet_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    arg_ptr = (char*)&ifname;
 	    arg_sz = sizeof(ifname);
 	    propagate = 1; /* We do want to know if this fails */
-
-	    DEBUGF(("inet_set_opts(%p): s=%d, SO_BINDTODEVICE=%s\r\n",
-		    desc->port, desc->s, ifname));
 	    break;
 #endif
 
-	default:
+	case INET_LOPT_DEBUG:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_set_opts(debug) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
+            if (ival) {
+                desc->debug = TRUE;
+            } else {
+                desc->debug = FALSE;
+            }
+            continue; /* take care of next option */
+
+ 	default:
 	    return -1;
 	}
+
+
+	DDBG(desc,
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "inet_set_opts -> try set opt (%d) %d\r\n",
+	      __LINE__, desc->s, driver_caller(desc->port), proto, type) );
+
+
 #if  defined(IP_TOS) && defined(IPPROTO_IP) \
     && defined(SO_PRIORITY) && !defined(__WIN32__)
 	res = setopt_prio_tos_trick (desc->s, proto, type, arg_ptr, arg_sz, propagate);
 #else
 	res = sock_setopt	    (desc->s, proto, type, arg_ptr, arg_sz);
 #endif
+
+
+	DDBG(desc,
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "inet_set_opts -> set opt result: %d\r\n",
+	      __LINE__, desc->s, driver_caller(desc->port), res) );
+
         if (res == 0) desc->recv_cmsgflags = recv_cmsgflags;
 	if (propagate && res != 0) {
 	    return -1;
 	}
-	DEBUGF(("inet_set_opts(%p): s=%d returned %d\r\n",
-		desc->port, desc->s, res));
     }
 
     if ( ((desc->stype == SOCK_STREAM) && IS_CONNECTED(desc)) ||
@@ -7140,6 +7379,11 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
         eopt = *curr;
 	curr++;
 
+	DDBG(desc,
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "sctp_set_opts -> eopt: %d\r\n",
+	      __LINE__, desc->s, driver_caller(desc->port), eopt) );
+
         recv_cmsgflags = desc->recv_cmsgflags;
 	/* Get the option value.  XXX: The condition  (curr < ptr + len)
 	   does not preclude us from reading from beyond the buffer end,
@@ -7151,43 +7395,82 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	/* Local INET options: */
 
 	case INET_LOPT_BUFFER:
-	    desc->bufsz  = get_int32(curr);		curr += 4;
+            {
+                int ival = get_int32(curr);		curr += 4;
 
-	    if (desc->bufsz < INET_MIN_BUFFER)
-		desc->bufsz = INET_MIN_BUFFER;
-            desc->flags |= INET_FLG_BUFFER_SET;
-	    res = 0;	  /* This does not affect the kernel buffer size */
+                DDBG(desc,
+                     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                      "sctp_set_opts(buffer) -> %d\r\n",
+                      __LINE__, desc->s, driver_caller(desc->port), ival) );
+
+                desc->bufsz  = ival;
+
+                if (desc->bufsz < INET_MIN_BUFFER)
+                    desc->bufsz = INET_MIN_BUFFER;
+                desc->flags |= INET_FLG_BUFFER_SET;
+                res = 0;   /* This does not affect the kernel buffer size */
+            }
 	    continue;
 
 	case INET_LOPT_MODE:
-	    desc->mode   = get_int32(curr);		curr += 4;
-	    res = 0;
+            {
+                int ival = get_int32(curr);		curr += 4;
+
+                DDBG(desc,
+                     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                      "sctp_set_opts(mode) -> %s (%d)\r\n",
+                      __LINE__, desc->s, driver_caller(desc->port),
+                      M2S(ival), ival) );
+                     
+                desc->mode = ival;
+                res        = 0;
+            }
 	    continue;
 
 	case INET_LOPT_ACTIVE:
-	    desc->active = get_int32(curr);		curr += 4;
-            if (desc->active == INET_MULTI) {
-                long ac = desc->active_count;
-                Sint16 nval = get_int16(curr);          curr += 2;
-		ac += nval;
-                if (ac > INT16_MAX || ac < INT16_MIN)
-                    return -1;
-                desc->active_count += nval;
-                if (desc->active_count < 0)
+            {
+                int ival = get_int32(curr);		curr += 4;
+
+                DDBG(desc,
+                     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                      "sctp_set_opts(active) -> %s (%d)\r\n",
+                      __LINE__, desc->s, driver_caller(desc->port),
+                      A2S(ival), ival) );
+
+                desc->active = ival;
+                if (desc->active == INET_MULTI) {
+                    long   ac   = desc->active_count;
+                    Sint16 nval = get_int16(curr);          curr += 2;
+                    DDBG(desc,
+                         ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                          "sctp_set_opts(active) -> nval: %d\r\n",
+                      __LINE__, desc->s, driver_caller(desc->port), nval) );
+                    ac += nval;
+                    if (ac > INT16_MAX || ac < INT16_MIN)
+                        return -1;
+                    desc->active_count += nval;
+                    if (desc->active_count < 0)
+                        desc->active_count = 0;
+                    if (desc->active_count == 0) {
+                        desc->active = INET_PASSIVE;
+                        packet_passive_message(desc);
+                    }
+                } else
                     desc->active_count = 0;
-                if (desc->active_count == 0) {
-                    desc->active = INET_PASSIVE;
-                    packet_passive_message(desc);
-                }
-            } else
-                desc->active_count = 0;
-	    res = 0;
+                res = 0;
+            }
 	    continue;
 
 #ifdef HAVE_SETNS
 	case INET_LOPT_NETNS:
 	{
 	    size_t ns_len;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> NETNS\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    ns_len = get_int32(curr);                   curr += 4;
 	    CHKLEN(curr, ns_len);
 	    if (desc->netns != NULL) FREE(desc->netns);
@@ -7203,6 +7486,11 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 
 	case SCTP_OPT_RTOINFO:
 	{
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> RTOINFO\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    CHKLEN(curr, ASSOC_ID_LEN + 3*4);
 	    arg.rtoi.srto_assoc_id = GET_ASSOC_ID(curr);  curr += ASSOC_ID_LEN;
 	    arg.rtoi.srto_initial  = get_int32   (curr);  curr += 4;
@@ -7215,8 +7503,14 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    arg_sz  = sizeof  ( arg.rtoi);
 	    break;
 	}
+
 	case SCTP_OPT_ASSOCINFO:
 	{
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> ASSOCINFO\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    CHKLEN(curr, ASSOC_ID_LEN + 2*2 + 3*4);
 
 	    arg.ap.sasoc_assoc_id    = GET_ASSOC_ID(curr); curr += ASSOC_ID_LEN;
@@ -7233,8 +7527,14 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    arg_sz  = sizeof  ( arg.ap);
 	    break;
 	}
+
 	case SCTP_OPT_INITMSG:
 	{
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> INITMSG\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    CHKLEN(curr, SCTP_GET_INITMSG_LEN);
 	    curr  = sctp_get_initmsg (&arg.im, curr);
 
@@ -7244,8 +7544,14 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    arg_sz  = sizeof  ( arg.im);
 	    break;
 	}
+
 	case INET_OPT_LINGER:
 	{
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> LINGER\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    CHKLEN(curr, 2*4);
 	    arg.lin.l_onoff  = get_int32 (curr);  curr += 4;
 	    arg.lin.l_linger = get_int32 (curr);  curr += 4;
@@ -7256,8 +7562,14 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    arg_sz  = sizeof  ( arg.lin);
 	    break;
 	}
+
 	case SCTP_OPT_NODELAY:
 	{
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> NODELAY\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    arg.ival= get_int32 (curr);	  curr += 4;
 	    proto   = IPPROTO_SCTP;
 	    type    = SCTP_NODELAY;
@@ -7265,9 +7577,17 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    arg_sz  = sizeof  ( arg.ival);
 	    break;
 	}
+
 	case INET_OPT_RCVBUF:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(rcvbuf) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
+
+	    arg.ival= ival;
 	    proto   = SOL_SOCKET;
 	    type    = SO_RCVBUF;
 	    arg_ptr = (char*) (&arg.ival);
@@ -7280,9 +7600,17 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
             desc->flags |= INET_FLG_BUFFER_SET;
 	    break;
 	}
+
 	case INET_OPT_SNDBUF:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(sndbuf) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
+
+	    arg.ival= ival;
 	    proto   = SOL_SOCKET;
 	    type    = SO_SNDBUF;
 	    arg_ptr = (char*) (&arg.ival);
@@ -7292,6 +7620,11 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	}
 	case INET_OPT_REUSEADDR:
 	{
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> REUSEADDR\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    arg.ival= get_int32 (curr);	  curr += 4;
 	    proto   = SOL_SOCKET;
 	    type    = SO_REUSEADDR;
@@ -7301,21 +7634,36 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	}
 	case INET_OPT_DONTROUTE:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = SOL_SOCKET;
-	    type    = SO_DONTROUTE;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(dontroute) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
+
+	    arg.ival = ival;
+	    proto    = SOL_SOCKET;
+	    type     = SO_DONTROUTE;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
 	    break;
 	}
+
 	case INET_OPT_PRIORITY:
 #	ifdef SO_PRIORITY
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = SOL_SOCKET;
-	    type    = SO_PRIORITY;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(prio) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
+
+	    arg.ival = ival;
+	    proto    = SOL_SOCKET;
+	    type     = SO_PRIORITY;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
 	    break;
 	}
 #	else
@@ -7327,11 +7675,17 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	case INET_OPT_TOS:
 #	if defined(IP_TOS) && defined(IPPROTO_IP)
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = IPPROTO_IP;
-	    type    = IP_TOS;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(tos) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
+
+	    arg.ival = ival;
+	    proto    = IPPROTO_IP;
+	    type     = IP_TOS;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
 	    break;
 	}
 #	else
@@ -7343,11 +7697,18 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 #       if defined(IPV6_TCLASS) && defined(IPPROTO_IPV6)
 	case INET_OPT_TCLASS:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = IPPROTO_IPV6;
-	    type    = IPV6_TCLASS;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(tclass) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
+
+	    arg.ival = ival;
+	    proto    = IPPROTO_IPV6;
+	    type     = IPV6_TCLASS;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
 	    break;
 	}
 #	endif
@@ -7355,11 +7716,18 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 #       if defined(IP_TTL) && defined(IPPROTO_IP)
 	case INET_OPT_TTL:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = IPPROTO_IP;
-	    type    = IP_TTL;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(ttl) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
+
+	    arg.ival = ival;
+	    proto    = IPPROTO_IP;
+	    type     = IP_TTL;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
 	    break;
 	}
 #	endif
@@ -7367,11 +7735,18 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 #	if defined(IP_RECVTOS) && defined(IPPROTO_IP)
 	case INET_OPT_RECVTOS:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = IPPROTO_IP;
-	    type    = IP_RECVTOS;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(recvtos) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
+
+	    arg.ival = ival;
+	    proto    = IPPROTO_IP;
+	    type     = IP_RECVTOS;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
             recv_cmsgflags =
                 arg.ival ?
                 (desc->recv_cmsgflags | INET_CMSG_RECVTOS) :
@@ -7383,11 +7758,18 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 #       if defined(IPV6_RECVTCLASS) && defined(IPPROTO_IPV6)
 	case INET_OPT_RECVTCLASS:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = IPPROTO_IPV6;
-	    type    = IPV6_RECVTCLASS;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(recvtclass) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
+
+	    arg.ival = ival;
+	    proto    = IPPROTO_IPV6;
+	    type     = IPV6_RECVTCLASS;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
             recv_cmsgflags =
                 arg.ival ?
                 (desc->recv_cmsgflags | INET_CMSG_RECVTCLASS) :
@@ -7399,11 +7781,18 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 #	if defined(IP_RECVTTL) && defined(IPPROTO_IP)
 	case INET_OPT_RECVTTL:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = IPPROTO_IP;
-	    type    = IP_RECVTTL;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(recvttl) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
+
+	    arg.ival = ival;
+	    proto    = IPPROTO_IP;
+	    type     = IP_RECVTTL;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
             recv_cmsgflags =
                 arg.ival ?
                 (desc->recv_cmsgflags | INET_CMSG_RECVTTL) :
@@ -7416,11 +7805,18 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	case INET_OPT_IPV6_V6ONLY:
 #       if HAVE_DECL_IPV6_V6ONLY && defined(IPPROTO_IPV6)
 	{
-	    arg.ival= get_int32 (curr);   curr += 4;
-	    proto   = IPPROTO_IPV6;
-	    type    = IPV6_V6ONLY;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(ipv6_v6only) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
+
+	    arg.ival = ival;
+	    proto    = IPPROTO_IPV6;
+	    type     = IPV6_V6ONLY;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
 	    break;
 	}
 #       elif defined(__WIN32__) && defined(HAVE_IN6) && defined(AF_INET6)
@@ -7431,6 +7827,11 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 
 #ifdef SO_BINDTODEVICE
 	case INET_OPT_BIND_TO_DEVICE:
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> BIND_TO_DEVICE\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    arg_sz = get_int32(curr);			curr += 4;
 	    CHKLEN(curr, arg_sz);
 	    if (arg_sz >= sizeof(arg.ifname))
@@ -7448,45 +7849,82 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 
 	case SCTP_OPT_AUTOCLOSE:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = IPPROTO_SCTP;
-	    type    = SCTP_AUTOCLOSE;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(autoclose) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
+
+	    arg.ival = ival;
+	    proto    = IPPROTO_SCTP;
+	    type     = SCTP_AUTOCLOSE;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
 	    break;
 	}
+
 	case SCTP_OPT_DISABLE_FRAGMENTS:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = IPPROTO_SCTP;
-	    type    = SCTP_DISABLE_FRAGMENTS;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(disable_fragments) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
+
+	    arg.ival = ival;
+	    proto    = IPPROTO_SCTP;
+	    type     = SCTP_DISABLE_FRAGMENTS;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
 	    break;
 	}
+
 	case SCTP_OPT_I_WANT_MAPPED_V4_ADDR:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = IPPROTO_SCTP;
-	    type    = SCTP_I_WANT_MAPPED_V4_ADDR;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(i_want_mapped_v4_addr) -> %s\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), B2S(ival)) );
+
+	    arg.ival = ival;
+	    proto    = IPPROTO_SCTP;
+	    type     = SCTP_I_WANT_MAPPED_V4_ADDR;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
 	    break;
 	}
+
 	case SCTP_OPT_MAXSEG:
 	{
-	    arg.ival= get_int32 (curr);	  curr += 4;
-	    proto   = IPPROTO_SCTP;
-	    type    = SCTP_MAXSEG;
-	    arg_ptr = (char*) (&arg.ival);
-	    arg_sz  = sizeof  ( arg.ival);
+            int ival = get_int32 (curr);	  curr += 4;
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts(maxseg) -> %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port), ival) );
+
+	    arg.ival = ival;
+	    proto    = IPPROTO_SCTP;
+	    type     = SCTP_MAXSEG;
+	    arg_ptr  = (char*) (&arg.ival);
+	    arg_sz   = sizeof  ( arg.ival);
 	    break;
 	}
+
 	case SCTP_OPT_PRIMARY_ADDR:
 	case SCTP_OPT_SET_PEER_PRIMARY_ADDR:
 	{
 	    ErlDrvSizeT alen;
 	    
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> PRIMARY_ADDR | SET_PEER_PRIMARY_ADDR\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    CHKLEN(curr, ASSOC_ID_LEN);
 	    /* XXX: These 2 opts have isomorphic value data structures,
 	       "sctp_setpeerprim" and "sctp_prim" (in Solaris 10, the latter
@@ -7510,8 +7948,14 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    arg_sz   =  sizeof  ( arg.prim);
 	    break;
 	}
+
 	case SCTP_OPT_ADAPTATION_LAYER:
 	{
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> ADAPTATION_LAYER\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    /* XXX: do we need to convert the Ind into network byte order??? */
 	    arg.ad.ssb_adaptation_ind = sock_htonl (get_int32(curr));  curr += 4;
 
@@ -7521,6 +7965,7 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    arg_sz  = sizeof  ( arg.ad);
 	    break;
 	}
+
 	case SCTP_OPT_PEER_ADDR_PARAMS:
 	{
 	    ErlDrvSizeT alen;
@@ -7533,6 +7978,11 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 #           endif
 #           endif
 	    
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> PEER_ADDR_PARAMS\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    CHKLEN(curr, ASSOC_ID_LEN);
 	    arg.pap.spp_assoc_id = GET_ASSOC_ID(curr);	curr += ASSOC_ID_LEN;
 
@@ -7597,8 +8047,14 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    arg_sz  = sizeof  ( arg.pap);
 	    break;
 	}
+
 	case SCTP_OPT_DEFAULT_SEND_PARAM:
 	{
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> DEFAULT_SEND_PARAM\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    CHKLEN(curr, SCTP_GET_SENDPARAMS_LEN);
 	    curr = sctp_get_sendparams (&arg.sri, curr);
 
@@ -7609,8 +8065,14 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    VALGRIND_MAKE_MEM_DEFINED(arg_ptr, arg_sz); /*suppress "uninitialised bytes"*/
 	    break;
 	}
+
 	case SCTP_OPT_EVENTS:
 	{
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> EVENTS\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    CHKLEN(curr, 9);
 	    /* We do not support "sctp_authentication_event" -- it is not
 	       implemented in Linux Kernel SCTP anyway.   Just in case if
@@ -7644,6 +8106,11 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 #if defined(HAVE_DECL_SCTP_DELAYED_ACK_TIME) && defined(SCTP_ASSOC_VALUE_ASSOC_ID)
 	case SCTP_OPT_DELAYED_ACK_TIME:
 	{
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "sctp_set_opts -> DELAYED_ACK_TIME\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    CHKLEN(curr, ASSOC_ID_LEN + 4);
 	    arg.av.assoc_id    = GET_ASSOC_ID(curr);	curr += ASSOC_ID_LEN;
 	    arg.av.assoc_value = get_int32(curr);	curr += 4;
@@ -7655,6 +8122,26 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    break;
 	}
 #endif
+
+	case INET_LOPT_DEBUG:
+            {
+                int ival = get_int32(curr); curr += 4;
+
+                DDBG(desc,
+                     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                      "sctp_set_opts(debug) -> %s\r\n",
+                      __LINE__, desc->s, driver_caller(desc->port),
+                      B2S(ival)) );
+                if (ival) {
+                    desc->debug = TRUE;
+                } else {
+                    desc->debug = FALSE;
+                }
+
+                res = 0;
+            }
+            continue; /* take care of next option */
+
 	default:
 	    /* XXX: No more supported SCTP options. In particular, authentica-
 	       tion options (SCTP_AUTH_CHUNK, SCTP_AUTH_KEY, SCTP_PEER_AUTH_
@@ -7665,12 +8152,15 @@ static int sctp_set_opts(inet_descriptor* desc, char* ptr, int len)
 	    */
 	    return -1;
 	}
+
+
 #if  defined(IP_TOS) && defined(IPPROTO_IP)             \
     && defined(SO_PRIORITY) && !defined(__WIN32__)
 	res = setopt_prio_tos_trick (desc->s, proto, type, arg_ptr, arg_sz, 1);
 #else
 	res = sock_setopt	    (desc->s, proto, type, arg_ptr, arg_sz);
 #endif
+
 	/* The return values of "sock_setopt" can only be 0 or -1: */
 	ASSERT(res == 0 || res == -1);
         if (res == 0) desc->recv_cmsgflags = recv_cmsgflags;
@@ -7788,7 +8278,13 @@ static ErlDrvSSizeT inet_fill_opts(inet_descriptor* desc,
 	dest_used = new_need;				\
     } while(0)
 
-    
+
+    DDBG(desc,
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+          "inet_fill_opts -> entry\r\n",
+          __LINE__, desc->s, driver_caller(desc->port)) );
+
+
     PLACE_FOR(1,ptr);
     *ptr = INET_REP_OK;
 
@@ -7801,6 +8297,11 @@ static ErlDrvSSizeT inet_fill_opts(inet_descriptor* desc,
 
 	PLACE_FOR(5,ptr);
 
+	DDBG(desc,
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "inet_fill_opts -> opt %d\r\n",
+	      __LINE__, desc->s, driver_caller(desc->port), opt) );
+
 	switch(opt) {
 	case INET_LOPT_BUFFER:
 	    *ptr++ = opt;
@@ -8234,11 +8735,32 @@ static ErlDrvSSizeT inet_fill_opts(inet_descriptor* desc,
         }
 #endif /* #ifdef __WIN32__ */
 
+	case INET_LOPT_DEBUG:
+            *ptr++ = opt;
+            ival = desc->debug;
+            put_int32(ival, ptr);
+            continue;
+
 	default:
 	    RETURN_ERROR();
 	}
+
+	DDBG(desc,
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "inet_fill_opts -> try get opt (proto %d, type %d)\r\n",
+	      __LINE__, desc->s, driver_caller(desc->port), proto, type) );
+
 	/* We have 5 bytes allocated to ptr */
 	if (IS_SOCKET_ERROR(sock_getopt(desc->s,proto,type,arg_ptr,&arg_sz))) {
+            int save_errno = sock_errno();
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "inet_fill_opts -> failed get option (%d) %d: "
+                  "\r\n   errno: %d\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port),
+                  proto, type, save_errno) );
+
 	    TRUNCATE_TO(0,ptr);
 	    continue;
 	}
@@ -9254,6 +9776,11 @@ static ErlDrvSSizeT inet_subscribe(inet_descriptor* desc,
 /* Terminate socket */
 static void inet_stop(inet_descriptor* desc)
 {
+    DDBG(desc,
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR "] "
+          "inet_stop -> entry\r\n",
+          __LINE__, desc->s) );
+
     erl_inet_close(desc);
 #ifdef HAVE_SETNS
     if (desc->netns != NULL)
@@ -9361,6 +9888,8 @@ static ErlDrvData inet_start(ErlDrvPort port, int size, int protocol)
 
     desc->recv_cmsgflags = 0;
 
+    desc->debug = DDBG_DEFAULT;
+
     return (ErlDrvData)desc;
 }
 
@@ -9382,6 +9911,11 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	  ErlDrvSizeT i;
 	  int dstlen = 1;  /* Reply code */
 
+          DDBG(desc,
+               ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                "inet_ctl -> GETSTAT\r\n",
+                __LINE__, desc->s, driver_caller(desc->port)) );
+
 	  for (i = 0; i < len; i++) {
 	      switch(buf[i]) {
 	      case INET_STAT_SEND_OCT: dstlen += 9; break;
@@ -9389,7 +9923,7 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	      default: dstlen += 5; break;
 	      }
 	  }
-	  DEBUGF(("inet_ctl(%p): GETSTAT\r\n", (long) desc->port)); 
+
 	  if (dstlen > INET_MAX_OPT_BUFFER) /* sanity check */
 	      return 0;
 	  if (dstlen > rsize) {
@@ -9405,8 +9939,12 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
     case INET_REQ_SUBSCRIBE: {
 	  char* dst;
 	  int dstlen = 1 /* Reply code */ + len*5;
-	  DEBUGF(("inet_ctl(%p): INET_REQ_SUBSCRIBE\r\n",
-                  desc->port)); 
+
+          DDBG(desc,
+               ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                "inet_ctl -> SUBSCRIBE\r\n",
+                __LINE__, desc->s, driver_caller(desc->port)) );
+
 	  if (dstlen > INET_MAX_OPT_BUFFER) /* sanity check */
 	      return 0;
 	  if (dstlen > rsize) {
@@ -9421,7 +9959,12 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 
     case INET_REQ_GETOPTS: {    /* get options */
 	ErlDrvSSizeT replen;
-	DEBUGF(("inet_ctl(%p): GETOPTS\r\n", desc->port)); 
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "inet_ctl -> GETOPTS\r\n",
+              __LINE__, desc->s, driver_caller(desc->port)) );
+
 #ifdef HAVE_SCTP
         if (IS_SCTP(desc))
         {
@@ -9436,37 +9979,63 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
     }
 
     case INET_REQ_GETIFLIST: {
-	DEBUGF(("inet_ctl(%p): GETIFLIST\r\n", desc->port)); 
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> GETIFLIST\r\n",
+              __LINE__, driver_caller(desc->port)) );
+
 	if (!IS_OPEN(desc))
 	    return ctl_xerror(EXBADPORT, rbuf, rsize);
 	return inet_ctl_getiflist(desc, rbuf, rsize);
     }
 
     case INET_REQ_GETIFADDRS: {
-	DEBUGF(("inet_ctl(%p): GETIFADDRS\r\n", desc->port));
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> GETIFADDRS\r\n",
+              __LINE__, driver_caller(desc->port)) );
+
 	if (!IS_OPEN(desc))
 	    return ctl_xerror(EXBADPORT, rbuf, rsize);
 	return inet_ctl_getifaddrs(desc, rbuf, rsize);
     }
 
     case INET_REQ_IFGET: {
-	DEBUGF(("inet_ctl(%p): IFGET\r\n", desc->port)); 	
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> IFGET\r\n",
+              __LINE__, driver_caller(desc->port)) );
+
 	if (!IS_OPEN(desc))
 	    return ctl_xerror(EXBADPORT, rbuf, rsize);
 	return inet_ctl_ifget(desc, buf, len, rbuf, rsize);
     }
 
     case INET_REQ_IFSET: {
-	DEBUGF(("inet_ctl(%p): IFSET\r\n", desc->port));
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> IFSET\r\n",
+              __LINE__, driver_caller(desc->port)) );
+
 	if (!IS_OPEN(desc))
 	    return ctl_xerror(EXBADPORT, rbuf, rsize);
 	return inet_ctl_ifset(desc, buf, len, rbuf, rsize);
     }
 
     case INET_REQ_SETOPTS:  {   /* set options */
-	DEBUGF(("inet_ctl(%p): SETOPTS\r\n", desc->port)); 
-	/* XXX fprintf(stderr,"inet_ctl(%p): SETOPTS (len = %d)\r\n", desc->port,(int) len); */
-	switch(inet_set_opts(desc, buf, len)) {
+        int sres;
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%d,%T] inet_ctl -> SETOPTS\r\n",
+              __LINE__, desc->s, driver_caller(desc->port)) );
+
+        sres = inet_set_opts(desc, buf, len);
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%d,%T] inet_ctl(setopts) -> sres: %d\r\n",
+              __LINE__, desc->s, driver_caller(desc->port), sres) );
+
+	switch(sres) {
 	case -1: 
 	    return ctl_error(EINVAL, rbuf, rsize);
 	case 0: 
@@ -9491,18 +10060,26 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	}
     }
 
+
     case INET_REQ_GETSTATUS: {
 	char tbuf[4];
 
-	DEBUGF(("inet_ctl(%p): GETSTATUS\r\n", desc->port)); 
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> GETSTATUS\r\n",
+              __LINE__, driver_caller(desc->port)) );
+
 	put_int32(desc->state, tbuf);
 	return ctl_reply(INET_REP_OK, tbuf, 4, rbuf, rsize);
     }
 
+
     case INET_REQ_GETTYPE: {
 	char tbuf[8];
 
-	DEBUGF(("inet_ctl(%p): GETTYPE\r\n", desc->port)); 
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> GETTYPE\r\n",
+              __LINE__, driver_caller(desc->port)) );
+
 	if (desc->sfamily == AF_INET) {
 	    put_int32(INET_AF_INET, &tbuf[0]);
 	}
@@ -9539,18 +10116,24 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
     case INET_REQ_GETFD: {
 	char tbuf[4];
 
-	DEBUGF(("inet_ctl(%p): GETFD\r\n", desc->port)); 
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%d,%T] inet_ctl -> GETFD\r\n",
+              __LINE__, desc->s, driver_caller(desc->port)) );
+
 	if (!IS_OPEN(desc))
 	    return ctl_error(EINVAL, rbuf, rsize);
 	put_int32((long)desc->s, tbuf);
 	return ctl_reply(INET_REP_OK, tbuf, 4, rbuf, rsize);
     }
 	
+
     case INET_REQ_GETHOSTNAME: { /* get host name */
 	char tbuf[INET_MAXHOSTNAMELEN + 1];
 
-	DEBUGF(("inet_ctl(%p): GETHOSTNAME\r\n",
-                desc->port)); 
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> GETHOSTNAME\r\n",
+              __LINE__, driver_caller(desc->port)) );
+
 	if (len != 0)
 	    return ctl_error(EINVAL, rbuf, rsize);
 
@@ -9560,9 +10143,12 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	return ctl_reply(INET_REP_OK, tbuf, strlen(tbuf), rbuf, rsize);
     }
 
+
     case INET_REQ_GETPADDRS: {
-	DEBUGF(("inet_ctl(%p): INET_GETPADDRS\r\n",
-                desc->port));
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> GETPADDRS\r\n",
+              __LINE__, driver_caller(desc->port)) );
 
 	if (len != 4) return ctl_error(EINVAL, rbuf, rsize);
 
@@ -9593,13 +10179,16 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	}
     }
 
+
     case INET_REQ_PEER:  {      /* get peername */
 	char tbuf[sizeof(inet_address)];
 	inet_address peer;
 	inet_address* ptr;
 	unsigned int sz;
 
-	DEBUGF(("inet_ctl(%p): PEER\r\n", desc->port)); 
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> PEER\r\n",
+              __LINE__, driver_caller(desc->port)) );
 
 	if (!(desc->state & INET_F_ACTIVE))
 	    return ctl_error(ENOTCONN, rbuf, rsize);
@@ -9622,6 +10211,11 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 
     case INET_REQ_SETPEER: { /* set fake peername Port Address */
         char *xerror;
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> SETPEER\r\n",
+              __LINE__, driver_caller(desc->port)) );
+
 	if (len == 0) {
 	    desc->peer_ptr = NULL;
 	    return ctl_reply(INET_REP_OK, NULL, 0, rbuf, rsize);
@@ -9639,8 +10233,10 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
     }
 
     case INET_REQ_GETLADDRS: {
-	DEBUGF(("inet_ctl(%p): INET_GETLADDRS\r\n",
-                desc->port));
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> GETLADDRS\r\n",
+              __LINE__, driver_caller(desc->port)) );
 
 	if (len != 4) return ctl_error(EINVAL, rbuf, rsize);
 
@@ -9678,7 +10274,9 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	inet_address* ptr;
 	unsigned int sz;
 
-	DEBUGF(("inet_ctl(%p): NAME\r\n", desc->port)); 
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%d,%T] inet_ctl -> NAME\r\n",
+              __LINE__, desc->s, driver_caller(desc->port)) );
 
 	if ((ptr = desc->name_ptr) != NULL) {
 	    sz = desc->name_addr_len;
@@ -9698,6 +10296,11 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 
     case INET_REQ_SETNAME: { /* set fake sockname Port Address */
         char *xerror;
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> SETNAME\r\n",
+              __LINE__, driver_caller(desc->port)) );
+
 	if (len == 0) {
 	    desc->name_ptr = NULL;
 	    return ctl_reply(INET_REP_OK, NULL, 0, rbuf, rsize);
@@ -9719,7 +10322,9 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	inet_address local;
 	int port;
 
-	DEBUGF(("inet_ctl(%p): BIND\r\n", desc->port)); 
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%d,%T] inet_ctl -> BIND\r\n",
+              __LINE__, desc->s, driver_caller(desc->port)) );
 
 	if (len < 2)
 	    return ctl_error(EINVAL, rbuf, rsize);
@@ -9752,8 +10357,10 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
     }
 
     case INET_REQ_IGNOREFD: {
-      DEBUGF(("inet_ctl(%p): IGNOREFD, IGNORED = %d\r\n",
-	      desc->port,(int)*buf));
+
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%d,%T] inet_ctl -> IGNOREFD: %s\r\n",
+              __LINE__, desc->s, driver_caller(desc->port), B2S(*buf)) );
 
       /*
        * FD can only be ignored for connected TCP connections for now,
@@ -9794,6 +10401,10 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	short port;
 	int n;
 
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> GETSERVBYNAME\r\n",
+              __LINE__, driver_caller(desc->port)) );
+
 	if (len < 2)
 	    return ctl_error(EINVAL, rbuf, rsize);
 	n = get_int8(buf); buf++; len--;
@@ -9820,6 +10431,10 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
 	int n;
 	struct servent* srv;
 
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> GETSERVBYPORT\r\n",
+              __LINE__, driver_caller(desc->port)) );
+
 	if (len < 3)
 	    return ctl_error(EINVAL, rbuf, rsize);
 	port = get_int16(buf);
@@ -9837,6 +10452,9 @@ static ErlDrvSSizeT inet_ctl(inet_descriptor* desc, int cmd, char* buf,
     }
 	
     default:
+        DDBG(desc,
+             ("INET-DRV-DBG[%d][%T] inet_ctl -> unknown command\r\n",
+              __LINE__, driver_caller(desc->port)) );
 	return ctl_xerror(EXBADPORT, rbuf, rsize);
     }
 }
@@ -10166,8 +10784,10 @@ static void tcp_close_check(tcp_descriptor* desc)
 static void tcp_inet_stop(ErlDrvData e)
 {
     tcp_descriptor* desc = (tcp_descriptor*)e;
-    DEBUGF(("tcp_inet_stop(%p) {s=%d\r\n", 
-	    desc->inet.port, desc->inet.s));
+
+    DDBG(INETP(desc),
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR "] tcp_inet_stop -> entry\r\n",
+          __LINE__, desc->inet.s) );
 
     tcp_close_check(desc);
     tcp_clear_input(desc);
@@ -10176,12 +10796,15 @@ static void tcp_inet_stop(ErlDrvData e)
     if(desc->tcp_add_flags & TCP_ADDF_SENDFILE) {
         desc->tcp_add_flags &= ~TCP_ADDF_SENDFILE;
         close(desc->sendfile.dup_file_fd);
-        DEBUGF(("tcp_inet_stop(%p): SENDFILE dup closed %d\r\n",
-                desc->inet.port, desc->sendfile.dup_file_fd));
+
+        DDBG(INETP(desc),
+             ("INET-DRV-DBG[%d][" SOCKET_FSTR "] "
+              "tcp_inet_stop -> SENDFILE dup closed %d\r\n",
+              __LINE__, desc->inet.s, desc->sendfile.dup_file_fd) );
+
     }
 #endif
 
-    DEBUGF(("tcp_inet_stop(%p) }\r\n", desc->inet.port));
     inet_stop(INETP(desc));
 }
 
@@ -10222,10 +10845,14 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 
     cmd -= ERTS_INET_DRV_CONTROL_MAGIC_NUMBER;
     switch(cmd) {
+
     case INET_REQ_OPEN: { /* open socket and return internal index */
 	int domain;
-	DEBUGF(("tcp_inet_ctl(%p): OPEN\r\n",
-                desc->inet.port));
+
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][%T] tcp_inet_ctl -> OPEN\r\n",
+	      __LINE__, driver_caller(desc->inet.port)) );
+
 	if (len != 2) return ctl_error(EINVAL, rbuf, rsize);
 	switch(buf[0]) {
 	case INET_AF_INET:
@@ -10249,11 +10876,16 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	break;
     }
 
+
     case INET_REQ_FDOPEN: {  /* pass in an open (and optionally bound) socket */
 	int domain;
         int bound;
-	DEBUGF(("tcp_inet_ctl(%p): FDOPEN\r\n",
-                desc->inet.port));
+
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "tcp_inet_ctl -> FDOPEN\r\n",
+	      __LINE__, desc->inet.s, driver_caller(desc->inet.port)) );
+
 	if (len != 6 && len != 10) return ctl_error(EINVAL, rbuf, rsize);
 	switch(buf[0]) {
 	case INET_AF_INET:
@@ -10283,11 +10915,15 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	break;
     }
 
-    case INET_REQ_LISTEN: { /* argument backlog */
 
+    case INET_REQ_LISTEN: { /* argument backlog */
 	int backlog;
-	DEBUGF(("tcp_inet_ctl(%p): LISTEN\r\n",
-                desc->inet.port)); 
+
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "tcp_inet_ctl -> LISTEN\r\n",
+	      __LINE__, desc->inet.s, driver_caller(desc->inet.port)) );
+
 	if (desc->inet.state == INET_STATE_CLOSED)
 	    return ctl_xerror(EXBADPORT, rbuf, rsize);
 	if (!IS_OPEN(INETP(desc)))
@@ -10307,8 +10943,11 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	char tbuf[2], *xerror;
 	unsigned timeout;
 
-	DEBUGF(("tcp_inet_ctl(%p): CONNECT\r\n",
-                desc->inet.port)); 
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "tcp_inet_ctl -> CONNECT\r\n",
+	      __LINE__, desc->inet.s, driver_caller(desc->inet.port)) );
+
 	/* INPUT: Timeout(4), Port(2), Address(N) */
 
 	if (!IS_OPEN(INETP(desc)))
@@ -10328,16 +10967,35 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	
 	code = sock_connect(desc->inet.s, 
 			    (struct sockaddr*) &desc->inet.remote, len);
+
+        /* We *cannot* have debug printouts here since it resets the
+         * 'errno' value (printf).
+         */
+
 	if (IS_SOCKET_ERROR(code) &&
 		((sock_errno() == ERRNO_BLOCK) ||  /* Winsock2 */
 		 (sock_errno() == EINPROGRESS))) {	/* Unix & OSE!! */
-          sock_select(INETP(desc), FD_CONNECT, 1);
+
+            DDBG(INETP(desc),
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "tcp_inet_ctl(connect) -> would block => select\r\n",
+                  __LINE__,
+                  desc->inet.s, driver_caller(desc->inet.port)) );
+
+            sock_select(INETP(desc), FD_CONNECT, 1);
 	    desc->inet.state = INET_STATE_CONNECTING;
 	    if (timeout != INET_INFINITY)
 		driver_set_timer(desc->inet.port, timeout);
 	    enq_async(INETP(desc), tbuf, INET_REQ_CONNECT);
 	}
 	else if (code == 0) { /* ok we are connected */
+
+            DDBG(INETP(desc),
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "tcp_inet_ctl(connect) -> connected\r\n",
+                  __LINE__,
+                  desc->inet.s, driver_caller(desc->inet.port)) );
+
 	    desc->inet.state = INET_STATE_CONNECTED;
 	    if (desc->inet.active)
 		sock_select(INETP(desc), (FD_READ|FD_CLOSE), 1);
@@ -10345,11 +11003,21 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	    async_ok(INETP(desc));
 	}
 	else {
-	    return ctl_error(sock_errno(), rbuf, rsize);
+            int save_errno = sock_errno();
+
+            DDBG(INETP(desc),
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "tcp_inet_ctl(connect) -> error: %s (%d)\r\n",
+                  __LINE__,
+                  desc->inet.s, driver_caller(desc->inet.port),
+                  errno_str(save_errno), save_errno) );
+
+	    return ctl_error(save_errno, rbuf, rsize);
 	}
 	return ctl_reply(INET_REP_OK, tbuf, 2, rbuf, rsize);
     }
 
+
     case INET_REQ_ACCEPT: {  /* do async accept */
 	char tbuf[2];
 	unsigned timeout;
@@ -10357,8 +11025,11 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	unsigned int n;
 	SOCKET s;
 
-	DEBUGF(("tcp_inet_ctl(%p): ACCEPT\r\n",
-                desc->inet.port)); 
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "tcp_inet_ctl -> ACCEPT\r\n",
+	      __LINE__, desc->inet.s, driver_caller(desc->inet.port)) );
+
 	/* INPUT: Timeout(4) */
 
 	if ((desc->inet.state != INET_STATE_LISTENING && desc->inet.state != INET_STATE_ACCEPTING &&
@@ -10460,9 +11131,12 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	    return ctl_reply(INET_REP_OK, tbuf, 2, rbuf, rsize);
 	}
     }
+
+
     case INET_REQ_CLOSE:
-	DEBUGF(("tcp_inet_ctl(%p): CLOSE\r\n",
-                desc->inet.port)); 
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] tcp_inet_ctl -> CLOSE\r\n",
+	      __LINE__, desc->inet.s, driver_caller(desc->inet.port)) );
 	tcp_close_check(desc);
 	tcp_desc_close(desc);
 	return ctl_reply(INET_REP_OK, NULL, 0, rbuf, rsize);
@@ -10473,8 +11147,10 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	char tbuf[2];
 	int n;
 
-	DEBUGF(("tcp_inet_ctl(%p): RECV (s=%d)\r\n",
-		desc->inet.port, desc->inet.s)); 
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] tcp_inet_ctl -> RECV\r\n",
+	      __LINE__, desc->inet.s, driver_caller(desc->inet.port)) );
+
 	/* INPUT: Timeout(4),  Length(4) */
 	if (!IS_CONNECTED(INETP(desc))) {
 	    if (desc->tcp_add_flags & TCP_ADDF_DELAYED_CLOSE_RECV) {
@@ -10493,8 +11169,13 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	timeout = get_int32(buf);
 	buf += 4;
 	n = get_int32(buf);
-	DEBUGF(("tcp_inet_ctl(%p) timeout = %d, n = %d\r\n",
-		desc->inet.port,timeout,n));
+
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "tcp_inet_ctl(recv) -> timeout: %d, n: %d\r\n",
+	      __LINE__,
+              desc->inet.s, driver_caller(desc->inet.port), timeout, n) );
+
 	if ((desc->inet.htype != TCP_PB_RAW) && (n != 0))
 	    return ctl_error(EINVAL, rbuf, rsize);
 	if (n > TCP_MAX_PACKET_SIZE)
@@ -10518,9 +11199,11 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	return ctl_reply(INET_REP_OK, tbuf, 2, rbuf, rsize);
     }
 
+
     case TCP_REQ_UNRECV: {
-	DEBUGF(("tcp_inet_ctl(%p): UNRECV\r\n",
-                desc->inet.port)); 
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] tcp_inet_ctl -> UNRECV\r\n",
+	      __LINE__, desc->inet.s, driver_caller(desc->inet.port)) );
 	if (!IS_CONNECTED(INETP(desc)))
    	    return ctl_error(ENOTCONN, rbuf, rsize);
 	tcp_push_buffer(desc, buf, len);
@@ -10528,17 +11211,31 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	    tcp_deliver(desc, 0);
 	return ctl_reply(INET_REP_OK, NULL, 0, rbuf, rsize);
     }
+
+
     case TCP_REQ_SHUTDOWN: {
 	int how;
-	DEBUGF(("tcp_inet_ctl(%p): FDOPEN\r\n",
-                desc->inet.port)); 
+
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "tcp_inet_ctl -> SHUTDOWN\r\n",
+	      __LINE__, desc->inet.s, driver_caller(desc->inet.port)) );
+
 	if (!IS_CONNECTED(INETP(desc))) {
 	    return ctl_error(ENOTCONN, rbuf, rsize);
 	}
 	if (len != 1) {
 	    return ctl_error(EINVAL, rbuf, rsize);
 	}
+
 	how = buf[0];
+
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "tcp_inet_ctl(shutdown) -> how: %s (%d)\r\n",
+	      __LINE__,
+              desc->inet.s, driver_caller(desc->inet.port), SH2S(how), how) );
+
 	if (how != TCP_SHUT_RD && driver_sizeq(desc->inet.port) > 0) {
 	    if (how == TCP_SHUT_WR) {
 		desc->tcp_add_flags |= TCP_ADDF_PENDING_SHUT_WR;
@@ -10556,6 +11253,7 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 	}
     }
 
+
     case TCP_REQ_SENDFILE: {
 #ifdef HAVE_SENDFILE
         const ErlDrvSizeT required_len =
@@ -10564,8 +11262,10 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 
         int raw_file_fd;
 
-        DEBUGF(("tcp_inet_ctl(%p): SENDFILE\r\n",
-                desc->inet.port));
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "tcp_inet_ctl -> SENDFILE\r\n",
+	      __LINE__, desc->inet.s, driver_caller(desc->inet.port)) );
 
         if (len != required_len) {
             return ctl_error(EINVAL, rbuf, rsize);
@@ -10585,8 +11285,12 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
 
         desc->sendfile.dup_file_fd = dup(raw_file_fd);
 
-        DEBUGF(("tcp_inet_ctl(%p): SENDFILE dup %d\r\n",
-                desc->inet.port, desc->sendfile.dup_file_fd));
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "tcp_inet_ctl(sendfile) -> dup: %d\r\n",
+	      __LINE__,
+              desc->inet.s, driver_caller(desc->inet.port),
+              desc->sendfile.dup_file_fd) );
 
         if(desc->sendfile.dup_file_fd == -1) {
             return ctl_error(errno, rbuf, rsize);
@@ -10620,8 +11324,11 @@ static ErlDrvSSizeT tcp_inet_ctl(ErlDrvData e, unsigned int cmd,
     }
 
     default:
-	DEBUGF(("tcp_inet_ctl(%p): %u\r\n",
-                desc->inet.port, cmd)); 
+	DDBG(INETP(desc),
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "tcp_inet_ctl -> (maybe) general command %u\r\n",
+	      __LINE__,
+              desc->inet.s, driver_caller(desc->inet.port), cmd) );
 	return inet_ctl(INETP(desc), cmd, buf, len, rbuf, rsize);
     }
 
@@ -10721,25 +11428,44 @@ static int tcp_inet_multi_timeout(ErlDrvData e, ErlDrvTermData caller)
 
 static void tcp_inet_command(ErlDrvData e, char *buf, ErlDrvSizeT len)
 {
-    tcp_descriptor* desc = (tcp_descriptor*)e;
-    desc->inet.caller = driver_caller(desc->inet.port);
+    tcp_descriptor* desc   = (tcp_descriptor*)e;
+    ErlDrvTermData  caller = driver_caller(desc->inet.port);
+
+    desc->inet.caller = caller;
+
+    DDBG(INETP(desc),
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+          "tcp_inet_command -> entry\r\n",
+          __LINE__, desc->inet.s, caller) );
 
-    DEBUGF(("tcp_inet_command(%p) {s=%d\r\n", 
-	    desc->inet.port, desc->inet.s)); 
     if (!IS_CONNECTED(INETP(desc)))
 	inet_reply_error(INETP(desc), ENOTCONN);
     else if (tcp_send(desc, buf, len) == 0)
 	inet_reply_ok(INETP(desc));
-    DEBUGF(("tcp_inet_command(%p) }\r\n", desc->inet.port)); 
+
+    DDBG(INETP(desc),
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+          "tcp_inet_command -> done\r\n",
+          __LINE__, desc->inet.s, caller) );
+
 }
 
 static void tcp_inet_commandv(ErlDrvData e, ErlIOVec* ev)
 {
-    tcp_descriptor* desc = (tcp_descriptor*)e;
-    desc->inet.caller = driver_caller(desc->inet.port);
+    tcp_descriptor* desc   = (tcp_descriptor*)e;
+    ErlDrvTermData  caller = driver_caller(desc->inet.port);
+
+    desc->inet.caller = caller;
+
+#ifdef INET_DRV_DEBUG
+    /* This function is just called to much to be part of this     *
+     * by default. Atleast as long as there are no 'debug levels'. */
+    DDBG(INETP(desc),
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+          "tcp_inet_commandv -> entry\r\n",
+          __LINE__, desc->inet.s, caller) );
+#endif
 
-    DEBUGF(("tcp_inet_commandv(%p) {s=%d\r\n",
-	    desc->inet.port, desc->inet.s)); 
     if (!IS_CONNECTED(INETP(desc))) {
 	if (desc->tcp_add_flags & TCP_ADDF_DELAYED_CLOSE_SEND) {
 	    desc->tcp_add_flags &= ~TCP_ADDF_DELAYED_CLOSE_SEND;
@@ -10758,7 +11484,13 @@ static void tcp_inet_commandv(ErlDrvData e, ErlIOVec* ev)
 	tcp_shutdown_error(desc, EPIPE);
     else if (tcp_sendv(desc, ev) == 0)
 	inet_reply_ok(INETP(desc));
-    DEBUGF(("tcp_inet_commandv(%p) }\r\n", desc->inet.port)); 
+ 
+#ifdef INET_DRV_DEBUG
+    DDBG(INETP(desc),
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] tcp_inet_commandv -> done\r\n",
+          __LINE__, desc->inet.s, caller) );
+#endif
+
 }
     
 static void tcp_inet_flush(ErlDrvData e)
@@ -10789,7 +11521,13 @@ static void tcp_inet_process_exit(ErlDrvData e, ErlDrvMonitor *monitorp)
 {
     tcp_descriptor* desc = (tcp_descriptor*)e;
     ErlDrvTermData who = driver_get_monitored_process(desc->inet.port,monitorp);
-    int state = desc->inet.state;
+    int            state = desc->inet.state;
+
+    DDBG(INETP(desc),
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%p] "
+          "tcp_inet_process_exit -> entry with"
+          "\r\n   who: %T\r\n",
+          __LINE__, desc->inet.s, desc->inet.port, who) );
 
     if ((state & INET_STATE_MULTI_ACCEPTING) == INET_STATE_MULTI_ACCEPTING) {
 	int id,req;
@@ -10812,6 +11550,12 @@ static void tcp_inet_process_exit(ErlDrvData e, ErlDrvMonitor *monitorp)
 	sock_select(INETP(desc),FD_ACCEPT,0);
 	desc->inet.state = INET_STATE_LISTENING; /* restore state */
     }
+
+    DDBG(INETP(desc),
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%p] "
+          "tcp_inet_process_exit -> done\r\n",
+          __LINE__, desc->inet.s, desc->inet.port) );
+
 } 
 
 static void inet_stop_select(ErlDrvEvent event, void* _)
@@ -10831,7 +11575,7 @@ static int tcp_recv_closed(tcp_descriptor* desc)
 #endif
     int blocking_send = 0;
     DEBUGF(("tcp_recv_closed(%p): s=%d, in %s, line %d\r\n",
-	    port, desc->inet.s, __FILE__, __LINE__));
+	    port, desc->inet.s, __LINE__));
     if (IS_BUSY(INETP(desc))) {
 	/* A send is blocked */
 	desc->inet.caller = desc->inet.busy_caller;
@@ -11379,7 +12123,7 @@ static void tcp_inet_event(ErlDrvData e, ErlDrvEvent event)
     }
     if (netEv.lNetworkEvents & FD_CLOSE) {
 	/* error in err = netEv.iErrorCode[FD_CLOSE_BIT] */
-	DEBUGF(("Detected close in %s, line %d\r\n", __FILE__, __LINE__));
+	DEBUGF(("Detected close in %s, line %d\r\n", __LINE__));
 	if (desc->tcp_add_flags & TCP_ADDF_SHOW_ECONNRESET) {
 	    err = netEv.iErrorCode[FD_CLOSE_BIT];
 	    if (err == ECONNRESET)
@@ -11588,7 +12332,7 @@ static int tcp_send_or_shutdown_error(tcp_descriptor* desc, int err)
      * and active sockets.
      */
     DEBUGF(("driver_failure_eof(%p) in %s, line %d\r\n",
-	    desc->inet.port, __FILE__, __LINE__));
+	    desc->inet.port, __LINE__));
     if (desc->inet.active) {
         ErlDrvTermData err_atom;
 	if (show_econnreset) {
@@ -12526,13 +13270,16 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
     int af = AF_INET;
 
     cmd -= ERTS_INET_DRV_CONTROL_MAGIC_NUMBER;
+
     switch(cmd) {
     case INET_REQ_OPEN:   /* open socket and return internal index */
-	DEBUGF(("packet_inet_ctl(%p): OPEN\r\n",
-                desc->port)); 
+	DDBG(desc,
+	     ("INET-DRV-DBG[%d][%T] packet_inet_ctl -> OPEN\r\n",
+	      __LINE__, driver_caller(desc->port)) );
 	if (len != 2) {
 	    return ctl_error(EINVAL, rbuf, rsize);
 	}
+
 	switch (buf[0]) {
 	case INET_AF_INET:  af = AF_INET; break;
 #if defined(HAVE_IN6) && defined(AF_INET6)
@@ -12544,6 +13291,7 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 	default:
 	    return ctl_xerror(str_eafnosupport, rbuf, rsize);
 	}
+
 	switch (buf[1]) {
 	case INET_TYPE_STREAM: type = SOCK_STREAM; break;
 	case INET_TYPE_DGRAM: type = SOCK_DGRAM; break;
@@ -12553,6 +13301,7 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 	default:
 	    return ctl_error(EINVAL, rbuf, rsize);
 	}
+
 	replen = inet_ctl_open(desc, af, type, rbuf, rsize);
 
 	if ((*rbuf)[0] != INET_REP_ERROR) {
@@ -12578,11 +13327,16 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
     case INET_REQ_FDOPEN: {  /* pass in an open (and optionally bound) socket */
 	SOCKET s;
         int bound;
-	DEBUGF(("packet inet_ctl(%p): FDOPEN\r\n",
-                desc->port));
+
+	DDBG(desc,
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "packet_inet_ctl -> FDOPEN\r\n",
+	      __LINE__, desc->s, driver_caller(desc->port)) );
+
 	if (len != 6 && len != 10) {
 	    return ctl_error(EINVAL, rbuf, rsize);
 	}
+
 	switch (buf[0]) {
 	case INET_AF_INET:  af = AF_INET; break;
 #if defined(HAVE_IN6) && defined(AF_INET6)
@@ -12594,6 +13348,7 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 	default:
 	    return ctl_xerror(str_eafnosupport, rbuf, rsize);
 	}
+
 	switch (buf[1]) {
 	case INET_TYPE_STREAM: type = SOCK_STREAM; break;
 	case INET_TYPE_DGRAM: type = SOCK_DGRAM; break;
@@ -12632,8 +13387,10 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 
 
     case INET_REQ_CLOSE:
-	DEBUGF(("packet_inet_ctl(%p): CLOSE\r\n",
-                desc->port)); 
+	DDBG(desc,
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "packet_inet_ctl -> CLOSE\r\n",
+	      __LINE__, desc->s, driver_caller(desc->port)) );
 	erl_inet_close(desc);
 	return ctl_reply(INET_REP_OK, NULL, 0, rbuf, rsize);
 
@@ -12653,8 +13410,12 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 #ifdef HAVE_SCTP
 	unsigned timeout;
 #endif
-	DEBUGF(("packet_inet_ctl(%p): CONNECT\r\n",
-                desc->port)); 
+
+
+	DDBG(desc,
+	     ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+              "packet_inet_ctl -> CONNECT\r\n",
+	      __LINE__, desc->s, driver_caller(desc->port)) );
 	
 	/* INPUT: [ Timeout(4), Port(2), Address(N) ] */
 
@@ -12784,9 +13545,12 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 		   from the TCP section. Returns: {ok,[]} on success.
 		*/
 	    int backlog;
-	    
-	    DEBUGF(("packet_inet_ctl(%p): LISTEN\r\n",
-                    desc->port)); 
+
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "packet_inet_ctl -> LISTEN\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    if (!IS_SCTP(desc))
 		return ctl_xerror(EXBADPORT, rbuf, rsize);
 	    if (!IS_OPEN(desc))
@@ -12813,6 +13577,11 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 	    char* curr;
 	    int   add_flag, rflag;
 	    
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "packet_inet_ctl -> BINDX\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    if (!IS_SCTP(desc))
 		return ctl_xerror(EXBADPORT, rbuf, rsize);
 
@@ -12851,8 +13620,11 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 	    int err;
 	    SOCKET new_socket;
 
-	    DEBUGF(("packet_inet_ctl(%p): PEELOFF\r\n",
-                    desc->port));
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "packet_inet_ctl -> PEELOFF\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    if (!IS_SCTP(desc))
 		return ctl_xerror(EXBADPORT, rbuf, rsize);
 	    if (!IS_OPEN(desc))
@@ -12893,8 +13665,11 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 	    unsigned timeout;
 	    char tbuf[2];
 
-	    DEBUGF(("packet_inet_ctl(%p): RECV\r\n",
-                    desc->port)); 
+            DDBG(desc,
+                 ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%T] "
+                  "packet_inet_ctl -> RECV\r\n",
+                  __LINE__, desc->s, driver_caller(desc->port)) );
+
 	    /* INPUT: Timeout(4), Length(4) */
 	    if (!IS_OPEN(desc))
 		return ctl_xerror(EXBADPORT, rbuf, rsize);
@@ -12919,6 +13694,7 @@ static ErlDrvSSizeT packet_inet_ctl(ErlDrvData e, unsigned int cmd, char* buf,
 	   INET_REQ_BIND goes here. If the req is not recognised
 	   there either, an error is returned:
 	*/
+
 	return inet_ctl(desc, cmd, buf, len, rbuf, rsize);
     }
 }
@@ -12927,6 +13703,12 @@ static void packet_inet_timeout(ErlDrvData e)
 {
     udp_descriptor  * udesc = (udp_descriptor*) e;
     inet_descriptor * desc  = INETP(udesc);
+
+    DDBG(desc,
+         ("INET-DRV-DBG[%d][" SOCKET_FSTR ",%p] "
+          "packet_inet_timeout -> entry\r\n",
+          __LINE__, desc->s, desc->port) );
+
     if (!(desc->active)) {
 	sock_select(desc, FD_READ, 0);
         async_error_am (desc, am_timeout);
diff --git a/lib/kernel/src/inet.erl b/lib/kernel/src/inet.erl
index 6ccf251372..eb9093069e 100644
--- a/lib/kernel/src/inet.erl
+++ b/lib/kernel/src/inet.erl
@@ -946,7 +946,8 @@ stats() ->
 %% Available options for tcp:connect
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 connect_options() ->
-    [tos, tclass, priority, reuseaddr, keepalive, linger, sndbuf, recbuf, nodelay,
+    [debug,
+     tos, tclass, priority, reuseaddr, keepalive, linger, sndbuf, recbuf, nodelay,
      recvtos, recvtclass, ttl, recvttl,
      header, active, packet, packet_size, buffer, mode, deliver, line_delimiter,
      exit_on_close, high_watermark, low_watermark, high_msgq_watermark,
@@ -1035,7 +1036,9 @@ con_add(Name, Val, #connect_opts{} = R, Opts, AllOpts) ->
 %% Available options for tcp:listen
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 listen_options() ->
-    [tos, tclass, priority, reuseaddr, keepalive, linger, sndbuf, recbuf, nodelay,
+    [debug,
+     tos, tclass,
+     priority, reuseaddr, keepalive, linger, sndbuf, recbuf, nodelay,
      recvtos, recvtclass, ttl, recvttl,
      header, active, packet, buffer, mode, deliver, backlog, ipv6_v6only,
      exit_on_close, high_watermark, low_watermark, high_msgq_watermark,
@@ -968,7 +969,10 @@ gen_tcp_module(Opts, socket) ->
 %% Available options for udp:open
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 udp_options() ->
-    [tos, tclass, priority, reuseaddr, sndbuf, recbuf, header, active, buffer, mode,
+    [
+     debug,
+     tos, tclass,
+     priority, reuseaddr, sndbuf, recbuf, header, active, buffer, mode,
      recvtos, recvtclass, ttl, recvttl, deliver, ipv6_v6only,
      broadcast, dontroute, multicast_if, multicast_ttl, multicast_loop,
      add_membership, drop_membership, read_packets,raw,
@@ -1242,6 +1248,7 @@ gen_udp_module(Opts, socket) ->
 %  (*) passing of open FDs ("fdopen") is not supported.
 sctp_options() ->
 [   % The following are generic inet options supported for SCTP sockets:
+    debug,
     mode, active, buffer, tos, tclass, ttl,
     priority, dontroute, reuseaddr, linger,
     recvtos, recvtclass, recvttl,
-- 
2.35.3

Places

File 5902-erts-inet-drv-kernel-Add-support-for-inet-drv-debug.patch of Package erlang (Revision fb8f015ac8ccbb72d49ed8284e9f5df5)

Places