6.5 Inter-Process Communications

int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
/* 
Parameters:
	1. sockfd: The file descriptor of the socket on which to set the option.
	2. level: The level at which the option is defined (e.g., SOL_SOCKET for socket-level options, IPPROTO_TCP for TCP options).
	3. optname: The option name to set.
	   - Under SOL_SOCKET level:
	     1. SO_RCVTIMEO: set receive timeout time.
	     2. SO_SNDTIMEO: set send timeout time.
	     3. SO_REUSEADDR: allow local address reuse.
	     4. SO_KEEPALIVE: keep connections alive by enabling periodic transmissions.
	     5. SO_RCVBUF: set the receive buffer size.
	     6. SO_SNDBUF: set the send buffer size.
	     7. SO_LINGER: linger on close if data is present.
	     8. SO_BROADCAST: permit sending of broadcast messages.
	     9. SO_ERROR: retrieve and clear the socket error status.
	     10. SO_OOBINLINE: leave received out-of-band data in the input stream.
	   - Under IPPROTO_TCP level:
	     1. TCP_NODELAY: disable Nagle's algorithm.
	     2. TCP_KEEPIDLE: set the idle time before keep-alive probes are sent.
	     3. TCP_KEEPINTVL: set the interval between keep-alive probes.
	     4. TCP_KEEPCNT: set the number of keep-alive probes to be sent.
	   - Under IPPROTO_IP level:
	     1. IP_TTL: set the IP time-to-live value.
	     2. IP_MULTICAST_TTL: set the multicast time-to-live value.
	     3. IP_MULTICAST_LOOP: control the loopback of multicast packets.
	     4. IP_ADD_MEMBERSHIP: join a multicast group.
	     5. IP_DROP_MEMBERSHIP: leave a multicast group.
	   - Under IPPROTO_IPV6 level:
	     1. IPV6_V6ONLY: restrict the socket to IPv6 communications only.
	     2. IPV6_MULTICAST_HOPS: set the multicast hop limit.
	     3. IPV6_MULTICAST_LOOP: control the loopback of multicast packets.
	     4. IPV6_JOIN_GROUP: join an IPv6 multicast group.
	     5. IPV6_LEAVE_GROUP: leave an IPv6 multicast group.
	4. optval: A pointer to the buffer containing the value for the option. This buffer contains the value to be set for the specified option.
	5. optlen: The size, in bytes, of the buffer pointed to by optval.

Return value:
	- On success: Returns 0.
	- On failure: Returns -1, and errno is set to indicate the error. You can use the perror function or strerror to print the error message.
*/

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

int getaddrinfo(const char *node,    // e.g. "www,example.com" or IP
				const char *service, // e.g. "http" or port number
				const struct addrinfo *hints,
				struct addrinfo **res);

/* 
Parameters:
	1. node: hostname or IP address
	2. service: protocol or port number
	3. hints: used to restrict the kind of connection you want
	4. res: pointer to be updated with the result

Return value: 
	- Returns 0 on success, and update the pointer res points to. 
	- Else on error.
*/

struct addrinfo hints, *res;
getaddrinfo("example.com", "http", &hints, &res);

struct sockaddr_in *ipv4 = (struct sockaddr_in *)res->ai_addr;

int connect(int sockfd, struct sockaddr *addr, socklen_t len);
/* Blocking the thread by default.
Parameters:
	1. sockfd: The file descriptor for the socket to be connected. This is the integer value returned by the socket() function.
	2. addr: A pointer to a struct sockaddr, which contains the address of the target host. This can be cast to a pointer of specific address types, like sockaddr_in for IPv4 or sockaddr_in6 for IPv6.
	3. len: The size, in bytes, of the address structure pointed to by addr. Typically, this will be sizeof(struct sockaddr_in) or sizeof(struct sockaddr_in6).

Return value:
	- On success: Returns 0.
	- On failure: Returns -1, and errno is set to indicate the error. You can use the perror function or strerror to print the error message.
*/

struct addrinfo hints;
struct addrinfo *res;
int sockfd;

memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;

getaddrinfo("www.example.com", "80", &hints, &res);
sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);

