100% found this document useful (1 vote)
130 views

Network Programming in Python

This document provides an overview of a tutorial on network programming in Python. The tutorial introduces TCP/IP networking concepts like layers, protocols, and client-server programming. It demonstrates simple UDP and TCP client-server examples in Python and discusses socket programming utilities. The objectives are to review networking principles, demonstrate Python network libraries, and give examples of client and server code structures.

Uploaded by

Aliyan Aman
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
100% found this document useful (1 vote)
130 views

Network Programming in Python

This document provides an overview of a tutorial on network programming in Python. The tutorial introduces TCP/IP networking concepts like layers, protocols, and client-server programming. It demonstrates simple UDP and TCP client-server examples in Python and discusses socket programming utilities. The objectives are to review networking principles, demonstrate Python network libraries, and give examples of client and server code structures.

Uploaded by

Aliyan Aman
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 73

Network Programming

in Python

Steve Holden
Holden Web

LinuxWorld
January 20, 2004
Introductions
• Steve Holden
– Professional instructor
• TCP/IP
• Database
• Security topics
– Consultant
• Over thirty years as a programmer
– Author of Python Web Programming
• New Riders, 2002

Steve Holden - LinuxWorld, January 20, 2004


Pleased to Meet You …
• In less than 30 seconds:
– Your name
– Your organization
– Your current position
– Your interest in this tutorial

• Now we all know each other

Steve Holden - LinuxWorld, January 20, 2004


Course Objectives
• Review principles of networking
• Contrast TCP and UDP features
• Show how Python programs access networking
functionality
• Give examples of client and server program
structures
• Demonstrate some Python network libraries
• Give pointers to other network functionality

Steve Holden - LinuxWorld, January 20, 2004


One-Minute Overview
• Introduction to TCP/IP networking
– Not IPv6
• Though Python 2.3 handles IPv6
• Sockets: servers and clients
• Popular client libraries
• HTTP servers and clients
• What’s in the future?

Steve Holden - LinuxWorld, January 20, 2004


Network Layering
• Applications talk to each other
– Call transport layer functions
• Transport layer has to ship packets
– Calls network layer
• Network layer talks to next system
– Calls subnetwork layer
• Subnetwork layer frames data for transmission
– Using appropriate physical standards
– Network layer datagrams "hop" from source to
destination through a sequence of routers
Steve Holden - LinuxWorld, January 20, 2004
Inter-Layer Relationships
• Each layer uses the layer below
– The lower layer adds headers to the data from
the upper layer
– The data from the upper layer can also be a
header on data from the layer above …

PROTOCOL DATA
Upper layer

Lower layer HDR DATA

Steve Holden - LinuxWorld, January 20, 2004


The TCP/IP Layering Model
• Simpler than OSI model, with four layers
Socket API
DATA

A Application
T Host-to-host
N Internetwork

DL CRC Subnetwork

Steve Holden - LinuxWorld, January 20, 2004


TCP/IP Components
• Just some of the protocols we expect to be
available in a “TCP/IP” environment

Application
Telnet SSH SMTP FTP NFS DNS SNMP
TCP UDP Host-to-host

IP Internetwork

Ethernet, Token Ring, RS232, IEEE 802.3, HDLC,


Frame Relay, Satellite, Wireless Links, Wet String Subnetwork

Steve Holden - LinuxWorld, January 20, 2004


IP Characteristics
• Datagram-based
– Connectionless
• Unreliable
– Best efforts delivery
– No delivery guarantees
• Logical (32-bit) addresses
– Unrelated to physical addressing
– Leading bits determine network membership

Steve Holden - LinuxWorld, January 20, 2004


UDP Characteristics
• Also datagram-based
– Connectionless, unreliable, can broadcast
• Applications usually message-based
– No transport-layer retries
– Applications handle (or ignore) errors
• Processes identified by port number
• Services live at specific ports
– Usually below 1024, requiring privilege

Steve Holden - LinuxWorld, January 20, 2004


TCP Characteristics
• Connection-oriented
– Two endpoints of a virtual circuit
• Reliable
– Application needs no error checking
• Stream-based
– No predefined blocksize
• Processes identified by port numbers
• Services live at specific ports

Steve Holden - LinuxWorld, January 20, 2004


Client/Server Concepts
• Server opens a specific port
– The one associated with its service
– Then just waits for requests
– Server is the passive opener
• Clients get ephemeral ports
– Guaranteed unique, 1024 or greater
– Uses them to communicate with server
– Client is the active opener

