programing - socket programming in c geeksforgeeks

Múltiples clientes en C Socket Programming

Question

Estoy creando un servidor de eco simple que escucha SOCK_STREAM y continúa aceptando conexiones infinitas. En la función int listen (int sockfd, int backlog). He configurado el retraso acumulado en 1, ¿no significa que un máximo de 1 cliente puede esperar en la cola?

Considere el siguiente caso que he encontrado.

El servidor se inició y aceptó la conexión del cliente 1

Ahora el cliente 2 intenta conectarse y está conectado

Ahora el cliente 3 intenta conectarse y está conectado

Ahora el cliente 2 envía "hello2" y espera la respuesta

Ahora el cliente 3 envía "hello3" y espera la respuesta

Ahora el Cliente 1 envía "hello1" y obtiene la respuesta "hello1" del servidor

Ahora el cliente 2 recibe la respuesta "hello2" del servidor

Luego, el cliente 3 recibe la respuesta "hello3" del servidor

¿Cómo es esto posible? ¿El cliente 2 y el cliente 3 no deben recibir un error al conectarse ya que el servidor ya está conectado al cliente 1 y el tamaño máximo de la cola es 1?

 Server:
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <string.h>
#define max_request 4
char buffer[50];
void clear()
{
int i;
for(i=0;i<50;i++)
buffer[i]=NULL;
}
int main()
{
int status;
struct sockaddr_in addrport;
addrport.sin_family = AF_INET;
addrport.sin_port = htons(5100);
addrport.sin_addr.s_addr = htonl(INADDR_ANY);
int sockid = socket(PF_INET, SOCK_STREAM, 0);
if(bind(sockid, (struct sockaddr *) &addrport, sizeof(addrport))== -1)
{
printf("/nBinding Failed/n");
return(0);
}
int listen_status=listen(sockid,1);
if(listen_status==-1)
printf("/nListening Error/n");
else
printf("/nWaiting for connections.../n");
while(1)
{
struct sockaddr_in clientaddr;
int addlen=sizeof(struct sockaddr_in);
int new_client_socket=accept(sockid,(struct sockaddr *)&clientaddr,&addlen);
char *client_ip;
client_ip=inet_ntoa(clientaddr.sin_addr);
printf("/n Connection from %s /n",client_ip);
status=recv(new_client_socket,buffer,50,0);
if(status!=-1)
status=send(new_client_socket,buffer,50,0);
clear(); // clears the variable buffer
}
close(sockid);
}

Cliente:

int main()
{
int s,k;char buff[50],c[50];
struct sockaddr_in serverport;
serverport.sin_family = AF_INET;
serverport.sin_port = htons(5100);
serverport.sin_addr.s_addr = inet_addr("0.0.0.0");
int sockid=socket(PF_INET,SOCK_STREAM,0);
int connect_status=connect(sockid,(struct sockaddr *) &serverport,sizeof(serverport));
if(connect_status<0)
{
printf("/nConnection Error/n");
return(1);
}
printf("/nConnected/n");
gets(buff); // message to be sent to server
s=send(sockid,buff,50,0);
k=recv(sockid,c,50,0);
printf("/nServer : %s /n ",c);
close(sockid);
}

Answer 1

¿El cliente 2 y el cliente 3 no deben recibir un error al conectarse ya que el servidor ya está conectado al cliente 1 y el tamaño máximo de la cola es 1?

No, no hay error

''tamaño máximo de COLA es 1'' - si la aceptación tiene éxito, entonces la cola está vacía y otro cliente puede conectarse.