Socket programming in C

Socket programming
Goal: learn how to build client/server application that
communicate using sockets
Socket API socket
• introduced in BSD4.1 UNIX, a host-local,
1981 application-created,
OS-controlled interface
• explicitly created, used, released (a “door”) into which
by apps application process can
• client/server paradigm both send and
receive messages to/from
• two types of transport service another application
via socket API: process
– unreliable datagram
– reliable, byte stream-oriented
 Socket-programming using TCP
Socket: a door between application process and end-
end-transport protocol (UDP or TCP)
TCP service: reliable transfer of bytes from one
process to another
controlled by
controlled by process application
application process
developer
developer socket socket
controlled by TCP with TCP with controlled by
buffers, operating
operating buffers, internet system
system variables variables

host or host or
server server
 Socket programming with TCP
Client must contact server
• server process must first be • When contacted by client,
running server TCP creates new
• server must have created socket socket for server process to
(door) that welcomes client’s communicate with client
contact – allows server to talk
with multiple clients
Client contacts server by:
– source port numbers
• creating client-local TCP
used to distinguish
socket clients (more in Chap 3)
• specifying IP address, port application viewpoint
number of server process
TCP provides reliable, in-order
• When client creates socket: transfer of bytes (“pipe”)
client TCP establishes between client and server
connection to server TCP
 Stream jargon
• A stream is a sequence of
characters that flow into
or out of a process.
• An input stream is
attached to some input
source for the process, eg,
keyboard or socket.
• An output stream is
attached to an output
source, eg, monitor or
socket.
 Socket programming with TCP
keyboard monitor

Example client-server app:

1) client reads line from

inFromUser
input
standard input stream

Client
(inFromUser stream) , Process
process
sends to server via socket
(outToServer stream)
2) server reads line from socket

inFromServer
3) server converts line to

outToServer
output input
stream stream

uppercase, sends back to

client client
clientSocket
TCP
socket TCP
4) client reads, prints modified socket

line from socket to network from network

(inFromServer stream)
 Client/server socket interaction: TCP
Server (running on hostid, port x) Client
create socket,
port=x, for
incoming request:
welcomeSocket =
ServerSocket()

TCP create socket,

wait for incoming
connection request connection setup connect to hostid, port=x
connectionSocket = clientSocket =
welcomeSocket.accept() Socket()

send request using

read request from clientSocket
connectionSocket

