def parse_address(local_address, str): check.check_is_af_inet_address(local_address) #=@R19 try: match = re.match(r"\s*(.+)\s*:\s*([0-9]+)\s*$", str) if match: ret = (socket.gethostbyname(match.group(1)), string.atoi(match.group(2))) else: match = re.match(r"\s*([0-9]+)\s*$", str) if match: ret = (local_address[0], string.atoi(match.group(1))) else: ret = (socket.gethostbyname(string.strip(str)), settings.default_ports[0]) check.check_is_af_inet_address(ret) #=@E9 # Proof: socket.gethostbyname returns a string, atoi returns an int, # settings.default_ports is a non-empty list of integers. # local_address is itself an af_inet_address (@R19), so its first # element is a string suitable for an af_inet_address. local_address # is deeply immutable from @E11. return ret except: raise error.Error(_("Could not find peer.\n"+\ "Please give a valid IP address or machine name,\n"+\ "optionally followed by a colon and a port number"))
def acq_change_thread(ns, acq, address, call_id, node): check.check_is_af_inet_address(address) #=@R29 try: result, subthread = try_address(acq,address,node) yield 'wait',subthread if not result[0]: return except error.Error: return #acq.lock.acquire() #acq.status = status #acq.lock.release() ns.acquaintance_status_changed(acq, 'connect')
def identity_test_thread(address, key, the_node, id_test_result): #from node import Node # Test identity check.check_is_af_inet_address(address) #check.check_isinstance(the_node, Node) tester = utility.random_bytes(settings.name_bytes) ticket, template, wait = the_node.call(address, ('identity test',tester)) if wait: yield 'call',(the_node,ticket) try: result = the_node.get_reply(ticket, template) except error.Error,err: print "error",err id_test_result.append(0) return
def handle(self, request, address,call_id): check.check_matches(request, (types.StringType,)) #=@R34 check.check_is_af_inet_address(address) #=@R31 self.lock.acquire() try: if request[0] == 'chat look': return (not self.quiet, self.activity) if request[0] in ['chat message 2']: unpacked = safe_pickle.loads(request[1]) # TODO check unpacked against template # TODO don't unpack twice (here and in receive task) sender = unpacked['from'] recipients = unpacked['to'] for recipient in recipients: if recipient[0] == self.app.name_server.public_key_name: break if recipient[2][:1] == '#' and \ self.channels.is_listening_to(recipient[2]) and \ sender[0] != self.app.name_server.public_key_name: break else: return None if not self.repeated(address,call_id): if self.quiet: new_item = (request, address, time.time()) check.check_matches(new_item, unread_message_list_item_tmpl) # Proof: @R34,@R31, and not having modified request or # address, and the relevant types being immutable # (partly by @E11). time.time() returns float. # Relevance: @R.I15. self.unread_message_list.append(new_item) self.set_prompt() del new_item else: self.receive(request,address,self.quiet,time.time()) # Proof of @R33: @R31; deep immutability by @E11. # Proof of @R35: time.time() returns float. return (not self.quiet, self.activity) finally: self.lock.release()
def handle(self, request,address,call_id): check.check_matches(request, (types.StringType,)) check.check_is_af_inet_address(address) # Idempotence is a bugger if request[0] == 'data cache store' or \ request[0] == 'data cache store multi': self.lock.acquire() try: if self.cached_items.has_key(request[1]): if self.cached_items[request[1]].call == (address,call_id): return None return Error('already storing') if request[0] == 'data cache store': names = [ request[2] ] else: names = request[2] if len(names) > settings.max_cache_names: return Error('too many names') item = Cache_item(names,request[3],request[4],(address,call_id)) self.cached_items[request[1]] = item # here is the actual publish: redundancy is settings.cache_redundancy for name in names: self.node.publish(name, request[3], settings.cache_redundancy) finally: self.lock.release() return None if request[0] == 'data cache remove': self.lock.acquire() try: lock = hash.hash_of(request[1]) if self.cached_items.has_key(lock): self.node.unpublish(self.cached_items[lock].data) del self.cached_items[lock] finally: self.lock.release() return None
def handle(self, request, ignored__address, call_id): check.check_matches(request, (types.StringType,)) check.check_is_af_inet_address(ignored__address) if request[0] == 'gossip list': #TODO: Type checking, locking, oh, and this is really inefficient self.any_gossip_gets = 1 list = [ ] for item in self.gossip[:]: list.append((to_fixed(item.distance(self.app.name_server)), item.unit_decay_time, item.signature)) list.sort() return list[request[1]:request[2]] elif request[0] == 'gossip get': for item in self.gossip: if item.signature == request[1]: return item.string return error.Error(_("No such wodge."))
def handle(self, request, address, call_id): check.check_matches(request, (types.StringType,)) check.check_is_af_inet_address(address) if request[0] == 'auction bid': name = request[1] bid = request[2] if self.auctions.has_key(name): print "auction found" if self.auctions_prices[name] < bid: self.auctions_prices[name] = bid return 'ok' else: print "bid too low" return 'bid too low' else: return 'error: no such auction' elif request[0] == 'auction list': list = self.auctions return list
def __init__(self, host,password=None, transient_for=None): utility.Synchronous.__init__(self) if sys.platform == 'win32': self.read_stdout, self.write_stdin = _make_connection_win32(host,password) else: self.read_stdout, self.write_stdin = _make_connection_daemon(host,password) #On win32 newline is \n\r, confusion ensues #line = self.read_stdout.readline() line = '' while 1: char = self.read_stdout.read(1) if char == '\n' or not char: break line = line + char if line[:5] != 'PORT ': self.write_stdin.close() self.read_stdout.close() if sys.platform == 'win32': message = 'Attempt to start the proxy failed.\n\n' + \ 'Check the username, server name and password.\n\n' + \ '(see "Help" for more information)' else: message = 'Attempt to start the proxy failed.\n\n'+\ 'Check your username, server name and password.' raise Error(message) self.address = ('127.0.0.1', string.atoi(line[5:])) self.broken = 0 self.running = 1 check.check_is_af_inet_address(self.address) #=@E3
def handle(self, request, address, call_id): check.check_matches(request, (types.StringType,)) check.check_is_af_inet_address(address) if request[0] == 'download chunk': path, mtime = self.paths.get(request[1],(None,None)) if not path: path, mtime = self.private_paths.get(request[1],(None,None)) try: if not path or \ os.path.getmtime(path) != mtime: return Error("no such file") file = open(path,'rb') except IOError: return Error("no such file") if address[0] !='127.0.0.1'\ and address not in self.node.trusted_addresses \ and self.private_directory != ''\ and utility.is_subdir(path,self.private_directory): return Error("access denied") try: file.seek(request[2]) return file.read(request[3]) finally: file.close() elif request[0] == 'files available': if len(request) == 3: # this returns the keys of # all published files from all directories # regardless of the directory structure list = self.paths.keys() else: list = [ ] access_denied = 0 directory_found = 0 string_request = [] for str in request[3]: string_request.append(utility.force_string(str)) if not self.roots: return Error('No public directory') request_dir = apply( os.path.join, [os.path.abspath(self.roots[0][0])] + string_request) if address[0]=='127.0.0.1': flags = flags_local else: flags = flags_fast if os.path.exists(request_dir): directory_found = 1 if address[0]!='127.0.0.1' \ and address not in self.node.trusted_addresses\ and self.private_directory != ''\ and utility.is_subdir(request_dir,self.private_directory): access_denied = 1 if not directory_found: return Error("no such directory: %s"%request_dir) elif access_denied: return Error("access denied") entry = build_entry(request_dir,None,flags,self) if entry: if not entry.is_dir: return Error("not a directory: "+request_dir) for file in entry.files: entry_2 = build_entry(file,None,flags,self) if entry_2: info = entry_2.info.copy() info['path'] = request[3] + [ info['filename'] ] list.append(info) return list[request[1]:request[2]]
def handle(self, request, address,call_id): check.check_matches(request, (types.StringType,)) check.check_is_af_inet_address(address) #=@R30 if request[0] == 'identity test': check.check_matches(request[1:], ('name',)) return self.sign('identity test ' + request[1]) elif request[0] == 'identity query': return self.get_info() elif request[0] == 'identity watch': self.lock.acquire() try: if address not in self.watchers: self.watchers.append(address) status = self.status finally: self.lock.release() return status elif request[0] == 'identity abort': def abort_thread(self, address=address): id_test_result = [] yield 'wait', identity_test_thread(address,self.public_key,self.node,id_test_result) if not id_test_result[0]: print "error testing identity" return self.aborted = 1 self.app.shutdown(_('Reconnecting from different machine')) utility.start_thread(abort_thread(self)) return None elif request[0] == 'identity connecting': if not (len(request) >= 2): return error.Error('Name_server.handle: identity connecting: expecting tuple of at least 2.') self.acquire_lock('get acq') try: acq = self.acquaintances.get(request[1]) finally: self.release_lock('get acq') if acq is None: return error.Error(_("I don't know you.")) else: #if len(request) > 2: # status = request[2] #else: # status = { } def acq_change_thread(ns, acq, address, call_id, node): check.check_is_af_inet_address(address) #=@R29 try: result, subthread = try_address(acq,address,node) yield 'wait',subthread if not result[0]: return except error.Error: return #acq.lock.acquire() #acq.status = status #acq.lock.release() ns.acquaintance_status_changed(acq, 'connect') utility.start_thread(acq_change_thread(self, acq, address, call_id, self.node)) # Proof of @R29: @R30; deeply immutable by @E11. return None elif request[0] == 'identity status changed': if not (len(request) >= 3): return error.Error('Name_server.handle: identity status changed: expecting tuple of at least 3.') self.lock.acquire() try: acq = self.acquaintances.get(request[1],None) if acq: acq.lock.acquire() try: acq.status = request[2] finally: acq.lock.release() self.acquaintance_status_changed(acq, 'status changed') finally: self.lock.release() elif request[0] == 'identity disconnecting': if not (len(request) >= 2): return error.Error('Name_server.handle: identity disconnecting: expecting tuple of at least 2.') self.lock.acquire() if address in self.watchers: self.watchers.remove(address) if self.acquaintances.has_key(request[1]): acq = self.acquaintances[request[1]] self.lock.release() if acq.disconnection(address): self.acquaintance_status_changed(acq, 'disconnect', message=request[2]) return None else: self.lock.release() return error.Error(_("I don't know you."))
def random_af_inet_address(): ret = (random_nullless_string(), random_int()) check.check_is_af_inet_address(ret) return ret