replace ambient authority in net package by explicit Root authority

examples/echo/echo.pony

@@ -2,7 +2,14 @@ use "net"
 
 actor Main
   new create(env: Env) =>
-    let listener = TCPListener.ip4(Listener(env))
+    match env.root
+    | let a: AmbientAuth =>
+      let net = NetworkInterface(a)
+      let listener = net.listen(Listener(env)
+                                where v=IPv4)
+    else
+      env.err.print("no root")
+    end
 
 class Listener is TCPListenNotify
   let _env: Env

examples/httpget/httpget.pony

@@ -1,24 +1,34 @@
 use "assert"
 use "collections"
+use "files"
+use "net"
 use "net/http"
 use "net/ssl"
 
 actor Main
+
+  new create(env: Env) =>
+    match env.root
+    | None => env.out.print("No root!")
+    | let r: AmbientAuth => Go(env, r)
+    end
+
+
+actor Go
   let _env: Env
   let _client: Client
 
-  new create(env: Env) =>
+  new create(env: Env, root: AmbientAuth) =>
     _env = env
-
     let sslctx = try
       recover
         SSLContext
           .set_client_verify(true)
-          .set_authority("./test/pony/httpget/cacert.pem")
+          .set_authority(FilePath(root, "./test/pony/httpget/cacert.pem"))
       end
     end
 
-    _client = Client(consume sslctx)
+    _client = Client(recover NetworkInterface(root) end, consume sslctx)
 
     for i in Range(1, env.args.size()) do
       try

examples/httpserver/httpserver.pony

@@ -1,25 +1,35 @@
+use "net"
 use "net/http"
 
 actor Main
   new create(env: Env) =>
