def list_available_devices() -> list: """ Method to return list of available device names on the network """ devices = upnpclient.discover() return [d.friendly_name for d in devices]
def discovery(timeout=5): out = {} try: _LOGGER.info("Searching upnp devices") devs = upnpclient.discover(timeout=5) _LOGGER.info("Found " + str(len(devs)) + " upnp devices") rc = { "RenderingControl": DeviceUpnpIRRC, "MainTVAgent2": DeviceUpnpIRTA2 } for d in devs: u = upar(d.location) for k, v in rc.items(): if k in d.service_map: _LOGGER.info("Found " + k + " at " + d.location) hp = (u.hostname, u.port) m = '{}:{}:'.format(*hp) + k out[m] = v(hp=hp, mac=m, name='', location=d.location, deviceobj=d) except: # noqa: E722 _LOGGER.warning(f"{traceback.format_exc()}") return out
async def discover(ctx): """Discover supported devices.""" TIMEOUT = 3 debug = 0 if ctx.obj: debug = ctx.obj["debug"] or 0 click.echo("Discovering for %s seconds" % TIMEOUT) devices = upnpclient.discover(TIMEOUT) for dev in devices: if "ScalarWebAPI" in dev.service_map: if debug: print( etree.tostring(dev._root_xml, pretty_print=True).decode()) model = dev.model_name model_number = dev.model_number pretty_name = "%s - %s" % (model, model_number) root = objectify.fromstring(etree.tostring(dev._root_xml)) device = root["device"] info = device["{urn:schemas-sony-com:av}X_ScalarWebAPI_DeviceInfo"] endpoint = info["X_ScalarWebAPI_BaseURL"].text version = info["X_ScalarWebAPI_Version"].text services = info["X_ScalarWebAPI_ServiceList"].iterchildren() click.echo(click.style("Found %s" % pretty_name, bold=True)) click.echo("* API version: %s" % version) click.echo("* Endpoint: %s" % endpoint) click.echo("* Services:") for serv in services: click.echo(" - Service: %s" % serv.text)
def main(): router = None while router == None: print("upnp discover looking for router") devices = upnpclient.discover() print(devices) for device in devices: print(device) print(device.model_name) if device.model_name == 'rt4230w-d187 router': router = device print("upnp router found") break print("upnp router not found, retrying") print("starting prom metrics http server on port %s", PROM_HTTP_PORT) start_http_server(PROM_HTTP_PORT) print("main metrics collection loop") while True: time.sleep(1) conn_status = router.WANIPConn1.GetStatusInfo() router_connection_uptime.set(conn_status.get('NewUptime', -1)) if conn_status.get('NewConnectionStatus', '') == 'Connected': router_connection_status.set(1) else: router_connection_status.set(0) router_bytes_sent.set(router.WANCommonIFC1.GetTotalBytesSent().get('NewTotalBytesSent', -1)) router_bytes_received.set(router.WANCommonIFC1.GetTotalBytesReceived().get('NewTotalBytesReceived', -1)) router_packets_sent.set(router.WANCommonIFC1.GetTotalPacketsSent().get('NewTotalPacketsSent', -1)) router_packets_received.set(router.WANCommonIFC1.GetTotalPacketsReceived().get('NewTotalPacketsReceived', -1))
def Port_forwarding(): try: devices = upnpclient.discover() status = devices[0].WANIPConn1.GetStatusInfo() if status['NewConnectionStatus'] != 'Connected': for i, x in enumerate(devices): status = x.WANIPConn1.GetStatusInfo() if status == 'Connected': d = devices[i] break else: d = devices[0] d.WANIPConn1.AddPortMapping( NewRemoteHost='0.0.0.0', NewExternalPort=port, NewProtocol='TCP', NewInternalPort=port, NewInternalClient=host, NewEnabled='1', NewPortMappingDescription='P2P', NewLeaseDuration=10000) print('Forwarding Success!!!') return True except: print('Device not found') return False
def _attempt_connection(self): """ This will attempt to connect to the bridge, but will not handle any errors on it's own. Raises ------ UnauthorizedUserException If self.username is not None, and is not registered with the bridge """ if self.user_supplied_ip: self.ip = self.settings.get('ip') else: device = next(filter(lambda device : "Philips hue" in device.model_name, upnpclient.discover())) self.ip = urllib.parse.urlparse(device.location).hostname if self.username: url = 'http://{ip}/api/{user}'.format(ip=self.ip, user=self.username) data = get(url).json() data = data[0] if isinstance(data, list) else data error = data.get('error') if error: description = error.get('description') if description == "unauthorized user": raise UnauthorizedUserException(self.username) else: raise Exception('Unknown Error: {0}'.format(description)) self.bridge = Bridge(self.ip, self.username)
def __init__(self, main_port=8000, timeout=2): log.info("UPnP Passthrough Service Started.") log.debug("Fetching a device list...") self.dev_list = upnpclient.discover(timeout) log.debug(f"Fetch finished in {timeout}s") log.debug(f"Devices detected: {self.dev_list}") if not self.dev_list: log.warning("No UPnP Devices was found. Stopping NatWorker...") del self
def discover_igd(): devices = upnpclient.discover() igd_devices = list(filter(lambda d: d.device_type in IGD, devices)) logger.debug("IGD devices: %s", igd_devices) if len(igd_devices) != 1: raise SystemExit() igd = igd_devices.pop() return igd
def _discover_upnp_device(self): devices = upnpclient.discover() if devices: for device in devices: try: device.WANIPConn1 except AttributeError: continue return device
def discover_hue(**kwargs): cloud = kwargs.get("cloud", False) upnp = kwargs.get("upnp", True) bridges = Bridge.select() bridge_addresses = [] for bridge in bridges: bridge_addresses.append(bridge.ip) if cloud: devices_resp = requests.get("https://discovery.meethue.com/") if devices_resp.status_code == 200: devices = devices_resp.json() for device in devices: ip_address = device.get("internalipaddress") urlbase = "http://%s:80" % ip_address debug_address = "%s/debug/clip.html" % urlbase if ip_address not in bridge_addresses: new_bridge = Bridge.create( name="Philips Hue Bridge", ip=ip_address, serial_number=device.get("id"), url=urlbase, debug=debug_address, device_id=device.get("id"), ) bridge_addresses.append(ip_address) if upnp: devices = upnpclient.discover() for device in devices: if "Philips hue" in device.friendly_name: urlbase = device.location.replace("/description.xml", "") ip_address = re.search(r"(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})", urlbase).group(1) debug_address = "%s/debug/clip.html" % urlbase if ip_address not in bridge_addresses: new_bridge = Bridge.create( name=device.friendly_name, ip=ip_address, serial_number=device.serial_number, url=urlbase, debug=debug_address, device_id=device.serial_number, ) bridge_addresses.append(ip_address) bridges = Bridge.select() return bridges
def getDevicesWithDefault(deviceURL): global cachedDevices startIfNeeded() if deviceURL: devices = [upnpclient.Device(deviceURL)] else: if not cachedDevices: #Very quick scan because we let the background thread handle the slow stuff. cachedDevices = upnpclient.discover(timeout=1) devices = cachedDevices return devices
def getWANAddresses(): devices = upnpclient.discover() addresses = [] for i in devices: for j in i.services: for k in j.actions: if k.name == "GetExternalIPAddress": if "WAN" in j.service_type: addresses.append( j.GetExternalIPAddress()["NewExternalIPAddress"]) return addresses
def test_discover(self, mock_scan, mock_server): """ discover() should call netdisco's scan function and return a list of unique servers. """ url = 'http://www.example.com' entry = mock.Mock() entry.location = url mock_scan.return_value = [entry, entry] ret = upnp.discover() mock_scan.assert_called() mock_server.assert_called_with(url) self.assertEqual(ret, ['test string'])
def test_discover_exception(self, mock_scan, mock_server): """ If unable to read a discovered server's root XML file, it should not appear in the list. """ url = 'http://www.example.com' entry = mock.Mock() entry.location = url mock_scan.return_value = [entry] ret = upnp.discover() mock_scan.assert_called() mock_server.assert_called_with(url) self.assertEqual(ret, [])
def discover_players(): players = {} others = {} devices = upnpclient.discover() for d in devices: services_s = map(lambda service: str(service), d.services) ip = ipaddress.ip_network('200.200.200.200/32') ip_text = '' m = re.search('^http://([^\/\:]+)', d._url_base) if m: ip = ipaddress.ip_network(m.group(1)) ip_text = m.group(1) if ip.subnet_of( local_net ) and "<Service service_id='urn:upnp-org:serviceId:AVTransport'>" in services_s: players[d.location] = { 'location': d.location, 'ip': ip_text, 'name': d.friendly_name, 'model_name': d.model_name, 'last_seen': time.time() } try: r = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True) r.set('upnp:player:' + d.location + ':data', json.dumps(players[d.location])) r.set('upnp:player:' + d.location + ':last_seen', players[d.location]['last_seen']) except Exception as e: logging.warning('setting data in redis nok ' + str(e)) logging.debug(traceback.format_exc()) finally: del r else: others[d.location] = { 'location': d.location, 'ip': ip_text, 'name': d.friendly_name, 'model_name': d.model_name, 'last_seen': time.time() } return (players, others)
def setup_port_map( port: int, duration: int = DEFAULT_PORTMAP_DURATION ) -> Tuple[AnyIPAddress, AnyIPAddress]: """ Set up the port mapping :return: the IP address of the new mapping (or None if failed) """ devices = upnpclient.discover() if not devices: raise PortMapFailed("No UPnP devices available") for upnp_dev in devices: try: internal_ip, external_ip = _setup_device_port_map( upnp_dev, port, duration) logger.info( "NAT port forwarding successfully set up: internal=%s:%d external=%s:%d", internal_ip, port, external_ip, port, ) break except _NoInternalAddressMatchesDevice: logger.debug( "No internal addresses were managed by the UPnP device at %s", upnp_dev.location, ) continue except _WANServiceNotFound: logger.debug( "No WAN services managed by the UPnP device at %s", upnp_dev.location, ) continue except PortMapFailed: logger.debug( "Failed to setup portmap on UPnP divec at %s", upnp_dev.location, exc_info=True, ) continue else: logger.info("Failed to setup NAT portmap. Tried %d devices", len(devices)) raise PortMapFailed( f"Failed to setup NAT portmap. Tried {len(devices)} devices.") return ipaddress.ip_address(internal_ip), ipaddress.ip_address(external_ip)
def punchHole(ip, eport, oport): upnpdevices = upnpclient.discover() firstdevice = upnpdevices[0] # assume only one firstdevice.WANIPConn1.AddPortMapping( NewRemoteHost='0.0.0.0', NewExternalPort=oport, NewProtocol='TCP', NewInternalPort=eport, NewInternalClient=ip, NewEnabled='1', NewPortMappingDescription='Дмитрий was here', NewLeaseDuration=84600) print('Forwarding is enabled') return ()
def available_devices(): """ List all devices that are AVTransport media renderers """ devices = [] for device in upnpclient.discover(): for service in device.services: if service.service_id == AVTRANSPORT_SERVICE_ID: logger.info(service.actions) devices.append(device) return devices
def addMapping(port, proto, desc="Description here"): """Returns a list of Mapping objects""" devices = upnpclient.discover() mappings = [] for i in devices: l = urlparse(i.location).netloc if ":" in l: l = l.split(":")[0] s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) s.connect((l, 12345)) #Get the IP that we use to talk to that particular router ownAddr = s.getsockname()[0] s.close() del s for j in i.services: for k in j.actions: if k.name == "GetExternalIPAddress": if "WAN" in j.service_type: def clean(): j.DeletePortMapping( NewRemoteHost="0.0.0.0", NewExternalPort=port, NewProtocol=proto, ) with listlock: cleanuplist.append(clean) def renew(): j.AddPortMapping(NewRemoteHost='0.0.0.0', NewExternalPort=port, NewProtocol=proto, NewInternalPort=port, NewInternalClient=ownAddr, NewEnabled='1', NewPortMappingDescription=desc, NewLeaseDuration=3600) renew() with listlock: renewlist.append(renew) mappings.append(Mapping(clean, renew)) return mappings
def search_igd_port_actions(): # search for devices which has WANIPConn1.AddPortMapping devices = upnpclient.discover(7) igd_actions = [] for router in [ device for device in devices if Environment().default_gateway in device.location ]: for service in router.services: for action in service.actions: if "AddPortMapping" in action.name and not not_in( igd_actions, action): igd_actions.append(action) return igd_actions
def upnp_add_port_mapping(internal_port: int, external_port: int, ip: str, name: str): devices = upnpclient.discover() for d in devices: if hasattr(d, "WANIPConn1"): print(d.WANIPConn1.GetStatusInfo()) d.WANIPConn1.AddPortMapping( NewRemoteHost="", NewExternalPort=external_port, NewProtocol='TCP', NewInternalPort=internal_port, NewInternalClient=ip, NewEnabled='1', NewPortMappingDescription=name, NewLeaseDuration=0)
def modem_bilgisi(): import upnpclient devices = upnpclient.discover() #print(devices) if len(devices) > 0: d = devices[0] sonuc = "upnp" marka = d.manufacturer model = d.model_name model_numarası = d.model_number modem_serinumarası = d.serial_number return sonuc, marka, model, model_numarası, modem_serinumarası else: return "not_upnp", "marka", "model", "model_numarası", "modem_serinumarası" #print(modem_bilgisi())
def renewer(): global cachedDevices while 1: #This takes such a long time that I can't think of a better way, #Aside from a background rescan try: cachedDevices = upnpclient.discover() listMappings() except: logger.exception("err") time.sleep(8*60) try: with listlock: for i in renewlist: i() except Exception as e: print(e)
def discover_ip(device_name) -> str: """ Method to return the URL (IP) to send requests to for a roku device of the given name :param device_name: Name of device we are searching for :return: An IP address string that can be used to send requests :raises: ValueError if no such device is found """ devices = upnpclient.discover() roku_device = [ d for d in devices if device_name.lower() == d.friendly_name.lower() ] if len(roku_device) == 0: raise ValueError(f'No device found for name {device_name}') return roku_device[0].location
def _init_upnp(self): devices = upnpclient.discover() self.log.info("Found %s UPnP devices on LAN", len(devices)) for device in devices: try: _ = device.WANIPConn1 self.gateway_device = device self.log.info("Found gateway device: %s", device) except Exception: pass if not self.gateway_device: raise exc.CouldNotFindUpnpGateway( "No UPnP Gateway found. Found %s UPnP devices on LAN" % len(devices)) self.log.info("Resolved WAN address: %s", self.get_wan_ip())
def start_yoga_paused(): time.sleep(60) devices = upnpclient.discover() xbox = [ d for d in devices if d.friendly_name == 'VANGUARD' and d.model_description == 'Digital Media Renderer' ][0] service = [ s for s in xbox.services if s.service_type == 'urn:schemas-upnp-org:service:AVTransport:1' ][0] index = get_day_number() % len(yoga_videos) print(get_day_number(), index) uri = dlna_server_uri + yoga_videos[index] print(uri) service.SetAVTransportURI(InstanceID=0, CurrentURI=uri, CurrentURIMetaData="") time.sleep(5) service.Pause(InstanceID=0) return "Started yoga video"
def run(self, internal_port=8192, external_port=8192, duration=0, protocol="TCP", name="Internet access", enabled="1", internal_ip=gethostbyname(gethostname()), **kwargs): from ipaddress import ip_address try: addr = ip_address(internal_ip) if addr.is_loopback: raise ValueError("Address can not be loopback!") except ValueError as e: raise ValueError("Internal IP address is invalid: {}".format(e)) import upnpclient devices = upnpclient.discover() success = 0 for x in devices: if self._run.is_set(): try: x.WANIPConn1.AddPortMapping(NewRemoteHost="0.0.0.0", NewExternalPort=external_port, NewProtocol=protocol, NewInternalPort=internal_port, NewInternalClient=internal_ip, NewEnabled=enabled, NewPortMappingDescription=name, NewLeaseDuration=duration) success = success + 1 except Exception: # noqa pass else: break return success > 0
def upnp_devices_information(): result = dict() result["status"] = True result["data"] = [] devices = upnpclient.discover(5) for device in devices: device_json = dict() device_json["location"] = device.location device_json["name"] = device.friendly_name device_json["services"] = [] for service in device.services: service_json = dict() service_json["id"] = service.service_id service_json["actions"] = [] for action in service.actions: action_json = dict() action_json["name"] = action.name action_json["args_in"] = parse_args(action.argsdef_in) action_json["args_out"] = parse_args(action.argsdef_out) action_json["url"] = device.location service_json["actions"].append(action_json) device_json["services"].append(service_json) result["data"].append(device_json) return result
#!/usr/bin/env python3 import socket import upnpclient def get_local_ip(): with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s: s.connect(("8.8.8.8", 80)) return s.getsockname()[0] if __name__ == '__main__': devices = upnpclient.discover() print(devices) d = devices[0] print(d.WANIPConn1.GetStatusInfo()) d.WANIPConn1.AddPortMapping( NewRemoteHost='', NewExternalPort=60000, NewProtocol='TCP', NewInternalPort=60000, NewInternalClient=get_local_ip(), NewEnabled='1', NewPortMappingDescription='file_server', NewLeaseDuration=0)
def discover(): SSDP.devices = upnpclient.discover() # print(SSDP.get_devices()) ssdp_daemon = thd.Timer(30, SSDP.discover) ssdp_daemon.setDaemon(True) ssdp_daemon.start()