unix socket support

examples/dataStream.nim

@@ -60,7 +60,7 @@ when isMainModule:
       await sendFut
 
   proc main() {.async.} =
-    var client = newClient(localHost, localPort)
+    var client = newClient(localHost, localPort, ssl = false, domain = hyxUnix)
     with client:
       await streamChunks(client, "/foo")
 

examples/localServer.nim

@@ -7,8 +7,8 @@ import std/strutils
 import std/asyncdispatch
 import ../src/hyperx/server
 
-const localHost* = "127.0.0.1"
-const localPort* = Port 8783
+const localHost* = "/tmp/hyperxasd22.sock"
+const localPort* = Port 0
 const certFile = getEnv "HYPERX_TEST_CERTFILE"
 const keyFile = getEnv "HYPERX_TEST_KEYFILE"
 
@@ -76,7 +76,7 @@ proc serve*(server: ServerContext, propagateErr = true) {.async.} =
 
 proc newServer*(): ServerContext =
   newServer(
-    localHost, localPort, certFile, keyFile
+    localHost, localPort, certFile, keyFile, ssl = false, domain = hyxUnix
   )
 
 when isMainModule:

src/hyperx/client.nim

@@ -33,7 +33,8 @@ export
   ClientContext,
   HyperxConnError,
   HyperxStrmError,
-  HyperxError
+  HyperxError,
+  HyperxSockDomain
 
 var sslContext {.threadvar.}: SslContext
 
@@ -48,9 +49,13 @@ proc defaultSslContext(): SslContext {.raises: [HyperxConnError].} =
   return sslContext
 
 when not defined(hyperxTest):
-  proc newMySocket(ssl: bool): MyAsyncSocket {.raises: [HyperxConnError].} =
+  proc newMySocket(
+    domain: Domain, protocol: Protocol, ssl: bool
+  ): MyAsyncSocket {.raises: [HyperxConnError].} =
+    doAssert domain in {AF_UNIX, AF_INET, AF_INET6}
+    doAssert protocol in {IPPROTO_IP, IPPROTO_TCP}
     try:
-      result = newAsyncSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, buffered = true)
+      result = newAsyncSocket(domain, SOCK_STREAM, protocol, buffered = true)
       if ssl:
         wrapSocket(defaultSslContext(), result)
     except CatchableError as err:
@@ -61,9 +66,16 @@ when not defined(hyperxTest):
 proc newClient*(
   hostname: string,
   port = Port 443,
-  ssl = true
+  ssl = true,
+  domain = hyxInet
 ): ClientContext {.raises: [HyperxConnError].} =
-  newClient(ctClient, newMySocket(ssl), hostname, port)
+  newClient(
+    ctClient,
+    newMySocket(domain.addrFamily(), domain.ipProto(), ssl),
+    hostname,
+    port,
+    domain
+  )
 
 type
   HttpMethod* = enum

src/hyperx/clientserver.nim

@@ -41,6 +41,21 @@ const
   stgServerMaxConcurrentStreams* {.intdefine: "hyperxMaxConcurrentStrms".} = 100
   stgMaxSettingsList* {.intdefine: "hyperxMaxSettingsList".} = 100
 
+type
+  HyperxSockDomain* = enum
+    hyxUnix, hyxInet, hyxInet6
+
+func addrFamily*(domain: HyperxSockDomain): Domain {.raises: [].} =
+  case domain
+  of hyxUnix: AF_UNIX
+  of hyxInet: AF_INET
+  of hyxInet6: AF_INET6
+
+func ipProto*(domain: HyperxSockDomain): Protocol {.raises: [].} =
+  case domain
+  of hyxUnix: IPPROTO_IP
+  of hyxInet, hyxInet6: IPPROTO_TCP
+
 type
   ClientTyp* = enum
     ctServer, ctClient
@@ -123,6 +138,7 @@ type
     sock*: MyAsyncSocket
     hostname*: string
     port: Port
+    domain: HyperxSockDomain
     isConnected*: bool
     headersEnc, headersDec: DynHeaders
     streams: Streams
