1. Socket Programming

2. Interprocess Communication
Within a single system
Pipes, FIFOs
Message Queues
Semaphores, Shared Memory
Across different systems
BSD Sockets
Transport Layer Interface (TLI)
Reference
Unix Network Programming by Richard Stevens
Computer Science, FSU

3. BSD Socket API Introduced in 1981 BSD 4.1 UNIX
Sockets is just a convenient interface for the processes on different hosts to communicate.
Just like if you want to write to the hard disk, you can operate the hard disk directly, but it is much more convenient to open a file and write to the file using the interface provided by the system.
Computer Science, FSU

4. Socket A 5-tuple associated with a socket
{protocol, local IP address, local port, remote IP address, remote port}
Complete socket is like a file descriptor
Both send() and recv() through same socket

5. Sockets: Conceptual View
You can think of the socket layer as another layer between application and transport layers. Or socket layer as the interface to transport layer services.
Socekt is an interface between app. Layer and the tcp layer. It is much more convenient to use it than to use the real IP address and port number.
Computer Science, FSU

6. Connection-Oriented Application
Server gets ready to service clients
Creates a socket
Binds an address (IP interface, port number) to the socket
Server’s address should be made known to clients
Client contacts the server
Connects to the server
Client has to supply the address of the server when using connect()
Accepts connection requests from clients
Further communication is specific to application
Computer Science, FSU

7. Creating a socket int socket(int family, int service, int protocol)
family: symbolic name for protocol family
AF_INET, AF_UNIX
type: symbolic name for type of service
SOCK_STREAM, SOCK_DGRAM, SOCK_RAW
protocol: further info in case of raw sockets
typically set to 0
Returns socket descriptor
The socket function call simply allocates a socket structure the contents of which get filled in by other calls such as bind(), connect(). This socket() call returns a socket descriptor which is used to refer to the socket for any subsequent operation on the socket.
Computer Science, FSU

8. Binding Socket with an Address
int bind(int sd, struct sockaddr *addr, int len)
sd: socket descriptor returned by socket()
addr: pointer to sockaddr structure containing address to be bound to socket
len: length of address structure
Returns 0 if success, -1 otherwise
Computer Science, FSU

