iframe-proxy | Sunbelt Computer Software

364 lines (306 loc) · 10.4 KB
import asyncio
import json
import time
import pprint
    "get": {},
    "post": {},
    "put": {},
    "delete": {}
CONTENT_TYPE = {
    "html": "text/html",
    "css": "text/css",
    "js": "application/javascript",
    "jpeg": "image/jpeg",
    "jpg": "image/jpg",
    "png": "image/png",
    "gif": "image/gif",
    "ico": "image/x-icon",
    "text": "text/plain",
    "json": "application/json",
    "pdf": "application/pdf"
MIDDLEWARES = []
def add_route(method, path, func):
    """ADD ROUTES
    Build ROUTES
    ROUTES[method][path] = func
def add_middleware(func):
    """ADD middlewares
    MIDDLEWARES.append(func)
# Server Functions
async def worker(data):
    """WORKER
    Accept requests and invoke request handler
    request = {}
    header_str = data["header"].split("\r\n\r\n")[0]
    if not header_str:
        return err_404_handler(request, {})
    request = header_parser(request, header_str)
    request["body"] = data["content"]
    if request:
        result = await request_handler(request)
        return result
def get_content(request):
    query_string = request["path"].split("?")
    request["path"] = query_string[0]
    content = {}
    for val in query_string[1].split("&"):
        temp = val.split("=")
        content[temp[0]] = temp[1]
    return [request["path"], content]
def get_header(header_list):
    header = {}
    for each_line in header_list:
        key, value = each_line.split(": ", 1)
        header[key] = value
    if "Cookie" in header:
        cookies = header["Cookie"].split(";")
        client_cookies = {}
        for cookie in cookies:
            head, body = cookie.strip().split("=", 1)
            client_cookies[head] = body
            header["Cookie"] = client_cookies
        header["Cookie"] = ""
    return header
def header_parser(request, header_str):
    HTTP Header Parser
    header_list = header_str.split("\r\n")
    first = header_list.pop(0)
    status_line = first.split()
    request["method"], request["path"], request["protocol"] = status_line
    if "?" in request["path"]:
        request["path"], request["content"] = get_content(request)
    request["header"] = get_header(header_list)
    return request
def form_parser(request):
    """FORM Parser"""
    content_type = request["header"]["Content-Type"]
    boundary = content_type.split("; ")[1]
    request["boundary"] = "--" + boundary.split("=")[1]
    for content in request["body"].split(request["boundary"].encode()):
        form_header_dict = {}
        data = {}
        form_data = content.split(b"\r\n\r\n", 1)
        form_header = form_data[0].split(b"\r\n")
        form_body = ""
        if len(form_data) > 1:
            form_body = form_data[1]
        for each_line in form_header:
            if not each_line or b": " not in each_line:
                continue
            key, value = each_line.split(b": ")
            form_header_dict[key] = value
        if not form_header_dict:
            continue
        form = {}
        for each_item in form_header_dict[b"Content-Disposition"].split(b"; "):
            if b"=" in each_item:
                name, value = each_item.split(b"=", 1)
                data[name] = value.strip(b'"')
                data["body"] = form_body
                form[data[b"name"]] = data
    request["form"] = form
    return request
def multipart_parser(request):
    content_dict = {}
    for key, value in request["form"].items():
        if b"filename" not in value:
            content_dict[key.decode()] = value["body"].decode()
        else:
            content_dict[key.decode()] = value["body"]
    return content_dict
def parse_fields(body):
    content_dict = {}
    data_split = body.split("&")
    for val in data_split:
        key, value = val.split("=")
        content_dict[key.decode()] = value.decode()
    return content_dict
# Handler Functions
async def request_handler(request):
    """Request Handler"""
    response = {}
    if MIDDLEWARES:
        for middleware in MIDDLEWARES:
            if middleware.PRE:
                request, response = middleware(request, response)
    return method_handler(request, response)
def method_handler(request, response):
    """METHOD Handler
    call respective method handler
    METHOD = {
        "GET": get_handler,
        "POST": post_handler,
        "HEAD": head_handler,
        "DELETE": delete_handler,
        "PUT": put_handler
    handler = METHOD[request["method"]]
    return handler(request, response)
def get_handler(request, response):
    """HTTP GET Handler"""
        return ROUTES["get"][request["path"]](request, response)
    except KeyError:
        return static_file_handler(request, response)
def post_handler(request, response):
    """HTTP POST Handler"""
        content_type = request["header"]["Content-Type"]
        if "multipart" in content_type:
            request = form_parser(request)
            request["content"] = multipart_parser(request)
        elif "json" in content_type:
            request["content"] = json.loads(request["body"].decode())
        else:
            request["content"] = parse_fields(request["body"])
        return ROUTES["post"][request["path"]](request, response)
    except KeyboardInterrupt:
        return err_404_handler(request, response)
def put_handler(request, response):
    """HTTP PUT Handler"""
        if "multipart" in request["header"]["Content-Type"]:
            request = form_parser(request)
            request["content"] = multipart_parser(request)
        else:
            request["content"] = parse_fields(request["body"])
        return ROUTES["put"][request["path"]](request, response)
    except KeyboardInterrupt:
        return err_404_handler(request, response)
def delete_handler(request, response):
    """HTTP DELETE Handler"""
        return ROUTES["delete"][request["path"]](request, response)
    except KeyError:
        return err_404_handler(request, response)
def head_handler(request, response):
    """HTTP HEAD Handler"""
    get_handler(request, response)
    response["content"] = ""
    return response_handler(request, response)
def static_file_handler(request, response):
    """HTTP Static File Handler"""
        with open("./public" + request["path"], "rb") as file_descriptor:
            res = file_descriptor.read()
    except IOError:
        return err_404_handler(request, response)
    except FileNotFoundError:
        res = b""
    response["content"] = res
    content_type = request["path"].split(".")[-1].lower()
    response["Content-type"] = CONTENT_TYPE[content_type]
    return ok_200_handler(request, response)
def err_404_handler(request, response):
    """HTTP 404 Handler"""
    response["status"] = "HTTP/1.1 404 Not Found"
    response["content"] = "Content Not Found"
    response["Content-type"] = "text/HTML"
    return response_handler(request, response)
def ok_200_handler(request, response):
    """HTTP 200 Handler"""
    response["status"] = "HTTP/1.1 200 OK"
    if response["content"] and response["Content-type"]:
        response["Content-Length"] = str(len(response["content"]))
    res = response_handler(request, response)
    return res
def redirect(request, response, tmp_uri):
    """HTTP 302 handler"""
    response["status"] = "HTTP/1.1 302 Found"
    response["location"] = tmp_uri
    res = response_handler(request, response)
    return res
def response_handler(request, response):
    """HTTP response Handler"""
    response["Date"] = time.strftime("%a, %d %b %Y %H:%M:%S", time.localtime())
    response["Connection"] = "close"
    response["Server"] = "magicserver0.2"
    if MIDDLEWARES:
        for middleware in MIDDLEWARES:
            if middleware.POST:
                request, response = middleware(request, response)
    response_string = make_response(response)
    return response_string
def send_html_handler(request, response, content):
    """send_html handler
    Add html content to response
    if content:
        response["content"] = content
        response["Content-type"] = "text/html"
        res = ok_200_handler(request, response)
        return res
        return err_404_handler(request, response)
def send_json_handler(request, response, content):
    """send_json handler
    Add JSON content to response
    if content:
        response["content"] = json.dumps(content)
        response["Content-type"] = "application/json"
        return ok_200_handler(request, response)
        return err_404_handler(request, response)
def make_response(response):
    Make a byte string of the response dictionary
    response_string = response["status"] + "\r\n"
    keys = [key for key in response if key not in ["status", "content"]]
    for key in keys:
        response_string += key + ": " + response[key] + "\r\n"
    response_string += "\r\n"
    response_string = response_string.encode()
    if "content" in response:
        content = response["content"]
        if isinstance(content, str):
            content = content.encode()
        new_line = b"\r\n\r\n"
        response_string += content + new_line
    return response_string
def check_content(headers):
    if b"Content-Length" in headers:
        con_pos = headers.find(b"Content-Length")
        col_pos = headers.find(b":", con_pos)
        srsn = headers.find(b"\r\n", col_pos)
        con_len = int(headers[col_pos + 2:srsn])
        return con_len
async def handle_connections(reader, writer):
    addr = writer.get_extra_info("peername")
    print("Connection from:{0}".format(addr))
    header = await reader.readuntil(b"\r\n\r\n")
    content_length = check_content(header)
    data = {"content": None}
    data["header"] = header.decode()
    pprint.pprint(data["header"])
    if content_length:
        content = await reader.readexactly(content_length)
        data["content"] = content
    response = await worker(data)
    writer.write(response)
    await writer.drain()
    writer.close()
def start_server(hostname, port):
    loop = asyncio.get_event_loop()
    coro = asyncio.start_server(handle_connections, hostname, port, loop=loop)
    server = loop.run_until_complete(coro)
    print("Serving on {0}".format(server.sockets[0].getsockname()))
        loop.run_forever()
    except KeyboardInterrupt:
        pass
    server.close()
    loop.run_until_complete(server.wait_closed())
    loop.close()
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Sunbelt Computer Software

PL/B Language Development and Support

FilesExpand file tree

server.py

Latest commit

History

server.py

File metadata and controls
