udp-redirect.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <getopt.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <poll.h>
#include <string.h>
#include <math.h>
#include <netdb.h>
#include <time.h>

#define UDP_REDIRECT_VERSION    "2.2.0"

#define STATISTICS_DELAY_SECONDS    60

#define NETWORK_BUFFER_SIZE    65535

#define EOK 0

#define MAX_ERRNO 256

#define ERRNO_IGNORE_INIT(X)   memset((X), 0, MAX_ERRNO * sizeof(unsigned char))

#define ERRNO_IGNORE_SET(X, Y) if ((Y) >= 0 && (Y) < MAX_ERRNO) (X)[(Y)] = 1

#define ERRNO_IGNORE_CHECK(X, Y) ((Y) >= 0 && (Y) < MAX_ERRNO && (X)[(Y)] == 1)

enum DEBUG_LEVEL {
    DEBUG_LEVEL_ERROR = 0,      
    DEBUG_LEVEL_INFO = 1,       
    DEBUG_LEVEL_VERBOSE = 2,    
    DEBUG_LEVEL_DEBUG = 3       
};

#define PARSE_PORT(src, dest, label) \
    do { \
        char *_endptr; \
        long _val; \
        errno = EOK; \
        _val = strtol((src), &_endptr, 10); \
        if (errno != EOK || _endptr == (src) || *_endptr != '\0' || _val < 0 || _val > 65535) { \
            DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Invalid %s: %s", (label), (src)); \
            exit(EXIT_FAILURE); \
        } \
        (dest) = (int)_val; \
    } while (0)

#define DEBUG(debug_level_local, debug_level_message, fmt, ...) \
        do { \
            if ((debug_level_local) >= (debug_level_message)) { \
                fprintf(stderr, "%s:%d:%lld:%s(): " fmt "\n", __FILE__, \
                    __LINE__, (long long)(time(NULL)), __func__, ##__VA_ARGS__); \
            } \
        } while (0)

static struct option longopts[] = {
    { "verbose",               no_argument,            NULL,           'v' }, 
    { "debug",                 no_argument,            NULL,           'd' }, 
 
    { "listen-address",        required_argument,      NULL,           'a' }, 
    { "listen-port",           required_argument,      NULL,           'b' }, 
    { "listen-interface",      required_argument,      NULL,           'c' }, 
 
    { "connect-address",       required_argument,      NULL,           'g' }, 
    { "connect-host",          required_argument,      NULL,           'h' }, 
    { "connect-port",          required_argument,      NULL,           'i' }, 
 
    { "send-address",          required_argument,      NULL,           'm' }, 
    { "send-port",             required_argument,      NULL,           'n' }, 
    { "send-interface",        required_argument,      NULL,           'o' }, 
 
    { "listen-address-strict", no_argument,            NULL,           'x' }, 
    { "connect-address-strict",no_argument,            NULL,           'y' }, 
 
    { "listen-sender-address", required_argument,      NULL,           'k' }, 
    { "listen-sender-port",    required_argument,      NULL,           'l' }, 
 
    { "ignore-errors",         no_argument,            NULL,           'r' }, 
    { "stop-errors",           no_argument,            NULL,           's' }, 
 
    { "stats",                 no_argument,            NULL,           'q' }, 
 
    { "version",               no_argument,            NULL,           'z' }, 
 
    { NULL,                    0,                      NULL,            0 }
};

struct settings {
    char *laddr;        
    int lport;          
    char *lif;          
 
    char *caddr;        
    char *chost;        
    int cport;          
 
    char *saddr;        
    int sport;          
    char *sif;          
 
    int lstrict;        
    int cstrict;        
 
    char *lsaddr;       
    int lsport;         
 
    int eignore;        
 
    int stats;          
};

struct statistics {
    time_t time_display_last;   
    time_t time_display_first;  
 
    unsigned long count_listen_packet_receive;  
    unsigned long count_listen_byte_receive;    
 
    unsigned long count_listen_packet_send;     
    unsigned long count_listen_byte_send;       
 
    unsigned long count_connect_packet_receive; 
    unsigned long count_connect_byte_receive;   
 
    unsigned long count_connect_packet_send;    
    unsigned long count_connect_byte_send;      
 
    unsigned long count_listen_packet_receive_total;  
    unsigned long count_listen_byte_receive_total;    
 
    unsigned long count_listen_packet_send_total;     
    unsigned long count_listen_byte_send_total;       
 
    unsigned long count_connect_packet_receive_total; 
    unsigned long count_connect_byte_receive_total;   
 
    unsigned long count_connect_packet_send_total;    
    unsigned long count_connect_byte_send_total;      
};
 
/* Function prototypes */
 
static int socket_setup(const int debug_level, const char *desc, const char *xaddr, const int xport, const char *xif, int xfamily, struct sockaddr_storage *xsock_name);
static char *resolve_host(int debug_level, const char *host);
 
static int parse_addr(const char *str, int port, struct sockaddr_storage *out);
static const char *addr_tostring(const struct sockaddr_storage *sa, char *buf, size_t len);
static int addr_port(const struct sockaddr_storage *sa);
static socklen_t addr_len(const struct sockaddr_storage *sa);
static int addr_is_unset(const struct sockaddr_storage *sa);
static int addr_equal(const struct sockaddr_storage *a, const struct sockaddr_storage *b);
 
void settings_initialize(struct settings *s);
void usage(const char *argv0, const char *message);
 
void statistics_initialize(struct statistics *st);
double int_to_human_value(double value);
char int_to_human_char(double value);
void statistics_display(int debug_level, struct statistics *st, time_t now);

int main(int argc, char *argv[]) {
    /* Store debug level and program name */
    int debug_level = DEBUG_LEVEL_ERROR;
    char *argv0 = argv[0];
 
    int ch; /* Used by getopt_long */
 
    /* Command line arguments */
    struct settings s;
 
    struct statistics st;
 
    time_t now;
 
    int lsock; /* Listen socket */
    int ssock; /* Send socket */
 
    struct sockaddr_storage lsock_name; /* Listen socket name */
    struct sockaddr_storage ssock_name; /* Send socket name */
 
    struct sockaddr_storage caddr; /* Connect address */
 
    /* Simplify addr_tostring() usage in DEBUG() by reserving buffers */
    char print_buffer1[INET6_ADDRSTRLEN];
    char print_buffer2[INET6_ADDRSTRLEN];
 
    static char network_buffer[NETWORK_BUFFER_SIZE]; /* The network buffer. All reads and writes happen here */
 
    struct pollfd ufds[2]; /* Poll file descriptors */
 
    struct sockaddr_storage endpoint; /* Address where the current packet was received from */
    struct sockaddr_storage previous_endpoint; /* Address where the previous packet was received from */
 
    unsigned char errno_ignore[MAX_ERRNO];
 
    settings_initialize(&s);
    statistics_initialize(&st);
 
    while ((ch = getopt_long(argc, argv, "", longopts, NULL)) != -1) {
        switch (ch) {
            case 'v': /* --verbose */
                if (debug_level < DEBUG_LEVEL_VERBOSE) {
                    debug_level = DEBUG_LEVEL_VERBOSE;
                } else {
                    debug_level = debug_level + 1;
                }
 
                break;
            case 'd': /* --debug */
                debug_level = DEBUG_LEVEL_DEBUG;
 
                break;
            case 'a': /* --listen-address */
                s.laddr = optarg;
 
                break;
            case 'b': /* --listen-port */
                PARSE_PORT(optarg, s.lport, "listen port");
 
                break;
            case 'c': /* --listeninterface */
                s.lif = optarg;
 
                break;
            case 'g': /* --connect-address */
                s.caddr = optarg;
 
                break;
            case 'h': /* --connect-host */
                s.chost = optarg;
 
                break;
            case 'i': /* --connect-port */
                PARSE_PORT(optarg, s.cport, "connect port");
 
                break;
            case 'm': /* --send-address */
                s.saddr = optarg;
 
                break;
            case 'n': /* --send-port */
                PARSE_PORT(optarg, s.sport, "send port");
 
                break;
            case 'o': /* --send-interface */
                s.sif = optarg;
 
                break;
            case 'x': /* --listen-address-strict */
                s.lstrict = 1;
 
                break;
            case 'y': /* --connect-address-strict */
                s.cstrict = 1;
 
                break;
            case 'k': /* --listen-sender-address */
                s.lsaddr = optarg;
 
                break;
            case 'l': /* --listen-sender-port */
                PARSE_PORT(optarg, s.lsport, "listen sender port");
 
                break;
            case 'r': /* --ignore-errors */
                s.eignore = 1;
 
                break;
            case 's': /* --stop-errors */
                s.eignore = 0;
 
                break;
            case 'q': /* --stats */
                s.stats = 1;
 
                break;
            case 'z': /* --version */
                fprintf(stderr, "udp-redirect v%s\n", UDP_REDIRECT_VERSION);
                exit(EXIT_SUCCESS);
 
                break;
            default:
                usage(argv0, NULL);
                break;
        }
    }
    argc -= optind;
    argv += optind;
 
    if (argc != 0) {
        usage(argv0, "Unknown argument");
    }
 
    if (s.lport == 0) {
        usage(argv0, "Listen port not specified");
    }
 
    if (s.caddr == NULL && s.chost == NULL) {
        usage(argv0, "Connect host or address not specified");
    }
 
    if (s.cport == 0) {
        usage(argv0, "Connect port not specified");
    }
 
    if ((s.lsaddr != NULL && s.lsport == 0) ||
            (s.lsaddr == NULL && s.lsport != 0)) {
        usage(argv0, "Options --listen-sender-port and --list-sender-address must either both be specified or none");
    }
 
    /* Set strict mode if using lsport and csport */
    if (s.lsaddr != NULL && s.lsport != 0) {
        s.lstrict = 1;
    }
 
    /* Resolve connect host if available */
    char *caddr_alloc = NULL;
    if (s.chost != NULL) {
        caddr_alloc = resolve_host(debug_level, s.chost);
        s.caddr = caddr_alloc;
    }
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "---- INFO ----");
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Listen address: %s", (s.laddr != NULL)?s.laddr:"ANY");
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Listen port: %d", s.lport);
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Listen interface: %s", (s.lif != NULL)?s.lif:"ANY");
 
    if (s.chost != NULL) {
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "Connect host: %s", s.chost);
    }
 
    if (s.caddr != NULL) {
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "Connect address: %s", s.caddr);
    }
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Connect port: %d", s.cport);
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Send address: %s", (s.saddr != NULL)?s.saddr:"ANY");
    if (s.sport != 0) {
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "Send port: %d", s.sport);
    } else {
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "Send port: %s", "ANY");
    }
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Send interface: %s", (s.sif != NULL)?s.sif:"ANY");
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Listen strict: %s", s.lstrict?"ENABLED":"DISABLED");
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Connect strict: %s", s.cstrict?"ENABLED":"DISABLED");
 
    if (s.lsaddr != NULL) {
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "Listen only accepts packets from address: %s", s.lsaddr);
    }
    if (s.lsport != 0) {
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "Listen only accepts packets from port: %d", s.lsport);
    }
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Ignore errors: %s", s.eignore?"ENABLED":"DISABLED");
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Display stats: %s", s.stats?"ENABLED":"DISABLED");
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "---- START ----");
 
    /* Set up connect address first so we know the family for the sockets below */
    if (parse_addr(s.caddr, s.cport, &caddr) == -1) {
        DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Invalid connect address: %s", s.caddr);
 
        if (caddr_alloc != NULL) {
            free(caddr_alloc);
        }
        exit(EXIT_FAILURE);
    }
    if (caddr_alloc != NULL) {
        free(caddr_alloc);
        s.caddr = NULL;
    }
 
    /* Determine listen socket family independently from the connect family.
     * When --listen-address is given its family drives lsock, enabling
     * cross-family forwarding (e.g. IPv4 listen with IPv6 connect).
     * When no listen address is given, fall back to the connect family. */
    int lsock_family = (int)caddr.ss_family;
    if (s.laddr != NULL) {
        struct sockaddr_storage tmp;
        memset(&tmp, 0, sizeof(tmp));
        int f = parse_addr(s.laddr, 0, &tmp);
        if (f != -1)
            lsock_family = f;
        /* parse failure is caught and reported inside socket_setup */
    }
 
    if (lsock_family != (int)caddr.ss_family) {
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "Cross-family forwarding: listen %s, connect/send %s",
            (lsock_family == AF_INET6) ? "IPv6" : "IPv4",
            ((int)caddr.ss_family == AF_INET6) ? "IPv6" : "IPv4");
    }
 
    /* Validate: --send-address family must match --connect-address family */
    if (s.saddr != NULL) {
        struct sockaddr_storage tmp;
        memset(&tmp, 0, sizeof(tmp));
        int f = parse_addr(s.saddr, 0, &tmp);
        if (f != -1 && f != (int)caddr.ss_family) {
            DEBUG(debug_level, DEBUG_LEVEL_ERROR,
                "Send address family (%s) does not match connect address family (%s)",
                (f == AF_INET6) ? "IPv6" : "IPv4",
                ((int)caddr.ss_family == AF_INET6) ? "IPv6" : "IPv4");
            exit(EXIT_FAILURE);
        }
    }
 
    lsock = socket_setup(debug_level, "Listen", s.laddr, s.lport, s.lif, lsock_family, &lsock_name); /* Set up listening socket */
    ssock = socket_setup(debug_level, "Send", s.saddr, s.sport, s.sif, (int)caddr.ss_family, &ssock_name); /* Set up send socket */
 
    memset(&endpoint, 0, sizeof(endpoint)); /* No packet received, no endpoint */
 
    /* previous_endpoint: ss_family == 0 (zero-init) means "no endpoint seen yet" */
    memset(&previous_endpoint, 0, sizeof(previous_endpoint));
    if (s.lsaddr != NULL && s.lsport != 0) {
        if (parse_addr(s.lsaddr, s.lsport, &previous_endpoint) == -1) {
            DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Invalid listen sender address: %s", s.lsaddr);
 
            exit(EXIT_FAILURE);
        }
    }
 
    socklen_t endpoint_len = sizeof(endpoint);
 
    ERRNO_IGNORE_INIT(errno_ignore);
    ERRNO_IGNORE_SET(errno_ignore, EINTR); /* Always ignore EINTR */
 
    if (s.eignore == 1) { /* List of harmless recvfrom / sendto errors. Possibly incorrect. */
        ERRNO_IGNORE_SET(errno_ignore, EAGAIN);
        ERRNO_IGNORE_SET(errno_ignore, EHOSTUNREACH);
        ERRNO_IGNORE_SET(errno_ignore, ENETDOWN);
        ERRNO_IGNORE_SET(errno_ignore, ENETUNREACH);
        ERRNO_IGNORE_SET(errno_ignore, ENOBUFS);
        ERRNO_IGNORE_SET(errno_ignore, EPIPE);
        ERRNO_IGNORE_SET(errno_ignore, EADDRNOTAVAIL);
    }
 
    DEBUG(debug_level, DEBUG_LEVEL_VERBOSE, "entering infinite loop");
 
    st.time_display_first = st.time_display_last = time(NULL);
 
    /* Main loop */
    while (1) {
        int poll_retval;
        ssize_t recvfrom_retval;
        ssize_t sendto_retval;
 
        now = time(NULL);
 
        ufds[0].fd = lsock; ufds[0].events = POLLIN | POLLPRI; ufds[0].revents = 0;
        ufds[1].fd = ssock; ufds[1].events = POLLIN | POLLPRI; ufds[1].revents = 0;
 
        DEBUG(debug_level, DEBUG_LEVEL_DEBUG, "waiting for readable sockets");
 
        if (s.stats && (now - st.time_display_last) >= STATISTICS_DELAY_SECONDS) {
            statistics_display(debug_level, &st, now);
            st.time_display_last = now;
        }
 
        if ((poll_retval = poll(ufds, 2, 1000)) == -1) {
            if (errno == EINTR) {
                continue;
            }
 
            perror("poll");
            DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Could not check readable sockets (%d)", errno);
 
            exit(EXIT_FAILURE);
        }
        if (poll_retval == 0) {
            DEBUG(debug_level, DEBUG_LEVEL_DEBUG, "poll timeout");
            continue;
        }
 
        /* New data on the LISTEN socket */
        if (ufds[0].revents & POLLIN || ufds[0].revents & POLLPRI) {
            endpoint_len = sizeof(endpoint);
            if ((recvfrom_retval = recvfrom(lsock, network_buffer, sizeof(network_buffer), 0,
                            (struct sockaddr *)&endpoint, &endpoint_len)) == -1) {
                if (!ERRNO_IGNORE_CHECK(errno_ignore, errno)) {
                    perror("recvfrom");
                    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Listen cannot receive (%d)", errno);
 
                    exit(EXIT_FAILURE);
                }
            }
            if (recvfrom_retval >= 0) {
                st.count_listen_packet_receive++;
                st.count_listen_byte_receive += recvfrom_retval;
 
                DEBUG(debug_level, DEBUG_LEVEL_DEBUG, "RECEIVE (%s, %d) -> (%s, %d) (LISTEN PORT): %zd bytes",
                        addr_tostring(&endpoint, print_buffer1, sizeof(print_buffer1)), addr_port(&endpoint),
                        addr_tostring(&lsock_name, print_buffer2, sizeof(print_buffer2)), addr_port(&lsock_name),
                        recvfrom_retval);

                if ((addr_is_unset(&previous_endpoint) || !s.lstrict) ||
                        addr_equal(&previous_endpoint, &endpoint)) {
 
                    if (addr_is_unset(&previous_endpoint) || !s.lstrict) {
                        if (!addr_equal(&previous_endpoint, &endpoint)) {
                            DEBUG(debug_level, DEBUG_LEVEL_DEBUG, "LISTEN remote endpoint set to (%s, %d)", addr_tostring(&endpoint, print_buffer1, sizeof(print_buffer1)), addr_port(&endpoint));
                        }
 
                        memcpy(&previous_endpoint, &endpoint, sizeof(endpoint));
                    }
 
                    if ((sendto_retval = sendto(ssock, network_buffer, recvfrom_retval, 0,
                                    (struct sockaddr *)&caddr, addr_len(&caddr))) == -1) {
                        if (!ERRNO_IGNORE_CHECK(errno_ignore, errno)) {
                            perror("sendto");
                            DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Cannot send packet to send port (%d)", errno);
 
                            exit(EXIT_FAILURE);
                        }
                    } else { // At least one byte was sent, record it
                        st.count_connect_packet_send++;
                        st.count_connect_byte_send += sendto_retval;
                    }
 
                    DEBUG(debug_level, (sendto_retval == recvfrom_retval || s.eignore == 1)?DEBUG_LEVEL_DEBUG:DEBUG_LEVEL_ERROR,
                            "SEND (%s, %d) -> (%s, %d) (SEND PORT): %zd bytes (%s WRITE %zd bytes)",
                            addr_tostring(&ssock_name, print_buffer1, sizeof(print_buffer1)), addr_port(&ssock_name),
                            addr_tostring(&caddr, print_buffer2, sizeof(print_buffer2)), addr_port(&caddr),
                            sendto_retval,
                            (sendto_retval == recvfrom_retval)?"FULL":"PARTIAL", recvfrom_retval);
                } else {
                    DEBUG(debug_level, DEBUG_LEVEL_ERROR, "LISTEN PORT invalid source (%s, %d), was expecting (%s, %d)",
                            addr_tostring(&endpoint, print_buffer1, sizeof(print_buffer1)), addr_port(&endpoint),
                            addr_tostring(&previous_endpoint, print_buffer2, sizeof(print_buffer2)), addr_port(&previous_endpoint));
                }
            }
        }
 
        /* New data on the SEND socket */
        if (ufds[1].revents & POLLIN || ufds[1].revents & POLLPRI) {
            endpoint_len = sizeof(endpoint);
            if ((recvfrom_retval = recvfrom(ssock, network_buffer, sizeof(network_buffer), 0,
                            (struct sockaddr *)&endpoint, &endpoint_len)) == -1) {
                if (!ERRNO_IGNORE_CHECK(errno_ignore, errno)) {
                    perror("recvfrom");
                    DEBUG(debug_level, DEBUG_LEVEL_INFO, "Send cannot receive packet (%d)", errno);
 
                    exit(EXIT_FAILURE);
                }
            }
            if (recvfrom_retval >= 0) {
                st.count_connect_packet_receive++;
                st.count_connect_byte_receive += recvfrom_retval;
 
                DEBUG(debug_level, DEBUG_LEVEL_DEBUG, "RECEIVE (%s, %d) -> (%s, %d) (SEND PORT): %zd bytes",
                        addr_tostring(&endpoint, print_buffer1, sizeof(print_buffer1)), addr_port(&endpoint),
                        addr_tostring(&ssock_name, print_buffer2, sizeof(print_buffer2)), addr_port(&ssock_name),
                        recvfrom_retval);

                if (!addr_is_unset(&previous_endpoint) &&
                        (!s.cstrict || addr_equal(&caddr, &endpoint))) {
 
                    if ((sendto_retval = sendto(lsock, network_buffer, recvfrom_retval, 0,
                                    (struct sockaddr *)&previous_endpoint, addr_len(&previous_endpoint))) == -1) {
                        if (!ERRNO_IGNORE_CHECK(errno_ignore, errno)) {
                            perror("sendto");
                            DEBUG(debug_level, DEBUG_LEVEL_INFO, "Cannot send packet to listen port (%d)", errno);
 
                            exit(EXIT_FAILURE);
                        }
                    } else { // At least one byte was sent, record it
                        st.count_listen_packet_send++;
                        st.count_listen_byte_send += sendto_retval;
                    }
 
                    DEBUG(debug_level, (sendto_retval == recvfrom_retval || s.eignore == 1)?DEBUG_LEVEL_DEBUG:DEBUG_LEVEL_ERROR,
                            "SEND (%s, %d) -> (%s, %d) (LISTEN PORT): %zd bytes (%s WRITE %zd bytes)",
                            addr_tostring(&lsock_name, print_buffer1, sizeof(print_buffer1)), addr_port(&lsock_name),
                            addr_tostring(&previous_endpoint, print_buffer2, sizeof(print_buffer2)), addr_port(&previous_endpoint),
                            sendto_retval,
                            (sendto_retval == recvfrom_retval)?"FULL":"PARTIAL", recvfrom_retval);
                } else {
                    DEBUG(debug_level, DEBUG_LEVEL_ERROR, "SEND PORT invalid source (%s, %d), was expecting (%s, %d)",
                            addr_tostring(&endpoint, print_buffer1, sizeof(print_buffer1)), addr_port(&endpoint),
                            addr_tostring(&caddr, print_buffer2, sizeof(print_buffer2)), addr_port(&caddr));
                }
            }
        }
    }
 
    /* Never reached. */
    return 0;
}
 
