Écoutez plusieurs ports d'un serveur

Pour chaque port que vous voulez écouter, vous:

1. De la création d'un socket avec socket.
2. Lier au port approprié avec bind.
3. Appel listen sur le socket de sorte qu'il est mis en place avec une écoute de la file d'attente.

À ce point, votre programme est à l'écoute sur de multiples supports. Pour accepter les connexions sur ces prises, vous avez besoin de savoir qui socket un client se connecte. C'est là que select. Il se trouve que j'ai un code qui fait exactement ce assis autour, voici donc une complète testé exemple de l'attente pour les connexions sur des prises multiples et retour le descripteur de fichier de connexion. L'adresse distante est retourné dans d'autres paramètres (le tampon doit être fourni par l'appelant, tout comme l'accepter).

(socket_type ici est un typedef pour int sur les systèmes Linux, et INVALID_SOCKET est -1. Ceux qui sont là parce que ce code a été porté sous Windows.)

socket_type
network_accept_any(socket_type fds[], unsigned int count,
                   struct sockaddr *addr, socklen_t *addrlen)
{
    fd_set readfds;
    socket_type maxfd, fd;
    unsigned int i;
    int status;

    FD_ZERO(&readfds);
    maxfd = -1;
    for (i = 0; i < count; i++) {
        FD_SET(fds[i], &readfds);
        if (fds[i] > maxfd)
            maxfd = fds[i];
    }
    status = select(maxfd + 1, &readfds, NULL, NULL, NULL);
    if (status < 0)
        return INVALID_SOCKET;
    fd = INVALID_SOCKET;
    for (i = 0; i < count; i++)
        if (FD_ISSET(fds[i], &readfds)) {
            fd = fds[i];
            break;
        }
    if (fd == INVALID_SOCKET)
        return INVALID_SOCKET;
    else
        return accept(fd, addr, addrlen);
}

Ce code n'indique pas à l'appelant de port du client connecté, mais vous pouvez facilement ajouter un int * paramètre qui permettrait d'obtenir le descripteur de fichier qui a vu la connexion entrante.

Dans une telle situation, vous pouvez être intéressé par libevent. Il va faire le travail de l' select() pour vous, probablement à l'aide d'une bien meilleure interface comme epoll().

L'énorme inconvénient avec select() est l'utilisation de la FD_... macros qui limite le nombre de sockets pour le nombre maximum de bits dans le fd_set variable (de l'ordre de 100 à 256). Si vous avez un petit serveur avec 2 ou 3 connexions, vous serez amende. Si vous avez l'intention de travailler un beaucoup plus grand serveur, puis le fd_set pourrait facilement obtenir survolées.

Aussi, l'utilisation de la select() ou poll() vous permet d'éviter les threads du serveur (c'est à dire que vous pouvez poll() votre prise et savoir si vous pouvez accept()read()ou write().)

Mais si vous voulez vraiment faire Unix, alors vous pouvez aussi envisager de fork()-ing avant d'appeler accept(). Dans ce cas, vous n'avez pas absolument besoin de la select() ou poll() (sauf si vous êtes à l'écoute sur plusieurs ip/ports et voulons que tous les enfants soient capables de répondre à toutes les connexions entrantes, mais vous avez inconvénients avec... le noyau peut vous envoyer une autre demande, alors que vous êtes déjà en cours de traitement d'une demande, alors que, avec juste un accept()le noyau sait que vous êtes occupé, si ce n'est dans le accept() appeler lui-même—bien, il ne fonctionne pas exactement comme cela, mais en tant qu'utilisateur, c'est la façon dont cela fonctionne pour vous.)

Avec le fork() vous préparez le support dans le processus principal et ensuite appeler handle_request() dans un processus enfant d'appeler le accept() fonction. De cette façon, vous pouvez avoir n'importe quel nombre de ports et d'un ou plusieurs enfants à écouter sur chaque. C'est la meilleure façon de vraiment très rapidement répondre à toute connexion entrante sous Linux (c'est à dire en tant qu'utilisateur et aussi longtemps que vous avez les processus enfants d'attente pour un client, il est instantanée.)

void init_server(int port)
{
    int server_socket = socket();
    bind(server_socket, ...port...);
    listen(server_socket);
    for(int c = 0; c < 10; ++c)
    {
        pid_t child_pid = fork();
        if(child_pid == 0)
        {
            //here we are in a child
            handle_request(server_socket);
        }
    }

    //WARNING: this loop cannot be here, since it is blocking...
    //         you will want to wait and see which child died and
    //         create a new child for the same `server_socket`...
    //         but this loop should get you started
    for(;;)
    {
        //wait on children death (you'll need to do things with SIGCHLD too)
        //and create a new children as they die...
        wait(...);
        pid_t child_pid = fork();
        if(child_pid == 0)
        {
            handle_request(server_socket);
        }
    }
}

void handle_request(int server_socket)
{
    //here child blocks until a connection arrives on 'server_socket'
    int client_socket = accept(server_socket, ...);
    ...handle the request...
    exit(0);
}

int create_servers()
{
    init_server(80);   //create a connection on port 80
    init_server(443);  //create a connection on port 443
}

Noter que le handle_request() fonction est montré ici que le traitement d'une demande. L'avantage de la manipulation d'une seule demande est que vous pouvez le faire de la manière Unix: allouer les ressources nécessaires et une fois que la demande est exaucée, exit(0). Le exit(0) fera appel à la nécessaire close()free()etc. pour vous.

En revanche, si vous souhaitez gérer plusieurs demandes en ligne, vous voulez vous assurer que les ressources seront libérées avant de revenir en accept() appel. Aussi, le sbrk() fonction est à peu près jamais être appelé à réduire l'empreinte mémoire de votre enfant. Cela signifie qu'il a tendance à augmenter un peu chaque maintenant et puis. C'est pourquoi un serveur comme Apache 2 est configuré pour répondre à un certain nombre de demandes par enfant avant de commencer un nouvel enfant (par défaut, c'est entre 100 et 1 000 ces jours-ci.)