import logging, json, os, re, sys, time, socket from Plugin import PluginManager from Config import config from Debug import Debug from http.client import HTTPSConnection, HTTPConnection, HTTPException from base64 import b64encode from pathlib import Path from .NamecoinUtils import is_namecoin_installed, is_namecoin_running, get_namecoin_conf, check_namecoin_rpc_conf, start_namecoin, kill_namecoin allow_reload = False # No reload supported @PluginManager.registerTo("SiteManager") class SiteManagerPlugin(object): def __del__(self): if self.namecoin_pid: kill_namecoin(self.namecoin_pid) self.log.debug("Kill namecoin pid : {}".format(self.namecoin_pid)) return def load(self, *args, **kwargs): super(SiteManagerPlugin, self).load(*args, **kwargs) self.log = logging.getLogger("ZeronameLocal Plugin") self.error_message = None self.namecoin_pid = None self.config = dict({ 'rpcconnect': config.namecoin_host, 'rpcport': config.namecoin_rpcport, 'rpcuser': config.namecoin_rpcuser, 'rpcpassword': config.namecoin_rpcpassword, 'path': config.namecoin_path }) self.log.debug("Namecoin config through CLI ? {}".format(self.config)) self.log.debug("Namecoin installed ? {}".format(is_namecoin_installed())) if sys.platform.startswith('linux') and is_namecoin_installed(): self.log.debug("Namecoin running ? {}".format(is_namecoin_running())) if is_namecoin_running() is not None: if check_namecoin_rpc_conf(self.config) is not True: self.config = get_namecoin_conf() if check_namecoin_rpc_conf(self.config) is not True: self.error_message = "Missing parameters" self.log.error("Missing parameters to connect to namecoin node. Please check all the arguments needed with '--help' or provide them in the namecoin.conf. Zeronet will continue working without it.") return else: if config.namecoin_path is not None: self.namecoin_pid = start_namecoin(self.config['path']) self.log.debug("Namecoin starting ? {}".format(str(self.namecoin_pid))) else: self.log.error("Please use --namecoin_path to specify namecoind binary path") if check_namecoin_rpc_conf(self.config) is not True: self.error_message = "Missing parameters" self.log.error("Namecoin is not installed or parameters are missing to connect to namecoin node. Please check all the arguments needed with '--help'. Zeronet will continue working without it.") return url = "%(host)s:%(port)s" % {"host": self.config['rpcconnect'], "port": self.config['rpcport']} self.c = HTTPConnection(url, timeout=3) user_pass = "%(user)s:%(password)s" % {"user": self.config['rpcuser'], "password": self.config['rpcpassword']} userAndPass = b64encode(bytes(user_pass, "utf-8")).decode("ascii") self.headers = {"Authorization" : "Basic %s" % userAndPass, "Content-Type": " application/json " } payload = json.dumps({ "jsonrpc": "2.0", "id": "zeronet", "method": "ping", "params": [] }) try: self.c.request("POST", "/", payload, headers=self.headers) response = self.c.getresponse() data = response.read() self.c.close() if response.status == 200: result = json.loads(data.decode())["result"] else: raise Exception(response.reason) except Exception as err: self.log.error("The Namecoin node is unreachable. Please check the configuration value are correct. Zeronet will continue working without it.") self.error_message = err self.cache = dict() # Checks if it's a valid address def isAddress(self, address): return self.isBitDomain(address) or super(SiteManagerPlugin, self).isAddress(address) # Return: True if the address is domain def isDomain(self, address): return self.isBitDomain(address) or super(SiteManagerPlugin, self).isDomain(address) # Return: True if the address is .bit domain def isBitDomain(self, address): return re.match(r"(.*?)([A-Za-z0-9_-]+\.bit)$", address) # Return: Site object or None if not found def get(self, address): if self.isBitDomain(address): # Its looks like a domain address_resolved = self.resolveDomain(address) if address_resolved: # Domain found site = self.sites.get(address_resolved) if site: site_domain = site.settings.get("domain") if site_domain != address: site.settings["domain"] = address else: # Domain not found site = self.sites.get(address) else: # Access by site address site = super(SiteManagerPlugin, self).get(address) return site # Return or create site and start download site files # Return: Site or None if dns resolve failed def need(self, address, *args, **kwargs): if self.isBitDomain(address): # Its looks like a domain address_resolved = self.resolveDomain(address) if address_resolved: address = address_resolved else: return None return super(SiteManagerPlugin, self).need(address, *args, **kwargs) # Resolve domain # Return: The address or None def resolveDomain(self, domain): domain = domain.lower() #remove .bit on end if domain[-4:] == ".bit": domain = domain[0:-4] domain_array = domain.split(".") if self.error_message: self.log.error("Not able to connect to Namecoin node : {!s}".format(self.error_message)) return None if len(domain_array) > 2: self.log.error("Too many subdomains! Can only handle one level (eg. staging.mixtape.bit)") return None subdomain = "" if len(domain_array) == 1: domain = domain_array[0] else: subdomain = domain_array[0] domain = domain_array[1] if domain in self.cache: delta = time.time() - self.cache[domain]["time"] if delta < 3600: # Must have been less than 1hour return self.cache[domain]["addresses_resolved"][subdomain] payload = json.dumps({ "jsonrpc": "2.0", "id": "zeronet", "method": "name_show", "params": ["d/"+domain] }) try: self.c.request("POST", "/", payload, headers=self.headers) response = self.c.getresponse() data = response.read() self.c.close() domain_object = json.loads(data.decode())["result"] except Exception as err: #domain doesn't exist return None if "zeronet" in domain_object["value"]: zeronet_domains = json.loads(domain_object["value"])["zeronet"] if isinstance(zeronet_domains, str): # { # "zeronet":"19rXKeKptSdQ9qt7omwN82smehzTuuq6S9" # } is valid zeronet_domains = {"": zeronet_domains} self.cache[domain] = {"addresses_resolved": zeronet_domains, "time": time.time()} elif "map" in domain_object["value"]: # Namecoin standard use {"map": { "blog": {"zeronet": "1D..."} }} data_map = json.loads(domain_object["value"])["map"] zeronet_domains = dict() for subdomain in data_map: if "zeronet" in data_map[subdomain]: zeronet_domains[subdomain] = data_map[subdomain]["zeronet"] if "zeronet" in data_map and isinstance(data_map["zeronet"], str): # {"map":{ # "zeronet":"19rXKeKptSdQ9qt7omwN82smehzTuuq6S9", # }} zeronet_domains[""] = data_map["zeronet"] self.cache[domain] = {"addresses_resolved": zeronet_domains, "time": time.time()} else: # No Zeronet address registered return None return self.cache[domain]["addresses_resolved"][subdomain] @PluginManager.registerTo("ConfigPlugin") class ConfigPlugin(object): def createArguments(self): group = self.parser.add_argument_group("Zeroname Local plugin") group.add_argument('--namecoin_host', help="Host to namecoin node (eg. 127.0.0.1)") group.add_argument('--namecoin_rpcport', help="Port to connect (eg. 8336)") group.add_argument('--namecoin_rpcuser', help="RPC user to connect to the namecoin node (eg. nofish)") group.add_argument('--namecoin_rpcpassword', help="RPC password to connect to namecoin node") group.add_argument('--namecoin_path', help="Path to namecoind binary") return super(ConfigPlugin, self).createArguments()