rbit py at
Wed Jan 9 05:39:00 CET 2013

Thank you. I will gladly port to Python 3 if there is interest from
the community.

Regarding PEP 3156: asynchronous use of unreliable network protocols
makes for an interesting use case. In particular, it forces
applications to deal with packet loss under some circumstances. One
such situation occurs during DTLS's handshaking phase: if no response
is received from the peer after some period of time, we must assume
that our most recent datagram has been lost, and so we need to
retransmit. The event loop interface as outlined in the PEP makes this
a bit difficult (as did the asyncore module). One possible way to make
things easier would be by adding two parameters to add_reader: a
callable to retrieve the current timeout, and a callable that is
invoked if that timeout expires before the descriptor becomes
readable. Each loop iteration would then collect all given timeouts,
and pass the minimum of that set to whatever polling facility it
invokes. If that timeout expires, the corresponding timeout handler
would be invoked prior to the next loop iteration.

The PEP also considers only stream transports when referring to
"transport." Datagram transports do not, for example, have the
property that calling t.write(b'abc'); t.write(b'def') is equivalent
to calling t.write(b'abcdef'). I'm not sure what sort of impact this
omission of datagram transports has for an implementation. Though I
would certainly like to see datagram transports be treated as
first-class citizens, despite not being nearly used as often as stream
transports. I would hope that an implementer of, say, RTP over UDP,
can tie into the same event loop as someone implementing a
single-process, single-threaded Web server.

Implementing DTLS as a tulip transport sounds interesting. Is the
tulip package available somewhere so that I can try it out?


On Tue, Jan 8, 2013 at 6:53 AM, Guido van Rossum <guido at> wrote:
> This sounds exciting. Are you considering a Python 3 port? It might make a
> nice demo of PEP 3156.
> On Monday, January 7, 2013, rbit wrote:
>> I would like to announce Datagram Transport Layer Security for
>> Python. From the top of the project README:
>> PyDTLS brings Datagram Transport Layer Security (DTLS - RFC 6347:
>> to the Python environment. In a
>> nutshell, DTLS brings security (encryption, server authentication,
>> user authentication, and message authentication) to UDP datagram
>> payloads in a manner equivalent to what SSL/TLS does for TCP stream
>> content.
>> DTLS is now very easy to use in Python. If you're familiar with the
>> ssl module in Python's standard library, you already know how. All it
>> takes is passing a datagram/UDP socket to the *wrap_socket* function
>> instead of a stream/TCP socket. Here's how one sets up the client side
>> of a connection:
>>     import ssl
>>     from socket import socket, AF_INET, SOCK_DGRAM
>>     from dtls import do_patch
>>     do_patch()
>>     sock = ssl.wrap_socket(socket(AF_INET, SOCK_DGRAM))
>>     sock.connect(('', 1234))
>>     sock.send('Hi there')
>> The project is hosted at, and licensed
>> under
>> the Apache license 2.0. PyPI has packages. I can be reached
>> at code AT liquibits DOT com for questions, feedback, etc.
>> <P><A HREF="">Dtls 0.1.0</A> -
>>       Datagram Transport Layer Security for Python.  (07-Jan-13)
>> --
>>         Support the Python Software Foundation:
> --
> --Guido van Rossum (
> --

More information about the Python-list mailing list