class Bras(object): """ Базовый класс для Брасов """ def __init__(self, di): self.host = str(di["host"]) self.user = str(di["user"]) self.pwd = str(di["password"]) self.tn = None self.clname = str(di["name"]) self.greet = str(di["greetings"]) def __login(self): """ Метод для авторизации на Брасе результат сохраняет в базовом классе """ self.tn = Telnet(self.host, 23, 5) self.tn.get_socket().settimeout(TIMEOUT) res = self.tn.expect(["Username:"******"login:"******"\n") res = self.tn.expect(["Password:"******"\n") # > ma5200 and e120, # asr, $ lisg res = self.tn.expect([r">", r"#", r"\$"], 5) if res[0] == -1: self.tn.close() return False # we're in for sure self.prepare_cli() return True def write(self, string): """ Метод для ввода команды в телнет терминал """ try: self.tn.read_very_eager() self.tn.write(string + "\n") except (EOFError, AttributeError, IOError): res = self.__login() if not res: return False self.tn.write(string + "\n") except: print_exc() print_stack() print("Exc in write bras") res = self.__login() if not res: return False self.tn.write(string + "\n") return True
def sendTo(self, hosts=None, default_port=1000, module=0, msg=None): """ Send the message to the DEP. If the argument 'hosts' is an IP or a list of IP's, it iterate over them to have an answer. If the argument 'hosts' is an instance of DEPMessage, it uses the hosts known in the instance. Open a connection to the DEP, sends the message and return the answer in a synchronous manner. """ if msg: self.message = msg self.module = module telnet = Telnet() # t.set_debuglevel(100) if isinstance(hosts, str): hosts = (hosts,) elif isinstance(hosts, DEPMessage): self._hosts = hosts._hosts hosts = self._hosts.keys() for host in hosts or self.hosts: try: if host in self._hosts and self._hosts[host]: telnet = self._hosts[host] else: logger.info('%s not active in %r', host, self._hosts) if ':' in host: telnet.open(*host.split(':')) else: telnet.open(host, default_port) self._hosts[host] = telnet sock = telnet.get_socket() msg = self._build() bytessent = sock.send(msg) logger.debug('%d chars sent', bytessent) answer, size = b'', None while True: answer += sock.recv(4096) if not size and len(answer) >= 4: size = int(codecs.encode(answer[:4][::-1], 'hex'), 16) if len(answer) >= size: break readsel, _, _ = select([sock], [], [], 0.5) if len(readsel) == 0: answer += telnet.read_very_lazy() break break except socket.error: telnet.close() self._hosts[host] = None logger.exception('Socket issue with %s', host) continue else: raise ValueError('No dep available in the list : ' + str(hosts or self._hosts)) self.current_answer = codecs.encode(answer, 'hex').decode().upper() if LOG_DEPCALLS: # pragma: no cover with open('result.txt', 'ab') as out: out.write(b'>>' + codecs.encode(msg[13:], 'hex').upper() + b':' + self.current_answer.encode().upper() + b'\n') return self.current_answer
def make_raw_request(self, request): try: conn = Telnet(self.host, self.port) conn.write(request.encode("UTF-8")) return self.read_response(conn.get_socket()) finally: conn.close()
class ClientNetworkCore(SingletonCore,QObject): instance = None THREADED_REQUESTS = False waiting_response = Event() threaded_response = None def __init__(self): QObject.__init__(self) self.HOST = 'localhost' self.PORT = 50007 self.status = 'DESCONECTADO' self.connected = False self.last_success_request = (datetime.now() - timedelta(hours=1)) def dump_configuration(self): return {'HOST': self.HOST, 'PORT': self.PORT} def load_configuration(self,conf): if 'HOST' in conf: self.HOST = conf['HOST'] if 'PORT' in conf: self.PORT = conf['PORT'] # def timerEvent(self,event): # print "sucedio el evento en el client network core" # def start_timer(self): # self.clock_id = self.startTimer(1000) # def stop_timer(self): # self.killTimer(self.clock_id) def connect(self): try : self.conection = Telnet(self.HOST,self.PORT) self.sock = self.conection.get_socket() self.fd = self.sock.makefile() self.status = 'CONECTADO' self.connected = True except Exception, e: new_e = NetworkException( "No se pudo establecer la \ conexion con el server.\n Cheque que la direccion sea correcta o el server este encendido") new_e.log_level_msg = e.message raise new_e
class TelnetConsole(ConsoleInterface): def __init__(self, mtda): self.telnet = None self.host = "localhost" self.mtda = mtda self.port = 23 self.opened = False self.delay = 5 self.timeout = 10 """ Configure this console from the provided configuration""" def configure(self, conf): self.mtda.debug(3, "console.telnet.configure()") if 'host' in conf: self.host = conf['host'] if 'port' in conf: self.port = conf['port'] if 'delay' in conf: self.delay = conf['delay'] if 'timeout' in conf: self.timeout = conf['timeout'] def probe(self): self.mtda.debug(3, "console.telnet.probe()") result = True self.mtda.debug(3, "console.telnet.probe(): %s" % str(result)) return result def open(self): self.mtda.debug(3, "console.telnet.open()") result = self.opened if self.opened == False: try: self.telnet = Telnet() self.telnet.open(self.host, self.port, self.timeout) self.opened = True result = True except: result = False self.mtda.debug(3, "console.telnet.open(): %s" % str(result)) return result def close(self): self.mtda.debug(3, "console.telnet.close()") if self.opened == True: self.opened = False self.telnet.get_socket().shutdown(socket.SHUT_WR) self.telnet.close() self.telnet = None result = (self.opened == False) self.mtda.debug(3, "console.telnet.close(): %s" % str(result)) return result """ Return number of pending bytes to read""" def pending(self): self.mtda.debug(3, "console.telnet.pending()") if self.opened == True: result = self.telnet.sock_avail() else: result = False self.mtda.debug(3, "console.telnet.pending(): %s" % str(result)) return result """ Read bytes from the console""" def read(self, n=1): self.mtda.debug(3, "console.telnet.read(n=%d)" % n) if self.opened == False: time_before_open = time.time() self.open() if self.opened == False: # make sure we do not return too quickly if we could not connect self.mtda.debug(4, "console.telnet.read(): failed to connnect!") time_after_open = time.time() elapsed_time = time_after_open - time_before_open if elapsed_time < self.delay: delay = self.delay - elapsed_time self.mtda.debug( 4, "console.telnet.read(): sleeping {0} seconds".format( delay)) time.sleep(delay) data = bytearray() try: while n > 0 and self.opened == True: avail = self.telnet.read_some() data = data + avail n = n - len(avail) except socket.timeout: self.mtda.debug(2, "console.telnet.read(): timeout!") self.mtda.debug(3, "console.telnet.read(): %d bytes" % len(data)) return data """ Write to the console""" def write(self, data): self.mtda.debug(3, "console.telnet.write()") if self.opened == True: result = self.telnet.write(data) else: self.mtda.debug(2, "console.telnet.write(): not connected!") result = None self.mtda.debug(3, "console.telnet.write(): %s" % str(result)) return result
class Jptelnet(object): def __init__(self): self.host = settings.JASMIN_HOST self.port = settings.JASMIN_PORT self.username = settings.JASMIN_USER self.password = settings.JASMIN_PWD self.tn = None def got_connection(self): self.jcli = { 'host': self.host, 'port': self.port, 'username': self.username, 'password': self.password } self.outcome = None try: self.tn = Telnet(self.jcli['host'], self.jcli['port']) self.tn.set_option_negotiation_callback(self.process_option) self.tn.read_until(b"Authentication required.", 16) self.tn.write(b"\r\n") self.tn.read_until(b"Username:"******"\r\n") self.tn.read_until(b"Password:"******"\r\n") # We must be connected idx, obj, response = self.tn.expect( [rb'Welcome to Jasmin ([0-9a-z\.]+) console'], 16) if idx == -1: return (0) else: # Wait for prompt self.wait_for_prompt() except jCliSessionError as e: print('Exception in got connection', e) return (0) return (self.tn) def process_option(self, tn, command, option): if command == DO and option == TTYPE: tn.sendall(IAC + WILL + TTYPE) #print( 'Sending terminal type "mypython"') tn.sendall(IAC + SB + TTYPE + '\0' + 'mypython' + IAC + SE) elif command in (DO, DONT): #print ('Will', ord(option)) tn.sendall(IAC + WILL + option) elif command in (WILL, WONT): #print ('Do', ord(option)) tn.sendall(IAC + DO + option) def wait_for_prompt(self, command=None, prompt=rb'jcli :', to=20): """Will send 'command' (if set) and wait for prompt Will raise an exception if 'prompt' is not obtained after 'to' seconds """ if command is not None: self.tn.write(command) idx, obj, response = self.tn.expect([prompt], to) if idx == -1: if command is None: raise jCliSessionError('Did not get prompt (%s)' % prompt) else: raise jCliSessionError( 'Did not get prompt (%s) for command (%s)' % (prompt, command)) else: return response def interceptor(self, data): response = None try: direction = data[0] i_type = data[1] order = data[2] script = data[3] filters = data[4] self.tn = self.got_connection() except Exception: raise MissingKeyError('Missing parameter: Action required') if direction == 'mt': #its an mt interceptor if i_type == 'StaticMTInterceptor': self.tn.write(b"mtinterceptor -a\r\n") self.tn.write(b"type " + i_type.encode() + b"\r\n") self.tn.write(b"order " + order.encode() + b"\r\n") self.tn.write(b"script " + script.encode() + b"\r\n") self.tn.write(b"filters " + filters.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: self.tn.write(b"ko\r\n") response = resp.decode('ascii') elif i_type == 'remove': resp = self.wait_for_prompt(command=b"mtinterceptor -r " + order.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: self.tn.write(b"ko\r\n") response = resp.decode('ascii') elif i_type == 'flush': resp = self.wait_for_prompt(command=b"mtinterceptor -f\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: self.tn.write(b"ko\r\n") response = resp.decode('ascii') else: self.tn.write(b"mtinterceptor -a\r\n") self.tn.write(b"type " + i_type.encode() + b"\r\n") self.tn.write(b"script " + script.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: self.tn.write(b"ko\r\n") response = resp.decode('ascii') if self.tn is not None and self.tn.get_socket(): self.tn.close() return response else: #its an mo interceptor if i_type == 'StaticMOInterceptor': self.tn.write(b"mointerceptor -a\r\n") self.tn.write(b"type " + i_type.encode() + b"\r\n") self.tn.write(b"order " + order.encode() + b"\r\n") self.tn.write(b"script " + script.encode() + b"\r\n") self.tn.write(b"filters " + filters.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: self.tn.write(b"ko\r\n") response = resp.decode('ascii') elif i_type == 'remove': resp = self.wait_for_prompt(command=b"mointerceptor -r " + order.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: self.tn.write(b"ko\r\n") response = resp.decode('ascii') elif i_type == 'flush': resp = self.wait_for_prompt(command=b"mointerceptor -f\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: self.tn.write(b"ko\r\n") response = resp.decode('ascii') else: self.tn.write(b"mointerceptor -a\r\n") self.tn.write(b"type " + i_type.encode() + b"\r\n") self.tn.write(b"script " + script.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: self.tn.write(b"ko\r\n") response = resp.decode('ascii') if self.tn is not None and self.tn.get_socket(): self.tn.close() return response def stats(self, data): result = None try: action = data[0] self.tn = self.got_connection() except Exception: raise MissingKeyError('Missing parameter: Action required') if action == 'user': # Show user stats using it’s UID usr = data[1] response = self.wait_for_prompt(command=b"stats --user="******"\r\n") result = response.decode('ascii').strip().replace("\r", '').split( "\n") #splitlines() elif action == 'users': #Show stats for all users response = self.wait_for_prompt(command=b"stats --users\r\n") result = response.decode('ascii').strip().replace("\r", '').split("\n") elif action == 'smppc': #Show smpp connector stats using it’s CID cid = data[1] response = self.wait_for_prompt(command=b"stats --smppc=" + cid.encode() + b"\r\n") result = response.decode('ascii').strip().replace("\r", '').split( "\n") #splitlines() elif action == 'smppcs': #Show all smpp connectors stats response = self.wait_for_prompt(command=b"stats --smppcs\r\n") result = response.decode('ascii').strip().replace("\r", '').split("\n") elif action == 'smppsapi': #Show SMPP Server API stats response = self.wait_for_prompt(command=b"stats --smppsapi\r\n") result = response.decode('ascii').strip().replace("\r", '').split("\n") elif action == 'httpapi': #Show HTTP stats response = self.wait_for_prompt(command=b"stats --httpapi\r\n") result = response.decode('ascii').strip().replace("\r", '').split("\n") else: result = 'Unknown stats type' if self.tn is not None and self.tn.get_socket(): self.tn.close() return result def morouter(self, data): response = None try: action = data[0] self.tn = self.got_connection() except Exception: raise MissingKeyError('Missing parameter: Action required') if action == 'StaticMORoute': # 1 connector many filters types = action order = data[1] connector = data[2] filters = data[3] self.tn.write(b"morouter -a\r\n") self.tn.write(b"type " + types.encode() + b"\r\n") self.tn.write(b"order " + order.encode() + b"\r\n") self.tn.write(b"connector " + connector.encode() + b"\r\n") self.tn.write(b"filters " + filters.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'RandomRoundrobinMORoute': types = action order = data[1] connector = data[2] filt = data[3] filters = filt self.tn.write(b"morouter -a\r\n") self.tn.write(b"type " + types.encode() + b"\r\n") self.tn.write(b"order " + order.encode() + b"\r\n") self.tn.write(b"connectors " + connector.encode() + b"\r\n") self.tn.write(b"filters " + filters.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'FailoverMORoute': types = action order = data[1] connector = data[2] filt = data[3] filters = filt self.tn.write(b"morouter -a\r\n") self.tn.write(b"type " + types.encode() + b"\r\n") self.tn.write(b"order " + order.encode() + b"\r\n") self.tn.write(b"connectors " + connector.encode() + b"\r\n") self.tn.write(b"filters " + filters.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'DefaultRoute': types = action connector = data[1] self.tn.write(b"morouter -a\r\n") self.tn.write(b"type " + types.encode() + b"\r\n") self.tn.write(b"connector " + connector.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'remove': route = data[1] resp = self.wait_for_prompt(command=b"morouter -r " + route.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'flush': resp = self.wait_for_prompt(command=b"morouter -f \r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') else: response = 'Invalid MO router optoin' if self.tn is not None and self.tn.get_socket(): self.tn.close() return response def mtrouter(self, data): response = None try: action = data[0] self.tn = self.got_connection() except Exception: raise MissingKeyError('Missing parameter: Action required') if action == 'StaticMTRoute': # 1 connector many filters types = action order = data[1] connector = data[2] filt = data[3] filters = filt[:-1] rate = data[4] self.tn.write(b"mtrouter -a\r\n") self.tn.write(b"type " + types.encode() + b"\r\n") self.tn.write(b"order " + order.encode() + b"\r\n") self.tn.write(b"connector " + connector.encode() + b"\r\n") self.tn.write(b"filters " + filters.encode() + b"\r\n") self.tn.write(b"rate " + rate.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'RandomRoundrobinMTRoute': types = action order = data[1] connector = data[2] filt = data[3] filters = filt print('Filters', filters) rate = data[4] self.tn.write(b"mtrouter -a\r\n") self.tn.write(b"type " + types.encode() + b"\r\n") self.tn.write(b"order " + order.encode() + b"\r\n") self.tn.write(b"connectors " + connector.encode() + b"\r\n") self.tn.write(b"filters " + filters.encode() + b"\r\n") self.tn.write(b"rate " + rate.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'FailoverMTRoute': types = action order = data[1] connector = data[2] filt = data[3] filters = filt rate = data[4] self.tn.write(b"mtrouter -a\r\n") self.tn.write(b"type " + types.encode() + b"\r\n") self.tn.write(b"order " + order.encode() + b"\r\n") self.tn.write(b"connectors " + connector.encode() + b"\r\n") self.tn.write(b"filters " + filters.encode() + b"\r\n") self.tn.write(b"rate " + rate.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'DefaultRoute': types = action connector = data[1] rate = data[2] self.tn.write(b"mtrouter -a\r\n") self.tn.write(b"type " + types.encode() + b"\r\n") self.tn.write(b"connector " + connector.encode() + b"\r\n") self.tn.write(b"rate " + rate.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'remove': route = data[1] resp = self.wait_for_prompt(command=b"mtrouter -r " + route.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'flush': resp = self.wait_for_prompt(command=b"mtrouter -f\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') else: response = 'Invalid action for router' if self.tn is not None and self.tn.get_socket(): self.tn.close() return response def filters(self, data): response = None try: action = data[0] self.tn = self.got_connection() except Excebption: raise MissingKeyError('Missing parameter: Action required') if action == 'delete': filter = data[1] resp = self.wait_for_prompt(command=b"filter -r" + filter.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'create': fid = data[1].encode() ft = data[2] ftype = data[2].encode() fval = data[3].encode() if ft == 'TransparentFilter': self.tn.write(b"filter -a\r\n") self.tn.write(b"fid " + fid + b"\r\n") self.tn.write(b"type " + ftype + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif ft == 'ShortMessageFilter': self.tn.write(b"filter -a\r\n") self.tn.write(b"fid " + fid + b"\r\n") self.tn.write(b"type " + ftype + b"\r\n") self.tn.write(b"short_message " + fval + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif ft == 'DateIntervalFilter': self.tn.write(b"filter -a\r\n") self.tn.write(b"fid " + fid + b"\r\n") self.tn.write(b"type " + ftype + b"\r\n") self.tn.write(b"dateInterval " + fval + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif ft == 'TimeIntervalFilter': self.tn.write(b"filter -a\r\n") self.tn.write(b"fid " + fid + b"\r\n") self.tn.write(b"type " + ftype + b"\r\n") self.tn.write(b"timeInterval " + fval + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif ft == 'TagFilter': self.tn.write(b"filter -a\r\n") self.tn.write(b"fid " + fid + b"\r\n") self.tn.write(b"type " + ftype + b"\r\n") self.tn.write(b"tag " + fval + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif ft == 'EvalPyFilter': self.tn.write(b"filter -a\r\n") self.tn.write(b"fid " + fid + b"\r\n") self.tn.write(b"type " + ftype + b"\r\n") self.tn.write(b"uid " + fval + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif ft == 'UserFilter': self.tn.write(b"filter -a\r\n") self.tn.write(b"fid " + fid + b"\r\n") self.tn.write(b"type " + ftype + b"\r\n") self.tn.write(b"uid " + fval + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif ft == 'DestinationAddrFilter': self.tn.write(b"filter -a\r\n") self.tn.write(b"fid " + fid + b"\r\n") self.tn.write(b"type " + ftype + b"\r\n") self.tn.write(b"destination_addr " + fval + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif ft == 'GroupFilter': self.tn.write(b"filter -a\r\n") self.tn.write(b"fid " + fid + b"\r\n") self.tn.write(b"type " + ftype + b"\r\n") self.tn.write(b"gid " + fval + b"\r\n") self.tn.write(b"ok\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif ft == 'SourceAddrFilter': self.tn.write(b"filter -a\r\n") self.tn.write(b"fid " + fid + b"\r\n") self.tn.write(b"type " + ftype + b"\r\n") self.tn.write(b"source_addr " + fval + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') else: if self.tn is not None and self.tn.get_socket(): self.tn.close() return response return () def http_cons(self, data): response = None try: action = data[0] self.tn = self.got_connection() except Exception: raise MissingKeyError('Missing parameter: Action required') if action == 'create': cid = data[1] method = data[2] base_url = data[3] self.tn.write(b"httpccm -a\r\n") self.tn.write(b"cid " + cid.encode() + b"\r\n") self.tn.write(b"method " + method.encode() + b"\r\n") self.tn.write(b"url " + base_url.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'remove': cid = data[1] resp = self.wait_for_prompt(command=b"httpccm -r " + cid.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'update': response = self.wait_for_prompt(command=b"httpccm -u " + cid.encode() + b"\r\n") else: reponse = 'Invalid option for HTTP connectors' if self.tn is not None and self.tn.get_socket(): self.tn.close() return response def list_it(self, list_type=None): result = None self.tn = self.got_connection() try: if list_type == 'smppcs': response = self.wait_for_prompt(command=b"smppccm -l\r\n") result = response.decode('ascii').strip().replace( "\r", '').split("\n") #splitlines() elif list_type == 'imos': response = self.wait_for_prompt(self.tn, command="mointerceptor -l\r\n") result = response.strip().replace("\r", '').split( "\n") #splitlines() elif list_type == 'imts': response = self.wait_for_prompt( command=b"mtinterceptor -l\r\n") result = response.decode('ascii').strip().replace( "\r", '').split("\n") #splitlines() elif list_type == 'httpcs': response = self.wait_for_prompt(command=b"httpccm -l\r\n") result = response.decode('ascii').strip().replace( "\r", '').split("\n") #splitlines() elif list_type == 'mtrouter': response = self.wait_for_prompt(command=b"mtrouter -l\r\n") result = response.decode('ascii').strip().replace( "\r", '').split("\n") #splitlines() elif list_type == 'morouter': response = self.wait_for_prompt(command=b"morouter -l\r\n") result = response.decode('ascii').strip().replace( "\r", '').split("\n") #splitlines() elif list_type == 'filters': response = self.wait_for_prompt(command=b"filter -l\r\n") result = response.decode('ascii').strip().replace( "\r", '').split("\n") #splitlines() elif list_type == 'users': response = self.wait_for_prompt(command=b"user -l\r\n") result = response.decode('ascii').strip().replace( "\r", '').split("\n") #splitlines() elif list_type == 'groups': response = self.wait_for_prompt(command=b"group -l\r\n") result = response.decode('ascii').strip().replace( "\r", '').split("\n") #splitlines() elif list_type == 'httpapi': result = self.get_list_ids(response) elif list_type == 'smppsapi': users = self.get_smppsapi_stats(response) result['data'].append({'{#Stats}': stats}) except Exception as e: if result is not None: print(e) if self.tn is not None and self.tn.get_socket(): self.tn.close() return result if self.tn is not None and self.tn.get_socket(): self.tn.close() return result def connector(self, data): response = None try: action = data[0] self.tn = self.got_connection() except Exception: raise MissingKeyError('Missing parameter: Action required') if action == 'start': cid = data[1] resp = self.wait_for_prompt(command=b"smppccm -1 " + cid.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'stop': cid = data[1] resp = self.wait_for_prompt(b"smppccm -0 " + cid.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'remove': cid = data[1] resp = self.wait_for_prompt(command=b"smppccm -r " + cid.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'show': cid = data[1] resp = self.wait_for_prompt(command=b"smppccm -s " + cid.encode() + b"\r\n") response = resp.decode('ascii').strip().replace("\r", '').split( "\n") #splitlines() elif action == 'update': ripf = data[2] con_fail_delay = data[3] dlr_expiry = data[4] coding = data[5] logrotate = data[6] submit_throughput = data[7] elink_interval = data[8] bind_to = data[9] port = data[10] con_fail_retry = data[11] password = data[12] src_addr = data[13] bind_npi = data[14] addr_range = data[15] dst_ton = data[16] res_to = data[17] def_msg_id = data[18] priority = data[19] con_loss_retry = data[20] username = data[21] dst_npi = data[22] validity = data[23] requeue_delay = data[24] host = data[25] src_npi = data[26] trx_to = data[27] logfile = data[28] ssl = data[29] loglevel = data[30] bind = data[31] proto_id = data[32] dlr_msgid = data[33] con_loss_delay = data[34] bind_ton = data[35] pdu_red_to = data[36] src_ton = data[37] cid = data[1] self.tn.write(b"smppccm -u " + cid.encode() + b"\r\n") self.tn.write(b"bind " + bind.encode() + b"\r\n") self.tn.write(b"ripf " + ripf.encode() + b"\r\n") self.tn.write(b"con_fail_delay " + con_fail_delay.encode() + b"\r\n") self.tn.write(b"dlr_expiry " + dlr_expiry.encode() + b"\r\n") self.tn.write(b"coding " + coding.encode() + b"\r\n") self.tn.write(b"logrotate " + logrotate.encode() + b"\r\n") self.tn.write(b"submit_throughput " + submit_throughput.encode() + b"\r\n") self.tn.write(b"elink_interval " + elink_interval.encode() + b"\r\n") self.tn.write(b"bind_to " + bind_to.encode() + b"\r\n") self.tn.write(b"port " + port.encode() + b"\r\n") self.tn.write(b"con_fail_retry " + con_fail_retry.encode() + b"\r\n") self.tn.write(b"password " + password.encode() + b"\r\n") self.tn.write(b"src_addr " + src_addr.encode() + b"\r\n") self.tn.write(b"bind_npi " + bind_npi.encode() + b"\r\n") self.tn.write(b"addr_range " + addr_range.encode() + b"\r\n") self.tn.write(b"dst_ton " + dst_ton.encode() + b"\r\n") self.tn.write(b"res_to " + res_to.encode() + b"\r\n") self.tn.write(b"def_msg_id " + def_msg_id.encode() + b"\r\n") self.tn.write(b"priority " + priority.encode() + b"\r\n") self.tn.write(b"con_loss_retry " + con_loss_retry.encode() + b"\r\n") self.tn.write(b"username " + username.encode() + b"\r\n") self.tn.write(b"dst_npi " + dst_npi.encode() + b"\r\n") self.tn.write(b"validity " + validity.encode() + b"\r\n") self.tn.write(b"requeue_delay " + requeue_delay.encode() + b"\r\n") self.tn.write(b"host " + host.encode() + b"\r\n") self.tn.write(b"src_npi " + src_npi.encode() + b"\r\n") self.tn.write(b"trx_to " + trx_to.encode() + b"\r\n") self.tn.write(b"logfile " + logfile.encode() + b"\r\n") self.tn.write(b"ssl " + ssl.encode() + b"\r\n") self.tn.write(b"loglevel " + loglevel.encode() + b"\r\n") self.tn.write(b"proto_id " + proto_id.encode() + b"\r\n") self.tn.write(b"dlr_msgid " + dlr_msgid.encode() + b"\r\n") self.tn.write(b"con_loss_delay " + con_loss_delay.encode() + b"\r\n") self.tn.write(b"bind_ton " + bind_ton.encode() + b"\r\n") self.tn.write(b"pdu_red_to " + pdu_red_to.encode() + b"\r\n") self.tn.write(b"src_ton " + src_ton.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'create': cid = data[1] username = data[2] password = data[3] host = data[4] port = data[5] submit_throughput = data[6] self.tn.write(b"smppccm -a\r\n") self.tn.write(b"cid " + cid.encode() + b"\r\n") self.tn.write(b"username " + username.encode() + b"\r\n") self.tn.write(b"password " + password.encode() + b"\r\n") self.tn.write(b"host " + host.encode() + b"\r\n") self.tn.write(b"port " + port.encode() + b"\r\n") self.tn.write(b"submit_throughput " + submit_throughput.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') else: response = 'Invalid fucntion for connectors' if self.tn is not None and self.tn.get_socket(): self.tn.close() return response def users(self, data): #User and Group Management response = None try: action = data[0] self.tn = self.got_connection() except Exception: raise MissingKeyError('Missing parameter: Action required') types = 'users' if action == 'update': juser = data[1] default_src_addr = data[2] quota_http_throughput = data[3] quota_balance = data[4] quota_smpps_throughput = data[5] quota_sms_count = data[6] quota_early_percent = data[7] value_priority = data[8] value_content = data[9] value_src_addr = data[10] value_dst_addr = data[11] value_validity_period = data[12] author_http_send = data[13] author_http_dlr_method = data[14] author_http_balance = data[15] author_smpps_send = data[16] author_priority = data[17] author_http_long_content = data[18] author_src_addr = data[19] author_dlr_level = data[20] author_http_rate = data[21] author_validity_period = data[22] author_http_bulk = data[23] self.tn.write(b"user -u " + juser.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred defaultvalue src_addr " + default_src_addr.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred quota http_throughput " + quota_http_throughput.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred quota balance " + quota_balance.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred quota smpps_throughput " + quota_smpps_throughput.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred quota sms_count " + quota_sms_count.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred quota early_percent " + quota_early_percent.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred valuefilter priority " + value_priority.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred valuefilter content " + value_content.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred valuefilter src_addr " + value_src_addr.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred valuefilter dst_addr " + value_dst_addr.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred valuefilter validity_period " + value_validity_period.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred authorization http_send " + author_http_send.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred authorization http_dlr_method " + author_http_dlr_method.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred authorization http_balance " + author_http_balance.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred authorization smpps_send " + author_smpps_send.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred authorization priority " + author_priority.encode() + b"\r\n") self.tn.write( b"mt_messaging_cred authorization http_long_content " + author_http_long_content.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred authorization src_addr " + author_src_addr.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred authorization dlr_level " + author_dlr_level.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred authorization http_rate " + author_http_rate.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred authorization validity_period " + author_validity_period.encode() + b"\r\n") self.tn.write(b"mt_messaging_cred authorization http_bulk " + author_http_bulk.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'unbind': uid = data[1] resp = self.wait_for_prompt(command=b"user --smpp-unbind=" + uid.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'ban': uid = data[1] resp = self.wait_for_prompt(command=b"user --smpp-ban=" + uid.encode() + b"\r\n") print('RESP in ban', resp) if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'create_user': uid = data[1] username = data[2] password = data[3] gid = data[4] self.tn.write(b"user -a\r\n") self.tn.write(b"uid " + uid.encode() + b"\r\n") self.tn.write(b"gid " + gid.encode() + b"\r\n") self.tn.write(b"username " + username.encode() + b"\r\n") self.tn.write(b"password " + password.encode() + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'get_creds': uid = data[1] response = self.wait_for_prompt(command=b"user -s" + uid.encode() + b"\r\n") result = response.decode('ascii').strip().replace("\r", '').split("\n") return result elif action == 'create_group': gid = data[1] self.tn.write(b"group -a\r\n") self.tn.write(b"gid " + str.encode(gid) + b"\r\n") resp = self.wait_for_prompt(command=b"ok\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'enable_user': user = data[1] resp = self.wait_for_prompt(command=b"user -e" + user.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'enable_group': grp = data[1] resp = self.wait_for_prompt(command=b"group -e" + grp.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'disable_user': user = data[1] resp = self.wait_for_prompt(command=b"user -d" + user.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'disable_group': grp = data[1] resp = self.wait_for_prompt(command=b"group -d" + grp.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'remove_user': outcome = None user = data[1] resp = self.wait_for_prompt(command=b"user -r" + user.encode() + b"\r\n") if b'Successfully' in resp: response = self.tn.write(b"persist a\r\n") else: response = resp.decode('ascii') elif action == 'remove_group': grp = data[1] resp = self.wait_for_prompt(command=b"group -r" + grp.encode() + b"\r\n") if b'Successfully' in resp: response = self.wait_for_prompt(command=b"persist a\r\n") else: response = resp.decode('ascii') else: respone = 'Invalid action for user management' if self.tn is not None and self.tn.get_socket(): self.tn.close() return (response)
if __name__ == "__main__": skip_sysupgrade = False if len(sys.argv) < 2: print_help() if len(sys.argv) == 3: skip_sysupgrade = "--skip-sysup" == sys.argv[2] dev_ip = sys.argv[1] scp_target = "root@{}:/tmp".format(dev_ip) wait_for_ssh(dev_ip) print("Telnet Connect from rapberryPi {}, port {}".format(dev_ip, PORT)) state = "start" telnet_con = Telnet(dev_ip, str(PORT)) socket = telnet_con.get_socket() tfile = socket.makefile('rwb', buffering=0) bufferr = io.BufferedReader(tfile) bufferw = io.BufferedWriter(tfile) i2c_read_ok = False ril_ok = False # rdb_ok = False start_time = None app_ckeck_ok = False strip_ln_telnet = False str_ = '' try: so = io.TextIOWrapper(bufferw, encoding='ascii') si = io.TextIOWrapper(bufferr, encoding='ascii', errors='replace') except Exception as e: print(e.msg)
sys.path.append('/home/bluec0re/sources/pentesting_utils/ctf') from telnetlib import Telnet from pprint import pprint from timing import timeit import string TARGET = ('192.168.56.101', 54311) #s = socket.create_connection(TARGET) tn = Telnet(*TARGET) print(tn.read_until(b'in\n').decode()) #print(tn.read_until(b':').decode()) s = tn.get_socket() def callback(pwd): s.send(pwd) data = s.recv(512) if b'succ' in data: raise Exception(pwd) pwd = '' s = tn.get_socket() while True: timings = [] for i, c in enumerate(string.ascii_letters + string.digits): sys.stderr.write("\r{}".format(c)) pwd2 = pwd + c
print "se produjo una excepcion en la lectura" compresed = r_data.rstrip("\n") compresed = compresed.decode("hex") yaml_coded = zlib.decompress(compresed) print yaml_coded HOST = '192.168.1.12' # The remote host PORT = 50007 # The same port as used by the server try : conection = Telnet(HOST,PORT) except Exception, e: print "No se pudo establecer la conexion %s " % e sys.exit() conected = True sock = conection.get_socket() fd = sock.makefile() while conected: if fd.closed : break comando = raw_input("ingrese el comando: ") if comando == 'ok' : l = LightMap() l.name="luces cocina" l.comment="comentraio sobre las luces de la cocina" n = NetMsg() n.method='map_light' n.params=[l] n.status="conectado" encoded = zlib.compress(yaml.dump(n)).encode('hex')
class WS66iSync(WS66i): def __init__(self, host_name: str, host_port: int): self._host_name = host_name self._host_port = host_port self._connected = False self._telnet = Telnet() def __del__(self): self._telnet.close() def open(self): try: self._telnet.open(self._host_name, self._host_port, TIMEOUT) self._connected = True except (TimeoutError, OSError, socket.timeout, socket.gaierror) as err: raise ConnectionError from err @synchronized def close(self): self._telnet.close() self._connected = False def _process_request(self, request: bytes, expect_zone=None): """ :param request: request that is sent to the WS66i :param exepct_zone: The zone to fetch data from :return: Match object or None """ _LOGGER.debug('Sending "%s"', request) try: self._telnet.write(request) if expect_zone is not None: # Exepct a regex string to prevent unsynchronized behavior when # multiple clients communicate simultaneously with the WS66i expect_str = f"({expect_zone})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)" resp = self._telnet.expect([expect_str.encode()], timeout=TIMEOUT) _LOGGER.debug('Received "%s"', str(resp[1])) return resp[1] except UnboundLocalError: _LOGGER.error('Bad Write Request') except EOFError: _LOGGER.error('Expect str "%s" produced no result', expect_str) except (TimeoutError, socket.timeout, BrokenPipeError) as error: _LOGGER.error('Timed-Out with exception: %s', repr(error)) return None @synchronized def zone_status(self, zone: int): # Check if socket is open before reading zone status # Did the caller called open first? if not self._connected: _LOGGER.debug('Connection needed first') return None if not self._telnet.get_socket(): # The connection should be established, but an error was # encountered (most likely amp was turned off) # Attempt to re-establish the connection. try: self.open() except ConnectionError: return None zone_status = ZoneStatus.from_string( self._process_request(_format_zone_status_request(zone), zone)) if zone_status is None: # Amp is most likely turned off. Close the connection. # Future calls to zone_status will try to reconnect. self._telnet.close() return zone_status @synchronized def set_power(self, zone: int, power: bool): self._process_request(_format_set_power(zone, power)) @synchronized def set_mute(self, zone: int, mute: bool): self._process_request(_format_set_mute(zone, mute)) @synchronized def set_volume(self, zone: int, volume: int): self._process_request(_format_set_volume(zone, volume)) @synchronized def set_treble(self, zone: int, treble: int): self._process_request(_format_set_treble(zone, treble)) @synchronized def set_bass(self, zone: int, bass: int): self._process_request(_format_set_bass(zone, bass)) @synchronized def set_balance(self, zone: int, balance: int): self._process_request(_format_set_balance(zone, balance)) @synchronized def set_source(self, zone: int, source: int): self._process_request(_format_set_source(zone, source)) @synchronized def restore_zone(self, status: ZoneStatus): self.set_power(status.zone, status.power) self.set_mute(status.zone, status.mute) self.set_volume(status.zone, status.volume) self.set_treble(status.zone, status.treble) self.set_bass(status.zone, status.bass) self.set_balance(status.zone, status.balance) self.set_source(status.zone, status.source)
class Connection(object): def __init__(self, host, username, password, **kwargs): whoami = type(self).__name__ logging.debug( f' INSTANCE OF {whoami} CREATED: host = {host}, username = {username}' ) self.host = host self.port = kwargs.get('port', 23) self.username = username.encode('ascii') self.password = password.encode('ascii') self.socket = None self.connected = False # to-do: make it a property, reflecting state of socket if possible self.authenticated = False self.global_timeout = kwargs.get('global_timeout', 2) self.prompt = None self.promptsign = None self.banner = None self.rPROMPT = PROMPTc self.rLOGINPROMPT = LOGINPROMPTc self.rPASSPROMPT = PASSPROMPTc self.rENABLEPROMPT = ENABLEPROMPTc self.rAUTHFAIL = AUTHFAILc protocol = kwargs.get('protocol', 'tel') if protocol in con_protocols: self.protocol = protocol else: raise Exception(f'No such connection protocol: {protocol}') device_type = kwargs.get('device_type', 'generic') if device_type in device_types: self.device_type = device_type else: raise Exception(f'No such device type: {device_type}') device_role = kwargs.get('device_role', 'l2') if device_role in device_roles: self.device_role = device_role else: raise Exception(f'No such device role: {device_role}') auto_connect = kwargs.get('auto_connect', True) if auto_connect: logging.debug(f'AUTO CONNECTION: ({self.host}:{self.port})') self.connect() def connect(self): logging.debug( f'{logaux.generic} {logaux.con}: to {self.host}:{self.port}.') if self.protocol == 'tel': self.connect_tel() else: self.connect_ssh() if not self.authenticated: logging.debug( f' AUTH WILL BE STARTED: ({self.host}:{self.port}) username = {self.username}' ) self.auth() def connect_ssh(): raise NotImplemented() try: # to-do: try to connect self.authenticated = True except: # to-do: determine exception types pass def connect_tel(self): logging.debug( f'{logaux.telnet} {logaux.con}: to {self.host}:{self.port}.') try: self.connection = Telnet(host=self.host, port=self.port, timeout=self.global_timeout) self.socket = self.connection.get_socket() self.connected = True logging.debug( f'{logaux.telnet} {logaux.con}: ({self.host}:{self.port}) SUCCESSFUL.' ) except: # to-do: determine exception types self.connected = False logging.debug( f'{logaux.telnet} {logaux.con}: ({self.host}:{self.port}) UNSUCCESSFUL.' ) def send_command(self, command, **kwargs): logging.debug( f'{logaux.generic} {logaux.sending}: ({self.host}:{self.port}) command: "{command}"' ) expect = kwargs.get('expect', self.rPROMPT) timeout = kwargs.get('timeout', self.global_timeout) if not self.connected: self.connect() #trying to connect if not self.connected: logging.debug( f'{logaux.generic} {logaux.sending}: ({self.host}:{self.port}) command: "{command}" UNSUCCESSFUL, can not connect' ) raise Exception('can not connect') if not self.authenticated: logging.debug( f'{logaux.generic} {logaux.sending}: ({self.host}:{self.port}) command: "{command}" UNSUCCESSFUL, not authenticated' ) raise Exception('not authenticated') if self.protocol == 'tel': return self.send_command_tel(command, expect, timeout) elif self.protocol == 'ssh': raise Exception( 'Base_class - send_command for ssh not implemented yet') def send_command_tel(self, command, expect, timeout): logging.debug( f'{logaux.telnet} {logaux.sending}: ({self.host}:{self.port}) "{command}" , expecting: {expect.pattern}, with timeout {timeout}s.' ) try: self.connection.write(command.encode('ascii', 'ignore') + tENTER) logging.debug( f'{logaux.telnet} {logaux.snt}: ({self.host}:{self.port}) "{command}" ' ) _, m, output = self.connection.expect([expect], timeout) outputln = len(output) logging.debug( f'{logaux.telnet} {logaux.rcvd}: ({self.host}:{self.port}) for "{command}" received answer, length {outputln} bytes.' ) except (ConnectionAbortedError, EOFError): self.connected = False self.authenticated = False self.connect() if self.connected and self.authenticated: # try one more time self.connection.write( command.encode('ascii', 'ignore') + tENTER) _, _, output = self.connection.expect([expect], timeout) elif not self.connected: raise Exception('can not reconnect') elif self.connected and not self.authenticated: raise Exception('reconnected, but can not reauthenticate') #timestamp = now() - start #print(f'command {command} take {timestamp:.3f}s') output = output.replace(b'\r\n', b'\n').decode('utf-8', 'ignore') logging.debug( f'{logaux.telnet} {logaux.snt}: ({self.host}:{self.port}) for "{command}" decoded answer is:\n{output}' ) if output and '\n' in output: command_end = output.find('\n') prompt_start = (len(output) - 1) - output[::-1].find('\n') + 1 self.prompt = output[ prompt_start:] # what if there is /n check ?? if command_end == prompt_start - 1: return '' else: return output[command_end + 1:prompt_start] else: return '' def auth(self): if not self.connected: raise Exception('Authentication is not possible if not connected') if self.protocol == 'tel': logging.debug( f' TELNET AUTH WILL BE STARTED: ({self.host}:{self.port}) username = {self.username}' ) self.auth_tel() elif self.protocol == 'ssh': raise Exception('Base_class - auth for ssh not implemented yet') def auth_tel(self): logging.debug( f' TELNET AUTHENTICATION STARTED: ({self.host}:{self.port}) username = {self.username}' ) _, _, output = self.connection.expect([self.rLOGINPROMPT], self.global_timeout) self.banner = output.replace(b'\r\n', b'\n').decode('utf-8', 'ignore') logging.debug( f' TELNET AUTH USERNAME PROMPT: ({self.host}:{self.port}) banner+username prompt:\n{self.banner}' ) logging.debug( f' TELNET AUTH SENDING USERNAME: ({self.host}:{self.port}) username = {self.username}' ) self.connection.write(self.username + tENTER) logging.debug( f' TELNET AUTH USERNAME SENT: ({self.host}:{self.port}) username = {self.username}' ) _, m, output = self.connection.expect([self.rPASSPROMPT], self.global_timeout) logging.debug( f' TELNET AUTH PASSWORD PROMPT: ({self.host}:{self.port}) username+password prompt:\n{output}' ) logging.debug( f' TELNET AUTH SENDING PASSWORD: ({self.host}:{self.port})') self.connection.write(self.password + tENTER) logging.debug( f' TELNET AUTH PASSWORD SENT: ({self.host}:{self.port})') self.post_auth_check() def post_auth_check(self): logging.debug( f' POST AUTH CHECKING STARTED: ({self.host}:{self.port})') if not self.rAUTHFAIL: raise Exception('rAUTHFAIL not defined in subclass') logging.debug( f' WAITING FOR PROMPT/FAILURE MSG: ({self.host}:{self.port}), self.global_timeout = {self.global_timeout}' ) _, match, output = self.connection.expect( [self.rPROMPT, self.rAUTHFAIL], self.global_timeout) outputdecoded = output.decode('utf-8', 'ignore') logging.debug( f' GOT PROMPT/FAILURE MSG: ({self.host}:{self.port}) got:\n{outputdecoded}' ) if not match: self.authenticated = False raise AuthException('Authentication failed, nothing matched') if 'prompt' in match.groupdict(): self.authenticated = True self.promptsign = match.groupdict()['promptsign'].decode( 'utf-8', 'ignore') self.prompt = match.groupdict()['prompt'].decode( 'utf-8', 'ignore') + self.promptsign elif 'failmessage' in match.groupdict(): self.authenticated = False output = output.decode('utf-8', 'ignore') raise AuthException( f'Authentication failed, fail message:\n{output}') def disconnect(self): logging.debug( f' DISCONNECTING: ({self.host}:{self.port})') if self.connected: self.connection.close() def get_mactable(self): Iam = type(self).__name__ raise NotImplementedError(f'for {Iam} this method is not implemented') def get_intftable(self): Iam = type(self).__name__ raise NotImplementedError(f'for {Iam} this method is not implemented') def get_ipintftable(self): Iam = type(self).__name__ raise NotImplementedError(f'for {Iam} this method is not implemented') def get_intfullinfo(self): Iam = type(self).__name__ raise NotImplementedError(f'for {Iam} this method is not implemented') def get_arptable(self): Iam = type(self).__name__ raise NotImplementedError(f'for {Iam} this method is not implemented') def get_routingtable(self): Iam = type(self).__name__ raise NotImplementedError(f'for {Iam} this method is not implemented')
class rokuSB: def __init__(self, dtype): self.sb = Telnet() self.dpytype = dtype self.host = None def open(self, host): try: self.sb.open(host, 4444, 10) prompt = self.sb.expect([b'SoundBridge> ', b'sketch> '], 2) if (prompt[0] == -1): print("SB not responding") self.sb.close() return False except (ConnectionError, socket.error) as err: print("SoundBridge '{}', not found or connect failure = {}".format(host, err)) return False # Save host for reopen() self.host = host # Set character encoding default self.msg(encoding='utf8') self.cmd("irman echo") return True def reopen(self): if (self.host is None): return False assert(self.sb.get_socket() is None) return self.open(self.host) def close(self): if (self.sb.get_socket() is None): return try: # self.cmd("sketch -c clear") self.cmd("sketch -c exit") self.cmd("irman off") self.cmd("exit") except socket.error: print("Socket error in close = {}", sys.exc_info()) finally: if (self.sb.get_socket() is not None): self.sb.close() # Optional args to msg (soundbridge display) # # text - default none - can be omitted to just set font and encoding # x,y location - default 0,0 # font - # clear - 0/1 force the display to clear first (default 0) # encoding - set roku text encoding # def msg(self, **kwargs): x = kwargs.get('x', 0) y = kwargs.get('y', 0) text = kwargs.get('text') clear = kwargs.get('clear', False) font = kwargs.get('font') encoding = kwargs.get('encoding') if (encoding is not None): self.cmd("sketch -c encoding " + str(encoding)) if (font is not None): self.cmd("sketch -c font " + str(font)) if (text is None): return if (clear): self.clear() self.cmd('sketch -c text {} {} "{}"'.format(x, y, text)) return def cmd(self, text): try: self.sb.write(text.encode('utf-8') + b'\n') except socket.error: print("Socket error in write = {}", sys.exc_info()) if (self.sb.get_socket() is not None): self.sb.close() raise def clear(self): self.cmd("sketch -c clear") # Handle input and look for IR commands between panels def keyproc(self, timeout): self.cmd("irman intercept") try: msg = self.sb.expect([b'irman: (.*)$'], timeout) except EOFError: if (self.sb.get_socket() is not None): self.sb.close() raise # Got an IR code - pass it on to SB and exit app self.cmd("irman off") if (msg[0] == -1): return 'TIMEOUT' self.cmd("sketch -c exit") ir_cmd = msg[1].group(1) self.cmd("irman dispatch {}".format(ir_cmd)) return ir_cmd