int status = connect(sockfd, res->ai_addr, res->ai_addrlen);

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
/* 
Parameters:
	1. sockfd: The file descriptor of the socket to be bound. This is the integer value returned by the socket() function.
	2. addr: A pointer to a struct sockaddr, which contains the address to bind to the socket. This can be cast to a pointer of specific address types, like sockaddr_in for IPv4 or sockaddr_in6 for IPv6.
	3. addrlen: The size, in bytes, of the address structure pointed to by addr. Typically, this will be sizeof(struct sockaddr_in) or sizeof(struct sockaddr_in6).

Return value:
	- On success: Returns 0.
	- On failure: Returns -1, and errno is set to indicate the error. You can use the perror function or strerror to print the error message.
*/

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <cstring>
#include <iostream>

int main() {
    int sockfd;
    struct sockaddr_in server_addr;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return 1;
    }

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind");
        close(sockfd);
        return 1;
    }

    // Other code...
    close(sockfd);
    return 0;
}

int listen(int sockfd, int backlog);
/* 
Parameters:
	1. sockfd: The file descriptor of the socket that will be put into a listening state. This is the integer value returned by the socket() function.
	2. backlog: The maximum length to which the queue of pending connections may grow. Typically a small positive integer.

Return value:
	- On success: Returns 0.
	- On failure: Returns -1, and errno is set to indicate the error. You can use the perror function or strerror to print the error message.
*/

// Assume the bind() function has been called

if (listen(sockfd, 10) == -1) {
    perror("listen");
    close(sockfd);
    return 1;
}

// Other code...
close(sockfd);
return 0;

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
/* 
Parameters:
	1. sockfd: The file descriptor of the listening socket. This is the integer value returned by the socket() function and used by the bind() and listen() functions.
	2. addr: A pointer to a struct sockaddr, which will be filled with the address of the connecting entity. Can be cast to a pointer of specific address types, like sockaddr_in for IPv4 or sockaddr_in6 for IPv6.
	3. addrlen: A pointer to a socklen_t, which on input contains the size of addr, and on output contains the size of the address returned.

Return value:
	- On success: Returns a new file descriptor for the accepted socket.
	- On failure: Returns -1, and errno is set to indicate the error. You can use the perror function or strerror to print the error message.
*/

    // Assume bind() and listen() functions have been called

    sin_size = sizeof(struct sockaddr_in);
    new_fd = accept(sockfd, (struct sockaddr *)&client_addr, &sin_size);
    if (new_fd == -1) {
        perror("accept");
        close(sockfd);
        return 1;
    }

    std::cout << "Connection accepted" << std::endl;

    // Other code...
    close(new_fd);
    close(sockfd);
    return 0;
}

int new_fd = accept(sockfd, NULL, NULL);

int send(int sockfd, const void* msg, int length, int flags);
/* 
Parameters
	1. sockfd: Socket to send the data to
	2. msg: Bytes of data to be sent
	3. length: Size of the message
	4. flags: Options, giving in 0 will suffice, common flags are:
	    - MSG_CONFIRM: Tell the link layer that the packet was received.
	    - MSG_DONTWAIT: Enable non-blocking operation.
	    - MSG_OOB: Send out-of-band data.
	    - MSG_PEEK: Peek at the incoming message.
	    - MSG_WAITALL: Wait for the full request or error.
	    - MSG_NOSIGNAL: Do not generate SIGPIPE.
	    - MSG_MORE: Sender will send more data.

Return value: number of bytes sent, returns -1 if something went wrong
*/

int recv(int sockfd, void* buffer, int length, int flags);
/* 
Parameters
	1. sockfd: Where to receive data from
	2. buffer: Where the data goes
	3. length: The maximum size of the buffer
	4. flags: Flags can also be 0 here, common flags are:
	    - MSG_CONFIRM: Tell the link layer that the packet was received.
	    - MSG_DONTWAIT: Enable non-blocking operation.
	    - MSG_OOB: Receive out-of-band data.
	    - MSG_PEEK: Peek at the incoming message.
	    - MSG_WAITALL: Wait for the full request or error.
	    - MSG_NOSIGNAL: Do not generate SIGPIPE.

Return value: 
	- Returns the number of bytes actually read into the buffer on success.
	- Returns 0 if the connection has been closed.
	- Returns -1 on error.
*/

