Exemplo n.º 1
0
    def handle(self):
        """Handle Gopher+ request."""
        self.handlemethod = None
        if self.gopherpstring[0] == '+':
            self.handlemethod = 'documentonly'
        elif self.gopherpstring == '!':
            self.handlemethod = 'infoonly'
        elif self.gopherpstring[0] == '$':
            self.handlemethod = 'gopherplusdir'

        try:
            handler = self.gethandler()
            self.log(handler)
            self.entry = handler.getentry()
            
            if self.handlemethod == 'infoonly':
                self.wfile.write("+-2\r\n")
                self.wfile.write(self.renderobjinfo(self.entry))
            else:
                handler.prepare()
                self.wfile.write("+" + str(self.entry.getsize(-2)) + "\r\n")
                if handler.isdir():
                    self.writedir(self.entry, handler.getdirlist())
                else:
                    handler.write(self.wfile)
        except GopherExceptions.FileNotFound as e:
            self.filenotfound(str(e))
        except IOError as e:
            GopherExceptions.log(e, self, None)
            self.filenotfound(e[1])
Exemplo n.º 2
0
 def testlog_basic(self):
     try:
         raise IOError("foo")
     except IOError as e:
         GopherExceptions.log(e)
     self.assertEqual(self.stringfile.getvalue(),
                      "unknown-address [None/None] EXCEPTION OSError: foo\n")
Exemplo n.º 3
0
    def handle(self):
        host, path, content_length = self.request.strip().split(" ")

        self.selector = urllib.parse.unquote(path, errors="surrogateescape")

        content_length = int(content_length)
        if content_length:
            data = self.rfile.read(content_length)
            self.searchrequest = data.decode(errors="surrogateescape")

        try:
            handler = self.gethandler()
            self.log(handler)
            self.entry = handler.getentry()
            handler.prepare()
        except GopherExceptions.FileNotFound as e:
            self.write_status(4, str(e))
            return
        except IOError as e:
            GopherExceptions.log(e, self, None)
            self.write_status(5, e.args[1])
            return

        if handler.isdir():
            self.write_status(2, "text/gemini")
            self.writedir(self.entry, handler.getdirlist())
        else:
            mimetype = self.adjust_mimetype(self.entry.getmimetype())
            self.write_status(2, mimetype)
            self.handler.write(self.wfile)
Exemplo n.º 4
0
    def handle(self):
        """Handle Gopher+ request."""
        self.handlemethod = None
        if self.gopherpstring[0] == "+":
            self.handlemethod = "documentonly"
        elif self.gopherpstring == "!":
            self.handlemethod = "infoonly"
        elif self.gopherpstring[0] == "$":
            self.handlemethod = "gopherplusdir"

        try:
            handler = self.gethandler()
            self.log(handler)
            self.entry = handler.getentry()

            if self.handlemethod == "infoonly":
                self.wfile.write(b"+-2\r\n")
                self.wfile.write(
                    self.renderobjinfo(self.entry).encode(errors="surrogateescape")
                )
            else:
                handler.prepare()
                self.wfile.write(f"+{self.entry.getsize(-2)}\r\n".encode())
                if handler.isdir():
                    self.writedir(self.entry, handler.getdirlist())
                else:
                    handler.write(self.wfile)
        except GopherExceptions.FileNotFound as e:
            self.filenotfound(str(e))
        except IOError as e:
            GopherExceptions.log(e, self, None)
            self.filenotfound(e.args[1])
