def connection_done(ok):
self.ssids.set_click(True)
self.scan_btn.set_click(True)
if ok:
self.screen.set_status("wifi", True)
self.write_key(ssid, password)
self.ssids.set_show_selected(True)
# find ssid in network list and select it
for i in range(len(self.networks)):
if self.networks[i]["ssid"] == ssid:
self.ssids.set_selected(i)
self.label.set_text("Connected\n\nSSID: " + ssid + "\nIP: " +
self.wlan.ifconfig()[0] + "\n" +
self.config["name"] + ".local")
try:
self.server = http_server()
self.server.register_input_callback()
except Exception as e:
print("Webserver error:", e)
import espidf
if espidf.mdns_init() == 0:
espidf.mdns_hostname_set(self.config["name"])
else:
self.label.set_text("Connection failed")
self.task.set_repeat_count(0)
def __init__(self, input_q, output_q, endpoint, **kwds):
from http_server import http_server
threading.Thread.__init__(self, **kwds)
self.setDaemon(1)
self.input_q = input_q
self.output_q = output_q
self.endpoint = endpoint
self.keep_running = True
self.server = http_server(self.input_q, self.output_q, self.endpoint)
self.start()
import filesys
import ftp_server
import http_server
import status_handler
# M2Crypto
import https_server
import poison_handler
import ftps_server
from M2Crypto import Rand, SSL, threading
HTTP_PORT = 39080
HTTPS_PORT = 39443
FTP_PORT = 39021
hs = http_server.http_server('', HTTP_PORT)
Rand.load_file('../randpool.dat', -1)
ssl_ctx = SSL.Context('sslv23')
ssl_ctx.load_cert('server.pem')
ssl_ctx.load_verify_locations('ca.pem', '')
ssl_ctx.load_client_CA('ca.pem')
#ssl_ctx.set_verify(SSL.verify_peer, 10)
#ssl_ctx.set_verify(SSL.verify_peer|SSL.verify_fail_if_no_peer_cert, 10)
#ssl_ctx.set_verify(SSL.verify_peer|SSL.verify_client_once, 10)
ssl_ctx.set_verify(SSL.verify_none, 10)
ssl_ctx.set_session_id_ctx('127.0.0.1:39443')
ssl_ctx.set_tmp_dh('dh1024.pem')
ssl_ctx.set_info_callback()
hss = https_server.https_server('', HTTPS_PORT, ssl_ctx)
import http_server
import status_handler
# M2Crypto
import https_server
import poison_handler
from M2Crypto import Rand, SSL
# XMLrpc
import xmlrpc_handler
HTTP_PORT=39080
HTTPS_PORT=39443
hs=http_server.http_server('', HTTP_PORT)
Rand.load_file('../randpool.dat', -1)
ssl_ctx=SSL.Context('sslv23')
ssl_ctx.load_cert('server.pem')
#ssl_ctx.load_verify_location('ca.pem')
#ssl_ctx.load_client_CA('ca.pem')
#ssl_ctx.set_verify(SSL.verify_peer, 10)
#ssl_ctx.set_verify(SSL.verify_peer|SSL.verify_fail_if_no_peer_cert, 10)
#ssl_ctx.set_verify(SSL.verify_peer|SSL.verify_client_once, 10)
ssl_ctx.set_verify(SSL.verify_none, 10)
ssl_ctx.set_session_id_ctx('127.0.0.1:9443')
ssl_ctx.set_tmp_dh('dh1024.pem')
#ssl_ctx.set_info_callback()
hss=https_server.https_server('', HTTPS_PORT, ssl_ctx)
# # XML-RPC SERVER # $Id: xmlrpc_handler.py,v 1.1 2001/07/11 17:42:21 effbot Exp $ # # an asynchronous XML-RPC server for Medusa # # written by Sam Rushing # # Based on "xmlrpcserver.py" by Fredrik Lundh ([email protected]) # import http_server import xmlrpclib import regex import string import sys class xmlrpc_handler: def match(self, request): # Note: /RPC2 is not required by the spec, so you may override this method. if request.uri[:5] == '/RPC2': return 1 else: return 0 def handle_request(self, request): [path, params, query, fragment] = request.split_uri() if request.command in ('post', 'put'): request.collector = collector(self, request) else: request.error(400) def continue_request(self, data, request):
if __name__ == "__main__":
import sys
if len(sys.argv) < 2:
print "Usage: %s <worker_threads>" % sys.argv[0]
else:
nthreads = string.atoi(sys.argv[1])
import asyncore
import http_server
# create a generic web server
hs = http_server.http_server("", 7080)
# create a request queue
q = request_queue()
# create a script handler
sh = script_handler(q)
# install the script handler on the web server
hs.install_handler(sh)
# get a couple of CGI modules
import test_module
import pi_module
# install the module on the script handler
# Make handler for /system
mod_h = pycs_module_handler.pycs_module_handler( set )
if os.path.isfile( os.path.join( pycs_paths.CONFDIR, 'users.conf' ) ):
# Add auth wrapper
mod_h = pycs_auth_handler.pycs_auth_handler( set, mod_h, set.authorizer )
# add the webauth wrapper (handles accessRestriction restrictions)
default_h = pycs_webauth_handler.pycs_webauth_handler( set, default_h, rpc_ar_h )
# Make logger
accessLog = logger.rotating_file_logger( pycs_paths.ACCESSLOG, None, 1024*1024 )
print "logging to",pycs_paths.ACCESSLOG
logger = status_handler.logger_for_status( accessLog )
# Make web server
hs = http_server.http_server( '', set.ServerPort(), None, logger )
hs.server_name = set.conf['serverhostname']
ms = None
if set.conf.has_key( 'monitorport' ):
port = int( set.conf['monitorport'] )
if set.conf.has_key( 'monitorpassword' ):
pwd = set.conf['monitorpassword']
ms = monitor.secure_monitor_server( pwd, '', port )
else:
ms = monitor.monitor_server( '', port )
# become the PyCS user
if os.name == 'posix':
try:
# look in ~medusa/patches for {set,get}euid.
if not cl:
request.error(411)
else:
cl = string.atoi(cl)
# using a 'numeric' terminator
self.request.channel.set_terminator(cl)
def collect_incoming_data(self, data):
self.data.append(data)
def found_terminator(self):
# set the terminator back to the default
self.request.channel.set_terminator('\r\n\r\n')
self.handler.continue_request("".join(self.data), self.request)
if __name__ == '__main__':
class rpc_demo(xmlrpc_handler):
def call(self, method, params):
print 'method="%s" params=%s' % (method, params)
return "Sure, that works"
import asyncore_25 as asyncore
hs = http_server.http_server('', 8000)
rpc = rpc_demo()
hs.install_handler(rpc)
asyncore.loop()
# deliver files!
# This default handler uses the filesystem object we just constructed.
dh = default_handler.default_handler (dfs)
cdh = cdms_handler.cdms_handler(fs)
# Wrap an authentication handler around the default file handler
ah = auth_handler.auth_handler(dh,'access')
acdh = auth_handler.auth_handler(cdh,'access')
# ===========================================================================
# HTTP Server
# ===========================================================================
hs = http_server.http_server (IP_ADDRESS, HTTP_PORT, rs, lg)
# Here we install the authentication handler created above.
hs.install_handler (ah)
hs.install_handler(acdh)
# ===========================================================================
# Unix user `public_html' directory support
# ===========================================================================
if os.name == 'posix':
import unix_user_handler
uh = unix_user_handler.unix_user_handler ('public_html')
hs.install_handler (uh)
# ===========================================================================
# FTP Server
request.error(411)
else:
cl = string.atoi(cl)
# using a 'numeric' terminator
self.request.channel.set_terminator(cl)
def collect_incoming_data(self, data):
self.data = self.data + data
def found_terminator(self):
# set the terminator back to the default
self.request.channel.set_terminator("\r\n\r\n")
self.handler.continue_request(self.data, self.request)
if __name__ == "__main__":
class rpc_demo(xmlrpc_handler):
def call(self, method, params):
print 'method="%s" params=%s' % (method, params)
return "Sure, that works"
import asyncore
import http_server
hs = http_server.http_server("", 8000)
rpc = rpc_demo()
hs.install_handler(rpc)
asyncore.loop()
import http_server, script_handler
import basecfg
#--------------------------------------
path = basecfg.basepath+'/browser/http'
#path = '/home/rand/apr/browser/http'
os.chdir(path)
fs = filesys.os_filesystem(path)
dh = default_handler.default_handler(fs)
sh = script_handler.script_handler(fs)
if os.uname()[0] == 'AIX' or len(sys.argv) > 1:
h = http_server.http_server('', 8080)
else:
h = http_server.http_server('', 8180)
h.install_handler (dh)
h.install_handler (sh)
authorizer = ftp_server.anon_authorizer (basecfg.baselog)
if os.uname()[0] == 'AIX' or len(sys.argv) > 1:
fs = ftp_server.ftp_server (authorizer, port=8021)
else:
fs = ftp_server.ftp_server (authorizer, port=8121)
asyncore.loop()
# set the terminator back to the default
self.request.channel.set_terminator ('\r\n\r\n')
self.handler.continue_request (self.data, self.request)
if __name__ == '__main__':
import asyncore
import http_server
class Thing:
def badparam(self, param):
if param == 'good param':
return 1
else:
return Fault(faultstring='bad param')
def dt(self, aDateTime):
return aDateTime
thing = Thing()
soaph = soap_handler()
soaph.registerObject(thing)
hs = http_server.http_server('', 10080)
hs.install_handler(soaph)
asyncore.loop()
def init_server(request):
"""
Launch the http server, but don't start blocking until
the testing session is over!
"""
request.addfinalizer(http_server().join)
# # XML-RPC SERVER # $Id: xmlrpc_handler.py,v 1.1 2001/07/11 17:42:21 effbot Exp $ # # an asynchronous XML-RPC server for Medusa # # written by Sam Rushing # # Based on "xmlrpcserver.py" by Fredrik Lundh ([email protected]) # import http_server import xmlrpclib import regex import string import sys class xmlrpc_handler: def match (self, request): # Note: /RPC2 is not required by the spec, so you may override this method. if request.uri[:5] == '/RPC2': return 1 else: return 0 def handle_request (self, request): [path, params, query, fragment] = request.split_uri() if request.command in ('post', 'put'): request.collector = collector (self, request) else: request.error (400) def continue_request (self, data, request): params, method = xmlrpclib.loads (data)
for opt,arg in optlist:
if opt =="-h":
print("usage python server.py [-p port_num] [-f num_forks] [-t num_threads_per_fork]")
sys.exit(0)
elif opt =="p":
server_settings.port=arg
elif opt =="-f":
server_settings.num_forks=arg
elif opt == "-t":
server_settings.num_threads_per_fork=arg
elif opt == "-d":
server_settings.service_dir=arg
server=http_server()
print("Starting server "+str(time.asctime()))
print("Port "+str(server_settings.port))
print("Num forks "+str(server_settings.num_forks))
print("Num threads per fork "+str(server_settings.num_threads_per_fork))
try:
server.serve_forever()
except KeyboardInterrupt:
pass
print("Closing server "+str(time.asctime()))
try:
server.shutdown()
def found_terminator(self):
# set the terminator back to the default
self.request.channel.set_terminator('\r\n\r\n')
self.handler.continue_request(self.data, self.request)
if __name__ == '__main__':
import asyncore
import http_server
class Thing:
def badparam(self, param):
if param == 'good param':
return 1
else:
return Fault(faultstring='bad param')
def dt(self, aDateTime):
return aDateTime
thing = Thing()
soaph = soap_handler()
soaph.registerObject(thing)
hs = http_server.http_server('', 10080)
hs.install_handler(soaph)
asyncore.loop()
# -*- Mode: Python; tab-width: 4 -*-
import asyncore
import http_server
import script_handler
import filesys
h = http_server.http_server ('', 8081)
fs = filesys.os_filesystem ('.')
sh = script_handler.script_handler (fs)
import persistent
ph = script_handler.persistent_script_handler()
ph.add_module ('per', persistent)
# install the two handlers
# Hit me as: http://www.your_server.com:8081/per
h.install_handler (ph)
# Hit me as: http://www.your_server.com:8081/form.mpy
h.install_handler (sh)
asyncore.loop()
import filesys
# For this demo, we'll just use a dictionary of usernames/passwords.
# You can of course use anything that supports the mapping interface,
# and it would be pretty easy to set this up to use the crypt module
# on unix.
users = { 'mozart' : 'jupiter', 'beethoven' : 'pastoral' }
# The filesystem we will be giving access to
fs = filesys.os_filesystem ('/home/medusa')
# The 'default' handler - delivers files for the HTTP GET method.
dh = default_handler.default_handler (fs)
# Supports the HTTP PUT method...
ph = put_handler.put_handler (fs, '/.*')
# ... but be sure to wrap it with an auth handler:
ah = auth_handler.auth_handler (users, ph)
# Create a Web Server
hs = http_server.http_server (ip='', port=8080)
# install the handlers we created:
hs.install_handler (dh) # for GET
hs.install_handler (ah) # for PUT
asyncore.loop()
while 1:
function, (env, stdin, stdout) = self.queue.get()
function(env, stdin, stdout)
stdout.close()
if __name__ == '__main__':
if len(sys.argv) < 2:
print('Usage: %s <worker_threads>' % sys.argv[0])
else:
nthreads = string.atoi(sys.argv[1])
import asyncore
import http_server
# create a generic web server
hs = http_server.http_server('', 7080)
# create a request queue
q = request_queue()
# create a script handler
sh = script_handler(q)
# install the script handler on the web server
hs.install_handler(sh)
# get a couple of CGI modules
import test_module
import pi_module
# install the module on the script handler
request.error (411)
else:
cl = int (cl)
# using a 'numeric' terminator
self.request.channel.set_terminator (cl)
def collect_incoming_data (self, data):
self.data = self.data + data
def found_terminator (self):
# set the terminator back to the default
self.request.channel.set_terminator ('\r\n\r\n')
self.handler.continue_request (self.data, self.request)
if __name__ == '__main__':
class rpc_demo (xmlrpc_handler):
def call (self, method, params):
print 'method="%s" params=%s' % (method, params)
return "Sure, that works"
import asyncore
import http_server
hs = http_server.http_server ('', 8000)
rpc = rpc_demo()
hs.install_handler (rpc)
asyncore.loop()
# deliver files!
# This default handler uses the filesystem object we just constructed.
dh = default_handler.default_handler(dfs)
cdh = cdms_handler.cdms_handler(fs)
# Wrap an authentication handler around the default file handler
ah = auth_handler.auth_handler(dh, 'access')
acdh = auth_handler.auth_handler(cdh, 'access')
# ===========================================================================
# HTTP Server
# ===========================================================================
hs = http_server.http_server(IP_ADDRESS, HTTP_PORT, rs, lg)
# Here we install the authentication handler created above.
hs.install_handler(ah)
hs.install_handler(acdh)
# ===========================================================================
# Unix user `public_html' directory support
# ===========================================================================
if os.name == 'posix':
import unix_user_handler
uh = unix_user_handler.unix_user_handler('public_html')
hs.install_handler(uh)
# ===========================================================================
# FTP Server