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
