UDP and ports

#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
/* ones' complement sum of 16-bit words (a trailing odd byte is padded with zero) */
static uint32_t add_words(uint32_t sum, const uint8_t *p, int n) {
    for (int i = 0; i < n; i += 2) {
        uint32_t w = (uint32_t)(p[i] << 8) | (i + 1 < n ? p[i + 1] : 0);
        sum += w;
        sum = (sum & 0xFFFF) + (sum >> 16);
    }
    return sum;
}
 
static uint32_t total(const uint8_t *dg, int n) {
    uint8_t pseudo[12] = {10, 0, 0, 1, 10, 0, 0, 2, 0, 17, (uint8_t)(n >> 8), (uint8_t)n};
    return add_words(add_words(0, pseudo, 12), dg, n);
}
 
int main(void) {
    uint8_t dg[] = {0x13, 0x88, 0x00, 0x35, 0x00, 0x0d, 0x94, 0x42, 'h', 'e', 'l', 'l', 'o'};
    int n = (int)sizeof dg;
    printf("source port %u, destination port %u, length %u, data %d bytes, checksum 0x%04X\n", (unsigned)(dg[0] << 8 | dg[1]), (unsigned)(dg[2] << 8 | dg[3]), (unsigned)(dg[4] << 8 | dg[5]), n - 8, (unsigned)(dg[6] << 8 | dg[7]));
    printf("receiver's sum over pseudo header and datagram: 0x%04X -> %s\n", (unsigned)total(dg, n), total(dg, n) == 0xFFFF ? "accepted" : "dropped");
 
    uint8_t copy[sizeof dg];
    memcpy(copy, dg, sizeof dg);
    copy[6] = copy[7] = 0;
    printf("checksum recomputed with the field set to zero: 0x%04X\n", (unsigned)(~total(copy, n) & 0xFFFF));
 
    dg[10] ^= 0x01;                                              /* one flipped bit in the data */
    printf("after flipping one bit: sum 0x%04X -> %s\n", (unsigned)total(dg, n), total(dg, n) == 0xFFFF ? "accepted" : "dropped");
    return 0;
}

source port 5000, destination port 53, length 13, data 5 bytes, checksum 0x9442
receiver's sum over pseudo header and datagram: 0xFFFF -> accepted
checksum recomputed with the field set to zero: 0x9442
after flipping one bit: sum 0x0100 -> dropped

#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <poll.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
 
static struct sockaddr_in loopback(unsigned short port) {
    struct sockaddr_in a;
    memset(&a, 0, sizeof a);
    a.sin_family = AF_INET;
    a.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    a.sin_port = port;
    return a;
}
 
static unsigned short port_of(int s) {
    struct sockaddr_in a;
    socklen_t len = sizeof a;
    getsockname(s, (struct sockaddr *)&a, &len);
    return a.sin_port;
}
 
int main(void) {
    int rx = socket(AF_INET, SOCK_DGRAM, 0);
    struct sockaddr_in to = loopback(0);
    if (bind(rx, (struct sockaddr *)&to, sizeof to) != 0) return 1;
    to = loopback(port_of(rx));
 
    int tx1 = socket(AF_INET, SOCK_DGRAM, 0), tx2 = socket(AF_INET, SOCK_DGRAM, 0);
    char buf[100] = {0};
    sendto(tx1, buf, 10, 0, (struct sockaddr *)&to, sizeof to);
    sendto(tx1, buf, 20, 0, (struct sockaddr *)&to, sizeof to);
    sendto(tx2, buf, 5, 0, (struct sockaddr *)&to, sizeof to);
    sendto(tx1, buf, 30, 0, (struct sockaddr *)&to, sizeof to);
    printf("one receiving socket, four datagrams from two senders:\n");
    for (int i = 0; i < 4; i++) {
        struct sockaddr_in from;
        socklen_t len = sizeof from;
        ssize_t n = recvfrom(rx, buf, sizeof buf, 0, (struct sockaddr *)&from, &len);
        printf("  recvfrom returned %zd bytes, sent by sender %d\n", n, from.sin_port == port_of(tx1) ? 1 : 2);
    }
 
    /* a port where nothing listens: bind a socket, note its port, close it */
    int tmp = socket(AF_INET, SOCK_DGRAM, 0);
    struct sockaddr_in dead = loopback(0);
    bind(tmp, (struct sockaddr *)&dead, sizeof dead);
    dead = loopback(port_of(tmp));
    close(tmp);
    int c = socket(AF_INET, SOCK_DGRAM, 0);
    connect(c, (struct sockaddr *)&dead, sizeof dead);
    ssize_t sent = send(c, "x", 1, 0);
    struct pollfd p = {c, POLLIN, 0};
    poll(&p, 1, 1000);
    ssize_t got = recv(c, buf, sizeof buf, 0);
    printf("send to a closed port returned %zd; the next recv returned %zd: %s\n", sent, got, got < 0 ? strerror(errno) : "no error");
 
    static char big[70000];
    ssize_t n = sendto(tx1, big, sizeof big, 0, (struct sockaddr *)&to, sizeof to);
    printf("sending 70000 bytes in one datagram returned %zd: %s\n", n, n < 0 ? strerror(errno) : "sent");
    return 0;
}

one receiving socket, four datagrams from two senders:
  recvfrom returned 10 bytes, sent by sender 1
  recvfrom returned 20 bytes, sent by sender 1
  recvfrom returned 5 bytes, sent by sender 2
  recvfrom returned 30 bytes, sent by sender 1
send to a closed port returned 1; the next recv returned -1: Connection refused
sending 70000 bytes in one datagram returned -1: Message too long

#include <stdio.h>
 
int main(void) {
    int max_data = 65535 - 20 - 8;                  /* IPv4 total length minus IP header and UDP header */
    int ip_payload = max_data + 8;                  /* the UDP datagram is the IP payload */
    int per_fragment = (1500 - 20) / 8 * 8;         /* data per fragment, a multiple of 8 bytes */
    int fragments = (ip_payload + per_fragment - 1) / per_fragment;
    int last = ip_payload - (fragments - 1) * per_fragment;
    printf("largest UDP data %d bytes; IP payload %d bytes\n", max_data, ip_payload);
    printf("MTU 1500: %d data bytes per fragment, %d fragments, the last carries %d bytes (%d with its IP header)\n", per_fragment, fragments, last, last + 20);
    return 0;
}

largest UDP data 65507 bytes; IP payload 65515 bytes
MTU 1500: 1480 data bytes per fragment, 45 fragments, the last carries 395 bytes (415 with its IP header)