1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

// Socket creation and addressing fundamentals
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
 
// Create a socket
int create_tcp_socket() {
    // socket(domain, type, protocol)
    // - AF_INET: IPv4
    // - SOCK_STREAM: TCP (reliable, connection-oriented)
    // - 0: Default protocol for type
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    
    if (sock < 0) {
        perror("socket creation failed");
        return -1;
    }
    
    return sock;  // Returns file descriptor >= 0
}
 
int create_udp_socket() {
    // SOCK_DGRAM: UDP (unreliable, connectionless)
    return socket(AF_INET, SOCK_DGRAM, 0);
}
 
int create_ipv6_socket() {
    // AF_INET6: IPv6
    return socket(AF_INET6, SOCK_STREAM, 0);
}
 
// Socket address structures
void demonstrate_addressing() {
    // IPv4 address structure
    struct sockaddr_in addr4 = {
        .sin_family = AF_INET,
        .sin_port = htons(8080),  // Network byte order (big-endian)
        .sin_addr.s_addr = inet_addr("192.168.1.100"),
    };
    
    // Or use inet_pton for both IPv4 and IPv6
    struct sockaddr_in6 addr6;
    memset(&addr6, 0, sizeof(addr6));
    addr6.sin6_family = AF_INET6;
    addr6.sin6_port = htons(8080);
    inet_pton(AF_INET6, "::1", &addr6.sin6_addr);  // Localhost
    
    // INADDR_ANY: Bind to all local interfaces
    struct sockaddr_in any_addr = {
        .sin_family = AF_INET,
        .sin_port = htons(8080),
        .sin_addr.s_addr = INADDR_ANY,  // 0.0.0.0
    };
}
 
