#include <stdio.h>: This includes the standard input-output header file.

It provides functions like printf()

#include <string.h>: This includes the string manipulation header file. It provides functions like strcpy(),
strcat(), strlen(), etc., which are used for various string operations.

#include <stdlib.h>: This includes the standard library header file. It provides functions like malloc(),
free(), exit(), etc., which are used for memory allocation, deallocation, and program termination.

#include <unistd.h>: This includes the header file related to POSIX operating system functionality. It
provides access to various standard POSIX functions such as fork(), pipe(), exec(), etc.

#include <arpa/inet.h>: This includes the header file containing definitions for internet operations. It
provides functions and structures related to internet addressing, such as inet_addr(), inet_ntoa(), etc.

#include <sys/socket.h>: This includes the header file containing definitions for socket programming. It
provides functions and structures related to creating and managing sockets, such as socket(), bind(),
listen(), etc.

#define BUF_SIZE 1024: This line is a preprocessor directive. It defines a macro named BUF_SIZE with the
value 1024. This macro will be replaced with its value wherever it appears in the code.

void error_handling(char *message);: This is a function prototype declaration. It declares a function

int main(int argc, char *argv[]): This is the main function of the program. It takes command-line
arguments argc (argument count) and argv (argument vector). argc contains the number of arguments
passed to the program, and argv is an array of strings containing the arguments themselves.

Inside main() function:

a. int sock;: Declares an integer variable sock which will be used to store the socket descriptor.

b. char message[BUF_SIZE];: Declares a character array named message with size BUF_SIZE (1024 in this
case). This array will be used to store the message to be sent to the server.

c. int str_len;: Declares an integer variable str_len which will be used to store the length of the string
received from the server.

d. struct sockaddr_in serv_adr;: Declares a structure variable serv_adr of type sockaddr_in. This
structure is used to specify the address and port of the server to which the client will connect.

e. if(argc!=3) { printf("usage : %s <IP><port>\n",argv[0]); exit(1); }: This condition checks whether the

sock=socket(PF_INET,SOCK_STREAM,0);:
This line creates a new socket and assigns its file descriptor to the variable sock.

PF_INET specifies that IPv4 will be used.

SOCK_STREAM specifies that the socket will be of type TCP, which provides a reliable, stream-oriented
connection.

The last argument 0 typically denotes the protocol, which is left to the system to choose the default.

if (sock==-1) error_handling ("socket() error");:

This checks if the socket creation was successful. If sock equals -1, it means an error occurred during
socket creation, and the program calls error_handling() function to handle the error.

memset(&serv_adr,0,sizeof(serv_adr));:

This line initializes the memory for the server address structure serv_adr to zeros.

serv_adr.sin_family =AF_INET;:

This line sets the address family of the server address structure to AF_INET, indicating IPv4.

serv_adr.sin_addr.s_addr = inet_addr(argv[1]);:

This line converts the IPv4 address provided as the first argument (argv[1]) to binary form and assigns it
to the sin_addr.s_addr field of serv_adr.

serv_adr.sin_port =htons(atoi(argv[2]));:

This line converts the port number provided as the second argument (argv[2]) to network byte order
using htons() function and assigns it to the sin_port field of serv_adr.

if(connect(sock,(struct sockaddr*)&serv_adr,sizeof(serv_adr))==-1) error_handling ("connect () error !");:

This line tries to establish a connection to the server using the connect() function. If it fails (connect()
returns -1), it calls error_handling() to handle the error.

else puts( "connected ----");:

If the connection is successful, it prints "connected ----" indicating a successful connection.

while(1): This starts an infinite loop. 1 is typically used as shorthand for true in C, so this loop will
continue indefinitely until explicitly broken out of.

Inside the loop:

fputs("input message (Q to quit): " ,stdout);: This line prints a prompt to the user, asking them to input a
message. It waits for input from the user.

fgets(message,BUF_SIZE, stdin);: This line reads the input message from the user and stores it in the
message variable. BUF_SIZE seems to be the maximum length of the input buffer.

if(!strcmp(message, "q\n")|| !strcmp (message, "Q\n")) break;: This condition checks if the user input is
"q" or "Q" followed by a newline character. If it is, the loop breaks, allowing the program to exit.
write (sock,message,strlen(message));: This line writes the message to the socket referenced by sock.
This presumably sends the message to the server.

str_len = read(sock,message,BUF_SIZE -1);: This line reads a response from the server into the message
buffer. It reads up to BUF_SIZE - 1 characters from the socket referenced by sock.

message [str_len]=0;: This line terminates the received message string properly with a null character.

printf("message from server : %s", message);: This line prints the message received from the server to
the console.

After the loop:

close(sock);: This line closes the socket referenced by sock, releasing any associated resources.

return 0;: This line exits the program, returning 0 to the operating system, indicating successful
execution.

fputs(message, stderr);: This line writes the content of the message string to the standard error stream
(stderr). fputs is a standard C library function used for writing strings to a file stream. stderr is typically
used for error messages in C programs, and it's different from stdout, which is used for normal output.

fputc('\n', stderr);: This line writes a newline character ('\n') to stderr, effectively adding a newline after
the error message. This ensures that subsequent messages printed to stderr will appear on a new line.

exit(1);: This line terminates the program immediately and returns an exit status of 1. This is commonly
used to indicate that an error occurred during program execution. A status of 0 typically indicates
successful execution, while non-zero values (like 1 in this case) indicate an error.