tcp-ip-sockets-in-c/common/Practical.c

#include <stdio.h>
#include <netdb.h>
#include <netinet/in.h>
#include <stddef.h>
#include <arpa/inet.h>
#include <string.h>

#include "Practical.h"

int proto_get_num(const char *name) {
    struct protoent *protoent = getprotobyname(name);
    if (protoent == NULL) {
        DieWithSystemMessage("getprotobyname");
    }
    return protoent->p_proto;
}

void PrintSocketAddress(const struct sockaddr *address, FILE *stream) {
    if (address == nullptr || stream == nullptr) {
        return;
    }

    void *numericAddress = nullptr;
    char addrBuffer[INET6_ADDRSTRLEN];
    in_port_t port;
    switch (address->sa_family) {
    case AF_INET:
        const struct sockaddr_in *const inet_addr = (struct sockaddr_in *) address;
        numericAddress = (void *) &inet_addr->sin_addr;
        port = ntohs(inet_addr->sin_port);
        break;
    case AF_INET6:
        const struct sockaddr_in6 *const inet6_addr = (struct sockaddr_in6 *) address;
        numericAddress = (void *) &inet6_addr->sin6_addr;
        port = ntohs(inet6_addr->sin6_port);
        break;
    default:
        fputs("[unkown type]", stream);
        return;
    }

    if (inet_ntop(
            address->sa_family,
            numericAddress,
            addrBuffer,
            sizeof(addrBuffer)
        )
        != nullptr) {
        fprintf(stream, "%s", addrBuffer);
        if (port != 0) {
            fprintf(stream, "-%u", port);
        }
    } else {
        fputs("[invalid address]", stream);
    }
}

// Chapter 3 exercise 4
int AF_to_PF(const int af) {
    switch (af) {
    case AF_UNSPEC:
        return PF_UNSPEC;
    case AF_LOCAL:
        return PF_LOCAL;
    case AF_INET:
        return PF_INET;
    case AF_AX25:
        return PF_AX25;
    case AF_IPX:
        return PF_IPX;
    case AF_APPLETALK:
        return PF_APPLETALK;
    case AF_NETROM:
        return PF_NETROM;
    case AF_BRIDGE:
        return PF_BRIDGE;
    case AF_ATMPVC:
        return PF_ATMPVC;
    case AF_X25:
        return PF_X25;
    case AF_INET6:
        return PF_INET6;
    case AF_ROSE:
        return PF_ROSE;
    case AF_DECnet:
        return PF_DECnet;
    case AF_NETBEUI:
        return PF_NETBEUI;
    case AF_SECURITY:
        return PF_SECURITY;
    case AF_KEY:
        return PF_KEY;
    case AF_PACKET:
        return PF_PACKET;
    case AF_ASH:
        return PF_ASH;
    case AF_ECONET:
        return PF_ECONET;
    case AF_ATMSVC:
        return PF_ATMSVC;
    case AF_RDS:
        return PF_RDS;
    case AF_SNA:
        return PF_SNA;
    case AF_IRDA:
        return PF_IRDA;
    case AF_PPPOX:
        return PF_PPPOX;
    case AF_WANPIPE:
        return PF_WANPIPE;
    case AF_LLC:
        return PF_LLC;
    case AF_IB:
        return PF_IB;
    case AF_MPLS:
        return PF_MPLS;
    case AF_CAN:
        return PF_CAN;
    case AF_TIPC:
        return PF_TIPC;
    case AF_BLUETOOTH:
        return PF_BLUETOOTH;
    case AF_IUCV:
        return PF_IUCV;
    case AF_RXRPC:
        return PF_RXRPC;
    case AF_ISDN:
        return PF_ISDN;
    case AF_PHONET:
        return PF_PHONET;
    case AF_IEEE802154:
        return PF_IEEE802154;
    case AF_CAIF:
        return PF_CAIF;
    case AF_ALG:
        return PF_ALG;
    case AF_NFC:
        return PF_NFC;
    case AF_VSOCK:
        return PF_VSOCK;
    case AF_KCM:
        return PF_KCM;
    case AF_QIPCRTR:
        return PF_QIPCRTR;
    case AF_SMC:
        return PF_SMC;
    case AF_XDP:
        return PF_XDP;
    case AF_MCTP:
        return PF_MCTP;
    case AF_MAX:
        return PF_MAX;
    }

    // Handle entries that (currently) have duplicate values
    if (af == AF_UNIX) {
        return PF_UNIX;
    }
    if (af == AF_FILE) {
        return PF_FILE;
    }
    if (af == AF_NETLINK) {
        return PF_NETLINK;
    }
    if (af == AF_ROUTE) {
        return PF_ROUTE;
    }

    DieWithUserMessage("AF_to_PF", "Unkown AF_ value");
    return -1; // Unreachable, makes LSP shut up about not returning a value.
}

bool sock_addrs_equal(const struct sockaddr *const a1, const struct sockaddr *const a2) {
    if (a1->sa_family != a2->sa_family) {
        return false;
    }
    if (a1->sa_family != AF_INET && a1->sa_family != AF_INET6) {
        DieWithUserMessage("Unsupported value for", "a1->sa_family");
    }

    const size_t addr_size = a1->sa_family == AF_INET
        ? sizeof(struct in_addr)
        : sizeof(struct in6_addr);

    return memcmp(a1->sa_data, a2->sa_data, addr_size) == 0;
}