14. Asynchronous IO

#include <fcntl.h> // For open(), O_RDONLY, O_WRONLY, O_RDWR, and file access modes
#include <unistd.h>// For close(), read(), write(), fsync(), lseek(), and others.

// Non-blocking file read. It still blocks, not what we expected.

int fd = open("example.txt", O_RDONLY | O_NONBLOCK);
int bytes_read = read(fd, buffer, numbytes);
// Do something here.
close(fd);

int sockfd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(sockfd, F_SETFL, O_NONBLOCK);

#include <sys/select.h> // For select() and related macros
#include <sys/time.h>   // For struct timeval
#include <sys/types.h>  // For data types used in some system calls
#include <unistd.h>     // For close(), read(), and other unix system calls

int select( int nfds, 
		    fd_set *_Nullable restrict readfds,
            fd_set *_Nullable restrict writefds,
            fd_set *_Nullable restrict exceptfds,
            struct timeval *_Nullable restrict timeout);
/* Parameters:

1. nfds: The highest-numbered file descriptor in any of the three sets, plus 1.
2. readfds: Pointer to an fd_set that will be checked for readability.
3. writefds: Pointer to an fd_set that will be checked for writability.
4. exceptfds: Pointer to an fd_set that will be checked for exceptional conditions.
5. timeout: Pointer to a struct timeval that specifies the maximum interval to wait for any file descriptor to become ready. If NULL, select() will block indefinitely.

Return value: 
- On success, returns the number of file descriptors contained in the three returned descriptor sets (that is, the total number of bits that are set in readfds, writefds, and exceptfds).
- On error, returns -1 and sets errno to indicate the error.
*/

void listen_for_connections(int client_sock1, int client_sock2, int client_sock3);
{
	int nfds = 1 +  (client_sock1 > client_sock2 
	                ?
	                (client_sock1 > client_sock3 ? client_sock1 : client_sock3)
	                : 
	                (client_sock2 > client_sock3 ? client_sock2 : client_sock3));

	fd_set s;
	struct timeval tv;
	ptintf("Startup complete!\n");
	while(!quit){
		FD_ZERO(&s);
		FD_SET(service1_sock, &s);
		FD_SET(service2_sock, &s);
		FD_SET(service3_sock, &s);
		tv.tv_sec = 30;
		tv.tv_usec = 0;

		int res = select(nfds, &s, NULL, NULL, &tv);
		// An Error occurred.
		if(res == -1){
			printf("An error occurred in selest(): %s.\n", strerror(errno));
			quit = 1;
		}
		else if(res == 0){
			printf("Still waiting events...\n");
		}
		else{
			if(FD_ISSET(service1_sock, &s)){
				service1_activate();
			}
			if(FD_ISSET(service2_sock, &s)){
				service2_activate();
			}
			if(FD_ISSET(service3_sock, &s)){
				service3_activate();
			}
		}
	}
}

#include <sys/time.h>

struct timespec{
	long tv_sec; /* seconds */
	long tv_nsec; /* nanoseconds */
};

ready = pselect(nfds, &readfds, &writefds, &exceptfds, timeout, &sigmask);

sigset_t origmask;
pthread_sigmask(SIG_SETMASK, &sigmask, &origmask); // Mask the signals in sigmask.
ready = select(nfds, &readfds, &writefds, &exceptfds, timeout);
pthread_sigmask(SIG_SETMASK, &origmask, NULL); // Back to origmask stage.

#include <poll.h>

struct pollfd{
    int fd;         /* file descriptor */
    short events;   /* requested events */
    short revents;  /* returned events */
};
/*
events/revents:
- POLLIN: Look for if there is data to read.
- POLLOUT: Writing is now possible without blocking.
- POLLRDHUP: Stream socket peer closed connection, or shut down writing half of connection.
- POLLPRI: There is urgent data to read.

revents specific(be ignored in events):
- POLLERR: Error condition.
- POLLHUP: Hang up, otherside closed socket.
- POLLNVAL: Invalid request: fd not open.

compiling with _XOPEN_SOURCE(additional bits):
- POLLRDNORM: equivalent to POLLIN
- POLLRDBAND
- POLLWRNORM
- POLLWRBAND
*/