Exemplo n.º 5
0
    def handle(self):
        self.canhandlerequest()  # To get self.requestparts
        self.iconmapping = eval(
            self.config.get("protocols.http.HTTPProtocol", "iconmapping"))

        self.headerslurp()
        splitted = self.requestparts[1].split('?')
        self.selector = splitted[0]
        self.selector = urllib.parse.unquote(self.selector)

        self.selector = self.slashnormalize(self.selector)
        self.formvals = {}
        if len(splitted) >= 2:
            self.formvals = cgi.parse_qs(splitted[1])

        if 'searchrequest' in self.formvals:
            self.searchrequest = self.formvals['searchrequest'][0]

        icon = re.match('/PYGOPHERD-HTTPPROTO-ICONS/(.+)$', self.selector)
        if icon:
            iconname = icon.group(1)
            if iconname in icons:
                self.wfile.write(b"HTTP/1.0 200 OK\r\n")
                self.wfile.write(
                    b"Last-Modified: Fri, 14 Dec 2001 21:19:47 GMT\r\n")
                self.wfile.write(b"Content-Type: image/gif\r\n\r\n")
                if self.requestparts[0] == 'HEAD':
                    return
                self.wfile.write(binascii.unhexlify(icons[iconname]))
                return

        try:
            handler = self.gethandler()
            self.log(handler)
            self.entry = handler.getentry()
            handler.prepare()
            headers = "HTTP/1.0 200 OK\r\n"
            if self.entry.getmtime() != None:
                gmtime = time.gmtime(self.entry.getmtime())
                mtime = time.strftime("%a, %d %b %Y %H:%M:%S GMT", gmtime)
                headers += "Last-Modified: " + mtime + "\r\n"
            mimetype = self.entry.getmimetype()
            mimetype = self.adjustmimetype(mimetype)
            headers += "Content-Type: " + mimetype + "\r\n\r\n"
            self.wfile.write(headers.encode('ascii'))
            if self.requestparts[0] == 'GET':
                if handler.isdir():
                    self.writedir(self.entry, handler.getdirlist())
                else:
                    self.handlerwrite(self.wfile)
        except GopherExceptions.FileNotFound as e:
            self.filenotfound(e.errno)
        except IOError as e:
            GopherExceptions.log(e, self, None)
            self.filenotfound(e.errno)
Exemplo n.º 6
0
    def handle(self):
        request = self.rfile.readline()

        protohandler = ProtocolMultiplexer.getProtocol(
            request, self.server, self, self.rfile, self.wfile, self.server.config
        )
        try:
            protohandler.handle()
        except socket.error, e:
            if not (e[0] in [errno.ECONNRESET, errno.EPIPE]):
                traceback.print_exc()
            GopherExceptions.log(sys.exc_info()[1], protohandler, None)
Exemplo n.º 7
0
    def handle(self):
        request = self.rfile.readline()

        protohandler = \
                     ProtocolMultiplexer.getProtocol(request, \
                     self.server, self, self.rfile, self.wfile, self.server.config)
        try:
            protohandler.handle()
        except socket.error, e:
            if not (e[0] in [errno.ECONNRESET, errno.EPIPE]):
                traceback.print_exc()
            GopherExceptions.log(sys.exc_info()[1], protohandler, None)
Exemplo n.º 8
0
def getserverobject(config):
    # Pick up the server type from the config.

    servertype = eval("socketserver." + config.get("pygopherd", "servertype"))

    class MyServer(servertype):
        allow_reuse_address = 1

        def server_bind(self):
            """Override server_bind to store server name."""
            servertype.server_bind(self)

            # Set a timeout.
            if config.has_option('pygopherd', 'timeout'):
                mytimeout = struct.pack(
                    "ll", int(config.get('pygopherd', 'timeout')), 0)
                self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVTIMEO,
                                       mytimeout)
                self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDTIMEO,
                                       mytimeout)
                #self.socket.settimeout(int(config.get('pygopherd', 'timeout')))
            host, port = self.socket.getsockname()
            if config.has_option("pygopherd", "servername"):
                self.server_name = config.get("pygopherd", "servername")
            else:
                self.server_name = socket.getfqdn(host)
            if config.has_option("pygopherd", "advertisedport"):
                self.server_port = config.getint("pygopherd", "advertisedport")
            else:
                self.server_port = port

    # Instantiate a server.  Has to be done before the security so we can
    # get a privileged port if necessary.

    interface = ''
    if config.has_option('pygopherd', 'interface'):
        servername = config.get('pygopherd', 'interface')
        interface = config.get('pygopherd', 'interface')

    try:
        s = MyServer((interface, config.getint('pygopherd', 'port')),
                     GopherRequestHandler)
    except:
        GopherExceptions.log(sys.exc_info()[1], None, None)
        logger.log("Application startup NOT successful!")
        raise

    s.config = config
    return s
Exemplo n.º 9
0
 def handle(self):
     """Handles the request."""
     try:
         handler = self.gethandler()
         self.log(handler)
         self.entry = handler.getentry()
         handler.prepare()
         if handler.isdir():
             self.writedir(self.entry, handler.getdirlist())
         else:
             handler.write(self.wfile)
     except GopherExceptions.FileNotFound as e:
         self.filenotfound(str(e))
     except IOError as e:
         GopherExceptions.log(e, self, None)
         self.filenotfound(e[1])