// Byte order conversion functions
void byte_order_example() {
    uint16_t port = 8080;
    uint32_t ip = 0xC0A80164;  // 192.168.1.100
    
    // Host to Network (for sending)
    uint16_t net_port = htons(port);  // host-to-network short
    uint32_t net_ip = htonl(ip);      // host-to-network long
    
    // Network to Host (after receiving)
    uint16_t host_port = ntohs(net_port);
    uint32_t host_ip = ntohl(net_ip);
    
    // These are no-ops on big-endian systems
    // but essential on little-endian (x86, ARM)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

// Complete TCP server implementation
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
 
#define PORT 8080
#define BACKLOG 128      // Listen queue size
#define BUFFER_SIZE 4096
 
int main() {
    int server_fd, client_fd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[BUFFER_SIZE];
    
    // 1. CREATE SOCKET
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    
    // Set SO_REUSEADDR to avoid "Address already in use" on restart
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
    // 2. BIND TO ADDRESS
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;  // All interfaces
    server_addr.sin_port = htons(PORT);
    
    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }
    
    // 3. LISTEN FOR CONNECTIONS
    // BACKLOG: Maximum pending connections in the queue
    if (listen(server_fd, BACKLOG) < 0) {
        perror("listen failed");
        exit(EXIT_FAILURE);
    }
    
    printf("Server listening on port %d
", PORT);
    
    // 4. ACCEPT CONNECTIONS (main loop)
    while (1) {
        // accept() blocks until a client connects
        client_fd = accept(server_fd, 
                          (struct sockaddr*)&client_addr, 
                          &client_len);
        
        if (client_fd < 0) {
            perror("accept failed");
            continue;
        }
        
        // Log client connection
        char client_ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));
        printf("Client connected: %s:%d
", client_ip, ntohs(client_addr.sin_port));
        
        // 5. HANDLE CLIENT (simple echo server)
        ssize_t bytes_read;
        while ((bytes_read = read(client_fd, buffer, sizeof(buffer) - 1)) > 0) {
            buffer[bytes_read] = '\0';  // Null-terminate
            printf("Received: %s
", buffer);
            
            // Echo back to client
            write(client_fd, buffer, bytes_read);
        }
        
        // 6. CLOSE CLIENT CONNECTION
        close(client_fd);
        printf("Client disconnected
");
    }
    
    close(server_fd);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

// Complete TCP client implementation
#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 <netdb.h>
 
#define BUFFER_SIZE 4096
 
int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <host> <port>
", argv[0]);
        exit(EXIT_FAILURE);
    }
    
    const char *host = argv[1];
    int port = atoi(argv[2]);
    
    int sock;
    struct sockaddr_in server_addr;
    char buffer[BUFFER_SIZE];
    
    // 1. CREATE SOCKET
    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    
    // Resolve hostname to IP address
    struct hostent *server = gethostbyname(host);
    if (server == NULL) {
        fprintf(stderr, "Host not found: %s
", host);
        exit(EXIT_FAILURE);
    }
    
    // Set up server address
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    memcpy(&server_addr.sin_addr.s_addr, server->h_addr, server->h_length);
    server_addr.sin_port = htons(port);
    
    // 2. CONNECT TO SERVER
    // This initiates the three-way handshake
    if (connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("connect failed");
        exit(EXIT_FAILURE);
    }
    
    printf("Connected to %s:%d
", host, port);
    
    // 3. SEND AND RECEIVE DATA
    const char *message = "Hello, server!";
    ssize_t sent = write(sock, message, strlen(message));
    printf("Sent %zd bytes: %s
", sent, message);
    
    ssize_t received = read(sock, buffer, sizeof(buffer) - 1);
    if (received > 0) {
        buffer[received] = '\0';
        printf("Received %zd bytes: %s
", received, buffer);
    }
    
    // 4. CLOSE CONNECTION
    close(sock);
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

// UDP server and client implementation
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
 
#define PORT 8080
#define BUFFER_SIZE 65535  // Max UDP payload
 
// =================== UDP SERVER ===================
void udp_server() {
    int sock;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[BUFFER_SIZE];
    
    // Create UDP socket
    sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    
    // Bind to address
    memset(&server_addr, 0, sizeof(server_addr));
    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 failed");
        exit(EXIT_FAILURE);
    }
    
    printf("UDP server listening on port %d
", PORT);
    
    // No listen() or accept() needed!
    // Just receive datagrams directly
    
    while (1) {
        // recvfrom: receive data and get sender's address
        ssize_t received = recvfrom(sock, buffer, sizeof(buffer) - 1, 0,
                                    (struct sockaddr*)&client_addr, &client_len);
        
        if (received < 0) {
            perror("recvfrom failed");
            continue;
        }
        
        buffer[received] = '\0';
        
        char client_ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));
        printf("Received from %s:%d: %s
", 
               client_ip, ntohs(client_addr.sin_port), buffer);
        
        // sendto: send response to the client
        const char *response = "Message received";
        sendto(sock, response, strlen(response), 0,
               (struct sockaddr*)&client_addr, client_len);
    }
    
    close(sock);
}
 
 
// =================== UDP CLIENT ===================
void udp_client(const char *server_ip, int port) {
    int sock;
    struct sockaddr_in server_addr;
    socklen_t server_len = sizeof(server_addr);
    char buffer[BUFFER_SIZE];
    
    // Create UDP socket
    sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }
    
    // Set up server address (no connect needed!)
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    inet_pton(AF_INET, server_ip, &server_addr.sin_addr);
    
    // Send datagram
    const char *message = "Hello, UDP server!";
    ssize_t sent = sendto(sock, message, strlen(message), 0,
                          (struct sockaddr*)&server_addr, server_len);
    printf("Sent %zd bytes
", sent);
    
    // Optional: Set receive timeout (UDP can't guarantee response)
    struct timeval timeout = {.tv_sec = 5, .tv_usec = 0};
    setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
    
    // Receive response
    ssize_t received = recvfrom(sock, buffer, sizeof(buffer) - 1, 0,
                                (struct sockaddr*)&server_addr, &server_len);
    
    if (received < 0) {
        perror("recvfrom failed (timeout?)");
    } else {
        buffer[received] = '\0';
        printf("Received: %s
", buffer);
    }
    
    close(sock);
}
 
 
// =================== CONNECTED UDP ===================
// You can also "connect" a UDP socket for convenience
 
void connected_udp_client(const char *server_ip, int port) {
    int sock;
    struct sockaddr_in server_addr;
    
    sock = socket(AF_INET, SOCK_DGRAM, 0);
    
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    inet_pton(AF_INET, server_ip, &server_addr.sin_addr);
    
    // "Connect" associates default destination with this socket
    // Does NOT establish a connection! Just sets default address
    connect(sock, (struct sockaddr*)&server_addr, sizeof(server_addr));
    
    // Now can use send/recv instead of sendto/recvfrom
    send(sock, "Hello", 5, 0);  // Goes to connected address
    
    char buffer[1024];
    recv(sock, buffer, sizeof(buffer), 0);  // Only from connected address
    
    close(sock);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

// Common socket options and their usage
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
 
void configure_socket(int sock) {
    int optval;
    socklen_t optlen = sizeof(optval);
    
    // =================== SO_REUSEADDR ===================
    // Allow reuse of local address. Essential for servers that restart.
    // Without this, bind() fails with "Address already in use" for
    // TIME_WAIT connections from previous server instance.
    optval = 1;
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
    
    
    // =================== SO_REUSEPORT ===================
    // Allow multiple sockets to bind to same port.
    // Enables multiple processes/threads to share one port.
    // Kernel load-balances incoming connections.
    optval = 1;
    setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval));
    
    
    // =================== SO_RCVBUF / SO_SNDBUF ===================
    // Set receive and send buffer sizes.
    // Larger buffers improve throughput on high-latency connections.
    // Must set before connect() for automatic TCP window scaling.
    int recv_buffer = 256 * 1024;  // 256 KB
    int send_buffer = 256 * 1024;
    setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &recv_buffer, sizeof(recv_buffer));
    setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &send_buffer, sizeof(send_buffer));
    
    // Read back actual size (kernel may double it)
    getsockopt(sock, SOL_SOCKET, SO_RCVBUF, &optval, &optlen);
    printf("Actual receive buffer: %d bytes
", optval);
    
    
    // =================== SO_RCVTIMEO / SO_SNDTIMEO ===================
    // Set timeout for blocking read/write operations.
    // Operations return -1 with errno=EAGAIN on timeout.
    struct timeval recv_timeout = {.tv_sec = 30, .tv_usec = 0};
    struct timeval send_timeout = {.tv_sec = 30, .tv_usec = 0};
    setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &recv_timeout, sizeof(recv_timeout));
    setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &send_timeout, sizeof(send_timeout));
    
    
    // =================== SO_KEEPALIVE ===================
    // Enable TCP keepalive probes.
    // Detects dead connections when no data is exchanged.
    optval = 1;
    setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval));
    
    // Configure keepalive timing (Linux-specific)
    int keepalive_idle = 60;    // Seconds before first probe
    int keepalive_interval = 10; // Seconds between probes
    int keepalive_count = 5;     // Probes before connection is dead
    setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, &keepalive_idle, sizeof(keepalive_idle));
    setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &keepalive_interval, sizeof(keepalive_interval));
    setsockopt(sock, IPPROTO_TCP, TCP_KEEPCNT, &keepalive_count, sizeof(keepalive_count));
    
    
    // =================== TCP_NODELAY ===================
    // Disable Nagle's algorithm.
    // Send data immediately, don't wait to aggregate small packets.
    // Essential for low-latency applications (interactive, RPC).
    optval = 1;
    setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval));
    
    
    // =================== TCP_QUICKACK ===================
    // Disable delayed acknowledgments.
    // ACK immediately instead of waiting up to 40ms.
    optval = 1;
    setsockopt(sock, IPPROTO_TCP, TCP_QUICKACK, &optval, sizeof(optval));
    
    
    // =================== SO_LINGER ===================
    // Control behavior on close().
    // With linger ON and timeout > 0: close() blocks until data sent
    // With linger ON and timeout = 0: close() sends RST, discards data
    struct linger linger_opt = {
        .l_onoff = 1,   // Enable linger
        .l_linger = 30, // Seconds to wait
    };
    setsockopt(sock, SOL_SOCKET, SO_LINGER, &linger_opt, sizeof(linger_opt));
}
 
 
// =================== PERFORMANCE TUNING EXAMPLE ===================
int create_optimized_server_socket(int port) {
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    
    // Reuse address for quick restart
    int opt = 1;
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    
    // Allow multiple threads to accept connections
    setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
    
    // Large buffers for high throughput
    int bufsize = 1024 * 1024;  // 1 MB
    setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
    setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
    
    // Fast connection behavior
    setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));
    
    // Enable keepalive for connection health monitoring
    setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof(opt));
    
    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_port = htons(port),
        .sin_addr.s_addr = INADDR_ANY,
    };
    bind(sock, (struct sockaddr*)&addr, sizeof(addr));
    listen(sock, 4096);  // Large backlog
    
    return sock;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

