def __init__(self, config, dns_resolver, is_local, stat_callback=None): """ 创建一个UDPRealy后的初始化参数 :param config: 配置数据 :param dns_resolver: dns解析器 :param is_local: 是否为本地服务端 :param stat_callback: 状态回调 """ self._config = config if is_local: self._listen_addr = config['local_address'] self._listen_port = config['local_port'] self._remote_addr = config['server'] self._remote_port = config['server_port'] else: self._listen_addr = config['server'] self._listen_port = config['server_port'] self._remote_addr = None self._remote_port = None self._dns_resolver = dns_resolver self._password = common.to_bytes(config['password']) self._method = config['method'] self._timeout = config['timeout'] self._is_local = is_local self._cache = lru_cache.LRUCache(timeout=config['timeout'], close_callback=self._close_client) self._client_fd_to_server_addr = \ lru_cache.LRUCache(timeout=config['timeout']) self._dns_cache = lru_cache.LRUCache(timeout=300) self._eventloop = None self._closed = False self._sockets = set() if 'forbidden_ip' in config: self._forbidden_iplist = config['forbidden_ip'] else: self._forbidden_iplist = None addrs = socket.getaddrinfo(self._listen_addr, self._listen_port, 0, socket.SOCK_DGRAM, socket.SOL_UDP) if len(addrs) == 0: raise Exception("can't get addrinfo for %s:%d" % (self._listen_addr, self._listen_port)) af, socktype, proto, canonname, sa = addrs[0] server_socket = socket.socket(af, socktype, proto) server_socket.bind((self._listen_addr, self._listen_port)) server_socket.setblocking(False) self._server_socket = server_socket self._stat_callback = stat_callback
def __init__(self, config, dns_resolver, is_local, stat_callback=None): self._config = config # 本地和远程采用同一份config文件,所以要区分 if is_local: self._listen_addr = config['local_address'] self._listen_port = config['local_port'] self._remote_addr = config['server'] self._remote_port = config['server_port'] else: self._listen_addr = config['server'] self._listen_port = config['server_port'] self._remote_addr = None self._remote_port = None self.tunnel_remote = config.get('tunnel_remote', "8.8.8.8") self.tunnel_remote_port = config.get('tunnel_remote_port', 53) self.tunnel_port = config.get('tunnel_port', 53) self._is_tunnel = False self._dns_resolver = dns_resolver self._password = common.to_bytes(config['password']) self._method = config['method'] self._timeout = config['timeout'] self._ota_enable = config.get('one_time_auth', False) self._ota_enable_session = self._ota_enable self._is_local = is_local # 这个字典是lrucache,存放callback。 self._cache = lru_cache.LRUCache(timeout=config['timeout'], close_callback=self._close_client) self._client_fd_to_server_addr = \ lru_cache.LRUCache(timeout=config['timeout']) self._dns_cache = lru_cache.LRUCache(timeout=300) self._eventloop = None self._closed = False # set集合,用于存放fielno(),见_handle_server()方法 self._sockets = set() self._forbidden_iplist = config.get('forbidden_ip') self._crypto_path = config['crypto_path'] addrs = socket.getaddrinfo(self._listen_addr, self._listen_port, 0, socket.SOCK_DGRAM, socket.SOL_UDP) if len(addrs) == 0: raise Exception("UDP can't get addrinfo for %s:%d" % (self._listen_addr, self._listen_port)) af, socktype, proto, canonname, sa = addrs[0] server_socket = socket.socket(af, socktype, proto) server_socket.bind((self._listen_addr, self._listen_port)) server_socket.setblocking(False) self._server_socket = server_socket self._stat_callback = stat_callback
def __init__(self, config, dns_resolver, is_local, stat_callback=None): self._config = config if is_local: self._listen_addr = config['local_address'] self._listen_port = config['local_port'] self._remote_addr = config['server'] self._remote_port = config['server_port'] else: self._listen_addr = config['server'] self._listen_port = config['server_port'] self._remote_addr = None self._remote_port = None self._dns_resolver = dns_resolver self._password = common.to_bytes(config['password']) self._method = config['method'] self._timeout = config['timeout'] if 'one_time_auth' in config and config['one_time_auth']: self._one_time_auth_enable = True else: self._one_time_auth_enable = False self._is_local = is_local # 地址到socket的映射 self._cache = lru_cache.LRUCache(timeout=config['timeout'], close_callback=self._close_client) # client上行upstream发送的地址 self._client_fd_to_server_addr = \ lru_cache.LRUCache(timeout=config['timeout']) # 服务器地址到socket.getaddrinfo的映射,上行upstream的dns self._dns_cache = lru_cache.LRUCache(timeout=300) self._eventloop = None self._closed = False self._sockets = set() if 'forbidden_ip' in config: self._forbidden_iplist = config['forbidden_ip'] else: self._forbidden_iplist = None addrs = socket.getaddrinfo(self._listen_addr, self._listen_port, 0, socket.SOCK_DGRAM, socket.SOL_UDP) if len(addrs) == 0: raise Exception("UDP can't get addrinfo for %s:%d" % (self._listen_addr, self._listen_port)) af, socktype, proto, canonname, sa = addrs[0] server_socket = socket.socket(af, socktype, proto) server_socket.bind((self._listen_addr, self._listen_port)) server_socket.setblocking(False) # udp监听 self._server_socket = server_socket self._stat_callback = stat_callback
def __init__(self): self._loop = None self._request_id = 1 # 以下四个均为字典类型 self._hosts = {} # 查询状态? self._hostname_status = {} # -------------------------------------------------- # hostname to callback 和 callback to hostname有什么区别>>>>参考本文件末尾的def resolve函数。 # hostname to callback就是每一个hostname对应一个回调函数 # 若多个函数对应相同的hostname,只需向远端发起一次dns请求,减少重复查询 # 删除重复键值(key=hostname,value=callback)的操作不需要人为干预,字典完成这个功能(key不允许重复) self._hostname_to_cb = {} # -------------------------------------------------- # callback to hostname就是一个回调函数对应一个hostname # 一个hostname有可能是由多个进程调用查询dns的。因此回朔时候也要逐个返回。 self._cb_to_hostname = {} # -------------------------------------------------- # todo : 阅lrucache的源码 self._cache = lru_cache.LRUCache(timeout=300) self._last_time = time.time() self._sock = None self._servers = None self._parse_resolv() self._parse_hosts()
def __init__(self, server_list=None, prefer_ipv6=False): self._loop = None self._hosts = {} self._hostname_status = {} # -------------------------------------------------- # hostname to callback 和 callback to hostname有什么区别>>>>参考本文件末尾的def resolve函数。 # hostname to callback就是每一个hostname对应一个回调函数 # 若多个函数对应相同的hostname,只需向远端发起一次dns请求,减少重复查询 # 删除重复键值(key=hostname,value=callback)的操作不需要人为干预,字典完成这个功能(key不允许重复) self._hostname_to_cb = {} # -------------------------------------------------- # callback to hostname就是一个回调函数对应一个hostname # 一个hostname有可能是由多个进程调用查询dns的。因此回朔时候也要逐个返回。 self._cb_to_hostname = {} # -------------------------------------------------- # todo : 阅lrucache的源码 self._cache = lru_cache.LRUCache(timeout=300) self._sock = None if server_list is None: self._servers = None self._parse_resolv() else: self._servers = server_list if prefer_ipv6: self._QTYPES = [QTYPE_AAAA, QTYPE_A] else: self._QTYPES = [QTYPE_A, QTYPE_AAAA] self._parse_hosts()
def update(self, user_id, client_id, connection_id): if user_id not in self.user_id: self.user_id[user_id] = lru_cache.LRUCache() local_client_id = self.user_id[user_id] if client_id in local_client_id: local_client_id[client_id].update()
def __init__(self): import threading self.event = threading.Event() self.key_list = [ 'port', 'u', 'd', 'transfer_enable', 'passwd', 'enable' ] self.last_get_transfer = {} # 上一次的实际流量 self.last_update_transfer = {} # 上一次更新到的流量(小于等于实际流量) self.force_update_transfer = set() # 强制推入数据库的ID self.users = [] self.onlineuser_cache = lru_cache.LRUCache(timeout=60 * 30) # 用户在线状态记录 self.pull_ok = False # 记录是否已经拉出过数据 self.mu_ports = {} self.user_pass = {} # 记录更新此用户流量时被跳过多少次 self.logger = logging.getLogger(__name__) if get_config().debug: self.logger.setLevel(logging.DEBUG) fh = logging.FileHandler('log.txt', mode='a', encoding=None, delay=False) formater = logging.Formatter( '%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s' ) fh.setFormatter(formater) self.logger.addHandler(fh)
def __init__(self): """ _loop: event loop object bind to. _request_id: DNS request id used to map the request and response. _hosts: dns records parsed from hosts file once initialized. _hostname_status: _hostname_to_cb: Mapping domain names to callback functions _cb_to_hostname: Mapping callback functions to domain names, conversely _cache: DNS record cache dict, such as {"localhost": "127.0.0.1"} _last_time: _sock: _servers: DNS server address parsed from /etc/resolv.conf or default value if it's empty _parse_resolv: _parse_hosts: """ self._loop = None self._request_id = 1 self._hosts = {} self._hostname_status = {} self._hostname_to_cb = {} self._cb_to_hostname = {} self._cache = lru_cache.LRUCache(timeout=300) self._last_time = time.time() self._sock = None self._servers = None self._parse_resolv() self._parse_hosts()
def insert(self, user_id, client_id, connection_id): if user_id not in self.user_id: self.user_id[user_id] = lru_cache.LRUCache() local_client_id = self.user_id[user_id] if local_client_id.get( client_id, None) is None or not local_client_id[client_id].enable: if local_client_id.first() is None or len( local_client_id) < self.max_client: if client_id not in local_client_id: # TODO: check local_client_id[client_id] = client_queue(connection_id) else: local_client_id[client_id].re_enable(connection_id) return local_client_id[client_id].insert(connection_id) if not local_client_id[local_client_id.first()].is_active(): del local_client_id[local_client_id.first()] if client_id not in local_client_id: # TODO: check local_client_id[client_id] = client_queue(connection_id) else: local_client_id[client_id].re_enable(connection_id) return local_client_id[client_id].insert(connection_id) logging.warn(self.name + ': no inactive client') return False else: return local_client_id[client_id].insert(connection_id)
class UDPAsyncDNSHandler(object): dns_cache = lru_cache.LRUCache(timeout=1800) def __init__(self, params): self.params = params self.remote_addr = None self.call_back = None def resolve(self, dns_resolver, remote_addr, call_back): if remote_addr in UDPAsyncDNSHandler.dns_cache: if call_back: call_back("", remote_addr, UDPAsyncDNSHandler.dns_cache[remote_addr], self.params) else: self.call_back = call_back self.remote_addr = remote_addr dns_resolver.resolve(remote_addr[0], self._handle_dns_resolved) UDPAsyncDNSHandler.dns_cache.sweep() def _handle_dns_resolved(self, result, error): if error: logging.error("%s when resolve DNS" % (error, )) #drop return self.call_back(error, self.remote_addr, None, self.params) if result: ip = result[1] if ip: return self.call_back("", self.remote_addr, ip, self.params) logging.warning("can't resolve %s" % (self.remote_addr, )) return self.call_back("fail to resolve", self.remote_addr, None, self.params)
def __init__(self, config, dns_resolver, is_local, stat_callback=None): logging.info("%d %s instantiated" % (sys._getframe().f_lineno, self.__class__.__name__)) self._config = config if is_local: self._listen_addr = config['local_address'] self._listen_port = config['local_port'] self._remote_addr = config['server'] self._remote_port = config['server_port'] else: self._listen_addr = config['server'] self._listen_port = config['server_port'] self._remote_addr = None self._remote_port = None self.tunnel_remote = config.get('tunnel_remote', "8.8.8.8") self.tunnel_remote_port = config.get('tunnel_remote_port', 53) self.tunnel_port = config.get('tunnel_port', 53) self._is_tunnel = False self._dns_resolver = dns_resolver self._password = common.to_bytes(config['password']) self._method = config['method'] self._timeout = config['timeout'] self._ota_enable = config.get('one_time_auth', False) self._ota_enable_session = self._ota_enable self._is_local = is_local self._cache = lru_cache.LRUCache(timeout=config['timeout'], close_callback=self._close_client) self._client_fd_to_server_addr = \ lru_cache.LRUCache(timeout=config['timeout']) self._dns_cache = lru_cache.LRUCache(timeout=300) self._eventloop = None self._closed = False self._sockets = set() self._forbidden_iplist = config.get('forbidden_ip') self._crypto_path = config['crypto_path'] addrs = socket.getaddrinfo(self._listen_addr, self._listen_port, 0, socket.SOCK_DGRAM, socket.SOL_UDP) if len(addrs) == 0: raise Exception("UDP can't get addrinfo for %s:%d" % (self._listen_addr, self._listen_port)) af, socktype, proto, canonname, sa = addrs[0] server_socket = socket.socket(af, socktype, proto) logging.info("%s %d %s is called. server_socket:%d" % (os.path.basename(__file__), sys._getframe().f_lineno, sys._getframe().f_code.co_name, server_socket.fileno())) server_socket.bind((self._listen_addr, self._listen_port)) server_socket.setblocking(False) self._server_socket = server_socket self._stat_callback = stat_callback
def __init__(self, config): DNSRelay.__init__(self, config) self._id_to_addr = lru_cache.LRUCache(CACHE_TIMEOUT) self._local_sock = None self._remote_sock = None self._create_sockets() self._pending_responses = []
def __init__(self, config, dns_resolver, is_local, stat_callback=None): self._config = config if is_local: self._listen_addr = config['local_address'] self._listen_port = config['local_port'] self._remote_addr = config['server'] self._remote_port = config['server_port'] else: self._listen_addr = config['server'] self._listen_port = config['server_port'] self._remote_addr = None self._remote_port = None self._dns_resolver = dns_resolver self._password = common.to_bytes(config['password']) self._method = config['method'] self._timeout = config['timeout'] self._is_local = is_local # 记录当前存活的client self._cache = lru_cache.LRUCache(timeout=config['timeout'], close_callback=self._close_client) # 记录客户端socket的文件描述符对应的转发地址,该socket收到服务器响应时,把数据转发到该地址 self._client_fd_to_server_addr = \ lru_cache.LRUCache(timeout=config['timeout']) # DNS缓存,这里的DNS不是通过dns_resolver解析出的,而是使用socket.getaddrinfo得到的 self._dns_cache = lru_cache.LRUCache(timeout=300) self._eventloop = None self._closed = False self._sockets = set() if 'forbidden_ip' in config: self._forbidden_iplist = config['forbidden_ip'] else: self._forbidden_iplist = None # 返回的是一个列表,里面每一个成员是一个五元组 # [(family, type, proto, canonname, sockaddr)] addrs = socket.getaddrinfo(self._listen_addr, self._listen_port, 0, socket.SOCK_DGRAM, socket.SOL_UDP) if len(addrs) == 0: raise Exception("can't get addrinfo for %s:%d" % (self._listen_addr, self._listen_port)) af, socktype, proto, canonname, sa = addrs[0] server_socket = socket.socket(af, socktype, proto) server_socket.bind((self._listen_addr, self._listen_port)) server_socket.setblocking(False) self._server_socket = server_socket self._stat_callback = stat_callback
def __init__(self, config, dns_resolver, is_local, stat_callback=None): self._config = config # analyse config if is_local: self._listen_addr = config['local_address'] self._listen_port = config['local_port'] self._remote_addr = config['server'] self._remote_port = config['server_port'] else: self._listen_addr = config['server'] self._listen_port = config['server_port'] self._remote_addr = None self._remote_port = None self._dns_resolver = dns_resolver self._password = common.to_bytes(config['password']) self._method = config['method'] self._timeout = config['timeout'] self._is_local = is_local self._cache = lru_cache.LRUCache(timeout=config['timeout'], close_callback=self._close_client) self._client_fd_to_server_addr = \ lru_cache.LRUCache(timeout=config['timeout']) self._dns_cache = lru_cache.LRUCache(timeout=300) self._eventloop = None self._closed = False self._sockets = set() if 'forbidden_ip' in config: self._forbidden_iplist = config['forbidden_ip'] else: self._forbidden_iplist = None # init self._server_socket, namely the relay server socket # the server is either local or remote, due to self._listen_addr # then bind the socket to _listen_port addrs = socket.getaddrinfo(self._listen_addr, self._listen_port, 0, socket.SOCK_DGRAM, socket.SOL_UDP) if len(addrs) == 0: raise Exception("can't get addrinfo for %s:%d" % (self._listen_addr, self._listen_port)) af, socktype, proto, canonname, sa = addrs[0] server_socket = socket.socket(af, socktype, proto) server_socket.bind((self._listen_addr, self._listen_port)) server_socket.setblocking(False) self._server_socket = server_socket self._stat_callback = stat_callback
def __init__(self, config, dns_resolver, is_local, stat_callback=None): self._config = config if is_local: self._listen_addr = config['local_address'] self._listen_port = config['local_port'] self._remote_addr = config['server'] self._remote_port = config['server_port'] else: self._listen_addr = config['server'] self._listen_port = config['server_port'] self._remote_addr = None self._remote_port = None self._dns_resolver = dns_resolver # note(yan): unused. self._password = common.to_bytes(config['password']) self._method = config['method'] self._timeout = config['timeout'] self._is_local = is_local # note(yan): 根据client地址<addr, port, server_af>映射到proxy client. self._cache = lru_cache.LRUCache(timeout=config['timeout'], close_callback=self._close_client) # 根据proxy client fd映射回client的<addr, port> self._client_fd_to_server_addr = \ lru_cache.LRUCache(timeout=config['timeout']) self._dns_cache = lru_cache.LRUCache(timeout=300) self._eventloop = None self._closed = False self._sockets = set() if 'forbidden_ip' in config: self._forbidden_iplist = config['forbidden_ip'] else: self._forbidden_iplist = None addrs = socket.getaddrinfo(self._listen_addr, self._listen_port, 0, socket.SOCK_DGRAM, socket.SOL_UDP) if len(addrs) == 0: raise Exception("can't get addrinfo for %s:%d" % (self._listen_addr, self._listen_port)) af, socktype, proto, canonname, sa = addrs[0] server_socket = socket.socket(af, socktype, proto) server_socket.bind((self._listen_addr, self._listen_port)) server_socket.setblocking(False) self._server_socket = server_socket self._stat_callback = stat_callback
def __init__(self): import threading self.event = threading.Event() self.key_list = ['port', 'u', 'd', 'transfer_enable', 'passwd', 'enable'] self.last_get_transfer = {} #上一次的实际流量 self.last_update_transfer = {} #上一次更新到的流量(小于等于实际流量) self.force_update_transfer = set() #强制推入数据库的ID self.port_uid_table = {} #端口到uid的映射(仅v3以上有用) self.onlineuser_cache = lru_cache.LRUCache(timeout=60*30) #用户在线状态记录 self.pull_ok = False #记录是否已经拉出过数据
def __init__(self, config, dns_resolver, is_local, stat_callback=None): self._config = config if is_local: self._listen_addr = config['local_address'] self._listen_port = config['local_port'] self._remote_addr = config['server'] self._remote_port = config['server_port'] else: self._listen_addr = config['server'] self._listen_port = config['server_port'] self._remote_addr = None self._remote_port = None self._dns_resolver = dns_resolver self._password = common.to_bytes(config['password']) self._method = config['method'] self._timeout = config['timeout'] self._ota_enable = config.get('one_time_auth', False) self._ota_enable_session = self._ota_enable self._is_local = is_local self._cache = lru_cache.LRUCache(timeout=config['timeout'], close_callback=self._close_client) self._client_fd_to_server_addr = \ lru_cache.LRUCache(timeout=config['timeout']) self._dns_cache = lru_cache.LRUCache(timeout=300) self._eventloop = None self._closed = False self._sockets = set() self._forbidden_iplist = config.get('forbidden_ip') #socket.SOCK_DGRAM sock_dgram 是无保障的面向消息的socket , 主要用于在网络上发广播信息。基于UDP的数据报式socket通信 #socket.SOCK_STREAM 是有保障的(即能保证数据正确传送到对方)面向连接的SOCKET,基于TCP的流式socket通信 addrs = socket.getaddrinfo(self._listen_addr, self._listen_port, 0, socket.SOCK_DGRAM, socket.SOL_UDP) if len(addrs) == 0: raise Exception("UDP can't get addrinfo for %s:%d" % (self._listen_addr, self._listen_port)) af, socktype, proto, canonname, sa = addrs[0] server_socket = socket.socket(af, socktype, proto) server_socket.bind((self._listen_addr, self._listen_port)) server_socket.setblocking(False) self._server_socket = server_socket self._stat_callback = stat_callback
def __init__(self): self._loop = None self._hosts = {} self._hostname_status = {} self._hostname_to_cb = {} self._cb_to_hostname = {} self._cache = lru_cache.LRUCache(timeout=300) self._sock = None self._servers = None self._parse_resolv() self._parse_hosts()
def __init__(self, config, dns_resolver, is_local): self._config = config # 本地和远程采用同一份config文件,所以要区分 if is_local: self._listen_addr = config['local_address'] self._listen_port = config['local_port'] self._remote_addr = config['server'] self._remote_port = config['server_port'] else: self._listen_addr = config['server'] self._listen_port = config['server_port'] self._remote_addr = None self._remote_port = None self._dns_resolver = dns_resolver self._password = config['password'] self._method = config['method'] self._timeout = config['timeout'] self._is_local = is_local # 这个字典是lrucache,存放callback。 self._cache = lru_cache.LRUCache(timeout=config['timeout'], close_callback=self._close_client) self._client_fd_to_server_addr = \ lru_cache.LRUCache(timeout = config['timeout']) self._eventloop = None self._closed = False self._last_time = time.time() # set集合,用于存放fielno(),见_handle_server()方法 self._sockets = set() addrs = socket.getaddrinfo(self._listen_addr, self._listen_port, 0, socket.SOCK_DGRAM, socket.SOL_UDP) if len(addrs) == 0: raise Exception("can't get addrinfo for %s:%d" % (self._listen_addr, self._listen_port)) af, socktype, proto, canonname, sa = addrs[0] server_socket = socket.socket(af, socktype, proto) # server_socket是自己的socket server_socket.bind((self._listen_addr, self._listen_port)) server_socket.setblocking(False) self._server_socket = server_socket
def __init__(self): import threading self.event = threading.Event() self.key_list = [ 'port', 'u', 'd', 'transfer_enable', 'passwd', 'enable' ] self.last_get_transfer = {} self.last_update_transfer = {} self.user_pass = {} self.port_uid_table = {} self.onlineuser_cache = lru_cache.LRUCache(timeout=60 * 30) self.pull_ok = False
def __init__(self, config, dns_resolver, is_local): self._config = config if is_local: self._listen_addr = config['local_address'] self._listen_port = config['local_port'] self._remote_addr = config['server'] self._remote_port = config['server_port'] else: self._listen_addr = config['server'] self._listen_port = config['server_port'] self._remote_addr = None self._remote_port = None self._dns_resolver = dns_resolver self._password = config['password'] self._method = config['method'] self._timeout = config['timeout'] self._is_local = is_local self._cache = lru_cache.LRUCache(timeout=config['timeout'], close_callback=self._close_client) self._client_fd_to_server_addr = \ lru_cache.LRUCache(timeout=config['timeout']) self._eventloop = None self._closed = False self._last_time = time.time() self._sockets = set() if 'forbidden_ip' in config: self._forbidden_iplist = config['forbidden_ip'] else: self._forbidden_iplist = None addrs = socket.getaddrinfo(self._listen_addr, self._listen_port, 0, socket.SOCK_DGRAM, socket.SOL_UDP) if len(addrs) == 0: raise Exception("can't get addrinfo for %s:%d" % (self._listen_addr, self._listen_port)) af, socktype, proto, canonname, sa = addrs[0] server_socket = socket.socket(af, socktype, proto) server_socket.bind((self._listen_addr, self._listen_port)) server_socket.setblocking(False) self._server_socket = server_socket
def __init__(self): import threading self.event = threading.Event() self.start_time = time.time() self.cfg = {} self.last_get_transfer = {} # 上一次的实际流量 self.last_update_transfer = {} # 上一次更新到的流量(小于等于实际流量) self.force_update_transfer = set() # 强制推入数据库的ID self.port_uid_table = {} # 端口到uid的映射(仅v3以上有用) self.onlineuser_cache = lru_cache.LRUCache(timeout=60 * 30) # 用户在线状态记录 self.pull_ok = False # 记录是否已经拉出过数据 self.mu_ports = {}
def __init__(self, server_list=None): self._loop = None self._hosts = {} self._hostname_status = {} self._hostname_to_cb = {} self._cb_to_hostname = {} self._cache = lru_cache.LRUCache(timeout=300) self._sock = None if server_list is None: self._servers = None self._parse_resolv() else: self._servers = server_list self._parse_hosts()
def __init__(self, config, dns_resolver, is_local, stat_callback=None, stat_counter=None): self._config = config self._is_local = is_local self._dns_resolver = dns_resolver self._closed = False self._eventloop = None self._fd_to_handlers = {} self.server_transfer_ul = 0 self.server_transfer_dl = 0 self.server_connections = 0 self.protocol_data = obfs.obfs(config['protocol']).init_data() self.obfs_data = obfs.obfs(config['obfs']).init_data() if config.get('connect_verbose_info', 0) > 0: common.connect_log = logging.info self._timeout = config['timeout'] self._timeout_cache = lru_cache.LRUCache(timeout=self._timeout, close_callback=self._close_tcp_client) if is_local: listen_addr = config['local_address'] listen_port = config['local_port'] else: listen_addr = config['server'] listen_port = config['server_port'] self._listen_port = listen_port addrs = socket.getaddrinfo(listen_addr, listen_port, 0, socket.SOCK_STREAM, socket.SOL_TCP) if len(addrs) == 0: raise Exception("can't get addrinfo for %s:%d" % (listen_addr, listen_port)) af, socktype, proto, canonname, sa = addrs[0] server_socket = socket.socket(af, socktype, proto) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) server_socket.bind(sa) server_socket.setblocking(False) if config['fast_open']: try: server_socket.setsockopt(socket.SOL_TCP, 23, 5) except socket.error: logging.error('warning: fast open is not available') self._config['fast_open'] = False server_socket.listen(config.get('max_connect', 1024)) self._server_socket = server_socket self._stat_counter = stat_counter self._stat_callback = stat_callback
def __init__(self): self._loop = None self._hosts = {} # 正在发起的host 的dns请求的地址解析类型,即正在对这个域名进行ipv4解析还是ipv6的解析。DNSResolver默认先进行ipv4的解析,当 # ipv4解析失败后再发起一次ipv6的解析。两次都解析失败才算是真正的失败 self._hostname_status = {} # dns解析服务和回调的对应关系,可能出现一个host解析请求对应多个回调的情况,当host请求解析有结果了,回调所有对应的回调。 self._hostname_to_cb = {} self._cb_to_hostname = {} self._cache = lru_cache.LRUCache(timeout=300) # dns解析结果缓存 self._sock = None self._servers = None # _parse_resolv是解析/etc/resolv.conf文件,得到dns服务器的ip地址,如果没有配置,则默认使用google的dns服务器 self._parse_resolv() self._parse_hosts() # _parse_hosts则是解析本地的hosts文件配置,将配置的ip和域名映射起来
def __init__(self, server_list=None): self._loop = None self._hosts = {} self._hostname_status = {} self._hostname_to_cb = {} self._cb_to_hostname = {} # 300 秒生命周期, 结果存放 hostname: ip self._cache = lru_cache.LRUCache(timeout=300) self._sock = None # 读取本地的 resolv.conf 文件, 获取域名服务器ip if server_list is None: self._servers = None self._parse_resolv() else: self._servers = server_list # 本地host文件 self._parse_hosts()
def __init__(self, server_list=None, prefer_ipv6=False): self._loop = None self._hosts = {} self._hostname_status = {} self._hostname_to_cb = {} self._cb_to_hostname = {} self._cache = lru_cache.LRUCache(timeout=300) self._sock = None if server_list is None: self._servers = None self._parse_resolv() else: self._servers = server_list if prefer_ipv6: self._QTYPES = [QTYPE_AAAA, QTYPE_A] else: self._QTYPES = [QTYPE_A, QTYPE_AAAA] self._parse_hosts()
def __init__(self, black_hostname_list=None): self._loop = None self._hosts = {} self._hostname_status = {} self._hostname_to_cb = {} self._cb_to_hostname = {} self._cache = lru_cache.LRUCache(timeout=300) # read black_hostname_list from config if type(black_hostname_list) != list: self._black_hostname_list = [] else: self._black_hostname_list = list( map((lambda t: t if type(t) == bytes else t.encode('utf8')), black_hostname_list)) # logging.info('Black hostname: ' + str(self._black_hostname_list)) self._sock = None self._servers = None self._parse_resolv() self._parse_hosts()
def __init__(self): # 时间循环 self._loop = None # host文件中的IP地址 self._hosts = {} # 记录请求的hostname的状态 self._hostname_status = {} # 记录{hostname:callback}对 self._hostname_to_cb = {} # 记录{callback:hostname}对 self._cb_to_hostname = {} # LRU缓存 self._cache = lru_cache.LRUCache(timeout=300) # 套接字 self._sock = None # DNS服务器地址 self._servers = None self._parse_resolv() self._parse_hosts()
def __init__(self, config): DNSRelay.__init__(self, config) self._id_to_addr = lru_cache.LRUCache(CACHE_TIMEOUT) self._local_sock = None self._remote_sock = None sockets = [] for addr in (self._local_addr, self._remote_addr): addrs = socket.getaddrinfo(addr[0], addr[1], 0, socket.SOCK_DGRAM, socket.SOL_UDP) if len(addrs) == 0: raise Exception("can't get addrinfo for %s:%d" % addr) af, socktype, proto, canonname, sa = addrs[0] sock = socket.socket(af, socktype, proto) sock.setblocking(False) sockets.append(sock) self._local_sock, self._remote_sock = sockets self._local_sock.bind(self._local_addr)