Steve Holden - LinuxWorld, January 20, 2004


Connectionless Services
socket() socket()

bind() bind()

recvfrom() sendto()

[blocked] recvfrom()
[blocked]
sendto()

SERVER CLIENT
Steve Holden - LinuxWorld, January 20, 2004
Simple Connectionless Server
from socket import socket, AF_INET, SOCK_DGRAM
s = socket(AF_INET, SOCK_DGRAM)
s.bind(('127.0.0.1', 11111))
while 1: # nowadays, "while True"
data, addr = s.recvfrom(1024)
print "Connection from", addr
s.sendto(data.upper(), addr)

• How much easier does it need to be?

Note that the bind() argument is a two-element tuple of address and port number

Steve Holden - LinuxWorld, January 20, 2004


Simple Connectionless Client
from socket import socket, AF_INET, SOCK_DGRAM
s = socket(AF_INET, SOCK_DGRAM)
s.bind(('127.0.0.1', 0)) # OS chooses port
print "using", s.getsocketname()
server = ('127.0.0.1', 11111)
s.sendto("MixedCaseString", server)
data, addr = s.recvfrom(1024)
print "received", data, "from", addr
s.close()

• Relatively easy to understand?

Steve Holden - LinuxWorld, January 20, 2004


Exercise 1: UDP Client/Server
• Run the sample UDP client and server I have
provided (see 00_README.txt)
– udpserv1.py
– udpcli1.py
• Additional questions:
– How easy is it to change the port number and
address used by the service?
– What happens if you run the client when the
server isn't listening?

Steve Holden - LinuxWorld, January 20, 2004


Sample Python Module
• Problem: remote debugging
– Need to report errors, print values, etc.
– Log files not always desirable
• Permissions issues
• Remote viewing often difficult
• Maintenance (rotation, etc.) issues
• Solution: messages as UDP datagrams
– e.g. "Mr. Creosote" remote debugger
– http://starship.python.net/crew/jbauer/creosote/

Steve Holden - LinuxWorld, January 20, 2004


Creosote Output
def spew(msg, host='localhost', port=PORT):
s = socket.socket((socket.AF_INET,
socket.SOCK_DGRAM))
s.bind(('', 0))
while msg:
s.sendto(msg[:BUFSIZE], (host, port))
msg = msg[BUFSIZE:]

• Creates a datagram (UDP) socket


• Sends the message
– In chunks if necessary

Steve Holden - LinuxWorld, January 20, 2004


Creosote Input
def bucket(port=PORT, logfile=None):
s = socket.socket(socket.AF_INET,
socket.SOCK_DGRAM)
s.bind(('', port))
print 'waiting on port: %s' % port
while 1:
try:
data, addr = \
s.recvfrom(BUFSIZE)
print `data`[1:-1]
except socket.error, msg:
print msg

• An infinite loop, printing out received messages

Steve Holden - LinuxWorld, January 20, 2004


Exercise 2: Mr Creosote Demo
• This module includes both client and server
functionality in a single module
– creosote.py
• Very simple module with no real attemot to use
object-oriented features
• The production code is more complex
– creosoteplus.py
– Defines a bucket listener class
– Instance created when called with no arguments

Steve Holden - LinuxWorld, January 20, 2004


Connection-Oriented Services
socket() Server Client
bind()
socket()

listen()
connect()

accept()
write()
[blocked]
read()

read() [blocked]

[blocked]

write()
When interaction is over, server
loops to accept a new connection
Steve Holden - LinuxWorld, January 20, 2004
Connection-Oriented Server
from socket import \
socket, AF_INET, SOCK_STREAM
s = socket(AF_INET, SOCK_STREAM)
s.bind(('127.0.0.1', 9999))
s.listen(5) # max queued connections
while 1:
sock, addr = s.accept()
# use socket sock to communicate
# with client process

• Client connection creates new socket


– Returned with address by accept()
• Server handles one client at a time
Steve Holden - LinuxWorld, January 20, 2004
Connection-Oriented Client
s = socket(AF_INET, SOCK_STREAM)
s.connect((HOST, PORT))
s.send('Hello, world')
data = s.recv(1024)
s.close()
print 'Received', `data`

• This is a simple example


– Sends message, receives response
– Server receives 0 bytes after close()

Steve Holden - LinuxWorld, January 20, 2004


Some socket Utility Functions

