def __init__(self, config, dns_resolver, is_local): 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() 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, listen_addr='127.0.0.1', listen_port=1080, remote_addr='127.0.0.1', remote_port=8387, password=None, method='table', timeout=300, is_local=True): self._listen_addr = listen_addr self._listen_port = listen_port self._remote_addr = remote_addr self._remote_port = remote_port self._password = password self._method = method self._timeout = timeout self._is_local = is_local self._cache = lru_cache.LRUCache(timeout=timeout, close_callback=self._close_client) self._client_fd_to_server_addr = lru_cache.LRUCache(timeout=timeout) self._closed = False 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, 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 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()
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 test_LRU2(self): lc = lru_cache.LRUCache(2) lc.set(1,1) self.assertEqual(1, lc.get(1)) lc.set(1,2) self.assertEqual(2, lc.get(1)) lc.set(1,3) self.assertEqual(3, lc.get(1)) lc.set(2,4) self.assertEqual(4, lc.get(2)) lc.set(3,5) self.assertEqual(5, lc.get(3)) self.assertEqual(-1, lc.get(1)) self.assertEqual(4, lc.get(2)) lc.set(4,6) self.assertEqual(6, lc.get(4)) self.assertEqual(-1, lc.get(2)) self.assertEqual(-1, lc.get(1)) self.assertEqual(-1, lc.get(2)) self.assertEqual(5, lc.get(3)) self.assertEqual(6, lc.get(4)) lc.set(4,7) self.assertEqual(7, lc.get(4))
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)
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.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) server_socket.bind((self._listen_addr, self._listen_port)) server_socket.setblocking(False) self._server_socket = server_socket self._stat_callback = stat_callback
def test_LRU2(self): lc2 = lru_cache.LRUCache(7) self.assertEqual(-1, lc2.get(2)) lc2.set(2,6) self.assertEqual(-1, lc2.get(1)) lc2.set(1,5) lc2.set(1,2) self.assertEqual(2, lc2.get(1)) self.assertEqual(6, lc2.get(2))
def testCacheClearOnTimeout(self): masterCache = lambda: list( map(lambda v: (v[0].__name__, v[1]), lru_cache.LRUCache()._masterCacheDict.items())) # Confirm that cache is empty in the begining self.assertListEqual(masterCache(), [('dieIn3Seconds', {}), ('dieIn10Seconds', {})]) # Register first item in cache LRUCacheTest.dieIn3Seconds(1, 2) dieIn3Entry1 = dict(masterCache())['dieIn3Seconds'] # Confirm that we set cache self.assertNotEqual(dieIn3Entry1, {}) # Let it timeout time.sleep(4) lru_cache.LRUCache()._clear() self.assertListEqual(masterCache(), [('dieIn3Seconds', { ((1, 2), ()): {} }), ('dieIn10Seconds', {})])
def __init__(self, listen_addr='127.0.0.1', listen_port=1080, remote_addr='127.0.0.1', remote_port=8387, password=None, method='table', timeout=300, is_local=True): self._listen_addr = listen_addr self._listen_port = listen_port self._remote_addr = remote_addr self._remote_port = remote_port self._password = password self._method = method self._timeout = timeout self._is_local = is_local self._eventloop = eventloop.EventLoop() self._cache = lru_cache.LRUCache(timeout=timeout, close_callback=self._close_client) self._client_fd_to_server_addr = lru_cache.LRUCache(timeout=timeout)
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 = [] self._parse_resolv() self._parse_hosts()
def __init__(self): 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._parse_resolv() self._parse_hosts()
def __init__(self, dns_list: List): self._event_loop = None # local host self._hosts = {"localhost": "127.0.0.1"} self._hostname_status = {} self._hostname_to_cb = {} self._cb_to_hostname = {} self._cache = lru_cache.LRUCache(timeout=300) self._sock = None # dns servers self._servers = [] self.__parse_resolv(dns_list)
def test_LRU1(self): lc = lru_cache.LRUCache(9) lc.set(1,1) self.assertEqual(1, lc.get(1)) lc.set(1,2) self.assertEqual(2, lc.get(1)) lc.set(1,3) self.assertEqual(3, lc.get(1)) lc.set(2,4) self.assertEqual(4, lc.get(2)) lc.set(3,5) self.assertEqual(5, lc.get(3))
def __init__(self): 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() self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.SOL_UDP) self.sock.setblocking(False) eventloop.SockManage.add(self, eventloop.POLL_IN)
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._QTYPES = [QTYPE_A, QTYPE_AAAA] self._parse_hosts()
def __init__(self, server_list=None, prefer_ipv6=False): self._loop = None # hostname 到ip的映射 self._hosts = {} self._hostname_status = {} # hostname 对应callback列表 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 setUp(self): self.lru_cache = lru_cache.LRUCache(5)
import lru_cache as lru C = lru.LRUCache(5) C.process_item(1) C.process_item(2) C.process_item(3) C.process_item(4) C.process_item(5) C.print_all() print("-----") C.process_item(6) C.process_item(7) C.print_all() print("-----") C.process_item(8) C.process_item(9) C.print_all() print("-----")
def __init__(self): self.client_id = lru_cache.LRUCache() self.local_client_id = b'' self.connection_id = 0 self.set_max_client(64) # max active client count
def __init__(self, config, dns_resolver, is_local, stat_callback=None, stat_counter=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 self._udp_cache_size = config['udp_cache'] self._cache = lru_cache.LRUCache( timeout=config['udp_timeout'], close_callback=self._close_client_pair) self._cache_dns_client = lru_cache.LRUCache( timeout=10, close_callback=self._close_client_pair) self._client_fd_to_server_addr = {} #self._dns_cache = lru_cache.LRUCache(timeout=1800) self._eventloop = None self._closed = False self.server_transfer_ul = 0 self.server_transfer_dl = 0 self.server_users = {} self.server_user_transfer_ul = {} self.server_user_transfer_dl = {} if common.to_bytes(config['protocol']) in obfs.mu_protocol(): self._update_users(None, None) self.protocol_data = obfs.obfs(config['protocol']).init_data() self._protocol = obfs.obfs(config['protocol']) server_info = obfs.server_info(self.protocol_data) server_info.host = self._listen_addr server_info.port = self._listen_port server_info.users = self.server_users server_info.protocol_param = config['protocol_param'] server_info.obfs_param = '' server_info.iv = b'' server_info.recv_iv = b'' server_info.key_str = common.to_bytes(config['password']) server_info.key = encrypt.encrypt_key(self._password, self._method) server_info.head_len = 30 server_info.tcp_mss = 1452 server_info.buffer_size = BUF_SIZE server_info.overhead = 0 self._protocol.set_server_info(server_info) self._sockets = set() self._fd_to_handlers = {} self._reqid_to_hd = {} self._data_to_write_to_server_socket = [] self._timeout_cache = lru_cache.LRUCache( timeout=self._timeout, close_callback=self._close_tcp_client) self._bind = config.get('out_bind', '') self._bindv6 = config.get('out_bindv6', '') self._ignore_bind_list = config.get('ignore_bind', []) if 'forbidden_ip' in config: self._forbidden_iplist = config['forbidden_ip'] else: self._forbidden_iplist = None if 'forbidden_port' in config: self._forbidden_portset = config['forbidden_port'] else: self._forbidden_portset = 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