Exemplo n.º 10
0
def getserverobject(config):
    # Pick up the server type from the config.

    servertype = eval("SocketServer." + config.get("pygopherd", "servertype"))

    class MyServer(servertype):
        allow_reuse_address = 1

        def server_bind(self):
            """Override server_bind to store server name."""
            servertype.server_bind(self)

            # Set a timeout.
            if config.has_option("pygopherd", "timeout"):
                mytimeout = struct.pack("ll", long(config.get("pygopherd", "timeout")), 0)
                self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVTIMEO, mytimeout)
                self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDTIMEO, mytimeout)
                # self.socket.settimeout(int(config.get('pygopherd', 'timeout')))
            host, port = self.socket.getsockname()
            if config.has_option("pygopherd", "servername"):
                self.server_name = config.get("pygopherd", "servername")
            else:
                self.server_name = socket.getfqdn(host)
            if config.has_option("pygopherd", "advertisedport"):
                self.server_port = config.getint("pygopherd", "advertisedport")
            else:
                self.server_port = port

    # Instantiate a server.  Has to be done before the security so we can
    # get a privileged port if necessary.

    interface = ""
    if config.has_option("pygopherd", "interface"):
        servername = config.get("pygopherd", "interface")
        interface = config.get("pygopherd", "interface")

    try:
        s = MyServer((interface, config.getint("pygopherd", "port")), GopherRequestHandler)
    except:
        GopherExceptions.log(sys.exc_info()[1], None, None)
        logger.log("Application startup NOT successful!")
        raise

    s.config = config
    return s
Exemplo n.º 11
0
    def handle(self):
        request = self.rfile.readline()

        protohandler = \
                     ProtocolMultiplexer.getProtocol(request, \
                     self.server, self, self.rfile, self.wfile, self.server.config)
        try:
            protohandler.handle()
        except socket.error as e:
            if not (e[0] in [errno.ECONNRESET, errno.EPIPE]):
                traceback.print_exc()
            GopherExceptions.log(sys.exc_info()[1], protohandler, None)
        except:
            if GopherExceptions.tracebacks:
                # Yes, this may be invalid.  Not much else we can do.
                #traceback.print_exc(file = self.wfile)
                traceback.print_exc()
            GopherExceptions.log(sys.exc_info()[1], protohandler, None)
Exemplo n.º 12
0
    def handle(self) -> None:
        request = self.rfile.readline().decode(errors="surrogateescape")

        protohandler = ProtocolMultiplexer.getProtocol(
            request, self.server, self, self.rfile, self.wfile, self.server.config
        )
        try:
            protohandler.handle()
        except IOError as e:
            if not (e.errno in [errno.ECONNRESET, errno.EPIPE]):
                traceback.print_exc()
            GopherExceptions.log(e, protohandler, None)
        except Exception as e:
            if GopherExceptions.tracebacks:
                # Yes, this may be invalid.  Not much else we can do.
                # traceback.print_exc(file = self.wfile)
                traceback.print_exc()
            GopherExceptions.log(e, protohandler, None)
Exemplo n.º 13
0
class GopherPlusProtocol(GopherProtocol):
    """Implementation of Gopher+ protocol.  Will handle Gopher+
    queries ONLY."""
    def canhandlerequest(self):
        """We can handle the request IF:
           * It has more than one parameter in the request list
           * The second parameter is ! or starts with + or $"""
        if len(self.requestlist) < 2:
            return 0
        if len(self.requestlist) == 2:
            self.gopherpstring = self.requestlist[1]
        elif len(self.requestlist) == 3:
            self.gopherpstring = self.requestlist[2]
            self.searchrequest = self.requestlist[1]
        else:
            return 0  # Too many params.

        return self.gopherpstring[0] == '+' or \
               self.gopherpstring == '!' or \
               self.gopherpstring[0] == '$'

    def handle(self):
        """Handle Gopher+ request."""
        self.handlemethod = None
        if self.gopherpstring[0] == '+':
            self.handlemethod = 'documentonly'
        elif self.gopherpstring == '!':
            self.handlemethod = 'infoonly'
        elif self.gopherpstring[0] == '$':
            self.handlemethod = 'gopherplusdir'

        try:
            handler = self.gethandler()
            self.log(handler)
            self.entry = handler.getentry()

            if self.handlemethod == 'infoonly':
                self.wfile.write("+-2\r\n")
                self.wfile.write(self.renderobjinfo(self.entry))
            else:
                handler.prepare()
                self.wfile.write("+" + str(self.entry.getsize(-2)) + "\r\n")
                if handler.isdir():
                    self.writedir(self.entry, handler.getdirlist())
                else:
                    handler.write(self.wfile)
        except GopherExceptions.FileNotFound, e:
            self.filenotfound(str(e))
        except IOError, e:
            GopherExceptions.log(e, self, None)
            self.filenotfound(e[1])
