C6.

Objectives
Network programming Client-server model Sockets interface Socket primitives Example code for echoclient and echoserver

Client/sever model
Client asks (request) server provides (response) Typically: single server - multiple clients The server does not need to know anything about the client even that it exists The client should always know something about the server at least where it is located
1. Client sends request
Client process Server process Resource

4. Client handles response

3. Server sends response

2. Server handles request

Note: clients and servers are processes running on hosts (can be the same or different hosts).

Sockets as means for inter-process communication (IPC)

Internet Connections (TCP/IP)

Address the machine on the network
By IP address

Address the process

By the port-number
application layer application layer

The pair of IP-address + port makes up a socket-address

Client socket address
128.2.194.242:3479

Client Process Socket OS network stack

transport layer (TCP/UDP) network layer (IP) link layer (e.g. ethernet) physical layer

Server Process Socket

transport layer (TCP/UDP) network layer (IP) link layer (e.g. ethernet)

Server socket address

208.216.181.15:80 Server (port 80) Server host address 208.216.181.15

Client

Internet

Connection socket pair (128.2.194.242:3479, 208.216.181.15:80)

physical layer

The interface that the OS provides to its networking subsystem

Client host address 128.2.194.242

Note: 3479 is an ephemeral port allocated by the kernel

Note: 80 is a well-known port associated with Web servers

Clients
Examples of client programs
Web browsers, ftp, telnet, ssh

Using Ports to Identify Services

Server host 128.2.194.242 Client host Service request for 128.2.194.242:80 (i.e., the Web server) Web server (port 80) Kernel Echo server (port 7)

How does a client find the server?

The IP address in the server socket address identifies the host The (well-known) port in the server socket address identifies the service, and thus implicitly identifies the server process that performs that service. Examples of well known ports
Port Port Port Port 7: Echo server 23: Telnet server 25: Mail server 80: Web server

Client

Client

Service request for 128.2.194.242:7 (i.e., the echo server)

Web server (port 80) Kernel Echo server (port 7)

Page 1

Servers
Servers are long-running processes (daemons).
Created at boot-time (typically) by the init process (process 1) Run continuously until the machine is turned off. What is a socket?

Sockets
To the kernel, a socket is an endpoint of communication. To an application, a socket is a file descriptor that lets the application read/write from/to the network.
Remember: All Unix I/O devices, including networks, are modeled as files.

Each server waits for requests to arrive on a wellknown port associated with a particular service.
Port 7: echo server See /etc/services for a Port 23: telnet server comprehensive list of the Port 25: mail server services available on a Linux machine. Port 80: HTTP server Other applications should choose between 1024 and 65535

Clients and servers communicate with each by reading from and writing to socket descriptors. The main distinction between regular file I/O and socket I/O is how the application opens the socket descriptors.

Socket Programming Cliches

Network Byte Ordering
Network is big-endian, host may be big- or little-endian Functions work on 16-bit (short) and 32-bit (long) values htons() / htonl() : convert host byte order to network byte order ntohs() / ntohl(): convert network byte order to host byte order Use these to convert network addresses, ports,
struct sockaddr_in serveraddr; /* fill in serveraddr with an address */ /* Connect takes (struct sockaddr *) as its second argument */ connect(clientfd, (struct sockaddr *) &serveraddr, sizeof(serveraddr));

Socket primitives
SOCKET: int socket(int domain, int type, int protocol);

domain := AF_INET (IPv4 protocol) type := (SOCK_DGRAM or SOCK_STREAM ) protocol := 0 (IPPROTO_UDP or IPPROTO_TCP) returned: socket descriptor (sockfd), -1 is an error

BIND: int bind(int sockfd, struct sockaddr *my_addr, int addrlen);

sockfd - socket descriptor (returned from socket()) my_addr: socket address, struct sockaddr_in is used addrlen := sizeof(struct sockaddr)
struct sockaddr_in { unsigned short sin_family; unsigned short sin_port; struct in_addr sin_addr; unsigned char sin_zero[8]; };

Structure Casts
You will see a lot of structure casts

/* /* /* /*

address family (always AF_INET) */ port num in network byte order */ IP addr in network byte order */ pad to sizeof(struct sockaddr) */

LISTEN : int listen(int sockfd, int backlog); backlog: how many connections we want to queue ACCEPT: int accept(int sockfd, void *addr, int *addrlen); addr: here the socket-address of the caller will be written returned: a new socket descriptor (for the temporal socket) CONNECT: int connect(int sockfd, struct sockaddr *serv_addr, int addrlen); //used by TCP client
parameters are same as for bind()

SEND (DGRAM-style): int sendto(int sockfd, const void * msg, int len, int flags, const struct sockaddr *to, int tolen); msg: message you want to send len: length of the message flags := 0 to: socket address of the remote process tolen: = sizeof(struct sockaddr) returned: the number of bytes actually sent RECEIVE (DGRAM-style): int recvfrom(int sockfd, void *buf, int len, unsigned int flags, struct sockaddr *from, int *fromlen); buf: buffer to receive the message len: length of the buffer (dont give me more!) from: socket address of the process that sent the data fromlen:= sizeof(struct sockaddr) flags := 0 returned: the number of bytes received CLOSE: close (socketfd);

SEND: int send(int sockfd, const void *msg, int len, int flags); msg: message you want to send len: length of the message flags := 0 returned: the number of bytes actually sent RECEIVE: int recv(int sockfd, void *buf, int len, unsigned int flags); buf: buffer to receive the message len: length of the buffer (dont give me more!) flags := 0 returned: the number of bytes received

Page 2

Client+server: connectionless
CREATE BIND

