class ReceptorUDP:
mensajesRecibidos = MensajesRecibidos()
tablaAlcanzabilidad = TablaAlcanzabilidad()
def __init__(self, mensajesRecibidos, tablaAlcanzabilidad):
self.mensajesRecibidos = mensajesRecibidos
self.tablaAlcanzabilidad = tablaAlcanzabilidad
def recibeMensajes(self, serverSocket):
while 1:
message, clientAddress = serverSocket.recvfrom(2048)
mensaje = Mensaje(clientAddress[0], clientAddress[1], message)
cantTuplas = int(codecs.encode(message[0:2], 'hex_codec'))
mensajeSalir = int.from_bytes(message[2:3], byteorder='big')
#Si el mensaje recibido es la palabra close se cierra la aplicacion
if cantTuplas == 1 and len(message) == 3 and mensajeSalir == 0:
print("Nodo aviso suicidio")
self.tablaAlcanzabilidad.borrarFuenteDesdeAfuera(
clientAddress[0], clientAddress[1])
else:
self.mensajesRecibidos.guardarMensaje(mensaje)
self.mensajesRecibidos.imprimirMensaje(mensaje)
self.tablaAlcanzabilidad.actualizarTabla(mensaje)
def procRecibeMsg(self, ip, puerto):
#self.lockMensajesRecibidos.acquire()
serverSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
serverSocket.bind((ip, puerto))
self.recibeMensajes(serverSocket)
#self.lockMensajesRecibidos.release()
class ReceptorUDP:
mensajesRecibidos = MensajesRecibidos()
tablaAlcanzabilidad = TablaAlcanzabilidad()
def __init__(self, mensajesRecibidos, tablaAlcanzabilidad):
self.mensajesRecibidos = mensajesRecibidos
self.tablaAlcanzabilidad = tablaAlcanzabilidad
def responderACK(self, serverSocket, clientAddress):
print("aqui")
if randrange(10) > 1:
serverSocket.sendto((1).to_bytes(1, byteorder='big'),
(clientAddress[0], clientAddress[1]))
print(clientAddress[0])
print(clientAddress[1])
#print(message)
def recivir(self, serverSocket, numero):
message, clientAddress = serverSocket.recvfrom(2048)
self.responderACK(serverSocket, clientAddress)
print(numero)
print(message)
def recibeMensajes(self, serverSocket):
while 1:
proceso_receptorUDP = threading.Thread(target=ReceptorUDP(
None, None).recivir,
args=(
serverSocket,
1,
))
proceso_receptorUDP.start()
proceso_receptorUDP = threading.Thread(target=ReceptorUDP(
None, None).recivir,
args=(
serverSocket,
2,
))
proceso_receptorUDP.start()
proceso_receptorUDP = threading.Thread(target=ReceptorUDP(
None, None).recivir,
args=(
serverSocket,
3,
))
proceso_receptorUDP.start()
message, clientAddress = serverSocket.recvfrom(2048)
#proceso_receptorUDP = threading.Thread(target=self.responderACK, args=(serverSocket,clientAddress,))
#proceso_receptorUDP.start()
#print("imprimi")
def procRecibeMsg(self, ip, puerto):
#self.lockMensajesRecibidos.acquire()
serverSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
serverSocket.bind((ip, puerto))
self.recibeMensajes(serverSocket)
def iniciarNodoTCP(self, ip, puerto):
mensajesRecibidos = MensajesRecibidos()
tablaAlcanzabilidad = TablaAlcanzabilidad()
repetorTcp = ReceptorTCP(mensajesRecibidos, tablaAlcanzabilidad)
proceso_repetorTcp = threading.Thread(target=repetorTcp.recibir,
args=(
ip,
puerto,
))
proceso_repetorTcp.start()
emisorTcp = EmisorTCP(mensajesRecibidos, tablaAlcanzabilidad)
proceso_emisorTcp = threading.Thread(target=emisorTcp.menu, args=())
proceso_emisorTcp.start()
def iniciarNodoUDP(self, ip, puerto):
mensajesRecibidos = MensajesRecibidos()
tablaAlcanzabilidad = TablaAlcanzabilidad()
receptorUDP = ReceptorUDP(mensajesRecibidos, tablaAlcanzabilidad)
proceso_receptorUDP = threading.Thread(
target=receptorUDP.procRecibeMsg, args=(
ip,
puerto,
))
proceso_receptorUDP.start()
emisorUDP = EmisorUDP(mensajesRecibidos, tablaAlcanzabilidad)
proceso_emisorUDP = threading.Thread(target=emisorUDP.despligueMenuUDP,
args=())
proceso_emisorUDP.start()
class EmisorTCP:
#Objeto para guardar conexiones
conexiones = list()
lockConexiones = threading.Lock()
mensajesRecibidos = MensajesRecibidos()
tablaAlcanzabilidad = TablaAlcanzabilidad()
def __init__(self, mensajesRecibidos, tablaAlcanzabilidad):
self.mensajesRecibidos = mensajesRecibidos
self.tablaAlcanzabilidad = tablaAlcanzabilidad
self.conexiones = list()
self.lockConexiones = threading.Lock()
#Llamar solo SIN candado adquirido
def imprimirConexionesExistentes(self):
self.lockConexiones.acquire()
i = 0
largo = len(self.conexiones)
while i < largo:
print(self.conexiones[i].ip + " " + str(self.conexiones[i].puerto))
i = i + 1
self.lockConexiones.release()
#Llamar solo CON candado adquirido
def hacerConexion(self, ip, puerto):
#se crea el socket para enviar
socketEmisorTCP = socket.socket()
conexion = ConexionAbierta(ip, puerto, socketEmisorTCP)
#Se establece la conexion con el receptorTCP mediante la ip y el puerto
try:
socketEmisorTCP.connect((ip, puerto))
except SocketError:
print("Fallo de conexion")
return False
else:
print("Conexion establecida")
self.conexiones.append(conexion)
return True
#Llamar solo CON candado adquirido
def buscarConexion(self, ip, puerto):
i = 0
largo = len(self.conexiones)
while i < largo:
if self.conexiones[i].soyLaConexion(ip, puerto):
return i
i = i + 1
return -1
#Llamar solo CON candado adquirido
def cerrarUnaConexion(self, ip, puerto):
i = 0
largo = len(self.conexiones)
while i < largo:
if self.conexiones[i].soyLaConexion(ip, puerto):
self.conexiones[i].cerrarConexion()
self.conexiones.remove(self.conexiones[i])
break
i = i + 1
#Llamar solo CON candado adquirido
def cerrarConexiones(self):
while len(self.conexiones) != 0:
self.conexiones[0].cerrarConexion()
self.conexiones.remove(self.conexiones[0])
#NO necesita tener candado
def tuplaToBytes(self, tupla):
tupladiv = tupla.split(' ')
numeroip = tupladiv[0]
myip = numeroip.split('.')
bytesmios = bytearray()
for x in range(0, 4):
ipnum = int(myip[x])
bytesmios += (ipnum).to_bytes(1, byteorder='big')
masc = int(tupladiv[1])
bytesmios += (masc).to_bytes(1, byteorder='big')
costo = int(tupladiv[2])
bytesmios += (costo).to_bytes(3, byteorder='big')
return bytesmios
#NO necesita tener candado
def leerMensaje(self):
#print('Ingrese la cantidad de tuplas que quiere enviar:')
entradas = 0
leerCantTuplas = True
while leerCantTuplas:
lectura = input("Ingrese la cantidad de tuplas: ")
try:
entradas = int(lectura)
leerCantTuplas = False
except ValueError as e:
print("Cantidad de tuplas invalido")
leerCantTuplas = True
vectorBytes = bytearray((entradas).to_bytes(2, byteorder='big'))
i = 0
while i < entradas:
#print('Ingrese la tupla:')
leer = True
while leer:
tupla = input("Ingrese una tupla(ip mascara costo): ")
tuplaDividida = tupla.split() # tupla.replace(" ", "/",1)
if len(tuplaDividida) == 3:
ipPrueba = tuplaDividida[0] + "/" + tuplaDividida[1]
try:
n = ipaddress.ip_network(ipPrueba)
except ValueError as e:
print("Ip o mascara no valida")
leer = True
else:
leer = False
try:
costo = int(tuplaDividida[2])
except ValueError as e:
print("Costo no valido")
leer = True
else:
if costo > 0 and costo < 65536:
leer = False
else:
print("Costo no valido")
leer = True
else:
print("Faltan valores")
vectorBytes += self.tuplaToBytes(tupla)
i = i + 1
#print('\n')
return vectorBytes
#Llamar solo SIN candado adquirido
def enviarMensaje(self):
#self.lockConexiones.acquire()
ip = input("Digite la ip del destinatario: ")
ipPrueba = ip + "/32"
try:
n = ipaddress.ip_network(ipPrueba)
except ValueError as e:
print("Ip no valida")
else:
puerto = input("Digite el puerto del destinatario: ")
try:
n = int(puerto)
except ValueError as e:
print("Puerto no valido")
else:
if n < 0 or n > 65535:
print("Puerto no valido")
else:
self.lockConexiones.acquire()
indice = self.buscarConexion(ip, int(puerto))
if indice == -1:
exito = self.hacerConexion(ip, int(puerto))
if exito:
print("Nueva conexion")
mensaje = self.leerMensaje()
respEnvio = self.conexiones[len(self.conexiones) -
1].enviarMensaje(
mensaje)
if respEnvio == False:
self.cerrarUnaConexion(ip, int(puerto))
if len(mensaje) == 3:
self.conexiones.pop(len(self.conexiones) - 1)
else:
print("Conexion existente")
mensaje = self.leerMensaje()
respEnvio = self.conexiones[indice].enviarMensaje(
mensaje)
if respEnvio == False:
self.cerrarUnaConexion(ip, int(puerto))
if len(mensaje) == 3:
self.conexiones.pop(indice)
self.lockConexiones.release()
#Llamar solo SIN candado adquirido
def borrarme(self):
#self.lockConexiones.acquire()
mensaje = bytearray((1).to_bytes(2, byteorder='big')) # cant tuplas
mensaje += (0).to_bytes(1, byteorder='big')
i = 0
self.lockConexiones.acquire()
cant = len(self.conexiones)
while i < cant:
self.conexiones[i].enviarMensaje(mensaje)
i = i + 1
self.cerrarConexiones()
self.lockConexiones.release()
return
#NO necesita tener candado
def menu(self):
bandera = True
while bandera == True:
print('Menu principal del modulo de Red TCP: \n'
'\t1. Enviar un mensaje. \n'
'\t2. Ver mensajes recibidos. \n'
'\t3. Imprimir tabla de alcanzabilidad. \n'
'\t4. Conexiones existentes. \n'
'\t5. Cerrar nodo.')
taskUsuario = input('Que desea hacer:')
if taskUsuario == '1':
self.enviarMensaje()
elif taskUsuario == '2':
print("\n\n")
print('Mensajes recibidos:')
self.mensajesRecibidos.imprimirMensajes()
print("\n\n")
elif taskUsuario == '3':
print("\n\n")
print('Tabla de alcanzabilidad:')
self.tablaAlcanzabilidad.imprimirTabla()
print("\n\n")
elif taskUsuario == '5':
bandera = False
self.borrarme()
print('Salida.')
os._exit(1)
#proceso_repetorTcp.exit()
elif taskUsuario == '4':
print("Conexiones existentes:")
self.imprimirConexionesExistentes()
else:
print('Ingrese una opcion valida.')
class EmisorUDP:
#Objeto para guardar conexiones
mensajesRecibidos = MensajesRecibidos()
tablaAlcanzabilidad = TablaAlcanzabilidad()
def __init__(self,mensajesRecibidos, tablaAlcanzabilidad):
self.mensajesRecibidos = mensajesRecibidos
self.tablaAlcanzabilidad = tablaAlcanzabilidad
def tuplaToBytes(self,tupla):
tupladiv = tupla.split(' ')
numeroip = tupladiv[0]
myip = numeroip.split('.')
bytesmios = bytearray()
for x in range(0, 4):
ipnum = int(myip[x])
bytesmios += (ipnum).to_bytes(1, byteorder='big')
masc = int(tupladiv[1])
bytesmios += (masc).to_bytes(1, byteorder='big')
costo = int(tupladiv[2])
bytesmios += (costo).to_bytes(3, byteorder='big')
return bytesmios
def leerMensaje(self):
#print('Ingrese la cantidad de tuplas que quiere enviar:')
entradas = 0
leerCantTuplas = True
while leerCantTuplas:
lectura = input( "Ingrese la cantidad de tuplas: " )
try:
entradas = int(lectura)
leerCantTuplas = False
except ValueError as e:
print("Cantidad de tuplas invalido")
leerCantTuplas = True
vectorBytes = bytearray((entradas).to_bytes(2, byteorder='big'))
i = 0
while i < entradas:
#print('Ingrese la tupla:')
leer = True
while leer:
tupla = input("Ingrese una tupla(ip mascara costo): ")
tuplaDividida = tupla.split()# tupla.replace(" ", "/",1)
if len(tuplaDividida) == 3 :
ipPrueba = tuplaDividida[0] + "/" + tuplaDividida[1]
try:
n = ipaddress.ip_network(ipPrueba)
except ValueError as e:
print ("Ip o mascara no valida")
leer = True
else:
leer = False
try:
costo = int(tuplaDividida[2])
except ValueError as e:
print ("Costo no valido")
leer = True
else:
if costo > 0 and costo < 65536:
leer = False
else:
print ("Costo no valido")
leer = True
else:
print ("Faltan valores")
vectorBytes += self.tuplaToBytes(tupla)
i = i + 1
#print('\n')
return vectorBytes
def envioMensajeUDP(self):
serverNameS = input('Digite la ip del destinatario: ')
ipPrueba = serverNameS + "/32"
try:
n = ipaddress.ip_network(ipPrueba)
except ValueError as e:
print ("Ip no valida")
else:
lecturaPuerto = input('Digite el puerto del destinatario: ')
try:
serverPortS = int(lecturaPuerto)
except ValueError as e:
print ("Puerto no valido")
else:
if serverPortS < 0 or serverPortS > 65535:
print ("Puerto no valido")
else:
message = self.leerMensaje()
clientSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
clientSocket.sendto(message, (serverNameS, serverPortS))
clientSocket.close()
def borrarme(self):
mensaje = bytearray((1).to_bytes(2, byteorder='big'))# cant tuplas
mensaje += (0).to_bytes(1, byteorder='big')
fuente = self.tablaAlcanzabilidad.eliminarPrimerFuente()
#print("Elimine la primer fuente")
print ("llegue aqui")
while fuente.puertoFuente != 0:
clientSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
clientSocket.sendto(mensaje, (fuente.ipFuente, fuente.puertoFuente))
clientSocket.close()
fuente = self.tablaAlcanzabilidad.eliminarPrimerFuente()
def despligueMenuUDP(self):
bandera = True
while bandera == True:
print('Menu principal del modulo de Red UDP: \n'
'\t1. Enviar un mensaje. \n'
'\t2. Ver mensajes recibidos. \n'
'\t3. Imprimir tabla de alcanzabilidad.\n'
'\t4. Cerrar servidor de mensajes.')
taskUsuario = input('Que desea hacer:')
if taskUsuario == '1':
self.envioMensajeUDP()
elif taskUsuario == '2':
print("\n\n")
print('Mensajes recibidos:')
self.mensajesRecibidos.imprimirMensajes()
print("\n\n")
elif taskUsuario == '3':
print("\n\n")
print('Tabla de alcanzabilidad:')
self.tablaAlcanzabilidad.imprimirTabla()
print("\n\n")
elif taskUsuario == '4':
bandera = False
self.borrarme()
print('Salida.')
os._exit(1)
else:
print('Ingrese opcion valida.')
class ReceptorTCP:
mensajesRecibidos = MensajesRecibidos()
tablaAlcanzabilidad = TablaAlcanzabilidad()
def __init__(self, mensajesRecibidos, tablaAlcanzabilidad):
self.mensajesRecibidos = mensajesRecibidos
self.tablaAlcanzabilidad = tablaAlcanzabilidad
def establecerConexion(self, conexion, addr):
while True:
#Recibimos el mensaje, con el metodo recv recibimos datos y como parametro
#la cantidad de bytes para recibir
try:
recibido = conexion.recv(2048)
except SocketError:
print("Conexion Perdida")
self.tablaAlcanzabilidad.borrarFuenteDesdeAfuera(
addr[0], addr[1])
break
if (
recibido == b''
): #Salida para cuando el otro muere antes de mandar el primer mensaje
print("Conexion Perdida")
self.tablaAlcanzabilidad.borrarFuenteDesdeAfuera(
addr[0], addr[1])
break
cantTuplas = int(codecs.encode(recibido[0:2], 'hex_codec'))
#mensajeSalir = int.from_bytes( recibido[2:3], byteorder='big' )
#Si el mensaje recibido es la palabra close se cierra la aplicacion
if cantTuplas == 1 and len(recibido) == 3:
print("Conexion Terminada")
self.tablaAlcanzabilidad.borrarFuenteDesdeAfuera(
addr[0], addr[1])
break
mensaje = Mensaje(addr[0], addr[1], recibido)
self.mensajesRecibidos.guardarMensaje(mensaje)
self.mensajesRecibidos.imprimirMensaje(mensaje)
self.tablaAlcanzabilidad.actualizarTabla(mensaje)
conexion.close()
def recibir(self, ip, puerto):
#instanciamos un objeto para trabajar con el socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((ip, puerto))
s.listen(5)
while True:
conexion, addr = s.accept()
thread_servidor = threading.Thread(target=self.establecerConexion,
args=(conexion, addr))
thread_servidor.start()
print("Conexion recibida")
#Cerramos la instancia del socket cliente y servidor
s.close()
class ReceptorUDP:
mensajesRecibidos = MensajesRecibidos()
tablaAlcanzabilidad = TablaAlcanzabilidad()
def __init__(self, mensajesRecibidos, tablaAlcanzabilidad):
self.mensajesRecibidos = mensajesRecibidos
self.tablaAlcanzabilidad = tablaAlcanzabilidad
def recibeMensajes(self, serverSocket):
while 1:
message, clientAddress = serverSocket.recvfrom(2048)
mensaje = Mensaje(clientAddress[0], clientAddress[1], message)
cantTuplas = int(codecs.encode(message[0:2], 'hex_codec'))
mensajeSalir = int.from_bytes(message[2:3], byteorder='big')
#Si el mensaje recibido es la palabra close se cierra la aplicacion
if cantTuplas == 1 and len(message) == 3 and mensajeSalir == 0:
print("Nodo aviso suicidio")
self.tablaAlcanzabilidad.borrarFuenteDesdeAfuera(
clientAddress[0], clientAddress[1])
else:
self.mensajesRecibidos.guardarMensaje(mensaje)
self.mensajesRecibidos.imprimirMensaje(mensaje)
self.tablaAlcanzabilidad.actualizarTabla(mensaje)
def procRecibeMsg(self, ip, puerto):
#self.lockMensajesRecibidos.acquire()
serverSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
serverSocket.bind((ip, puerto))
self.recibeMensajes(serverSocket)
#self.lockMensajesRecibidos.release()
def tuplaToBytes(self, tupla):
tupladiv = tupla.split(' ')
numeroip = tupladiv[0]
myip = numeroip.split('.')
bytesmios = bytearray()
for x in range(0, 4):
ipnum = int(myip[x])
bytesmios += (ipnum).to_bytes(1, byteorder='big')
masc = int(tupladiv[1])
bytesmios += (masc).to_bytes(1, byteorder='big')
costo = int(tupladiv[2])
bytesmios += (costo).to_bytes(3, byteorder='big')
return bytesmios
def leerMensaje(self):
#print('Ingrese la cantidad de tuplas que quiere enviar:')
entradas = 0
leerCantTuplas = True
while leerCantTuplas:
lectura = input("Ingrese la cantidad de tuplas: ")
try:
entradas = int(lectura)
leerCantTuplas = False
except ValueError as e:
print("Cantidad de tuplas invalido")
leerCantTuplas = True
vectorBytes = bytearray((entradas).to_bytes(2, byteorder='big'))
i = 0
while i < entradas:
#print('Ingrese la tupla:')
leer = True
while leer:
tupla = input("Ingrese una tupla(ip mascara puerto): ")
tuplaDividida = tupla.split() # tupla.replace(" ", "/",1)
if len(tuplaDividida) == 3:
ipPrueba = tuplaDividida[0] + "/" + tuplaDividida[1]
try:
n = ipaddress.ip_network(ipPrueba)
except ValueError as e:
print("Ip o mascara no valida")
leer = True
else:
leer = False
try:
costo = int(tuplaDividida[2])
except ValueError as e:
print("Costo no valido")
leer = True
else:
if costo > 0 and costo < 65536:
leer = False
else:
print("Costo no valido")
leer = True
else:
print("Faltan valores")
vectorBytes += self.tuplaToBytes(tupla)
i = i + 1
#print('\n')
return vectorBytes
class ReceptorUDP:
mensajesRecibidos = MensajesRecibidos()
tablaAlcanzabilidad = TablaAlcanzabilidad()
conexiones = list()
lockConexiones = threading.Lock()
posiblesConexiones = list()
lockPosiblesConexiones = threading.Lock()
def __init__(self, mensajesRecibidos, tablaAlcanzabilidad):
self.mensajesRecibidos = mensajesRecibidos
self.tablaAlcanzabilidad = tablaAlcanzabilidad
self.conexiones = list(
) #DEBE ENTRAR POR PARAMETRO EN CASO DE QUE LAS CONEXIONES LAS TENGAN EMISOR Y RECEPTOR
self.lockConexiones = threading.Lock(
) #DEBE ENTRAR POR PARAMETRO EN CASO DE QUE LAS CONEXIONES LAS TENGAN EMISOR Y RECEPTOR
self.posiblesConexiones = list()
self.lockPosiblesConexiones = threading.Lock()
#Llamar solo SIN candado adquirido
def imprimirConexionesLogicas(self):
self.lockConexiones.acquire()
i = 0
largo = len(self.conexiones)
while i < largo:
print(self.conexiones[i].ip + " " + str(self.conexiones[i].puerto))
i = i + 1
self.lockConexiones.release()
#Llamar solo CON candado adquirido
def buscarConexionLogica(
self, ip, puerto
): #APLICA SI LAS CONEXIONES DEBEN ESTAR PARA AMBOS , creo que deben estar aunque para tener una lista de las conexiones hechas para usarlas, VER QUE DICE LA PROFE
i = 0
largo = len(self.conexiones)
while i < largo:
if self.conexiones[i].soyLaConexionHacia(ip, puerto):
return i
i = i + 1
return -1
#Llamar solo CON candado adquirido
def buscarPosibleConexionLogica(
self, ip, puerto
): #APLICA SI LAS CONEXIONES DEBEN ESTAR PARA AMBOS , creo que deben estar aunque para tener una lista de las conexiones hechas para usarlas, VER QUE DICE LA PROFE
i = 0
largo = len(self.posiblesConexiones)
while i < largo:
if self.posiblesConexiones[i].soyLaConexionHacia(ip, puerto):
return i
i = i + 1
return -1
def accept(self, serverSocket, emisor, recibido):
#Establecer RN = 0, poner en la estructura de la conexion un buffer y este RN
otroIpRec = bytesToIp(recibido[0:4])
print(otroIpRec)
otroPuertoRec = bytesToInt(recibido[4:6])
print(otroPuertoRec)
miIpRec = bytesToIp(recibido[6:10])
print(miIpRec)
miPuertoRec = bytesToInt(recibido[10:12])
print(miPuertoRec)
tipoPaq = bytesToInt(recibido[12:13])
secuencia = bytesToInt(
recibido[13:14]) #OJO SI SE CAMBIA A MAS GRANDE AL SECUENCIA
#ver si hay que verificar que la conexion no exista
conexionNueva = ConexionLogicaUDP(otroIpRec, otroPuertoRec, miIpRec,
miPuertoRec)
mensaje = armarPaq(miIpRec, miPuertoRec, otroIpRec, otroPuertoRec, 5,
0, bytearray())
serverSocket.sendto(mensaje, (emisor[0], emisor[1]))
#SE METE A UNA LISTA DE POSIBLES COENXIONES
self.lockPosiblesConexiones.acquire()
self.posiblesConexiones.append(conexionNueva)
self.lockPosiblesConexiones.release()
def finalaccept(self, recibido):
otroIpRec = bytesToIp(recibido[0:4])
otroPuertoRec = bytesToInt(recibido[4:6])
miIpRec = bytesToIp(recibido[6:10])
miPuertoRec = bytesToInt(recibido[10:12])
tipoPaq = bytesToInt(recibido[12:13])
secuencia = bytesToInt(
recibido[13:14]) #OJO SI SE CAMBIA A MAS GRANDE AL SECUENCIA
self.lockPosiblesConexiones.acquire()
indice = self.buscarPosibleConexionLogica(otroIpRec, otroPuertoRec)
if indice == -1:
print("Llego un finSyn sin que exista un syn")
else:
conexionestablecida = self.posiblesConexiones.pop(indice)
self.lockConexiones.acquire()
self.conexiones.append(conexionestablecida)
self.lockConexiones.release()
print("Conexion Establecida")
self.lockPosiblesConexiones.release()
#Algoritmo ARQRECEPTOR
def paqueteConDatos(self, emisor, recibido):
otroIpRec = bytesToIp(recibido[0:4])
#print(otroIpRec)
otroPuertoRec = bytesToInt(recibido[4:6])
#print(otroPuertoRec)
miIpRec = bytesToIp(recibido[6:10])
#print(miIpRec)
miPuertoRec = bytesToInt(recibido[10:12])
#print(miPuertoRec)
tipoPaq = bytesToInt(recibido[12:13])
secuencia = bytesToInt(recibido[13:14])
datos = recibido[13:]
self.lockConexiones.acquire()
indice = self.buscarConexionLogica(otroIpRec, otroPuertoRec)
if indice == -1:
print("Paquete de conexion no establecida")
else:
print("Mande a porocesar")
self.conexiones[indice].recv(emisor, recibido)
self.lockConexiones.release()
def listen(self, ip, puerto):
#self.lockMensajesRecibidos.acquire()
serverSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
serverSocket.bind((ip, puerto))
while 1: #CREAR UN HILO PARA QUE PROCESE CADA MENSAJE RECIBIDO
mensaje, addr = serverSocket.recvfrom(2048)
if bytesToInt(
mensaje[12:13]) == 1: # Mensaje para establecer conexion
self.accept(serverSocket, addr, mensaje)
elif bytesToInt(
mensaje[12:13]
) == 6: # Mensaje ack de establecer conexion(fin de establecimiento de conexion)
self.finalaccept(mensaje)
elif bytesToInt(mensaje[12:13]) == 16: # Mensaje de datos
if randrange(10) > 1:
self.paqueteConDatos(addr, mensaje)
self.lockConexiones.release()
def listen(self, ip, puerto):
#self.lockMensajesRecibidos.acquire()
serverSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
serverSocket.bind((ip, puerto))
while 1: #CREAR UN HILO PARA QUE PROCESE CADA MENSAJE RECIBIDO
mensaje, addr = serverSocket.recvfrom(2048)
if bytesToInt(
mensaje[12:13]) == 1: # Mensaje para establecer conexion
self.accept(serverSocket, addr, mensaje)
elif bytesToInt(
mensaje[12:13]
) == 6: # Mensaje ack de establecer conexion(fin de establecimiento de conexion)
self.finalaccept(mensaje)
elif bytesToInt(mensaje[12:13]) == 16: # Mensaje de datos
if randrange(10) > 1:
self.paqueteConDatos(addr, mensaje)
if __name__ == '__main__':
mensajesRecibidos = MensajesRecibidos()
tablaAlcanzabilidad = TablaAlcanzabilidad()
servidorUDP = ReceptorUDP(mensajesRecibidos, tablaAlcanzabilidad)
proceso_receptorUDP = threading.Thread(target=servidorUDP.listen,
args=(
"172.16.105.251",
5000,
))
proceso_receptorUDP.start()