def __init__(self, porta, use_fake, id_sessao, time_slot, max_retries,
timeout_arq, timeout_session, check_interval):
'''
Cria um objeto Protocolo, responsável por inicializar
todas as subcamadas
'''
if (use_fake):
self.cb = fake_layer.FakeLayer(sys.stdin)
else:
tun = Tun("tun0",
"10.0.0.1",
"10.0.0.2",
mask="255.255.255.252",
mtu=1500,
qlen=4)
tun.start()
self.cb = tun_layer.TunLayer(tun)
self.e = enquadramento.Enquadramento(porta, 1024, 3)
self.a = arq_mac.ARQ_MAC(timeout_arq, time_slot, id_sessao,
max_retries)
self.s = sessao.Sessao(timeout_session, check_interval)
# Define organização das subcamadas
self.cb.set_lower(self.s)
self.s.set_upper(self.cb)
self.s.set_lower(self.a)
self.a.set_upper(self.s)
self.a.set_lower(self.e)
self.e.set_upper(self.a)
def __init__(self,
p_serial,
idSessao,
timeout,
ip1,
ip2,
bytes_min=0,
bytes_max=256):
self.min_bytes = bytes_min
self.max_bytes = bytes_max
self.timeout = timeout
self.ser = serial.Serial(
p_serial, 9600,
timeout=self.timeout) #timeout = timeout do método read da Serial
self.enq = enquadramento.Enquadramento(self.ser, 0.05)
self.arq = ARQ.ARQ(self.enq, idSessao, self.timeout)
self.sessao = sessao.Sessao(self.arq, self.timeout)
self.tun = Tun("tun1",
ip1,
ip2,
mask="255.255.255.252",
mtu=1500,
qlen=4)
self.tun.start()
self.cb_tun = CallbackTun(self.tun, self) #self = próprio enlayce
self.sched = poller.Poller()
self.sched.adiciona(self.cb_tun)
self.cb_serial = CallbackStdin(self)
self.timer = CallbackTimer(0.01, self)
self.sched.adiciona(self.cb_serial)
self.sched.adiciona(self.timer)
self.sched.despache()
def __init__(self, tun):
Subcamada.__init__(self, tun.fd)
self._tun = tun
tun = Tun("tun0",
"10.0.0.1",
"10.0.0.2",
mask="255.255.255.252",
mtu=1500,
qlen=4)
self._tun.start()
#! /usr/bin/python
import enq
import serial
import arq
import sys
import Callback
import poller
import threading
from tun import Tun
import os
import time
import Protocol
tun = Tun("tun1",sys.argv[1],sys.argv[2],mask="255.255.255.252",mtu=1500,qlen=4)
#print(sys.argv[1])
ser = serial.Serial(sys.argv[3],9600)
protocol = Protocol.protocol(ser, tun, 0)
protocol.start()
import serial
from FAKE_APP import Fake_app
from session_manage import Session_Manager
from Interface_Tun import Tun_Tun
from ARQ import Arq
import sys
from tun import Tun
if __name__ == "__main__":
ser = serial.Serial(
'/dev/pts/3', 9600,
timeout=5) #porta serial que será monitorada pelo poller
tun = Tun("tun0",
"10.0.0.2",
"10.0.0.1",
mask="255.255.255.252",
mtu=1500,
qlen=4)
print("Aguardando em", ser.port)
arq = Arq(None,
1) #'''Criando objetos que vão ser usados pelo poller para fazer
Int_tun = Tun_Tun(tun) # o monitoramento dos eventos '''
Fake = Fake_app(sys.stdin, 1)
cb = Enquadramento(ser)
Manager = Session_Manager(None, 5)
Fake.Fake_send(Manager)
arq.get_framming(cb)
arq.get_Tun(Int_tun)
Manager.Get_Tun(Int_tun)
import os
import time
from tun import Tun
tun = Tun("tun0",
"10.0.0.1",
"10.0.0.2",
mask="255.255.255.252",
mtu=1500,
qlen=4)
tun.start()
while (True):
quadro = tun.get_frame()
print('Recebeu: ', quadro)
time.sleep(1)
#!/usr/bin/python3
from tun import Tun
import os
import time
tun = Tun("tun0",
"10.0.0.1",
"10.0.0.2",
mask="255.255.255.252",
mtu=1500,
qlen=4)
tun.start()
while True:
proto, payload = tun.get_frame()
print("recebeu: proto=%s, payload=" % hex(proto), payload)
# aqui envio de volta pra tun o pacote recebido ...
# você pode ver o pacote duplicado com o wireshark
tun.send_frame(payload, proto)
args = parser.parse_args()
porta = '{}'.format(args.serial)
ipOrigem = '{}'.format(args.iporigem)
ipDestino = '{}'.format(args.ipdestino)
try:
cnx = Serial(porta, timeout=0)
print('Porta utilizada: %s' % porta)
except Exception as e:
print('Erro')
sys.exit(0)
# CallbackTun
tun = Tun("tun0", ipOrigem, ipDestino, mtu=1024)
tun.start()
cbTun = CallbackTun(tun)
# Callback ARQ
arq = CallbackARQ(Timeout)
# Callback Enquadramento
enquadra = CallbackEnquadramento(cnx, Timeout)
# Conecta os Callbacks
arq.conecta(cbTun)
enquadra.conecta(arq)
# Despache Poller
sched = poller.Poller()
QUOTE, COMMAND, BASE, BUDGET, CONFIRM = range(5)
CONFIG_FILE = '{}/config.ini'.format(os.path.dirname(
os.path.abspath(__file__)))
config = ConfigParser()
config.read(CONFIG_FILE)
updater = Updater(config['CONFIG']['BOT_TOKEN'],
request_kwargs={
'read_timeout': 30,
'connect_timeout': 60
})
exchange = ccxt.binance({
'apiKey': config['CONFIG']['API_KEY'],
'secret': config['CONFIG']['API_SECRET']
})
tun = Tun(exchange)
buy_prices = {}
trade_type = ''
trade_quote = ''
trade_base = ''
trade_budget = ''
def start(bot, update):
reply_keyboard = [['USDT', 'BTC', 'ETH', 'BNB']]
update.message.reply_text('Hello! Set your quote first, sir.',
reply_markup=ReplyKeyboardMarkup(
reply_keyboard, one_time_keyboard=True))
return QUOTE
tun_name = input("Favor digitar o nome da interface tun:")
ip_v4_origem = input("Favor digitar o ipv4 de origem:")
ip_v4_destino = input("Favor digitar o ipv4 de destino:")
print(
"\nAVISO: Não estamos fazendo a verificação do IPv6, favor digitá-los corretamente\n"
)
print("O Ipv6 exemplo: 2801::3\n")
ip_v6_origem = input("Favor digitar o ipv6 de origem:")
ip_v6_destino = input("Favor digitar o ipv6 de destino:")
tun = Tun(tun_name,
ip_v4_origem,
ip_v4_destino,
ip_v6_origem,
ip_v6_destino,
mask="255.255.255.252",
mtu=1500,
qlen=4)
tun.start()
#pegando as portas
porta_transmissor = input(
"Favor digitar a porta serial referente ao transmissor:")
porta_receptor = input("Favor digitar a porta serial referente ao receptor:")
portas = {'transmissor': porta_transmissor, 'receptor': porta_receptor}
arq = Arq(lambda arg: print(arg), portas['receptor'], portas['transmissor'])
enq = Desenquadramento.Desenquadrador(portas['receptor'], 9600)
cb_enquadramento = CallbackEnq(enq, arq, tun, 10)
cb_tun = CallbackTun(tun, 1)
class Enlayce:
def __init__(self,
p_serial,
idSessao,
timeout,
ip1,
ip2,
bytes_min=0,
bytes_max=256):
self.min_bytes = bytes_min
self.max_bytes = bytes_max
self.timeout = timeout
self.ser = serial.Serial(
p_serial, 9600,
timeout=self.timeout) #timeout = timeout do método read da Serial
self.enq = enquadramento.Enquadramento(self.ser, 0.05)
self.arq = ARQ.ARQ(self.enq, idSessao, self.timeout)
self.sessao = sessao.Sessao(self.arq, self.timeout)
self.tun = Tun("tun1",
ip1,
ip2,
mask="255.255.255.252",
mtu=1500,
qlen=4)
self.tun.start()
self.cb_tun = CallbackTun(self.tun, self) #self = próprio enlayce
self.sched = poller.Poller()
self.sched.adiciona(self.cb_tun)
self.cb_serial = CallbackStdin(self)
self.timer = CallbackTimer(0.01, self)
self.sched.adiciona(self.cb_serial)
self.sched.adiciona(self.timer)
self.sched.despache()
def envia(self, dado):
#print('Enlayce envia!')
if (self.sessao.conectado() == False):
self.sessao.inicia()
return
print('Enviando')
print(dado)
return self.sessao.envia(
dado
) #retorna para a aplicação quando chegar o ack da outra aplicação, desbloqueando a mesma para um novo envio
def recebe(self):
#if (self.sessao.conectado() == False):
# self.sessao.espera_conexao()
tam, buf = self.sessao.recebe()
if ((type(buf) == bytearray) and buf != bytearray()):
print('Recebeu')
print(buf)
self.tun.send_frame(buf, Tun.PROTO_IPV4)
def encerra(self):
return self.sessao.encerra()
def func_timeout(self):
self.enq.func_timeout()
self.arq.func_timeout()
self.sessao.func_timeout()