1. Socket programming
Socket programming

2. What is a socket?
goal: learn how to build client/server applications that communicate using sockets socket: door between application process and end-end-transport protocol
Internet
controlled
by OS
controlled by
app developer
transport
application
physical
link
network
process
socket

3. What is a socket?
Socket is an interface between application and network (the lower levels of the protocol stack)
The application creates a socket
The socket type dictates the style of communication
reliable vs. best effort
connection-oriented vs. connectionless
Once a socket is setup the application can
pass data to the socket for network transmission
receive data from the socket (transmitted through the network, received from some other host)

4. Most popular types of sockets
TCP socket
Type: SOCK_STREAM
reliable delivery
in-order guaranteed
connection-oriented
bidirectional
UDP socket
Type: SOCK_DGRAM
unreliable delivery
no order guarantees
no notion of “connection” – app indicates destination for each packet
can send or receive

5. Ports Each host machine has an IP address (or more!)
Each host has 65,536 ports (2?)
As you know some ports are reserved for specific apps
20,21: FTP
23: Telnet
80: HTTP
see RFC 1700 (about 2000 ports are reserved)
Port 0
Port 1
Port 65535
A socket provides an interface to send data to/from the network through a port

6. Addresses, Ports and Sockets
Like apartments and mailboxes
You are the application
Your apartment building address is the address
Your mailbox is the port
The post-office is the network
The socket is the key that gives you access to the right mailbox (one difference: assume outgoing mail is placed by you in your mailbox)
Q: How do you choose which port a socket connects to?

7. Socket programming Application Example:
Client reads a line of characters (data) from its keyboard and sends the data to the server.
The server receives the data and converts characters to uppercase.
The server sends the modified data to the client.
The client receives the modified data and displays the line on its screen.

8. Ports Each host machine has an IP address (or more!)
Each host has 65,536 ports (2?)
As you know some ports are reserved for specific apps
20,21: FTP
23: Telnet
80: HTTP
see RFC 1700 (about 2000 ports are reserved)
Port 0
Port 1
Port 65535
A socket provides an interface to send data to/from the network through a port

9. Addresses, Ports and Sockets
Like apartments and mailboxes
You are the application
Your apartment building address is the address
Your mailbox is the port
The post-office is the network
The socket is the key that gives you access to the right mailbox (one difference: assume outgoing mail is placed by you in your mailbox)
Q: How do you choose which port a socket connects to?

10. Socket programming with UDP
UDP: no “connection” between client & server
no handshaking before sending data
sender explicitly attaches IP destination address and port # to each packet
rcvr extracts sender IP address and port# from received packet
UDP: transmitted data may be lost or received out-of-order
Application viewpoint:
UDP provides unreliable transfer of groups of bytes (“datagrams”) between client and server

11. Client/server socket interaction: UDP
server (running on serverIP)
create socket:
clientSocket =
socket(AF_INET,SOCK_DGRAM)
Create datagram with server IP and
port=x; send datagram via clientSocket
client
create socket, port= x:
serverSocket =
socket(AF_INET,SOCK_DGRAM)
read datagram from
serverSocket
close
clientSocket
read datagram from
write reply to
serverSocket
specifying client address,
port number
Application 2-11

12. Example app: UDP client
Python UDPClient
include Python’s socket
library
from socket import *
serverName = ‘hostname’
serverPort = 12000
clientSocket = socket(socket.AF_INET,
socket.SOCK_DGRAM)
message = raw_input(’Input lowercase sentence:’)
clientSocket.sendto(message,(serverName, serverPort))
modifiedMessage, serverAddress =
clientSocket.recvfrom(2048)
print modifiedMessage
clientSocket.close()
create UDP socket for server
get user keyboard
input
Attach server name, port to message; send into socket
read reply characters from
socket into string
print out received string and close socket

13. Example app: UDP server
Python UDPServer
from socket import *
serverPort = 12000
serverSocket = socket(AF_INET, SOCK_DGRAM)
serverSocket.bind(('', serverPort))
print “The server is ready to receive”
while 1:
message, clientAddress = serverSocket.recvfrom(2048)
modifiedMessage = message.upper()
serverSocket.sendto(modifiedMessage, clientAddress)
create UDP socket
bind socket to local port number 12000
loop forever
Read from UDP socket into message, getting client’s address (client IP and port)
send upper case string back to this client

