Non-Blocking I/O

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

#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
 
int main() {
    // Open a named pipe (FIFO) in non-blocking mode
    // Without O_NONBLOCK, this would block until a writer opens the FIFO
    int fd = open("/tmp/myfifo", O_RDONLY | O_NONBLOCK);
    
    if (fd < 0) {
        perror("open");
        return 1;
    }
    
    // All reads on this fd will be non-blocking
    char buffer[1024];
    ssize_t n = read(fd, buffer, sizeof(buffer));
    
    if (n < 0) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            printf("No data available yet (not an error)
");
        } else {
            perror("read error");
        }
    } else if (n == 0) {
        printf("EOF reached
");
    } else {
        printf("Read %zd bytes
", n);
    }
    
    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

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
 
/**
 * Set a file descriptor to non-blocking mode.
 * Returns 0 on success, -1 on error.
 */
int set_nonblocking(int fd) {
    // Get current flags
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags < 0) {
        perror("fcntl F_GETFL");
        return -1;
    }
    
    // Add O_NONBLOCK flag
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
        perror("fcntl F_SETFL");
        return -1;
    }
    
    return 0;
}
 
/**
 * Set a file descriptor back to blocking mode.
 */
int set_blocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags < 0) return -1;
    
    // Remove O_NONBLOCK flag
    return fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
}
 
int main() {
    // Create a socket (blocking by default)
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    
    // Make it non-blocking
    if (set_nonblocking(sockfd) < 0) {
        return 1;
    }
    
    // Now all I/O on sockfd will be non-blocking
    // connect(), read(), write() all return immediately
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10

#include <sys/socket.h>
#include <netinet/in.h>
 
// Create a non-blocking TCP socket in one call
// Avoids race condition between socket() and fcntl()
int sockfd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
 
// Similarly for accept4():
int client_fd = accept4(server_fd, NULL, NULL, SOCK_NONBLOCK);
// The new client socket is created in non-blocking mode

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

#include <unistd.h>
#include <errno.h>
#include <stdio.h>
 
/**
 * Attempt to read available data from a non-blocking fd.
 * Returns:
 *   > 0: bytes read
 *   0: EOF
 *   -1: would block (not an error!)
 *   -2: actual error
 */
ssize_t try_read(int fd, void *buf, size_t count) {
    ssize_t n = read(fd, buf, count);
    
    if (n > 0) {
        // Success! Got some data
        return n;
    }
    
    if (n == 0) {
        // EOF / connection closed
        return 0;
    }
    
    // n == -1, check errno
    if (errno == EAGAIN || errno == EWOULDBLOCK) {
        // NOT an error: just no data available
        return -1;  // Signal "would block"
    }
    
    if (errno == EINTR) {
        // Interrupted by signal - typically retry immediately
        return try_read(fd, buf, count);  // Recursive retry
    }
    
    // Actual error
    perror("read");
    return -2;
}
 
/**
 * Non-blocking read pattern: read all available data
 * Useful for draining a socket of all pending data
 */
ssize_t read_all_available(int fd, void *buf, size_t bufsize) {
    size_t total = 0;
    char *ptr = (char *)buf;
    
    while (total < bufsize) {
        ssize_t n = read(fd, ptr + total, bufsize - total);
        
        if (n > 0) {
            total += n;
            // Continue reading - there might be more data
            continue;
        }
        
        if (n == 0) {
            // EOF reached
            break;
        }
        
        // n == -1
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            // No more data available right now
            // This is NOT an error - we've read all available data
            break;
        }
        
        if (errno == EINTR) {
            continue;  // Retry
        }
        
        // Actual error
        return -1;
    }
    
    return total;
}

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

#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
 
/**
 * Write buffer for handling partial writes in non-blocking I/O.
 * Tracks pending data that couldn't be written immediately.
 */
typedef struct {
    char *data;         // Buffer of pending data
    size_t capacity;    // Total buffer capacity
    size_t size;        // Amount of pending data
    size_t offset;      // Start of pending data (bytes already sent)
} WriteBuffer;
 
/**
 * Initialize a write buffer.
 */
WriteBuffer *write_buffer_create(size_t capacity) {
    WriteBuffer *wb = malloc(sizeof(WriteBuffer));
    wb->data = malloc(capacity);
    wb->capacity = capacity;
    wb->size = 0;
    wb->offset = 0;
    return wb;
}
 
/**
 * Add data to the write buffer.
 * Returns 0 on success, -1 if buffer is full.
 */
int write_buffer_append(WriteBuffer *wb, const void *data, size_t len) {
    // Compact buffer if needed
    if (wb->offset > 0 && wb->offset + wb->size + len > wb->capacity) {
        memmove(wb->data, wb->data + wb->offset, wb->size);
        wb->offset = 0;
    }
    
    if (wb->size + len > wb->capacity) {
        return -1;  // Buffer full
    }
    
    memcpy(wb->data + wb->offset + wb->size, data, len);
    wb->size += len;
    return 0;
}
 
/**
 * Attempt to flush write buffer to non-blocking fd.
 * Returns:
 *   1: all data flushed
 *   0: partial write, data remains
 *   -1: error (connection closed or other)
 */
int write_buffer_flush(WriteBuffer *wb, int fd) {
    while (wb->size > 0) {
        ssize_t n = write(fd, wb->data + wb->offset, wb->size);
        
        if (n > 0) {
            wb->offset += n;
            wb->size -= n;
            continue;  // Try to write more
        }
        
        if (n == 0) {
            // Unusual but handle defensively
            return 0;  // Partial progress
        }
        
        // n == -1
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            // Kernel buffer full, can't write more now
            return 0;  // Partial: data remains
        }
        
        if (errno == EINTR) {
            continue;  // Retry immediately
        }
        
        // EPIPE, ECONNRESET, or other error
        return -1;
    }
    
    // All data flushed!
    wb->offset = 0;
    return 1;
}
 
