diff --git a/Doc/howto/urllib2.rst b/Doc/howto/urllib2.rst
index 4ba3932..0940d82 100644
--- a/Doc/howto/urllib2.rst
+++ b/Doc/howto/urllib2.rst
@@ -230,7 +230,7 @@
 codes in the 100-299 range indicate success, you will usually only see error
 codes in the 400-599 range.
 
-``BaseHTTPServer.BaseHTTPRequestHandler.responses`` is a useful dictionary of
+:attr:`http.server.BaseHTTPRequestHandler.responses` is a useful dictionary of
 response codes in that shows all the response codes used by RFC 2616. The
 dictionary is reproduced here for convenience ::
 
@@ -385,7 +385,7 @@
 
 **info** - this returns a dictionary-like object that describes the page
 fetched, particularly the headers sent by the server. It is currently an
-``httplib.HTTPMessage`` instance.
+``http.client.HTTPMessage`` instance.
 
 Typical headers include 'Content-length', 'Content-type', and so on. See the
 `Quick Reference to HTTP Headers <http://www.cs.tut.fi/~jkorpela/http.html>`_
@@ -526,13 +526,13 @@
 ==================
 
 The Python support for fetching resources from the web is layered. urllib2 uses
-the httplib library, which in turn uses the socket library.
+the http.client library, which in turn uses the socket library.
 
 As of Python 2.3 you can specify how long a socket should wait for a response
 before timing out. This can be useful in applications which have to fetch web
 pages. By default the socket module has *no timeout* and can hang. Currently,
-the socket timeout is not exposed at the httplib or urllib2 levels.  However,
-you can set the default timeout globally for all sockets using ::
+the socket timeout is not exposed at the http.client or urllib2 levels.
+However, you can set the default timeout globally for all sockets using ::
 
     import socket
     import urllib2