14. Socket programming with TCP
client must contact server
server process must first be running
server must have created socket (door) that welcomes client’s contact
client contacts server by:
Creating TCP socket, specifying IP address, port number of server process
when client creates socket: client TCP establishes connection to server TCP
when contacted by client, server TCP creates new socket for server process to communicate with that particular client
allows server to talk with multiple clients
source port numbers used to distinguish clients
application viewpoint:
TCP provides reliable, in-order
byte-stream transfer (“pipe”)
between client and server

15. Client/server socket interaction: TCP
server (running on hostid)
client
create socket,
port=x, for incoming request:
serverSocket = socket()
wait for incoming
connection request
connectionSocket =
serverSocket.accept()
create socket,
connect to hostid, port=x
clientSocket = socket()
TCP
connection setup
send request using
clientSocket
read request from
connectionSocket
write reply to
close
connectionSocket
read reply from
clientSocket

16. Example app: TCP client
Python TCPClient
from socket import *
serverName = ’servername’
serverPort = 12000
clientSocket = socket(AF_INET, SOCK_STREAM)
clientSocket.connect((serverName,serverPort))
sentence = raw_input(‘Input lowercase sentence:’)
clientSocket.send(sentence)
modifiedSentence = clientSocket.recv(1024)
print ‘From Server:’, modifiedSentence
clientSocket.close()
create TCP socket for server, remote port 12000
No need to attach server name, port

17. Example app: TCP server
Python TCPServer
from socket import *
serverPort = 12000
serverSocket = socket(AF_INET,SOCK_STREAM)
serverSocket.bind((‘’,serverPort))
serverSocket.listen(1)
print ‘The server is ready to receive’
while 1:
connectionSocket, addr = serverSocket.accept()
sentence = connectionSocket.recv(1024)
capitalizedSentence = sentence.upper()
connectionSocket.send(capitalizedSentence)
connectionSocket.close()
create TCP welcoming
socket
server begins listening for incoming TCP requests
loop forever
server waits on accept()
for incoming requests, new socket created on return
read bytes from socket (but not address as in UDP)
close connection to this client (but not welcoming socket)

18. Socket Creation in C int s = socket(domain, type, protocol);
s: socket descriptor, an integer (like a file-handle)
domain: integer, communication domain
e.g., PF_INET (IPv4 protocol) – typically used
type: communication type
SOCK_STREAM: reliable, 2-way, connection-based service
SOCK_DGRAM: unreliable, connectionless,
other values: need root permission, rarely used, or obsolete
protocol: specifies protocol (see file /etc/protocols for a list of options) - usually set to 0
NOTE: socket call does not specify where data will be coming from, nor where it will be going to - it just creates the interface.

19. The bind function
The bind function associates and (can exclusively) reserves a port for use by the socket
int status = bind(sockid, &addrport, size);
status: error status, = -1 if bind failed
sockid: integer, socket descriptor
addrport: struct sockaddr, the (IP) address and port of the machine (address usually set to INADDR_ANY – chooses a local address)
size: the size (in bytes) of the addrport structure
bind can be skipped for both types of sockets. When and why?

20. Skipping the bind SOCK_DGRAM: SOCK_STREAM:
if only sending, no need to bind. The OS finds a port each time the socket sends a pkt
if receiving, need to bind
SOCK_STREAM:
destination determined during conn. setup
don’t need to know port sending from (during connection setup, receiving end is informed of port)

21. On the connecting end
When connecting to another host (i.e., connecting end is the client and the receiving end is the server), the OS automatically assigns a free port for the outgoing connection.
During connection setup, receiving end is informed of port)
You can however bind to a specific port if need be.

22. Connection Setup A connection occurs between two ends
Server: waits for an active participant to request connection
Client: initiates connection request to passive side
Once connection is established, server and client ends are “similar”
both can send & receive data
either can terminate the connection

23. Server and clients TCP Server TCP Client socket() bind() listen()
accept()
connection establishment
connect()
data request
read()
write()
data reply
write()
read()
read()
end-of-file notification
close()
close()

24. Connection setup steps
Client end:
step 2: request & establish connection
step 4: send/recv
Server end:
step 1: listen (for incoming requests)
step 3: accept (a request)
step 4: send/recv
The accepted connection is on a new socket
The old socket continues to listen for other active participants
Server
a-sock-1
l-sock
a-sock-2
Client1
Client2
socket
socket
From: Dan Rubenstein’s slides:

