def deployProxy(configs, index):
config = configs[index]
try:
logging.info("starting local at %s:%d" %
(config['local_address'], config['local_port']))
dns_resolver = asyncdns.DNSResolver()
tcp_server = tcprelay.TCPRelay(config, dns_resolver, True)
udp_server = udprelay.UDPRelay(config, dns_resolver, True)
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
tcp_server.add_to_loop(loop)
udp_server.add_to_loop(loop)
def handler(signum, _):
logging.warn('received SIGQUIT, doing graceful shutting down..')
tcp_server.close(next_tick=True)
udp_server.close(next_tick=True)
signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM), handler)
def int_handler(signum, _):
sys.exit(1)
signal.signal(signal.SIGINT, int_handler)
daemon.set_user(config.get('user', None))
loop.run()
except Exception as e:
raise
def handler():
config = {
"password": password,
"method": crypt_name,
"server_port": port,
"timeout": 60,
"server": "::",
"fast_open": False
}
try:
loop = eventloop.EventLoop()
dns_resolver = asyncdns.DNSResolver()
tcp_server = tcprelay.TCPRelay(config,
dns_resolver,
False,
stat_callback=call_back)
udp_server = udprelay.UDPRelay(config, dns_resolver, False)
dns_resolver.add_to_loop(loop)
tcp_server.add_to_loop(loop)
udp_server.add_to_loop(loop)
loop.run()
except IOError as e:
if e.errno == 98:
sys.exit(1)
except Exception as e:
shell.print_exception(e)
sys.exit(1)
def __init__(self):
shell.check_python()
self.config = shell.get_config(False)
self.dns_resolver = asyncdns.DNSResolver()
if not self.config.get('dns_ipv6', False):
asyncdns.IPV6_CONNECTION_SUPPORT = False
self.mgr = None # asyncmgr.ServerMgr()
self.tcp_servers_pool = {}
self.tcp_ipv6_servers_pool = {}
self.udp_servers_pool = {}
self.udp_ipv6_servers_pool = {}
self.stat_counter = {}
self.loop = eventloop.EventLoop()
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)
self.thread = MainThread((self.loop, self.dns_resolver, self.mgr))
self.thread.start()
def __init__(self):
self._config = {}
self._relays = {}
self._loop = eventloop.EventLoop()
self._dns_resolver = asyncdns.DNSResolver()
self._dns_resolver.add_to_loop(self._loop)
self._statistics = collections.defaultdict(int)
def run_server():
# 收到退出信号的处理函数，关闭所有socket释放资源。
def child_handler(signum, _):
logging.warn('received SIGQUIT, doing graceful shutting down..')
# 关闭所有的socket，一句话搞定，好厉害，跪拜ing
# map(function, sequence[, sequence, ...]) -> list
# Return a list of the results of applying the function to the items of the argument sequence(s).
list(
map(lambda s: s.close(next_tick=True),
tcp_servers + udp_servers))
# 收到退出信号，调用child_handler进行自杀。
signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM),
child_handler)
# 收到退出信号，调用int_handler进行自杀。
def int_handler(signum, _):
sys.exit(1)
signal.signal(signal.SIGINT, int_handler)
try:
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
# 把所有的监听端口添加到时间循环中，一句话搞定，好厉害，跪拜ing
list(map(lambda s: s.add_to_loop(loop), tcp_servers + udp_servers))
loop.run()
except (KeyboardInterrupt, IOError, OSError) as e:
logging.error(e)
if config['verbose']:
import traceback
traceback.print_exc()
os._exit(1)
def run_server():
def child_handler(signum, _):
logging.warn('received SIGQUIT, doing graceful shutting down..')
list(
map(lambda s: s.close(next_tick=True),
tcp_servers + udp_servers))
signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM),
child_handler)
def int_handler(signum, _):
sys.exit(1)
signal.signal(signal.SIGINT, int_handler)
try:
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
# 这条语句有点屌
list(map(lambda s: s.add_to_loop(loop), tcp_servers + udp_servers))
loop.run()
except (KeyboardInterrupt, IOError, OSError) as e:
logging.error(e)
if config['verbose']:
import traceback
traceback.print_exc()
os._exit(1)
def run_server():
def child_handler(signum, _):
logging.warn('received SIGQUIT, doing graceful shutting down..')
# map(function, sequence[, sequence, ...]) -> list 将function函数作用到
# sequence中的每一个元素，也就是关掉上面打开的所有的socket
list(
map(lambda s: s.close(next_tick=True),
tcp_servers + udp_servers))
# 注册SIGQUIT或SIGTERM的信号处理函数，Windows不支持SIGQUIT而Linux支持，所以为了
# 跨平台兼容，此处使用了getattr函数
# 在调用exec前，子进程会继承父进程注册的信号处理action，这里在子进程中重新注册
# 了SIGTERM信号的处理action，不出意外，signal函数会返回上一次注册的action
signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM),
child_handler)
# 为SIGINT注册信号处理函数
def int_handler(signum, _):
sys.exit(1)
signal.signal(signal.SIGINT, int_handler)
try:
loop = eventloop.EventLoop()
# 将dns以及之前tcp, udp的socket都注册到epoll事件表中
dns_resolver.add_to_loop(loop)
list(map(lambda s: s.add_to_loop(loop), tcp_servers + udp_servers))
daemon.set_user(config.get('user', None))
loop.run()
except Exception as e:
shell.print_exception(e)
sys.exit(1)
def main():
shell.check_python()
# fix py2exe
if hasattr(sys, "frozen") and sys.frozen in \
("windows_exe", "console_exe"):
p = os.path.dirname(os.path.abspath(sys.executable))
os.chdir(p)
config = shell.get_config(True)
daemon.daemon_exec(config)
logging.info("starting local at %s:%d" %
(config['local_address'], config['local_port']))
dns_resolver = asyncdns.DNSResolver()
tcp_server = tcprelay.TCPRelay(config, dns_resolver, True)
udp_server = udprelay.UDPRelay(config, dns_resolver, True)
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
tcp_server.add_to_loop(loop)
udp_server.add_to_loop(loop)
def handler(signum, _):
logging.warn('received SIGQUIT, doing graceful shutting down..')
tcp_server.close(next_tick=True)
udp_server.close(next_tick=True)
signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM), handler)
def int_handler(signum, _):
sys.exit(1)
signal.signal(signal.SIGINT, int_handler)
daemon.set_user(config.get('user', None))
loop.run()
def run_server():
def child_handler(signum, _):
logging.warn('received SIGQUIT, doing graceful shutting down..')
# 关闭所有的socket，lambda表达式一句话搞定
# map(function, sequence[, sequence, ...]) -> list
# Return a list of the results of applying the function to the items of the argument sequence(s).
list(
map(lambda s: s.close(next_tick=True),
tcp_servers + udp_servers))
signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM),
child_handler)
def int_handler(signum, _):
sys.exit(1)
signal.signal(signal.SIGINT, int_handler)
try:
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
# 把所有的监听端口添加到事件循环loop中，lambda表达式一句话搞定
list(map(lambda s: s.add_to_loop(loop), tcp_servers + udp_servers))
daemon.set_user(config.get('user', None))
loop.run()
except Exception as e:
shell.print_exception(e)
sys.exit(1)
def run_server():
def child_handler(signum, _):
logging.warn('received SIGQUIT, doing graceful shutting down..')
list(
map(lambda s: s.close(next_tick=True),
tcp_servers + udp_servers))
signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM),
child_handler)
def int_handler(signum, _):
sys.exit(1)
signal.signal(signal.SIGINT, int_handler)
try:
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
list(map(lambda s: s.add_to_loop(loop), tcp_servers + udp_servers))
daemon.set_user(config.get('user', None))
loop.run()
except Exception as e:
shell.print_exception(e)
sys.exit(1)
def run_server():
def child_handler(signum, _):
logging.warn('received SIGQUIT, doing graceful shutting down..')
list(
map(lambda s: s.close(next_tick=True),
tcp_servers + udp_servers))
signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM),
child_handler)
def int_handler(signum, _):
sys.exit(1)
signal.signal(signal.SIGINT, int_handler)
try:
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
# 观察者模式
# epoll/kqueue/select观察着socket的状态，当socket状态发生变化时
# 调用消息处理函数
# 将已经打开的socket注册到EventLoop侦听相应的事件
#print(list(map(lambda x: x * 2 + 10, foo)))
# [14, 46, 28, 54, 44, 58, 26, 34, 64]
# print ([x * 2 + 10 for x in foo])
# foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
list(map(lambda s: s.add_to_loop(loop), tcp_servers + udp_servers))
daemon.set_user(config.get('user', None))
# 启动事件循环，等待shadowsocks客户端的连接
loop.run()
except Exception as e:
shell.print_exception(e)
sys.exit(1)
def __init__(self):
shell.check_python()
self.config = shell.get_config(False)
self.dns_resolver = asyncdns.DNSResolver()
if not self.config.get('dns_ipv6', False):
asyncdns.IPV6_CONNECTION_SUPPORT = False
self.mgr = None # asyncmgr.ServerMgr()
self.eventloop_pool = {}
self.thread_pool = {}
self.dns_resolver_pool = {}
self.dns_resolver = asyncdns.DNSResolver()
self.loop = eventloop.EventLoop()
self.thread = MainThread((self.loop, self.dns_resolver, self.mgr))
self.thread.start()
self.tcp_servers_pool = {}
self.tcp_ipv6_servers_pool = {}
self.udp_servers_pool = {}
self.udp_ipv6_servers_pool = {}
self.stat_counter = {}
self.uid_port_table = {}
def main():
dns_resolver = asyncdns.DNSResolver()
myserv = MyServer(dns_resolver)
loop = eventloop.EventLoop()
myserv.add_to_loop(loop)
dns_resolver.add_to_loop(loop)
loop.run()
def main():
# Python 2.6+ or Python3.3+
shell.check_python()
# fix py2exe
if hasattr(sys, "frozen") and sys.frozen in \
("windows_exe", "console_exe"):
p = os.path.dirname(os.path.abspath(sys.executable))
os.chdir(p)
config = shell.get_config(True)
if not config.get('dns_ipv6', False):
asyncdns.IPV6_CONNECTION_SUPPORT = False
# only
daemon.daemon_exec(config)
logging.info(
"local start with protocol[%s] password [%s] method [%s] obfs [%s] obfs_param [%s]"
% (config['protocol'], config['password'], config['method'],
config['obfs'], config['obfs_param']))
try:
logging.info("starting local at %s:%d" %
(config['local_address'], config['local_port']))
# DNS分解器
dns_resolver = asyncdns.DNSResolver()
# TCP服务
tcp_server = tcprelay.TCPRelay(config, dns_resolver, True)
# UDP服务
udp_server = udprelay.UDPRelay(config, dns_resolver, True)
# 将DNS服务、TCP服务、UDP服务加入事件循环
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
tcp_server.add_to_loop(loop)
udp_server.add_to_loop(loop)
def handler(signum, _):
logging.warn('received SIGQUIT, doing graceful shutting down..')
tcp_server.close(next_tick=True)
udp_server.close(next_tick=True)
# 预设信号处理函数，接收到正常的退出信号
signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM), handler)
def int_handler(signum, _):
sys.exit(1)
# SIGINT是键盘ctrl + c
signal.signal(signal.SIGINT, int_handler)
daemon.set_user(config.get('user', None))
loop.run()
except Exception as e:
shell.print_exception(e)
sys.exit(1)
def __init__(self, ssconfig, thread_num=0, timeout=1.0):
super(SSThread, self).__init__()
self.ssconfig = ssconfig
self.loop = eventloop.EventLoop()
self.dns_resolver = asyncdns.DNSResolver()
self.tcp_server = tcprelay.TCPRelay(self.ssconfig, self.dns_resolver,
True)
self.udp_server = udprelay.UDPRelay(self.ssconfig, self.dns_resolver,
True)
def __init__(self):
shell.check_python()
self.config = shell.get_config(False)
self.dns_resolver = asyncdns.DNSResolver()
self.tcp_servers_pool = {}
self.udp_servers_pool = {}
self.loop = eventloop.EventLoop()
self.thread = MainThread((self.loop, self.dns_resolver))
self.thread.start()
def __init__(self, config):
self._config = config
self._port_info = {}
self._relays = {} # (tcprelay, udprelay)
self._loop = eventloop.EventLoop()
self._dns_resolver = asyncdns.DNSResolver()
self._dns_resolver.add_to_loop(self._loop)
self._last_day = datetime.date.today().day
self._statistics = collections.defaultdict(int)
# 使用 _statistics_sum 来记录每天使用的流量的总量，每天凌晨刷新
self._statistics_sum = collections.defaultdict(int)
self._control_client_addr = None
self._control_client_url = None
try:
manager_address = config['manager_address']
if ':' in manager_address:
addr = manager_address.rsplit(':', 1)
addr = addr[0], int(addr[1])
addrs = socket.getaddrinfo(addr[0], addr[1])
if addrs:
family = addrs[0][0]
else:
logging.error('invalid address: %s', manager_address)
exit(1)
else:
addr = manager_address
self._control_client_url = addr
family = socket.AF_UNIX
self._control_socket = socket.socket(family, socket.SOCK_DGRAM)
self._control_socket.bind(addr)
self._control_socket.setblocking(False)
except (OSError, IOError) as e:
logging.error(e)
logging.error('can not bind to manager address')
exit(1)
self._loop.add(self._control_socket, eventloop.POLL_IN, self)
self._loop.add_periodic(self.handle_periodic)
port_password = config['port_password']
port_limit = config['port_limit']
del config['port_password']
del config['port_limit']
del config['server_port']
if port_limit is None:
port_limit = {}
for port, password in port_password.items():
a_config = config.copy()
a_config['server_port'] = int(port)
a_config['password'] = password
if port in port_limit:
a_config['limit'] = int(port_limit[port]) * LIMIT_MULTIPLE
self.add_user(a_config)
def main():
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
filemode='a+')
parser = argparse.ArgumentParser(description='Forward DNS requests.')
parser.add_argument('-b',
'--local_address',
metavar='BIND_ADDR',
type=str,
help='address that listens, default: 127.0.0.1',
default='127.0.0.1')
parser.add_argument('-p',
'--local_port',
metavar='BIND_PORT',
type=int,
help='port that listens, default: 53',
default=53)
parser.add_argument('-s',
'--dns',
metavar='DNS',
type=str,
help='DNS server to use, default: '
'114.114.114.114,208.67.222.222,8.8.8.8',
default='114.114.114.114,208.67.222.222,8.8.8.8')
parser.add_argument('-l',
'--ip_list',
metavar='IP_LIST_FILE',
type=str,
default=None)
config = vars(parser.parse_args())
if config['ip_list']:
logging.info('loading IP list from %s', config['ip_list'])
with open(config['ip_list'], 'rb') as f:
global GFW_LIST
GFW_LIST = set(f.readlines())
logging.info("starting dns at %s:%d", config['local_address'],
config['local_port'])
loop = eventloop.EventLoop()
try:
udprelay = UDPDNSRelay(config)
udprelay.add_to_loop(loop)
tcprelay = TCPDNSRelay(config)
tcprelay.add_to_loop(loop)
loop.run()
except (OSError, IOError) as e:
logging.error(e)
if eventloop.errno_from_exception(e) == errno.EACCES:
logging.info('please use sudo to run this program')
sys.exit(1)
def main():
global loop
utils.check_python()
# fix py2exe
if hasattr(sys, "frozen") and sys.frozen in \
("windows_exe", "console_exe"):
p = os.path.dirname(os.path.abspath(sys.executable))
os.chdir(p)
config = utils.get_config(True)
daemon.daemon_exec(config)
utils.print_shadowsocks()
encrypt.try_cipher(config['password'], config['method'])
try:
logging.info("starting local at %s:%d" %
(config['local_address'], config['local_port']))
dns_resolver = asyncdns.DNSResolver()
tcp_server = tcprelay.TCPRelay(config, dns_resolver, True)
udp_server = udprelay.UDPRelay(config, dns_resolver, True)
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
tcp_server.add_to_loop(loop)
udp_server.add_to_loop(loop)
def handler(signum, _):
logging.warn('received SIGQUIT, doing graceful shutting down..')
tcp_server.close(next_tick=True)
udp_server.close(next_tick=True)
# signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM), handler)
def int_handler(signum, _):
sys.exit(1)
# signal.signal(signal.SIGINT, int_handler)
loop.run()
try:
tcp_server.close(next_tick=True)
udp_server.close(next_tick=True)
except:
pass
except (KeyboardInterrupt, IOError, OSError) as e:
import traceback
traceback.print_exc()
logging.error(e)
if config['verbose']:
import traceback
traceback.print_exc()
os._exit(1)
def __init__(self):
self._config = None
self._relays = {} # (tcprelay, udprelay, username, password, method)
self._loop = eventloop.EventLoop()
self._dns_resolver = asyncdns.DNSResolver()
self._dns_resolver.add_to_loop(self._loop)
self._statistics = collections.defaultdict(dict)
self._control_client_addr = None
self._loop.add_periodic(self.handle_periodic)
def run_server():
try:
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
list(map(lambda s: s.add_to_loop(loop), tcp_servers))
daemon.set_user(config.get('user', None))
loop.run()
except Exception as e:
shell.print_exception(e)
sys.exit(1)
def test():
logging.basicConfig(
level=logging.DEBUG,
format=
'%(asctime)s %(levelname)-8s %(filename)s:%(lineno)s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
dns_resolver = DNSResolver()
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
global counter
counter = 0
def make_callback():
global counter
def callback(result, error):
global counter
# TODO: what can we assert?
counter += 1
print(counter, result, error)
if counter == 1:
dns_resolver.close()
loop.stop()
a_callback = callback
return a_callback
assert (make_callback() != make_callback())
dns_resolver.resolve('www.yk5jin.com', make_callback())
# dns_resolver.resolve(b'google.com', make_callback())
# dns_resolver.resolve('google.com', make_callback())
# dns_resolver.resolve('yk5jin.com', make_callback())
# dns_resolver.resolve('yk5jin.cn', make_callback())
# dns_resolver.resolve('example.com', make_callback())
# dns_resolver.resolve('ipv6.google.com', make_callback())
# dns_resolver.resolve('www.facebook.com', make_callback())
# dns_resolver.resolve('ns2.google.com', make_callback())
# dns_resolver.resolve('invalid.@!#$%^&[email protected]', make_callback())
# dns_resolver.resolve('toooooooooooooooooooooooooooooooooooooooooooooooooo'
# 'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
# 'long.hostname', make_callback())
# dns_resolver.resolve('toooooooooooooooooooooooooooooooooooooooooooooooooo'
# 'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
# 'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
# 'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
# 'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
# 'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
# 'long.hostname', make_callback())
loop.run()
def __init__(self, config):
self._config = config
self._relays = {} # (tcprelay, udprelay)
self._loop = eventloop.EventLoop()
self._dns_resolver = asyncdns.DNSResolver()
self._dns_resolver.add_to_loop(self._loop)
dbconfig = {
'host': config['db_host'],
'port': config['db_port'],
'user': config['db_user'],
'passwd': config['db_passwd'],
'db': config['db_name'],
'charset': 'utf8'
}
self._db = LightMysql.LightMysql(dbconfig)
self._statistics = collections.defaultdict(int)
self._control_client_addr = None
try:
manager_address = config['manager_address']
if ':' in manager_address:
addr = manager_address.rsplit(':', 1)
addr = addr[0], int(addr[1])
addrs = socket.getaddrinfo(addr[0], addr[1])
if addrs:
family = addrs[0][0]
else:
logging.error('invalid address: %s', manager_address)
exit(1)
else:
addr = manager_address
family = socket.AF_UNIX
self._control_socket = socket.socket(family, socket.SOCK_DGRAM)
self._control_socket.bind(addr)
self._control_socket.setblocking(False)
except (OSError, IOError) as e:
logging.error(e)
logging.error('can not bind to manager address')
exit(1)
self._loop.add(self._control_socket, eventloop.POLL_IN, self)
self._loop.add_periodic(self.handle_periodic)
del config['port_password']
port_passwords = self._db.select(
'select port,passwd from t_ss_port where enable=1')
for port_password in port_passwords:
a_config = config.copy()
a_config['server_port'] = int(port_password['port'])
a_config['password'] = port_password['passwd']
self.add_port(a_config)
def _start_ss(self):
logging.info("starting local at %s:%d" %
(self.config['local_address'], self.config['local_port']))
print("starting local at %s:%d" %
(self.config['local_address'], self.config['local_port']))
dns_resolver = asyncdns.DNSResolver()
tcp_server = tcprelay.TCPRelay(self.config, dns_resolver, True)
udp_server = udprelay.UDPRelay(self.config, dns_resolver, True)
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
tcp_server.add_to_loop(loop)
udp_server.add_to_loop(loop)
loop.run()
def test():
dns_resolver = DNSResolver()
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
global counter
counter = 0
# a closure
# http://simeonfranklin.com/blog/2012/jul/1/python-decorators-in-12-steps/
# key is, inner functions defined in non-global scope remember \
# what their enclosing namespaces looked like at definition time
# closures can be used to build custom functions
# in this case, callback() remembers counter even if make_callback() has returned
def make_callback():
global counter
def callback(result, error):
global counter
# TODO: what can we assert?
print(result, error)
counter += 1 # counter?
if counter == 9:
dns_resolver.close()
loop.stop()
a_callback = callback
return a_callback
assert(make_callback() != make_callback())
dns_resolver.resolve(b'google.com', make_callback())
dns_resolver.resolve('google.com', make_callback())
dns_resolver.resolve('example.com', make_callback())
dns_resolver.resolve('ipv6.google.com', make_callback())
dns_resolver.resolve('www.facebook.com', make_callback())
dns_resolver.resolve('ns2.google.com', make_callback())
dns_resolver.resolve('invalid.@!#$%^&[email protected]', make_callback())
dns_resolver.resolve('toooooooooooooooooooooooooooooooooooooooooooooooooo'
'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
'long.hostname', make_callback())
dns_resolver.resolve('toooooooooooooooooooooooooooooooooooooooooooooooooo'
'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
'ooooooooooooooooooooooooooooooooooooooooooooooooooo'
'long.hostname', make_callback())
loop.run()
def __init__(self, config):
"""
初始化Manager的配置参数，进入循环事件
:param config: 配置信息
"""
self._config = config
self._relays = {} # (tcprelay, udprelay)
self._loop = eventloop.EventLoop()
self._dns_resolver = asyncdns.DNSResolver()
self._dns_resolver.add_to_loop(self._loop)
self._statistics = collections.defaultdict(int)
self._control_client_addr = None
try:
manager_address = config['manager_address']
if ':' in manager_address:
addr = manager_address.rsplit(':', 1)
addr = addr[0], int(addr[1])
addrs = socket.getaddrinfo(addr[0], addr[1])
if addrs:
family = addrs[0][0]
else:
logging.error('invalid address: %s', manager_address)
exit(1)
else:
addr = manager_address
family = socket.AF_UNIX
self._control_socket = socket.socket(family,
socket.SOCK_DGRAM)
self._control_socket.bind(addr)
self._control_socket.setblocking(False)
except (OSError, IOError) as e:
logging.error(e)
logging.error('can not bind to manager address')
exit(1)
self._loop.add(self._control_socket,
eventloop.POLL_IN, self)
self._loop.add_periodic(self.handle_periodic)
port_password = config['port_password']
del config['port_password']
for port, password in port_password.items():
a_config = config.copy()
a_config['server_port'] = int(port)
a_config['password'] = password
self.add_port(a_config)
def run_server():
"""
服务器运行
:return: None
"""
def child_handler(signum, _):
"""
子程序要求关闭
:param signum: 信号值
:param _: 不明
:return: None
"""
logging.warn('received SIGQUIT, doing graceful shutting down..')
list(
map(lambda s: s.close(next_tick=True),
tcp_servers + udp_servers))
signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM),
child_handler)
def int_handler(signum, _):
"""
强制退出程序，意义不明
:param signum: 信号值
:param _: 不明
:return: None
"""
sys.exit(1)
signal.signal(signal.SIGINT, int_handler)
try:
loop = eventloop.EventLoop()
# 用addtoloop把dnsresolver添加到eventloop里，当DNSResolver对应的socket有dns解析结果可以读取的时候，eventloop会自动调用其handle_event方法将就绪的socket递给DNSResolver，DNSResolver就可以从其中读取dns应答数据了。
dns_resolver.add_to_loop(loop)
list(map(lambda s: s.add_to_loop(loop), tcp_servers + udp_servers))
daemon.set_user(config.get('user', None))
loop.run()
except Exception as e:
shell.print_exception(e)
sys.exit(1)
def __init__(self, config):
atexit.register(self.cleanup)
self._is_unix = False
self._mngr_address = None
self._config = config
self._relays = {} # (tcprelay, udprelay)
self._loop = eventloop.EventLoop()
self._dns_resolver = asyncdns.DNSResolver()
self._dns_resolver.add_to_loop(self._loop)
self._statistics = collections.defaultdict(int)
self._control_client_addr = None
try:
manager_address = config['manager_address']
if hasattr(manager_address, 'decode'):
manager_address = manager_address.decode('utf-8')
if ':' in manager_address:
addr = manager_address.rsplit(':', 1)
addr = addr[0], int(addr[1])
addrs = socket.getaddrinfo(addr[0], addr[1])
if addrs:
family = addrs[0][0]
else:
logging.error('invalid address: %s', manager_address)
exit(1)
else:
addr = manager_address
family = socket.AF_UNIX
self._is_unix = True
self._mngr_address = manager_address
self._control_socket = socket.socket(family, socket.SOCK_DGRAM)
self._control_socket.bind(addr)
self._control_socket.setblocking(False)
except (OSError, IOError) as e:
logging.error(e)
logging.error('can not bind to manager address')
exit(1)
self._loop.add(self._control_socket, eventloop.POLL_IN, self)
self._loop.add_periodic(self.handle_periodic)
port_password = config['port_password']
del config['port_password']
config['crypto_path'] = config.get('crypto_path', dict())
for port, password in port_password.items():
a_config = config.copy()
a_config['server_port'] = int(port)
a_config['password'] = password
self.add_port(a_config)
def main():
shell.check_python() # 判断python版本
# fix py2exe
# hasattr(object, name) 判断一个对象里面是否有name属性或者name方法，返回BOOL值，有name特性返回True， 否则返回False。
if hasattr(sys, "frozen") and sys.frozen in \
("windows_exe", "console_exe"):
# sys.executable python可执行文件的绝对路径
# os.path.abspath(path) 返回绝对路径
# os.path.dirname(path) 返回文件路径
# os.chdir() 用于改变当前工作目录到指定的路径
p = os.path.dirname(os.path.abspath(sys.executable))
os.chdir(p)
# 获取配置字典，包含每个配置项的具体配置值
config = shell.get_config(True)
# 根据配置文件当中的关键字daemon决定程序是启动/停止/重启
daemon.daemon_exec(config)
try:
logging.info("starting local at %s:%d" %
(config['local_address'], config['local_port']))
dns_resolver = asyncdns.DNSResolver()
tcp_server = tcprelay.TCPRelay(config, dns_resolver, True)
udp_server = udprelay.UDPRelay(config, dns_resolver, True)
loop = eventloop.EventLoop()
dns_resolver.add_to_loop(loop)
tcp_server.add_to_loop(loop)
udp_server.add_to_loop(loop)
def handler(signum, _):
logging.warn('received SIGQUIT, doing graceful shutting down..')
tcp_server.close(next_tick=True)
udp_server.close(next_tick=True)
signal.signal(getattr(signal, 'SIGQUIT', signal.SIGTERM), handler)
def int_handler(signum, _):
sys.exit(1)
signal.signal(signal.SIGINT, int_handler)
daemon.set_user(config.get('user', None))
loop.run()
except Exception as e:
shell.print_exception(e)
sys.exit(1)
def main():
# 检查当前的运行环境 是否支持, 如果不支持, sys.exit(1) 退出
shell.check_python()
config = shell.get_config(True)
# deamon.deamon_exec(config)
logging.info('start local at %s:%d' %
(config['local_address'], config['local_port']))
dns_resolver = asyncdns.DNSResolver()
tcp_server = tcprelay.TCPRelay(config, dns_resolver)
loop = eventloop.EventLoop()
tcp_server.add_to_loop(loop)
loop.run()
