home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_270 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  13.9 KB  |  301 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __version__ = '0.3'
  5. __all__ = [
  6.     'HTTPServer',
  7.     'BaseHTTPRequestHandler']
  8. import sys
  9. import time
  10. import socket
  11. from warnings import filterwarnings, catch_warnings
  12. catch_warnings().__enter__()
  13.  
  14. try:
  15.     import mimetools
  16. finally:
  17.     pass
  18.  
  19. import SocketServer
  20. DEFAULT_ERROR_MESSAGE = '<head>\n<title>Error response</title>\n</head>\n<body>\n<h1>Error response</h1>\n<p>Error code %(code)d.\n<p>Message: %(message)s.\n<p>Error code explanation: %(code)s = %(explain)s.\n</body>\n'
  21. DEFAULT_ERROR_CONTENT_TYPE = 'text/html'
  22.  
  23. def _quote_html(html):
  24.     return html.replace('&', '&').replace('<', '<').replace('>', '>')
  25.  
  26.  
  27. class HTTPServer(SocketServer.TCPServer):
  28.     allow_reuse_address = 1
  29.     
  30.     def server_bind(self):
  31.         SocketServer.TCPServer.server_bind(self)
  32.         (host, port) = self.socket.getsockname()[:2]
  33.         self.server_name = socket.getfqdn(host)
  34.         self.server_port = port
  35.  
  36.  
  37.  
  38. class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler):
  39.     sys_version = 'Python/' + sys.version.split()[0]
  40.     server_version = 'BaseHTTP/' + __version__
  41.     default_request_version = 'HTTP/0.9'
  42.     
  43.     def parse_request(self):
  44.         self.command = None
  45.         self.request_version = version = self.default_request_version
  46.         self.close_connection = 1
  47.         requestline = self.raw_requestline
  48.         if requestline[-2:] == '\r\n':
  49.             requestline = requestline[:-2]
  50.         elif requestline[-1:] == '\n':
  51.             requestline = requestline[:-1]
  52.         
  53.         self.requestline = requestline
  54.         words = requestline.split()
  55.         if len(words) == 3:
  56.             (command, path, version) = words
  57.             if version[:5] != 'HTTP/':
  58.                 self.send_error(400, 'Bad request version (%r)' % version)
  59.                 return False
  60.             
  61.             try:
  62.                 base_version_number = version.split('/', 1)[1]
  63.                 version_number = base_version_number.split('.')
  64.                 if len(version_number) != 2:
  65.                     raise ValueError
  66.                 len(version_number) != 2
  67.                 version_number = (int(version_number[0]), int(version_number[1]))
  68.             except (ValueError, IndexError):
  69.                 version[:5] != 'HTTP/'
  70.                 version[:5] != 'HTTP/'
  71.                 self.send_error(400, 'Bad request version (%r)' % version)
  72.                 return False
  73.  
  74.             if version_number >= (1, 1) and self.protocol_version >= 'HTTP/1.1':
  75.                 self.close_connection = 0
  76.             
  77.             if version_number >= (2, 0):
  78.                 self.send_error(505, 'Invalid HTTP Version (%s)' % base_version_number)
  79.                 return False
  80.         elif len(words) == 2:
  81.             (command, path) = words
  82.             self.close_connection = 1
  83.             if command != 'GET':
  84.                 self.send_error(400, 'Bad HTTP/0.9 request type (%r)' % command)
  85.                 return False
  86.         elif not words:
  87.             return False
  88.         self.send_error(400, 'Bad request syntax (%r)' % requestline)
  89.         return False
  90.         self.command = command
  91.         self.path = path
  92.         self.request_version = version
  93.         self.headers = self.MessageClass(self.rfile, 0)
  94.         conntype = self.headers.get('Connection', '')
  95.         if conntype.lower() == 'close':
  96.             self.close_connection = 1
  97.         elif conntype.lower() == 'keep-alive' and self.protocol_version >= 'HTTP/1.1':
  98.             self.close_connection = 0
  99.         
  100.         return True
  101.  
  102.     
  103.     def handle_one_request(self):
  104.         self.raw_requestline = self.rfile.readline()
  105.         if not self.raw_requestline:
  106.             self.close_connection = 1
  107.             return None
  108.         if not self.parse_request():
  109.             return None
  110.         mname = 'do_' + self.command
  111.         if not hasattr(self, mname):
  112.             self.send_error(501, 'Unsupported method (%r)' % self.command)
  113.             return None
  114.         method = getattr(self, mname)
  115.         method()
  116.  
  117.     
  118.     def handle(self):
  119.         self.close_connection = 1
  120.         self.handle_one_request()
  121.         while not self.close_connection:
  122.             self.handle_one_request()
  123.  
  124.     
  125.     def send_error(self, code, message = None):
  126.         
  127.         try:
  128.             (short, long) = self.responses[code]
  129.         except KeyError:
  130.             (short, long) = ('???', '???')
  131.  
  132.         if message is None:
  133.             message = short
  134.         
  135.         explain = long
  136.         self.log_error('code %d, message %s', code, message)
  137.         content = self.error_message_format % {
  138.             'code': code,
  139.             'message': _quote_html(message),
  140.             'explain': explain }
  141.         self.send_response(code, message)
  142.         self.send_header('Content-Type', self.error_content_type)
  143.         self.send_header('Connection', 'close')
  144.         self.end_headers()
  145.         if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
  146.             self.wfile.write(content)
  147.         
  148.  
  149.     error_message_format = DEFAULT_ERROR_MESSAGE
  150.     error_content_type = DEFAULT_ERROR_CONTENT_TYPE
  151.     
  152.     def send_response(self, code, message = None):
  153.         self.log_request(code)
  154.         if message is None:
  155.             if code in self.responses:
  156.                 message = self.responses[code][0]
  157.             else:
  158.                 message = ''
  159.         
  160.         if self.request_version != 'HTTP/0.9':
  161.             self.wfile.write('%s %d %s\r\n' % (self.protocol_version, code, message))
  162.         
  163.         self.send_header('Server', self.version_string())
  164.         self.send_header('Date', self.date_time_string())
  165.  
  166.     
  167.     def send_header(self, keyword, value):
  168.         if self.request_version != 'HTTP/0.9':
  169.             self.wfile.write('%s: %s\r\n' % (keyword, value))
  170.         
  171.         if keyword.lower() == 'connection':
  172.             if value.lower() == 'close':
  173.                 self.close_connection = 1
  174.             elif value.lower() == 'keep-alive':
  175.                 self.close_connection = 0
  176.             
  177.         
  178.  
  179.     
  180.     def end_headers(self):
  181.         if self.request_version != 'HTTP/0.9':
  182.             self.wfile.write('\r\n')
  183.         
  184.  
  185.     
  186.     def log_request(self, code = '-', size = '-'):
  187.         self.log_message('"%s" %s %s', self.requestline, str(code), str(size))
  188.  
  189.     
  190.     def log_error(self, format, *args):
  191.         self.log_message(format, *args)
  192.  
  193.     
  194.     def log_message(self, format, *args):
  195.         sys.stderr.write('%s - - [%s] %s\n' % (self.address_string(), self.log_date_time_string(), format % args))
  196.  
  197.     
  198.     def version_string(self):
  199.         return self.server_version + ' ' + self.sys_version
  200.  
  201.     
  202.     def date_time_string(self, timestamp = None):
  203.         if timestamp is None:
  204.             timestamp = time.time()
  205.         
  206.         (year, month, day, hh, mm, ss, wd, y, z) = time.gmtime(timestamp)
  207.         s = '%s, %02d %3s %4d %02d:%02d:%02d GMT' % (self.weekdayname[wd], day, self.monthname[month], year, hh, mm, ss)
  208.         return s
  209.  
  210.     
  211.     def log_date_time_string(self):
  212.         now = time.time()
  213.         (year, month, day, hh, mm, ss, x, y, z) = time.localtime(now)
  214.         s = '%02d/%3s/%04d %02d:%02d:%02d' % (day, self.monthname[month], year, hh, mm, ss)
  215.         return s
  216.  
  217.     weekdayname = [
  218.         'Mon',
  219.         'Tue',
  220.         'Wed',
  221.         'Thu',
  222.         'Fri',
  223.         'Sat',
  224.         'Sun']
  225.     monthname = [
  226.         None,
  227.         'Jan',
  228.         'Feb',
  229.         'Mar',
  230.         'Apr',
  231.         'May',
  232.         'Jun',
  233.         'Jul',
  234.         'Aug',
  235.         'Sep',
  236.         'Oct',
  237.         'Nov',
  238.         'Dec']
  239.     
  240.     def address_string(self):
  241.         (host, port) = self.client_address[:2]
  242.         return socket.getfqdn(host)
  243.  
  244.     protocol_version = 'HTTP/1.0'
  245.     MessageClass = mimetools.Message
  246.     responses = {
  247.         100: ('Continue', 'Request received, please continue'),
  248.         101: ('Switching Protocols', 'Switching to new protocol; obey Upgrade header'),
  249.         200: ('OK', 'Request fulfilled, document follows'),
  250.         201: ('Created', 'Document created, URL follows'),
  251.         202: ('Accepted', 'Request accepted, processing continues off-line'),
  252.         203: ('Non-Authoritative Information', 'Request fulfilled from cache'),
  253.         204: ('No Content', 'Request fulfilled, nothing follows'),
  254.         205: ('Reset Content', 'Clear input form for further input.'),
  255.         206: ('Partial Content', 'Partial content follows.'),
  256.         300: ('Multiple Choices', 'Object has several resources -- see URI list'),
  257.         301: ('Moved Permanently', 'Object moved permanently -- see URI list'),
  258.         302: ('Found', 'Object moved temporarily -- see URI list'),
  259.         303: ('See Other', 'Object moved -- see Method and URL list'),
  260.         304: ('Not Modified', 'Document has not changed since given time'),
  261.         305: ('Use Proxy', 'You must use proxy specified in Location to access this resource.'),
  262.         307: ('Temporary Redirect', 'Object moved temporarily -- see URI list'),
  263.         400: ('Bad Request', 'Bad request syntax or unsupported method'),
  264.         401: ('Unauthorized', 'No permission -- see authorization schemes'),
  265.         402: ('Payment Required', 'No payment -- see charging schemes'),
  266.         403: ('Forbidden', 'Request forbidden -- authorization will not help'),
  267.         404: ('Not Found', 'Nothing matches the given URI'),
  268.         405: ('Method Not Allowed', 'Specified method is invalid for this server.'),
  269.         406: ('Not Acceptable', 'URI not available in preferred format.'),
  270.         407: ('Proxy Authentication Required', 'You must authenticate with this proxy before proceeding.'),
  271.         408: ('Request Timeout', 'Request timed out; try again later.'),
  272.         409: ('Conflict', 'Request conflict.'),
  273.         410: ('Gone', 'URI no longer exists and has been permanently removed.'),
  274.         411: ('Length Required', 'Client must specify Content-Length.'),
  275.         412: ('Precondition Failed', 'Precondition in headers is false.'),
  276.         413: ('Request Entity Too Large', 'Entity is too large.'),
  277.         414: ('Request-URI Too Long', 'URI is too long.'),
  278.         415: ('Unsupported Media Type', 'Entity body in unsupported format.'),
  279.         416: ('Requested Range Not Satisfiable', 'Cannot satisfy request range.'),
  280.         417: ('Expectation Failed', 'Expect condition could not be satisfied.'),
  281.         500: ('Internal Server Error', 'Server got itself in trouble'),
  282.         501: ('Not Implemented', 'Server does not support this operation'),
  283.         502: ('Bad Gateway', 'Invalid responses from another server/proxy.'),
  284.         503: ('Service Unavailable', 'The server cannot process the request due to a high load'),
  285.         504: ('Gateway Timeout', 'The gateway server did not receive a timely response'),
  286.         505: ('HTTP Version Not Supported', 'Cannot fulfill request.') }
  287.  
  288.  
  289. def test(HandlerClass = BaseHTTPRequestHandler, ServerClass = HTTPServer, protocol = 'HTTP/1.0'):
  290.     if sys.argv[1:]:
  291.         port = int(sys.argv[1])
  292.     else:
  293.         port = 8000
  294.     server_address = ('', port)
  295.     HandlerClass.protocol_version = protocol
  296.     httpd = ServerClass(server_address, HandlerClass)
  297.     sa = httpd.socket.getsockname()
  298.     print 'Serving HTTP on', sa[0], 'port', sa[1], '...'
  299.     httpd.serve_forever()
  300.  
  301.