9. Specifying Socket Address
struct sockaddr_in {
short sin_family; /* set to AF_INET */
u_short sin_port; /* 16 bit port number */
struct in_addr sin_addr; /* 32 bit host address */
char sin_zero[8]; /* not used */ };
struct in_addr {
u_long s_addr; /* 32 bit host address */
Computer Science, FSU

10. Bind Example int sd; struct sockaddr_in ma;
sd = socket(AF_INET, SOCK_STREAM, 0);
ma.sin_family = AF_INET; ma.sin_port = htons(5100); ma.sin_addr.s_addr = htonl(INADDR_ANY); if (bind(sd, (struct sockaddr *) &ma, sizeof(ma)) != -1) …
In this example, we are assuming that server is being bound to port The function htons() converts a short integer (port is a 16 bit number) from host format to network (standard) format. The special value for IP address INADDR_ANY says that the server is willing to accept requests addressed to any of its machine’s IP addresses. This option conveniently covers the case of the server machine having multiple interfaces each with an IP address. Similar to htons, the function htonl converts a long integer (IP address is a 32 bit number) from host format to network format.
Computer Science, FSU

11. Connecting to Server
int connect(int sd, struct sockaddr *addr, int len)
sd: socket descriptor returned by socket()
addr: pointer to sockaddr structure containing server’s address (IP address and port)
len: length of address structure
Returns 0 if success, -1 otherwise
Computer Science, FSU

12. Connect Example int sd; struct sockaddr_in sa;
sd = socket(AF_INET, SOCK_STREAM, 0);
sa.sin_family = AF_INET; sa.sin_port = htons(5100); sa.sin_addr.s_addr = inet_addr(“ ”); if (connect(sd, (struct sockaddr *) &sa, sizeof(sa)) != -1) …
For connect(), we have to pass the whereabouts the server so that we can connect to the server. Here we are assuming that server is running on a machine with IP address and bound to port The function inet_addr is used to convert IP address from dotted decimal string form to 32 bit integer (network byte order).
Once the connect() is successful, the socket descriptor sd can be used just like a file descriptor to read from and write to the server.
Computer Science, FSU

13. Connection Acceptance by Server
int accept(int sd, struct sockaddr *from, int *len)
sd: socket descriptor returned by socket()
from: pointer to sockaddr structure which gets filled with client’s address
len: length of address structure
Blocks until connection requested or error
returns a new socket descriptor on success
For accept() you pass a structure and it gets filled with the details of the client when the accept() call returns. Note that for the third argument you have to pass a pointer to an integer so that the accept() call can store the length of the structure that got filled.
The accept() call blocks until there is a connection request from a client. It is important to remember that accept() call returns a new socket descriptor (unlike connect() call). This new socket descriptor can be used by the server to communicate with the specific client that requested the connection.
Computer Science, FSU

14. Connection-oriented Server
int sd, cd, calen; struct sockaddr_in ma, ca;
sd = socket(AF_INET, SOCK_STREAM, 0); ma.sin_family = AF_INET; ma.sin_port = htons(5100); ma.sin_addr.s_addr = htonl(INADDR_ANY); bind(sd, (struct sockaddr *) &ma, sizeof(ma));
listen(sd, 5);
calen = sizeof(ca);
cd = accept(sd, (struct sockaddr *) &ca, &calen);
…read and write to client treating cd as file descriptor…
As pointed out in the previous slide, accept() call returns a new socket descriptor which in this case is cd. This cd can be used to read from/write to the client. The original socket descriptor sd can continue to be passed to any future accept() calls for accepting more connections.
Computer Science, FSU

15. More on Socket Descriptor
socket() fills the protocol component
local IP address/port filled by bind()
remote IP address/port by accept() in case of server
in case of client both local and remote by connect()
accept() returns a new complete socket
Original one can be used to accept more connections
Computer Science, FSU

16. Streams and Datagrams Connection-oriented reliable byte stream
SOCK_STREAM based on TCP
No message boundaries
Multiple write() may be consumed by one read()
Connectionless unreliable datagram
SOCK_DGRAM based on UDP
Message boundaries are preserved
Each sendto() corresponds to one recvfrom()
Computer Science, FSU

17. Input/Output Multiplexing
Polling
Nonblocking option using fcntl()/ioctl()
Waste of computer resources
Asynchronous I/O
Generates a signal on an input/output event
Expensive to catch signals
Wait for multiple events simultaneously
Using select() system call
Process sleeps till an event happens
Suppose you want to read from a keyboard and write that to a server and also display on the screen whatever is written by the sever. So you have to worry about input from either keyboard or socket. You can not read one at a time. There may be input from the a source while you are blocked reading from other source.
One solution is to use fcntl() and ioctl() calls to make I/O on a stream non-blocking. In that case a read would return immediately either with some input or 0 bytes if nothing to be read. We can then poll the descriptors in a round robin fashion. This approach of periodic polling wastes cpu resources. Instead it is better if our process is notified whenever there is some input on any of the sources.
Using fcntl() and ioctl() calls, it is possible to make the system generate a SIGIO signal whenever there is something to be read on a file descriptor. A signal handler can be setup to be called to service that signal. Then within the signal handler, we can probe all the descriptors to find the descriptor with some input.
A better alternative is to wait on multiple descriptors simultaneously. Using select() call we can wait till some event happens or specified time expires.
Computer Science, FSU

18. Select System Call
int select(int maxfdp1, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
maxfdp1: largest numbered file descriptor + 1
readfds: check if ready for reading
writefds: check if ready for writing
exceptfds: check for exceptional conditions
timeout: specifies how long to wait for events
Computer Science, FSU

19. Timeout in Select Wait indefinitely till there is an event
Pass NULL to the timeout argument
Don’t wait beyond a fixed amount of time
Pass pointer to a timeval structure specifying the number of seconds and microseconds.
Just poll without blocking
Pass pointer to a timeval structure specifying the number of seconds and microseconds as 0
Computer Science, FSU

20. Working with File Descriptor Set
Set is represented by a bit mask
Keep a descriptor in/out the set, turn on/off corresponding bit
Using FD_ZERO, FD_SET and FD_CLR
Use FD_ISSET to check for membership
Example:
Make descriptors 1 and 4 members of the readset
fd_set readset;
FD_ZERO(&readset);
FD_SET(1, &readset);
FD_SET(4, &readset);
Check if 4 is a member of readset
FD_ISSET(4, &readset);
Computer Science, FSU

21. Return Values from Select
Arguments readfds etc are value-result
Pass set of descriptors you are interested in
Select modifies the descriptor set
Keeps the bit on if an event on the descriptor
Turns the bit off if no event on the descriptor
On return, test the descriptor set
Using FD_ISSET
Computer Science, FSU

22. Select Example fd_set readset; FD_ZERO(&readset); FD_SET(0, &readset);
select(5, &readset, NULL, NULL, NULL);
if (FD_ISSET(0, &readset) { /* something to be read from 0 */ }
if (FD_ISSET(4, &readset) { /* something to be read from 4 */ }
Note that the first argument is 5 (largest descriptor + 1) because the largest descriptor we are interested in is 4.
Computer Science, FSU

23. Servers and Services Mapping between names and addresses (DNS)
Host name to address: gethostbyname()
Host address to name: gethostbyaddr()
Computer Science, FSU

24. send() and recv()
Once the sockets have been set up, the bytes can be sent and receive using send() and recv().
send():
ssize_t send(int socket, const void *buffer, size_t length, int flags);
Returns the number of bytes sent. -1 if error.
To send, fill the buffer to length, and call send().
recv():
ssize_t recv(int socket, void *buffer, size_t length, int flags);
Returns the number of bytes received. If returns 0, means the connection is down. -1 if error.
When the socket fd is set, call recv(), and check the return value and buffer.