diff --git a/Doc/library/basehttpserver.rst b/Doc/library/basehttpserver.rst
deleted file mode 100644
index 52a3866..0000000
--- a/Doc/library/basehttpserver.rst
+++ /dev/null
@@ -1,265 +0,0 @@
-
-:mod:`BaseHTTPServer` --- Basic HTTP server
-===========================================
-
-.. module:: BaseHTTPServer
-   :synopsis: Basic HTTP server (base class for SimpleHTTPServer and CGIHTTPServer).
-
-
-.. index::
-   pair: WWW; server
-   pair: HTTP; protocol
-   single: URL
-   single: httpd
-
-.. index::
-   module: SimpleHTTPServer
-   module: CGIHTTPServer
-
-This module defines two classes for implementing HTTP servers (Web servers).
-Usually, this module isn't used directly, but is used as a basis for building
-functioning Web servers. See the :mod:`SimpleHTTPServer` and
-:mod:`CGIHTTPServer` modules.
-
-The first class, :class:`HTTPServer`, is a :class:`socketserver.TCPServer`
-subclass.  It creates and listens at the HTTP socket, dispatching the requests
-to a handler.  Code to create and run the server looks like this::
-
-   def run(server_class=BaseHTTPServer.HTTPServer,
-           handler_class=BaseHTTPServer.BaseHTTPRequestHandler):
-       server_address = ('', 8000)
-       httpd = server_class(server_address, handler_class)
-       httpd.serve_forever()
-
-
-.. class:: HTTPServer(server_address, RequestHandlerClass)
-
-   This class builds on the :class:`TCPServer` class by storing the server
-   address as instance variables named :attr:`server_name` and
-   :attr:`server_port`. The server is accessible by the handler, typically
-   through the handler's :attr:`server` instance variable.
-
-
-.. class:: BaseHTTPRequestHandler(request, client_address, server)
-
-   This class is used to handle the HTTP requests that arrive at the server. By
-   itself, it cannot respond to any actual HTTP requests; it must be subclassed
-   to handle each request method (e.g. GET or
-   POST). :class:`BaseHTTPRequestHandler` provides a number of class and
-   instance variables, and methods for use by subclasses.
-
-   The handler will parse the request and the headers, then call a method
-   specific to the request type. The method name is constructed from the
-   request. For example, for the request method ``SPAM``, the :meth:`do_SPAM`
-   method will be called with no arguments. All of the relevant information is
-   stored in instance variables of the handler.  Subclasses should not need to
-   override or extend the :meth:`__init__` method.
-
-   :class:`BaseHTTPRequestHandler` has the following instance variables:
-
-
-   .. attribute:: client_address
-
-      Contains a tuple of the form ``(host, port)`` referring to the client's
-      address.
-
-
-   .. attribute:: command
-
-      Contains the command (request type). For example, ``'GET'``.
-
-
-   .. attribute:: path
-
-      Contains the request path.
-
-
-   .. attribute:: request_version
-
-      Contains the version string from the request. For example, ``'HTTP/1.0'``.
-
-
-   .. attribute:: headers
-
-      Holds an instance of the class specified by the :attr:`MessageClass` class
-      variable. This instance parses and manages the headers in the HTTP
-      request.
-
-
-   .. attribute:: rfile
-
-      Contains an input stream, positioned at the start of the optional input
-      data.
-
-
-   .. attribute:: wfile
-
-      Contains the output stream for writing a response back to the
-      client. Proper adherence to the HTTP protocol must be used when writing to
-      this stream.
-
-
-   :class:`BaseHTTPRequestHandler` has the following class variables:
-
-
-   .. attribute:: server_version
-
-      Specifies the server software version.  You may want to override this. The
-      format is multiple whitespace-separated strings, where each string is of
-      the form name[/version]. For example, ``'BaseHTTP/0.2'``.
-
-
-   .. attribute:: sys_version
-
-      Contains the Python system version, in a form usable by the
-      :attr:`version_string` method and the :attr:`server_version` class
-      variable. For example, ``'Python/1.4'``.
-
-
-   .. attribute:: error_message_format
-
-      Specifies a format string for building an error response to the client. It
-      uses parenthesized, keyed format specifiers, so the format operand must be
-      a dictionary. The *code* key should be an integer, specifying the numeric
-      HTTP error code value. *message* should be a string containing a
-      (detailed) error message of what occurred, and *explain* should be an
-      explanation of the error code number. Default *message* and *explain*
-      values can found in the *responses* class variable.
-
-
-   .. attribute:: error_content_type
-
-      Specifies the Content-Type HTTP header of error responses sent to the
-      client.  The default value is ``'text/html'``.
-
-
-   .. attribute:: protocol_version
-
-      This specifies the HTTP protocol version used in responses.  If set to
-      ``'HTTP/1.1'``, the server will permit HTTP persistent connections;
-      however, your server *must* then include an accurate ``Content-Length``
-      header (using :meth:`send_header`) in all of its responses to clients.
-      For backwards compatibility, the setting defaults to ``'HTTP/1.0'``.
-
-
-   .. attribute:: MessageClass
-
-      .. index:: single: Message (in module mimetools)
-
-      Specifies a :class:`rfc822.Message`\ -like class to parse HTTP headers.
-      Typically, this is not overridden, and it defaults to
-      :class:`mimetools.Message`.
-
-
-   .. attribute:: responses
-
-      This variable contains a mapping of error code integers to two-element tuples
-      containing a short and long message. For example, ``{code: (shortmessage,
-      longmessage)}``. The *shortmessage* is usually used as the *message* key in an
-      error response, and *longmessage* as the *explain* key (see the
-      :attr:`error_message_format` class variable).
-
-
-   A :class:`BaseHTTPRequestHandler` instance has the following methods:
-
-
-   .. method:: handle()
-
-      Calls :meth:`handle_one_request` once (or, if persistent connections are
-      enabled, multiple times) to handle incoming HTTP requests. You should
-      never need to override it; instead, implement appropriate :meth:`do_\*`
-      methods.
-
-
-   .. method:: handle_one_request()
-
-      This method will parse and dispatch the request to the appropriate
-      :meth:`do_\*` method.  You should never need to override it.
-
-
-   .. method:: send_error(code[, message])
-
-      Sends and logs a complete error reply to the client. The numeric *code*
-      specifies the HTTP error code, with *message* as optional, more specific text. A
-      complete set of headers is sent, followed by text composed using the
-      :attr:`error_message_format` class variable.
-
-
-   .. method:: send_response(code[, message])
-
-      Sends a response header and logs the accepted request. The HTTP response
-      line is sent, followed by *Server* and *Date* headers. The values for
-      these two headers are picked up from the :meth:`version_string` and
-      :meth:`date_time_string` methods, respectively.
-
-
-   .. method:: send_header(keyword, value)
-
-      Writes a specific HTTP header to the output stream. *keyword* should
-      specify the header keyword, with *value* specifying its value.
-
-
-   .. method:: end_headers()
-
-      Sends a blank line, indicating the end of the HTTP headers in the
-      response.
-
-
-   .. method:: log_request([code[, size]])
-
-      Logs an accepted (successful) request. *code* should specify the numeric
-      HTTP code associated with the response. If a size of the response is
-      available, then it should be passed as the *size* parameter.
-
-
-   .. method:: log_error(...)
-
-      Logs an error when a request cannot be fulfilled. By default, it passes
-      the message to :meth:`log_message`, so it takes the same arguments
-      (*format* and additional values).
-
-
-   .. method:: log_message(format, ...)
-
-      Logs an arbitrary message to ``sys.stderr``. This is typically overridden
-      to create custom error logging mechanisms. The *format* argument is a
-      standard printf-style format string, where the additional arguments to
-      :meth:`log_message` are applied as inputs to the formatting. The client
-      address and current date and time are prefixed to every message logged.
-
-
-   .. method:: version_string()
-
-      Returns the server software's version string. This is a combination of the
-      :attr:`server_version` and :attr:`sys_version` class variables.
-
-
-   .. method:: date_time_string([timestamp])
-
-      Returns the date and time given by *timestamp* (which must be in the
-      format returned by :func:`time.time`), formatted for a message header. If
-      *timestamp* is omitted, it uses the current date and time.
-
-      The result looks like ``'Sun, 06 Nov 1994 08:49:37 GMT'``.
-
-
-   .. method:: log_date_time_string()
-
-      Returns the current date and time, formatted for logging.
-
-
-   .. method:: address_string()
-
-      Returns the client address, formatted for logging. A name lookup is
-      performed on the client's IP address.
-
-
-.. seealso::
-
-   Module :mod:`CGIHTTPServer`
-      Extended request handler that supports CGI scripts.
-
-   Module :mod:`SimpleHTTPServer`
-      Basic request handler that limits response to files actually under the document
-      root.
-
diff --git a/Doc/library/cgihttpserver.rst b/Doc/library/cgihttpserver.rst
deleted file mode 100644
index 6275c1a..0000000
--- a/Doc/library/cgihttpserver.rst
+++ /dev/null
@@ -1,73 +0,0 @@
-
-:mod:`CGIHTTPServer` --- CGI-capable HTTP request handler
-=========================================================
-
-.. module:: CGIHTTPServer
-   :synopsis: This module provides a request handler for HTTP servers which can run CGI
-              scripts.
-.. sectionauthor:: Moshe Zadka <moshez@zadka.site.co.il>
-
-
-The :mod:`CGIHTTPServer` module defines a request-handler class, interface
-compatible with :class:`BaseHTTPServer.BaseHTTPRequestHandler` and inherits
-behavior from :class:`SimpleHTTPServer.SimpleHTTPRequestHandler` but can also
-run CGI scripts.
-
-.. note::
-
-   This module can run CGI scripts on Unix and Windows systems; on Mac OS it will
-   only be able to run Python scripts within the same process as itself.
-
-.. note::
-
-   CGI scripts run by the :class:`CGIHTTPRequestHandler` class cannot execute
-   redirects (HTTP code 302), because code 200 (script output follows) is sent
-   prior to execution of the CGI script.  This pre-empts the status code.
-
-The :mod:`CGIHTTPServer` module defines the following class:
-
-
-.. class:: CGIHTTPRequestHandler(request, client_address, server)
-
-   This class is used to serve either files or output of CGI scripts from  the
-   current directory and below. Note that mapping HTTP hierarchic structure to
-   local directory structure is exactly as in
-   :class:`SimpleHTTPServer.SimpleHTTPRequestHandler`.
-
-   The class will however, run the CGI script, instead of serving it as a file, if
-   it guesses it to be a CGI script. Only directory-based CGI are used --- the
-   other common server configuration is to treat special extensions as denoting CGI
-   scripts.
-
-   The :func:`do_GET` and :func:`do_HEAD` functions are modified to run CGI scripts
-   and serve the output, instead of serving files, if the request leads to
-   somewhere below the ``cgi_directories`` path.
-
-   The :class:`CGIHTTPRequestHandler` defines the following data member:
-
-
-   .. attribute:: cgi_directories
-
-      This defaults to ``['/cgi-bin', '/htbin']`` and describes directories to
-      treat as containing CGI scripts.
-
-   The :class:`CGIHTTPRequestHandler` defines the following methods:
-
-
-   .. method:: do_POST()
-
-      This method serves the ``'POST'`` request type, only allowed for CGI
-      scripts.  Error 501, "Can only POST to CGI scripts", is output when trying
-      to POST to a non-CGI url.
-
-Note that CGI scripts will be run with UID of user nobody, for security reasons.
-Problems with the CGI script will be translated to error 403.
-
-For example usage, see the implementation of the :func:`test` function.
-
-
-.. seealso::
-
-   Module :mod:`BaseHTTPServer`
-      Base class implementation for Web server and request handler.
-
diff --git a/Doc/library/codecs.rst b/Doc/library/codecs.rst
index 0745c66..42273051 100644
--- a/Doc/library/codecs.rst
+++ b/Doc/library/codecs.rst
@@ -1159,8 +1159,8 @@
 transparently converts Unicode host names to ACE, so that applications need not
 be concerned about converting host names themselves when they pass them to the
 socket module. On top of that, modules that have host names as function