Exemplo n.º 14
0
    def handle(self):
        # Be overly permissive here and ignore most request validation like
        # checking for a strict <CR><LF> or denying requests over 1024 bytes.
        url_parts = urllib.parse.urlparse(self.request.strip())

        selector = url_parts.path
        searchrequest = url_parts.query

        if selector.startswith(self.query_prefix):
            self.handle_input(selector, searchrequest)
            return

        self.selector = urllib.parse.unquote(selector,
                                             errors="surrogateescape")
        self.searchrequest = urllib.parse.unquote(searchrequest,
                                                  errors="surrogateescape")

        try:
            handler = self.gethandler()
            self.log(handler)
            self.entry = handler.getentry()
            handler.prepare()
        except GopherExceptions.FileNotFound as e:
            self.write_status(51, str(e))
            return
        except IOError as e:
            GopherExceptions.log(e, self, None)
            self.write_status(51, e.args[1])
            return

        if handler.isdir():
            self.write_status(20, "text/gemini")
            self.writedir(self.entry, handler.getdirlist())
        else:
            mimetype = self.adjust_mimetype(self.entry.getmimetype())
            self.write_status(20, mimetype)
            self.handler.write(self.wfile)
Exemplo n.º 15
0
def get_server(
    config: ConfigParser,
    context: typing.Optional[ssl.SSLContext] = None
) -> pygopherd.server.BaseServer:

    # Pick up the server type from the config.
    server_class: typing.Type[pygopherd.server.BaseServer]

    server_type = config.get("pygopherd", "servertype")
    if server_type == "ForkingTCPServer":
        server_class = pygopherd.server.ForkingTCPServer
    elif server_type == "ThreadingTCPServer":
        server_class = pygopherd.server.ThreadingTCPServer
    else:
        raise RuntimeError(f"Invalid servertype option: {server_type}")

    # Instantiate a server.  Has to be done before the security so we can
    # get a privileged port if necessary.
    interface = ""
    if config.has_option("pygopherd", "interface"):
        interface = config.get("pygopherd", "interface")

    port = config.getint("pygopherd", "port")
    address = (interface, port)

    try:
        server = server_class(config,
                              address,
                              GopherRequestHandler,
                              context=context)
    except Exception as e:
        GopherExceptions.log(e, None, None)
        logger.log("Application startup NOT successful!")
        raise

    return server
Exemplo n.º 16
0
def getHandler(
    selector: str,
    searchrequest: str,
    protocol: BaseGopherProtocol,
    config: configparser.ConfigParser,
    handlerlist: typing.Optional[typing.List[BaseHandler]] = None,
    vfs: typing.Optional[VFS_Real] = None,
):
    """Called without handlerlist specified, uses the default as listed
    in config."""
    global handlers, rootpath
    init_default_handlers(config)

    if vfs is None:
        vfs = VFS_Real(config)

    if handlerlist is None:
        handlerlist = handlers

    typing.cast(handlers, typing.List[BaseHandler])
    typing.cast(rootpath, str)

    # SECURITY: assert that our absolute path is within the absolute
    # path of the site root.

    # if not os.path.abspath(rootpath + '/' + selector). \
    #   startswith(os.path.abspath(rootpath)):
    #    raise GopherExceptions.FileNotFound, \
    #          [selector, "Requested document is outside the server root",
    #           protocol]

    statresult = None
    try:
        statresult = vfs.stat(selector)
    except OSError:
        pass
    for handler in handlerlist:
        htry = handler(selector, searchrequest, protocol, config, statresult,
                       vfs)
        if htry.isrequestforme():
            return htry.gethandler()

    raise GopherExceptions.FileNotFound(selector, "no handler found", protocol)
