code.grnet.gr Git - ganeti-local/blob - lib/http/__init__.py

   1 #
   2 #
   3
   4 # Copyright (C) 2007, 2008, 2010 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21 """HTTP module.
  22
  23 """
  24
  25 import logging
  26 import mimetools
  27 import OpenSSL
  28 import select
  29 import socket
  30 import errno
  31
  32 from cStringIO import StringIO
  33
  34 from ganeti import constants
  35 from ganeti import utils
  36
  37
  38 HTTP_GANETI_VERSION = "Ganeti %s" % constants.RELEASE_VERSION
  39
  40 HTTP_OK = 200
  41 HTTP_NO_CONTENT = 204
  42 HTTP_NOT_MODIFIED = 304
  43
  44 HTTP_0_9 = "HTTP/0.9"
  45 HTTP_1_0 = "HTTP/1.0"
  46 HTTP_1_1 = "HTTP/1.1"
  47
  48 HTTP_GET = "GET"
  49 HTTP_HEAD = "HEAD"
  50 HTTP_POST = "POST"
  51 HTTP_PUT = "PUT"
  52 HTTP_DELETE = "DELETE"
  53
  54 HTTP_ETAG = "ETag"
  55 HTTP_HOST = "Host"
  56 HTTP_SERVER = "Server"
  57 HTTP_DATE = "Date"
  58 HTTP_USER_AGENT = "User-Agent"
  59 HTTP_CONTENT_TYPE = "Content-Type"
  60 HTTP_CONTENT_LENGTH = "Content-Length"
  61 HTTP_CONNECTION = "Connection"
  62 HTTP_KEEP_ALIVE = "Keep-Alive"
  63 HTTP_WWW_AUTHENTICATE = "WWW-Authenticate"
  64 HTTP_AUTHORIZATION = "Authorization"
  65 HTTP_AUTHENTICATION_INFO = "Authentication-Info"
  66 HTTP_ALLOW = "Allow"
  67
  68 HTTP_APP_OCTET_STREAM = "application/octet-stream"
  69 HTTP_APP_JSON = "application/json"
  70
  71 _SSL_UNEXPECTED_EOF = "Unexpected EOF"
  72
  73 # Socket operations
  74 (SOCKOP_SEND,
  75  SOCKOP_RECV,
  76  SOCKOP_SHUTDOWN,
  77  SOCKOP_HANDSHAKE) = range(4)
  78
  79 # send/receive quantum
  80 SOCK_BUF_SIZE = 32768
  81
  82
  83 class HttpError(Exception):
  84   """Internal exception for HTTP errors.
  85
  86   This should only be used for internal error reporting.
  87
  88   """
  89
  90
  91 class HttpConnectionClosed(Exception):
  92   """Internal exception for a closed connection.
  93
  94   This should only be used for internal error reporting. Only use
  95   it if there's no other way to report this condition.
  96
  97   """
  98
  99
 100 class HttpSessionHandshakeUnexpectedEOF(HttpError):
 101   """Internal exception for errors during SSL handshake.
 102
 103   This should only be used for internal error reporting.
 104
 105   """
 106
 107
 108 class HttpSocketTimeout(Exception):
 109   """Internal exception for socket timeouts.
 110
 111   This should only be used for internal error reporting.
 112
 113   """
 114
 115
 116 class HttpException(Exception):
 117   code = None
 118   message = None
 119
 120   def __init__(self, message=None, headers=None):
 121     Exception.__init__(self)
 122     self.message = message
 123     self.headers = headers
 124
 125
 126 class HttpBadRequest(HttpException):
 127   """400 Bad Request
 128
 129   RFC2616, 10.4.1: The request could not be understood by the server
 130   due to malformed syntax. The client SHOULD NOT repeat the request
 131   without modifications.
 132
 133   """
 134   code = 400
 135
 136
 137 class HttpUnauthorized(HttpException):
 138   """401 Unauthorized
 139
 140   RFC2616, section 10.4.2: The request requires user
 141   authentication. The response MUST include a WWW-Authenticate header
 142   field (section 14.47) containing a challenge applicable to the
 143   requested resource.
 144
 145   """
 146   code = 401
 147
 148
 149 class HttpForbidden(HttpException):
 150   """403 Forbidden
 151
 152   RFC2616, 10.4.4: The server understood the request, but is refusing
 153   to fulfill it.  Authorization will not help and the request SHOULD
 154   NOT be repeated.
 155
 156   """
 157   code = 403
 158
 159
 160 class HttpNotFound(HttpException):
 161   """404 Not Found
 162
 163   RFC2616, 10.4.5: The server has not found anything matching the
 164   Request-URI.  No indication is given of whether the condition is
 165   temporary or permanent.
 166
 167   """
 168   code = 404
 169
 170
 171 class HttpMethodNotAllowed(HttpException):
 172   """405 Method Not Allowed
 173
 174   RFC2616, 10.4.6: The method specified in the Request-Line is not
 175   allowed for the resource identified by the Request-URI. The response
 176   MUST include an Allow header containing a list of valid methods for
 177   the requested resource.
 178
 179   """
 180   code = 405
 181
 182
 183 class HttpNotAcceptable(HttpException):
 184   """406 Not Acceptable
 185
 186   RFC2616, 10.4.7: The resource identified by the request is only capable of
 187   generating response entities which have content characteristics not
 188   acceptable according to the accept headers sent in the request.
 189
 190   """
 191   code = 406
 192
 193
 194 class HttpRequestTimeout(HttpException):
 195   """408 Request Timeout
 196
 197   RFC2616, 10.4.9: The client did not produce a request within the
 198   time that the server was prepared to wait. The client MAY repeat the
 199   request without modifications at any later time.
 200
 201   """
 202   code = 408
 203
 204
 205 class HttpConflict(HttpException):
 206   """409 Conflict
 207
 208   RFC2616, 10.4.10: The request could not be completed due to a
 209   conflict with the current state of the resource. This code is only
 210   allowed in situations where it is expected that the user might be
 211   able to resolve the conflict and resubmit the request.
 212
 213   """
 214   code = 409
 215
 216
 217 class HttpGone(HttpException):
 218   """410 Gone
 219
 220   RFC2616, 10.4.11: The requested resource is no longer available at
 221   the server and no forwarding address is known. This condition is
 222   expected to be considered permanent.
 223
 224   """
 225   code = 410
 226
 227
 228 class HttpLengthRequired(HttpException):
 229   """411 Length Required
 230
 231   RFC2616, 10.4.12: The server refuses to accept the request without a
 232   defined Content-Length. The client MAY repeat the request if it adds
 233   a valid Content-Length header field containing the length of the
 234   message-body in the request message.
 235
 236   """
 237   code = 411
 238
 239
 240 class HttpPreconditionFailed(HttpException):
 241   """412 Precondition Failed
 242
 243   RFC2616, 10.4.13: The precondition given in one or more of the
 244   request-header fields evaluated to false when it was tested on the
 245   server.
 246
 247   """
 248   code = 412
 249
 250
 251 class HttpUnsupportedMediaType(HttpException):
 252   """415 Unsupported Media Type
 253
 254   RFC2616, 10.4.16: The server is refusing to service the request because the
 255   entity of the request is in a format not supported by the requested resource
 256   for the requested method.
 257
 258   """
 259   code = 415
 260
 261
 262 class HttpInternalServerError(HttpException):
 263   """500 Internal Server Error
 264
 265   RFC2616, 10.5.1: The server encountered an unexpected condition
 266   which prevented it from fulfilling the request.
 267
 268   """
 269   code = 500
 270
 271
 272 class HttpNotImplemented(HttpException):
 273   """501 Not Implemented
 274
 275   RFC2616, 10.5.2: The server does not support the functionality
 276   required to fulfill the request.
 277
 278   """
 279   code = 501
 280
 281
 282 class HttpBadGateway(HttpException):
 283   """502 Bad Gateway
 284
 285   RFC2616, 10.5.3: The server, while acting as a gateway or proxy,
 286   received an invalid response from the upstream server it accessed in
 287   attempting to fulfill the request.
 288
 289   """
 290   code = 502
 291
 292
 293 class HttpServiceUnavailable(HttpException):
 294   """503 Service Unavailable
 295
 296   RFC2616, 10.5.4: The server is currently unable to handle the
 297   request due to a temporary overloading or maintenance of the server.
 298
 299   """
 300   code = 503
 301
 302
 303 class HttpGatewayTimeout(HttpException):
 304   """504 Gateway Timeout
 305
 306   RFC2616, 10.5.5: The server, while acting as a gateway or proxy, did
 307   not receive a timely response from the upstream server specified by
 308   the URI (e.g.  HTTP, FTP, LDAP) or some other auxiliary server
 309   (e.g. DNS) it needed to access in attempting to complete the
 310   request.
 311
 312   """
 313   code = 504
 314
 315
 316 class HttpVersionNotSupported(HttpException):
 317   """505 HTTP Version Not Supported
 318
 319   RFC2616, 10.5.6: The server does not support, or refuses to support,
 320   the HTTP protocol version that was used in the request message.
 321
 322   """
 323   code = 505
 324
 325
 326 def SocketOperation(sock, op, arg1, timeout):
 327   """Wrapper around socket functions.
 328
 329   This function abstracts error handling for socket operations, especially
 330   for the complicated interaction with OpenSSL.
 331
 332   @type sock: socket
 333   @param sock: Socket for the operation
 334   @type op: int
 335   @param op: Operation to execute (SOCKOP_* constants)
 336   @type arg1: any
 337   @param arg1: Parameter for function (if needed)
 338   @type timeout: None or float
 339   @param timeout: Timeout in seconds or None
 340   @return: Return value of socket function
 341
 342   """
 343   # TODO: event_poll/event_check/override
 344   if op in (SOCKOP_SEND, SOCKOP_HANDSHAKE):
 345     event_poll = select.POLLOUT
 346
 347   elif op == SOCKOP_RECV:
 348     event_poll = select.POLLIN
 349
 350   elif op == SOCKOP_SHUTDOWN:
 351     event_poll = None
 352
 353     # The timeout is only used when OpenSSL requests polling for a condition.
 354     # It is not advisable to have no timeout for shutdown.
 355     assert timeout
 356
 357   else:
 358     raise AssertionError("Invalid socket operation")
 359
 360   # Handshake is only supported by SSL sockets
 361   if (op == SOCKOP_HANDSHAKE and
 362       not isinstance(sock, OpenSSL.SSL.ConnectionType)):
 363     return
 364
 365   # No override by default
 366   event_override = 0
 367
 368   while True:
 369     # Poll only for certain operations and when asked for by an override
 370     if event_override or op in (SOCKOP_SEND, SOCKOP_RECV, SOCKOP_HANDSHAKE):
 371       if event_override:
 372         wait_for_event = event_override
 373       else:
 374         wait_for_event = event_poll
 375
 376       event = utils.WaitForFdCondition(sock, wait_for_event, timeout)
 377       if event is None:
 378         raise HttpSocketTimeout()
 379
 380       if event & (select.POLLNVAL | select.POLLHUP | select.POLLERR):
 381         # Let the socket functions handle these
 382         break
 383
 384       if not event & wait_for_event:
 385         continue
 386
 387     # Reset override
 388     event_override = 0
 389
 390     try:
 391       try:
 392         if op == SOCKOP_SEND:
 393           return sock.send(arg1)
 394
 395         elif op == SOCKOP_RECV:
 396           return sock.recv(arg1)
 397
 398         elif op == SOCKOP_SHUTDOWN:
 399           if isinstance(sock, OpenSSL.SSL.ConnectionType):
 400             # PyOpenSSL's shutdown() doesn't take arguments
 401             return sock.shutdown()
 402           else:
 403             return sock.shutdown(arg1)
 404
 405         elif op == SOCKOP_HANDSHAKE:
 406           return sock.do_handshake()
 407
 408       except OpenSSL.SSL.WantWriteError:
 409         # OpenSSL wants to write, poll for POLLOUT
 410         event_override = select.POLLOUT
 411         continue
 412
 413       except OpenSSL.SSL.WantReadError:
 414         # OpenSSL wants to read, poll for POLLIN
 415         event_override = select.POLLIN | select.POLLPRI
 416         continue
 417
 418       except OpenSSL.SSL.WantX509LookupError:
 419         continue
 420
 421       except OpenSSL.SSL.ZeroReturnError, err:
 422         # SSL Connection has been closed. In SSL 3.0 and TLS 1.0, this only
 423         # occurs if a closure alert has occurred in the protocol, i.e. the
 424         # connection has been closed cleanly. Note that this does not
 425         # necessarily mean that the transport layer (e.g. a socket) has been
 426         # closed.
 427         if op == SOCKOP_SEND:
 428           # Can happen during a renegotiation
 429           raise HttpConnectionClosed(err.args)
 430         elif op == SOCKOP_RECV:
 431           return ""
 432
 433         # SSL_shutdown shouldn't return SSL_ERROR_ZERO_RETURN
 434         raise socket.error(err.args)
 435
 436       except OpenSSL.SSL.SysCallError, err:
 437         if op == SOCKOP_SEND:
 438           # arg1 is the data when writing
 439           if err.args and err.args[0] == -1 and arg1 == "":
 440             # errors when writing empty strings are expected
 441             # and can be ignored
 442             return 0
 443
 444         if err.args == (-1, _SSL_UNEXPECTED_EOF):
 445           if op == SOCKOP_RECV:
 446             return ""
 447           elif op == SOCKOP_HANDSHAKE:
 448             # Can happen if peer disconnects directly after the connection is
 449             # opened.
 450             raise HttpSessionHandshakeUnexpectedEOF(err.args)
 451
 452         raise socket.error(err.args)
 453
 454       except OpenSSL.SSL.Error, err:
 455         raise socket.error(err.args)
 456
 457     except socket.error, err:
 458       if err.args and err.args[0] == errno.EAGAIN:
 459         # Ignore EAGAIN
 460         continue
 461
 462       raise
 463
 464
 465 def ShutdownConnection(sock, close_timeout, write_timeout, msgreader, force):
 466   """Closes the connection.
 467
 468   @type sock: socket
 469   @param sock: Socket to be shut down
 470   @type close_timeout: float
 471   @param close_timeout: How long to wait for the peer to close
 472       the connection
 473   @type write_timeout: float
 474   @param write_timeout: Write timeout for shutdown
 475   @type msgreader: http.HttpMessageReader
 476   @param msgreader: Request message reader, used to determine whether
 477       peer should close connection
 478   @type force: bool
 479   @param force: Whether to forcibly close the connection without
 480       waiting for peer
 481
 482   """
 483   #print msgreader.peer_will_close, force
 484   if msgreader and msgreader.peer_will_close and not force:
 485     # Wait for peer to close
 486     try:
 487       # Check whether it's actually closed
 488       if not SocketOperation(sock, SOCKOP_RECV, 1, close_timeout):
 489         return
 490     except (socket.error, HttpError, HttpSocketTimeout):
 491       # Ignore errors at this stage
 492       pass
 493
 494   # Close the connection from our side
 495   try:
 496     # We don't care about the return value, see NOTES in SSL_shutdown(3).
 497     SocketOperation(sock, SOCKOP_SHUTDOWN, socket.SHUT_RDWR,
 498                     write_timeout)
 499   except HttpSocketTimeout:
 500     raise HttpError("Timeout while shutting down connection")
 501   except socket.error, err:
 502     # Ignore ENOTCONN
 503     if not (err.args and err.args[0] == errno.ENOTCONN):
 504       raise HttpError("Error while shutting down connection: %s" % err)
 505
 506
 507 def Handshake(sock, write_timeout):
 508   """Shakes peer's hands.
 509
 510   @type sock: socket
 511   @param sock: Socket to be shut down
 512   @type write_timeout: float
 513   @param write_timeout: Write timeout for handshake
 514
 515   """
 516   try:
 517     return SocketOperation(sock, SOCKOP_HANDSHAKE, None, write_timeout)
 518   except HttpSocketTimeout:
 519     raise HttpError("Timeout during SSL handshake")
 520   except socket.error, err:
 521     raise HttpError("Error in SSL handshake: %s" % err)
 522
 523
 524 def InitSsl():
 525   """Initializes the SSL infrastructure.
 526
 527   This function is idempotent.
 528
 529   """
 530   if not OpenSSL.rand.status():
 531     raise EnvironmentError("OpenSSL could not collect enough entropy"
 532                            " for the PRNG")
 533
 534   # TODO: Maybe add some additional seeding for OpenSSL's PRNG
 535
 536
 537 class HttpSslParams(object):
 538   """Data class for SSL key and certificate.
 539
 540   """
 541   def __init__(self, ssl_key_path, ssl_cert_path):
 542     """Initializes this class.
 543
 544     @type ssl_key_path: string
 545     @param ssl_key_path: Path to file containing SSL key in PEM format
 546     @type ssl_cert_path: string
 547     @param ssl_cert_path: Path to file containing SSL certificate
 548         in PEM format
 549
 550     """
 551     self.ssl_key_pem = utils.ReadFile(ssl_key_path)
 552     self.ssl_cert_pem = utils.ReadFile(ssl_cert_path)
 553     self.ssl_cert_path = ssl_cert_path
 554
 555   def GetKey(self):
 556     return OpenSSL.crypto.load_privatekey(OpenSSL.crypto.FILETYPE_PEM,
 557                                           self.ssl_key_pem)
 558
 559   def GetCertificate(self):
 560     return OpenSSL.crypto.load_certificate(OpenSSL.crypto.FILETYPE_PEM,
 561                                            self.ssl_cert_pem)
 562
 563
 564 class HttpBase(object):
 565   """Base class for HTTP server and client.
 566
 567   """
 568   def __init__(self):
 569     self.using_ssl = None
 570     self._ssl_params = None
 571     self._ssl_key = None
 572     self._ssl_cert = None
 573
 574   def _CreateSocket(self, ssl_params, ssl_verify_peer, family):
 575     """Creates a TCP socket and initializes SSL if needed.
 576
 577     @type ssl_params: HttpSslParams
 578     @param ssl_params: SSL key and certificate
 579     @type ssl_verify_peer: bool
 580     @param ssl_verify_peer: Whether to require client certificate
 581         and compare it with our certificate
 582     @type family: int
 583     @param family: socket.AF_INET | socket.AF_INET6
 584
 585     """
 586     assert family in (socket.AF_INET, socket.AF_INET6)
 587
 588     self._ssl_params = ssl_params
 589     sock = socket.socket(family, socket.SOCK_STREAM)
 590
 591     # Should we enable SSL?
 592     self.using_ssl = ssl_params is not None
 593
 594     if not self.using_ssl:
 595       return sock
 596
 597     self._ssl_key = ssl_params.GetKey()
 598     self._ssl_cert = ssl_params.GetCertificate()
 599
 600     ctx = OpenSSL.SSL.Context(OpenSSL.SSL.SSLv23_METHOD)
 601     ctx.set_options(OpenSSL.SSL.OP_NO_SSLv2)
 602
 603     ciphers = self.GetSslCiphers()
 604     logging.debug("Setting SSL cipher string %s", ciphers)
 605     ctx.set_cipher_list(ciphers)
 606
 607     ctx.use_privatekey(self._ssl_key)
 608     ctx.use_certificate(self._ssl_cert)
 609     ctx.check_privatekey()
 610
 611     if ssl_verify_peer:
 612       ctx.set_verify(OpenSSL.SSL.VERIFY_PEER |
 613                      OpenSSL.SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
 614                      self._SSLVerifyCallback)
 615
 616       # Also add our certificate as a trusted CA to be sent to the client.
 617       # This is required at least for GnuTLS clients to work.
 618       try:
 619         # This will fail for PyOpenssl versions before 0.10
 620         ctx.add_client_ca(self._ssl_cert)
 621       except AttributeError:
 622         # Fall back to letting OpenSSL read the certificate file directly.
 623         ctx.load_client_ca(ssl_params.ssl_cert_path)
 624
 625     return OpenSSL.SSL.Connection(ctx, sock)
 626
 627   def GetSslCiphers(self): # pylint: disable=R0201
 628     """Returns the ciphers string for SSL.
 629
 630     """
 631     return constants.OPENSSL_CIPHERS
 632
 633   def _SSLVerifyCallback(self, conn, cert, errnum, errdepth, ok):
 634     """Verify the certificate provided by the peer
 635
 636     We only compare fingerprints. The client must use the same certificate as
 637     we do on our side.
 638
 639     """
 640     # some parameters are unused, but this is the API
 641     # pylint: disable=W0613
 642     assert self._ssl_params, "SSL not initialized"
 643
 644     return (self._ssl_cert.digest("sha1") == cert.digest("sha1") and
 645             self._ssl_cert.digest("md5") == cert.digest("md5"))
 646
 647
 648 class HttpMessage(object):
 649   """Data structure for HTTP message.
 650
 651   """
 652   def __init__(self):
 653     self.start_line = None
 654     self.headers = None
 655     self.body = None
 656
 657
 658 class HttpClientToServerStartLine(object):
 659   """Data structure for HTTP request start line.
 660
 661   """
 662   def __init__(self, method, path, version):
 663     self.method = method
 664     self.path = path
 665     self.version = version
 666
 667   def __str__(self):
 668     return "%s %s %s" % (self.method, self.path, self.version)
 669
 670
 671 class HttpServerToClientStartLine(object):
 672   """Data structure for HTTP response start line.
 673
 674   """
 675   def __init__(self, version, code, reason):
 676     self.version = version
 677     self.code = code
 678     self.reason = reason
 679
 680   def __str__(self):
 681     return "%s %s %s" % (self.version, self.code, self.reason)
 682
 683
 684 class HttpMessageWriter(object):
 685   """Writes an HTTP message to a socket.
 686
 687   """
 688   def __init__(self, sock, msg, write_timeout):
 689     """Initializes this class and writes an HTTP message to a socket.
 690
 691     @type sock: socket
 692     @param sock: Socket to be written to
 693     @type msg: http.HttpMessage
 694     @param msg: HTTP message to be written
 695     @type write_timeout: float
 696     @param write_timeout: Write timeout for socket
 697
 698     """
 699     self._msg = msg
 700
 701     self._PrepareMessage()
 702
 703     buf = self._FormatMessage()
 704
 705     pos = 0
 706     end = len(buf)
 707     while pos < end:
 708       # Send only SOCK_BUF_SIZE bytes at a time
 709       data = buf[pos:(pos + SOCK_BUF_SIZE)]
 710
 711       sent = SocketOperation(sock, SOCKOP_SEND, data, write_timeout)
 712
 713       # Remove sent bytes
 714       pos += sent
 715
 716     assert pos == end, "Message wasn't sent completely"
 717
 718   def _PrepareMessage(self):
 719     """Prepares the HTTP message by setting mandatory headers.
 720
 721     """
 722     # RFC2616, section 4.3: "The presence of a message-body in a request is
 723     # signaled by the inclusion of a Content-Length or Transfer-Encoding header
 724     # field in the request's message-headers."
 725     if self._msg.body:
 726       self._msg.headers[HTTP_CONTENT_LENGTH] = len(self._msg.body)
 727
 728   def _FormatMessage(self):
 729     """Serializes the HTTP message into a string.
 730
 731     """
 732     buf = StringIO()
 733
 734     # Add start line
 735     buf.write(str(self._msg.start_line))
 736     buf.write("\r\n")
 737
 738     # Add headers
 739     if self._msg.start_line.version != HTTP_0_9:
 740       for name, value in self._msg.headers.iteritems():
 741         buf.write("%s: %s\r\n" % (name, value))
 742
 743     buf.write("\r\n")
 744
 745     # Add message body if needed
 746     if self.HasMessageBody():
 747       buf.write(self._msg.body)
 748
 749     elif self._msg.body:
 750       logging.warning("Ignoring message body")
 751
 752     return buf.getvalue()
 753
 754   def HasMessageBody(self):
 755     """Checks whether the HTTP message contains a body.
 756
 757     Can be overridden by subclasses.
 758
 759     """
 760     return bool(self._msg.body)
 761
 762
 763 class HttpMessageReader(object):
 764   """Reads HTTP message from socket.
 765
 766   """
 767   # Length limits
 768   START_LINE_LENGTH_MAX = None
 769   HEADER_LENGTH_MAX = None
 770
 771   # Parser state machine
 772   PS_START_LINE = "start-line"
 773   PS_HEADERS = "headers"
 774   PS_BODY = "entity-body"
 775   PS_COMPLETE = "complete"
 776
 777   def __init__(self, sock, msg, read_timeout):
 778     """Reads an HTTP message from a socket.
 779
 780     @type sock: socket
 781     @param sock: Socket to be read from
 782     @type msg: http.HttpMessage
 783     @param msg: Object for the read message
 784     @type read_timeout: float
 785     @param read_timeout: Read timeout for socket
 786
 787     """
 788     self.sock = sock
 789     self.msg = msg
 790
 791     self.start_line_buffer = None
 792     self.header_buffer = StringIO()
 793     self.body_buffer = StringIO()
 794     self.parser_status = self.PS_START_LINE
 795     self.content_length = None
 796     self.peer_will_close = None
 797
 798     buf = ""
 799     eof = False
 800     while self.parser_status != self.PS_COMPLETE:
 801       # TODO: Don't read more than necessary (Content-Length), otherwise
 802       # data might be lost and/or an error could occur
 803       data = SocketOperation(sock, SOCKOP_RECV, SOCK_BUF_SIZE, read_timeout)
 804
 805       if data:
 806         buf += data
 807       else:
 808         eof = True
 809
 810       # Do some parsing and error checking while more data arrives
 811       buf = self._ContinueParsing(buf, eof)
 812
 813       # Must be done only after the buffer has been evaluated
 814       # TODO: Content-Length < len(data read) and connection closed
 815       if (eof and
 816           self.parser_status in (self.PS_START_LINE,
 817                                  self.PS_HEADERS)):
 818         raise HttpError("Connection closed prematurely")
 819
 820     # Parse rest
 821     buf = self._ContinueParsing(buf, True)
 822
 823     assert self.parser_status == self.PS_COMPLETE
 824     assert not buf, "Parser didn't read full response"
 825
 826     # Body is complete
 827     msg.body = self.body_buffer.getvalue()
 828
 829   def _ContinueParsing(self, buf, eof):
 830     """Main function for HTTP message state machine.
 831
 832     @type buf: string
 833     @param buf: Receive buffer
 834     @type eof: bool
 835     @param eof: Whether we've reached EOF on the socket
 836     @rtype: string
 837     @return: Updated receive buffer
 838
 839     """
 840     # TODO: Use offset instead of slicing when possible
 841     if self.parser_status == self.PS_START_LINE:
 842       # Expect start line
 843       while True:
 844         idx = buf.find("\r\n")
 845
 846         # RFC2616, section 4.1: "In the interest of robustness, servers SHOULD
 847         # ignore any empty line(s) received where a Request-Line is expected.
 848         # In other words, if the server is reading the protocol stream at the
 849         # beginning of a message and receives a CRLF first, it should ignore
 850         # the CRLF."
 851         if idx == 0:
 852           # TODO: Limit number of CRLFs/empty lines for safety?
 853           buf = buf[2:]
 854           continue
 855
 856         if idx > 0:
 857           self.start_line_buffer = buf[:idx]
 858
 859           self._CheckStartLineLength(len(self.start_line_buffer))
 860
 861           # Remove status line, including CRLF
 862           buf = buf[idx + 2:]
 863
 864           self.msg.start_line = self.ParseStartLine(self.start_line_buffer)
 865
 866           self.parser_status = self.PS_HEADERS
 867         else:
 868           # Check whether incoming data is getting too large, otherwise we just
 869           # fill our read buffer.
 870           self._CheckStartLineLength(len(buf))
 871
 872         break
 873
 874     # TODO: Handle messages without headers
 875     if self.parser_status == self.PS_HEADERS:
 876       # Wait for header end
 877       idx = buf.find("\r\n\r\n")
 878       if idx >= 0:
 879         self.header_buffer.write(buf[:idx + 2])
 880
 881         self._CheckHeaderLength(self.header_buffer.tell())
 882
 883         # Remove headers, including CRLF
 884         buf = buf[idx + 4:]
 885
 886         self._ParseHeaders()
 887
 888         self.parser_status = self.PS_BODY
 889       else:
 890         # Check whether incoming data is getting too large, otherwise we just
 891         # fill our read buffer.
 892         self._CheckHeaderLength(len(buf))
 893
 894     if self.parser_status == self.PS_BODY:
 895       # TODO: Implement max size for body_buffer
 896       self.body_buffer.write(buf)
 897       buf = ""
 898
 899       # Check whether we've read everything
 900       #
 901       # RFC2616, section 4.4: "When a message-body is included with a message,
 902       # the transfer-length of that body is determined by one of the following
 903       # [...] 5. By the server closing the connection. (Closing the connection
 904       # cannot be used to indicate the end of a request body, since that would
 905       # leave no possibility for the server to send back a response.)"
 906       #
 907       # TODO: Error when buffer length > Content-Length header
 908       if (eof or
 909           self.content_length is None or
 910           (self.content_length is not None and
 911            self.body_buffer.tell() >= self.content_length)):
 912         self.parser_status = self.PS_COMPLETE
 913
 914     return buf
 915
 916   def _CheckStartLineLength(self, length):
 917     """Limits the start line buffer size.
 918
 919     @type length: int
 920     @param length: Buffer size
 921
 922     """
 923     if (self.START_LINE_LENGTH_MAX is not None and
 924         length > self.START_LINE_LENGTH_MAX):
 925       raise HttpError("Start line longer than %d chars" %
 926                        self.START_LINE_LENGTH_MAX)
 927
 928   def _CheckHeaderLength(self, length):
 929     """Limits the header buffer size.
 930
 931     @type length: int
 932     @param length: Buffer size
 933
 934     """
 935     if (self.HEADER_LENGTH_MAX is not None and
 936         length > self.HEADER_LENGTH_MAX):
 937       raise HttpError("Headers longer than %d chars" % self.HEADER_LENGTH_MAX)
 938
 939   def ParseStartLine(self, start_line):
 940     """Parses the start line of a message.
 941
 942     Must be overridden by subclass.
 943
 944     @type start_line: string
 945     @param start_line: Start line string
 946
 947     """
 948     raise NotImplementedError()
 949
 950   def _WillPeerCloseConnection(self):
 951     """Evaluate whether peer will close the connection.
 952
 953     @rtype: bool
 954     @return: Whether peer will close the connection
 955
 956     """
 957     # RFC2616, section 14.10: "HTTP/1.1 defines the "close" connection option
 958     # for the sender to signal that the connection will be closed after
 959     # completion of the response. For example,
 960     #
 961     #        Connection: close
 962     #
 963     # in either the request or the response header fields indicates that the
 964     # connection SHOULD NOT be considered `persistent' (section 8.1) after the
 965     # current request/response is complete."
 966
 967     hdr_connection = self.msg.headers.get(HTTP_CONNECTION, None)
 968     if hdr_connection:
 969       hdr_connection = hdr_connection.lower()
 970
 971     # An HTTP/1.1 server is assumed to stay open unless explicitly closed.
 972     if self.msg.start_line.version == HTTP_1_1:
 973       return (hdr_connection and "close" in hdr_connection)
 974
 975     # Some HTTP/1.0 implementations have support for persistent connections,
 976     # using rules different than HTTP/1.1.
 977
 978     # For older HTTP, Keep-Alive indicates persistent connection.
 979     if self.msg.headers.get(HTTP_KEEP_ALIVE):
 980       return False
 981
 982     # At least Akamai returns a "Connection: Keep-Alive" header, which was
 983     # supposed to be sent by the client.
 984     if hdr_connection and "keep-alive" in hdr_connection:
 985       return False
 986
 987     return True
 988
 989   def _ParseHeaders(self):
 990     """Parses the headers.
 991
 992     This function also adjusts internal variables based on header values.
 993
 994     RFC2616, section 4.3: The presence of a message-body in a request is
 995     signaled by the inclusion of a Content-Length or Transfer-Encoding header
 996     field in the request's message-headers.
 997
 998     """
 999     # Parse headers
1000     self.header_buffer.seek(0, 0)
1001     self.msg.headers = mimetools.Message(self.header_buffer, 0)
1002
1003     self.peer_will_close = self._WillPeerCloseConnection()
1004
1005     # Do we have a Content-Length header?
1006     hdr_content_length = self.msg.headers.get(HTTP_CONTENT_LENGTH, None)
1007     if hdr_content_length:
1008       try:
1009         self.content_length = int(hdr_content_length)
1010       except (TypeError, ValueError):
1011         self.content_length = None
1012       if self.content_length is not None and self.content_length < 0:
1013         self.content_length = None
1014
1015     # if the connection remains open and a content-length was not provided,
1016     # then assume that the connection WILL close.
1017     if self.content_length is None:
1018       self.peer_will_close = True