Write two C programs using sockets on Linux that implement the following behavio

Question

Write two C programs using sockets on Linux that implement the following behavior:

One program is a server, and the other is a client

The server:

o Receives numbers that are sent from the client

o Keeps a running sum of all numbers received so far

o Sends a the sum of all numbers received back to the client every time a new number is received

The client:

o Establishes a connection to the server

o Prompts the user to enter a number

o Sends the number to the server

o Waits for a response back that says what the sum so far is

o Prints the response received from the server

Please add comments to the code.

Explanation / Answer

#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<unistd.h>   
int main(int argc , char *argv[])
{
int socket_desc , client_sock , c , read_size;
struct sockaddr_in server , client;
char client_message[2000];

socket_desc = socket(AF_INET , SOCK_STREAM , 0);
if (socket_desc == -1)
{
printf("Could not create socket");
}
puts("Socket created");

  
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons( 8888 );
  
if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
{
  
perror("bind failed. Error");
return 1;
}
puts("bind done");


listen(socket_desc , 3);

//Accept and incoming connection
puts("Waiting for incoming connections...");
c = sizeof(struct sockaddr_in);

//accept connection from an incoming client
client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c);
if (client_sock < 0)
{
perror("accept failed");
return 1;
}
puts("Connection accepted");

  
while( (read_size = recv(client_sock , client_message , 2000 , 0)) > 0 )
{

write(client_sock , client_message , strlen(client_message));
}

if(read_size == 0)
{
puts("Client disconnected");
fflush(stdout);
}
else if(read_size == -1)
{
perror("recv failed");
}

return 0;
}

client:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<pthread.h>
void *connection_handler(void *);

int main(int argc , char *argv[])
{
int socket_desc , client_sock , c , *new_sock;
struct sockaddr_in server , client;

socket_desc = socket(AF_INET , SOCK_STREAM , 0);
if (socket_desc == -1)
{
printf("Could not create socket");
}
puts("Socket created");
  
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
server.sin_port = htons( 8888 );
  
if( bind(socket_desc,(struct sockaddr *)&server , sizeof(server)) < 0)
{
perror("bind failed. Error");
return 1;
}
puts("bind done");

listen(socket_desc , 3);

puts("Waiting for incoming connections...");
c = sizeof(struct sockaddr_in);

  
puts("Waiting for incoming connections...");
c = sizeof(struct sockaddr_in);
while( (client_sock = accept(socket_desc, (struct sockaddr *)&client, (socklen_t*)&c)) )
{
puts("Connection accepted");

pthread_t sniffer_thread;
new_sock = malloc(1);
*new_sock = client_sock;

if( pthread_create( &sniffer_thread , NULL , connection_handler , (void*) new_sock) < 0)
{
perror("could not create thread");
return 1;
}


//pthread_join( sniffer_thread , NULL);
puts("Handler assigned");
}

if (client_sock < 0)
{
perror("accept failed");
return 1;
}

return 0;
}

void *connection_handler(void *socket_desc)
{
  
int sock = *(int*)socket_desc;
int read_size;
char *message , client_message[2000];

  
message = "Greetings! I am your connection handler ";
write(sock , message , strlen(message));

message = "Now type something and i shall repeat what you type ";
write(sock , message , strlen(message));

while( (read_size = recv(sock , client_message , 2000 , 0)) > 0 )
{
write(sock , client_message , strlen(client_message));
}

if(read_size == 0)
{
puts("Client disconnected");
fflush(stdout);
}
else if(read_size == -1)
{
perror("recv failed");
}

free(socket_desc);

return 0;
}

Related Questions

Navigate

• Browse (All)
• Browse W
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.