Expose address getters (#14)

Author: yassernasc

binding.c

@@ -598,29 +598,7 @@ bare_tcp_bind(js_env_t *env, js_callback_info_t *info) {
     return NULL;
   }
 
-  struct sockaddr_storage name;
-  err = uv_tcp_getsockname(&tcp->handle, (struct sockaddr *) &name, &addr_len);
-
-  if (err < 0) {
-    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
-    assert(err == 0);
-
-    return NULL;
-  }
-
-  int local_port;
-
-  if (family == 4) {
-    local_port = ntohs(((struct sockaddr_in *) &name)->sin_port);
-  } else {
-    local_port = ntohs(((struct sockaddr_in6 *) &name)->sin6_port);
-  }
-
-  js_value_t *res;
-  err = js_create_uint32(env, local_port, &res);
-  assert(err == 0);
-
-  return res;
+  return NULL;
 }
 
 static js_value_t *
@@ -871,6 +849,101 @@ bare_tcp_nodelay(js_env_t *env, js_callback_info_t *info) {
   return NULL;
 }
 
+static js_value_t *
+bare_tcp_address(js_env_t *env, js_callback_info_t *info) {
+  int err;
+
+  size_t argc = 2;
+  js_value_t *argv[2];
+
+  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 2);
+
+  bare_tcp_t *tcp;
+  err = js_get_arraybuffer_info(env, argv[0], (void **) &tcp, NULL);
+  assert(err == 0);
+
+  bool local;
+  err = js_get_value_bool(env, argv[1], &local);
+  assert(err == 0);
+
+  struct sockaddr_storage addr;
+  int len = sizeof(addr);
+
+  if (local) {
+    err = uv_tcp_getsockname(&tcp->handle, (struct sockaddr *) &addr, &len);
+  } else {
+    err = uv_tcp_getpeername(&tcp->handle, (struct sockaddr *) &addr, &len);
+  }
+
+  if (err < 0) {
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  js_value_t *result;
+  err = js_create_object(env, &result);
+  assert(err == 0);
+
+  js_value_t *result_address;
+  js_value_t *result_family;
+  js_value_t *result_port;
+
+  if (addr.ss_family == AF_INET) {
+    struct sockaddr_in *addr_in = (struct sockaddr_in *) &addr;
+
+    char address[INET_ADDRSTRLEN];
+    err = uv_inet_ntop(AF_INET, &(addr_in->sin_addr), address, sizeof(address));
+    assert(err == 0);
+
+    err = js_create_string_utf8(env, (utf8_t *) address, -1, &result_address);
+    assert(err == 0);
+
+    err = js_create_int32(env, 4, &result_family);
+    assert(err == 0);
+
+    err = js_create_int32(env, ntohs(addr_in->sin_port), &result_port);
+    assert(err == 0);
+  } else if (addr.ss_family == AF_INET6) {
+    struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *) &addr;
+
+    char address[INET6_ADDRSTRLEN];
+    err = uv_inet_ntop(AF_INET6, &(addr_in6->sin6_addr), address, sizeof(address));
+    assert(err == 0);
+
+    err = js_create_string_utf8(env, (utf8_t *) address, -1, &result_address);
+    assert(err == 0);
+
+    err = js_create_int32(env, 6, &result_family);
+    assert(err == 0);
+
+    err = js_create_int32(env, ntohs(addr_in6->sin6_port), &result_port);
+    assert(err == 0);
+  } else {
+    err = UV_EAI_ADDRFAMILY;
+
+    err = js_throw_error(env, uv_err_name(err), uv_strerror(err));
+    assert(err == 0);
+
+    return NULL;
+  }
+
+  err = js_set_named_property(env, result, "address", result_address);
+  assert(err == 0);
+
+  err = js_set_named_property(env, result, "family", result_family);
+  assert(err == 0);
+
+  err = js_set_named_property(env, result, "port", result_port);
+  assert(err == 0);
+
+  return result;
+}
+
 static js_value_t *
 bare_tcp_ref(js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -938,6 +1011,7 @@ bare_tcp_exports(js_env_t *env, js_value_t *exports) {
   V("close", bare_tcp_close)
   V("keepalive", bare_tcp_keepalive)
   V("nodelay", bare_tcp_nodelay)
+  V("address", bare_tcp_address)
   V("ref", bare_tcp_ref)
   V("unref", bare_tcp_unref)
 #undef V

index.d.ts

@@ -45,6 +45,12 @@ interface TCPSocket<M extends TCPSocketEvents = TCPSocketEvents> extends Duplex<
   readonly pending: boolean
   readonly timeout?: number
   readonly readyState: 'open' | 'opening'
+  readonly localAddress?: string
+  readonly localFamily?: string
+  readonly localPort?: number
+  readonly remoteAddress?: string
+  readonly remoteFamily?: string
+  readonly remotePort?: number
 
   connect(port: number, host?: string, opts?: TCPSocketConnectOptions, onconnect?: () => void): this
   connect(port: number, host: string, onconnect: () => void): this

index.js

@@ -19,9 +19,8 @@ exports.Socket = class TCPSocket extends Duplex {
 
     this._allowHalfOpen = allowHalfOpen
 
-    this._remotePort = -1
-    this._remoteHost = null
-    this._remoteFamily = 0
+    this._localAddress = null
+    this._remoteAddress = null
 
     this._pendingOpen = null
     this._pendingWrite = null
@@ -69,6 +68,30 @@ exports.Socket = class TCPSocket extends Duplex {
     return 'opening'
   }
 
+  get localAddress() {
+    if (this._state & constants.state.CONNECTED) return this._localAddress.address
+  }
+
+  get localFamily() {
+    if (this._state & constants.state.CONNECTED) return `IPv${this._localAddress.family}`
+  }
+
+  get localPort() {
+    if (this._state & constants.state.CONNECTED) return this._localAddress.port
+  }
+
+  get remoteAddress() {
+    if (this._state & constants.state.CONNECTED) return this._remoteAddress.address
+  }
+
+  get remoteFamily() {
+    if (this._state & constants.state.CONNECTED) return `IPv${this._remoteAddress.family}`
+  }
+
+  get remotePort() {
+    if (this._state & constants.state.CONNECTED) return this._remoteAddress.port
+  }
+
   connect(port, host = 'localhost', opts = {}, onconnect) {
     if (this._state & constants.state.CONNECTING || this._state & constants.state.CONNECTED) {
       throw errors.SOCKET_ALREADY_CONNECTED('Socket is already connected')
@@ -152,10 +175,6 @@ exports.Socket = class TCPSocket extends Duplex {
       if (noDelay) this.setNoDelay()
       if (timeout) this.setTimeout(timeout)
 
-      this._remotePort = port
-      this._remoteHost = host
-      this._remoteFamily = family
-
       if (onconnect) this.once('connect', onconnect)
     } catch (err) {
       queueMicrotask(() => {
@@ -293,6 +312,9 @@ exports.Socket = class TCPSocket extends Duplex {
   _reset() {
     this._state = 0
 
+    this._localAddress = null
+    this._remoteAddress = null
+
     binding.reset(this._handle)
   }
 
@@ -315,6 +337,9 @@ exports.Socket = class TCPSocket extends Duplex {
     this._state &= ~constants.state.CONNECTING
     this._continueOpen()
 
+    this._localAddress = binding.address(this._handle, true)
+    this._remoteAddress = binding.address(this._handle, false)
+
     this.emit('connect')
   }
 
@@ -396,9 +421,7 @@ exports.Server = class TCPServer extends EventEmitter {
     this._noDelay = noDelay
     this._pauseOnConnect = pauseOnConnect
 
-    this._port = -1
-    this._host = null
-    this._family = 0
+    this._address = null
     this._connections = new Set()
 
     this._error = null
@@ -420,15 +443,11 @@ exports.Server = class TCPServer extends EventEmitter {
   }
 
   address() {
-    if ((this._state & constants.state.BOUND) === 0) {
-      return null
-    }
+    if ((this._state & constants.state.BOUND) === 0) return null
 
-    return {
-      address: this._host,
-      family: `IPv${this._family}`,
-      port: this._port
-    }
+    const { address, family, port } = this._address
+
+    return { address, family: `IPv${family}`, port }
   }
 
   listen(port = 0, host = 'localhost', backlog = 511, opts = {}, onlistening) {
@@ -506,9 +525,10 @@ exports.Server = class TCPServer extends EventEmitter {
     if (this._state & constants.state.UNREFED) binding.unref(this._handle)
 
     try {
-      this._port = binding.bind(this._handle, port, host, backlog, family)
-      this._host = host
-      this._family = family
+      binding.bind(this._handle, port, host, backlog, family)
+
+      this._address = binding.address(this._handle, true)
+
       this._state |= constants.state.BOUND
       this._state &= ~constants.state.BINDING
 
@@ -577,6 +597,9 @@ exports.Server = class TCPServer extends EventEmitter {
 
       socket._state |= constants.state.CONNECTED
 
+      socket._localAddress = binding.address(socket._handle, true)
+      socket._remoteAddress = binding.address(socket._handle, false)
+
       this._connections.add(socket)
 
       if (this._keepAlive) socket.setKeepAlive(this._keepAlive, this._keepAliveInitialDelay)
@@ -601,6 +624,7 @@ exports.Server = class TCPServer extends EventEmitter {
     this._state &= ~constants.state.BINDING
     this._error = null
     this._handle = null
+    this._address = null
 
     if (err) this.emit('error', err)
     else this.emit('close')

package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-tcp",
-  "version": "2.2.2",
+  "version": "2.2.2-0",
   "description": "Native TCP sockets for JavaScript",
   "exports": {
     ".": {

test.js

@@ -79,6 +79,44 @@ test('socket state getters', async (t) => {
   server.close()
 })
 
+test('address getters', async (t) => {
+  t.plan(14)
+
+  const server = createServer()
+    .on('connection', (socket) => {
+      t.is(socket.localAddress, '127.0.0.1')
+      t.is(socket.localFamily, 'IPv4')
+      t.is(typeof socket.localPort, 'number')
+
+      t.is(socket.remoteAddress, '127.0.0.1')
+      t.is(socket.remoteFamily, 'IPv4')
+      t.is(typeof socket.remotePort, 'number')
+
+      t.ok(socket.localPort !== socket.remotePort)
+
+      socket.on('close', () => server.close()).end()
+    })
+    .listen(0, '127.0.0.1')
+
+  await waitForServer(server)
+
+  const { port: serverPort } = server.address()
+
+  const socket = createConnection(serverPort)
+    .on('connect', () => {
+      t.is(socket.localAddress, '127.0.0.1')
+      t.is(socket.localFamily, 'IPv4')
+      t.is(typeof socket.localPort, 'number')
+
+      t.is(socket.remoteAddress, '127.0.0.1')
+      t.is(socket.remoteFamily, 'IPv4')
+      t.is(socket.remotePort, serverPort)
+
+      t.ok(socket.localPort !== socket.remotePort)
+    })
+    .end()
+})
+
 test('port already in use', async (t) => {
   t.plan(1)