int sendto(int sockfd, const void *msg, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
/* 
Parameters:
	1. sockfd: The socket file descriptor.
	2. msg: A pointer to the buffer containing the message to be sent.
	3. len: The length of the message in bytes.
	4. flags: Options to modify the behavior of the function.
	5. dest_addr: A pointer to the struct sockaddr containing the destination address.
	6. addrlen: The size of the destination address structure.

Return value:
	- On success: Returns the number of bytes sent.
	- On failure: Returns -1, and errno is set to indicate the error. You can use the perror function or strerror to print the error message.
*/

int recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
/* 
Parameters:
	1. sockfd: The socket file descriptor.
	2. buf: A pointer to the buffer where the received message will be stored.
	3. len: The length of the buffer.
	4. flags: Options to modify the behavior of the function.
	5. src_addr: A pointer to the struct sockaddr where the source address will be stored. Can be NULL.
	6. addrlen: A pointer to a socklen_t object which will contain the size of the source address structure.

Return value:
	- On success: Returns the number of bytes received.
	- On failure: Returns -1, and errno is set to indicate the error. You can use the perror function or strerror to print the error message.
*/

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

int main(void) {
    CURL *curl;
    CURLcode res;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "http://example.com");
        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
        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_global_cleanup();
    return 0;
}

#include <unistd.h>

pipe(int pipefd[2]);
// pipefd[0] is the read-end
// pipefd[1] is the write-end

#include <mqueue.h>

mqd_t mq_open(const char *name, int oflag, ...);
/* 
Parameters:
	1. name: Name of the message queue.
	2. oflag: Flags for the operation (e.g., O_CREAT to create the queue if it doesn't exist).
	3. ...: Optional mode and attributes (used when creating the queue).

Return value: Message queue descriptor (mqd_t) on success, (mqd_t)-1 on failure and sets errno appropriately.
*/

int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio);
/* 
Parameters:
	1. mqdes: Message queue descriptor.
	2. msg_ptr: Pointer to the message to be sent.
	3. msg_len: Size of the message in bytes.
	4. msg_prio: Priority of the message.

Return value: 0 on success, -1 on failure and sets errno appropriately.
*/

ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio);
/* 
Parameters:
	1. mqdes: Message queue descriptor.
	2. msg_ptr: Pointer to the buffer where the received message will be stored.
	3. msg_len: Size of the message buffer in bytes.
	4. msg_prio: Pointer to store the message priority (optional).

Return value: Number of bytes received on success, -1 on failure and sets errno appropriately.
*/

int mq_close(mqd_t mqdes);
/* 
Parameters:
	1. mqdes: Message queue descriptor.

Return value: 0 on success, -1 on failure and sets errno appropriately.
*/

int mq_unlink(const char *name);
/* 
Parameters:
	1. name: Name of the message queue.

Return value: 0 on success, -1 on failure and sets errno appropriately.
*/

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

int msgget(key_t key, int msgflg);
/* 
Parameters:
	1. key: Unique key to identify the message queue.
	2. msgflg: Flags for the operation (e.g., IPC_CREAT to create the queue if it doesn't exist).

Return value: Message queue identifier (msgid) on success, -1 on failure and sets errno appropriately.
*/

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
/* 
Parameters:
	1. msqid: Message queue identifier.
	2. msgp: Pointer to the message to be sent.
	3. msgsz: Size of the message in bytes.
	4. msgflg: Message flags to alter default behavior (e.g., IPC_NOWAIT).

Return value: 0 on success, -1 on failure and sets errno appropriately.
*/

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
/* 
Parameters:
	1. msqid: Message queue identifier.
	2. msgp: Pointer to the buffer where the received message will be stored.
	3. msgsz: Size of the message buffer in bytes.
	4. msgtyp: Type of message to be received.
	5. msgflg: Message flags to alter default behavior (e.g., IPC_NOWAIT).

Return value: Number of bytes received on success, -1 on failure and sets errno appropriately.
*/

int msgctl(int msqid, int cmd, struct msqid_ds *buf);
/* 
Parameters:
	1. msqid: Message queue identifier.
	2. cmd: Command to perform on the message queue (e.g., IPC_RMID to remove the queue).
	3. buf: Pointer to a struct msqid_ds, used for control commands that require or return data.

Return value: 0 on success, -1 on failure and sets errno appropriately.
*/

