Foundations of Python Network Programming 978-1-4302-3004-5

CHAPTER 3 ■ TCP
As before, my operating system uses the special IP address 0.0.0.0 to mean “accept connections on
any interface,” but that may vary with operating system, and Python hides this fact by letting you use the
empty string instead.
Deadlock
The term “deadlock” is used for all sorts of situations in computer science where two programs, sharing
limited resources, can wind up waiting on each other forever because of poor planning. It turns out that
it can happen fairly easily when using TCP.
I mentioned previously that typical TCP stacks use buffers, both so that they have somewhere to
place incoming packet data until an application is ready to read it, and so that they can collect outgoing
data until the network hardware is ready to transmit an outgoing packet. These buffers are typically
quite limited in size, and the system is not generally willing to let programs fill all of RAM with unsent
network data. After all, if the remote end is not yet ready to process the data, it makes little sense to
expend system resources on the generating end trying to produce more of it.
This limitation will generally not trouble you if you follow the client-server pattern shown in Listing
3–1, where each end always reads its partner’s complete message before turning around and sending
data in the other direction. But you can run into trouble very quickly if you design a client and server
that leave too much data waiting without having some arrangement for promptly reading it.
Take a look at Listing 3–2 for an example of a server and client that try to be a bit too clever without
thinking through the consequences. Here, the server author has done something that is actually quite
intelligent. His job is to turn an arbitrary amount of text into uppercase. Recognizing that its client’s
requests can be arbitrarily large, and that one could run out of memory trying to read an entire stream of
input before trying to process it, the server reads and processes small blocks of 1,024 bytes at a time.
Listing 3–2. TCP Server and Client That Deadlock
#!/usr/bin/env python
# Foundations of Python Network Programming - Chapter 3 - tcp_deadlock.py
# TCP client and server that leave too much data waiting
import socket, sys
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
HOST = '127.0.0.1'
PORT = 1060
if sys.argv[1:] == ['server']:
» s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
» s.bind((HOST, PORT))
» s.listen(1)
» while True:
» » print 'Listening at', s.getsockname()
» » sc, sockname = s.accept()
» » print 'Processing up to 1024 bytes at a time from', sockname
» » n = 0
» » while True:
» » » message = sc.recv(1024)
» » » if not message:
» » » » break
» » » sc.sendall(message.upper()) # send it back uppercase
» » » n += len(message)
44