/* Network helper functions below */

static int parse_addr(const char *str, int port, struct sockaddr_storage *out) {
    struct sockaddr_in  *a4 = (struct sockaddr_in  *)out;
    struct sockaddr_in6 *a6 = (struct sockaddr_in6 *)out;
 
    memset(out, 0, sizeof(*out));
 
    /* Reject IPv6 zone IDs (e.g. "fe80::1%en0"): inet_pton on macOS silently
     * accepts them but drops the scope, leading to inconsistent behaviour
     * across platforms.  Zone IDs are not supported. */
    if (strchr(str, '%') != NULL)
        return -1;
 
    if (inet_pton(AF_INET, str, &a4->sin_addr) == 1) {
        out->ss_family = AF_INET;
        a4->sin_port   = htons(port);
        return AF_INET;
    }
    if (inet_pton(AF_INET6, str, &a6->sin6_addr) == 1) {
        out->ss_family  = AF_INET6;
        a6->sin6_port   = htons(port);
        return AF_INET6;
    }
    return -1;
}

static const char *addr_tostring(const struct sockaddr_storage *sa, char *buf, size_t len) {
    const void *ptr;
    if (sa->ss_family == AF_INET6)
        ptr = &((const struct sockaddr_in6 *)sa)->sin6_addr;
    else
        ptr = &((const struct sockaddr_in  *)sa)->sin_addr;
    return inet_ntop((int)sa->ss_family, ptr, buf, (socklen_t)len) ? buf : "?";
}

