TCP Sockets - RMIT University

Lecture 2
Dr Andrew Fry
RMIT University
Network Programming
COSC 1176/1179
Lecture 2
Introduction to Socket Programming:
Client/Server Design with TCP/UDP
© School of Computer Science and Information
Technology Slide 1

Lecture 2
Dr Andrew Fry
Lecture Overview
During this lecture, we will learn TCP sockets
Introduction to sockets
TCP sockets
Various functions related sockets
Simple Server Design with TCP sockets
Simple Client Design with TCP sockets
we will also learn UDP sockets
Introduction UDP sockets
Differences between TCP and UDP
Applications of UDP
Socket functions for Network programming using UDP
Examples of Simple UDP Client and Server
© School of Computer Science and Information
Technology Slide 2

Lecture 2
Dr Andrew Fry
Types of data deliveries
© School of Computer Science and Information
Technology Slide 3

Lecture 2
Dr Andrew Fry
Client-server model and Process-Process
Interaction
Client-Server interaction
is a process-to-process
interaction.
Server could be a
webserver, a mailserver, a
database server, ftp
server, telent server, ssh
server etc.
© School of Computer Science and Information
Technology Slide 4

Well known services use well known ports
Lecture 2
Dr Andrew Fry
Services could be
supported by TCP or
UDP, or others.
Well known
services use well
known port numbers
to be well identified.
Servers can also
use short lived ports
to support
concurrency
Clients use
temporary ports.
© School of Computer Science and Information
Technology Slide 5

Lecture 2
Dr Andrew Fry
/etc/services
Port numbers of some well known services.
echo 7/tcp
echo 7/udp
systat 11/tcp users
daytime 13/tcp
daytime 13/udp
netstat 15/tcp
ftp-data 20/tcp
ftp 21/tcp
ssh 22/tcp # Secure Shell
telnet 23/tcp
smtp 25/tcp mail
© School of Computer Science and Information
Technology Slide 6

