Socket Programming in C

Socket programming is a method of enabling communication between two nodes over a network using sockets.

• One socket acts as a server, listening on a specific IP address and port.
• Another socket acts as a client, initiating a connection to the server.
• It follows a client-server architecture for data exchange.
• Widely used in applications like instant messaging, streaming services, and real-time collaboration tools.

Example: In this C program, we are exchanging a "hello" message between server and client to demonstrate the client/server model.

server.c

client.c

Compiling

gcc client.c -o clientgcc server.c -o server

Output

Client:Hello message sentHello from serverServer:Hello from clientHello message sent

Components of Socket Programming

1. Sockets

Sockets are one of the core components used by the program to access the network to communicate with other processes/nodes over the network. It is simply a combination of an IP address and a port number that acts as an endpoint for Communication.
Example: 192.168.1.1:8080, where the two parts separated by the colon represent the IP address( 192.168.1.1 ) and the port number( 8080 ).

Socket Types:

• TCP Socket (Stream Socket): Provides reliable, connection-based communication (i.e., TCP protocol).
• UDP Socket (Datagram Socket): Provides connectionless communication, faster but unreliable (i.e., UDP protocol).

2. Client-Server Model

The client-server model refers to the architecture used in socket programming, where a client and a server to interact with each other to exchange information or services. This architecture allows client to send service requests and the server to process and send response to those service requests.

State Diagram for Server and Client Model

Socket programming in C is a powerful way to handle network communication.

Creating a Server-Side Process

The server is created using the following steps:

1. Socket Creation

This step involves the creation of the socket using the socket() function.

Parameters:

• sockfd: socket descriptor, an integer (like a file handle)
• domain: integer, specifies communication domain. We use AF_ LOCAL as defined in the POSIX standard for communication between processes on the same host. For communicating between processes on different hosts connected by IPV4, we use AF_INET and AF_I NET 6 for processes connected by IPV6.
• type: communication type
  SOCK_STREAM: TCP(reliable, connection-oriented)
  SOCK_DGRAM: UDP(unreliable, connectionless)
• protocol: Protocol value for Internet Protocol(IP), which is 0. This is the same number that appears on the protocol field in the IP header of a packet.(man protocols for more details)

2. Setsockopt

This helps in manipulating options for the socket referred by the file descriptor sockfd. This is completely optional, but it helps in reuse of address and port. Prevents error such as: “address already in use”.

3. Bind

After the creation of the socket, the bind() function binds the socket to the address and port number specified in addr(custom data structure). In the example code, we bind the server to the localhost, hence we use INADDR_ANY to specify the IP address.

Parameters:

• sockfd: socket file descriptor created using the socket() function.
• addr: pointer to a struct sockaddr that contains the IP address and port number to bind the socket.
• addrlen: length of the addr structure.

4. Listen

In this step the server uses the listen() function that puts the server socket in a passive mode, where it waits for the client to approach the server to make a connection. The backlog, defines the maximum length to which the queue of pending connections for sockfd may grow. If a connection request arrives when the queue is full, the client may receive an error with an indication of ECONNREFUSED.

Parameters:

• sockfd: socket file descriptor created using the socket() function.
• backlog: number representing the size of the queue holding the pending connections while the server is waiting to accept a connection.

5. Accept

In this step the server extracts the first connection request from the queue of pending connections for the listening socket, sockfd, creates a new connected socket using the accept() function, and returns a new file descriptor referring to that socket. At this point, the connection is established between client and server, and they are ready to transfer data.

Parameters:

• sockfd: socket file descriptor returned by socket() and bind().
• addr: pointer to a struct sockaddr that will be hold the client's IP address and port number.
• addrlen: pointer to a variable that specifies the length of the address structure.

6. Send/Receive

In this step the server can send or receive data from the client .

Send(): to send data to the client

Parameters:

• sockfd: socket file descriptor returned by the socket() function.
• buf: pointer to the buffer containing the data to be sent.
• len: number of bytes of data to be sent.
• flags: integer specifying various options for how the data is sent, typically 0 is used for default behavior.

recv() : to recieve the data from the client.

Parameters:

• sockfd: socket file descriptor returned by the socket() function.
• buf: pointer to the buffer containing the data to be stored.
• len: number of bytes of data to be sent.
• flags: integer specifying various options for how the data is sent, typically 0 is used for default behavior.

7. Close

After the exchange of information is complete, the server closes the socket using the close() function and releases the system resources.

Parameters:

• fd: file descriptor of the socket.

Creating Client-Side Process

Follow the below steps for creating a client-side process:

1. Socket connection

This step involves the creation of the socket which is done in the same way as that of server’s socket creation

2. Connect

The connect() system call connects the socket referred to by the file descriptor sockfd to the address specified by addr. Server’s address and port is specified in addr.

Parameters

• sockfd: socket file descriptor returned by the socket() function.
• addr: pointer to struct sockaddr containing the server's IP address and port number.
• addrlen: size of the addr.

3. Send/Receive

In this step the client can send or receive data from the server which is done using the send() and recv() functions similar to how the server sends/receives data from the client.

4. Close

Once the exchange of information is complete, the client also needs to close the created socket and releases the system resources using the close() function in the same way as the server does.

Common Issues and their Fixes in Socket Programming

• Connection Failures: To avoid connection failures we should ensure that the client is trying to connect to the correct IP address and port.

• Port Binding Errors: These errors occur when a port is already in use by another application, in this scenario the binding to that port will fail. Try using a different port or close the previous application using the port.

• Blocking Sockets: By default, sockets are blocking. This means that calls like accept() or recv() will wait indefinitely if there is no client connection or data. You can set the socket to non-blocking mode if needed.