@@ -146,13 +162,15 @@ proc newClient*(
   typ: ClientTyp,
   sock: MyAsyncSocket,
   hostname: string,
-  port = Port 443
+  port = Port 443,
+  domain = hyxInet
 ): ClientContext {.raises: [].} =
   result = ClientContext(
     typ: typ,
     sock: sock,
     hostname: hostname,
     port: port,
+    domain: domain,
     isConnected: false,
     headersEnc: initDynHeaders(stgHeaderTableSize.int),
     headersDec: initDynHeaders(stgHeaderTableSize.int),
@@ -756,7 +774,11 @@ proc windowUpdateTask(client: ClientContext) {.async.} =
 
 proc connect(client: ClientContext) {.async.} =
   try:
-    await client.sock.connect(client.hostname, client.port)
+    case client.domain
+    of hyxInet, hyxInet6:
+      await client.sock.connect(client.hostname, client.port)
+    of hyxUnix:
+      await client.sock.connectUnix(client.hostname)
   except OsError as err:
     debugInfo err.getStackTrace()
     debugInfo err.msg

src/hyperx/errors.nim

@@ -49,7 +49,7 @@ func toErrorCode(e: uint32): ErrorCode {.raises: [].} =
 # XXX remove ConnError and StrmError; expose code in Hyperx*
 type
   HyperxErrTyp* = enum
-    hxLocalErr, hxRemoteErr
+    hxLocalErr, hxRemoteErr  # XXX use hyx prefix
   HyperxError* = object of CatchableError
   HyperxConnError* = object of HyperxError
   HyperxStrmError* = object of HyperxError

src/hyperx/server.nim

@@ -34,7 +34,9 @@ export
   ClientContext,
   HyperxConnError,
   HyperxStrmError,
-  HyperxError
+  HyperxError,
+  #HyperxErrTyp,
+  HyperxSockDomain
 
 var sslContext {.threadvar.}: SslContext
 
@@ -52,12 +54,16 @@ proc defaultSslContext(
 
 when not defined(hyperxTest):
   proc newMySocket(
+    domain: Domain,
+    protocol: Protocol,
     ssl: bool,
     certFile = "",
     keyFile = ""
   ): MyAsyncSocket {.raises: [HyperxConnError].} =
+    doAssert domain in {AF_UNIX, AF_INET, AF_INET6}
+    doAssert protocol in {IPPROTO_IP, IPPROTO_TCP}
     try:
-      result = newAsyncSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, buffered = true)
+      result = newAsyncSocket(domain, SOCK_STREAM, protocol, buffered = true)
       if ssl:
         wrapSocket(defaultSslContext(certFile, keyFile), result)
     except CatchableError as err:
@@ -70,23 +76,28 @@ type
     sock: MyAsyncSocket
     hostname: string
     port: Port
+    domain: HyperxSockDomain
     isConnected: bool
 
 proc newServer*(
   hostname: string,
   port: Port,
   sslCertFile = "",
   sslKeyFile = "",
-  ssl = true
+  ssl = true,
+  domain = hyxInet
 ): ServerContext =
   ServerContext(
     sock: newMySocket(
+      domain.addrFamily(),
+      domain.ipProto(),
       ssl,
       certFile = sslCertFile,
       keyFile = sslKeyFile
     ),
     hostname: hostname,
     port: port,
+    domain: domain,
     isConnected: false
   )
 
@@ -107,12 +118,24 @@ proc close*(server: ServerContext) {.raises: [HyperxConnError].} =
     debugInfo err.msg
     raise newException(Defect, err.msg)
 
-proc listen(server: ServerContext) =
-  server.sock.setSockOpt(OptReuseAddr, true)
-  server.sock.setSockOpt(OptReusePort, true)
-  server.sock.setSockOpt(OptNoDelay, true, level = IPPROTO_TCP.cint)
-  server.sock.bindAddr server.port
-  server.sock.listen()
+proc listen(server: ServerContext) {.raises: [HyperxConnError].} =
+  try:
+    case server.domain
+    of hyxInet, hyxInet6:
+      server.sock.setSockOpt(OptReuseAddr, true)
+      server.sock.setSockOpt(OptReusePort, true)
+      server.sock.setSockOpt(OptNoDelay, true, level = IPPROTO_TCP.cint)
+      server.sock.bindAddr server.port
+    of hyxUnix:
+      # XXX tryRemoveFile to avoid OSError
+      server.sock.bindUnix server.hostname
+    server.sock.listen()
+  except OSError, ValueError:
+    let err = getCurrentException()
+    debugInfo err.getStackTrace()
+    debugInfo err.msg
+    # XXX probably not a conn error
+    raise newHyperxConnError(err.msg)
 
 # XXX dont allow receive push promise
 
@@ -127,7 +150,9 @@ proc recvClient*(server: ServerContext): Future[ClientContext] {.async.} =
       wrapConnectedSocket(
         sslContext, sock, handshakeAsServer, server.hostname
       )
-    result = newClient(ctServer, sock, server.hostname)
+    result = newClient(
+      ctServer, sock, server.hostname, server.port, server.domain
+    )
   except CatchableError as err:
     debugInfo err.getStackTrace()
     debugInfo err.msg

src/hyperx/testsocket.nim

@@ -17,9 +17,13 @@ type
     isConnected*: bool
     hostname*: string
     port*: Port
+    domain*: Domain
+    protocol*: Protocol
     isSsl*: bool
 
-proc newMySocket*(ssl: bool, certFile = "", keyFile = ""): TestSocket =
+proc newMySocket*(
+  domain: Domain, protocol: Protocol, ssl: bool, certFile = "", keyFile = ""
+): TestSocket =
   TestSocket(
     recvData: newQueue[seq[byte]](1000),
     sentData: newQueue[seq[byte]](1000),
@@ -30,6 +34,8 @@ proc newMySocket*(ssl: bool, certFile = "", keyFile = ""): TestSocket =
     isConnected: false,
     hostname: "",
     port: Port 0,
+    domain: domain,
+    protocol: protocol,
     isSsl: ssl
   )
 
@@ -110,7 +116,7 @@ proc listen*(s: TestSocket) =
   s.isConnected = true
 
 proc accept*(s: TestSocket): Future[TestSocket] {.async.} =
-  result = newMySocket(s.isSsl)
+  result = newMySocket(s.domain, s.isSsl)
   result.isConnected = true
 
 proc wrapConnectedSocket*(