Lecture 2
Dr Andrew Fry
Port Numbers, IP & Socket Address
The combination of ip addr and
port number is called a socket
address
© School of Computer Science and Information
Technology Slide 7

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
Server starts by getting ready to receive client
connections…
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 8

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
int socket(int family, int type, int protocol);
/* Create socket for incoming connections */
if ((servSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
DieWithError("socket() failed");
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 9

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
int bind(int sockfd, const struct sockaddr *myaddr,
socklen_t addrlen);
echoServAddr.sin_family = AF_INET; /* Internet address family */
echoServAddr.sin_addr.s_addr = htonl(INADDR_ANY);/* Any incoming interface */
echoServAddr.sin_port = htons(echoServPort); /* Local port */
if (bind(servSock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0)
DieWithError("bind() failed");
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 10

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
int listen(int sockfd, int backlog);
/* Mark the socket so it will listen for incoming connections */
if (listen(servSock, MAXPENDING) < 0)
DieWithError("listen() failed");
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 11

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
int accept(int sockfd,
struct sockaddr* cliaddr, int *addrlen);
for (;;) /* Run forever */
{
clntLen = sizeof(echoClntAddr);
if ((clntSock=accept(servSock,(struct sockaddr *)&echoClntAddr,&clntLen)) < 0)
DieWithError("accept() failed");
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 12

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
Server is now blocked waiting for connection from a client
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
Later, a client decides to talk to the server…
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 13

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
/* Create a reliable, stream socket using TCP */
if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
DieWithError("socket() failed");
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 14

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
int connect(int sockfd, const struct sockaddr*
servaddr, int addrlen);
echoServAddr.sin_family = AF_INET; /* Internet address family */
echoServAddr.sin_addr.s_addr = inet_addr(servIP); /* Server IP address */
echoServAddr.sin_port = htons(echoServPort); /* Server port */
if (connect(sock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0)
DieWithError("connect() failed");
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 15

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
if ((clntSock=accept(servSock,(struct sockaddr
*)&echoClntAddr,&clntLen)) < 0)
DieWithError("accept() failed");
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 16

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
int send(SOCKET sockfd,
const char* buf, int buflen,int flags);
echoStringLen = strlen(echoString); /* Determine input length */
/* Send the string to the server */
if (send(sock, echoString, echoStringLen, 0) != echoStringLen)
DieWithError("send() sent a different number of bytes than
expected");
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 17

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
int recv(SOCKET sockfd,
char* buf, int len,int flags);
/* Receive message from client */
if ((recvMsgSize = recv(clntSocket, echoBuffer, RCVBUFSIZE, 0)) < 0)
DieWithError("recv() failed");
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 18

Lecture 2
Dr Andrew Fry
TCP Client/Server Interaction
Client
1. Create a TCP socket
2. Establish connection
3. Communicate
4. Close the connection
int close(int sockfd);
close(sock); close(clntSocket)
Server
1. Create a TCP socket
2. Bind socket to a port
3. Set socket to listen
4. Repeatedly:
a. Accept new connection
b. Communicate
c. Close the connection
© School of Computer Science and Information
Technology Slide 19

Summary of Socket Calls For a TCP Client &
Server
socket()
Lecture 2
Dr Andrew Fry
socket()
connect()
write()
read()
close()
Three Way Handshake
Response
Request
End-of-File Notification
bind()
listen()
accept()
read()
write()
read()
close()
© School of Computer Science and Information
Technology Slide 20

Lecture 2
Dr Andrew Fry
socket()
Creates an endpoint for communication
int socket(int family, int type, int protocol);
family : specifies the protocol/address family for the socket:
Typically, AF_INET or AF_UNIX (AF_LOCAL)
AF_INET6 (for IPv6), AF_X25 (X.25 Protocols), AF_ATMPVC (ATM Private
Virtual Circuits), AF_PACKET (low level packet communications)
AF_ROUTE (access to routing tables), AF_KEY (new, for encryption)
There are more.
type : specifies the type of socket:
Typically, SOCK_STREAM (reliable, connection oriented bytestream); or
SOCK_DGRAM (unreliable, connectionless datagrams)
SOCK_RAW (access to raw network protocols), and there are more.
protocol : which protocol to use within the family, most often set
to 0 (default protocol)
IPPROTO_TCP for SOCK_STREAM, or IPPROTO_UDP for SOCK_DGRAM
Returns a ‘socket descriptor’ if successful, or
-1/INVALID_SOCKET on failure
© School of Computer Science and Information
Technology Slide 21

Lecture 2
Dr Andrew Fry
bind()
Assigns a local protocol address (name) to a socket
int bind(int sockfd, const struct sockaddr
*myaddr, socklen_t addrlen);
sockfd : is socket descriptor from socket()
myaddr : protocol-specific structure containing the local
address information. It is a pointer to address struct with:
port number and IP address
if port is 0, then host will pick ephemeral port not usually for
server (exception RPC port-map)
IP address = INADDR_ANY, indicates we want to bind to all of our
local host’s addresses.
addrlen : the size of the structure pointed to by myaddr
Returns 0 on success or -1/SOCKET_ERROR if it fails.
© School of Computer Science and Information
Technology Slide 22

Lecture 2
Dr Andrew Fry
Socket Address Structure
struct in_addr {
in_addr_t s_addr; /* 32-bit IPv4 addresses */
};
struct sockaddr_in {
unit8_t sin_len; /* length of structure */
sa_family_t sin_family; /* AF_INET */
in_port_t sin_port; /* TCP/UDP Port num */
struct in_addr sin_addr; /* IPv4 address (above) */
char sin_zero[8]; /* unused */
}
Are also “generic” and “IPv6” socket structures
© School of Computer Science and Information
Technology Slide 23

Lecture 2
Dr Andrew Fry
listen()
Makes a socket ‘listen’ for new connections
int listen(int sockfd, int backlog);
sockfd : sockfd is socket descriptor from socket()
backlog : specifies the length of the queue of waiting
connections that the kernel should maintain. backlog is
maximum number of incomplete connections
historically 5
rarely above 15 on a even moderate Web server!
Returns 0 on success or -1/SOCKET_ERROR on
failure
© School of Computer Science and Information
Technology Slide 24

Lecture 2
Dr Andrew Fry
accept()
Accepts new connections from a listening socket
int accept(int sockfd,
struct sockaddr* cliaddr, int *addrlen);
sockfd : sockfd is socket descriptor from socket()
cliaddr : protocol-specific structure containing the
remote address information
addrlen : a pointer to the size of the structure pointed
to by cliaddr, altered to indicate the size used
Returns a new socket descriptor on success or
-1/INVALID_SOCKET on failure
© School of Computer Science and Information
Technology Slide 25

Lecture 2
Dr Andrew Fry
connect()
Used by TCP clients to establish a connection to a ‘listening’
socket
int connect(int sockfd, const struct sockaddr*
servaddr, int addrlen);
sockfd : sockfd is socket descriptor from socket()
servddr : protocol-specific structure containing the local
address information. servaddr is a pointer to a structure with:
port number and IP address
addrlen : the size of the structure pointed to by servaddr
client doesn’t need bind()
OS will pick ephemeral port
Returns 0 on success or -1/SOCKET_ERROR on failure
© School of Computer Science and Information
Technology Slide 26

Lecture 2
Dr Andrew Fry
read() and write()
Used by Unix TCP clients to read and write on a socket
descriptor
ssize_t read(int sockfd,
void *buf, size_t buflen);
ssize_t write(int sockfd,
void *buf, size_t len);
sockfd : socket descriptor (would be normally be fd)
buf : a buffer containing either data to write or space to read
into
buflen/len : the maximum number of bytes which may be read or
the number of bytes to write
Returns the number of bytes read/written or -1 on failure
read() returns 0 to indicate end-of-file
© School of Computer Science and Information
Technology Slide 27

Lecture 2
Dr Andrew Fry
send() and recv()
int send(SOCKET sockfd,
const char* buf, int buflen,
int flags);
int recv(SOCKET sockfd,
char* buf, int len,
int flags);
sockfd : socket descriptor
buf : a buffer containing either data to write or space to
read into
buflen/len : the maximum number of bytes which may be
read or the number of bytes to write
flags : bitwise OR of several options
© School of Computer Science and Information
Technology Slide 28

Lecture 2
Dr Andrew Fry
close()
Closes a connection & frees associated resources
int close(int sockfd);
sockfd: socket descriptor
closes socket for reading/writing
returns (doesn’t block)
attempts to send any unsent data
Returns 0 on success or -1/SOCKET_ERROR on
failure
© School of Computer Science and Information
Technology Slide 29

#include
Lecture 2
Dr Andrew Fry
Simpleserver.c – walk through code
#include
#include
#include
const char NPMESSAGE[] = "Welcome to Network Programming.This is a fun
course!\n";
int main(int argc, char *argv[]) {
int simpleSocket = 0;
int simplePort = 0;
int returnStatus = 0;
struct sockaddr_in simpleServer;
if (2 != argc) {
}
fprintf(stderr, "Usage: %s \n", argv[0]);
exit(1);
/* retrieve the port number for listening */
simplePort = atoi(argv[1]);
Program
setup and
parameter
parsing
© School of Computer Science and Information
Technology Slide 30

Simpleserver.c – walk through code contd
simpleSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (simpleSocket == -1) {
}
else {
}
fprintf(stderr, "Could not create a socket!\n");
exit(1);
Lecture 2
Dr Andrew Fry
fprintf(stderr, "Socket created!\n");
bzero(&simpleServer, sizeof(simpleServer));
simpleServer.sin_family = AF_INET;
simpleServer.sin_addr.s_addr = htonl(INADDR_ANY);
simpleServer.sin_port = htons(simplePort);
returnStatus = bind(simpleSocket,(struct sockaddr *)&simpleServer,sizeof(simpleServer));
if (returnStatus == 0) {
} else {
fprintf(stderr, "Bind completed!\n");
fprintf(stderr, "Could not bind to address!\n");
close(simpleSocket);
exit(1);}
Create a TCP
socket
/* setup the address structure
*/
/* use INADDR_ANY to
bind to all local addresses */
/* bind
to the
address
and port
with our
socket
*/
© School of Computer Science and Information
Technology Slide 31

Simpleserver.c – walk through code contd
Lecture 2
Dr Andrew Fry
returnStatus = listen(simpleSocket, 5);
if (returnStatus == -1) {
}
fprintf(stderr, "Cannot listen on socket!\n");
close(simpleSocket);
exit(1);
Informs
the TCP
implementat
ion to
allown
incoming
connections
from clients
© School of Computer Science and Information
Technology Slide 32

while (1)
{
Simpleserver.c – walk through code contd
struct sockaddr_in clientName = { 0 };
int simpleChildSocket = 0;
int clientNameLength = sizeof(clientName);
simpleChildSocket = accept(simpleSocket,(struct sockaddr *)&clientName, &clientNameLength);
if (simpleChildSocket == -1) {
}
fprintf(stderr, "Cannot accept connections!\n");
close(simpleSocket);
exit(1);
write(simpleChildSocket, NPMESSAGE, strlen(NPMESSAGE));
}
}
close(simpleChildSocket);
close(simpleSocket);
return 0;
Lecture 2
Dr Andrew Fry
Wait here at
the accept()
call until a
connection
request is
received
from a
client. So
the default
behavior is
blocking.
write
out
messag
e to
the
clinet
© School of Computer Science and Information
Technology Slide 33

#include
#include
#include
#include
int main(int argc, char *argv[]) {
int simpleSocket = 0;
int simplePort = 0;
int returnStatus = 0;
char buffer[256] = "";
struct sockaddr_in simpleServer;
if (3 != argc) {
}
Lecture 2
Dr Andrew Fry
Simpleclient.c
fprintf(stderr, "Usage: %s \n", argv[0]);
exit(1);
This is pretty
similar to
simpleserver
Simpleserver can
be modified to
create simpleclient
Remove bind(),
listen(),accept()
functions from
simpleserver
Add connect()
Modify use of
read()
© School of Computer Science and Information
Technology Slide 34

* create a streaming socket */
Lecture 2
Dr Andrew Fry
Simpleclient.c
simpleSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (simpleSocket == -1) {
}
else {
}
fprintf(stderr, "Could not create a socket!\n");
exit(1);
fprintf(stderr, "Socket created!\n");
/* retrieve the port number for connecting */
simplePort = atoi(argv[2]);
/* setup the address structure */
/* use the IP address sent as an argument for the server address */
bzero(&simpleServer, sizeof(simpleServer));
simpleServer.sin_family = AF_INET;
inet_addr(argv[1], &simpleServer.sin_addr.s_addr);
simpleServer.sin_port = htons(simplePort);
These are part of
the newly added
code
© School of Computer Science and Information
Technology Slide 35

Lecture 2
Dr Andrew Fry
Simpleclient.c
/* connect to the address and port with our socket */
returnStatus = connect(simpleSocket, (struct sockaddr *)&simpleServer, sizeof(simpleServer));
if (returnStatus == 0) {
} else {
}
fprintf(stderr, "Connect successful!\n");
fprintf(stderr, "Could not connect to address!\n");
close(simpleSocket);
exit(1);
/* get the message from the server */
returnStatus = read(simpleSocket, buffer, sizeof(buffer));
if ( returnStatus > 0 ) {
printf("%d: %s", returnStatus, buffer);
} else {
}
fprintf(stderr, "Return Status = %d \n", returnStatus);
close(simpleSocket);
return 0;}
These are part of
the newly added
code
With these simple
modifications you
now have converted
simpleserver ->
simpleclient !
© School of Computer Science and Information
Technology Slide 36

Solaris :
Lecture 2
Dr Andrew Fry
Compiling code
Goanna% gcc simpleserver.c -o simpleserver -lsocket -lnsl
Goanna% gcc simpleclient.c -o simpleclient -lsocket -lnsl
Linux :
mymachine% gcc simpleserver.c -o simpleserver
mymachine% gcc simpleclient.c -o simpleclient
Get code from NP course webpage!!!
© School of Computer Science and Information
Technology Slide 37

Lecture 2
Dr Andrew Fry
Types of data deliveries
Services could be supported by TCP or UDP, or others. (We have
already learnt about TCP sockets in the previous lecture)
Transmission Control Protocol
Connection oriented
RFC 793
User Datagram Protocol (UDP)
Connectionless
RFC 768
© School of Computer Science and Information
Technology Slide 38

Lecture 2
Dr Andrew Fry
The Transport Layer
IP protocol made it possible to shift packets between
computers on different networks
IP offers only ‘best effort connectionless’ service
performance of intervening networks is unknown
To ensure reliable, sequenced delivery the people at each end
wrote their own ‘Transport Layer’ software
Concerned with providing (reasonably) reliable, cost effective
data transport from the source to the destination
as programmers, this is really what we want from a
network
therefore the most used Application Programming
Interfaces (APIs) for network programming are
interfaces to the Transport layer
© School of Computer Science and Information
Technology Slide 39

Lecture 2
Dr Andrew Fry
Transport Layer as a Concept
Design goals:
service should meet user’s requirements independent of
the underlying Network layer services
service should be efficient
uniform scheme for addressing should allow addressing
of individual access points for application layer
The Transport layer can implement:
error control
sequencing
flow control
© School of Computer Science and Information
Technology Slide 40

Lecture 2
Dr Andrew Fry
/etc/services – udp based services
Port numbers of some well known services.
echo 7/tcp
echo 7/udp
systat 11/tcp users
daytime 13/tcp
daytime 13/udp
netstat 15/tcp
ftp-data 20/tcp
ftp 21/tcp
ssh 22/tcp # Secure Shell
telnet 23/tcp
smtp 25/tcp mail
Many services are
UDP based
© School of Computer Science and Information
Technology Slide 41

Connection-Oriented vs Connectionless Services:
basic concept
Connection-oriented service is like the telephone
service:
establish an end-to-end connection (for which you need a
destination address);
communicate via that connection;
terminate the connection.
Connectionless service is like the postal service:
attach a destination address to a message, and send that
message;
repeat as necessary
Lecture 2
Dr Andrew Fry
© School of Computer Science and Information
Technology Slide 42

Lecture 2
Dr Andrew Fry
Reliable vs Unreliable Services
A reliable service never corrupts or loses any part
of the communication
often achieved with end-to-end acknowledgement
An unreliable service offers no such guarantee
often more efficient & less delay
In the Internet world the most common
combinations are:
reliable, connection oriented service (TCP); and
unreliable, connectionless service (UDP).
© School of Computer Science and Information
Technology Slide 43

Lecture 2
Dr Andrew Fry
Connection Establishment
© School of Computer Science and Information
Technology Slide 44

Lecture 2
Dr Andrew Fry
TCP format
© School of Computer Science and Information
Technology Slide 45

Lecture 2
Dr Andrew Fry
UDP Header
Like TCP, UDP adds ‘ports’ to
addresses
full transport-layer address is
specified by IP address, protocol, and
port
Note: TCP and UDP do not share ports.
© School of Computer Science and Information
Technology Slide 46

Three-step connection establishment
(TCP)
Connection establishment
Lecture 2
Dr Andrew Fry
Three way handshake
Between pairs of ports
One port can connect to multiple
destinations
Reliable communication between pairs
of processes
Across variety of reliable and
unreliable networks and internets
© School of Computer Science and Information
Technology Slide 47

Four-step connection termination (TCP)
Lecture 2
Dr Andrew Fry
© School of Computer Science and Information
Technology Slide 48

Lecture 2
Dr Andrew Fry
User Datagram Protocol
UDP offers a simple, unreliable connectionless service
no concept of a connection
no end-to-end reliability management
a user interface to IP datagrams
UDP is a convenient transport-layer protocol for applications
that provide flow and error control. It is also used by
multimedia applications
Characteristics: Reduced overhead, Segments may get lost, Segments
may arrive out of order
Complexities
Ordered Delivery,Retransmission strategy
Duplication detection, Flow control
Connection establishment, Connection termination
Crash recovery
© School of Computer Science and Information
Technology Slide 49

Lecture 2
Dr Andrew Fry
When to Use (and not use)UDP
Particularly appropriate circumstances include:
broadcast applications
multicast applications
simple request-reply operations
idempotent operations
simple one way message transfer
Particularly inappropriate circumstances include:
error free bulk transfer
© School of Computer Science and Information
Technology Slide 50

Lecture 2
Dr Andrew Fry
When to Use TCP
TCP is a powerful and efficient error and flow
control protocol
Not appropriate for real-time streaming
Not appropriate where the overhead of
establishing and maintaining a connection is large
compared to the load of the application itself
Appropriate for specific applications in specific
networks
© School of Computer Science and Information
Technology Slide 51

Summary of Socket Calls For a TCP Client &
Server
Operations for client-server connections:
server must listen for connections
client must connect to the server
server must accept the connection
client & server must send & receive data
client & server must be able to disconnect
Lecture 2
Dr Andrew Fry
socket()
connect()
write()
read()
close()
Three Way Handshake
Response
Request
End-of-File Notification
socket()
bind()
listen()
accept()
read()
write()
read()
close()
© School of Computer Science and Information
Technology Slide 52

Lecture 2
Dr Andrew Fry
Socket Calls For a UDP Client & Server
Can use read(), write() and send(),
recv() in connected mode UDP.
Sendto()
And
Recvfrom()
socket()
connect()
write()
read()
close()
Three Way Handshake
Response
Request
End-of-File Notification
socket()
bind()
listen()
accept()
read()
write()
read()
close()
Recvfrom()
And
Sendto()
© School of Computer Science and Information
Technology Slide 53

Socket Calls For a UDP Client & Server
Typical Socket Calls For a connectionless UDP Client & Server
Lecture 2
Dr Andrew Fry
socket()
sendto()
recvfrom()
close()
Response
Request
socket()
bind()
recvfrom()
sendto()
© School of Computer Science and Information
Technology Slide 54

Lecture 2
Dr Andrew Fry
Sending UDP Datagrams
ssize_t sendto( int sockfd,
sockfd is a UDP socket
void *buff,
size_t nbytes,
int flags,
const struct sockaddr* to,
socklen_t addrlen);
buff is the address of the data (nbytes long)
(pointer to a buffer containing data to be transmitted)
to is the address of a sockaddr containing the destination
address.
flags : covered in future lectures
Return value is the number of bytes sent, or -1 on error.
© School of Computer Science and Information
Technology Slide 55

Lecture 2
Dr Andrew Fry
sendto()
You can send 0 bytes of data! (Q: what does it
mean?)
The return value of sendto() indicates how much
data was accepted by the O.S. for sending as a
datagram - not how much data made it to the
destination.
There is no error condition that indicates that the
destination did not get the data!!!
Some possible errors :
EBADF, ENOTSOCK: bad socket descriptor
EFAULT: bad buffer address
EMSGSIZE: message too large
ENOBUFS: system buffers are full
© School of Computer Science and Information
Technology Slide 56

Lecture 2
Dr Andrew Fry
Receiving UDP Datagrams
ssize_t recvfrom( int sockfd,
void *buff,
size_t nbytes,
int flags,
struct sockaddr* from,
socklen_t *fromaddrlen);
sockfd is a UDP socket
buff is the address of a buffer (nbytes long)
(pointer to a buffer that is used to store the received data)
from is the address of a sockaddr.
Return value is the number of bytes received
and put into buff, or -1 on error.
© School of Computer Science and Information
Technology Slide 57

Lecture 2
Dr Andrew Fry
recvfrom()
If buff is not large enough, any extra data is lost forever...
You can receive 0 bytes of data! (Q: what does it mean?)
The sockaddr at from is filled in with the address of the
sender.
You should set fromaddrlen before calling.
If from and fromaddrlen are NULL we don’t find out who
sent the data.
Same errors as sendto, but also:
EINTR: System call interrupted by signal.
Unless you do something special - recvfrom doesn’t return
until there is a datagram available.
© School of Computer Science and Information
Technology Slide 58

Lecture 2
Dr Andrew Fry
Typical UDP client code
Create UDP socket.
Create sockaddr with address of server.
Call sendto(), sending request to the server. No
call to bind() is necessary! (but you can use it)
Possibly call recvfrom() (if we need a reply).
int socket(int family,int type,int proto);
int sock;
sock = socket( PF_INET,
SOCK_DGRAM,
if (sock

Lecture 2
Dr Andrew Fry
Socket Address Structure revisited
sockaddr with address of server (and client)
struct in_addr {
in_addr_t s_addr; /* 32-bit IPv4 addresses */
};
struct sockaddr_in {
unit8_t sin_len; /* length of structure */
sa_family_t sin_family; /* AF_INET */
in_port_t sin_port; /* TCP/UDP Port num */
struct in_addr sin_addr; /* IPv4 address (above) */
char sin_zero[8]; /* unused */
}
Are also “generic” and “IPv6” socket structures
© School of Computer Science and Information
Technology Slide 60

Lecture 2
Dr Andrew Fry
Typical UDP Server code
Create UDP socket and bind to well known address.
Call recvfrom() to get a request, noting the
address of the client.
Process request and send reply back with
sendto().
int mysock;
struct sockaddr_in myaddr;
mysock = socket(PF_INET,SOCK_DGRAM,0);
myaddr.sin_family = AF_INET;
myaddr.sin_port = htons( 1234 );
myaddr.sin_addr = htonl( INADDR_ANY );
bind(mysock, &myaddr, sizeof(myaddr));
© School of Computer Science and Information
Technology Slide 61

* UDP Server */
#include
#include
#include
#include
#include
#define MAXBUF 1024
int main(int argc, char* argv[])
{
int udpSocket;
int returnStatus = 0;
int addrlen = 0;
struct sockaddr_in udpServer, udpClient;
char buf[MAXBUF];
Lecture 2
Dr Andrew Fry
A simple UDP Server
if (argc < 2)
{
fprintf(stderr, "Usage: %s \n", argv[0]);
exit(1);
}
/* initializing */
/* check for the right number of
arguments */
udpSocket = socket(AF_INET, SOCK_DGRAM, 0); /* create a socket */
© School of Computer Science and Information
Technology Slide 62

if (udpSocket == -1)
{
}
else {
udpServer.sin_family = AF_INET;
returnStatus = bind(udpSocket, (struct
sockaddr*)&udpServer, sizeof(udpServer));
if (returnStatus == 0) {
}
else {
}
Lecture 2
Dr Andrew Fry
fprintf(stderr, "Bind completed!\n");
A simple UDP Server
fprintf(stderr, "Could not create a socket!\n");
exit(1);
printf("Socket created.\n");}
udpServer.sin_addr.s_addr = htonl(INADDR_ANY);
udpServer.sin_port = htons(atoi(argv[1]));
fprintf(stderr, "Could not bind to address!\n");
close(udpSocket);
exit(1);
/* setup the server address and
port */
/* use INADDR_ANY to bind to all
local addresses */
/* use the port pased as
argument */
/* bind to the socket */
© School of Computer Science and Information
Technology Slide 63

while (1)
}
{
}
addrlen = sizeof(udpClient);
Lecture 2
Dr Andrew Fry
A simple UDP Server
returnStatus = recvfrom(udpSocket, buf, MAXBUF, 0,
if (returnStatus == -1) {
}
else {
}
(struct sockaddr*)&udpClient, &addrlen);
fprintf(stderr, "Could not receive message!\n");
printf("Received: %s\n", buf);
strcpy(buf, "OK");
returnStatus = sendto(udpSocket, buf, strlen(buf)+1, 0,
if (returnStatus == -1) {
}
(struct sockaddr*)&udpClient, sizeof(udpClient));
fprintf(stderr, "Could not send confirmation!\n");
else { printf("Confirmation sent.\n"); }
close(udpSocket);
return 0;
/* receive data
from client */
/* a message was
received so send a
confirmation */
/* send data to
client */
/*cleanup */
© School of Computer Science and Information
Technology Slide 64

* UDP client */
#include
#include
#include
#include
#include
#define MAXBUF 1024
int main(int argc, char* argv[])
{
int udpSocket;
int returnStatus;
int addrlen;
struct sockaddr_in udpClient, udpServer;
char buf[MAXBUF];
if (argc < 3)
{
Lecture 2
Dr Andrew Fry
A simple UDP Client
fprintf(stderr, "Usage: %s \n",
argv[0]);
}
exit(1);
© School of Computer Science and Information
Technology Slide 65

* create a socket */
Lecture 2
Dr Andrew Fry
A simple UDP Client
udpSocket = socket(AF_INET, SOCK_DGRAM, 0);
if (udpSocket == -1)
{
}
else {
}
fprintf(stderr, "Could not create a socket!\n");
exit(1);
printf("Socket created.\n");
/* client address */
/* use INADDR_ANY to use all local addresses */
udpClient.sin_family = AF_INET;
udpClient.sin_addr.s_addr = INADDR_ANY;
udpClient.sin_port = 0;
© School of Computer Science and Information
Technology Slide 66

eturnStatus = bind(udpSocket, (struct
sockaddr*)&udpClient, sizeof(udpClient));
if (returnStatus == 0) {
}
else {
Lecture 2
Dr Andrew Fry
fprintf(stderr, "Bind completed!\n");
A simple UDP Client
fprintf(stderr, "Could not bind to address!\n");
close(udpSocket);
exit(1);
}
/* setup the message to be sent to the server */
strcpy(buf, "Hey ..... What's UP?\n");
/* server address */
/* use the command line arguments */
udpServer.sin_family = AF_INET;
udpServer.sin_addr.s_addr = inet_addr(argv[1]);
udpServer.sin_port = htons(atoi(argv[2]));
© School of Computer Science and Information
Technology Slide 67

Lecture 2
Dr Andrew Fry
A simple UDP Client
returnStatus = sendto(udpSocket, buf, strlen(buf)+1, 0,
(struct sockaddr*)&udpServer, sizeof(udpServer));
if (returnStatus == -1) {
fprintf(stderr, "Could not send message!\n");
}
else {
printf("Message sent.\n");
/* message sent: look for confirmation */
addrlen = sizeof(udpServer);
returnStatus = recvfrom(udpSocket, buf, MAXBUF, 0,
(struct sockaddr*)&udpServer, &addrlen);
if (returnStatus == -1) {
fprintf(stderr, "Did not receive confirmation!\n");
}
else {
buf[returnStatus] = 0;
printf("Received: %s\n", buf);
}
}
close(udpSocket);
return 0;
}
© School of Computer Science and Information
Technology Slide 68

Lecture 2
Dr Andrew Fry
Connected mode
A UDP socket can be used in a call to connect().
This simply tells the O.S. the address of the peer.
No handshake is made to establish that the peer
exists.
does not do three way handshake, or connection
“connect” a misnomer, here. Should be setpeername()
No data of any kind is sent on the network as a
result of calling connect() on a UDP socket.
© School of Computer Science and Information
Technology Slide 69

Lecture 2
Dr Andrew Fry
Connected UDP
connect() with SOCK_DGRAM sockets:
Sets the destination for all further sends, allowing use of
write() instead of sendto()
Sets the source of all further reads, allowing the use of
read() instead of recvfrom()
Once a UDP socket is connected:
Can also use send() instead of sendto()
Can also use recv() instead of recvfrom()
Asynchronous errors will be returned to the process.
OS Specific, some won’t do this!
© School of Computer Science and Information
Technology Slide 70

Lecture 2
Dr Andrew Fry
Asynchronous error
What happens if a client sends data to a server
that is not running?
ICMP “port unreachable” error is generated by receiving
host and sent to sending host.
The ICMP error may reach the sending host after
sendto() has already returned!
The next call dealing with the socket could return the
error.
© School of Computer Science and Information
Technology Slide 71

Lecture 2
Dr Andrew Fry
Back to UDP connect()
Connect() is typically used with UDP when
communication is with a single peer only.
Many UDP clients use connect().
Some servers (TFTP).
It is possible to disconnect and connect the same
socket to a new peer.
© School of Computer Science and Information
Technology Slide 72

Lecture 2
Dr Andrew Fry
Why use connected UDP?
Send two datagrams
unconnected:
connect the socket
output first dgram
unconnect the
socket
connect the socket
ouput second dgram
unconnect the
socket
Send two datagrams
connected:
connect the socket
output first dgram
ouput second dgram
© School of Computer Science and Information
Technology Slide 73

Lecture 2
Dr Andrew Fry
Next Time
More about Server and client Design with TCP
Missing links (e.g sockaddr_in : bzero, memset; hton*, ntoh*;
intet_addr)
Identification functions: gethostbyaddr(), gethostbyname()
etc.
More examples of socket related functions
© School of Computer Science and Information
Technology Slide 74