static int addr_port(const struct sockaddr_storage *sa) {
    if (sa->ss_family == AF_INET6)
        return ntohs(((const struct sockaddr_in6 *)sa)->sin6_port);
    return ntohs(((const struct sockaddr_in *)sa)->sin_port);
}

static socklen_t addr_len(const struct sockaddr_storage *sa) {
    return (sa->ss_family == AF_INET6)
        ? (socklen_t)sizeof(struct sockaddr_in6)
        : (socklen_t)sizeof(struct sockaddr_in);
}

static int addr_is_unset(const struct sockaddr_storage *sa) {
    return sa->ss_family == 0;
}

static int addr_equal(const struct sockaddr_storage *a, const struct sockaddr_storage *b) {
    if (a->ss_family != b->ss_family)
        return 0;
    if (a->ss_family == AF_INET) {
        const struct sockaddr_in *a4 = (const struct sockaddr_in *)a;
        const struct sockaddr_in *b4 = (const struct sockaddr_in *)b;
        return a4->sin_addr.s_addr == b4->sin_addr.s_addr &&
               a4->sin_port        == b4->sin_port;
    }
    if (a->ss_family == AF_INET6) {
        const struct sockaddr_in6 *a6 = (const struct sockaddr_in6 *)a;
        const struct sockaddr_in6 *b6 = (const struct sockaddr_in6 *)b;
        return memcmp(&a6->sin6_addr, &b6->sin6_addr, sizeof(struct in6_addr)) == 0 &&
               a6->sin6_port == b6->sin6_port;
    }
    return 0;
}