Exemplo n.º 17
0
def getHandler(selector,
               searchrequest,
               protocol,
               config,
               handlerlist=None,
               vfs=None):
    """Called without handlerlist specified, uses the default as listed
    in config."""
    global handlers, rootpath

    if vfs == None:
        from pygopherd.handlers.base import VFS_Real
        vfs = VFS_Real(config)

    if not handlers:
        handlers = eval(config.get("handlers.HandlerMultiplexer", "handlers"))
        rootpath = config.get("pygopherd", "root")
    if handlerlist == None:
        handlerlist = handlers

    # TODO: assert that our absolute path is within the absolute
    # path of the site root.

    #if not os.path.abspath(rootpath + '/' + selector). \
    #   startswith(os.path.abspath(rootpath)):
    #    raise GopherExceptions.FileNotFound, \
    #          [selector, "Requested document is outside the server root",
    #           protocol]

    statresult = None
    try:
        statresult = vfs.stat(selector)
    except OSError:
        pass
    for handler in handlerlist:
        htry = handler(selector, searchrequest, protocol, config, statresult,
                       vfs)
        if htry.isrequestforme():
            return htry.gethandler()

    raise GopherExceptions.FileNotFound(
        [selector, "no handler found", protocol])
Exemplo n.º 18
0
 def testlog_basic(self):
     try:
         raise IOError, "foo"
     except IOError, e:
         GopherExceptions.log(e)
Exemplo n.º 19
0
class HTTPProtocol(BaseGopherProtocol):
    def canhandlerequest(self):
        self.requestparts = map(lambda arg: arg.strip(), self.request.split(" "))
        return len(self.requestparts) == 3 and \
               (self.requestparts[0] == 'GET' or self.requestparts[0] == 'HEAD') and \
               self.requestparts[2][0:5] == 'HTTP/'

    def headerslurp(self):
        if hasattr(self.requesthandler, 'pygopherd_http_slurped'):
            # Already slurped.
            self.httpheaders = self.requesthandler.pygopherd_http_slurped
            return
        # Slurp up remaining lines.
        self.httpheaders = {}
        while 1:
            line = self.rfile.readline()
            if not len(line):
                break
            line = line.strip()
            if not len(line):
                break
            splitline = line.split(':', 1)
            if len(splitline) == 2:
                self.httpheaders[splitline[0].lower()] = splitline[1]
        self.requesthandler.pygopherd_http_slurped = self.httpheaders

    def handle(self):
        self.canhandlerequest()         # To get self.requestparts
        self.iconmapping = eval(self.config.get("protocols.http.HTTPProtocol",
                                                "iconmapping"))

        self.headerslurp()
        splitted = self.requestparts[1].split('?')
        self.selector = splitted[0]
        self.selector = urllib.unquote(self.selector)

        self.selector = self.slashnormalize(self.selector)
        self.formvals = {}
        if len(splitted) >= 2:
            self.formvals = cgi.parse_qs(splitted[1])

        if self.formvals.has_key('searchrequest'):
            self.searchrequest = self.formvals['searchrequest'][0]

        icon = re.match('/PYGOPHERD-HTTPPROTO-ICONS/(.+)$', self.selector)
        if icon:
            iconname = icon.group(1)
            if icons.has_key(iconname):
                self.wfile.write("HTTP/1.0 200 OK\r\n")
                self.wfile.write("Last-Modified: Fri, 14 Dec 2001 21:19:47 GMT\r\n")
                self.wfile.write("Content-Type: image/gif\r\n\r\n")
                if self.requestparts[0] == 'HEAD':
                    return
                self.wfile.write(binascii.unhexlify(icons[iconname]))
                return

        try:
            handler = self.gethandler()
            self.log(handler)
            self.entry = handler.getentry()
            handler.prepare()
            self.wfile.write("HTTP/1.0 200 OK\r\n")
            if self.entry.getmtime() != None:
                gmtime = time.gmtime(self.entry.getmtime())
                mtime = time.strftime("%a, %d %b %Y %H:%M:%S GMT", gmtime)
                self.wfile.write("Last-Modified: " + mtime + "\r\n")
            mimetype = self.entry.getmimetype()
            mimetype = self.adjustmimetype(mimetype)
            self.wfile.write("Content-Type: " + mimetype + "\r\n\r\n")
            if self.requestparts[0] == 'GET':
                if handler.isdir():
                    self.writedir(self.entry, handler.getdirlist())
                else:
                    self.handlerwrite(self.wfile)
        except GopherExceptions.FileNotFound, e:
            self.filenotfound(str(e))
        except IOError, e:
            GopherExceptions.log(e, self, None)
            self.filenotfound(e[1])