void listen_for_connections(int client_sock1, int client_sock2, int client_sock3)
{
	struct pollfd pollfds[3];
	pollfds[0].fd = client_sock1;
	pollfds[0].events = POLLIN;
	pollfds[1].fd = client_sock2;
	pollfds[1].events = POLLIN;
	pollfds[2].fd = client_sock3;
	pollfds[2].events = POLLIN;
	int timeout = 30 * 1000;
	printf( "Going to start listening for socket events.\n" );

	while(!quit){
		int res = poll(&pollfds, 3, timeout);
		// Error checking.
		if(res == -1){
			printf
			quit = 1;
		}
		// 0 sockets had events occur
		else if(res == 0){
			printf("Still waiting for events...\n");
		}
		// things happened
		else{
			if(pollfds[0].revents & POLLIN){
				service0_activate();
			}
			if(pollfds[1].revents & POLLIN){
				service1_activate();
			}
			if(pollfds[2].revents & POLLIN){
				service2_activate();
			}						
		}
	}
}

#include <sys/epoll.h>

/* Waits for events on an epoll file descriptor. */
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
/*
Parameters:
1. epfd: The epoll file descriptor obtained from epoll_create or epoll_create1.
2. events: Pointer to an array of epoll_event structures where the ready events will be stored.
3. maxevents: The maximum number of events that can be returned (must be > 0).
4. timeout: Timeout in milliseconds:
   - -1: Block indefinitely until an event occurs.
   - 0: Return immediately.
   - > 0: Maximum wait time in milliseconds.

Return value:
- Returns the number of ready file descriptors.
- On failure, returns -1 and sets errno.
*/

/* Waits for events with the ability to temporarily block signals. */
int epoll_pwait(int epfd, struct epoll_event *events, int maxevents, int timeout,  
				const sigset_t *_Nullable sigmask);
/*
Parameters:
1. epfd, events, maxevents, timeout: Same as epoll_wait.
2. sigmask: Signal mask to be temporarily applied during the wait. Can be NULL to behave like epoll_wait.

Return value:
- Same as epoll_wait.
*/

/* Waits for events with nanosecond-resolution timeout and signal mask support. */
int epoll_pwait2(int epfd, struct epoll_event *events, int maxevents, 
				 const struct timespec *_Nullable timeout, 
				 const sigset_t *_Nullable sigmask);
/*
Parameters:
1. epfd, events, maxevents: Same as epoll_wait.
2. timeout: High-resolution timeout using timespec structure (supports nanosecond precision). NULL indicates indefinite blocking.
3. sigmask: Signal mask to be temporarily applied during the wait. Can be NULL to behave like epoll_wait.

Return value:
- Same as epoll_wait.
*/

CURL *curl_easy_init(void);
/* Initializes a CURL easy handle.
   Return value:
   - On success, returns a pointer to a CURL easy handle.
   - On failure, returns NULL.
*/

CURLcode curl_easy_setopt(CURL *handle, CURLoption option, ...);
/* Sets options for a CURL easy handle.
   Parameters:
   1. handle: The CURL easy handle.
   2. option: The option to set. Common options include:
      - CURLOPT_URL: The URL to fetch.
      - CURLOPT_POSTFIELDS: The data to send in a POST request.
      - CURLOPT_HTTPHEADER: A linked list of HTTP headers to include in the request.
      - CURLOPT_WRITEFUNCTION: A callback function to handle data received from the server.
      - CURLOPT_WRITEDATA: A pointer to pass to the write callback function.
      - CURLOPT_READFUNCTION: A callback function to handle data sent to the server.
      - CURLOPT_READDATA: A pointer to pass to the read callback function.
      - CURLOPT_TIMEOUT: The maximum time in seconds that the request is allowed to take.
   3. ...: The value to set for the option, depends on the option being set.
   Return value:
   - On success, returns CURLE_OK.
   - On failure, returns a CURLcode error value.
*/

CURLcode curl_easy_perform(CURL *handle);
/* Performs the file transfer.
   Parameters:
   1. handle: The CURL easy handle.
   Return value:
   - On success, returns CURLE_OK.
   - On failure, returns a CURLcode error value.
*/

void curl_easy_cleanup(CURL *handle);
/* Cleans up a CURL easy handle.
   Parameters:
   1. handle: The CURL easy handle to clean up.
   Return value: None.
*/

const char *curl_easy_strerror(CURLcode errornum);
/* Returns a string describing the CURLcode error.
   Parameters:
   1. errornum: The CURLcode error value.
   Return value:
   - Returns a pointer to a null-terminated string describing the error.
*/

#include <stdio.h>
#include <curl/curl.h>

int main(int argc, char** argv){
    CURL *curl;
    CURLcode res;

    curl_global_init(CURL_GLOBAL_DEFAULT);

    curl = curl_easy_init();
    if(curl){
        curl_easy_setopt(curl, CURLOPT_URL, "https://congzhi.wiki/");
        res = curl_easy_perform(curl);
    }
    if(res != CURLE_OK){
        fprintf(stderr, "curl_easy_perform() failed: %s\n",
				curl_easy_strerror(res));
        curl_easy_cleanup(curl);
    }
    curl_easy_cleanup(curl);
    curl_global_cleanup();
    return 0;
}

