mirror of
https://github.com/ChronosX88/PyNesca.git
synced 2024-11-21 20:52:18 +00:00
Removed duplicate directories.
This commit is contained in:
Zloooy
parent
b16e248712
commit
77ca495fdf
106
MainPresenter.py
106
MainPresenter.py
@ -1,106 +0,0 @@
|
||||
from network_scan.CoreModel import CoreModel
|
||||
from address_generation.Parser import Parser
|
||||
from threading import RLock
|
||||
import datetime
|
||||
from PyQt5.Qt import QThread, pyqtSignal
|
||||
from PyQt5.QtCore import QObject, pyqtSlot
|
||||
from address_generation.IpGenerator import IpGenerator
|
||||
from storage.JSONStorage import JSONStorage
|
||||
|
||||
|
||||
class MainPresenter:
|
||||
def __init__(self, ui):
|
||||
self.ui = ui
|
||||
self.threads = []
|
||||
self.isScanEnabled = False
|
||||
self.parser = Parser()
|
||||
#needed config to specify path
|
||||
self.storage = JSONStorage("results.json")
|
||||
self.exit_lock = RLock()
|
||||
|
||||
def startScan(self, ipRanges, portsStr, threadNumber, timeout):
|
||||
timeout = 3 if not timeout else int(timeout)
|
||||
addresses = self.parser.parse_address_field(ipRanges)
|
||||
ports = self.parser.parse_port_field(portsStr)
|
||||
self.ip_generator = IpGenerator(addresses, ports)
|
||||
self.scanner = CoreModel(timeout)
|
||||
threadNumber = int(threadNumber)
|
||||
for i in range(threadNumber):
|
||||
scan_worker = ScanWorker(
|
||||
self.ip_generator,
|
||||
self.scanner,
|
||||
self.storage
|
||||
)
|
||||
scan_thread = QThread()
|
||||
scan_worker.log_signal.connect(self.log_text)
|
||||
scan_worker.moveToThread(scan_thread)
|
||||
scan_worker.exit_signal.connect(scan_thread.exit)
|
||||
scan_worker.exit_signal.connect(self.on_worker_exit)
|
||||
scan_thread.started.connect(scan_worker.work)
|
||||
self.threads.append((scan_worker, scan_thread))
|
||||
self.changeThreadLabel(threadNumber)
|
||||
for thread in self.threads:
|
||||
scan_worker, scan_thread = thread
|
||||
scan_thread.start()
|
||||
|
||||
def changeThreadLabel(self, number_of_threads):
|
||||
self.number_of_threads = number_of_threads
|
||||
self.ui.currentThreadsLabel.setText(str(number_of_threads))
|
||||
|
||||
def on_worker_exit(self):
|
||||
self.changeThreadLabel(self.number_of_threads - 1)
|
||||
with self.exit_lock:
|
||||
for num, thread in enumerate(self.threads):
|
||||
scan_worker, scan_thread = thread
|
||||
if not scan_worker.isRunning:
|
||||
self.threads.pop(num)
|
||||
break
|
||||
if self.number_of_threads == 0:
|
||||
self.on_end_scanning()
|
||||
|
||||
def on_end_scanning(self):
|
||||
self.isScanEnabled = False
|
||||
self.ui.startButton.setText("Start")
|
||||
self.storage.save()
|
||||
|
||||
def stopScan(self):
|
||||
while self.threads:
|
||||
scan_worker, scan_thread = self.threads[0]
|
||||
if scan_worker.isRunning:
|
||||
scan_worker.stop()
|
||||
|
||||
def log_text(self, string):
|
||||
self.ui.dataText.append("[" + str(datetime.datetime.now()) + "] " + str(string))
|
||||
|
||||
|
||||
class ScanWorker(QObject):
|
||||
|
||||
log_signal = pyqtSignal(str)
|
||||
exit_signal = pyqtSignal()
|
||||
|
||||
def __init__(self, ip_generator, scanner, storage, **kwargs):
|
||||
super().__init__()
|
||||
self.ip_generator = ip_generator
|
||||
self.storage = storage
|
||||
self.scanner = scanner
|
||||
self.previous_address = None
|
||||
self.isRunning = True
|
||||
|
||||
@pyqtSlot()
|
||||
def work(self):
|
||||
while self.isRunning:
|
||||
scan_address = self.ip_generator.get_next_address(self.previous_address)
|
||||
if not scan_address:
|
||||
break
|
||||
self.previous_address = scan_address
|
||||
scan_result = self.scanner.scan_address(scan_address)
|
||||
self.storage.put_responce(scan_address, scan_result)
|
||||
if scan_result == 0:
|
||||
self.log_signal.emit('%s has open port: %s' % scan_address)
|
||||
else:
|
||||
self.log_signal.emit('%s has closed port: %s' % scan_address)
|
||||
self.stop()
|
||||
|
||||
def stop(self):
|
||||
self.isRunning = False
|
||||
self.exit_signal.emit()
|
||||
98
RawTCP.py
98
RawTCP.py
@ -1,98 +0,0 @@
|
||||
from struct import pack, unpack
|
||||
import socket
|
||||
|
||||
|
||||
class TCPHeader():
|
||||
# TCP header class. Thanks to Silver Moon for the flags calculation and packing order
|
||||
# This was designed to be re-used. You might want to randomize the seq number
|
||||
# get_struct performs packing based on if you have a valid checksum or not
|
||||
def __init__(self, src_port=47123, dst_port=80, seqnum=1000, acknum=0, data_offset=80, fin=0, syn=1, rst=0, psh=0, ack=0, urg=0, window=5840, check=0, urg_ptr=0):
|
||||
# !=network(big-endian), H=short(2), L=long(4),B=char(1)
|
||||
self.order = "!HHLLBBHHH"
|
||||
self.src_port = src_port
|
||||
self.dst_port = dst_port
|
||||
self.seqnum = seqnum
|
||||
self.acknum = acknum
|
||||
# size of tcp header; size is specified by 4-byte words; This is 80
|
||||
# decimal, which is 0x50, which is 20bytes (5words*4bytes).
|
||||
self.data_offset = data_offset
|
||||
self.fin = fin
|
||||
self.syn = syn
|
||||
self.rst = rst
|
||||
self.psh = psh
|
||||
self.ack = ack
|
||||
self.urg = urg
|
||||
self.window = socket.htons(window)
|
||||
self.check = check
|
||||
self.urg_ptr = urg_ptr
|
||||
|
||||
def flags(self):
|
||||
return self.fin + (self.syn << 1) + (self.rst << 2) + (self.psh << 3) + (self.ack << 4) + (self.urg << 5)
|
||||
|
||||
def get_struct(self, check=False, checksummed=False):
|
||||
if check is not False:
|
||||
self.check = check
|
||||
if checksummed:
|
||||
return pack('!HHLLBBH', self.src_port, self.dst_port, self.seqnum, self.acknum, self.data_offset, self.flags(), self.window) + pack('H', self.check) + pack('!H', self.urg_ptr)
|
||||
else:
|
||||
return pack(self.order, self.src_port, self.dst_port, self.seqnum, self.acknum, self.data_offset, self.flags(), self.window, self.check, self.urg_ptr)
|
||||
|
||||
|
||||
def checksum(msg):
|
||||
# Shoutout to Silver Moon @ binarytides for this checksum algo.
|
||||
sum = 0
|
||||
for i in range(0, len(msg), 2):
|
||||
w = msg[i] + (msg[i + 1] << 8)
|
||||
sum = sum + w
|
||||
|
||||
sum = (sum >> 16) + (sum & 0xffff)
|
||||
sum = sum + (sum >> 16)
|
||||
sum = ~sum & 0xffff
|
||||
return sum
|
||||
|
||||
|
||||
def tcp_checksum(source_ip, dest_ip, tcp_header, user_data=b''):
|
||||
# Calculates the correct checksum for the tcp header
|
||||
tcp_length = len(tcp_header) + len(user_data)
|
||||
# This is an IP header w/ TCP as protocol.
|
||||
ip_header = pack('!4s4sBBH', socket.inet_aton(source_ip), socket.inet_aton(
|
||||
dest_ip), 0, socket.IPPROTO_TCP, tcp_length)
|
||||
# Assemble the packet (IP Header + TCP Header + data, and then send it to
|
||||
# checksum function)
|
||||
packet = ip_header + tcp_header + user_data
|
||||
return checksum(packet)
|
||||
|
||||
|
||||
def handle_packet(raw_packet):
|
||||
# Now we need to unpack the packet. It will be an IP/TCP packet
|
||||
# We are looking for SYN-ACKs from our SYN scan
|
||||
# Fields to check: IP - src addr; TCP - src port, flags
|
||||
# We want to pull out and compare only these three
|
||||
# Heres the math for unpacking: B=1, H=2, L=4, 4s=4 (those are bytes)
|
||||
packet = raw_packet[0]
|
||||
# This is the IP header, not including any self.options OR THE DST ADDR.
|
||||
# Normal length is 20!! Im parsing as little as possible
|
||||
ip_header = unpack('!BBHHHBBH4s', packet[0:16])
|
||||
# If there are any self.options, the length of the IP header will be >20. We
|
||||
# dont care about self.options
|
||||
ip_header_length = (ip_header[0] & 0xf) * 4
|
||||
# This is the source address (position 8, or the first "4s" in our
|
||||
# unpack)
|
||||
src_addr = socket.inet_ntoa(ip_header[8])
|
||||
|
||||
# We had to get the proper IP Header length to find the TCP header
|
||||
# offset.
|
||||
tcp_header_raw = packet[ip_header_length:ip_header_length + 14]
|
||||
# TCP header structure is pretty straight-forward. We want PORTS and
|
||||
# FLAGS, so we partial unpack it
|
||||
tcp_header = unpack('!HHLLBB', tcp_header_raw)
|
||||
|
||||
src_port = tcp_header[0] # self-explanatory
|
||||
dst_port = tcp_header[1] # self-explanatory FIXME: notused
|
||||
# We only care about syn-ack, which will be 18 (0x12)
|
||||
flag = tcp_header[5]
|
||||
|
||||
if flag == 18:
|
||||
return (src_addr, src_port)
|
||||
else:
|
||||
return None
|
||||
89
TCPScan.py
89
TCPScan.py
@ -1,89 +0,0 @@
|
||||
from RawTCP import TCPHeader, handle_packet, tcp_checksum
|
||||
import socket
|
||||
import sys
|
||||
|
||||
|
||||
class TCPScanner:
|
||||
def __init__(self):
|
||||
self.source_ips = {}
|
||||
# TODO: options, threading, input/output queues
|
||||
self.options = None
|
||||
return
|
||||
|
||||
def in_scope(self):
|
||||
"""Check that IP is in scanning scope"""
|
||||
# TODO
|
||||
pass
|
||||
|
||||
def tcp_listener(self):
|
||||
# Raw socket listener for when send_raw_syn() is used. This will catch
|
||||
# return SYN-ACKs
|
||||
listen = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
|
||||
while True:
|
||||
# packet = ('E \x00(\x1f\xaa@\x00w\x06\x99w2\xe0\xc8\xa2\xa2\xf3\xac\x18\xdf\xb3\x00\x16\xb6\x80\xc1\xa0/\xa6=$P\x10\xce\xab\xd1\xe4\x00\x00', ('50.XXX.200.162', 0))
|
||||
raw_packet = listen.recvfrom(65565)
|
||||
ret = handle_packet(raw_packet)
|
||||
if ret is None:
|
||||
continue
|
||||
src_addr, src_port = ret
|
||||
if self.in_scope(src_addr) and src_port in self.ports:
|
||||
self.output_queue.put((src_addr, src_port))
|
||||
|
||||
def send_raw_syn(self, dest_ip, dst_port):
|
||||
# Use raw sockets to send a SYN packet.
|
||||
# If you want, you could use the IP header assembled in the tcp_checksum
|
||||
# function to have a fully custom TCP/IP stack
|
||||
try:
|
||||
# Using IPPROTO_TCP so the kernel will deal with the IP packet for us.
|
||||
# Change to IPPROTO_IP if you want control of IP header as well
|
||||
s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
|
||||
except Exception:
|
||||
sys.stderr.write("Error creating socket in send_raw_syn\n")
|
||||
return
|
||||
if self.options.source == "auto":
|
||||
# This gets the correct source IP. Just in case of multiple interfaces,
|
||||
# it will pick the right one
|
||||
src_addr = self.get_source_ip(dest_ip)
|
||||
else:
|
||||
src_addr = self.options.source
|
||||
src_port = 54321
|
||||
make_tcpheader = TCPHeader(src_port, dst_port)
|
||||
tcp_header = make_tcpheader.get_struct()
|
||||
packet = make_tcpheader.get_struct(check=tcp_checksum(
|
||||
src_addr, dest_ip, tcp_header), checksummed=True)
|
||||
try:
|
||||
s.sendto(packet, (dest_ip, 0))
|
||||
except Exception as e:
|
||||
sys.stderr.write("Error utilizing raw socket in send_raw_syn: {}\n".format(e))
|
||||
|
||||
def get_source_ip(self, dst_addr):
|
||||
# Credit: 131264/alexander from stackoverflow. This gets the correct IP for sending. Useful if you have multiple interfaces
|
||||
# NOTE: This will send an additional packet for every single IP to confirm
|
||||
# the route. (but just one packet)
|
||||
try:
|
||||
if dst_addr in self.source_ips:
|
||||
return self.source_ips[dst_addr]
|
||||
else:
|
||||
self.source_ips[dst_addr] = [(s.connect((dst_addr, 53)), s.getsockname()[0], s.close(
|
||||
)) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]
|
||||
return self.source_ips[dst_addr]
|
||||
except Exception:
|
||||
sys.stderr.write(
|
||||
"Something went wrong in get_source_ip, results might be wrong\n")
|
||||
|
||||
|
||||
def send_full_connect_syn(ip, port, timeout):
|
||||
# Normal scan using socket to connect. Does 3-way handshack, then graceful
|
||||
# teardown using FIN
|
||||
try:
|
||||
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
s.settimeout(timeout)
|
||||
except Exception as e:
|
||||
sys.stderr.write("Error creating socket in send_full_connect_syn: {}\n".format(e))
|
||||
return False
|
||||
try:
|
||||
s.connect((ip, port))
|
||||
return True
|
||||
s.close()
|
||||
except Exception:
|
||||
return False
|
||||
@ -1,15 +0,0 @@
|
||||
from abc import abstractmethod, ABC
|
||||
|
||||
|
||||
class AbstractAddressGenerator(ABC):
|
||||
'''The class describes addess generation mechanism.
|
||||
In __init__ method it should get results of parsing fields
|
||||
and then it returns addresses.'''
|
||||
@classmethod
|
||||
@abstractmethod
|
||||
def get_next_address(self, previous_address, **kwargs):
|
||||
'''Address - an only, indivisible object, that describes single scan
|
||||
target address. This method should return next address to scan based on
|
||||
previous scanned address and result of scanning previous address, that
|
||||
can be placed in kwargs.'''
|
||||
pass
|
||||
@ -1,18 +0,0 @@
|
||||
from abc import ABC, abstractmethod
|
||||
|
||||
|
||||
class AbstractParser(ABC):
|
||||
'''The class describes fields parsing mechanisms'''
|
||||
|
||||
@classmethod
|
||||
@abstractmethod
|
||||
def parse_address_field(self, field):
|
||||
'''In address field can be plased any text, describing address of
|
||||
scanning target'''
|
||||
pass
|
||||
|
||||
@classmethod
|
||||
@abstractmethod
|
||||
def parse_port_field(self, field):
|
||||
'''In port field only numbers, whitespaces, comma and '-' allowed'''
|
||||
pass
|
||||
@ -1,28 +0,0 @@
|
||||
from AbstractAddressGenerator import AbstractAddressGenerator
|
||||
from threading import RLock
|
||||
|
||||
|
||||
class IpGenerator(AbstractAddressGenerator):
|
||||
|
||||
def __init__(self, ip_generator, ports):
|
||||
self.ip_generator = ip_generator
|
||||
self.ports = ports
|
||||
self.lock = RLock()
|
||||
|
||||
def get_next_port_number(self, previous_port):
|
||||
return (self.ports.index(previous_port) + 1) % len(self.ports)
|
||||
|
||||
def get_next_address(self, previous_address):
|
||||
with self.lock:
|
||||
portnum = 0
|
||||
next_ip = None
|
||||
if previous_address:
|
||||
next_ip, port = previous_address
|
||||
portnum = self.get_next_port_number(port)
|
||||
if (portnum == 0):
|
||||
try:
|
||||
next_ip = str(next(self.ip_generator))
|
||||
except StopIteration:
|
||||
return None
|
||||
result = (next_ip, self.ports[portnum])
|
||||
return result
|
||||
@ -1,80 +0,0 @@
|
||||
import ipaddress
|
||||
from AbstractParser import AbstractParser
|
||||
|
||||
|
||||
class Parser(AbstractParser):
|
||||
|
||||
def parse_port_field(self, ports):
|
||||
"""
|
||||
Parses ports from string, returns them as integers in the list.
|
||||
Handles non-existent ports and non-port values.
|
||||
"""
|
||||
if ports:
|
||||
# Using set to avoid repetitions
|
||||
parsed = set()
|
||||
ports = ports.split(",")
|
||||
for port in ports:
|
||||
try:
|
||||
# Input is in range form ("100-200"):
|
||||
if '-' in port:
|
||||
start, end = map(int, port.split('-'))
|
||||
parsed.update(
|
||||
[p for p in range(start, end + 1) if 65355 >= p > 0])
|
||||
# Input is a single port ("80"):
|
||||
else:
|
||||
parsed.add(int(port))
|
||||
except ValueError as e:
|
||||
# If we get any not integer just ignore it
|
||||
pass
|
||||
return sorted(list(parsed))
|
||||
else:
|
||||
# Change to default ports from constant
|
||||
return [21, 22, 23, 25, 80, 443, 110, 111, 135, 139, 445, 8080, 8443, 53, 143, 989, 990, 3306, 1080, 5554, 6667, 2222, 4444, 666, 6666, 1337, 2020, 31337]
|
||||
|
||||
def parse_address_field(self, ips):
|
||||
"""
|
||||
Parses ip input string, returns the generator over them.
|
||||
|
||||
Supports next inputs:
|
||||
1) 1.2.3.4
|
||||
2) 192.168.0.0/24
|
||||
3) 1.2.3.4 - 5.6.7.8
|
||||
Any non-ip value will be ignored.
|
||||
"""
|
||||
|
||||
# A set to contain non repeating ip objects from ipaddress
|
||||
ip_objects = set()
|
||||
inputs = [ip.strip() for ip in ips.split(',')]
|
||||
|
||||
for input_ in inputs:
|
||||
try:
|
||||
# Input is in range form ("1.2.3.4 - 5.6.7.8"):
|
||||
if '-' in input_:
|
||||
input_ips = input_.split('-')
|
||||
ranges = set(
|
||||
ipaddress.summarize_address_range(
|
||||
*map(lambda x: ipaddress.IPv4Address(x.strip()), input_ips)
|
||||
)
|
||||
)
|
||||
ip_objects.update(ranges)
|
||||
# Input is in CIDR form ("192.168.0.0/24"):
|
||||
elif '/' in input_:
|
||||
network = ipaddress.ip_network(input_)
|
||||
ip_objects.add(network)
|
||||
# Input is a single ip ("1.1.1.1"):
|
||||
else:
|
||||
ip = ipaddress.ip_address(input_)
|
||||
ip_objects.add(ip)
|
||||
except ValueError as e:
|
||||
print(e)
|
||||
# If we get any non-ip value just ignore it
|
||||
pass
|
||||
|
||||
for ip_obj in ip_objects:
|
||||
# The object is just one ip, simply yield it:
|
||||
if isinstance(ip_obj, ipaddress.IPv4Address):
|
||||
yield ip_obj
|
||||
# The object is a network, yield every host in it:
|
||||
else:
|
||||
for host in ip_obj:
|
||||
yield host
|
||||
@ -1,6 +0,0 @@
|
||||
import sys
|
||||
import os
|
||||
|
||||
|
||||
fil = __file__[:__file__.rindex(os.sep)]
|
||||
sys.path.insert(0,fil)
|
||||
@ -1,27 +0,0 @@
|
||||
from unittest import TestCase, main
|
||||
from ipaddress import IPv4Address
|
||||
from IpGenerator import IpGenerator
|
||||
from Parser import Parser
|
||||
|
||||
|
||||
class testIpGenerator(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
p = Parser()
|
||||
self.ipgen = IpGenerator(
|
||||
p.parse_address_field("192.168.1.1 - 192.168.1.10"), [80, 90])
|
||||
|
||||
def testIpGeneration(self):
|
||||
'''self.assertEqual(
|
||||
self.ipgen.get_next_address(None),
|
||||
("192.168.1.1", 80))'''
|
||||
previous_address = None
|
||||
a = True
|
||||
while previous_address or a:
|
||||
previous_address=self.ipgen.get_next_address(previous_address)
|
||||
a = False
|
||||
self.assertEqual(self.ipgen.get_next_address(None), None)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,37 +0,0 @@
|
||||
from unittest import main, TestCase
|
||||
from Parser import Parser
|
||||
import ipaddress
|
||||
|
||||
|
||||
class TestParser(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.parser = Parser()
|
||||
|
||||
def test_port_parsing(self):
|
||||
self.assertEqual(self.parser.parse_port_field("80,90"), [80, 90])
|
||||
|
||||
def test_ip_parsing(self):
|
||||
self.assertEqual(
|
||||
set(self.parser.parse_address_field("192.168.1.1 - 192.168.1.3")),
|
||||
{ipaddress.IPv4Address(ip) for ip in
|
||||
[
|
||||
"192.168.1.1",
|
||||
"192.168.1.2",
|
||||
"192.168.1.3"
|
||||
]})
|
||||
self.assertEqual(
|
||||
set(self.parser.parse_address_field("192.168.1.1")),
|
||||
{ipaddress.IPv4Address("192.168.1.1")}
|
||||
)
|
||||
self.assertEqual(
|
||||
set(self.parser.parse_address_field("192.168.1.0/31")),
|
||||
{ipaddress.IPv4Address(ip) for ip in
|
||||
[
|
||||
'192.168.1.1',
|
||||
'192.168.1.0'
|
||||
]})
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,19 +0,0 @@
|
||||
from abc import ABC, abstractmethod
|
||||
|
||||
|
||||
class AbstractScanner(ABC):
|
||||
'''The class is used by one thread to scan targets'''
|
||||
|
||||
@classmethod
|
||||
@abstractmethod
|
||||
def __init__(self, **kwargs):
|
||||
'''In this method you can init some
|
||||
reusable resources needed for scan'''
|
||||
pass
|
||||
|
||||
@classmethod
|
||||
@abstractmethod
|
||||
def scan_address(self, address):
|
||||
'''This method should contain scanning process of given address. All
|
||||
items returned will be passed to AbstractStorage and ui'''
|
||||
pass
|
||||
@ -1,15 +0,0 @@
|
||||
import socket
|
||||
from AbstractScanner import AbstractScanner
|
||||
|
||||
|
||||
class CoreModel(AbstractScanner):
|
||||
def __init__(self, timeout):
|
||||
self.defSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
self.defSocket.settimeout(int(timeout))
|
||||
|
||||
def scan_address(self, address):
|
||||
host, port = address
|
||||
result = self.defSocket.connect_ex((host, port))
|
||||
self.defSocket.close()
|
||||
self.defSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
return result
|
||||
@ -1,6 +0,0 @@
|
||||
import sys
|
||||
import os
|
||||
|
||||
|
||||
fil = __file__[:__file__.rindex(os.sep)]
|
||||
sys.path.insert(0,fil)
|
||||
@ -1,14 +0,0 @@
|
||||
from abc import ABC, abstractmethod
|
||||
|
||||
|
||||
class AbstractStorage(ABC):
|
||||
|
||||
@classmethod
|
||||
@abstractmethod
|
||||
def put_responce(self, address, responce):
|
||||
pass
|
||||
|
||||
@classmethod
|
||||
@abstractmethod
|
||||
def save(self):
|
||||
pass
|
||||
@ -1,23 +0,0 @@
|
||||
from AbstractStorage import AbstractStorage
|
||||
import json
|
||||
from threading import RLock
|
||||
|
||||
|
||||
class JSONStorage(AbstractStorage):
|
||||
|
||||
def __init__(self, path):
|
||||
self.path = path
|
||||
self.respdict = dict()
|
||||
self.lock = RLock()
|
||||
|
||||
def put_responce(self, address, responce):
|
||||
ip, port = address
|
||||
if ip not in self.respdict.keys():
|
||||
self.respdict[ip] = {"open": [], "close": []}
|
||||
self.respdict[ip]["open" if responce != 0 else "close"].append(port)
|
||||
|
||||
def save(self):
|
||||
print("saving")
|
||||
with open(self.path, "w") as f:
|
||||
json.dump(self.respdict, f)
|
||||
self.respdict = {}
|
||||
@ -1,6 +0,0 @@
|
||||
import sys
|
||||
import os
|
||||
|
||||
|
||||
fil = __file__[:__file__.rindex(os.sep)]
|
||||
sys.path.insert(0,fil)
|
||||
Loading…
Reference in New Issue
Block a user