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.