UNIX Sockets

Note: The slides are adapted from the materials from Prof. Richard Han at CU Boulder and Profs. Jennifer Rexford and Mike Freedman at Princeton University,
and the networking book (Computer Networking: A Top Down Approach) from Kurose and Ross.
 Programming Assignment #1
• UDP Socket Programming

2
UNIX Sockets
Socket and Process Communication

application layer application layer

User Process Internet User Process

Socket Socket
transport layer (TCP/UDP)
OS network transport layer (TCP/UDP)
OS network
network layer (IP)
Internet network layer (IP)
stack stack
link layer (e.g. ethernet) Internet link layer (e.g. ethernet)

The interface that the OS provides to its networking

subsystem
4
Delivering the Data: Division of Labor
• Network
– Deliver data packet to the destination host
– Based on the destination IP address
• Operating system
– Deliver data to the destination socket
– Based on the destination port number (e.g., 80)
• Application
– Read data from and write data to the socket
– Interpret the data (e.g., render a Web page)
5
 Socket: End Point of Communication
• Sending message from one process to another
– Message must traverse the underlying network
• Process sends and receives through a "socket"
– In essence, the doorway leading in/out of the house
• Socket as an Application Programming Interface
– Supports the creation of network applications

User process User process

socket socket
Operating Operating
System System
6
 Socket programming

goal: learn how to build client/server applications that

communicate using sockets
socket: door between application process and end-end-transport
protocol
application application
socket controlled by
process process app developer

transport transport
network network controlled
link link by OS
Internet
physical physical
 Two Types of Application Processes
Communication

• Datagram Socket (UDP)

– Collection of messages
– Best effort
– Connectionless

• Stream Socket (TCP)

– Stream of bytes
– Reliable
– Connection-oriented
8
 User Datagram Protocol (UDP):
Datagram Socket
UDP Postal Mail
• Single socket to receive messages •• Single
Singlemailbox
mailboxto receive letters
to receive
messages
• No guarantee of delivery • •Unreliable
Unreliable J

• Not necessarily in-order delivery

• Not necessarily in-order
• Not necessarily in-order delivery
delivery
• Datagram – independent packets • •Each letter
Letters sentisindependently
independent
• Must address each reply
• Must address each packet • Must address each mail

Example UDP applications

Multimedia, voice over IP (Skype)
9
 Transmission Control Protocol (TCP):
Stream Socket
TCP Telephone
Postal Mail
Call
• Reliable – guarantee delivery • Guaranteed
• Single mailboxdelivery
to receive
messages
• Byte stream – in-order delivery •• In-order delivery
Unreliable J
• Connection-oriented – single
• Not necessarily in-order
• Connection-oriented
socket per connection delivery
• Each letter is independent
• Setup connection followed by Mustconnection
•• Setup address each reply
followed by
data transfer conversation

Example TCP applications

Web, Email, Telnet
10
 Socket Identification
• Receiving host
– Destination address that Process Process
uniquely identifies host A B
– IP address: 32-bit quantity port X
port Y
Port
Number

• Receiving socket TCP/UDP Protocol

– Host may be running
many different processes IP Host
Address
– Destination port that
uniquely identifies socket
– Port number: 16-bits Ethernet Adapter

11
 Client-Server Communication
• Client "sometimes on" • Server is "always on"
– Initiates a request to the – Handles services requests
server when interested from many client hosts
– E.g., Web browser on your – E.g., Web server for the
laptop or cell phone www.cnn.com Web site
– Doesn't communicate – Doesn't initiate contact with
directly with other clients the clients
– Needs to know server's – Needs fixed, known address
address

12
 Knowing What Port Number To Use
• Popular applications have well-known ports
– E.g., port 80 for Web and port 25 for e-mail
– See http://www.iana.org/assignments/port-numbers

• Well-known vs. ephemeral ports

– Server has a well-known port (e.g., port 80)
• Between 0 and 1023 (requires root to use)
– Client picks an unused ephemeral (i.e., temporary) port
• Between 1024 and 65535

• "5 tuple" uniquely identifies traffic between hosts

– Two IP addresses and two port numbers
– + underlying transport protocol (e.g., TCP or UDP)
13
 Using Ports to Identify Services
Server host 128.2.194.242
Service request for
Client host
128.2.194.242:80 Web server
(i.e., the Web server) (port 80)
Client OS
Echo server
(port 7)

Service request for

128.2.194.242:7 Web server
(i.e., the echo server) (port 80)
Client OS
Echo server
(port 7)
14
 UNIX Socket API
• In UNIX, everything is like a file
– All input is like reading a file
– All output is like writing a file
– File is represented by an integer file descriptor