-parameters, such as :mod:`httplib` and :mod:`ftplib`, accept Unicode host names
-(:mod:`httplib` then also transparently sends an IDNA hostname in the
+parameters, such as :mod:`http.client` and :mod:`ftplib`, accept Unicode host
+names (:mod:`http.client` then also transparently sends an IDNA hostname in the
 :mailheader:`Host` field if it sends that field at all).
 
 When receiving host names from the wire (such as in reverse name lookup), no
diff --git a/Doc/library/httplib.rst b/Doc/library/http.client.rst
similarity index 97%
rename from Doc/library/httplib.rst
rename to Doc/library/http.client.rst
index 16b74ee..6903b6a 100644
--- a/Doc/library/httplib.rst
+++ b/Doc/library/http.client.rst
@@ -1,14 +1,13 @@
+:mod:`http.client` --- HTTP protocol client
+===========================================
 
-:mod:`httplib` --- HTTP protocol client
-=======================================
-
-.. module:: httplib
+.. module:: http.client
    :synopsis: HTTP and HTTPS protocol client (requires sockets).
 
 
 .. index::
    pair: HTTP; protocol
-   single: HTTP; httplib (standard module)
+   single: HTTP; http.client (standard module)
 
 .. index:: module: urllib
 
@@ -39,10 +38,10 @@
    For example, the following calls all create instances that connect to the server
    at the same host and port::
 
-      >>> h1 = httplib.HTTPConnection('www.cwi.nl')
-      >>> h2 = httplib.HTTPConnection('www.cwi.nl:80')
-      >>> h3 = httplib.HTTPConnection('www.cwi.nl', 80)
-      >>> h3 = httplib.HTTPConnection('www.cwi.nl', 80, timeout=10)
+      >>> h1 = http.client.HTTPConnection('www.cwi.nl')
+      >>> h2 = http.client.HTTPConnection('www.cwi.nl:80')
+      >>> h3 = http.client.HTTPConnection('www.cwi.nl', 80)
+      >>> h3 = http.client.HTTPConnection('www.cwi.nl', 80, timeout=10)
 
 
 .. class:: HTTPSConnection(host[, port[, key_file[, cert_file[, strict[, timeout]]]]])
@@ -338,7 +337,7 @@
 
    This dictionary maps the HTTP 1.1 status codes to the W3C names.
 
-   Example: ``httplib.responses[httplib.NOT_FOUND]`` is ``'Not Found'``.
+   Example: ``http.client.responses[http.client.NOT_FOUND]`` is ``'Not Found'``.
 
 
 .. _httpconnection-objects:
@@ -464,15 +463,13 @@
    Reason phrase returned by server.
 
 
-.. _httplib-examples:
-
 Examples
 --------
 
 Here is an example session that uses the ``GET`` method::
 
-   >>> import httplib
-   >>> conn = httplib.HTTPConnection("www.python.org")
+   >>> import http.client
+   >>> conn = http.client.HTTPConnection("www.python.org")
    >>> conn.request("GET", "/index.html")
    >>> r1 = conn.getresponse()
    >>> print(r1.status, r1.reason)
@@ -487,11 +484,11 @@
 
 Here is an example session that shows how to ``POST`` requests::
 
-   >>> import httplib, urllib
+   >>> import http.client, urllib
    >>> params = urllib.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})
    >>> headers = {"Content-type": "application/x-www-form-urlencoded",
    ...            "Accept": "text/plain"}
-   >>> conn = httplib.HTTPConnection("musi-cal.mojam.com:80")
+   >>> conn = http.client.HTTPConnection("musi-cal.mojam.com:80")
    >>> conn.request("POST", "/cgi-bin/query", params, headers)
    >>> response = conn.getresponse()
    >>> print(response.status, response.reason)
diff --git a/Doc/library/cookielib.rst b/Doc/library/http.cookiejar.rst
similarity index 94%
rename from Doc/library/cookielib.rst
rename to Doc/library/http.cookiejar.rst
index c8e7298..250abde 100644
--- a/Doc/library/cookielib.rst
+++ b/Doc/library/http.cookiejar.rst
@@ -1,14 +1,13 @@
+:mod:`http.cookiejar` --- Cookie handling for HTTP clients
+==========================================================
 
-:mod:`cookielib` --- Cookie handling for HTTP clients
-=====================================================
-
-.. module:: cookielib
+.. module:: http.cookiejar
    :synopsis: Classes for automatic handling of HTTP cookies.
 .. moduleauthor:: John J. Lee <jjl@pobox.com>
 .. sectionauthor:: John J. Lee <jjl@pobox.com>
 
 
-The :mod:`cookielib` module defines classes for automatic handling of HTTP
+The :mod:`http.cookiejar` module defines classes for automatic handling of HTTP
 cookies.  It is useful for accessing web sites that require small pieces of data
 -- :dfn:`cookies` -- to be set on the client machine by an HTTP response from a
 web server, and then returned to the server in later HTTP requests.
@@ -18,7 +17,7 @@
 :rfc:`2109` cookies are parsed as Netscape cookies and subsequently treated
 either as Netscape or RFC 2965 cookies according to the 'policy' in effect.
 Note that the great majority of cookies on the Internet are Netscape cookies.