// High-performance event-driven server using epoll
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
 
#define MAX_EVENTS 10000
#define BUFFER_SIZE 4096
 
// Set socket to non-blocking mode
int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags == -1) return -1;
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}
 
int main() {
    int server_fd, epoll_fd;
    struct sockaddr_in server_addr;
    struct epoll_event event, events[MAX_EVENTS];
    
    // Create and configure server socket
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
    setsockopt(server_fd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt));
    
    set_nonblocking(server_fd);
    
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(8080);
    
    bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr));
    listen(server_fd, 4096);
    
    // Create epoll instance
    epoll_fd = epoll_create1(0);
    if (epoll_fd < 0) {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }
    
    // Add server socket to epoll
    event.data.fd = server_fd;
    event.events = EPOLLIN | EPOLLET;  // Edge-triggered mode
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &event);
    
    printf("epoll server listening on port 8080
");
    
    // Event loop
    while (1) {
        // Wait for events on any of our sockets
        int n_events = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        
        for (int i = 0; i < n_events; i++) {
            int fd = events[i].data.fd;
            
            if (events[i].events & (EPOLLERR | EPOLLHUP)) {
                // Error or hang-up
                close(fd);
                continue;
            }
            
            if (fd == server_fd) {
                // New connection(s) ready
                while (1) {
                    struct sockaddr_in client_addr;
                    socklen_t client_len = sizeof(client_addr);
                    
                    int client_fd = accept(server_fd, 
                                           (struct sockaddr*)&client_addr,
                                           &client_len);
                    
                    if (client_fd < 0) {
                        if (errno == EAGAIN || errno == EWOULDBLOCK) {
                            // No more pending connections
                            break;
                        }
                        perror("accept");
                        break;
                    }
                    
                    // Configure new client socket
                    set_nonblocking(client_fd);
                    int nodelay = 1;
                    setsockopt(client_fd, IPPROTO_TCP, TCP_NODELAY, 
                              &nodelay, sizeof(nodelay));
                    
                    // Add to epoll
                    event.data.fd = client_fd;
                    event.events = EPOLLIN | EPOLLET;
                    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event);
                }
            } else {
                // Data ready on a client socket
                char buffer[BUFFER_SIZE];
                
                while (1) {
                    ssize_t count = read(fd, buffer, sizeof(buffer));
                    
                    if (count < 0) {
                        if (errno == EAGAIN) {
                            // No more data to read
                            break;
                        }
                        perror("read");
                        close(fd);
                        break;
                    } else if (count == 0) {
                        // Client disconnected
                        close(fd);
                        break;
                    }
                    
                    // Echo data back (simple example)
                    write(fd, buffer, count);
                }
            }
        }
    }
    
    close(server_fd);
    close(epoll_fd);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

