Applcation layer interfaces with the lower layers via the socket interface. For example, a web server opens a socket, browser opens a socket, both sockets are linked to provide a datapipe abstraction. That is, whatever data is pushed in at one end comes out the other and vice versa. For example, all the HTTP request and response messages seen in last lecture and sent and received through sockets on browsers and web servers.
Any user space process can invoke the socket system call to create a socket. Sockets belong to two families: Unix domain sockets (for process to process communication on the same machine) and Internet sockets (what we will use). Internet sockets are further of three main types: stream socket (uses TCP to send the message given to the socket), datagram socket (uses UDP), and raw socket (sends the given packet as-is without any additional processing, don’t worry about these).
Every socket has a socket address: the IP address and a port number. Port number is a 16-bit number used to distinguish sockets on the same machine. Servers open sockets on well known ports, so that clients know how to contact them. For example, web servers listen on port 80, 20/21 for FTP data/control, 22 for SSH, 23 Telnet, 25 SMTP (email) etc. Ports 0-1023 are reserved for these well-known services.
Inside a process / application, open sockets are referenced by a number called the socket descriptor (much like a file descriptor when you open files). Whenever you have to refer to a socket to the kernel in a system call, you must quote this number. The socket file descriptor / handle is obtained when any process opens a socket using the “socket” system call.
After a server creates a socket (by specifying its type, family etc), it “binds” the socket to a particular well-known IP address and port number. After server binds to a particular port, it issues the “listen” system call to tell the lower layers to start listening for incoming requests. Whenever an incoming request arrives on the server’s socket, it must do an “accept” system call. If the server calls accept, it will block till a request arrives.
Clients create sockets, but need not pick a port number. Client sockets are assigned a random unused port number that is not reserved by the system. Once a client socket is created, the client “connects” to the server socket by specifying the server IP and port. This connection involves the three-way TCP handshake for TCP sockets, and nothing for UDP sockets.
When the client connects, the server accepts the connection, a new socket is created at the server for communication with this client. The original listening socket continues to listen for new requests, and the new socket is used to send and receive from a particular client.
Once the client and server sockets have been connected, both endpoints can read and write from sockets, much like they do from files. For example, you call read(socket number,…) and this call returns when there is some data to be read on the socket. Similarly, the write call writes data into a socket.
Summary: main system calls for TCP communication: socket (for creation), bind, listen, accept (at server), connect (at client), read, write (at both). Demo: show a simple socket program.
UDP communication proceeds similarly, but without the connection establishment phase.
Handling multiple clients concurrently at the server: the accept and read system calls are “blocking” (i.e., the server does not make progress until some data arrives), so how can a server serve multiple clients at the same time, without blocking for any one of them?
Non-blocking sockets, along with polling or event-driven I/O (system calls like select, epoll).
Blocking sockets, but have multiple threads/processes, one per active connection.
Overview of the programming assignment 1.