• htonl(i), htons(i)
– 32-bit or 16-bit integer to network format
• ntohl(i), ntohs(i)
– 32-bit or 16-bit integer to host format
• inet_aton(ipstr), inet_ntoa(packed)
– Convert addresses between regular strings and
4-byte packed strings

Steve Holden - LinuxWorld, January 20, 2004


Handling Names & Addresses
• getfqdn(host='')
– Get canonical host name for host
• gethostbyaddr(ipaddr)
– Returns (hostname, aliases, addresses)
• Hostname is canonical name
• Aliases is a list of other names
• Addresses is a list of IP address strings
• gethostbyname_ex(hostname)
– Returns same values as gethostbyaddr()

Steve Holden - LinuxWorld, January 20, 2004


Treating Sockets as Files

• makefile([mode[, bufsize]])
– Creates a file object that references the socket
– Makes it easier to program to handle data
streams
• No need to assemble stream from buffers

Steve Holden - LinuxWorld, January 20, 2004


Exercise 3: TCP Client/Server
• Run the sample client and server I have
provided
– tcpserv1.py
– tcpcli1.py
• Additional questions:
– What happens if the client aborts (try entering
CTRL/D as input, for example)?
– Can you run two clients against the same
server?

Steve Holden - LinuxWorld, January 20, 2004


Summary of Address Families
• socket.AF_UNIX
– Unix named pipe (NOT Windows…)
• socket.AF_INET
– Internet – IP version 4
– The basis of this class
• socket.AF_INET6
– Internet – IP version 6
– Rather more complicated … maybe next year

Steve Holden - LinuxWorld, January 20, 2004


Summary of Socket Types
• socket.SOCK_STREAM
– TCP, connection-oriented
• socket.SOCK_DGRAM
– UDP, connectionless
• socket.SOCK_RAW
– Gives access to subnetwork layer
• SOCK_RDM, SOCK_SEQPACKET
– Very rarely used

Steve Holden - LinuxWorld, January 20, 2004


Other socket.* Constants

• The usual suspects


– Most constants from Unix C support
SO_*, MSG_*, IP_* and so on
• Most are rarely needed
– C library documentation should be your guide

Steve Holden - LinuxWorld, January 20, 2004


Timeout Capabilities
• Originally provided by 3rd-party module
– Now (Python 2.3) integrated with socket
module
• Can set a default for all sockets
– socket.setdefaulttimeout(seconds)
– Argument is float # of seconds
– Or None (indicates no timeout)
• Can set a timeout on an existing socket s
– s.settimeout(seconds)

Steve Holden - LinuxWorld, January 20, 2004


Server Libraries

• SocketServer module provides basic server


features
• Subclass the TCPServer and UDPServer classes
to serve specific protocols
• Subclass BaseRequestHandler, overriding its
handle() method, to handle requests
• Mix-in classes allow asynchronous handling

Steve Holden - LinuxWorld, January 20, 2004


Using SocketServer Module
• Server instance created with address and
handler-class as arguments:
SocketServer.UDPServer(myaddr,
MyHandler)
• Each connection/transmission creates a request
handler instance by calling the handler-class*
• Created handler instance handles a message
(UDP) or a complete client session (TCP)

* In Python you instantiate a class by calling it like a function

Steve Holden - LinuxWorld, January 20, 2004


Writing a handle() Method
• self.request gives client access
– (string, socket) for UDP servers
– Connected socket for TCP servers
• self.client_address is remote address
• self.server is server instance
• TCP servers should handle a complete client
session

Steve Holden - LinuxWorld, January 20, 2004


Skeleton Handler Examples
• No error checking
• Unsophisticated session handling (TCP)
• Simple tailored clients
– Try telnet with TCP server!
• Demonstrate the power of the Python network
libraries

Steve Holden - LinuxWorld, January 20, 2004


UDP Upper-Case SocketServer
# udps1.py
import SocketServer
class UCHandler(SocketServer.BaseRequestHandler):
def handle(self):
remote = self.client_address
data, skt = self.request
print data
skt.sendto(data.upper(), remote)
myaddr = ('127.0.0.1', 2345)
myserver = SocketServer.UDPServer(myaddr, UCHandler)
myserver.serve_forever()
Change this function to
alter server's functionality

• Note: this server never terminates!


Steve Holden - LinuxWorld, January 20, 2004
UDP Upper-Case Client
# udpc1.py
from socket import socket, AF_INET, SOCK_DGRAM
srvaddr = ('127.0.0.1', 2345)
data = raw_input("Send: ")
s = socket(AF_INET, SOCK_DGRAM)
s.bind(('', 0))
s.sendto(data, srvaddr)
data, addr = s.recvfrom(1024)
print "Recv:", data

