Programming Python (103 page)

"""
Server side: open a TCP/IP socket on a port, listen for a message from
a client, and send an echo reply; this is a simple one-shot listen/reply
conversation per client, but it goes into an infinite loop to listen for
more clients as long as this server script runs; the client may run on
a remote machine, or on same computer if it uses 'localhost' for server
"""
from socket import *                    # get socket constructor and constants
myHost = ''                             # '' = all available interfaces on host
myPort = 50007                          # listen on a non-reserved port number
sockobj = socket(AF_INET, SOCK_STREAM)       # make a TCP socket object
sockobj.bind((myHost, myPort))               # bind it to server port number
sockobj.listen(5)                            # listen, allow 5 pending connects
while True:                                  # listen until process killed
connection, address = sockobj.accept()   # wait for next client connect
print('Server connected by', address)    # connection is a new socket
while True:
data = connection.recv(1024)         # read next line on client socket
if not data: break                   # send a reply line to the client
connection.send(b'Echo=>' + data)    # until eof when socket closed
connection.close()

"""
Client side: use sockets to send data to the server, and print server's
reply to each message line; 'localhost' means that the server is running
on the same machine as the client, which lets us test client and server
on one machine;  to test over the Internet, run a server on a remote
machine, and set serverHost or argv[1] to machine's domain name or IP addr;
Python sockets are a portable BSD socket interface, with object methods
for the standard socket calls available in the system's C library;
"""
import sys
from socket import *              # portable socket interface plus constants
serverHost = 'localhost'          # server name, or: 'starship.python.net'
serverPort = 50007                # non-reserved port used by the server
message = [b'Hello network world']          # default text to send to server
# requires bytes: b'' or str,encode()
if len(sys.argv) > 1:
serverHost = sys.argv[1]                # server from cmd line arg 1
if len(sys.argv) > 2:                   # text from cmd line args 2..n
message = (x.encode() for x in sys.argv[2:])
sockobj = socket(AF_INET, SOCK_STREAM)      # make a TCP/IP socket object
sockobj.connect((serverHost, serverPort))   # connect to server machine + port
for line in message:
sockobj.send(line)                      # send line to server over socket
data = sockobj.recv(1024)               # receive line from server: up to 1k
print('Client received:', data)         # bytes are quoted, was `x`, repr(x)
sockobj.close()                             # close socket to send eof to server

sockobj = socket(AF_INET,
SOCK_STREAM)


Uses the
Python socket module to create a TCP socket
object. The names
AF_INET
and
SOCK_STREAM
are preassigned
variables defined by and imported from the socket module; using
them in combination means “create a TCP/IP socket,” the standard
communication device for the Internet. More specifically,
AF_INET
means the IP address
protocol, and
SOCK_STREAM
means the TCP transfer protocol. The
AF_INET
/
SOCK_STREAM
combination is the default
because it is so common, but it’s typical to make this
explicit.

If you use other names in this call, you can instead
create things like UDP connectionless sockets (use
SOCK_DGRAM
second) and Unix domain
sockets on the local machine (use
AF_UNIX
first), but we won’t do so in
this book. See the Python library manual for details on these
and other socket module options. Using other socket types is
mostly a matter of using different forms of boilerplate
code.

sockobj.bind((myHost,
myPort))


Associates the
socket object with an address—for IP addresses, we
pass a server machine name and port number on that machine. This
is where the server identifies the machine and port associated
with the socket. In server programs, the hostname is typically
an empty string (“”), which means the machine that the script
runs on (formally, all available local and remote interfaces on
the machine), and the port is a number outside the range 0 to
1023 (which is reserved for standard protocols, described
earlier).

Note that each unique socket dialog you support must have
its own port number; if you try to open a socket on a port
already in use, Python will raise an exception. Also notice the
nested parentheses in this call—for the
AF_INET
address protocol socket here,
we pass the host/port socket address to
bind
as a two-item tuple object (pass
a string for
AF_UNIX
).
Technically,
bind
takes a
tuple of values appropriate for the type of socket
created.

sockobj.listen(5)


Starts
listening for incoming client connections and
allows for a backlog of up to five pending requests. The value
passed sets the number of incoming client requests queued by the
operating system before new requests are denied (which happens
only if a server isn’t fast enough to process requests before
the queues fill up). A value of 5 is usually enough for most
socket-based programs; the value must be at least 1.

connection, address =
sockobj.accept()


Waits for the next client connection request to occur;
when it does, the
accept
call
returns a brand-new socket object over which data can be
transferred from and to the connected client. Connections are
accepted on
sockobj
, but
communication with a client happens on
connection
, the new socket. This call
actually returns a two-item tuple—
address
is the connecting client’s
Internet address. We can call
accept
more than one time, to service
multiple client connections; that’s why each call returns a new,
distinct socket for talking to a particular client.

data =
connection.recv(1024)


Reads at most 1,024 more bytes of the next message sent
from a client (i.e., coming across the network or IPC
connection), and returns it to the script as a byte string. We
get back an empty byte string when the client has
finished—end-of-file is triggered when the client closes its end
of the socket.

connection.send(b'Echo=>' +
data)


Sends the latest byte string data block back to the client
program, prepending the string
'Echo=>'
to it first. The client
program can then
recv
what we
send
here—the next reply
line. Technically this call sends as much data as possible, and
returns the number of bytes actually sent. To be fully robust,
some programs may need to resend unsent portions or use
connection.sendall
to force all bytes
to be sent.

connection.close()


Shuts down the connection with this particular
client.

sockobj = socket(AF_INET,
SOCK_STREAM)


Creates a Python socket object in the client program, just
like the server.

sockobj.connect((serverHost,
serverPort))


Opens a
connection to the machine and port on which the
server program is listening for client connections. This is
where the client specifies the string name of the service to be
contacted. In the client, we can either specify the name of the
remote machine as a domain name (e.g.,
starship.python.net
) or numeric IP address.
We can also give the server name as
localhost
(or the equivalent IP
address
127.0.0.1
) to specify
that the server program is running on the same machine as the
client; that comes in handy for debugging servers without having
to connect to the Net. And again, the client’s port number must
match the server’s exactly. Note the nested parentheses
again—just as in server
bind
calls, we really pass the server’s host/port address to
connect
in a tuple object.

sockobj.send(line)


Transfers
the next byte-string message line to the server
over the socket. Notice that the default list of lines contains
bytes
strings (
b'...'
). Just as on the server, data
passed through the socket must be a byte string, though it can
be the result of a manual
str.encode
encoding call or an object
conversion with
pickle
or
struct
if desired. When lines
to be sent are given as command-line arguments instead, they
must be converted from
str
to
bytes
; the client arranges
this by encoding in a generator expression (a call
map(str.encode, sys.argv[2:])
would
have the same effect).

data =
sockobj.recv(1024)


Reads the next reply line sent by the server program.
Technically, this reads up to 1,024 bytes of the next reply
message and returns it as a byte string.

sockobj.close()


Closes the
connection with the server, sending it the
end-of-file signal.