Exemplo n.º 20
0
class BaseGopherProtocol:
    """Skeleton protocol -- includes commonly-used routines."""
    def __init__(self, request, server, requesthandler, rfile, wfile, config):
        """Parameters are:
        request -- the raw request string.

        server -- a SocketServer object.

        rfile -- input file.  The first line will already have been read.

        wfile -- output file.  Where the output should be sent.

        config -- a ConfigParser object."""

        self.request = request
        requestparts = map(lambda arg: arg.strip(), request.split("\t"))
        self.rfile = rfile
        self.wfile = wfile
        self.config = config
        self.server = server
        self.requesthandler = requesthandler
        self.requestlist = requestparts
        self.searchrequest = None
        self.handler = None

        selector = requestparts[0]
        selector = self.slashnormalize(selector)

        self.selector = selector

    def slashnormalize(self, selector):
        """Normalize slashes in the selector.  Make sure it starts
        with a slash and does not end with one.  If it is a root directory
        request, make sure it is exactly '/'.  Returns result."""
        if len(selector) and selector[-1] == '/':
            selector = selector[0:-1]
        if len(selector) == 0 or selector[0] != '/':
            selector = '/' + selector
        return selector

    def canhandlerequest(self):
        """Decides whether or not a given request is valid for this
        protocol.  Should be overridden by all subclasses."""
        return 0

    def log(self, handler):
        """Log a handled request."""
        logger.log("%s [%s/%s]: %s" % \
                   (self.requesthandler.client_address[0],
                    re.search("[^.]+$", str(self.__class__)).group(0),
                    re.search("[^.]+$", str(handler.__class__)).group(0),
                    self.selector))

    def handle(self):
        """Handles the request."""
        try:
            handler = self.gethandler()
            self.log(handler)
            self.entry = handler.getentry()
            handler.prepare()
            if handler.isdir():
                self.writedir(self.entry, handler.getdirlist())
            else:
                handler.write(self.wfile)
        except GopherExceptions.FileNotFound, e:
            self.filenotfound(str(e))
        except IOError, e:
            GopherExceptions.log(e, self, None)
            self.filenotfound(e[1])
Exemplo n.º 21
0
def init_exceptions(config: ConfigParser) -> None:
    GopherExceptions.init(config.getboolean("pygopherd", "tracebacks"))
Exemplo n.º 22
0
        protohandler = ProtocolMultiplexer.getProtocol(
            request, self.server, self, self.rfile, self.wfile, self.server.config
        )
        try:
            protohandler.handle()
        except socket.error, e:
            if not (e[0] in [errno.ECONNRESET, errno.EPIPE]):
                traceback.print_exc()
            GopherExceptions.log(sys.exc_info()[1], protohandler, None)
        except:
            if GopherExceptions.tracebacks:
                # Yes, this may be invalid.  Not much else we can do.
                # traceback.print_exc(file = self.wfile)
                traceback.print_exc()
            GopherExceptions.log(sys.exc_info()[1], protohandler, None)


def getserverobject(config):
    # Pick up the server type from the config.

    servertype = eval("SocketServer." + config.get("pygopherd", "servertype"))

    class MyServer(servertype):
        allow_reuse_address = 1

        def server_bind(self):
            """Override server_bind to store server name."""
            servertype.server_bind(self)

            # Set a timeout.
Exemplo n.º 23
0
def initexceptions(config):
    GopherExceptions.init(config.getboolean("pygopherd", "tracebacks"))
Exemplo n.º 24
0
def initexceptions(config):
    GopherExceptions.init(config.getboolean("pygopherd", "tracebacks"))
Exemplo n.º 25
0
        protohandler = \
                     ProtocolMultiplexer.getProtocol(request, \
                     self.server, self, self.rfile, self.wfile, self.server.config)
        try:
            protohandler.handle()
        except socket.error, e:
            if not (e[0] in [errno.ECONNRESET, errno.EPIPE]):
                traceback.print_exc()
            GopherExceptions.log(sys.exc_info()[1], protohandler, None)
        except:
            if GopherExceptions.tracebacks:
                # Yes, this may be invalid.  Not much else we can do.
                #traceback.print_exc(file = self.wfile)
                traceback.print_exc()
            GopherExceptions.log(sys.exc_info()[1], protohandler, None)

def getserverobject(config):
    # Pick up the server type from the config.

    servertype = eval("SocketServer." + config.get("pygopherd", "servertype"))

    class MyServer(servertype):
        allow_reuse_address = 1

        def server_bind(self):
            """Override server_bind to store server name."""
            servertype.server_bind(self)

            # Set a timeout.
            if config.has_option('pygopherd', 'timeout'):
Exemplo n.º 26
0
 def testlog_basic(self):
     try:
         raise IOError, "foo"
     except IOError, e:
         GopherExceptions.log(e)