Merge #1041: Allow user to configure host,port of onion.

13f9bb7 change default to IP (Adam Gibson)
b5a4ba3 Allow user to configure host,port of onion. (Adam Gibson)

jmbase/jmbase/twisted_utils.py

@@ -2,7 +2,8 @@
 from zope.interface import implementer
 from twisted.internet.error import ReactorNotRunning
 from twisted.internet import reactor, defer
-from twisted.internet.endpoints import TCP4ClientEndpoint, UNIXClientEndpoint
+from twisted.internet.endpoints import (TCP4ClientEndpoint,
+                        UNIXClientEndpoint, serverFromString)
 from twisted.web.client import Agent, BrowserLikePolicyForHTTPS
 import txtorcon
 from txtorcon.web import tor_agent
@@ -105,6 +106,12 @@ def get_nontor_agent(tls_whitelist=[]):
                 contextFactory=WhitelistContextFactory(tls_whitelist))
     return agent
 
+def config_to_hs_ports(virtual_port, host, port):
+    # See https://github.com/meejah/txtorcon/blob/0c416cc8fe18b913cd0c7422935885a1bfecf4c0/txtorcon/onion.py#L1320
+    # for non default config, pass port mapping strings like:
+    # "80 127.0.0.1:1234"
+    return "{} {}:{}".format(virtual_port, host, port)
+
 class JMHiddenService(object):
     """ Wrapper class around the actions needed to
     create and serve on a hidden service; an object of
@@ -113,7 +120,8 @@ class JMHiddenService(object):
     """
     def __init__(self, resource, info_callback, error_callback,
                  onion_hostname_callback, tor_control_host,
-                 tor_control_port, serving_port = None,
+                 tor_control_port, serving_host, serving_port,
+                 virtual_port = None,
                  shutdown_callback = None):
         self.site = Site(resource)
         self.site.displayTracebacks = False
@@ -124,26 +132,29 @@ class JMHiddenService(object):
         # known and is 80 by default)
         self.onion_hostname_callback = onion_hostname_callback
         self.shutdown_callback = shutdown_callback
-        if not serving_port:
-            self.port = 80
+        if not virtual_port:
+            self.virtual_port = 80
         else:
-            self.port = serving_port
+            self.virtual_port = virtual_port
         self.tor_control_host = tor_control_host
         self.tor_control_port = tor_control_port
-        print("got these settings: ", self.port, self.site, self.tor_control_host, self.tor_control_port)
+        # note that defaults only exist in jmclient
+        # config object, so no default here:
+        self.serving_host = serving_host
+        self.serving_port = serving_port
 
     def start_tor(self):
         """ This function executes the workflow
         of starting the hidden service and returning its hostname
         """
         self.info_callback("Attempting to start onion service on port: {} "
-                           "...".format(self.port))
+                           "...".format(self.virtual_port))
         if str(self.tor_control_host).startswith('unix:'):
             control_endpoint = UNIXClientEndpoint(reactor,
                                     self.tor_control_host[5:])
         else:
             control_endpoint = TCP4ClientEndpoint(reactor,
-                            self.tor_control_host,self.tor_control_port)
+                            self.tor_control_host, self.tor_control_port)
         d = txtorcon.connect(reactor, control_endpoint)
         d.addCallback(self.create_onion_ep)
         d.addErrback(self.setup_failed)
@@ -158,20 +169,27 @@ class JMHiddenService(object):
 
     def create_onion_ep(self, t):
         self.tor_connection = t
-        return t.create_onion_endpoint(self.port, private_key=txtorcon.DISCARD)
-
-    def onion_listen(self, onion_ep):
-        return onion_ep.listen(self.site)
+        portmap_string = config_to_hs_ports(self.virtual_port,
+                                self.serving_host, self.serving_port)
+        return t.create_onion_service(
+            ports=[portmap_string], private_key=txtorcon.DISCARD)
+
+    def onion_listen(self, onion):
+        # 'onion' arg is the created EphemeralOnionService object;
+        # now we know it exists, we start serving the Site on the
+        # relevant port:
+        self.onion =  onion
+        serverstring = "tcp:{}:interface={}".format(self.serving_port,
+                                                    self.serving_host)
+        onion_endpoint = serverFromString(reactor, serverstring)
+        return onion_endpoint.listen(self.site)
 
     def print_host(self, ep):