static int socket_setup(const int debug_level, const char *desc, const char *xaddr, const int xport, const char *xif, int xfamily, struct sockaddr_storage *xsock_name) {
    int xsock;
    const int enable = 1;
    int family;
    struct sockaddr_storage addr;
 
    memset(&addr, 0, sizeof(addr));
 
    /* Determine address family and fill bind address */
    if (xaddr != NULL) {
        if (parse_addr(xaddr, xport, &addr) == -1) {
            DEBUG(debug_level, DEBUG_LEVEL_ERROR, "%s address invalid: %s", desc, xaddr);
 
            exit(EXIT_FAILURE);
        }
        family = (int)addr.ss_family;
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "%s socket: bind to address %s", desc, xaddr);
    } else {
        family = xfamily;
        addr.ss_family = (sa_family_t)family;
        if (family == AF_INET6) {
            ((struct sockaddr_in6 *)&addr)->sin6_addr = in6addr_any;
            ((struct sockaddr_in6 *)&addr)->sin6_port = htons(xport);
        } else {
            ((struct sockaddr_in *)&addr)->sin_addr.s_addr = INADDR_ANY;
            ((struct sockaddr_in *)&addr)->sin_port = htons(xport);
        }
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "%s socket: bind to address %s", desc, "ANY");
    }
 
    /* Port specified or any */
    if (xport != 0) {
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "%s socket: bind to port %d", desc, xport);
    } else {
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "%s socket: bind to port %s", desc, "ANY");
    }
 
    /* Set up socket */
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "%s socket: create", desc);
    if ((xsock = socket(family, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
        perror("socket");
        DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Cannot create DGRAM socket (%d)", errno);
 
        exit(EXIT_FAILURE);
    }
 
    if (xif != NULL) {
#ifdef __MACH__
        unsigned int xif_idx;
 
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "%s socket: bind to interface %s", desc, xif);
 
        if ((xif_idx = if_nametoindex(xif)) == 0) {
            perror("if_nametoindex");
            DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Cannot get the interface ID (%d)", errno);
 
            exit(EXIT_FAILURE);
        }
 
        {
            int if_level  = (family == AF_INET6) ? IPPROTO_IPV6 : IPPROTO_IP;
            int if_optname = (family == AF_INET6) ? IPV6_BOUND_IF : IP_BOUND_IF;
            if (setsockopt(xsock, if_level, if_optname, &xif_idx, sizeof(xif_idx)) == -1) {
                perror("setsockopt");
                DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Cannot set socket interface (%d)", errno);
 
                exit(EXIT_FAILURE);
            }
        }
#elif __unix__
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "%s socket: bind to interface %s", desc, xif);
 
        if (strlen(xif) >= IFNAMSIZ) {
            DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Interface name too long (max %d): %s", IFNAMSIZ - 1, xif);
            exit(EXIT_FAILURE);
        }
 
        if (setsockopt(xsock, SOL_SOCKET, SO_BINDTODEVICE, xif, strlen(xif) + 1) == -1) {
            perror("setsockopt");
            DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Cannot set socket interface (%d)", errno);
 
            exit(EXIT_FAILURE);
        }
#endif
    } else {
        DEBUG(debug_level, DEBUG_LEVEL_INFO, "%s socket: bind to interface %s", desc, "ANY");
    }
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "%s socket: reuse local address", desc);
 
    if (setsockopt(xsock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int)) < 0) {
        perror("setsockopt");
        DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Cannot set socket SO_REUSEADDR (%d)", errno);
 
        exit(EXIT_FAILURE);
    }
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "%s socket: set nonblocking", desc);
    if (fcntl(xsock, F_SETFL, O_NONBLOCK) == -1) {
        perror("fcntl");
        DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Cannot set socket O_NONBLOCK (%d)", errno);
 
        exit(EXIT_FAILURE);
    }
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "%s socket: bind", desc);
    if (bind(xsock, (struct sockaddr *)&addr, addr_len(&addr)) == -1) {
        perror("bind");
        DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Cannot bind socket (%d)", errno);
 
        exit(EXIT_FAILURE);
    }
 
    socklen_t xsock_name_len = sizeof(*xsock_name);
    if (getsockname(xsock, (struct sockaddr *)xsock_name, &xsock_name_len) == -1) {
        perror("getsockname");
        DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Cannot get socket name (%d)", errno);
 
        exit(EXIT_FAILURE);
    }
 
    return xsock;
}

