Lib/CGIHTTPServer.py

   1 """CGI-savvy HTTP Server.
   2
   3 This module builds on SimpleHTTPServer by implementing GET and POST
   4 requests to cgi-bin scripts.
   5
   6 If the os.fork() function is not present, this module will not work;
   7 SystemError will be raised instead.
   8
   9 """
  10
  11
  12 __version__ = "0.3"
  13
  14
  15 import os
  16 import string
  17 import urllib
  18 import BaseHTTPServer
  19 import SimpleHTTPServer
  20
  21
  22 try:
  23     os.fork
  24 except AttributeError:
  25     raise SystemError, __name__ + " requires os.fork()"
  26
  27
  28 class CGIHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
  29
  30     """Complete HTTP server with GET, HEAD and POST commands.
  31
  32     GET and HEAD also support running CGI scripts.
  33
  34     The POST command is *only* implemented for CGI scripts.
  35
  36     """
  37
  38     def do_POST(self):
  39         """Serve a POST request.
  40
  41         This is only implemented for CGI scripts.
  42
  43         """
  44
  45         if self.is_cgi():
  46             self.run_cgi()
  47         else:
  48             self.send_error(501, "Can only POST to CGI scripts")
  49
  50     def send_head(self):
  51         """Version of send_head that support CGI scripts"""
  52         if self.is_cgi():
  53             return self.run_cgi()
  54         else:
  55             return SimpleHTTPServer.SimpleHTTPRequestHandler.send_head(self)
  56
  57     def is_cgi(self):
  58         """test whether PATH corresponds to a CGI script.
  59
  60         Return a tuple (dir, rest) if PATH requires running a
  61         CGI script, None if not.  Note that rest begins with a
  62         slash if it is not empty.
  63
  64         The default implementation tests whether the path
  65         begins with one of the strings in the list
  66         self.cgi_directories (and the next character is a '/'
  67         or the end of the string).
  68
  69         """
  70
  71         path = self.path
  72
  73         for x in self.cgi_directories:
  74             i = len(x)
  75             if path[:i] == x and (not path[i:] or path[i] == '/'):
  76                 self.cgi_info = path[:i], path[i+1:]
  77                 return 1
  78         return 0
  79
  80     cgi_directories = ['/cgi-bin', '/htbin']
  81
  82     def run_cgi(self):
  83         """Execute a CGI script."""
  84         dir, rest = self.cgi_info
  85         i = string.rfind(rest, '?')
  86         if i >= 0:
  87             rest, query = rest[:i], rest[i+1:]
  88         else:
  89             query = ''
  90         i = string.find(rest, '/')
  91         if i >= 0:
  92             script, rest = rest[:i], rest[i:]
  93         else:
  94             script, rest = rest, ''
  95         scriptname = dir + '/' + script
  96         scriptfile = self.translate_path(scriptname)
  97         if not os.path.exists(scriptfile):
  98             self.send_error(404, "No such CGI script (%s)" % `scriptname`)
  99             return
 100         if not os.path.isfile(scriptfile):
 101             self.send_error(403, "CGI script is not a plain file (%s)" %
 102                             `scriptname`)
 103             return
 104         if not executable(scriptfile):
 105             self.send_error(403, "CGI script is not executable (%s)" %
 106                             `scriptname`)
 107             return
 108         nobody = nobody_uid()
 109         self.send_response(200, "Script output follows")
 110         self.wfile.flush() # Always flush before forking
 111         pid = os.fork()
 112         if pid != 0:
 113             # Parent
 114             pid, sts = os.waitpid(pid, 0)
 115             if sts:
 116                 self.log_error("CGI script exit status x%x" % sts)
 117             return
 118         # Child
 119         try:
 120             # Reference: http://hoohoo.ncsa.uiuc.edu/cgi/env.html
 121             # XXX Much of the following could be prepared ahead of time!
 122             env = {}
 123             env['SERVER_SOFTWARE'] = self.version_string()
 124             env['SERVER_NAME'] = self.server.server_name
 125             env['GATEWAY_INTERFACE'] = 'CGI/1.1'
 126             env['SERVER_PROTOCOL'] = self.protocol_version
 127             env['SERVER_PORT'] = str(self.server.server_port)
 128             env['REQUEST_METHOD'] = self.command
 129             uqrest = urllib.unquote(rest)
 130             env['PATH_INFO'] = uqrest
 131             env['PATH_TRANSLATED'] = self.translate_path(uqrest)
 132             env['SCRIPT_NAME'] = scriptname
 133             if query:
 134                 env['QUERY_STRING'] = query
 135             host = self.address_string()
 136             if host != self.client_address[0]:
 137                 env['REMOTE_HOST'] = host
 138             env['REMOTE_ADDR'] = self.client_address[0]
 139             # AUTH_TYPE
 140             # REMOTE_USER
 141             # REMOTE_IDENT
 142             if self.headers.typeheader is None:
 143                 env['CONTENT_TYPE'] = self.headers.type
 144             else:
 145                 env['CONTENT_TYPE'] = self.headers.typeheader
 146             length = self.headers.getheader('content-length')
 147             if length:
 148                 env['CONTENT_LENGTH'] = length
 149             accept = []
 150             for line in self.headers.getallmatchingheaders('accept'):
 151                 if line[:1] in string.whitespace:
 152                     accept.append(string.strip(line))
 153                 else:
 154                     accept = accept + string.split(line[7:], ',')
 155             env['HTTP_ACCEPT'] = string.joinfields(accept, ',')
 156             ua = self.headers.getheader('user-agent')
 157             if ua:
 158                 env['HTTP_USER_AGENT'] = ua
 159             co = filter(None, self.headers.getheaders('cookie'))
 160             if co:
 161                 env['HTTP_COOKIE'] = string.join(co, ', ')
 162             # XXX Other HTTP_* headers
 163             decoded_query = string.replace(query, '+', ' ')
 164             try:
 165                 os.setuid(nobody)
 166             except os.error:
 167                 pass
 168             os.dup2(self.rfile.fileno(), 0)
 169             os.dup2(self.wfile.fileno(), 1)
 170             print scriptfile, script, decoded_query
 171             os.execve(scriptfile,
 172                       [script, decoded_query],
 173                       env)
 174         except:
 175             self.server.handle_error(self.request, self.client_address)
 176             os._exit(127)
 177
 178
 179 nobody = None
 180
 181 def nobody_uid():
 182     """Internal routine to get nobody's uid"""
 183     global nobody
 184     if nobody:
 185         return nobody
 186     import pwd
 187     try:
 188         nobody = pwd.getpwnam('nobody')[2]
 189     except KeyError:
 190         nobody = 1 + max(map(lambda x: x[2], pwd.getpwall()))
 191     return nobody
 192
 193
 194 def executable(path):
 195     """Test for executable file."""
 196     try:
 197         st = os.stat(path)
 198     except os.error:
 199         return 0
 200     return st[0] & 0111 != 0
 201
 202
 203 def test(HandlerClass = CGIHTTPRequestHandler,
 204          ServerClass = BaseHTTPServer.HTTPServer):
 205     SimpleHTTPServer.test(HandlerClass, ServerClass)
 206
 207
 208 if __name__ == '__main__':
 209     test()