25. Server Socket: listen & accept
Called on server side:
int status = listen(sock, queuelen);
status: 0 if listening, -1 if error
sock: integer, socket descriptor
queuelen: integer, # of active participants that can “wait” for a connection
listen is non-blocking: returns immediately
int s = accept(sock, &addr, &addrlen);
s: integer, the new socket (used for data-transfer)
sock: integer, the orig. socket (being listened on)
addr: struct sockaddr, address of the active participant
addrlen: sizeof(addr): value/result parameter
must be set appropriately before call
adjusted by OS upon return
accept is blocking: waits for connection before returning

26. connect int status = connect(sock, &addr, addrlen);
status: 0 if successful connect, -1 otherwise
sock: integer, socket to be used in connection
addr: struct sockaddr: address of passive participant
addrlen: integer, sizeof(addr)
connect is blocking

27. Sending / Receiving Data
int count = send(sock, &buf, len, flags);
count: # bytes transmitted (-1 if error)
buf: void*, buffer to be transmitted
len: integer, length of buffer (in bytes) to transmit
flags: integer, special options, usually just 0
int count = recv(sock, &buf, len, flags);
count: # bytes received (-1 if error)
buf: void*, stores received bytes
len: # bytes received
Calls are blocking [returns only after data is sent (to socket buf) / received]

28. close When finished using a socket, the socket should be closed:
status = close(s);
status: 0 if successful, -1 if error
s: the file descriptor (socket being closed)
Closing a socket
closes a connection
frees up the port used by the socket
From: Dan Rubenstein’s slides:

29. The struct sockaddr
The struct to store the Internet address of a host:
struct sockaddr_in {
short sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8]; };
sin_family = AF_INET // Specifies the address family
sin_port: // Specifies the port #( )
sin_addr: // Specifies the IP address
sin_zero: unused // unused!
From: Dan Rubenstein’s slides:

30. SOCKADDR Example struct sockaddr_in server; // Definition
memset(&server, 0, sizeof(server)); // Initilize to 0
server.sin_family = AF_INET; // Set address family
server.sin_port = htons(MYPORTNUM); // Set port
server.sin_addr.s_addr = htonl(INADDR_ANY);// Set address
Host Byte-Ordering: the byte ordering used by a host (big- endian or little-endian)
Network Byte-Ordering: the byte ordering used by the network – always big-endian
Any words sent through the network should be converted to Network Byte-Order prior to transmission (and back to Host Byte- Order once received)

31. Network Byte-Ordering
u_long htonl(u_long x);
u_short htons(u_short x);
u_long ntohl(u_long x);
u_short ntohs(u_short x);
On big-endian machines, these routines do nothing
On little-endian machines, they reverse the byte order
Big-Endian
machine
Little-Endian
machine
128
119 40 12
128
119 40 12
htonl
ntohl
128
119 40 12
128
119 40 12
From: Dan Rubenstein’s slides:

32. TIPS 1
Sometimes, an ungraceful exit from a program (e.g., ctrl-c) does not properly free up a port
Eventually (after a few minutes), the port will be freed
You can kill the process, or
To reduce the likelihood of this problem, include the following code:
In header include:
#include <signal.h>
void cleanExit(){exit(0);}
In socket code:
signal(SIGTERM, cleanExit);
signal(SIGINT, cleanExit);

33. Tips 2
Check Beej's Guide to Network Programming Using Internet Sockets
Search the specification for the function you need to use for more info, or check the man pages.

34. Tips 3
How to find the IP address of the machine my server program is running on?
Use or localhost for accessing a server running on your local machine.
For a remote server running linux use the bash shell command: “$ /sbin/ifconfig”
For windows, use ipconfig in cmd

35. summary specific protocols: HTTP FTP SMTP, POP, IMAP DNS
our study of network apps now complete!
application architectures
client-server
P2P
application service requirements:
reliability, bandwidth, delay
Internet transport service model
connection-oriented, reliable: TCP
unreliable, datagrams: UDP
specific protocols:
HTTP
FTP
SMTP, POP, IMAP
DNS
P2P: BitTorrent, DHT
socket programming: TCP, UDP sockets

36. summary most importantly: learned about protocols! important themes:
typical request/reply message exchange:
client requests info or service
server responds with data, status code
message formats:
headers: fields giving info about data
data: info being communicated
important themes:
control vs. data msgs
in-band, out-of-band
centralized vs. decentralized
stateless vs. stateful
reliable vs. unreliable msg transfer
“complexity at network edge”