-:mod:`cookielib` attempts to follow the de-facto Netscape cookie protocol (which
+:mod:`http.cookiejar` attempts to follow the de-facto Netscape cookie protocol (which
 differs substantially from that set out in the original Netscape specification),
 including taking note of the ``max-age`` and ``port`` cookie-attributes
 introduced with RFC 2965.
@@ -94,7 +93,7 @@
 .. class:: Cookie()
 
    This class represents Netscape, RFC 2109 and RFC 2965 cookies.  It is not
-   expected that users of :mod:`cookielib` construct their own :class:`Cookie`
+   expected that users of :mod:`http.cookiejar` construct their own :class:`Cookie`
    instances.  Instead, if necessary, call :meth:`make_cookies` on a
    :class:`CookieJar` instance.
 
@@ -104,9 +103,10 @@
    Module :mod:`urllib2`
       URL opening with automatic cookie handling.
 
-   Module :mod:`Cookie`
+   Module :mod:`http.cookies`
       HTTP cookie classes, principally useful for server-side code.  The
-      :mod:`cookielib` and :mod:`Cookie` modules do not depend on each other.
+      :mod:`http.cookiejar` and :mod:`http.cookies` modules do not depend on each
+      other.
 
    http://wwwsearch.sf.net/ClientCookie/
       Extensions to this module, including a class for reading Microsoft Internet
@@ -115,7 +115,7 @@
    http://wp.netscape.com/newsref/std/cookie_spec.html
       The specification of the original Netscape cookie protocol.  Though this is
       still the dominant protocol, the 'Netscape cookie protocol' implemented by all
-      the major browsers (and :mod:`cookielib`) only bears a passing resemblance to
+      the major browsers (and :mod:`http.cookiejar`) only bears a passing resemblance to
       the one sketched out in ``cookie_spec.html``.
 
    :rfc:`2109` - HTTP State Management Mechanism
@@ -339,7 +339,7 @@
 
    Return boolean value indicating whether cookie should be accepted from server.
 
-   *cookie* is a :class:`cookielib.Cookie` instance.  *request* is an object
+   *cookie* is a :class:`Cookie` instance.  *request* is an object
    implementing the interface defined by the documentation for
    :meth:`CookieJar.extract_cookies`.
 
@@ -348,7 +348,7 @@
 
    Return boolean value indicating whether cookie should be returned to server.
 
-   *cookie* is a :class:`cookielib.Cookie` instance.  *request* is an object
+   *cookie* is a :class:`Cookie` instance.  *request* is an object
    implementing the interface defined by the documentation for
    :meth:`CookieJar.add_cookie_header`.
 
@@ -424,10 +424,10 @@
 its methods in your overridden implementations before adding your own additional
 checks::
 
-   import cookielib
-   class MyCookiePolicy(cookielib.DefaultCookiePolicy):
+   import http.cookiejar
+   class MyCookiePolicy(http.cookiejar.DefaultCookiePolicy):
        def set_ok(self, cookie, request):
-           if not cookielib.DefaultCookiePolicy.set_ok(self, cookie, request):
+           if not http.cookiejar.DefaultCookiePolicy.set_ok(self, cookie, request):
                return False
            if i_dont_want_to_store_this_cookie(cookie):
                return False
@@ -584,8 +584,6 @@
    Equivalent to ``DomainStrictNoDots|DomainStrictNonDomain``.
 
 
-.. _cookielib-cookie-objects:
-
 Cookie Objects
 --------------
 
@@ -594,7 +592,7 @@
 correspondence is not one-to-one, because there are complicated rules for
 assigning default values, because the ``max-age`` and ``expires``
 cookie-attributes contain equivalent information, and because RFC 2109 cookies
-may be 'downgraded' by :mod:`cookielib` from version 1 to version 0 (Netscape)
+may be 'downgraded' by :mod:`http.cookiejar` from version 1 to version 0 (Netscape)
 cookies.
 
 Assignment to these attributes should not be necessary other than in rare
@@ -606,7 +604,7 @@
 
    Integer or :const:`None`.  Netscape cookies have :attr:`version` 0. RFC 2965 and
    RFC 2109 cookies have a ``version`` cookie-attribute of 1.  However, note that
-   :mod:`cookielib` may 'downgrade' RFC 2109 cookies to Netscape cookies, in which
+   :mod:`http.cookiejar` may 'downgrade' RFC 2109 cookies to Netscape cookies, in which
    case :attr:`version` is 0.
 
 
@@ -664,7 +662,7 @@
    True if this cookie was received as an RFC 2109 cookie (ie. the cookie
    arrived in a :mailheader:`Set-Cookie` header, and the value of the Version
    cookie-attribute in that header was 1).  This attribute is provided because
-   :mod:`cookielib` may 'downgrade' RFC 2109 cookies to Netscape cookies, in
+   :mod:`http.cookiejar` may 'downgrade' RFC 2109 cookies to Netscape cookies, in
    which case :attr:`version` is 0.
 
 
@@ -713,23 +711,21 @@
    cookie has expired at the specified time.
 
 
-.. _cookielib-examples:
-
 Examples
 --------
 
-The first example shows the most common usage of :mod:`cookielib`::
+The first example shows the most common usage of :mod:`http.cookiejar`::
 
-   import cookielib, urllib2
-   cj = cookielib.CookieJar()
+   import http.cookiejar, urllib2
+   cj = http.cookiejar.CookieJar()
    opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
    r = opener.open("http://example.com/")
 
 This example illustrates how to open a URL using your Netscape, Mozilla, or Lynx
 cookies (assumes Unix/Netscape convention for location of the cookies file)::
 
-   import os, cookielib, urllib2
-   cj = cookielib.MozillaCookieJar()
+   import os, http.cookiejar, urllib2
+   cj = http.cookiejar.MozillaCookieJar()
    cj.load(os.path.join(os.environ["HOME"], ".netscape/cookies.txt"))
    opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
    r = opener.open("http://example.com/")
@@ -740,7 +736,7 @@
 returned::
 
    import urllib2
-   from cookielib import CookieJar, DefaultCookiePolicy
+   from http.cookiejar import CookieJar, DefaultCookiePolicy
    policy = DefaultCookiePolicy(
        rfc2965=True, strict_ns_domain=Policy.DomainStrict,
        blocked_domains=["ads.net", ".ads.net"])
diff --git a/Doc/library/cookie.rst b/Doc/library/http.cookies.rst
similarity index 88%
rename from Doc/library/cookie.rst
rename to Doc/library/http.cookies.rst
index ccc2faa..8c90c5e 100644
--- a/Doc/library/cookie.rst
+++ b/Doc/library/http.cookies.rst
@@ -1,14 +1,13 @@
+:mod:`http.cookies` --- HTTP state management
+=============================================
 
-:mod:`Cookie` --- HTTP state management
-=======================================
-
-.. module:: Cookie
+.. module:: http.cookies
    :synopsis: Support for HTTP state management (cookies).
 .. moduleauthor:: Timothy O'Malley <timo@alum.mit.edu>
 .. sectionauthor:: Moshe Zadka <moshez@zadka.site.co.il>
 
 
-The :mod:`Cookie` module defines classes for abstracting the concept of
+The :mod:`http.cookies` module defines classes for abstracting the concept of
 cookies, an HTTP state management mechanism. It supports both simple string-only
 cookies, and provides an abstraction for having any serializable data-type as
 cookie value.
@@ -63,7 +62,7 @@
       The same security warning from :class:`SerialCookie` applies here.
 
 A further security note is warranted.  For backwards compatibility, the
-:mod:`Cookie` module exports a class named :class:`Cookie` which is just an
+:mod:`http.cookies` module exports a class named :class:`Cookie` which is just an
 alias for :class:`SmartCookie`.  This is probably a mistake and will likely be
 removed in a future version.  You should not use the :class:`Cookie` class in
 your applications, for the same reason why you should not use the
@@ -72,9 +71,9 @@
 
 .. seealso::
 
-   Module :mod:`cookielib`
-      HTTP cookie handling for web *clients*.  The :mod:`cookielib` and :mod:`Cookie`
-      modules do not depend on each other.
+   Module :mod:`http.cookiejar`
+      HTTP cookie handling for web *clients*.  The :mod:`http.cookiejar` and
+      :mod:`http.cookies` modules do not depend on each other.
 
    :rfc:`2109` - HTTP State Management Mechanism
       This is the state management specification implemented by this module.
@@ -206,15 +205,15 @@
 Example
 -------
 
-The following example demonstrates how to use the :mod:`Cookie` module.
+The following example demonstrates how to use the :mod:`http.cookies` module.
 
 .. doctest::
    :options: +NORMALIZE_WHITESPACE
 
-   >>> import Cookie
-   >>> C = Cookie.SimpleCookie()
-   >>> C = Cookie.SerialCookie()
-   >>> C = Cookie.SmartCookie()
+   >>> from http import cookies
+   >>> C = cookies.SimpleCookie()
+   >>> C = cookies.SerialCookie()
+   >>> C = cookies.SmartCookie()
    >>> C["fig"] = "newton"
    >>> C["sugar"] = "wafer"
    >>> print(C) # generate HTTP headers
@@ -223,32 +222,32 @@
    >>> print(C.output()) # same thing
    Set-Cookie: fig=newton
    Set-Cookie: sugar=wafer
-   >>> C = Cookie.SmartCookie()
+   >>> C = cookies.SmartCookie()
    >>> C["rocky"] = "road"
    >>> C["rocky"]["path"] = "/cookie"
    >>> print(C.output(header="Cookie:"))
    Cookie: rocky=road; Path=/cookie
    >>> print(C.output(attrs=[], header="Cookie:"))
    Cookie: rocky=road
-   >>> C = Cookie.SmartCookie()
+   >>> C = cookies.SmartCookie()
    >>> C.load("chips=ahoy; vienna=finger") # load from a string (HTTP header)
    >>> print(C)
    Set-Cookie: chips=ahoy
    Set-Cookie: vienna=finger
-   >>> C = Cookie.SmartCookie()
+   >>> C = cookies.SmartCookie()
    >>> C.load('keebler="E=everybody; L=\\"Loves\\"; fudge=\\012;";')
    >>> print(C)
    Set-Cookie: keebler="E=everybody; L=\"Loves\"; fudge=\012;"
-   >>> C = Cookie.SmartCookie()
+   >>> C = cookies.SmartCookie()
    >>> C["oreo"] = "doublestuff"
    >>> C["oreo"]["path"] = "/"
    >>> print(C)
    Set-Cookie: oreo=doublestuff; Path=/
-   >>> C = Cookie.SmartCookie()
+   >>> C = cookies.SmartCookie()
    >>> C["twix"] = "none for you"
    >>> C["twix"].value
    'none for you'
-   >>> C = Cookie.SimpleCookie()
+   >>> C = cookies.SimpleCookie()
    >>> C["number"] = 7 # equivalent to C["number"] = str(7)
    >>> C["string"] = "seven"
    >>> C["number"].value
@@ -258,7 +257,7 @@
    >>> print(C)
    Set-Cookie: number=7
    Set-Cookie: string=seven
-   >>> C = Cookie.SerialCookie()
+   >>> C = cookies.SerialCookie()
    >>> C["number"] = 7
    >>> C["string"] = "seven"
    >>> C["number"].value
@@ -268,7 +267,7 @@
    >>> print(C)
    Set-Cookie: number="I7\012."
    Set-Cookie: string="S'seven'\012p1\012."
-   >>> C = Cookie.SmartCookie()
+   >>> C = cookies.SmartCookie()
    >>> C["number"] = 7
    >>> C["string"] = "seven"
    >>> C["number"].value
diff --git a/Doc/library/http.server.rst b/Doc/library/http.server.rst
new file mode 100644
index 0000000..941f043
--- /dev/null
+++ b/Doc/library/http.server.rst
@@ -0,0 +1,322 @@
+:mod:`http.server` --- HTTP servers
+===================================
+
+.. module:: http.server
+   :synopsis: HTTP server and request handlers.
+
+
+.. index::
+   pair: WWW; server
+   pair: HTTP; protocol
+   single: URL
+   single: httpd
+
+This module defines classes for implementing HTTP servers (Web servers).
+
+One class, :class:`HTTPServer`, is a :class:`socketserver.TCPServer` subclass.
+It creates and listens at the HTTP socket, dispatching the requests to a
+handler.  Code to create and run the server looks like this::
+
+   def run(server_class=HTTPServer, handler_class=BaseHTTPRequestHandler):
+       server_address = ('', 8000)
+       httpd = server_class(server_address, handler_class)
+       httpd.serve_forever()
+
+
+.. class:: HTTPServer(server_address, RequestHandlerClass)
+
+   This class builds on the :class:`TCPServer` class by storing the server
+   address as instance variables named :attr:`server_name` and
+   :attr:`server_port`. The server is accessible by the handler, typically
+   through the handler's :attr:`server` instance variable.
+
+
+The :class:`HTTPServer` must be given a *RequestHandlerClass* on instantiation,
+of which this module provides three different variants:
+
+.. class:: BaseHTTPRequestHandler(request, client_address, server)
+
+   This class is used to handle the HTTP requests that arrive at the server.  By
+   itself, it cannot respond to any actual HTTP requests; it must be subclassed
+   to handle each request method (e.g. GET or POST).
+   :class:`BaseHTTPRequestHandler` provides a number of class and instance
+   variables, and methods for use by subclasses.
+
+   The handler will parse the request and the headers, then call a method
+   specific to the request type. The method name is constructed from the
+   request. For example, for the request method ``SPAM``, the :meth:`do_SPAM`
+   method will be called with no arguments. All of the relevant information is
+   stored in instance variables of the handler.  Subclasses should not need to
+   override or extend the :meth:`__init__` method.
+
+   :class:`BaseHTTPRequestHandler` has the following instance variables:
+
+   .. attribute:: client_address
+
+      Contains a tuple of the form ``(host, port)`` referring to the client's
+      address.
+
+   .. attribute:: command
+
+      Contains the command (request type). For example, ``'GET'``.
+
+   .. attribute:: path
+
+      Contains the request path.
+
+   .. attribute:: request_version
+
+      Contains the version string from the request. For example, ``'HTTP/1.0'``.
+
+   .. attribute:: headers
+
+      Holds an instance of the class specified by the :attr:`MessageClass` class
+      variable. This instance parses and manages the headers in the HTTP
+      request.
+
+   .. attribute:: rfile
+
+      Contains an input stream, positioned at the start of the optional input
+      data.
+
+   .. attribute:: wfile
+
+      Contains the output stream for writing a response back to the
+      client. Proper adherence to the HTTP protocol must be used when writing to
+      this stream.
+
+   :class:`BaseHTTPRequestHandler` has the following class variables:
+
+   .. attribute:: server_version
+
+      Specifies the server software version.  You may want to override this. The
+      format is multiple whitespace-separated strings, where each string is of
+      the form name[/version]. For example, ``'BaseHTTP/0.2'``.
+
+   .. attribute:: sys_version
+
+      Contains the Python system version, in a form usable by the
+      :attr:`version_string` method and the :attr:`server_version` class
+      variable. For example, ``'Python/1.4'``.
+
+   .. attribute:: error_message_format
+
+      Specifies a format string for building an error response to the client. It
+      uses parenthesized, keyed format specifiers, so the format operand must be
+      a dictionary. The *code* key should be an integer, specifying the numeric
+      HTTP error code value. *message* should be a string containing a
+      (detailed) error message of what occurred, and *explain* should be an
+      explanation of the error code number. Default *message* and *explain*
+      values can found in the *responses* class variable.
+
+   .. attribute:: error_content_type
+
+      Specifies the Content-Type HTTP header of error responses sent to the
+      client.  The default value is ``'text/html'``.
+
+   .. attribute:: protocol_version
+
+      This specifies the HTTP protocol version used in responses.  If set to
+      ``'HTTP/1.1'``, the server will permit HTTP persistent connections;
+      however, your server *must* then include an accurate ``Content-Length``
+      header (using :meth:`send_header`) in all of its responses to clients.
+      For backwards compatibility, the setting defaults to ``'HTTP/1.0'``.
+
+   .. attribute:: MessageClass
+
+      .. index:: single: Message (in module mimetools)
+
+      Specifies a :class:`rfc822.Message`\ -like class to parse HTTP headers.
+      Typically, this is not overridden, and it defaults to
+      :class:`mimetools.Message`.
+
+   .. attribute:: responses
+
+      This variable contains a mapping of error code integers to two-element tuples
+      containing a short and long message. For example, ``{code: (shortmessage,
+      longmessage)}``. The *shortmessage* is usually used as the *message* key in an
+      error response, and *longmessage* as the *explain* key (see the
+      :attr:`error_message_format` class variable).
+
+   A :class:`BaseHTTPRequestHandler` instance has the following methods:
+
+   .. method:: handle()
+
+      Calls :meth:`handle_one_request` once (or, if persistent connections are
+      enabled, multiple times) to handle incoming HTTP requests. You should
+      never need to override it; instead, implement appropriate :meth:`do_\*`
+      methods.
+
+   .. method:: handle_one_request()
+
+      This method will parse and dispatch the request to the appropriate
+      :meth:`do_\*` method.  You should never need to override it.
+
+   .. method:: send_error(code[, message])
+
+      Sends and logs a complete error reply to the client. The numeric *code*
+      specifies the HTTP error code, with *message* as optional, more specific text. A
+      complete set of headers is sent, followed by text composed using the
+      :attr:`error_message_format` class variable.
+
+   .. method:: send_response(code[, message])
+
+      Sends a response header and logs the accepted request. The HTTP response
+      line is sent, followed by *Server* and *Date* headers. The values for
+      these two headers are picked up from the :meth:`version_string` and
+      :meth:`date_time_string` methods, respectively.
+
+   .. method:: send_header(keyword, value)
+
+      Writes a specific HTTP header to the output stream. *keyword* should
+      specify the header keyword, with *value* specifying its value.
+
+   .. method:: end_headers()
+
+      Sends a blank line, indicating the end of the HTTP headers in the
+      response.
+
+   .. method:: log_request([code[, size]])
+
+      Logs an accepted (successful) request. *code* should specify the numeric
+      HTTP code associated with the response. If a size of the response is
+      available, then it should be passed as the *size* parameter.
+
+   .. method:: log_error(...)
+
+      Logs an error when a request cannot be fulfilled. By default, it passes
+      the message to :meth:`log_message`, so it takes the same arguments
+      (*format* and additional values).
+
+
+   .. method:: log_message(format, ...)
+
+      Logs an arbitrary message to ``sys.stderr``. This is typically overridden
+      to create custom error logging mechanisms. The *format* argument is a
+      standard printf-style format string, where the additional arguments to
+      :meth:`log_message` are applied as inputs to the formatting. The client
+      address and current date and time are prefixed to every message logged.
+
+   .. method:: version_string()
+
+      Returns the server software's version string. This is a combination of the
+      :attr:`server_version` and :attr:`sys_version` class variables.
+
+   .. method:: date_time_string([timestamp])
+
+      Returns the date and time given by *timestamp* (which must be in the
+      format returned by :func:`time.time`), formatted for a message header. If
+      *timestamp* is omitted, it uses the current date and time.
+
+      The result looks like ``'Sun, 06 Nov 1994 08:49:37 GMT'``.
+
+   .. method:: log_date_time_string()
+
+      Returns the current date and time, formatted for logging.
+
+   .. method:: address_string()
+
+      Returns the client address, formatted for logging. A name lookup is
+      performed on the client's IP address.
+
+
+.. class:: SimpleHTTPRequestHandler(request, client_address, server)
+
+   This class serves files from the current directory and below, directly
+   mapping the directory structure to HTTP requests.
+
+   A lot of the work, such as parsing the request, is done by the base class
+   :class:`BaseHTTPRequestHandler`.  This class implements the :func:`do_GET`
+   and :func:`do_HEAD` functions.
+
+   The following are defined as class-level attributes of
+   :class:`SimpleHTTPRequestHandler`:
+
+   .. attribute:: server_version
+
+      This will be ``"SimpleHTTP/" + __version__``, where ``__version__`` is
+      defined at the module level.
+
+   .. attribute:: extensions_map
+
+      A dictionary mapping suffixes into MIME types. The default is
+      signified by an empty string, and is considered to be
+      ``application/octet-stream``. The mapping is used case-insensitively,
+      and so should contain only lower-cased keys.
+
+   The :class:`SimpleHTTPRequestHandler` class defines the following methods:
+
+   .. method:: do_HEAD()
+
+      This method serves the ``'HEAD'`` request type: it sends the headers it
+      would send for the equivalent ``GET`` request. See the :meth:`do_GET`
+      method for a more complete explanation of the possible headers.
+
+   .. method:: do_GET()
+
+      The request is mapped to a local file by interpreting the request as a
+      path relative to the current working directory.
+
+      If the request was mapped to a directory, the directory is checked for a
+      file named ``index.html`` or ``index.htm`` (in that order). If found, the
+      file's contents are returned; otherwise a directory listing is generated
+      by calling the :meth:`list_directory` method. This method uses
+      :func:`os.listdir` to scan the directory, and returns a ``404`` error
+      response if the :func:`listdir` fails.
+
+      If the request was mapped to a file, it is opened and the contents are
+      returned.  Any :exc:`IOError` exception in opening the requested file is
+      mapped to a ``404``, ``'File not found'`` error. Otherwise, the content
+      type is guessed by calling the :meth:`guess_type` method, which in turn
+      uses the *extensions_map* variable.
+
+      A ``'Content-type:'`` header with the guessed content type is output,
+      followed by a ``'Content-Length:'`` header with the file's size and a
+      ``'Last-Modified:'`` header with the file's modification time.
+
+      Then follows a blank line signifying the end of the headers, and then the
+      contents of the file are output. If the file's MIME type starts with
+      ``text/`` the file is opened in text mode; otherwise binary mode is used.
+
+      For example usage, see the implementation of the :func:`test` function.
+
+
+.. class:: CGIHTTPRequestHandler(request, client_address, server)
+
+   This class is used to serve either files or output of CGI scripts from the
+   current directory and below. Note that mapping HTTP hierarchic structure to
+   local directory structure is exactly as in :class:`SimpleHTTPRequestHandler`.
+
+   .. note::
+
+      CGI scripts run by the :class:`CGIHTTPRequestHandler` class cannot execute
+      redirects (HTTP code 302), because code 200 (script output follows) is
+      sent prior to execution of the CGI script.  This pre-empts the status
+      code.
+
+   The class will however, run the CGI script, instead of serving it as a file,
+   if it guesses it to be a CGI script.  Only directory-based CGI are used ---
+   the other common server configuration is to treat special extensions as
+   denoting CGI scripts.
+
+   The :func:`do_GET` and :func:`do_HEAD` functions are modified to run CGI scripts
+   and serve the output, instead of serving files, if the request leads to
+   somewhere below the ``cgi_directories`` path.
+
+   The :class:`CGIHTTPRequestHandler` defines the following data member:
+
+   .. attribute:: cgi_directories
+
+      This defaults to ``['/cgi-bin', '/htbin']`` and describes directories to
+      treat as containing CGI scripts.
+
+   The :class:`CGIHTTPRequestHandler` defines the following method:
+
+   .. method:: do_POST()
+
+      This method serves the ``'POST'`` request type, only allowed for CGI
+      scripts.  Error 501, "Can only POST to CGI scripts", is output when trying
+      to POST to a non-CGI url.
+
+   Note that CGI scripts will be run with UID of user nobody, for security
+   reasons.  Problems with the CGI script will be translated to error 403.
diff --git a/Doc/library/internet.rst b/Doc/library/internet.rst
index a5f6d22..948a0b2 100644
--- a/Doc/library/internet.rst
+++ b/Doc/library/internet.rst
@@ -26,7 +26,7 @@
    wsgiref.rst
    urllib.rst
    urllib2.rst
-   httplib.rst
+   http.client.rst
    ftplib.rst
    poplib.rst
    imaplib.rst
@@ -37,10 +37,8 @@
    uuid.rst
    urlparse.rst
    socketserver.rst
-   basehttpserver.rst
-   simplehttpserver.rst
-   cgihttpserver.rst
-   cookielib.rst
-   cookie.rst
+   http.server.rst
+   http.cookies.rst
+   http.cookiejar.rst
    xmlrpc.client.rst
    xmlrpc.server.rst
diff --git a/Doc/library/simplehttpserver.rst b/Doc/library/simplehttpserver.rst
deleted file mode 100644
index 7d99681..0000000
--- a/Doc/library/simplehttpserver.rst
+++ /dev/null
@@ -1,86 +0,0 @@
-
-:mod:`SimpleHTTPServer` --- Simple HTTP request handler
-=======================================================
-
-.. module:: SimpleHTTPServer
-   :synopsis: This module provides a basic request handler for HTTP servers.
-.. sectionauthor:: Moshe Zadka <moshez@zadka.site.co.il>
-
-
-The :mod:`SimpleHTTPServer` module defines a single class,
-:class:`SimpleHTTPRequestHandler`, which is interface-compatible with
-:class:`BaseHTTPServer.BaseHTTPRequestHandler`.
-
-The :mod:`SimpleHTTPServer` module defines the following class:
-
-
-.. class:: SimpleHTTPRequestHandler(request, client_address, server)
-
-   This class serves files from the current directory and below, directly
-   mapping the directory structure to HTTP requests.
-
-   A lot of the work, such as parsing the request, is done by the base class
-   :class:`BaseHTTPServer.BaseHTTPRequestHandler`.  This class implements the
-   :func:`do_GET` and :func:`do_HEAD` functions.
-
-   The following are defined as class-level attributes of
-   :class:`SimpleHTTPRequestHandler`:
-
-
-   .. attribute:: server_version
-
-   This will be ``"SimpleHTTP/" + __version__``, where ``__version__`` is
-   defined at the module level.
-
-
-   .. attribute:: extensions_map
-
-      A dictionary mapping suffixes into MIME types. The default is
-      signified by an empty string, and is considered to be
-      ``application/octet-stream``. The mapping is used case-insensitively,
-      and so should contain only lower-cased keys.
-
-   The :class:`SimpleHTTPRequestHandler` class defines the following methods:
-
-
-   .. method:: do_HEAD()
-
-      This method serves the ``'HEAD'`` request type: it sends the headers it
-      would send for the equivalent ``GET`` request. See the :meth:`do_GET`
-      method for a more complete explanation of the possible headers.
-
-
-   .. method:: do_GET()
-
-      The request is mapped to a local file by interpreting the request as a
-      path relative to the current working directory.
-
-      If the request was mapped to a directory, the directory is checked for a
-      file named ``index.html`` or ``index.htm`` (in that order). If found, the
-      file's contents are returned; otherwise a directory listing is generated
-      by calling the :meth:`list_directory` method. This method uses
-      :func:`os.listdir` to scan the directory, and returns a ``404`` error
-      response if the :func:`listdir` fails.
-
-      If the request was mapped to a file, it is opened and the contents are
-      returned.  Any :exc:`IOError` exception in opening the requested file is
-      mapped to a ``404``, ``'File not found'`` error. Otherwise, the content
-      type is guessed by calling the :meth:`guess_type` method, which in turn
-      uses the *extensions_map* variable.
-
-      A ``'Content-type:'`` header with the guessed content type is output,
-      followed by a ``'Content-Length:'`` header with the file's size and a
-      ``'Last-Modified:'`` header with the file's modification time.
-
-      Then follows a blank line signifying the end of the headers, and then the
-      contents of the file are output. If the file's MIME type starts with
-      ``text/`` the file is opened in text mode; otherwise binary mode is used.
-
-      For example usage, see the implementation of the :func:`test` function.
-
-
-.. seealso::
-
-   Module :mod:`BaseHTTPServer`
-      Base class implementation for Web server and request handler.
-
diff --git a/Doc/library/ssl.rst b/Doc/library/ssl.rst
index f60620c..33904b5 100644
--- a/Doc/library/ssl.rst
+++ b/Doc/library/ssl.rst
@@ -489,7 +489,7 @@
    pprint.pprint(ssl_sock.getpeercert())
    print(pprint.pformat(ssl_sock.getpeercert()))
 
-   # Set a simple HTTP request -- use httplib in actual code.
+   # Set a simple HTTP request -- use http.client in actual code.
    ssl_sock.write("""GET / HTTP/1.0\r
    Host: www.verisign.com\r\n\r\n""")
 
diff --git a/Doc/library/urllib2.rst b/Doc/library/urllib2.rst
index 143fe50..0462222 100644
--- a/Doc/library/urllib2.rst
+++ b/Doc/library/urllib2.rst
@@ -37,7 +37,7 @@
      determine if a redirect was followed
 
    * :meth:`info` --- return the meta-information of the page, such as headers, in
-     the form of an ``httplib.HTTPMessage`` instance
+     the form of an ``http.client.HTTPMessage`` instance
      (see `Quick Reference to HTTP Headers <http://www.cs.tut.fi/~jkorpela/http.html>`_)
 
    Raises :exc:`URLError` on errors.
@@ -100,7 +100,7 @@
 
       An HTTP status code as defined in `RFC 2616 <http://www.faqs.org/rfcs/rfc2616.html>`_. 
       This numeric value corresponds to a value found in the dictionary of
-      codes as found in :attr:`BaseHTTPServer.BaseHTTPRequestHandler.responses`.
+      codes as found in :attr:`http.server.BaseHTTPRequestHandler.responses`.
 
 
 
@@ -133,10 +133,11 @@
    HTTP cookies:
 
    *origin_req_host* should be the request-host of the origin transaction, as
-   defined by :rfc:`2965`.  It defaults to ``cookielib.request_host(self)``.  This
-   is the host name or IP address of the original request that was initiated by the
-   user.  For example, if the request is for an image in an HTML document, this
-   should be the request-host of the request for the page containing the image.
+   defined by :rfc:`2965`.  It defaults to ``http.cookiejar.request_host(self)``.
+   This is the host name or IP address of the original request that was
+   initiated by the user.  For example, if the request is for an image in an
+   HTML document, this should be the request-host of the request for the page
+   containing the image.
 
    *unverifiable* should indicate whether the request is unverifiable, as defined
    by RFC 2965.  It defaults to False.  An unverifiable request is one whose URL
@@ -627,7 +628,7 @@
 
 .. attribute:: HTTPCookieProcessor.cookiejar
 
-   The :class:`cookielib.CookieJar` in which cookies are stored.
+   The :class:`http.cookiejar.CookieJar` in which cookies are stored.
 
 
 .. _proxy-handler:
diff --git a/Doc/library/wsgiref.rst b/Doc/library/wsgiref.rst
index 2437bcd..70064fc 100644
--- a/Doc/library/wsgiref.rst
+++ b/Doc/library/wsgiref.rst
@@ -260,7 +260,7 @@
    :synopsis: A simple WSGI HTTP server.
 
 
-This module implements a simple HTTP server (based on :mod:`BaseHTTPServer`)
+This module implements a simple HTTP server (based on :mod:`http.server`)
 that serves WSGI applications.  Each server instance serves a single WSGI
 application on a given host and port.  If you want to serve multiple
 applications on a single host and port, you should create a WSGI application
@@ -303,13 +303,13 @@
 
    Create a :class:`WSGIServer` instance.  *server_address* should be a
    ``(host,port)`` tuple, and *RequestHandlerClass* should be the subclass of
-   :class:`BaseHTTPServer.BaseHTTPRequestHandler` that will be used to process
+   :class:`http.server.BaseHTTPRequestHandler` that will be used to process
    requests.
 
    You do not normally need to call this constructor, as the :func:`make_server`
    function can handle all the details for you.
 
-   :class:`WSGIServer` is a subclass of :class:`BaseHTTPServer.HTTPServer`, so all
+   :class:`WSGIServer` is a subclass of :class:`http.server.HTTPServer`, so all
    of its methods (such as :meth:`serve_forever` and :meth:`handle_request`) are
    available. :class:`WSGIServer` also provides these WSGI-specific methods:
 
diff --git a/Doc/library/xmlrpc.client.rst b/Doc/library/xmlrpc.client.rst
index 7d59750..e249b12 100644
--- a/Doc/library/xmlrpc.client.rst
+++ b/Doc/library/xmlrpc.client.rst
@@ -506,14 +506,14 @@
 
 ::
 
-   import xmlrpc.client, httplib
+   import xmlrpc.client, http.client
 
    class ProxiedTransport(xmlrpc.client.Transport):
        def set_proxy(self, proxy):
            self.proxy = proxy
        def make_connection(self, host):
            self.realhost = host
-   	h = httplib.HTTP(self.proxy)
+   	h = http.client.HTTP(self.proxy)
    	return h
        def send_request(self, connection, handler, request_body):
            connection.putrequest("POST", 'http://%s%s' % (self.realhost, handler))
diff --git a/Doc/license.rst b/Doc/license.rst
index ed399dc..892b5ea 100644
--- a/Doc/license.rst
+++ b/Doc/license.rst
@@ -449,7 +449,7 @@
 Cookie management
 -----------------
 
-The :mod:`Cookie` module contains the following notice::
+The :mod:`http.cookies` module contains the following notice::
 
    Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu>