ex_bind_exclusive.c

Go to the documentation of this file.

 
#include "nilorea/n_log.h"
#include "nilorea/n_network.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int check_exclusive(int udp) {
    NETWORK* first = NULL;
    NETWORK* second = NULL;
    char port[16] = "";
    const char* what = udp ? "netw_bind_udp" : "netw_make_listening";
    int p, ok = 0;
 
    /* Take a free port by trying a range, rather than asking for 0: the NETWORK keeps the
     * port string it was GIVEN, so an ephemeral bind would not report back which one it got
     * and the second bind would have nothing to aim at. */
    for (p = 34100; p < 34100 + 200; p++) {
        snprintf(port, sizeof(port), "%d", p);
        ok = udp ? (netw_bind_udp(&first, "127.0.0.1", port, NETWORK_IPV4) == TRUE)
                 : (netw_make_listening(&first, "127.0.0.1", port, 8, NETWORK_IPV4) == TRUE);
        if (ok && first)
            break;
        first = NULL;
    }
    if (!ok || !first) {
        n_log(LOG_ERR, "%s: could not take any port in the test range", what);
        return 1;
    }
 
    second = NULL;
    ok = udp ? (netw_bind_udp(&second, "127.0.0.1", port, NETWORK_IPV4) == TRUE)
             : (netw_make_listening(&second, "127.0.0.1", port, 8, NETWORK_IPV4) == TRUE);
    if (second)
        netw_close(&second);
    netw_close(&first);
 
    if (!udp) {
        /* TCP: exclusive on every platform. This is the contract that matters for a
         * listener a user was told is running. */
        if (ok) {
            n_log(LOG_ERR,
                  "%s: the SECOND bind to port %s SUCCEEDED. The port is being shared, so a "
                  "listener can be started over one another process already owns.",
                  what, port);
            return 1;
        }
        n_log(LOG_INFO, "%s: a second bind to port %s was refused, as it must be", what, port);
        return 0;
    }
 
    /* UDP is not the same question, and asserting it were would be asserting something
     * POSIX does not offer. SO_REUSEADDR on a datagram socket deliberately PERMITS several
     * sockets on one port (that is how multicast and broadcast receivers work), so a second
     * bind succeeding on POSIX is correct behaviour rather than a defect. What is worth
     * holding is the Windows side, where the option is not set and the second bind is
     * refused, because that is where it would otherwise mean a process silently binding
     * over one already holding the port. */
#ifdef __windows__
    if (ok) {
        n_log(LOG_ERR,
              "%s: the second UDP bind to port %s SUCCEEDED on Windows, where the port "
              "should be exclusive",
              what, port);
        return 1;
    }
    n_log(LOG_INFO, "%s: a second UDP bind to port %s was refused, as it must be on Windows", what, port);
#else
    n_log(LOG_INFO,
          "%s: a second UDP bind to port %s %s, which is what POSIX SO_REUSEADDR means "
          "for datagram sockets (shared receivers); the exclusivity that matters is "
          "asserted for TCP above and for UDP on Windows",
          what, port, ok ? "succeeded" : "was refused");
#endif
    return 0;
}
 
int main(void) {
    int rc = 0;
    set_log_level(LOG_INFO);
    rc |= check_exclusive(0);
    rc |= check_exclusive(1);
    if (rc == 0)
        printf(
            "ex_bind_exclusive: a TCP listener's port is exclusive; UDP is exclusive on Windows "
            "and shareable on POSIX, which is what SO_REUSEADDR means there\n");
    else
        printf("ex_bind_exclusive: FAILED\n");
    return rc;
}