// Robust socket I/O with proper error handling
 
#include <errno.h>
#include <signal.h>
#include <sys/socket.h>
 
// =================== ROBUST READ ===================
// Handle partial reads and interrupted syscalls
ssize_t read_fully(int fd, void *buf, size_t count) {
    size_t total_read = 0;
    char *ptr = buf;
    
    while (total_read < count) {
        ssize_t bytes_read = read(fd, ptr + total_read, count - total_read);
        
        if (bytes_read < 0) {
            if (errno == EINTR) {
                // Interrupted by signal, retry
                continue;
            }
            return -1;  // Error
        }
        
        if (bytes_read == 0) {
            // EOF - connection closed
            break;
        }
        
        total_read += bytes_read;
    }
    
    return total_read;
}
 
 
// =================== ROBUST WRITE ===================
// Handle partial writes and interrupted syscalls
ssize_t write_fully(int fd, const void *buf, size_t count) {
    size_t total_written = 0;
    const char *ptr = buf;
    
    while (total_written < count) {
        ssize_t bytes_written = write(fd, ptr + total_written, 
                                       count - total_written);
        
        if (bytes_written < 0) {
            if (errno == EINTR) {
                continue;  // Retry
            }
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                // Non-blocking socket would block
                // In a real app, you'd use epoll here
                continue;
            }
            if (errno == EPIPE) {
                // Connection closed by peer
                return total_written;  // Return what we wrote
            }
            return -1;
        }
        
        total_written += bytes_written;
    }
    
    return total_written;
}
 
 
// =================== MESSAGE FRAMING ===================
// TCP is a byte stream - you need to frame messages yourself
 
