Socketpair program using Select System Call

Socketpair

In this program, you are going to learn

How to create a socket ?

How to create a fork ?

How to send a data ?

How to recv a data?

How to use socketpair APIs ?
- socket
- fork
- send
- recv

Topics in this section,

socketpair FAQs

Step 1: Sequence Diagram for socketpair.c

Step 2: Program for socketpair.c

Step 3: Compile and Execute socketpair.c

Summary

socketpair FAQs : FAQs

Let us answer few basic questions in this socket

Why use socketpair in the program?

What parameters does socketpair take?

Why use AF_UNIX as the domain for socketpair?

What is the significance of SOCK_STREAM as the socket type?

Can socketpair be used for network communication?

Why is protocol often specified as 0 in the socketpair call?

What is the purpose of the sv array in the socketpair call?

How does socketpair handle errors during execution?

Can the created sockets be used for communication between unrelated processes?

Can the created sockets be passed between processes using fork?

How does socketpair differ from other socket creation functions like socket?

How is data sent from the parent to the child process?

How is data received by the child process?

Why is close called for each socket in both parent and child processes?

What is the purpose of the select system call in network programming?

How does select help in handling multiple sockets efficiently?

What types of file descriptors can be monitored using select?

What is the significance of the timeout parameter in the select function?

How do you handle errors when using the select system call?

How does select handle a set of file descriptors with different states (e.g., reading, writing, exception)?

How does select Checking Ready File Descriptors?

What does it mean if select returns 0?

Step 1: Sequence Diagram for socketpair.c

Step 2: Program for socketpair.c

There are many functions used in socketpair. We can classify those functions based on functionalities.
- Create Socket
- Fork
- Select
- Recv data_packet
- Send data_packet
- Close socket
socketpair creates a pair of connected sockets for local inter-process communication. For example,

sockfd = socketpair(AF_UNIX, SOCK_STREAM, 0, sv);

fork creates a child process, and both the parent and child processes can communicate through the socket pair. For example,

pid_t pid = fork();

select() is used in network programming to monitor multiple file descriptors (usually sockets) for read, write, or error conditions. For example,

ret = select(sv[1] + 1, &read_fds, NULL, NULL, NULL);

recv is used in network programming to receive data from a connected socket. For example,

ret = recv(sv[1], buffer, sizeof(buffer), 0);

send is used in network programming to send data over a connected socket. For example,

ret = send(sv[0], buffer, strlen(buffer), 0);

close is used to close the socket To free up system resources associated with the socket. For example,

(void)close(sv[0]);
(void)close(sv[1]);

See the full program below,

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <signal.h>

#define BUFFER_SIZE 1024

int sv[2];

static void sigint_handler(
int signo)
{
   (void)close(sv[0]);
   (void)close(sv[1]);
   sleep(2);
   (void)printf("Caught sigINT!\n");
   exit(EXIT_SUCCESS);
}

void register_signal_handler(
int signum,
void (*handler)(int))
{
  if (signal(signum, handler) == 
  SIG_ERR) {
     printf("Cannot handle signal\n");
     exit(EXIT_FAILURE);
  }
}

int main() 
{
  int sockfd;
  int ret;
  fd_set read_fds;
  char buffer[BUFFER_SIZE];

  register_signal_handler(SIGINT,
  sigint_handler);

  sockfd = socketpair(AF_UNIX, 
  SOCK_STREAM, 0, sv);
 
  if (sockfd < 0) {
    perror("socketpair");
    return -1;
  }

  printf("Socket pair created\n");

  pid_t pid = fork();

  if (pid == -1) {
    perror("fork");
    return -2;
  }

  if (pid == 0) {
    // Child process (Server)
    (void)close(sv[0]);

    while (1) {
      FD_ZERO(&read_fds);
      FD_SET(sv[1], &read_fds);

      ret = select(sv[1] + 1, 
      &read_fds, NULL, NULL, NULL);
      
      if (ret == -1) {
         perror("select");
         break;
      }
      
      if (FD_ISSET(sv[1], 
      &read_fds)) {
        ret = recv(sv[1], buffer, 
        sizeof(buffer), 0);

        if (ret < 0) {
          perror("recv");
          break;
        }

        buffer[ret] = '\0';
        printf("Received from server: %s\n", 
        buffer);
      }
    }

    (void)close(sv[1]);
  } else {
    // Parent process (Client)
    (void)close(sv[1]);

    while (1) {
      memset(buffer, 0, 
      sizeof(buffer));
      strncpy(buffer, "hello child", 
      strlen("hello child") + 1);
      buffer[strlen(buffer) + 1] = '\0';
      
      ret = send(sv[0], buffer, 
      strlen(buffer), 0);

      if (ret < 0) {
        perror("send");
        break;
      }
      printf("Sending client buffer = %s\n", 
      buffer);
      sleep(1);
    }
  }

  (void)close(sv[0]);
  (void)close(sv[1]);
  return 0;
}

Step 3: Compile and Execute socketpair.c

$ gcc -o socketpair socketpair.c

$ sudo ./socketpair

Socket pair created
Sending client buffer = hello child
Received from server: hello child
Sending client buffer = hello child
Received from server: hello child
Sending client buffer = hello child
Received from server: hello child
Sending client buffer = hello child
Received from server: hello child
Sending client buffer = hello child
Received from server: hello child
Sending client buffer = hello child
Received from server: hello child
Sending client buffer = hello child
Received from server: hello child
Sending client buffer = hello child
Received from server: hello child
Sending client buffer = hello child
Received from server: hello child
Sending client buffer = hello child
Received from server: hello child
^CCaught sigINT!
Caught sigINT!

Summary

Socket API	Learning
socketpair	creates a pair of connected sockets for local inter-process communication.
fork	creates a child process, and both the parent and child processes can communicate through the socket pair.
select	Monitor multiple file descriptors (usually sockets) for read, write, or error conditions.
recv	Receive data from a connected socket.
send	Send data over a connected socket.