def __fill_values(self,value_list):
for val in value_list:
#TODO: Before remove brackets and parenthesis
#we should agroup this info
val = TextUtils(val).remove_chars(self.__r_chars)
#Test if it is a domain
if self.__is_domain(val):
self._values['domain'] = val
#Test if it is a ipv4
elif WhatIs(val).IsIPv4():
self._values['ip'] = ip(val)
#Test if it is a ipv6
#TODO:Check
#BUG:Check if it really degtect IPv6
elif WhatIs(val).IsIPv6():
self._values['ip'] = ip(val)
#Otherwise
else:
#It could be a tuple ip:port
if val.find(':') != -1:
possible_ip,*port = val.split(':')
if WhatIs(possible_ip).IsIP():
self._values['ip'] = ip(possible_ip)
self._values['port'] = port
#Or somenthing else
else:
self._values['extra'].append(val)
async def _ready_msg(self, mt, msg, extra, lsa_type, otype, addr):
if lsa_type == LSA_TYPE_OPAQUE_LINK:
e = "ifaddr {}".format(ip(addr))
elif lsa_type == LSA_TYPE_OPAQUE_AREA:
e = "area {}".format(ip(addr))
else:
e = ""
logging.info(
"RECV: %s ready notify for %s opaque-type %s%s",
self,
lsa_typename(lsa_type),
otype,
e,
)
# Signal all waiting senders they can send now.
async with self.ready_lock:
cond = self.ready_cond[lsa_type].get(otype)
self.ready_cond[lsa_type][otype] = True
if cond is True:
logging.warning(
"RECV: dup ready received for %s opaque-type %s",
lsa_typename(lsa_type),
otype,
)
elif cond:
for evt in cond:
evt.set()
async def async_main(args):
c = OspfOpaqueClient(args.server)
await c.connect()
try:
# Start handling async messages from server.
if sys.version_info[1] > 6:
asyncio.create_task(c._handle_msg_loop())
else:
asyncio.get_event_loop().create_task(c._handle_msg_loop())
await c.req_lsdb_sync()
await c.req_reachable_routers()
await c.req_ism_states()
await c.req_nsm_states()
if args.actions:
for action in args.actions:
_s = action.split(",")
what = _s.pop(False)
ltype = int(_s.pop(False))
if ltype == 11:
addr = ip(0)
else:
aval = _s.pop(False)
try:
addr = ip(int(aval))
except ValueError:
addr = ip(aval)
oargs = [addr, ltype, int(_s.pop(False)), int(_s.pop(False))]
assert len(_s) <= 1, "Bad format for action argument"
try:
b = bytes.fromhex(_s.pop(False))
except IndexError:
b = b""
logging.info("opaque data is %s octets", len(b))
# Needs to be multiple of 4 in length
mod = len(b) % 4
if mod:
b += b"\x00" * (4 - mod)
logging.info("opaque padding to %s octets", len(b))
if what.casefold() == "add":
await c.add_opaque_data(*oargs, b)
else:
assert what.casefold().startswith("del")
await c.delete_opaque_data(*oargs)
if args.exit:
return 0
except Exception as error:
logging.error("async_main: unexpected error: %s", error, exc_info=True)
return 2
try:
logging.info("Sleeping forever")
while True:
await asyncio.sleep(120)
except EOFError:
logging.info("Got EOF from OSPF API server on async notify socket")
return 2
def __fill_values(self, value_list):
for val in value_list:
#TODO: Before remove brackets and parenthesis
#we should agroup this info
val = TextUtils(val).remove_chars(self.__r_chars)
#Test if it is a domain
if self.__is_domain(val):
self._values['domain'] = val
#Test if it is a ipv4
elif WhatIs(val).IsIPv4():
self._values['ip'] = ip(val)
#Test if it is a ipv6
#TODO:Check
#BUG:Check if it really degtect IPv6
elif WhatIs(val).IsIPv6():
self._values['ip'] = ip(val)
#Otherwise
else:
#It could be a tuple ip:port
if val.find(':') != -1:
possible_ip, *port = val.split(':')
if WhatIs(possible_ip).IsIP():
self._values['ip'] = ip(possible_ip)
self._values['port'] = port
#Or somenthing else
else:
self._values['extra'].append(val)
async def _if_msg(self, mt, msg, extra, *args):
if mt == MSG_NEW_IF:
ifaddr, aid = args
else:
assert mt == MSG_DEL_IF
ifaddr, aid = args[0], 0
logging.info("RECV: %s ifaddr %s areaid %s", api_msgname(mt),
ip(ifaddr), ip(aid))
def test_ip6_to_country(self):
# Instituto Costarricense de Electricidad y Telecom
self.assertEqual(("CR", "Costa Rica"), self._ip_service.get_country(
ip("2001:1330::")))
# Wikimedia Foundation
self.assertEqual(("US", "United States"), self._ip_service.get_country(
ip("2620:62:c000::")))
self.assertEqual(("ZZ", "Unknown"),
self._ip_service.get_country(ip("::1")))
def test_ip4_to_country(self):
# nycourts.gov
self.assertEqual(("US", "United States"),
self._ip_service.get_country(ip("207.29.128.60")))
# Technical Research Centre of Finland
self.assertEqual(("FI", "Finland"),
self._ip_service.get_country(ip("130.188.0.0")))
self.assertEqual(("ZZ", "Unknown"),
self._ip_service.get_country(ip("127.0.0.1")))
def test_resolve_ip6(self):
self.assertEqual("dns.google", self._ip_service.resolve_ip(
GOOGLE_DNS_IP6_8888))
self.assertEqual("dns.google", self._ip_service.resolve_ip(
GOOGLE_DNS_IP6_8844))
self.assertEqual(
"localhost", self._ip_service.resolve_ip(ip("::1")))
def test_resolve_ip4(self):
self.assertEqual(
"dns.google", self._ip_service.resolve_ip(GOOGLE_DNS_IP4_8888))
self.assertEqual(
"dns.google", self._ip_service.resolve_ip(GOOGLE_DNS_IP4_8888))
self.assertEqual(
"localhost", self._ip_service.resolve_ip(ip("127.0.0.1")))
def random_topology(n: int, e: int, c: int, bw_min=1, bw_max=10):
nodes = []
edges = []
clients = []
if n < 1:
cprint("number of nodes should be bigger than 1", 'red')
elif e < n - 1:
cprint("number of edges should be bigger than #nodes - 1", 'red')
elif e > n * (n - 1) / 2:
cprint("number of edges should be smaller", 'red')
else:
nodes = [0]
candidate_edges = [(i, j) for i in range(n) for j in range(i + 1, n)]
for i in range(1, n):
edge = (i, choice(nodes))
nodes.append(i)
edges.append(edge + (randint(bw_min, bw_max), ))
try:
candidate_edges.remove(edge)
except ValueError:
candidate_edges.remove((edge[1], edge[0]))
for _ in range(e - n + 1):
edge = choice(candidate_edges)
candidate_edges.remove(edge)
edges.append(edge + (randint(bw_min, bw_max), ))
for i in range(c):
clients.append(
(str(ip(0) + i), choice(nodes), randint(bw_min, bw_max)))
return nodes, edges, clients
async def _if_change_msg(self, mt, msg, extra, ifaddr, aid, state):
ifaddr = ip(ifaddr)
aid = ip(aid)
logging.info(
"RECV: %s ifaddr %s areaid %s state %s",
api_msgname(mt),
ifaddr,
aid,
ism_name(state),
)
self.if_area[ifaddr] = aid
self.ism_states[ifaddr] = state
if self.ism_change_cb:
self.ism_change_cb(ifaddr, aid, state)
async def _nbr_change_msg(self, mt, msg, extra, ifaddr, nbraddr, router_id, state):
ifaddr = ip(ifaddr)
nbraddr = ip(nbraddr)
router_id = ip(router_id)
logging.info(
"RECV: %s ifaddr %s nbraddr %s router_id %s state %s",
api_msgname(mt),
ifaddr,
nbraddr,
router_id,
nsm_name(state),
)
if ifaddr not in self.nsm_states:
self.nsm_states[ifaddr] = {}
self.nsm_states[ifaddr][(nbraddr, router_id)] = state
if self.nsm_change_cb:
self.nsm_change_cb(ifaddr, nbraddr, router_id, state)
async def _lsa_change_msg(self, mt, msg, extra, ifaddr, aid, is_self,
*ls_header):
(
lsa_age, # ls_age,
_, # ls_options,
lsa_type,
ls_id,
_, # ls_adv_router,
ls_seq,
_, # ls_cksum,
ls_len,
) = ls_header
otype = (ls_id >> 24) & 0xFF
if mt == MSG_LSA_UPDATE_NOTIFY:
ts = "update"
else:
assert mt == MSG_LSA_DELETE_NOTIFY
ts = "delete"
logging.info(
"RECV: LSA %s msg for LSA %s in area %s seq 0x%x len %s age %s",
ts,
ip(ls_id),
ip(aid),
ls_seq,
ls_len,
lsa_age,
)
idx = (lsa_type, otype)
pre_lsa_size = msg_size[mt] - FMT_LSA_HEADER_SIZE
lsa = msg[pre_lsa_size:]
if idx in self.opaque_change_cb:
self.opaque_change_cb[idx](mt, ifaddr, aid, ls_header, extra, lsa)
if self.lsa_change_cb:
self.lsa_change_cb(mt, ifaddr, aid, ls_header, extra, lsa)
async def _reachable_msg(self, mt, msg, extra, nadd, nremove):
router_ids = struct.unpack(">{}I".format(nadd + nremove), extra)
router_ids = [ip(x) for x in router_ids]
logging.info(
"RECV: %s added %s removed %s",
api_msgname(mt),
router_ids[:nadd],
router_ids[nadd:],
)
self.reachable_routers |= set(router_ids[:nadd])
self.reachable_routers -= set(router_ids[nadd:])
logging.info("RECV: %s new set %s", api_msgname(mt), self.reachable_routers)
if self.reachable_change_cb:
logging.info("RECV: %s calling callback", api_msgname(mt))
await self.reachable_change_cb(router_ids[:nadd], router_ids[nadd:])
async def _router_id_msg(self, mt, msg, extra, router_id):
router_id = ip(router_id)
logging.info("RECV: %s router ID %s", api_msgname(mt), router_id)
old_router_id = self.router_id
if old_router_id == router_id:
return
self.router_id = router_id
logging.info(
"RECV: %s new router ID %s older router ID %s",
api_msgname(mt),
router_id,
old_router_id,
)
if self.router_id_change_cb:
logging.info("RECV: %s calling callback", api_msgname(mt))
await self.router_id_change_cb(router_id, old_router_id)
def __init__(self, server="localhost"):
handlers = {
MSG_READY_NOTIFY: self._ready_msg,
MSG_LSA_UPDATE_NOTIFY: self._lsa_change_msg,
MSG_LSA_DELETE_NOTIFY: self._lsa_change_msg,
MSG_NEW_IF: self._if_msg,
MSG_DEL_IF: self._if_msg,
MSG_ISM_CHANGE: self._if_change_msg,
MSG_NSM_CHANGE: self._nbr_change_msg,
MSG_REACHABLE_CHANGE: self._reachable_msg,
MSG_ROUTER_ID_CHANGE: self._router_id_msg,
}
super().__init__(server, handlers)
self.ready_lock = Lock()
self.ready_cond = {
LSA_TYPE_OPAQUE_LINK: {},
LSA_TYPE_OPAQUE_AREA: {},
LSA_TYPE_OPAQUE_AS: {},
}
self.router_id = ip(0)
self.router_id_change_cb = None
self.lsid_seq_num = {}
self.lsa_change_cb = None
self.opaque_change_cb = {}
self.reachable_routers = set()
self.reachable_change_cb = None
self.if_area = {}
self.ism_states = {}
self.ism_change_cb = None
self.nsm_states = {}
self.nsm_change_cb = None
def test_ip6_to_as(self):
self.assertEqual(GOOGLE_ASN, self._ip_service.get_as(
GOOGLE_DNS_IP6_8888).id)
self.assertEqual(GOOGLE_ASN, self._ip_service.get_as(
GOOGLE_DNS_IP6_8844).id)
self.assertEqual(-1, self._ip_service.get_as(ip("::1")).id)
def doAction(self):
if self.timer.isActive():
self.startButton.setText('Start')
self.newPBARvalue = 0
else:
self.startButton.setText('Pause')
try:
f_hn = ip(self.firstIPedit.text())
l_hn = ip(self.lastIPedit.text())
if f_hn > l_hn:
f_hn, l_hn = l_hn, f_hn
if self.count >= 1 and f_hn != self.tmp1:
self.count = 0
if self.count >= 1 and l_hn != self.tmp2:
self.temp_l_hn = l_hn
self.valueIP = int(l_hn) - int(f_hn)
self.tmp1 = f_hn
self.tmp2 = l_hn
except ValueError:
# Message if user entered incorrect address. Will break function.
QMessageBox.warning(self, 'Warning!',
'IP address is incorrect. Enter again.',
QMessageBox.Cancel | QMessageBox.NoButton,
QMessageBox.Cancel)
self.startButton.setText('Start')
return
if self.count >= 1:
f_hn = self.temp_f_hn
l_hn = self.temp_l_hn
self.valuePBAR = (100 - self.step) / (self.valueIP -
self.count2)
self.step -= self.valuePBAR
if self.count == 0:
self.valuePBAR = 100 / (self.valueIP + 1)
self.resultEdit.setPlainText('')
self.count2 = 0
f_hn -= 1
self.timer.start(100, self) # Start progress bar
self.count += 1
QApplication.processEvents() # Will update QTextEdit in loop
while f_hn != l_hn:
if self.startButton.text() == 'Start':
# Remember old values if you pause the application
self.temp_f_hn = f_hn
self.temp_l_hn = l_hn
self.timer.stop()
break
self.count2 += 1
f_hn += 1
self.resultEdit.append('\nping {}'.format(f_hn))
if sys.platform == 'win32':
result = system('ping -n 2 -w 200 {}'.format(f_hn))
else:
result = system('ping -c 2 -W 2 {}'.format(f_hn))
QApplication.processEvents()
if result == 0:
self.resultEdit.append('{} - in use'.format(f_hn))
else:
self.resultEdit.append('{} - is free'.format(f_hn))
else:
self.count = 0
self.count2 = 0
def isIPv4Address(inputString):
try:
ip(inputString)
except:
return False
return True
def get_rbndr(ip1, ip2):
return '%.08X.%.08X.rbndr.us' % (int(ip(
ip1.decode())), int(ip(ip2.decode())))
list2 = []
if output is not None:
line = output.split()
for a in line:
w = str(a).split(':')
list1.append(w[1])
for b in list1:
time1 = int(b)
time2 = int(str(minute))
if time1 >= time2:
list2.append(time1 - time2)
else:
list2.append(time2 - time1)
parse = (str(line[list2.index(min(list2))])).split(",")
preip = ipaddress.ip(parse[2])
print("Pre-Nat IP: " + preip)
try:
cnx = mysql.connector.connect(user='******',
password='******',
host='127.0.0.1',
database='logs_db')
commend1 = "select mac_string from dhcp where ip_decimal = '" + preip + "' and timestamp <= '" + datetimestr + "' order by timestamp desc;"
cursor = cnx.cursor(buffered=True)
cursor.execute(commend1)
macaddress = cursor.fetchone()
except mysql.connector.Error:
print("Error")
if macaddress == None:
def arg_parser(args):
test=False
packetsize=512
payloadsize=packetsize-28
limit=50
pause=2
pts=2000
decode=False
message=None
if len(sys.argv) >=4:
vector=sys.argv[1]
if sys.argv[1] not in '-t-r':
print("\nMust specify either -t for transmit or -r for recieve.\n")
sys.exit()
LOGMSG_GRP = sys.argv[2]
try:
is_mcast=ip(sys.argv[2]).is_multicast
if is_mcast==False:
print("\n%s is not a multicast address\n"%(sys.argv[2]))
sys.exit()
except:
print("\nMust specify a correct IP address in dotted decimal format (x.x.x.x)\n")
sys.exit()
LOGMSG_PORT = int(sys.argv[3])
if vector == '-r':
print("Listing on: "+str(sys.argv[2])+' port: '+str(sys.argv[3])+'\n')
if '-d' in sys.argv:
print("\nDecoding recieved messages\n")
decode=True
return vector,LOGMSG_GRP,LOGMSG_PORT,test,packetsize,limit,pause,pts,message,decode
else:
return vector,LOGMSG_GRP,LOGMSG_PORT,test,packetsize,limit,pause,pts,message,decode
elif vector == '-t':
if '-m' in sys.argv:
m_idx=sys.argv.index('-m')
try:
message=sys.argv[m_idx+1]
except:
print("Need to specify message after -m")
sys.exit()
return vector,LOGMSG_GRP,LOGMSG_PORT,test,packetsize,limit,pause,pts,message,decode
elif '-T' in sys.argv:
test=True
if '-p' in sys.argv:
p_idx=sys.argv.index('-p')
try:
packetsize=int(sys.argv[p_idx+1])
payloadsize=packetsize-28
except:
print("Need to specify packet size after -p")
sys.exit()
else:
payloadsize=1472
packetsize=1500
if '-l' in sys.argv:
l_idx=sys.argv.index('-l')
try:
limit=int(sys.argv[l_idx+1])
except:
print("Need to specify loop number after -l")
sys.exit()
else:
limit=100
if '-P' in sys.argv:
P_idx=sys.argv.index('-P')
try:
pause=float(sys.argv[P_idx+1])
except:
print("Need to specify time to pause between loops after -P")
sys.exit()
else:
pause=1
if '-s' in sys.argv:
s_idx=sys.argv.index('-s')
try:
pts=int(sys.argv[s_idx+1])
except:
print("Need to specify number of packets sent after -s")
sys.exit()
else:
pts=2000
return vector,LOGMSG_GRP,LOGMSG_PORT,test,packetsize,limit,pause,pts,message,decode
else:
test=True
print("-m or -T transmit variable not specified. Defaulting to -T: %iB packetsize, %i packets per loop, %i seconds interloop pause, sending %i packets."%(payloadsize+28,limit,pause,pts))
return vector,LOGMSG_GRP,LOGMSG_PORT,test,packetsize,limit,pause,pts,message,decode
else:
if '-h' in sys.argv:
with open ('helpfile.txt', 'r') as hf:
f=hf.readlines()
for i in f:
i.rstrip('\n')
i.lstrip('\t')
print(i)
sys.exit()
else:
print("Not enough arguments. Need to at least specify '-t'(TX) or '-r'(RX) IPv4 Multicast Address and Port.\n")
vector=input('\nSpecify -t or -r: ')
if vector not in '-t-r':
vector='-t'
print('No valid vector specified. Defaulting to -t\n')
LOGMSG_GRP=input('\nIPv4 Multicast Address: ')
LOGMSG_PORT=int(input('\nUDP Port: '))
if vector == '-t':
packetsize=int(input('\nPacket Size: '))
pts=int(input('\nPackets to send: '))
if vector == '-r':
packetsize,pts=(None,None)
limit=50
pause=1
test=True
if vector == '-t':
print("\n-m or -T transmit variable not specified. Defaulting to -T: %iB packetsize, %i packets per loop, %i seconds interloop pause, sending %i packets."%(packetsize,limit,pause,pts))
return vector,LOGMSG_GRP,LOGMSG_PORT,test,packetsize,limit,pause,pts,message,decode
def test_ip4_to_as(self):
self.assertEqual(GOOGLE_ASN, self._ip_service.get_as(
GOOGLE_DNS_IP4_8888).id)
self.assertEqual(GOOGLE_ASN, self._ip_service.get_as(
GOOGLE_DNS_IP4_8888).id)
self.assertEqual(-1, self._ip_service.get_as(ip("127.0.0.1")).id)
def main():
token = Token()
logging.basicConfig()
# Creating an object
logger = logging.getLogger()
# Setting the threshold of logger to DEBUG
logger.setLevel(logging.DEBUG)
ring_routes = []
unique_ring = set()
pc_number = int(input("Please enter number of computers: "))
if pc_number == 0:
return False
for index in range(pc_number):
try:
curr_ip = input(f"Enter ip number {index + 1}: ")
curr_ip = ip(curr_ip)
ring_routes.append(curr_ip)
if unique_ring.__contains__(curr_ip):
print(f"Error, ip {curr_ip} is not unique!")
return False
else:
unique_ring.add(curr_ip)
except:
print(f"Error, ip {index + 1} is invalid!")
return False
while True:
print(ring_routes)
print("Number of ip's:" + str(len(ring_routes)))
message = input("Please enter message: ")
# pool = cycle(list())
token.sent_message = message
user_response_source = int(input("Select source: "))
user_response_target = int(input("Select target: "))
if 1 > user_response_target or user_response_target > pc_number or 1 > user_response_source or\
user_response_source > pc_number:
print("Error, out of index!")
return False
if user_response_target == user_response_source:
print("Source is the same as target!")
return False
token.IP_source = ring_routes[user_response_source - 1]
token.IP_target = ring_routes[user_response_target - 1]
user_response = input("Default direction is clockwise. Do you want to change?(y/n) ")
if user_response == 'y':
ring_routes.reverse()
ring_cycle = cycle(ring_routes)
token.is_free = False
current_item = None
while current_item != token.IP_source:
current_item = next(ring_cycle)
# print(token)
while current_item != token.IP_target:
token.history.append(current_item)
print(f"PC {current_item}: " + token.__str__())
current_item = next(ring_cycle)
else:
token.history.append(current_item)
token.finish_line = True
print(f"PC {current_item}: " + token.__str__())
print("Messsage printed: " + token.sent_message)
current_item = next(ring_cycle)
while current_item != token.IP_source:
token.history.append(current_item)
print(f"PC {current_item}: " + token.__str__())
current_item = next(ring_cycle)
else:
token.free()
print(f"PC {current_item}: " + token.__str__())
user_response = input("Do you want to sent another message?(y/n) ")
if user_response != 'y':
return False
import unittest
from ipaddress import ip_address as ip
from . import ip_info as ii
# Google DNS addresses will be stably assigned to Google's AS"
GOOGLE_DNS_IP4_8888 = ip("8.8.8.8")
GOOGLE_DNS_IP4_8844 = ip("8.8.4.4")
GOOGLE_DNS_IP6_8888 = ip("2001:4860:4860::8888")
GOOGLE_DNS_IP6_8844 = ip("2001:4860:4860::8844")
GOOGLE_ASN = 15169
class TestIpInfo(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls._ip_service = ii.create_default_ip_info_service()
def test_ip4_to_as(self):
self.assertEqual(GOOGLE_ASN, self._ip_service.get_as(
GOOGLE_DNS_IP4_8888).id)
self.assertEqual(GOOGLE_ASN, self._ip_service.get_as(
GOOGLE_DNS_IP4_8888).id)
self.assertEqual(-1, self._ip_service.get_as(ip("127.0.0.1")).id)
def test_ip6_to_as(self):
self.assertEqual(GOOGLE_ASN, self._ip_service.get_as(
GOOGLE_DNS_IP6_8888).id)
self.assertEqual(GOOGLE_ASN, self._ip_service.get_as(
GOOGLE_DNS_IP6_8844).id)