EchoClient.c #includes
#include <stdio.h> /* for printf() and fprintf() */ #include <sys/socket.h> /* for socket(), connect(), sendto(), and recvfrom() */ #include <arpa/inet.h> /* for sockaddr_in and inet_addr() */ #include <stdlib.h> /* for atoi() and exit() */ #include <string.h> /* for memset() */ #include <unistd.h> /* for close() */ #define ECHOMAX 255 /* Longest string to echo */

SEND RECEIVE SEND CLOSE

EchoClient.c -variable declarations

int main(int argc, char *argv[]) { int sock; /* Socket descriptor */ struct sockaddr_in echoServAddr; /* Echo server address */ struct sockaddr_in fromAddr; /* Source address of echo */ unsigned short echoServPort =7; /* Echo server port */ unsigned int fromSize; /* address size for recvfrom() */ char *servIP=172.24.23.4; /* IP address of server */ char *echoString=I hope this works; /* String to send to echo server */ char echoBuffer[ECHOMAX+1]; /* Buffer for receiving echoed string */ int echoStringLen; /* Length of string to echo */ int respStringLen; /* Length of received response */

EchoClient.c - creating the socket and sending

/* Create a datagram/UDP socket */ sock = socket(AF_INET, SOCK_DGRAM, 0); /* Construct the server address structure */ memset(&echoServAddr, 0, sizeof(echoServAddr)); /* Zero out structure */ echoServAddr.sin_family = AF_INET; /* Internet addr family */ echoServAddr.sin_addr.s_addr = htonl(servIP); /* Server IP address */ echoServAddr.sin_port = htons(echoServPort); /* Server port */ /* Send the string to the server */ sendto(sock, echoString, echoStringLen, 0, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr); /* Recv a response */

EchoClient.c receiving and printing

fromSize = sizeof(fromAddr); recvfrom(sock, echoBuffer, ECHOMAX, 0, (struct sockaddr *) &fromAddr, &fromSize); /* Error checks like packet is received from the same server*/ /* null-terminate the received data */ echoBuffer[echoStringLen] = '\0'; printf("Received: %s\n", echoBuffer); /* Print the echoed arg */ close(sock); exit(0); } /* end of main () */

EchoServer.c
int main(int argc, char *argv[]) { int sock; /* Socket */ struct sockaddr_in echoServAddr; /* Local address */ struct sockaddr_in echoClntAddr; /* Client address */ unsigned int cliAddrLen; /* Length of incoming message */ char echoBuffer[ECHOMAX]; /* Buffer for echo string */ unsigned short echoServPort =7; /* Server port */ int recvMsgSize; /* Size of received message */ /* Create socket for sending/receiving datagrams */ sock = socket(AF_INET, SOCK_DGRAM, 0); /* Construct local address structure */ memset(&echoServAddr, 0, sizeof(echoServAddr)); /* Zero out structure */ echoServAddr.sin_family = AF_INET; /* Internet address family */ echoServAddr.sin_addr.s_addr = htonl(172.24.23.4); echoServAddr.sin_port = htons(echoServPort); /* Local port */ /* Bind to the local address */ bind(sock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr);

Page 3

for (;;) /* Run forever */ { cliAddrLen = sizeof(echoClntAddr); /* Block until receive message from a client */ recvMsgSize = recvfrom(sock, echoBuffer, ECHOMAX, 0, (struct sockaddr *) &echoClntAddr, &cliAddrLen); printf("Handling client %s\n", inet_ntoa(echoClntAddr.sin_addr)); /* Send received datagram back to the client */ sendto(sock, echoBuffer, recvMsgSize, 0, (struct sockaddr *) &echoClntAddr, sizeof(echoClntAddr); }

Client+server: connection-oriented
BIND SOCKET LISTEN CONNECT TCP three-way handshake ACCEPT

SEND

RECEIVE

SEND

} /* end of main () */

RECEIVE

CLOSE

Concurrent server

HTTP
Client

HTTP conversation
Server OK I would like to open a connection GET <file location> Send page or error message Display response Close connection OK

HTML: hypertext markup language

Definitions of tags that are added to Web documents to control their appearance

HTTP: hypertext transfer protocol

The rules governing the conversation between a Web client and a Web server

HTTP is the set of rules governing the format and content of the conversation between a Web client and server

HTTP conversation
C:\telnet aut.unitbv.ro 80 GET /aut/bti/index.html [ENTER] [ENTER] Html code here To activate local echo, use: Ctrl + ] set localecho

Email POP3
Used in conjunction with an SMTP Host
SMTP Host sends and receives e-mail for remote users, POP allows users to retreive their mail from the host. SMTP stores mail for unconnected hosts

RFC 1730 TCP Port 110

Page 4

POP3
protocol is relatively simple
connect to port 110 of remote host
read back a response check for OK or ERR over and over again
Commands

POP3 - Commands
USER name
terminate with <crlf> identifies the user/mail drop name

PASS string
user password usually the same as the users logon password

close the connection

STAT
request number of messages on server and size of mail drop

LIST
return a list <crlf> of all msgs on server
format msg size

Auth

Auth

Transaction

Update

LIST [msg_no]
request size of msg_no
format msg_no size

USER

RETR msg_no
PASS QUIT
return the message identified by msg_no

POP3 - Commands
DELE msg_no
delete msg_no from server happens in UPDATE State

POP3 - Conversation
C:\telnet mail.unitbv.ro 110 +OK UNITBV.RO POP server

NOOP
nothing except a positive reply from server

user <username> pass <userpass>

+OK <username> has 3 mail messages

RSET
reset all deletions pending on server

list
1 144058 2 3707 3 448431

QUIT
quit session, UPDATE, enter AUTH1 State

retr 2
..

quit

Page 5