typedef struct {
    uint32_t length;  // Message length (network byte order)
    uint8_t type;
    // payload follows
} __attribute__((packed)) message_header_t;
 
int send_message(int fd, uint8_t type, const void *payload, size_t len) {
    // Build header
    message_header_t header = {
        .length = htonl(len),
        .type = type,
    };
    
    // Send header
    if (write_fully(fd, &header, sizeof(header)) != sizeof(header)) {
        return -1;
    }
    
    // Send payload
    if (len > 0) {
        if (write_fully(fd, payload, len) != (ssize_t)len) {
            return -1;
        }
    }
    
    return 0;
}
 
int receive_message(int fd, uint8_t *type, void *payload, size_t max_len) {
    message_header_t header;
    
    // Read header
    if (read_fully(fd, &header, sizeof(header)) != sizeof(header)) {
        return -1;
    }
    
    *type = header.type;
    uint32_t len = ntohl(header.length);
    
    // Sanity check length
    if (len > max_len) {
        errno = EMSGSIZE;
        return -1;
    }
    
    // Read payload
    if (len > 0) {
        if (read_fully(fd, payload, len) != (ssize_t)len) {
            return -1;
        }
    }
    
    return len;
}
 
 
// =================== CONNECTION TIMEOUT ===================
// Set timeout for connect() operation
 
int connect_with_timeout(int sock, struct sockaddr *addr, 
                         socklen_t addrlen, int timeout_sec) {
    // Set non-blocking
    int flags = fcntl(sock, F_GETFL, 0);
    fcntl(sock, F_SETFL, flags | O_NONBLOCK);
    
    int result = connect(sock, addr, addrlen);
    
    if (result < 0 && errno == EINPROGRESS) {
        // Connection in progress - wait with timeout
        fd_set fdset;
        FD_ZERO(&fdset);
        FD_SET(sock, &fdset);
        
        struct timeval tv = {.tv_sec = timeout_sec, .tv_usec = 0};
        
        result = select(sock + 1, NULL, &fdset, NULL, &tv);
        
        if (result == 0) {
            errno = ETIMEDOUT;
            return -1;
        }
        
        if (result < 0) {
            return -1;
        }
        
        // Check if connection succeeded
        int error;
        socklen_t len = sizeof(error);
        getsockopt(sock, SOL_SOCKET, SO_ERROR, &error, &len);
        
        if (error) {
            errno = error;
            return -1;
        }
    }
    
    // Restore blocking mode
    fcntl(sock, F_SETFL, flags);
    
    return 0;
}
 
 
// =================== SIGNAL HANDLING ===================
// Ignore SIGPIPE to handle write to closed socket gracefully
 
void setup_signal_handling() {
    // SIGPIPE causes process to exit if writing to closed socket
    // We want errno=EPIPE instead
    signal(SIGPIPE, SIG_IGN);
    
    // Or use MSG_NOSIGNAL flag per-write:
    // send(sock, data, len, MSG_NOSIGNAL);
}