abandoning traditional socket API parameter naming convention for something that actually makes sense0.3.3

12 files changed, 218 insertions, 236 deletions

diff --git a/src/SDK.h b/src/SDK.h
index dc29e82..bfa8522 100644
--- a/src/SDK.h
+++ b/src/SDK.h
@@ -104,7 +104,7 @@ char *zts_get_homepath();
 
 // ZT Intercept/RPC Controls
 // TODO: Remove any?
-void set_intercept_status(int mode); /* TODO: Rethink this */
+void set_intercept_status(int mode); // TODO: Rethink this
 void init_service(int key, const char * path);
 void init_service_and_rpc(int key, const char * path, const char * nwid);
 void init_intercept(int key);
@@ -132,7 +132,7 @@ ssize_t zts_recvmsg(RECVMSG_SIG);
 #if defined(__UNITY_3D__)
     ssize_t zts_recv(int fd, void *buf, int len);
     ssize_t zts_send(int fd, void *buf, int len);
-    int zts_set_nonblock(int fd); /* TODO combine with fcntl() */
+    int zts_set_nonblock(int fd); // TODO combine with fcntl()
 #endif  
 
 #if !defined(__IOS__)
@@ -143,9 +143,6 @@ ssize_t zts_recvmsg(RECVMSG_SIG);
 
 // Android JNI Direct-call API
 // JNI naming convention: Java_PACKAGENAME_CLASSNAME_METHODNAME
-/* If you define anything else in this file it that you wish to expose to your Android 
-	Java application you *must* follow that convention and any corresponding Java package/classes 
-	in your Android project must match this as well */
 #if defined(__ANDROID__)
 	// Exported JNI : ZT SERVICE CONTROLS
 	JNIEXPORT jint JNICALL Java_ZeroTier_SDK_zt_1start_1service(JNIEnv *env, jobject thisObj, jstring path);