#include <sys/mman.h>

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
/* 
Parameters:
	1. addr: Starting address for the new mapping. Typically set to NULL to let the kernel choose the address.
	2. length: Length of the mapping in bytes. Must be a multiple of the system's page size.
	3. prot: Desired memory protection of the mapping. This can be a combination of the following:
	   - PROT_READ: Pages can be read.
	   - PROT_WRITE: Pages can be written.
	   - PROT_EXEC: Pages can be executed.
	   - PROT_NONE: Pages cannot be accessed.
	4. flags: Flags that determine the nature of the mapping. Common flags include:
       - MAP_SHARED: Write updates to the mapping are visible to other processes mapping the same region, and also reflected in the underlying file.
       - MAP_PRIVATE: Changes to the mapping are private to the process and not visible to other processes. Changes are not reflected in the underlying file (copy-on-write).
       - MAP_ANONYMOUS: Mapping is not backed by any file; the fd parameter is ignored (should be -1).
       - MAP_FIXED: Forces the mapping to use exactly the address specified in addr. Be cautious as it may overwrite existing mappings.
       - MAP_FIXED_NOREPLACE: Similar to MAP_FIXED, but will fail with EINVAL if the specified address is already occupied.
       - MAP_POPULATE: Populates page tables for the mapping immediately instead of waiting for lazy access.
       - MAP_NORESERVE: Prevents reserving swap space for the mapping. If physical memory runs out, the process may be terminated.
       - MAP_LOCKED: Locks the mapping in memory, preventing it from being swapped out.
       - MAP_HUGETLB: Uses huge pages for the mapping to reduce TLB (Translation Lookaside Buffer) overhead.
       - MAP_UNINITIALIZED: Allocates uninitialized memory. Unsafe and supported only on specific architectures.
	5. fd: File descriptor of the file to be mapped. Ignored if MAP_ANONYMOUS is set.
	6. offset: Offset in the file where the mapping starts. Typically set to 0.

Return value: Returns a pointer to the mapped area on success, or MAP_FAILED on failure. The errno variable is set to indicate the error.
*/

#include <sys/mman.h>

int mprotect(void* address, size_t length, int prot);
/* 
Parameters:
	1. address: Starting address of the memory region to be protected.
	2. length: Length of the memory region in bytes.
	3. prot: Desired protection of the memory region. It can be a combination of the following:
	   - PROT_READ: Pages can be read.
	   - PROT_WRITE: Pages can be written.
	   - PROT_EXEC: Pages can be executed.
	   - PROT_NONE: Pages cannot be accessed.
   
Return value: Returns 0 on success, -1 on failure and sets errno to indicate the error.
*/

#include <sys/mman.h>

int msync(void* address, size_t length, int flags);
/* 
Parameters:
	1. address: Starting address of the memory region to be synchronized.
	2. length: Length of the memory region to be synchronized.
	3. flags: Flags that determine the synchronization behavior. Common flags include:
	   - MS_SYNC: Perform synchronous writes(blocking).
	   - MS_ASYNC: Perform asynchronous writes.
	   - MS_INVALIDATE: Invalidate all cached data.

Return value: Returns 0 on success, -1 on failure and sets errno to indicate the error.
*/

int munmap(void *addr, size_t length);
/* 
Parameters:
	1. addr: Starting address of the memory region to be unmapped. This should be the address returned by a previous call to mmap.
	2. length: Length of the memory region to be unmapped. Must be the same length as that specified in the original mmap call.

Return value: Returns 0 on success, -1 on failure and sets errno to indicate the error.
*/

void *mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
// Size must be a multiple of the system's page size. (4n * KB)

void *mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
// Size must be a multiple of the system's page size. (4n * KB)

struct task_struct{
// ...
	// 指向一个signal_struct结构体的指针。用于管理与进程相关的信号信息。
	struct signal_struct *signal; 
	// 指向一个sighand_struct结构体。用于管理信号服务例程。	
	struct sighand_struct *sighand; 
	// 用于表示当前被阻塞的信号。其中sigset_t是一个64位的位掩码。
	sigset_t blocked;
	// sigpending用于表示当前挂起的信号。
	struct sigpending pending;
// ...
}