def AddRoute(self, network, gw):
"""Verifies that the route points to localhost."""
network = dnet.addr(network)
gw = dnet.addr(gw)
router = dnet.route()
error = 0
try:
res = router.delete(network)
except OSError:
if self.debug:
print >> sys.stderr, "Cannot remove route: ", network
try:
res = router.add(network, gw)
except OSError:
if self.debug:
print >> sys.stderr, "Cannot add route: ", network
error = 1
if error:
return 1
else:
return 0
def AddRoute(self, network, gw):
"""Verifies that the route points to localhost."""
network = dnet.addr(network)
gw = dnet.addr(gw)
router = dnet.route()
error = 0
try:
res = router.delete(network)
except OSError:
if self.debug:
print >> sys.stderr, "Cannot remove route: ", network
try:
res = router.add(network, gw)
except OSError:
if self.debug:
print >> sys.stderr, "Cannot add route: ", network
error = 1
if error:
return 1
else:
return 0
def new_read_routes():
rtlst = []
def addrt(rt,lst):
dst,gw = rt
lst.append(rt)
r = dnet.route()
print r.loop(addrt, rtlst)
return rtlst
def new_read_routes():
rtlst = []
def addrt(rt, lst):
dst, gw = rt
lst.append(rt)
r = dnet.route()
print r.loop(addrt, rtlst)
return rtlst
def RemoveRoute(self, network):
"""Removes the route pointing to localhost."""
network = dnet.addr(network)
router = dnet.route()
error = 0
try:
res = router.delete(network)
except OSError:
if self.debug:
print >> sys.stderr, "Cannot remove route: ", network
error = 1
if error:
return 1
else:
return 0
def RemoveRoute(self, network):
"""Removes the route pointing to localhost."""
network = dnet.addr(network)
router = dnet.route()
error = 0
try:
res = router.delete(network)
except OSError:
if self.debug:
print >> sys.stderr, "Cannot remove route: ", network
error = 1
if error:
return 1
else:
return 0
def setUp(self):
self.route = dnet.route()
self.failUnless(self.route, "couldn't open route handle")
def setUp(self):
self.route = dnet.route()
self.failUnless(self.route, "couldn't open route handle")
def gen_probes_raw():
""" Pre-generate raw Ethernet packets and store these in the
array pkts.
"""
from dpkt.ethernet import Ethernet
from dpkt.ip import IP
from dpkt.icmp import ICMP
eth_info = dnet.intf().get_dst(options.net_info['ip_dst'])
options.net_info['l2_src'] = eth_info['link_addr'].eth
gw = dnet.route().get(options.net_info['ip_dst'])
if gw:
options.net_info['l2_dst'] = dnet.arp().get(gw).eth
else: # destination is in the same subnet
options.net_info['l2_dst'] = dnet.arp().get(options.net_info['ip_dst']).eth
try:
icmp_data = ICMP(type=8, data=ICMP.Echo(seq=0, id=0,data = 'H'*(options.plen-ICMP_HDR_LEN-IP_HDR_LEN)))
ip_data = IP(src=options.net_info['ip_src'].ip, dst=options.net_info['ip_dst'].ip, p=1, data=icmp_data)
ip_data.len += len(ip_data.data)
p0 = Ethernet(src=options.net_info['l2_src'], dst=options.net_info['l2_dst'], data=ip_data)
str_p = str(p0)
hdr = str_p[:ETHER_HDR_LEN+IP_HDR_LEN]
pkt = str_p[ETHER_HDR_LEN+IP_HDR_LEN:]
psize = options.plen + ETHER_HDR_LEN
# packet and format
p = [ hdr,
pkt[:2],
struct.pack('<H', (0)), # p[2] = ICMP checksum
pkt[4:16],
struct.pack('!L', (0) % 0xFFFFFFFF), # p[4] = sequence number (4 bytes)
struct.pack('!L', (0) % 0xFFFFFFFF), # p[5] = slot number (4 bytes)
pkt[16+4+4:]] # payload
ck = checksum(''.join(p[1:])) & 0xFFFF # calculate initial ICMP cksum
p[2] = struct.pack('H', (ck)) # update ICMP cksum
M_ = sum(struct.unpack('HHHH',''.join(p[4:6])))
j = 0
for i in xrange(options.pnum):
j=long(slottimes[i])
p[4] = struct.pack('!L', (i) % 0xFFFFFFFF) # increment 4 byte seq ID in ICMP payload
p[5] = struct.pack('!L', (j) % 0xFFFFFFFF) # increment 4 byte slot ID in ICMP payload
M = sum(struct.unpack('HHHH', ''.join(p[4:6])))
ck = ck + M_ - M
p[2] = struct.pack('H', (ck) % 0xFFFF) # update ICMP cksum
pkts[i] = ''.join(p)[:PKT_ARRAY_WIDTH] # only store first 100 packet bytes
M_=M
except (MemoryError, ValueError):
ERROR("Not enough memory!",2)
except KeyboardInterrupt:
print 'terminated by user.'
raise SystemExit(-1)
print 'done.'
try:
po = pcap.pcap(options.net_info['eth'])
return po
except Exception as e:
print e
logger.info("Garbaging route %s (to %s, but unsure)" % (r[1], r[2]))
try:
iR.delete(r[1]) # FIXME #BUG #TODO l'interface de dnet ne permet pas de limiter la supression a une interface /!\ tres dangereux
except Exception:
logger.exception("Error when garbaging route")
if __name__ == "__main__":
# Variables
announcer = {}
networks = []
last_announce = last_calc = last_gc = 0
flag_halt = False
sock = None
iR = dnet.route()
# Creation du logger
logger = logging.Logger("nsrpd", level=logging.DEBUG)
try:
logger.addHandler(logging.handlers.SysLogHandler(address="/dev/log", facility=logging.handlers.SysLogHandler.LOG_DAEMON))
logger.handlers[-1].setFormatter(logging.Formatter("%(name)s: %(message)s"))
except Exception:
pass
if True:
logger.addHandler(logging.StreamHandler())
logger.handlers[-1].setFormatter(logging.Formatter("%(asctime)s %(levelname)-8s %(message)s"))
# Enregistrement des actions de garbage final
atexit.register(garbage_collector, True)
def setUp(self):
self.route = dnet.route()
self.assertTrue(self.route, "couldn't open route handle")