static char *resolve_host(int debug_level, const char *host) {
    struct addrinfo hints;
    struct addrinfo *res;
    char buf[INET6_ADDRSTRLEN];
    char *retval;
    int rc;
 
    memset(&hints, 0, sizeof(hints));
    hints.ai_family   = AF_UNSPEC;   /* accept IPv4 or IPv6 */
    hints.ai_socktype = SOCK_DGRAM;
 
    if ((rc = getaddrinfo(host, NULL, &hints, &res)) != 0) {
        DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Could not resolve host %s: %s", host, gai_strerror(rc));
 
        exit(EXIT_FAILURE);
    }
 
    /* Use the first result; inet_ntop converts it back to a string for parse_addr() */
    {
        const void *addr_ptr = (res->ai_family == AF_INET6)
            ? (const void *)&((struct sockaddr_in6 *)res->ai_addr)->sin6_addr
            : (const void *)&((struct sockaddr_in  *)res->ai_addr)->sin_addr;
 
        if (inet_ntop(res->ai_family, addr_ptr, buf, sizeof(buf)) == NULL) {
            perror("inet_ntop");
            DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Could not format resolved address (%d)", errno);
            freeaddrinfo(res);
 
            exit(EXIT_FAILURE);
        }
    }
 
    freeaddrinfo(res);
 
    if ((retval = strdup(buf)) == NULL) {
        perror("strdup");
        DEBUG(debug_level, DEBUG_LEVEL_ERROR, "Could not duplicate resolved address string (%d)", errno);
 
        exit(EXIT_FAILURE);
    }
 
    DEBUG(debug_level, DEBUG_LEVEL_DEBUG, "Resolved %s to %s", host, retval);
 
    return retval;
}
 