diff --git a/src/SDK_EthernetTap.cpp b/src/SDK_EthernetTap.cpp
index 6eabecb..5b3ff5e 100644
--- a/src/SDK_EthernetTap.cpp
+++ b/src/SDK_EthernetTap.cpp
@@ -965,14 +965,14 @@ void NetconEthernetTap::handleGetsockname(PhySocket *sock, PhySocket *rpcSock, v
 {
 	Mutex::Lock _l(_tcpconns_m);
 	Connection *conn = getConnection(sock);
-	if(conn->addr == NULL){
+	if(conn->local_addr == NULL){
 		dwr(MSG_DEBUG_EXTRA," handleGetsockname(): No address info available. Is it bound?");
 		struct sockaddr_storage storage;
 		memset(&storage, 0, sizeof(struct sockaddr_storage));
 		write(_phy.getDescriptor(rpcSock), NULL, sizeof(struct sockaddr_storage));
 		return;
 	}
-	write(_phy.getDescriptor(rpcSock), conn->addr, sizeof(struct sockaddr_storage));
+	write(_phy.getDescriptor(rpcSock), conn->local_addr, sizeof(struct sockaddr_storage));
 }
 
 void NetconEthernetTap::handleGetpeername(PhySocket *sock, PhySocket *rpcSock, void **uptr, struct getsockname_st *getsockname_rpc)
@@ -1012,7 +1012,7 @@ void NetconEthernetTap::handleBind(PhySocket *sock, PhySocket *rpcSock, void **u
 
 	connAddr.addr = *((u32_t *)_ips[0].rawIpData());
 	Connection *conn = getConnection(sock);
-    dwr(MSG_DEBUG," handleBind(sock=%p,fd=%d,port=%d)\n", (void*)&sock, bind_rpc->sockfd, port);
+    dwr(MSG_DEBUG," handleBind(sock=%p,fd=%d,port=%d)\n", (void*)&sock, bind_rpc->fd, port);
     if(conn) {
         if(conn->type == SOCK_DGRAM) {
        		#if defined(__ANDROID__)
@@ -1027,7 +1027,7 @@ void NetconEthernetTap::handleBind(PhySocket *sock, PhySocket *rpcSock, void **u
             	struct sockaddr_in addr_in;
                 memcpy(&addr_in, &bind_rpc->addr, sizeof(addr_in));
                 addr_in.sin_port = Utils::ntoh(conn->UDP_pcb->local_port); // Newly assigned port
-                memcpy(&conn->addr, &addr_in, sizeof(addr_in));
+                memcpy(&conn->local_addr, &addr_in, sizeof(addr_in));
   				sendReturnValue(rpcSock, ERR_OK, ERR_OK); // Success
             }
             return;
@@ -1044,7 +1044,7 @@ void NetconEthernetTap::handleBind(PhySocket *sock, PhySocket *rpcSock, void **u
                     if(err == ERR_BUF)
                         sendReturnValue(rpcSock, -1, ENOMEM);
                 } else {
-                    conn->addr = (struct sockaddr_storage *) &bind_rpc->addr;
+                    conn->local_addr = (struct sockaddr_storage *) &bind_rpc->addr;
                     sendReturnValue(rpcSock, ERR_OK, ERR_OK); // Success
                 }
             } else {
@@ -1122,7 +1122,7 @@ Connection * NetconEthernetTap::handleSocketProxy(PhySocket *sock, int socket_ty
     if(new_udp_PCB || new_tcp_PCB) {
         conn->sock = sock;
         conn->type = socket_type;
-		conn->addr = NULL;
+		conn->local_addr = NULL;
 		conn->peer_addr = NULL;
         if(conn->type == SOCK_DGRAM) conn->UDP_pcb = new_udp_PCB;
         if(conn->type == SOCK_STREAM) conn->TCP_pcb = new_tcp_PCB;
@@ -1153,7 +1153,7 @@ Connection * NetconEthernetTap::handleSocket(PhySocket *sock, void **uptr, struc
         *uptr = newConn;
         newConn->type = socket_rpc->socket_type;
         newConn->sock = sock;
-		newConn->addr = NULL;
+		newConn->local_addr = NULL;
 		newConn->peer_addr = NULL;
         if(newConn->type == SOCK_DGRAM) newConn->UDP_pcb = new_udp_PCB;
         if(newConn->type == SOCK_STREAM) newConn->TCP_pcb = new_tcp_PCB;
@@ -1265,7 +1265,7 @@ void NetconEthernetTap::handleConnect(PhySocket *sock, PhySocket *rpcSock, Conne
 {
     dwr(MSG_DEBUG_EXTRA, "handleConnect(%p)\n", (void*)&sock);
     Mutex::Lock _l(_tcpconns_m);
-	struct sockaddr_in *rawAddr = (struct sockaddr_in *) &connect_rpc->__addr;
+	struct sockaddr_in *rawAddr = (struct sockaddr_in *) &connect_rpc->addr;
 	int port = lwipstack->__lwip_ntohs(rawAddr->sin_port);
 	ip_addr_t connAddr = convert_ip(rawAddr);    
 	int err = 0, ip = rawAddr->sin_addr.s_addr;
diff --git a/src/SDK_EthernetTap.hpp b/src/SDK_EthernetTap.hpp
index 77f79e4..fb6fff5 100644
--- a/src/SDK_EthernetTap.hpp
+++ b/src/SDK_EthernetTap.hpp
@@ -94,12 +94,11 @@ namespace ZeroTier {
 	  PhySocket *rpcSock, *sock;
 	  struct tcp_pcb *TCP_pcb;
 	  struct udp_pcb *UDP_pcb;
-	  struct sockaddr_storage *addr; // TODO: Rename
-	  struct sockaddr_storage *peer_addr; // Only set by connection procedure
+	  struct sockaddr_storage *local_addr; // Address we've bound to locally
+	  struct sockaddr_storage *peer_addr; // Address of connection call to remote host
 	  unsigned short port;
 	  unsigned char txbuf[DEFAULT_TCP_TX_BUF_SZ];
 	  unsigned char rxbuf[DEFAULT_TCP_RX_BUF_SZ];
-	    
 	  // TODO: necessary still?
 	  int proxy_conn_state;
 	};
diff --git a/src/SDK_Intercept.c b/src/SDK_Intercept.c
index eadfda9..3e8b11d 100644
--- a/src/SDK_Intercept.c
+++ b/src/SDK_Intercept.c
@@ -127,10 +127,10 @@ char *api_netpath;
             load_symbols();
         }
     #if defined(SDK_BUNDLED)
-        /* The reasoning for this check is that if you've built the SDK with SDK_BUNDLE=1, then 
-        you've included a full ZeroTier service in the same binary as your intercept, and we 
-        don't want to run ZeroTier network API calls through the intercept, so we must specify
-        which threads should be intercepted manually */
+        // The reasoning for this check is that if you've built the SDK with SDK_BUNDLE=1, then 
+        // you've included a full ZeroTier service in the same binary as your intercept, and we 
+        // don't want to run ZeroTier network API calls through the intercept, so we must specify
+        // which threads should be intercepted manually
         void *spec = pthread_getspecific(thr_id_key);
         int thr_id = spec != NULL ? *((int*)spec) : -1;
         return thr_id == INTERCEPT_ENABLED;
@@ -164,76 +164,75 @@ char *api_netpath;
     // ------------------------------------------------------------------------------
     // ------------------------------------ sendto() --------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, const void *buf, size_t len, int flags, 
-    // const struct sockaddr *addr, socklen_t addr_len
+    // int fd, const void *buf, size_t len, int flags, 
+    // const struct sockaddr *addr, socklen_t addrlen
 
 #if !defined(__ANDROID__)
     ssize_t sendto(SENDTO_SIG)
     {
-        dwr(MSG_DEBUG, "sendto(%d, %d)\n", sockfd, len);
+        dwr(MSG_DEBUG, "sendto(%d, ..., %d)\n", fd, len);
         //if (!check_intercept_enabled())
-            return realsendto(sockfd, buf, len, flags, addr, addr_len);
-        return zts_sendto(sockfd, buf, len, flags, addr, addr_len);
+            return realsendto(fd, buf, len, flags, addr, addrlen);
+        return zts_sendto(fd, buf, len, flags, addr, addrlen);
     }
 #endif
 
     // ------------------------------------------------------------------------------
     // ----------------------------------- sendmsg() --------------------------------
     // ------------------------------------------------------------------------------
-    // int socket, const struct msghdr *message, int flags
+    // int fd, const struct msghdr *msg, int flags
 
 #if !defined(__ANDROID__)
     ssize_t sendmsg(SENDMSG_SIG)
     {
         dwr(MSG_DEBUG, "sendmsg()\n");
         //if(!check_intercept_enabled())
-            return realsendmsg(socket, message, flags);
-        zts_sendmsg(socket, message, flags);
+            return realsendmsg(fd, msg, flags);
+        zts_sendmsg(fd, msg, flags);
     }
 #endif
     
     // ------------------------------------------------------------------------------
     // ---------------------------------- recvfrom() --------------------------------
     // ------------------------------------------------------------------------------
-    // int socket, void *restrict buffer, size_t length, int flags, struct sockaddr
-    // *restrict address, socklen_t *restrict address_len
+    // int fd, void *restrict buf, size_t len, int flags, struct sockaddr
+    // *restrict addr, socklen_t *restrict addrlen
 
 #if !defined(__ANDROID__)
     ssize_t recvfrom(RECVFROM_SIG)
     {
         dwr(MSG_DEBUG, "recvfrom(%d)\n", socket);
         if(!check_intercept_enabled())
-            return realrecvfrom(socket, buffer, length, flags, address, address_len);
-        return zts_recvfrom(socket, buffer, length, flags, address, address_len);
+            return realrecvfrom(fd, buf, len, flags, addr, addrlen);
+        return zts_recvfrom(fd, buf, len, flags, addr, addrlen);
     }
 #endif
 
     // ------------------------------------------------------------------------------
     // ----------------------------------- recvmsg() --------------------------------
     // ------------------------------------------------------------------------------
-    // int socket, struct msghdr *message, int flags
+    // int fd, struct msghdr *msg, int flags
 
 #if !defined(__ANDROID__)
     ssize_t recvmsg(RECVMSG_SIG)
     {
-        dwr(MSG_DEBUG, "recvmsg(%d)\n", socket);
+        dwr(MSG_DEBUG, "recvmsg(%d)\n", fd);
         //if(!check_intercept_enabled())
-            return realrecvmsg(socket, message, flags);
-        return zts_recvmsg(socket, message, flags);
+            return realrecvmsg(fd, msg, flags);
+        return zts_recvmsg(fd, msg, flags);
     }
 #endif
 
     // ------------------------------------------------------------------------------
     // --------------------------------- setsockopt() -------------------------------
     // ------------------------------------------------------------------------------
-    // int socket, int level, int optname, const void *optval, 
-    // socklen_t optlen
+    // int fd, int level, int optname, const void *optval, socklen_t optlen
 
     int setsockopt(SETSOCKOPT_SIG)
     {
-        dwr(MSG_DEBUG, "setsockopt(%d)\n", socket);
+        dwr(MSG_DEBUG, "setsockopt(%d)\n", fd);
         if (!check_intercept_enabled())
-            return realsetsockopt(socket, level, optname, optval, optlen);
+            return realsetsockopt(fd, level, optname, optval, optlen);
     #if defined(__linux__)
         if(level == SOL_IPV6 && optname == IPV6_V6ONLY)
             return 0;
@@ -242,23 +241,22 @@ char *api_netpath;
     #endif
         if(level == IPPROTO_TCP || (level == SOL_SOCKET && optname == SO_KEEPALIVE))
             return 0;
-        if(realsetsockopt(socket, level, optname, optval, optlen) < 0)
+        if(realsetsockopt(fd, level, optname, optval, optlen) < 0)
             perror("setsockopt():\n");
-        return zts_setsockopt(socket, level, optname, optval, optlen);
+        return zts_setsockopt(fd, level, optname, optval, optlen);
     }
 
     // ------------------------------------------------------------------------------
     // --------------------------------- getsockopt() -------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, int level, int optname, void *optval, 
-    // socklen_t *optlen 
+    // int fd, int level, int optname, void *optval, socklen_t *optlen 
 
     int getsockopt(GETSOCKOPT_SIG)
     {
-        dwr(MSG_DEBUG, "getsockopt(%d)\n", sockfd);
-        if (!check_intercept_enabled() || !connected_to_service(sockfd))
-            return realgetsockopt(sockfd, level, optname, optval, optlen);
-        return zts_getsockopt(sockfd, level, optname, optval, optlen);
+        dwr(MSG_DEBUG, "getsockopt(%d)\n", fd);
+        if (!check_intercept_enabled() || !connected_to_service(fd))
+            return realgetsockopt(fd, level, optname, optval, optlen);
+        return zts_getsockopt(fd, level, optname, optval, optlen);
     }
 
     // ------------------------------------------------------------------------------
@@ -295,16 +293,16 @@ char *api_netpath;
     // ------------------------------------------------------------------------------
     // ---------------------------------- connect() ---------------------------------
     // ------------------------------------------------------------------------------
-    // int __fd, const struct sockaddr * __addr, socklen_t __len
+    // int fd, const struct sockaddr *addr, socklen_t addrlen
 
     int connect(CONNECT_SIG)
     {
-        dwr(MSG_DEBUG, "connect(%d)\n", __fd);
+        dwr(MSG_DEBUG, "connect(%d)\n", fd);
         struct sockaddr_in *connaddr;
-        connaddr = (struct sockaddr_in *)__addr;
-        if(__addr->sa_family == AF_LOCAL || __addr->sa_family == AF_UNIX) {
+        connaddr = (struct sockaddr_in *)addr;
+        if(addr->sa_family == AF_LOCAL || addr->sa_family == AF_UNIX) {
             struct sockaddr_storage storage;
-            memcpy(&storage, __addr, __len);
+            memcpy(&storage, addr, addrlen);
             struct sockaddr_un *s_un = (struct sockaddr_un*)&storage;
             dwr(MSG_DEBUG, "connect(): address = %s\n", s_un->sun_path);
         }
@@ -319,53 +317,53 @@ char *api_netpath;
         dwr(MSG_DEBUG,"connect(): %d.%d.%d.%d: %d\n", d[0],d[1],d[2],d[3], ntohs(port));
         
         if(!check_intercept_enabled())
-            return realconnect(__fd, __addr, __len);
+            return realconnect(fd, addr, addrlen);
 
-        /* Check that this is a valid fd */
-        if(fcntl(__fd, F_GETFD) < 0) {
+        // Check that this is a valid fd
+        if(fcntl(fd, F_GETFD) < 0) {
             errno = EBADF;
             return -1;
         }
-        /* Check that it is a socket */
+        // Check that it is a socket 
         int sock_type;
         socklen_t sock_type_len = sizeof(sock_type);
-        if(getsockopt(__fd, SOL_SOCKET, SO_TYPE, (void *) &sock_type, &sock_type_len) < 0) {
+        if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *) &sock_type, &sock_type_len) < 0) {
             errno = ENOTSOCK;
             return -1;
         }
     #if defined(__linux__)
-        /* Check family */
+        // Check family
         if (connaddr->sin_family < 0 || connaddr->sin_family >= NPROTO){
             errno = EAFNOSUPPORT;
             return -1;
         }
     #endif
-        /* make sure we don't touch any standard outputs */
-        if(__fd == 0 || __fd == 1 || __fd == 2)
-            return(realconnect(__fd, __addr, __len));
+        // make sure we don't touch any standard outputs
+        if(fd == 0 || fd == 1 || fd == 2)
+            return(realconnect(fd, addr, addrlen));
         
-        if(__addr != NULL && (connaddr->sin_family == AF_LOCAL
+        if(addr != NULL && (connaddr->sin_family == AF_LOCAL
     #if defined(__linux__)
                               || connaddr->sin_family == PF_NETLINK
                               || connaddr->sin_family == AF_NETLINK
     #endif
                               || connaddr->sin_family == AF_UNIX)) {
-            return realconnect(__fd, __addr, __len);
+            return realconnect(fd, addr, addrlen);
         }
-        return zts_connect(__fd, __addr, __len);
+        return zts_connect(fd, addr, addrlen);
     }
 
     // ------------------------------------------------------------------------------
     // ------------------------------------ bind() ----------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, const struct sockaddr *addr, socklen_t addrlen
+    // int fd, const struct sockaddr *addr, socklen_t addrlen
 
     int bind(BIND_SIG)
     {
-        dwr(MSG_DEBUG,"bind(%d)\n", sockfd);
+        dwr(MSG_DEBUG,"bind(%d)\n", fd);
         // make sure we don't touch any standard outputs
-        if(sockfd == 0 || sockfd == 1 || sockfd == 2)
-            return(realbind(sockfd, addr, addrlen));
+        if(fd == 0 || fd == 1 || fd == 2)
+            return(realbind(fd, addr, addrlen));
         struct sockaddr_in *connaddr;
         connaddr = (struct sockaddr_in *)addr;
 
@@ -374,7 +372,7 @@ char *api_netpath;
            || connaddr->sin_family == AF_NETLINK
         #endif
            || connaddr->sin_family == AF_UNIX) {
-            int err = realbind(sockfd, addr, addrlen);
+            int err = realbind(fd, addr, addrlen);
             dwr(MSG_DEBUG,"realbind, err = %d\n", err);
             return err;
         }
@@ -389,132 +387,132 @@ char *api_netpath;
 
         int sock_type;
         socklen_t sock_type_len = sizeof(sock_type);
-        if(getsockopt(sockfd, SOL_SOCKET, SO_TYPE, (void *) &sock_type, &sock_type_len) < 0) {
+        if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *) &sock_type, &sock_type_len) < 0) {
             errno = ENOTSOCK;
             return -1;
         }
 
         // Otherwise, perform usual intercept logic
         if (!check_intercept_enabled())
-            return realbind(sockfd, addr, addrlen);
+            return realbind(fd, addr, addrlen);
 
         // Check that this is a valid fd
-        if(fcntl(sockfd, F_GETFD) < 0) {
+        if(fcntl(fd, F_GETFD) < 0) {
             errno = EBADF;
             return -1;
         }
         // Check that it is a socket
         int opt = -1;
         socklen_t opt_len;
-        if(getsockopt(sockfd, SOL_SOCKET, SO_TYPE, (void *) &opt, &opt_len) < 0) {
+        if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *) &opt, &opt_len) < 0) {
             errno = ENOTSOCK;
             return -1;
         }
-        return zts_bind(sockfd, addr, addrlen);
+        return zts_bind(fd, addr, addrlen);
     }
 
     // ------------------------------------------------------------------------------
     // ----------------------------------- accept4() --------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags
+    // int fd, struct sockaddr *addr, socklen_t *addrlen, int flags
 
 #if defined(__linux__)
     int accept4(ACCEPT4_SIG) {
-        dwr(MSG_DEBUG,"accept4(%d):\n", sockfd);
-        return zts_accept4(sockfd, addr, addrlen, flags);
+        dwr(MSG_DEBUG,"accept4(%d):\n", fd);
+        return zts_accept4(fd, addr, addrlen, flags);
     }
 #endif
 
     // ------------------------------------------------------------------------------
     // ----------------------------------- accept() ---------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd struct sockaddr *addr, socklen_t *addrlen
+    // int fd struct sockaddr *addr, socklen_t *addrlen
 
     int accept(ACCEPT_SIG) {
-        dwr(MSG_DEBUG,"accept(%d):\n", sockfd);
+        dwr(MSG_DEBUG,"accept(%d):\n", fd);
         if (!check_intercept_enabled())
-            return realaccept(sockfd, addr, addrlen);
+            return realaccept(fd, addr, addrlen);
 
-        /* Check that this is a valid fd */
-        if(fcntl(sockfd, F_GETFD) < 0) {
+        // Check that this is a valid fd
+        if(fcntl(fd, F_GETFD) < 0) {
             return -1;
             errno = EBADF;
             dwr(MSG_DEBUG,"EBADF\n");
             return -1;
         }
-        /* Check that it is a socket */
+        // Check that it is a socket
         int opt;
         socklen_t opt_len;
-        if(getsockopt(sockfd, SOL_SOCKET, SO_TYPE, (void *) &opt, &opt_len) < 0) {
+        if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *) &opt, &opt_len) < 0) {
             errno = ENOTSOCK;
             dwr(MSG_DEBUG,"ENOTSOCK\n");
             return -1;
         }
-        /* Check that this socket supports accept() */
+        // Check that this socket supports accept()
         if(!(opt && (SOCK_STREAM | SOCK_SEQPACKET))) {
             errno = EOPNOTSUPP;
             dwr(MSG_DEBUG,"EOPNOTSUPP\n");
             return -1;
         }
-        /* Check that we haven't hit the soft-limit file descriptors allowed */
+        // Check that we haven't hit the soft-limit file descriptors allowed
         struct rlimit rl;
         getrlimit(RLIMIT_NOFILE, &rl);
-        if(sockfd >= rl.rlim_cur){
+        if(fd >= rl.rlim_cur){
             errno = EMFILE;
             dwr(MSG_DEBUG,"EMFILE\n");
             return -1;
         }
-        /* Check address length */
+        // Check address length
         if(addrlen < 0) {
             errno = EINVAL;
             dwr(MSG_DEBUG,"EINVAL\n");
             return -1;
         }
-        /* redirect calls for standard I/O descriptors to kernel */
-        if(sockfd == 0 || sockfd == 1 || sockfd == 2){
+        // redirect calls for standard I/O descriptors to kernel
+        if(fd == 0 || fd == 1 || fd == 2){
             dwr(MSG_DEBUG,"realaccept():\n");
-            return(realaccept(sockfd, addr, addrlen));
+            return(realaccept(fd, addr, addrlen));
         }
 
-        return zts_accept(sockfd, addr, addrlen);
+        return zts_accept(fd, addr, addrlen);
     }
 
     // ------------------------------------------------------------------------------
     // ------------------------------------- listen()--------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, int backlog
+    // int fd, int backlog
 
     int listen(LISTEN_SIG)
     {
-        dwr(MSG_DEBUG,"listen(%d):\n", sockfd);
+        dwr(MSG_DEBUG,"listen(%d):\n", fd);
         if (!check_intercept_enabled())
-            return reallisten(sockfd, backlog);
+            return reallisten(fd, backlog);
         
         int sock_type;
         socklen_t sock_type_len = sizeof(sock_type);
-        /* Check that this is a valid fd */
-        if(fcntl(sockfd, F_GETFD) < 0) {
+        // Check that this is a valid fd
+        if(fcntl(fd, F_GETFD) < 0) {
             errno = EBADF;
             return -1;
         }
-        /* Check that it is a socket */
-        if(getsockopt(sockfd, SOL_SOCKET, SO_TYPE, (void *) &sock_type, &sock_type_len) < 0) {
+        // Check that it is a socket
+        if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *) &sock_type, &sock_type_len) < 0) {
             errno = ENOTSOCK;
             return -1;
         }
-        /* Check that this socket supports accept() */
+        // Check that this socket supports accept()
         if(!(sock_type && (SOCK_STREAM | SOCK_SEQPACKET))) {
             errno = EOPNOTSUPP;
             return -1;
         }
-        /* make sure we don't touch any standard outputs */
-        if(sockfd == 0 || sockfd == 1 || sockfd == 2)
-            return reallisten(sockfd, backlog);
+        // make sure we don't touch any standard outputs
+        if(fd == 0 || fd == 1 || fd == 2)
+            return reallisten(fd, backlog);
         
-        if(!connected_to_service(sockfd)) {
-            return reallisten(sockfd, backlog);
+        if(!connected_to_service(fd)) {
+            return reallisten(fd, backlog);
         }
-        return zts_listen(sockfd, backlog);
+        return zts_listen(fd, backlog);
     }
 
     // ------------------------------------------------------------------------------
@@ -533,26 +531,27 @@ char *api_netpath;
     // ------------------------------------------------------------------------------
     // -------------------------------- getsockname() -------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, struct sockaddr *addr, socklen_t *addrlen
+    // int fd, struct sockaddr *addr, socklen_t *addrlen
 
     int getsockname(GETSOCKNAME_SIG)
     {
-        dwr(MSG_DEBUG,"getsockname(%d):\n", sockfd);
+        dwr(MSG_DEBUG,"getsockname(%d):\n", fd);
     #if !defined(__IOS__)
         if (!check_intercept_enabled())
-            return realgetsockname(sockfd, addr, addrlen);
+            return realgetsockname(fd, addr, addrlen);
     #endif
-        dwr(MSG_DEBUG,"getsockname(%d)\n", sockfd);
-        if(!connected_to_service(sockfd)) {
+        dwr(MSG_DEBUG,"getsockname(%d)\n", fd);
+        if(!connected_to_service(fd)) {
             dwr(MSG_DEBUG,"getsockname(): not used by service\n");
-            return realgetsockname(sockfd, addr, addrlen);
+            return realgetsockname(fd, addr, addrlen);
         }
-        return zts_getsockname(sockfd, addr, addrlen);
+        return zts_getsockname(fd, addr, addrlen);
     }
 
     // ------------------------------------------------------------------------------
     // ------------------------------------ syscall() -------------------------------
     // ------------------------------------------------------------------------------
+    // long number, ...
 
 #if !defined(__ANDROID__)
 #if defined(__linux__)
diff --git a/src/SDK_RPC.c b/src/SDK_RPC.c
index dfe8329..98a6cad 100644
--- a/src/SDK_RPC.c
+++ b/src/SDK_RPC.c
@@ -175,7 +175,6 @@ int rpc_send_command(char *path, int cmd, int forfd, void *data, int len)
   memcpy(CANARY+CANARY_SZ, padding, sizeof(padding));
   uint64_t canary_num;
   // ephemeral RPC socket used only for this command
-  // TODO: Re-engineer RPC socket model for more efficiency
   int rpc_sock = rpc_join(path);
   // Generate token
   int fdrand = open("/dev/urandom", O_RDONLY);
diff --git a/src/SDK_RPC.h b/src/SDK_RPC.h
index ec817b6..1385577 100644
--- a/src/SDK_RPC.h
+++ b/src/SDK_RPC.h
@@ -89,17 +89,17 @@ void rpc_mutex_init();
 /* Structures used for sending commands via RPC mechanism */
 
 struct bind_st {
-	int sockfd;
+	int fd;
 	struct sockaddr_storage addr;
 	socklen_t addrlen;
-	int __tid;
+	int tid;
 };
 
 struct connect_st {
-	int __fd;
-	struct sockaddr_storage __addr;
-	socklen_t __len;
-	int __tid;
+	int fd;
+	struct sockaddr_storage addr;
+	socklen_t addrlen;
+	int tid;
 };
 
 struct close_st {
@@ -107,23 +107,23 @@ struct close_st {
 };
 
 struct listen_st {
-	int sockfd;
+	int fd;
 	int backlog;
-	int __tid;
+	int tid;
 };
 
 struct socket_st {
-  int socket_family;
-  int socket_type;
-  int protocol;
-	int __tid;
+	int socket_family;
+	int socket_type;
+	int protocol;
+	int tid;
 };
 
 struct accept_st {
-	int sockfd;
+	int fd;
 	struct sockaddr_storage addr;
 	socklen_t addrlen;
-	int __tid;
+	int tid;
 };
 
 struct shutdown_st {
@@ -132,7 +132,7 @@ struct shutdown_st {
 };
 
 struct getsockname_st {
-	int sockfd;
+	int fd;
 	struct sockaddr_storage addr;
 	socklen_t addrlen;
 };
diff --git a/src/SDK_Service.cpp b/src/SDK_Service.cpp
index ea809ca..54e512c 100644
--- a/src/SDK_Service.cpp
+++ b/src/SDK_Service.cpp
@@ -331,9 +331,7 @@ char *zts_get_homepath() {
 
 // Typically used on iOS/OSX 
 #if !defined(__ANDROID__)
-    /*
-     * Starts a service thread and performs basic setup tasks
-     */
+    // Starts a service thread and performs basic setup tasks
     void init_service(int key, const char * path) {
         givenHomeDir = path;
         pthread_key_create(&thr_id_key, NULL);
@@ -346,9 +344,7 @@ char *zts_get_homepath() {
         rpcNWID = nwid;
         init_service(key, path);
     }
-    /*
-     * Enables or disables intercept for current thread using key in thread-local storage
-     */
+    // Enables or disables intercept for current thread using key in thread-local storage
     void set_intercept_status(int mode) {
         #if defined(__APPLE__)
             fprintf(stderr, "set_intercept_status(mode=%d): tid = %d\n", mode, pthread_mach_thread_np(pthread_self()));
diff --git a/src/SDK_Signatures.h b/src/SDK_Signatures.h
index f82dbf1..7fc3bb3 100644
--- a/src/SDK_Signatures.h
+++ b/src/SDK_Signatures.h
@@ -30,29 +30,28 @@
 
 #include <sys/socket.h>
 
-#define SETSOCKOPT_SIG int socket, int level, int optname, const void *optval, socklen_t optlen
-#define GETSOCKOPT_SIG int sockfd, int level, int optname, void *optval, socklen_t *optlen
+#define SETSOCKOPT_SIG int fd, int level, int optname, const void *optval, socklen_t optlen
+#define GETSOCKOPT_SIG int fd, int level, int optname, void *optval, socklen_t *optlen
 
-#define SENDMSG_SIG int socket, const struct msghdr *message, int flags
-#define SENDTO_SIG int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t addr_len
-#define RECV_SIG int socket, void *buffer, size_t length, int flags
-#define RECVFROM_SIG int socket, void * buffer, size_t length, int flags, struct sockaddr * address, socklen_t * address_len
-#define RECVMSG_SIG int socket, struct msghdr *message,int flags
+#define SENDMSG_SIG int fd, const struct msghdr *msg, int flags
+#define SENDTO_SIG int fd, const void *buf, size_t len, int flags, const struct sockaddr *addr, socklen_t addrlen
+#define RECV_SIG int fd, void *buf, size_t len, int flags
+#define RECVFROM_SIG int fd, void *buf, size_t len, int flags, struct sockaddr *addr, socklen_t *addrlen
+#define RECVMSG_SIG int fd, struct msghdr *msg,int flags
 
-#define SEND_SIG int socket, const void *buffer, size_t length, int flags
-#define WRITE_SIG int __fd, const void *__buf, size_t __n
-#define RECV_SIG int socket, void *buffer, size_t length, int flags
-#define READ_SIG int __fd, void *__buf, size_t __nbytes
+#define SEND_SIG int fd, const void *buf, size_t len, int flags
+#define WRITE_SIG int fd, const void *buf, size_t len
+#define READ_SIG int fd, void *buf, size_t len
 
 #define SOCKET_SIG int socket_family, int socket_type, int protocol
-#define CONNECT_SIG int __fd, const struct sockaddr * __addr, socklen_t __len
-#define BIND_SIG int sockfd, const struct sockaddr *addr, socklen_t addrlen
-#define LISTEN_SIG int sockfd, int backlog
-#define ACCEPT4_SIG int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags
-#define ACCEPT_SIG int sockfd, struct sockaddr *addr, socklen_t *addrlen
+#define CONNECT_SIG int fd, const struct sockaddr *addr, socklen_t addrlen
+#define BIND_SIG int fd, const struct sockaddr *addr, socklen_t addrlen
+#define LISTEN_SIG int fd, int backlog
+#define ACCEPT4_SIG int fd, struct sockaddr *addr, socklen_t *addrlen, int flags
+#define ACCEPT_SIG int fd, struct sockaddr *addr, socklen_t *addrlen
 #define CLOSE_SIG int fd
-#define GETSOCKNAME_SIG int sockfd, struct sockaddr *addr, socklen_t *addrlen
-#define GETPEERNAME_SIG int sockfd, struct sockaddr *addr, socklen_t *addrlen
+#define GETSOCKNAME_SIG int fd, struct sockaddr *addr, socklen_t *addrlen
+#define GETPEERNAME_SIG int fd, struct sockaddr *addr, socklen_t *addrlen
 #define FCNTL_SIG int fd, int cmd, int flags
 #define SYSCALL_SIG long number, ...
 
diff --git a/src/SDK_Sockets.c b/src/SDK_Sockets.c
index 533e487..cda1e59 100644
--- a/src/SDK_Sockets.c
+++ b/src/SDK_Sockets.c
@@ -125,7 +125,7 @@ int (*realclose)(CLOSE_SIG);
     // ------------------------------------------------------------------------------
     // ------------------------------------ send() ----------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, const void *buf, size_t len
+    // int fd, const void *buf, size_t len
 
 #if defined(__ANDROID__)
     JNIEXPORT jint JNICALL Java_ZeroTier_SDK_zt_1send(JNIEnv *env, jobject thisObj, jint fd, jarray buf, jint len, int flags)
@@ -142,8 +142,8 @@ int (*realclose)(CLOSE_SIG);
     // ------------------------------------------------------------------------------
     // ------------------------------------ sendto() --------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, const void *buf, size_t len, int flags, 
-    // const struct sockaddr *addr, socklen_t addr_len
+    // int fd, const void *buf, size_t len, int flags, 
+    // const struct sockaddr *addr, socklen_t addrlen
 
 #if defined(__ANDROID__)
     // TODO: Check result of each JNI call
@@ -177,14 +177,14 @@ int (*realclose)(CLOSE_SIG);
         ssize_t zts_sendto(SENDTO_SIG) // Used as internal implementation 
     #endif
         {
-            dwr(MSG_DEBUG_EXTRA, "zt_sendto(%d, ...)\n", sockfd);
+            dwr(MSG_DEBUG_EXTRA, "zt_sendto(%d, ...)\n", fd);
             if(len > ZT_UDP_DEFAULT_PAYLOAD_MTU) {
                 errno = EMSGSIZE; // Msg is too large
                 return -1;
             }
             int socktype = 0;
             socklen_t socktype_len;
-            getsockopt(sockfd,SOL_SOCKET, SO_TYPE, (void*)&socktype, &socktype_len);
+            getsockopt(fd,SOL_SOCKET, SO_TYPE, (void*)&socktype, &socktype_len);
 
             if((socktype & SOCK_STREAM) || (socktype & SOCK_SEQPACKET)) {
                 if(addr == NULL || flags != 0) {
@@ -197,19 +197,19 @@ int (*realclose)(CLOSE_SIG);
             // TODO: More efficient solution
             // This connect call is used to get the address info to the stack for sending the packet
             int err;
-            if((err = zts_connect(sockfd, addr, addr_len)) < 0) {
+            if((err = zts_connect(fd, addr, addrlen)) < 0) {
                 LOGV("sendto(): unknown problem passing address info to stack\n");
                 errno = EISCONN; // double-check this is correct
                 return -1;
             }
-            return write(sockfd, buf, len);
+            return write(fd, buf, len);
         }
 //#endif
 
     // ------------------------------------------------------------------------------
     // ----------------------------------- sendmsg() --------------------------------
     // ------------------------------------------------------------------------------
-    // int socket, const struct msghdr *message, int flags
+    // int fd, const struct msghdr *msg, int flags
 
 #if !defined(__ANDROID__)
     #ifdef DYNAMIC_LIB
@@ -218,12 +218,12 @@ int (*realclose)(CLOSE_SIG);
         ssize_t zts_sendmsg(SENDMSG_SIG)
     #endif
         {
-            dwr(MSG_DEBUG_EXTRA, "zt_sendmsg()\n");
+            dwr(MSG_DEBUG_EXTRA, "zt_sendmsg(%d)\n", fd);
             char * p, * buf;
             size_t tot_len = 0;
             size_t err;
-            struct iovec * iov = message->msg_iov;
-            for(int i=0; i<message->msg_iovlen; ++i)
+            struct iovec * iov = msg->msg_iov;
+            for(int i=0; i<msg->msg_iovlen; ++i)
                 tot_len += iov[i].iov_len;
             if(tot_len > ZT_UDP_DEFAULT_PAYLOAD_MTU) {
                 errno = EMSGSIZE; // Message too large to send atomically via underlying protocol, don't send
@@ -235,11 +235,11 @@ int (*realclose)(CLOSE_SIG);
                 return -1;
             }
             p = buf;
-            for(int i=0; i < message->msg_iovlen; ++i) {
+            for(int i=0; i < msg->msg_iovlen; ++i) {
                 memcpy(p, iov[i].iov_base, iov[i].iov_len);
                 p += iov[i].iov_len;
             }
-            err = sendto(socket, buf, tot_len, flags, message->msg_name, message->msg_namelen);
+            err = sendto(fd, buf, tot_len, flags, msg->msg_name, msg->msg_namelen);
             free(buf);
             return err;
         }
@@ -248,8 +248,8 @@ int (*realclose)(CLOSE_SIG);
     // ------------------------------------------------------------------------------
     // ---------------------------------- recvfrom() --------------------------------
     // ------------------------------------------------------------------------------
-    // int socket, void *restrict buffer, size_t length, int flags, struct sockaddr
-    // *restrict address, socklen_t *restrict address_len
+    // int fd, void *restrict buf, size_t len, int flags, struct sockaddr
+    // *restrict addr, socklen_t *restrict addrlen
 
 #if defined(__ANDROID__)
     // UDP RX
@@ -283,11 +283,11 @@ int (*realclose)(CLOSE_SIG);
     #endif
         {
             int tmpsz = 0; // payload size
-            // dwr(MSG_DEBUG_EXTRA,"zt_recvfrom(%d, ...)\n", socket);
-            if(read(socket, buffer, ZT_MAX_MTU) > 0) {
+            // dwr(MSG_DEBUG_EXTRA,"zt_recvfrom(%d, ...)\n", fd);
+            if(read(fd, buf, ZT_MAX_MTU) > 0) {
                 // TODO: case for address size mismatch?
-                memcpy(address, buffer, address_len);
-                memcpy(&tmpsz, buffer + sizeof(struct sockaddr_storage), sizeof(tmpsz));
+                memcpy(addr, buf, addrlen);
+                memcpy(&tmpsz, buf + sizeof(struct sockaddr_storage), sizeof(tmpsz));
             }
             else {
                 perror("read:\n");
@@ -299,7 +299,7 @@ int (*realclose)(CLOSE_SIG);
     // ------------------------------------------------------------------------------
     // ----------------------------------- recvmsg() --------------------------------
     // ------------------------------------------------------------------------------
-    // int socket, struct msghdr *message, int flags
+    // int fd, struct msghdr *msg, int flags
 
 #if !defined(__ANDROID__)
     #ifdef DYNAMIC_LIB
@@ -308,25 +308,25 @@ int (*realclose)(CLOSE_SIG);
         ssize_t zts_recvmsg(RECVMSG_SIG)
     #endif
         {
-            dwr(MSG_DEBUG_EXTRA, "zt_recvmsg(%d)\n", socket);
+            dwr(MSG_DEBUG_EXTRA, "zt_recvmsg(%d)\n", fd);
             ssize_t err, n, tot_len = 0;
             char *buf, *p;
-            struct iovec *iov = message->msg_iov;
+            struct iovec *iov = msg->msg_iov;
             
-            for(int i = 0; i < message->msg_iovlen; ++i)
+            for(int i = 0; i < msg->msg_iovlen; ++i)
                 tot_len += iov[i].iov_len;
             buf = malloc(tot_len);
             if(tot_len != 0 && buf == NULL) {
                 errno = ENOMEM;
                 return -1;
             }
-            n = err = recvfrom(socket, buf, tot_len, flags, message->msg_name, &message->msg_namelen);
+            n = err = recvfrom(fd, buf, tot_len, flags, msg->msg_name, &msg->msg_namelen);
             p = buf;
             
             // According to: http://pubs.opengroup.org/onlinepubs/009695399/functions/recvmsg.html
-            if(err > message->msg_controllen && !( message->msg_flags & MSG_PEEK)) {
+            if(err > msg->msg_controllen && !( msg->msg_flags & MSG_PEEK)) {
                 // excess data should be disgarded
-                message->msg_flags |= MSG_TRUNC; // Indicate that the buffer has been truncated
+                msg->msg_flags |= MSG_TRUNC; // Indicate that the buffer has been truncated
             }
             
             while (n > 0) {
@@ -388,8 +388,7 @@ int (*realclose)(CLOSE_SIG);
     // ------------------------------------------------------------------------------
     // --------------------------------- setsockopt() -------------------------------
     // ------------------------------------------------------------------------------
-    // int socket, int level, int option_name, const void *option_value, 
-    // socklen_t option_len
+    // int fd, int level, int optname, const void *optval, socklen_t optlen
 
 #if defined(__ANDROID__)
 	JNIEXPORT jint JNICALL Java_ZeroTier_SDK_zt_1setsockopt(
@@ -404,15 +403,14 @@ int (*realclose)(CLOSE_SIG);
     int zts_setsockopt(SETSOCKOPT_SIG)
     #endif
     {
-        dwr(MSG_DEBUG, "zt_setsockopt()\n");
+        dwr(MSG_DEBUG, "zt_setsockopt(%d)\n", fd);
         return 0;
     }
     
     // ------------------------------------------------------------------------------
     // --------------------------------- getsockopt() -------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, int level, int optname, void *optval, 
-    // socklen_t *optlen 
+    // int fd, int level, int optname, void *optval, socklen_t *optlen 
 
 #if defined(__ANDROID__)
 	JNIEXPORT jint JNICALL Java_ZeroTier_SDK_zt_1getsockopt(
@@ -427,7 +425,7 @@ int (*realclose)(CLOSE_SIG);
     int zts_getsockopt(GETSOCKOPT_SIG)
 #endif
     {
-        dwr(MSG_DEBUG,"zt_getsockopt(%d)\n", sockfd);
+        dwr(MSG_DEBUG,"zt_getsockopt(%d)\n", fd);
         if(optname == SO_TYPE) {
             int* val = (int*)optval;
             *val = 2;
@@ -455,7 +453,7 @@ int (*realclose)(CLOSE_SIG);
     {
         get_api_netpath();
         dwr(MSG_DEBUG, "zt_socket()\n");
-        /* Check that type makes sense */
+        // Check that type makes sense
 #if defined(__linux__)
         int flags = socket_type & ~SOCK_TYPE_MASK;
     #if !defined(__ANDROID__)
@@ -466,7 +464,7 @@ int (*realclose)(CLOSE_SIG);
     #endif
 #endif
         socket_type &= SOCK_TYPE_MASK;
-        /* Check protocol is in range */
+        // Check protocol is in range
 #if defined(__linux__)
         if (socket_family < 0 || socket_family >= NPROTO){
             errno = EAFNOSUPPORT;
@@ -477,19 +475,19 @@ int (*realclose)(CLOSE_SIG);
             return -1;
         }
 #endif
-        /* Assemble and send RPC */
+        // Assemble and send RPC
         struct socket_st rpc_st;
         rpc_st.socket_family = socket_family;
         rpc_st.socket_type = socket_type;
         rpc_st.protocol = protocol;
 #if defined(__linux__)
     #if !defined(__ANDROID__)
-        rpc_st.__tid = 5; //syscall(SYS_gettid);
+        rpc_st.tid = 5; //syscall(SYS_gettid);
     #else
-        rpc_st.__tid = gettid(); // dummy value
+        rpc_st.tid = gettid(); // dummy value
     #endif
 #endif
-        /* -1 is passed since we we're generating the new socket in this call */
+        // -1 is passed since we we're generating the new socket in this call
         printf("api_netpath = %s\n", api_netpath);
         int err = rpc_send_command(api_netpath, RPC_SOCKET, -1, &rpc_st, sizeof(struct socket_st));
         dwr(MSG_DEBUG," socket() = %d\n", err);
@@ -499,7 +497,7 @@ int (*realclose)(CLOSE_SIG);
     // ------------------------------------------------------------------------------
     // ---------------------------------- connect() ---------------------------------
     // ------------------------------------------------------------------------------
-    // int __fd, const struct sockaddr * __addr, socklen_t __len
+    // int fd, const struct sockaddr *addr, socklen_t addrlen
 
 #if defined(__ANDROID__)
     JNIEXPORT jint JNICALL Java_ZeroTier_SDK_zt_1connect(JNIEnv *env, jobject thisObj, jint fd, jstring addrstr, jint port) {
@@ -521,25 +519,25 @@ int (*realclose)(CLOSE_SIG);
 #endif
     {
         get_api_netpath();
-        dwr(MSG_DEBUG,"zt_connect(%d)\n", __fd);
+        dwr(MSG_DEBUG,"zt_connect(%d)\n", fd);
         struct connect_st rpc_st;
 #if defined(__linux__)
     #if !defined(__ANDROID__)
-        //rpc_st.__tid = syscall(SYS_gettid);
+        //rpc_st.tid = syscall(SYS_gettid);
     #else
-        //rpc_st.__tid = gettid(); // dummy value
+        //rpc_st.tid = gettid(); // dummy value
     #endif
 #endif
-        rpc_st.__fd = __fd;
-        memcpy(&rpc_st.__addr, __addr, sizeof(struct sockaddr_storage));
-        memcpy(&rpc_st.__len, &__len, sizeof(socklen_t));
-        return rpc_send_command(api_netpath, RPC_CONNECT, __fd, &rpc_st, sizeof(struct connect_st));
+        rpc_st.fd = fd;
+        memcpy(&rpc_st.addr, addr, sizeof(struct sockaddr_storage));
+        memcpy(&rpc_st.addrlen, &addrlen, sizeof(socklen_t));
+        return rpc_send_command(api_netpath, RPC_CONNECT, fd, &rpc_st, sizeof(struct connect_st));
     }
     
     // ------------------------------------------------------------------------------
     // ------------------------------------ bind() ----------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, const struct sockaddr *addr, socklen_t addrlen
+    // int fd, const struct sockaddr *addr, socklen_t addrlen
 
 #if defined(__ANDROID__)
     JNIEXPORT jint JNICALL Java_ZeroTier_SDK_zt_1bind(JNIEnv *env, jobject thisObj, jint fd, jstring addrstr, jint port) {
@@ -561,26 +559,26 @@ int (*realclose)(CLOSE_SIG);
 #endif
     {
         get_api_netpath();
-        dwr(MSG_DEBUG,"zt_bind(%d)\n", sockfd);
+        dwr(MSG_DEBUG,"zt_bind(%d)\n", fd);
         struct bind_st rpc_st;
-        rpc_st.sockfd = sockfd;
+        rpc_st.fd = fd;
 #if defined(__linux__)
     #if !defined(__ANDROID__)
         // TODO: Candidate for removal
-        rpc_st.__tid = 5;//syscall(SYS_gettid);
+        rpc_st.tid = 5;//syscall(SYS_gettid);
     #else
-        rpc_st.__tid = gettid(); // dummy value
+        rpc_st.tid = gettid(); // dummy value
     #endif
 #endif
         memcpy(&rpc_st.addr, addr, sizeof(struct sockaddr_storage));
         memcpy(&rpc_st.addrlen, &addrlen, sizeof(socklen_t));
-        return rpc_send_command(api_netpath, RPC_BIND, sockfd, &rpc_st, sizeof(struct bind_st));
+        return rpc_send_command(api_netpath, RPC_BIND, fd, &rpc_st, sizeof(struct bind_st));
     }
 
     // ------------------------------------------------------------------------------
     // ----------------------------------- accept4() --------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags
+    // int fd, struct sockaddr *addr, socklen_t *addrlen, int flags
 
 #if defined(__ANDROID__)
     JNIEXPORT jint JNICALL Java_ZeroTier_SDK_zt_1accept4(JNIEnv *env, jobject thisObj, jint fd, jstring addrstr, jint port, jint flags) {
@@ -603,22 +601,22 @@ int (*realclose)(CLOSE_SIG);
     #endif
         {
             get_api_netpath();
-            dwr(MSG_DEBUG,"zt_accept4(%d):\n", sockfd);
+            dwr(MSG_DEBUG,"zt_accept4(%d):\n", fd);
         #if !defined(__ANDROID__)
             if ((flags & SOCK_CLOEXEC))
-                fcntl(sockfd, F_SETFL, FD_CLOEXEC);
+                fcntl(fd, F_SETFL, FD_CLOEXEC);
             if ((flags & SOCK_NONBLOCK))
-               fcntl(sockfd, F_SETFL, O_NONBLOCK);
+               fcntl(fd, F_SETFL, O_NONBLOCK);
         #endif
             int len = !addr ? 0 : addrlen;
-            return accept(sockfd, addr, len);
+            return accept(fd, addr, len);
         }
 #endif
     
     // ------------------------------------------------------------------------------
     // ----------------------------------- accept() ---------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd struct sockaddr *addr, socklen_t *addrlen
+    // int fd struct sockaddr *addr, socklen_t *addrlen
 
 #if defined(__ANDROID__)
     JNIEXPORT jint JNICALL Java_ZeroTier_SDK_zt_1accept(JNIEnv *env, jobject thisObj, jint fd, jstring addrstr, jint port) {
@@ -638,13 +636,13 @@ int (*realclose)(CLOSE_SIG);
 #endif
     {
         get_api_netpath();
-        dwr(MSG_DEBUG,"zt_accept(%d):\n", sockfd);
+        dwr(MSG_DEBUG,"zt_accept(%d):\n", fd);
     // FIXME: Find a better solution for this before production
     #if !defined(__UNITY_3D__)
         if(addr)
             addr->sa_family = AF_INET;
     #endif
-        int new_fd = get_new_fd(sockfd);
+        int new_fd = get_new_fd(fd);
         dwr(MSG_DEBUG,"newfd = %d\n", new_fd);
 
         if(new_fd > 0) {
@@ -658,7 +656,7 @@ int (*realclose)(CLOSE_SIG);
     // ------------------------------------------------------------------------------
     // ------------------------------------- listen()--------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, int backlog
+    // int fd, int backlog
 
 #if defined(__ANDROID__)
     JNIEXPORT jint JNICALL Java_ZeroTier_SDK_zt_1listen(JNIEnv *env, jobject thisObj, jint fd, int backlog) {
@@ -673,18 +671,18 @@ int (*realclose)(CLOSE_SIG);
 #endif
     {
         get_api_netpath();
-        dwr(MSG_DEBUG,"zt_listen(%d):\n", sockfd);
+        dwr(MSG_DEBUG,"zt_listen(%d):\n", fd);
         struct listen_st rpc_st;
-        rpc_st.sockfd = sockfd;
+        rpc_st.fd = fd;
         rpc_st.backlog = backlog;
 #if defined(__linux__)
     #if !defined(__ANDROID__)
-        rpc_st.__tid = syscall(SYS_gettid);
+        rpc_st.tid = syscall(SYS_gettid);
     #else
-        rpc_st.__tid = gettid(); // dummy value
+        rpc_st.tid = gettid(); // dummy value
     #endif
 #endif
-        return rpc_send_command(api_netpath, RPC_LISTEN, sockfd, &rpc_st, sizeof(struct listen_st));
+        return rpc_send_command(api_netpath, RPC_LISTEN, fd, &rpc_st, sizeof(struct listen_st));
     }
     
     // ------------------------------------------------------------------------------
@@ -712,7 +710,7 @@ int (*realclose)(CLOSE_SIG);
     // ------------------------------------------------------------------------------
     // -------------------------------- getsockname() -------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, struct sockaddr *addr, socklen_t *addrlen
+    // int fd, struct sockaddr *addr, socklen_t *addrlen
     
 #if defined(__ANDROID__)
     JNIEXPORT jint JNICALL Java_ZeroTier_SDK_zt_1getsockname(JNIEnv *env, jobject thisObj, jint fd, jobject ztaddr) {
@@ -735,11 +733,11 @@ int (*realclose)(CLOSE_SIG);
 #endif
     {
         get_api_netpath();
-        dwr(MSG_DEBUG_EXTRA,"zt_getsockname(%d):\n", sockfd);
+        dwr(MSG_DEBUG_EXTRA,"zt_getsockname(%d):\n", fd);
         struct getsockname_st rpc_st;
-        rpc_st.sockfd = sockfd;
+        rpc_st.fd = fd;
         memcpy(&rpc_st.addrlen, &addrlen, sizeof(socklen_t));
-        int rpcfd = rpc_send_command(api_netpath, RPC_GETSOCKNAME, sockfd, &rpc_st, sizeof(struct getsockname_st));
+        int rpcfd = rpc_send_command(api_netpath, RPC_GETSOCKNAME, fd, &rpc_st, sizeof(struct getsockname_st));
         // read address info from service
         char addrbuf[sizeof(struct sockaddr_storage)];
         memset(&addrbuf, 0, sizeof(struct sockaddr_storage));
@@ -774,7 +772,7 @@ int (*realclose)(CLOSE_SIG);
     // ------------------------------------------------------------------------------
     // -------------------------------- getpeername() -------------------------------
     // ------------------------------------------------------------------------------
-    // int sockfd, struct sockaddr *addr, socklen_t *addrlen
+    // int fd, struct sockaddr *addr, socklen_t *addrlen
     
 #if defined(__ANDROID__)
     JNIEXPORT jint JNICALL Java_ZeroTier_SDK_zt_1getpeername(JNIEnv *env, jobject thisObj, jint fd, jobject ztaddr) {
@@ -797,11 +795,11 @@ int (*realclose)(CLOSE_SIG);
 #endif
     {
         get_api_netpath();
-        dwr(MSG_DEBUG_EXTRA,"zt_getpeername(%d):\n", sockfd);
+        dwr(MSG_DEBUG_EXTRA,"zt_getpeername(%d):\n", fd);
         struct getsockname_st rpc_st;
-        rpc_st.sockfd = sockfd;
+        rpc_st.fd = fd;
         memcpy(&rpc_st.addrlen, &addrlen, sizeof(socklen_t));
-        int rpcfd = rpc_send_command(api_netpath, RPC_GETPEERNAME, sockfd, &rpc_st, sizeof(struct getsockname_st));
+        int rpcfd = rpc_send_command(api_netpath, RPC_GETPEERNAME, fd, &rpc_st, sizeof(struct getsockname_st));
         // read address info from service
         char addrbuf[sizeof(struct sockaddr_storage)];
         memset(&addrbuf, 0, sizeof(struct sockaddr_storage));
diff --git a/src/SDK_XcodeWrapper.hpp b/src/SDK_XcodeWrapper.hpp
index ef9d3a4..6c6722e 100755
--- a/src/SDK_XcodeWrapper.hpp
+++ b/src/SDK_XcodeWrapper.hpp
@@ -28,4 +28,4 @@
 #ifndef SDK_XCODE_WRAPPER_HPP
 #define SDK_XCODE_WRAPPER_HPP
 
-#endif /* SDK_XCODE_WRAPPER_HPP */
+#endif // SDK_XCODE_WRAPPER_HPP
diff --git a/src/SDK_ZTAddress.java b/src/SDK_ZTAddress.java
index b347dbb..20ad61c 100644
--- a/src/SDK_ZTAddress.java
+++ b/src/SDK_ZTAddress.java
@@ -6,12 +6,7 @@ import java.net.InetSocketAddress;
 import java.net.UnknownHostException;
 import java.util.regex.Pattern;
 
-/* 
-
-The ZTAddress object is merely a convenience object for moving address information
-across the JNI memory border. 
-
-*/
+// A convenience object for moving address information across the JNI memory border. 
 
 public class ZTAddress
 {
diff --git a/zerotierone/make-mac.mk b/zerotierone/make-mac.mk
index f14f340..1588c5a 100644
--- a/zerotierone/make-mac.mk
+++ b/zerotierone/make-mac.mk
@@ -68,7 +68,7 @@ else
 endif
 
 # Debug output for Network Containers 
-# Specific levels can be controlled in netcon/common.inc.c
+# Specific levels can be controlled in src/SDK_Debug.h
 ifeq ($(SDK_DEBUG),1)
 	DEFS+=-DSDK_DEBUG
 endif