write reply to
connectionSocket read reply from
clientSocket
close
connectionSocket close
clientSocket
Example: C client (TCP)
/* client.c */
void main(int argc, char *argv[])
{
struct sockaddr_in sad; /* structure to hold an IP address */
int clientSocket; /* socket descriptor */
struct hostent *ptrh; /* pointer to a host table entry */

char Sentence[128]; Create client socket,

char modifiedSentence[128]; connect to server

host = argv[1]; port = atoi(argv[2]);

clientSocket = socket(PF_INET, SOCK_STREAM, 0);

memset((char *)&sad,0,sizeof(sad)); /* clear sockaddr structure */
sad.sin_family = AF_INET; /* set family to Internet */
sad.sin_port = htons((u_short)port);
ptrh = gethostbyname(host); /* Convert host name to IP address */
memcpy(&sad.sin_addr, ptrh->h_addr, ptrh->h_length); connect(clientSocket,
(struct sockaddr *)&sad, sizeof(sad));
 Example: C client (TCP), cont.
Get
input stream gets(Sentence);
from user

Send line n=write(clientSocket, Sentence, strlen(Sentence)+1);

to server

Read line n=read(clientSocket, modifiedSentence, sizeof(modifiedSentence));

from server

printf("FROM SERVER: %s\n”,modifiedSentence);

Close close(clientSocket);
connection
}
Example: C server (TCP)
/* server.c */
void main(int argc, char *argv[])
{
struct sockaddr_in sad; /* structure to hold an IP address */
struct sockaddr_in cad;
int welcomeSocket, connectionSocket; /* socket descriptor */
struct hostent *ptrh; /* pointer to a host table entry */

char clientSentence[128]; Create welcoming socket at port

char capitalizedSentence[128]; &
Bind a local address
port = atoi(argv[1]);

welcomeSocket = socket(PF_INET, SOCK_STREAM, 0);

memset((char *)&sad,0,sizeof(sad)); /* clear sockaddr structure */
sad.sin_family = AF_INET; /* set family to Internet */
sad.sin_addr.s_addr = INADDR_ANY; /* set the local IP address */
sad.sin_port = htons((u_short)port);/* set the port number */
bind(welcomeSocket, (struct sockaddr *)&sad, sizeof(sad));
 Example: C server (TCP), cont
/* Specify the maximum number of clients that can be queued */
listen(welcomeSocket, 10)
Wait, on welcoming socket
while(1) { for contact by a client

connectionSocket=accept(welcomeSocket, (struct sockaddr *)&cad, &alen);

n=read(connectionSocket, clientSentence, sizeof(clientSentence));

/* capitalize Sentence and store the result in capitalizedSentence*/

n=write(connectionSocket, capitalizedSentence, strlen(capitalizedSentence)+1);

close(connectionSocket);
} Write out the result to socket
}
End of while loop,
loop back and wait for
another client connection
 Socket programming with UDP
UDP: no “connection”
between client and server
• no handshaking
application viewpoint
• sender explicitly attaches
UDP provides unreliable transfer
IP address and port of
of groups of bytes (“datagrams”)
destination to each packet between client and server
• server must extract IP
address, port of sender
from received packet
UDP: transmitted data may
be received out of order,
or lost
 Client/server socket interaction: UDP
Server (running on hostid, port x) Client

create socket,
port=x, for create socket,
clientSocket =
incoming request: DatagramSocket()
serverSocket =
DatagramSocket()
Create, address (hostid, port=x,
send datagram request
using clientSocket
read request from
serverSocket

write reply to
serverSocket
specifying client read reply from
host address, clientSocket
port number close
clientSocket
Example: Java client (UDP)
keyboard monitor

inFromUser
input
stream

Client
Process
Input: receives
process
packet (TCP
Output: sends received “byte
packet (TCP sent stream”)

receivePacket
sendPacket
“byte stream”) UDP UDP
packet packet

client
clientSocket UDP
socket UDP
socket

to network from network

Example: C client (UDP)
/* client.c */
void main(int argc, char *argv[])
{
struct sockaddr_in sad; /* structure to hold an IP address */
int clientSocket; /* socket descriptor */
struct hostent *ptrh; /* pointer to a host table entry */

char Sentence[128];
char modifiedSentence[128]; Create client socket,
NO connection to server
host = argv[1]; port = atoi(argv[2]);

clientSocket = socket(PF_INET, SOCK_DGRAM, 0);

/* determine the server's address */

memset((char *)&sad,0,sizeof(sad)); /* clear sockaddr structure */
sad.sin_family = AF_INET; /* set family to Internet */
sad.sin_port = htons((u_short)port);
ptrh = gethostbyname(host); /* Convert host name to IP address */
memcpy(&sad.sin_addr, ptrh->h_addr, ptrh->h_length);
 Example: C client (UDP), cont.
Get
input stream gets(Sentence);
from user

Send line addr_len =sizeof(struct sockaddr);

to server n=sendto(clientSocket, Sentence, strlen(Sentence)+1,
(struct sockaddr *) &sad, addr_len);

n=recvfrom(clientSocket, modifiedSentence, sizeof(modifiedSentence).

Read line (struct sockaddr *) &sad, &addr_len);
from server

printf("FROM SERVER: %s\n”,modifiedSentence);

Close close(clientSocket);
connection }
Example: C server (UDP)
/* server.c */
void main(int argc, char *argv[])
{
struct sockaddr_in sad; /* structure to hold an IP address */
struct sockaddr_in cad;
int serverSocket; /* socket descriptor */
struct hostent *ptrh; /* pointer to a host table entry */

char clientSentence[128]; Create welcoming socket at port

char capitalizedSentence[128]; &
Bind a local address
port = atoi(argv[1]);

serverSocket = socket(PF_INET, SOCK_DGRAM, 0);

memset((char *)&sad,0,sizeof(sad)); /* clear sockaddr structure */
sad.sin_family = AF_INET; /* set family to Internet */
sad.sin_addr.s_addr = INADDR_ANY; /* set the local IP address */
sad.sin_port = htons((u_short)port);/* set the port number */
bind(serverSocket, (struct sockaddr *)&sad, sizeof(sad));
 Example: C server (UDP), cont
while(1) { Receive messages from clients

n=recvfrom(serverSocket, clientSentence, sizeof(clientSentence), 0

(struct sockaddr *) &cad, &addr_len );

/* capitalize Sentence and store the result in capitalizedSentence*/

n=sendto(connectionSocket, capitalizedSentence, strlen(capitalizedSentence)+1,0

(struct sockaddr *) &cad, &addr_len);

close(connectionSocket);
} Write out the result to socket
}
End of while loop,
loop back and wait for
another client connection