TCP/IP Application Interface

Loosely specified for TCP/IP

UC-Berkeley:

UNIX sockets Microsoft: Windows Sockets AT&T System V: TLI

Subset of system calls

Existing UNIX File IOs

Basic file IO operations
open

-- prepare a device or file for IO close -- terminate use of opened device or file read -- obtain data from from an open file or device write -- store data into an open file or device seek -- move to a specific position in a file or device ioctl -- control or configure a device

Is UNIX File IO Good Enough?

It provides a basic model of IO access

Not sufficient! network addresses client vs. server different transport layers

Socket Descriptors
Treat as traditional file descriptors File descriptor table augmented A lot more complicated to fill in the data structure for socket descriptors
Specifying remote end and local end Is the socket listening or connecting Will we use TCP or UDP?

Socket Endpoint Address

Generic endpoint specification

Struct sockaddr { /* struct to hold address */ u_char sa_len; /* total length */ u_short sa_family; /* address family */ char sa_data[14]; /* value of address */ }

TCP/IP protocol endpoint specification Address family: AF_INET All TCP/IP applications should use sockaddr_in instead of the generic one

Struct sockaddr_in { /* struct to hold address */ u_char sa_len; /* total length */ u_short sa_family; /* address family */ u_short sin_port; /* protocol port number */ struct in_addr sin_addr; /* IP address */ char sin_zero[8]; /* unused */ }
Server OS chooses based on routing

AF_INET AF_INET6 AF_UNIX AF_X25

Well-Known or Ephemeral

More Details
Network byte order / Host byte order Why does it matter? Protocol port field of a sockaddr_in structure uses network byte order Utility functions: htons, ntohs, htonl, ntohl Symbolic constants (e.g. AF_INET)

#include <sys/types.h> #include <sys/socket.h>

7

Server
socket() bind() listen() accept()

TCP Client Server

well-known port

Client
socket()

(Block until connection)

Handshake
Data (request)

connect() write()

read() write() read() close() Data (reply)

read()
End-of-File close()

TCP Client
PF_INET PF_INET6 PF_UNIX PF_X25 STREAM DGRAM RAW 0, used by RAW socket

family port
ephemeral port ip addr (routing)

sd = socket (family, type, protocol); sd = connect (sd, server_addr, addr_len);

three way handshaking

addr

CONNECT actions 1. socket is valid 2. fill remote endpoint addr/port 3. choose local endpoint add/port 4. initiate 3-way handshaking

write (sd, *buff, mbytes);

read (sd, *buff, mbytes); close (sd);

Server PORT# IP-ADDR

disconnect sequence

TCP Server
family port addr
bind port # MASTER SOCKET

sd = socket (family, type, protocol);

bind (sd, *server_addr, len);

listen (sd, backlog);

well-known port # INADDR_ANY

1. Turn sd from active to passive 2. Queue length

family port addr

SLAVE SOCKET

ssd = accept (sd, *cliaddr, *len);

three way handshaking

read (ssd, *buff, mbytes);

closes socket for R/W non-blocking attempts to send unsent data socket option SO_LINGER block until data sent

write (ssd, *buff, mbytes);

disconnect sequence

close (ssd);

10

TCP Server
family port family

addr

msock

liste n

accep t

client port/addr

port

addr

ssock read, write

bind

port

three way handshaking

11

Create a socket

socket()

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

PF_INET (IPv4), PF_INET6 (IPv6), PF_LOCAL (local Unix), PF_ROUTE (access to routing tables), PF_KEY (encryption) type is one of SOCK_STREAM (TCP), SOCK_DGRAM (UDP) SOCK_RAW (for special IP packets, PING, etc. Must be root) setuid bit (-rws--x--x root 2002 /bin/ping*) protocol is 0 (used for some raw socket options) upon success returns socket descriptor Integer, like file descriptor Return -1 if failure

family is one of

12

Connect to server
int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen);
sockfd is socket descriptor from socket() servaddr is a pointer to a structure with:

connect()

port number and IP address

client doesnt need bind()

addrlen is length of structure

OS will pick ephemeral port

must be specified (unlike bind())

returns socket descriptor if ok, -1 on error

13

Assign a local protocol address (name) to a socket

bind()

int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen);

sockfd is socket descriptor from socket() myaddr is a pointer to address struct with:

port number and IP address

if port is 0, then

if IP address is wildcard: INADDR_ANY (multiple net cards)

host kernel will choose IP address INADDR_ defined in <netinet/in.h> INADDR_ in host byte order => htonl(INADDR_ANY)

host will pick ephemeral port (very rare for server) How do you know assigned port number?

addrlen is length of structure returns 0 if ok, -1 on error

EADDRINUSE (Address already in use)

14

bind()
address and port
process specifies
IP address port

result
kernel chooses IP addr and port

wildcard

wildcard
local IP addr local IP addr

nonzero
0 nonzero

kernel chooses IP, process specifies port

process specifies IP, kernel chooses port process specifies IP and port

15

Change socket state to TCP server

int listen(int sockfd, int backlog);
Sockets default to active (for a client) change to passive so OS will accept connection sockfd is socket descriptor from socket()

listen()

backlog is maximum number of connections that

the server should queue for this socket

historically 5 rarely above 15 on a even moderate Web server!

16

accept()
Return next completed connection

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

sockfd is socket descriptor from socket() cliaddr and addrlen return protocol address from

client returns brand new descriptor, created by OS if used with fork(), can create concurrent server

17

read() and write()

int read (int sockfd, void *buff, size_t mbytes); int write (int sockfd, void *buff, size_t mbytes);
Reading and writing packets Both are system calls

18

close()
Close socket for use
int close(int sockfd);

closes socket for reading/writing returns (doesnt block) attempts to send any unsent data socket option SO_LINGER
Returns -1 if error
block until data sent or discard any remaining data

sockfd is socket descriptor from socket()

19

UDP Client Server

Server
socket()

Client
socket()
well-known port

bind()
recvfrom()

sendto (sd, *buff, mbytes, flag, to, len);

(Block until receive datagram) Data (request)

receivefrom (sd, *buff,
mbytes, flags, *from, *len);

sendto() Data (reply)

close()
20

UDP sending and receiving

sendto(), recvfrom()
int recvfrom(int sockfd, void *buff, size_t mbytes, int flags, struct sockaddr *from, socklen_t *addrlen); int sendto(int sockfd, void *buff, size_t mbytes, int flags, const struct sockaddr *to, socklen_t addrlen);

Similar to read() and write() but need to

specify remote socket address

recvfrom fills in address of where packet came from sento requires address of where sending packet to

21

Connect with UDP

Record address and port of peer datagrams to/from others are not allowed does not do three way handshake, or connection connect a misnomer, here. Should be setpeername() Use send() instead of sendto() Use recv() instead of recvfrom() Can change connect or unconnect by repeating

connect() call

22

recv() and send()

int recv(int mbytes, int int send(int mbytes, int sockfd, void *buff, size_t flags); sockfd, void *buff, size_t flags);
flags

Used for connected sockets (both UDP and TCP)

Same as read() and write() but for

MSG_DONTWAIT (this send non-blocking) MSG_OOB (out of band data) MSG_PEEK (look, but dont remove) MSG_WAITALL (dont give me less than max) MSG_DONTROUTE (bypass routing table)

23