def init(self): """ Initialize the connection to the FRITZ!Box """ self._fc = fritzconnection.FritzConnection( address=self._fritz_address, port=self._fritz_port, user=self._fritz_user) if self._fc.modelname is None: self._fc = None raise IOError("fritzcollectd: Failed to connect to %s" % self._fritz_address) if not self._fc.call_action('WANIPConnection:1', 'GetStatusInfo'): self._fc = None raise IOError("fritzcollectd: Statusinformation via UPnP is " "not enabled") self._filter_service_actions(self.SERVICE_ACTIONS, self._fc.actionnames) if self._fritz_password != '': self._fc_auth = fritzconnection.FritzConnection( address=self._fritz_address, port=self._fritz_port, user=self._fritz_user, password=self._fritz_password) try: self._fc_auth.call_action('WANIPConnection:1', 'GetStatusInfo') self._filter_service_actions(self.SERVICE_ACTIONS_AUTH, self._fc_auth.actionnames) except XMLSyntaxError: self._fc = None self._fc_auth = None raise IOError("fritzcollectd: Incorrect password") else: collectd.info("fritzcollectd: No password configured, " "some values cannot be queried")
def __init__(self, host, user, passwd): self.host = host self.user = user self.passwd = passwd self.conn = fc.FritzConnection(address=self.host, user=self.user, password=self.passwd)
def init(self): """ Initialize the connection to the FRITZ!Box """ self._fc = fritzconnection.FritzConnection( address=self._fritz_address, port=self._fritz_port, user=self._fritz_user, password=self._fritz_password) if self._fc.modelname is None: self._fc = None raise IOError("fritzcollectd: Failed to connect to %s" % self._fritz_address) if not self._fc.call_action('WANIPConn:1', 'GetStatusInfo'): self._fc = None raise IOError("fritzcollectd: Statusinformation via UPnP is " "not enabled") if self._fritz_password != '': # If the 'Allow access for applications' option is disabled, # the connection behaves as if it was created without password. if 'WANIPConnection:1' not in self._fc.services.keys(): self._fc = None raise IOError("fritzcollectd: Allow access for applications " "is not enabled") try: self._fc.call_action('WANIPConnection:1', 'GetStatusInfo') except fritzconnection.AuthorizationError: self._fc = None raise IOError("fritzcollectd: Incorrect password or " "'FRITZ!Box Settings' rights for user disabled") else: collectd.info("fritzcollectd: No password configured, " "some values cannot be queried") self._filter_service_actions(self.SERVICE_ACTIONS, self._fc.actionnames)
def __init__(self, host, port, username, password): # pylint: disable=import-error import fritzconnection as fc self._connection = fc.FritzConnection(address=host, port=port, user=username, password=password)
def main(unused_argv): if FLAGS.verbose: logging.set_verbosity(logging.DEBUG) if FLAGS.ipv6_hack: # TODO(pkern): Eliminate this. Right now socketserver is IPv4-only, # so what we should do is actually bring up a proper HTTP server and # then map the path. However to enable IPv6 listening this is an # awful hack of monkey-patching to make it work for now. import socketserver import socket socketserver.TCPServer.address_family = socket.AF_INET6 client = fritzconnection.FritzConnection( address=FLAGS.address, user=FLAGS.username, password=FLAGS.password, ) logging.info( f'Connection succeeded to {client.modelname} on {FLAGS.address}') actions = collect_actions(client) logging.info(f'Collected {len(actions)} actions') variables = collect_variables(client, actions) logging.info(f'Collected {len(variables)} variables') address, port = FLAGS.listen.rsplit(':', 1) start_wsgi_server(port=int(port), addr=address) logging.info(f'Listening on {FLAGS.listen}') for sig in (signal.SIGTERM, signal.SIGINT, signal.SIGHUP): signal.signal(sig, quit) exit.wait()
def connect(self): logging.info("Connecting to Fritz!Box " + self.address + ":" + str(self.port) + " ...") self._connection = fritzconnection.FritzConnection(address = self.address, port = self.port, user = self.username, password = self.password) fritzboxLoopThread = threading.Thread(target=self._fritzboxLoop, name="fritzboxLoop") fritzboxLoopThread.start() self._threads.append(fritzboxLoopThread)
def main(): '''Application entry point.''' args = parse_args() logging.basicConfig( format='%(asctime)-15s %(levelname)s: %(message)s', level=(logging.DEBUG if args.verbose else logging.INFO)) settings = EnvSettingsResolver(SETTINGS_DESC) conn = fc.FritzConnection(address=settings.FRITZ_HOST, user=settings.FRITZ_USER, password=settings.FRITZ_PASS) results = [] results.extend(process_all(conn)) results.sort(key=lambda e: (e[0], e[1], e[2])) with open(args.csvfile, 'w', newline='') as fhdl: writer = csv.writer(fhdl) writer.writerow(['Service', 'Action', 'Attribute', 'Value']) for row in results: if args.data: writer.writerow(row) else: writer.writerow(row[0:3]) logging.info(f'Wrote {len(results)} services / actions to {args.csvfile}.')
def __init__( self, host, port, username, password, profile_on, profile_off, device_list, ): # pylint: disable=import-error import fritzconnection as fc from fritz_switch_profiles import FritzProfileSwitch self.connection = fc.FritzConnection(address=host, port=port, user=username, password=password) if device_list != DEFAULT_DEVICES: self.profile_switch = FritzProfileSwitch("http://" + host, username, password) self.fritzstatus = fc.FritzStatus(fc=self.connection) self.ha_ip = get_local_ip() self.profile_on = profile_on self.profile_off = profile_off self.profile_last_updated = time.time() self.device_list = device_list self.username = username self.password = password self.port = port self.host = host
def __init__(self, address=FRITZ_IP_ADDRESS, port=FRITZ_TCP_PORT): connection = fc.FritzConnection(address=address, port=port) print("Connected to FritzBox") self.connection = connection self.last_bytes_sent = self.bytes_sent self.last_bytes_received = self.bytes_received self.last_traffic_call = time.time()
def __init__(self, host, port, username, password, ha_ip): # pylint: disable=import-error import fritzconnection as fc self.connection = fc.FritzConnection(address=host, port=port, user=username, password=password) self.fritzstatus = fc.FritzStatus(fc=self.connection) self.ha_ip = ha_ip
def main(): prefs = read_configuration( os.path.join(os.path.dirname(__file__), "fritz-speed.ini")) fc = fritzconnection.FritzConnection(address=prefs["fritz_ip"]) status = fc.call_action("WANCommonIFC1", "GetAddonInfos") bytes_down = status["NewX_AVM_DE_TotalBytesReceived64"] bytes_up = status["NewX_AVM_DE_TotalBytesSent64"] update_rra(prefs["rra_filename"], str(bytes_up), str(bytes_down))
def __init__(self, fc=None, address=fritzconnection.fritzconnection.FRITZ_IP_ADDRESS, port=fritzconnection.fritzconnection.FRITZ_TCP_PORT, user=fritzconnection.fritzconnection.FRITZ_USERNAME, password=''): super(FritzConnect, self).__init__() if fc is None: fc = fritzconnection.FritzConnection(address, port, user, password) self.fc = fc
def __init__(self, fc=None, address=None, port=None, user=None, password=None): super(FritzHosts, self).__init__() if fc is None: fc = fritzconnection.FritzConnection(address, port, user, password) self.fc = fc
def _fritzboxLoop(self): logging.debug("Starting Fritz!Box loop ...") while not self._stopEvent.is_set(): for serviceName, serviceData in self.services.items(): for actionName, actionData in serviceData['actions'].items(): try: # Skip if period is not reached yet if (('lastRun' in actionData) and ((time.time() - actionData['lastRun']) < actionData['period'])): continue logging.debug("Querying data for service: %s action %s ..." % (serviceName, actionName)) res = self._connection.call_action(serviceName, actionName) for key, value in res.items(): # Skip keys not needed if key not in actionData['values']: continue topic = serviceData['prefix']+key if (key in actionData['values']) and ('topic' in actionData['values'][key]): topic = (serviceData['prefix'] + actionData['values'][key]['topic']).format( id = serviceData['id'] if ('id' in serviceData) else "" ) if ('type' in actionData['values'][key]): if (actionData['values'][key]['type'] == 'int'): value = int(value) elif (actionData['values'][key]['type'] == 'float'): value = float(value) elif (actionData['values'][key]['type'] == 'bool'): value = bool(value) else: value = str(value) if (('retain' in actionData['values'][key]) and (actionData['values'][key]['retain'] == 'true')): retain = True else: retain = False logging.debug('%s/%s/%s to %s: %r' % (serviceName, actionName, key, topic, value)) self._queue.put({'topic': topic, 'value': value, 'retain': retain}) actionData['lastRun'] = time.time() except fritzconnection.fritzconnection.ServiceError as e: logging.error("ServiceError: %r" % (e)) logging.info("Reconnecting to Fritz!Box " + self.address + ":" + str(self.port) + " ...") self._connection = fritzconnection.FritzConnection(address = self.address, port = self.port, user = self.username, password = self.password) except Exception as e: logging.error("Exception: %r" % (e)) self._stopEvent.wait(1)
def __init__(self, host, port, username, password): # pylint: disable=import-error import fritzconnection as fc self._connection = fc.FritzConnection(address=host, port=port, user=username, password=password) self._name = "GuestWifi" self._state = None self._icon = "mdi:wifi" self._update_timestamp = time.time()
def fritz_init(self): """ Initialize the connection to the FRITZ!Box """ try: self._fc = fritzconnection.FritzConnection( address=self._fritz_address, port=self._fritz_port, user=self._fritz_user, password=self._fritz_password) except IOError: collectd.error("fritzcollectd: Failed to connect to %s" % self._fritz_address)
def __init__(self, fc=None, address=fritzconnection.FRITZ_IP_ADDRESS, port=fritzconnection.FRITZ_TCP_PORT): super(FritzStatus, self).__init__() if fc is None: fc = fritzconnection.FritzConnection(address=address, port=port) self.fc = fc self.last_bytes_sent = self.bytes_sent self.last_bytes_received = self.bytes_received self.last_traffic_call = time.time()
def __init__(self, hass, config): """Initialize the connection.""" host = config[DOMAIN].get(CONF_HOST) port = config[DOMAIN].get(CONF_PORT) username = config[DOMAIN].get(CONF_USERNAME) password = config[DOMAIN].get(CONF_PASSWORD) self._hass = hass self._connection = fc.FritzConnection(address=host, port=port, user=username, password=password)
def connect(self, host, user, passwd): self._session = fritzconnection.FritzConnection(address=host, port=49000, user=user, password=passwd) # print(self._session.call_action('WANCommonInterfaceConfig', 'GetTotalBytesSent')['NewTotalBytesSent']) if not self._session.modelname: self._log.error('Cannot connect to Fritzbox') return False self._log.info('Connect to %s' % self._session.modelname) return self._session.modelname
def __init__(self, fritz_connection=None, address=fritzconnection.FRITZ_IP_ADDRESS, port=fritzconnection.FRITZ_TCP_PORT, user=fritzconnection.FRITZ_USERNAME, password=''): """Initialize a FritzCallforwarding instance.""" super(FritzCallforwarding, self).__init__() if fritz_connection is None: fritz_connection = fritzconnection.FritzConnection( address, port, user, password) self.fritz_connection = fritz_connection self.service = 1
def main(password=PASSWORD): """ Small python script to talk to your fritzbox """ global c print('[+] Connecting to "{}" ... '.format(ADDRESS)) c = fc.FritzConnection(address=ADDRESS, password=password) # check connection by getting DeviceInfo try: print('[+] Connected to ', c.call_action('DeviceInfo:1', 'GetInfo')['NewModelName']) except Exception as e: print('[-] Could not connect!') print(e) exit(1)
def __init__(self, fc=None, address=None, port=None, user=None, password=None): super(FritzStatus, self).__init__() if fc is None: fc = fritzconnection.FritzConnection( address=address, port=port, user=user, password=password, ) self.fc = fc self.last_bytes_sent = self.bytes_sent self.last_bytes_received = self.bytes_received self.last_traffic_call = time.time()
def getPhoneList(self): FRITZ_IP = self.config.get('main', 'FRITZ_IP') FRITZ_USER = self.config.get('main', 'FRITZ_USER') FRITZ_PASSWORD = self.config.get('main', 'FRITZ_PASSWORD') result = "Master, versuche die Anrufe zu ermitteln.." telitem = [ 'Kein Call', 'Kein Call', 'Kein Call', 'Kein Call', 'Kein Call' ] f = fc.FritzConnection(address=FRITZ_IP, user=FRITZ_USER, password=FRITZ_PASSWORD) fritz = f.call_action('X_AVM-DE_OnTel', 'GetCallList') print( "This is the URL for the callers, including session token for now: " + fritz["NewCallListURL"]) xmlhandle = urllib.request.urlopen(fritz["NewCallListURL"]) xmlresult = xmlhandle.read() xmlhandle.close() root = ET.fromstring(xmlresult) result = "Master, hier die verpassten Anrufe (letzte 5):\n" thisCall = "" maxResults = 4 countedresults = 0 for callerID in root.iter('Call'): if callerID.find("Type").text == '2': callDate = callerID.find("Date").text inPhoneBook = callerID.find("Name").text callerNumber = callerID.find("Caller").text thisCall = callDate + ":\n" if callerNumber is not None: thisCall = thisCall + callerNumber if inPhoneBook is not None: thisCall = thisCall + " (" + inPhoneBook + ")" thisCall = thisCall + "\n" telitem[countedresults] = thisCall result = result + thisCall countedresults = countedresults + 1 # print countedresults if countedresults > maxResults: # print "break now" break return {'reply': result, 'tellist': telitem}
def __init__(self, settings, metrics): self.request_tm = Summary( 'pfbex_tr64_requests', 'Time and count for each TR-64 request to the FritzBox') self.conn = fc.FritzConnection(address=settings.FRITZ_HOST, user=settings.FRITZ_USER, password=settings.FRITZ_PASS) self._settings = settings self._cfg = metrics for item in self._cfg.values(): item['fails'] = 0 self._serial = 'n/a' self._data = {} self._last_clear_time = datetime.now()
def setup_platform(hass, config, add_devices, discovery_info=None): """Set up the FRITZ!Box status sensors.""" # pylint: disable=import-error import fritzconnection as fconn from fritzconnection.fritzconnection import FritzConnectionException host = config.get(CONF_HOST) username = config.get(CONF_USERNAME) password = config.get(CONF_PASSWORD) fc = fconn.FritzConnection(address=host, user=username, password=password) try: fstatus = fconn.FritzStatus(fc) except (ValueError, TypeError, FritzConnectionException): fstatus = None if fstatus is None: _LOGGER.error("Failed to establish connection to FRITZ!Box: %s", host) return 1 else: _LOGGER.info("Successfully connected to FRITZ!Box") add_devices([FritzboxStateSensor(fc)], True)
def process_isp_logs(isp_address: str, isp_uname: str, isp_pword: str) -> list: """ Function to join together multiple operations related to the Fritz ISP Router portion of the script. Args: isp_address (str): hostname / IP Address of the target FritzBox device isp_uname (str): Username to log in to the device isp_pword (str): Password to log in to the device Raises: N/A Returns: new_entries (list): List of LogEntry objects from the device which are not yet present in the local logfile. Can be used for further processing with a notifier. """ # Create a logs directory to save the results into. log_dir = os.path.join(dirname, "..", "logs") output_dir = create_log_dir(log_dir=log_dir) log_file = f"{output_dir}/{isp_address}.log" # Initialise connection to Fritz ISP Router conn = fritzconnection.FritzConnection(address=isp_address, user=isp_uname, password=isp_pword) # Read log entries from the local logfile file_entries = load_list_from_logfile(filepath=log_file) device_entries = get_list_from_device(conn=conn) # get the log entries which are present on the device # but not yet written to the local logfile new_entries = get_list_of_new_entries(file_entries=file_entries, device_entries=device_entries) # Append only the log entries which are not yet present to the local logfile append_list_to_logfile(log_entries=new_entries, filepath=log_file) # return the new log entries for the notifiers of choice return new_entries
def init_fritzconnection(): global fc fc = fritzconnection.FritzConnection( address=os.getenv("FB_ADDRESS"), password=os.getenv("FB_PASSWORD"))
def main(): signal.signal(signal.SIGTERM, shutdown) signal.signal(signal.SIGINT, shutdown) # parse command line arguments args = parse_args() # set logging log_level = logging.DEBUG if args.debug == True else default_loglevel logging.basicConfig(level=log_level, format="%(levelname)s: %(message)s") # check if config file exists if not os.path.isfile(args.config_file): logging.error("config file \"%s\" not found" % args.config_file) exit(1) # read config from ini file config = read_config(args.config_file) logging.info("Done parsing config file") # set up influxdb handler influxdb_client = influxdb.InfluxDBClient( config.get('influxdb', 'host'), config.getint('influxdb', 'port'), config.get('influxdb', 'username'), config.get('influxdb', 'password'), config.get('influxdb', 'database'), ) # check influx db status check_db_status(influxdb_client, config.get('influxdb', 'database')) logging.info("Connection to InfluxDB established and database present") # create unauthenticated FB client handler fritz_client_unauth = fritzconnection.FritzConnection( address=config.get('fritzbox', 'host'), port=config.get('fritzbox', 'port'), ) # test connection if fritz_client_unauth.modelname is None: logging.error("Failed to connect to %s" % config.get('fritzbox', 'host')) exit(1) # create authenticated FB client handler fritz_client_auth = fritzconnection.FritzConnection( address=config.get('fritzbox', 'host'), port=config.get('fritzbox', 'port'), user=config.get('fritzbox', 'username'), password=config.get('fritzbox', 'password') ) # test connection if fritz_client_auth.modelname is None: logging.error("Failed to connect to %s" % config.get('fritzbox', 'host')) exit(1) logging.info("Successfully connected to FritzBox") # read services from config file unauth_services = get_services(config, "service") auth_services = get_services(config, "auth_service") while running: points = query_points(fritz_client_unauth, unauth_services) points.update(query_points(fritz_client_auth, auth_services)) data = { "measurement": config.get('influxdb', 'measurement_name'), "time": datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ'), "fields": points } try: logging.debug("writing data to InfluxDB") influxdb_client.write_points([data], time_precision="ms") except Exception: logging.error("Failed to write to InfluxDB %s" % config.get('influxdb', 'host')) # just sleep for 10 seconds time.sleep(10)
def __init__(self): self.conn = fc.FritzConnection(password='******')
def __init__(self, address, port, user, password): super(FritzAccess, self).__init__() self.fc = fritzconnection.FritzConnection(address, port, user, password)