Merge pull request #12 from Shibin-Ez/master

Shibin-Ez · web-flow · commit a7f6865bdf89 · 2026-01-07T12:09:10.000+05:30
stage 4 fixes and general typos
diff --git a/.vitepress/cache/deps/chunk-Z6B2QTD3.js b/.vitepress/cache/deps/chunk-Z6B2QTD3.js
diff --git a/docs/guides/resources/coding-conventions.md b/docs/guides/resources/coding-conventions.md
@@ -73,7 +73,7 @@ If a function is intended to perform a task that could fail, it should return an
 
 ### Pointer Return with Error Code
 
-When a function needs to return a pointer to an instance and report an error code, it's not possible in C to return more than one value directly. In such cases, the return type of the function will be a pointer, and a reference to an integer, `int *error`, is passed to the function by the calling function. On error, `NULL` is returned, and the error integer is set to a valid error code.
+When a function needs to return a pointer to an instance and report an error code, it is not possible in C to return more than one value directly. In such cases, the return type of the function will be a pointer, and a reference to an integer, `int *error`, is passed to the function by the calling function. On error, `NULL` is returned, and the error integer is set to a valid error code.
 
 For example: `xps_file_t xps_file_create(..., int *error)`. On successful creation of the file instance, a valid pointer will be returned, and `*error` will be set to `E_SUCCESS`. In case of an error, `NULL` is returned, and `*error` is set to a valid error code such as `E_NOTFOUND`.
 
diff --git a/docs/guides/resources/introduction-to-linux-epoll.md b/docs/guides/resources/introduction-to-linux-epoll.md
@@ -8,7 +8,7 @@ However, a key drawback of this approach is that each time `select()` or `poll()
 
 **_epoll_** stands for _event poll_ and is a Linux-specific construct. It allows a process to monitor multiple file descriptors and receive notifications when an event occurs on them. Essentially, it is a kernel data structure facilitating I/O multiplexing on multiple file descriptors.
 
-epoll can be managed through three system calls, facilitating its creation, modification, and deletion. It is notably employed in [Nginx](https://en.wikipedia.org/wiki/Nginx), a popular web server, and it's a fundamental component of our implementation of eXpServer as well.
+epoll can be managed through three system calls, facilitating its creation, modification, and deletion. It is notably employed in [Nginx](https://en.wikipedia.org/wiki/Nginx), a popular web server, and it is a fundamental component of our implementation of eXpServer as well.
 
 ## **The Problem**
 
diff --git a/docs/guides/resources/ip.md b/docs/guides/resources/ip.md
@@ -17,7 +17,7 @@ IP addresses have two distinct versions or standards:
 - The Internet Protocol version 4 ([IPv4](https://en.wikipedia.org/wiki/Internet_Protocol_version_4)) address is the older of the two, which has space for up to 4 billion IP addresses and is assigned to all computers.
 - The more recent Internet Protocol version 6 ([IPv6](https://en.wikipedia.org/wiki/IPv6)) has space for trillions of IP addresses
 
-Every device with an internet connection has an IP address, whether it's a computer, laptop, IoT device, or even toys. The IP addresses allow for the efficient transfer of data between two connected devices, allowing machines on different networks to talk to each other.
+Every device with an internet connection has an IP address, whether it is a computer, laptop, IoT device, or even toys. The IP addresses allow for the efficient transfer of data between two connected devices, allowing machines on different networks to talk to each other.
 
 Read more about them [here](https://en.wikipedia.org/wiki/IP_address).
 
diff --git a/docs/guides/resources/linux-epoll.md b/docs/guides/resources/linux-epoll.md
@@ -14,7 +14,7 @@ This queue holds the list of processes (threads) that are currently blocked in `
 #### 2. The Ready List (`rdlist`)
 This is a **doubly linked list** that stores the file descriptors (FDs) that are currently "ready" (i.e., have data to read or space to write).
 - When an event occurs on a monitored FD, it is added to this list.
-- `epoll_wait()` simply checks this list. If it's not empty, it returns the events to the user.
+- `epoll_wait()` simply checks this list. If it is not empty, it returns the events to the user.
 
 #### 3. The Red-Black Tree (`rbr`)
 This is a **Red-Black Tree** that stores all the file descriptors currently being monitored by this epoll instance.
