暂时停止收听套接字

Question

I'm writing a server in C++, using the POSIX sockets api.

This is running as part of a GUI application, which needs to be able to stop and start the server from listening and sending data to clients.

The main part of the server looks basically like this (i've exluded lots of the code because some of it wasn't relevant to this question.)

if (listen(listener_fd, backlog) < 0) {
    std::perror("listen");
    exit(EXIT_FAILURE);
}

while (true) {
    /* This part sets up the FD set */
    FD_ZERO(&read_fds);
    FD_SET(0, &read_fds); // stdin (for server commands)
    FD_SET(listener_fd, &read_fds);
    FD_SET(read_pipe, &read_fds);
    for (auto it = client_socks.begin(); it != client_socks.end(); it++) {
        FD_SET(*it, &read_fds); // listen on each of the open client-server sockets
    }

    max_fd = 0;
    if (client_socks.size() > 0) {
        max_fd = *std::max_element(client_socks.begin(), client_socks.end());
    }
    if (listener_fd > max_fd) max_fd = listener_fd;
    if (read_pipe > max_fd) max_fd = read_pipe;

    std::fill_n(in_buf, IN_BUF_LENGTH, 0);

    // wait for input on stdin or any of the sockets, with a timeout of 20s
    sel_ret = select(max_fd + 1, &read_fds, NULL, NULL, &read_timeout);
    if (sel_ret == -1) {
        std::perror("select");
        exit(EXIT_FAILURE);
    } 
    else if (sel_ret) {
        if (FD_ISSET(0, &read_fds)) { /* stdin */
            // send stdin to all clients
            // excl. for brev.
        } 
        else if (FD_ISSET(listener_fd, &read_fds) && serving) { /* listen(...) can accept, but only bother if the server is listening */
            int newclient_sock = accept(listener_fd, (struct sockaddr*)&addr, &addrlen);
            std::cout << "New client: " << newclient_sock << std::endl;
            client_socks.push_back(newclient_sock);
        }
        else if (FD_ISSET(read_pipe, &read_fds)) { /* someone sent some data down the pipe - probably GUI info, like a button press */
            // here i've got a message from the GUI, which
            // is either starting or stopping the server
            // excluded here for brevity
        }
        else if (serving) { /* one of the sockets, but only if the server is listening */
            // here i've got data from a client socket
            // this handles the message that they send to me
            // again, excluded here for brevity
        }
    }
}

Or in other words:

1. Make socket listen for connections
2. Setup fds for select() call
3. Call select() with stdin, all connect client sockets, and a pipe getting any data sent from the GUI
4. If stdin is active, send the typed data to all clients
5. If the listener is active, append this new client to the list of clients.
6. If the data pipe is active, then either start or stop the server based on the data which it has.
7. If a client sent data, send that data to all clients, or if they have disconnected, then remove them from the client list.
8. Goto 2.

My problem

I need to be able to make the server basically stop , until I tell it to start again. To clarify, what I mean by stopping is:

• Not listening for any clients
• Not able to receive data from any clients
• Any connected clients are disconnected.

What I've tried

My first thought was to keep track of whether it should be running or not with a boolean serving .

At the beginning of each loop of the while(true), I do this:

if (serving) {
    // listen(...), same as I did it originally
} else {
    shutdown(listener_fd, SHUT_RD);
}

But that didn't work at all. It worked so badly that it's hard to even say what it did do instead, so sorry about that.

Another thought was to use the close(listener_fd) call, but of course that just makes the fd not useable anymore.

Another option I considered was, before accepting a connection, first checking if serving was set. If it is, then accept the connection. Same goes for receiving and sending data. This kind of worked, but didn't inform the clients that I was not serving.

Answer 1

Sockets do not support "temporary" deactivation like what you are asking for. You need to either:

• close() the listening socket, and then create a new listening socket when ready to start again.

• keep the listening socket open and running normally, but immediately close() any new client that is accepted.

As for clients that have been accepted, you need to shutdown() + close() them individually, optionally sending them a goodbye message first, depending on whether your protocol allows that.