def delete_port_mapping(
protocol: SupportedTransportProtocols = SupportedTransportProtocols.
TCP,
external_port: int = LISTENING_PORT):
"""
Removes any UPnP temporary port forwards, to be executed on the application's closure
:param protocol: Transport protocol of port to be deleted
:param external_port: Port as viewable from internet
"""
port_forward_deleted = False
upnp = UPnP()
upnp.discoverdelay = 20 # Gives up after 20 ms
try:
discovered_count = upnp.discover()
if discovered_count > 0:
upnp.selectigd()
port_forward_deleted = upnp.deleteportmapping(
external_port, protocol.value)
if not port_forward_deleted:
# Send signal to show failure message and how to set up static port forwarding
print_err(
2, "Failed to delete UPnP Port Mapping on {} port {}".format(
protocol.value, external_port))
pass
except Exception as e:
print(type(e))
print(str(e))
pass
print("UPnP Port Mapping Deleted")
def init_my_peer(cls, config, mongo, network):
import socket
from miniupnpc import UPnP
# deploy as an eventlet WSGI server
try:
raise ValueError('test')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind((config.serve_host, 0))
server_port = sock.getsockname()[1]
sock.close()
eport = server_port
u = UPnP(None, None, 200, 0)
u.discover()
u.selectigd()
r = u.getspecificportmapping(eport, 'TCP')
while r is not None and eport < 65536:
eport = eport + 1
r = u.getspecificportmapping(eport, 'TCP')
b = u.addportmapping(eport, 'TCP', u.lanaddr, server_port,
'UPnP YadaCoin Serve port %u' % eport, '')
config.serve_host = '0.0.0.0'
config.serve_port = server_port
config.peer_host = u.externalipaddress()
config.peer_port = server_port
except Exception as e:
print(e)
config.serve_host = config.serve_host
config.serve_port = config.serve_port
config.peer_host = config.peer_host
config.peer_port = config.peer_port
print('UPnP failed: you must forward and/or whitelist port',
config.peer_port)
cls.save_my_peer(config, mongo, network)
return cls(config, mongo, config.peer_host, config.peer_port)
def ensure_port_is_forwarded(
protocol: SupportedTransportProtocols = SupportedTransportProtocols.
TCP,
external_port: int = LISTENING_PORT,
internal_port=LISTENING_PORT):
"""
Ensures that the given external to internal port mapping has been forwarded to allow inbound connections to this
host on this port.
If already done, whether by lack of NAT, firewall, or static port forwarding, no action is taken.
Otherwise, the port is forwarded dynamically using UPnP (if supported by the router and OS) for the duration of the
application's runtime.
:param protocol: Transport protocol of port to be mapped
:param external_port: Port as viewable from the internet
:param internal_port: Port as viewable from the LAN
"""
upnp = UPnP()
upnp.discoverdelay = 20 # Gives up after 20 ms
port_forwarded = False
discovered_count = upnp.discover()
if discovered_count > 0:
upnp.selectigd()
port_forwarded = upnp.addportmapping(external_port, protocol.value,
upnp.lanaddr, internal_port,
'UChat P2P Messaging', '')
if not port_forwarded:
# Send signal to show failure message and how to set up static port forwarding
print_err(
2, "Unable to open UPnP {} port {}".format(protocol.value,
external_port))
print("UPnP Port Mapping added")
def __init__(self, debug=False, config_dir=None):
self.platform_config = PlatformConfig(config_dir=config_dir)
if not logger.factory_instance:
console = True if debug else False
level = logging.DEBUG if debug else logging.INFO
logger.init(level, console, join(self.platform_config.get_platform_log()))
self.user_platform_config = PlatformUserConfig(self.platform_config.get_user_config())
self.log_aggregator = Aggregator(self.platform_config)
self.platform_app_paths = AppPaths(PLATFORM_APP_NAME, self.platform_config)
self.platform_app_paths.get_data_dir()
self.versions = Versions(self.platform_config)
self.redirect_service = RedirectService(self.user_platform_config, self.versions)
self.port_config = PortConfig(self.platform_app_paths.get_data_dir())
self.nat_pmp_port_mapper = NatPmpPortMapper()
self.upnp_port_mapper = UpnpPortMapper(UPnP())
self.port_mapper_factory = PortMapperFactory(self.nat_pmp_port_mapper, self.upnp_port_mapper)
self.port_drill_factory = PortDrillFactory(self.user_platform_config, self.port_config,
self.port_mapper_factory)
self.device_info = DeviceInfo(self.user_platform_config, self.port_config)
if self.platform_config.get_installer() == 'sam':
self.sam = SamStub(self.platform_config, self.device_info)
else:
self.sam = Snap(self.platform_config, self.device_info)
self.platform_cron = PlatformCron(self.platform_config)
self.systemctl = Systemctl(self.platform_config)
self.ldap_auth = LdapAuth(self.platform_config, self.systemctl)
self.event_trigger = EventTrigger(self.sam, self.platform_config)
self.nginx = Nginx(self.platform_config, self.systemctl, self.device_info)
self.certbot_genetator = CertbotGenerator(self.platform_config, self.user_platform_config,
self.device_info, self.sam)
self.tls = CertificateGenerator(self.platform_config, self.user_platform_config, self.device_info, self.nginx,
self.certbot_genetator)
self.device = Device(self.platform_config, self.user_platform_config, self.redirect_service,
self.port_drill_factory, self.sam, self.platform_cron, self.ldap_auth,
self.event_trigger, self.tls, self.nginx)
self.internal = Internal(self.platform_config, self.device, self.redirect_service, self.log_aggregator)
self.path_checker = PathChecker(self.platform_config)
self.lsblk = Lsblk(self.platform_config, self.path_checker)
self.hardware = Hardware(self.platform_config, self.event_trigger,
self.lsblk, self.path_checker, self.systemctl)
self.network = Network()
self.public = Public(self.platform_config, self.user_platform_config, self.device, self.device_info, self.sam,
self.hardware, self.redirect_service, self.log_aggregator, self.certbot_genetator,
self.port_mapper_factory, self.network, self.port_config)
self.udev = Udev(self.platform_config)
def __init__(self, debug=False):
self.platform_config = PlatformConfig()
if not logger.factory_instance:
console = True if debug else False
level = logging.DEBUG if debug else logging.INFO
logger.init(level, console, join(self.platform_config.get_platform_log()))
self.user_platform_config = PlatformUserConfig(self.platform_config.get_user_config())
self.log_aggregator = Aggregator(self.platform_config)
self.platform_app_paths = AppPaths(PLATFORM_APP_NAME, self.platform_config)
self.platform_app_paths.get_data_dir()
self.redirect_service = RedirectService(self.user_platform_config, platform_version)
self.port_config = PortConfig(self.platform_app_paths.get_data_dir())
self.nat_pmp_port_mapper = NatPmpPortMapper()
self.upnp_port_mapper = UpnpPortMapper(UPnP())
self.port_drill_factory = PortDrillFactory(self.user_platform_config, self.port_config,
self.nat_pmp_port_mapper, self.upnp_port_mapper)
self.info = DeviceInfo(self.user_platform_config, self.port_config)
self.sam = SamStub(self.platform_config, self.info)
self.platform_cron = PlatformCron(self.platform_config)
self.ldap_auth = LdapAuth(self.platform_config)
self.event_trigger = EventTrigger(self.sam)
self.nginx = Nginx(self.platform_config)
self.tls = Tls(self.platform_config, self.info, self.nginx)
self.device = Device(self.platform_config, self.user_platform_config, self.redirect_service,
self.port_drill_factory, self.sam, self.platform_cron, self.ldap_auth,
self.event_trigger, self.tls)
self.internal = Internal(self.platform_config, self.device, self.redirect_service, self.log_aggregator)
self.path_checker = PathChecker(self.platform_config)
self.lsblk = Lsblk(self.platform_config, self.path_checker)
self.hardware = Hardware(self.platform_config, self.event_trigger, self.lsblk, self.path_checker)
self.public = Public(self.platform_config, self.user_platform_config, self.device, self.info, self.sam, self.hardware,
self.redirect_service, self.log_aggregator)
self.udev = Udev(self.platform_config)
def start(self):
self.upnp = UPnP()
self.upnp.discoverdelay = 3000
devices = self.upnp.discover()
if not devices:
reactor.callFromThread(self.log.error, 'no upnp device found')
raise ValueError('no devices found')
f = self.upnp.selectigd()
reactor.callFromThread(self.log.info, 'upnp device found')
self.ip = self.upnp.lanaddr
newcport = self.addPortMapping(self.cport)
if newcport:
newdport = self.addPortMapping(self.dport)
if newdport:
return (newcport, newdport)
else:
raise ValueError('could not forward control port')
else:
raise ValueError('could not forward data port')
def create_upnp_mapping(cls, config):
from miniupnpc import UPnP
config = get_config()
try:
u = UPnP(None, None, 200, 0)
u.discover()
config.igd = u.selectigd()
except:
config.igd = ""
if config.use_pnp:
import socket
# deploy as an eventlet WSGI server
try:
server_port = config.peer_port
eport = server_port
r = u.getspecificportmapping(eport, 'TCP')
if r:
u.deleteportmapping(eport, 'TCP')
u.addportmapping(eport, 'TCP', u.lanaddr, server_port,
'UPnP YadaCoin Serve port %u' % eport, '')
config.peer_host = u.externalipaddress()
if 'web' in config.modes:
server_port = config.serve_port
eport = server_port
r = u.getspecificportmapping(eport, 'TCP')
if r:
u.deleteportmapping(eport, 'TCP')
u.addportmapping(eport, 'TCP', u.lanaddr, server_port,
'UPnP YadaCoin Serve port %u' % eport, '')
except Exception as e:
print(e)
config.serve_host = config.serve_host
config.serve_port = config.serve_port
config.peer_host = config.peer_host
config.peer_port = config.peer_port
print('UPnP failed: you must forward and/or whitelist port',
config.peer_port)
@pytest.fixture(scope="module")
def http_server(request):
server = SomeHttpServer(18088)
server.start()
def fin():
server.stop()
request.addfinalizer(fin)
return server
ids = []
mappers = []
mapper = provide_mapper(NatPmpPortMapper(), UpnpPortMapper(UPnP()))
if mapper is not None:
ids.append(mapper.name())
mappers.append(mapper)
@pytest.mark.parametrize("mapper", mappers, ids=ids)
def test_external_ip(mapper):
external_ip = mapper.external_ip()
assert external_ip is not None
@pytest.mark.parametrize("mapper", mappers, ids=ids)
def test_add_mapping_simple(http_server, mapper):
external_port = mapper.add_mapping(http_server.port, http_server.port, 'TCP')
assert external_port is not None
def http_server(request):
server = SomeHttpServer(18088)
server.start()
def fin():
server.stop()
request.addfinalizer(fin)
return server
ids = []
mappers = []
mapper = PortMapperFactory(NatPmpPortMapper(),
UpnpPortMapper(UPnP())).provide_mapper()
if mapper is not None:
ids.append(mapper.name())
mappers.append(mapper)
# @pytest.mark.parametrize("mapper", mappers, ids=ids)
# def test_external_ip(mapper):
# external_ip = mapper.external_ip()
# assert external_ip is not None
#
#
# @pytest.mark.parametrize("mapper", mappers, ids=ids)
# def test_add_mapping_simple(http_server, mapper):
# external_port = mapper.add_mapping(http_server.port, http_server.port, 'TCP')
# assert external_port is not None
# external_ip = mapper.external_ip()
from yaml import load, FullLoader
from miniupnpc import UPnP
import requests
# load the configuration file
with open('config.yaml') as f:
config = load(f, Loader=FullLoader)
# use UPnP to get the external IP address
upnp = UPnP()
upnp.discoverdelay = 200
upnp.discover()
upnp.selectigd()
ip = upnp.externalipaddress()
# set up variables needed for api access
api_url = 'https://api.cloudflare.com/client/v4'
headers = {
'Authorization': 'Bearer ' + config['api_token'],
'Content-Type': 'application/json'
}
# get the DNS record so we can save the ID and check the IP
url = '{}/zones/{}/dns_records?name={}'.format(api_url, config['zone_id'],
config['hostname'])
response = requests.get(url, headers=headers).json()
if response['result'][0]['content'] == ip:
exit
'graphnewmessages'),
methods=['GET', 'POST'])
app.add_url_rule('/wallet',
view_func=endpoints.WalletView.as_view('wallet'))
app.add_url_rule('/faucet',
view_func=endpoints.FaucetView.as_view('faucet'))
app = socketio.Middleware(sio, app)
# deploy as an eventlet WSGI server
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind((Config.serve_host, 0))
server_port = sock.getsockname()[1]
sock.close()
eport = server_port
u = UPnP(None, None, 200, 0)
u.discover()
u.selectigd()
r = u.getspecificportmapping(eport, 'TCP')
while r != None and eport < 65536:
eport = eport + 1
r = u.getspecificportmapping(eport, 'TCP')
b = u.addportmapping(eport, 'TCP', u.lanaddr, server_port,
'UPnP YadaCoin Serve port %u' % eport, '')
Config.serve_host = '0.0.0.0'
Config.serve_port = server_port
Config.peer_host = u.externalipaddress()
Config.peer_port = server_port
print "http://{}:{}/".format(u.externalipaddress(), server_port)
except:
Config.serve_host = Config.serve_host
def test_many_ports_until_fail():
mapper = UpnpPortMapper(UPnP())
base_port = 11000
for port in range(base_port, base_port + 50, 1):
mapper.add_mapping(port, port, 'TCP')
