Introduction To Unix Network Programming Network Programming

Network Programming
Introduction to Unix Network

Programming
Key Components:
Internet protocols
IP, TCP, UDP, etc
Sockets
Reference: Stevens Unix

Network Programming
API - application programming interface
Why focus on the Internet?

Internet Protocol (IP)

IP is standard
allows a common namespace across most of Internet
reduces number of translations, which incur overhead
Sockets

CS/ECE 338
Robin Kravets & Steve Lumetta, UIUC Spring 2003
reasonably simple and elegant, Unix interface
CS/ECE 338
Internet Protocols
Direction and Principles

Programming
Application
Layers
FTP
HTTP
NV
TFTP
Transport
Network
Transport
TCP
UDP
learn to use Internet for

communication (with focus on
implementation of networking
concepts)
Data Link
Network
IP
Physical
Data Link
Ethernet
FDDI
ATM
Modem
Principles and
Concepts
Physical
CS/ECE 338
learn to build network from ground

up
CS/ECE 338
Network Programming with

Sockets
Outline
Reading:
Client-Sever Model
TCP Connection
UDP Services
Addresses and Data
Sockets API
Example
Stevens 2nd ed., Ch. 1-6 or 1st ed., Ch. 1-3, 6
Sockets API:
A transport layer service interface
Introduced in 1981 by BSD 4.1
Implemented as library and/or system calls
Similar interfaces to TCP and UDP
Can also serve as interface to IP (for super-user);
known as raw sockets
CS/ECE 338
Client-Server Model
Client
Asymmetric
Communication
Client
Server/Daemon
Server
Client
CS/ECE 338
CS/ECE 338
Examples
Web
FTP
Telnet
Client sends requests

Server sends replies
Well-known name
Waits for contact
Processes requests, sends
replies
Client
Initiates contact
Waits for response
Client-Server Model
Client
Client
CS/ECE 338
Communication Link
Server
8
Client-Server Communication
Model
TCP Connections
Service Model
Transmission Control Protocol (TCP)

Service
Concurrent:
Server processes multiple clients requests
simultaneously
OSI Transport Layer

Service Model
Sequential:
Server processes only one clients requests at a time
Byte stream (interpreted by application)

16-bit port space allows multiple connections
on a single host
Connection-oriented
Hybrid:
Server maintains multiple connections, but processes
responses sequentially
Client and server categories are not disjoint

A server can be a client of another server
A server can be a client of its own client
CS/ECE 338
Set up connection before communicating

Tear down connection when done
9
TCP Service
CS/ECE 338
10
TCP Connection Establishment

Passive open
Reliable Data Transfer
3-Way Handshake
Guarantees delivery of all data

Exactly once if no catastrophic failures
Sequence Numbers
Active open
Client
J,K
Sequenced Data Transfer
Message Types
Guarantees in-order delivery of data

If A sends M1 followed by M2 to B, B never receives M2
before M1
Synchronize (SYN)
Acknowledge (ACK)
Passive Open
Regulated Data Flow
Server listens for

connection from client
Monitors network and adjusts transmission appropriately

Prevents senders from wasting bandwidth
Reduces global congestion problems
Client initiates
connection to server
Full-Duplex byte stream