#include <curl/multi.h> // Included <curl/curl.h>

CURLM *curl_multi_init(void);
/* Initializes a CURL multi handle.
   Return value:
   - On success, returns a pointer to a CURL multi handle.
   - On failure, returns NULL.
*/

CURLMcode curl_multi_add_handle(CURLM *multi_handle, CURL *easy_handle);
/* Adds a CURL easy handle to a CURL multi handle.
   Parameters:
   1. multi_handle: The CURL multi handle.
   2. easy_handle: The CURL easy handle to add.
   Return value:
   - On success, returns CURLM_OK.
   - On failure, returns a CURLMcode error value.
*/

CURLMcode curl_multi_perform(CURLM *multi_handle, int *still_running_handles);
/* Performs the transfers for all added handles.
   Parameters:
   1. multi_handle: The CURL multi handle.
   2. still_running_handles: Pointer to an integer that will be set to the number of running handles.
   Return value:
   - On success, returns CURLM_OK.
   - On failure, returns a CURLMcode error value.
*/

CURLMcode curl_multi_wait(CURLM *multi_handle, struct curl_waitfd extra_fds[], 
						  unsigned int extra_nfds, int timeout_ms, int *numfds);
/* Waits for activity on any of the curl easy handles within a multi handle.
   Parameters:
   1. multi_handle: The CURL multi handle.
   2. extra_fds: An array of extra fds to wait on.(NULL)
   3. extra_nfds: The number of extra file descriptors.(0)
   4. timeout_ms: The maximum time to wait in milliseconds.
   5. numfds: Pointer to an integer number of "interesting" events occurred.
   Return value:
   - On success, returns CURLM_OK.
   - On failure, returns a CURLMcode error value.
*/

const char *curl_multi_strerror(CURLMcode errornum);
/* Returns a string describing the CURLMcode error.
   Parameters:
   1. errornum: The CURLMcode error value.
   Return value:
   - Returns a pointer to a null-terminated string describing the error.
*/

CURLMsg *curl_multi_info_read(CURLM *multi_handle, int *msgs_left);
/* Reads information about completed transfers.
   Parameters:
   1. multi_handle: The CURL multi handle.
   2. msgs_left: Pointer to an integer that will be set to the number of messages left in the queue.
   Return value:
   - On success, returns a pointer to a CURLMsg structure.
   - On failure, returns NULL.
*/

typedef struct {
    CURLMSG msg;       /* What this message means */
    CURL *easy_handle; /* The handle it concerns */
    union {
        void *whatever; /* Message-specific data */
        CURLcode result; /* Return code for transfer */
    } data;
} CURLMsg;

CURLMcode curl_multi_remove_handle(CURLM *multi_handle, CURL *easy_handle);
/* Removes an easy handle from a multi handle.
   Parameters:
   1. multi_handle: The CURL multi handle.
   2. easy_handle: The CURL easy handle to remove.
   Return value:
   - On success, returns CURLM_OK.
   - On failure, returns a CURLMcode error value, such as:
     - CURLM_BAD_HANDLE: The provided multi handle is invalid.
     - CURLM_BAD_EASY_HANDLE: The provided easy handle is invalid.
     - CURLM_OUT_OF_MEMORY: Memory allocation failed.
*/

CURLMcode curl_multi_cleanup(CURLM *multi_handle);
/* Cleans up a CURL multi handle.
   Parameters:
   1. multi_handle: The CURL multi handle to clean up.
   Return value:
   - On success, returns CURLM_OK.
   - On failure, returns a CURLMcode error value.
*/

#include <aio.h>

struct aiocb {
    int             aio_fildes;   /* File descriptor */
    off_t           aio_offset;   /* File offset */
    volatile void  *aio_buf;      /* Buffer for data */
    size_t          aio_nbytes;   /* Number of bytes for I/O */
    int             aio_reqprio;  /* Request priority */
    struct sigevent aio_sigevent; /* Signal or function to call when I/O completes */
    int             aio_lio_opcode; /* Operation to be performed (LIO_READ, LIO_WRITE, etc.) */
};

#include <signal.h>

struct sigevent {
    int          sigev_notify;              /* Notification type */
    int          sigev_signo;               /* Signal number (for signal-based notification) */
    union sigval sigev_value;               /* Data passed with notification */
    void       (*sigev_notify_function)(union sigval); /* Callback function (if applicable) */
    void        *sigev_notify_attributes;   /* Attributes for the thread (if using thread notification) */
};

union sigval {
	int          sival_int;
	void*        sival_ptr;
};