SOCKET PROGRAMMING ON UNIX - INTRODUCTION TO SOCKETS(PART 1/3)

What is a socket?

>

A socket is logical endpoint(situated on the transport layer) between two processes running in two different hosts. A socket can be seen as a tuple of one IP address and a port.

-- Wikipedia

Client/Server communication

• Client side
  1. Create a socket using the socket() syscall;
  2. Connect the socket to the server's endpoint(specifying IP address and port) using the connect() syscall;
  3. Perform I/O operations using write()/read() syscalls;
• Client side
  1. Create a socket using the socket() syscall;
  2. Bind the socket to an address(e.g., 127.0.0.1) using bind() syscall;
  3. Listen for connections using listen() syscall;
  4. Accept connections using accept() syscall;
  5. Receive request and send response using send()/receive() syscalls.

Server code

/*
* Server code
* Compile it with: gcc -Wall -Wextra -Werror server.c -o server
*/
#include <stdio.h> // printf, puts
#include <stdlib.h> // memset, strlen
#include <string.h> // strlen
#include <unistd.h> // write
#include <sys/socket.h>
#include <arpa/inet.h>

#define BUF_SIZE 1024

int main(int argc, char **argv) {
     int server_fd = 0, client_fd = 0, read_sz, count = 0;
     struct sockaddr_in server_sock, client_sock;
     char buf[BUF_SIZE];

     // Check for cli arguments
     if(argc != 2) {
          printf("Usage: %s <SERVER_PORT>\n", argv[0]);
          return 1;
     }

     // 1. Create socket
     server_fd = socket(AF_INET, SOCK_STREAM, 0);
     if(server_fd == -1) {
           puts("Unable to create socket");
           return 1;
     }

     // Setup socket and initialize buffer
     server_sock.sin_addr.s_addr = inet_addr("127.0.0.1");
     server_sock.sin_port = htons(atoi(argv[1]));
     server_sock.sin_family = AF_INET;
     memset(buf, 0, sizeof(buf));

     // 2. Bind socket to address and port
     int ret = bind(server_fd, (struct sockaddr*)&server_sock, sizeof(server_sock));
     if(ret < 0) {
           puts("Unable to bind TCP socket");
           return 1;
     }

     // 3. Listen for connections
     // 2nd parameter is the backlog. i.e., the maximum length to which the queue
     // of pending connections may grow
     listen(server_fd, 128);
     int len = sizeof(struct sockaddr_in);

     for(;;) {
         // 4. Accept incoming connections
          client_fd = accept(server_fd,
          (struct sockaddr*)&client_sock,
          (socklen_t*)&len);

          if(client_fd < 0) {
          puts("Unable to accept connections");
          return 1;
          }
          // Print client IP address
          char *client_addr = inet_ntoa(client_sock.sin_addr);
          int client_port = ntohs(client_sock.sin_port);
          printf("New connection from %s:%d\n", client_addr, client_port);
          // 5. Send data back to clients
          snprintf(buf,
          sizeof(buf),
          "server> You've reached me %d time(s)\n",
          ++count);
          write(client_fd, buf, strlen(buf));
     }

     if(read_sz == -1) {
          puts("Error reading from client");
          return 1;
     }
     
     return 0;
}

$> ./server 3000 &
[1] 356203
$> telnet localhost 3000
Trying ::1...
Connection failed: Connessione rifiutata # Ignore this, we do not support IPv6
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
Hi
server> You've reached me 1 time(s)
^]
telnet> q
Connection closed.
[1]  + 356203 done       ./server 3000

Client code

/*
* Client code
* Compile it with: gcc -Wall -Wextra -Werror client.c -o client
* by Marco Cetica <ceticamarco@gmail.com> 2021
*/

#include <stdio.h> // printf, puts
#include <string.h> // strlen
#include <stdlib.h> // atoi, memset
#include <unistd.h> // close
#include <sys/socket.h>
#include <arpa/inet.h>

#define BUF_SIZE 1024

int main(int argc, char **argv) {
     int server_fd = 0, ret = 0;
     struct sockaddr_in server_sock;
     char msg[BUF_SIZE], server_msg[BUF_SIZE];

     if(argc != 3) {
          printf("Usage: %s <IP_ADDRESS> <PORT>\n", argv[0]);
          return 1;
     }

     // 1. Create socket
     server_fd = socket(AF_INET, SOCK_STREAM, 0);
     if(server_fd  == -1) {
          puts("Unable to create socket");
          return 1;
     }

     // Setup socket and buffers
     server_sock.sin_addr.s_addr = inet_addr(argv[1]);
     server_sock.sin_port = htons(atoi(argv[2]));
     server_sock.sin_family = AF_INET;
     memset(server_msg, 0, sizeof(server_msg));
     sprintf(msg, "Hello World");


     // 2. Connect to server
     ret = connect(server_fd, (struct sockaddr*)&server_sock, sizeof(server_sock));
     if(ret < 0) {
          puts("Unable to connect to remote host");
          return 1;
     }

     // 3. Send data to server
     ret = send(server_fd, msg, strlen(msg), 0);
     if(ret < 0) {
          puts("Unable to send data to remote server");
          return 1;
     }

     // Read server's response
     ret = recv(server_fd, server_msg, sizeof(server_msg), 0);
     if(ret < 0) {
          puts("Unable to read data from remote server");
          return 1;
     }

     printf("%s", server_msg);


     // Finally, close socket
     close(server_fd);

     return 0;
}

$> ./server 5000 &
[1] 362784
$> for i in {1..5}; do ./client 127.0.0.1 5000; done
New connection from 127.0.0.1:58706
server> You've reached me 1 time(s)
New connection from 127.0.0.1:58708
server> You've reached me 2 time(s)
New connection from 127.0.0.1:58710
server> You've reached me 3 time(s)
New connection from 127.0.0.1:58712
server> You've reached me 4 time(s)
New connection from 127.0.0.1:58714
server> You've reached me 5 time(s)

Conclusions