TCP Server/Client Wie man Verbindungen am Leben erhält?

Question

Ich schrieb einen einfachen TCP-Echo-Server für mehrere Clients. Es verwendet select(), um mehrere Verbindungen zu erhalten.

Server-Code:

#include <stdio.h> 
#include <errno.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <sys/socket.h> 
#include <netinet/in.h> 
#include <netdb.h> 
#include <string.h> 


int create_listener(uint16_t port) { 

    int listen_fd; 
    struct sockaddr_in name; 

    listen_fd = socket(AF_INET, SOCK_STREAM, 0); 
    if (listen_fd < 0) { 
     perror ("socket"); 
     exit(EXIT_FAILURE); 
    } 

    bzero(&name, sizeof(name)); 
    name.sin_family = AF_INET; 
    name.sin_addr.s_addr = htonl(INADDR_ANY); 
    name.sin_port = htons(port); 

    if (bind(listen_fd, (struct sockaddr *) &name, sizeof(name)) < 0) { 
     perror ("bind"); 
     exit(EXIT_FAILURE); 
    } 


    return listen_fd; 
} 

int read_from_client(int fd) { 
    char buffer[100]; 
    int nbytes; 

    nbytes = read(fd, buffer, 100); 
    if (nbytes < 0) { 
     perror("read"); 
     exit(EXIT_FAILURE); 
    } 
    else if (nbytes == 0) { 
     return -1; 
    } 
    else { 
     fprintf(stderr, "Server: got message: %s\n", buffer); 
     write(fd, buffer, strlen(buffer) + 1); 
     return 0; 
    } 
} 


int main(int argc, char *argv[]) { 

    int listen_fd; 
    uint16_t port = 22000; 

    fd_set active_fd_set, read_fd_set; 
    int i; 

    struct sockaddr_in servaddr; 

    /* Create the socket and set it up to accept connections. */ 
    listen_fd = create_listener(port); 
    if (listen(listen_fd, 10) < 0) { 
     perror("listen"); 
     exit(EXIT_FAILURE); 
    } 

    /* Initialize the set of active sockets. */ 
    FD_ZERO(&active_fd_set); 
    FD_SET(listen_fd, &active_fd_set); 


    while (1) { 

     /* Block until input arrives on one or more active sockets. */ 
     read_fd_set = active_fd_set; 
     if (select(FD_SETSIZE, &read_fd_set, NULL, NULL, 0) < 0) { 
      perror("select"); 
      exit(EXIT_FAILURE); 
     } 

     /* Service all the sockets with input pending. */ 
     for (i = 0; i < FD_SETSIZE; ++i) { 
      if (FD_ISSET(i, &read_fd_set)) { 
       if (i == listen_fd) { 
        /* Connection request on original socket. */ 
        int new_fd; 
        new_fd = accept(listen_fd, (struct sockaddr *) NULL, NULL); 

        if (new_fd < 0) { 
         perror ("accept"); 
         exit(EXIT_FAILURE); 
        } 

        FD_SET(new_fd, &active_fd_set); 
       } 
       else { 
        /* Data arriving on an already-connected socket. */ 
        if (read_from_client(i) < 0) { 
         close(i); 
         FD_CLR(i, &active_fd_set); 
        } 
       } 
      } 
     } 
    } 

    return 0; 
} 

Code Auftraggeber:

#include <sys/types.h> 
#include <sys/socket.h> 
#include <netdb.h> 
#include <stdio.h> 
#include <string.h> 

int main(int argc, char *argv[]) { 

    int sockfd, n; 
    char sendline[100]; 
    char recvline[100]; 
    struct sockaddr_in servaddr; 

    sockfd = socket(AF_INET, SOCK_STREAM, 0); 
    bzero(&servaddr, sizeof(servaddr)); 

    servaddr.sin_family = AF_INET; 
    servaddr.sin_port = htons(22000); 

    inet_pton(AF_INET, "127.0.0.1", &(servaddr.sin_addr)); 

    connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)); 


    while (1) { 
     bzero(sendline, 100); 
     bzero(recvline, 100); 
     fgets(sendline, 100, stdin); 

     write(sockfd, sendline, strlen(sendline) + 1); 
     read(sockfd, recvline, 100); 

     printf("%s", recvline); 
    } 



    return 0; 
} 

Das Problem ist, wenn ich Server in einem Terminal laufen und zwei Clients in zwei weiteren Terminals laufen. Wenn ich Strg + C verwende, um einen Client zu beenden, wird der Server automatisch beendet. Ich frage mich, warum der Server so handelt. Was ich erwarte ist, dass der Server für immer läuft. Wenn Client 1 beendet wird, sollte der Server noch eine Live-Verbindung mit Client 2 haben.

Answer 1

Sieht aus wie Sie schlagen die 10 in read_from_client. Im Allgemeinen möchten Sie in einem Server, der mehrere Clients bedient, wahrscheinlich nicht beenden, wenn bei einer der Clientverbindungen ein Fehler auftritt.