update readme

.gitignore

@@ -1 +1,2 @@
 .idea/
+build/

Makefile

@@ -0,0 +1,26 @@
+# Makefile for strict C89/C90 compatibility
+# Compiles all samples in src/c90/ with -std=c90 -pedantic -Wall -Wextra -Werror
+
+.PHONY: all clean
+
+CC := gcc
+CFLAGS := -std=c90 -pedantic -Wall -Wextra -Werror
+SRCDIR := src/c90
+BINDIR := build
+SOURCES := $(wildcard $(SRCDIR)/*.c)
+BINS := $(SOURCES:$(SRCDIR)/%.c=$(BINDIR)/%)
+
+all: $(BINS)
+
+$(BINDIR)/%: $(SRCDIR)/%.c | $(BINDIR)
+	$(CC) $(CFLAGS) -o $@ $<
+
+$(BINDIR):
+	mkdir -p $(BINDIR)
+
+clean:
+	rm -rf $(BINDIR)
+
+print:
+	@echo "Strict C90 binaries in bin/:"
+	@ls $(BINDIR)

REAMDE.md

@@ -1,3 +1,48 @@
 # socket-samples
 
-A simple repo with examples of python sockets
+Socket programming examples in strict C90 and modern Python3.
+
+## Build & Run C90 Examples
+
+```
+make clean && make all
+```
+Builds 9 binaries in `build/` (strict `-std=c90 -pedantic -Wall -Wextra -Werror`).
+
+Port: **9999**
+
+All use the same **custom binary protocol**:
+- Header: `1-byte type + 2-byte BE16 length`
+- Types: `PING(0x01)`, `PONG(0x02)`, `METRIC_REQ(0x03)`, `METRIC_RESP(0x04)`, `SUBSCRIBE(0x05)`, `PUSH(0x06)`, `UNSUB(0x07)`, `ERROR(0xFF)`
+- Metrics: `cpu`, `memory`, `disk`, `loadavg`, `uptime` (simulated)
+
+### C90 Clients
+- `src/c90/metric_client.c`: Basic interactive TCP client (ping/get/quit).
+- `src/c90/metric_client_ansi.c`: Advanced TCP client w/ `select()` + unsubscribe.
+- `src/c90/metric_client_sub.c`: TCP client w/ live subscribe/push via `select()`.
+- `src/c90/metric_client_udp.c`: Full-featured UDP client (get/sub/unsub).
+- `src/c90/perf_client_udp.c`: UDP perf tester (`--flood` or subscribe mode, 30s throughput).
+
+### C90 Servers
+- `src/c90/metric_server.c`: Iterative TCP server (single client).
+- `src/c90/metric_server_fork.c`: Forking TCP server (multi-client).
+- `src/c90/metric_server_fork_sub.c`: Forking TCP server w/ subscribe/push.
+- `src/c90/metric_server_udp.c`: UDP server w/ subscriber management (`select()`).
+
+## Python Examples
+
+Run: `python3 src/python/<file>.py [host [port]]`
+
+Port: **9999** (metrics), **65432** (echo)
+
+### Echo (text protocol)
+- `src/python/echo_client.py`: Interactive TCP echo client.
+- `src/python/echo_server.py`: Iterative TCP echo server.
+
+### Metrics (same binary protocol as C90)
+- `src/python/metric_client.py`: Threaded TCP client (ping/get).
+- `src/python/metric_server.py`: Threaded multi-client TCP server.
+
+### Monitor (advanced w/ subscribe/push)
+- `src/python/mon_client.py`: Full TCP client (ping/get/sub).
+- `src/python/mon_server.py`: Threaded TCP server w/ subscribe/push support.

src/c90/metric_client.c

@@ -1,4 +1,4 @@
-/* metric_client.c - C89/C90 custom binary metric client */
+/* metric_client.c - STRICT C89/C90 custom binary metric client */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -10,7 +10,7 @@
 #define PORT     9999
 #define BUF_SIZE 1024
 
-/* same constants */
+/* Protocol constants (must match server) */
 #define MSG_PING        0x01
 #define MSG_PONG        0x02
 #define MSG_METRIC_REQ  0x03
@@ -19,16 +19,20 @@
 
 #define HEADER_SIZE 3
 
-static void send_message(int sock, unsigned char type, const void *payload, unsigned short len) {
+static void send_message(int sock, unsigned char type,
+                         const void *payload, unsigned short len)
+{
     unsigned char header[HEADER_SIZE];
     header[0] = type;
-    header[1] = (len >> 8) & 0xFF;
+    header[1] = (len >> 8) & 0xFF;   /* big-endian */
     header[2] = len & 0xFF;
     write(sock, header, HEADER_SIZE);
-    if (len > 0) write(sock, payload, len);
+    if (len > 0)
+        write(sock, payload, len);
 }
 
-static int recv_exact(int sock, void *buf, int n) {
+static int recv_exact(int sock, void *buf, int n)
+{
     int total = 0;
     while (total < n) {
         int r = read(sock, (char *)buf + total, n - total);
@@ -38,70 +42,96 @@ static int recv_exact(int sock, void *buf, int n) {
     return total;
 }
 
-static void print_wire_comparison(void) {
+static void print_wire_comparison(void)
+{
     printf("\n--- Wire overhead comparison ---\n");
     printf("Our protocol (METRIC_REQ 'cpu'):  %d bytes\n", HEADER_SIZE + 3);
     printf("Equivalent HTTP GET:              77 bytes\n");
     printf("HTTP is ~13x larger\n\n");
 }
 
-int main(void) {
+int main(void)
+{
     int sock;
     struct sockaddr_in addr;
     unsigned char header[HEADER_SIZE];
     unsigned char payload[BUF_SIZE];
     double val;
     char line[256];
+    unsigned char type;
+    unsigned short len;
+    const char *metric;
 
     sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock < 0) {
+        perror("socket");
+        exit(1);
+    }
+
     addr.sin_family = AF_INET;
     addr.sin_port   = htons(PORT);
     inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
 
     if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
         perror("connect");
+        close(sock);
         exit(1);
     }
 
-    printf("Connected to 127.0.0.1:%d\n", PORT);
+    printf("Connected to 127.0.0.1:%d (STRICT C89 client)\n", PORT);
     print_wire_comparison();
 
-    printf("Commands: ping | get <metric> | quit\nMetrics: cpu, memory, disk, loadavg, uptime\n\n");
+    printf("Commands: ping | get <metric> | quit\n");
+    printf("Metrics:  cpu, memory, disk, loadavg, uptime\n\n");
 
     while (1) {
         printf("> ");
-        if (fgets(line, sizeof(line), stdin) == NULL) break;
+        if (fgets(line, sizeof(line), stdin) == NULL)
+            break;
+
         line[strcspn(line, "\n")] = '\0';
 
-        if (strcmp(line, "quit") == 0) break;
-        if (strcmp(line, "ping") == 0) {
+        if (strcmp(line, "quit") == 0) {
+            break;
+        }
+        else if (strcmp(line, "ping") == 0) {
             send_message(sock, MSG_PING, NULL, 0);
-        } else if (strncmp(line, "get ", 4) == 0) {
-            const char *metric = line + 4;
+        }
+        else if (strncmp(line, "get ", 4) == 0) {
+            metric = line + 4;
             send_message(sock, MSG_METRIC_REQ, metric, strlen(metric));
-        } else {
+        }
+        else {
             printf("  Unknown command.\n");
             continue;
         }
 
         /* blocking receive */
-        if (recv_exact(sock, header, HEADER_SIZE) != HEADER_SIZE) break;
-        unsigned char type = header[0];
-        unsigned short len = (header[1] << 8) | header[2];
+        if (recv_exact(sock, header, HEADER_SIZE) != HEADER_SIZE)
+            break;
+
+        type = header[0];
+        len  = (header[1] << 8) | header[2];
 
         if (len > 0) {
-            if (recv_exact(sock, payload, len) != len) break;
+            if (recv_exact(sock, payload, len) != len)
+                break;
         }
 
         if (type == MSG_PONG) {
             printf("  [PONG] server alive\n");
-        } else if (type == MSG_METRIC_RESP) {
+        }
+        else if (type == MSG_METRIC_RESP) {
             memcpy(&val, payload, sizeof(double));
             printf("  [METRIC] %.2f\n", val);
-        } else if (type == MSG_ERROR) {
+        }
+        else if (type == MSG_ERROR) {
             payload[len] = '\0';
             printf("  [ERROR] %s\n", payload);
         }
+        else {
+            printf("  [???] Unknown message type 0x%02X\n", type);
+        }
     }
 
     close(sock);

src/c90/metric_client_ansi.c

@@ -0,0 +1,174 @@
+/* metric_client.c - FINAL STRICT C89/C90 clean live client with unsub */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/select.h>
+#include <errno.h>
+
+#define PORT     9999
+#define BUF_SIZE 1024
+
+#define MSG_PING        0x01
+#define MSG_PONG        0x02
+#define MSG_METRIC_REQ  0x03
+#define MSG_METRIC_RESP 0x04
+#define MSG_SUBSCRIBE   0x05
+#define MSG_PUSH        0x06
+#define MSG_UNSUB       0x07
+#define MSG_ERROR       0xFF
+
+#define HEADER_SIZE 3
+
+static void send_message(int sock, unsigned char type,
+                         const void *payload, unsigned short len)
+{
+    unsigned char header[HEADER_SIZE];
+    header[0] = type;
+    header[1] = (len >> 8) & 0xFF;
+    header[2] = len & 0xFF;
+    write(sock, header, HEADER_SIZE);
+    if (len > 0)
+        write(sock, payload, len);
+}
+
+static int recv_exact(int sock, void *buf, int n)
+{
+    int total = 0;
+    while (total < n) {
+        int r = read(sock, (char *)buf + total, n - total);
+        if (r <= 0) return -1;
+        total += r;
+    }
+    return total;
+}
+
+static void print_wire_comparison(void)
+{
+    printf("\n--- Wire overhead comparison ---\n");
+    printf("Our protocol (METRIC_REQ 'cpu'):  %d bytes\n", HEADER_SIZE + 3);
+    printf("Equivalent HTTP GET:              77 bytes\n");
+    printf("HTTP is ~13x larger\n\n");
+}
+
+int main(void)
+{
+    int sock, maxfd;
+    struct sockaddr_in addr;
+    unsigned char header[HEADER_SIZE];
+    unsigned char payload[BUF_SIZE];
+    double val;
+    char line[256];
+    unsigned char type;
+    unsigned short len;
+    fd_set readfds;
+
+    sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock < 0) { perror("socket"); exit(1); }
+
+    addr.sin_family = AF_INET;
+    addr.sin_port   = htons(PORT);
+    inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
+
+    if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        perror("connect"); close(sock); exit(1);
+    }
+
+    printf("Connected to 127.0.0.1:%d (FINAL clean C89 demo client)\n", PORT);
+    print_wire_comparison();
+
+    printf("Commands: ping | get <metric> | sub <metric> <ms> | unsub | quit\n");
+    printf("Metrics:  cpu, memory, disk, loadavg, uptime\n\n");
+
+    printf("> "); fflush(stdout);
+
+    maxfd = sock + 1;
+
+    while (1) {
+        FD_ZERO(&readfds);
+        FD_SET(0, &readfds);
+        FD_SET(sock, &readfds);
+
+        if (select(maxfd, &readfds, NULL, NULL, NULL) < 0) {
+            if (errno == EINTR) continue;
+            perror("select");
+            break;
+        }
+
+        if (FD_ISSET(sock, &readfds)) {
+            if (recv_exact(sock, header, HEADER_SIZE) != HEADER_SIZE) break;
+
+            type = header[0];
+            len  = (header[1] << 8) | header[2];
+
+            if (len > 0) {
+                if (recv_exact(sock, payload, len) != len) break;
+            }
+
+            printf("\r\x1b[2K");
+
+            if (type == MSG_PONG) {
+                printf("  [PONG] server alive\n");
+            } else if (type == MSG_METRIC_RESP) {
+                memcpy(&val, payload, sizeof(double));
+                printf("  [METRIC] %.2f\n", val);
+            } else if (type == MSG_PUSH) {
+                unsigned char name_len = payload[0];
+                payload[1 + name_len] = '\0';
+                memcpy(&val, payload + 1 + name_len, sizeof(double));
+                printf("  [PUSH] %s: %.2f\n", (char *)payload + 1, val);
+            } else if (type == MSG_ERROR) {
+                payload[len] = '\0';
+                printf("  [ERROR] %s\n", payload);
+            }
+
+            printf("> "); fflush(stdout);
+        }
+
+        if (FD_ISSET(0, &readfds)) {
+            if (fgets(line, sizeof(line), stdin) == NULL) break;
+            line[strcspn(line, "\n")] = '\0';
+
+            if (strcmp(line, "quit") == 0) break;
+            else if (strcmp(line, "ping") == 0) {
+                send_message(sock, MSG_PING, NULL, 0);
+            }
+            else if (strncmp(line, "get ", 4) == 0) {
+                const char *metric = line + 4;
+                send_message(sock, MSG_METRIC_REQ, metric, strlen(metric));
+            }
+            else if (strncmp(line, "sub ", 4) == 0) {
+                char *metric = strtok(line + 4, " ");
+                if (metric) {
+                    unsigned int ms = atoi(strtok(NULL, " "));
+                    unsigned char name_len = strlen(metric);
+                    unsigned char p[BUF_SIZE];
+                    p[0] = name_len;
+                    memcpy(p + 1, metric, name_len);
+                    p[1 + name_len]     = (ms >> 24) & 0xFF;
+                    p[1 + name_len + 1] = (ms >> 16) & 0xFF;
+                    p[1 + name_len + 2] = (ms >>  8) & 0xFF;
+                    p[1 + name_len + 3] = ms & 0xFF;
+                    send_message(sock, MSG_SUBSCRIBE, p, 1 + name_len + 4);
+                    printf("  Subscribed to '%s' every %u ms\n", metric, ms);
+                }
+            }
+            else if (strcmp(line, "unsub") == 0) {
+                send_message(sock, MSG_UNSUB, NULL, 0);
+                printf("  Unsubscribed (push stopped)\n");
+            }
+            else if (line[0] != '\0') {
+                printf("  Unknown command: '%s'\n", line);
+            }
+
+            printf("> "); fflush(stdout);
+        }
+    }
+
+    close(sock);
+    printf("\nDisconnected.\n");
+    return 0;
+}

src/c90/metric_client_sub.c

@@ -0,0 +1,173 @@
+/* metric_client.c - STRICT C89/C90 client with live SUBSCRIBE/PUSH using select() */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/select.h>
+#include <errno.h>
+
+#define PORT     9999
+#define BUF_SIZE 1024
+
+#define MSG_PING        0x01
+#define MSG_PONG        0x02
+#define MSG_METRIC_REQ  0x03
+#define MSG_METRIC_RESP 0x04
+#define MSG_SUBSCRIBE   0x05
+#define MSG_PUSH        0x06
+#define MSG_ERROR       0xFF
+
+#define HEADER_SIZE 3
+
+static void send_message(int sock, unsigned char type,
+                         const void *payload, unsigned short len)
+{
+    unsigned char header[HEADER_SIZE];
+    header[0] = type;
+    header[1] = (len >> 8) & 0xFF;
+    header[2] = len & 0xFF;
+    write(sock, header, HEADER_SIZE);
+    if (len > 0)
+        write(sock, payload, len);
+}
+
+static int recv_exact(int sock, void *buf, int n)
+{
+    int total = 0;
+    while (total < n) {
+        int r = read(sock, (char *)buf + total, n - total);
+        if (r <= 0) return -1;
+        total += r;
+    }
+    return total;
+}
+
+static void print_wire_comparison(void)
+{
+    printf("\n--- Wire overhead comparison ---\n");
+    printf("Our protocol (METRIC_REQ 'cpu'):  %d bytes\n", HEADER_SIZE + 3);
+    printf("Equivalent HTTP GET:              77 bytes\n");
+    printf("HTTP is ~13x larger\n\n");
+}
+
+int main(void)
+{
+    int sock, maxfd;
+    struct sockaddr_in addr;
+    unsigned char header[HEADER_SIZE];
+    unsigned char payload[BUF_SIZE];
+    double val;
+    char line[256];
+    unsigned char type;
+    unsigned short len;
+    const char *metric;
+    unsigned int interval_ms;
+    unsigned char name_len;
+    fd_set readfds;
+
+    sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock < 0) { perror("socket"); exit(1); }
+
+    addr.sin_family = AF_INET;
+    addr.sin_port   = htons(PORT);
+    inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
+
+    if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        perror("connect"); close(sock); exit(1);
+    }
+
+    printf("Connected to 127.0.0.1:%d (STRICT C89 live client)\n", PORT);
+    print_wire_comparison();
+
+    printf("Commands: ping | get <metric> | sub <metric> <ms> | quit\n");
+    printf("Metrics:  cpu, memory, disk, loadavg, uptime\n\n");
+
+    maxfd = sock > 0 ? sock : 0;
+
+    while (1) {
+        FD_ZERO(&readfds);
+        FD_SET(0, &readfds);      /* stdin */
+        FD_SET(sock, &readfds);   /* socket */
+
+        if (select(maxfd + 1, &readfds, NULL, NULL, NULL) < 0) {
+            if (errno == EINTR) continue;
+            perror("select");
+            break;
+        }
+
+        /* 1. Data ready on the socket → handle PUSH / response immediately */
+        if (FD_ISSET(sock, &readfds)) {
+            if (recv_exact(sock, header, HEADER_SIZE) != HEADER_SIZE) break;
+
+            type = header[0];
+            len  = (header[1] << 8) | header[2];
+
+            if (len > 0) {
+                if (recv_exact(sock, payload, len) != len) break;
+            }
+
+            if (type == MSG_PONG) {
+                printf("\n  [PONG] server alive\n");
+            }
+            else if (type == MSG_METRIC_RESP) {
+                memcpy(&val, payload, sizeof(double));
+                printf("\n  [METRIC] %.2f\n", val);
+            }
+            else if (type == MSG_PUSH) {
+                name_len = payload[0];
+                payload[1 + name_len] = '\0';
+                memcpy(&val, payload + 1 + name_len, sizeof(double));
+                printf("\n  [PUSH] %s: %.2f\n", (char *)payload + 1, val);
+            }
+            else if (type == MSG_ERROR) {
+                payload[len] = '\0';
+                printf("\n  [ERROR] %s\n", payload);
+            }
+            else {
+                printf("\n  [???] Unknown type 0x%02X\n", type);
+            }
+            printf("> "); fflush(stdout);   /* re-print prompt after async message */
+        }
+
+        /* 2. User typed something on stdin */
+        if (FD_ISSET(0, &readfds)) {
+            if (fgets(line, sizeof(line), stdin) == NULL) break;
+            line[strcspn(line, "\n")] = '\0';
+
+            if (strcmp(line, "quit") == 0) break;
+            else if (strcmp(line, "ping") == 0) {
+                send_message(sock, MSG_PING, NULL, 0);
+            }
+            else if (strncmp(line, "get ", 4) == 0) {
+                metric = line + 4;
+                send_message(sock, MSG_METRIC_REQ, metric, strlen(metric));
+            }
+            else if (strncmp(line, "sub ", 4) == 0) {
+                metric = strtok(line + 4, " ");
+                if (metric) {
+                    interval_ms = atoi(strtok(NULL, " "));
+                    name_len = strlen(metric);
+                    payload[0] = name_len;
+                    memcpy(payload + 1, metric, name_len);
+                    payload[1 + name_len]     = (interval_ms >> 24) & 0xFF;
+                    payload[1 + name_len + 1] = (interval_ms >> 16) & 0xFF;
+                    payload[1 + name_len + 2] = (interval_ms >>  8) & 0xFF;
+                    payload[1 + name_len + 3] =  interval_ms        & 0xFF;
+                    send_message(sock, MSG_SUBSCRIBE, payload, 1 + name_len + 4);
+                    printf("  Subscribed to '%s' every %u ms\n", metric, interval_ms);
+                }
+            }
+            else {
+                printf("  Unknown command.\n");
+            }
+            printf("> "); fflush(stdout);
+        }
+    }
+
+    close(sock);
+    printf("\nDisconnected.\n");
+    return 0;
+}

src/c90/metric_client_udp.c

@@ -0,0 +1,170 @@
+/* metric_client_udp.c - STRICT C89/C90 UDP client with clean UI */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/select.h>
+#include <errno.h>
+
+#define PORT     9999
+#define BUF_SIZE 1024
+
+#define MSG_PING        0x01
+#define MSG_PONG        0x02
+#define MSG_METRIC_REQ  0x03
+#define MSG_METRIC_RESP 0x04
+#define MSG_SUBSCRIBE   0x05
+#define MSG_PUSH        0x06
+#define MSG_UNSUB       0x07
+#define MSG_ERROR       0xFF
+
+#define HEADER_SIZE 3
+
+static void send_to(int sock, struct sockaddr_in *to,
+                    unsigned char type, const void *payload, unsigned short len)
+{
+    unsigned char header[HEADER_SIZE];
+    header[0] = type;
+    header[1] = (len >> 8) & 0xFF;
+    header[2] = len & 0xFF;
+    sendto(sock, header, HEADER_SIZE, 0, (struct sockaddr *)to, sizeof(*to));
+    if (len > 0)
+        sendto(sock, payload, len, 0, (struct sockaddr *)to, sizeof(*to));
+}
+
+static int recv_from_exact(int sock, void *buf, int n)
+{
+    int total = 0;
+    while (total < n) {
+        int r = recv(sock, (char *)buf + total, n - total, 0);
+        if (r <= 0) return -1;
+        total += r;
+    }
+    return total;
+}
+
+static void print_wire_comparison(void)
+{
+    printf("\n--- Wire overhead comparison ---\n");
+    printf("Our protocol (METRIC_REQ 'cpu'):  %d bytes\n", HEADER_SIZE + 3);
+    printf("Equivalent HTTP GET:              77 bytes\n");
+    printf("HTTP is ~13x larger\n\n");
+}
+
+int main(void)
+{
+    int sock, maxfd;
+    struct sockaddr_in server_addr;
+    unsigned char header[HEADER_SIZE];
+    unsigned char payload[BUF_SIZE];
+    double val;
+    char line[256];
+    unsigned char type;
+    unsigned short len;
+    fd_set readfds;
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock < 0) { perror("socket"); exit(1); }
+
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_port   = htons(PORT);
+    inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);
+
+    printf("Connected to UDP 127.0.0.1:%d (FINAL clean C89 demo client)\n", PORT);
+    print_wire_comparison();
+
+    printf("Commands: ping | get <metric> | sub <metric> <ms> | unsub | quit\n");
+    printf("Metrics:  cpu, memory, disk, loadavg, uptime\n\n");
+
+    printf("> "); fflush(stdout);
+
+    maxfd = sock + 1;
+
+    while (1) {
+        FD_ZERO(&readfds);
+        FD_SET(0, &readfds);
+        FD_SET(sock, &readfds);
+
+        if (select(maxfd, &readfds, NULL, NULL, NULL) < 0) {
+            if (errno == EINTR) continue;
+            perror("select");
+            break;
+        }
+
+        if (FD_ISSET(sock, &readfds)) {
+            if (recv_from_exact(sock, header, HEADER_SIZE) != HEADER_SIZE) break;
+
+            type = header[0];
+            len  = (header[1] << 8) | header[2];
+
+            if (len > 0) {
+                if (recv_from_exact(sock, payload, len) != len) break;
+            }
+
+            printf("\r\x1b[2K");
+
+            if (type == MSG_PONG) {
+                printf("  [PONG] server alive\n");
+            } else if (type == MSG_METRIC_RESP) {
+                memcpy(&val, payload, sizeof(double));
+                printf("  [METRIC] %.2f\n", val);
+            } else if (type == MSG_PUSH) {
+                unsigned char name_len = payload[0];
+                payload[1 + name_len] = '\0';
+                memcpy(&val, payload + 1 + name_len, sizeof(double));
+                printf("  [PUSH] %s: %.2f\n", (char *)payload + 1, val);
+            } else if (type == MSG_ERROR) {
+                payload[len] = '\0';
+                printf("  [ERROR] %s\n", payload);
+            }
+
+            printf("> "); fflush(stdout);
+        }
+
+        if (FD_ISSET(0, &readfds)) {
+            if (fgets(line, sizeof(line), stdin) == NULL) break;
+            line[strcspn(line, "\n")] = '\0';
+
+            if (strcmp(line, "quit") == 0) break;
+            else if (strcmp(line, "ping") == 0) {
+                send_to(sock, &server_addr, MSG_PING, NULL, 0);
+            }
+            else if (strncmp(line, "get ", 4) == 0) {
+                const char *metric = line + 4;
+                send_to(sock, &server_addr, MSG_METRIC_REQ, metric, strlen(metric));
+            }
+            else if (strncmp(line, "sub ", 4) == 0) {
+                char *metric = strtok(line + 4, " ");
+                if (metric) {
+                    unsigned int ms = atoi(strtok(NULL, " "));
+                    unsigned char name_len = strlen(metric);
+                    unsigned char p[BUF_SIZE];
+                    p[0] = name_len;
+                    memcpy(p + 1, metric, name_len);
+                    p[1 + name_len]     = (ms >> 24) & 0xFF;
+                    p[1 + name_len + 1] = (ms >> 16) & 0xFF;
+                    p[1 + name_len + 2] = (ms >>  8) & 0xFF;
+                    p[1 + name_len + 3] = ms & 0xFF;
+                    send_to(sock, &server_addr, MSG_SUBSCRIBE, p, 1 + name_len + 4);
+                    printf("  Subscribed to '%s' every %u ms\n", metric, ms);
+                }
+            }
+            else if (strcmp(line, "unsub") == 0) {
+                send_to(sock, &server_addr, MSG_UNSUB, NULL, 0);
+                printf("  Unsubscribed (push stopped)\n");
+            }
+            else if (line[0] != '\0') {
+                printf("  Unknown command: '%s'\n", line);
+            }
+
+            printf("> "); fflush(stdout);
+        }
+    }
+
+    close(sock);
+    printf("\nDisconnected.\n");
+    return 0;
+}

src/c90/metric_server.c

@@ -55,11 +55,10 @@ static void handle_client(int client_sock) {
     unsigned char payload[BUF_SIZE];
 
     while (1) {
+        unsigned char type = 0;
+        unsigned short len = 0;
         if (recv_exact(client_sock, header, HEADER_SIZE) != HEADER_SIZE) break;
 
-        unsigned char type = header[0];
-        unsigned short len = (header[1] << 8) | header[2];
-
         if (len > 0) {
             if (recv_exact(client_sock, payload, len) != len) break;
         }
@@ -67,8 +66,9 @@ static void handle_client(int client_sock) {
         if (type == MSG_PING) {
             send_message(client_sock, MSG_PONG, NULL, 0);
         } else if (type == MSG_METRIC_REQ) {
+            double val;
             payload[len] = '\0'; /* null-terminate */
-            double val = get_metric((char*)payload);
+            val = get_metric((char*)payload);
             if (val < 0) {
                 const char *err = "Unknown metric";
                 send_message(client_sock, MSG_ERROR, err, strlen(err));

src/c90/metric_server_fork.c

@@ -1,4 +1,4 @@
-/* metric_server_fork.c - C89/C90 multi-client metric server using fork() */
+/* metric_server_fork.c - STRICT C89/C90 multi-client metric server using fork() */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -58,9 +58,12 @@ static int recv_exact(int sock, void *buf, int n)
 
 static void handle_client(int client_sock, struct sockaddr_in *addr)
 {
-    unsigned char header[HEADER_SIZE];
+    unsigned char header[HEADER_SIZE];      /* all declarations first */
     unsigned char payload[BUF_SIZE];
     char client_ip[INET_ADDRSTRLEN];
+    unsigned char type;
+    unsigned short len;
+    double val;
 
     inet_ntop(AF_INET, &addr->sin_addr, client_ip, sizeof(client_ip));
     printf("[+] Connected from %s:%d\n", client_ip, ntohs(addr->sin_port));
@@ -69,8 +72,8 @@ static void handle_client(int client_sock, struct sockaddr_in *addr)
         if (recv_exact(client_sock, header, HEADER_SIZE) != HEADER_SIZE)
             break;
 
-        unsigned char type = header[0];
-        unsigned short len = (header[1] << 8) | header[2];
+        type = header[0];
+        len  = (header[1] << 8) | header[2];
 
         if (len > 0) {
             if (recv_exact(client_sock, payload, len) != len)
@@ -83,7 +86,7 @@ static void handle_client(int client_sock, struct sockaddr_in *addr)
         }
         else if (type == MSG_METRIC_REQ) {
             payload[len] = '\0';
-            double val = get_metric((char *)payload);
+            val = get_metric((char *)payload);
             printf("  <- METRIC_REQ '%s' from %s\n", (char *)payload, client_ip);
             if (val < 0.0) {
                 const char *err = "Unknown metric";
@@ -111,7 +114,6 @@ int main(void)
 
     srand(time(NULL));
 
-    /* Classic Unix trick to reap children automatically (no zombies) */
     signal(SIGCHLD, SIG_IGN);
 
     srv_sock = socket(AF_INET, SOCK_STREAM, 0);
@@ -147,17 +149,17 @@ int main(void)
         }
 
         pid = fork();
-        if (pid < 0) {               /* fork failed */
+        if (pid < 0) {
             perror("fork");
             close(client_sock);
         }
-        else if (pid == 0) {         /* CHILD process */
-            close(srv_sock);         /* child does not need the listening socket */
+        else if (pid == 0) {         /* CHILD */
+            close(srv_sock);
             handle_client(client_sock, &client_addr);
             exit(0);
         }
-        else {                       /* PARENT process */
-            close(client_sock);      /* parent does not need the client socket */
+        else {                       /* PARENT */
+            close(client_sock);
         }
     }
 

src/c90/metric_server_fork_sub.c

@@ -0,0 +1,221 @@
+/* metric_server_fork.c - STRICT C89/C90 multi-client metric server with SUBSCRIBE/PUSH (fixed) */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <time.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/select.h>
+
+#define PORT     9999
+#define BACKLOG  10
+#define BUF_SIZE 1024
+
+#define MSG_PING        0x01
+#define MSG_PONG        0x02
+#define MSG_METRIC_REQ  0x03
+#define MSG_METRIC_RESP 0x04
+#define MSG_SUBSCRIBE   0x05
+#define MSG_PUSH        0x06
+#define MSG_UNSUB       0x07
+#define MSG_ERROR       0xFF
+#define HEADER_SIZE 3
+
+static double get_metric(const char *name)
+{
+    if (strcmp(name, "cpu")     == 0) return  5.0 + (rand() % 9000)/100.0;
+    if (strcmp(name, "memory")  == 0) return 30.0 + (rand() % 5000)/100.0;
+    if (strcmp(name, "disk")    == 0) return 40.0 + (rand() % 5000)/100.0;
+    if (strcmp(name, "loadavg") == 0) return  0.5 + (rand() % 350)/100.0;
+    if (strcmp(name, "uptime")  == 0) return (double)(time(NULL) % 100000);
+    return -1.0;
+}
+
+static void send_message(int sock, unsigned char type,
+                         const void *payload, unsigned short len)
+{
+    unsigned char header[HEADER_SIZE];
+    header[0] = type;
+    header[1] = (len >> 8) & 0xFF;
+    header[2] = len & 0xFF;
+    if (write(sock, header, HEADER_SIZE) != HEADER_SIZE) return;
+    if (len > 0)
+        write(sock, payload, len);
+}
+
+static int recv_exact(int sock, void *buf, int n)
+{
+    int total = 0;
+    while (total < n) {
+        int r = read(sock, (char *)buf + total, n - total);
+        if (r <= 0) return -1;
+        total += r;
+    }
+    return total;
+}
+
+static void handle_client(int client_sock, struct sockaddr_in *addr)
+{
+    unsigned char header[HEADER_SIZE];
+    unsigned char payload[BUF_SIZE];
+    char client_ip[INET_ADDRSTRLEN];
+    unsigned char type;
+    unsigned short len;
+    double val;
+    fd_set readfds;
+    struct timeval tv;
+    int retval;
+
+    /* Subscription state (one active subscription per client for this demo) */
+    char subscribed_metric[64] = {0};
+    unsigned int interval_ms = 0;
+    int have_subscription = 0;
+
+    inet_ntop(AF_INET, &addr->sin_addr, client_ip, sizeof(client_ip));
+    printf("[+] Connected from %s:%d\n", client_ip, ntohs(addr->sin_port));
+
+    while (1) {
+        FD_ZERO(&readfds);
+        FD_SET(client_sock, &readfds);
+
+        /* If we have a subscription, set a timeout for the next PUSH */
+        if (have_subscription && interval_ms > 0) {
+            tv.tv_sec  = interval_ms / 1000;
+            tv.tv_usec = (interval_ms % 1000) * 1000;
+            retval = select(client_sock + 1, &readfds, NULL, NULL, &tv);
+        } else {
+            retval = select(client_sock + 1, &readfds, NULL, NULL, NULL);
+        }
+
+        if (retval < 0) {
+            if (errno == EINTR) continue;
+            perror("select");
+            break;
+        }
+
+        /* Timeout fired → send PUSH */
+        if (retval == 0 && have_subscription) {
+            val = get_metric(subscribed_metric);
+            if (val >= 0.0) {
+                unsigned char name_len = strlen(subscribed_metric);
+                payload[0] = name_len;
+                memcpy(payload + 1, subscribed_metric, name_len);
+                memcpy(payload + 1 + name_len, &val, sizeof(double));
+                send_message(client_sock, MSG_PUSH, payload, 1 + name_len + sizeof(double));
+                printf("  -> PUSH '%s' to %s\n", subscribed_metric, client_ip);
+            }
+            continue;
+        }
+
+        /* Data from client */
+        if (recv_exact(client_sock, header, HEADER_SIZE) != HEADER_SIZE)
+            break;
+
+        type = header[0];
+        len  = (header[1] << 8) | header[2];
+
+        if (len > 0) {
+            if (recv_exact(client_sock, payload, len) != len)
+                break;
+        }
+
+        if (type == MSG_PING) {
+            printf("  <- PING from %s\n", client_ip);
+            send_message(client_sock, MSG_PONG, NULL, 0);
+        }
+        else if (type == MSG_METRIC_REQ) {
+            payload[len] = '\0';
+            val = get_metric((char *)payload);
+            printf("  <- METRIC_REQ '%s' from %s\n", (char *)payload, client_ip);
+            if (val < 0.0) {
+                const char *err = "Unknown metric";
+                send_message(client_sock, MSG_ERROR, err, strlen(err));
+            } else {
+                send_message(client_sock, MSG_METRIC_RESP, &val, sizeof(double));
+            }
+        }
+        else if (type == MSG_SUBSCRIBE) {
+            unsigned char name_len = payload[0];
+            if (name_len < sizeof(subscribed_metric)-1) {
+                memcpy(subscribed_metric, payload + 1, name_len);
+                subscribed_metric[name_len] = '\0';
+            }
+            interval_ms = (payload[1 + name_len] << 24) |
+                          (payload[1 + name_len + 1] << 16) |
+                          (payload[1 + name_len + 2] <<  8) |
+                           payload[1 + name_len + 3];
+            have_subscription = 1;
+            printf("  -> SUBSCRIBE '%s' every %u ms from %s\n", subscribed_metric, interval_ms, client_ip);
+        }
+        else if (type == MSG_UNSUB) {
+            have_subscription = 0;
+            printf("  <- UNSUB from %s\n", client_ip);
+        }
+        else {
+            const char *err = "Unknown message type";
+            send_message(client_sock, MSG_ERROR, err, strlen(err));
+        }
+    }
+
+    close(client_sock);
+    printf("[-] Disconnected from %s\n", client_ip);
+}
+
+int main(void)
+{
+    int srv_sock, client_sock;
+    struct sockaddr_in server_addr, client_addr;
+    socklen_t client_len = sizeof(client_addr);
+    pid_t pid;
+
+    srand(time(NULL));
+    signal(SIGCHLD, SIG_IGN);
+
+    srv_sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (srv_sock < 0) { perror("socket"); exit(1); }
+
+    server_addr.sin_family      = AF_INET;
+    server_addr.sin_addr.s_addr = INADDR_ANY;
+    server_addr.sin_port        = htons(PORT);
+
+    if (bind(srv_sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
+        perror("bind"); exit(1);
+    }
+    if (listen(srv_sock, BACKLOG) < 0) {
+        perror("listen"); exit(1);
+    }
+
+    printf("Metric server (fork() + SUBSCRIBE/PUSH with select()) listening on port %d\n", PORT);
+    printf("Available metrics: cpu, memory, disk, loadavg, uptime\n");
+    printf("Commands: ping, get <metric>, sub <metric> <ms>\n\n");
+
+    while (1) {
+        client_sock = accept(srv_sock, (struct sockaddr *)&client_addr, &client_len);
+        if (client_sock < 0) {
+            if (errno == EINTR) continue;
+            perror("accept");
+            continue;
+        }
+
+        pid = fork();
+        if (pid < 0) {
+            perror("fork");
+            close(client_sock);
+        }
+        else if (pid == 0) {
+            close(srv_sock);
+            handle_client(client_sock, &client_addr);
+            exit(0);
+        }
+        else {
+            close(client_sock);
+        }
+    }
+
+    close(srv_sock);
+    return 0;
+}

src/c90/metric_server_udp.c

@@ -0,0 +1,209 @@
+/* metric_server_udp.c - STRICT C89/C90 UDP metric server with SUBSCRIBE/PUSH */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <time.h>
+#include <sys/select.h>
+#include <errno.h>
+
+#define PORT     9999
+#define MAX_SUBS 32
+#define BUF_SIZE 1024
+
+#define MSG_PING        0x01
+#define MSG_PONG        0x02
+#define MSG_METRIC_REQ  0x03
+#define MSG_METRIC_RESP 0x04
+#define MSG_SUBSCRIBE   0x05
+#define MSG_PUSH        0x06
+#define MSG_UNSUB       0x07
+#define MSG_ERROR       0xFF
+
+#define HEADER_SIZE 3
+
+struct Subscriber {
+    struct sockaddr_in addr;
+    char metric[64];
+    unsigned int interval_ms;
+    time_t last_push;
+    int active;
+};
+
+static double get_metric(const char *name)
+{
+    if (strcmp(name, "cpu")     == 0) return  5.0 + (rand() % 9000)/100.0;
+    if (strcmp(name, "memory")  == 0) return 30.0 + (rand() % 5000)/100.0;
+    if (strcmp(name, "disk")    == 0) return 40.0 + (rand() % 5000)/100.0;
+    if (strcmp(name, "loadavg") == 0) return  0.5 + (rand() % 350)/100.0;
+    if (strcmp(name, "uptime")  == 0) return (double)(time(NULL) % 100000);
+    return -1.0;
+}
+
+static void send_to(int sock, const struct sockaddr_in *to,
+                    unsigned char type, const void *payload, unsigned short len)
+{
+    unsigned char header[HEADER_SIZE];
+    header[0] = type;
+    header[1] = (len >> 8) & 0xFF;
+    header[2] = len & 0xFF;
+    sendto(sock, header, HEADER_SIZE, 0, (struct sockaddr *)to, sizeof(*to));
+    if (len > 0)
+        sendto(sock, payload, len, 0, (struct sockaddr *)to, sizeof(*to));
+}
+
+static int recv_from_exact(int sock, void *buf, int n, struct sockaddr_in *from)
+{
+    socklen_t len = sizeof(*from);
+    int total = 0;
+    while (total < n) {
+        int r = recvfrom(sock, (char *)buf + total, n - total, 0,
+                         (struct sockaddr *)from, &len);
+        if (r <= 0) return -1;
+        total += r;
+    }
+    return total;
+}
+
+static void handle_datagram(int sock, struct Subscriber subs[])
+{
+    unsigned char header[HEADER_SIZE];
+    unsigned char payload[BUF_SIZE];
+    struct sockaddr_in from;
+    unsigned char type;
+    unsigned short len;
+    double val;
+    int i;
+
+    if (recv_from_exact(sock, header, HEADER_SIZE, &from) != HEADER_SIZE)
+        return;
+
+    type = header[0];
+    len  = (header[1] << 8) | header[2];
+
+    if (len > 0) {
+        if (recv_from_exact(sock, payload, len, &from) != len)
+            return;
+    }
+
+    if (type == MSG_PING) {
+        send_to(sock, &from, MSG_PONG, NULL, 0);
+    }
+    else if (type == MSG_METRIC_REQ) {
+        payload[len] = '\0';
+        val = get_metric((char *)payload);
+        if (val < 0.0) {
+            const char *err = "Unknown metric";
+            send_to(sock, &from, MSG_ERROR, err, strlen(err));
+        } else {
+            send_to(sock, &from, MSG_METRIC_RESP, &val, sizeof(double));
+        }
+    }
+    else if (type == MSG_SUBSCRIBE) {
+        unsigned char name_len = payload[0];
+        unsigned int interval_ms = (payload[1 + name_len] << 24) |
+                                   (payload[1 + name_len + 1] << 16) |
+                                   (payload[1 + name_len + 2] <<  8) |
+                                    payload[1 + name_len + 3];
+
+        if (name_len < 63) {
+            /* find free slot or overwrite existing for same client */
+            for (i = 0; i < MAX_SUBS; ++i) {
+                if (!subs[i].active || memcmp(&subs[i].addr, &from, sizeof(from)) == 0) {
+                    memcpy(&subs[i].addr, &from, sizeof(from));
+                    memcpy(subs[i].metric, payload + 1, name_len);
+                    subs[i].metric[name_len] = '\0';
+                    subs[i].interval_ms = interval_ms;
+                    subs[i].last_push = time(NULL);
+                    subs[i].active = 1;
+                    printf("  -> SUBSCRIBE '%s' every %u ms from %s:%d\n",
+                           subs[i].metric, interval_ms,
+                           inet_ntoa(from.sin_addr), ntohs(from.sin_port));
+                    break;
+                }
+            }
+        }
+    }
+    else if (type == MSG_UNSUB) {
+        for (i = 0; i < MAX_SUBS; ++i) {
+            if (subs[i].active && memcmp(&subs[i].addr, &from, sizeof(from)) == 0) {
+                subs[i].active = 0;
+                printf("  <- UNSUB from %s:%d\n",
+                       inet_ntoa(from.sin_addr), ntohs(from.sin_port));
+                break;
+            }
+        }
+    }
+}
+
+int main(void)
+{
+    int sock, i;
+    struct sockaddr_in server_addr;
+    fd_set readfds;
+    struct timeval tv;
+    struct Subscriber subs[MAX_SUBS];
+    time_t now;
+
+    srand(time(NULL));
+    memset(subs, 0, sizeof(subs));
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock < 0) { perror("socket"); exit(1); }
+
+    server_addr.sin_family      = AF_INET;
+    server_addr.sin_addr.s_addr = INADDR_ANY;
+    server_addr.sin_port        = htons(PORT);
+
+    if (bind(sock, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
+        perror("bind"); exit(1);
+    }
+
+    printf("UDP Metric server listening on port %d (fire-and-forget mode)\n", PORT);
+    printf("Available metrics: cpu, memory, disk, loadavg, uptime\n");
+    printf("Commands: ping, get <metric>, sub <metric> <ms>, unsub\n\n");
+
+    while (1) {
+        FD_ZERO(&readfds);
+        FD_SET(sock, &readfds);
+
+        tv.tv_sec  = 0;
+        tv.tv_usec = 100000;   /* 100 ms tick for pushes */
+
+        if (select(sock + 1, &readfds, NULL, NULL, &tv) < 0) {
+            if (errno == EINTR) continue;
+            perror("select");
+            break;
+        }
+
+        if (FD_ISSET(sock, &readfds)) {
+            handle_datagram(sock, subs);
+        }
+
+        /* Periodic PUSHes */
+        now = time(NULL);
+        for (i = 0; i < MAX_SUBS; ++i) {
+            if (subs[i].active) {
+                if (now - subs[i].last_push >= subs[i].interval_ms / 1000) {
+                    double val = get_metric(subs[i].metric);
+                    if (val >= 0.0) {
+                        unsigned char name_len = strlen(subs[i].metric);
+                        unsigned char p[BUF_SIZE];
+                        p[0] = name_len;
+                        memcpy(p + 1, subs[i].metric, name_len);
+                        memcpy(p + 1 + name_len, &val, sizeof(double));
+                        send_to(sock, &subs[i].addr, MSG_PUSH,
+                                p, 1 + name_len + sizeof(double));
+                    }
+                    subs[i].last_push = now;
+                }
+            }
+        }
+    }
+
+    close(sock);
+    return 0;
+}

src/c90/perf_client_udp.c

@@ -0,0 +1,157 @@
+/* perf_client_udp.c - STRICT C89/C90 UDP performance tester for the metric protocol */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/select.h>
+#include <errno.h>
+#include <time.h>
+
+#define PORT         9999
+#define BUF_SIZE     1024
+#define TEST_DURATION 30   /* seconds */
+
+#define MSG_PING        0x01
+#define MSG_PONG        0x02
+#define MSG_METRIC_REQ  0x03
+#define MSG_METRIC_RESP 0x04
+#define MSG_SUBSCRIBE   0x05
+#define MSG_PUSH        0x06
+#define MSG_UNSUB       0x07
+#define MSG_ERROR       0xFF
+
+#define HEADER_SIZE 3
+
+static void send_to(int sock, struct sockaddr_in *to,
+                    unsigned char type, const void *payload, unsigned short len)
+{
+    unsigned char header[HEADER_SIZE];
+    header[0] = type;
+    header[1] = (len >> 8) & 0xFF;
+    header[2] = len & 0xFF;
+    sendto(sock, header, HEADER_SIZE, 0, (struct sockaddr *)to, sizeof(*to));
+    if (len > 0)
+        sendto(sock, payload, len, 0, (struct sockaddr *)to, sizeof(*to));
+}
+
+static int recv_from_exact(int sock, void *buf, int n)
+{
+    int total = 0;
+    while (total < n) {
+        int r = recv(sock, (char *)buf + total, n - total, 0);
+        if (r <= 0) return -1;
+        total += r;
+    }
+    return total;
+}
+
+int main(int argc, char *argv[])
+{
+    int sock, maxfd, flood_mode = 0, duration = TEST_DURATION;
+    struct sockaddr_in server_addr;
+    unsigned char header[HEADER_SIZE];
+    unsigned char payload[BUF_SIZE];
+    double val;
+    unsigned char type;
+    unsigned short len;
+    fd_set readfds;
+    time_t start, now;
+    unsigned long count = 0;
+    const char *metric = "cpu";
+    unsigned int interval_ms = 10;   /* 10 ms pushes in subscribe mode */
+
+    if (argc > 1 && strcmp(argv[1], "--flood") == 0) flood_mode = 1;
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock < 0) { perror("socket"); exit(1); }
+
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_port   = htons(PORT);
+    inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr);
+
+    printf("=== UDP Metric Performance Test (C89) ===\n");
+    printf("Server: 127.0.0.1:%d\n", PORT);
+    if (flood_mode) {
+        printf("Mode: FLOOD (rapid get %s)\n", metric);
+    } else {
+        printf("Mode: SUBSCRIBE '%s' every %u ms\n", metric, interval_ms);
+    }
+    printf("Test duration: %d seconds\n\n", duration);
+
+    /* Subscribe or start flooding */
+    if (flood_mode) {
+        /* nothing extra needed */
+    } else {
+        unsigned char p[BUF_SIZE];
+        unsigned char name_len = strlen(metric);
+        p[0] = name_len;
+        memcpy(p + 1, metric, name_len);
+        p[1 + name_len]     = (interval_ms >> 24) & 0xFF;
+        p[1 + name_len + 1] = (interval_ms >> 16) & 0xFF;
+        p[1 + name_len + 2] = (interval_ms >>  8) & 0xFF;
+        p[1 + name_len + 3] = interval_ms & 0xFF;
+        send_to(sock, &server_addr, MSG_SUBSCRIBE, p, 1 + name_len + 4);
+        printf("Subscribed... counting PUSHes\n");
+    }
+
+    start = time(NULL);
+    maxfd = sock + 1;
+
+    while (1) {
+        FD_ZERO(&readfds);
+        FD_SET(sock, &readfds);
+
+        if (select(maxfd, &readfds, NULL, NULL, NULL) < 0) {
+            if (errno == EINTR) continue;
+            perror("select");
+            break;
+        }
+
+        if (FD_ISSET(sock, &readfds)) {
+            if (recv_from_exact(sock, header, HEADER_SIZE) != HEADER_SIZE) break;
+
+            type = header[0];
+            len  = (header[1] << 8) | header[2];
+
+            if (len > 0) {
+                if (recv_from_exact(sock, payload, len) != len) break;
+            }
+
+            if (type == MSG_PUSH) {
+                unsigned char name_len = payload[0];
+                payload[1 + name_len] = '\0';
+                memcpy(&val, payload + 1 + name_len, sizeof(double));
+                count++;
+            }
+            else if (type == MSG_METRIC_RESP && flood_mode) {
+                count++;
+            }
+            else if (type == MSG_ERROR) {
+                printf("  [ERROR] %.*s\n", len, payload);
+            }
+        }
+
+        now = time(NULL);
+        if (now - start >= duration) break;
+    }
+
+    if (!flood_mode) {
+        send_to(sock, &server_addr, MSG_UNSUB, NULL, 0);
+    }
+
+    printf("\n=== Results ===\n");
+    printf("Duration:      %lu seconds\n", (unsigned long)(now - start));
+    printf("Messages received: %lu\n", count);
+    printf("Throughput:    %.1f messages/second\n", (double)count / (now - start));
+    if (flood_mode) {
+        printf("(This is the rate of successful round-trips)\n");
+    } else {
+        printf("(UDP PUSH rate — best-effort)\n");
+    }
+
+    close(sock);
+    return 0;
+}