CS/ECE 338
11
CS/ECE 338
roniz
e
listen
(SYN
)J
K,
+1
SY N
CK) J
dge (A
owle
n
k
c
a
AC K
Active Open
Data Transmission
Server
Synch
K+1
Time flows down

12
TCP Connection Termination
UDP Services
Active close
Either client or server

can initiate
connection teardown
Message Types
Passive close
Client
Server
Finis
Finished (FIN)
Acknowledge (ACK)
ACK
OSI Transport Layer

Provides a thin layer over IP
16-bit port space (distinct from TCP
ports) allows multiple recipients on a
single host
)J
J+1
FIN K
Active Close
Sends no more data
AC K
Passive close
Accepts no more data
CS/ECE 338
hed (F
IN
User Datagram Protocol Service
K+1
Time flows down
13
CS/ECE 338
UDP Services
Addresses and Data
Unit of Transfer
Internet domain names
Datagram (variable length packet)
Human readable
Variable length
Ex: sal.cs.uiuc.edu
Unreliable
No guaranteed delivery
Drops packets silently
IP addresses
Easily handled by routers/computers
Fixed length
Somewhat geographical
Ex: 128.174.252.217
Unordered
No guarantee of maintained order of delivery
Unlimited Transmission
No flow control
CS/ECE 338
14
15
CS/ECE 338
16
Byte Ordering
Byte Ordering Functions

16- and 32-bit conversion functions (for platform
independence)
Examples:
Big Endian vs. Little Endian

Little Endian (Intel, DEC):
Least significant byte of word is stored in the lowest
memory address
int m, n;
short int s,t;
Big Endian (Sun, SGI, HP):

Most significant byte of word is stored in the lowest
memory address
m
s
n
t
Network Byte Order = Big Endian

Allows both sides to communicate
Must be used for some data (i.e. IP Addresses)
Good form for all binary data
CS/ECE 338
17
=
=
=
=
ntohl
ntohs
htonl
htons
CS/ECE 338
(n)
(t)
(m)
(s)
net-to-host
net-to-host
host-to-net
host-to-net
long (32-bit) translation

short (16-bit) translation
long (32-bit) translation
short (16-bit) translation
18
Address Access/Conversion
Functions
Socket Address Structure

IP address:
All binary values are network byte ordered
struct in_addr {
in_addr_t s_addr;
};
/* 32-bit IP address */
struct hostent* gethostbyname (const char*

hostname);
Translate English host name to IP address (uses DNS)
TCP or UDP address:

struct sockaddr_in {
short sin_family;
ushort sin_port;
struct in_addr;
};
struct hostent* gethostbyaddr (const char*

addr, size_t len, int family);
/* e.g., AF_INET */
/* TCP/UDP port */
/* IP address */
Translate IP address to English host name (not secure)
char* inet_ntoa (struct in_addr inaddr);

all but sin_family in network byte order
CS/ECE 338
Translate IP address to ASCII dotted-decimal notation (e.g.,

128.32.36.37); not thread-safe
19
CS/ECE 338
20
Address Access/Conversion
Functions
Sockets API
in_addr_t inet_addr (const char* strptr);

Translate dotted-decimal notation to IP address; returns -1 on
failure, thus cannot handle broadcast value 255.255.255.255
int inet_aton (const char* strptr, struct

in_addr inaddr);
Translate dotted-decimal notation to IP address; returns 1 on
success, 0 on failure
int gethostname (char* name, size_t

namelen);
Basic Unix Concepts

Creation and Setup
Establishing a Connection (TCP)
Sending and Receiving Data
Tearing Down a Connection (TCP)
Advanced Sockets
Read hosts name (use with gethostbyname to find local IP)

CS/ECE 338
21
Basic Unix Concepts
CS/ECE 338
Example Socket Creation

Bothous
Actoris
Input/Output I/O
I am Bothous
port 46.
Per-process table of I/O channels

Table entries describe files, sockets, devices, pipes, etc.
Unifies I/O interface
Table entry/index into table called file descriptor
Error Model
Talk to Bothous
port 46.
Return value

client
0 on success
-1 on failure
NULL on failure for routines returning pointers
I am accepting
connections.
I will speak to
Actoris port 87.
server
resulting TCP connection identified by

(Actoris:87, Bothous:46)
errno variable
CS/ECE 338
22
23
CS/ECE 338
24
Socket Creation and Setup
Functions: socket
Include file <sys/socket.h>

Create a socket
int socket (int family, int type, int protocol);
int socket (int family, int type, int

protocol);
Create a socket.
Returns file descriptor or -1. Also sets errno on failure.
family: address family (namespace)
Returns file descriptor or -1.

Bind a socket to a local IP address and port number

int bind (int sockfd, struct sockaddr* myaddr,
int addrlen);
type: style of communication

Put socket into passive state (wait for connections

rather than initiate a connection).

25
Function: bind
see RFC 1700 or
1-512
513-1023
1024-49151
= sizeof (struct sockaddr_in)
standard services (see /etc/services)

super-user only
IP address: set by kernel if value passed is INADDR_ANY,

else set by caller
port number: set by kernel if value passed is 0, else set by
caller
49152-65535
CS/ECE 338
26
ftp://ftp.isi.edu/in-notes/iana/assignments/port-numbers
addrlen: length of address structure
CS/ECE 338
Allocated and assigned by the Internet Assigned

Numbers Authority
Returns 0 on success, -1 and sets errno on failure.

sockfd: socket file descriptor (returned from socket)
myaddr: includes IP address and port number
typically 0
TCP and UDP Ports
int bind (int sockfd, struct sockaddr*

myaddr, int addrlen);
Bind a socket to a local IP address and port
number.
SOCK_STREAM for TCP (with AF_INET)

SOCK_DGRAM for UDP (with AF_INET)
protocol: protocol within family
int listen (int sockfd, int backlog);
CS/ECE 338
AF_INET for IPv4

other possibilities: AF_INET6 (IPv6), AF_UNIX or AF_LOCAL
(Unix socket), AF_ROUTE (routing)
27
CS/ECE 338
registered and controlled, also used for identity

verification
super-user only
registered services/ephemeral ports
private/ephemeral ports
28
Functions: listen
Establishing a Connection
Include file <sys/socket.h>
int listen (int sockfd, int backlog);

Put socket into passive state (wait for connections
rather than initiate a connection).
backlog: bound on length of unaccepted connection
queue (connection backlog); kernel will cap, thus better to
set high
CS/ECE 338
29
int connect (int sockfd, struct

sockaddr* servaddr, int addrlen);
Connect to another socket.
int accept (int sockfd, struct sockaddr*
cliaddr, int* addrlen);
Accept a new connection. Returns file descriptor
or -1.
CS/ECE 338
30
Functions: connect
Functions: accept
int connect (int sockfd, struct

sockaddr* servaddr, int addrlen);
int accept (int sockfd, struct sockaddr* cliaddr,

int* addrlen);
Accept a new connection.
Connect to another socket.
Returns file descriptor or -1. Also sets errno on failure.

cliaddr: IP address and port number of client (returned from
call)
addrlen: length of address structure = pointer to int set to
sizeof (struct sockaddr_in)

servaddr: IP address and port number of server
addrlen is a value-result argument:
Can use with UDP to restrict incoming datagrams

and to obtain asynchronous errors.
CS/ECE 338
the caller passes the size of the address structure, the kernel
returns the size of the clients address (the number of bytes
written)
31
CS/ECE 338
32
int write (int sockfd, char* buf, size_t

nbytes);
Write data to a stream (TCP) or connected
datagram (UDP) socket.
int sendto (int sockfd, char* buf,

size_t nbytes, int flags, struct
sockaddr* destaddr, int addrlen);
Send a datagram to another UDP socket.
Returns number of bytes written or -1.
Returns number of bytes written or -1.
int read (int sockfd, char* buf, size_t

nbytes);
Read data from a stream (TCP) or connected
int recvfrom (int sockfd, char* buf,

size_t nbytes, int flags, struct
sockaddr* srcaddr, int* addrlen);
Read a datagram from a UDP socket.
Returns number of bytes read or -1.

CS/ECE 338
Returns number of bytes read or -1.

33
CS/ECE 338
Functions: write
Functions: read
int write (int sockfd, char* buf, size_t

nbytes);
Write data to a stream (TCP) or connected
int read (int sockfd, char* buf, size_t

nbytes);
Returns number of bytes written or -1. Also sets errno on

failure.
buf: data buffer
nbytes: number of bytes to try to write
Read data from a stream (TCP) or connected

Returns number of bytes read or -1. Also sets errno on
failure.
Returns 0 if socket closed.
buf: data buffer
nbytes: number of bytes to try to read
Some reasons for failure or partial writes:

CS/ECE 338
process received interrupt or signal

kernel resources unavailable (e.g., buffers)
35
34
CS/ECE 338
36
Functions: sendto
Functions: recvfrom
int sendto (int sockfd, char* buf, size_t nbytes,

int flags, struct sockaddr* destaddr, int
addrlen);
Send a datagram to another UDP socket.
int recvfrom (int sockfd, char* buf, size_t

nbytes, int flags, struct sockaddr* srcaddr,
int* addrlen);
Read a datagram from a UDP socket.
Returns number of bytes read (0 is valid) or -1. Also sets errno
on failure.
buf: data buffer
flags: see man page for details; typically use 0
srcaddr: IP address and port number of sending socket
(returned from call)
addrlen: length of address structure = pointer to int set to
sizeof (struct sockaddr_in)
Returns number of bytes written or -1. Also sets errno on

failure.
buf: data buffer
flags: see man page for details; typically use 0
destaddr: IP address and port number of destination socket
CS/ECE 338
37
CS/ECE 338
Tearing Down a Connection
Functions: close
int close (int sockfd);
int close (int sockfd);
Close a socket.
38
Close a socket.

int shutdown (int sockfd, int howto);

Force termination of communication across a socket in
one or both directions.
Closes communication on socket in both directions.

All data sent before close are delivered to other side
(although this aspect can be overridden).
After close, sockfd is not valid for reading or

writing.
CS/ECE 338
39
CS/ECE 338
40
10
Functions: shutdown
Advanced Sockets
int shutdown (int sockfd, int howto);

Force termination of communication across a socket in one or
both directions.
Managing Multiple Connections

fork/exec: multiple server processes
pthread_create: multi-threaded server
process
(no calls): event-based server process

howto:
SHUT_RD to stop reading
SHUT_WR to stop writing
SHUT_RDWR to stop both
Detecting Data Arrival

select and poll functions
shutdown overrides the usual rules regarding duplicated

sockets, in which TCP teardown does not occur until all copies
have closed the socket.
CS/ECE 338
41
Examples
CS/ECE 338
42
server
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#define PORT 3490
/* well-known port */
#define BACKLOG 10
/* how many pending
connections queue
will hold */
Taken from Beejs Guide to Network

Programming:
http://www.ecst.csuchico.edu/~beej/guide/net/
Client-Server example using TCP

For each client
server forks new process to handle
connection
sends Hello, world
CS/ECE 338
Synchronous vs. Asynchronous

Connections
Other Socket Options
43
CS/ECE 338
44
11
server
server
main()
{
int sockfd, new_fd;
my_addr.sin_family = AF_INET; /* host byte order */

my_addr.sin_port = htons(MYPORT); /* short, network
byte order */
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
/* automatically fill with my IP (w/o Beejs bug)
*/
bzero(&(my_addr.sin_zero), 8); /* zero the struct
*/
/* listen on sock_fd, new

connection on new_fd */
struct sockaddr_in my_addr;
/* my address */
struct sockaddr_in their_addr; /* connector addr */
int sin_size;
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0))==1){
perror("socket");
exit(1);
}
CS/ECE 338
45
46
Spring 2003
server
server
if (listen(sockfd, BACKLOG) == -1) {

perror("listen");
exit(1);
}
while(1) { /* main accept() loop */
sin_size = sizeof(struct sockaddr_in);
if ((new_fd = accept(sockfd, (struct sockaddr*)
&their_addr,&sin_size)) == -1)
{
perror("accept");
continue;
}
printf("server: got connection from %s\n",
inet_ntoa(their_addr.sin_addr));
CS/ECE 338
if (bind(sockfd, (struct sockaddr *)&my_addr,

sizeof(struct sockaddr)) == -1) {
perror("bind");
exit(1);
CS/ECE}
338
Robin Kravets & Steve Lumetta, UIUC -
if (!fork()) { /* this is the child process */

if (send(new_fd,"Hello, world!\n", 14, 0)
== -1)
perror("send");
close(new_fd);
exit(0);
}
close(new_fd); /* parent doesn't need this */
/* clean up all child processes */
while(waitpid(-1,NULL,WNOHANG) > 0);
}
}
47
CS/ECE 338
48
12
client
client
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define PORT 3490
/* well-known port */
#define MAXDATASIZE 100 /* max number of bytes we
can get at once */
int main (int argc, char* argv[]){

int sockfd, numbytes;
char buf[MAXDATASIZE + 1];
struct hostent* he;
struct sockaddr_in their_addr;
/* connectors address information */
if (argc != 2) {
fprintf (stderr, usage: client hostname\n);
exit (1);
}
if ((he = gethostbyname (argv[1])) == NULL) {
/* get the host info */
perror (gethostbyname);
exit (1);
}
CS/ECE 338
CS/ECE 338
49
Structure: hostent
if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) == -1) {

perror (socket);
exit (1);
}
canonical domain name and aliases