diff --git a/docs/roadmap/phase-0/stage-1.md b/docs/roadmap/phase-0/stage-1.md
@@ -72,7 +72,7 @@ The function takes three arguments:
 - **type:** This argument determines the communication semantics and the characteristics of the data transmission over the socket. `SOCK_STREAM` indicates a socket of type stream. Stream sockets provide a reliable, connection-oriented, and sequenced flow of data. They are typically used with the [Transmission Control Protocol (TCP)](https://en.wikipedia.org/wiki/Transmission_Control_Protocol), which ensures that data sent from one end of the connection is received correctly at the other end, with no loss, duplication, or corruption.
 - **protocol:** This specifies the specific protocol to be used with the socket. When `0` is passed as the protocol, the system selects the default protocol for the given domain and type combination. For `AF_INET` and `SOCK_STREAM`, this typically results in TCP being chosen as the protocol, as it is the default protocol for stream sockets in the IPv4 domain.
 
-Now that we've initialized our listening socket, it's crucial to ensure its proper functioning, especially in scenarios where the server is stopped and restarted frequently.
+Now that we've initialized our listening socket, it is crucial to ensure its proper functioning, especially in scenarios where the server is stopped and restarted frequently.
 
 Assume that our server is up and running, listening on a particular `IP:port` combination. When we terminate the server program, the socket goes into a `TIME_WAIT` state. In the `TIME_WAIT` state, the socket remains open for a predetermined period to ensure that any lingering packets associated with the previous connection are properly handled.
 
@@ -155,7 +155,7 @@ The [`accept()`](https://en.wikipedia.org/wiki/Berkeley_sockets#:~:text=1%20is%2
 
 - `listen_sock_fd`: The file descriptor of the listening socket.
 - `(struct sockaddr *)&client_addr`: A pointer to the `client_addr` structure where information about the client's address will be stored.
-- `&client_addr_len`: A pointer to the variable storing the size of the client address structure. Upon successful execution, `accept()` updates this variable with the actual size of the client address structure. This is required because the size of the sockaddr structure may vary depending on whether it's an IPv4 or [IPv6](https://en.wikipedia.org/wiki/IPv6) address.
+- `&client_addr_len`: A pointer to the variable storing the size of the client address structure. Upon successful execution, `accept()` updates this variable with the actual size of the client address structure. This is required because the size of the sockaddr structure may vary depending on whether it is an IPv4 or [IPv6](https://en.wikipedia.org/wiki/IPv6) address.
 
 After `accept()` completes successfully, the server can use the `conn_sock_fd` file descriptor to communicate with the client over the newly established connection.
 
diff --git a/docs/roadmap/phase-0/stage-4.md b/docs/roadmap/phase-0/stage-4.md
@@ -17,7 +17,7 @@ In the previous stage we have created a concurrent server using multithreading m
 
 [epoll](https://en.wikipedia.org/wiki/Epoll) is an I/O event notification mechanism provided by the Linux kernel. It allows applications to efficiently monitor multiple file descriptors for various I/O events.
 
-There are various [asynchronous I/O](https://en.wikipedia.org/wiki/Asynchronous_I/O) mechanisms available in operating systems. We have chosen epoll as it is widely used in modern servers such as nginx.
+There are various [I/O multiplexing](https://nima101.github.io/io_multiplexing) mechanisms available in operating systems. We have chosen epoll as it is widely used in modern servers such as nginx.
 
 ## Implementation
 
diff --git a/docs/roadmap/phase-0/stage-5-a.md b/docs/roadmap/phase-0/stage-5-a.md
@@ -129,7 +129,7 @@ Now that we have that, we are ready to start accepting connection; so lets write
 - Accept the client connection and create the connection socket FD `conn_sock_fd`
 - Add the connection socket to epoll to monitor for events using `epoll_ctl()`
 - Open up a connection to the upstream server using `connect_upstream()`, and add it to the epoll
-- An entry will be added to the route table with the `conn_sock_fd` and it's corresponding `upstream_sock_fd`
+- An entry will be added to the route table with the `conn_sock_fd` and it is corresponding `upstream_sock_fd`
 
 ```c
 void accept_connection(int listen_sock_fd) {
diff --git a/docs/roadmap/phase-0/stage-5-b.md b/docs/roadmap/phase-0/stage-5-b.md
@@ -77,7 +77,7 @@ we opened the file **t2.txt** for writing the contents from the client. Recieve
     }
 ```
 
-The `fprintf()` function in C writes formatted output to a specified file stream. It's defined in the `<stdio.h>` library and works similarly to `printf()`, but instead of writing to the console, it writes to a file. After writing the data into the text file we can close the file using the `fclose()` function.
+The `fprintf()` function in C writes formatted output to a specified file stream. It is defined in the `<stdio.h>` library and works similarly to `printf()`, but instead of writing to the console, it writes to a file. After writing the data into the text file we can close the file using the `fclose()` function.
 
 ```c
     fclose(fp);
diff --git a/docs/roadmap/phase-1/stage-13.md b/docs/roadmap/phase-1/stage-13.md
@@ -481,7 +481,7 @@ In this function similar to pipes, listeners and connections filter out the numb
 
 ## Modifications to `xps_listener` Module
 
-Till the previous stages we have seen that on accepting a connection on the listening socket, the `listener_connection_handler()` will call the `xps_connection_create()` to create a connection instance for the incoming client connection. Further depending on the port on which the client request is received, either upstream module or file module are created using `xps_upstream_create()` or `xps_file_create()` . From this stage on wards instead of directly calling upstream create and file create form `listener_connection_handler()`, we will be calling `xps_session_create()`, which will further decide on whether to create upstream or file modules. On accepting a connection on the listening socket, the `listener_connection_handler()` will create a connection instance as well as a session instance.
+Till the previous stages we have seen that on accepting a connection on the listening socket, the `listener_connection_handler()` will call the `xps_connection_create()` to create a connection instance for the incoming client connection. Further depending on the port on which the client request is received, either upstream module or file module are created using `xps_upstream_create()` or `xps_file_create()` . From this stage onwards, instead of directly calling upstream create and file create form `listener_connection_handler()`, we will be calling `xps_session_create()`, which will further decide on whether to create upstream or file modules. On accepting a connection on the listening socket, the `listener_connection_handler()` will create a connection instance as well as a session instance.
 
 ```c
 void listener_connection_handler(void *ptr) {
diff --git a/docs/roadmap/phase-1/stage-6.md b/docs/roadmap/phase-1/stage-6.md
@@ -105,7 +105,7 @@ void xps_loop_run(int epoll_fd);
 Let us have a brief look at what are included in the file:
 
 - `#ifndef XPS_H` & `#define XPS_H`:
-  This is called an [include guard](https://en.wikipedia.org/wiki/Include_guard) in C programming. It's a common technique used to prevent multiple inclusions of the same header file while compiling.
+  This is called an [include guard](https://en.wikipedia.org/wiki/Include_guard) in C programming. It is a common technique used to prevent multiple inclusions of the same header file while compiling.
 - **Standard header files:**
   Headers files from [C standard library](https://en.wikipedia.org/wiki/C_standard_library). The use of each header will be explained at appropriate parts of the stage.
 - **3rd party libraries:**
diff --git a/docs/roadmap/phase-2/stage-14.md b/docs/roadmap/phase-2/stage-14.md
@@ -505,7 +505,7 @@ GET http://example.com/index.html HTTP/1.1
 1. Initial State: RL_START
 
 - The parser starts in the `RL_START` state.
-- It reads the first character, which is `'G'`. The method starts at this position. Since it's a valid character for an HTTP method, it moves to the `RL_METHOD` state.
+- It reads the first character, which is `'G'`. The method starts at this position. Since it is a valid character for an HTTP method, it moves to the `RL_METHOD` state.
 
 2. State: RL_METHOD
 
diff --git a/docs/roadmap/phase-2/stage-16.md b/docs/roadmap/phase-2/stage-16.md
@@ -1462,7 +1462,7 @@ As the server configuration is present in the form of JSON data, a parser is req
         /* Serialization */
         
         /*  APPEND_STRING() is only called on string literals.
-            It's a bit hacky because it makes plenty of assumptions about the external state
+            It is a bit hacky because it makes plenty of assumptions about the external state
             and should eventually be tidied up into a function (same goes for APPEND_INDENT)
          */
         #define APPEND_STRING(str) do {\
@@ -2863,7 +2863,7 @@ As the server configuration is present in the form of JSON data, a parser is req
             char cleanup_command[256];
             char output_filename[] = "commits.json";
             
-            /* it ain't pretty, but it's not a libcurl tutorial */
+            /* it ain't pretty, but it is not a libcurl tutorial */
             sprintf(curl_command, 
                 "curl -s \"https://api.github.com/repos/%s/%s/commits\" > %s",
                 username, repo, output_filename);

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ we opened the file t2.txt for writing the contents from the client. Recieve`
`77`	`77`	`}`
`78`	`78`	```
`79`	`79`
`80`		-The `fprintf()` function in C writes formatted output to a specified file stream. It's defined in the `<stdio.h>` library and works similarly to `printf()`, but instead of writing to the console, it writes to a file. After writing the data into the text file we can close the file using the `fclose()` function.
	`80`	+The `fprintf()` function in C writes formatted output to a specified file stream. It is defined in the `<stdio.h>` library and works similarly to `printf()`, but instead of writing to the console, it writes to a file. After writing the data into the text file we can close the file using the `fclose()` function.
`81`	`81`
`82`	`82`	```c
`83`	`83`	`fclose(fp);`