ICS 2305 : SYSTEMS PROGRAMMING
NETWORKING
Karanja Mwangi
Lesson objective
At the end of this class you will
Refresh on Networking concepts and how they relate to
systems programming
Able to build your client and server (TCP) applications in C
Use C programs to interact with Ports
client and the server on the same
Same LAN local network
The client and the server may be in
different LANs, with both LANs
connected to a Wide Area Network
TCP/IP (WAN) by means of routers.
Network Layering
7 Application Application
6 Presentation Presentation
5 Session Session
4 Transport Transport
3 Network Network Network
2 Data link Data link Data link
1 Physical Physical Physical
Client Server Communication TCP and UDP
The main transport protocols TCP and UDP
enables communication between network
applications
UDP is a connectionless protocol (RFC 768)
built on top of IPv4 and IPv6.
Determines the destination address and port and
send your data packet!
Packets or Datagrams may be dropped if the
network is congested. Packets may be duplicated or
arrive out of order.--- No guarantee on good delivery
Client Server Communication-TCP
TCP is a connection-based protocol that is built on
top of IPv4 and IPv6 ("TCP/IP" or "TCP over IP").
source IP address and source port number.
TCP -Manages the packets, re-arranging out-of-
order packets and changing the rate at which
packets are sent, removes the duplicate etc
TCP manages packets through 3 handshake SYN,
SYN-ACK, and ACK
For more on handshaking read
https://www.inetdaemon.com/tutorials/internet/tcp/
3-way_handshake.shtml
• RFC 793, RFC 1323, RFC 2581 and RFC
3390.
User Datagram Protocol(UDP): An Analogy
UDP Postal Mail
Postal Mail
• Single socket to receive • Single
Single mailbox
mailbox to letters
to receive
•
messages receive messages
Not very reliable
• No guarantee of delivery • Not necessarily in-order delivery
• Not necessarily in-order delivery
• Unreliable
Letters sent independently
• Datagram – independent packets • Not necessarily
Must address in-
each reply
• Must address each packet order delivery
Each letter is
independent
Must address each
reply
Example UDP applications
Multimedia, voice over IP
8
Transmission Control Protocol (TCP): An
Analogy
TCP Telephone Call
Reliable – guarantee delivery • Guaranteed delivery
Byte stream – in-order delivery • In-order delivery
Connection-oriented – single • Connection-oriented
socket per connection • Setup connection followed by
Setup connection followed by conversation
data transfer
Example TCP applications
Web, Email, Telnet
9
PORTS (IPv4 vs. IPv6)
Port - A 16-bit number that identifies the application
process that receives an incoming message.
Local hosts for IPv4 address is 127.0.0.1
Local hosts for IPv6 address is IPv6
is 0:0:0:0:0:0:0:1 shortened form is ::1
Both are stored in an IP address struct of appropriate
type(library functions in C usually hide them)
in_addr for IPv4
in6_addr for IPv6
Port numbers divided into three categories
• Well Known Ports 0-1023
• Registered Ports 1024-49151 by the IANA (Internet
Assigned Numbers Authority), and represent second tier common
ports (socks (1080), WINS (1512), kermit (1649), https (443))
• Dynamic/Private Ports 49152-65535 ephemeral ports, available
for temporary client usage
Well Known Ports- Reserved ports
Reserved ports or well-known ports (0 to 1023)
– Standard ports for well-known applications.
– See /etc/services file on any UNIX machine for
listing of services on reserved ports.
•1 TCP Port Service Multiplexer
• 7 Echo Server
• 20 File Transfer Protocol (FTP) Data
• 21 FTP Control
• 23 Telnet
• 25 Simple Mail Transfer (SMT)
• 43 Who Is
• 69 Trivial File Transfer Protocol (TFTP)
• 80 HTTP
Using Ports to Identify Services
Server host 181.66.37.53
Client host Service request for Web server
181.66.37.53 (port 80)
:80
Client Kernel
(i.e., Web server)
Echo server
(port 7)
Service request for Web server
181.66.37.53 (port 80)
Client :7 Kernel
(i.e., echo server)
Echo server
(port 7)
The Socket----Socket as a File
a socket is like a file: you can read/write to/from
the network just like you would a file
For connection-oriented communication (e.g.
TCP)
• servers (passive open) do listen and accept
operations
• clients (active open) do connect operations
• both sides can then do read and/or write (or
send and recv)
• then each side must close etc
Connectionless (e.g. UDP): uses sendto and
recvfrom
Sockets And Socket Libraries
In Unix, socket procedures (e.g. listen, connect,
etc.) are system calls
part of the operating system
when you call the function, control moves to the
operating system, and you are using “system” CPU
time
Sockets And Socket Libraries
On some operating systems, socket procedures are
not part of the OS e.g in Windows
instead, they are implemented as a library,
linked into the application object code (e.g. a
DLL under Windows)
Typically, this DLL makes calls to similar
procedures that are part of the native
operating system.
The Most Popular Socket Interface
The Berkeley Sockets API
Originally developed as part of BSD Unix
BSD = Berkeley Software Distribution
• API=Application Program Interface
Now the most popular API for C/C++
programmers writing applications over TCP/IP
• Also emulated in other languages: Perl,
Tcl/Tk, Python etc.
• Also emulated on other operating systems:
Windows, etc.
Sockets and Data types
Data types
int8_t signed 8-bit integer
int16_t signed 16-bit integer
int32_t signed 32-bit integer
uint8_t unsigned 8-bit integer
uint16_t unsigned 16-bit integer
uint32_t unsigned 32-bit integer
More on Data types
Internet Address Structure
struct in_addr
{
in_addr_t s_addr;
};
Socket address structure
Socket Structure
Sockets
Sockets provide a standard interface between
network and application –they are Independent of
network type:
Commonly used with TCP/IP and UDP/IP,
Two types of socket:
Stream – provides a virtual circuit service
Datagram – delivers individual packets
Socket Types
Byte Ordering
two ways to store two bytes in memory: with the lower-
order byte at the starting address (little-endian byte
order) or with the high-order byte at the starting address
(big-endian byte order). They are called host byte order.
• an Intel processor stores the 32-bit integer as four consecutives
bytes in memory in the order 1-2-3-4, where 1 is the most
significant byte. IBM PowerPC processors would store the integer
in the byte order 4-3-2-1.
Big-Endian (RISC-Sparc)
Little-Endian (Intel)
Low Byte Address A High Byte
High Byte Address A+1 Low Byte
Byte Order and Networking
Suppose a Big Endian machine sends a 16 bit integer with the
value 2:
0000000000000010
A Little Endian machine will understand the number as 512:
0000001000000000
How do two machines with different byte-orders communicate?
Using network byte-order
Network byte-order = big-endian order
network byte-order conversion
The following functions are used for conversion to the
network order
The htons(), htonl(), ntohs(), and ntohl() Functions
#include <netinet/in.h>
uint16_t htons(uint16_t host16bitvalue);
uint32_t htonl(uint32_t host32bitvalue);
uint16_t ntohs(uint16_t net16bitvalue);
uint32_t ntohl(uint32_t net32bitvalue);
first two return the value in network byte order (16 and 32
bit, respectively). The latter return the value in host byte
order (16 and 32 bit, respectively).
Network Byte Order
Conversion of application-level data is left up to the
presentation layer.
Lower level layers communicate using a fixed byte order
called network byte order for all control data.
TCP/IP mandates that big-endian byte ordering be used for
transmitting protocol information
All values stored in a sockaddr_in must be in network
byte order.
sin_port a TCP/IP port number.
sin_addr an IP address.
Network Byte Order Functions
Several functions are provided to allow conversion
between host and network byte ordering,
Conversion macros (<netinet/in.h>)
to translate 32-bit numbers (i.e. IP addresses):
• unsigned long htonl(unsigned long hostlong);
• unsigned long ntohl(unsigned long netlong);
to translate 16-bit numbers (i.e. Port numbers):
• unsigned short htons(unsigned short hostshort);
• unsigned short ntohs(unsigned short netshort);
Byte-Order Transformation
Address Transformation
Byte-Manipulation Functions
In network programming, we often need to initialize a
field, copy the contents of one field to another, or compare
the contents of two fields.
Cannot use string functions (strcpy, strcmp,
…) which assume null character termination.
Creating a Socket: The socket() Function
#include <sys/types.h>
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
domain is one of the Protocol Families (AF_INET,
AF_UNIX, etc.)
type defines the communication protocol semantics,
usually defines either:
SOCK_STREAM: connection-oriented stream (TCP)
SOCK_DGRAM: connectionless, unreliable (UDP)
protocol specifies a particular protocol, just set this to
0 to accept the default
Example int sockfd = socket (AF_INET, SOCK_STREAM, 0);
Socket Primitives ---in the library
Creating a Socket-2:The socket() Function
Programming Sockets
The connect() Function
The connect() function is used by a TCP client to establish
a connection with a TCP server
#include <sys/socket.h>
int connect (int sockfd, const struct sockaddr *servad
dr, socklen_t addrlen);
where sockfd is the socket descriptor returned by the socket function.
The function returns 0 if the it succeeds in establishing a connection
(i.e., successful TCP three-way handshake, -1 otherwise.
The bind() Function
The bind() assigns a local protocol address to a socket.
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *servaddr, socklen_t addrl
en);
where sockfd is the socket descriptor, servaddr is a pointer to
a protocol-specific address and addrlen is the size of the
address structure.
bind() returns 0 if it succeeds, -1 on error.
The bind() Function-2 example in IPV4
use of generic socket address sockaddr requires that any
calls to these functions must cast the pointer to the
protocol-specific address structure
struct sockaddr_in serv; /* IPv4 socket address structure */
bind(sockfd, (struct sockaddr*) &serv, sizeof(serv))
A process can bind a specific IP address to its socket: for a TCP
client, this assigns the source IP address that will be used for IP
datagrams sent on the sockets. For a TCP server, this restricts the
socket to receive incoming client connections destined only to
that IP address.
TCP client does not bind an IP address to its socket. The kernel chooses
the source IP socket to be connected, based on the outgoing interface
that is used. If a TCP server does not bind an IP address to its socket,
the kernel uses the destination IP address of the incoming packets as the
server’s source address.
The listen() Function
The listen() function converts an unconnected socket into a
passive socket, indicating that the kernel should accept
incoming connection requests directed to this socket.
#define _OE_SOCKETS
#include <sys/socket.h>
int listen(int socket, int backlog);
Where
Backlog Defines the maximum length for the queue of
pending connections.
The function listen() return 0 if it
succeeds, -1 on error.
The accept() Function
used by a server to accept a connection request from a
client
#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *cliaddr,
socklen_t *addrlen);
sockfd is a new file descriptor that is connected to the client that
called the connect()
cliaddr and addrlen arguments are used to return the protocol
address of the client
The send() Function
Remember Socket as a file ? We can use read and write to
communicate with a socket as long as it is connected.
If we need to specify other options , other than read and
write plainly , we use other functions. E.g here send() is
similar to write() but allows to specify some options.
buf and nbytes have the same meaning as they have
with write. flags is used to specify how we want the data
to be transmitted
#include <sys/socket.h>
ssize_t send(int sockfd, const void *buf, size_t nbytes, i
nt flags);
The function returns the number
of bytes if it succeeds, -1 on error
The receive() Function
The recv() function is similar to read(), but allows to
specify some options
#include <sys/socket.h>
ssize_t recv(int sockfd, void *buf, size_t nbytes, int flags);
The function returns the length of
the message in bytes, 0 if no
messages are available and peer
had done an orderly shutdown, or
-1 on error.
The close() Function
close() function is used to close a socket and terminate a
TCP socket. It returns 0 if it succeeds, -1 on error.
#include <unistd.h>
int close(int sockfd);
More on Networking and Sockets
functions getaddrinfo() and getnameinfo() convert do
main names, hostnames, and IP addresses between
human-readable text representations and structured
binary formats for the operating system's networking API.
Working Exercises
To be shared in the Piazza
Sources
https://beej.us/guide/bgnet/html//index.html
https://academy.nordicsemi.com/courses/cellular-iot-
fundamentals/lessons/lesson-3-cellular-
fundamentals/topic/lesson-3-exercise-1/
https://www.youtube.com/watch?v=WdE3PCHSBy8
https://people.cs.rutgers.edu/~pxk/rutgers/notes/sockets/
