# Python-based gopher server # Module: initialization # COPYRIGHT # # Copyright (C) 2002 John Goerzen # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; version 2 of the License. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # END OF COPYRIGHT # from ConfigParser import ConfigParser # Import lots of stuff so it's here before chrooting. import socket, os, sys, SocketServer, re, stat, os.path, UserDict, tempfile import time, atexit, errno, struct from pygopherd import handlers, protocols, GopherExceptions, logger, sighandlers from pygopherd.protocols import * from pygopherd.protocols import ProtocolMultiplexer from pygopherd.handlers import * from pygopherd.handlers import HandlerMultiplexer import pygopherd.fileext import mimetypes import traceback def initconffile(conffile): if not (os.path.isfile(conffile) and os.access(conffile, os.R_OK)): raise Exception, "Could NOT access config file %s\nPlease specify config file as a command-line argument\n" % conffile config = ConfigParser() config.read(conffile) return config def initlogger(config, conffile): logger.init(config) logger.log("Pygopherd starting, using configuration file %s" % conffile) def initexceptions(config): GopherExceptions.init(config.getboolean("pygopherd", "tracebacks")) def initmimetypes(config): mimetypesfiles = config.get("pygopherd", "mimetypes").split(":") mimetypesfiles = filter(lambda x: os.path.isfile(x) and os.access(x, os.R_OK), mimetypesfiles) if not mimetypesfiles: errmsg = "Could not find any mimetypes files; check mimetypes option in config." logger.log(errmsg) raise Exception, errmsg configencoding = eval(config.get("pygopherd", "encoding")) mimetypes.encodings_map.clear() for key, value in configencoding: mimetypes.encodings_map[key] = value mimetypes.init(mimetypesfiles) logger.log("mimetypes initialized with files: " + str(mimetypesfiles)) # Set up the inverse mapping file. pygopherd.fileext.init() class GopherRequestHandler(SocketServer.StreamRequestHandler): 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) 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'): 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 def initsecurity(config): idsetuid = None idsetgid = None if config.has_option("pygopherd", "setuid"): import pwd idsetuid = pwd.getpwnam(config.get("pygopherd", "setuid"))[2] if config.has_option("pygopherd", "setgid"): import grp idsetgid = grp.getgrnam(config.get("pygopherd", "setgid"))[2] if config.getboolean("pygopherd", "usechroot"): os.chroot(config.get("pygopherd", "root")) logger.log("Chrooted to " + config.get("pygopherd", "root")) config.set("pygopherd", "root", "/") if idsetuid != None or idsetgid != None: os.setgroups( () ) logger.log("Supplemental group list cleared.") if idsetgid != None: os.setregid(idsetgid, idsetgid) logger.log("Switched to group %d" % idsetgid) if idsetuid != None: os.setreuid(idsetuid, idsetuid) logger.log("Switched to uid %d" % idsetuid) def initconditionaldetach(config): if config.getboolean("pygopherd", "detach"): pid = os.fork() if pid: logger.log("Parent process detaching; child is %d" % pid) sys.exit(0) def initpidfile(config): if config.has_option("pygopherd", "pidfile"): pidfile = config.get("pygopherd", "pidfile") fd = open(pidfile, "wt") fd.write("%d\n" % os.getpid()) fd.close() def initpgrp(config): if 'setpgrp' in os.__dict__: os.setpgrp() pgrp = os.getpgrp() logger.log("Process group is %d" % pgrp) return pgrp else: logger.log("setpgrp() unavailable; not initializing process group") return None def initsighandlers(config, pgrp): sighandlers.setsighuphandler() sighandlers.setsigtermhandler(pgrp) def initeverything(conffile): config = initconffile(conffile) initlogger(config, conffile) initexceptions(config) initmimetypes(config) s = getserverobject(config) initconditionaldetach(config) initpidfile(config) pgrp = initpgrp(config) initsighandlers(config, pgrp) initsecurity(config) os.chdir(config.get("pygopherd", "root")) logger.log("Running. Root is '%s'" % config.get("pygopherd", "root")) return s