def init_func(self, creator_fd, dns_fd, whitelist, debug=False):
taddr = fnc_config.configs["tcp_server_address"]
s = socket.socket()
self.set_socket(s)
self.connect(taddr, 6)
crypto_info = fnc_config.configs["tcp_crypto_module"]
name = crypto_info["name"]
args = crypto_info["args"]
name = "freenet.lib.crypto.%s" % name
__import__(name)
m = sys.modules[name]
self.__encrypt = m.encrypt(*args)
self.__decrypt = m.decrypt(*args)
self.__debug = debug
self.__static_nat = static_nat.nat()
self.__dns_fd = dns_fd
self.__traffic_send_fd = self.create_handler(self.fileno, traffic_pass.traffic_send)
self.__timer = timer.timer()
self.__udp_proxy_map = {}
# 如果是非全局UDP代理,那么开启UDP白名单模式
if not fnc_config.configs["udp_global"]:
self.__udp_whitelist = udp_whitelist.whitelist()
for subn, mask in whitelist: self.__udp_whitelist.add_rule(subn, mask)
if not self.__debug:
sys.stdout = open(fnc_config.configs["access_log"], "a+")
sys.stderr = open(fnc_config.configs["error_log"], "a+")
return self.fileno
def init_func(self,
creator,
address,
host_match,
debug=False,
server_side=False,
is_ipv6=False):
if is_ipv6:
fa = socket.AF_INET6
else:
fa = socket.AF_INET
self.__is_ipv6 = is_ipv6
s = socket.socket(fa, socket.SOCK_DGRAM)
if server_side and is_ipv6:
s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
self.set_socket(s)
self.__server_side = server_side
if server_side:
self.bind((address, 53))
else:
self.connect((address, 53))
self.__debug = debug
self.__host_match = host_match
self.__timer = timer.timer()
self.set_timeout(self.fileno, self.__LOOP_TIMEOUT)
self.register(self.fileno)
self.add_evt_read(self.fileno)
return self.fileno
def init_func(self,
creator_fd,
address,
packet_id,
is_udplite=False,
is_ipv6=False):
self.__creator = creator_fd
self.__packet_id = packet_id
self.__time = time.time()
self.__access = {}
self.__timer = timer.timer()
self.__is_udplite = is_udplite
if not self.dispatcher.enable_ipv6 and is_ipv6: return -1
if is_ipv6:
fa = socket.AF_INET6
listen_ip = "::"
self.__addr_type = socks2https.ADDR_TYPE_IPv6
else:
self.__addr_type = socks2https.ADDR_TYPE_IP
fa = socket.AF_INET
listen_ip = "0.0.0.0"
s = socket.socket(fa, socket.SOCK_DGRAM)
self.set_socket(s)
self.bind((listen_ip, 0))
self.get_handler(self.__creator).tell_conn_ok(self.__packet_id)
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.set_timeout(self.fileno, 10)
return self.fileno
def __init__(self):
"""
:param max_size: 组包之后数据的最大大小,单位为字节
"""
self.__frag_data = {}
self.__timer = timer.timer()
self.__ok_packets = []
def init_func(self, creator_fd, dns_fd, whitelist, debug=False):
taddr = fnc_config.configs["tcp_server_address"]
s = socket.socket()
self.set_socket(s)
self.connect(taddr, 6)
crypto_info = fnc_config.configs["tcp_crypto_module"]
name = crypto_info["name"]
args = crypto_info["args"]
name = "freenet.lib.crypto.%s" % name
__import__(name)
m = sys.modules[name]
self.__encrypt = m.encrypt(*args)
self.__decrypt = m.decrypt(*args)
self.__debug = debug
self.__static_nat = static_nat.nat()
self.__dns_fd = dns_fd
self.__traffic_send_fd = self.create_handler(self.fileno, traffic_pass.traffic_send)
self.__timer = timer.timer()
self.__udp_proxy_map = {}
# 如果是非全局UDP代理,那么开启UDP白名单模式
if not fnc_config.configs["udp_global"]:
self.__udp_whitelist = udp_whitelist.whitelist()
for subn, mask in whitelist: self.__udp_whitelist.add_rule(subn, mask)
if not self.__debug:
sys.stdout = open(fnc_config.configs["access_log"], "a+")
sys.stderr = open(fnc_config.configs["error_log"], "a+")
return self.fileno
def __init__(self, serviced):
self.__map_info = {}
self.__timer = timer.timer()
self.__sessions = {}
self.__serviced = serviced
self.myinit()
def init_func(self,
creator_fd,
address,
dnsserver,
proxy_dnsserver,
is_ipv6=False):
self.__query_timer = timer.timer()
self.__dnsserver = dnsserver
self.__proxy_dnsserver = proxy_dnsserver
self.__dns_client = -1
self.__cur_max_dns_id = 1
self.__empty_ids = []
self.__packet_id = -1
self.__is_ipv6 = is_ipv6
self.__is_sent_handshake = False
self.__conn_ok = False
self.__dns_map = {}
if is_ipv6:
fa = socket.AF_INET6
else:
fa = socket.AF_INET
s = socket.socket(fa, socket.SOCK_DGRAM)
if is_ipv6: s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.set_socket(s)
self.bind(address)
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.set_timeout(self.fileno, 10)
return self.fileno
def __init__(self):
super(fdslightgw, self).__init__()
self.set_mode("gateway")
self.__timer = timer.timer()
self.__routers = {}
account = fngw_config.configs["account"]
self.__session_id = proto_utils.gen_session_id(account["username"],
account["password"])
def init_func(self, creator_fd, dns_fd, raw_socket_fd, whitelist, debug=False):
self.__nat = static_nat.nat()
self.__server = fnc_config.configs["udp_server_address"]
name = "freenet.lib.crypto.%s" % fnc_config.configs["udp_crypto_module"]["name"]
__import__(name)
m = sys.modules.get(name, None)
crypto_args = fnc_config.configs["udp_crypto_module"].get("args", ())
self.__encrypt_m = m.encrypt(*crypto_args)
self.__decrypt_m = m.decrypt(*crypto_args)
self.__debug = debug
self.__timer = timer.timer()
self.__traffic_send_fd = raw_socket_fd
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.set_socket(s)
self.__dns_fd = dns_fd
try:
self.connect(self.__server)
except socket.gaierror:
self.dispatcher.ctunnel_fail()
return -1
ipaddr, _ = s.getpeername()
self.__server_ipaddr = ipaddr
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.__udp_proxy_map = {}
# 如果是非全局UDP代理,那么开启UDP白名单模式
if not fnc_config.configs["udp_global"]:
self.__udp_whitelist = udp_whitelist.whitelist()
for subn, mask in whitelist: self.__udp_whitelist.add_rule(subn, mask)
if not self.__debug:
sys.stdout = open(fnc_config.configs["access_log"], "a+")
sys.stderr = open(fnc_config.configs["error_log"], "a+")
self.__force_udp_global_clients = {}
for client_ip in fnc_config.configs["udp_force_global_clients"]:
saddr = socket.inet_aton(client_ip)
self.__force_udp_global_clients[saddr] = None
self.fn_init()
self.fn_auth_request()
self.set_timeout(self.fileno, self.__TIMEOUT_NO_AUTH)
return self.fileno
def init_func(self, creator_fd, dns_fd, whitelist, debug=False):
self.__nat = static_nat.nat()
self.__server = fnc_config.configs["udp_server_address"]
name = "freenet.lib.crypto.%s" % fnc_config.configs[
"udp_crypto_module"]["name"]
__import__(name)
m = sys.modules.get(name, None)
crypto_args = fnc_config.configs["udp_crypto_module"].get("args", ())
self.__encrypt_m = m.encrypt(*crypto_args)
self.__decrypt_m = m.decrypt(*crypto_args)
self.__debug = debug
self.__timer = timer.timer()
self.__traffic_send_fd = self.create_handler(self.fileno,
traffic_pass.traffic_send)
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.set_socket(s)
self.__dns_fd = dns_fd
try:
self.connect(self.__server)
except socket.gaierror:
self.dispatcher.ctunnel_fail()
return -1
ipaddr, _ = s.getpeername()
self.__server_ipaddr = ipaddr
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.__udp_proxy_map = {}
# 如果是非全局UDP代理,那么开启UDP白名单模式
if not fnc_config.configs["udp_global"]:
self.__udp_whitelist = udp_whitelist.whitelist()
for subn, mask in whitelist:
self.__udp_whitelist.add_rule(subn, mask)
if not self.__debug:
sys.stdout = open(fnc_config.configs["access_log"], "a+")
sys.stderr = open(fnc_config.configs["error_log"], "a+")
self.fn_init()
self.fn_auth_request()
self.set_timeout(self.fileno, self.__TIMEOUT_NO_AUTH)
return self.fileno
def init_func(self,
creator_fd,
tun_fd,
tun6_fd,
dns_fd,
auth_module,
debug=True,
is_ipv6=False):
self.__debug = debug
config = fns_config.configs
self.__SESSION_TIMEOUT = int(config["timeout"])
# 导入加入模块
name = "freenet.lib.crypto.%s" % config["udp_crypto_module"]["name"]
__import__(name)
m = sys.modules.get(name, None)
crypto_config = config["udp_crypto_module"]["configs"]
self.__encrypt = m.encrypt()
self.__decrypt = m.decrypt()
self.__encrypt.config(crypto_config)
self.__decrypt.config(crypto_config)
self.__timer = timer.timer()
self.__debug = debug
self.__sessions = {}
self.__auth_module = auth_module
if is_ipv6:
bind_address = fns_config.configs["udp6_listen"]
else:
bind_address = fns_config.configs["udp_listen"]
if is_ipv6:
s = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
else:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.set_socket(s)
self.bind(bind_address)
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.set_timeout(self.fileno, self.__LOOP_TIMEOUT)
self.__tun_fd = tun_fd
self.__tun6_fd = tun6_fd
self.__dns_fd = dns_fd
return self.fileno
def init_func(self, creator_fd, dns_server):
self.__timer = timer.timer()
self.__creator_fd = creator_fd
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.set_socket(s)
self.connect((dns_server, 53))
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.set_timeout(self.fileno, self.__TIMEOUT)
return self.fileno
def init_func(self, creator_fd, dns_server):
self.__timer = timer.timer()
self.__creator_fd = creator_fd
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.set_socket(s)
self.connect((dns_server, 53))
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.set_timeout(self.fileno, self.__TIMEOUT)
return self.fileno
def init_func(self, debug, configs):
self.create_poll()
signal.signal(signal.SIGINT, self.__exit)
self.__routes = {}
self.__configs = configs
self.__mbuf = utils.mbuf()
self.__debug = debug
self.__tundev_fileno = self.create_handler(-1, tundev.tundevc,
self.__DEVNAME)
self.__port_mapv4 = port_map.port_map(is_ipv6=False)
self.__port_mapv6 = port_map.port_map(is_ipv6=True)
self.__ROUTE_TIMEOUT = 1200
self.__route_timer = timer.timer()
conn = configs["connection"]
m = "freenet.lib.crypto.noany"
try:
self.__tcp_crypto = importlib.import_module("%s.noany_tcp" % m)
self.__udp_crypto = importlib.import_module("%s.noany_udp" % m)
except ImportError:
print("cannot found tcp or udp crypto module")
sys.exit(-1)
crypto_fpath = "%s/fdslight_etc/noany.json" % BASE_DIR
if not os.path.isfile(crypto_fpath):
print("crypto configfile not exists")
sys.exit(-1)
try:
crypto_configs = proto_utils.load_crypto_configfile(crypto_fpath)
except:
print("crypto configfile should be json file")
sys.exit(-1)
self.__crypto_configs = crypto_configs
if not debug:
sys.stdout = open(LOG_FILE, "a+")
sys.stderr = open(ERR_FILE, "a+")
''''''
def init_func(self, creator_fd, dns_server, is_ipv6=False):
self.__timer = timer.timer()
if is_ipv6:
fa = socket.AF_INET6
else:
fa = socket.AF_INET
s = socket.socket(fa, socket.SOCK_DGRAM)
self.set_socket(s)
self.connect((dns_server, 53))
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.set_timeout(self.fileno, self.__LOOP_TIMEOUT)
return self.fileno
def init_func(self,
creator_fd,
tun_fd,
dns_fd,
raw_socket_fd,
ip_pool,
debug=True):
self.__debug = debug
config = fns_config.configs
# 导入加入模块
name = "freenet.lib.crypto.%s" % config["udp_crypto_module"]["name"]
__import__(name)
m = sys.modules.get(name, None)
self.__crypto = m
self.__empty_sessions = []
self.__client_info_by_v_ip = {}
self.__timer = timer.timer()
self.__debug = debug
self.__sessions = {}
self.__ipalloc = ip_pool
bind_address = fns_config.configs["udp_listen"]
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.set_socket(s)
self.bind(bind_address)
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.set_timeout(self.fileno, self.__TIMEOUT)
self.__tun_fd = tun_fd
self.__dns_fd = dns_fd
self.__raw_socket_fd = raw_socket_fd
if not self.__debug:
sys.stdout = open(fns_config.configs["access_log"], "a+")
sys.stderr = open(fns_config.configs["error_log"], "a+")
self.fn_init()
return self.fileno
def init_func(self,
creator_fd,
client_ip,
client_port,
upper_proxy=False,
is_ipv6=False):
self.__creator = creator_fd
self.__time = time.time()
self.__client_ip = client_ip
self.__client_port = client_port
self.__is_ipv6 = is_ipv6
self.__access_list = {}
self.__timer = timer.timer()
self.__upper_proxy = upper_proxy
if is_ipv6:
listen_ip = self.dispatcher.socks5_listen_ipv6
else:
listen_ip = self.dispatcher.socks5_listen_ip
self.__listen_ip = listen_ip
if is_ipv6:
fa = socket.AF_INET6
else:
fa = socket.AF_INET
s = socket.socket(fa, socket.SOCK_DGRAM)
self.set_socket(s)
self.bind((listen_ip, 0))
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.set_timeout(self.fileno, 10)
if self.__upper_proxy:
self.__packet_id = self.dispatcher.alloc_packet_id()
if is_ipv6:
addr_type = socks2https.ADDR_TYPE_IPv6
else:
addr_type = socks2https.ADDR_TYPE_IP
self.dispatcher.send_conn_frame(socks2https.FRAME_TYPE_UDP_CONN,
self.__packet_id, client_ip,
client_port, addr_type)
return self.fileno
def ioloop(self, *args, **kwargs):
"""
:param args: 传递给self.init_func的参数
:param kwargs: 传递给self.init_func的参数
:return:
"""
self.__timer = timer.timer()
self.init_func(*args, **kwargs)
while 1:
wait_time = self.__timer.get_min_time()
if wait_time < 1: wait_time = 10
event_set = self.__poll.poll(wait_time)
self.__handle_events(event_set)
self.__handle_timeout()
self.myloop()
return
def init_func(self,
creator,
virtual_nameserver,
remote_nameserver,
debug=False):
self.__match = _host_match()
self.__virt_ns_naddr = socket.inet_aton(virtual_nameserver)
self.__dns_map = {}
self.__debug = debug
self.__timer = timer.timer()
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.set_socket(s)
self.connect((remote_nameserver, 53))
self.register(self.fileno)
self.add_evt_read(self.fileno)
return self.fileno
def ioloop(self, *args, **kwargs):
"""
:param args: 传递给self.init_func的参数
:param kwargs: 传递给self.init_func的参数
:return:
"""
self.__timer = timer.timer()
self.init_func(*args, **kwargs)
while 1:
wait_time = self.__timer.get_min_time()
if wait_time < 1: wait_time = 10
event_set = self.__poll.poll(wait_time)
self.__handle_events(event_set)
self.__handle_timeout()
self.myloop()
return
def init_func(self, creator_fd, raw_socket_fd, vlan_address, session_uniq_id):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.__creator_fd = creator_fd
self.set_socket(s)
self.bind(("0.0.0.0", 0))
self.__bind_address = self.getsockname()
self.__internet_ip = {}
self.__raw_socket_fd = raw_socket_fd
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.set_timeout(self.fileno, self.__TIMEOUT)
self.__timer = timer.timer()
self.__lan_address = vlan_address
self.__session_uniq_id = session_uniq_id
return self.fileno
def init_func(self, creator_fd, tun_fd, dns_fd, raw_socket_fd, ip_pool, debug=True):
self.__debug = debug
config = fns_config.configs
# 导入加入模块
name = "freenet.lib.crypto.%s" % config["udp_crypto_module"]["name"]
__import__(name)
m = sys.modules.get(name, None)
self.__crypto = m
self.__empty_sessions = []
self.__client_info_by_v_ip = {}
self.__timer = timer.timer()
self.__debug = debug
self.__sessions = {}
self.__ipalloc = ip_pool
bind_address = fns_config.configs["udp_listen"]
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.set_socket(s)
self.bind(bind_address)
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.set_timeout(self.fileno, self.__TIMEOUT)
self.__tun_fd = tun_fd
self.__dns_fd = dns_fd
self.__raw_socket_fd = raw_socket_fd
if not self.__debug:
sys.stdout = open(fns_config.configs["access_log"], "a+")
sys.stderr = open(fns_config.configs["error_log"], "a+")
self.fn_init()
return self.fileno
def init_func(self, creator_fd, host_rules, debug=False):
self.__transparent_dns = fn_config.configs["dns"]
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.set_socket(s)
self.__debug = debug
self.bind((fn_config.configs["dns_bind"], 53))
self.set_timeout(self.fileno, self.__TIMEOUT)
self.__host_match = _host_match()
self.__timer = timer.timer()
self.__blacklist_ips = {}
self.__dns_flags = {}
for rule in host_rules: self.__host_match.add_rule(rule)
self.register(self.fileno)
self.add_evt_read(self.fileno)
return self.fileno
def init_func(self, creator_fd, host_rules, debug=False):
self.__transparent_dns = fn_config.configs["dns"]
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.set_socket(s)
self.__debug = debug
self.bind((fn_config.configs["dns_bind"], 53))
self.set_timeout(self.fileno, self.__TIMEOUT)
self.__host_match = _host_match()
self.__timer = timer.timer()
self.__blacklist_ips = {}
self.__dns_flags = {}
for rule in host_rules: self.__host_match.add_rule(rule)
self.register(self.fileno)
self.add_evt_read(self.fileno)
return self.fileno
def __init__(self):
self.__ok_packets = []
self.__timer = timer.timer()
self.__fragdata = {}
def __init__(self):
self.__tree = {}
self.__timer = timer.timer()
self.__cache = {}
def init_func(self, mode, debug, configs):
self.create_poll()
signal.signal(signal.SIGINT, self.__exit)
self.__route_timer = timer.timer()
self.__routes = {}
self.__configs = configs
if mode == "local":
self.__mode = _MODE_LOCAL
else:
self.__mode = _MODE_GW
self.__mbuf = utils.mbuf()
self.__debug = debug
self.__tundev_fileno = self.create_handler(-1, tundev.tundevc, self.__DEVNAME)
public = configs["public"]
gateway = configs["gateway"]
self.__enable_ipv6_traffic = bool(int(public["enable_ipv6_traffic"]))
is_ipv6 = utils.is_ipv6_address(public["remote_dns"])
if self.__mode == _MODE_GW:
self.__dns_fileno = self.create_handler(-1, dns_proxy.dnsc_proxy, gateway["dnsserver_bind"], debug=debug,
server_side=True, is_ipv6=False)
self.get_handler(self.__dns_fileno).set_parent_dnsserver(public["remote_dns"], is_ipv6=is_ipv6)
if self.__enable_ipv6_traffic:
self.__dns_listen6 = self.create_handler(-1, dns_proxy.dnsc_proxy, gateway["dnsserver_bind6"],
debug=debug, server_side=True, is_ipv6=True)
self.get_handler(self.__dns_listen6).set_parent_dnsserver(public["remote_dns"], is_ipv6=is_ipv6)
else:
self.__dns_fileno = self.create_handler(-1, dns_proxy.dnsc_proxy, public["remote_dns"], debug=debug,
server_side=False)
self.__set_host_rules(None, None)
if self.__mode == _MODE_GW:
self.__load_kernel_mod()
udp_global = bool(int(gateway["dgram_global_proxy"]))
if udp_global:
self.__dgram_fetch_fileno = self.create_handler(-1, traffic_pass.traffic_read,
self.__configs["gateway"],
enable_ipv6=self.__enable_ipv6_traffic)
''''''
else:
local = configs["local"]
vir_dns = local["virtual_dns"]
vir_dns6 = local["virtual_dns6"]
self.set_route(vir_dns, is_ipv6=False, is_dynamic=False)
if self.__enable_ipv6_traffic: self.set_route(vir_dns6, is_ipv6=True, is_dynamic=False)
conn = configs["connection"]
m = "freenet.lib.crypto.%s" % conn["crypto_module"]
try:
self.__tcp_crypto = importlib.import_module("%s.%s_tcp" % (m, conn["crypto_module"]))
self.__udp_crypto = importlib.import_module("%s.%s_udp" % (m, conn["crypto_module"]))
except ImportError:
print("cannot found tcp or udp crypto module")
sys.exit(-1)
crypto_fpath = "%s/fdslight_etc/%s" % (BASE_DIR, conn["crypto_configfile"])
if not os.path.isfile(crypto_fpath):
print("crypto configfile not exists")
sys.exit(-1)
try:
crypto_configs = proto_utils.load_crypto_configfile(crypto_fpath)
except:
print("crypto configfile should be json file")
sys.exit(-1)
self.__crypto_configs = crypto_configs
if not debug:
sys.stdout = open(LOG_FILE, "a+")
sys.stderr = open(ERR_FILE, "a+")
''''''
signal.signal(signal.SIGUSR1, self.__set_host_rules)
def __init__(self):
self.__dst_nat_table = {}
self.__src_nat_table = {}
self.__virtual_ips = []
self.__timer = timer.timer()
def __init__(self):
self.__tree = {}
self.__timer = timer.timer()
self.__cache = {}
def __init__(self, dispatcher):
self.__timer = timer.timer()
self.__sessions = {}
self.__dispatcher = dispatcher
self.init()
def dev_init(self, tun_devname, subnet):
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.__add_route(tun_devname, subnet)
self.__timer = timer.timer()
self.__map = {}
def __init__(self):
self.__ok_packets = []
self.__timer = timer.timer()
self.__fragdata = {}
def __init__(self):
super(fdslightlc, self).__init__()
self.set_mode("local")
self.__timer = timer.timer()
self.__routers = {}
def __init__(self):
super(udp_handler, self).__init__()
self.__timer = timer.timer()
def __init__(self, dispatcher):
self.__timer = timer.timer()
self.__sessions = {}
self.__dispatcher = dispatcher
self.init()
def __init__(self):
self.__ip_rules = []
self.__ipv6_rules = []
self.__ip_hosts = {}
self.__host_timer = timer.timer()
def __init__(self, subnet):
super(nat, self).__init__()
self.__ip_alloc = ipaddr.ip4addr(*subnet)
self.__timer = timer.timer()
def dev_init(self, tun_devname, subnet):
self.register(self.fileno)
self.add_evt_read(self.fileno)
self.__add_route(tun_devname, subnet)
self.__timer = timer.timer()
self.__map = {}
def init_func(self, mode, debug, configs):
self.create_poll()
signal.signal(signal.SIGINT, self.__exit)
self.__router_timer = timer.timer()
self.__routers = {}
self.__configs = configs
if mode == "local":
self.__mode = _MODE_LOCAL
else:
self.__mode = _MODE_GW
self.__mbuf = utils.mbuf()
self.__debug = debug
self.__tundev_fileno = self.create_handler(-1, tundev.tundevc,
self.__DEVNAME)
public = configs["public"]
gateway = configs["gateway"]
self.__enable_ipv6_traffic = bool(int(public["enable_ipv6_traffic"]))
is_ipv6 = utils.is_ipv6_address(public["remote_dns"])
if self.__mode == _MODE_GW:
self.__dns_fileno = self.create_handler(-1,
dns_proxy.dnsc_proxy,
gateway["dnsserver_bind"],
debug=debug,
server_side=True,
is_ipv6=False)
self.get_handler(self.__dns_fileno).set_parent_dnsserver(
public["remote_dns"], is_ipv6=is_ipv6)
if self.__enable_ipv6_traffic:
self.__dns_listen6 = self.create_handler(
-1,
dns_proxy.dnsc_proxy,
gateway["dnsserver_bind6"],
debug=debug,
server_side=True,
is_ipv6=True)
self.get_handler(self.__dns_listen6).set_parent_dnsserver(
public["remote_dns"], is_ipv6=is_ipv6)
else:
self.__dns_fileno = self.create_handler(-1,
dns_proxy.dnsc_proxy,
public["remote_dns"],
debug=debug,
server_side=False)
self.__set_host_rules(None, None)
if self.__mode == _MODE_GW:
self.__load_kernel_mod()
udp_global = bool(int(gateway["dgram_global_proxy"]))
if udp_global:
self.__dgram_fetch_fileno = self.create_handler(
-1,
traffic_pass.traffic_read,
self.__configs["gateway"],
enable_ipv6=self.__enable_ipv6_traffic)
''''''
else:
local = configs["local"]
vir_dns = local["virtual_dns"]
vir_dns6 = local["virtual_dns6"]
self.set_router(vir_dns, is_ipv6=False, is_dynamic=False)
if self.__enable_ipv6_traffic:
self.set_router(vir_dns6, is_ipv6=True, is_dynamic=False)
conn = configs["connection"]
m = "freenet.lib.crypto.%s" % conn["crypto_module"]
try:
self.__tcp_crypto = importlib.import_module(
"%s.%s_tcp" % (m, conn["crypto_module"]))
self.__udp_crypto = importlib.import_module(
"%s.%s_udp" % (m, conn["crypto_module"]))
except ImportError:
print("cannot found tcp or udp crypto module")
sys.exit(-1)
crypto_fpath = "%s/fdslight_etc/%s" % (BASE_DIR,
conn["crypto_configfile"])
if not os.path.isfile(crypto_fpath):
print("crypto configfile not exists")
sys.exit(-1)
try:
crypto_configs = proto_utils.load_crypto_configfile(crypto_fpath)
except:
print("crypto configfile should be json file")
sys.exit(-1)
self.__crypto_configs = crypto_configs
if not debug:
sys.stdout = open(LOG_FILE, "a+")
sys.stderr = open(ERR_FILE, "a+")
''''''
signal.signal(signal.SIGUSR1, self.__set_host_rules)
def __init__(self, subnet, is_ipv6=False):
super(nat, self).__init__()
self.__is_ipv6 = is_ipv6
self.__ip_alloc = ipaddr.ipalloc(*subnet, is_ipv6=is_ipv6)
self.__timer = timer.timer()
def __init__(self, subnet, is_ipv6=False):
super(nat, self).__init__()
self.__is_ipv6 = is_ipv6
self.__ip_alloc = ipaddr.ipalloc(*subnet, is_ipv6=is_ipv6)
self.__timer = timer.timer()
def __init__(self):
super(udp_handler, self).__init__()
self.__timer = timer.timer()