/* Settings helper functions below */

void settings_initialize(struct settings *s) {
    s->laddr = NULL;
    s->lport = 0;
    s->lif = NULL;
 
    s->caddr = NULL;
    s->chost = NULL;
    s->cport = 0;
 
    s->saddr = NULL;
    s->sport = 0;
    s->sif = NULL;
 
    s->lstrict = 0;
    s->cstrict = 0;
 
    s->lsaddr = NULL;
    s->lsport = 0;
 
    s->eignore = 1;
    s->stats = 0;
}

void usage(const char *argv0, const char *message) {
    if (message != NULL)
        fprintf(stderr, "%s\n", message);
 
    fprintf(stderr, "Usage: %s\n", argv0);
    fprintf(stderr, "          [--listen-address <address>] --listen-port <port> [--listen-interface <interface>]\n");
    fprintf(stderr, "          [--connect-address <address> | --connect-host <hostname> --connect-port <port>\n");
    fprintf(stderr, "          [--send-address <address>] [--send-port <port>] [--send-interface <interface>]\n");
    fprintf(stderr, "          [--listen-address-strict] [--connect-address-strict]\n");
    fprintf(stderr, "          [--listen-sender-address <address>] [--listen-sender-port <port>]\n");
    fprintf(stderr, "          [--ignore-errors] [--stop-errors]\n");
    fprintf(stderr, "          [--stats] [--verbose] [--debug] [--version]\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "--stats                                 Display sent/received bytes statistics every 60 seconds (optional)\n");
    fprintf(stderr, "--verbose                               Verbose mode, can be specified multiple times (optional)\n");
    fprintf(stderr, "--debug                                 Debug mode (optional)\n");
    fprintf(stderr, "--version                               Display the version and exit\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "--listen-address <address>              Listen address, IPv4 or IPv6 (optional)\n");
    fprintf(stderr, "--listen-port <port>                    Listen port (required)\n");
    fprintf(stderr, "--listen-interface <interface>          Listen interface name (optional)\n");
    fprintf(stderr, "--listen-address-strict                 Only receive packets from the same source as the first packet (optional)\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "--connect-address <address>             Connect address, IPv4 or IPv6 (optional if --connect-host is specified)\n");
    fprintf(stderr, "--connect-host <hostname>               Connect host, overwrites --connect-address if both are specified (optional if --connect-address is specified)\n");
    fprintf(stderr, "--connect-port <port>                   Connect port (required)\n");
    fprintf(stderr, "--connect-address-strict                Only receive packets from --connect-address / --connect-port (optional)\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "--send-address <address>                Send packets from address, IPv4 or IPv6 (optional)\n");
    fprintf(stderr, "--send-port <port>                      Send packets from port (optional)\n");
    fprintf(stderr, "--send-interface <interface>            Send packets from interface (optional)\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "--listen-sender-address <address>       Listen endpoint only accepts packets from this source address, IPv4 or IPv6 (optional)\n");
    fprintf(stderr, "--listen-sender-port <port>             Listen endpoint only accepts packets from this source port (optional)\n");
    fprintf(stderr, "                                        (must be set together, --listen-address-strict is implied)\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "--ignore-errors                         Ignore most receive or send errors (unreachable, etc.) instead of exiting (optional) (default)\n");
    fprintf(stderr, "--stop-errors                           Exit on most receive or send errors (unreachable, etc.) (optional)\n");
    fprintf(stderr, "\n");
 
    exit(EXIT_FAILURE);
}
 
/* Statistics helper functions below */

#define HUMAN_READABLE_FORMAT "%.1lf%c"

#define HRF HUMAN_READABLE_FORMAT

#define HUMAN_READABLE(X) int_to_human_value((X)), int_to_human_char((X))

#define HUMAN_READABLE_SIZES { ' ', 'K', 'M', 'G', 'T', 'P', 'E' }

#define HUMAN_READABLE_SIZES_COUNT 7

void statistics_initialize(struct statistics *st) {
    st->time_display_last = 0;
    st->time_display_first = 0;
 
    st->count_listen_packet_receive = 0;
    st->count_listen_byte_receive = 0;
 
    st->count_listen_packet_send = 0;
    st->count_listen_byte_send = 0;
 
    st->count_connect_packet_receive = 0;
    st->count_connect_byte_receive = 0;
 
    st->count_connect_packet_send = 0;
    st->count_connect_byte_send = 0;
 
    st->count_listen_packet_receive_total = 0;
    st->count_listen_byte_receive_total = 0;
 
    st->count_listen_packet_send_total = 0;
    st->count_listen_byte_send_total = 0;
 
    st->count_connect_packet_receive_total = 0;
    st->count_connect_byte_receive_total = 0;
 
    st->count_connect_packet_send_total = 0;
    st->count_connect_byte_send_total = 0;
}

static double int_to_human_scale(double value, int *count_out) {
    int count = 0;
 
    while (value >= 1000 && count < (HUMAN_READABLE_SIZES_COUNT - 1)) {
        value = value / 1000;
        count = count + 1;
    }
 
    *count_out = count;
    return value;
}

double int_to_human_value(double value) {
    int count;
    return int_to_human_scale(value, &count);
}

char int_to_human_char(double value) {
    static const char human_readable_sizes[] = HUMAN_READABLE_SIZES;
    int count;
    int_to_human_scale(value, &count);
    return human_readable_sizes[count];
}

void statistics_display(int debug_level, struct statistics *st, time_t now) {
    /* Stats were explicitly requested: ensure they're visible at any verbosity level. */
    if (debug_level < DEBUG_LEVEL_INFO)
        debug_level = DEBUG_LEVEL_INFO;
 
    time_t time_delta = now - st->time_display_last;
    time_t time_delta_total = now - st->time_display_first;
 
    /* Clamp to 1 to avoid division by zero when called within the same second. */
    if (time_delta < 1)
        time_delta = 1;
    if (time_delta_total < 1)
        time_delta_total = 1;
 
    st->count_listen_packet_receive_total += st->count_listen_packet_receive;
    st->count_listen_byte_receive_total += st->count_listen_byte_receive;
    st->count_listen_packet_send_total += st->count_listen_packet_send;
    st->count_listen_byte_send_total += st->count_listen_byte_send;
 
    st->count_connect_packet_receive_total += st->count_connect_packet_receive;
    st->count_connect_byte_receive_total += st->count_connect_byte_receive;
    st->count_connect_packet_send_total += st->count_connect_packet_send;
    st->count_connect_byte_send_total += st->count_connect_byte_send;
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "---- STATS %ds ----", STATISTICS_DELAY_SECONDS);
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "listen:receive:packets: " HRF " (" HRF "/s), listen:receive:bytes: " HRF " (" HRF "/s)",
            HUMAN_READABLE((double)st->count_listen_packet_receive),
            HUMAN_READABLE((double)st->count_listen_packet_receive / time_delta),
            HUMAN_READABLE((double)st->count_listen_byte_receive),
            HUMAN_READABLE((double)st->count_listen_byte_receive / time_delta));
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "listen:send:packets: " HRF " (" HRF "/s), listen:send:bytes: " HRF " (" HRF "/s)",
            HUMAN_READABLE((double)st->count_listen_packet_send),
            HUMAN_READABLE((double)st->count_listen_packet_send / time_delta),
            HUMAN_READABLE((double)st->count_listen_byte_send),
            HUMAN_READABLE((double)st->count_listen_byte_send / time_delta));
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "connect:receive:packets: " HRF " (" HRF "/s), connect:receive:bytes: " HRF " (" HRF "/s)",
            HUMAN_READABLE((double)st->count_connect_packet_receive),
            HUMAN_READABLE((double)st->count_connect_packet_receive / time_delta),
            HUMAN_READABLE((double)st->count_connect_byte_receive),
            HUMAN_READABLE((double)st->count_connect_byte_receive / time_delta));
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "connect:send:packets: " HRF " (" HRF "/s), connect:send:bytes: " HRF " (" HRF "/s)",
            HUMAN_READABLE((double)st->count_connect_packet_send),
            HUMAN_READABLE((double)st->count_connect_packet_send / time_delta),
            HUMAN_READABLE((double)st->count_connect_byte_send),
            HUMAN_READABLE((double)st->count_connect_byte_send / time_delta));
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "---- STATS TOTAL ----");
 
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "listen:receive:packets: " HRF " (" HRF "/s), listen:receive:bytes: " HRF " (" HRF "/s)",
            HUMAN_READABLE((double)st->count_listen_packet_receive_total),
            HUMAN_READABLE((double)st->count_listen_packet_receive_total / time_delta_total),
            HUMAN_READABLE((double)st->count_listen_byte_receive_total),
            HUMAN_READABLE((double)st->count_listen_byte_receive_total / time_delta_total));
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "listen:send:packets: " HRF " (" HRF "/s), listen:send:bytes: " HRF " (" HRF "/s)",
            HUMAN_READABLE((double)st->count_listen_packet_send_total),
            HUMAN_READABLE((double)st->count_listen_packet_send_total / time_delta_total),
            HUMAN_READABLE((double)st->count_listen_byte_send_total),
            HUMAN_READABLE((double)st->count_listen_byte_send_total / time_delta_total));
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "connect:receive:packets: " HRF " (" HRF "/s), connect:receive:bytes: " HRF " (" HRF "/s)",
            HUMAN_READABLE((double)st->count_connect_packet_receive_total),
            HUMAN_READABLE((double)st->count_connect_packet_receive_total / time_delta_total),
            HUMAN_READABLE((double)st->count_connect_byte_receive_total),
            HUMAN_READABLE((double)st->count_connect_byte_receive_total / time_delta_total));
    DEBUG(debug_level, DEBUG_LEVEL_INFO, "connect:send:packets: " HRF " (" HRF "/s), connect:send:bytes: " HRF " (" HRF "/s)",
            HUMAN_READABLE((double)st->count_connect_packet_send_total),
            HUMAN_READABLE((double)st->count_connect_packet_send_total / time_delta_total),
            HUMAN_READABLE((double)st->count_connect_byte_send_total),
            HUMAN_READABLE((double)st->count_connect_byte_send_total / time_delta_total));
 
    st->count_listen_packet_receive = st->count_listen_byte_receive = \
        st->count_listen_packet_send = st->count_listen_byte_send = \
        st->count_connect_packet_receive = st->count_connect_byte_receive = \
        st->count_connect_packet_send = st->count_connect_byte_send = 0;
}