MrKalzu/traceroute_map
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Writing to the database works now.

Browse Source
This commit is contained in:
kalzu rekku 2024-05-27 22:37:47 +03:00
parent 6e9d11dcde
commit 929a3523ba
1 changed files with 90 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
traceroute_collector.py
View File

@ -6,8 +6,11 @@ import sqlite3
import re
import json
import ipaddress
import uuid
import hashlib
from datetime import datetime
def run_traceroute(host):
timestamp = datetime.now().timestamp()
result = subprocess.run(['traceroute', host], stdout=subprocess.PIPE)
@ -16,6 +19,7 @@ def run_traceroute(host):
def parse_traceroute_output(output, timestamp):
lines = output.strip().split('\n')
trace = {}
hops = []
ip_regex = r"\((.*?)\)" # ipaddress are in ()
@ -40,7 +44,8 @@ def parse_traceroute_output(output, timestamp):
# source node drops or blocks icmp packages
# We will give funny to name to hop for not answering and move on.
if part == '*':
hop_name = 'hop.'+str(count)+'.'+str(target)
hop_name = 'unresponsive'
hop_ip = 'unresponsive'
break
@ -73,17 +78,18 @@ def parse_traceroute_output(output, timestamp):
hop_latency = sum(latencies) / len(latencies) if latencies else None
hop['timestamp'] = timestamp
hop['hop_number'] = hop_number
if not hop_name == None:
hop['hop_name'] = hop_name
hop['hop_ip'] = hop_ip
hop['hop_latency'] = hop_latency
hops.append(target)
hops.append(hop)
return hops
trace['target'] = target
trace['timestamp'] = timestamp
trace['hops'] = hops
return trace
def create_tables(databasefile):
@ -104,10 +110,10 @@ def create_tables(databasefile):
create_paths_table = """
CREATE TABLE IF NOT EXISTS Paths (
id INTEGER PRIMARY KEY,
start_ip TEXT NOT NULL,
end_ip TEXT NOT NULL,
node TEXT NOT NULL,
target TEXT NOT NULL,
hops_json TEXT NOT NULL,
UNIQUE(start_ip, end_ip, hops_json)
UNIQUE(node, target, hops_json)
);
"""
@ -124,12 +130,9 @@ def create_tables(databasefile):
create_hopdetails_table = """
CREATE TABLE IF NOT EXISTS HopDetails (
id INTEGER PRIMARY KEY,
link_id INTEGER NOT NULL,
ttl INTEGER,
icmp_type INTEGER,
icmp_code INTEGER,
packet_loss REAL,
FOREIGN KEY (link_id) REFERENCES Links(id)
hop_name TEXT,
hop_ip TEXT,
hop_latency TEXT
);
"""
@ -143,70 +146,101 @@ def create_tables(databasefile):
conn.commit()
conn.close()
def store_traceroute(db_file, start_ip, end_ip, hops):
def store_traceroute(db_file, node, trace):
conn = sqlite3.connect(db_file)
cursor = conn.cursor()
# Insert links and get their IDs
link_ids = []
for hop in hops:
print(hop)
source_ip = start_ip if not link_ids else hops[len(link_ids)-1][0]
destination_ip = hop[0]
latency = hop[1]
hops_json = json.dumps(trace['hops'])
path_ids = {}
previous_hop_ip = None
previous_hop_latency = None
for hop in trace['hops']:
hop_number = hop['hop_number']
hop_name = hop.get('hop_name')
hop_ip = hop.get('hop_ip')
hop_latency = hop.get('hop_latency')
link_id = None
# insert links and get their id's
if previous_hop_ip:
cursor.execute("""
INSERT OR IGNORE INTO Links (source_ip, destination_ip) VALUES (?, ?)
""", (source_ip, destination_ip))
""", (previous_hop_ip, hop_ip))
cursor.execute("""
SELECT id FROM Links WHERE source_ip = ? AND destination_ip = ?
""", (source_ip, destination_ip))
""", (previous_hop_ip, hop_ip))
result = cursor.fetchone()
if result is None:
print(hop)
raise ValueError(f"Failed to insert of find link between {source_ip} and {destination_ip}")
link_id = result[0]
link_ids.append(link_id)
link_id = result
path_ids[hop_number] = link_id
previous_hop_ip = hop_ip
cursor.execute("""
INSERT INTO Latency (link_id, latency_ms) VALUES (?, ?)
""", (link_id, latency))
# Save hop details
cursor.execute("INSERT INTO HopDetails (hop_name, hop_ip, hop_latency) VALUES (?, ?, ?)",
(hop_name, hop_ip, hop_latency))
# Insert path
hops_json = json.dumps(link_ids)
cursor.execute("""
INSERT INTO Paths (start_ip, end_ip, hops_json) VALUES (?, ?, ?)
""", (start_ip, end_ip, hops_json))
# calculate link latency if possible and store it
if link_id and previous_hop_latency:
link_latency = hop_latency - previous_hop_latency
cursor.execute("INSERT INTO Latency (link_id, timestamp, latency_ms) VALUES (?, ?, ?)",
(link_id, trace['timestamp'], link_latency))
# make entry to "Paths" table
if path_ids:
json_path_ids = json.dumps(path_ids)
cursor.execute("INSERT OR IGNORE INTO Paths (node, target, hops_json) VALUES (?, ?, ?)",
(node, trace['target'], json_path_ids))
conn.commit()
conn.close()
def retrieve_traceroute():
conn = sqlite3.connect('traceroute.db')
def retrieve_traceroute(db_file):
retval = {}
conn = sqlite3.connect(db_file)
cursor = conn.cursor()
cursor.execute('''
SELECT l.source_ip, l.destination_ip, ll.latency, ll.timestamp
FROM link_latency ll
JOIN links l ON ll.link_id = l.id
ORDER BY ll.timestamp
SELECT target, hops_json
FROM Paths
''')
rows = cursor.fetchall()
retval['path'] = cursor.fetchall()
cursor.execute('''
SELECT source_ip, destination_ip
FROM Links
''')
retval['links'] = cursor.fetchall()
conn.close()
return rows
return retval
def generate_node_id():
mac = uuid.getnode()
mac_str = ':'.join(['{:02x}'.format((mac >> ele) & 0xff) for ele in range(0,8*6,8)][::-1])
# Hash the MAC address using SHA-256 to generate a unique ID
unique_id = hashlib.sha256(mac_str.encode()).hexdigest()
return unique_id
if __name__ == '__main__':
databasefile="./traceroute.db"
create_tables(databasefile)
db_file="./traceroute.db"
create_tables(db_file)
my_id = generate_node_id()
target='vi.fi'
target='1.1.1.1'
traceroute_output, timestamp = run_traceroute(target)
hops = parse_traceroute_output(traceroute_output, timestamp)
trace = parse_traceroute_output(traceroute_output, timestamp)
store_traceroute(db_file, my_id, trace)
print("#####")
print(hops)
print(retrieve_traceroute(db_file))
print("#####")
exit(0)