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)