-        """ Callback fired once the HS is available;
-        we let the caller know the hidden service onion hostname,
-        which is not otherwise available to them:
+        """ Callback fired once the HS is available
+        and the site is up ready to receive requests.
+        The hidden service hostname will be used in the BIP21 uri.
         """
-        # Note that ep,getHost().onion_port must return the same
-        # port as we chose in self.port; if not there is an error.
-        assert ep.getHost().onion_port == self.port
-        self.onion_hostname_callback(ep.getHost().onion_uri)
+        self.onion_hostname_callback(self.onion.hostname)
 
     def shutdown(self):
         self.tor_connection.protocol.transport.loseConnection()

jmclient/jmclient/client_protocol.py

@@ -86,7 +86,9 @@ class BIP78ClientProtocol(BaseClientProtocol):
         else:
             netconfig = {"port": 80,
                          "tor_control_host": jcg("PAYJOIN", "tor_control_host"),
-                         "tor_control_port": jcg("PAYJOIN", "tor_control_port")}
+                         "tor_control_port": jcg("PAYJOIN", "tor_control_port"),
+                         "onion_serving_host": jcg("PAYJOIN", "onion_serving_host"),
+                         "onion_serving_port": jcg("PAYJOIN", "onion_serving_port")}
             d = self.callRemote(commands.BIP78ReceiverInit,
                                 netconfig=netconfig)
         self.defaultCallbacks(d)

jmclient/jmclient/configure.py

@@ -374,15 +374,22 @@ max_additional_fee_contribution = default
 # transaction; note it is decimal, not integer.
 min_fee_rate = 1.1
 
-# for payjoins to hidden service endpoints, the socks5 configuration:
+# for payjoins as sender (i.e. client) to hidden service endpoints,
+# the socks5 configuration:
 onion_socks5_host = localhost
 onion_socks5_port = 9050
 
-# for payjoin onion service creation, the tor control configuration:
+# for payjoin onion service creation:
+# the tor control configuration:
 tor_control_host = localhost
 # or, to use a UNIX socket
 # control_host = unix:/var/run/tor/control
 tor_control_port = 9051
+# the host/port actually serving the hidden service
+# (note the *virtual port*, that the client uses,
+# is hardcoded to 80):
+onion_serving_host = 127.0.0.1
+onion_serving_port = 8080
 
 # in some exceptional case the HS may be SSL configured,
 # this feature is not yet implemented in code, but here for the

jmdaemon/jmdaemon/daemon_protocol.py

@@ -274,6 +274,8 @@ class BIP78ServerProtocol(HTTPPassThrough):
         self.serving_port = int(netconfig["port"])
         self.tor_control_host = netconfig["tor_control_host"]
         self.tor_control_port = int(netconfig["tor_control_port"])
+        self.onion_serving_host=netconfig["onion_serving_host"]
+        self.onion_serving_port=int(netconfig["onion_serving_port"])
         self.bip78_rr = BIP78ReceiverResource(self.info_callback,
                                               self.shutdown_callback,
                                               self.post_request_handler)
@@ -283,8 +285,9 @@ class BIP78ServerProtocol(HTTPPassThrough):
                                   self.onion_hostname_callback,
                                   self.tor_control_host,
                                   self.tor_control_port,
-                                  self.serving_port,
-                                  self.shutdown_callback)
+                                  self.onion_serving_host,
+                                  self.onion_serving_port,
+                                  shutdown_callback=self.shutdown_callback)
         # this call will start bringing up the HS; when it's finished,
         # it will fire the `onion_hostname_callback`, or if it fails,
         # it'll fire the `setup_error_callback`.