-    let service = try env.args(1) else "50000" end
-    let limit = try env.args(2).usize() else 100 end
-    Server(Info(env), Handle, CommonLog(env.out) where service = service,
+    match env.root
+    | let a: AmbientAuth =>
+      let service = try env.args(1) else "50000" end
+      let limit = try env.args(2).usize() else 100 end
+      let net: NetworkInterface val = recover NetworkInterface(a) end
+      Server(net, Info(env, net), Handle, CommonLog(env.out, net) where service = service,
       limit = limit)
     // Server(Info(env), Handle, ContentsLog(env.out) where service = service,
     //   limit = limit)
     // Server(Info(env), Handle, DiscardLog where service = service,
     //   limit = limit)
+    else
+      env.err.print("cannot use network: no root")
+    end
+
 
 class Info
   let _env: Env
+  let _dns: DNSClient val
 
-  new iso create(env: Env) =>
+  new iso create(env: Env, dns: DNSClient val) =>
     _env = env
+    _dns = dns
 
   fun ref listening(server: Server ref) =>
     try
-      (let host, let service) = server.local_address().name()
+      (let host, let service) = server.local_address().name(_dns)
       _env.out.print("Listening on " + host + ":" + service)
     else
       _env.out.print("Couldn't get local address.")

examples/net/listener.pony

@@ -1,3 +1,4 @@
+use "files"
 use "net"
 use "net/ssl"
 
@@ -8,17 +9,22 @@ class Listener is TCPListenNotify
   var _host: String = ""
   var _service: String = ""
   var _count: USize = 0
+  let _root: AmbientAuth
 
-  new create(env: Env, ssl: Bool, limit: USize) =>
+  new create(env: Env, ssl: Bool, limit: USize) ? =>
     _env = env
+    _root = env.root as AmbientAuth
     _limit = limit
 
+    let cert = try FilePath(_root, "./test/pony/net/cert.pem") else error end
+    let key = try FilePath(_root, "./test/pony/net/key.pem") else error end
+
     _sslctx = if ssl then
       try
         recover
           SSLContext
-            .set_authority("./test/pony/net/cert.pem")
-            .set_cert("./test/pony/net/cert.pem", "./test/pony/net/key.pem")
+            .set_authority(cert)
+            .set_cert(cert, key)
             .set_client_verify(true)
             .set_server_verify(true)
         end
@@ -70,13 +76,14 @@ class Listener is TCPListenNotify
     try
       let env = _env
 
+     let network = NetworkInterface(_root)
       match _sslctx
       | let ctx: SSLContext =>
         let ssl = ctx.client()
-        TCPConnection(SSLConnection(ClientSide(env), consume ssl), _host,
-          _service)
+        network.connect(SSLConnection(ClientSide(env), consume ssl),
+		_host, _service)
       else
-        TCPConnection(ClientSide(env), _host, _service)
+        network.connect(ClientSide(env), _host, _service)
       end
     else
       _env.out.print("couldn't create client side")

examples/net/net.pony

@@ -22,5 +22,13 @@ actor Main
       1
     end
 
-    TCPListener(recover Listener(env, ssl, limit) end)
-    UDPSocket(recover Pong(env) end)
+    match env.root
+    | let r: AmbientAuth =>
+      let network = NetworkInterface(r)
+      try
+        network.listen(recover Listener(env, ssl, limit) end)
+        network.udp_socket(recover Pong(env) end)
+      end
+    else
+      env.out.print("no root in Env!")
+    end

examples/net/pong.pony

@@ -2,9 +2,15 @@ use "net"
 
 class Pong is UDPNotify
   let _env: Env
+  let _network: UDPEndpoint val
 
-  new create(env: Env) =>
+  new create(env: Env) ? =>
     _env = env
+    _network = match env.root
+	  | let r: AmbientAuth => recover NetworkInterface(r) end
+	  else
+	    error
+	  end
 
   fun ref listening(sock: UDPSocket ref) =>
     try
@@ -14,13 +20,7 @@ class Pong is UDPNotify
 
       let env = _env
 
-      if ip.ip4() then
-        UDPSocket.ip4(recover Ping(env, ip) end)
-      elseif ip.ip6() then
-        UDPSocket.ip6(recover Ping(env, ip) end)
-      else
-        error
-      end
+      _network.udp_socket(recover Ping(env, ip) end where v=ip.version())
     else
       _env.out.print("Pong: couldn't get local name")
       sock.dispose()

packages/net/dns.pony

@@ -2,35 +2,29 @@ primitive DNS
   """
   Helper functions for resolving DNS queries.
   """
-  fun apply(host: String, service: String): Array[IPAddress] iso^ =>
-    """
-    Gets all IPv4 and IPv6 addresses for a host and service.
-    """
-    _resolve(0, host, service)
-
-  fun ip4(host: String, service: String): Array[IPAddress] iso^ =>
+  fun _ip4(host: String, service: String): Array[IPAddress] iso^ =>
     """
     Gets all IPv4 addresses for a host and service.
     """
     _resolve(1, host, service)
 
-  fun ip6(host: String, service: String): Array[IPAddress] iso^ =>
+  fun _ip6(host: String, service: String): Array[IPAddress] iso^ =>
     """
     Gets all IPv6 addresses for a host and service.
     """
     _resolve(2, host, service)
 
-  fun broadcast_ip4(service: String): Array[IPAddress] iso^ =>
+  fun _broadcast_ip4(service: String): Array[IPAddress] iso^ =>
     """
     Link-local IP4 broadcast address.
     """
-    ip4("255.255.255.255", service)
+    _ip4("255.255.255.255", service)
 
-  fun broadcast_ip6(service: String): Array[IPAddress] iso^ =>
+  fun _broadcast_ip6(service: String): Array[IPAddress] iso^ =>
     """
     Link-local IP6 broadcast address.
     """
-    ip6("FF02::1", service)
+    _ip6("FF02::1", service)
 
   fun is_ip4(host: String): Bool =>
     """

packages/net/http/client.pony

@@ -9,8 +9,12 @@ actor Client
   let _sslctx: SSLContext
   let _pipeline: Bool
   let _clients: Map[_HostService, _ClientConnection] = _clients.create()
+  let _tcp: TCPClient val
 
-  new create(sslctx: (SSLContext | None) = None, pipeline: Bool = true) =>
+  new create(tcp: TCPClient val,
+    sslctx: (SSLContext | None) = None,
+    pipeline: Bool = true)
+  =>
     """
     Create a client for the given host and service.
     """
@@ -21,6 +25,7 @@ actor Client
     end
 
     _pipeline = pipeline
+    _tcp = tcp
 
   be apply(request: Payload val) =>
     """
@@ -50,8 +55,8 @@ actor Client
       _clients(hs)
     else
       let client = match url.scheme
-      | "http" => _ClientConnection(hs.host, hs.service, None, _pipeline)
-      | "https" => _ClientConnection(hs.host, hs.service, _sslctx, _pipeline)
+      | "http" => _ClientConnection(_tcp, hs.host, hs.service, None, _pipeline)
+      | "https" => _ClientConnection(_tcp, hs.host, hs.service, _sslctx, _pipeline)
       else
         error
       end

packages/net/http/clientconnection.pony

@@ -13,8 +13,10 @@ actor _ClientConnection
   let _unsent: List[Payload val] = _unsent.create()
   let _sent: List[Payload val] = _sent.create()
   var _conn: (TCPConnection | None) = None
+  let _tcp: TCPClient val
 
-  new create(host: String, service: String, sslctx: (SSLContext | None) = None,
+  new create(tcp: TCPClient val,
+    host: String, service: String, sslctx: (SSLContext | None) = None,
     pipeline: Bool = true)
   =>
     """
@@ -24,6 +26,7 @@ actor _ClientConnection
     _service = service
     _sslctx = sslctx
     _pipeline = pipeline
+    _tcp = tcp
 
   be apply(request: Payload val) =>
     """
@@ -130,10 +133,10 @@ actor _ClientConnection
     _conn = try
       let ctx = _sslctx as SSLContext
       let ssl = ctx.client(_host)
-      TCPConnection(SSLConnection(_ResponseBuilder(this), consume ssl),
+      _tcp.connect(SSLConnection(_ResponseBuilder(this), consume ssl),
         _host, _service)
     else
-      TCPConnection(_ResponseBuilder(this), _host, _service)
+      _tcp.connect(_ResponseBuilder(this), _host, _service)
     end
 
   fun ref _cancel_all() =>

packages/net/http/commonlog.pony

@@ -1,13 +1,24 @@
+use "net"
 use "time"
 
 class CommonLog is Logger
   """
   Logs HTTP requests in the common log format.
   """
   let _out: OutStream
+  let _dns: DNSClient val
 
-  new val create(out: OutStream) =>
+  new val create(out: OutStream, dns: DNSClient val) =>
     _out = out
+    _dns = dns
+
+  fun val client_ip(addr: IPAddress): String ? =>
+    try
+      (let host, let port) = addr.name(_dns)
+      host
+    else
+      error
+    end
 
   fun val apply(ip: String, request: Payload val, response: Payload val) =>
     let list = recover Array[String](24) end

packages/net/http/discardlog.pony

@@ -1,6 +1,11 @@
+use "net"
+
 primitive DiscardLog
   """
   Doesn't log anything.
   """
   fun val apply(ip: String, request: Payload val, response: Payload val) =>
     None
+
+  fun val client_ip(addr: IPAddress): String ? =>
+    error

packages/net/http/notify.pony

@@ -1,3 +1,5 @@
+use "net"
+
 interface val ResponseHandler
   """
   Handles responses to HTTP requests.
@@ -26,6 +28,11 @@ interface val Logger
     Called after the server has handled a request.
     """
 
+  fun val client_ip(addr: IPAddress): String ? =>
+    """
+    Convert client IP address to string.
+    """
+
 interface ServerNotify
   """
   Notifications for HTTP servers.

packages/net/http/requestbuilder.pony

@@ -21,7 +21,7 @@ class _RequestBuilder is TCPConnectionNotify
     """
     Create a server connection to handle response ordering.
     """
-    (let host, let port) = try conn.remote_address().name() else ("-", "-") end
+    let host = try _logger.client_ip(conn.remote_address()) else "-" end
     _server = _ServerConnection(_handler, _logger, conn, host)
 
   fun ref received(conn: TCPConnection ref, data: Array[U8] iso) =>

packages/net/http/server.pony

@@ -15,7 +15,8 @@ actor Server
   var _address: IPAddress
   var _dirty_routes: Bool = false
 
-  new create(notify: ServerNotify iso, handler: RequestHandler,
+  new create(tcp: TCPServer val,
+    notify: ServerNotify iso, handler: RequestHandler,
     logger: Logger = DiscardLog, host: String = "", service: String = "0",
     limit: USize = 0, sslctx: (SSLContext | None) = None)
   =>
@@ -26,7 +27,7 @@ actor Server
     _handler = handler
     _logger = logger
     _sslctx = sslctx
-    _listen = TCPListener(_ServerListener(this, sslctx, _handler, _logger),
+    _listen = tcp.listen(_ServerListener(this, sslctx, _handler, _logger),
       host, service, limit)
     _address = recover IPAddress end