• API implemented as system calls

– E.g., connect, send, recv, close, …

15
 Client-Server Communication
Datagram Sockets (UDP): Connectionless

Server
Client
socket() Create a socket
Create a socket socket()

bind() Bind the socket

Bind the socket bind()

t)
data (reques Send the request sendto()
recvfrom() Receive Request

data (reply)
sendto() Send response
Receive response recvfrom()

16
 Example app: UDP client

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

Python UDPServer
from socket import *
serverPort = 12000
create UDP socket serverSocket = socket(AF_INET, SOCK_DGRAM)
bind socket to local port number 12000 serverSocket.bind(('', serverPort))
print (“The server is ready to receive”)
loop forever while True:
Read from UDP socket into message, message, clientAddress = serverSocket.recvfrom(2048)
getting client’s address (client IP and port)
modifiedMessage = message.decode().upper()
send upper case string back to this client serverSocket.sendto(modifiedMessage.encode(),
clientAddress)
 Client-Server Communication
Stream Sockets (TCP): Connection-oriented
Server
socket() Create a socket

bind() Bind the socket Client

(what port am I on?)

Create a socket socket()

Listen for client
listen()
(Wait for incoming
connections)
connection Connect to server connect()
sh
establi
accept() Accept connection

( request) send()
data Send the request
recv() Receive Request

send() Send response data (reply)

Receive response recv()19
 Example app: TCP client

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

Python TCPServer
from socket import *
serverPort = 12000
create TCP welcoming socket serverSocket = socket(AF_INET,SOCK_STREAM)
serverSocket.bind((‘’,serverPort))
server begins listening for
incoming TCP requests serverSocket.listen(1)
print ‘The server is ready to receive’
loop forever while True:
server waits on accept() for incoming connectionSocket, addr = serverSocket.accept()
requests, new socket created on return

read bytes from socket (but sentence = connectionSocket.recv(1024).decode()

not address as in UDP) capitalizedSentence = sentence.upper()
connectionSocket.send(capitalizedSentence.
encode())
close connection to this client (but connectionSocket.close()
not welcoming socket)
 Client: Learning Server Address/Port
• Server typically known by name and service
– E.g., "www.cnn.com" and "http"
• Need to translate into IP address and port #
– E.g., "64.236.16.20" and "80"

• Get address info with given host name and service

– int getaddrinfo( char *node,
char *service,
struct addrinfo *hints,
struct addrinfo **result)

– *node: host name (e.g., "www.cnn.com") or IP address

– *service: port number or service listed in /etc/services (e.g. ftp)
– hints: points to a struct addrinfo with known information

22
Client: Learning Server Address/Port (cont.)
• Data structure to host address information
struct addrinfo {
int ai_flags;
int ai_family;//e.g. AF_INET for IPv4
int ai_socketype; //e.g. SOCK_STREAM for TCP
int ai_protocol; //e.g. IPPROTO_TCP
size_t ai_addrlen;
char *ai_canonname;
struct sockaddr *ai_addr; // point to sockaddr struct
struct addrinfo *ai_next;
}

• Example
hints.ai_family = AF_UNSPEC; // don't care IPv4 or IPv6
hints.ai_socktype = SOCK_STREAM; // TCP stream sockets
int status = getaddrinfo("www.cnn.com", "80", &hints, &result);
// result now points to a linked list of 1 or more addrinfos
// etc.

23
 Client: Creating a Socket
• Creating a socket
– int socket(int domain, int type, int protocol)
– Returns a file descriptor (or handle) for the socket
• Domain: protocol family
– PF_INET for IPv4
– PF_INET6 for IPv6
• Type: semantics of the communication
– SOCK_STREAM: reliable byte stream (TCP)
– SOCK_DGRAM: message-oriented service (UDP)
• Protocol: specific protocol
– UNSPEC: unspecified
– (PF_INET and SOCK_STREAM already implies TCP)
• Example
sockfd = socket( result->ai_family,
result->ai_socktype,
result->ai_protocol); 24
 Client: Connecting Socket to the Server
• Client contacts the server to establish connection
– Associate the socket with the server address/port
– Acquire a local port number (assigned by the OS)
– Request connection to server, who hopefully accepts
– connect is blocking
• Establishing the connection
– int connect( int sockfd,
struct sockaddr *server_address,
socketlen_t addrlen )
– Args: socket descriptor, server address, and address size
– Returns 0 on success, and -1 if an error occurs
– E.g. connect( sockfd,
result->ai_addr,
result->ai_addrlen); 25
 Client: Sending Data
• Sending data
– int send( int sockfd, void *msg,
size_t len, int flags)

– Arguments: socket descriptor, pointer to buffer of data to

send, and length of the buffer
– Returns the number of bytes written, and -1 on error
– send is blocking: return only after data is sent

– Write short messages into a buffer and send once

26
 Client: Receiving Data
• Receiving data
– int recv( int sockfd, void *buf,
size_t len, int flags)

– Arguments: socket descriptor, pointer to buffer to place

the data, size of the buffer
– Returns the number of characters read (where 0 implies
"end of file"), and -1 on error
– Why do you need len? What happens if buf's size < len?
– recv is blocking: return only after data is received

27
 Byte Order
• Network byte order
– Big Endian

• Host byte order

– Big Endian (IBM mainframes, Sun SPARC) or Little Endian (x86)

• Functions to deal with this

– htons() & htonl() (host to network short and long)
– ntohs() & ntohl() (network to host short and long)

• When to worry?
– putting data onto the wire
– pulling data off the wire
28
Server: Server Preparing its Socket
• Server creates a socket and binds address/port
– Server creates a socket, just like the client does
– Server associates the socket with the port number

• Create a socket
– int socket( int domain,
int type, int protocol )

• Bind socket to the local address and port number

– int bind( int sockfd,
struct sockaddr *my_addr,
socklen_t addrlen )

29
 Server: Allowing Clients to Wait
• Many client requests may arrive
– Server cannot handle them all at the same time
– Server could reject the requests, or let them wait
• Define how many connections can be pending
– int listen(int sockfd, int backlog)
– Arguments: socket descriptor and acceptable backlog
– Returns a 0 on success, and -1 on error
– Listen is non-blocking: returns immediately
• What if too many clients arrive?
– Some requests don't get through
– The Internet makes no promises…
– And the client can always try again
30
Server: Accepting Client Connection
• Now all the server can do is wait…
– Waits for connection request to arrive
– Blocking until the request arrives
– And then accepting the new request

• Accept a new connection from a client

– int accept( int sockfd,
struct sockaddr *addr,
socketlen_t *addrlen)
– Arguments: sockfd, structure that will provide client
address and port, and length of the structure
– Returns descriptor of socket for this new connection
31
 Client and Server: Cleaning House
• Once the connection is open
– Both sides and read and write
– Two unidirectional streams of data
– In practice, client writes first, and server reads
– … then server writes, and client reads, and so on
• Closing down the connection
– Either side can close the connection
– … using the int close(int sockfd)
• What about the data still "in flight"
– Data in flight still reaches the other end
– So, server can close() before client finishes reading
32
 Server: One Request at a Time?
• Serializing requests is inefficient
– Server can process just one request at a time
– All other clients must wait until previous one is done
– What makes this inefficient?
• May need to time share the server machine
– Alternate between servicing different requests
• Do a little work on one request, then switch when you are
waiting for some other resource (e.g., reading file from disk)
• "Nonblocking I/O"
– Or, use a different process/thread for each request
• Allow OS to share the CPU(s) across processes
– Or, some hybrid of these two approaches 33
 Handle Multiple Clients using fork()
• Steps to handle multiple clients
– Go to a loop and accept connections using accept()
– After a connection is established, call fork() to create a
new child process to handle it
– Go back to listen for another socket in the parent process
– close() when you are done.

34
while (1) {
fd = accept (srv_fd, (struct sockaddr *) &caddr, &clen);
...
pid = fork(); children++;
/* child process to handle request */
if (pid == 0) {
/* exit(0) on success, exit(1) on error */
}
/* parent process */
else if (pid > 0) {
while ((waitpid(-1, &status, WNOHANG)) > 0)
children--;
if (children > MAX_PROCESSES)
...
}
else {
perror("ERROR on fork");
exit(1);
}}
35
udpclient.c

36
udpserver.c

37
tcpechoserver.c

38
tcpechoclient.c

39
 Debugging with netcat (nc)
• UDP
– nc –u –l localhost 9999 # listening from UDP port 9999
– nc –u localhost 9999 # connect and send data to port 999

• TCP
– nc –lv localhost 9999 # listening from TCP port 9999
– nc localhost 9999 # connect and send data to TCP port 999

Please search more netcat examples on the Internet

40
 Helpful Links

• Want to know more?

– Beej's guide to network programming,
https://beej.us/guide/bgnet/
– Another tutorial at https://tutorialspoint.com/unix_sockets/
– http://www.linuxhowtos.org/C_C++/socket.htm
– https://www.geeksforgeeks.org/udp-server-client-
implementation-c/
– Also please check out the use of Netcat (NC) utility,
https://www.thegeekstuff.com/2012/04/nc-command-
examples/?utm_source=feedburner

41