• Client interacts once then terminates


• hangs if no response

Steve Holden - LinuxWorld, January 20, 2004


TCP Upper-Case SocketServer
# tcps1.py
import SocketServer
class UCHandler(SocketServer.BaseRequestHandler):
def handle(self):
print "Connected:", self.client_address
while 1:
data = self.request.recv(1024)
if data == "\r\n": Change this function to
alter server's functionality
break
print data[:-2]
self.request.send(data.upper())
myaddr = ('127.0.0.1', 2345)
myserver = SocketServer.TCPServer(myaddr, UCHandler)
myserver.serve_forever()

Steve Holden - LinuxWorld, January 20, 2004


TCP Upper-Case Client
# tcpc1.py
from socket import socket, AF_INET, SOCK_STREAM
srvaddr = ('127.0.0.1', 2345)
s = socket(AF_INET, SOCK_STREAM)
s.connect(srvaddr)
while 1:
data = raw_input("Send: ")
s.send(data + "\r\n")
if data == "":
break
data = s.recv(1024)
print data[:-2] # Avoids doubling-up the newline
s.close()

Steve Holden - LinuxWorld, January 20, 2004


Exercise 4: SocketServer Usage
• Run the TCP and UDP SocketServer-based
servers with the same clients you used before
– SockServUDP.py
– SockServTCP.py
• Additional questions:
– Is the functionality any different?
– What advantages are there over writing a
"classical" server?
– Can the TCP server accept multiple
connections?
Steve Holden - LinuxWorld, January 20, 2004
Skeleton Server Limitations (1)
• UDP server adequate for short requests
– If service is extended, other clients must wait
• TCP server cannot handle concurrent sessions
– Transport layer queues max 5 connections
• After that requests are refused
• Solutions?
– Fork a process to handle requests, or
– Start a thread to handle requests

Steve Holden - LinuxWorld, January 20, 2004


Simple Server Limitations (2)

accept()

[blocked]
Client connection

read()

Server creates a new [blocked] Remote


thread or forks a new Client
process to handle
each request write() Process

Forked server process or


thread runs independently

Steve Holden - LinuxWorld, January 20, 2004


Asynchronous Server Classes

• Use provided asynchronous classes


myserver = SocketServer.TCPServer(
myaddr, UCHandler)

becomes
myserver = SocketServer.ThreadingTCPServer(
myaddr, UCHandler)

or
myserver = SocketServer.ForkingTCPServer(
myaddr, UCHandler)

Steve Holden - LinuxWorld, January 20, 2004


Implementation Details
• This is the implementation of all four
servers (from SocketServer.py):
class ForkingUDPServer(ForkingMixIn,
UDPServer): pass
class ForkingTCPServer(ForkingMixIn,
TCPServer): pass
class ThreadingUDPServer(ThreadingMixIn,
UDPServer): pass
class ThreadingTCPServer(ThreadingMixIn,
TCPServer): pass
• Uses Python's multiple inheritance
– Overrides process_request() method
Steve Holden - LinuxWorld, January 20, 2004
More General Asynchrony
• See the asyncore and asynchat modules
• Use non-blocking sockets
• Based on select using an event-driven model
– Events occur at state transitions on underlying
socket
• Set up a listening socket
• Add connected sockets on creation

Steve Holden - LinuxWorld, January 20, 2004


Exercise 5: Async TCP servers
• Can also be used with UDP, but less often
required (UDP often message-response)
– SockServTCPThread.py
• Very simple to replace threading with forking
– Non-portable, since forking not supported
under Windows (like you care … )

Steve Holden - LinuxWorld, January 20, 2004


Network Client Libraries
• Python offers a rich variety of network client
code
– Email: smtplib, poplib, imaplib
• rfc822 and email modules handle content
– File transfer: ftplib
– Web: httplib, urllib
• More on these later
– Network news: nntplib
– Telnet: telnetlib

Steve Holden - LinuxWorld, January 20, 2004


General Client Strategy

• Library usually defines an object class


• Create an instance of the object to interact with
the server
• Call the instance's methods to request
particular interactions

Steve Holden - LinuxWorld, January 20, 2004


Using smtplib
• s = smtplib.SMTP([host[, port]])
– Create SMTP object with given
connection parameters
• r = s.sendmail(from, to, msg
[, mopts[, ropts]])
– from : sender address
– to : list of recipient addresses
– msg : RFC822-formatted message
(including all necessary headers)
– mopts, ropts : ESMTP option lists

