161 lines
4.4 KiB
Python
161 lines
4.4 KiB
Python
import socketserver
|
|
import subprocess
|
|
import os
|
|
|
|
host = "localhost"
|
|
port = 77
|
|
|
|
class GopherError(BaseException): pass
|
|
class RequestError(GopherError): pass
|
|
|
|
class GopherLine:
|
|
def __init__(self, line):
|
|
self.item = "i"
|
|
self.text = ""
|
|
self.location = "null"
|
|
self.host = "null.host"
|
|
self.port = "0"
|
|
self.line = line
|
|
self.parse()
|
|
def parse(self):
|
|
split = self.line.rstrip().split('\t')
|
|
location = False
|
|
if len(split) == 1:
|
|
self.text = split[0]
|
|
return
|
|
|
|
try: self.item = split[0][0]
|
|
except IndexError: pass
|
|
|
|
try: self.text = split[0][1:]
|
|
except IndexError: pass
|
|
|
|
try:
|
|
self.location = split[1]
|
|
location = True
|
|
except IndexError: pass
|
|
|
|
try: self.host = split[2]
|
|
except IndexError:
|
|
if location == True: self.host = host
|
|
|
|
try: self.port = split[3]
|
|
except IndexError:
|
|
if location == True: self.port = str(port)
|
|
def render(self):
|
|
return "{}{}\t{}\t{}\t{}".format(
|
|
self.item,
|
|
self.text,
|
|
self.location,
|
|
self.host,
|
|
self.port
|
|
)
|
|
|
|
class GopherServerLogic:
|
|
def recieveRequest(self):
|
|
data = b""
|
|
while data[-2:] != b"\r\n":
|
|
data += self.request.recv(1)
|
|
decoded = data[:-2].decode("utf-8")
|
|
return decoded
|
|
|
|
def requestParser(self, request):
|
|
if ".." in request: raise RequestError
|
|
try:
|
|
if request[0] == "/": request = request[1:]
|
|
except IndexError: pass
|
|
request = request.replace("?", "\t").split("\t")
|
|
try: return (request[0], request[1])
|
|
except IndexError: return (request[0], "")
|
|
|
|
def returnRelative(self, file):
|
|
gph = False
|
|
if file == "":
|
|
ret = "gophermap"
|
|
gph = True
|
|
elif os.path.isdir(file):
|
|
ret = file + "/gophermap"
|
|
gph = True
|
|
elif os.path.isfile(file): ret = file
|
|
else: raise RequestError("unreachable state")
|
|
return (ret, gph)
|
|
|
|
def fileSendable(self, file): return os.access(file, os.F_OK|os.R_OK)
|
|
|
|
def fileCGI(self, file):
|
|
return os.access(file, os.F_OK|os.R_OK|os.X_OK)
|
|
|
|
def notFound(self):
|
|
self.request.sendall(b"3error: file not found!\r\n.\r\n")
|
|
|
|
def invalid(self):
|
|
self.request.sendall(b"3error: selector contains '..'!\r\n.\r\n")
|
|
|
|
def fileToFileArray(self, file):
|
|
fd = open(file, "r")
|
|
ret = [i.rstrip() for i in fd.readlines()]
|
|
fd.close()
|
|
return ret
|
|
|
|
def sendFileArray(self, arr):
|
|
[self.request.sendall(
|
|
(i.rstrip() + "\r\n").encode("utf-8")
|
|
) for i in arr]
|
|
self.request.sendall(b".\r\n")
|
|
|
|
def cgi(self, file, query):
|
|
env = {}
|
|
env["QUERY_STRING"] = query
|
|
env["SCRIPT_NAME"] = "/" + file
|
|
env["REMOTE_ADDR"] = self.client_address[0]
|
|
|
|
proc = subprocess.Popen(
|
|
[os.getcwd() + "/" + file],
|
|
stdout = subprocess.PIPE,
|
|
env = env
|
|
)
|
|
|
|
try: out, err = proc.communicate(timeout=10)
|
|
except TimeoutExpired:
|
|
proc.kill()
|
|
out, err = proc.communicate()
|
|
|
|
return out.decode("utf-8").replace("\r", "").split("\n")
|
|
|
|
def gopherRenderer(self, fileArray):
|
|
gopherlines = []
|
|
for i in fileArray:
|
|
gopherlines.append(GopherLine(i))
|
|
returned = []
|
|
for i in gopherlines:
|
|
returned.append(i.render())
|
|
return returned
|
|
|
|
def serveFile(self, file, query, gph):
|
|
if self.fileCGI(file): fa = self.cgi(file, query)
|
|
elif self.fileSendable(file): fa = self.fileToFileArray(file)
|
|
else:
|
|
self.notFound()
|
|
return
|
|
if gph: fa = self.gopherRenderer(fa)
|
|
self.sendFileArray(fa)
|
|
|
|
class GopherHandler(socketserver.BaseRequestHandler, GopherServerLogic):
|
|
def handle(self):
|
|
decoded = self.recieveRequest()
|
|
try:
|
|
parsed = self.requestParser(decoded)
|
|
except RequestError:
|
|
self.invalid()
|
|
return
|
|
|
|
try: file = self.returnRelative(parsed[0])
|
|
except RequestError:
|
|
self.notFound()
|
|
return
|
|
self.serveFile(file[0], parsed[1], file[1])
|
|
|
|
if __name__ == "__main__":
|
|
with socketserver.TCPServer((host, port), GopherHandler) as server:
|
|
server.serve_forever()
|