Merged revisions 57620-57771 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r57771 | thomas.wouters | 2007-08-30 23:54:39 +0200 (Thu, 30 Aug 2007) | 5 lines
Don't lie in __all__ attributes when SSL is not available: only add the SSL
classes when they are actually created.
........
r57620 | walter.doerwald | 2007-08-28 18:38:26 +0200 (Tue, 28 Aug 2007) | 5 lines
Fix title endtag in HTMLCalender.formatyearpage(). Fix documentation for
HTMLCalender.formatyearpage() (there's no themonth parameter).
This fixes issue1046.
........
r57622 | georg.brandl | 2007-08-28 20:54:44 +0200 (Tue, 28 Aug 2007) | 2 lines
Add a crasher for the thread-unsafety of file objects.
........
r57626 | skip.montanaro | 2007-08-29 01:22:52 +0200 (Wed, 29 Aug 2007) | 1 line
fixes 813986
........
r57628 | walter.doerwald | 2007-08-29 01:35:33 +0200 (Wed, 29 Aug 2007) | 2 lines
Fix test output.
........
r57631 | skip.montanaro | 2007-08-29 03:24:11 +0200 (Wed, 29 Aug 2007) | 2 lines
Install pygettext (once the scriptsinstall target is working again).
........
r57633 | skip.montanaro | 2007-08-29 03:33:45 +0200 (Wed, 29 Aug 2007) | 2 lines
Recent items.
........
r57650 | neal.norwitz | 2007-08-29 08:15:33 +0200 (Wed, 29 Aug 2007) | 1 line
Add Bill as a developer
........
r57651 | facundo.batista | 2007-08-29 12:28:28 +0200 (Wed, 29 Aug 2007) | 5 lines
Ignore test failures caused by 'resource temporarily unavailable'
exceptions raised during FailingServerTestCase tests.
[GSoC - Alan McIntyre]
........
r57680 | bill.janssen | 2007-08-30 00:35:05 +0200 (Thu, 30 Aug 2007) | 17 lines
This contains a number of things:
1) Improve the documentation of the SSL module, with a fuller
explanation of certificate usage, another reference, proper
formatting of this and that.
2) Fix Windows bug in ssl.py, and general bug in sslsocket.close().
Remove some unused code from ssl.py. Allow accept() to be called on
sslsocket sockets.
3) Use try-except-else in import of ssl in socket.py. Deprecate use of
socket.ssl().
4) Remove use of socket.ssl() in every library module, except for
test_socket_ssl.py and test_ssl.py.
........
r57714 | georg.brandl | 2007-08-30 12:09:42 +0200 (Thu, 30 Aug 2007) | 2 lines
Stronger urge to convert filenames to str before using them as argument to ZipFile.write().
........
r57716 | georg.brandl | 2007-08-30 12:38:56 +0200 (Thu, 30 Aug 2007) | 2 lines
Patch #1680959: add test suite for pipes module.
........
r57717 | georg.brandl | 2007-08-30 14:32:23 +0200 (Thu, 30 Aug 2007) | 3 lines
* Skip test_pipes on non-POSIX.
* Don't raise TestSkipped within a test function.
........
r57723 | mark.summerfield | 2007-08-30 17:03:03 +0200 (Thu, 30 Aug 2007) | 3 lines
Added more cross-references.
........
r57726 | walter.doerwald | 2007-08-30 17:30:09 +0200 (Thu, 30 Aug 2007) | 2 lines
Rewrap line.
........
r57727 | walter.doerwald | 2007-08-30 17:34:55 +0200 (Thu, 30 Aug 2007) | 2 lines
Set startinpos before calling the error handler.
........
r57730 | bill.janssen | 2007-08-30 19:07:28 +0200 (Thu, 30 Aug 2007) | 3 lines
Added docstrings to methods and functions.
........
r57743 | bill.janssen | 2007-08-30 20:08:06 +0200 (Thu, 30 Aug 2007) | 1 line
added note on new ssl module and deprecation of socket.ssl
........
r57747 | martin.v.loewis | 2007-08-30 20:14:01 +0200 (Thu, 30 Aug 2007) | 1 line
Fix popen usage.
........
r57748 | martin.v.loewis | 2007-08-30 20:15:22 +0200 (Thu, 30 Aug 2007) | 1 line
Fix typo.
........
r57750 | martin.v.loewis | 2007-08-30 20:25:47 +0200 (Thu, 30 Aug 2007) | 1 line
Bug #1746880: Correctly install DLLs into system32 folder on Win64.
........
r57760 | martin.v.loewis | 2007-08-30 21:04:09 +0200 (Thu, 30 Aug 2007) | 1 line
Bug #1709599: Run test_1565150 only if the file system is NTFS.
........
r57762 | martin.v.loewis | 2007-08-30 22:10:57 +0200 (Thu, 30 Aug 2007) | 2 lines
Bump autoconf minimum version to 2.61.
........
r57764 | lars.gustaebel | 2007-08-30 22:24:31 +0200 (Thu, 30 Aug 2007) | 2 lines
Warn about possible risks when extracting untrusted archives.
........
r57769 | thomas.wouters | 2007-08-30 23:01:17 +0200 (Thu, 30 Aug 2007) | 7 lines
Somewhat-preliminary slice-object and extended slicing support for ctypes.
The exact behaviour of omitted and negative indices for the Pointer type may
need a closer look (especially as it's subtly different from simple slices)
but there's time yet before 2.6, and not enough before 3.0a1 :-)
........
This commit is contained in:
Thomas Wouters
parent
cf1be88b43
commit
47b49bf6dc
|
|
@ -162,7 +162,7 @@ it's the base calendar for all computations.
|
||||||
the number of months per row.
|
the number of months per row.
|
||||||
|
|
||||||
|
|
||||||
.. method:: HTMLCalendar.formatyearpage(theyear, themonth[, width[, css[, encoding]]])
|
.. method:: HTMLCalendar.formatyearpage(theyear[, width[, css[, encoding]]])
|
||||||
|
|
||||||
Return a year's calendar as a complete HTML page. *width* (defaulting to 3)
|
Return a year's calendar as a complete HTML page. *width* (defaulting to 3)
|
||||||
specifies the number of months per row. *css* is the name for the cascading
|
specifies the number of months per row. *css* is the name for the cascading
|
||||||
|
|
|
||||||
|
|
@ -405,10 +405,14 @@ Setting the :attr:`default_factory` to :class:`set` makes the
|
||||||
print record
|
print record
|
||||||
|
|
||||||
To cast an individual record stored as :class:`list`, :class:`tuple`, or some
|
To cast an individual record stored as :class:`list`, :class:`tuple`, or some
|
||||||
other iterable type, use the star-operator to unpack the values::
|
other iterable type, use the star-operator [#]_ to unpack the values::
|
||||||
|
|
||||||
>>> Color = NamedTuple('Color', 'name code')
|
>>> Color = NamedTuple('Color', 'name code')
|
||||||
>>> m = dict(red=1, green=2, blue=3)
|
>>> m = dict(red=1, green=2, blue=3)
|
||||||
>>> print Color(*m.popitem())
|
>>> print Color(*m.popitem())
|
||||||
Color(name='blue', code=3)
|
Color(name='blue', code=3)
|
||||||
|
|
||||||
|
.. rubric:: Footnotes
|
||||||
|
|
||||||
|
.. [#] For information on the star-operator see
|
||||||
|
:ref:`tut-unpacking-arguments` and :ref:`calls`.
|
||||||
|
|
|
||||||
|
|
@ -12,8 +12,8 @@ numbers representations in 100% pure Python.
|
||||||
|
|
||||||
.. note::
|
.. note::
|
||||||
|
|
||||||
This module is unneeded: everything here could be done via the ``%`` string
|
This module is unnecessary: everything here can be done using the ``%`` string
|
||||||
interpolation operator.
|
interpolation operator described in the :ref:`string-formatting` section.
|
||||||
|
|
||||||
The :mod:`fpformat` module defines the following functions and an exception:
|
The :mod:`fpformat` module defines the following functions and an exception:
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -1,12 +1,16 @@
|
||||||
|
|
||||||
:mod:`ssl` --- SSL wrapper for socket objects, and utility functions
|
:mod:`ssl` --- SSL wrapper for socket objects
|
||||||
====================================================================
|
====================================================================
|
||||||
|
|
||||||
.. module:: ssl
|
.. module:: ssl
|
||||||
:synopsis: SSL wrapper for socket objects, and utility functions
|
:synopsis: SSL wrapper for socket objects
|
||||||
|
|
||||||
|
.. moduleauthor:: Bill Janssen <bill.janssen@gmail.com>
|
||||||
|
|
||||||
.. versionadded:: 2.6
|
.. versionadded:: 2.6
|
||||||
|
|
||||||
|
.. sectionauthor:: Bill Janssen <bill.janssen@gmail.com>
|
||||||
|
|
||||||
|
|
||||||
This module provides access to Transport Layer Security (often known
|
This module provides access to Transport Layer Security (often known
|
||||||
as "Secure Sockets Layer") encryption and peer authentication
|
as "Secure Sockets Layer") encryption and peer authentication
|
||||||
|
|
@ -20,10 +24,9 @@ platforms, as long as OpenSSL is installed on that platform.
|
||||||
Some behavior may be platform dependent, since calls are made to the operating
|
Some behavior may be platform dependent, since calls are made to the operating
|
||||||
system socket APIs.
|
system socket APIs.
|
||||||
|
|
||||||
This section documents the objects and functions in the `ssl` module;
|
This section documents the objects and functions in the ``ssl`` module;
|
||||||
for more general information about TLS, SSL, and certificates, the
|
for more general information about TLS, SSL, and certificates, the
|
||||||
reader is referred to the paper, *Introducing SSL and Certificates using OpenSSL*, by Frederick J. Hirsch, at
|
reader is referred to the documents in the :ref:`ssl-references` section.
|
||||||
http://old.pseudonym.org/ssl/wwwj-index.html.
|
|
||||||
|
|
||||||
This module defines a class, :class:`ssl.sslsocket`, which is
|
This module defines a class, :class:`ssl.sslsocket`, which is
|
||||||
derived from the :class:`socket.socket` type, and supports additional
|
derived from the :class:`socket.socket` type, and supports additional
|
||||||
|
|
@ -57,25 +60,25 @@ This module defines the following functions, exceptions, and constants:
|
||||||
|
|
||||||
.. data:: CERT_NONE
|
.. data:: CERT_NONE
|
||||||
|
|
||||||
Value to pass to the `cert_reqs` parameter to :func:`sslobject`
|
Value to pass to the ``cert_reqs`` parameter to :func:`sslobject`
|
||||||
when no certificates will be required or validated from the other
|
when no certificates will be required or validated from the other
|
||||||
side of the socket connection.
|
side of the socket connection.
|
||||||
|
|
||||||
.. data:: CERT_OPTIONAL
|
.. data:: CERT_OPTIONAL
|
||||||
|
|
||||||
Value to pass to the `cert_reqs` parameter to :func:`sslobject`
|
Value to pass to the ``cert_reqs`` parameter to :func:`sslobject`
|
||||||
when no certificates will be required from the other side of the
|
when no certificates will be required from the other side of the
|
||||||
socket connection, but if they are provided, will be validated.
|
socket connection, but if they are provided, will be validated.
|
||||||
Note that use of this setting requires a valid certificate
|
Note that use of this setting requires a valid certificate
|
||||||
validation file also be passed as a value of the `ca_certs`
|
validation file also be passed as a value of the ``ca_certs``
|
||||||
parameter.
|
parameter.
|
||||||
|
|
||||||
.. data:: CERT_REQUIRED
|
.. data:: CERT_REQUIRED
|
||||||
|
|
||||||
Value to pass to the `cert_reqs` parameter to :func:`sslobject`
|
Value to pass to the ``cert_reqs`` parameter to :func:`sslobject`
|
||||||
when certificates will be required from the other side of the
|
when certificates will be required from the other side of the
|
||||||
socket connection. Note that use of this setting requires a valid certificate
|
socket connection. Note that use of this setting requires a valid certificate
|
||||||
validation file also be passed as a value of the `ca_certs`
|
validation file also be passed as a value of the ``ca_certs``
|
||||||
parameter.
|
parameter.
|
||||||
|
|
||||||
.. data:: PROTOCOL_SSLv2
|
.. data:: PROTOCOL_SSLv2
|
||||||
|
|
@ -99,10 +102,12 @@ This module defines the following functions, exceptions, and constants:
|
||||||
protection, if both sides can speak it.
|
protection, if both sides can speak it.
|
||||||
|
|
||||||
|
|
||||||
|
.. _ssl-certificates:
|
||||||
|
|
||||||
Certificates
|
Certificates
|
||||||
------------
|
------------
|
||||||
|
|
||||||
Certificates in general are part of a public-key / private-key system. In this system, each `principal`,
|
Certificates in general are part of a public-key / private-key system. In this system, each *principal*,
|
||||||
(which may be a machine, or a person, or an organization) is assigned a unique two-part encryption key.
|
(which may be a machine, or a person, or an organization) is assigned a unique two-part encryption key.
|
||||||
One part of the key is public, and is called the *public key*; the other part is kept secret, and is called
|
One part of the key is public, and is called the *public key*; the other part is kept secret, and is called
|
||||||
the *private key*. The two parts are related, in that if you encrypt a message with one of the parts, you can
|
the *private key*. The two parts are related, in that if you encrypt a message with one of the parts, you can
|
||||||
|
|
@ -120,17 +125,54 @@ the certificate. The certificate also contains information about the
|
||||||
time period over which it is valid. This is expressed as two fields,
|
time period over which it is valid. This is expressed as two fields,
|
||||||
called "notBefore" and "notAfter".
|
called "notBefore" and "notAfter".
|
||||||
|
|
||||||
The underlying system which is used in the Python SSL support is
|
In the Python use of certificates, a client or server
|
||||||
called "OpenSSL". It contains facilities for constructing and
|
can use a certificate to prove who they are. The other
|
||||||
validating certificates. In the Python use of certificates, the other
|
side of a network connection can also be required to produce a certificate,
|
||||||
side of a network connection can be required to produce a certificate,
|
and that certificate can be validated to the satisfaction
|
||||||
and that certificate can be validated against a file filled with
|
of the client or server that requires such validation.
|
||||||
self-signed *root* certificates (so-called because the issuer is the
|
The connection can be set to fail automatically if such
|
||||||
same as the subject), and and "CA" (certification authority)
|
validation is not achieved.
|
||||||
certificates assured by those root certificates (and by other CA
|
|
||||||
certificates). Either side of a connection, client or server, can
|
Python uses files to contain certificates. They should be formatted
|
||||||
request certificates and validation, and the connection can be optionally
|
as "PEM" (see :rfc:`1422`), which is a base-64 encoded form wrapped
|
||||||
set up to fail if a valid certificate is not presented by the other side.
|
with a header line and a footer line::
|
||||||
|
|
||||||
|
-----BEGIN CERTIFICATE-----
|
||||||
|
... (certificate in base64 PEM encoding) ...
|
||||||
|
-----END CERTIFICATE-----
|
||||||
|
|
||||||
|
The Python files which contain certificates can contain a sequence
|
||||||
|
of certificates, sometimes called a *certificate chain*. This chain
|
||||||
|
should start with the specific certificate for the principal who "is"
|
||||||
|
the client or server, and then the certificate for the issuer of that
|
||||||
|
certificate, and then the certificate for the issuer of *that* certificate,
|
||||||
|
and so on up the chain till you get to a certificate which is *self-signed*,
|
||||||
|
that is, a certificate which has the same subject and issuer,
|
||||||
|
sometimes called a *root certificate*. The certificates should just
|
||||||
|
be concatenated together in the certificate file. For example, suppose
|
||||||
|
we had a three certificate chain, from our server certificate to the
|
||||||
|
certificate of the certification authority that signed our server certificate,
|
||||||
|
to the root certificate of the agency which issued the certification authority's
|
||||||
|
certificate::
|
||||||
|
|
||||||
|
-----BEGIN CERTIFICATE-----
|
||||||
|
... (certificate for your server)...
|
||||||
|
-----END CERTIFICATE-----
|
||||||
|
-----BEGIN CERTIFICATE-----
|
||||||
|
... (the certificate for the CA)...
|
||||||
|
-----END CERTIFICATE-----
|
||||||
|
-----BEGIN CERTIFICATE-----
|
||||||
|
... (the root certificate for the CA's issuer)...
|
||||||
|
-----END CERTIFICATE-----
|
||||||
|
|
||||||
|
If you are going to require validation of the other side of the connection's
|
||||||
|
certificate, you need to provide a "CA certs" file, filled with the certificate
|
||||||
|
chains for each issuer you are willing to trust. Again, this file just
|
||||||
|
contains these chains concatenated together. For validation, Python will
|
||||||
|
use the first chain it finds in the file which matches.
|
||||||
|
Some "standard" root certificates are available at
|
||||||
|
http://www.thawte.com/roots/ (for Thawte roots) and
|
||||||
|
http://www.verisign.com/support/roots.html (for Verisign roots).
|
||||||
|
|
||||||
|
|
||||||
sslsocket Objects
|
sslsocket Objects
|
||||||
|
|
@ -138,76 +180,67 @@ sslsocket Objects
|
||||||
|
|
||||||
.. class:: sslsocket(sock [, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None])
|
.. class:: sslsocket(sock [, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None])
|
||||||
|
|
||||||
Takes an instance *sock* of :class:`socket.socket`, and returns an instance of a subtype
|
Takes an instance ``sock`` of :class:`socket.socket`, and returns an instance of a subtype
|
||||||
of :class:`socket.socket` which wraps the underlying socket in an SSL context.
|
of :class:`socket.socket` which wraps the underlying socket in an SSL context.
|
||||||
For client-side sockets, the context construction is lazy; if the underlying socket isn't
|
For client-side sockets, the context construction is lazy; if the underlying socket isn't
|
||||||
connected yet, the context construction will be performed after :meth:`connect` is called
|
connected yet, the context construction will be performed after :meth:`connect` is called
|
||||||
on the socket.
|
on the socket.
|
||||||
|
|
||||||
The `keyfile` and `certfile` parameters specify optional files which contain a certificate
|
The ``keyfile`` and ``certfile`` parameters specify optional files which contain a certificate
|
||||||
to be used to identify the local side of the connection. Often the private key is stored
|
to be used to identify the local side of the connection. See the above discussion of :ref:`ssl-certificates`
|
||||||
in the same file as the certificate; in this case, only the `certfile` parameter need be
|
for more information on how the certificate is stored in the ``certfile``.
|
||||||
passed. If the private key is stored in a separate file, both parameters must be used.
|
|
||||||
|
|
||||||
The parameter `server_side` is a boolean which identifies whether server-side or client-side
|
Often the private key is stored
|
||||||
|
in the same file as the certificate; in this case, only the ``certfile`` parameter need be
|
||||||
|
passed. If the private key is stored in a separate file, both parameters must be used.
|
||||||
|
If the private key is stored in the ``certfile``, it should come before the first certificate
|
||||||
|
in the certificate chain::
|
||||||
|
|
||||||
|
-----BEGIN RSA PRIVATE KEY-----
|
||||||
|
... (private key in base64 encoding) ...
|
||||||
|
-----END RSA PRIVATE KEY-----
|
||||||
|
-----BEGIN CERTIFICATE-----
|
||||||
|
... (certificate in base64 PEM encoding) ...
|
||||||
|
-----END CERTIFICATE-----
|
||||||
|
|
||||||
|
The parameter ``server_side`` is a boolean which identifies whether server-side or client-side
|
||||||
behavior is desired from this socket.
|
behavior is desired from this socket.
|
||||||
|
|
||||||
The parameter `cert_reqs` specifies whether a certificate is
|
The parameter ``cert_reqs`` specifies whether a certificate is
|
||||||
required from the other side of the connection, and whether it will
|
required from the other side of the connection, and whether it will
|
||||||
be validated if provided. It must be one of the three values
|
be validated if provided. It must be one of the three values
|
||||||
:const:`CERT_NONE` (certificates ignored), :const:`CERT_OPTIONAL` (not required,
|
:const:`CERT_NONE` (certificates ignored), :const:`CERT_OPTIONAL` (not required,
|
||||||
but validated if provided), or :const:`CERT_REQUIRED` (required and
|
but validated if provided), or :const:`CERT_REQUIRED` (required and
|
||||||
validated). If the value of this parameter is not :const:`CERT_NONE`, then
|
validated). If the value of this parameter is not :const:`CERT_NONE`, then
|
||||||
the `ca_certs` parameter must point to a file of CA certificates.
|
the ``ca_certs`` parameter must point to a file of CA certificates.
|
||||||
|
|
||||||
The parameter `ssl_version` specifies which version of the SSL protocol to use. Typically,
|
The parameter ``ssl_version`` specifies which version of the SSL protocol to use. Typically,
|
||||||
the server specifies this, and a client connecting to it must use the same protocol. An
|
the server specifies this, and a client connecting to it must use the same protocol. An
|
||||||
SSL server using :const:`PROTOCOL_SSLv23` can understand a client connecting via SSL2, SSL3, or TLS1,
|
SSL server using :const:`PROTOCOL_SSLv23` can understand a client connecting via SSL2, SSL3, or TLS1,
|
||||||
but a client using :const:`PROTOCOL_SSLv23` can only connect to an SSL2 server.
|
but a client using :const:`PROTOCOL_SSLv23` can only connect to an SSL2 server.
|
||||||
|
|
||||||
The `ca_certs` file contains a set of concatenated "certification authority" certificates,
|
The ``ca_certs`` file contains a set of concatenated "certification authority" certificates,
|
||||||
which are used to validate certificates passed from the other end of the connection.
|
which are used to validate certificates passed from the other end of the connection.
|
||||||
This file
|
See the above discussion of :ref:`ssl-certificates` for more information about how to arrange
|
||||||
contains the certificates in PEM format (IETF RFC 1422) where each certificate is
|
the certificates in this file.
|
||||||
encoded in base64 encoding and surrounded with a header and footer::
|
|
||||||
|
|
||||||
-----BEGIN CERTIFICATE-----
|
|
||||||
... (CA certificate in base64 encoding) ...
|
|
||||||
-----END CERTIFICATE-----
|
|
||||||
|
|
||||||
The various certificates in the file are just concatenated together::
|
|
||||||
|
|
||||||
-----BEGIN CERTIFICATE-----
|
|
||||||
... (CA certificate in base64 encoding) ...
|
|
||||||
-----END CERTIFICATE-----
|
|
||||||
-----BEGIN CERTIFICATE-----
|
|
||||||
... (a second CA certificate in base64 encoding) ...
|
|
||||||
-----END CERTIFICATE-----
|
|
||||||
-----BEGIN CERTIFICATE-----
|
|
||||||
... (a root certificate in base64 encoding) ...
|
|
||||||
-----END CERTIFICATE-----
|
|
||||||
|
|
||||||
Some "standard" root certificates are available at
|
|
||||||
http://www.thawte.com/roots/ (for Thawte roots) and
|
|
||||||
http://www.verisign.com/support/roots.html (for Verisign roots).
|
|
||||||
|
|
||||||
.. method:: sslsocket.read([nbytes])
|
.. method:: sslsocket.read([nbytes])
|
||||||
|
|
||||||
Reads up to `nbytes` bytes from the SSL-encrypted channel and returns them.
|
Reads up to ``nbytes`` bytes from the SSL-encrypted channel and returns them.
|
||||||
|
|
||||||
.. method:: sslsocket.write(data)
|
.. method:: sslsocket.write(data)
|
||||||
|
|
||||||
Writes the `data` to the other side of the connection, using the SSL channel to encrypt. Returns the number
|
Writes the ``data`` to the other side of the connection, using the SSL channel to encrypt. Returns the number
|
||||||
of bytes written.
|
of bytes written.
|
||||||
|
|
||||||
.. method:: sslsocket.getpeercert()
|
.. method:: sslsocket.getpeercert()
|
||||||
|
|
||||||
If there is no certificate for the peer on the other end of the connection, returns `None`.
|
If there is no certificate for the peer on the other end of the connection, returns ``None``.
|
||||||
If a certificate was received from the peer, but not validated, returns an empty `dict` instance.
|
If a certificate was received from the peer, but not validated, returns an empty ``dict`` instance.
|
||||||
If a certificate was received and validated, returns a `dict` instance with the fields
|
If a certificate was received and validated, returns a ``dict`` instance with the fields
|
||||||
`subject` (the principal for which the certificate was issued), `issuer` (the signer of
|
``subject`` (the principal for which the certificate was issued), ``issuer`` (the signer of
|
||||||
the certificate), `notBefore` (the time before which the certificate should not be trusted),
|
the certificate), ``notBefore`` (the time before which the certificate should not be trusted),
|
||||||
and `notAfter` (the time after which the certificate should not be trusted) filled in.
|
and ``notAfter`` (the time after which the certificate should not be trusted) filled in.
|
||||||
|
|
||||||
The "subject" and "issuer" fields are themselves dictionaries containing the fields given
|
The "subject" and "issuer" fields are themselves dictionaries containing the fields given
|
||||||
in the certificate's data structure for each principal::
|
in the certificate's data structure for each principal::
|
||||||
|
|
@ -229,12 +262,34 @@ sslsocket Objects
|
||||||
'version': 2}
|
'version': 2}
|
||||||
|
|
||||||
This certificate is said to be *self-signed*, because the subject
|
This certificate is said to be *self-signed*, because the subject
|
||||||
and issuer are the same entity. The *version* field refers the the X509 version
|
and issuer are the same entity. The *version* field refers to the X509 version
|
||||||
that's used for the certificate.
|
that's used for the certificate.
|
||||||
|
|
||||||
|
.. method:: sslsocket.ssl_shutdown()
|
||||||
|
|
||||||
|
Closes the SSL context (if any) over the socket, but leaves the socket connection
|
||||||
|
open for further use, if both sides are willing. This is different from :meth:`socket.socket.shutdown`,
|
||||||
|
which will close the connection, but leave the local socket available for further use.
|
||||||
|
|
||||||
|
|
||||||
Examples
|
Examples
|
||||||
--------
|
--------
|
||||||
|
|
||||||
|
Testing for SSL support
|
||||||
|
^^^^^^^^^^^^^^^^^^^^^^^
|
||||||
|
|
||||||
|
To test for the presence of SSL support in a Python installation, user code should use the following idiom::
|
||||||
|
|
||||||
|
try:
|
||||||
|
import ssl
|
||||||
|
except ImportError:
|
||||||
|
pass
|
||||||
|
else:
|
||||||
|
[ do something that requires SSL support ]
|
||||||
|
|
||||||
|
Client-side operation
|
||||||
|
^^^^^^^^^^^^^^^^^^^^^
|
||||||
|
|
||||||
This example connects to an SSL server, prints the server's address and certificate,
|
This example connects to an SSL server, prints the server's address and certificate,
|
||||||
sends some bytes, and reads part of the response::
|
sends some bytes, and reads part of the response::
|
||||||
|
|
||||||
|
|
@ -281,6 +336,9 @@ looked like this::
|
||||||
'notBefore': 'May 9 00:00:00 2007 GMT',
|
'notBefore': 'May 9 00:00:00 2007 GMT',
|
||||||
'version': 2}
|
'version': 2}
|
||||||
|
|
||||||
|
Server-side operation
|
||||||
|
^^^^^^^^^^^^^^^^^^^^^
|
||||||
|
|
||||||
For server operation, typically you'd need to have a server certificate, and private key, each in a file.
|
For server operation, typically you'd need to have a server certificate, and private key, each in a file.
|
||||||
You'd open a socket, bind it to a port, call :meth:`listen` on it, then start waiting for clients
|
You'd open a socket, bind it to a port, call :meth:`listen` on it, then start waiting for clients
|
||||||
to connect::
|
to connect::
|
||||||
|
|
@ -300,7 +358,7 @@ end, and use :func:`sslsocket` to create a server-side SSL context for it::
|
||||||
keyfile="mykeyfile", ssl_protocol=ssl.PROTOCOL_TLSv1)
|
keyfile="mykeyfile", ssl_protocol=ssl.PROTOCOL_TLSv1)
|
||||||
deal_with_client(connstream)
|
deal_with_client(connstream)
|
||||||
|
|
||||||
Then you'd read data from the `connstream` and do something with it till you are finished with the client (or the client is finished with you)::
|
Then you'd read data from the ``connstream`` and do something with it till you are finished with the client (or the client is finished with you)::
|
||||||
|
|
||||||
def deal_with_client(connstream):
|
def deal_with_client(connstream):
|
||||||
|
|
||||||
|
|
@ -317,3 +375,14 @@ Then you'd read data from the `connstream` and do something with it till you are
|
||||||
And go back to listening for new client connections.
|
And go back to listening for new client connections.
|
||||||
|
|
||||||
|
|
||||||
|
.. _ssl-references:
|
||||||
|
|
||||||
|
References
|
||||||
|
----------
|
||||||
|
|
||||||
|
Class :class:`socket.socket`
|
||||||
|
Documentation of underlying :mod:`socket` class
|
||||||
|
|
||||||
|
`Introducing SSL and Certificates using OpenSSL <http://old.pseudonym.org/ssl/wwwj-index.html>`_, by Frederick J. Hirsch
|
||||||
|
|
||||||
|
`Privacy Enhancement for Internet Electronic Mail: Part II: Certificate-Based Key Management`, :rfc:`1422`, by Steve Kent
|
||||||
|
|
|
||||||
|
|
@ -8,7 +8,8 @@
|
||||||
|
|
||||||
This module implements a file-like class, :class:`StringIO`, that reads and
|
This module implements a file-like class, :class:`StringIO`, that reads and
|
||||||
writes a string buffer (also known as *memory files*). See the description of
|
writes a string buffer (also known as *memory files*). See the description of
|
||||||
file objects for operations (section :ref:`bltin-file-objects`).
|
file objects for operations (section :ref:`bltin-file-objects`). (For
|
||||||
|
standard strings, see :class:`str` and :class:`unicode`.)
|
||||||
|
|
||||||
|
|
||||||
.. class:: StringIO([buffer])
|
.. class:: StringIO([buffer])
|
||||||
|
|
|
||||||
|
|
@ -338,6 +338,13 @@ object, see :ref:`tarinfo-objects` for details.
|
||||||
reset each time a file is created in it. And, if a directory's permissions do
|
reset each time a file is created in it. And, if a directory's permissions do
|
||||||
not allow writing, extracting files to it will fail.
|
not allow writing, extracting files to it will fail.
|
||||||
|
|
||||||
|
.. warning::
|
||||||
|
|
||||||
|
Never extract archives from untrusted sources without prior inspection.
|
||||||
|
It is possible that files are created outside of *path*, e.g. members
|
||||||
|
that have absolute filenames starting with ``"/"`` or filenames with two
|
||||||
|
dots ``".."``.
|
||||||
|
|
||||||
.. versionadded:: 2.5
|
.. versionadded:: 2.5
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -354,6 +361,10 @@ object, see :ref:`tarinfo-objects` for details.
|
||||||
are some issues you must take care of yourself. See the description for
|
are some issues you must take care of yourself. See the description for
|
||||||
:meth:`extractall` above.
|
:meth:`extractall` above.
|
||||||
|
|
||||||
|
.. warning::
|
||||||
|
|
||||||
|
See the warning for :meth:`extractall`.
|
||||||
|
|
||||||
|
|
||||||
.. method:: TarFile.extractfile(member)
|
.. method:: TarFile.extractfile(member)
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -223,7 +223,7 @@ ZipFile Objects
|
||||||
.. note::
|
.. note::
|
||||||
|
|
||||||
There is no official file name encoding for ZIP files. If you have unicode file
|
There is no official file name encoding for ZIP files. If you have unicode file
|
||||||
names, please convert them to byte strings in your desired encoding before
|
names, you must convert them to byte strings in your desired encoding before
|
||||||
passing them to :meth:`write`. WinZip interprets all file names as encoded in
|
passing them to :meth:`write`. WinZip interprets all file names as encoded in
|
||||||
CP437, also known as DOS Latin.
|
CP437, also known as DOS Latin.
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -471,7 +471,7 @@ class HTMLCalendar(Calendar):
|
||||||
a('<meta http-equiv="Content-Type" content="text/html; charset=%s" />\n' % encoding)
|
a('<meta http-equiv="Content-Type" content="text/html; charset=%s" />\n' % encoding)
|
||||||
if css is not None:
|
if css is not None:
|
||||||
a('<link rel="stylesheet" type="text/css" href="%s" />\n' % css)
|
a('<link rel="stylesheet" type="text/css" href="%s" />\n' % css)
|
||||||
a('<title>Calendar for %d</title\n' % theyear)
|
a('<title>Calendar for %d</title>\n' % theyear)
|
||||||
a('</head>\n')
|
a('</head>\n')
|
||||||
a('<body>\n')
|
a('<body>\n')
|
||||||
a(self.formatyear(theyear, width))
|
a(self.formatyear(theyear, width))
|
||||||
|
|
|
||||||
|
|
@ -95,6 +95,10 @@ class ArrayTestCase(unittest.TestCase):
|
||||||
p = create_string_buffer("foo")
|
p = create_string_buffer("foo")
|
||||||
sz = (c_char * 3).from_address(addressof(p))
|
sz = (c_char * 3).from_address(addressof(p))
|
||||||
self.failUnlessEqual(sz[:], "foo")
|
self.failUnlessEqual(sz[:], "foo")
|
||||||
|
self.failUnlessEqual(sz[::], "foo")
|
||||||
|
self.failUnlessEqual(sz[::-1], "oof")
|
||||||
|
self.failUnlessEqual(sz[::3], "f")
|
||||||
|
self.failUnlessEqual(sz[1:4:2], "o")
|
||||||
self.failUnlessEqual(sz.value, "foo")
|
self.failUnlessEqual(sz.value, "foo")
|
||||||
|
|
||||||
try:
|
try:
|
||||||
|
|
@ -106,6 +110,10 @@ class ArrayTestCase(unittest.TestCase):
|
||||||
p = create_unicode_buffer("foo")
|
p = create_unicode_buffer("foo")
|
||||||
sz = (c_wchar * 3).from_address(addressof(p))
|
sz = (c_wchar * 3).from_address(addressof(p))
|
||||||
self.failUnlessEqual(sz[:], "foo")
|
self.failUnlessEqual(sz[:], "foo")
|
||||||
|
self.failUnlessEqual(sz[::], "foo")
|
||||||
|
self.failUnlessEqual(sz[::-1], "oof")
|
||||||
|
self.failUnlessEqual(sz[::3], "f")
|
||||||
|
self.failUnlessEqual(sz[1:4:2], "o")
|
||||||
self.failUnlessEqual(sz.value, "foo")
|
self.failUnlessEqual(sz.value, "foo")
|
||||||
|
|
||||||
if __name__ == '__main__':
|
if __name__ == '__main__':
|
||||||
|
|
|
||||||
|
|
@ -15,6 +15,10 @@ class StringBufferTestCase(unittest.TestCase):
|
||||||
self.failUnless(type(b[0]) is bytes)
|
self.failUnless(type(b[0]) is bytes)
|
||||||
self.failUnlessEqual(b[0], b"a")
|
self.failUnlessEqual(b[0], b"a")
|
||||||
self.failUnlessEqual(b[:], "abc\0")
|
self.failUnlessEqual(b[:], "abc\0")
|
||||||
|
self.failUnlessEqual(b[::], "abc\0")
|
||||||
|
self.failUnlessEqual(b[::-1], "\0cba")
|
||||||
|
self.failUnlessEqual(b[::2], "ac")
|
||||||
|
self.failUnlessEqual(b[::5], "a")
|
||||||
|
|
||||||
def test_string_conversion(self):
|
def test_string_conversion(self):
|
||||||
b = create_string_buffer("abc")
|
b = create_string_buffer("abc")
|
||||||
|
|
@ -23,6 +27,10 @@ class StringBufferTestCase(unittest.TestCase):
|
||||||
self.failUnless(type(b[0]) is bytes)
|
self.failUnless(type(b[0]) is bytes)
|
||||||
self.failUnlessEqual(b[0], b"a")
|
self.failUnlessEqual(b[0], b"a")
|
||||||
self.failUnlessEqual(b[:], "abc\0")
|
self.failUnlessEqual(b[:], "abc\0")
|
||||||
|
self.failUnlessEqual(b[::], "abc\0")
|
||||||
|
self.failUnlessEqual(b[::-1], "\0cba")
|
||||||
|
self.failUnlessEqual(b[::2], "ac")
|
||||||
|
self.failUnlessEqual(b[::5], "a")
|
||||||
|
|
||||||
try:
|
try:
|
||||||
c_wchar
|
c_wchar
|
||||||
|
|
@ -41,6 +49,10 @@ class StringBufferTestCase(unittest.TestCase):
|
||||||
self.failUnless(type(b[0]) is str)
|
self.failUnless(type(b[0]) is str)
|
||||||
self.failUnlessEqual(b[0], "a")
|
self.failUnlessEqual(b[0], "a")
|
||||||
self.failUnlessEqual(b[:], "abc\0")
|
self.failUnlessEqual(b[:], "abc\0")
|
||||||
|
self.failUnlessEqual(b[::], "abc\0")
|
||||||
|
self.failUnlessEqual(b[::-1], "\0cba")
|
||||||
|
self.failUnlessEqual(b[::2], "ac")
|
||||||
|
self.failUnlessEqual(b[::5], "a")
|
||||||
|
|
||||||
def test_unicode_conversion(self):
|
def test_unicode_conversion(self):
|
||||||
b = create_unicode_buffer("abc")
|
b = create_unicode_buffer("abc")
|
||||||
|
|
@ -49,6 +61,10 @@ class StringBufferTestCase(unittest.TestCase):
|
||||||
self.failUnless(type(b[0]) is str)
|
self.failUnless(type(b[0]) is str)
|
||||||
self.failUnlessEqual(b[0], "a")
|
self.failUnlessEqual(b[0], "a")
|
||||||
self.failUnlessEqual(b[:], "abc\0")
|
self.failUnlessEqual(b[:], "abc\0")
|
||||||
|
self.failUnlessEqual(b[::], "abc\0")
|
||||||
|
self.failUnlessEqual(b[::-1], "\0cba")
|
||||||
|
self.failUnlessEqual(b[::2], "ac")
|
||||||
|
self.failUnlessEqual(b[::5], "a")
|
||||||
|
|
||||||
if __name__ == "__main__":
|
if __name__ == "__main__":
|
||||||
unittest.main()
|
unittest.main()
|
||||||
|
|
|
||||||
|
|
@ -50,12 +50,24 @@ class Test(unittest.TestCase):
|
||||||
def test_other(self):
|
def test_other(self):
|
||||||
p = cast((c_int * 4)(1, 2, 3, 4), POINTER(c_int))
|
p = cast((c_int * 4)(1, 2, 3, 4), POINTER(c_int))
|
||||||
self.failUnlessEqual(p[:4], [1,2, 3, 4])
|
self.failUnlessEqual(p[:4], [1,2, 3, 4])
|
||||||
|
self.failUnlessEqual(p[:4:], [1, 2, 3, 4])
|
||||||
|
self.failUnlessEqual(p[3:-1:-1], [4, 3, 2, 1])
|
||||||
|
self.failUnlessEqual(p[:4:3], [1, 4])
|
||||||
c_int()
|
c_int()
|
||||||
self.failUnlessEqual(p[:4], [1, 2, 3, 4])
|
self.failUnlessEqual(p[:4], [1, 2, 3, 4])
|
||||||
|
self.failUnlessEqual(p[:4:], [1, 2, 3, 4])
|
||||||
|
self.failUnlessEqual(p[3:-1:-1], [4, 3, 2, 1])
|
||||||
|
self.failUnlessEqual(p[:4:3], [1, 4])
|
||||||
p[2] = 96
|
p[2] = 96
|
||||||
self.failUnlessEqual(p[:4], [1, 2, 96, 4])
|
self.failUnlessEqual(p[:4], [1, 2, 96, 4])
|
||||||
|
self.failUnlessEqual(p[:4:], [1, 2, 96, 4])
|
||||||
|
self.failUnlessEqual(p[3:-1:-1], [4, 96, 2, 1])
|
||||||
|
self.failUnlessEqual(p[:4:3], [1, 4])
|
||||||
c_int()
|
c_int()
|
||||||
self.failUnlessEqual(p[:4], [1, 2, 96, 4])
|
self.failUnlessEqual(p[:4], [1, 2, 96, 4])
|
||||||
|
self.failUnlessEqual(p[:4:], [1, 2, 96, 4])
|
||||||
|
self.failUnlessEqual(p[3:-1:-1], [4, 96, 2, 1])
|
||||||
|
self.failUnlessEqual(p[:4:3], [1, 4])
|
||||||
|
|
||||||
def test_char_p(self):
|
def test_char_p(self):
|
||||||
# This didn't work: bad argument to internal function
|
# This didn't work: bad argument to internal function
|
||||||
|
|
|
||||||
|
|
@ -30,6 +30,14 @@ class MemFunctionsTest(unittest.TestCase):
|
||||||
self.failUnlessEqual(cast(a, c_char_p).value, "abcdef")
|
self.failUnlessEqual(cast(a, c_char_p).value, "abcdef")
|
||||||
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7],
|
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7],
|
||||||
[97, 98, 99, 100, 101, 102, 0])
|
[97, 98, 99, 100, 101, 102, 0])
|
||||||
|
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7:],
|
||||||
|
[97, 98, 99, 100, 101, 102, 0])
|
||||||
|
self.failUnlessEqual(cast(a, POINTER(c_byte))[6:-1:-1],
|
||||||
|
[0, 102, 101, 100, 99, 98, 97])
|
||||||
|
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7:2],
|
||||||
|
[97, 99, 101, 0])
|
||||||
|
self.failUnlessEqual(cast(a, POINTER(c_byte))[:7:7],
|
||||||
|
[97])
|
||||||
|
|
||||||
def test_string_at(self):
|
def test_string_at(self):
|
||||||
s = string_at(b"foo bar")
|
s = string_at(b"foo bar")
|
||||||
|
|
|
||||||
|
|
@ -8,13 +8,22 @@ class SlicesTestCase(unittest.TestCase):
|
||||||
a = (c_int * 100)(*range(1100, 1200))
|
a = (c_int * 100)(*range(1100, 1200))
|
||||||
b = list(range(1100, 1200))
|
b = list(range(1100, 1200))
|
||||||
self.failUnlessEqual(a[0:2], b[0:2])
|
self.failUnlessEqual(a[0:2], b[0:2])
|
||||||
|
self.failUnlessEqual(a[0:2:], b[0:2:])
|
||||||
self.failUnlessEqual(len(a), len(b))
|
self.failUnlessEqual(len(a), len(b))
|
||||||
self.failUnlessEqual(a[5:7], b[5:7])
|
self.failUnlessEqual(a[5:7], b[5:7])
|
||||||
|
self.failUnlessEqual(a[5:7:], b[5:7:])
|
||||||
self.failUnlessEqual(a[-1], b[-1])
|
self.failUnlessEqual(a[-1], b[-1])
|
||||||
self.failUnlessEqual(a[:], b[:])
|
self.failUnlessEqual(a[:], b[:])
|
||||||
|
self.failUnlessEqual(a[::], b[::])
|
||||||
|
self.failUnlessEqual(a[10::-1], b[10::-1])
|
||||||
|
self.failUnlessEqual(a[30:20:-1], b[30:20:-1])
|
||||||
|
self.failUnlessEqual(a[:12:6], b[:12:6])
|
||||||
|
self.failUnlessEqual(a[2:6:4], b[2:6:4])
|
||||||
|
|
||||||
a[0:5] = range(5, 10)
|
a[0:5] = range(5, 10)
|
||||||
self.failUnlessEqual(a[0:5], list(range(5, 10)))
|
self.failUnlessEqual(a[0:5], list(range(5, 10)))
|
||||||
|
self.failUnlessEqual(a[0:5:], list(range(5, 10)))
|
||||||
|
self.failUnlessEqual(a[4::-1], list(range(9, 4, -1)))
|
||||||
|
|
||||||
def test_setslice_cint(self):
|
def test_setslice_cint(self):
|
||||||
a = (c_int * 100)(*range(1100, 1200))
|
a = (c_int * 100)(*range(1100, 1200))
|
||||||
|
|
@ -22,17 +31,36 @@ class SlicesTestCase(unittest.TestCase):
|
||||||
|
|
||||||
a[32:47] = list(range(32, 47))
|
a[32:47] = list(range(32, 47))
|
||||||
self.failUnlessEqual(a[32:47], list(range(32, 47)))
|
self.failUnlessEqual(a[32:47], list(range(32, 47)))
|
||||||
|
a[32:47] = range(132, 147)
|
||||||
|
self.failUnlessEqual(a[32:47:], list(range(132, 147)))
|
||||||
|
a[46:31:-1] = range(232, 247)
|
||||||
|
self.failUnlessEqual(a[32:47:1], list(range(246, 231, -1)))
|
||||||
|
|
||||||
from operator import setslice
|
a[32:47] = range(1132, 1147)
|
||||||
|
self.failUnlessEqual(a[:], b)
|
||||||
|
a[32:47:7] = range(3)
|
||||||
|
b[32:47:7] = range(3)
|
||||||
|
self.failUnlessEqual(a[:], b)
|
||||||
|
a[33::-3] = range(12)
|
||||||
|
b[33::-3] = range(12)
|
||||||
|
self.failUnlessEqual(a[:], b)
|
||||||
|
|
||||||
|
from operator import setslice, setitem
|
||||||
|
|
||||||
# TypeError: int expected instead of str instance
|
# TypeError: int expected instead of str instance
|
||||||
self.assertRaises(TypeError, setslice, a, 0, 5, "abcde")
|
self.assertRaises(TypeError, setslice, a, 0, 5, "abcde")
|
||||||
|
self.assertRaises(TypeError, setitem, a, slice(0, 5), "abcde")
|
||||||
# TypeError: int expected instead of str instance
|
# TypeError: int expected instead of str instance
|
||||||
self.assertRaises(TypeError, setslice, a, 0, 5, ["a", "b", "c", "d", "e"])
|
self.assertRaises(TypeError, setslice, a, 0, 5, ["a", "b", "c", "d", "e"])
|
||||||
|
self.assertRaises(TypeError, setitem, a, slice(0, 5),
|
||||||
|
["a", "b", "c", "d", "e"])
|
||||||
# TypeError: int expected instead of float instance
|
# TypeError: int expected instead of float instance
|
||||||
self.assertRaises(TypeError, setslice, a, 0, 5, [1, 2, 3, 4, 3.14])
|
self.assertRaises(TypeError, setslice, a, 0, 5, [1, 2, 3, 4, 3.14])
|
||||||
|
self.assertRaises(TypeError, setitem, a, slice(0, 5),
|
||||||
|
[1, 2, 3, 4, 3.14])
|
||||||
# ValueError: Can only assign sequence of same size
|
# ValueError: Can only assign sequence of same size
|
||||||
self.assertRaises(ValueError, setslice, a, 0, 5, range(32))
|
self.assertRaises(ValueError, setslice, a, 0, 5, range(32))
|
||||||
|
self.assertRaises(ValueError, setitem, a, slice(0, 5), range(32))
|
||||||
|
|
||||||
def test_char_ptr(self):
|
def test_char_ptr(self):
|
||||||
s = b"abcdefghijklmnopqrstuvwxyz"
|
s = b"abcdefghijklmnopqrstuvwxyz"
|
||||||
|
|
@ -42,15 +70,32 @@ class SlicesTestCase(unittest.TestCase):
|
||||||
dll.my_free.restype = None
|
dll.my_free.restype = None
|
||||||
res = dll.my_strdup(s)
|
res = dll.my_strdup(s)
|
||||||
self.failUnlessEqual(res[:len(s)], s)
|
self.failUnlessEqual(res[:len(s)], s)
|
||||||
|
self.failUnlessEqual(res[:3], s[:3])
|
||||||
|
self.failUnlessEqual(res[:len(s):], s)
|
||||||
|
self.failUnlessEqual(res[len(s)-1:-1:-1], s[::-1])
|
||||||
|
self.failUnlessEqual(res[len(s)-1:5:-7], s[:5:-7])
|
||||||
|
self.failUnlessEqual(res[0:-1:-1], s[0::-1])
|
||||||
|
|
||||||
import operator
|
import operator
|
||||||
|
self.assertRaises(ValueError, operator.getitem,
|
||||||
|
res, slice(None, None, None))
|
||||||
|
self.assertRaises(ValueError, operator.getitem,
|
||||||
|
res, slice(0, None, None))
|
||||||
|
self.assertRaises(ValueError, operator.getitem,
|
||||||
|
res, slice(None, 5, -1))
|
||||||
|
self.assertRaises(ValueError, operator.getitem,
|
||||||
|
res, slice(-5, None, None))
|
||||||
|
|
||||||
self.assertRaises(TypeError, operator.setslice,
|
self.assertRaises(TypeError, operator.setslice,
|
||||||
res, 0, 5, "abcde")
|
res, 0, 5, "abcde")
|
||||||
|
self.assertRaises(TypeError, operator.setitem,
|
||||||
|
res, slice(0, 5), "abcde")
|
||||||
dll.my_free(res)
|
dll.my_free(res)
|
||||||
|
|
||||||
dll.my_strdup.restype = POINTER(c_byte)
|
dll.my_strdup.restype = POINTER(c_byte)
|
||||||
res = dll.my_strdup(s)
|
res = dll.my_strdup(s)
|
||||||
self.failUnlessEqual(res[:len(s)], list(range(ord("a"), ord("z")+1)))
|
self.failUnlessEqual(res[:len(s)], list(range(ord("a"), ord("z")+1)))
|
||||||
|
self.failUnlessEqual(res[:len(s):], list(range(ord("a"), ord("z")+1)))
|
||||||
dll.my_free(res)
|
dll.my_free(res)
|
||||||
|
|
||||||
def test_char_ptr_with_free(self):
|
def test_char_ptr_with_free(self):
|
||||||
|
|
@ -80,6 +125,10 @@ class SlicesTestCase(unittest.TestCase):
|
||||||
|
|
||||||
p = (c_char * 27)(*s)
|
p = (c_char * 27)(*s)
|
||||||
self.failUnlessEqual(p[:], s)
|
self.failUnlessEqual(p[:], s)
|
||||||
|
self.failUnlessEqual(p[::], s)
|
||||||
|
self.failUnlessEqual(p[::-1], s[::-1])
|
||||||
|
self.failUnlessEqual(p[5::-2], s[5::-2])
|
||||||
|
self.failUnlessEqual(p[2:5:-3], s[2:5:-3])
|
||||||
|
|
||||||
|
|
||||||
try:
|
try:
|
||||||
|
|
@ -96,10 +145,15 @@ class SlicesTestCase(unittest.TestCase):
|
||||||
dll.my_free.restype = None
|
dll.my_free.restype = None
|
||||||
res = dll.my_wcsdup(s)
|
res = dll.my_wcsdup(s)
|
||||||
self.failUnlessEqual(res[:len(s)], s)
|
self.failUnlessEqual(res[:len(s)], s)
|
||||||
|
self.failUnlessEqual(res[:len(s):], s)
|
||||||
|
self.failUnlessEqual(res[len(s)-1:-1:-1], s[::-1])
|
||||||
|
self.failUnlessEqual(res[len(s)-1:5:-7], s[:5:-7])
|
||||||
|
|
||||||
import operator
|
import operator
|
||||||
self.assertRaises(TypeError, operator.setslice,
|
self.assertRaises(TypeError, operator.setslice,
|
||||||
res, 0, 5, "abcde")
|
res, 0, 5, "abcde")
|
||||||
|
self.assertRaises(TypeError, operator.setitem,
|
||||||
|
res, slice(0, 5), "abcde")
|
||||||
dll.my_free(res)
|
dll.my_free(res)
|
||||||
|
|
||||||
if sizeof(c_wchar) == sizeof(c_short):
|
if sizeof(c_wchar) == sizeof(c_short):
|
||||||
|
|
@ -111,8 +165,11 @@ class SlicesTestCase(unittest.TestCase):
|
||||||
else:
|
else:
|
||||||
return
|
return
|
||||||
res = dll.my_wcsdup(s)
|
res = dll.my_wcsdup(s)
|
||||||
self.failUnlessEqual(res[:len(s)-1],
|
tmpl = list(range(ord("a"), ord("z")+1))
|
||||||
list(range(ord("a"), ord("z")+1)))
|
self.failUnlessEqual(res[:len(s)-1], tmpl)
|
||||||
|
self.failUnlessEqual(res[:len(s)-1:], tmpl)
|
||||||
|
self.failUnlessEqual(res[len(s)-2:-1:-1], tmpl[::-1])
|
||||||
|
self.failUnlessEqual(res[len(s)-2:5:-7], tmpl[:5:-7])
|
||||||
dll.my_free(res)
|
dll.my_free(res)
|
||||||
|
|
||||||
################################################################
|
################################################################
|
||||||
|
|
|
||||||
|
|
@ -121,6 +121,9 @@ class StringTestCase(unittest.TestCase):
|
||||||
def XX_test_initialized_strings(self):
|
def XX_test_initialized_strings(self):
|
||||||
|
|
||||||
self.failUnless(c_string("ab", 4).raw[:2] == "ab")
|
self.failUnless(c_string("ab", 4).raw[:2] == "ab")
|
||||||
|
self.failUnless(c_string("ab", 4).raw[:2:] == "ab")
|
||||||
|
self.failUnless(c_string("ab", 4).raw[:2:-1] == "ba")
|
||||||
|
self.failUnless(c_string("ab", 4).raw[:2:2] == "a")
|
||||||
self.failUnless(c_string("ab", 4).raw[-1] == "\000")
|
self.failUnless(c_string("ab", 4).raw[-1] == "\000")
|
||||||
self.failUnless(c_string("ab", 2).raw == "a\000")
|
self.failUnless(c_string("ab", 2).raw == "a\000")
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -236,7 +236,13 @@ class StructureTestCase(unittest.TestCase):
|
||||||
|
|
||||||
# can use tuple to initialize array (but not list!)
|
# can use tuple to initialize array (but not list!)
|
||||||
self.failUnlessEqual(SomeInts((1, 2)).a[:], [1, 2, 0, 0])
|
self.failUnlessEqual(SomeInts((1, 2)).a[:], [1, 2, 0, 0])
|
||||||
|
self.failUnlessEqual(SomeInts((1, 2)).a[::], [1, 2, 0, 0])
|
||||||
|
self.failUnlessEqual(SomeInts((1, 2)).a[::-1], [0, 0, 2, 1])
|
||||||
|
self.failUnlessEqual(SomeInts((1, 2)).a[::2], [1, 0])
|
||||||
|
self.failUnlessEqual(SomeInts((1, 2)).a[1:5:6], [2])
|
||||||
|
self.failUnlessEqual(SomeInts((1, 2)).a[6:4:-1], [])
|
||||||
self.failUnlessEqual(SomeInts((1, 2, 3, 4)).a[:], [1, 2, 3, 4])
|
self.failUnlessEqual(SomeInts((1, 2, 3, 4)).a[:], [1, 2, 3, 4])
|
||||||
|
self.failUnlessEqual(SomeInts((1, 2, 3, 4)).a[::], [1, 2, 3, 4])
|
||||||
# too long
|
# too long
|
||||||
# XXX Should raise ValueError?, not RuntimeError
|
# XXX Should raise ValueError?, not RuntimeError
|
||||||
self.assertRaises(RuntimeError, SomeInts, (1, 2, 3, 4, 5))
|
self.assertRaises(RuntimeError, SomeInts, (1, 2, 3, 4, 5))
|
||||||
|
|
|
||||||
|
|
@ -58,11 +58,19 @@ else:
|
||||||
ctypes.set_conversion_mode("ascii", "replace")
|
ctypes.set_conversion_mode("ascii", "replace")
|
||||||
buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc")
|
buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc")
|
||||||
self.failUnlessEqual(buf[:], "ab\uFFFD\uFFFD\uFFFD\0")
|
self.failUnlessEqual(buf[:], "ab\uFFFD\uFFFD\uFFFD\0")
|
||||||
|
self.failUnlessEqual(buf[::], "ab\uFFFD\uFFFD\uFFFD\0")
|
||||||
|
self.failUnlessEqual(buf[::-1], "\0\uFFFD\uFFFD\uFFFDba")
|
||||||
|
self.failUnlessEqual(buf[::2], "a\uFFFD\uFFFD")
|
||||||
|
self.failUnlessEqual(buf[6:5:-1], "")
|
||||||
|
|
||||||
ctypes.set_conversion_mode("ascii", "ignore")
|
ctypes.set_conversion_mode("ascii", "ignore")
|
||||||
buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc")
|
buf = ctypes.create_unicode_buffer(b"ab\xe4\xf6\xfc")
|
||||||
# is that correct? not sure. But with 'ignore', you get what you pay for..
|
# is that correct? not sure. But with 'ignore', you get what you pay for..
|
||||||
self.failUnlessEqual(buf[:], "ab\0\0\0\0")
|
self.failUnlessEqual(buf[:], "ab\0\0\0\0")
|
||||||
|
self.failUnlessEqual(buf[::], "ab\0\0\0\0")
|
||||||
|
self.failUnlessEqual(buf[::-1], "\0\0\0\0ba")
|
||||||
|
self.failUnlessEqual(buf[::2], "a\0\0")
|
||||||
|
self.failUnlessEqual(buf[6:5:-1], "")
|
||||||
|
|
||||||
import _ctypes_test
|
import _ctypes_test
|
||||||
func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p
|
func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p
|
||||||
|
|
@ -104,11 +112,17 @@ else:
|
||||||
ctypes.set_conversion_mode("ascii", "replace")
|
ctypes.set_conversion_mode("ascii", "replace")
|
||||||
buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc")
|
buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc")
|
||||||
self.failUnlessEqual(buf[:], "ab???\0")
|
self.failUnlessEqual(buf[:], "ab???\0")
|
||||||
|
self.failUnlessEqual(buf[::], "ab???\0")
|
||||||
|
self.failUnlessEqual(buf[::-1], "\0???ba")
|
||||||
|
self.failUnlessEqual(buf[::2], "a??")
|
||||||
|
self.failUnlessEqual(buf[6:5:-1], "")
|
||||||
|
|
||||||
ctypes.set_conversion_mode("ascii", "ignore")
|
ctypes.set_conversion_mode("ascii", "ignore")
|
||||||
buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc")
|
buf = ctypes.create_string_buffer("ab\xe4\xf6\xfc")
|
||||||
# is that correct? not sure. But with 'ignore', you get what you pay for..
|
# is that correct? not sure. But with 'ignore', you get what you pay for..
|
||||||
self.failUnlessEqual(buf[:], "ab\0\0\0\0")
|
self.failUnlessEqual(buf[:], "ab\0\0\0\0")
|
||||||
|
self.failUnlessEqual(buf[::], "ab\0\0\0\0")
|
||||||
|
self.failUnlessEqual(buf[::-1], "\0\0\0\0ba")
|
||||||
|
|
||||||
if __name__ == '__main__':
|
if __name__ == '__main__':
|
||||||
unittest.main()
|
unittest.main()
|
||||||
|
|
|
||||||
216
Lib/httplib.py
216
Lib/httplib.py
|
|
@ -72,7 +72,7 @@ import mimetools
|
||||||
import socket
|
import socket
|
||||||
from urlparse import urlsplit
|
from urlparse import urlsplit
|
||||||
|
|
||||||
__all__ = ["HTTPResponse", "HTTPConnection", "HTTPSConnection",
|
__all__ = ["HTTPResponse", "HTTPConnection",
|
||||||
"HTTPException", "NotConnected", "UnknownProtocol",
|
"HTTPException", "NotConnected", "UnknownProtocol",
|
||||||
"UnknownTransferEncoding", "UnimplementedFileMode",
|
"UnknownTransferEncoding", "UnimplementedFileMode",
|
||||||
"IncompleteRead", "InvalidURL", "ImproperConnectionState",
|
"IncompleteRead", "InvalidURL", "ImproperConnectionState",
|
||||||
|
|
@ -964,207 +964,33 @@ class HTTPConnection:
|
||||||
|
|
||||||
return response
|
return response
|
||||||
|
|
||||||
# The next several classes are used to define FakeSocket, a socket-like
|
try:
|
||||||
# interface to an SSL connection.
|
import ssl
|
||||||
|
except ImportError:
|
||||||
|
pass
|
||||||
|
else:
|
||||||
|
class HTTPSConnection(HTTPConnection):
|
||||||
|
"This class allows communication via SSL."
|
||||||
|
|
||||||
# The primary complexity comes from faking a makefile() method. The
|
default_port = HTTPS_PORT
|
||||||
# standard socket makefile() implementation calls dup() on the socket
|
|
||||||
# file descriptor. As a consequence, clients can call close() on the
|
|
||||||
# parent socket and its makefile children in any order. The underlying
|
|
||||||
# socket isn't closed until they are all closed.
|
|
||||||
|
|
||||||
# The implementation uses reference counting to keep the socket open
|
def __init__(self, host, port=None, key_file=None, cert_file=None,
|
||||||
# until the last client calls close(). SharedSocket keeps track of
|
strict=None, timeout=None):
|
||||||
# the reference counting and SharedSocketClient provides an constructor
|
HTTPConnection.__init__(self, host, port, strict, timeout)
|
||||||
# and close() method that call incref() and decref() correctly.
|
self.key_file = key_file
|
||||||
|
self.cert_file = cert_file
|
||||||
|
|
||||||
class SharedSocket:
|
def connect(self):
|
||||||
|
"Connect to a host on a given (SSL) port."
|
||||||
|
|
||||||
def __init__(self, sock):
|
sock = socket.create_connection((self.host, self.port), self.timeout)
|
||||||
self.sock = sock
|
self.sock = ssl.sslsocket(sock, self.key_file, self.cert_file)
|
||||||
self._refcnt = 0
|
|
||||||
|
|
||||||
def incref(self):
|
|
||||||
self._refcnt += 1
|
|
||||||
|
|
||||||
def decref(self):
|
def FakeSocket (sock, sslobj):
|
||||||
self._refcnt -= 1
|
return sslobj
|
||||||
assert self._refcnt >= 0
|
|
||||||
if self._refcnt == 0:
|
|
||||||
self.sock.close()
|
|
||||||
|
|
||||||
def __del__(self):
|
|
||||||
self.sock.close()
|
|
||||||
|
|
||||||
class SharedSocketClient:
|
|
||||||
|
|
||||||
def __init__(self, shared):
|
|
||||||
self._closed = 0
|
|
||||||
self._shared = shared
|
|
||||||
self._shared.incref()
|
|
||||||
self._sock = shared.sock
|
|
||||||
|
|
||||||
def close(self):
|
|
||||||
if not self._closed:
|
|
||||||
self._shared.decref()
|
|
||||||
self._closed = 1
|
|
||||||
self._shared = None
|
|
||||||
|
|
||||||
class SSLFile(SharedSocketClient):
|
|
||||||
"""File-like object wrapping an SSL socket."""
|
|
||||||
|
|
||||||
BUFSIZE = 8192
|
|
||||||
|
|
||||||
def __init__(self, sock, ssl, bufsize=None):
|
|
||||||
SharedSocketClient.__init__(self, sock)
|
|
||||||
self._ssl = ssl
|
|
||||||
self._buf = b""
|
|
||||||
self._bufsize = bufsize or self.__class__.BUFSIZE
|
|
||||||
|
|
||||||
def _read(self):
|
|
||||||
buf = b""
|
|
||||||
# put in a loop so that we retry on transient errors
|
|
||||||
while True:
|
|
||||||
try:
|
|
||||||
buf = self._ssl.read(self._bufsize)
|
|
||||||
except socket.sslerror as err:
|
|
||||||
err_type = err.args[0]
|
|
||||||
if (err_type == socket.SSL_ERROR_WANT_READ
|
|
||||||
or err_type == socket.SSL_ERROR_WANT_WRITE):
|
|
||||||
continue
|
|
||||||
if (err_type == socket.SSL_ERROR_ZERO_RETURN
|
|
||||||
or err_type == socket.SSL_ERROR_EOF):
|
|
||||||
break
|
|
||||||
raise
|
|
||||||
except socket.error as err:
|
|
||||||
err_type = err.args[0]
|
|
||||||
if err_type == errno.EINTR:
|
|
||||||
continue
|
|
||||||
if err_type == errno.EBADF:
|
|
||||||
# XXX socket was closed?
|
|
||||||
break
|
|
||||||
raise
|
|
||||||
else:
|
|
||||||
break
|
|
||||||
return buf
|
|
||||||
|
|
||||||
def read(self, size=None):
|
|
||||||
L = [self._buf]
|
|
||||||
avail = len(self._buf)
|
|
||||||
while size is None or avail < size:
|
|
||||||
s = self._read()
|
|
||||||
if s == b"":
|
|
||||||
break
|
|
||||||
L.append(s)
|
|
||||||
avail += len(s)
|
|
||||||
all = b"".join(L)
|
|
||||||
if size is None:
|
|
||||||
self._buf = b""
|
|
||||||
return all
|
|
||||||
else:
|
|
||||||
self._buf = all[size:]
|
|
||||||
return all[:size]
|
|
||||||
|
|
||||||
def readline(self):
|
|
||||||
L = [self._buf]
|
|
||||||
self._buf = b""
|
|
||||||
while 1:
|
|
||||||
i = L[-1].find("\n")
|
|
||||||
if i >= 0:
|
|
||||||
break
|
|
||||||
s = self._read()
|
|
||||||
if s == b"":
|
|
||||||
break
|
|
||||||
L.append(s)
|
|
||||||
if i == -1:
|
|
||||||
# loop exited because there is no more data
|
|
||||||
return b"".join(L)
|
|
||||||
else:
|
|
||||||
all = b"".join(L)
|
|
||||||
# XXX could do enough bookkeeping not to do a 2nd search
|
|
||||||
i = all.find("\n") + 1
|
|
||||||
line = all[:i]
|
|
||||||
self._buf = all[i:]
|
|
||||||
return line
|
|
||||||
|
|
||||||
def readlines(self, sizehint=0):
|
|
||||||
total = 0
|
|
||||||
list = []
|
|
||||||
while True:
|
|
||||||
line = self.readline()
|
|
||||||
if not line:
|
|
||||||
break
|
|
||||||
list.append(line)
|
|
||||||
total += len(line)
|
|
||||||
if sizehint and total >= sizehint:
|
|
||||||
break
|
|
||||||
return list
|
|
||||||
|
|
||||||
def fileno(self):
|
|
||||||
return self._sock.fileno()
|
|
||||||
|
|
||||||
def __iter__(self):
|
|
||||||
return self
|
|
||||||
|
|
||||||
def __next__(self):
|
|
||||||
line = self.readline()
|
|
||||||
if not line:
|
|
||||||
raise StopIteration
|
|
||||||
return line
|
|
||||||
|
|
||||||
class FakeSocket(SharedSocketClient):
|
|
||||||
|
|
||||||
class _closedsocket:
|
|
||||||
def __getattr__(self, name):
|
|
||||||
raise error(9, 'Bad file descriptor')
|
|
||||||
|
|
||||||
def __init__(self, sock, ssl):
|
|
||||||
sock = SharedSocket(sock)
|
|
||||||
SharedSocketClient.__init__(self, sock)
|
|
||||||
self._ssl = ssl
|
|
||||||
|
|
||||||
def close(self):
|
|
||||||
SharedSocketClient.close(self)
|
|
||||||
self._sock = self.__class__._closedsocket()
|
|
||||||
|
|
||||||
def makefile(self, mode, bufsize=None):
|
|
||||||
if mode != 'r' and mode != 'rb':
|
|
||||||
raise UnimplementedFileMode()
|
|
||||||
return SSLFile(self._shared, self._ssl, bufsize)
|
|
||||||
|
|
||||||
def send(self, stuff, flags = 0):
|
|
||||||
return self._ssl.write(stuff)
|
|
||||||
|
|
||||||
sendall = send
|
|
||||||
|
|
||||||
def recv(self, len = 1024, flags = 0):
|
|
||||||
return self._ssl.read(len)
|
|
||||||
|
|
||||||
def __getattr__(self, attr):
|
|
||||||
return getattr(self._sock, attr)
|
|
||||||
|
|
||||||
def close(self):
|
|
||||||
SharedSocketClient.close(self)
|
|
||||||
self._ssl = None
|
|
||||||
|
|
||||||
class HTTPSConnection(HTTPConnection):
|
|
||||||
"This class allows communication via SSL."
|
|
||||||
|
|
||||||
default_port = HTTPS_PORT
|
|
||||||
|
|
||||||
def __init__(self, host, port=None, key_file=None, cert_file=None,
|
|
||||||
strict=None, timeout=None):
|
|
||||||
HTTPConnection.__init__(self, host, port, strict, timeout)
|
|
||||||
self.key_file = key_file
|
|
||||||
self.cert_file = cert_file
|
|
||||||
|
|
||||||
def connect(self):
|
|
||||||
"Connect to a host on a given (SSL) port."
|
|
||||||
|
|
||||||
sock = socket.create_connection((self.host, self.port), self.timeout)
|
|
||||||
ssl = socket.ssl(sock, self.key_file, self.cert_file)
|
|
||||||
self.sock = FakeSocket(sock, ssl)
|
|
||||||
|
|
||||||
|
__all__.append("HTTPSConnection")
|
||||||
|
|
||||||
class HTTPException(Exception):
|
class HTTPException(Exception):
|
||||||
# Subclasses that define an __init__ must call Exception.__init__
|
# Subclasses that define an __init__ must call Exception.__init__
|
||||||
|
|
|
||||||
148
Lib/imaplib.py
148
Lib/imaplib.py
|
|
@ -24,7 +24,7 @@ __version__ = "2.58"
|
||||||
|
|
||||||
import binascii, os, random, re, socket, sys, time
|
import binascii, os, random, re, socket, sys, time
|
||||||
|
|
||||||
__all__ = ["IMAP4", "IMAP4_SSL", "IMAP4_stream", "Internaldate2tuple",
|
__all__ = ["IMAP4", "IMAP4_stream", "Internaldate2tuple",
|
||||||
"Int2AP", "ParseFlags", "Time2Internaldate"]
|
"Int2AP", "ParseFlags", "Time2Internaldate"]
|
||||||
|
|
||||||
# Globals
|
# Globals
|
||||||
|
|
@ -1111,95 +1111,101 @@ class IMAP4:
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
class IMAP4_SSL(IMAP4):
|
try:
|
||||||
|
import ssl
|
||||||
|
except ImportError:
|
||||||
|
pass
|
||||||
|
else:
|
||||||
|
class IMAP4_SSL(IMAP4):
|
||||||
|
|
||||||
"""IMAP4 client class over SSL connection
|
"""IMAP4 client class over SSL connection
|
||||||
|
|
||||||
Instantiate with: IMAP4_SSL([host[, port[, keyfile[, certfile]]]])
|
Instantiate with: IMAP4_SSL([host[, port[, keyfile[, certfile]]]])
|
||||||
|
|
||||||
host - host's name (default: localhost);
|
host - host's name (default: localhost);
|
||||||
port - port number (default: standard IMAP4 SSL port).
|
port - port number (default: standard IMAP4 SSL port).
|
||||||
keyfile - PEM formatted file that contains your private key (default: None);
|
keyfile - PEM formatted file that contains your private key (default: None);
|
||||||
certfile - PEM formatted certificate chain file (default: None);
|
certfile - PEM formatted certificate chain file (default: None);
|
||||||
|
|
||||||
for more documentation see the docstring of the parent class IMAP4.
|
for more documentation see the docstring of the parent class IMAP4.
|
||||||
"""
|
|
||||||
|
|
||||||
|
|
||||||
def __init__(self, host = '', port = IMAP4_SSL_PORT, keyfile = None, certfile = None):
|
|
||||||
self.keyfile = keyfile
|
|
||||||
self.certfile = certfile
|
|
||||||
IMAP4.__init__(self, host, port)
|
|
||||||
|
|
||||||
|
|
||||||
def open(self, host = '', port = IMAP4_SSL_PORT):
|
|
||||||
"""Setup connection to remote server on "host:port".
|
|
||||||
(default: localhost:standard IMAP4 SSL port).
|
|
||||||
This connection will be used by the routines:
|
|
||||||
read, readline, send, shutdown.
|
|
||||||
"""
|
"""
|
||||||
self.host = host
|
|
||||||
self.port = port
|
|
||||||
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
||||||
self.sock.connect((host, port))
|
|
||||||
self.sslobj = socket.ssl(self.sock, self.keyfile, self.certfile)
|
|
||||||
|
|
||||||
|
|
||||||
def read(self, size):
|
def __init__(self, host = '', port = IMAP4_SSL_PORT, keyfile = None, certfile = None):
|
||||||
"""Read 'size' bytes from remote."""
|
self.keyfile = keyfile
|
||||||
# sslobj.read() sometimes returns < size bytes
|
self.certfile = certfile
|
||||||
chunks = []
|
IMAP4.__init__(self, host, port)
|
||||||
read = 0
|
|
||||||
while read < size:
|
|
||||||
data = self.sslobj.read(size-read)
|
|
||||||
read += len(data)
|
|
||||||
chunks.append(data)
|
|
||||||
|
|
||||||
return ''.join(chunks)
|
|
||||||
|
|
||||||
|
|
||||||
def readline(self):
|
def open(self, host = '', port = IMAP4_SSL_PORT):
|
||||||
"""Read line from remote."""
|
"""Setup connection to remote server on "host:port".
|
||||||
# NB: socket.ssl needs a "readline" method, or perhaps a "makefile" method.
|
(default: localhost:standard IMAP4 SSL port).
|
||||||
line = []
|
This connection will be used by the routines:
|
||||||
while 1:
|
read, readline, send, shutdown.
|
||||||
char = self.sslobj.read(1)
|
"""
|
||||||
line.append(char)
|
self.host = host
|
||||||
if char == "\n": return ''.join(line)
|
self.port = port
|
||||||
|
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||||
|
self.sock.connect((host, port))
|
||||||
|
self.sslobj = ssl.sslsocket(self.sock, self.keyfile, self.certfile)
|
||||||
|
|
||||||
|
|
||||||
def send(self, data):
|
def read(self, size):
|
||||||
"""Send data to remote."""
|
"""Read 'size' bytes from remote."""
|
||||||
# NB: socket.ssl needs a "sendall" method to match socket objects.
|
# sslobj.read() sometimes returns < size bytes
|
||||||
bytes = len(data)
|
chunks = []
|
||||||
while bytes > 0:
|
read = 0
|
||||||
sent = self.sslobj.write(data)
|
while read < size:
|
||||||
if sent == bytes:
|
data = self.sslobj.read(size-read)
|
||||||
break # avoid copy
|
read += len(data)
|
||||||
data = data[sent:]
|
chunks.append(data)
|
||||||
bytes = bytes - sent
|
|
||||||
|
return ''.join(chunks)
|
||||||
|
|
||||||
|
|
||||||
def shutdown(self):
|
def readline(self):
|
||||||
"""Close I/O established in "open"."""
|
"""Read line from remote."""
|
||||||
self.sock.close()
|
# NB: socket.ssl needs a "readline" method, or perhaps a "makefile" method.
|
||||||
|
line = []
|
||||||
|
while 1:
|
||||||
|
char = self.sslobj.read(1)
|
||||||
|
line.append(char)
|
||||||
|
if char == "\n": return ''.join(line)
|
||||||
|
|
||||||
|
|
||||||
def socket(self):
|
def send(self, data):
|
||||||
"""Return socket instance used to connect to IMAP4 server.
|
"""Send data to remote."""
|
||||||
|
# NB: socket.ssl needs a "sendall" method to match socket objects.
|
||||||
socket = <instance>.socket()
|
bytes = len(data)
|
||||||
"""
|
while bytes > 0:
|
||||||
return self.sock
|
sent = self.sslobj.write(data)
|
||||||
|
if sent == bytes:
|
||||||
|
break # avoid copy
|
||||||
|
data = data[sent:]
|
||||||
|
bytes = bytes - sent
|
||||||
|
|
||||||
|
|
||||||
def ssl(self):
|
def shutdown(self):
|
||||||
"""Return SSLObject instance used to communicate with the IMAP4 server.
|
"""Close I/O established in "open"."""
|
||||||
|
self.sock.close()
|
||||||
|
|
||||||
ssl = <instance>.socket.ssl()
|
|
||||||
"""
|
|
||||||
return self.sslobj
|
|
||||||
|
|
||||||
|
def socket(self):
|
||||||
|
"""Return socket instance used to connect to IMAP4 server.
|
||||||
|
|
||||||
|
socket = <instance>.socket()
|
||||||
|
"""
|
||||||
|
return self.sock
|
||||||
|
|
||||||
|
|
||||||
|
def ssl(self):
|
||||||
|
"""Return SSLObject instance used to communicate with the IMAP4 server.
|
||||||
|
|
||||||
|
ssl = <instance>.socket.ssl()
|
||||||
|
"""
|
||||||
|
return self.sslobj
|
||||||
|
|
||||||
|
__all__.append("IMAP4_SSL")
|
||||||
|
|
||||||
|
|
||||||
class IMAP4_stream(IMAP4):
|
class IMAP4_stream(IMAP4):
|
||||||
|
|
|
||||||
16
Lib/pipes.py
16
Lib/pipes.py
|
|
@ -60,7 +60,6 @@ For an example, see the function test() at the end of the file.
|
||||||
|
|
||||||
|
|
||||||
import re
|
import re
|
||||||
|
|
||||||
import os
|
import os
|
||||||
import tempfile
|
import tempfile
|
||||||
import string
|
import string
|
||||||
|
|
@ -267,18 +266,3 @@ def quote(file):
|
||||||
c = '\\' + c
|
c = '\\' + c
|
||||||
res = res + c
|
res = res + c
|
||||||
return '"' + res + '"'
|
return '"' + res + '"'
|
||||||
|
|
||||||
|
|
||||||
# Small test program and example
|
|
||||||
|
|
||||||
def test():
|
|
||||||
print('Testing...')
|
|
||||||
t = Template()
|
|
||||||
t.append('togif $IN $OUT', 'ff')
|
|
||||||
t.append('giftoppm', '--')
|
|
||||||
t.append('ppmtogif >$OUT', '-f')
|
|
||||||
t.append('fromgif $IN $OUT', 'ff')
|
|
||||||
t.debug(1)
|
|
||||||
FILE = '/usr/local/images/rgb/rogues/guido.rgb'
|
|
||||||
t.copy(FILE, '@temp')
|
|
||||||
print('Done.')
|
|
||||||
|
|
|
||||||
155
Lib/poplib.py
155
Lib/poplib.py
|
|
@ -15,7 +15,7 @@ Based on the J. Myers POP3 draft, Jan. 96
|
||||||
|
|
||||||
import re, socket
|
import re, socket
|
||||||
|
|
||||||
__all__ = ["POP3","error_proto","POP3_SSL"]
|
__all__ = ["POP3","error_proto"]
|
||||||
|
|
||||||
# Exception raised when an error or invalid response is received:
|
# Exception raised when an error or invalid response is received:
|
||||||
|
|
||||||
|
|
@ -307,90 +307,97 @@ class POP3:
|
||||||
return self._shortcmd('UIDL %s' % which)
|
return self._shortcmd('UIDL %s' % which)
|
||||||
return self._longcmd('UIDL')
|
return self._longcmd('UIDL')
|
||||||
|
|
||||||
class POP3_SSL(POP3):
|
try:
|
||||||
"""POP3 client class over SSL connection
|
import ssl
|
||||||
|
except ImportError:
|
||||||
|
pass
|
||||||
|
else:
|
||||||
|
|
||||||
Instantiate with: POP3_SSL(hostname, port=995, keyfile=None, certfile=None)
|
class POP3_SSL(POP3):
|
||||||
|
"""POP3 client class over SSL connection
|
||||||
|
|
||||||
hostname - the hostname of the pop3 over ssl server
|
Instantiate with: POP3_SSL(hostname, port=995, keyfile=None, certfile=None)
|
||||||
port - port number
|
|
||||||
keyfile - PEM formatted file that countains your private key
|
|
||||||
certfile - PEM formatted certificate chain file
|
|
||||||
|
|
||||||
See the methods of the parent class POP3 for more documentation.
|
hostname - the hostname of the pop3 over ssl server
|
||||||
"""
|
port - port number
|
||||||
|
keyfile - PEM formatted file that countains your private key
|
||||||
|
certfile - PEM formatted certificate chain file
|
||||||
|
|
||||||
def __init__(self, host, port = POP3_SSL_PORT, keyfile = None, certfile = None):
|
See the methods of the parent class POP3 for more documentation.
|
||||||
self.host = host
|
"""
|
||||||
self.port = port
|
|
||||||
self.keyfile = keyfile
|
|
||||||
self.certfile = certfile
|
|
||||||
self.buffer = ""
|
|
||||||
msg = "getaddrinfo returns an empty list"
|
|
||||||
self.sock = None
|
|
||||||
for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
|
|
||||||
af, socktype, proto, canonname, sa = res
|
|
||||||
try:
|
|
||||||
self.sock = socket.socket(af, socktype, proto)
|
|
||||||
self.sock.connect(sa)
|
|
||||||
except socket.error as msg:
|
|
||||||
if self.sock:
|
|
||||||
self.sock.close()
|
|
||||||
self.sock = None
|
|
||||||
continue
|
|
||||||
break
|
|
||||||
if not self.sock:
|
|
||||||
raise socket.error(msg)
|
|
||||||
self.file = self.sock.makefile('rb')
|
|
||||||
self.sslobj = socket.ssl(self.sock, self.keyfile, self.certfile)
|
|
||||||
self._debugging = 0
|
|
||||||
self.welcome = self._getresp()
|
|
||||||
|
|
||||||
def _fillBuffer(self):
|
def __init__(self, host, port = POP3_SSL_PORT, keyfile = None, certfile = None):
|
||||||
localbuf = self.sslobj.read()
|
self.host = host
|
||||||
if len(localbuf) == 0:
|
self.port = port
|
||||||
raise error_proto('-ERR EOF')
|
self.keyfile = keyfile
|
||||||
self.buffer += localbuf
|
self.certfile = certfile
|
||||||
|
self.buffer = ""
|
||||||
|
msg = "getaddrinfo returns an empty list"
|
||||||
|
self.sock = None
|
||||||
|
for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
|
||||||
|
af, socktype, proto, canonname, sa = res
|
||||||
|
try:
|
||||||
|
self.sock = socket.socket(af, socktype, proto)
|
||||||
|
self.sock.connect(sa)
|
||||||
|
except socket.error as msg:
|
||||||
|
if self.sock:
|
||||||
|
self.sock.close()
|
||||||
|
self.sock = None
|
||||||
|
continue
|
||||||
|
break
|
||||||
|
if not self.sock:
|
||||||
|
raise socket.error(msg)
|
||||||
|
self.file = self.sock.makefile('rb')
|
||||||
|
self.sslobj = ssl.sslsocket(self.sock, self.keyfile, self.certfile)
|
||||||
|
self._debugging = 0
|
||||||
|
self.welcome = self._getresp()
|
||||||
|
|
||||||
def _getline(self):
|
def _fillBuffer(self):
|
||||||
line = ""
|
localbuf = self.sslobj.read()
|
||||||
renewline = re.compile(r'.*?\n')
|
if len(localbuf) == 0:
|
||||||
match = renewline.match(self.buffer)
|
raise error_proto('-ERR EOF')
|
||||||
while not match:
|
self.buffer += localbuf
|
||||||
self._fillBuffer()
|
|
||||||
|
def _getline(self):
|
||||||
|
line = ""
|
||||||
|
renewline = re.compile(r'.*?\n')
|
||||||
match = renewline.match(self.buffer)
|
match = renewline.match(self.buffer)
|
||||||
line = match.group(0)
|
while not match:
|
||||||
self.buffer = renewline.sub('' ,self.buffer, 1)
|
self._fillBuffer()
|
||||||
if self._debugging > 1: print('*get*', repr(line))
|
match = renewline.match(self.buffer)
|
||||||
|
line = match.group(0)
|
||||||
|
self.buffer = renewline.sub('' ,self.buffer, 1)
|
||||||
|
if self._debugging > 1: print('*get*', repr(line))
|
||||||
|
|
||||||
octets = len(line)
|
octets = len(line)
|
||||||
if line[-2:] == CRLF:
|
if line[-2:] == CRLF:
|
||||||
return line[:-2], octets
|
return line[:-2], octets
|
||||||
if line[0] == CR:
|
if line[0] == CR:
|
||||||
return line[1:-1], octets
|
return line[1:-1], octets
|
||||||
return line[:-1], octets
|
return line[:-1], octets
|
||||||
|
|
||||||
def _putline(self, line):
|
def _putline(self, line):
|
||||||
if self._debugging > 1: print('*put*', repr(line))
|
if self._debugging > 1: print('*put*', repr(line))
|
||||||
line += CRLF
|
line += CRLF
|
||||||
bytes = len(line)
|
bytes = len(line)
|
||||||
while bytes > 0:
|
while bytes > 0:
|
||||||
sent = self.sslobj.write(line)
|
sent = self.sslobj.write(line)
|
||||||
if sent == bytes:
|
if sent == bytes:
|
||||||
break # avoid copy
|
break # avoid copy
|
||||||
line = line[sent:]
|
line = line[sent:]
|
||||||
bytes = bytes - sent
|
bytes = bytes - sent
|
||||||
|
|
||||||
def quit(self):
|
def quit(self):
|
||||||
"""Signoff: commit changes on server, unlock mailbox, close connection."""
|
"""Signoff: commit changes on server, unlock mailbox, close connection."""
|
||||||
try:
|
try:
|
||||||
resp = self._shortcmd('QUIT')
|
resp = self._shortcmd('QUIT')
|
||||||
except error_proto as val:
|
except error_proto as val:
|
||||||
resp = val
|
resp = val
|
||||||
self.sock.close()
|
self.sock.close()
|
||||||
del self.sslobj, self.sock
|
del self.sslobj, self.sock
|
||||||
return resp
|
return resp
|
||||||
|
|
||||||
|
__all__.append("POP3_SSL")
|
||||||
|
|
||||||
if __name__ == "__main__":
|
if __name__ == "__main__":
|
||||||
import sys
|
import sys
|
||||||
|
|
|
||||||
|
|
@ -230,6 +230,11 @@ class URLopener(urllib.FancyURLopener):
|
||||||
urllib.FancyURLopener.__init__(self, *args)
|
urllib.FancyURLopener.__init__(self, *args)
|
||||||
self.errcode = 200
|
self.errcode = 200
|
||||||
|
|
||||||
|
def prompt_user_passwd(self, host, realm):
|
||||||
|
## If robots.txt file is accessible only with a password,
|
||||||
|
## we act as if the file wasn't there.
|
||||||
|
return None, None
|
||||||
|
|
||||||
def http_error_default(self, url, fp, errcode, errmsg, headers):
|
def http_error_default(self, url, fp, errcode, errmsg, headers):
|
||||||
self.errcode = errcode
|
self.errcode = errcode
|
||||||
return urllib.FancyURLopener.http_error_default(self, url, fp, errcode,
|
return urllib.FancyURLopener.http_error_default(self, url, fp, errcode,
|
||||||
|
|
|
||||||
117
Lib/smtplib.py
117
Lib/smtplib.py
|
|
@ -52,7 +52,7 @@ from sys import stderr
|
||||||
__all__ = ["SMTPException","SMTPServerDisconnected","SMTPResponseException",
|
__all__ = ["SMTPException","SMTPServerDisconnected","SMTPResponseException",
|
||||||
"SMTPSenderRefused","SMTPRecipientsRefused","SMTPDataError",
|
"SMTPSenderRefused","SMTPRecipientsRefused","SMTPDataError",
|
||||||
"SMTPConnectError","SMTPHeloError","SMTPAuthenticationError",
|
"SMTPConnectError","SMTPHeloError","SMTPAuthenticationError",
|
||||||
"quoteaddr","quotedata","SMTP","SMTP_SSL"]
|
"quoteaddr","quotedata","SMTP"]
|
||||||
|
|
||||||
SMTP_PORT = 25
|
SMTP_PORT = 25
|
||||||
SMTP_SSL_PORT = 465
|
SMTP_SSL_PORT = 465
|
||||||
|
|
@ -128,43 +128,6 @@ class SMTPAuthenticationError(SMTPResponseException):
|
||||||
combination provided.
|
combination provided.
|
||||||
"""
|
"""
|
||||||
|
|
||||||
class SSLFakeSocket:
|
|
||||||
"""A fake socket object that really wraps a SSLObject.
|
|
||||||
|
|
||||||
It only supports what is needed in smtplib.
|
|
||||||
"""
|
|
||||||
def __init__(self, realsock, sslobj):
|
|
||||||
self.realsock = realsock
|
|
||||||
self.sslobj = sslobj
|
|
||||||
|
|
||||||
def send(self, str):
|
|
||||||
self.sslobj.write(str)
|
|
||||||
return len(str)
|
|
||||||
|
|
||||||
sendall = send
|
|
||||||
|
|
||||||
def close(self):
|
|
||||||
self.realsock.close()
|
|
||||||
|
|
||||||
class SSLFakeFile:
|
|
||||||
"""A fake file like object that really wraps a SSLObject.
|
|
||||||
|
|
||||||
It only supports what is needed in smtplib.
|
|
||||||
"""
|
|
||||||
def __init__(self, sslobj):
|
|
||||||
self.sslobj = sslobj
|
|
||||||
|
|
||||||
def readline(self):
|
|
||||||
str = ""
|
|
||||||
chr = None
|
|
||||||
while chr != "\n":
|
|
||||||
chr = self.sslobj.read(1)
|
|
||||||
str += chr
|
|
||||||
return str
|
|
||||||
|
|
||||||
def close(self):
|
|
||||||
pass
|
|
||||||
|
|
||||||
def quoteaddr(addr):
|
def quoteaddr(addr):
|
||||||
"""Quote a subset of the email addresses defined by RFC 821.
|
"""Quote a subset of the email addresses defined by RFC 821.
|
||||||
|
|
||||||
|
|
@ -193,6 +156,33 @@ def quotedata(data):
|
||||||
return re.sub(r'(?m)^\.', '..',
|
return re.sub(r'(?m)^\.', '..',
|
||||||
re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data))
|
re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data))
|
||||||
|
|
||||||
|
try:
|
||||||
|
import ssl
|
||||||
|
except ImportError:
|
||||||
|
_have_ssl = False
|
||||||
|
else:
|
||||||
|
|
||||||
|
class SSLFakeFile:
|
||||||
|
"""A fake file like object that really wraps a SSLObject.
|
||||||
|
|
||||||
|
It only supports what is needed in smtplib.
|
||||||
|
"""
|
||||||
|
def __init__(self, sslobj):
|
||||||
|
self.sslobj = sslobj
|
||||||
|
|
||||||
|
def readline(self):
|
||||||
|
str = b""
|
||||||
|
chr = None
|
||||||
|
while chr != b"\n":
|
||||||
|
chr = self.sslobj.read(1)
|
||||||
|
str += chr
|
||||||
|
return str
|
||||||
|
|
||||||
|
def close(self):
|
||||||
|
pass
|
||||||
|
|
||||||
|
_have_ssl = True
|
||||||
|
|
||||||
|
|
||||||
class SMTP:
|
class SMTP:
|
||||||
"""This class manages a connection to an SMTP or ESMTP server.
|
"""This class manages a connection to an SMTP or ESMTP server.
|
||||||
|
|
@ -597,9 +587,10 @@ class SMTP:
|
||||||
"""
|
"""
|
||||||
(resp, reply) = self.docmd("STARTTLS")
|
(resp, reply) = self.docmd("STARTTLS")
|
||||||
if resp == 220:
|
if resp == 220:
|
||||||
sslobj = socket.ssl(self.sock, keyfile, certfile)
|
if not _have_ssl:
|
||||||
self.sock = SSLFakeSocket(self.sock, sslobj)
|
raise RuntimeError("No SSL support included in this Python")
|
||||||
self.file = SSLFakeFile(sslobj)
|
self.sock = ssl.sslsocket(self.sock, keyfile, certfile)
|
||||||
|
self.file = SSLFakeFile(self.sock)
|
||||||
return (resp, reply)
|
return (resp, reply)
|
||||||
|
|
||||||
def sendmail(self, from_addr, to_addrs, msg, mail_options=[],
|
def sendmail(self, from_addr, to_addrs, msg, mail_options=[],
|
||||||
|
|
@ -711,27 +702,31 @@ class SMTP:
|
||||||
self.docmd("quit")
|
self.docmd("quit")
|
||||||
self.close()
|
self.close()
|
||||||
|
|
||||||
class SMTP_SSL(SMTP):
|
if _have_ssl:
|
||||||
""" This is a subclass derived from SMTP that connects over an SSL encrypted
|
|
||||||
socket (to use this class you need a socket module that was compiled with SSL
|
|
||||||
support). If host is not specified, '' (the local host) is used. If port is
|
|
||||||
omitted, the standard SMTP-over-SSL port (465) is used. keyfile and certfile
|
|
||||||
are also optional - they can contain a PEM formatted private key and
|
|
||||||
certificate chain file for the SSL connection.
|
|
||||||
"""
|
|
||||||
def __init__(self, host='', port=0, local_hostname=None,
|
|
||||||
keyfile=None, certfile=None, timeout=None):
|
|
||||||
self.keyfile = keyfile
|
|
||||||
self.certfile = certfile
|
|
||||||
SMTP.__init__(self, host, port, local_hostname, timeout)
|
|
||||||
self.default_port = SMTP_SSL_PORT
|
|
||||||
|
|
||||||
def _get_socket(self, host, port, timeout):
|
class SMTP_SSL(SMTP):
|
||||||
if self.debuglevel > 0: print('connect:', (host, port), file=stderr)
|
""" This is a subclass derived from SMTP that connects over an SSL encrypted
|
||||||
self.sock = socket.create_connection((host, port), timeout)
|
socket (to use this class you need a socket module that was compiled with SSL
|
||||||
sslobj = socket.ssl(self.sock, self.keyfile, self.certfile)
|
support). If host is not specified, '' (the local host) is used. If port is
|
||||||
self.sock = SSLFakeSocket(self.sock, sslobj)
|
omitted, the standard SMTP-over-SSL port (465) is used. keyfile and certfile
|
||||||
self.file = SSLFakeFile(sslobj)
|
are also optional - they can contain a PEM formatted private key and
|
||||||
|
certificate chain file for the SSL connection.
|
||||||
|
"""
|
||||||
|
def __init__(self, host='', port=0, local_hostname=None,
|
||||||
|
keyfile=None, certfile=None, timeout=None):
|
||||||
|
self.keyfile = keyfile
|
||||||
|
self.certfile = certfile
|
||||||
|
SMTP.__init__(self, host, port, local_hostname, timeout)
|
||||||
|
self.default_port = SMTP_SSL_PORT
|
||||||
|
|
||||||
|
def _get_socket(self, host, port, timeout):
|
||||||
|
if self.debuglevel > 0: print('connect:', (host, port), file=stderr)
|
||||||
|
self.sock = socket.create_connection((host, port), timeout)
|
||||||
|
sslobj = socket.ssl(self.sock, self.keyfile, self.certfile)
|
||||||
|
self.sock = SSLFakeSocket(self.sock, sslobj)
|
||||||
|
self.file = SSLFakeFile(sslobj)
|
||||||
|
|
||||||
|
__all__.append("SMTP_SSL")
|
||||||
|
|
||||||
#
|
#
|
||||||
# LMTP extension
|
# LMTP extension
|
||||||
|
|
|
||||||
|
|
@ -46,13 +46,35 @@ the setsockopt() and getsockopt() methods.
|
||||||
import _socket
|
import _socket
|
||||||
from _socket import *
|
from _socket import *
|
||||||
|
|
||||||
_have_ssl = False
|
try:
|
||||||
## try:
|
import _ssl
|
||||||
## import _ssl
|
import ssl as _realssl
|
||||||
## from _ssl import *
|
except ImportError:
|
||||||
## _have_ssl = True
|
# no SSL support
|
||||||
## except ImportError:
|
pass
|
||||||
## pass
|
else:
|
||||||
|
def ssl(sock, keyfile=None, certfile=None):
|
||||||
|
# we do an internal import here because the ssl
|
||||||
|
# module imports the socket module
|
||||||
|
warnings.warn("socket.ssl() is deprecated. Use ssl.sslsocket() instead.",
|
||||||
|
DeprecationWarning, stacklevel=2)
|
||||||
|
return _realssl.sslwrap_simple(sock, keyfile, certfile)
|
||||||
|
|
||||||
|
# we need to import the same constants we used to...
|
||||||
|
from _ssl import \
|
||||||
|
sslerror, \
|
||||||
|
RAND_add, \
|
||||||
|
RAND_egd, \
|
||||||
|
RAND_status, \
|
||||||
|
SSL_ERROR_ZERO_RETURN, \
|
||||||
|
SSL_ERROR_WANT_READ, \
|
||||||
|
SSL_ERROR_WANT_WRITE, \
|
||||||
|
SSL_ERROR_WANT_X509_LOOKUP, \
|
||||||
|
SSL_ERROR_SYSCALL, \
|
||||||
|
SSL_ERROR_SSL, \
|
||||||
|
SSL_ERROR_WANT_CONNECT, \
|
||||||
|
SSL_ERROR_EOF, \
|
||||||
|
SSL_ERROR_INVALID_ERROR_CODE
|
||||||
|
|
||||||
import os, sys, io
|
import os, sys, io
|
||||||
|
|
||||||
|
|
@ -63,12 +85,9 @@ except ImportError:
|
||||||
|
|
||||||
__all__ = ["getfqdn"]
|
__all__ = ["getfqdn"]
|
||||||
__all__.extend(os._get_exports_list(_socket))
|
__all__.extend(os._get_exports_list(_socket))
|
||||||
if _have_ssl:
|
|
||||||
__all__.extend(os._get_exports_list(_ssl))
|
|
||||||
def ssl(sock, keyfile=None, certfile=None):
|
_realsocket = socket
|
||||||
import ssl as realssl
|
|
||||||
return realssl.sslwrap_simple(sock, keyfile, certfile)
|
|
||||||
__all__.append("ssl")
|
|
||||||
|
|
||||||
# WSA error codes
|
# WSA error codes
|
||||||
if sys.platform.lower().startswith("win"):
|
if sys.platform.lower().startswith("win"):
|
||||||
|
|
|
||||||
235
Lib/ssl.py
235
Lib/ssl.py
|
|
@ -60,55 +60,47 @@ PROTOCOL_TLSv1
|
||||||
import os, sys
|
import os, sys
|
||||||
|
|
||||||
import _ssl # if we can't import it, let the error propagate
|
import _ssl # if we can't import it, let the error propagate
|
||||||
from socket import socket
|
|
||||||
from _ssl import sslerror
|
from _ssl import sslerror
|
||||||
from _ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED
|
from _ssl import CERT_NONE, CERT_OPTIONAL, CERT_REQUIRED
|
||||||
from _ssl import PROTOCOL_SSLv2, PROTOCOL_SSLv3, PROTOCOL_SSLv23, PROTOCOL_TLSv1
|
from _ssl import PROTOCOL_SSLv2, PROTOCOL_SSLv3, PROTOCOL_SSLv23, PROTOCOL_TLSv1
|
||||||
|
from _ssl import \
|
||||||
|
SSL_ERROR_ZERO_RETURN, \
|
||||||
|
SSL_ERROR_WANT_READ, \
|
||||||
|
SSL_ERROR_WANT_WRITE, \
|
||||||
|
SSL_ERROR_WANT_X509_LOOKUP, \
|
||||||
|
SSL_ERROR_SYSCALL, \
|
||||||
|
SSL_ERROR_SSL, \
|
||||||
|
SSL_ERROR_WANT_CONNECT, \
|
||||||
|
SSL_ERROR_EOF, \
|
||||||
|
SSL_ERROR_INVALID_ERROR_CODE
|
||||||
|
|
||||||
|
from socket import socket
|
||||||
|
from socket import getnameinfo as _getnameinfo
|
||||||
|
|
||||||
# Root certs:
|
|
||||||
#
|
|
||||||
# The "ca_certs" argument to sslsocket() expects a file containing one or more
|
|
||||||
# certificates that are roots of various certificate signing chains. This file
|
|
||||||
# contains the certificates in PEM format (RFC ) where each certificate is
|
|
||||||
# encoded in base64 encoding and surrounded with a header and footer:
|
|
||||||
# -----BEGIN CERTIFICATE-----
|
|
||||||
# ... (CA certificate in base64 encoding) ...
|
|
||||||
# -----END CERTIFICATE-----
|
|
||||||
# The various certificates in the file are just concatenated together:
|
|
||||||
# -----BEGIN CERTIFICATE-----
|
|
||||||
# ... (CA certificate in base64 encoding) ...
|
|
||||||
# -----END CERTIFICATE-----
|
|
||||||
# -----BEGIN CERTIFICATE-----
|
|
||||||
# ... (a second CA certificate in base64 encoding) ...
|
|
||||||
# -----END CERTIFICATE-----
|
|
||||||
#
|
|
||||||
# Some "standard" root certificates are available at
|
|
||||||
#
|
|
||||||
# http://www.thawte.com/roots/ (for Thawte roots)
|
|
||||||
# http://www.verisign.com/support/roots.html (for Verisign)
|
|
||||||
|
|
||||||
class sslsocket (socket):
|
class sslsocket (socket):
|
||||||
|
|
||||||
|
"""This class implements a subtype of socket.socket that wraps
|
||||||
|
the underlying OS socket in an SSL context when necessary, and
|
||||||
|
provides read and write methods over that channel."""
|
||||||
|
|
||||||
def __init__(self, sock, keyfile=None, certfile=None,
|
def __init__(self, sock, keyfile=None, certfile=None,
|
||||||
server_side=False, cert_reqs=CERT_NONE,
|
server_side=False, cert_reqs=CERT_NONE,
|
||||||
ssl_version=PROTOCOL_SSLv23, ca_certs=None):
|
ssl_version=PROTOCOL_SSLv23, ca_certs=None):
|
||||||
socket.__init__(self, _sock=sock._sock)
|
socket.__init__(self, _sock=sock._sock)
|
||||||
if certfile and not keyfile:
|
if certfile and not keyfile:
|
||||||
keyfile = certfile
|
keyfile = certfile
|
||||||
if server_side:
|
# see if it's connected
|
||||||
self._sslobj = _ssl.sslwrap(self._sock, 1, keyfile, certfile,
|
try:
|
||||||
cert_reqs, ssl_version, ca_certs)
|
socket.getpeername(self)
|
||||||
|
except:
|
||||||
|
# no, no connection yet
|
||||||
|
self._sslobj = None
|
||||||
else:
|
else:
|
||||||
# see if it's connected
|
# yes, create the SSL object
|
||||||
try:
|
self._sslobj = _ssl.sslwrap(self._sock, server_side,
|
||||||
socket.getpeername(self)
|
keyfile, certfile,
|
||||||
except:
|
cert_reqs, ssl_version, ca_certs)
|
||||||
# no, no connection yet
|
|
||||||
self._sslobj = None
|
|
||||||
else:
|
|
||||||
# yes, create the SSL object
|
|
||||||
self._sslobj = _ssl.sslwrap(self._sock, 0, keyfile, certfile,
|
|
||||||
cert_reqs, ssl_version, ca_certs)
|
|
||||||
self.keyfile = keyfile
|
self.keyfile = keyfile
|
||||||
self.certfile = certfile
|
self.certfile = certfile
|
||||||
self.cert_reqs = cert_reqs
|
self.cert_reqs = cert_reqs
|
||||||
|
|
@ -116,73 +108,123 @@ class sslsocket (socket):
|
||||||
self.ca_certs = ca_certs
|
self.ca_certs = ca_certs
|
||||||
|
|
||||||
def read(self, len=1024):
|
def read(self, len=1024):
|
||||||
|
|
||||||
|
"""Read up to LEN bytes and return them.
|
||||||
|
Return zero-length string on EOF."""
|
||||||
|
|
||||||
return self._sslobj.read(len)
|
return self._sslobj.read(len)
|
||||||
|
|
||||||
def write(self, data):
|
def write(self, data):
|
||||||
|
|
||||||
|
"""Write DATA to the underlying SSL channel. Returns
|
||||||
|
number of bytes of DATA actually transmitted."""
|
||||||
|
|
||||||
return self._sslobj.write(data)
|
return self._sslobj.write(data)
|
||||||
|
|
||||||
def getpeercert(self):
|
def getpeercert(self):
|
||||||
|
|
||||||
|
"""Returns a formatted version of the data in the
|
||||||
|
certificate provided by the other end of the SSL channel.
|
||||||
|
Return None if no certificate was provided, {} if a
|
||||||
|
certificate was provided, but not validated."""
|
||||||
|
|
||||||
return self._sslobj.peer_certificate()
|
return self._sslobj.peer_certificate()
|
||||||
|
|
||||||
def send (self, data, flags=0):
|
def send (self, data, flags=0):
|
||||||
if flags != 0:
|
if self._sslobj:
|
||||||
raise ValueError(
|
if flags != 0:
|
||||||
"non-zero flags not allowed in calls to send() on %s" %
|
raise ValueError(
|
||||||
self.__class__)
|
"non-zero flags not allowed in calls to send() on %s" %
|
||||||
return self._sslobj.write(data)
|
self.__class__)
|
||||||
|
return self._sslobj.write(data)
|
||||||
|
else:
|
||||||
|
return socket.send(self, data, flags)
|
||||||
|
|
||||||
def send_to (self, data, addr, flags=0):
|
def send_to (self, data, addr, flags=0):
|
||||||
raise ValueError("send_to not allowed on instances of %s" %
|
if self._sslobj:
|
||||||
self.__class__)
|
raise ValueError("send_to not allowed on instances of %s" %
|
||||||
|
self.__class__)
|
||||||
|
else:
|
||||||
|
return socket.send_to(self, data, addr, flags)
|
||||||
|
|
||||||
def sendall (self, data, flags=0):
|
def sendall (self, data, flags=0):
|
||||||
if flags != 0:
|
if self._sslobj:
|
||||||
raise ValueError(
|
if flags != 0:
|
||||||
"non-zero flags not allowed in calls to sendall() on %s" %
|
raise ValueError(
|
||||||
self.__class__)
|
"non-zero flags not allowed in calls to sendall() on %s" %
|
||||||
return self._sslobj.write(data)
|
self.__class__)
|
||||||
|
return self._sslobj.write(data)
|
||||||
|
else:
|
||||||
|
return socket.sendall(self, data, flags)
|
||||||
|
|
||||||
def recv (self, buflen=1024, flags=0):
|
def recv (self, buflen=1024, flags=0):
|
||||||
if flags != 0:
|
if self._sslobj:
|
||||||
raise ValueError(
|
if flags != 0:
|
||||||
"non-zero flags not allowed in calls to sendall() on %s" %
|
raise ValueError(
|
||||||
self.__class__)
|
"non-zero flags not allowed in calls to sendall() on %s" %
|
||||||
return self._sslobj.read(data, buflen)
|
self.__class__)
|
||||||
|
return self._sslobj.read(data, buflen)
|
||||||
|
else:
|
||||||
|
return socket.recv(self, buflen, flags)
|
||||||
|
|
||||||
def recv_from (self, addr, buflen=1024, flags=0):
|
def recv_from (self, addr, buflen=1024, flags=0):
|
||||||
raise ValueError("recv_from not allowed on instances of %s" %
|
if self._sslobj:
|
||||||
self.__class__)
|
raise ValueError("recv_from not allowed on instances of %s" %
|
||||||
|
self.__class__)
|
||||||
|
else:
|
||||||
|
return socket.recv_from(self, addr, buflen, flags)
|
||||||
|
|
||||||
|
def ssl_shutdown(self):
|
||||||
|
|
||||||
|
"""Shuts down the SSL channel over this socket (if active),
|
||||||
|
without closing the socket connection."""
|
||||||
|
|
||||||
def shutdown(self):
|
|
||||||
if self._sslobj:
|
if self._sslobj:
|
||||||
self._sslobj.shutdown()
|
self._sslobj.shutdown()
|
||||||
self._sslobj = None
|
self._sslobj = None
|
||||||
else:
|
|
||||||
socket.shutdown(self)
|
def shutdown(self, how):
|
||||||
|
self.ssl_shutdown()
|
||||||
|
socket.shutdown(self, how)
|
||||||
|
|
||||||
def close(self):
|
def close(self):
|
||||||
if self._sslobj:
|
self.ssl_shutdown()
|
||||||
self.shutdown()
|
socket.close(self)
|
||||||
else:
|
|
||||||
socket.close(self)
|
|
||||||
|
|
||||||
def connect(self, addr):
|
def connect(self, addr):
|
||||||
|
|
||||||
|
"""Connects to remote ADDR, and then wraps the connection in
|
||||||
|
an SSL channel."""
|
||||||
|
|
||||||
# Here we assume that the socket is client-side, and not
|
# Here we assume that the socket is client-side, and not
|
||||||
# connected at the time of the call. We connect it, then wrap it.
|
# connected at the time of the call. We connect it, then wrap it.
|
||||||
if self._sslobj or (self.getsockname()[1] != 0):
|
if self._sslobj:
|
||||||
raise ValueError("attempt to connect already-connected sslsocket!")
|
raise ValueError("attempt to connect already-connected sslsocket!")
|
||||||
socket.connect(self, addr)
|
socket.connect(self, addr)
|
||||||
self._sslobj = _ssl.sslwrap(self._sock, 0, self.keyfile, self.certfile,
|
self._sslobj = _ssl.sslwrap(self._sock, False, self.keyfile, self.certfile,
|
||||||
self.cert_reqs, self.ssl_version,
|
self.cert_reqs, self.ssl_version,
|
||||||
self.ca_certs)
|
self.ca_certs)
|
||||||
|
|
||||||
def accept(self):
|
def accept(self):
|
||||||
raise ValueError("accept() not supported on an sslsocket")
|
|
||||||
|
"""Accepts a new connection from a remote client, and returns
|
||||||
|
a tuple containing that new connection wrapped with a server-side
|
||||||
|
SSL channel, and the address of the remote client."""
|
||||||
|
|
||||||
|
newsock, addr = socket.accept(self)
|
||||||
|
return (sslsocket(newsock, True, self.keyfile, self.certfile,
|
||||||
|
self.cert_reqs, self.ssl_version,
|
||||||
|
self.ca_certs), addr)
|
||||||
|
|
||||||
|
|
||||||
# some utility functions
|
# some utility functions
|
||||||
|
|
||||||
def cert_time_to_seconds(cert_time):
|
def cert_time_to_seconds(cert_time):
|
||||||
|
|
||||||
|
"""Takes a date-time string in standard ASN1_print form
|
||||||
|
("MON DAY 24HOUR:MINUTE:SEC YEAR TIMEZONE") and return
|
||||||
|
a Python time value in seconds past the epoch."""
|
||||||
|
|
||||||
import time
|
import time
|
||||||
return time.mktime(time.strptime(cert_time, "%b %d %H:%M:%S %Y GMT"))
|
return time.mktime(time.strptime(cert_time, "%b %d %H:%M:%S %Y GMT"))
|
||||||
|
|
||||||
|
|
@ -190,66 +232,9 @@ def cert_time_to_seconds(cert_time):
|
||||||
|
|
||||||
def sslwrap_simple (sock, keyfile=None, certfile=None):
|
def sslwrap_simple (sock, keyfile=None, certfile=None):
|
||||||
|
|
||||||
|
"""A replacement for the old socket.ssl function. Designed
|
||||||
|
for compability with Python 2.5 and earlier. Will disappear in
|
||||||
|
Python 3.0."""
|
||||||
|
|
||||||
return _ssl.sslwrap(sock._sock, 0, keyfile, certfile, CERT_NONE,
|
return _ssl.sslwrap(sock._sock, 0, keyfile, certfile, CERT_NONE,
|
||||||
PROTOCOL_SSLv23, None)
|
PROTOCOL_SSLv23, None)
|
||||||
|
|
||||||
# fetch the certificate that the server is providing in PEM form
|
|
||||||
|
|
||||||
def fetch_server_certificate (host, port):
|
|
||||||
|
|
||||||
import re, tempfile, os
|
|
||||||
|
|
||||||
def subproc(cmd):
|
|
||||||
from subprocess import Popen, PIPE, STDOUT
|
|
||||||
proc = Popen(cmd, stdout=PIPE, stderr=STDOUT, shell=True)
|
|
||||||
status = proc.wait()
|
|
||||||
output = proc.stdout.read()
|
|
||||||
return status, output
|
|
||||||
|
|
||||||
def strip_to_x509_cert(certfile_contents, outfile=None):
|
|
||||||
m = re.search(r"^([-]+BEGIN CERTIFICATE[-]+[\r]*\n"
|
|
||||||
r".*[\r]*^[-]+END CERTIFICATE[-]+)$",
|
|
||||||
certfile_contents, re.MULTILINE | re.DOTALL)
|
|
||||||
if not m:
|
|
||||||
return None
|
|
||||||
else:
|
|
||||||
tn = tempfile.mktemp()
|
|
||||||
fp = open(tn, "w")
|
|
||||||
fp.write(m.group(1) + "\n")
|
|
||||||
fp.close()
|
|
||||||
try:
|
|
||||||
tn2 = (outfile or tempfile.mktemp())
|
|
||||||
status, output = subproc(r'openssl x509 -in "%s" -out "%s"' %
|
|
||||||
(tn, tn2))
|
|
||||||
if status != 0:
|
|
||||||
raise OperationError(status, tsig, output)
|
|
||||||
fp = open(tn2, 'rb')
|
|
||||||
data = fp.read()
|
|
||||||
fp.close()
|
|
||||||
os.unlink(tn2)
|
|
||||||
return data
|
|
||||||
finally:
|
|
||||||
os.unlink(tn)
|
|
||||||
|
|
||||||
if sys.platform.startswith("win"):
|
|
||||||
tfile = tempfile.mktemp()
|
|
||||||
fp = open(tfile, "w")
|
|
||||||
fp.write("quit\n")
|
|
||||||
fp.close()
|
|
||||||
try:
|
|
||||||
status, output = subproc(
|
|
||||||
'openssl s_client -connect "%s:%s" -showcerts < "%s"' %
|
|
||||||
(host, port, tfile))
|
|
||||||
finally:
|
|
||||||
os.unlink(tfile)
|
|
||||||
else:
|
|
||||||
status, output = subproc(
|
|
||||||
'openssl s_client -connect "%s:%s" -showcerts < /dev/null' %
|
|
||||||
(host, port))
|
|
||||||
if status != 0:
|
|
||||||
raise OSError(status)
|
|
||||||
certtext = strip_to_x509_cert(output)
|
|
||||||
if not certtext:
|
|
||||||
raise ValueError("Invalid response received from server at %s:%s" %
|
|
||||||
(host, port))
|
|
||||||
return certtext
|
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,8 @@
|
||||||
|
# An example for http://bugs.python.org/issue815646
|
||||||
|
|
||||||
|
import thread
|
||||||
|
|
||||||
|
while 1:
|
||||||
|
f = open("/tmp/dupa", "w")
|
||||||
|
thread.start_new_thread(f.close, ())
|
||||||
|
f.close()
|
||||||
|
|
@ -862,6 +862,7 @@ _expectations = {
|
||||||
test_mhlib
|
test_mhlib
|
||||||
test_openpty
|
test_openpty
|
||||||
test_ossaudiodev
|
test_ossaudiodev
|
||||||
|
test_pipes
|
||||||
test_poll
|
test_poll
|
||||||
test_posix
|
test_posix
|
||||||
test_pty
|
test_pty
|
||||||
|
|
|
||||||
|
|
@ -49,7 +49,7 @@ result_2004_html = """
|
||||||
<head>
|
<head>
|
||||||
<meta http-equiv="Content-Type" content="text/html; charset=ascii" />
|
<meta http-equiv="Content-Type" content="text/html; charset=ascii" />
|
||||||
<link rel="stylesheet" type="text/css" href="calendar.css" />
|
<link rel="stylesheet" type="text/css" href="calendar.css" />
|
||||||
<title>Calendar for 2004</title
|
<title>Calendar for 2004</title>
|
||||||
</head>
|
</head>
|
||||||
<body>
|
<body>
|
||||||
<table border="0" cellpadding="0" cellspacing="0" class="year">
|
<table border="0" cellpadding="0" cellspacing="0" class="year">
|
||||||
|
|
|
||||||
|
|
@ -235,10 +235,20 @@ class StatAttributeTests(unittest.TestCase):
|
||||||
# Restrict test to Win32, since there is no guarantee other
|
# Restrict test to Win32, since there is no guarantee other
|
||||||
# systems support centiseconds
|
# systems support centiseconds
|
||||||
if sys.platform == 'win32':
|
if sys.platform == 'win32':
|
||||||
def test_1565150(self):
|
def get_file_system(path):
|
||||||
t1 = 1159195039.25
|
import os
|
||||||
os.utime(self.fname, (t1, t1))
|
root = os.path.splitdrive(os.path.realpath("."))[0] + '\\'
|
||||||
self.assertEquals(os.stat(self.fname).st_mtime, t1)
|
import ctypes
|
||||||
|
kernel32 = ctypes.windll.kernel32
|
||||||
|
buf = ctypes.create_string_buffer("", 100)
|
||||||
|
if kernel32.GetVolumeInformationA(root, None, 0, None, None, None, buf, len(buf)):
|
||||||
|
return buf.value
|
||||||
|
|
||||||
|
if get_file_system(test_support.TESTFN) == "NTFS":
|
||||||
|
def test_1565150(self):
|
||||||
|
t1 = 1159195039.25
|
||||||
|
os.utime(self.fname, (t1, t1))
|
||||||
|
self.assertEquals(os.stat(self.fname).st_mtime, t1)
|
||||||
|
|
||||||
def test_1686475(self):
|
def test_1686475(self):
|
||||||
# Verify that an open file can be stat'ed
|
# Verify that an open file can be stat'ed
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,187 @@
|
||||||
|
import pipes
|
||||||
|
import os
|
||||||
|
import string
|
||||||
|
import unittest
|
||||||
|
from test.test_support import TESTFN, run_unittest, unlink, TestSkipped
|
||||||
|
|
||||||
|
if os.name != 'posix':
|
||||||
|
raise TestSkipped('pipes module only works on posix')
|
||||||
|
|
||||||
|
TESTFN2 = TESTFN + "2"
|
||||||
|
|
||||||
|
class SimplePipeTests(unittest.TestCase):
|
||||||
|
def tearDown(self):
|
||||||
|
for f in (TESTFN, TESTFN2):
|
||||||
|
unlink(f)
|
||||||
|
|
||||||
|
def testSimplePipe1(self):
|
||||||
|
t = pipes.Template()
|
||||||
|
t.append('tr a-z A-Z', pipes.STDIN_STDOUT)
|
||||||
|
f = t.open(TESTFN, 'w')
|
||||||
|
f.write('hello world #1')
|
||||||
|
f.close()
|
||||||
|
self.assertEqual(open(TESTFN).read(), 'HELLO WORLD #1')
|
||||||
|
|
||||||
|
def testSimplePipe2(self):
|
||||||
|
open(TESTFN, 'w').write('hello world #2')
|
||||||
|
t = pipes.Template()
|
||||||
|
t.append('tr a-z A-Z < $IN > $OUT', pipes.FILEIN_FILEOUT)
|
||||||
|
t.copy(TESTFN, TESTFN2)
|
||||||
|
self.assertEqual(open(TESTFN2).read(), 'HELLO WORLD #2')
|
||||||
|
|
||||||
|
def testSimplePipe3(self):
|
||||||
|
open(TESTFN, 'w').write('hello world #2')
|
||||||
|
t = pipes.Template()
|
||||||
|
t.append('tr a-z A-Z < $IN', pipes.FILEIN_STDOUT)
|
||||||
|
self.assertEqual(t.open(TESTFN, 'r').read(), 'HELLO WORLD #2')
|
||||||
|
|
||||||
|
def testEmptyPipeline1(self):
|
||||||
|
# copy through empty pipe
|
||||||
|
d = 'empty pipeline test COPY'
|
||||||
|
open(TESTFN, 'w').write(d)
|
||||||
|
open(TESTFN2, 'w').write('')
|
||||||
|
t=pipes.Template()
|
||||||
|
t.copy(TESTFN, TESTFN2)
|
||||||
|
self.assertEqual(open(TESTFN2).read(), d)
|
||||||
|
|
||||||
|
def testEmptyPipeline2(self):
|
||||||
|
# read through empty pipe
|
||||||
|
d = 'empty pipeline test READ'
|
||||||
|
open(TESTFN, 'w').write(d)
|
||||||
|
t=pipes.Template()
|
||||||
|
self.assertEqual(t.open(TESTFN, 'r').read(), d)
|
||||||
|
|
||||||
|
def testEmptyPipeline3(self):
|
||||||
|
# write through empty pipe
|
||||||
|
d = 'empty pipeline test WRITE'
|
||||||
|
t = pipes.Template()
|
||||||
|
t.open(TESTFN, 'w').write(d)
|
||||||
|
self.assertEqual(open(TESTFN).read(), d)
|
||||||
|
|
||||||
|
def testQuoting(self):
|
||||||
|
safeunquoted = string.ascii_letters + string.digits + '!@%_-+=:,./'
|
||||||
|
unsafe = '"`$\\'
|
||||||
|
|
||||||
|
self.assertEqual(pipes.quote(safeunquoted), safeunquoted)
|
||||||
|
self.assertEqual(pipes.quote('test file name'), "'test file name'")
|
||||||
|
for u in unsafe:
|
||||||
|
self.assertEqual(pipes.quote('test%sname' % u),
|
||||||
|
"'test%sname'" % u)
|
||||||
|
for u in unsafe:
|
||||||
|
self.assertEqual(pipes.quote("test%s'name'" % u),
|
||||||
|
'"test\\%s\'name\'"' % u)
|
||||||
|
|
||||||
|
def testRepr(self):
|
||||||
|
t = pipes.Template()
|
||||||
|
self.assertEqual(repr(t), "<Template instance, steps=[]>")
|
||||||
|
t.append('tr a-z A-Z', pipes.STDIN_STDOUT)
|
||||||
|
self.assertEqual(repr(t),
|
||||||
|
"<Template instance, steps=[('tr a-z A-Z', '--')]>")
|
||||||
|
|
||||||
|
def testSetDebug(self):
|
||||||
|
t = pipes.Template()
|
||||||
|
t.debug(False)
|
||||||
|
self.assertEqual(t.debugging, False)
|
||||||
|
t.debug(True)
|
||||||
|
self.assertEqual(t.debugging, True)
|
||||||
|
|
||||||
|
def testReadOpenSink(self):
|
||||||
|
# check calling open('r') on a pipe ending with
|
||||||
|
# a sink raises ValueError
|
||||||
|
t = pipes.Template()
|
||||||
|
t.append('boguscmd', pipes.SINK)
|
||||||
|
self.assertRaises(ValueError, t.open, 'bogusfile', 'r')
|
||||||
|
|
||||||
|
def testWriteOpenSource(self):
|
||||||
|
# check calling open('w') on a pipe ending with
|
||||||
|
# a source raises ValueError
|
||||||
|
t = pipes.Template()
|
||||||
|
t.prepend('boguscmd', pipes.SOURCE)
|
||||||
|
self.assertRaises(ValueError, t.open, 'bogusfile', 'w')
|
||||||
|
|
||||||
|
def testBadAppendOptions(self):
|
||||||
|
t = pipes.Template()
|
||||||
|
|
||||||
|
# try a non-string command
|
||||||
|
self.assertRaises(TypeError, t.append, 7, pipes.STDIN_STDOUT)
|
||||||
|
|
||||||
|
# try a type that isn't recognized
|
||||||
|
self.assertRaises(ValueError, t.append, 'boguscmd', 'xx')
|
||||||
|
|
||||||
|
# shouldn't be able to append a source
|
||||||
|
self.assertRaises(ValueError, t.append, 'boguscmd', pipes.SOURCE)
|
||||||
|
|
||||||
|
# check appending two sinks
|
||||||
|
t = pipes.Template()
|
||||||
|
t.append('boguscmd', pipes.SINK)
|
||||||
|
self.assertRaises(ValueError, t.append, 'boguscmd', pipes.SINK)
|
||||||
|
|
||||||
|
# command needing file input but with no $IN
|
||||||
|
t = pipes.Template()
|
||||||
|
self.assertRaises(ValueError, t.append, 'boguscmd $OUT',
|
||||||
|
pipes.FILEIN_FILEOUT)
|
||||||
|
t = pipes.Template()
|
||||||
|
self.assertRaises(ValueError, t.append, 'boguscmd',
|
||||||
|
pipes.FILEIN_STDOUT)
|
||||||
|
|
||||||
|
# command needing file output but with no $OUT
|
||||||
|
t = pipes.Template()
|
||||||
|
self.assertRaises(ValueError, t.append, 'boguscmd $IN',
|
||||||
|
pipes.FILEIN_FILEOUT)
|
||||||
|
t = pipes.Template()
|
||||||
|
self.assertRaises(ValueError, t.append, 'boguscmd',
|
||||||
|
pipes.STDIN_FILEOUT)
|
||||||
|
|
||||||
|
|
||||||
|
def testBadPrependOptions(self):
|
||||||
|
t = pipes.Template()
|
||||||
|
|
||||||
|
# try a non-string command
|
||||||
|
self.assertRaises(TypeError, t.prepend, 7, pipes.STDIN_STDOUT)
|
||||||
|
|
||||||
|
# try a type that isn't recognized
|
||||||
|
self.assertRaises(ValueError, t.prepend, 'tr a-z A-Z', 'xx')
|
||||||
|
|
||||||
|
# shouldn't be able to prepend a sink
|
||||||
|
self.assertRaises(ValueError, t.prepend, 'boguscmd', pipes.SINK)
|
||||||
|
|
||||||
|
# check prepending two sources
|
||||||
|
t = pipes.Template()
|
||||||
|
t.prepend('boguscmd', pipes.SOURCE)
|
||||||
|
self.assertRaises(ValueError, t.prepend, 'boguscmd', pipes.SOURCE)
|
||||||
|
|
||||||
|
# command needing file input but with no $IN
|
||||||
|
t = pipes.Template()
|
||||||
|
self.assertRaises(ValueError, t.prepend, 'boguscmd $OUT',
|
||||||
|
pipes.FILEIN_FILEOUT)
|
||||||
|
t = pipes.Template()
|
||||||
|
self.assertRaises(ValueError, t.prepend, 'boguscmd',
|
||||||
|
pipes.FILEIN_STDOUT)
|
||||||
|
|
||||||
|
# command needing file output but with no $OUT
|
||||||
|
t = pipes.Template()
|
||||||
|
self.assertRaises(ValueError, t.prepend, 'boguscmd $IN',
|
||||||
|
pipes.FILEIN_FILEOUT)
|
||||||
|
t = pipes.Template()
|
||||||
|
self.assertRaises(ValueError, t.prepend, 'boguscmd',
|
||||||
|
pipes.STDIN_FILEOUT)
|
||||||
|
|
||||||
|
def testBadOpenMode(self):
|
||||||
|
t = pipes.Template()
|
||||||
|
self.assertRaises(ValueError, t.open, 'bogusfile', 'x')
|
||||||
|
|
||||||
|
def testClone(self):
|
||||||
|
t = pipes.Template()
|
||||||
|
t.append('tr a-z A-Z', pipes.STDIN_STDOUT)
|
||||||
|
|
||||||
|
u = t.clone()
|
||||||
|
self.assertNotEqual(id(t), id(u))
|
||||||
|
self.assertEqual(t.steps, u.steps)
|
||||||
|
self.assertNotEqual(id(t.steps), id(u.steps))
|
||||||
|
self.assertEqual(t.debugging, u.debugging)
|
||||||
|
|
||||||
|
def test_main():
|
||||||
|
run_unittest(SimplePipeTests)
|
||||||
|
|
||||||
|
if __name__ == "__main__":
|
||||||
|
test_main()
|
||||||
|
|
@ -135,8 +135,19 @@ bad = [] # Bug report says "/" should be denied, but that is not in the RFC
|
||||||
|
|
||||||
RobotTest(7, doc, good, bad)
|
RobotTest(7, doc, good, bad)
|
||||||
|
|
||||||
|
class TestCase(unittest.TestCase):
|
||||||
|
def runTest(self):
|
||||||
|
test_support.requires('network')
|
||||||
|
# whole site is password-protected.
|
||||||
|
url = 'http://mueblesmoraleda.com'
|
||||||
|
parser = robotparser.RobotFileParser()
|
||||||
|
parser.set_url(url)
|
||||||
|
parser.read()
|
||||||
|
self.assertEqual(parser.can_fetch("*", url+"/robots.txt"), False)
|
||||||
|
|
||||||
def test_main():
|
def test_main():
|
||||||
test_support.run_unittest(tests)
|
test_support.run_unittest(tests)
|
||||||
|
TestCase().run()
|
||||||
|
|
||||||
if __name__=='__main__':
|
if __name__=='__main__':
|
||||||
test_support.Verbose = 1
|
test_support.Verbose = 1
|
||||||
|
|
|
||||||
|
|
@ -110,12 +110,12 @@ class BasicTests(unittest.TestCase):
|
||||||
if test_support.verbose:
|
if test_support.verbose:
|
||||||
print("test_978833 ...")
|
print("test_978833 ...")
|
||||||
|
|
||||||
import os, httplib
|
import os, httplib, ssl
|
||||||
with test_support.transient_internet():
|
with test_support.transient_internet():
|
||||||
s = socket.socket(socket.AF_INET)
|
s = socket.socket(socket.AF_INET)
|
||||||
s.connect(("www.sf.net", 443))
|
s.connect(("www.sf.net", 443))
|
||||||
fd = s.fileno()
|
fd = s.fileno()
|
||||||
sock = httplib.FakeSocket(s, socket.ssl(s))
|
sock = ssl.sslsocket(s)
|
||||||
s = None
|
s = None
|
||||||
sock.close()
|
sock.close()
|
||||||
try:
|
try:
|
||||||
|
|
|
||||||
|
|
@ -83,7 +83,6 @@ with catch_warning():
|
||||||
import opcode
|
import opcode
|
||||||
import os2emxpath
|
import os2emxpath
|
||||||
import pdb
|
import pdb
|
||||||
import pipes
|
|
||||||
import pstats
|
import pstats
|
||||||
import py_compile
|
import py_compile
|
||||||
import pydoc
|
import pydoc
|
||||||
|
|
|
||||||
|
|
@ -147,8 +147,7 @@ class WinregTests(unittest.TestCase):
|
||||||
|
|
||||||
def testRemoteMachineRegistryWorks(self):
|
def testRemoteMachineRegistryWorks(self):
|
||||||
if not self.remote_name:
|
if not self.remote_name:
|
||||||
raise test_support.TestSkipped("Remote machine name "
|
return # remote machine name not specified
|
||||||
"not specified.")
|
|
||||||
remote_key = ConnectRegistry(self.remote_name, HKEY_CURRENT_USER)
|
remote_key = ConnectRegistry(self.remote_name, HKEY_CURRENT_USER)
|
||||||
self.TestAll(remote_key)
|
self.TestAll(remote_key)
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -441,8 +441,10 @@ class FailingServerTestCase(unittest.TestCase):
|
||||||
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
|
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
|
||||||
self.assertEqual(p.pow(6,8), 6**8)
|
self.assertEqual(p.pow(6,8), 6**8)
|
||||||
except xmlrpclib.ProtocolError as e:
|
except xmlrpclib.ProtocolError as e:
|
||||||
# protocol error; provide additional information in test output
|
# ignore failures due to non-blocking socket 'unavailable' errors
|
||||||
self.fail("%s\n%s" % (e, e.headers))
|
if not is_unavailable_exception(e):
|
||||||
|
# protocol error; provide additional information in test output
|
||||||
|
self.fail("%s\n%s" % (e, e.headers))
|
||||||
|
|
||||||
def test_fail_no_info(self):
|
def test_fail_no_info(self):
|
||||||
# use the broken message class
|
# use the broken message class
|
||||||
|
|
@ -452,9 +454,11 @@ class FailingServerTestCase(unittest.TestCase):
|
||||||
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
|
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
|
||||||
p.pow(6,8)
|
p.pow(6,8)
|
||||||
except xmlrpclib.ProtocolError as e:
|
except xmlrpclib.ProtocolError as e:
|
||||||
# The two server-side error headers shouldn't be sent back in this case
|
# ignore failures due to non-blocking socket 'unavailable' errors
|
||||||
self.assertTrue(e.headers.get("X-exception") is None)
|
if not is_unavailable_exception(e):
|
||||||
self.assertTrue(e.headers.get("X-traceback") is None)
|
# The two server-side error headers shouldn't be sent back in this case
|
||||||
|
self.assertTrue(e.headers.get("X-exception") is None)
|
||||||
|
self.assertTrue(e.headers.get("X-traceback") is None)
|
||||||
else:
|
else:
|
||||||
self.fail('ProtocolError not raised')
|
self.fail('ProtocolError not raised')
|
||||||
|
|
||||||
|
|
@ -470,10 +474,12 @@ class FailingServerTestCase(unittest.TestCase):
|
||||||
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
|
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
|
||||||
p.pow(6,8)
|
p.pow(6,8)
|
||||||
except xmlrpclib.ProtocolError as e:
|
except xmlrpclib.ProtocolError as e:
|
||||||
# We should get error info in the response
|
# ignore failures due to non-blocking socket 'unavailable' errors
|
||||||
expected_err = "invalid literal for int() with base 10: 'I am broken'"
|
if not is_unavailable_exception(e):
|
||||||
self.assertEqual(e.headers.get("x-exception"), expected_err)
|
# We should get error info in the response
|
||||||
self.assertTrue(e.headers.get("x-traceback") is not None)
|
expected_err = "invalid literal for int() with base 10: 'I am broken'"
|
||||||
|
self.assertEqual(e.headers.get("x-exception"), expected_err)
|
||||||
|
self.assertTrue(e.headers.get("x-traceback") is not None)
|
||||||
else:
|
else:
|
||||||
self.fail('ProtocolError not raised')
|
self.fail('ProtocolError not raised')
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -91,6 +91,14 @@ def urlcleanup():
|
||||||
if _urlopener:
|
if _urlopener:
|
||||||
_urlopener.cleanup()
|
_urlopener.cleanup()
|
||||||
|
|
||||||
|
# check for SSL
|
||||||
|
try:
|
||||||
|
import ssl
|
||||||
|
except:
|
||||||
|
_have_ssl = False
|
||||||
|
else:
|
||||||
|
_have_ssl = True
|
||||||
|
|
||||||
# exception raised when downloaded size does not match content-length
|
# exception raised when downloaded size does not match content-length
|
||||||
class ContentTooShortError(IOError):
|
class ContentTooShortError(IOError):
|
||||||
def __init__(self, message, content):
|
def __init__(self, message, content):
|
||||||
|
|
@ -382,7 +390,7 @@ class URLopener:
|
||||||
fp.close()
|
fp.close()
|
||||||
raise IOError('http error', errcode, errmsg, headers)
|
raise IOError('http error', errcode, errmsg, headers)
|
||||||
|
|
||||||
if hasattr(socket, "ssl"):
|
if _have_ssl:
|
||||||
def _https_connection(self, host):
|
def _https_connection(self, host):
|
||||||
return httplib.HTTPSConnection(host,
|
return httplib.HTTPSConnection(host,
|
||||||
key_file=self.key_file,
|
key_file=self.key_file,
|
||||||
|
|
|
||||||
|
|
@ -17,6 +17,9 @@ the format to accommodate documentation needs as they arise.
|
||||||
Permissions History
|
Permissions History
|
||||||
-------------------
|
-------------------
|
||||||
|
|
||||||
|
- Bill Janssen was given SVN access on 28 August 2007 by NCN,
|
||||||
|
for his work on the SSL module and other things related to (SSL) sockets.
|
||||||
|
|
||||||
- Jeffrey Yasskin was given SVN access on 9 August 2007 by NCN,
|
- Jeffrey Yasskin was given SVN access on 9 August 2007 by NCN,
|
||||||
for his work on PEPs and other general patches.
|
for his work on PEPs and other general patches.
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -3747,6 +3747,108 @@ Array_slice(PyObject *_self, Py_ssize_t ilow, Py_ssize_t ihigh)
|
||||||
return (PyObject *)np;
|
return (PyObject *)np;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static PyObject *
|
||||||
|
Array_subscript(PyObject *_self, PyObject *item)
|
||||||
|
{
|
||||||
|
CDataObject *self = (CDataObject *)_self;
|
||||||
|
|
||||||
|
if (PyIndex_Check(item)) {
|
||||||
|
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
|
||||||
|
|
||||||
|
if (i == -1 && PyErr_Occurred())
|
||||||
|
return NULL;
|
||||||
|
if (i < 0)
|
||||||
|
i += self->b_length;
|
||||||
|
return Array_item(_self, i);
|
||||||
|
}
|
||||||
|
else if PySlice_Check(item) {
|
||||||
|
StgDictObject *stgdict, *itemdict;
|
||||||
|
PyObject *proto;
|
||||||
|
PyObject *np;
|
||||||
|
Py_ssize_t start, stop, step, slicelen, cur, i;
|
||||||
|
|
||||||
|
if (PySlice_GetIndicesEx((PySliceObject *)item,
|
||||||
|
self->b_length, &start, &stop,
|
||||||
|
&step, &slicelen) < 0) {
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
stgdict = PyObject_stgdict((PyObject *)self);
|
||||||
|
assert(stgdict); /* Cannot be NULL for array object instances */
|
||||||
|
proto = stgdict->proto;
|
||||||
|
itemdict = PyType_stgdict(proto);
|
||||||
|
assert(itemdict); /* proto is the item type of the array, a
|
||||||
|
ctypes type, so this cannot be NULL */
|
||||||
|
|
||||||
|
if (itemdict->getfunc == getentry("c")->getfunc) {
|
||||||
|
char *ptr = (char *)self->b_ptr;
|
||||||
|
char *dest;
|
||||||
|
|
||||||
|
if (slicelen <= 0)
|
||||||
|
return PyString_FromString("");
|
||||||
|
if (step == 1) {
|
||||||
|
return PyString_FromStringAndSize(ptr + start,
|
||||||
|
slicelen);
|
||||||
|
}
|
||||||
|
dest = (char *)PyMem_Malloc(slicelen);
|
||||||
|
|
||||||
|
if (dest == NULL)
|
||||||
|
return PyErr_NoMemory();
|
||||||
|
|
||||||
|
for (cur = start, i = 0; i < slicelen;
|
||||||
|
cur += step, i++) {
|
||||||
|
dest[i] = ptr[cur];
|
||||||
|
}
|
||||||
|
|
||||||
|
np = PyString_FromStringAndSize(dest, slicelen);
|
||||||
|
PyMem_Free(dest);
|
||||||
|
return np;
|
||||||
|
}
|
||||||
|
#ifdef CTYPES_UNICODE
|
||||||
|
if (itemdict->getfunc == getentry("u")->getfunc) {
|
||||||
|
wchar_t *ptr = (wchar_t *)self->b_ptr;
|
||||||
|
wchar_t *dest;
|
||||||
|
|
||||||
|
if (slicelen <= 0)
|
||||||
|
return PyUnicode_FromUnicode(NULL, 0);
|
||||||
|
if (step == 1) {
|
||||||
|
return PyUnicode_FromWideChar(ptr + start,
|
||||||
|
slicelen);
|
||||||
|
}
|
||||||
|
|
||||||
|
dest = (wchar_t *)PyMem_Malloc(
|
||||||
|
slicelen * sizeof(wchar_t));
|
||||||
|
|
||||||
|
for (cur = start, i = 0; i < slicelen;
|
||||||
|
cur += step, i++) {
|
||||||
|
dest[i] = ptr[cur];
|
||||||
|
}
|
||||||
|
|
||||||
|
np = PyUnicode_FromWideChar(dest, slicelen);
|
||||||
|
PyMem_Free(dest);
|
||||||
|
return np;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
np = PyList_New(slicelen);
|
||||||
|
if (np == NULL)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
for (cur = start, i = 0; i < slicelen;
|
||||||
|
cur += step, i++) {
|
||||||
|
PyObject *v = Array_item(_self, cur);
|
||||||
|
PyList_SET_ITEM(np, i, v);
|
||||||
|
}
|
||||||
|
return np;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
PyErr_SetString(PyExc_TypeError,
|
||||||
|
"indices must be integers");
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
static int
|
static int
|
||||||
Array_ass_item(PyObject *_self, Py_ssize_t index, PyObject *value)
|
Array_ass_item(PyObject *_self, Py_ssize_t index, PyObject *value)
|
||||||
{
|
{
|
||||||
|
|
@ -3818,6 +3920,63 @@ Array_ass_slice(PyObject *_self, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *va
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
Array_ass_subscript(PyObject *_self, PyObject *item, PyObject *value)
|
||||||
|
{
|
||||||
|
CDataObject *self = (CDataObject *)_self;
|
||||||
|
|
||||||
|
if (value == NULL) {
|
||||||
|
PyErr_SetString(PyExc_TypeError,
|
||||||
|
"Array does not support item deletion");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (PyIndex_Check(item)) {
|
||||||
|
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
|
||||||
|
|
||||||
|
if (i == -1 && PyErr_Occurred())
|
||||||
|
return -1;
|
||||||
|
if (i < 0)
|
||||||
|
i += self->b_length;
|
||||||
|
return Array_ass_item(_self, i, value);
|
||||||
|
}
|
||||||
|
else if (PySlice_Check(item)) {
|
||||||
|
Py_ssize_t start, stop, step, slicelen, otherlen, i, cur;
|
||||||
|
|
||||||
|
if (PySlice_GetIndicesEx((PySliceObject *)item,
|
||||||
|
self->b_length, &start, &stop,
|
||||||
|
&step, &slicelen) < 0) {
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
if ((step < 0 && start < stop) ||
|
||||||
|
(step > 0 && start > stop))
|
||||||
|
stop = start;
|
||||||
|
|
||||||
|
otherlen = PySequence_Length(value);
|
||||||
|
if (otherlen != slicelen) {
|
||||||
|
PyErr_SetString(PyExc_ValueError,
|
||||||
|
"Can only assign sequence of same size");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
for (cur = start, i = 0; i < otherlen; cur += step, i++) {
|
||||||
|
PyObject *item = PySequence_GetItem(value, i);
|
||||||
|
int result;
|
||||||
|
if (item == NULL)
|
||||||
|
return -1;
|
||||||
|
result = Array_ass_item(_self, cur, item);
|
||||||
|
Py_DECREF(item);
|
||||||
|
if (result == -1)
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
PyErr_SetString(PyExc_TypeError,
|
||||||
|
"indices must be integer");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
static Py_ssize_t
|
static Py_ssize_t
|
||||||
Array_length(PyObject *_self)
|
Array_length(PyObject *_self)
|
||||||
{
|
{
|
||||||
|
|
@ -3839,6 +3998,12 @@ static PySequenceMethods Array_as_sequence = {
|
||||||
0, /* sq_inplace_repeat; */
|
0, /* sq_inplace_repeat; */
|
||||||
};
|
};
|
||||||
|
|
||||||
|
static PyMappingMethods Array_as_mapping = {
|
||||||
|
Array_length,
|
||||||
|
Array_subscript,
|
||||||
|
Array_ass_subscript,
|
||||||
|
};
|
||||||
|
|
||||||
PyTypeObject Array_Type = {
|
PyTypeObject Array_Type = {
|
||||||
PyVarObject_HEAD_INIT(NULL, 0)
|
PyVarObject_HEAD_INIT(NULL, 0)
|
||||||
"_ctypes.Array",
|
"_ctypes.Array",
|
||||||
|
|
@ -3852,7 +4017,7 @@ PyTypeObject Array_Type = {
|
||||||
0, /* tp_repr */
|
0, /* tp_repr */
|
||||||
0, /* tp_as_number */
|
0, /* tp_as_number */
|
||||||
&Array_as_sequence, /* tp_as_sequence */
|
&Array_as_sequence, /* tp_as_sequence */
|
||||||
0, /* tp_as_mapping */
|
&Array_as_mapping, /* tp_as_mapping */
|
||||||
0, /* tp_hash */
|
0, /* tp_hash */
|
||||||
0, /* tp_call */
|
0, /* tp_call */
|
||||||
0, /* tp_str */
|
0, /* tp_str */
|
||||||
|
|
@ -4303,6 +4468,139 @@ Pointer_slice(PyObject *_self, Py_ssize_t ilow, Py_ssize_t ihigh)
|
||||||
return (PyObject *)np;
|
return (PyObject *)np;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static PyObject *
|
||||||
|
Pointer_subscript(PyObject *_self, PyObject *item)
|
||||||
|
{
|
||||||
|
CDataObject *self = (CDataObject *)_self;
|
||||||
|
if (PyIndex_Check(item)) {
|
||||||
|
Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
|
||||||
|
if (i == -1 && PyErr_Occurred())
|
||||||
|
return NULL;
|
||||||
|
return Pointer_item(_self, i);
|
||||||
|
}
|
||||||
|
else if (PySlice_Check(item)) {
|
||||||
|
PySliceObject *slice = (PySliceObject *)item;
|
||||||
|
Py_ssize_t start, stop, step;
|
||||||
|
PyObject *np;
|
||||||
|
StgDictObject *stgdict, *itemdict;
|
||||||
|
PyObject *proto;
|
||||||
|
Py_ssize_t i, len, cur;
|
||||||
|
|
||||||
|
/* Since pointers have no length, and we want to apply
|
||||||
|
different semantics to negative indices than normal
|
||||||
|
slicing, we have to dissect the slice object ourselves.*/
|
||||||
|
if (slice->step == Py_None) {
|
||||||
|
step = 1;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
step = PyNumber_AsSsize_t(slice->step,
|
||||||
|
PyExc_ValueError);
|
||||||
|
if (step == -1 && PyErr_Occurred())
|
||||||
|
return NULL;
|
||||||
|
if (step == 0) {
|
||||||
|
PyErr_SetString(PyExc_ValueError,
|
||||||
|
"slice step cannot be zero");
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (slice->start == Py_None) {
|
||||||
|
if (step < 0) {
|
||||||
|
PyErr_SetString(PyExc_ValueError,
|
||||||
|
"slice start is required "
|
||||||
|
"for step < 0");
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
start = 0;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
start = PyNumber_AsSsize_t(slice->start,
|
||||||
|
PyExc_ValueError);
|
||||||
|
if (start == -1 && PyErr_Occurred())
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
if (slice->stop == Py_None) {
|
||||||
|
PyErr_SetString(PyExc_ValueError,
|
||||||
|
"slice stop is required");
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
stop = PyNumber_AsSsize_t(slice->stop,
|
||||||
|
PyExc_ValueError);
|
||||||
|
if (stop == -1 && PyErr_Occurred())
|
||||||
|
return NULL;
|
||||||
|
if ((step > 0 && start > stop) ||
|
||||||
|
(step < 0 && start < stop))
|
||||||
|
len = 0;
|
||||||
|
else if (step > 0)
|
||||||
|
len = (stop - start - 1) / step + 1;
|
||||||
|
else
|
||||||
|
len = (stop - start + 1) / step + 1;
|
||||||
|
|
||||||
|
stgdict = PyObject_stgdict((PyObject *)self);
|
||||||
|
assert(stgdict); /* Cannot be NULL for pointer instances */
|
||||||
|
proto = stgdict->proto;
|
||||||
|
assert(proto);
|
||||||
|
itemdict = PyType_stgdict(proto);
|
||||||
|
assert(itemdict);
|
||||||
|
if (itemdict->getfunc == getentry("c")->getfunc) {
|
||||||
|
char *ptr = *(char **)self->b_ptr;
|
||||||
|
char *dest;
|
||||||
|
|
||||||
|
if (len <= 0)
|
||||||
|
return PyString_FromString("");
|
||||||
|
if (step == 1) {
|
||||||
|
return PyString_FromStringAndSize(ptr + start,
|
||||||
|
len);
|
||||||
|
}
|
||||||
|
dest = (char *)PyMem_Malloc(len);
|
||||||
|
if (dest == NULL)
|
||||||
|
return PyErr_NoMemory();
|
||||||
|
for (cur = start, i = 0; i < len; cur += step, i++) {
|
||||||
|
dest[i] = ptr[cur];
|
||||||
|
}
|
||||||
|
np = PyString_FromStringAndSize(dest, len);
|
||||||
|
PyMem_Free(dest);
|
||||||
|
return np;
|
||||||
|
}
|
||||||
|
#ifdef CTYPES_UNICODE
|
||||||
|
if (itemdict->getfunc == getentry("u")->getfunc) {
|
||||||
|
wchar_t *ptr = *(wchar_t **)self->b_ptr;
|
||||||
|
wchar_t *dest;
|
||||||
|
|
||||||
|
if (len <= 0)
|
||||||
|
return PyUnicode_FromUnicode(NULL, 0);
|
||||||
|
if (step == 1) {
|
||||||
|
return PyUnicode_FromWideChar(ptr + start,
|
||||||
|
len);
|
||||||
|
}
|
||||||
|
dest = (wchar_t *)PyMem_Malloc(len * sizeof(wchar_t));
|
||||||
|
if (dest == NULL)
|
||||||
|
return PyErr_NoMemory();
|
||||||
|
for (cur = start, i = 0; i < len; cur += step, i++) {
|
||||||
|
dest[i] = ptr[cur];
|
||||||
|
}
|
||||||
|
np = PyUnicode_FromWideChar(dest, len);
|
||||||
|
PyMem_Free(dest);
|
||||||
|
return np;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
np = PyList_New(len);
|
||||||
|
if (np == NULL)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
for (cur = start, i = 0; i < len; cur += step, i++) {
|
||||||
|
PyObject *v = Pointer_item(_self, cur);
|
||||||
|
PyList_SET_ITEM(np, i, v);
|
||||||
|
}
|
||||||
|
return np;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
PyErr_SetString(PyExc_TypeError,
|
||||||
|
"Pointer indices must be integer");
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
static PySequenceMethods Pointer_as_sequence = {
|
static PySequenceMethods Pointer_as_sequence = {
|
||||||
0, /* inquiry sq_length; */
|
0, /* inquiry sq_length; */
|
||||||
0, /* binaryfunc sq_concat; */
|
0, /* binaryfunc sq_concat; */
|
||||||
|
|
@ -4317,6 +4615,11 @@ static PySequenceMethods Pointer_as_sequence = {
|
||||||
0, /* intargfunc sq_inplace_repeat; */
|
0, /* intargfunc sq_inplace_repeat; */
|
||||||
};
|
};
|
||||||
|
|
||||||
|
static PyMappingMethods Pointer_as_mapping = {
|
||||||
|
0,
|
||||||
|
Pointer_subscript,
|
||||||
|
};
|
||||||
|
|
||||||
static int
|
static int
|
||||||
Pointer_bool(CDataObject *self)
|
Pointer_bool(CDataObject *self)
|
||||||
{
|
{
|
||||||
|
|
@ -4349,7 +4652,7 @@ PyTypeObject Pointer_Type = {
|
||||||
0, /* tp_repr */
|
0, /* tp_repr */
|
||||||
&Pointer_as_number, /* tp_as_number */
|
&Pointer_as_number, /* tp_as_number */
|
||||||
&Pointer_as_sequence, /* tp_as_sequence */
|
&Pointer_as_sequence, /* tp_as_sequence */
|
||||||
0, /* tp_as_mapping */
|
&Pointer_as_mapping, /* tp_as_mapping */
|
||||||
0, /* tp_hash */
|
0, /* tp_hash */
|
||||||
0, /* tp_call */
|
0, /* tp_call */
|
||||||
0, /* tp_str */
|
0, /* tp_str */
|
||||||
|
|
|
||||||
|
|
@ -11,6 +11,7 @@ if __name__ == '__main__':
|
||||||
'ftpmirror.py',
|
'ftpmirror.py',
|
||||||
'h2py.py',
|
'h2py.py',
|
||||||
'lfcr.py',
|
'lfcr.py',
|
||||||
|
'../i18n/pygettext.py',
|
||||||
'logmerge.py',
|
'logmerge.py',
|
||||||
'../../Lib/tabnanny.py',
|
'../../Lib/tabnanny.py',
|
||||||
'../../Lib/timeit.py',
|
'../../Lib/timeit.py',
|
||||||
|
|
|
||||||
|
|
@ -4,7 +4,7 @@ dnl Process this file with autoconf 2.0 or later to make a configure script.
|
||||||
m4_define(PYTHON_VERSION, 3.0)
|
m4_define(PYTHON_VERSION, 3.0)
|
||||||
|
|
||||||
AC_REVISION($Revision$)
|
AC_REVISION($Revision$)
|
||||||
AC_PREREQ(2.59)
|
AC_PREREQ(2.61)
|
||||||
AC_INIT(python, PYTHON_VERSION, http://www.python.org/python-bugs)
|
AC_INIT(python, PYTHON_VERSION, http://www.python.org/python-bugs)
|
||||||
AC_CONFIG_SRCDIR([Include/object.h])
|
AC_CONFIG_SRCDIR([Include/object.h])
|
||||||
AC_CONFIG_HEADER(pyconfig.h)
|
AC_CONFIG_HEADER(pyconfig.h)
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue