Esempio n. 1
0
    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)
Esempio n. 2
0
def upnp():
    u = UPnP()
    u.discoverdelay = 2000
    if u.discover():
        u.selectigd()
        eport = 81
         
        r = u.getspecificportmapping(eport, 'TCP')
        while r != None and eport < 65536:
            eport = eport + 1
	    r = u.getspecificportmapping(eport, 'TCP')
        
	u.addportmapping(eport, 'TCP', u.lanaddr, 80,
	                'HubDNS port forwarding', '')
Esempio n. 3
0
    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)
Esempio n. 4
0
class miniUPNP(object):
    def __init__(self, cport, dport, log=None):
        self.cport = cport
        self.dport = dport
        self.log = log

    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 addPortMapping(self, port):
        reactor.callFromThread(self.log.info, 'trying to forward port %d',
                               port)
        pm = self.upnp.getspecificportmapping(port, 'UDP')
        if pm:
            if self.ip == pm[0]:
                print 'port is already forwarded for this ip'
                reactor.callFromThread(self.log.info,
                                       'port %d is already forwarded for %s',
                                       port, self.ip)
                return port
            else:
                return self.addPortMapping(port=findNextUDPPort(port))
        try:
            b = self.upnp.addportmapping(port, 'UDP', self.ip, port, 'P2NER',
                                         '')
        except:
            reactor.callFromThread(
                self.log.warning,
                'a problem occured trying to forward port %d', port)
            reactor.callFromThread(
                self.log.warning,
                'validating if port %d was correctly forwarded', port)
            self.upnp.discover()
            d = self.upnp.selectigd()
            pm = self.upnp.getspecificportmapping(port, 'UDP')
            b = False
            if pm and self.ip in pm:
                b = True

        if b:
            reactor.callFromThread(self.log.info,
                                   'port %d was successfully forwarded', port)
            return port
        else:
            reactor.callFromThread(self.log.warning,
                                   "couldn't forward port %d", port)
            return False
Esempio n. 5
0
                         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
            Config.serve_port = Config.serve_port
            Config.peer_host = Config.peer_host
            Config.peer_port = Config.peer_port