list of addresses associated with machine
also address type and length information
their_addr.sin_family = AF_INET; /* interpd by host */

their_addr.sin_port = htons (PORT);
their_addr.sin_addr = *((struct in_addr*)he->h_addr);
bzero (&(their_addr.sin_zero), 8);
/* zero rest of struct */
if (connect (sockfd, (struct sockaddr*)&their_addr,
sizeof (struct sockaddr)) == -1) {
perror (connect);
exit (1);
}
struct hostent {
char* h_name;
/* official name of host */
char** h_aliases;
/* NULL-terminated alias list */
int h_addrtype
/* address type (AF_INET) */
int h_length;
/* length of addresses (4B) */
char** h_addr_list; /* NULL-terminated address list */
#define h_addr h_addr_list[0];/* backward-compatibility */
};
50
client
The hostent data structure (from

/usr/include/netdb.h)
CS/ECE 338
51
CS/ECE 338
52
13
client
Summary
if ((numbytes = recv (sockfd, buf, MAXDATASIZE, 0))

== -1) {
perror (recv);
exit (1);
}
TCP connection setup handshake

annotated with socket API calls
client-server interaction
buf[numbytes] = \0;
printf (Received: %s, buf);
close (sockfd);
return 0;
TCP version
UDP version
CS/ECE 338
53
TCP Connection Setup
CS/ECE 338
54
TCP Connection Example
client
server
client
server
socket
socket
socket
connect
Synch
roniz
e
AC K
socket
bind
listen
connect
listen
write
accept
(SYN
)J
K,
+1
SY N
CK) J
dge (A
owle
n
k
c
a
connect completes
bind
connection moved to
complete queue
read
write
read
K+1
close
close
connection added to
incomplete queue
accept
CS/ECE 338
55
CS/ECE 338
56
14
UDP Connection Example

client
Framing
Goal
server
Framing messages on a byte stream
socket
socket
Given a TCP message stream, how can we

pass logical messages?
bind
sendto
Note:
recvfrom
read may return partial or multiple messages
sendto
Questions:
recvfrom
How can we determine the end of a message?
close
Hint
string storage in C and Pascal
format strings with printf
CS/ECE 338
57
CS/ECE 338
58
Framing Problem
Approach
Think about the problem for a minute or two
Introduce yourself to 2-3 people near you
(form groups of 3-4)
Discuss the problem and agree on a solution
Pick a representative
Well ask a couple groups to present their
answers
CS/ECE 338
59
15

Introduction To Unix Network Programming Network Programming

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introduction To Unix Network Programming Network Programming

Uploaded by

Copyright:

Available Formats

Network Programming

Introduction to Unix Network

IP, TCP, UDP, etc

Reference: Stevens Unix

API - application programming interface

Why focus on the Internet?

Robin Kravets & Steve Lumetta, UIUC Spring 2003

reasonably simple and elegant, Unix interface

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Direction and Principles

learn to use Internet for

Robin Kravets & Steve Lumetta, UIUC Spring 2003

learn to build network from ground

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Network Programming with

Stevens 2nd ed., Ch. 1-6 or 1st ed., Ch. 1-3, 6

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Client sends requests

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Transmission Control Protocol (TCP)

OSI Transport Layer

Byte stream (interpreted by application)

Client and server categories are not disjoint

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Set up connection before communicating

Robin Kravets & Steve Lumetta, UIUC Spring 2003

TCP Connection Establishment

Reliable Data Transfer

Guarantees delivery of all data

Sequenced Data Transfer

Guarantees in-order delivery of data

Regulated Data Flow

Server listens for

Monitors network and adjusts transmission appropriately

Full-Duplex byte stream

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Time flows down

TCP Connection Termination

Either client or server

OSI Transport Layer

User Datagram Protocol Service

Time flows down

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Addresses and Data

Internet domain names

Datagram (variable length packet)

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Byte Ordering Functions

Big Endian vs. Little Endian

Big Endian (Sun, SGI, HP):

Network Byte Order = Big Endian

Robin Kravets & Steve Lumetta, UIUC Spring 2003

long (32-bit) translation

Robin Kravets & Steve Lumetta, UIUC Spring 2003

Socket Address Structure

All binary values are network byte ordered

struct hostent* gethostbyname (const char*

TCP or UDP address:

struct hostent* gethostbyaddr (const char*