Steve Holden - LinuxWorld, January 20, 2004


SMTP Example (1)
import smtplib, socket

frad = "[email protected]"
toads = ["[email protected]",
"[email protected]",
"[email protected]"]

msg = """To: Various recipients


From: Steve Holden <[email protected]>

Hello. This is an RFC822 mail message.


"""

Steve Holden - LinuxWorld, January 20, 2004


SMTP Example (2)
try:
server = smtplib.SMTP('10.0.0.1')
result = server.sendmail(frad, toads, msg)
server.quit()
if result:
for r in result.keys():
print "Error sending to", r
rt = result[r]
print "Code", rt[0], ":", rt[1]
else:
print "Sent without errors"
except smtplib.SMTPException, arg:
print "Server could not send mail", arg

Steve Holden - LinuxWorld, January 20, 2004


Using poplib
• p = poplib.POP3(host[, port])
– Creates a POP object with given
connection parameters
• p.user(username)
– Provide username to server
• p.pass_(password)
– Provide password to server
• p.stat()
– Returns (# of msgs, # of bytes)

Steve Holden - LinuxWorld, January 20, 2004


Using poplib (continued)
• p.retr(msgnum)
– returns (response, linelist, bytecount)
• p.dele(msgnum)
– Marks the given message for deletion
• p.quit()
– Terminate the connection
– Server actions pending deletes and
unlocks the mailbox

Steve Holden - LinuxWorld, January 20, 2004


poplib Example (1)
import poplib, rfc822, sys, StringIO
SRVR = "mymailserver.com"
USER = "user"
PASS = "password"
try:
p = poplib.POP3(SRVR)
except:
print "Can't contact %s" % (SRVR, )
sys.exit(-1)
try:
print p.user(USER)
print p.pass_(PASS)
except:
print "Authentication failure"
sys.exit(-2)

Steve Holden - LinuxWorld, January 20, 2004


poplib Example (2)
msglst = p.list()[1]
for m in msglst:
mno, size = m.split()
lines = p.retr(mno)[1]
print "----- Message %s" % (mno, )
file = StringIO.StringIO(
"\r\n".join(lines))
msg = rfc822.Message(file)
body = file.readlines()
addrs = msg.getaddrlist("to")
for rcpt, addr in addrs:
print "%-15s %s" % (rcpt, addr)
print len(body), "lines in message body"
print "-----"
p.quit()

Steve Holden - LinuxWorld, January 20, 2004


Using ftplib
• f = ftplib.FTP(host[,user[,passwd[,acct]]])
– Creates an FTP object
• f.dir(directory)
– Send directory listing to standard output
• f.cwd(directory)
– Change to given directory
• f.mkd(directory)
– Create directory on server
• f.pwd()
– Returns current directory on server

Steve Holden - LinuxWorld, January 20, 2004


Using ftplib (continued)
• retrbinary(command, callback[,
maxblocksize[, rest]])
– Retrieve a file in binary mode
– command - an FTP command
• E.g. "RETR myfile.dat"
– callback - processes each block
– maxblocksize – how much data per block
– rest – restart position

Steve Holden - LinuxWorld, January 20, 2004


Using ftplib (continued)
• f.retrlines(command[, callback])
– Retrieves a file in text mode
– command - an FTP command
• E.g. "RETR myfile.txt"
– callback - processes each line as an argument
• Default callback prints line to standard output
• f.storlines(command, file)
– Sends content of file line-by-line
• f.storbinary(command, file, blocksize)
– Sends content of file block-by-block

Steve Holden - LinuxWorld, January 20, 2004


Abbreviated ftplib Example
class Writer:
def __init__(self, file):
self.f = open(file, "w")
def __call__(self, data):
self.f.write(data)
self.f.write('\n')
print data
FILENAME = "AutoIndent.py"
writer = Writer(FILENAME)
import ftplib
ftp = ftplib.FTP('127.0.0.1', 'book',
'bookpw')
ftp.retrlines("RETR %s" % FILENAME, writer)

Steve Holden - LinuxWorld, January 20, 2004


HTTP and HTML Libraries
• Python applications are often web-based
• htmllib, HTMLParser – HTML parsing
• httplib – HTTP protocol client
• urllib, urllib2 – multiprotocol client
• SimpleHTTPServer, CGIHTTPServer –
SocketServer-based servers
• cgi, cgitb – CGI scripting assistance
• Various web samples also available

Steve Holden - LinuxWorld, January 20, 2004


Using urllib
• f = urllib.urlopen(URL)
– Create file-like object that allows you to
read the identified resource
• urlretrieve(url[, filename[,
reporthook[, data]]])
– Reads the identified resource and store it
as a local file
• See documentation for further details
• This is very convenient for interactive use

Steve Holden - LinuxWorld, January 20, 2004


Interactive urllib Session
>>> import urllib
>>> f = urllib.urlopen("http://www.python.org/")
>>> page = f.read() # treat as file to get body
>>> len(page)
14790
>>> h = f.info()
>>> h.getheader("Server")
'Apache/1.3.26 (Unix)'
>>> h.getheaders("Date")
['Thu, 29 May 2003 15:07:27 GMT']
>>> h.type
'text/html'

• Useful for testing & quick interactions

Steve Holden - LinuxWorld, January 20, 2004


Using urllib2
• urllib has limitations - difficult to
– Include authentication
– Handle new protocols/schemes
• Must subclass urllib.FancyURLOpener and
bind an instance to urllib._urlopener
• urllib2 is intended to be more flexible
• The price is added complexity
– Many applications don't need the
complexity

Steve Holden - LinuxWorld, January 20, 2004


urllib2.Request Class
• Instance can be passed instead of a URL
to the urllib2.urlopen() function
• r = Request(url, data=None, headers={})
– r.add_header(key, value)
• Can only add one header with a given key
– r.set_proxy(host, scheme )
• Sets the request to use a given proxy to
access the given scheme
– r.add_data(data)
• Forces use of POST rather than GET
• Requires http scheme

Steve Holden - LinuxWorld, January 20, 2004


Serving HTTP
• Several related modules:
– BaseHTTPServer defines
• HTTPServer class
• BaseHTTPRequestHandler class
– SimpleHTTPServer defines
• SimpleHTTPRequestHandler class
– CGIHTTPServer defines
• CGIHTTPRequestHandler class
• All request handlers use the standard
HTTPServer.BaseHTTPRequestHandler
Steve Holden - LinuxWorld, January 20, 2004
The Simplest Web Server …
import CGIHTTPServer, BaseHTTPServer
httpd = BaseHTTPServer.HTTPServer(('', 8888),
CGIHTTPServer.CGIHTTPRequestHandler)
httpd.serve_forever()

• Uses the basic HTTP server class


• Request handler methods implement the
HTTP PUT/GET/HEAD requests
• Yes, this really works!

Steve Holden - LinuxWorld, January 20, 2004


Standard CGI Support
• cgimodule provides input handling
• Recent (2.2) changes make things easier
– cgitb module traps errors
• Easier to diagnose problems
– Gives complete Python traceback
– Situation previously complicated by
differences in multi-valued form inputs
• Had to check, and program different actions
(string vs list)
• Python is excellent for producing HTML!
Steve Holden - LinuxWorld, January 20, 2004
The cgi.FieldStorage Class
• Makes web client's input accessible
– Consumes input, so only instantiate once!
– Handles method GET or POST
– Optional argument retains blank values
• f.getfirst(name, default=None)
– Returns first (only) input value with given
name
• f.getlist(name)
– Returns a list of all values with given
name

Steve Holden - LinuxWorld, January 20, 2004


Error Handling
• Should use for all CGI scripts!
import cgitb; cgitb.enable()
• Traps any errors, producing legible trace

Steve Holden - LinuxWorld, January 20, 2004


Sample CGI Script
#!/usr/bin/python
import cgi, cgitb; cgitb.enable()
fields = ["subnum", "reviewer", "comments"]

form = cgi.FieldStorage()
vlist = []
for f in fields:
vlist.append("%s=%s" % (f, form.getfirst(f)))

print pgtmpl = """Content-Type: text/html

<html><head><title>Hello!</title></head>
%s
</body></html>
""" % "<br>".join(vlist)

Steve Holden - LinuxWorld, January 20, 2004


Course Summary
• Reviewed principles of networking
• Contrasted TCP and UDP features
• Shown how Python programs access
networking functionality
• Given examples of client and server program
structures
• Demonstrated some Python network libraries
• Given pointers to other network functionality

Steve Holden - LinuxWorld, January 20, 2004


Need more training?
Want to offer feedback?

Need help with a Python project?


Got budget?

Get in touch:

[email protected]

Steve Holden - LinuxWorld, January 20, 2004

You might also like