/**
 * Check if buffer has pending data.
 */
int write_buffer_has_data(WriteBuffer *wb) {
    return wb->size > 0;
}
 
// Usage example
void example_usage(int sockfd) {
    WriteBuffer *wb = write_buffer_create(65536);
    
    // Application wants to send a message
    const char *msg = "Hello, World!";
    write_buffer_append(wb, msg, strlen(msg));
    
    // Try to flush
    int result = write_buffer_flush(wb, sockfd);
    
    if (result == 1) {
        // All sent!
    } else if (result == 0) {
        // Partial write - need to monitor fd for writability
        // When epoll says fd is writable, call flush again
    } else {
        // Error - connection problems
    }
}

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

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
 
/**
 * Initiate a non-blocking connect.
 * Returns:
 *   1: connected immediately (local connection, rare)
 *   0: connection in progress
 *   -1: error
 */
int start_connect(int sockfd, const char *host, int port) {
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    inet_pton(AF_INET, host, &addr.sin_addr);
    
    int result = connect(sockfd, (struct sockaddr *)&addr, sizeof(addr));
    
    if (result == 0) {
        // Connected immediately (rare - usually loopback only)
        return 1;
    }
    
    if (errno == EINPROGRESS) {
        // Connection initiated, check back later
        return 0;
    }
    
    // Actual error (ECONNREFUSED, ENETUNREACH, etc.)
    return -1;
}
 
/**
 * Check if a non-blocking connect has completed.
 * Call this after poll/epoll indicates the socket is writable.
 * Returns:
 *   0: success, connected
 *   -1: connection failed (errno set)
 */
int check_connect_result(int sockfd) {
    int error = 0;
    socklen_t len = sizeof(error);
    
    // Get pending error on socket
    if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
        return -1;  // getsockopt failed
    }
    
    if (error != 0) {
        // Connection failed - error contains the reason
        errno = error;
        return -1;
    }
    
    // Success!
    return 0;
}
 
/**
 * Complete example: non-blocking connect with timeout
 */
int connect_with_timeout(const char *host, int port, int timeout_ms) {
    // Create non-blocking socket
    int sockfd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
    if (sockfd < 0) return -1;
    
    // Start connection
    int result = start_connect(sockfd, host, port);
    if (result == 1) {
        // Already connected
        return sockfd;
    }
    if (result < 0) {
        close(sockfd);
        return -1;
    }
    
    // Wait for socket to become writable (or timeout)
    struct pollfd pfd = {
        .fd = sockfd,
        .events = POLLOUT,  // Wait for writability
        .revents = 0
    };
    
    result = poll(&pfd, 1, timeout_ms);
    
    if (result == 0) {
        // Timeout
        close(sockfd);
        errno = ETIMEDOUT;
        return -1;
    }
    
    if (result < 0) {
        close(sockfd);
        return -1;
    }
    
    // Socket is writable - check if connect succeeded
    if (check_connect_result(sockfd) < 0) {
        close(sockfd);
        return -1;
    }
    
    // Success! Optionally switch back to blocking mode
    // (or keep non-blocking for the data phase)
    return sockfd;
}
 
int main() {
    int sock = connect_with_timeout("192.168.1.1", 80, 5000);
    if (sock < 0) {
        perror("connect failed");
        return 1;
    }
    printf("Connected!
");
    close(sock);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// BAD: Busy polling wastes CPU!
while (1) {
    ssize_t n = read(fd, buffer, sizeof(buffer));
    
    if (n > 0) {
        // Got data, process it
        process(buffer, n);
    } else if (n == 0) {
        break;  // EOF
    } else if (errno == EAGAIN) {
        // No data yet - but we immediately retry!
        // This loop runs millions of times per second
        // consuming 100% CPU doing nothing useful
        continue;  // BAD!
    } else {
        break;  // Error
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// MEDIOCRE: Sleep reduces CPU but adds latency
while (1) {
    ssize_t n = read(fd, buffer, sizeof(buffer));
    
    if (n > 0) {
        process(buffer, n);
    } else if (n == 0) {
        break;
    } else if (errno == EAGAIN) {
        // Sleep before retrying
        usleep(10000);  // 10 milliseconds
        // Problem: We ALWAYS wait 10ms, even if data arrives in 1ms
        // Average added latency: 5ms
        // This is too slow for many applications
        continue;
    } else {
        break;
    }
}

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

#include <time.h>
 
/**
 * Example: Game loop with non-blocking network I/O
 * The game continues running smoothly regardless of network conditions
 */
void game_loop(int network_socket) {
    // Socket is non-blocking
    set_nonblocking(network_socket);
    
    struct timespec last_frame, current;
    clock_gettime(CLOCK_MONOTONIC, &last_frame);
    
    while (game_running) {
        // 1. Handle network I/O (non-blocking, never stalls)
        char net_buffer[1024];
        ssize_t n = read(network_socket, net_buffer, sizeof(net_buffer));
        if (n > 0) {
            process_network_message(net_buffer, n);
        }
        // EAGAIN is fine - no network data this frame, carry on
        
        // 2. Process input (from queue, non-blocking)
        process_input_queue();
        
        // 3. Update game state
        clock_gettime(CLOCK_MONOTONIC, &current);
        double delta = (current.tv_sec - last_frame.tv_sec) + 
                       (current.tv_nsec - last_frame.tv_nsec) / 1e9;
        update_game_state(delta);
        last_frame = current;
        
        // 4. Render frame
        render_frame();
        
        // 5. Send pending network messages (non-blocking)
        flush_network_queue(network_socket);
        
        // Target 60 FPS
        sleep_until_next_frame();
    }
}