From 30abf64bf32b62e66673a7716abef7e3bb61484e Mon Sep 17 00:00:00 2001 From: Nikisha Date: Tue, 8 Oct 2024 22:38:10 +0530 Subject: [PATCH 1/6] stage-10-added --- docs/roadmap/phase-1/stage-10.md | 856 +++++++++++++++++++++++++++++++ 1 file changed, 856 insertions(+) diff --git a/docs/roadmap/phase-1/stage-10.md b/docs/roadmap/phase-1/stage-10.md index ced883d..8aa5d49 100644 --- a/docs/roadmap/phase-1/stage-10.md +++ b/docs/roadmap/phase-1/stage-10.md @@ -1 +1,857 @@ # Stage 10: Pipe Module + +## Recap + +- In the last stage we started using epoll in edge triggered mode to handle the CPU utilization problem. + +## Learning Objectives + +- Use pipes for data transmission between source and destination, hence reducing the memory usage. + +## Introduction + + In the previous stage, we implemented an edge-triggered epoll which ensures  optimal CPU utilization by triggering notifications only when the state of the file descriptor changes. Thus the issue mentioned in Experiment #1 of Stage 8 is resolved. However, the problem of high memory usage still persists. + +Reason for high memory usage is as follows: + +- The data only being send by the server and not receiving at the other end by the client leads to the kernel buffering this data into its internal buffer. +- Kernel buffer has a limited size and once its full, the data gets filled up in the user - space buffer +- Since there is no size limit for the `write_buff_list`, data gets accumulated in this user-space buffer which eventually leads to higher memory utilization + +The solution to this problem is assigning a maximum threshold for the `write_buff_list` size. By enforcing a limit on the buffer size, the uncontrolled accumulation of data in memory is prevented. Once the buffer is full, the sender won't be able to write any more data unless some of the data is received by the recipient. + +In the above scenario, **pipes** play a crucial role in managing the flow of data between the incoming stream (data being read from the socket) and the outgoing stream (data being written back to the socket). + +- Pipes act as an intermediary between the **source** (which reads data from the socket) and the **sink** (which writes data back to the socket). +- Data read from the socket is stored in a pipe’s buffer (`buff_list`), which can then be processed and written back to the client at an appropriate rate. +- **Source**: Reads data from the client and stores it in the pipe’s buffer. +- **Sink**: Reads data from the pipe’s buffer and sends it back to the client. +- Pipes allow the system to temporarily store data when the sink is not ready to process it. + +## Design + +Along with modifying the existing modules to enable data transfer through pipes, a new module (`xps_pipe`) is added. This enables creation of a  source-sink system for transferring data through pipes in an event-driven mode. + +Three new structs are introduced here. The `xps_pipe_s` struct includes the buffer and the maximum threshold. The `xps_pipe_source_s` and `xps_pipe_sink_s` structs includes the `ready`/`active` flags and callback functions. Earlier the callback functions were called based on the `read_ready` / `write_ready` flags of connection , here it would be based on the status of source/sink and whether the pipe is readable/writable. A pipe is readable if the length of `buff_list` greater than `0` and writable if its length less than the maximum threshold. + +The callback functions in `connection.c` are modified to ensure the working of source-sink system. The `connection_source_handler()` reads the data using `recv()` and writes it to pipe, whereas the `connection_sink_handler()` reads the data from pipe and `send()`. + +Here, the timeout in the `epollwait()` is set according to the existence of ready pipes. A ready pipe indicates that some operation has to be done on that - write into, read from , destroy. The availability of ready pipe leads to the timeout being set to 0, which results in a non-blocking call as discussed earlier. + +In Stage 6, we have discussed the issue of accumulating nulls in the events,connections and listeners list, here we would be filtering those. + +## Implementation + +A new module `xps_pipe` is added and the existing modules are modified. + +Modifications are carried out in the following order : + +- `xps_connection` +- `xps_listener` +- `xps_loop` +- `xps_core` + +## `xps_pipe` Module + +We are introducing pipes in this module. This will be connected to the core itself and will be implemented in a similar way how connections and listeners were implemented. + +`xps_pipe.h` + +The code below has the contents of the header file for `xps_pipe`. Have a look at it and make a copy of it in your codebase. + +::: details **expserver/src/core/xps_pipe.h** + +```c +#ifndef XPS_PIPE_H +#define XPS_PIPE_H + +#include "../xps.h" + +struct xps_pipe_s { + xps_core_t *core; + xps_pipe_source_t *source; + xps_pipe_sink_t *sink; + xps_buffer_list_t *buff_list; + size_t buff_thresh; +}; + +struct xps_pipe_source_s { + xps_pipe_t *pipe; + bool ready; + bool active; + xps_handler_t handler_cb; + xps_handler_t close_cb; + void *ptr; +}; + +struct xps_pipe_sink_s { + xps_pipe_t *pipe; + bool ready; + bool active; + xps_handler_t handler_cb; + xps_handler_t close_cb; + void *ptr; +}; + +/* xps_pipe */ +xps_pipe_t *xps_pipe_create(xps_core_t *core, size_t buff_thresh, xps_pipe_source_t *source, + xps_pipe_sink_t *sink); +void xps_pipe_destroy(xps_pipe_t *pipe); +bool xps_pipe_is_readable(xps_pipe_t *pipe); +bool xps_pipe_is_writable(xps_pipe_t *pipe); +int xps_pipe_attach_source(xps_pipe_t *pipe, xps_pipe_source_t *source); +int xps_pipe_detach_source(xps_pipe_t *pipe); +int xps_pipe_attach_sink(xps_pipe_t *pipe, xps_pipe_sink_t *sink); +int xps_pipe_detach_sink(xps_pipe_t *pipe); + +/* xps_pipe_source */ +xps_pipe_source_t *xps_pipe_source_create(void *ptr, xps_handler_t handler_cb, + xps_handler_t close_cb); +void xps_pipe_source_destroy(xps_pipe_source_t *source); +int xps_pipe_source_write(xps_pipe_source_t *source, xps_buffer_t *buff); + +/* xps_pipe_sink */ +xps_pipe_sink_t *xps_pipe_sink_create(void *ptr, xps_handler_t handler_cb, xps_handler_t close_cb); +void xps_pipe_sink_destroy(xps_pipe_sink_t *sink); +xps_buffer_t *xps_pipe_sink_read(xps_pipe_sink_t *sink, size_t len); +int xps_pipe_sink_clear(xps_pipe_sink_t *sink, size_t len); + +#endif +``` +::: + + +The following are the structs included and its fields + +- `xps_pipe_s` + - `xps_core_t *core` : Represents the core system the pipe belongs to + - `xps_pipe_source_t *source` : A pointer to the source side of the pipe + - `xps_pipe_sink_t *sink` : A pointer to the sink side of the pipe + - `xps_buffer_list_t *buff_list` : The buffer that holds the data being transferred. + - `size_t buff_thresh` : The maximum threshold size of the buffer +- `xps_pipe_source_s`/`xps_pipe_sink_s` + - `xps_pipe_t *pipe` : A pointer to the pipe to which source/sink is attached. + - `bool ready` : For source, it indicates the readiness to write data to pipe and for sink, the readiness to read data from pipe. + - `bool active` : Whether source/sink is currently in operation + - `xps_handler_t handler_cb` : Callback function of source/sink to handle data through pipe. + - `xps_handler_t close_cb` : Callback function to close source/sink + - `void *ptr` : A pointer to the connection corresponding to source/sink + +`xps_pipe.c` + +Contains functions for creation and destruction of pipes,source/sink , for attaching and detaching source/sink to pipe, for reading from and writing into the pipe. A short description of the functions included are as follows: + +### **1. Pipe Creation and Destruction:** + +**`xps_pipe_create`** + +- Allocates memory and initialize the pipe instance. +- Adds the created pipe to the core’s pipe list. +- Attach source and sink. +- Returns the created pipe or NULL on failure. + +**`xps_pipe_destroy`** + +- Removes the pipe from the core’s pipe list. +- Destroy the buffer list of the pipe and free the pipe itself. +::: details **expserver/src/core/xps_pipe.c - `xps_pipe_create()`, `xps_pipe_destroy()`** + +```c +xps_pipe_t *xps_pipe_create(xps_core_t *core, size_t buff_thresh, xps_pipe_source_t *source, + xps_pipe_sink_t *sink) { + assert(core != NULL); + assert(buff_thresh > 0); + assert(source != NULL); + assert(sink != NULL); + + // Alloc memory for pipe instance + xps_pipe_t *pipe = /*fill this*/ + if (pipe == NULL) { + logger(LOG_ERROR, "xps_pipe_create()", "malloc() failed for 'pipe'"); + return NULL; + } + + /*Create buff_list instance*/ + + // Init values + pipe->core = /*fill this*/ + pipe->source = NULL; + pipe->sink = NULL; + pipe->buff_list = /*fill this*/ + pipe->buff_thresh = /*fill this*/ + + /* Add pipe to 'pipes' list of core*/ + + /*Attach source and sink to pipe*/ + + logger(LOG_DEBUG, "xps_pipe_create()", "created pipe"); + + return pipe; +} + +void xps_pipe_destroy(xps_pipe_t *pipe) { + assert(pipe != NULL); + + /*Set NULL in 'pipes' list of core and increment n_null_pipes*/ + + /*Destroy the buff_list of pipe*/ + /*Free the pipe*/ + logger(LOG_DEBUG, "xps_pipe_destroy()", "destroyed pipe"); +} +``` +::: + + +### **2. Pipe Readiness Checking:** + +**`xps_pipe_is_readable`** + +- Returns whether the pipe’s buffer has data (ie `buff_list->len` > 0). + +**`xps_pipe_is_writable`** + +- Checks if the buffer list length is below the buffer threshold, allowing new data to be written. +::: details **expserver/src/core/xps_pipe.c - `xps_pipe_is_readable()`, `xps_pipe_is_writable()`** + +```c +bool xps_pipe_is_readable(xps_pipe_t *pipe) { return /*fill this*/ } + +bool xps_pipe_is_writable(xps_pipe_t *pipe) { return /*fill this*/ } +``` +::: + +### **3. Source/Sink Attachment and Detachment:** + +**`xps_pipe_attach_source` and `xps_pipe_attach_sink`** + +- Attach a source or sink to a pipe, ensuring only one source or sink can be attached at a time. +- Return error if a source/sink is already attached. + +**`xps_pipe_detach_source` and `xps_pipe_detach_sink`** + +- Detach the source/sink(if present) by clearing the pipe pointer in the respective structures. +::: details **expserver/src/core/xps_pipe.c - `xps_pipe_attach_source()` , `xps_pipe_attach_sink()`, `xps_pipe_detach_source()` , `xps_pipe_detach_sink()`** + +```c +int xps_pipe_attach_source(xps_pipe_t *pipe, xps_pipe_source_t *source) { + /*assert pipe and source not null*/ + /*check whether pipe already has a source and return E_FAIL*/ + + pipe->source = /*fill this*/ + source->pipe = /*fill this*/ + + return OK; +} + +int xps_pipe_detach_source(xps_pipe_t *pipe) { + /*assert pipe not null*/ + + /*check whether pipe has no source and return E_FAIL*/ + + pipe->source->pipe = NULL; + pipe->source = NULL; + + return OK; +} + +int xps_pipe_attach_sink(xps_pipe_t *pipe, xps_pipe_sink_t *sink) { + /*assert pipe and sink not null*/ + + /*check whether pipe already has a sink and return E_FAIL*/ + + pipe->sink = /*fill this*/ + sink->pipe = /*fill this*/ + + return OK; +} + +int xps_pipe_detach_sink(xps_pipe_t *pipe) { + /*assert pipe not null*/ + + /*check whether pipe has no sink and return E_FAIL*/ + + pipe->sink->pipe = NULL; + pipe->sink = NULL; + + return OK; +} +``` +::: + + +### **4. Source Functions:** + +**`xps_pipe_source_create`** + +- Allocates and initializes a source. Source is intially not `ready`. + +**`xps_pipe_source_destroy`** + +- Detaches the source from the pipe and frees the memory. + +**`xps_pipe_source_write`** + +- Checks if the pipe is writable and writes to the pipe +::: details **expserver/src/core/xps_pipe.c - `xps_pipe_source_create()`, `xps_pipe_source_destroy()`, `xps_pipe_source_write()`** + +```c +xps_pipe_source_t *xps_pipe_source_create(void *ptr, xps_handler_t handler_cb, + xps_handler_t close_cb) { + /*assert ptr, handler_cb, close_cb not null*/ + + /*Allocate memory for 'source' instance, if null returned log the error and return*/ + + // Init values + source->pipe = NULL; + source->ready = false; + source->active = true; + /*similarly initialise the remaining fields of source instance*/ + + logger(LOG_DEBUG, "xps_pipe_source_create()", "create pipe_source"); + + return source; +} + +void xps_pipe_source_destroy(xps_pipe_source_t *source) { + /*assert source not null*/ + + // Detach from pipe + if (source->pipe != NULL) + /*detach source from pipe*/ + + free(source); + + logger(LOG_DEBUG, "xps_pipe_source_destroy()", "destroyed pipe_source"); +} + +int xps_pipe_source_write(xps_pipe_source_t *source, xps_buffer_t *buff) { + /*assert source, buff not null*/ + + if (/*Check if source not have a pipe*/) { + logger(LOG_ERROR, "xps_pipe_source_write()", "source is not attached to a pipe"); + return E_FAIL; + } + + + if (/*Check whether pipe is not writable*/) { + logger(LOG_ERROR, "xps_pipe_source_write()", "pipe is not writable"); + return E_FAIL; + } + + // Duplicate buffer + xps_buffer_t *dup_buff = xps_buffer_duplicate(buff); + if (dup_buff == NULL) { + logger(LOG_ERROR, "xps_pipe_source_write()", "xps_buffer_duplicate() failed"); + return E_FAIL; + } + + /*Append dup_buff to buff_list of pipe*/ + return OK; +} + +``` +::: + + +### **5. Sink Functions:** + +**`xps_pipe_sink_create`** + +- Allocates and initializes a sink. Sink is initially not `ready`. + +**`xps_pipe_sink_destroy`** + +- Detaches the sink from the pipe and frees the memory. + +**`xps_pipe_sink_read`** + +- Reads a specified length of data from the pipe’s buffer list, ensuring the pipe is attached and has sufficient data available. The length of data to be read is given as input. + +**`xps_pipe_sink_clear`** + +- Clears the specified length of data from the pipe’s buffer list, ensuring the data is available to clear. +::: details **expserver/src/core/xps_pipe.c - `xps_pipe_sink_create()`, `xps_pipe_sink_destroy()`, `xps_pipe_sink_read()`, `xps_pipe_sink_clear()`** + +```c +xps_pipe_sink_t *xps_pipe_sink_create(void *ptr, xps_handler_t handler_cb, xps_handler_t close_cb) { + /*refer to xps_pipe_source_create() and fill accordingly*/ +} + +void xps_pipe_sink_destroy(xps_pipe_sink_t *sink) { + /*refer to xps_pipe_source_destroy() and fill accordingly*/ +} + +xps_buffer_t *xps_pipe_sink_read(xps_pipe_sink_t *sink, size_t len) { + /*assert sink not null and len greater than 0*/ + + if (/*Check if sink not have a pipe*/) { + logger(LOG_ERROR, "xps_pipe_sink_read()", "sink is not attached to a pipe"); + return NULL; + } + + if (/*Check if requested length is not available*/) { + logger(LOG_ERROR, "xps_pipe_sink_read()", "requested length more than available"); + return NULL; + } + + xps_buffer_t *buff = xps_buffer_list_read(sink->pipe->buff_list, len); + if (buff == NULL) { + logger(LOG_ERROR, "xps_pipe_sink_read()", "xps_buffer_list_read() failed"); + return NULL; + } + + return buff; +} + +int xps_pipe_sink_clear(xps_pipe_sink_t *sink, size_t len) { + assert(sink != NULL); + assert(len > 0); + + if (/*Check if sink not have a pipe*/) { + logger(LOG_ERROR, "xps_pipe_sink_clear()", "sink is not attached to a pipe"); + return E_FAIL; + } + + if (/*Check whether requested length not available*/) { + logger(LOG_ERROR, "xps_pipe_sink_clear()", "requested length more than available"); + return E_FAIL; + } + + if (xps_buffer_list_clear(/*fill this*/) != OK) { + logger(LOG_ERROR, "xps_pipe_sink_clear()", "xps_buffer_list_clear() failed"); + return E_FAIL; + } + + return OK; +} +``` +::: + + +## `xps_connection` Module - Modifications + +`xps_connection.h` + +As we are not invoking the callback functions depending on the ready state of connection but based on the pipe availability and source/sink status , the flags `read_ready` and `write_ready` are removed. The existing callback functions are also changed. Add `source` and `sink` to `xps_connection_s` struct. + +::: details **expserver/src/network/xps_connection.h** + +```c +struct xps_connection_s { + xps_core_t *core; + u_int sock_fd; + xps_listener_t *listener; + char *remote_ip; + xps_buffer_list_t *write_buff_list;//-- + + xps_pipe_source_t *source;//++ + xps_pipe_sink_t *sink;//++ + + bool read_ready;//-- + bool write_ready;//-- + xps_handler_t send_handler;//-- + xps_handler_t receive_handler;//-- +}; +``` +::: + + +`xps_connection.c` + +The existing callback functions `connection_read_handler()` and `connection_write_handler()` are removed and new ones added in accordance with the source-sink system. + +```c +void connection_read_handler(void *ptr);// [!code --] +void connection_write_handler(void *ptr);// [!code --] + +void connection_source_handler(void *ptr);// [!code ++] +void connection_source_close_handler(void *ptr);// [!code ++] +void connection_sink_handler(void *ptr);// [!code ++] +void connection_sink_close_handler(void *ptr);// [!code ++] +void connection_close(xps_connection_t *connection, bool peer_closed);// [!code ++] +``` + +Functions Modified + +- `xps_connection_create()` - source and sink are attached during connection creation +- `xps_connection_destroy()` - source and sink are dettached during connection destruction +- `connection_loop_read_handler()` - set source as ready instead of connection, thus indicating the source is ready to receive data and write to pipe. +- `connection_loop_write_handler()` - set sink as ready instead of connection, thus indicating the sink is ready to read data from pipe and sent. +- `connection_loop_close_handler()` - invokes `connection_close()` (explained below) +::: details **expserver/src/network/xps_connection.c - modified functions** + +```c +xps_connection_t *xps_connection_create(xps_core_t *core, u_int sock_fd) { + assert(core != NULL); + + // Allocate memory for connection instance + ... + /*Create source instance*/ + if (source == NULL) { + logger(LOG_ERROR, "xps_connection_create()", "xps_pipe_source_create() failed"); + free(connection); + return NULL; + } + + /*Create sink instance*/ + if (sink == NULL) { + logger(LOG_ERROR, "xps_connection_create()", "xps_pipe_sink_create() failed"); + xps_pipe_source_destroy(source); + free(connection); + return NULL; + } + + // Init values + ... + connection->source = /*fill this*/; + connection->sink = /*fill this*/; + ... + + // Attach connection to loop + if ((...) != OK) { + logger(LOG_ERROR, "xps_connection_create()", "xps_loop_attach() failed"); + /*destroy source*/ + /*destroy sink*/ + free(connection); + return NULL; + } +... +} + +void xps_connection_destroy(xps_connection_t *connection) { + assert(connection != NULL); + + // Detach connection from loop + ... + /*destroy source*/ + /*destroy sink*/ + ... +} + +void connection_loop_read_handler(void *ptr) { + .. + /*ready flag of source*/ = true; +} + +void connection_loop_write_handler(void *ptr) { + ... + /*ready flag of sink*/ = true; +} + +void connection_loop_close_handler(void *ptr) { + ... + xps_connection_destroy(connection);// [!code --] + connection_close(connection, true);// [!code ++] +} +``` +::: + + +Functions Added + +- `connection_source_handler()` - read data using `recv()` and upon successful reading, writes the buffer to pipe using `xps_pipe_source_write()`. +- `connection_source_close_handler()` - call back for closing the source. If both the source and sink not active the connection is closed. +- `connection_sink_handler()` - read data from the pipe using `xps_pipe_sink_read()` and sent using `send()`. Upon successful sending, clears the data sent from the pipe buffer. +- `connection_sink_close_handler()` - call back for closing the sink. If both the source and sink not active the connection is closed. +- `connection_close()` - prints whether connection is closing because the peer is closed. Destroys the connction using `xps_connection_destroy()`. +::: details **expserver/src/network/xps_connection.c - added functions** + +```c +void connection_source_handler(void *ptr) { + /*assert ptr not null*/ + xps_pipe_source_t *source = ptr; + xps_connection_t *connection = source->ptr; + + xps_buffer_t *buff = /*create a buffer*/ + if (buff == NULL) { + logger(LOG_DEBUG, "connection_source_handler()", "xps_buffer_create() failed"); + return; + } + + /*Read from socket using recv()*/ + buff->len = read_n; + + // Socket would block + if (read_n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) { + xps_buffer_destroy(buff); + /*ready flag of source*/ = false; + return; + } + + // Socket error + if (read_n < 0) { + /*destroy buff*/ + logger(LOG_ERROR, "connection_source_handler()", "recv() failed"); + connection_close(connection, false); + return; + } + + // Peer closed connection + if (read_n == 0) { + /*destroy buff*/ + /*close connection*/ + return; + } + + if (/*write into pipe*/ != OK) { + logger(LOG_ERROR, "connection_source_handler()", "xps_pipe_source_write() failed"); + /*destroy buff*/ + /*close connection*/ + return; + } + + xps_buffer_destroy(buff); +} + +void connection_source_close_handler(void *ptr) { + /*assert*/ + xps_pipe_source_t *source = ptr; + xps_connection_t *connection = source->ptr; + + if (/*source not active AND sink not active*/) + /*close connection*/ +} + +void connection_sink_handler(void *ptr) { + /*assert*/ + xps_pipe_sink_t *sink = ptr; + xps_connection_t *connection = sink->ptr; + + xps_buffer_t *buff = /*read from pipe*/ + if (buff == NULL) { + logger(LOG_ERROR, "connection_sink_handler()", "xps_pipe_sink_read() failed"); + return; + } + + // Write to socket + int write_n = send(/*fill this*/, MSG_NOSIGNAL); + + /*destroy buff*/ + + // Socket would block + if (write_n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) { + /*sink made not ready*/ + return; + } + + // Socket error + if (write_n < 0) { + logger(LOG_ERROR, "connection_sink_handler()", "send() failed"); + /*close connection*/ + return; + } + + if (write_n == 0) + return; + + if (/*Clear write_n length from pipe buff_list*/ != OK) + logger(LOG_ERROR, "connection_sink_handler()", "failed to clear %d bytes from sink", write_n); +} + +void connection_sink_close_handler(void *ptr) { + /*assert*/ + xps_pipe_sink_t *sink = ptr; + xps_connection_t *connection = sink->ptr; + + if (/*source not active AND sink not active*/) + /*close connection*/ +} + +void connection_close(xps_connection_t *connection, bool peer_closed) { + /*assert*/ + logger(LOG_INFO, "connection_close()", + peer_closed ? "peer closed connection" : "closing connection"); + /*destroy connection*/ +} +``` +::: + + +## `xps_listener` Module - Modifications + +Functions Modified + +- `listener_connection_handler()` - For each connection created , a pipe is also created. The source and sink are added to the connection in `xps_connection_create()`. `xps_pipe_create()` creates pipe and attaches the source and sink to the created pipe. + +```c +void listener_connection_handler(void *ptr) { + ..... + while (1) { + .... + // Accepting connection + ... + //No incoming connections + ... + // Making socket non blocking + .... + // Creating connection instance + ... + //Creates pipe for the connection created + xps_pipe_create(listener->core, DEFAULT_PIPE_BUFF_THRESH, client->source, client->sink);// [!code ++] + .... + } +} +``` + +## `xps_loop` Module - Modifications + +`xps_loop.c` + +We replace current `handle_connections()` function to `handle_pipes()` as we will be setting `timeout` based on the pipes instead of connections. + +```c +bool handle_connections(xps_loop_t *loop);// [!code --] +void handle_epoll_events(xps_loop_t *loop, int n_events);// [!code ++] +bool handle_pipes(xps_loop_t *loop);// [!code ++] +void filter_nulls(xps_core_t *core);// [!code ++] +``` + +Functions Added + +- `handle_pipes()` - Here, we are replacing the `handle_connections()` with `handle_pipes()`, as the callback functions were invoked based on the `read_ready` and `write_ready` flags of the connection earlier but now it would be based on the status of source, sink and pipe. There are two iterations over the pipe. The first one is for invoking the callback functions and second for checking the existence of ready pipes. Checking for ready pipes can't be done in the first iteration itself as callbacks on current pipe could affect previously iterated pipes making them ready. It returns `true` if ready pipes exist. +::: details **expserver/src/core/xps_loop.c - `handle_pipes()`** + +```c +bool handle_pipes(xps_loop_t *loop) { + assert(loop != NULL); + for (int i = 0; i < loop->core->pipes.length; i++) { + xps_connection_t *pipe = loop->core->pipes.data[i]; + if (pipe == NULL) + continue; + + /*Destroy the pipe if it has no source and sink and continue*/ + + if (/*Pipe has source AND source is ready AND pipe is writable*/){ + pipe->source->handler_cb(pipe->source);//call connection_source_handler to write into pipe + } + + if (/*Pipe has sink AND sink is ready AND pipe is readable*/) { + pipe->sink->handler_cb(pipe->sink);//call connection_sink_handler to read from pipe + } + + if (/*Pipe has source and no sink*/) { + pipe->source->active = false; + pipe->source->close_cb(pipe->source); + } + + if (/*Pipe has sink and no source and pipe is not readable*/) { + pipe->sink->active = false; + pipe->sink->close_cb(pipe->sink); + } + + } + + for (int i = 0; i < loop->core->pipes.length; i++) { + xps_connection_t *pipe = loop->core->pipes.data[i]; + if (pipe == NULL){ + logger(LOG_DEBUG, "handle_pipes", "pipe is null"); + continue; + } + if (/*Pipe has source AND source is ready AND pipe is writable*/){ + return true; + } + if (/*Pipe has sink AND sink is ready AND pipe is readable*/) { + return true; + } + if (/*Pipe has source and no sink*/) { + return true; + } + if (/*Pipe has sink and no source and pipe is not readable*/) { + return true; + } + } + return false; +} +``` +::: + + + + +- `filter_nulls` - Filters the null accumulated in events , listeners, connections, pipes list +::: details **expserver/src/core/xps_loop.c - `filter_nulls()`** + +```c +void filter_nulls(xps_core_t *core) { +/*check whether number of nulls in each of events, listeners, connections, pipes list + exceeds DEFAULT_NULLS_THRESH and filter nulls using vec_filter_null() and set + number of nulls in each list to 0*/ + +} +``` +::: + +- `handle_epoll_events()` - Replaces the existing `xps_loop_run()`,  this function would be invoked from the new `xps_loop_run()`. It iterates thorough the events and corresponding call back functions are called based on epoll notification. This is added to simplify the new `xps_loop_run()`. +::: details **expserver/src/core/xps_loop.c -** `handle_epoll_events()` + +```c +void handle_epoll_events(xps_loop_t *loop, int n_events) { + logger(LOG_DEBUG, "handle_epoll_events()", "handling %d events", n_events); + + for (int i = 0; i < n_events; i++) { + logger(LOG_DEBUG, "handle_epoll_events()", "handling event no. %d", i + 1); + /*Handle events as given in existing xps_loop_run()*/ + } +} +``` +::: + + +Functions Modified + +- `xps_loop_run()` - This function is modified to check the existence of ready pipes , setting the `timeout` of `epollwait()` accordingly, handling the epoll events and filtering nulls from the lists attached to core. If there are ready pipes, it sets `timeout` to `0`, meaning `epoll_wait()` will be non-blocking. If there are no ready pipes, it sets `timeout` to `-1`, meaning `epoll_wait()` will block indefinitely until an event occurs. This ensures that if there are pipes ready for immediate processing, the program doesn’t block waiting for other events. +::: details **expserver/src/core/xps_loop.c -** `xps_loop_run()` + +```c +void xps_loop_run(xps_loop_t *loop) { + assert(loop != NULL); + + logger(LOG_DEBUG, "xps_loop_run()", "starting to run loop"); + + while (1) { + logger(LOG_DEBUG, "xps_loop_run()", "loop top"); + + // Handle pipes + bool has_ready_pipes = handle_pipes(loop); + + int timeout = /*set timeout as described above*/ + + logger(LOG_DEBUG, "xps_loop_run()", "epoll waiting"); + int n_events = /*fill this*/ + logger(LOG_DEBUG, "xps_loop_run()", "epoll wait over"); + + if (n_events < 0) + logger(LOG_ERROR, "xps_loop_run()", "epoll_wait() error"); + + // Handle epoll events + if (n_events > 0) + handle_epoll_events(loop, n_events); + + // Filter NULLs from vec lists + filter_nulls(loop->core); + } +} +``` +::: + + +## `xps_core` Module - Modifications + +`xps_core.h` + +Similar to listeners and connections list in the struct `xps_core_s`, add a list for `pipes` and add `n_null_pipes` to track the number of pointers in `pipes` list set to `NULL`. + +`xps_pipe.c` + +Functions Modified + +- `xps_core_create()` - Initialise the `core→pipes` and `n_null_pipes` +- `xps_core_destroy()` - Similar to destroying each connections and listeners attached to the core instance while destroying the core, the pipes attached should also be destroyed. The source and sink, if present, are closed before destroying the corresponding pipe. De-initialise the `core→pipes` list + +## Experiment #1 + +Repeat the Experiment #2 of Stage8 and ensure memory utilization is reduced. + +## Conclusion + +We have now solved both the issues specified in the Experiments of Stage8. The high CPU utilization was solved in stage 9 using edge-triggered epoll. In this stage, we have reduced the memory utilization by managing data flow through pipes. In the next stage, we would be implementing an upstream module. From b75fa5c73d0f9d33e21233ddfca9b3bf03584a3f Mon Sep 17 00:00:00 2001 From: Nikisha Date: Wed, 9 Oct 2024 00:18:28 +0530 Subject: [PATCH 2/6] stage10-minor-updates --- docs/roadmap/phase-1/stage-10.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/docs/roadmap/phase-1/stage-10.md b/docs/roadmap/phase-1/stage-10.md index 8aa5d49..d17cf41 100644 --- a/docs/roadmap/phase-1/stage-10.md +++ b/docs/roadmap/phase-1/stage-10.md @@ -432,7 +432,7 @@ int xps_pipe_sink_clear(xps_pipe_sink_t *sink, size_t len) { `xps_connection.h` -As we are not invoking the callback functions depending on the ready state of connection but based on the pipe availability and source/sink status , the flags `read_ready` and `write_ready` are removed. The existing callback functions are also changed. Add `source` and `sink` to `xps_connection_s` struct. +As we are not invoking the callback functions depending on the ready state of connection but based on the pipe availability and source/sink status , the flags `read_ready` and `write_ready` are removed. The existing callback functions are also changed. Add `source` and `sink` to `xps_connection_s` struct. `write_buff_list` removed as we would be using pipe’s buffer for data transfer. ::: details **expserver/src/network/xps_connection.h** @@ -442,15 +442,15 @@ struct xps_connection_s { u_int sock_fd; xps_listener_t *listener; char *remote_ip; - xps_buffer_list_t *write_buff_list;//-- + xps_buffer_list_t *write_buff_list;// [!code --] - xps_pipe_source_t *source;//++ - xps_pipe_sink_t *sink;//++ + xps_pipe_source_t *source;// [!code ++] + xps_pipe_sink_t *sink;// [!code ++] - bool read_ready;//-- - bool write_ready;//-- - xps_handler_t send_handler;//-- - xps_handler_t receive_handler;//-- + bool read_ready;// [!code --] + bool write_ready;// [!code --] + xps_handler_t send_handler;// [!code --] + xps_handler_t receive_handler;// [!code --] }; ``` ::: From 3b84b8e62962981d77241757ee4065ec74fd95d5 Mon Sep 17 00:00:00 2001 From: Nandana S Nair Date: Sat, 12 Oct 2024 01:21:51 +0530 Subject: [PATCH 3/6] phase 0 cleanup --- docs/.vitepress/config.mjs | 11 +- docs/assets/resources/fork.png | Bin 0 -> 87863 bytes docs/assets/resources/pcb.png | Bin 0 -> 21979 bytes docs/assets/resources/segments.png | Bin 0 -> 38237 bytes docs/assets/resources/tcb.png | Bin 0 -> 22480 bytes docs/assets/resources/thread.png | Bin 0 -> 216871 bytes docs/assets/resources/udp-ip-packet.png | Bin 4934 -> 53245 bytes docs/guides/index.md | 12 +- docs/guides/resources/fork.md | 13 -- docs/guides/resources/linux-epoll-tutorial.md | 38 ++--- docs/guides/resources/process-and-threads.md | 109 ++++++++++++++ docs/guides/resources/sockets.md | 111 -------------- docs/guides/resources/system-calls.md | 83 ++++++++++ docs/guides/resources/tcp-ip-model.md | 8 +- .../resources/tcp-socket-programming.md | 107 ++++++------- docs/guides/resources/tcp.md | 19 --- .../resources/udp-socket-programming.md | 142 ++++++++++++++++++ docs/guides/resources/udp.md | 50 ------ docs/roadmap/index.md | 4 +- docs/roadmap/phase-0/stage-1.md | 5 +- docs/roadmap/phase-0/stage-2.md | 101 ++++++++++++- docs/roadmap/phase-0/stage-3.md | 47 +++--- docs/roadmap/phase-0/stage-5.md | 4 +- 23 files changed, 557 insertions(+), 307 deletions(-) create mode 100644 docs/assets/resources/fork.png create mode 100644 docs/assets/resources/pcb.png create mode 100644 docs/assets/resources/segments.png create mode 100644 docs/assets/resources/tcb.png create mode 100644 docs/assets/resources/thread.png delete mode 100644 docs/guides/resources/fork.md create mode 100644 docs/guides/resources/process-and-threads.md delete mode 100644 docs/guides/resources/sockets.md create mode 100644 docs/guides/resources/system-calls.md delete mode 100644 docs/guides/resources/tcp.md create mode 100644 docs/guides/resources/udp-socket-programming.md delete mode 100644 docs/guides/resources/udp.md diff --git a/docs/.vitepress/config.mjs b/docs/.vitepress/config.mjs index c0a2607..c9bde9a 100644 --- a/docs/.vitepress/config.mjs +++ b/docs/.vitepress/config.mjs @@ -41,19 +41,22 @@ export default defineConfig({ link: '/guides/resources/tcp-ip-model', }, { text: 'TCP Socket Programming', link: '/guides/resources/tcp-socket-programming' }, - { text: 'Sockets', link: '/guides/resources/sockets' }, + { text: 'UDP Socket Programming', link: '/guides/resources/udp-socket-programming' }, + { text: 'Process and Threads', link: '/guides/resources/process-and-threads' }, + { text: 'System Calls', link: '/guides/resources/system-calls' }, { text: 'Introduction to Linux epoll', link: '/guides/resources/introduction-to-linux-epoll', }, + { + text: 'Linux epoll tutorial', + link: '/guides/resources/linux-epoll-tutorial', + }, { text: 'Blocking & Non-Blocking Sockets', link: '/guides/resources/blocking-and-non-blocking-sockets', }, { text: 'HTTP', link: '/guides/resources/http' }, - { text: 'UDP', link: '/guides/resources/udp' }, - { text: 'Multi-threading', link: '/guides/resources/multi-threading' }, - { text: 'Fork', link: '/guides/resources/fork' }, // { text: 'Internet Protocol (IP)', link: '/guides/resources/ip' }, // { text: 'File descriptors', link: '/guides/resources/file-descriptors' }, diff --git a/docs/assets/resources/fork.png b/docs/assets/resources/fork.png new file mode 100644 index 0000000000000000000000000000000000000000..2f87af6427295139f7dcfa25dcd4c6e409f39ddb GIT binary patch literal 87863 zcmeFZ_g7Qj_AV?%2oQRe8l*`P0!Z)h5s)TIP^3ddL_q1i1p_GELhmA>SLvNZic$qB zBE2KMcep#K=e_UuoO}O(JI*f|gE-u4?YZWf^OeG0u)Iz>7MBIGcMjU&( z_TgS>Mk(hv+jZ@_FJi5q=THop+}zIuMw$ad3A9(a7{zW2KU*b*>Hb3l!~b};=)Aeg z(q?7-vujbv*#o^0Xlh>;#@0mlet9&=PHe^;=g@}2=%o>p*y~Ic(niF zUuj<91|!Ju|KtC3x^B)8|1PpJf%ryx0Pg?%U?7kt_)qK6bi59*FxQbDeZu!2{?`q2 zh9!pov=3bf53m!d<)=xx|GpNmzC}9x-`@>bACU}VAXxaAX^;B19b$JKjEMXBSM)KxH^=y-#;4%S4Fd|Y1jqfHFCO4ajmWs~uCOl(2rxZ7ax75Mw;7t3$6EVkaZ zc3vH7Re}@>g9{?$_XPjcIS?iQ{r^}}Gs?gg6w#tM==Z++KX@nzsPF|Jm2q0*idTIi zhKdgqw}!<91M1KV%%NGmU**GK>I53`zDfGdlOqF(|Evk72q;@j30du2h$wxR?vMPTWoby z0+n3li3CZZD7Z^mXq4a&Jnr}ad{5^+D9($m@E)5s1NEhe@eb)NaKVvaInIBd_5ZZJ zn)|afF_)gzus2lFufcCsS6W%beKi!*?A$9SVORc5H3PWW?7j`$O!M0Of13c;D4^gj zMV`^iUIXHk2&meNdu>N_|=9Z1Vt5ZjvvqpkpE!GK}(U`s>W}z{RNFEnkCOUX1s^ zlTo#z?;?c3U5~3qZ~R>`0QjCj`WyG<1)sZ{&Vg1edgSG@+@JMiv*v{R=R%0rrrl`CV!Oky9fC!RB{pk&~ZKVp8X3-^V`o=wAE~Wrn$<HeHSjgMp!I+y> zhiUw$omsja4}H29Ow)EKoTzZ=2onlP>1FmH%Tr0B;MFOz&Fw#iPH!d#;us6#??1n% z0~>B$9>@-%H}ethN)+QSDDT&p9!NWPF>vk{gTERYIri!%oi)_#E}y?9`sA~1@uwc? z4DW;Wn`C&o1j#b)&*LRtm>Rf`yW%aLPQ4^YpC0YZP8v}QR#wV+dZb#IvwHmy|I?^a zyh+SJFl1Tm*?YNo4Sf!bL0xe_Y4VhN%wsmfVt@6AFchA+nU`P0==Q@ZZgZCHLXyC7 zP=3N^r`ur)LD)96K5AP`ibnu8C@L!+JDa-AaG0{;!*hBvc|rEj)YHnqb3O(mcQ8iX zBRL!Hu>FN6q~TyfrZT3Twm8OMeeCAZ`P)`a#vy*r_dZASaqz6`D3xIFYrXV=J-sEv z)8ts={7g1mhLLY_Q+t1#d5AV3hp=4xm$|sm%~wh2kZEVD*3)k_1&N9q_6@-o$NOtc zhte58gxi^^{f-CHf{XS{m~ac9ebY`7zX@iOmwm7=x6>tRF;Ze747R&-dq)4E32o!~ zUU3K>nIt6H?|8X%W-CHs0>q&f8Qub6hd241F%GHQZB%CEcEC(5Pve?SxgMCJ`l6a+ zh`TZ)rTOd{j~2c)JS;Yicwkw1(4ar#6O4$_-An#^%!)sOegAyEbnTDN*D3-#e`w|_ z=5xN2Mqb=>?sYg#?$4ka!AOfIs?5?T@w6`;>M+$jG8Bt+SVIgLFvN>rJncEk6<`*& z{Kt-|WkHq6p2ll;iSlKo+4**y@SN;+2L~phNnW(zyLZ+?a#?Fs%hrbfh4OW`erfr z>W#32Nx8>8kJHk24DDC6@?|vy_0SGPPyMcPuyM76MfH5F5jrD;mGOa@@18+T+xJIg z$}E1A(Kk)Y?RX{@f)TJfu?OR^ZXg{5^UC7Z;;sQ&wCE1>%djR!k?$llpIUD!I|?&<6nKVA0dUk1w`rY&dN1ZZq2Vc*WIoCw|)J ziGusY2G7njhnXE@$+$XC&ZnB)lqk-;3}A|;fCui3?o=9Kvr0PZ>L?=t6{`bT;5+vT zPoDFH(DJi`NrhmCg3jSO_YDFL++g|qT_Vj`L6WPOeyc$Q63(o}kt*fA(_;h}}A_3bdtz=ulFFO%Z;)-#$NqiwKv9jS9 znJVYq)*Na6>V!Msq(82aMtsElNxqgBWrt(R7aIOJa= zKv6h+L!+w&Pvh+Lmbw}oZt>j6r=6TR(OR=xmrmpb&v}N=)7DH~t3}d&epviCIIpjfMl$WVD7u+1`+m z5d9U3%~Bjf9OKcg*me`2t=8#Y|8r;K3&E=|k&aByt1ZUjUv@*Qb>M>t7(3N04WjMH_b-Mpo{9(8QtC5%7-GK1tX04uLeqrRi-{>MdgdT z^VkW5HfXe8moX4BE_VnTd^wMdOeamhVdYTf(>5j;3GWLo(PV=B1K84PUY z7S4WWmd$(3A@#S_Lauz{Z0NC z4ts+SB?>CkBo7K-`0}s6>O?Ukjb(!=f&-!)qOUmi${m244qJt0V8b&n`)2ggj$z<^ zZmoEVwg@Kr{6$F+#gpDtmh(mbbDrR*f9F^?p~dEXiKoDQP5H1IgxYL_syYM%v7lX_{NMC=oe_@K9`vxTlCaS&0;FaPx~qp zNCAAj@n+@7^Os~T)kOFFW6@5re)@IMx(7SSop5=@<#?szrB33 zh$Lh|X&YmPt?#ghke*orWAB$8kPeY9(@$pnyUOkPt7mYy? zp!tjIsZ_2h)8c;iJ3DR-pyroNG%Swro;D<8anW53JK1Pb2?+z*-;e? z)!Qs{`O?2x+ZX~!b4DhRmgs`8ENd8S@YOJYq4eC=q({}&HM|qJ>klTpt4_$;V_2I9!FV<#10~A} z$4O$>ADY?kL65$DDYbM3AQ-XCM!mDg+#9tSc+RuJ$BOMML5?~d-5z3B#C?|#<6_s$@1{2%_n7H7-wvXahVUSpnq zf69&M^G+AxfiD5tIO_UJXrw>p-9R@tjUB{E>L-ZbOK69wRyl!Oe&DNlwJPHV?;qxYo$Z0$GjgA3I{6cjLoyrQh&1jk`}a*jcf&^Wu;meEr@l z3ba>rwQY^7pB zJ0r`&+>3ORF+sxLwBQtOoc-)hn*wm0GR0y2!VM!P^W*}r zii7S9x{Y0MC)rW)QyiT?Y}}5qs$+7`HL6r`__Cg9gGb4SM>NC=0AU0B+k?z8rpRl{ ziLEVMwilF}l!Eu|tB!x=w?~(`Xp5mKl{JTAjDS)}fsUZ@WW8?dlvF?LYBUNRG{L_Y zY1>9Af6uCQ)Yk5~<0W()(cs6^?2SP)paq6pWTpb}z<6N$`l zs*+mKo$={qPQ`Kup|eDKd|E^?!$3x6@XLyh?>5N^wX# zk-23|004hxB}bC^`g`ldTR2jKJ_QjS(uuNB8V^x81F^T(JxLw>Oxu&wATgEBePrS| z*LNpf=ZdBiiH1L)XeTXx944PVV!Jq0tEZcs^+n{4)cfg3P9v*>Eu6E7J_&L!awuk* z;4f*#v?oAfbVc^AO%@mDlat6BQ~Y%3yjk^G&W;sRv}7}`H`=zc z)k4SyzAJz9xSn-!j*#e7Bc?-GR^T*hSV%4J@srh$jp%r!kzrK0KT`Uyv?{cun0Y zX0GG!yZhN$vp@1cJ)i4DC=$oK0GEFx|_x{MYYFy4giX1BR|0RXpKSG2`W>(k94Xd z`s9eqw&2P9z%Cel%WCwim)ksA5tnp`WljpIiDZwk_vxpE7uO6I%-ynRQ!}i4bLI8< zb!b~sGdRCop38!LcEeiXW2bSg!WU?$RCquX&Y^BqK%I1r>$WJ zbZyrU)R#1K!sKQfYGR_hedSIhu^A6x2UN6A@)hhOu%4u-gP+GjfXc1%$;nC#=8FaD z3-$*!VzdO?IB|Uet~f+Wp~KVsWOz~1zj7E1KaPiL*1gFSly}(4h;vQ_8XH>}+1}aS zBgCYT^4jl(2NsZ`Jc9))?A`xPk-Q@`h^=TnU2(mK)_l=3lu@oNer$Bwr)jVHUp zLZwV0Ugl?6V-p86@jL1?i#*VFz1E^y=v!Uv!VrH-WRt_7Jx#;ZLJ|JiW--V-q&abt zC<}0p$##>hs-JFkeV>NQo=LO`&%T<9YJNo#o2QSyod-Jj;hnbGe#bxDf|0feTLQv! zFo(0F^rjvb;O_?1@63ZC@n6f?PNxWkR~JsgW%3#r6kr5YU@=#y4u~uFI+OEmyd?LJ zSHZ&+F;OZZWD!h$eLACUI%7yg-CCs)xYmH@-802TH7@32N?ftP-kCkBT$tSc2z)k} zZ}NPa6ROvP}rg3B)sOh)ls}+>h$3URmV{Hrbn(>I-DGo&rnz>Oe zQB*|z#3QpiC?$WlHKi7aqKGD=Q6D~`!*~a6)myHWWf(l7WQsFCq$a^?}f5+ zX;MI+RMSuFJX;GPlsam9en~EKVFa3@Is>#5uYO0OZu%TI2K6B77+&Kz@@1d&vsNKL z%6!+H626q7PC^?rM42?NG+w7YL?8W{1}S{=Q?&@xUa)^;)WGNIBA&uD!vNcnL)YFB zRGUIYQLkP`U~!6GZ#^DY-2oF~k4~YzN}c=?8bH3`b10Ph^$x=wS{-R2xj~p@yO>@K z{V>OvdG!UBw5)Z?h@W3WLlhB(uGziib z@NBeh+$2#KXu+dvQQ_h!xZ5r#lHw*dVy5lh7!3KfE_o;f7OYDl)axaQS^auQHl9_lhgzVU8a zgDeB>L?50q#aM>Z2Of6{HOW5cE-NJ;{`mGy`umdTjR~F`QpP^B zyF3OO=QlfM!=jFwM5QOYig_v+z8JUCYtB99RQ#x2PRjxggYC5GHxJPCiLPKTz0+fu1m}-Rhe2I`m(;kJE8Zq4Pc^-wMJINEh6@aD46eu9F zSr-WlopOBy$_s^+qkO?(Fh8fMJ6U|T=J#DSl89u5A&`$=R7Rs}P39M$sqcQ~BD!DU z(%x{~P<9z;tm&cP)m6EX~hRODkfwz}d*Upeuqw zUicu`@+M9^WFbW1&|+x<{%DU)&5=PpMpI8_6{W!?57ATl9O5&iezNw$pXnu?d=7PW z)|DIDHFI0|B*@pW9~Ahv=(K=YCa%&OQ}DOs zfHh|$6vG{rI(&ys+*>IMtMft^sVaqsM({(Pjg)gUH~B*kUiM{LM+Gl_PA@CjpMPGr zLC4<%vdIzWC(F>pm<>f}BBWz%$Eb%tXy>AZE3-By!zHYd*e1M&Sld;)aO%7s(EeeA zOFh&iHm~wf8t4Tw;d%~zpWD+)@AItAc1A${EfD=6pI^%e%Vh3Y)CZy=Hj$ zVn6wZa6v25q?0IgzzKg@>~;*t+1Hh~8uuD|SJH^pm3>S`x@r!*= z)^UW|s9H?(+;nE&^TCf}4;UxdJfmh(LHI}PgtW;v1s{p$Zat_Gw1rU}-`mp?vnux*S>i3<)CN8{w>7@UNW z&)ASECGSuAUl{B;1KpXB0e?>~urlLGNtcTX-}9oz<6qEc-*eo?OI|`>hGKw@4c}_* zO3`#Ef6*(pV@H0|v~cnhEq&C?E53AKc+5jUFpqxk#$>SO@d5CUh{Ag{8;vJzeoy#r z_&#E;rVT;h%OLe_>a!HX_m%`34`+h6^t6;{>82$R?6a?3ajw0ziJPK{9atzwaYgZf zKbD2@=4xxlWEJZjY6bkG&oY4VWNi=4(|w1h=R<_kE47$x@a4g=;mn>|iTXS0iTSde_2DrdPM#pq zO(NQ(7QC4FG0_Z>NsjNFecCN{%biHS^l<^9=3CAa`S+K;o^bZg`bPV)gFZS@c#kSg ziloG+zfF(Yx-I$jjOIo7`#}3VdMSyG?D8}*Z> z2>NHX_D)d^i7M!2j!n1{XCsKyW=v$@&={J1@JQ5n56Fho|#GQfW87gI3hSd8oUB&M-&3Rj55N zUS~sW&P3Lvsqg$?$-Z=_I6j{|=m7ME=rp%aYlHqv81&6S@-5%^MO3J)-wmY^)jeUo zXeoENe$yDmI6 zEsoRVscw)Xra`w`BTH02|1>(_nL-;qg6$weVi@xIv9>DenHeyj6V914J-Q81H?REw zt@zY<*Td|x8^yw5&M+dpZmR$Lx{4FQ_`!23_IbbVFo8A?2w6QK4@QOUqoO0oyL`;& zw~$;u)mguyY>=>;t(IyJmB?~xYht`d+4;Gytw7;9a7#&ga z7n^<2EjBE`Bq&M%N{`?FdhBe2VL^)zH5q+tv5hQAve_)~R~Iu|KBIn1MNr18y+v~v z3nSR}vOH7b8v=Fy;0)1y&)ahvm*-e>H}DZ!3N04+!>O2uZ#svQbL@p(gUp0?KkO;4 z99nTgD2I%@B=dTFiFm_8`yE2lF9NFlIC{B|oM7M8t@at|4C8kP;0Zj? zIRPnix!tcFwSi2}yK{u};VOaf0#5-Zfvm4z_B|%InJ>@p2MsXof6_F{cUcOAlfbTn zKZ--v#KojwNP6_JNrsnRm&a+K4>~zsbi8!0AN4ahKDaD)k z^hLI6(zV+ZA-(ZoHYRnbJUmZXJv*X`90yH(-+K8+?a?-8NL#H(3l-WWcbIa^IADt* zWU$*PF`5C};FE;YrMVF@v_z_rw6^59=)o6ndK``zPkdy-yjt3({B5&>r^DOjyEt`X zpZ0GIb0oJGdW?T9AA&4CDI7RVHCQqmZD;sk210t?osrL>T4)HgnS!bAFHK}x2uy9a z)RUuszGz};zuqEhtANrDeYO_@8uUxs_QFV^ zi~VV4V$fF}Wl8z>PG&F?%C^nvM8!9mrH}yfbC?n3YF5R!2j6+|DPbCpCMZt&jonV? zLugNfv%In*I%q~QWGaw+x%^FYv47Kf>DOTLDSWV2+T(6Xd5<0T+OhJsN-%5S6*pTe zIFTQZ@duOKna~oh!rQ~KD=xdvGH?dGcWg+B!vd+VFW0R23mcB?OIfAgxD(M5Lf_d$z1+sSa7gK zt2Zl+XrZ617j`0|AEOxNdWC2!$q+Zd*@-n!CD02!c&kEu4{vdSkQRoaMC}+(d)Ehh zT%?c2MaK;b7H7?MeII}HqBoT3)n;nT*~h&rHG*!ZmS6A+JSWpXylL;BL~if0>%fe+ z_ht_MnK)t4(^6TG_aL7OVKz=X;FuT=ZKrDC&?~G_3v6?t5Y)5y+CY<*mOFr-vI^<) z3JF)>qkF_5oFX9?lG~2o0;8vX8~YsH|80ZN)a-H~>kL%+Zbj#t&wmdUp2jMAhahtK zxJ+aVeTTkxZ?=fre{R`X>`h|JCfP>RNb2%VFlS8T9jXmNmp8hf?W(a&Fp>N^WMn&i zSRTf0fxBXN&jO=L1Vd1|-6#5td+PIwr;i=~X4MZR=Z%VFmT8J3YTXxTJdPl?qApGWptQ_*!=_ar~3fxZf(VeXKd?0hkZauPh$8a2hX{7#<=dFzgojYHyAZPkeD=P~(-lTpRZ=L0C4}xXmDt^r_$?)TsR1@?bXFGWKUCSzgGU5yt zvz((}hlvbwBj*S~$PciUtwg`m*X^_3L~clLV-f}22YKLSlD2^a>(py1+C7-W;BcZm z>KZcI$T6mA!GXdW`Gbg?3iVSBt0ZQJ%HWG?!L<)>-#eH3J>IH~uGsdQ_Prcr!yW>a zPVI!L_Mb|J^63V&Bx~@gO(HbHru+Tq0)AwxEZ;; zOsd>!bS|R>1c%$gy!5u_Nrnl5UXTtJp|aQ!sl*e1MNzfRzE#j0S5s7biiQota5@qZ zY7tU=4-D^Z#VW5`(uosih=gs%FP1)Fou-)vFJ9N;{(Ohl$#`RLxj5wFyvM&C5~eK- z>Lz*v`askW+HR2eE1?Zn-xTR<7pm0vZm5Yf{kpm3;%vFCcy9)7#8<_@JLnJnHZ}OB zNKY+lofw2{)Xpb5Hrh{GZ@6VS)Mve6TvYf}(QxJJc3<6yw)ei`Xp0D00np-8@(fnm z=RQ&0ULIrF;x`L$3_#LJ(m5`06Zt?9l%lg~(U%i&TY*`JXTq;!H*i~gZt1Sr%G`9< z0SKq2eI7+Z-=h+9eUZC)z9N!Kzmpm1UXZPx(>c7EDQClrkCsFcQ-4Rfs(UiGK$&`> zV$~igDku@rArOhw!_nI*wp+~TpSM&Ku4^gu`P=ELD8AyE4da6yhm*cN6vg3K$#i-? zsv_g4p-D<{DAF_Fl}YPm<863}mcW2k@<}?iec)w3;~dKbvWqZJ934qqtlX8d!ZgRG zmUPV;Q9D%5(HSxZSI&*4%$EXVO(M6EE5YVLig_M8$nSCZEl4|j34B3bsJHEc(e#hS z)CifmwHD(zPg-$GA+Y&UoC#p6I5ce(6UacB65SW-%%%!dsKa-?ac8-uDxuk_w3kdkDMN_y3xS<2~-=GpDZB{3N2#A zV7vatRjo#%K<_XnmUYTBN1k&m(@ax>*Rbfg%pocqXFaTfkZ7n{VrY?576U0HOc2-6 z(C-|hUzDK@pS?fW3iwQWbr488(x%bf}` zE3i76MqAN7g$-qO3x^h$esG0)lC?a{dob%L+vHL;OVdSPJo{+u<+9}Pw9F} zex}uGte3hD31y;$}Y7boaf6+yn0tr}~)VI1bIV|#mlwZabmwylk4 zc=ptWh+y;%sN-I(fHI>I!`5PXFxT*}p^B1Js|1a%%BEVmmzVBWNCL1ey~w>TE=^Jc z!1@BaDkg%;@hV^f?5oVrkZg zhSyZn-=RWK%Tuy~>(xf_p+?eK4ZD7N(AJgYW*&WM)bdeQ)Ljd6L!sjGgZt|7fxN6~ zxV1DCbP7C$CXbBInDD+FqeuPO)zG@ndVQ5+NAijNy~9gU4ES^c{ft@sUQJVmvX#}O z+BdH%diNiGAn#uvJWUXeZR0&?@$7efrvgqR85Zy}{%Q6lRS6qPAz@g0;i~@6OJ=RE z7>>Np7LLLi#n;I&eyu}_>c`7vFBdc6U2_oBww^L28068a|2{cia?|JyN7S9l z)`55L%xvZjYY!HR5MNwozP#gUx9Nlt&`s*yI(e$yM-x!7d)i$S<7AA}M|HMa8k z7LIwmUW{bv+trjZk-7Rd7xz|$_w8X`GJ>#n9qmR(kAcgx)Tac_lK2z-<=C$yPw_aK zSz&2wdNY%hy+34dHzShVF+zWbGtP;PTk{N1KuCWm8z_nd;o06UHoh^^fAG?2O=sA4 z%`<7|wDQye4ooe=nBJF=nZj+s;&gp6w$7SOlLl$G<_BZ<#TO?SNo+d<~z&l%Jw^5sEfWPyKWKr*0yg2t% zuTMG`h1Lq*c7~XI@VEp?)9~P6`+PCLeq|lLwrV;OQ&wa*=Y5J730CeT38;`nQ1OucRQ824)^>wyr{?K1vL~jDr_vLl_gSHA6L%X`k0G>;( zyDmfxu#VI(yQI9!u9rBXTyGhmEi>)^uuj_q2FjmJm}bd72Bon4Q0FY9?1;G^qzT4< zB;UB{Eqw@&Ll=EOBDYq8QbeTsBa>U17&m?S$m9I|;-K)h@RDz;OhH7{+{kH6h`*iM zKxM^{HGiKt&{wNGI`xaBn?17iC-`V-` z+k1d2HVasepKHbQH^YKQw;nYZ!sf@&7JiL7A1{|ifOO>-iC#dGbS>QwiGVDx09kHg zi6;0ey*~{%%0W2g<#Gpp5WaxcwFNIGyAmaj)zWrGasDsN)ueegfB_TN)b7mutsRn?SbzZx9c=+f$BVQ!JteAveoG)5v__G%icCb2(5Yx(tKQE<=4P+G~wiBN& zT{(n=VyZhql&5G|!teAD`eLGfem%DV(_F3!!RZ7Tc#PaS$qZOx1JtJfBLjigjlLg% zO=OIsJQV&~saXUEqo{U?R|0SgX&~v|Ko=YX@XlDC^d#4e!KP8@W~q8=CcWq_~m+o*L;OLTf9+7MG3%KVaEB5bD2pAgLWcsR!wJ8QTpp zU59`lk2k;5k>)*JQd1z#FRFbu0`PL-LFOA14WxKG(iAd|b%4ssanZx}&w|mmzyTS% zH$^fuI5UWi-F)hC<$OsEKP)SBjKW$Sv>i0h$>D-bcOpmn3K4qg)#ZMD~92 zmo#TcHZDF3^Qq3^!P$ntLNY+=bIdkFkqg~K2JuU4yllw|y5ewWnwj~uru5~CvFo6| z1(v-g=e-LC)Fu{K>X!sug5t|EWOc4v9K1TmGPm}78kVm39H3J>|J)NdzPvti_&Fn) z(hj5LHWt|UZA;je?r`T0ulbkO`w;cRb`B;t8dD_(kKJ!-A!cX49y(>ZbVt|B1n4xyS>iAWV(Do?BvF)0p z#>QK8@r-0iQEAYXu)Z01SfC>648?*3JOJY`8zDj92ee-h1)9|WairY_^MGK%ao6=+ zoQc5gTz;GE4}}zx26)KPs=HC)Wyn*-36u_$I){H1Y~QsRz+fj~slYTP%6{pdI9MPT zG+*Srz#>I0Fb9Lv4`ifnwonQ@To3ONNUdfFGze$OZB_Ue3kQf^3$|2uANV*f)78(LGS zfyUH(tpaNAU;WGP3EH|1??Q9|?t+wnmp^lgh<);)4Sb~;?_clZW{u4ESP z|FmW>IPrZ-@+Zbak^qbUSbb>pd$gj8putC(_(`!Sv8)`9`<<*!f8{R*W3>Jm}YUelDoy#fE%^GZutAAH~RR13;Ce*i1W8!fj&Z@`n%%*X?YsZ`Va&BY_eYY z6FZNCad)_b+Ef)l$w$H?rMR(tJd3_`rRmhV4I)A|CkKy>I`=y^Nqe#=l0N^L)035SkxeMd!O*9D}EuvT9!Uv2) zbdrNV1`KX3L0COWFanPdD_s?nygxsjwaGSsB$q#&s`i@-?ND||j32&F!D1D_;132;nlzT6Y|#Cka(dM3 z|9nLK@$Hf1q_60o&+Bf2nZyMMBIn7_if$sNHd!%W<-Tw5>$(D~=e_e*`g1C}>5l-n z?6%xiy4=hoddO_G?ZKsGfU#Ctx{0B&6)aXc=Rfgle4SIL5 zU=8pAc-I- z&e-XW2SCBX>@E+?dIiA7NLghieU>%Nh-KEw^%!KII)HIV-i5+}T4C#L383|;9x_{2 zqEL@khd2SiAQ(%ET36MgwSY4PGJ7p$Om~U)g7b?Ty?!jW0A%?k1GZ5M;7wUnH-i2Z zthj;b#R9o}@fs>fbY_1PbOUI4y&kaR0mKG?HXwI%yHlurgA!llYCK;9R>?*Xhzuye z>$qTy%nDj=Ef6)3e7Fp=z-=nG>3B&l&mh4#UGI~^+fpD5v=Yx8{KOf5Jk5+?>>2oO zhzLg1FqVn^Gyssxn)Hjy9D+qIf&jqSBCGVg+(svUKQ}v@;3;&y-+Rqkntb zEWW3uI|HTq~hZV!X5OT3&;D_03^0l zRKKCV6hCxT_F&8zb5D(hHk&X`#>~-QT6^T%cmnY9GR_+wFaCI8v^C%vvImX!*p%(W z+5CP&(A5MD$d#A?;Ycmib9+vbE56zC{Pf82z*M@D7L5bQJYv3RAla6YVBzVNVRJnoHk1t1Tm6j`XoVT39()P zoWkHx=m9ldU>z#bX_{pKffXV^0W{`e68P42=n)S9 zN{xHH#NXvV0n4X)PgY`y!BP~}0O1`oQVPdl$Q8zPi6pUsAD7jk8E5(xMAn>27sA;UqxBtSj|SQsJ1ss3&_w?+l0(K&wM? zK8KstKgfzP<)%+GdzRsUZw$`WQEcJq%Pbdm34aMmD1s?PO4vKFihF=q*A!%(<|~fH zEW!cljIT9n0l}PPtr8S6JN0R*%zyu_iVA3#l zQ+SKIGrAc|TuRMnJTP@+7K)Zal%MP`XQ#0iHJu+b5Qr2pku-@8docY=q3dD^xUJ5Z z)I{Rtj&`nMg%^@6hnGBHxjk4sAdpq57z3ghoBPT*AY;Wuv#VIPQZ@C%rk-gTJx);^ zVmGdSYT*IMQD>zQrwz~=i6YIB#IMZ&JGngr5KRi3+vs?V_-M1`Dz02*2+PHd))=!H zKm~31EXt6=E2={W9e;XRr~T_k-O3*TCaQ3f@}2WP zorMGy{Vlg;#njzi)qH2!yoL~QDqrqx>e{X$U2CI~{$clOJHRUDgIx{X(+9q@!I}*wc z-nIpVeUY>Mec8^tdbaD=8-{P~83#6F#X;xC2Td0&Sn0C?kveFk>cynPXG*n8@ecN9 zF9si&-26T$l%%Q^V5d8lXu2i!zi%S?Hn0hS{bw?jyuONn{B&@(C`qV(QyF{}_=%7k zh+Euu0rBT1AjcIq#>xi+@W@ImD>9`&rW7#^BaH7GXckjUW$j%dItFbmbSKgCD_y1} zkD1p{pt!H*hD@4aa{)FFv|nL*Sy1)d!lbO$D#_-3k5I(DK==WZ@`-Lq9=g)yg~nDCHBe z+&tSJ6%`XuK%x$+2E-%n2bn5lQb6p$BLstO3u;u8(N^SpoZB6i2upY$xB5U%$$!PflTL$N1qa5tG04H zYclTVnP<&>leKYrzhC4Jj(esGJm^Vn-t6=5(308JhV6DBnSGMsTl$HW4^0C}o19#3 zSNAWH2ICSD9RTr$0UwJf5iC7KI7h7dftqweul2&^{>PTFrgA~Pr-gzAH0SX0umSn@ zDzQmuZllRcojB6HzP*HXdBg9ZZWF7poCl2v$2W50kHMql&~MaOuch-Vi{@X#YzbiQkJaRs%$FZfI)XGl{~t!tYW~{HxKa{XZGvfz)ICV# zrveUrytKueXu#_SyT?LT!gRfJFNuHSe6KKmvY73IrNR7%=HrTJtUOfE2M{ch0E!CJ zrGf0bpBU{KMg+Lo{uO4iuOI~!t6fJ|p6cw7;w5Fy!Sk?n_|4_7#)~lzO^E5Hv!vn$A4NyQlL{^?q3j{rx?fwLW=Fvzy{B%^J2sc>bPN z<{mLF(a8vC?s%n`eAw7o+XMLR0!;Wd(HYm=8Mr9L5dN5d(-|gMMZyk*qsf0-aF}oK z(9`m7OvQR{9wmTz^yR6jw$*ke;rA4-eoF145~{|JE#*Ey7o6HN;AH2g0Ds@4bP* zGDeQjxeDw&w{{jTff@C$8h86&guMk+mE9IKtbl|ZB$UoWBOTJsK}t%b1nE?|;}8dl zgEXjsq=;hBjZzZQsdRTsN`v2i^uG7M??1*jzA+pQG4MS5*?X9yp+bC7U@lO+{OZZKl`>Yd>*qcVB?86nMWu`#qYT)AYqr{)AJ5Aei!m}*IsWyckHCwqp~qOd3d8K8 zK0&VoC4^qz=L6L!GBU5jt>HVlGvANs0gN}mJ8ox+3th6_nC^Wh~!Kj>>@?-tq4GajUW#A7Ytbe;L4%i{Nu6UQeYvXfqg~K*K zbHOBmcT^L|&lVJ;8W+!R|GvLU#kqg|tfxT?Sc3potCeU6hzG6%I1#NI7#f!5T<%$c~|WHe_u|@FC9=a)3KF|S=R^#^+ahre`uS7?H?t9brZvjv?zu6D+x~5tkN$N|wX)xWZN^R7HMc;3 z={~xaQQiSa@ofs2PAi>G;l_IM)@9djuf%pJm=fkV-;E3UL-|03@4~C#eCq06@r_XE z#Aa_y?pN#=PD#b{N z8ePZ6yTS|9%{xHk|3|QXyK%bCKjMYnLk=3ZcK96diHZG=0=oDqpPTot*>t+>ij8}D z|0PiW*?^!eK?R;=NUL!73Fu?`;MlAl5@1eDr?yI*->3AM*s5ynkpl)QL17~%{@f;J zpfdaem#;|9?=V3}Qvpyz_+i0n)LxEGTv`riQ@;P$YyItd$f8sMTd4O?6mvxcGETC| z#e>$W{Q<2{8?ATf6EsL&g9;+Tyg5AV>IF{dPpQv9 zM|=H6aM+{t54cu&X0h{TC0pLh|1n+p&wq6F+DAADZ3IhH4dLcyG2Uk3PBVPPYrR~V z*xf>=!>0>ow_Q%BA+HHYZ@vRry%gg8IXpem281r%Dg1K~{joYyWZEobCXC4;UG)Xa zc2&_@=YPQigEth^HuheMjPeyP*+{<;0AKfbTQ3mG*B+de^+{8M7Y|CwQi&aq-pMhg z=>&ln8U=8ecyM z?0|{?8|20=a@8A!Uz(nC=rn=gNG}ZrNhq)Y1(ik6MjwP61v;Db_b^s5TB@fDMN%q+VDzE=N4yypppe5`I827vzvt0vvlU{`H>(<$=^ z%9dxKynaLGe5V*jgESz9*AD zi3Iedos=s+z-`nx&0(~`5SIt$3^Vw=Hb?(7OE7w0-T7qxhS2Mp^vPmU^9_kjB5z!q zw%K_mbpkKTc(NP!=>JRP{sCA&;z70|@YGY9`e<&Z)ZssMAFR}p;`=N4fYp1n{<$Sa z_8$)k6M!HnuFosJnCXA501h7T{DDzBmTMc|EC!S-0d+)f*=LRHBC&r(M}{-7Dr4IV z!d3lz#XX^!*%{zrk|RJQ7js_@rFO36zn3n`58QAB`EkKi7)SFaF0z}yEfi`(YT%ey z#@w0z#()+2>(?*(4N`zUsNQGZ{qHM)4&7=C_zyCw-Nm~KD6zd>X6{IX?@y2U2Uu;E zc3E6$zwtF6N4b9lszlo15us0Sh_fGT&&W6wf5oPspcPfW#v}d4JiCbh|Mj`|D6mO> z67OkmwUq!i&1J)}Dx9;hno;udc)|6N>@a>laOL_`Q27u{tTQzMZkjv~v#4s?&-EkU z%mUx$lRVVw|F6EFg6fO8-cQ2?)Yy7z;~UR!wgZJ|nohPiFm4Hl6v&dl4s-zO1UvA2 z8WeMMUNZql(9mkQ941cKuVK?7__>-~Hki8`SUURm2|z;j=Wntmey9R&d-r6~>lXCA zt!EcIlKwdTU0xnF0EV&x1MlShfu&RPYDt+H0j0*n_NIm)7dCAFphD{sAZw zf8p?8XmC44-19N)>cY|Wp1p($iO&4T z8t(6dyoY=YskW*gPgk0o-KnV4)4?#r#~g#@7S-7)CF%~n6Sajo+j-;;t0 zz186YBOg#UDgYw;nohO?mH;_+VEN$;AZ(i<*`O0J%LBYQuh2al8&#f|u79)u$+O&5 zlLE*kPE$NEjP6MxV5R)Ns3`960g15Qnk~gBT;Y4vUl*BwaMc|qGi$RR58bw@_b*Vi zw%ad~$=e@Nh`KL#^O-k=LfoDxtq&MJb{*%1&q62IV|J@*M!FFHPjPx(E|A-xnBic3 z=+nTQImPOyf1fg~Y!1+HZBsG?>sN}9&Q`^!pujF2HvPD)_5ulJg`BE^rnI@*bz$Da zECdXZ5{WvD7DFRQ#h^pdB6GC%eZ}%S>N}Xvvp5p?--;i6dP)$iyR~ffK63nR=W~<3 zui%T1ku%tbS~(>j_LqC`Z?b8?AcQtadki?cxQ%OrgvobM;)f3pB&r@cUxBgoIBQR!X-*4s3Mz zKwGL>f)CEH;qI2p(Quv_B8&O;Hi0njzcHBA1Av#`&`xCb02#lgdfyNk>LEVnhf_-( zBKbyWXr%UV{0UqazjS#9Fa#8k*$M^5A&5SM9#G{!YF}L}KieiR3zQAf3|ar}&Hk-@ zA+PBFvH&XCWnrk+G*6;IQvIC^Kp)`&oJAS0W zGk9z7uhcFks?B@MLLO{|l@R{*l(e`3bO*xqdtm z=$W@wV2-ip3e7(GC;;+R0aN?Rzp*et`r_D~;OCbtdslTyR^Ri*Z%e@cH!57Oy}4#8V}vyiUS-E+8uEnD{R|p#>bvPZ%!XMH#_Dg8qd3b-XiRKM3hsAjuGr z#ANs9X=aJONZA&&7A^Q~3pzX~`+uy1{_Z9e6$I>F_pZM;0>F;lx5(&r|FrpRt?#~k zkx3mDPxA@h&(X=J+f$%>0fHXh+-@6voCKC2ZOS%3?J=O9qKATkbs`=xhVVj~_yz86 zw>lOx_VfSg=l>H(!3f^~SR&df%sVatAYH8HrcYV`qoVXD15JvrjgFkU)^>kEo?XU1 zb75cx2!wLWEA1feDR|*XZx%PpHxQhLU1FXFIf%^8C%yOya{$++pdJhUJ3(sz@y%$Y zL|)k>*t524c-wEJnq`HeIFFC_L0G2aX*l280euKg0Hc{|fhgg%QXCyWE;E)@#4Lfx zB%dCJ7u2~O5~-su26v$7{RV*t4st#Oq&H+F${p}A z4r=HLfSJIQ)WUpY1t8e4O}qSx1ns0Sl_b`%u`=5T&}L|9v>(#dC-|~iswN8T=ct}f=}D7puS%m*O567N1vnxEz!lB@PoE7^15I?+xXu9bZvIv9 zAKSI~uL|-3Bi2JfYt!e!Ix*U-cm80W$0}wW^DMhKju2eGI6Ep@Z!mh?(c!;Eg8_93 z&R-uujiMl}El7~O2)JgxxVq^kAbhDL%D+a~b_n<$0w~h}iUJ0Cn^A~+*yWSdf|An0 z?l39qJa_%K*6SQ6NYE3-U5UQRf}%VcdSH<0uKJJOaf#fC zsqz`;T7lb505m=Ciz_Vi>w{)%kjrj$1E~1<8E614GFkrg1JzrdcxwEahg8_}-@euv zdkiS@V?iGdVmPTduK^=a(Ee^30sm;HrZ0d;k7u5qK>8th@v-#nEz_EW<{!5wBBs&_6{pr8Dc9a}GK)(OZx zcGcGC1zjI+D(QGV+pZUNS>T^k*!BG`^f2@6l)5MaqLuhwgjB%B6h)*m{TKUM=geFu zMEjfr_tRWDIr3UKs%$fTZ6Nl%nF^JjbQ@YXUSpT9*XDvR2yq{M;eO(+qhwFf?)%}R zB#2IL^hZvc#GXkbwT9ZiF#v;)fb`6JzpSt0icC0^RZHwZr7boA)vdg!TR1`IH8tOp zC!9ll{zJ_@)?~Oy3;TsS`8^4mwqwC>4?pvZc;6#xZy@{tTa0LaE3?^45K5pci!uge z%JS#4v=JW=#l-HcXy@ak2*c)fp}KwY!^@yht%AE|dg3e0^_$TEOqE0XQ}Sg^B&`m)|RK+%-{L+LH*v@4hFkKgM+R z3|TVSoXWM|!_rSXf5`r#F`oqtF}=6QGW!jTnz(ZOo!_?GlCxYKopp~SniI!fq$jhe z-eOk1uf@!vJoZZkupKrkC`6}fBKykd<2qVgXfG1zO{~0z~WE6k{^-M zd-Y`Y$Swl)2ffP(6YJyaZ$j@!+viQOuSWQ2m~Za9@EWZO7D5&ak!^y-jJctk z>De1&WtO3)?|btqvE9pHE3>lPQy+si14mNklKu!GOoDnn^1K_rLB5$(qK^KjbVIVo%hiqj6Lgc4~Q`Z@GHD_nsU+Z4V8 zRGCv6skHa6l_sF4dc1$jjR(P^P(=Bx$Hh8aoJo>6qHLv`&iCe|opMD~pQuzK>f{l= zcp@%37#A&DhpUV|{7G^now}n@Jh^a>6@#&#>uN`%jmocGFYq@>>j@RM6gJkeTbvF{f}N&)v^E+ zWij(LeQw7=u1l92y=|c#fL<*ic>PNm5jq>mmT7m!NJ9KL9~&Kf4$^~pQ~<+>C_QI! z3HOQ=Fn(<=X``cN<$3|zR}ZJ%_YS|sv_$0Du7Z`*_jGj)o(0&LOuP4Z$qgQLTV5@fDmSph!r3j4 zxn~T|F;J~E5}%4H{Zb^H3%Ns4?f$>~iYmkI5Sig3mPO>;h)DsXKM{i%gp(3`aJ@$@ zibKM)wY-e_#$xka3IP|u4-28fl@(e_2&0}5iB$oWy`dF+FTuQC`5WZ$Bz!Mr3vDO) zvwEQ^F6i9yrX%QSitwvQ$sO}=CX@Q9d?yUtd0N~`W;D8M{J9lBW)d{{g@fo7o~w{6 zc$ejDORAD|;FbYhO)n$$T*u5YgN_RRK;k0G7o)@Id>?p^h?a(w5Sn{k9kp}1%SiIb zYgwPkgPEA6$r3XnR%h6%td)Y{aIyI9XD6q!Qjj5l}r|d zzTRNhgh6i8!b&rQLB|S4EFxq^Xz85uV~P3r1wLN*8dNRb<2hySBI=&&=0nz|CnlvvZ8wJ+mw))UX=bV63#}=i5&~S^*_r)BG5W`EQ zj`zh0&`_*zPCP$(_O<>!Zhi;#pew+tLS8=>KtG`)<>s$y;A|KHrZ1Qn@T5ZcOdQ2t zrZ|!{c!9V9EeL9yBp#OUI55m(nTV?3yl<@xVhjOBBFa&Aqv{be=02yZ0b@$MGcFtB z&lJvhMV@#A#Efq!?fq`+A1Z8_x1`;dY`HpPUpIHNp|2n&;k86wu+|G;IPZk-$}pUw zx!vwfPf2Fzk&po6yLSw@`?noMP=8)Hf0TuMMl3vt=!HXD31nsY3ZZ}%2+YZGh^NiTURk+v!V?iRm|gj1emzNplA z{LIRd?V!BqZv-jAQ^r30jOB4@1AZZ_raBQBjQb-MMAr;8k-S=PPO#hz?!x;_R4x@_ zF95SyMe3P=;#!n@PD>xRynjtXc+4khr_1zWknBhlU_=KB{x%n1a(pSWt>by}20M40 zQnXSndqh{`QSFM<96+^;7*WwJ+M$SFj({a5`CT637$e~C`MvvVc zD2>r$w@DGrkFQOisWQhEXz1(o54@wTMDm~gf&?qG+@+($84H%h)xpyW?4flcu!l4Z ze{sD9QTBCQM7!Gq#$(}WAIl_t^ld90uEpcj2I9BjEfxcDA9UV@@8T0GVhNuX-`;K| zH+9HaSCTm$KnldW6QkO5=%Kmuw&y6sFdUQeXIHT)8MQg?7T{LQ_en{#lQl4ZUjm%%&idZJl-*;9CU7v$J<*l@PePW(x(>xwA_H1sZ*XjCn1-$@%3|GC zmK7)t2^-#GR>NLas@0`Liz=AFQ;s!qXMkMYy4g~RTF(!Xl7I^9JL4#w?_$D<6~iY? zL7HUt25^5tCxFF~Z(nrDGH%A}Bg%*kA@TRbj)k;zLpJ@>3qw+$tboIk1Na${9io1B zrm@#kO!h!vA|qNQS+Zzi#Kw{N?awI0_rD7T|kPQUYsJNpD8$U~Lo z8Lz8g?j`a@F`qZcgvp%m5|Y`sS1$JS&F$YhEnYByolb@#O)Uqh%qxcUsZ*2U-4?sz zEKgJ}1;x*!Z_z03E$icZ{u5N&v%qG!yyw|s0a7qov#t^;2()A%&^~^luX&%7GKKz7 z&pMmXQjvlGH=VXO*CdK>->yQ`6Y(nG{3d-BX<%fvKe)hxEFOg`AASOr3BsDw1_DId zN*=UPiRr))-%De8`3r<92C0L%G$C{X&r_J~?n@fto-AOcn4lciR@3#5gt0eUsBq+m! z^w5(bi~sHfGG+$K_Ybv6!9LLC;CQP8La8$Nwc=nwM+pmN6sPhcNfUwVuw4qD?Oh9g zWD0IYT)?I!)BY~M!;AJ>QTh0+nWO2Wuuszdy3o~54*W3&$Bsat2@{Ip~^yJbcVl&HV8YqtWt_Q8s}aY zE6eC%LCr_?S8zxT|gLZ~#?t8JRJRn=HL?;JdHm1)DNl)c<^N~dn3g^FQg&isnQhr(E? zTLJv3qJI5>$q1uT*{C4oYRNLaLnW)d#NT`)33kY`oOatPHrO6cTEk)h)plxt)3V9( zAml&=I6vZc8@4^GebXUpD!T}r>HMJ>Xrqln{HmFC=U>Fv;!~Q^E1KwJrg6t8U3a3X zi^#Ra-5dgj*9oYY@Do3$1f$#-cClQR!DltNymbfn(=+o1b2~cQk%{kuu1M!Kj4=)`Ri=@McOPs+H94 zCCtMWC@MxmfeQC)3*G(r7f2;5O#yoPW~YXMTl*HdW2fw>lXxrPNDY6xM5)50vGzvcOJQWJm}-k9JWc`3yUln`xIt z6bHrUB2SuFxH{+YlNqiX7Kd&lNEsiG-59X@q)x~?El+jg?T30b|F|la>+ch5LQnjm z{8NTL2nxwr_jxfG;|akNBSnW#*`X(Peu%B{Fkld=ARX}f8K~e{H-Vym4oun+IQukH zHz`T)B@|CpPKPiftwA++9ku4xfls$c2I-{%o7m6OhC&FQgyLoF$qMMH|)kZ(ZS==zM4Tb zAceo}=^Hh<7KWywxA1);60!E$1mz~sLYi6TxYspovux{7Dq5cU7iDDKjE8ORU)OrQ zsfMlhzWDhAkV2cFz!_dCjq?)5Rmc^2!%~_1K3WX4m$?n?z0UhTR@-X}J{it;0e2xh zL{Mt`Zsga+a?7Il^2Mc+EWBy$vAPpxl7}^^kt!#IO$Vm8C0cW~~-y5dC9}5ssw$k`Y zZ>9>tZ&FT2S=B-k235|2A3x^dne^cOsj7tN70DNwyJndc)&BQbx4fCXHkljO}o7uiqCzz==cZKl7gxKkZh+b=OND zSqpwi8qUTtQqFX=hQk8vKW`5wfIJF<0|SVuep>(cn3^+BWR0dr5SD&>Q#E-1+SLPq z3nQQzpE-~r1mU4Oadw*xDURQMSkw zHL@>eX+Uz@5{@hA%pfBoVVbSR7S7q1!vBUupg4mHAstX%!fVjv4R((r`c`f)171So z50+)l#RYe^Z#g&YHxojUd6MT*?DC8_7ZM?_g8WmXyVb>NZ|}E@CBobDZ%K_C$B;bT zdR}`-3_BmGA6GRnXY zq+>2e7$$3Hw9u}9D2uio*MpFBixR-Sj#^l0h_AyEUGg%#1UP&FFiA5&V3V920}q)n zP#N~*daVYF zxo1AOKj#n_Sz%q2@N9{o+|NKis24o19hiJ-sVG|+kYK0uH+iT+Koh~wk$?vtR~Hld zP37luZVMU~5(mVn0RT>FPIfE?+d^13`;Z~swCyxcf%Nm`+c?V% zw@!{Za5V?g44wqG!1qJP!|%=ld{PLJM}<4VL6W?ns9=}Jg3FvWv2-h}y5D4c@f!%p zy4kV=G~{F3ToY=QFperDpNbs!-s!*>vebbq1g?9;5*nRnb)h z!XxFV=G%hWXTiA9cVz{%JeiWfpRndsinx@7&qgjy7~s%wpWc?%6U1}-Fx*|q6EVM9 z=M(f>OoQ6j51P3Imqb_!tiLpJ;zzZ_4?~(Y2QUT;ja?ZtbmpfX6caRu2J|+5(DCb% zQU6B^kS81+>TqbFJJZYTx;JE3&C|g4jA(bWIfgj&oSMIV$AS@$gK3#Hw|kT)mgaz6 zhdj1EJF>`0(sdresl@nzI1GW>%P?Og#vyzh$$o$<7i(!=~683p{|mo112}a zx-`Ym*`FhiUmk2PrjP4GC)@(;+K+^~Z~&uUB;FSX$Nm`rQU=UZuV{<}idnCXEjd(= znwv=IDcHQ{AFxKV=H9f3FS3ci$xF%_dEE5q+x=JHwWaF~BGu%>Z+>C6O4+5q+`&l- z#Wh}LwUUTKFf$>pGvc0T#UcXlf8)VB>D{Ji>fMXVIX;R-qM|6dmvD} z{VDhgczw(u$LSIXfL&I=&HSa5~z1u?vnRJ1%ZJi!5J>uDJ}2ga@1I+%Hg%vEjEIexxq~o){m*gqIpe zB-Y+<$p}^~-jdmcW^IM|4f3c4H$c~t@meISl^wq+mqAl{XuCXFn>mFW9b=8V+mfg} zk~;wC{0WV3;_9@}52S$U++>2h2y4Hqscwt1AHb1iew7s^?n%A8&^&bRKMmxfzQ-jc|yB);92DV2x_xA#A<{Vx?5a+Lw!YQ zBxPTKjj4KvsWu(3+C}@YDb?xRf{^#$^=woDa~FEL_i@v2oDJ zk2~pszsNFj85k2z8s{k#O7Bi2K>nIgQI^TpCw^~#Eu!JMss z-*qP;(QThhLfjCL6sGfvmh@Ol?iRI^?_Yr*3>AHuGIYwi4DtUK_4JS1uEfkqFB)d` z#GsT>i1;O2x{JII7}{|9BzHFRG5ttVY~6rS3kRbdr}lhS!qJ+y&>7I9KXNbIpIVs( zJuh?Pz+mJPhSEp;-}F%~7X>!55td$Jk5K~3Rq4mk{;C8s+^vrZS1M=684QFdGs8h; z@C?O_1RZtmM7~0i^Lth_^f^;xhE@p)VtB+RYFs6uk$k2@DRbYD@NX%}{rV;vc?IOO zt6ov$tjg+G8$ikLyg5&p5L|y-=tLT5yqhDW58zSd`S+zKmfl<-va@ho94Q?wdC6dj zu+2Ow{jFM6Y`rh%&;7tcBcU3ixnx)=0haH%d&umbh?4p`y{iH~Zu;g6-;Uc1NZd|K z{&>V}37@i`&+P^!EL&5p{OFGE{ z#s+)%Ei-<1gq0b}#dEb1&o0GfV)b+Bn<$xN)UFCOUe(=@(Fhn*9h&hVOzoI*xApcn z#EnZpCl#~H*VBQWD;xT{Po=%a7)>k}!Hyte#38mqHv!Gp_@#QwB$!*L8HPa3Q-I(K z2_#q(`Ai~5mRQ>MaGQmGIQ7awYF>jC`q!^6MV}0=4ah?(Fi{|rYzCCLbI40vMhakr z{y0d(Eh^Rfaz_W+-l0i}r_SL%I;21d)h6)V*fQA33?7tj4V8Ut@TF6m++%!Htj zPMr$&ksz`CQ#z2gH?JO$X{N?9cT23twu@v%#c%WAXCe1g(vo%nD_-`x4C-BONkk>b zzw`05WTwop)>HISX(zG_rv)jMORK3i6pVeni=Wy zhpr(L1!byIxO$oSt2>PS5xPv$#2MRuBVU^Qr}s0B^^STudBtPFi#fxpKVRaFV2TxO z8W%LNW4KHR0j<863U|zf#AJ-3TOy$b0>u}l-!rFJ7$`>{O^ZWhxfqD*FUyQoU)=6! zyiXcIB6ts+`*Ypbc9ghRqv)c;nV4$PR}OsfEDeuAk~LtS;|)4dOA12}0}vTheoY;u z%-EiNj%Ee-Yv*Gjo&&EpsbK{Z^v&d{7PS1=Btf z(K$wDGyBZX2(6EAV^lEXJM8y4upbqA zvWoeQa28BXEoIdl@KWZ$!{I9#U))s2)@y)mq+o);_VTgwUg+Y!7~UhIJzD$Kgiyfb z(eAgpSSH8s)}nZB*b5SeB8kJwz#Q|KcR016N1Pa5Bs(;);&2S|>bnS%ID{l?R8dQi zTA#l1c;sE?PJYh4`1dM@M<>{jROqci5!~FT45n8O>crL63dSpvxphTgK-nE`=uf z*b@$8c3<2`(AH*>cY-VQ-Iv4fkie_wRXM}K*t#eUvj3|&BWDyL^FWu1$DNtF*vhmo zrJaqUjN%z0<68BDBkp?s<2+0=eG_h3pL3?xm?=m!B<8oU+tm78jSwcrIj3qIy=zC$ z4^DheemwRcxGMFMrNl_eF!fCL#F0H`h#z5lv_bg&rA^wIGRC73wte; zfu@7A6auPcL-CaJqfRR|Q^R)oh>P3)Oee1S@wl*y5%c>%ps}WLLj$m>+Vp#KVb*>?^(5bX zuuj{Y*D1^Ju!Z=&_kh5|%*VJ;J%Baa;E!djGg@o^a^cDd12{%yF+@c)q87ye4`Id-Md8^ul84)_0 zK1WXa|Qw51gVY|^ZYMRvy}K5W515!0!2hu6OiTDfXmRR zPZq&Vsj(jKzK?fSOlfSH5Bcl)vj&I+?JgIe<_;M>(PZyibO++5G5inE&9sMZD0Z)( zc=zaCfiLP<-COkQ{$2iyOYAa8#_c8Z&|;UR2{_tNncQ(@KP`8l2Z8YgdJrVKeteL* z>atBr+yUIkZ#-qLNkj$Q@0aSf;p$sm?4JW$S@UdlqJ%&jg_etBM$o|V6GH0k@MO+z zw;|Mg*q#T7VgEjyYik!>hA)De@3N=ZqCN#PdSMa-Na1`T&b=H;N?a%L4(NguZuxj! zW#Xi%)A%frx;6E0QS3E!hvQvj4!(eJ3Tw;qnY3cx=iRffEX&kaN@1r9zpeAm!^be8 zCROP8gt)aGNBpPE@mE5J6j8VE*Ujigs5kFW(n?0=DQf-!j}|Z0=|ys{4i5(4F@062 zOO7p~BE~w7##D@+p0izdK@L{t*A0)GM-^1UKu7be$tKOo#rrn{J3a#_jx6?V%dBo_K}aWt4C4M2I-P1RQ2r?%TbW8_KAwGun3eOh_DB?H>Q z_ipczgxO=G%~ryip(~hN0F{~Yd?~3aWht;VAo7fnc>VXj%nwq} zK{49>Cr4mh=O=ZiFmFGjjz*1DdsA>mK0{@{nhIG8VMimz+)Nv z?i;Dv+T2;n5@^|HvTt5%^~mP*4$d)Qgs#dhW(VaxUH?Q~hK?+9xo6wC@mcBWDUBJT zg0DLzmQ1FMFw2A4@Ux{@>G~dfWNa1vJuK1;og9r6BM0E#UUtA&&drHYLdjZBK&!Ix z{swIPs3>S*!+ib62d~%&I%IpehSBG6Of|_EX{^EJ3DrZEy_S_v^WLs`Nl2#2LHd=A zjEBGdC$)dooE`TXCxGGn*Dsd(Ks#AmV!OAatC{@C$s(JKeaJ6pz`PQ_V`IgFdhY_d zvfJ3TmDC)}zE?I>-Nt!nUgWr;WL7VRnS|SLEa+@PvRl>PPvr5%DN&|(!TPR6ZX1h& zSh6yLWWXL*Fqc8WZozkY-j^%jW61Hbi9U#DDoi6>I`~A~D!A3g`tyfK=hTI1t^xIn8d z;)(v3=MBG)es4P08bd0Q0x8AGrLjz{IMESILP??&=a**`M~s1*w6kFpz6=i&;N6pI z=wKeTmNF}|i*cDHsKe|DPFaEA#uq8T3KzDkWtan0MIJ{o!hCg`d5}Z##@`sQcDv|Na1+FQ7dBCL3ibr|9rk@Bu zF5KbP9ZDtD(-{t&z{9zL>FJ$}Qd#W#(m?m#jv>&`!tm)K6Px4fmvg>l=$CS(#SESL z4X3(Mf%lThGrs?E{sCOu9Hb(tT^aLr&O?@KR^UdnU~V5q){Y-;-k@J7lmkpesdz_L>{MzyW*tq@D83e+}7I$R`7dqj#} zz%Tr4uHM?aD2oUrI~@1t-6&_ABnr5EE!f2;dMRw{RXXk@@O*%YbnTpRgW@t`)WE!z z)PaK6;aDh<98s{dJ2&R>ZY@~wL|R+K!!AHtDNcY&4cjlZq=0a%l0BbUsw!y7E3GX` zS!r3?YSsM}ycs>$Z5#;-n$kH>>&Tn|MI!w|G^@L$Z?TqCBWv8}d&&9_tGv`&qlM zVY$WFZ~B8_E>>)rBFVj+4Y9GrfmuTj$4DK%LX3___B=7MT-kjQmilHF)J*t!>2A*= zJAl2H4>|!+NWP3TP%OL2|%r_1NN}kiRGbeAVA8&9~COq!Pkx+<0S~J zS{+KIym-lN(QnPhsr^At0xfYG`AQ^%{JHL3@jBwxbTxuDWJd8QVQ+YXV|)H$w#U!P zX|FUFFd`og4fKepD6XW&?nBjc6djxwu@fI89_zZ2VkfuUE+2oQWgWT(HRYl(p`km_ zk8YP~VbQ@Qq6|f<1(_Xw&MUxgK`QA(N+t`mU9Y294R;EvSy~BY*&)e$Pl*gX2 z5Zo^w#dY}|pK{gl_CPhvoaJ`xlla$VJRe8H$?@x5l;3!i&WkihkG*{1>sv!qr4$p6 z*Kphv#j5*A+|8tgmX|X=xBN|gHcrBHyX@uN7CwdWg@rO_q@*V2O4v3qce3UsPkGp= zNPiY@GEOkA5UWCcQc)DpvmEq`gN^-*SBn{!2IVVA>^vTIQ}6DIb(``;`VSUSpC3z* zhUm$J-ApPrN_>2SoE9i^g!n!@nm_G78Q7DOPyPPVS;JF^cr_Yu3byB`7J%HTXJ78L zx-U>Hp!ha4R*r!agJl}r$+fucJ>{!E`aAd{Li{qayzEBcfqh=th+UB8#<3z=M z5%R~ihWUqT<#0~k?|4$6;>&NQ30f5uj3Z6j1Of_l|3bBc8e4M5QN!MgqR`zA<0o8Z zBuab7HSw%mxbk#F<;s%c>+NddM`$B5{MY-xXMSJI%z+6Cn#dg$ed6UiXF$y3L>vMJ zMMf~9s#IJ|giB4qLHNP*<)LV!>m8e^H&J0cmGI!j* zhDii1yt0ME3Vj(pQ=g#-C-O@>Zyz=Vvv=H07)ZwyMzHTEqAH`3F`@pD`d!AWl#EfU zZ1)pZovbo6B^vvtZQL`Gun$*^fr|b^!R>7U!rgDrdTKY1H*IAkNFvE+IDyzC)+hux|pDi`4NnXZJg46)6w&kVlk^V+n_v5@i}z0=*hd_ z)mB|VjZ%4z-)hikyMW=y3{JqQUe|Rx!34@$$&6z;*PD!9RG;FX< z1rTowP5Q$tOgkX)|InNKWnS3v_{#o89dH5uCKcb^+}6w=vX$*kbF24!CzZ(}*1f_{ zx`m$hx_C;%*~KROPfJ#{B#kLfjxvvG*^GlOehq&xXS{@X8u3qvBRI(_a(gG7b~6Pw0L^=- z|MX=hG*2Rw*(;`vfcpcdLaXEc2x+T~8#3e>xZ!>LRySO0wkjut)4Q|W85oHo+m*>U z;4-^yxz43i2JY~6fi+DGW5HSm(bd_f_pn(BkM~i^!|YiN0Th?}1_FH3S5cv>3#Urg z>yPTTD>hJZgh7h1gZtQ@^X0p5*4#~Nin=-&fwhA+zKqFNQXRmCUjVM6LM@kei|EAI zeeac5oz!7O+vfISOlttqWlZ>#+l@k_Ld)ABCFd6O+X4TdP7fG zU~3?Lr2BJVl5;=0X~6(79JCu{TApkRb9WYQItG*Up^yB3sD~Hmj2tseCk#wDe#t1{ zq0^KRpt=?pz3jUH<}Aur@CxlsFqZGAt3F}LE>O&-09&WkrC>;#1@nn+`is73E3>62 zEz0)DD;UpkOyf*cS})4ER=%l{HRG(@bwkA-;K&@yB{?9GvG4Utm-jDx7vUKMIaetX zl`~iENMc%Mq!_~kM9CBI5N&+7;@N4!F$QZqwA)K4Sli-_#b0|opbS(if88UN;_;q1 z8eIjb&E7zp5-h7L3fsq3gblG0w|0xA2k%B)KHBz6CXiz$SjlvEN~v95JYlp#YsvGS z_B*i-9!a*=9@AkP`wqiK}spa72&~;D{s!&8~RYo zv!Y$z(9WIO!db&b+_(6v=(HV-H67w84pvRZshMd*aJ8Y1{y08H+8d#h?J#mvzJwrf z2fe{WBaKga(3<&qyEbE5sw&F*QBBl zUmua-8%jH-cEJe}l-ikGpl|rj0A9wT?%6Y0L%@H(e9Nqwexsw2gj|E3Rb8N%5dV=O z9h|5El~>l&%n{N}_YjBtRosJ534WI5m9MQL`4||(bX|${y7QE9hUrr##7xC=g3-ji za^-KjWVdINq{-19EtENTm8h@EGn+8MJ9Zctu~SGjivIm07yZIy{)uB*g=FHEd@wO>$1pXTkr=F))1iIBg8q^&Rs;n$XB zfW7BW9#Vq4c=V>D(Z_)AS6mR&<@^1!t*Wd@&%#KP4%woa621r=_a%4%#d<{JqTinR zmwIkuWIKP3cchztm(euIOAS5UL$vK)7m>yCEo*j}ErR_WU;nw4Wkqc5=2}^X$8jgB z0o6H#Z*8ijM+DsBeHHCBmD%hSEcOy3T7^>x55cfe)vvk2I8& zIBY7hHKtIbqj7kgi(Vu4xuvq`2r+Si8dp6+N1?l{_wJ+llplEEgYGg*(<-+tkTSGe zqLWO&_l`|B$LBu#Z9OrSxZhxmy*Js^BwoMgrT2=fuY=tEy5Myb@IgA(XH*L+N0$aTaOMaG!7Z zsx(`Q=P`Gu^Qs)ViY$)n4R=D;1|uKjprJ+}Yb-hp3oSp!@5?abnkQn|<_>minKEgX zcV24jqMeKJ;}d>#xFwoUfa@j7Ll!N~upU8pKh`&l0$b@8VF>TVyBUd9v}m~CfVs6@ zI-%I|BtlqVWf*8qZJaOJG?bSqReMR5C{Fv(;*3G7L&Wjl}HSaVs9ygS&7X8rbZ{mEd zq4f}>-DMrCd4if?g1$RN&`k($m9nxmG>83B+^zYeS_;`4aI93FxN8A^b-}py)~hmZ z8FoT}tQqCc+N-Mtg9cUD#^Mn`ZObK)o+eZw)9d?4^3{q(M(An%ixG?5ctSeE}5|AxL|o2@CttL{Qt1`-a%1i-M_a43DN>hMskyLl$>dD5>x~vXGA0; zC_#|WWSSr#ISEQeKtLoTIio~Da+VAdeRq#D^UUv=d#m0*@2$F3lyaIr=j^lhT05P! zKHv22<|RL2y`Tb_54(H|!);fP1^fArO>2zbIvY>)5QkI08mICqJK8_zN*5{n@-2T}1%$eFU(HL*TYvGr z^9X;%B5S7?^JyapX9_a*oMmqCUKI(Aii_Uf?=6e}(@u5nam(@54==CK;ZWS^ z*r_}W4U%-zbIBm0lr~}a??~UPW=ir8PlYIKI^h@Y&4_CY0qNLUR|5^UAhbuyZ8SAv5+2qlkcd`N;v#ZUm4KgrmS;AwzDd3hpAMn0 z{OL+#OSN5+S_X^!Y7{c*Sq&F~5wBMY19cVe#xP7)jiYtg!O1VbZ zbLx{sR4O|&w$}OY>&6bY$vhY3s=FtUAnj3hD8AX|SHi7!b$;aJ=cv#g*1UX+(Z7mZ zc*o2&Q^Y>OM;U8B@FrU4C(>69I4`-U_a)$Ub4BxgbA>TWsZB04b@0_XboOZdyhhh2 z8$S?kH!R zLhdgbx?f#Y2D@7H5Sx&cCsTT_F4GV4COkF#x~I|Hi)#YeH44hJtzeiNxL%orRQ+T{ zf;$SO7ZJm@&vsn8t~Fyb>886+x7<1i63#vpUm-;{2v=doeuMMWekL2V)92w^Rd=i2 zmznH*Ikp(3j1$=y1CgK(9&@J2tzp}~;X$w+(o4U`;9YYWn&uLipn!;$JO|Wk&JaUZ z4oWmr$v`Wplxy?!$@|bbm+qI&xuJVpl%mtKODs-~+vZ+R_J=+iO^6{aBnh9qcAwHS zwC}KrF0^hX>TWxkvBDXU9Z|Kj>FCxguZCe<)=KsfDYmuAxLNR%5D2di5T@S{uZN81 z#t$kmbKZb0e*gSZw9RLIXy@ZjCFh9nzh3CY(|WA!r_!3!Gv`2a43T-k2sh6N-TuB=spw-b87v?vo&L?;=%9) zU73+#@$`W~GIgbbHZjV|o*5A8S#O~4JF?-K&JQ6$i(^KF=cO@Yh>6e`)mUCh=n*K% z@-aCJsdm)#sef*T<6yTdHBg|@SWe-RZPWKS6$fM0zVe+yYiEZAsBq(NxuTt zlgd37M!XkIKJ~R(869mw&^!Z+m?Tz>f)^?PV?y=#s=3%VyqL~g z8B14$Lb@Nu57%l~H?67|`>EHO38+iV(!&*&#wOWMFiK{+lukE8h0n3XzSpw%?%SD_Z^u6|A$%_#GT= z6ZAXE=9vB?N*`sXc))I|I-bQ7A<8wv337v&3F~A*w_EW%J(;%Tq5^%dj{}BpG;|%Z zD~O65;JKym2F9`J`YAsjzzH&VZ(~p|itnAnE#G&S)vT|&kDMr8yv19RXv)C(Qs;+; z6Z&2M(mXBa=wD}LzXV!Bv)m@t8s91`;i_spZ<&L>9}~0t`!+=D^5E=f?U*XoFyEJ{u`>IjUXHh(1ldBjO3$$e zYckE;k&xSr-`niGye#q?1mnKA*s{hw5n@kZ#xQ+->6%FDAS4Vndaht#}5{M?t%8^6*Agby5bct@AN+1qk(V?Yg9 zGkq#=mMBJ^`nbYV=+}`!)=2?IGVZd-3-~01mRFsu$t~ZtA(-lb=puypx_kSlQH|#> zx#sKh9TAF(xt35gg+roo0T}jrtIt~mf$194tP>aI#M;j&7=|S!B1m3VSE&)vrT^es zPIyhcXS6V33Vf=Y6FF$9csGuW>9$TkBBIRis7NZQ!@E~@f*~&K2mFvvh6WuA8R{d4 zvoDf^4%HtcFC`}Xo;|=oc=}@@wyQUNuEEUa6B| zK4W}$!yCt~W?8y}&zp()Ae?A;;I>-&hhW!`-1A!Oy|~Cl7}I4fLJKDT_N0q@WsIpm zFMpWziGQqO-xuXe7T&y<&t5>5PZ|#8u_|P5T10vV+fwJShk04L@EjXk%`3KQ(_Pr3 zQqi`g)e@M8o#FM+PfG1PZG*@#gg{w5Bx$vS226n(a`Dd(&`u10{OaN#2%TA&;LC0J z9xc15NMkMb8WNf77M5itZ5ypl>6PKFWnS%?@z72LaZPEa?q|Wx1+n1ct^!jt_iKZk zh%bxUqO(@8;RucHYyKP5gOCRLpQkIL8Y^_+QroWcdlMQf_XDy_^M!z;-sL712# zKL@cR;jWlpEtWpc;#5&t1-9WYzHvf=UijIhkDzMk%lj|LZ|UR2*cPD?->lUi8U7|o z`J}S<$;XiGxKO>Nxp%7YK`@K%u%$GT6>xdMQ*4x)AvhF*tL$cjp=yi3))VJT-9iMyz< zO$BQ$mk~TvF!G|wn=3@mCN}Y4~>{(g`yl788qK=dO<Tou&6f^Qyv3S$xVB(a94#H`g+6wV_dXl^l|pp2-%$U^ z*I+bb&rOntJ@c*UPh>W3D)=NBx~hm@Z3g=X+jmFY`LXW2?6)2f+Ja#oE-61DK~PGZ z6o8|@@vhpbJ7NGNXC%rt7)*xft_dUul7V@GSxN%IlAS`pe}?LWxLbEkkIA zT*6jkQ`1tPEsnFm687`Cyxz(&(JzNS&f}tBZt2BIZVMm~h!(JjzQ;u8h%=~~7I7B5 z#&n4=VB+Xw;{~sUA1j`nI^%B;@XFPEvzcZHOOw3o>XVb5Vi<_9^V6nkQP(!9p;z`r z<~^yxyYvEEE`D4`WCx%Vgz-6=uz~O}`Mr(rqztmyJB`o%g#<7$(Cp|^A3XXov=cAV z-A!LB8$_QTb2DC~5werr*79<;r>I!6%7VqMmC0$58@+tkc4?xcZ7;0R7Y!;7Q<%IJ zuIrAg6q;U$KD%^qoEm!KrRzkFpvGozc_~&IjgTf&Ns+Rx*;eQbx%A#$33$pyx#os7 z!v39GjGz&2Lyx^yHI$Nj(9Z7@_;^H4IW3xk;7s!Idrd~wW{h8o!j$`+iGd|mP;_uF>e z@#oiqvByX|(6v^Dx`!Z15qOz6GSVLg?Uh(($*JaV-rSMv89)AAkSrXKU|#83h6$C8#7HTzJgFOC81ZR9c_s* zwQx3C!t(}+?~PIdbMFe;a?9RE_#ilPE*UE$Pe(t;scgUU<~(2K#_&ce9MZVHbPc+# z@sMDW9ODO=#8lJ#rAb={;}qBf`FAt^?Z142xwG{}I|%q2J|7Aoqse zP*mCQD-4SC>tdrj?!7JRUCAwgiyI&PLs8ykjwuk2l7b-KsXen$V1vPXd6KbI;i6Bn zZcO3F(Uk=n?&sS|G^zZSAr*&pkh&&ViWf4J1nyIJmG!nWYBr=GR#U>#2YAL>caL}Y?DT&vF;tn=K z{|y%#`37{|MoT7#Z;}1F-Aga;0NJHlI6qN$_f=l{F*G2>FC@aWhF=NMb z1;hmL!W&{ApKL5e$q;;$+$#GxTTgbq_Tok_D?!6zsFnGCxr59>jE+%OFzM8&(O!yr zudF}gmOyN%8?6TAfP80os2Q#NI`#QW;kSpLf%rI1tzlJJ?>pK+1lEq(=v(tb{9(+J z9@!jr3X_9u0^hFLyaUe+^Lvs@&#|Xj?-acMj3L-&78|;!7N?acbnq(OJHSiUhBm!o z$!ae@Tku|#YzBxzz(>-noG{M$TIsu$+~y7+C@b??tN5j{N z>-3D;uO52VArnm&#a~R=;?UFh2F36SFF>a%AbIhUAZLDnzu~o|0696Y4PuF*6>qPH z+88dihmMK+eVc50bQX#Rmk_m{V^N4ZU@P$j21TuOiDePiV(bz}E+CLo1rt-h$)O1A+3Jc2oI$V7eci{UtzMt9efEz`3(+GUC@W z^G1?E%@ABxhwmXCadrA2A@2Eeyrz~ADki7h2bICHWX3)f4D%vfM=MMObr5D7G@|na zE`it&D_37rm%Oh|2dEsxW!;@q;zR84LeM&$>cf<>78O~8LN#ZlpLYf??wM_;M|)b) z6HHTM1gJ6*2n68B((Z=I@8S?N5?8lKD&fFG;HN(Rdu<|ZBld#r+&`Xn^gg8@t zH4_Z<{vO#KM9g)h7R~rg9mO$+oCgikXVh+c?&uW|E73+}s-t&VN)eDlhk;Qo?DS}^ zaaMugs?k#?A#C<>QAvcpxfZARC1aL4#<&8r^n$xK^iwDoUqXYxrA1g}*N-#u}jZLp^24Ji~UXSx+pljacU z%3>Ic5Napb7Efar)GL=+Fjk(x>IjXK}U+g)^uBy%--Ll@$ z@kgj^>|dUIb8S?k*)-*Vj<#mbHBVRIwJ&2`9n<4t9yE7ek{Y) z<77;Q7^5M1kjLjs25VryxstpHvd+>&rj^ziob`b;fpXzX=v6dxVe)6IO~)GHI>d~^ zi?hxcO~2SfBVy+_7pGL?B!i?zbXB+a8vV33pm*iyRgrZOysx+pkqtQX{f`%?8RlX? z_pNt&sD5IwAYf1#%Z`{8bzB!m=bR$+V%U^?G#FaHxs+1q^*M$8go9CxZ$qdNQU$){~$GPEuX zv$Fu+fzO;}edjSaTyj^n<6dI{Wv@CL;PwnF>FBeDf|#KnW+a!+6r>2Ms6(;M8xgTt zZd&dTI)D8YQTTUg|2W{=id%s^VqD^G1=dcw3^9;Fzcxlp+118PFnBc|kRmb*Y0DPW z=$y;(jT5R(o}Z^{=~m#wliR(M<|oQ4$Ip(-%tF}PY!kOmBajJDi)(!j-8qC^Jain% zv>}<&jpLTE8N|?fH3TloXUfW}wdO3KoH_V%c|6h7AI#ee={LgE z#XK)P#zT282FV})q~DJt7b)TK8`Cg;;*knmz&bSYwX|`zUtuoxmJ77avaGwZvgot>(>LVF8E1!DK% zSM-a7nq$?q_z#V>uO2=*T`vA{w=wtT$#Ifr16&qs_9XYb*pH`j%^#DoQ(HM#Cwh$C zBumH1Ub$i0g})n}1)e>ugw)FHdEtpo*~MpWm8C9U>f6rVnG>1JVP&#^@v=FX*^xRT zVy|JzKHT&cVV$Z0v}85zY1P?^Kx|ShbtX=aXpCQaE1mi08DAq2$<V zA*aG|%8mA}nVhzWhST>q2g9jf?q^@v$A=LyWp*_`_xEzrcYRy2`V8m}2r=&15x;Fp zkfGaOeEf-Lv~j3$|9R>4DHD^m5fhjavP2Slcm-)|iU@Y34AhiR#AKaGjvpx?%95n? z<)1=VEHOEm@{Up-gVm>)o7aSm7c|{EWE-SnbSm5?_y{Sp z@Q_@Y-;2iUw9sM{FO<|6Vb^-vSNDM*9x;Dka?LfZB4jyEnAU9FYP3#as-qGg*=#i{ zIW)?`fVr^9pBEbqVx{ZwMu$b+A0zH8Fk`17^qh+2W<@en(HK3>=6!hkxAQML=5XuzcE{Ocz6lC~4X zh9A!4vac44VVL@@Tc@Tb?;mIHF5#N@U-p*~YzTE8KZiLIo>+plhKeLB?Wvg^`=HcJ z6Z9m?ivILKMYWw|+_2#_-}?7_#z9=Z;KW|-7`8*pR!Ds3D5kS?sbEGJLJQ6jXIiQ)%J_{i zXs?qo*j!$sm3$S(5homDzL?fK+A?R1AIECz=)qEFOW4u3<81jNb8=*9u+DCF)(_32cf2W?>)SJM?5}*z?sk#Xp0Ja+oF+@~yHsrJ?gwD+I0S!6@@w?61wB?~1vr6Y`=}|o? z&xs{tL)=Bz4|kVOxM)MdxDMyJqhN%HHA@OoBwhoOZZjC2;9cL_C3|&c<9$L+D|%SG zRu%#2an)TL$wR?Rf&=Q2(}F%9X=Yfwmu$hy+MXU&I8#LZ8Y4P4%4na3rVY?Q8R3}2 zEdc9Q-L|04B|Xwo^TxspEwffo_%$TYG717`JJto!V>#~#-HqH3#QT$lG-eM=9mIE4 zaB|$Cjywl-$M%f1e)I6@)K^Eld5bakWczlBU=C=|qyU84Qm#7vK&TzVS*YaDUek}M z&0?dULpFq}p95Lp)BNpYrU-F26KB4@7{}N&?Jjm0-G$712?c=QJa}{VHJq z4hwmJ_1f4fH$Wt5US{>N6Z~NAqHaWtus+Lt{+@tzc}D|VP7K=Z2~s!u$uCI;Mbz^| z<;mHvOZ?!cPMWWbj5ODIcbN8}@wGE2AU!BbS;=v&d|dQfI)M+UrwGVU>&B6L^cS;4 z7Q#19XS_VqmP`gOqZXkRo*j{#t#a6OLNFf+z5a5yee$MzyTaI%I1U>}`T|2`rluF1 zuL4Z`#iV&jp{9_*>P=fO7lzW?rbkpMidBZMAZdcnqi+(kv_^Hw1idm%C7TqLwB>Id z%vCaW2TA(@34()Y6_7(uJe`p51&>9sa|WkvYqDpDqWK>PIno{6ccspxN?g?4`T2ZC zx`LNia{U1VhdpQ5(t!?S44ZCSmNwS6ihYbXdeIeGC3!lYZ3j1hoAsS6~iGXG(h8 zq-DTufC@xZH#Ib?MMQPAuODcs8b-Ib5sY?bVRXLa)}i--(yY8}ZZo=4?xa}*WPl$&Jg~Rf zL}}CQTfAS$F$2xoi?g8%CCONfyd-@7bXOCB-Hz%;AnTLb1>Su|?RQ+cx7H0nIpEY$ zUpzZ_$yHK$Ipn5dlOTA0ORF)MD@6Ga!l+rwV;pXlRpmE)UiQ`Z2Y=14o`ydq_C1~EeOJj+SzxGx2vj2iE!4)r#CK2CeWFcy#J zcJOABCr#VX76ZUYy5fnQ^SjL^UfiBxPS^ju2xVZ7%%D~tIRkGIhbnleV}KPdu(D8Kcp z5{sOW9n<+$S4R9vb@F+_?S-`K2#S5phwE*%z8pkW^wzY!vZdbp3ZG;@$FV3;?Q+cz zLNB6@1I4bVI6*5qYmPONs~i(Jx256;->N@f8HaVsfV@>leAS%rlwWbaUJNa}4nemW zb!%vT-`TO?@iHpS{=keO&Vp|QpLq0KA3%J=))W;p#pxPpz$x{AI%cZUE z-hFDtlFJi2{iz|dYI@+FxlDI6M}lt5C>!O(BKpue6#$3a>sS*(pIzS#%TeBU!b58k zILvBKU0s@6Ph>9Y>N!aH;&Q0f@U(oyJ4)gS9!}J}$k#m|yZ*{s+^tK&fZRw<-%B>7*&m)#>T+1 zCU5k>p{vyd4N@77J(6-vDs5m*TGvWw!W4@4R%=A$YvU|dJWt5=vnIzD93~YQyT%%1 zyd-C2xW`2zF(85bD79g)L%l9{&aFz7I*8o6K$1{uEVJ7|1K(+S(~<0Gd7R{6+~p<_ zZm4Y7s-l}s7bPr@P#LZdt44fR$bu$@vB@nQXrRzHuf2kATSTdN)-dQw`EsA3!>B_G zHDib@6D?LsnYnSSOD%t>!n>gSy?36MI;9Hk+IBx`B@PXtKNn&#!7};UhpkM)sS81V z_UWX?u-6Kb4D3>5;3fK5ehtS0f0(jN?a8>x{x6Zn)0^solCc3i-HkrINo^lzFL^$) z#74SU@va7;MTGOWr(_SS2!%*78ig4$Ho>zhxGku>m6&Kv;n!g@@0AFDrUl^KH8sOI z4Q5+8d%=4O`(@O$htA%&6Dk{oEzk2RV9yQTy5$}doU;+|j;aK5GN9ecLd?+mw0Omr zcGGn%Z(m+qg6zc)Nzr}TeS+8?iG_MO+F`YDD*^b-vXoIF!5HHP`Fg&z3zrr5va(^a zLZbNKY2An7hLIlg@o%2hP@<)mVrbBc$PD^9zJh2SI)wOAy;-Rtj0hRo@cp|Y)(LAn zOWXDldk6?t=QncjxYylmNNVdSz(}c|nsZO-HB&6@tEAbI$$@9_1)HZfQ8_!6M7POu zi@VNx9SS=g)lcTYM%#AV`+LU>LumPTQyPW$7 zhzlCD_q`IdwBLlzeGPfted`%J#%MKc=UC9U!R9pb{=@ep$+JnP)o(O2ZQ7`j4-;4& zaglPn$_RSf1C@v0N-MRjvfl5i@V1}x`dvjhcX#qu)bA)XB5!r^H4-y_0NJ^(v*f-z zJMPLOx;S%6y`Ut$vN4#98~btUJQZxbJw)p-3t9FFD}wbcG7NHx38hrXO1*pNx&zzI zGu>(E1-?BXR*F0g|CC3{9%RK>f733W=l1GVtuamo~BSyzzN84TNUTgTQ8*<*YV#uMo+V9M+E z5SI8;%G*+giEX%TS5_8DXZk$^M?CsED--!RrEW}N%P{N&1d>udi^OEEk2)8Jx+bv7 zlLu($vD)vMw@YhKQL2E%1dP#fI@dV%Yoeh^G^^iJ0vVe5tPs-0m&<7W1zd!E#afz% zqS({1!aafRr#^)yeq5#UzFE>plXjSO=N@8KLC=lHf4=*+>?wao!0O-wZW*9E$7Ki& z(5x?1;M!F(cwbV0J={(B1V)e|@J8b#uD&`LEcrQy(f5H>T)Rh8X$eMS8pbg+4kh}c z+(P`hK$^H(L@zytDh9!X&lZ}Wmw@+G|D2cT%FbSFOZfe}%pXEAZ`~w5uA8Q?=?FR} z^X0d{Nu|3nEZf+xKd$nATfM2P85S;96csbL-lmm85XJBgZal2Ix{U6YJu=DC^LaY4 zVuhCr#%nEO!z17?l}7d*iH~u3D)FGI?zcKsdPzdu z7(-%3rSoXex@*R`ue2JIiKBfdqlE;lXvN@XqBY85!tXv_;Jc`PS~6OCnPi@qGT-40 z6X<_%db}pTzk!!X7?3QDO@znad6m~YRTj{)dnl+qEzjI=Z?V=T1DONggzhQRh9w_~ zg-vF<#hJdr{k}s@wbw~*-F{V--BnXzGFAs+LXVatOjOPYTgm02-wK;$LLVyN+3Paa zhpywM7MoX;!}`muq%D>xPgf@3!mhNLk2;o%nh52^1(;GA;*^*Kc^M~@b`oTc;?J5J zeO!2^C>!rO*_(>Sl-=1<2oS?QimvZz<)+T`zpK?JsM=Vkb&=2N5#%0AOQBQKSgwtMK|uK4)K!aiBAEV+;SVHgp^#>;4KDEumn@fuY%-QLmI<8v70gx{%6_1+$G zUE_SnHdBx*`i+)$=FsEQ>ddo8+bN-tL*Z|X7YNwmWWxTg_g>mZUW=C7Yef=wl@Rz% zdZU<&-dJMzuvkE1s5HNvk%@~bo7vE5Zmciu%~Wc8Z#>(6#6+7Bjk92+HyC$N?xiXD z>!Emm6wLaRX8M!_^CI=&tj_U?k?9s!cW2if%gRKJ`$KEe6v}*pPiYoL{Z~(eRnKhw zlnu?gTsnD$W{(&1RW9Q2Q-0h<&tp80jF~AL#WV4mtb@Qm!w8LOTjMXedt5JC$qd#S zMj_t?r}i!-g@t^Rxnaq^v8j3|A)AQ@k=FF*(>uhUd9ThD&r^JTZkxqmDH&wLapbf_k!gGx~Z+;Y{Pr-Gyc4ox@wBR@sjx* z>%@TIYdiCD#+da#?|d9KG&BF1AIQt~6!Ge(n9bvOB2eFGy8(6OMy<6Y@A*+6kZC zF6!@L^zVO@uj8FJO0F(V*3U&-&YiU9|bqJIQ_b? z23m*h^OQ9pT6-$KgZwUJmFkNDwgVo1|AfKqWtz{ySn*^- zGeRMegpKm!raR@|8$C5d5>8;Baz!YDIt`S0^INm}VRz*DE| z4bYN07-KGOr@peWGLuY8OyWav5|pgW1czPwhtCJ~6qlO}ei%$wzov7XlK`FfCri^5 zL4Z1ZQ+URa4btiF&-4`kCLv;>={;szKt$gvN*YKP5lMN*c`61CP#jcPPrsWK0OZzv z=U2B@Zy-Yt z6O|4s=r{H7_bIdBo14asJ;vv#Q)~;Q0O9Jt@A5&ed36p2Yf0v}R7w_evjMu@;Ww2> z_#%W~JR<+&A<&>}u`ePzy^@_pRyel!CZ|4W;{u02CrPd32IwF`U;?)}hhUXpJjc9G z^WGR7Z^w=L0r&{&=MDson_d_4fTsF)7SR_SP>Oe`f*US>i62wLI>!8{C4K`1{JZ(* z?byhH;kzb=>I(kBts+Eyj3Xy-r<(o`OdiZ}NDLoA2a8MKT5JV=s`*xCO$k-|0J(*_ z#a~cMVsNW>*r<=Px@5luuz)KFqp7C4qd0EkcQ)aF*3=LQcF-_e4KMZADv+{b>60-InmIgZ>$wS__n@n3Cm7u6Q6c~NR8 z(hSq}Y%5e-B!F|Chd13~O@b6Fi5;nP0JLR(UZVCNwHxpb6t`GSl|3E&e@_ZD1tFT^ zKY(_BhyVTsDSv~i!C+OYL=Z-c?1e5)`6<$;^t>aqwZ#tJL6*SaWpcerHnw< zHw#7qN?HUP8&G|+{-FAxu7BqmC>eUzMr<&uhl7;h0~GHa25>`Cj$#w$`vT<;mON%F zP>tsIN28%ASK#PXE_Fiq3iw61Q}rQevoREu@>8!!(hT6=2kKyVqj>lOvL2#;89vJA zQomO{)CT9Ee3b*-MgZJ~nKM>^1>}-O=I02hg4X)aP5M$LcmW(zq`18G#ym*JzTxz2 zG*!q$Su9-Xt)1+5ASi-^65^=^5)Z8w5!^Np?FMA;lcHcbjKHRxm}iyzK!*E^H^w(u zft89{q@&Cl_469m{2pcs;HDZA0La$1QB=l5IYA=kIEIHVb3QrP3Z#l#Q3^Q#nr-F* zUYwINXS)H$=3yLo1m5)rOWCI2rjXnyROC`vvNC8KEhIg$^h zTx#8uz$Yqd*EFvDrzQQ_AO1EhGk0Ll?`Zyd8^;5-(Y9cZ)7Ad<-7HVgw>dn>JGE62 z;PZbYZt;(S^?zIubzOjU{ojpO|7gB3l+MC-xX>>MaKFKO%8yZ~{qwD=-<|J2z6jbJ z1^KiBh3kXo-K<9`5JZ%FaQx|}e{`C^d($bN+tu)3rg8QYy%$k)U@-4(20eP<~Iv*Zv_ugv9n8V~sXA_Vt|l zJ+A%b@W0OkLmT#A*i~cHd`odcJn`QayA3MnYpKe?VC-+Pf@APJHG^8uK@ad>4ue2( zQ)O8|;WXe=StuOlN1TTRe~vEysHH-%a&Mj@wZEc_gY;#-jh>JO$H$ZQzlW`Vd=bU_GK6q+Jv`-d7_ zKmgkL$p0Thr6o+3_I*|hI9eK5S}6j|5PWR{1pLp)x-vM3tmD+tP|N#QCCYY#3V&5B+mlS)-7N4be1r)!{r@n9KMkn_ zWq|1hbK4A*6HgUQ!XRLtk&~RD^6z`cp@uSpfCPRq@LG|JG+z}s(f_oC-xgsA28Ido z_l?sEfX*AbmadCGhkW_Yzou5B*mi{&8rR4vb*4@9YVnS~YU+ zt62f;BvD5m{NLu7fP#B;-^h#XMnbqO-?9PV<~xjkKMHI}9GKtNl%sF7V3qY?DY2{E z%8WT&HSFJx%|;2n8Aqx@84o7qpLKO!qg?2}o&$CGU!W#Vqiy+Y7Ko||FRyu0d9KbQ+FWszv*nx0%RrR zgM9&I{s|F<$P=U8dU4x3uCKw zF{T>UtJ0s3(zAf%lBDFXivx2YVt^0WemE$uZ#=6ut+zes3N{xWto;25YN#%6>H58p zB~`3f*(3=ezeNW8SY@X#069h)AXK@{frydgjnJS!mcICy6hwVPW;xeRCT-~=mP`P` zg*!YI?4;qxdf@!0#CE?|3}^NtV6x1yy|Dz=BI4Hh31rG0^k&yr@{2QFDcwAlu@SLfwJoUzv3%{NHm z;`INTebW#*Q+C}kx1t|$nr-mL>jJMu@#P!6ny?vbd&4fQ>1_#Fu0K^)+luX5}Jxo$m+=xdFKYwI-#_+sHvTjek5~Vmk;v+R_Kbi%%w1H&`dY~6kU-kqe2er=ZaZ+C zS`k??>;ecb_mXe-gj<>sVI(6$>!ER%Mw4p4=0+O6%`sEIo*x0V6n? zUegl}%84>&(;q&7((utIq5cQ>d<)+;J^$Ym!aJzljGV5oYqh9~>$_#GC{V5x{Ip1{1jE9(Dwr)|DJ!bq4s5T ztQ_3Is`(bFO;ja}Qa`u#p57D-s0?B8?FnY^0Gt-mZJ zD+fFur=jyV4UjS_V!vr*0FF^O;7hP5DbG~<_}UxTv`roRm%ry2N1(R!clP_4p8|<9 zvoSeWVBE>XDl~7%z^M*8k<|l1R%Rs;4^sY=6$AnasC1%mG9!_AZpsPGDe(tn;FwGP z?70leU<*b{ZA`$1mBACW>c9L$_7j+ofBop=)}3x;#zWx|n+95S1yeWl?R9XfA&F&) zAOot0y8oXZibD+)IOqC!zm+6IfX3Gcm1dx2D_o4?RRgg-+)z3{FMYq$<+fUv z#T$d~tjy*S9)b9%B{868|Lu(kSv24gcrOe;D1Z*T1l~Ci(_7=|_HF&jU^Vd%PktKF z{Nv*eZR4-YolpRVm^04~Cc6RlAaILH>mMacdb@go59yA9Ui-N(5`c*>*2%twEN3pb z(t-V*nPr8IdY#qx1IVM3{k!*W{5c3_8G@S@-8Yd^Edip86O>w_eivR6EpxxFPIghM zJSfdF^DyRDIGiO_y82Gvj#{_G-nW6RHL{idblU?Y>8YH}uACWaUN8@+@4_tsGZYkE z(kJS?pGd&AqB16q2e!^W0NV#W__T4~97vNA@HXtqd;KB*z>)FbCYim<2wSC^KzY}# zEXxn_W?&-|h$A`8N^WXA|CTrF+K<8#qgc^5r=NT*F($uAXOrI$`!%q5HxH7h`RwO> zXq(KhQ|$;>6yuUu&(!yb@9B@3R%Tm9;VMOK$-N*K6cP7fMiTPU{1-?Dnlg$(Nf@Pv z93xx}yq6QV=W2r>FET#V0${kylb`sJROQFB(;Zra>B`0qCm;@WJ8pBpPf=CW zfq3;3(aI-*G3k+&jw7!s@$GG^XYZ~%NMMs!ZU)*$9X1sA8!`Gx-L5}=J=r9|ob&$A zu|f9tIOCQ-2nG?OJqD=PwNGm~5v>4+`6OL8Mqoh>$TWHq&`EE$u|P%%MileH4~L-3 zJ_x|~6>VPnhT3}6(>D+150%o@UfYVJ)8_1ySkH@Z1(7;2p zTp!&IkS1eyX#_I>HftI|UUU=%;OCF0O%9=p^{W1bJ1Rvqo)ax(l#>8oukj<&l+7D0 zHj@5{Qn_vZZ70gE+ZxK}BkH_20X#9O8Y3^o!3BWYg+&%n_{LX8uHD6X%U37BD+RW| zoa?L7EI?G7kL0Ox-|Tpk&cIuc@$AvhZf!rJCk=Z_4&zV2&7Fa?EGAjdq(j*!rRWr% zOf73UE@Lwd3A~-T%O6jViR|9yzY<`;eVF+)?l>t)&PQCz|Ht)_B{XJ?RLn0g`wRVN z3L*@55tVe?f>W2@PE<|(S-Rts;*Uk z#6kHOv(S56$F;W`+#FH`-LwXeQ@%;Bu3z>$JzaHw@IZ=G>r2z@NePezeJ2W(wQjV3 z0O+#14j}E3Cd{$+9tGxdX@@G40O7(k{};FK)`ABZ5e;(o1frJ(ZH5~HDE-D!tm`~8 zk6X=xFAHQY*}vTUC4G4~8gXCGgxSDKyM4d#AyS?Y$oBlwM`=%MYOs^%Kz1x6gTyRX z!0ID8$bd&!|BQLUz4ze4uarWx2{YASy7-tjLvWlbi_R_5Zu4}`GVG~G32~8L%_pLs zxzS#q+;R6$+UP{FFEE*gl+eQi9E+<}2i{wl{dzG6%)0}C-VMt6d_ZSsx&@RTy2UYD zwt(ubM#OG`^wHZ~o{*)y9}7=mb^cz*Z5?zw7nVdA241G17wD+pES`R!Du9j?e?;E! z{dxyjIX%1p0_)sg^(~`@iS=ActoR$h8aj{yUD=osSVR2v0E_SNM}xL35waruvDbwy zv~c`u^G7m)*$i3$EdtJ0#-5X>KL#};0wNW0EcJ^jpaJ>RmLo3-B=u+ZIwiutWY#~c z*yrGU`i){unTF3qdXaKa#c~8#RMO{|CyVBdKb2>!G%OZ_?`FNlYZn>$IkPJLpkdQ^ zN3DWZ<}jNefB*jIkKln738`6JCMkv$bk9i{&~Un3?|+(pJh&E z?vm7UrfudJ&AD8P38CSz{0F2nJPqGlEfN9g`T){?$ujjc<9#o0lVm?e#^shR>xUD? zH+|2ubdP+IGH2|xn5j;Ur;_s|I8fP4bK)1$x+m?P`)xL>fbXuSkuF@;yKmKB!lLIU z&5VYtB8yJ6Mu67QeC142c#jk#wMdKQGn6y(rwBthznpcPdYUX|kd=YRg1n?jWctLn z&KohDBU(>{7TYNz2VKdtRU*73mqNotA{=MN2oJv+x%DR$IHTc@n{c5ORX|R+K)Sp3 zlc&$ODwOwtAUZ#HXPL2WL1C=?d*oWlc|j51D++vTWG}9oxsBt>le&(wtjy zt23NRg*ELbaNUV9Bz^fBNORcO)KzQE=CssvV-%bdT~^%ppat zyd+}K3G{3W27}M^Zp9<45quMx&0U=>gFY*Q-HKj-Uaj>iCQ=zWh+=c+lBJTH`s~?F zow6u?czV=IhkRMFBhqxL>FVYOL{c)^iHyq4!@I&d=(9-)?aK?5Vz;ZM4&y?*8X3jKfax5w_~<5F1#x$gF{(?j|$QyeR zJzHra>-!0ak9KlYp9El;eA@xh%Sekb=A^aPnZdbV`+_l<=s_!H`D2n`oOgPf>FPlq zmvUGN4CKTpu7Q3YIfIpwwQwA=eCNxVWkZL1a^29xR~H+`IFH>M-iqM zFas=DUIor)$H(jWNm`lrgVD5F8!nHh;~!EI`;f&KmDC$ntVJqz_HW5tUB$SjU)j0h zs_F6PZw~mL%q6jGa-HFt&;=U*hzqr*f70kOp{#$S!p;_bP;iM^+c6H~H zr}@iOfK2unL-OEQ+1U!oJT4Tvc(l9dQ*8?<+Z?T?iv{M&14!htmZTiqrQKzr`aBLaem)X)@^-ld$) zeLwf}yytz-H^%w>jq}g3F>9~2_FD6rYp!`+)49fZTvj z7{Af5`oReuaaZ~cDgLGLD%i|V2uFb%k8L-{jEtGAs1RFX5+n?i-(llIaWIwXc8`>6 z=Q#!Aqx+=K)Q};M{d&z7&FC7Jdn#iEvYs80CqH{*G@J%N5U@-7Bmg^iARtFEAW9`; z*$ot&KrxevwiP_IBBwe!b- z*J}{By={76-+a8M$KpevN4pz~uiD(=5hAORw4Uv6%k$wr`P3el6X&Izu7boK>^j7< z@JTkKts>})nuoOAh)bU_X9Yq;ES69uR;#PgP+x%ABYfuLR?>-%%XxDN** z$)MmV_4^V*8*xkZ_V57D(fB`wr$w~S?$-^($b*qCuul?Wye9_GpcD%3~%lD~jzIDsR z&<06l#!foDyyUYzBr|Tz>?!gWWErsBq;r1u<6L3LqFm#ETMU6og!|KT&)*S z2@l4Aa&)N_+06hX0rW|deIJw5wu55QOK{(7`>9%LpRMhcf&bbkNsq2t?70|xYhJD#dJ zn%w514R^FCY#FD@lo?8xXfH{1Pu$pO+!_#NxW4_FwAXwZc(L8$^zduNUgTXSfL7SS zPtm1Wk(D`U7w~1Ghe-z1$Zp|l?O{AG)NymQJrcUo1Z_tva#cQdyYKG0(G|t$jAJOR zivMj*Pn^EHv6ohOWZOgjo2&p8GEmK1&wIFG8xy)Q>9#X+ui|~YT))rdK+GC+{BiBa zJiY;UjXAV#mDG+oXn=xLvKP-Y(9-IDA&b zm!g4rNXZdralV22A{F2@1sp1G>^XF%)3R^M*@i2D*Jd7{C@-a4({X6t9@2|z28zSI zWQ481?e5I8u6+Go7k!)sJVQ=KRH`wbc1C7-SWOyn+;|K)*G4~=idAI32fY0!$C7TbdEvPvTaQ_-vs=cSBM!KDeWKA&qp@37P>#q zCVZttb{ql;Au41n0!2_cV-NN1JhYW(#wDbC_BQUbo!WaqgSsq|JkHsCEW1Uj8@<`X zuOMh1&E;_e;FkpO9T(n~Fnu9;@H_|=Z{^qq&yL}ty+QHe5f`suEaI|h0QP3vt>h=* zjT83)<@8GNyhMt8}CSl z@*V=E;TwDb>z2FO{j)5+;`>OqR5B$!tvD&2m=Tw_u_hy4+OV;{MX7zRSIn@ze4s2m zSPL?r^4t||HKpYz7$FLIfd7W>ZrfJ@2SO&TVQI9~h(0XZ3@8n?=y>|^rcR)@t*QYk zBzW?)`UzUnoq%C`3dB1qh-my_4c>+er1!oK@CmywgK@EP7Ko|#*V#)0%BM#pKAwXc zhk2Tc(I@eVI%TehpMOOUwXvOlyz;tEyz8u>be;wSlo!6P6eR2^P6gK@pfu^Q_nH?+ zbbPJS$n+wt0orObxc@R=W2zgY{(#J59lhLmKE^Gf+Qbg zd1MGX8OYD7kIt!cqd*xr(P*!b8Dlo^SvN0y{BmqNC2fl4jsIp2rxJ6ao+UFTdkB(T z3taOb_OWC}^{g2zr~gTmBVqVAYc`1XitRp3Z5%j0Cc9T9EG`u87g8d;Tc9dt#Z8Xk z+psCsQ_^)%^fo00&aHdt0frwl?i>$$k@6Lcc^N$3tpF68+4i66%!4r;x8~;~e*~@t zS}y;w_Tz~@ANX@$qRc>f6SJ5=ZK7eTuNF!^)OKA8^#biiwX2y$sQ3Wm3L%S9!7rGhm z^Su|0ra=14UN?`|jz{tw%}{GIE~_U0dQzmLWHAhR4^*Y*CrEuVc3o6-i+{p&MZ~ip zSn2uH3+Y8i=LzPLa~A30$oa{&%bl$`Wpx@H&kyoE2Xwe0eKg&k>1-Q&b`t)k@(4;9 zk#f&#M)3*IRc&xtRjtst(C_OMmNJ%ImNiNejDhfgUcfdU+amjq8{?1{aTzkLd5Ota z4`5IFbiO5nV3G`Z>f7ZBo?sSsKe+O?#F*4x_+#gr(z~}R0zeEj(h=L6-RyDnkU@kBpa>Hyi4KX3w30{S^Ax9oI)8Vo#VGPp zF{iCBnzLMJ#GuboJ2Sy4#Wsyv@%!1)4u4Hanc0_mwGdWPSs<47m2lV`-KBO`; z6m>}WS&L3Wd)jtG27R7Ye;E^sTjzdPCGrOrCxMUz z(_*o984r(Bd5_?V$M zLFoqOd_?jQda(QDM+AlG3-k!rEY(oC_JMskz3dH02f`b-Nqm%uONb+0UQ<_z5J1D? zJRvpl(xqO&ek(_X#HWBbd9E)%C%&refA?ax#2G zQ20lv5Maw0H=zMW9)p5@iQZ2DUBR*s>R8hCfX8rto9;T`q)@*0bgJFw=e?%Qj4y9= z*!5mP$=#ePT+*m1JQ2><{GNX66f--T?NDY#6`+4=3NsuUU~J|oVF~@J<03ebZrWo= zrN%h(@iQE4t0MxL{6vjH6O7(U>Q@=RS~a70%6C0NX|od*^11U}D-~zy0hOOkeCb5I z-L_N2%ef?FrJdfjfF*@3d<$PlYs8^#0PU(|83R*3n7rEzSh%+hw@eftef1 z4-F&EaiC{>+vJb)+{2!tZ&S6#(~|{7xA;u?EtQ1>nz9GE9z>LyA4sp|INl|lNtG^2 zvK8P2GH);!r_kRUXDUH+32Gn1cyDLg7Mr`)!hfXL54CRQY)USsaC^1xgQR7wIYi-H zWHzFl3Z?4)zU`b-$uf{1S)hhmyK&h)o8MjdfbYNS%H$t%cWNa5y}pVd^7$;dr? z{-&FytMLNaJif7V&3yo8QnXm4L1?ypeO8rLorUh(i3qv!zg*Zbd_fm($|cd z{(w>Yt7QhmLSro@!MsN<*b^#ZO>aM2HB&AV5&UY*S-lj-h^pUEIJ~R|;dH|9+^)tL zVnR^0#?6ZCHs|0Mkm5hhBIb(vKP!Wy##9sz($j96X-bwpj&u@g#JzYY@gh%bP&~H$?09BH0%B1@pIjXZ?f|i< zSL$7{thh!RQ7%Cg!i3br{!*V6=W5NK(`~1J!KRgS0P7GuQfZmtjW)$#`3f3NC3Vz+ z=s-IO7UP>CI@POog#p|Or&{5TP@+%~+(pP_;}=!Cbz-}bwDjVFv-T~-!vPDenKuYfdE3uyO5hN^2^-#`p>$UJF|4px;jXdAyRgl)`v3|@V1e$-b$ z-46%Ne|yaRl0aAG!Qb(9n>DFgcrGyGO=sD{cwUXs02`r)(p}^ZHoL44yRT{9b}?Gh zGw4O9#!7UgM4${og&+%Qfo*FylO9)9{yd7rW}?xNMmbHy-Oc(u3L58Y2o*qdHtH~rXlue{9Qjy7+<07Mv%GW!8} zKm$MlNG9erG%Cv_xrq&ZyH>QSV&9ODfyYIOhI8SVG3z+zP)JOJd&1wwCSiJmn}U7f zVs@>l)(x!O@{|`^7VmxlVr3l+$A*cko-AS6?_6K z^qt2xE?vs?FO8Gj9X>sF#BGTyR1Cjh(&jtT3b>c1eJF+&-0)^1-@5&}GM$N=DafIL zaHDkX9#K6)5P!>6Zd1HN1jTD^oQU}f{b@tgc`(THKCtzDHz~&hhG@%iPk_c_izV6Nq9;Yt8VeH+tvvRgKL6?e?^-@Prx_neldOx)xC?v29I1Ejvy4iHv=27SozC+>~9C$rhbS-IJIdsxQfSZ9f@3$T1fes=u5qT!XQr z&dq-SVaK0O^0J~<==s%_rtBTb7X?jgUnX(rX$ihXnMzs{!-^827=PA=tzYJ8GI1}D zE=>+CTlPQOlmy=}XO9Ys;^vwYBS3NKA%!CO1MJ z_oz+k4Gl6GM^&dRBaGd*eoH1QI59i~Qz?^-(WGT>qp)E%G4TKRq?%APOu8uOY~|*0 z&BPxuYNKz}cpo?wr>=;L=(Neax0)D z5Jp8Z(Q#H-rWKW_T6V{2zF2-ZsS`}^eqlqns+sgha!PYDRnX4LP~|$`ldT7_m`^?r z?q+M{*?69ddy3d?H^^?%3MNqxR^L`o2hD%+XiHkpSIUHf7$bZRIc*r=OviQXwAEnD zSl7IN)3|rc%g%CsPpXJl*iw3A^5$b{r(FKFNGOyVLqIV_JMi{wsNZKY;hhF+xM@mi z{7_qehI0_1dWejAuDpQeH7Si}!oAs>b(67+Z6d ziG!(L@)2y&9B7&xTBj6tjYo!8D$G%wx5Oj#JLDI2-P?S>XudNPrk#^ObBDo4gYl8l zLh;}$>7nki??b@-R3I1DUhRpeOrRXkRO$|k#SFje9SXQq`@GJPoL$|?VexNtiRw2M zXI>jTfA5zOLJ<`if}X*C*$zm*jdW9*@$$PuQ1M>Q!Q3UPaNFOCvOAY119?Y5HxRBk zz$cT=qAd88Lc?D6S&WT1Rn2n%GTtZ>ykCkJ=!n+Q*=}~KT`}Zb^z;63O|mp?g?HfX zO|*48nq#kO!!U(*HdK>dVFhLIgk{~MS4FTMb&2;zgp>8B=UJ3`r;om-Q|GrN$Q~6x zp>M4CrR~Xh`NakD9b$`L%ylg~#Jko7y*-JltKjqQdu=0CBFJPcdELa*-WSj=xGbTC zwWaAuk)7OB82vH)yRA^lWyo`UV)f}>wCt%};;6K)qd(&FKr3f-c=vvAzv&L~(Z+&pz!Zs&tp?uO@I z*O%GmfCHb_+mP}2Hr+4FcRN7e*6pOAw3i4ixGMGRJ|=&V-n9r#2+sk3W~8jb7$S4m zZ$atO16jaJ1#D{5FDvPdQZcM>i*8Ap*SW&ElQuF4Q%d6!ZT7NlhK?Yu`6_)D!IjM7 zE*;@FrCxc!2G7+|vDYWS5@RF}t>fBXBmv^yrXHto?l0-OeJ$n0mSaG{&vsU8`XQ`? zES2bxhUO(Z{;<-Y&?}n>?Lsp;J`!@` zHqr)6Cs-^+m0O=QdM9GQxL#i>W6)Q_3H|Qi)kir?0z>?}mtgE_>20Lf2{z-v;nhvu zS@ZMEABtY3aZVEBv^we=tZFcbsfG_h?ZqVYKJ}}dB=u;m2t_fgG&aEXZNID@3A6^1 z?b{eX_gf6jX5szQj)(>{Kq(a7U@E))yV!G|;Nv?~k=tTb_29&@naU4~w@eT=I6N^H zQIAN%gx1;+a;|$%^TlL?dYDdAcQp#F)Qj1XU}H{NH40goX)9)-?}_)ks|Y{TK|qC{ zr$ND(&~%pG7B`9VQ<(fNn&ZaP2ws(&>T-7Bl8EVLWf(ywCcUMvYEc$!1lJ$7s%;gSzH&Cb}O3z46D!LbD!# zeceFGhlxT|R8CWx{wnD zjMH~eLoSmk{KneU-)xi=YvJj5=k_FL+DxX>wS8E(?j1D`f5*`Cg|L+H(8UiKzwdW& z`TPBxde_>)DNva(0bD2v(-I8hMy5PAf_-2pTy~tgJZb*H6uWrlw(=p8Rxv_MjiGTT zxlXV$>lHqu>a=H?W$i+pMwL1=jZ|wq)rZd7%kyoE5t;hw8%N~7lbIQUdCC>m!q|2( z4h6}j=618H*?oCm%~}AmVf2mHnv1LVG9zu3+)*ftB;VrY1uZKzjpYT>2}YgWL>J{~ z{jEKW%ZUiSnAYnq!at`4g{Ud=P>b-MSUmk%)-7L=@YOapbiMe}Tcp+lcQD0H6sN7T z$wpvo*_f_qb$U}XcDckr>$)ZV<&HpT;jE*u`xg$c^C;vM1T+Z z9`d4-bVRp*nnV-kxy=>GjhVMiUIE2H~j4lMpW zxIJ^XO)=3u&AU}Dx+Nh))CSc2oXfq)m|&K$%jt+S4x^QrfbR+%#AFZP0YQ@I&fRG? z{GS9(W(I}8hhr0VL3=5T!KL^k`>cwm?FrX*LZuS0edW`WK5K!*z`cP4WOuf%zFMQ! zv;Bfcb5Mr@0pOMuQ3V|T*hin4Vm8a5W6eE31gWIDZQ43kud|4lPrB_{gTb$TJ zt5?Z1;b)%}SNC#@i+w2HumT!Z`xt`HgVq>u)SeXGx?xrkUs<=Ab`Jp&6Vu;}YZ|YG zVrHUHkj&70HTGoc2r&vVNIBuH4Wj!G@4}3l@Z^)X25ELQadUFc{0u(6i{k?b?EV~> zoNP2nh)SzZMS~jB1A;j_OGbeQ(nJ2B`mk;TV!z#Hwa%gS(Oc)(>kQGnC4H_E-^5JG zVB9GdviB@{pmwiM6xdzrsr4=n+4X5iwh$FeV-g~wG+613qujG_dAKZlsOa|($pt_( z&pQ;8T6nI1k9kd-wVjL}DMM@&TRB%uv!_Q9mmo9YaHntP1f&pZ$ExNLz;46QSq@bb zBcp{p&_PJN{z$rpSYjFgtL)QN-kAz76GqY<6eM~Rmq11!7ySLr<9I#ffjXTA)*r~H z%b7BDiQ6_dU!&nm4GxBvShw;ZPhL^~`TU7dZaswmvyE8C;;e54%`ilSHVnMb(sp&+ zn` z2Xbstp!S6F_?@QKlr{l`R2lvtGdHbF)I}OC+m=yN<{rQwBnCg!u~cx}=4C%TPX-Tr zOt>2lOumCOKF*W((r^DpEON3L`BD9^%(iEOMQ15m=k<+%Q(ngSU4WkV1X(N(#FBKnz81b6*@YSjEpN& zHIJezEId*p?^Ab!X)=pha<>D%=1ECcp#FZ&%-gZwUbFNp8k7iMAlK)sl7U|U8F08< zZZq{_394lcylfxaw-r_k7Ny+T=^e{??AsokAs#az&VJ~WZeoL?$utqS<2^olbf3<) zY5=IG^iv)PU(-|st$dkp(=D{CYRwR{4CxF5Z$u(vaN&On-V!~v#AZ+tqip0HY2bb^ z2ezkmGfq=BF0g~2pbGh6Ex;1zrp7MmO}eEo9BD|R9u-U9d(*I{+h&Y+N*uYMM$t!X zd2~E~s?Dkzq86Wh)yagJ+SEDPiz7JND(qYcZ(AFeYy5%ByC7gqgJoUEso*RnMuf;x z%UR|);jj=gy`~CqE4Tn`=k|>tFUimWAHZA*Xuiql96$IFixv=5TJi%T>tam};4!%; z6dO@^*P{Xhq8FIHPM9jA}^s zrxR!$b8TKZNm}2()QFjy$z9Npg&|bXp*^X&YB($sedc$hXia8RSx5f1oWsgj*Nq)S@dyR29M=p;2L4a{h zP`gv8VtX_)#t%Ym&zlUZ-MviJG5gTj_p=hVC$ZmXoMVoMba9Sxi>Z+>73zCmgsSNk zoJuN-lPTUh{H_ojX;Rtu9O?vjp}2vd$9dcKwV+vsD%3t6=beHby}1}Za`1Oz8NwIvt!bMWActJSRJ+x&uh6^-Z|hesu()fS zn-IeitoJxJ=;I>fx+N!!z|-03QiFDN94pFI2WJt6?1n5!cUxRPfz|jNGFblk!^dmIf$~zQ7;@PVdmN-EU+>vpvxdOUGcTxeBH$IQp1Q@4mP>{^ zS;=$d46;vB&8QLusNl~gZ*%9hl`tDKs73&Z9IZdvOEnP^kSzQn{E5}Ew(vQn_GcXK zA(8N6T2uftBQDp@3OKy_+NH$qaK+t<099RNvc*dv3QhUn`fBZ4_o=bIy03R0!mii> z+YHf!QVT4=pv#Fucipp3=k9A;FiFmI%F!q*JwL{7kkL-aF*z|P{K5id`HY)sUp+R= zgkpTdR^;HUZJew1&bMIYaOcmXV*zU0a}8`M6z(zhZU@9$X{eM4e2Z6hIIjaa{{7Yi z-3ApawZ;;|eL7j4an_xf9Z|?pfPI12sOd}kAtfd~H>U-E23m#Xe0!z{Ol!wlH;c=h zsgttPov~JQ;t}j5Les?}I-j6&DCqJt&hik=%*2HK;V&6V`5SOY8jY0@9Y3=22`zHS zT&0B1(Rdp62!TWSFj0~)TmcSTzLeN=Jqv%wH%A_Jb7!5U2bly#eKJi|@B~br5sQ}9 z^T+E9Qwfq$4We*16Z-(~1G_BthF>4_o-%qh12P_h#;HfMqx}=HN|9IHtI@mzR_^-G zoUia+@?52-?1=l11f_i$X~ha#7u6Q<0cEVB>wzuPuea1rus)gj2FWJ;b> zLT4JKpr?w=t?b^`oWp3o(a}a~@%Y>ExsB058kb;doBj;2;sF?B^TFrdsI{<*6#>;i zzF4R=Kalhg|IXrVUu@{r&=Guo3@UFdH*6=1gc8T#8ZMH3_xfs)<(>OYXHiMe8jo|s zIV|~|JYTBS7 ztW&%BvlLkhqjg{a9pk=!dQM;B2Zqc&m>}t-FQOn=TBlmPpi{k@^dc9EdVaa_F4;R8 z>{KBQdUGFqbe8RL`K`i)k!Y7Z8|i_Yri747Z*ckgm0i zkc<%2P}F!mv5>os{m|CNY8~S<80AZaeAX{Tk%f8Q`*xdYTy8XIo@RsIJ@F(7q@zqy zkglRsm($u-vzq(!<}k2-3lm#gET_UhE;9YmIo*0t>wD+Llq1;1!6rW{RhnY(LtsaY zIh5w7x^CY#p8$vh#S)vcWU|HD;NB9(_9S~Sd40vj%!q71RCa4&quU0;1k+~>{sx_f zKjd92N%FK}4vdm7ld$&MZwY7QPhru!Mq-7BA(v*Toy;TjDfDH|Lq+9d(u_a3O+G}} zkh7^W#2GH4(m7Xa&ud7GQ+tYULfy9(V>slPSCA9oTN|9nEF4Bk(nM-XG8pc%sE+Z$ zyu(Dcilbp|Y@*5<_8m6kVsIHa*MOulU&0GoCG{tZ4?wk;f%tsMG6Mn)5!9HTf|HRE z=rXFk-qSk4;w~X$-7O85J7{Gq_z*KZ<){2RSH6F;*D3hh;onJ<+d%No$`Z?9QUctP zRt{k4Y;R!%dX|kI1Qy^mUr^89Z)*-VDKL+{ONMmB%3!SKk8&?PVi+3pDGZGB8hv2@ zBrJO==n5*>ktU?U$ZPge8+n?wxi*&D%2-#4FOjLCW1hx|hjhLM|L_(RN2kMQ{thF7 zxl8VP-8zOPj8B}Pzidi}{qbAC!pZ_N#2<)Y5vi;AvQwS^%)_1xMG1f}-0}Xxm05Fy zT8BDa-fi)`{o_0-IR#`Uz@REbuic_hAA8z1S14J{tHfO4xcxh6giPCrg@MT?Xyvku za2p&tXoVPz3rgI%kg18d!V!%g?6C)dL5!FHP-K3UTHF1cEAk0CetxK;sCQE0_IKGI zMyN1ALH7(9Sh_SBNNG%#$^PKE%`wwGfU#9mqspcB;~S72%9*5oF;@U1jX8%JTNg*Q zCum-u<1;aLPM3Ux{ze=b^$mq#o$DsObucpuAO`oF>K4sj#F0m4(LAoHN4#3p_n@1{ zn6Am6pFxN!aFxR!MRF$%v4UBDi7Kfrb!PDP7;5f;Vl=)jildD_@LK)dp;;Q5YePx6 zbkd*H{;T7hVQg(QC0B9Nucoa*TNuoI_|cuob!*H!uI7Qs8{xEJyj;FK({qiC5GSR; z{`u56hp2PJy#OKcyG^zIGkR0-axTAi4?5W8YV{5(jTim0q7Po`iOwu5%osjRFT{n# z`Tq#Vwp~@IqI-VHnA`B(f~gG05793Q$3Q6T#K^t(bzS_Z@)lo*#4_bzdOz)I+Nz$(HuMe_J{`qFylqGHm?H$+Jq(R>7}W-{=F^ zo!P&vueSg6oz=bNrDM~kx&9DBIGXSsPH>d!e5+5&&O8@T z7S#GGmImH%ppW)AN<8!x6y?%>7n$5nb#iyNl4Bw4 zN!AeDzIjN~Ie%x=fVNkgX5NB{1xJ^+w9HF|-cjRuq)Qi%j0tMk(Bfp5?p4?Gs1)90 zIkiX3P9xB!={28inFhu*3m+E8TXm}CZNEZOyL#O-_tU)C34Y{JH(}@!{|5|(ZpjGG zT{d~`-^B=rje1Gj_v!Bue0859oN-s+68K@Qj_%t90GaD{+F*ICZLn zBFXjXAD24zx@mX+ao-mEdDvS1AO!XQgM4idl?r%KGA; z;j;q&M#|$TS zewXV5PNp!EVw7+yL*a&nI0dQ89d z$G0xRZR~ZzLH%F3>H6G2ZhE)P=CYe31BLQ*SJOg}dOk_|d^_B^H)7-%J|b zfjdGU5U*k$gp1OP-^aPNj4T0p*?OZ9BUYmyhfL^xWu))z#Hk1&B_TcehcjPl23(FC z0WNpOXhUu$>EO1B#H6|2`Q%}YyL5qxc){gMHJhiMnWc`%FaAp&|KtKlt_>rV=7pvf zuYqs^Kmer05oeyr9w*i`W-i*=C;v)baDjHhqN>d!MF7%x7mhp6y!vEhfW|R|Q-~T2 zw#gt~Cc!eDP|X2*!A-dgS81G{`zmR~T5OsI+Mno;>_}x3NgPg`c%Uc@m*kMi%2GF& zTw!N})zfFb!A(*1a*UMSG~J*WyVa}XYZQ1ny70s27A2FBBQ{6P!{rtj%`cwfQ+IoB zvhh?FCS7n@*xNj%gzYyspqs!YcR>%H2R5=g54CEPS?zxgXDp*{#=QY6&7EYEM@U}D zw6j*~d|89p;M-(ZgZlZ>)ur67o7*eZo9>Ss(AITwT84K#@ACARy+l*rcAPIGxEb`R znS*xBiYNuH^Q3qyOk3EAV%^Cv;IY=RG*nycDtA74keozmoY`gc#U4ebbq!5ke0%av zuNwET9FlaGc_6}y18t4BSei2~2*Sn%v3MG+(wu*v2F1AD7{{fk1vzlKjwXJ4cLbyg zCby6QnYnnCjk>voGkC7ZzOlqIh=VX8RadW^uQarsJGBvO>b!4D(70B&-pkGaqv{}g z`N8QyAdhP}qS2ib29+0Az^l(e;v*SU$K0!5m4BsmC$?A!`xzaIa!C75~+oObl!AS@V;oTcY zcn|+V=6)V0{^8G?hO`Fp4G@##mZoQ&)aXIu&&{uXdtr?}sxhIoHGQ;O4V}xfljHVv zC!@a)B6Dc`dMPCk6CfM4eF&PsIs@=`|;$a!st=;*QdXCPb`LiW*RAH zoq2_!iy&cu)8t`w`xbEHHsYPDn6R_x3ZFp5?YXWw-JNDFT=m%Z4ip zQ=mIUm2sI>WBjkJt!Gk#GXQ|5Y6v1edsI%(KUF}pjeY;#)4)o;q&niFSeY1p@UT}g zQ>~1WK|IPj|K2-5H6ZB2gj`jeHL<1q{!Qth!c^Xi*=9dx(SbkhvdU4RD6gfBbN;_O zV?(z*Rx`|`Ur*fmn-|9p#4kSHytwIq7BV~c^g*AA=VuwDWKYgg!$sSV;&#NA4}`{M zM<9?U$-sF=yN&~>+C?b;-|vQ1!6Hp2B69Aj>rY4?ksyrdy?i~Sn;P0mk&xZqK|%Wm z6PZC9F%tasLhufP^W;WZ{u9B=xh|0v4%)8ic zE)l@6_@D+Fe+6RC8oZ(lxOK*P;W^pp8LLsJ?|Q)f!|p|{yrZRxn^C-DKWm+dEv+v- z^@bFH-cOnORs4m#XAIbE1Texh%@4#iV>)N|1$s9i=1GnBFuPytS`jWv^}ZI}zZ<}G zlP*spKnd|TX%?7W1!tv1F9kk=$WD~^E2t{NH@3Tq0}qdz~8TBmh=Dn z7ti28xR|y3ydjXR6(U+k)V%%I>m1HrSBn-K{l9%j=|VOS*>|86viqlNORRv3ldwEd zB(JbG(1gqY$UAZlD{(v<*4d}x4SfjAuuQKf@9o=kTwRY`0*hJ6%`77!MdyJr)2m#G zX<`O4l|(IA{@U7qb(IC^rX0+faOSkO_Q@w~EwKSBWj5RimTqx=8HKU5E1*d4XS?(@6Uv3jCspbk+UeOGpw1yq={^ z#+*@vis4>hU0E%_5PvDM_00%)eq8D_{{IH@|GvoCBL4sH(gH5|4Rd8)qij<&?^}w~ z@`hT_NXh^*C<79}uFgYu#B&hSMQ%S0{PKri((x>(mj0c@zic`%G1mc8`io;^eQLie zPdk?F-hJFYKtFj9@XLlrFV0Yc1_2_g{TR*t^aToF%Eb;FDSwm$*gnhAAtAN7J7ePSOg+LOJ@atBj?QIpo38b{_Q^){1CZxB8$IiHYQd|XYT#t;F z_PmBl)m^5;-Ra;{QoQshVG~ok4D|Asmz0GIWJTziwp&h%e_zF&MQmY!-9lWw-s(|< z&%5sLjT<&pVB4Dx4nC{{WJ_4jLz402Te8ZS@G}LGSfFeJ@9~r#S-Y0i$lZHlfF4Et z9cPWqqgNLYv61bg@(_K$%HN5&LqMSVa?qde(-5Pep|rS{!;9~S9g;4D(v}wlRQ_WC z+YJCv$FDS33`wUn?~Xeyq(0n`=^LLPSDo4H zl`zV^0usGztck>4@{)T|AHUnl73MUTAZrMzx+`lR*D!=()6h$a89kBJEb;%AC+uR#6?mCp8#W~Kl4;0Wb4<)~o1JV39 zPW~Gj{`wzt0It;r{_oHJMh@W5RyP1ok3mP%O#k18`(N$;g)Qd+Xc?#aH<eL#HnEbskpH(w|13@b41vnKm$#-i1n$G_`{-;~XA?PBPe}MJBzh512 z2i$I49!CS&KmYTk!2BUU%lx03Ji}<%*~;Z-b3y*|+5X$Gil7dh|LxH~O|>Kgh|iT8 z`#$^s_);I*y zzV!R|Hu$eS_*Yuq_qum^=Sb6l+K%Z25Emsb=03Inv|w)|u?t?0cK_#a+ckh$%zpH} zMn-L>g`5!)w3$}Ox>Oh(w6Wi*+|>2@{5v{l3S7*89mT(<`?C-V8clS0dh0!MnIc?#HqwF9x}wczZ>@`d$lwOit{Voi<0{2+Tx4W!}R1_NPjiQWtiN5d3NuPTYTmOnfC_}MMP^R$G*T+ zalM6{*r~LOBQXZ=t8dIQ2Fra6UrEvC7V!oYG)V4A{u4HYzP#zApzY`L7L8|OI%f>P zxHyR>xq7ax#H*vI=VJh)EzT~}^kKo3#lD=|M*tyLZ%=8(bl`HqL7zS3OmIJT8j!Sl zX}(h39Hg5hkJ)rTWei#mCjoWn^_s({Jqxz-?)bRPkoM9=H;uUWFVR&u9WImBf=~T> zXt}!B_4%~W7ImfW0F8|8o`s(sN&Wa{hgiW!%~yr^Ec*l4B&|5UXn%4oC~Hjlr;gEO znK7&II~DWvneze*mGOhV-xjh2Hg;ix4~+h^WD)0p z)kAyk>3549jXZ5`u^^9bqYLJ?rz_1TqBIZB03&rQ0vcfz363iA`eLlj254Y;Gkb%F z%Z&;PBHo`(6mbBUBYr9vY5iI-pY0{jJ|yurprU{t|8lEVl<~(5>EulNhZrMNfXV|n ze}Ep&MjSuLAYcC7ehanI&Bo1)YJEpO756m&{cj)rGzz{9dGKVAUkWCiGT_tvXHw_p z{1hI19uT`*C4HYh@jlF}6WpQ4h)Uoe zJyW%l$OO{z2Gwu+cIHJdu{JlK>=FH^whH*4-1-C_hXC?9XkfF5D($y2mLDyYET5jN zok9wa=7r(_xdU;Um*%z96l1U7k6(UANl+b2lhx2)PTU2P{RX^-Tn%l4$`C2g+^v`a zECe`8!R3nWF|_A5068Tiw8Zb$f57s;nC8$aU@z}>I6ACd(36hHd;3Yga?EEsFikjW z;oDZhUgP#wgpeZ4v>tZT+C6$^`;50vqlUSu*Z`0)1z`?L`99*_(}8>Z0Wg`AMH->J zn~lHhB=ksdGHx~QLcU#I=B6K-61pWEj=V!K{@=Jx?rwP|>kG6WB?5oybw675s`h_? zBgKkB7?t*|Y6Sm~*qgHn0-I6i>V9nBYRs* zAls{x+NsHVj@mS_jwEsmm_gFns6Cqie4+O4yrtxN3=I^@z=VTqQrbEPZO|Q7w znVJgmYxBvD?QyhlR8jPPq*c_-z2mpdmW|7It1tUfF9}%;$Ap^q4fuP;D-M8ET6-AvL z^(pY)3%#Hu?3p%#AdC?*PhaOWMR|MmcxtaHi{d7NXL`RwwtSax4Aj6l*{+DY*L*ml z)3uOq@y|~EFQ$JRh^1g<4b_9$NqvAJYe%2SHHGz^aqJOWZfTl$^?-Kf-~Eq+JVW0> z;oKx<_AqFsKSmEo#!zRT#ICE!HLQGUh)s~05~h*IC!|6$?QTPIZZ*#3uiYqNHnHmD z2@b$@3+D1$OCY*^3+%xo*dg_O^>y_|^{TdKztV3T>Vyq`pW1y-`nVSOn3=r7F!vdS z!9+3>*6oibik}hl7?eAI$(q3$JPSr9E6@7_H-4hxjq7dmQw^KCqDl9q677p2N8l?= zOI?g6VW^c23xdM_#|5#+I$;x?fJ#p~wbI<=UrA&7e$wbBN1eY2G>G1R_D@{AU?bk9=k76R@Ea4n2Om`aOh%4Vj(;UPY1(cl0WX9Sw zyEz|Thm(qfF&}T~s^Qw9&zt<{NhtGa|4PE+Dwtf(HjLh+1+a)SU&z z+3F^P%$^Qtak`{0he);l0F21}nhOGkb6-Sm5BtA7T?z7efR1*9x(=vM>rnpVoBYSk z`Vk5Q2pE&24l*%Y5cgedhgyW%dOM}8d0;r8GJ?vqJ|E@9%RU+eaz08>5M~eKDH$}7 zolGad2$#)or?FXxaHHv?p_tFxLs?B%XaWNuBzSO|kcQTTA=CDm44?o^q-tZIt5*g+ zHM-&?qr)Tgtc`I&$Qx6)dB zDk5L?Jg)w@t6L&`g#A_7(MTI~X3SZXtJY^CC_Df3{=N`U$rz+U>-D!1682>3R|Dl;X*7CMHEPts1uu!j_ zn|`;D7^ywo$yooi{vfISeF$*1&ObG z)Pv4^l&RE=UcEbc0EnupG?n-qlABD{ImAYs6lFn+$cAQda;^iDP?PTn?JeLjRDeRQ zhy^}u2&&3n%p7bN5f?g!rp*MeweN?-s-@iQ_=S>0xrJ4l;YnI1#n{$kA0qe(_}Vw; zD{ee0Su>4m(l82tacV(5Wl51)Vrqk&kPj>`7z-w@ z1H*R$&Fq58!^$>vS2)nSP=>iMyD|TwJv@Eic&BRHiL7X#?I?+Ib=iVhktOJkeb*{b zi^sH93$yh{6_eksd>T~kJ*Y`gC(KdobkJjX+w2j@(o5oU7l0bmNX^i1B9vy10(}ff zCJ`$Xu=ic5B;hcl*O zQMXKO4>&d-QXP4Z`j=_eKUUkn^i1B|K`hYGB2wbu24zPRw()ZDnF{8R60q`nE->!$ zmrT+EZ%q|LW}0B0;0hyfsp)oidkZ(7y1XP-%F>r_mXr4(1ze`gd$wS?(ECtc*w3BH zC6dJ7p;a6C7KXs*3aCPxmyUX0uv5F6)bu0U9#i#0`YpWLT8_v*8SthLK2F@F*J1+^ zjn_%It3^;iH_`jw^}E0;!x|U7RK38nrsWGLe&leP@yvJF;{+;YOV>RMlzuBZ{h4fF3gCCKlrxwW6zVPtegf*} zSN0@GlbzdJAkFQv#1`-!q^%>P#u9B`sPz(Ow0Qgj9moptnWtqvTpkZ|Z68&e0Xwmih;I?$L@9pv zWGoH8&$d2z{&K2~ax~zwA(;GjZ~I(KN_ENBKuUCm`XW@ehQch-mgI$PCLfzGzkGe! zh6k4`K+*>5nq6eRfk@QJd>hfhfm8zQY~iI~E2xx?QY=3qz;&8Rm$JR8Z%um1HAmE2 z{!u_F%nNg}@LqJ)#+o=lC^dD}I^$A1jQ|mA$B;}@n8N3F8evo7-Q<_rn1SpcrdRt6 zG^t5$3P@i{dNo@=njD8(0XZ2g{y^xE3$t(ThZssf2|WMRy7qtaVerK0+#X>}o(06{ zNZo*_0Geb;t^I?@zjpP zOkrVdD6wL`l-k7FvqvJ{7Grkud18_lLz=byiT*0)-6gWAXqSS+}%El2~hyxL@a8j1^!RV^<6Q8n>5Jw8B&hF@NVZO1j9Zf4iuA#x(+W3e3W@`|OcsnSka^y(|Z zJHlaC8H;iND=WJGkqqDOniZB}^t%c`cI8n?&htJ=Ez`0^>d(HM)320)>|ONQ+31A$ zQ)p5(sI4R!8@xR=*o}~r1p^+abUt}5iv*O5BBlXT)$ztbjWKLZw?#f9Z836k%lj(a z&H#uhwL!Kw(@OmV>!~nP4U7<42^ zeKr7edYus78<GsxLrAiBH?jQw-teafSXrEyYNaX9S#l+!H>lK$ZInR7HD z;^Tu+BrD8krz~5LeT}Hy^wRGJftq@AQc3N4ZzYAy_%Ikd!x%-Y^? zsTB#Uoizkny8z1$h1tW7OiQ-83iF1D5S?rByh?v}WrmzN4r~KwtEzNAu7 zzgE@#o`+)LS16r{#mA!%qxc#dIm=s^`IvKhUAZ6Yfm6a$phQ zXknNJfa7!;RLCG2atapS^hbe=6$8=(ld)y;%x^mzk+FIdt@wT4kTVsm z5Z6}V7`somBef+0uLY%j|GQp6W5Ypn&-K? z(i^^A&5sgMp9_cE)n>Zm9%3UhGp)UJQdu9_M{%zuS4PE#L zzwy_*^qp-PuP$RK>)d^~s?6G$>RG?#Y3~WSP^?h{s$aFA+0|8A@U+KohbX^ER=rhH zfIwU4GbyL^-Mxk{EKX?rL$mqwt<*IjJa77Rta>q^tl*^a$ln^1Y8w{=RIlJD0bP%1 zmj^KU`?brjCTb8I&}R|LKy6dhX4f->0;{VAv2n7!=8;P0PKZ#=K%2T1v&^u0ZUP)g zo#q(&-%(Wsd#!atqyH!!z3s4*d5c4XvXOR)dD-0+~jgPasPxzqjG zhn}8}kTC(VZi)iAcyz9N5(xKe9f{M~LeEc3B0S#B0kn5B@usUDKKJ7Qvf6QB+54-_ z5>wU5jHK^>B{iV5(0iG1aGI$w8!F_;uVs5T!Mu`_3C(rW>y;g)--GYUh0SR6SL2-n?BW$` z5O6%xM-!h(mbG5m;3FFbmuO^N32o1*!9~4DAP@B~G}Vrruk>JrUJW$-V_UoA=T5;| zzZIE7J`Pzy_$P%Go;!`hch|oL!l<8Q0Q5GYC$i{OC!|Hj1~U$kv9u=E{H({G-_@2v z#Tr?n6ZJ;A1N#>&g;9&%t3yJ~j^FE?Hg0c8c+UT)r^>&sSeRQd*;?_Eb^M5$OJ*{A znvpja(?Ka4=}B7fh+k8yU*jx!FMSUbC}kD_g*iI2MqdUJ056Z20s4_(B5$4*+@wk> zLH#sbJni_;8deiA$cJt;@692iL1pINpsc@jjKAT%I50bpCIHF9z~_N&*svKbF>t#+ z^K{cV=&zE_e=sNDZ73i^4&T!utzQv)dZ2<8bYOfV^nwd#(W^k4Kj*-u?KkBS~_AX&3$kD506aaR{#J2 literal 0 HcmV?d00001 diff --git a/docs/assets/resources/pcb.png b/docs/assets/resources/pcb.png new file mode 100644 index 0000000000000000000000000000000000000000..accd54c1814dbd567c5b691171758067b4f87e63 GIT binary patch literal 21979 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 Ur3}#2i03|f*!)n5p=;Ft0KEuR3;+NC literal 0 HcmV?d00001 diff --git a/docs/assets/resources/tcb.png b/docs/assets/resources/tcb.png new file mode 100644 index 0000000000000000000000000000000000000000..5c9d225a5aacdba34b21acd24acc6b43d220ac97 GIT binary patch literal 22480 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∨?JoPCW0I(6Z^bH%kI`?2E4 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 literal 0 HcmV?d00001 diff --git a/docs/assets/resources/udp-ip-packet.png b/docs/assets/resources/udp-ip-packet.png index c890b7b745352dc1c9d680090e6b8e2586e38521..90b894050819f36eaca5a16888ca05a09959a950 100644 GIT binary patch literal 53245 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 p>RZhn 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 diff --git a/docs/guides/index.md b/docs/guides/index.md index bd1fbaf..19cf946 100644 --- a/docs/guides/index.md +++ b/docs/guides/index.md @@ -9,20 +9,20 @@ The guides feature supplementary documentation intended for your reference as yo ✅ Reviewed 🟡 To be reviewed +⚪ Partially reviewed - ✅ [Architecture](/guides/resources/architecture) - ✅ [Coding Conventions](/guides/resources/coding-conventions) - ✅ [TCP/IP Model](/guides/resources/tcp-ip-model) - - +- ✅ [TCP Socket Programming](/guides/resources/tcp-socket-programming) +- 🟡 [UDP Socket Programming](/guides/resources/udp-socket-programming) +- ⚪ [Process and Threads](/guides/resources/process-and-threads) +- ⚪ [System Calls](/guides/resources/system-calls) - ✅ [Linux epoll](/guides/resources/introduction-to-linux-epoll) - 🟡 [Linux epoll tutorial](/guides/resources/linux-epoll-tutorial) - 🟡 [Blocking & Non-Blocking Sockets](/guides/resources/blocking-and-non-blocking-sockets) -- 🟡 [TCP Socket Programming](/guides/resources/tcp-socket-programming) - 🟡 [HTTP](/guides/resources/http) -- 🟡 [UDP](/guides/resources/udp) -- 🟡 [Multi-threading](/guides/resources/multi-threading) -- 🟡 [Fork()](/guides/resources/fork) + ## References diff --git a/docs/guides/resources/fork.md b/docs/guides/resources/fork.md deleted file mode 100644 index c1a5689..0000000 --- a/docs/guides/resources/fork.md +++ /dev/null @@ -1,13 +0,0 @@ -# Fork() system call - -The Fork system call is used for creating a new process (child process) which runs concurrently with the process that makes the fork() call (parent process). After a new child process is created, both processes will execute the next instruction following the fork() system call. With forking,the operating system creates a child process, which is an exact copy of the parent process. This includes copying the process's memory, file descriptors, and execution context. - -- **`pid = fork()`**: This creates a new process. The return value is stored in `pid` (integer). -- **Child Process**: `fork()` returns `0`. -- **Parent Process**: `fork()` returns a positive value (the pid of the child process). -- **Error Handling**: If `fork()` returns a negative value, it indicates that the process creation failed. - -**Some other system calls used along with fork()** - -- **`wait(NULL)`**: The parent process waits for each child process to finish before proceeding. This ensures that all clients complete their work before the program ends. -- **`getpid()`**: This system call retrieves the process ID of the current process. \ No newline at end of file diff --git a/docs/guides/resources/linux-epoll-tutorial.md b/docs/guides/resources/linux-epoll-tutorial.md index ce027b9..19829c4 100644 --- a/docs/guides/resources/linux-epoll-tutorial.md +++ b/docs/guides/resources/linux-epoll-tutorial.md @@ -2,13 +2,13 @@ ## epoll -*epoll* is an I/O event notification mechanism widely being used in modern web servers like Nginx. *epoll* stands for event poll and it is a Linux specific construct. +*epoll* is an I/O event notification mechanism widely being used in modern web servers like [Nginx](https://en.wikipedia.org/wiki/Nginx). *epoll* stands for event poll and it is a Linux specific construct. -Epoll refers to a kernel data structure. It maintains a list of file descriptors, which allows a process to get notifications whenever an I/O event is possible on any of these file descriptors. epoll_create(), epoll_ctl() and epoll_wait() are the three main system calls that deal with the implementation of epoll. All these system calls are included in the sys/epoll.h header file. +Epoll refers to a kernel data structure. It maintains a list of file descriptors, which allows a process to get notifications whenever an I/O event is possible on any of these file descriptors. `epoll_create()`, `epoll_ctl()` and `epoll_wait()` are the three main system calls that deal with the implementation of epoll. All these system calls are included in the `` header file. -## epoll_create() +## `epoll_create()` -epoll_create() is the system call used to create an epoll instance. An epoll instance is identified by a file descriptor in linux. The epoll_create() returns a file descriptor that identify the newly created kernel data structure. +`epoll_create()` is the system call used to create an epoll instance. An epoll instance is identified by a file descriptor in linux. The `epoll_create()` returns a file descriptor that identify the newly created kernel data structure. ```c #include @@ -17,31 +17,31 @@ int epoll_create(int size); **Arguments** -**size** - This is the only argument for epoll_create(). It is of integer type. It refers to the number of file descriptors that the process wants to monitor. The kernel decides the size required for the epoll instance(data structure) according to the value in size. +**size** - This is the only argument for `epoll_create(`). It is of integer type. It refers to the number of file descriptors that the process wants to monitor. The kernel decides the size required for the epoll instance(data structure) according to the value in size. **Return value** -epoll_create() returns an integer which refers to the file descriptor of the created epoll instance. +`epoll_create()` returns an integer which refers to the file descriptor of the created epoll instance. -### epoll_create1() +### `epoll_create1()` -This system call is also used to create an epoll instance similar to epoll_create(), but the arguments differ. +This system call is also used to create an epoll instance similar to `epoll_create()`, but the arguments differ. ```c int epoll_create1(int flags) ``` -Here the flags can be either 0 or EPOLL_CLOEXEC +Here the flags can be either `0` or `EPOLL_CLOEXEC` -if the flag is set to zero, this function behaves same as epoll_create() +if the flag is set to zero, this function behaves same as `epoll_create()` -when the flag is set to EPOLL_CLOEXEC, whenever a child process is forked from the current process it closes the epoll file descriptor in the child before starting its execution. So only the current process will have access to the epoll instance. +when the flag is set to `EPOLL_CLOEXEC`, whenever a child process is forked from the current process it closes the epoll file descriptor in the child before starting its execution. So only the current process will have access to the epoll instance. -Since epoll instance is treated as a file descriptor, we use the close() system call in unistd.h header file to close an epoll instance. +Since epoll instance is treated as a file descriptor, we use the `close()` system call in `` header file to close an epoll instance. -## epoll_ctl() +## `epoll_ctl()` -An epoll instance can maintain a list of file descriptors that has to be monitored. All file descriptors registered with an epoll instance is collectively referred to as epoll list or interest list. Whenever any of the file descriptors become ready for I/O operations, they are added to the ready list. Ready list is a subset of interest list. epoll_ctl() system call is used to add, modify or delete file descriptors to be monitored in the interest list of epoll. +An epoll instance can maintain a list of file descriptors that has to be monitored. All file descriptors registered with an epoll instance is collectively referred to as epoll list or **interest list**. Whenever any of the file descriptors become ready for I/O operations, they are added to the **ready list**. Ready list is a subset of interest list. `epoll_ctl()` system call is used to add, modify or delete file descriptors to be monitored in the interest list of epoll. ```c #include @@ -62,7 +62,7 @@ int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); 4. **event** - It is of epoll_event type. - `epoll_event` structure is included in the `sys/epoll.h` header. The structure of epoll_event is shown below. + `epoll_event` structure is included in the `` header. The structure of `epoll_event` is shown below. ```c struct epoll_event @@ -94,7 +94,7 @@ int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); **Return Value -** when successful, epol_ctl returns zero. When an error occurs, it returns -1 and errno is set to indicate the error. -## epoll_wait() +## `epoll_wait()` This system call is used to notify the process, when some event has occurred on the interest list of the epoll instance. It blocks the process until any of the descriptors being monitored becomes ready for I/O events. @@ -106,9 +106,9 @@ int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout) **Arguments** 1. **epfd** - It is of type integer. It is the file descriptor that refers to the epoll instance. -2. **events** - It is an array of `epoll_event` structures. It is allocated by the calling process. The values in this array is filled when epoll_wait returns. It will have the list of file descriptors that are in ready state. -3. **maxevents** - ****It is of integer type. It refers to the length of events array. -4. **timeout** - It is of integer type. It refers to the time in milliseconds for which epoll_wait() will block. If it is set to 0, epoll_wait() will not block and if it is set to -1, it will block forever. +2. **events** - It is an array of `epoll_event` structures. It is allocated by the calling process. The values in this array is filled when `epoll_wait` returns. It will have the list of file descriptors that are in ready state. +3. **maxevents** - It is of integer type. It refers to the length of events array. +4. **timeout** - It is of integer type. It refers to the time in milliseconds for which `epoll_wait()` will block. If it is set to 0, `epoll_wait()` will not block and if it is set to -1, it will block forever. diff --git a/docs/guides/resources/process-and-threads.md b/docs/guides/resources/process-and-threads.md new file mode 100644 index 0000000..d7180dc --- /dev/null +++ b/docs/guides/resources/process-and-threads.md @@ -0,0 +1,109 @@ +# Process and Threads + +An executable program stored on a system’s hard disk typically contains several components, including the text (the executable code), statically defined data, a header, and other auxiliary information such as the [symbol table](https://en.wikipedia.org/wiki/Symbol_table) and string table etc. When the [operating system's loader](https://en.wikipedia.org/wiki/Loader_(computing)) (typically the `exec` system call in Unix/Linux systems) loads the program into memory for execution, a region of memory (logically divided into segments in architectures that support segmentation, such as [x86 systems](https://en.wikipedia.org/wiki/X86)) is allocated to the program. Each of the program parts, such as the program text and static data, is loaded into separate segments of this allocated memory, called the text segment, data segment respectively. + +In addition to the data loaded from the executable file, additional segments are allocated among which the most important one is that for maintaining run time data of the stack and the heap. Unix/Linux systems use the same memory segment for both the stack and the heap, with the stack allocated in the higher memory and the heap allocated in the lower memory of the same segment. + +A program loaded into memory for execution is called a “[process](https://en.wikipedia.org/wiki/Process_(computing))” and the memory allocated to the process is called the “[address space](https://en.wikipedia.org/wiki/Address_space)” of the process in OS jargon. + +## **Process** + +A computer program is a set of instructions stored in the file. A [process](https://en.wikipedia.org/wiki/Process_(computing)) is an instance of a computer program in execution. When the program is loaded into memory and starts execution, the process become active. Each process operates in its own isolated memory space, which consists of four main memory segments: + +- **Text Segment**: Contains the executable code. +- **Data Segment**: Stores global and static variables. +- **Heap**: Used for dynamic memory allocation during runtime. +- **Stack**: Stores local variables and function call information. + +Among the above, Heap and Stack are allocated in the same segment with the heap growing upwards from the lower memory and the stack growing downwards from the higher memory. + +(Caution: In the following figure, the lower memory starting from the smallest address within the segment is shown on bottom and the upper memory region is shown at the top) + +![segments.png](/assets/resources/segments.png) + +The above image denotes the representation of a process in memory. Here, the arrows represent that both the Heap and the Stack can grow during execution of the process. Heap memory expands during dynamic memory allocation (using the [`malloc()`](https://en.wikipedia.org/wiki/C_dynamic_memory_allocation) function) and stack grows due to space allocation for automatic variables and allocation of space for run time [activation records](https://en.wikipedia.org/wiki/Call_stack) during function calls. + +Each process is identified by a unique process id (PID). The OS maintains an internal data structure called the [process control block](https://en.wikipedia.org/wiki/Process_control_block) to maintain meta-data pertaining to various processes in execution. Each process has an entry in the [PCB](https://en.wikipedia.org/wiki/Process_control_block). The PID of each process is stored in the PCB entry of the process. The [PCB](https://en.wikipedia.org/wiki/Process_control_block) also contains a lot of meta data associated with the process. Let’s look into the structure of PCB in detail. + +### Process Control Block (PCB) + +A **process control block** (**PCB**), also called a **process descriptor** or **task control block**, is a data structure used by a computer [operating system](https://en.wikipedia.org/wiki/Operating_system) to store all the information about a [process](https://en.wikipedia.org/wiki/Process_(computing)). When a process is initialized or installed, the operating system creates a corresponding [process control block](https://en.wikipedia.org/wiki/Process_control_block), which specifies the process state, program counter, stack pointer, status of opened files, scheduling algorithms, etc of the corresponding process. An operating system kernel stores PCBs in a process table. i.e, The **Process Table** acts as an index which points to individual **PCB**s. When the operating system needs to perform an operation on a process (e.g., context switching or scheduling), it looks up the process in the Process Table and retrieves the necessary information from the corresponding PCB. + +The structure and contents of PCB is given below + +![pcb.png](/assets/resources/pcb.png) + +- **Process ID (PID)**: A unique identifier for the process. +- **Process State**: The current state of the process (e.g., ready, running, waiting, terminated). +- **Process Priority** : Priority level of the process, used by the scheduler to decide which process to execute next and distribute the CPU resources accordingly. +- **Accounting Information**: Keeps track of the process's resource utilization data, such as ***CPU time, memory usage, and I/O activities***. This data aids in performance evaluation and resource allocation choices. +- **Program Counter (PC)**: Indicates the next instruction to be executed for the process. +- **CPU Registers**: Stores the values of CPU registers such as ***stack pointers***, **general-purpose registers,** and ***program status flags*** when the process is not executing (to resume the process correctly). +- **PCB Pointer:** This contains the address of the next process control block, which is in the ready state. It helps in maintaining an easy control flow between the parent and child processes. +- **List of open files**: Contains information about those files that are used by that process. This helps the operating system close all the opened files at the termination state of the process. +- **I/O Status Information**: Information on I/O devices allocated to the process, such as open file descriptors, I/O buffers, and pending I/O requests. +- **Memory Management Information**: Information about the memory allocated to the process (e.g., page tables, base and limit registers). + +When the process terminates the PCB entry associated with it is typically removed by the operating system. Which includes the de allocation of resources(such as memory, file descriptors, and I/O devices) that were assigned to the process and deletion of the PCB block which contains all the execution details of the process from the process table. This allows the OS to free up the memory and resources occupied by the PCB. + +### **Process Creation** + +**`exec()` and `fork()`** + +Processes are created through different system calls. The two most popular ones in Unix/Linux systems are [`exec()`](https://en.wikipedia.org/wiki/Exec_(system_call)) and [`fork()`](https://en.wikipedia.org/wiki/Fork_(system_call)) . + +- `fork()`: When the `fork()` system call is invoked, the OS creates a new memory region (address space) for the child process and copies the contents of the text, data and stack/heap segments of the parent into corresponding segments of the new address space. Thus, the contents of memory allocated to the child process will be (well - almost!) identical to that of the parent at the time of completion of the `fork()` operation. A separate [PCB](https://en.wikipedia.org/wiki/Process_control_block) entry will be created for the child process, and the [PCB](https://en.wikipedia.org/wiki/Process_control_block) entries corresponding to files (and other resources like [semaphores](https://en.wikipedia.org/wiki/Semaphore_(programming)), pipes or [shared memory](https://en.wikipedia.org/wiki/Shared_memory)) opened by the parent will be copied to the **PCB** entry of the child as well. Hence the child process will also be able to access these resources. Both process continues execution from the instruction immediately following the `fork()` invocation. Details of the programming interface of `fork()` in Unix/Linux systems is described in [fork()](https://www.notion.so/System-calls-5455244fc8f84a38b4d06f452c2cc969?pvs=21) + + + +![fork.png](/assets/resources/fork.png) + +- `exec()`: The `exec()` system call takes the name of an executable program on the disk as input and loads the program’s text into the text segment of the process that invoked `exec()`. The contents of stack/heap and data segments of the current process are replaced with the initial configuration of stack/heap and data segments of the newly loaded program. Thus, `exec()` completely destroys the calling process and replaces it with a new process executing a completely different code. All file (pipes and shared memory) pointers opened by the calling process are closed and not shared with the newly created process. However, the same PCB entry of the calling process will be used by the new program, and as a result, the new program executes with the same PID as the calling process. Hence technically `exec()` does not create a new process, but only “overlays” the current process with new code and execution context. (Linux/Unix systems provide a family of similar functions implementing essentially the same `exec()` functionality, but with minor technical differences). Further details may be found in the page [[exec](https://en.wikipedia.org/wiki/Exec_(system_call))] + +In the eXpServer project, we want to create server programs that connects to several clients concurrently. One way to handle this is for the server to create (an identical) child process using the `fork()` system call to handle each client request. However, this is very inefficient because creating a new address space and PCB entry, and then copying all the text, data, stack and heap to the new address space for each client connection would slow down the server considerably. Observe that the code for each child process is nearly identical and these concurrent processes can actually share most of the text and data regions as well as files and other resources. + +What is needed here is to create a version of `fork()` where the child process shares the PCB entry as well as the address space. While the heap memory is shared by all **threads** within a process, each thread needs a separate stack to be allocated within the same stack/heap segment. The bare minimum “separate data” to be maintained separately for each thread includes the thread’s execution context (values of registers, stack pointer, instruction pointer), local variables, function call stack etc. Each thread is allocated a separate stack within the same stack/heap segment. + +To support this kind of “light weight” forking of processes, the notion of “[**threads**](https://en.wikipedia.org/wiki/Thread_(computing))” where introduced in Unix/Linux system in 1996 and since then most servers implement concurrent code using threads. A few years later, it was realized that an even more efficient way to handle concurrent connection requirements in a single server was to avoid creating new processes or threads, but making a single process capable of handling I/O events happening concurrently. The advantage of this approach was that there is no need to maintain separate stack/heap segments or execution contexts for each concurrent connection. [**Linux epoll**](https://en.wikipedia.org/wiki/Epoll) is a mechanism introduced in 2001 to support creation of such server programs and they will be used in this project extensively. + +The [Apache server](https://en.wikipedia.org/wiki/Apache_HTTP_Server) (1995) uses threads for handling concurrent client connections whereas [Nginx](https://en.wikipedia.org/wiki/Nginx) (2004) uses epoll. + +In the current page, we will describe threads. For a discussion on epoll, see the [epoll documentation](/guides/resources/introduction-to-linux-epoll). + +## Threads + +As noted previously, each thread within a process shares a common text, data and stack/heap segments with other threads of the same process, but has separate copies of: + +1. **Stack**: It holds the thread's local variables, activation records of function calls, and return addresses and dynamic memory. The stack of all threads of a process are maintained within the same segment of the underlying process. +2. **Register Set**: The register set contains the thread's execution context, including the values of CPU registers. These registers include the program counter of each thread, stack pointer of each thread. +3. **Thread-Specific Data**: Thread-specific data allows each thread to maintain its unique state. It can include variables specific to the thread, such as thread ID, state (running/ready/blocked) etc. + +Multi-threading is the ability of a CPU to allow multiple threads of execution to run concurrently. Multi-threading is different from multiprocessing as multi-threading aims to increase the utilization of a single core. Modern system architectures support both multi-threading and multiprocessing. + +![thread.png](/assets/resources/thread.png) + +The main Improvements achieved through multi-threading are listed below + +**Fast Concurrent Execution** : OS schedules multiple threads in the same process concurrently. Since Switching between threads within a process is much faster than context switch between multiple processes, concurrent servers uses threads for handling multiple connections for faster response to each client. + +**Non-blocking Operations**: One thread can handle blocking input/output operations while other threads can continue executing without blocking. + +The major thread operations which we use in this project are thread creation and termination using pthread_create() , pthread_exit() and pthread_detach() . Refer the [system calls](/guides/resources/system-calls) page for more details. + +### **Thread Control Block** + +**Thread Control Block** (**TCB**) is a data structure in an operating system kernel that contains thread-specific information needed to manage the thread. Each thread has a thread control block which consists of: + +![tcb.png](/assets/resources/tcb.png) + +- **Thread ID**: A unique identifier for the thread. +- **Thread State**: The current state of the thread (e.g., running, ready, blocked, waiting, terminated). +- **Program Counter**: The address of the next instruction that the thread will execute when it is scheduled to run. +- **Registers**: The values of CPU registers when the thread is not running. These need to be stored when a thread is preempted or switched out by the scheduler. +- **Stack Pointer**: A pointer to the thread’s stack in memory. Each thread has its own stack to store local variables, return addresses, and function call data. +- **Priority**: It indicates the weight (or priority) of the thread over other threads which helps the thread scheduler to determine which thread should be selected next from the READY queue. +- **Pointer to the Process Control Block (PCB)**: Since multiple threads may belong to the same process, the TCB often contains a reference to the PCB of the process the thread belongs to, allowing shared access to process-wide resources like memory and file descriptors. +- A **pointer** which points to the thread(s) created by this thread. +- **Thread-Specific Data**: Some operating systems allow threads to have local storage that is unique to each thread. + + Once a **detached** thread terminates, the TCB and all other resources related to the thread (such as its stack and registers) are **immediately de allocated** by the operating system. diff --git a/docs/guides/resources/sockets.md b/docs/guides/resources/sockets.md deleted file mode 100644 index 6769c3a..0000000 --- a/docs/guides/resources/sockets.md +++ /dev/null @@ -1,111 +0,0 @@ -# Sockets - -Sockets are **[file descriptors](https://en.wikipedia.org/wiki/File_descriptor)** that serve as the communication end-points for processes running on a operating system like Linux. A socket connection is a bidirectional communication interface that allows two processes to exchange information within a network. - -Sockets are the interface to use the [TCP protocol](https://en.wikipedia.org/wiki/Transmission_Control_Protocol). Sockets allow applciations to send and receive data from a TCP connection just like reading and writing to a file using a [file descriptor](https://en.wikipedia.org/wiki/File_descriptor). Hence they are used to implement client and server applications. The server process creates a socket and listens on it for clients' requests. - -![socket.png](/assets/phase-0-overview/socket.png) - -The main two types of sockets in networking: - -- `SOCK_STREAM`: Stream sockets ensure that data is delivered in the order it was sent and without errors. For example web browsing ([HTTP](https://en.wikipedia.org/wiki/HTTP)), email ([STMP](https://en.wikipedia.org/wiki/Simple_Mail_Transfer_Protocol)), etc use this socket type ([TCP](https://en.wikipedia.org/wiki/Transmission_Control_Protocol)). -- `SOCK_DGRAM`: Datagram sockets send packets of data, called datagrams, without establishing a connection or ensuring delivery. For example video streaming, online gaming etc. use this socket type ([UDP](https://en.wikipedia.org/wiki/User_Datagram_Protocol)). - -Each network socket is associated with an [IP address](https://en.wikipedia.org/wiki/IP_address) and a [port number](), identifying both the host and a specific application or service. - -## Flow of events - -Sockets used in a client-server model has a typical flow of events. The following figure shows the typical flow of events (and the sequence of issued APIs) for a connection-oriented socket session. An explanation of each event follows the figure. - -We will be using the following functions to setup TCP connections: - -![socket-flow.png](/assets/resources/flow-of-events.png) - -::: details int socket ( int domain, int type, int protocol ) -*Create an endpoint for communication* - -| Argument Name | Argument Type | Description | -| --- | --- | --- | -| domain | int | Specifies the communication domain (e.g., AF_INET for IPv4). | -| type | int | Specifies the communication semantics (e.g., SOCK_STREAM for TCP). | -| protocol | int | Specifies a particular protocol to be used with the socket. (default 0) | - -::: -::: details int bind ( int sockfd, const struct sockaddr * addr, int addrlen ) -*Binds a socket to a local address* - -| Argument Name | Argument Type | Description | -| --- | --- | --- | -| sockfd | int | File descriptor of the socket to bind. | -| addr | const struct sockaddr * | Pointer to a sockaddr structure that contains the address to bind to. | -| addrlen | int / socklen_t | Size of the address structure. | - -::: -::: details int listen ( int sockfd, int backlog ) -*Listen for connections on a socket* - - -| Argument Name | Argument Type | Description | -| --- | --- | --- | -| sockfd | int | File descriptor of the socket(server) to listen on. | -| backlog | int | maximum length of the queue maintaining pending connections | -::: -::: details int connect( int sockfd, const struct sockaddr * addr, int addrlen ) -*Initiates a connection on a socket.* - - -| Argument Name | Argument Type | Description | -| --- | --- | --- | -| sockfd | int | File descriptor of the socket(client). | -| addr | const struct sockaddr * | Pointer to a sockaddr structure that contains the server address to which the client wishes to connect to. | -| addrlen | int / socklen_t | Size of the address structure. | -::: -::: details int accept( int sockfd, const struct sockaddr * addr, int addrlen ) -*Accepts an incoming connection on a listening socket.* - - -| Argument Name | Argument Type | Description | -| --- | --- | --- | -| sockfd | int | File descriptor of the listening socket. | -| addr | const struct sockaddr * | Pointer to a sockaddr structure to receive the address of the connecting entity (client).See the note below.| -| addrlen | int / socklen_t | Size of the address structure. | - -Note: The fields of the sockaddr structure are filled by the OS kernel and returned after analysing the client connection details. Note that the client doesnot set this structure in the connect() system call. -::: -::: details int send( int sockfd, const void * buf, int len, int flags ) -*Send a message on a socket* - - -| Argument Name | Argument Type | Description | -| --- | --- | --- | -| sockfd | int | File descriptor of the connected socket. | -| buf | const void * | Pointer to he buffer containing the data to be sent. | -| len | int | Length of the data to be sent. | -| flags | int | Bitwise OR of flags controlling the operation(Default 0). | -::: -::: details int recv( int sockfd, const void * buf, int len, int flags ) -Recieves *a message from a socket* - -| Argument Name | Argument Type | Description | -| --- | --- | --- | -| sockfd | int | File descriptor of the connected socket. | -| buf | const void * | Pointer to the buffer to receive the data. | -| len | int | Length of the buffer. | -| flags | int | Bitwise OR of flags controlling the operation(Default 0). | -::: -::: details int close( int sockfd ) -*Closes a socket* - -| Argument Name | Argument Type | Description | -| --- | --- | --- | -| sockfd | int | File descriptor of the socket to close. | - -::: - -1. **Socket creation:** The process begins with the creation of a socket using the `socket()` system call. This call initializes a communication endpoint and returns a [file descriptor](https://en.wikipedia.org/wiki/File_descriptor). -2. **Binding (optional):** In server applications, the socket may be bound to a specific address and port using the `bind()` system call. This step is necessary for servers to listen for incoming connections on a specific network interface and port. (Bind is optional for client sockets as the operating system assigns a local address and port automatically) -3. **Listening (Server Only)**: Server then enters the listening state using the `listen()` system call, indicating their readiness to accept incoming connections from clients. -4. **Connection Establishment (Client)**: Clients initiate a connection to the server by using the `connect()` system call, specifying the server's address and port. This call establishes a connection to the server, allowing for data exchange. -5. **Accepting Connections (Server):** Upon receiving a connection request from a client, the server accepts the connection using the `accept()` system call. This call creates a new socket specifically for communication with the client. -6. **Data Exchange**: Once the connection is established, both the client and server can send and receive data using the `send()` and `recv()` system calls, respectively. Data sent by one party is received by the other, allowing for bidirectional communication. -7. **Connection Termination**: When communication is complete, either party can initiate the termination of the connection using the `close()` system call. This releases the allocated resources associated with the socket and terminates the communication channel. diff --git a/docs/guides/resources/system-calls.md b/docs/guides/resources/system-calls.md new file mode 100644 index 0000000..0086efc --- /dev/null +++ b/docs/guides/resources/system-calls.md @@ -0,0 +1,83 @@ +# System calls + +This page briefly describes the programming interface of some of the Unix/Linux system calls that will be used in the eXpServer project. + +## Fork() + +The [`Fork()`](https://en.wikipedia.org/wiki/Fork_(system_call)) system call is used for creating a new process (child process) which runs concurrently with the process that makes the `fork()` call (parent process). With forking, the operating system creates a **child process**, which is an exact copy of the **parent process**. This includes copying the process's memory, file descriptors, and execution context, stack and heap. The parent process and child process run in separate memory address spaces. After a new child process is created, both processes will execute the next instruction following the `fork()` system call. + +```c +#include +pid_t fork(void); +``` + +- **`pid = fork()`**: This creates a new process. The return value is stored in `pid` (integer). +- **Child Process**: `fork()` returns `0` +- **Parent Process**: `fork()` returns a positive value (the PID of the child process) +- **Error Handling**: If `fork()` returns a negative value, it indicates that the process creation is failed. + +**Use Case**: + +- The `fork()` system call is often used in server applications to handle multiple clients concurrently by creating a new process that handles communication with each client. + +## wait() + +`wait()` blocks the calling process until one of its child processes exits or a [signal](https://en.wikipedia.org/wiki/C_signal_handling) is received. If `wait()` returns after some child process terminates, the PID of the child is returned by `wait()` (If a process unblocks from `wait()` due to a signal, -1 is the return value. We don't need this case in our project). After return from `wait()`, the parent continues its execution from the next instruction after the `wait()` system call. `wait()` requires an integer pointer argument in which the exit status of the child is stored (relevant only if `wait()` unblocks due to termination of a child). The caller is supposed to allocate the memory for the pointer argument before the calls. In this project, we will not require the [exit status](https://en.wikipedia.org/wiki/Exit_status) of the child and will pass NULL instead. + +```c +#include +pid_t wait(int *); +``` + +## getpid() + +```c +#include +pid_t getpid(void); +``` + +getpid() returns the process id (PID) of the calling process. + +## pthread_create() + +**Header :** `#include ` + +```c +int pthread_create(pthread_t * thread, + const pthread_attr_t * attr, + void * (*start_routine)(void *), + void *arg); +``` + +**Description :** The `pthread_create()` function shall create a new thread, with attributes specified by *attr*, within a process. + +**Return Value :** On success, `pthread_create()` returns 0; on error, it returns an error number, and the contents of *thread are undefined. Upon successful completion, `pthread_create()` shall store the ID of the created thread in the location referenced by *thread*. + +| Argument Name | Argument Type | Description | +| --- | --- | --- | +| thread | `pthread_t *` | pointer to an unsigned integer value that returns the thread id of the thread created. If the call is successful, `pthread_create()` will populate the pointer with the address of the location storing the thread ID of the process. If the call fails, the value is undefined. | +| attr | `const pthread_attr_t *` | pointer to a structure that is used to define thread attributes. The thread attributes includes a) detached state which controls whether the thread created is in a joinable or detached state, b) stack address which is used to set a specific memory location as the base address of stack for the thread, c) scheduling policy etc. Here we set to NULL for default thread attributes (i.e default stack size, default scheduling policy, joinable thread (the thread will not be detached by default)). | +| start_routine | `void *` | pointer to a subroutine (function pointer) that is executed by the thread. The return type and parameter type of the subroutine must be of type `void *`. The function has a single attribute, but if multiple values need to be passed to the function, a structure can be used. | +| arg | `void *` | pointer to void that contains the arguments to the function defined in the start_routine. Typically a structure pointer with values of arguments to the start_routine are passed in practice. | + +## **pthread_exit()** + +**Header**: `#include ` + +`void pthread_exit(void *status);` + +**Description** : Ends the calling thread and makes *status* available to any thread that calls `pthread_join()` with the thread ID of the terminating thread. + +**Return value :** The function’s return type is void however the return status of the terminated thread is stored in *status* which is defined as a pointer (`void *`), so it can point to any data type, including a simple integer or a more complex structure. The scope of this variable must be global so that any thread waiting to join this thread may read the return status. + +## pthread_detach() + +**Header** : `#include ` + +`int pthread_detach(pthread_t thread);` + +**Description** : The `pthread_detach()` function marks the thread identified by *thread* as detached. When a detached thread terminates, TCB and all other resources related to the thread (such as its stack and registers) are **immediately de allocated** by the operating system without the need for another thread to join with the terminated thread. Attempting to detach an already detached thread results in unspecified behavior. + +**Return value**: on success, returns 0.If error occurs returns an error number + +- **thread:** thread id of the thread that must be detached. diff --git a/docs/guides/resources/tcp-ip-model.md b/docs/guides/resources/tcp-ip-model.md index 0ca05af..a79dc35 100644 --- a/docs/guides/resources/tcp-ip-model.md +++ b/docs/guides/resources/tcp-ip-model.md @@ -45,11 +45,11 @@ At the bottom of the TCP/IP model is the Data Link layer. This layer deals with Just as in the case of Interent layer, there is no direct interaction with the Data Link layer. -### Data Flow over TCP/IP model +## Data Flow over TCP/IP model Now let us look into how the data flow occurs from the source to destination through different layers of the TCP/IP model. -Let’s take an example of a client(browser) requesting for a web page from the server. Here the client interacts with the application layer (user interface), i.e requesting the webpage by entering a URL. The data from the application layer now moves to the transport layer through the **socket**(to do-add link) created.Here, the data is fragmented into TCP segments and header is added to each of the segments,this header contains sending and receiving port numbers along with other fields, we will soon explain why this port number is included.These segments are further passed down to the Network layer where one more header is added to form the IP datagrams, this IP header contains source and destination IP address along with certain other fields(will explore the fields later). Then, IP datagrams are passed on to the lower layer i.e Data Link layer, here another header is added to form a link layer frame, this header includes the source and destination MAC address. This is how data encapsulation occurs in different layers of TCP/IP Protocol suite. Later, the physical layer sends the frame out over the network media. Inbetween the source and destination, the packets are passed through switches and routers. On reaching the final destination, the headers are removed sequentially at each layer(decapsulation), and finally data reaches the application layer of the destination. +Let’s take an example of a client(browser) requesting for a web page from the server. Here the client interacts with the application layer (user interface), i.e requesting the webpage by entering a URL. The data from the application layer now moves to the transport layer through the [socket](https://en.wikipedia.org/wiki/Network_socket) created. Here, the data is fragmented into TCP segments and header is added to each of the segments, this header contains sending and receiving port numbers along with other fields, we will soon explain why this port number is included. These segments are further passed down to the Network layer where one more header is added to form the IP datagrams, this IP header contains source and destination IP address along with certain other fields(will explore the fields later). Then, IP datagrams are passed on to the lower layer i.e Data Link layer, here another header is added to form a link layer frame, this header includes the source and destination MAC address. This is how data encapsulation occurs in different layers of TCP/IP Protocol suite. Later, the physical layer sends the frame out over the network media. In between the source and destination, the packets are passed through switches and routers. On reaching the final destination, the headers are removed sequentially at each layer(decapsulation), and finally data reaches the application layer of the destination. ![tcp-ip-header.png](/assets/resources/tcp-ip-header.png) @@ -59,9 +59,11 @@ Lets look into the structure of both TCP segment and IP datagram : ### Port Number -The **source port** helps the receiver know which application on the sender's side sent the data. It also helps in mapping return traffic to the correct application or service. The **destination port** is the port number on the receiving device that indicates which specific service or application the data is intended for. Thus, the port number ensures application to application communication. +The **source port** helps the receiver to know which application on the sender's side sent the data. It also helps in mapping return traffic to the correct application or service. The **destination port** is the port number on the receiving device that indicates which specific service or application the data is intended for. Thus, the port number ensures application to application communication. +::: info Ports 0-1023 are reserved for well-known services (like HTTP, DNS) to ensure consistent network communication and prevent conflicts. Their use is restricted to privileged processes for security reasons. So the temporary port numbers are chosen from the range of dynamic ports (typically 1024–65535). +::: ### IP Address diff --git a/docs/guides/resources/tcp-socket-programming.md b/docs/guides/resources/tcp-socket-programming.md index 73f057f..ab1f176 100644 --- a/docs/guides/resources/tcp-socket-programming.md +++ b/docs/guides/resources/tcp-socket-programming.md @@ -2,14 +2,14 @@ Have you ever thought about how we are able to get websites through browsers on searching, how emails are delivered, and how files are transmitted between devices. All these should happen reliably. TCP Protocol in the [**Transport layer**](/guides/resources/tcp-ip-model) plays a crucial role in ensuring this. -::: tip Before looking into what TCP is, and its significance in networking, you should have a proper understanding of the layers in the TCP/IP model and how they are interconnected. +::: tip Before looking into what TCP is, and its significance in networking, you should have a proper understanding of the layers in the [TCP/IP Model](https://simple.wikipedia.org/wiki/TCP/IP_model) and how they are interconnected. ::: -### TCP(Transmission Control Protocol) +## TCP (Transmission Control Protocol) Let us look into the TCP Protocol in detail. **Transmission Control Protocol (TCP)** is part of the [Transport Layer](https://en.wikipedia.org/wiki/Transport_layer) of the [TCP/IP suite](https://en.wikipedia.org/wiki/Internet_protocol_suite). TCP ensures that all data sent is received by the recipient in the correct order. If packets are lost, TCP will re-transmit them until they are correctly received. Thus it ensures a reliable transmission of data. Before any data is sent, TCP requires a connection to be established between the client and server. This connection setup involves a three-way handshake. -**The Phases of TCP operations** +### The Phases of TCP operations The working of [TCP protocol](https://en.wikipedia.org/wiki/Transmission_Control_Protocol#Protocol_operation) can be broadly divided into three different phases. These steps fit into three main stages: @@ -19,19 +19,19 @@ The working of [TCP protocol](https://en.wikipedia.org/wiki/Transmission_Control ### **TCP segments** -When the Transmission Control Protocol receives a data stream, divides it up, and adds a TCP header to the transfer, the data stream becomes a “TCP segment.” The TCP header ensures that when the individual data packets arrive at their destination, they can easily be arranged in the correct order. +When the Transmission Control Protocol receives a data stream, divides it up, and adds a TCP header to the transfer, the data stream becomes a '**TCP segment**'. The TCP header ensures that when the individual data packets arrive at their destination, they can easily be arranged in the correct order. -In the connection establishment phase, applications can announce their Maximum Segment Size (MSS), which defines the largest TCP segment they will exchange. This represents the largest amount of data that will be transmitted in a single segment. If the MSS is too large, IP fragmentation will break the individual packets into smaller pieces. The packets are re-ordered correctly on reaching the destination. The minimum header size for a TCP segment is 20 bytes and maximum header size is 60 bytes. The default maximum segment size for IPv4 is 536 bytes and for IPv6 it is 1220 bytes. +In the connection establishment phase, applications can announce their [**Maximum Segment Size**](https://en.wikipedia.org/wiki/Maximum_segment_size) (**MSS**), which defines the largest TCP segment they will exchange. This represents the largest amount of data that will be transmitted in a single segment. If the MSS is too large, it can cause the packet to exceed the [**Maximum Transmission Unit**](https://en.wikipedia.org/wiki/Maximum_transmission_unit) (**MTU**) of the underlying network. So the IP fragmentation will break the individual packets into smaller pieces. The packets are re-ordered correctly on reaching the destination. The minimum header size for a TCP segment is 20 bytes and maximum header size is 60 bytes. The default maximum segment size for IPv4 is 536 bytes and for IPv6 it is 1220 bytes. ![tcp-ip-packet.png](/assets/resources/tcp-ip-packet.png) -### **Socket Programming** +## **Socket Programming** Sockets provide a programming interface that allows two application programs or processes to communicate with each other over a network using the TCP protocol. They enable these programs on different host machines to send and receive data reliably and efficiently. The Unix/Linux socket programming interface, provided in the `sys/socket.h` header, contains declarations of a set of functions that can be invoked by applications to carry out various actions such as establishment of connection, transmission and reception of data, connection termination etc. The socket programming interface also provides functions that allow use of other transport layer protocols including UDP. Although sockets primarily connect processes on a computer network, they also enable communication between processes on the same device. The same-machine connections use the [IPC (Inter-process communication)](https://en.wikipedia.org/wiki/Inter-process_communication) sockets, also known as [Unix domain sockets](https://en.wikipedia.org/wiki/Unix_domain_socket). In Unix-like systems, sockets are treated as [file descriptors](https://en.wikipedia.org/wiki/Inter-process_communication). ![socket.png](/assets/phase-0-overview/socket.png) -Sockets are commonly used in a [client-server](https://en.wikipedia.org/wiki/Client%E2%80%93server_model) network. In this model, the server socket listens and waits for clients' requests. The clients exchange information with the server using [TCP/IP](/guides/resources/tcp-ip-model) protocol. Application programs such as browsers and email servers/clients that use the [HTTP and](/guides/resources/http) [SMTP](https://en.wikipedia.org/wiki/Simple_Mail_Transfer_Protocol) protocols respectively at the application layer also use the socket programming interface for transport layer communication. +Sockets are commonly used in a [client-server](https://en.wikipedia.org/wiki/Client%E2%80%93server_model) network. In this model, the server socket listens and waits for client's requests. The clients exchange information with the server using [TCP/IP](/guides/resources/tcp-ip-model) protocol. Application programs such as browsers and email servers/clients that use the [HTTP and](/guides/resources/http) [SMTP](https://en.wikipedia.org/wiki/Simple_Mail_Transfer_Protocol) protocols respectively at the application layer also use the socket programming interface for transport layer communication. Sockets in networking are typically classified as follows: @@ -39,16 +39,20 @@ Sockets in networking are typically classified as follows: - `SOCK_DGRAM`: Datagram sockets send packets of data, called datagrams, without establishing a connection or ensuring delivery. UDP protocol uses this type of socket. Eg: Video streaming, online gaming etc use this socket type. - `SOCK_RAW`: Raw sockets provide access to lower-level network protocols (like IP) and is often used for custom protocols or network monitoring tools. -Each network socket is associated with an [IP address](https://en.wikipedia.org/wiki/IP_address) and a [port number](https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers), identifying both the host and a specific application or service. **Socket address** is the combination of both **IP address and port number**. +Each network socket is associated with an [IP address](https://en.wikipedia.org/wiki/IP_address) and a [port number](https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers), identifying both the host and a specific application or service. -## Flow of events +::: tip +**Socket address** is the combination of both **IP address** and **port number**. +::: + +## Flow of events in TCP A socket has a typical flow of events. The following figure shows the typical flow of events (and the sequence of function calls) for a connection-oriented socket session in TCP. An explanation of each event follows the figure. ![socket-flow.png](/assets/resources/flow-of-events.png) 1. **Socket creation:** An application process that uses sockets for communication begins with the creation of a socket using the `socket()` system call. This call returns a file descriptor. - ::: details socket() + ::: details `socket()` **Header** : `#include ` @@ -60,30 +64,30 @@ A socket has a typical flow of events. The following figure shows the typical fl | Argument Name | Argument Type | Description | | --- | --- | --- | - | domain | int | Specifies the communication domain.This selects the protocol family which will be used for communication. (e.g., `AF_INET` for [IPv4,](https://en.wikipedia.org/wiki/IPv4) `AF_INET6` for [IPv6](https://en.wikipedia.org/wiki/IPv6)). In this project we will be using IPv4. | - | type | int | Specifies the communication semantics (e.g., `SOCK_STREAM` - Provides sequenced, reliable, two-way, connection-based byte streams.Used with TCP. `SOCK_DGRAM` - Supports connection less, unreliable messages of a fixed maximum length. Used with UDP. The following options, which are not used in the project, are also supported. `SOCK_RAW` - Provides raw network protocol access. `SOCK_SEQPACKET` - Provides a sequenced, reliable, two-way connection-based data transmission path for datagrams of fixed maximum length). | - | protocol | int | Specifies the particular protocol to be used with the socket. When `0` is passed as the protocol argument, 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. | + | domain | `int` | Specifies the communication domain.This selects the protocol family which will be used for communication. (e.g., `AF_INET` for [IPv4,](https://en.wikipedia.org/wiki/IPv4) `AF_INET6` for [IPv6](https://en.wikipedia.org/wiki/IPv6)). In this project we will be using IPv4. | + | type | `int` | Specifies the communication semantics (e.g., `SOCK_STREAM` - Provides sequenced, reliable, two-way, connection-based byte streams, Used with TCP. `SOCK_DGRAM` - Supports connection less, unreliable messages of a fixed maximum length, Used with UDP. The following options, which are not used in the project, are also supported. `SOCK_RAW` - Provides raw network protocol access. `SOCK_SEQPACKET` - Provides a sequenced, reliable, two-way connection-based data transmission path for datagrams of fixed maximum length). | + | protocol | `int` | Specifies the particular protocol to be used with the socket. When `0` is passed as the protocol argument, 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. | ::: 2. **Binding :** In server applications, the socket may be bound to a specific [IP address](https://en.wikipedia.org/wiki/IP_address) and [Port Number](https://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers) using the `bind()` system call. This step is necessary for servers to listen to incoming connections on a specific IP address and port number. (Bind is optional for client sockets, as the operating system assigns a local IP address and port number automatically) - ::: details bind() + ::: details `bind()` **Header** : `#include ` `int bind ( int sockfd, const struct sockaddr *addr, socklen_t addrlen );` - **Description :** When a socket is created with socket(), it has no socket address assigned to it. The bind() assigns the IP address and port number specified by ***addr*** to the socket referred to by the file descriptor ***sockfd***. + **Description :** When a socket is created with `socket()`, it has no socket address assigned to it. The `bind()` assigns the IP address and port number specified by ***addr*** to the socket referred to by the file descriptor ***sockfd***. **Return Value :** On success, zero is returned. On error, -1 is returned, and [***errno***](https://man7.org/linux/man-pages/man3/errno.3.html) is set to indicate the error. | Argument Name | Argument Type | Description | | --- | --- | --- | - | sockfd | int | Specifies the file descriptor of the socket to be bound. | - | addr | const struct sockaddr * | Points to a **`sockaddr`** structure containing the address to be bound to the socket. The length and format of the address depend on the address family of the socket. | + | sockfd | `int` | Specifies the file descriptor of the socket to be bound. | + | addr | `const struct sockaddr *` | Points to a **`sockaddr`** structure containing the address to be bound to the socket. The length and format of the address depend on the address family of the socket. | | addrlen | `socklen_t` | Specifies the length of the **`sockaddr`** structure pointed to by the *addr* argument. | ::: details `struct sockaddr` - The **`sockaddr`** structure is used to define a socket address. The ** header shall define the **sockaddr** structure that includes at least the following members: + The **`sockaddr`** structure is used to define a socket address. The `` header shall define the **sockaddr** structure that includes at least the following members: ```c struct sockaddr{ @@ -94,105 +98,106 @@ A socket has a typical flow of events. The following figure shows the typical fl }; ``` - **sa_family_t ****is defined as an *unsigned integer* type in ** header. + `sa_family_t` is defined as an *unsigned integer* type in `` header. ::: details `socklen_t` - **socklen_t** is an *unsigned opaque integer type* of length of at least 32 bits (the exact length depends on the host machine). It is included in ** header. socklen_t enables writing code in a platform independent manner. The header may use different definitions according to the target platform. + `socklen_t` is an *unsigned opaque integer type* of length of at least 32 bits (the exact length depends on the host machine). It is included in `` header. `socklen_t` enables writing code in a platform independent manner. The header may use different definitions according to the target platform. ::: 3. **Listening (Server Only)**: Servers transition into a listening state using the `listen()` system call, indicating their readiness to accept incoming connections from clients. - ::: details listen() + ::: details `listen()` **Header** : `#include ` `int listen ( int sockfd, int backlog );` - **Description :** listen() marks the socket referred to by sockfd as a passive socket, that is, as a socket that will be used to accept incoming connection requests. + **Description :** `listen()` marks the socket referred to by sockfd as a passive socket, that is, as a socket that will be used to accept incoming connection requests. **Return Value :** On success, zero is returned. On error, -1 is returned, and [***errno***](https://man7.org/linux/man-pages/man3/errno.3.html) is set to indicate the error. | Argument Name | Argument Type | Description | | --- | --- | --- | - | sockfd | int | The sockfd is a file descriptor(of server) that refers to a socket of type `SOCK_STREAM` or `SOCK_SEQPACKET` to listen on. | - | backlog | int | The backlog defines the maximum length to which the queue of pending connections for sockfd may grow. a)if backlog less than 0, the function sets the length of the listen queue to 0. b)If **backlog** exceeds the maximum queue length specified, the length will be set to the maximum supported value. + | sockfd | `int` | The sockfd is a file descriptor(of server) that refers to a socket of type `SOCK_STREAM` or `SOCK_SEQPACKET` to listen on. | + | backlog | `int` | The backlog defines the maximum length to which the queue of pending connections for sockfd may grow. a) if backlog less than 0, the function sets the length of the listen queue to 0. b) If backlog exceeds the maximum queue length specified, the length will be set to the maximum supported value. | ::: 4. **Connection Establishment (Client)**: Clients initiate a connection to the server by using the `connect()` system call, specifying the server's address and port. This call establishes a connection to the server, allowing for data exchange. - ::: details connect() + ::: details `connect()` **Header** : `#include ` `int connect( int sockfd, const struct sockaddr * addr, socklen_t addrlen );` - **Description** : The connect() system call connects the socket referred by the file descriptor sockfd to the address specified by ***addr***. The `connect()` system call is normally called by the client process to connect to the server process. + **Description** : The `connect()` system call connects the socket referred by the file descriptor sockfd to the address specified by ***addr***. The `connect()` system call is normally called by the client process to connect to the server process. **Return Value :** If the connection succeeds, zero is returned. On error, -1 is returned, and [errno](https://man7.org/linux/man-pages/man3/errno.3.html) is set to indicate the error. | Argument Name | Argument Type | Description | | --- | --- | --- | - | sockfd | int | Specifies the file descriptor associated with the socket(of client). | - | addr | const struct sockaddr * | Pointer to a `sockaddr` structure that contains the server address to which the client wishes to connect to. The length and format of the address depend on the address family of the socket. | - | addrlen | socklen_t | Specifies the length of the **sockaddr** structure pointed to by the *addr* argument | + | sockfd | `int` | Specifies the file descriptor associated with the socket(of client). | + | addr | `const struct sockaddr *` | Pointer to a `sockaddr` structure that contains the server address to which the client wishes to connect to. The length and format of the address depend on the address family of the socket. | + | addrlen | `socklen_t` | Specifies the length of the `sockaddr` structure pointed to by the *addr* argument | ::: 5. **Accepting Connections (Server):** Upon receiving a connection request from a client, the server accepts the connection using the `accept()` system call. This call creates a new socket specifically for communication with the client. - ::: details accept() + ::: details `accept()` **Header** : `#include ` `int accept ( int sockfd, struct sockaddr *addr, socklen_t *addrlen );` - **Description :** The accept() system call is used with connection-based socket types (SOCK_STREAM, SOCK_SEQPACKET) for accepting an incoming connection on a listening socket. It extracts the first connection request on the queue of pending connections for the listening socket, sockfd, creates a new connected socket ( with the same socket type protocol and address family as the specified socket), and returns a new file descriptor referring to that socket. The newly created socket is not in the listening state. The original socket sockfd is unaffected by this call. + **Description :** The `accept()` system call is used with connection-based socket types (`SOCK_STREAM`, `SOCK_SEQPACKET`) for accepting an incoming connection on a listening socket. It extracts the first connection request on the queue of pending connections for the listening socket, sockfd, creates a new connected socket ( with the same socket type protocol and address family as the specified socket), and returns a new file descriptor referring to that socket. The newly created socket is not in the listening state. The original socket sockfd is unaffected by this call. **Return Value :** On success, return a file descriptor for the accepted socket (a non negative integer). On error, -1 is returned, errno is set to indicate the error, and addrlen is left unchanged. | Argument Name | Argument Type | Description | | --- | --- | --- | - | sockfd | int | sockfd refers to a listening socket that has been created with `socket()`, bound to a local address with `bind()`, and is listening for connections after a `listen()`. | - | addr | const struct sockaddr * | Pointer to a `sockaddr` structure to receive the address of the connecting entity (client).See the note below. | + | sockfd | `int` | sockfd refers to a listening socket that has been created with `socket()`, bound to a local address with `bind()`, and is listening for connections after a `listen()`. | + | addr | `const struct sockaddr *` | Pointer to a `sockaddr` structure to receive the address of the connecting entity (client).See the note below. | | addrlen | `socklen_t` | Points to a `socklen_t` structure which on input specifies the length of the supplied **`sockaddr`** structure, and on output specifies the length of the stored address. | - Note: The fields of the `sockaddr` structure are filled by the OS kernel and returned after analyzing the client connection details. Note that the client does not set this structure in the connect() system call. + Note: The fields of the `sockaddr` structure are filled by the OS kernel and returned after analyzing the client connection details. Note that the client does not set this structure in the `connect()` system call. ::: 6. **Data Exchange**: Once the connection is established, both the client and server can send and receive data using the `send()` and `recv()` system calls, respectively. Data sent by one party is received by the other, allowing for bidirectional communication. - ::: details send() + ::: details `send()` - **Header** : `#include ` + **Header** : `#include ` `ssize_t send( int sockfd, const void *buf, size_t len, int flags );` - **Description :** The system call send() is used to transmit a message to another socket. The send() call may be used only when the socket is in a connected state (so that the intended recipient is known). + **Description :** The system call `send()` is used to transmit a message to another socket. The `send()` call may be used only when the socket is in a connected state (so that the intended recipient is known). **Return Value :** On success, these calls return the number of bytes sent. On error, -1 is returned, and [errno](https://man7.org/linux/man-pages/man3/errno.3.html) is set to indicate the error. - When the message does not fit into the send buffer of the socket, send() normally blocks, unless the socket has been placed in nonblocking I/O mode. + When the message does not fit into the send buffer of the socket, `send()` normally blocks, unless the socket has been placed in nonblocking I/O mode. | Argument Name | Argument Type | Description | | --- | --- | --- | - | sockfd | int | File descriptor of the sending socket | - | buf | const void * | Pointer to the buffer containing the data to be sent. | - | len | size_t | Length of the data to be sent in bytes. | - | flags | int | This is used to specify various options or behaviors for the `send()` operation. Commonly, this argument is set to `0` to indicate no special behavior. Eg: `MSG_CONFIRM` flag ensures that destination address is confirmed as reachable, `MSG_OOB` flag is used for urgent messages. | + | sockfd | `int` | File descriptor of the sending socket | + | buf | `const void *` | Pointer to the buffer containing the data to be sent. | + | len | `size_t` | Length of the data to be sent in bytes. | + | flags | `int` | This is used to specify various options or behaviors for the `send()` operation. Commonly, this argument is set to `0` to indicate no special behavior. Eg: `MSG_CONFIRM` flag ensures that destination address is confirmed as reachable, `MSG_OOB` flag is used for urgent messages. | ::: - ::: details recv() + ::: details `recv()` **Header** : `#include ` - `ssize_t recv ( int socket, const void *buf, size_t length, int flags );` + + `ssize_t recv ( int socket, const void *buf, size_t length, int flags );` - **Description :** The *recv*() function shall receive a message from a socket. It is normally used with connected sockets because it does not permit the application to retrieve the source address of received data. The recv() function receives data on a socket and stores it in a buffer. The recv() call applies only to connected sockets. + **Description :** The `recv()` function shall receive a message from a socket. It is normally used with connected sockets because it does not permit the application to retrieve the source address of received data. The `recv()` function receives data on a socket and stores it in a buffer. The `recv()` call applies only to connected sockets. **Return Value :** It return the number of bytes received, or -1 if an error occurred. In the event of an error, [errno](https://man7.org/linux/man-pages/man3/errno.3.html) is set to indicate the error. If a message is too long to fit in the supplied buffer, excess bytes may be discarded depending on the type of socket the message is received from. | Argument Name | Argument Type | Description | | --- | --- | --- | - | sockfd | int | File descriptor of the connected socket. | - | buf | const void * | Pointer to the buffer to receive the data. | - | len | int | Length of the buffer. | - | flags | int | This is used to specify various options or behaviors for the `recv()` operation. Commonly, this argument is set to `0` to indicate no special behavior. Eg: `MSG_DONTWAIT` flag makes the `recv()` operation non-blocking, `MSG_WAITALL` flag enables waiting until the full amount of requested data is received. | + | sockfd | `int` | File descriptor of the connected socket. | + | buf | `const void *` | Pointer to the buffer to receive the data. | + | len | `int` | Length of the buffer. | + | flags | `int` | This is used to specify various options or behaviors for the `recv()` operation. Commonly, this argument is set to `0` to indicate no special behavior. Eg: `MSG_DONTWAIT` flag makes the `recv()` operation non-blocking, `MSG_WAITALL` flag enables waiting until the full amount of requested data is received. | ::: 7. **Connection Termination**: When communication is complete, either party can initiate the termination of the connection using the `close()` system call. This releases the allocated resources associated with the socket and terminates the communication channel. - ::: details close() + ::: details `close()` **Header :** `#include ` @@ -204,5 +209,5 @@ A socket has a typical flow of events. The following figure shows the typical fl | Argument Name | Argument Type | Description | | --- | --- | --- | - | sockfd | int | File descriptor of the socket to close. | + | sockfd | `int` | File descriptor of the socket to close. | ::: diff --git a/docs/guides/resources/tcp.md b/docs/guides/resources/tcp.md deleted file mode 100644 index 10030eb..0000000 --- a/docs/guides/resources/tcp.md +++ /dev/null @@ -1,19 +0,0 @@ -# TCP - -**Transmission Control Protocol (TCP)** is part of the [Transport Layer](https://en.wikipedia.org/wiki/Transport_layer) of the [TCP/IP suite](https://en.wikipedia.org/wiki/Internet_protocol_suite). TCP ensures that data sent from one device reaches its destination intact and in the correct order, handling error detection, retransmission of lost packets, flow control, and congestion control. - -TCP is used on top of [Internet Protocol](https://en.wikipedia.org/wiki/Internet_Protocol), therefore the Internet protocol stack is sometimes referred to as **TCP/IP**. - -When we want to send data over the network from the [Application layer](https://en.wikipedia.org/wiki/Application_layer), we create a **TCP socket**. For sending and receieving data from the socket, we use the socket programming API's provided by the operating system. These APIs in the form of [system calls](https://en.wikipedia.org/wiki/System_call), such as `send()` and `receive()` facilitate the bidirectional flow of data between [Application layer](https://en.wikipedia.org/wiki/Application_layer) and [Transport layer](https://en.wikipedia.org/wiki/Transport_layer). - -TCP then takes this data and breaks it into units called **TCP segments**. These segments are encapsulated with TCP headers, which contain information such as source and destination port numbers, sequence numbers, and acknowledgment numbers. - -Once the data is segmented and encapsulated, TCP passes it down to the [Internet layer](https://en.wikipedia.org/wiki/Internet_layer) for further processing and transmission over the network. - -::: tip PRE-REQUISITE READING -Read the following [sockets](/guides/resources/sockets) documentation before proceeding further. -::: - -Below is the structure of IP packets and TCP segments. This is just for our reference as we will not be directly involved in the creation of these packets and segments. The socket programming APIs provides an abstraction that makes it easier to work with them. - -![tcp-ip-packet.png](/assets/resources/tcp-ip-packet.png) diff --git a/docs/guides/resources/udp-socket-programming.md b/docs/guides/resources/udp-socket-programming.md new file mode 100644 index 0000000..0e70075 --- /dev/null +++ b/docs/guides/resources/udp-socket-programming.md @@ -0,0 +1,142 @@ +# UDP Socket Programming + +## User Datagram Protocol (UDP) + +The **User Datagram Protocol (UDP)** is a key protocol in the [**Transport Layer**](https://en.wikipedia.org/wiki/Transport_layer) of the [**TCP/IP suite**](https://en.wikipedia.org/wiki/Internet_protocol_suite). UDP provides a connection-less communication method for transferring data between devices. Unlike TCP, UDP does not guarantee data delivery, ordering, or re-transmission of lost packets. Instead, it offers a simpler, faster way to transmit data with minimal overhead. + +### **The Phases of UDP Operations** + +UDP operations are much simpler than TCP due to the lack of connection setup, error correction, or acknowledgment. Here are the main stages: + +1. **No Connection Establishment:** UDP does not require a connection to be established before data is sent. The client can start sending packets (called datagrams) to the server immediately without a handshake. +2. **Data Transmission:** In UDP ,the client and server send data as datagrams without checking if the data has been received or delivered in order. Each datagram is independent and can be delivered out of order, duplicated, or lost without any notification to the sender. There is no mechanism for re-transmission or error checking at the protocol level. UDP is best used in scenarios where speed is more critical than reliability, such as video streaming or online gaming. +3. **No Connection Termination:** Since there is no formal connection in UDP, there is no need for a termination process like in TCP. The communication ends when no more data is sent. + +### **UDP Datagrams** + +UDP handles data by dividing it into small, independent packets called “[datagrams](https://en.wikipedia.org/wiki/Datagram)”. Each datagram contains both the data and header information, including source and destination IP addresses and port numbers, but there is no ordering or acknowledgment like in TCP. If a packet is lost, it is not re-transmitted. The header size of a UDP datagram is a fixed 8 bytes. + +UDP does not provide mechanisms for dividing data into segments or handling large data sizes like TCP does. If datagrams exceed the [maximum transmission unit](https://en.wikipedia.org/wiki/Maximum_transmission_unit) (MTU) of the network, they may be fragmented at the IP layer, but UDP itself does not handle reassembly. The minimum datagram size is 8 bytes for the header, and the maximum is typically determined by the network’s MTU. + +![tcp-ip-packet.png](/assets/resources/tcp-ip-packet.png) + +## UDP Socket Programming + +When sending data over the network from the Application layer, we create a UDP socket. To send and receive data using this socket, we use the socket programming APIs provided by the operating system. These APIs include system calls like `sendto()` and `recvfrom()`, which facilitate the transmission of data between the Application layer and the Transport layer. + +The flow of events in UDP is given below: + +![udp_flow.png](/assets/resources/udp_flow.png) + +1. **Socket creation:** An application process that uses sockets for communication begins with the creation of a socket using the `socket()` system call. This call returns a file descriptor. Here we create a UDP socket using the `socket()` system call. + ::: details `socket()` + + **Header** : `#include ` + + `int socket ( int domain, int type, int protocol );` + + **Description** : creates a transport layer communication endpoint and returns a file descriptor that refers to that endpoint. + + **Return Value :** On success, a file descriptor for the new socket is returned. On error, -1 is returned, and [**errno**](https://man7.org/linux/man-pages/man3/errno.3.html) is set to indicate the error. + + | Argument Name | Argument Type | Description | + | --- | --- | --- | + | domain | `int` | Specifies the communication domain.This selects the protocol family which will be used for communication. (e.g., `AF_INET` for [IPv4,](https://en.wikipedia.org/wiki/IPv4) `AF_INET6` for [IPv6](https://en.wikipedia.org/wiki/IPv6)). In this project we will be using IPv4. | + | type | `int` | Specifies the communication semantics (e.g., `SOCK_STREAM` - Provides sequenced, reliable, two-way, connection-based byte streams, used with TCP. `SOCK_DGRAM` - Supports connection less, unreliable messages of a fixed maximum length, used with UDP. The following options, which are not used in the project, are also supported. `SOCK_RAW` - Provides raw network protocol access. `SOCK_SEQPACKET` - Provides a sequenced, reliable, two-way connection-based data transmission path for datagrams of fixed maximum length). | + | protocol | `int` | Specifies the particular protocol to be used with the socket. When `0` is passed as the protocol argument, the system selects the default protocol for the given domain and type combination. For `AF_INET` and `SOCK_DGRAM`, this typically results in UDP being chosen as the protocol, as it is the default protocol for stream sockets in the IPv4 domain. | + ::: + +2. **Binding :** In server applications, the socket may be bound to a specific [IP address](https://www.notion.so/2c33762c6bd047f39055aa2eed772611?pvs=21) and [port number](Port Number) using the `bind()` system call. This step is necessary for servers to listen to incoming connections on a specific IP address and port number. + ::: details `bind()` + + **Header** : `#include ` + + `int bind ( int sockfd, const struct sockaddr *addr, socklen_t addrlen );` + + **Description :** When a socket is created with `socket()`, it has no socket address assigned to it. The `bind()` assigns the IP address and port number specified by ***addr*** to the socket referred to by the file descriptor ***sockfd***. + + **Return Value :** On success, zero is returned. On error, -1 is returned, and + [***errno***](https://man7.org/linux/man-pages/man3/errno.3.html) is set to indicate the error. + + | Argument Name | Argument Type | Description | + | --- | --- | --- | + | sockfd | `int` | Specifies the file descriptor of the socket to be bound. | + | addr | `const struct sockaddr *` | Points to a **`sockaddr`** structure containing the address to be bound to the socket. The length and format of the address depend on the address family of the socket. | + | addrlen | `socklen_t` | Specifies the length of the **`sockaddr`** structure pointed to by the *addr* argument. | + ::: details `struct sockaddr` + + The **`sockaddr`** structure is used to define a socket address. The `` header shall define the **sockaddr** structure that includes at least the following members: + + ```c + struct sockaddr{ + + sa_family_t sa_family //Address family. + char sa_data[] //Socket address (variable-length data). + + }; + ``` + + `sa_family_t` is defined as an *unsigned integer* type in `` header. + + ::: details `socklen_t` + + **`socklen_t`** is an *unsigned opaque integer type* of length of at least 32 bits (the exact length depends on the host machine). It is included in `` header. `socklen_t` enables writing code in a platform independent manner. The header may use different definitions according to the target platform. + +3. **Data Exchange**: Data is exchanged between the client and server using `sendto()` and `recvfrom()` system calls. These calls allow sending and receiving datagrams without requiring a connection. + ::: details `sendto()` + + **Header** : `#include ` + + `ssize_t recvfrom(int sockfd,const void *buf, size_t len, int flags,const struct sockaddr *src_addr, socklen_t *addrlen);` + + **Description:** The `recvfrom()` function is used to receive data in **UDP**. It allows the receiving socket to read data sent by a specific sender and also retrieve the sender's address. Since UDP is connectionless, each call to `recvfrom()` can receive data from a different sender. + + **Return Value :** It return the number of bytes received, or -1 if an error occurred. In the event of an error, [errno](https://man7.org/linux/man-pages/man3/errno.3.html) is set to indicate the error. If a message is too long to fit in the supplied buffer, excess bytes may be discarded depending on the type of socket the message is received from. + + | Argument Name | Argument Type | Description | + | --- | --- | --- | + | sockfd | `int` | File descriptor of the socket which receive the incoming datagrams. | + | buf | `const void *` | A pointer to the buffer where the received data will be stored. | + | len | `size_t` | The maximum number of bytes to be received. | + | flags | `int` | This is used to specify various options or behaviors for the `recv()` operation. Commonly, this argument is set to `0` to indicate no special behavior. Eg: `MSG_DONTWAIT` flag makes the `recv()` operation non-blocking, `MSG_WAITALL` flag enables waiting until the full amount of requested data is received. | + | src_addr | `const struct sockaddr *` | A pointer to a `sockaddr` structure where the address of the sender will be stored. This is useful for identifying where the data came from. If this parameter is `NULL`, the sender's address is not captured. | + | addrlen | `socklen_t *` | A pointer to a variable containing the size of the `sockaddr` structure. When `recvfrom()` returns, this variable will be updated to reflect the actual size of the sender’s address. | + ::: + +4. **Connection Termination**: When communication is complete, either party can initiate the termination of the connection using the `close()` system call. This releases the allocated resources associated with the socket and terminates the communication channel. + ::: details `close()` + + **Header :** `#include ` + + `int close(int fd);` + + **Description :** closes a file descriptor, so that it no longer refers to any file and may be reused. + + **Return Value :** returns zero on success. On error, -1 is returned, and [errno](https://man7.org/linux/man-pages/man3/errno.3.html) is set to indicate the error. + + | Argument Name | Argument Type | Description | + | --- | --- | --- | + | sockfd | `int` | File descriptor of the socket to close. | + ::: \ No newline at end of file diff --git a/docs/guides/resources/udp.md b/docs/guides/resources/udp.md deleted file mode 100644 index a300669..0000000 --- a/docs/guides/resources/udp.md +++ /dev/null @@ -1,50 +0,0 @@ -# UDP - -**User Datagram Protocol (UDP)** is part of the Transport Layer of the TCP/IP suite. UDP provides a connectionless communication method for sending data between devices. Unlike TCP, UDP does not guarantee data delivery, ordering, or error recovery. Instead, it offers a simpler, faster way to transmit data with minimal overhead. - -When sending data over the network from the Application layer, we create a UDP socket. To send and receive data using this socket, we use the socket programming APIs provided by the operating system. These APIs include system calls like `sendto()` and `recvfrom()`, which facilitate the transmission of data between the Application layer and the Transport layer. - -![udp-ip-packet.png](/assets/resources/udp-ip-packet.png) - -Here’s how UDP handles data: -1. **Socket Creation:** - - **UDP Socket:** An application creates a UDP socket using the `socket()` system call, specifying the UDP protocol. -2. **Data Transmission:** -- **Sending Data:** When data is sent via a UDP socket, the data is provided to the `sendto()` system call. The data is then encapsulated in UDP packets (datagrams). - -::: details int sendto( int sockfd, const void * buf, int len, int flags, const struct sockaddr * dest_addr, int addr_len) -*Send data to a specific address without establishing a connection* - - -| Argument Name | Argument Type | Description | -| --- | --- | --- | -| sockfd | int | File descriptor of the socket. | -| buf | const void * | Pointer to he buffer containing the data to be sent. | -| len | int | Length of the data to be sent. | -| flags | int | Bitwise OR of flags controlling the operation(Default 0). | -| dest_addr | const struct sockaddr * | Pointer to a sockaddr structure that contains destination address. | -| addr_len | int | The size of the destination address. | -::: - -- **Receiving Data:** The `recvfrom()` system call is used to receive data from the socket. The received UDP datagram is then passed up to the application layer. - -::: details int recvfrom( int sockfd, const void * buf, int len, int flags, const struct sockaddr * src_addr, int addr_len) -*Send data to a specific address without establishing a connection* - - -| Argument Name | Argument Type | Description | -| --- | --- | --- | -| sockfd | int | File descriptor of the socket. | -| buf | const void * | Pointer to he buffer containing the data to be sent. | -| len | int | Length of the data to be sent. | -| flags | int | Bitwise OR of flags controlling the operation(Default 0). | -| src_addr | const struct sockaddr * | Pointer to a sockaddr structure that contains source address. | -| addr_len | int | The size of the source address. | -::: - -3. **UDP Datagram Structure:** - - **Datagram Format:** A UDP datagram consists of a UDP header and the data payload. The UDP header includes fields such as: - - **Source Port:** The port number of the sending application. - - **Destination Port:** The port number of the receiving application. - - **Length:** The length of the UDP header and payload. - - **Checksum:** Used for error checking, but it's optional in IPv4. \ No newline at end of file diff --git a/docs/roadmap/index.md b/docs/roadmap/index.md index 43b31e6..85e1fcd 100644 --- a/docs/roadmap/index.md +++ b/docs/roadmap/index.md @@ -27,8 +27,8 @@ The eXpServer project comprises 24 stages, organized into 5 phases. Prior to the - ✅ [Stage 0: Setup](phase-0/stage-0) - ✅ [Stage 1: TCP Server](phase-0/stage-1) - ✅ [Stage 2: TCP Client](phase-0/stage-2) -- ✅ [Stage 3: Linux epoll](phase-0/stage-3) -- 🟡 [Stage 4: UDP with Multi-threading](phase-0/stage-4) +- 🟡 [Stage 3: UDP with Multi-threading](phase-0/stage-3) +- ✅ [Stage 4: Linux Epoll](phase-0/stage-4) - ✅ [Stage 5: TCP Proxy](phase-0/stage-5) ### Phase 1: Building the core of eXpServer by creating reusable modules diff --git a/docs/roadmap/phase-0/stage-1.md b/docs/roadmap/phase-0/stage-1.md index b38a0a3..7b308f0 100644 --- a/docs/roadmap/phase-0/stage-1.md +++ b/docs/roadmap/phase-0/stage-1.md @@ -14,7 +14,6 @@ - Read about the [TCP/IP Model](/guides/resources/tcp-ip-model) - Read about [TCP Socket Programming](/guides/resources/tcp-socket-programming) - ::: @@ -241,7 +240,7 @@ The `memset` function is initialize the value of `buff` to 0. ```c // Read message from client to buffer - int read_n = recv(conn_sock_fd, buff, sizeof(buff), 0); + ssize_t read_n = recv(conn_sock_fd, buff, sizeof(buff), 0); ``` The [`recv()`](https://man7.org/linux/man-pages/man2/recv.2.html) function is used to receive data from the connected socket. This function reads incoming data from the client and stores it in the character buffer `buff`. Upon successful reception, `recv()` returns the number of bytes received, which is stored in the variable `read_n`. @@ -357,7 +356,7 @@ int main() { memset(buff, 0, BUFF_SIZE); // Read message from client to buffer - int read_n = recv(conn_sock_fd, buff, sizeof(buff), 0); + ssize_t read_n = recv(conn_sock_fd, buff, sizeof(buff), 0); // Client closed connection or error occurred if (read_n <= 0) { diff --git a/docs/roadmap/phase-0/stage-2.md b/docs/roadmap/phase-0/stage-2.md index 838640b..d24cf38 100644 --- a/docs/roadmap/phase-0/stage-2.md +++ b/docs/roadmap/phase-0/stage-2.md @@ -217,12 +217,111 @@ Now,we can modify the client code for creating multiple clients in a single exec ::: tip PRE-REQUISITE READING -- Read about [Fork()](/guides/resources/fork) +- Read about [Process and Threads](/guides/resources/process-and-threads) +- Read about [System Calls](/guides/resources/system-calls) + ::: +Create a file `udp_multi_client.c` and place it inside `expserver/phase_0`. We would be implementing our client code here. + +Try to run the the modified server code from the experiment 2 and below client code written in the `udp_multi_client.c` file. Observe how multiple clients are created concurrently in a single client code using `fork()` system call and their corresponding output. Try to run it again by updating the number of clients created in the client code and observe how the server deals with it iteratively. +```c +#include +#include +#include +#include +#include +#include +#define SERVER_PORT 8080 +#define SERVER_ADDR "127.0.0.1" +#define BUFF_SIZE 10000 +#define NUM_CLIENTS 3 + +void client_process(int client_id) { + int client_sock_fd; + struct sockaddr_in server_addr; + + // Create client socket + client_sock_fd = socket(AF_INET, SOCK_STREAM, 0); + if (client_sock_fd < 0) { + perror("Socket creation error"); + exit(EXIT_FAILURE); + } + + // Set up server address + server_addr.sin_family = AF_INET; + server_addr.sin_addr.s_addr = inet_addr(SERVER_ADDR); + server_addr.sin_port = htons(SERVER_PORT); + + // Connect to TCP server + if (connect(client_sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) != 0) { + printf("[Client %d] [ERROR] Failed to connect to server\n", client_id); + exit(EXIT_FAILURE); + } else { + printf("[Client %d] [INFO] Connected to server\n", client_id); + } + + while (1) { + // Hardcoded message "hello" + const char *message = "hello\n"; + size_t message_len = strlen(message); + + // Send hardcoded message to TCP server + send(client_sock_fd, message, message_len, 0); + printf("[Client %d] Sent: %s", client_id, message); + + // Buffer to store server's response + char buff[BUFF_SIZE]; + memset(buff, 0, BUFF_SIZE); + + // Read message from server + ssize_t read_n = recv(client_sock_fd, buff, sizeof(buff), 0); + + // Client closed connection or error occurred + if (read_n <= 0) { + printf("[Client %d] [INFO] Server disconnected. Closing client\n", client_id); + close(client_sock_fd); + exit(1); + } + + // Print message from server + printf("[Client %d] [SERVER MESSAGE] %s", client_id, buff); + + // Exit after first interaction + break; + } + + close(client_sock_fd); +} + +int main() { + pid_t pid; + + // Fork multiple clients + for (int i = 0; i < NUM_CLIENTS; i++) { + pid = fork(); + + if (pid < 0) { + perror("Fork failed"); + exit(EXIT_FAILURE); + } else if (pid == 0) { + // Child process runs the client + client_process(i + 1); + exit(0); + } + } + + // Parent process waits for all child processes to complete + for (int i = 0; i < NUM_CLIENTS; i++) { + wait(NULL); + } + + return 0; +} +``` ## Conclusion diff --git a/docs/roadmap/phase-0/stage-3.md b/docs/roadmap/phase-0/stage-3.md index 385bb74..6fd3466 100644 --- a/docs/roadmap/phase-0/stage-3.md +++ b/docs/roadmap/phase-0/stage-3.md @@ -14,8 +14,9 @@ ::: tip PRE-REQUISITE READING -- Read about [UDP](/guides/resources/udp.md) -- Read about [multi-threading](/guides/resources/multi-threading.md) +- Read about [UDP Socket Programming](/guides/resources/udp-socket-programming.md) +- Read about [Process and Threads](/guides/resources/process-and-threads.md) +- Read about [System Calls](/guides/resources/system-calls.md) ::: @@ -45,27 +46,27 @@ In `socket()` function, for TCP protocol we used `SOCK_STREAM` as the type. Here ```c int sockfd = socket(/*todo*/ , SOCK_DGRAM, /*todo*/); ``` -Now, assign an address (consisting of an IP address and a port) to the socket using the data structure struct sockaddr_in and then bind the socket created, as done in previous stages. +Now, assign an address (consisting of an IP address and a port) to the socket using the data structure `struct sockaddr_in` and then bind the socket created using `bind()`, as done in previous stages. ::: tip IMPORTANT! -User Datagram Protocol (UDP) is a connectionless protocol that doesn't require a connection to be established between the source and destination before data is transmitted,i.e datagrams can come in any order from any source.Therefore, listen(), accept() and connect() system calls are not required in UDP. +User Datagram Protocol (UDP) is a connectionless protocol that doesn't require a connection to be established between the source and destination before data is transmitted, i.e datagrams can come in any order from any source. Therefore, `listen()`, `accept()` and `connect()` system calls are not required in UDP. ::: ::: tip IMPORTANT! -We will be using sendto() and recvfrom() system calls, instead of send() and recv() as used in TCP. Since we are not creating a connection socket, we use sendto() in order to specify the destination and recvfrom() to specify from where the data was received from. +We will be using `sendto()` and `recvfrom()` system calls, instead of `send()` and `recv()` as used in TCP. Since we are not creating a connection socket, we use `sendto()` in order to specify the destination and `recvfrom()` to specify from where the data was received from. ::: -Now server is ready to receive messages from the clients. We can use recvfrom() to receive data from the client. +Now server is ready to receive messages from the clients. We can use `recvfrom()` to receive data from the client. ```C -int n = recvfrom(sockfd, buffer, BUFF_SIZE, 0,(struct sockaddr*)&client_addr, &len); +ssize_t n = recvfrom(sockfd, buffer, BUFF_SIZE, 0,(struct sockaddr*)&client_addr, &len); ``` -recvfrom() function reads incoming data from the client and stores it in the character buffer, `buffer` .Upon successful reception, `recvfrom()` returns the number of bytes received, which is stored in the variable n. +`recvfrom()` function reads incoming data from the client and stores it in the character buffer, `buffer`. Upon successful reception, `recvfrom()` returns the number of bytes received, which is stored in the variable n. Now we have received the data from the client. To store the received data and client details we are creating a new data structure named `client_data_t` . @@ -78,7 +79,7 @@ typedef struct { } client_data_t; ``` -In the main function initialize a variable of type client_data_t , which will store the received data and client details. +In the main function initialize a variable of type `client_data_t` , which will store the received data and client details. ```C client_data_t* data = (client_data_t*)malloc(sizeof(client_data_t)); @@ -88,22 +89,22 @@ client_data_t* data = (client_data_t*)malloc(sizeof(client_data_t)); data->addr_len = len; ``` -In the next step we will be creating a thread for handling the received request. We can use pthread_create() function for creating a new thread. +In the next step we will be creating a thread for handling the received request. We can use `pthread_create()` function for creating a new thread. ```C pthread_create(&thread_id, NULL, handle_client, (void*)data) ``` -pthread_create() function takes four arguments as follows. +`pthread_create()` function takes four arguments as follows. - **thread:** pointer to an unsigned integer value that returns the thread id of the thread created. - **attr:** pointer to a structure that is used to define thread attributes like detached state, scheduling policy, stack address, etc. Set to NULL for default thread attributes. -- **handle_client:** pointer to a subroutine that is executed by the thread. The return type and parameter type of the subroutine must be of type void *. The function has a single attribute but if multiple values need to be passed to the function, a struct must be used. +- **handle_client:** pointer to a subroutine that is executed by the thread. The return type and parameter type of the subroutine must be of type `void *`. The function has a single attribute but if multiple values need to be passed to the function, a structure must be used. - **data:** pointer to void that contains the arguments to the function defined in the earlier argument. -The thread created above will execute the handle_client function in which we are reversing the string and sending it back to the client. In this function we are passing an argument of type void*, which will be further typecasted to client_data_t* . +The thread created above will execute the handle_client function in which we are reversing the string and sending it back to the client. In this function we are passing an argument of type `void *`, which will be further typecasted to `client_data_t*`. -Now we can see the handle_client function. +Now we can see the `handle_client` function. ```C void* handle_client(void* arg) { @@ -121,9 +122,9 @@ void* handle_client(void* arg) { } ``` -Here the sendto() function sends message to the client address without establishing a connection. After sending the message we can free the memory allocated to the argument of the function. At the end of handle_client, the thread can be terminated by calling pthread_exit(). +Here the `sendto()` function sends message to the client address without establishing a connection. After sending the message we can free the memory allocated to the argument of the function. At the end of `handle_client`, the thread can be terminated by calling `pthread_exit()`. -After successful termination of the thread, control will reach the main function where we will be detaching the created thread using pthread_detach() . +After successful termination of the thread, control will reach the main function where we will be detaching the created thread using `pthread_detach()`. ```C pthread_detach(thread_id); @@ -197,7 +198,7 @@ int main() { while (1) { socklen_t len = sizeof(client_addr); - int n = recvfrom(/* TODO */); + ssize_t n = recvfrom(/* TODO */); buffer[n] = '\0'; // Allocate memory for client data to pass to the thread @@ -239,13 +240,13 @@ start the server: ./udp_server ``` -Now you can test the server using a netcat client.Open another terminal in parallel and type the following command to start a netcat UDP client: +Now you can test the server using a netcat client. Open another terminal in parallel and type the following command to start a netcat UDP client: ```bash nc -u localhost 8080 ``` -Try sending messages from the client.Check whether you are getting the reversed strings. +Try sending messages from the client. Check whether you are getting the reversed strings. Your UDP server is ready now. @@ -256,9 +257,9 @@ Your UDP server is ready now. Now lets implement the UDP client code. Create a file `udp_client.c` and place it inside `expserver/phase_0`. We would be implementing our client code here. The header files and global variables required are same as that in the TCP client code. -Create a socket of type SOCK_DGRAM. As mentioned earlier here we wont be using connect() system call due to the connectionless property of UDP. +Create a socket of type `SOCK_DGRAM`. As mentioned earlier here we wont be using `connect()` system call due to the connectionless property of UDP. -Here we are sending the message to server using sendto() and the reversed string is received using recvfrom(). +Here we are sending the message to server using `sendto()` and the reversed string is received using `recvfrom()`. Our final code looks like this. ```C @@ -297,7 +298,7 @@ int main() { sendto(sockfd, message, strlen(message), 0,(struct sockaddr*)&server_addr, sizeof(server_addr)); // Receive the reversed string from the server - int n = recvfrom(sockfd, buffer, BUFF_SIZE, 0, NULL, NULL); + ssize_t n = recvfrom(sockfd, buffer, BUFF_SIZE, 0, NULL, NULL); buffer[n] = '\0'; printf("[SERVER MESSAGE] %s",buffer); @@ -310,4 +311,4 @@ int main() { ``` ## Conclusion -Now our UDP server is capable of handling multiple client requests simultaneously. Here we have achieved concurrency using multithreading. We are creating a new thread for each of the incoming client requests.In the next stage we will see how to make a server concurrent using epoll mechanism which is used by most of modern web servers for obtaining concurrency. +Now our UDP server is capable of handling multiple client requests simultaneously. Here we have achieved concurrency using multithreading. We are creating a new thread for each of the incoming client requests. In the next stage we will see how to make a server concurrent using epoll mechanism which is used by most of modern web servers for obtaining concurrency. diff --git a/docs/roadmap/phase-0/stage-5.md b/docs/roadmap/phase-0/stage-5.md index d60f04f..fba1381 100644 --- a/docs/roadmap/phase-0/stage-5.md +++ b/docs/roadmap/phase-0/stage-5.md @@ -6,7 +6,7 @@ ## Learning Objectives -- We will combine the functionalities of a TCP server from [Stage 1](/roadmap/phase-0/stage-1) and client from [Stage 3](/roadmap/phase-0/stage-3) to make a TCP [proxy](https://en.wikipedia.org/wiki/Proxy_server) which will relay communication between a web browser and a python file server. +- We will combine the functionalities of a TCP server from [Stage 1](/roadmap/phase-0/stage-1) and client from [Stage 4](/roadmap/phase-0/stage-4) to make a TCP [proxy](https://en.wikipedia.org/wiki/Proxy_server) which will relay communication between a web browser and a python file server. ## Introduction @@ -30,7 +30,7 @@ Now that the local file server is running on port 3000, we can connect to it usi ![python-server.png](/assets/stage-4/python-server.png) -Right now, the client (web browser), is directly accessing the file server. Our goal is to modify the TCP server code from Stage 3 to turn it into a TCP proxy server, so that all the communication between the client and upstream server goes though the proxy. +Right now, the client (web browser), is directly accessing the file server. Our goal is to modify the TCP server code from Stage 4 to turn it into a TCP proxy server, so that all the communication between the client and upstream server goes though the proxy. ## Implementation From 8528a40d7cf3d7d6dbb1ba6e6080342e19c83b1d Mon Sep 17 00:00:00 2001 From: Nandana S Nair Date: Sat, 12 Oct 2024 02:00:56 +0530 Subject: [PATCH 4/6] minor changes --- docs/.vitepress/config.mjs | 5 +---- docs/roadmap/index.md | 4 ++-- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/docs/.vitepress/config.mjs b/docs/.vitepress/config.mjs index c9bde9a..c765e74 100644 --- a/docs/.vitepress/config.mjs +++ b/docs/.vitepress/config.mjs @@ -102,14 +102,11 @@ export default defineConfig({ { text: 'Stage 3: UDP Multi-threading', link: '/roadmap/phase-0/stage-3', - // text: 'Stage 3: Linux epoll', - // link: '/roadmap/phase-0/stage-3', }, { text: 'Stage 4: Linux epoll', link: '/roadmap/phase-0/stage-4', - // text: 'Stage 4: UDP Multi-threading', - // link: '/roadmap/phase-0/stage-4', + }, { text: 'Stage 5: TCP Proxy', diff --git a/docs/roadmap/index.md b/docs/roadmap/index.md index 85e1fcd..d5fb1a6 100644 --- a/docs/roadmap/index.md +++ b/docs/roadmap/index.md @@ -27,8 +27,8 @@ The eXpServer project comprises 24 stages, organized into 5 phases. Prior to the - ✅ [Stage 0: Setup](phase-0/stage-0) - ✅ [Stage 1: TCP Server](phase-0/stage-1) - ✅ [Stage 2: TCP Client](phase-0/stage-2) -- 🟡 [Stage 3: UDP with Multi-threading](phase-0/stage-3) -- ✅ [Stage 4: Linux Epoll](phase-0/stage-4) +- ✅ [Stage 3: Linux Epoll](phase-0/stage-3) +- 🟡 [Stage 4: UDP with Multi-threading](phase-0/stage-4) - ✅ [Stage 5: TCP Proxy](phase-0/stage-5) ### Phase 1: Building the core of eXpServer by creating reusable modules From 9ff2ebcd336bc6d382387c9e647e60088c26f21e Mon Sep 17 00:00:00 2001 From: Nikisha Date: Mon, 14 Oct 2024 20:33:42 +0530 Subject: [PATCH 5/6] stage10-pipe-creation-updated --- docs/roadmap/phase-1/stage-10.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/roadmap/phase-1/stage-10.md b/docs/roadmap/phase-1/stage-10.md index d17cf41..5725db4 100644 --- a/docs/roadmap/phase-1/stage-10.md +++ b/docs/roadmap/phase-1/stage-10.md @@ -183,6 +183,7 @@ xps_pipe_t *xps_pipe_create(xps_core_t *core, size_t buff_thresh, xps_pipe_sourc /* Add pipe to 'pipes' list of core*/ /*Attach source and sink to pipe*/ + /*Make both source and sink of pipe active*/ logger(LOG_DEBUG, "xps_pipe_create()", "created pipe"); @@ -304,7 +305,7 @@ xps_pipe_source_t *xps_pipe_source_create(void *ptr, xps_handler_t handler_cb, // Init values source->pipe = NULL; source->ready = false; - source->active = true; + source->active = false; /*similarly initialise the remaining fields of source instance*/ logger(LOG_DEBUG, "xps_pipe_source_create()", "create pipe_source"); From e384bda5836e8acbbbf80c01d7b5d52a554ed3dc Mon Sep 17 00:00:00 2001 From: Nikisha Date: Mon, 14 Oct 2024 20:34:14 +0530 Subject: [PATCH 6/6] stage12-added --- docs/roadmap/phase-1/stage-12.md | 392 +++++++++++++++++++++++++++++++ 1 file changed, 392 insertions(+) diff --git a/docs/roadmap/phase-1/stage-12.md b/docs/roadmap/phase-1/stage-12.md index 65a5892..a91635d 100644 --- a/docs/roadmap/phase-1/stage-12.md +++ b/docs/roadmap/phase-1/stage-12.md @@ -1 +1,393 @@ # Stage 12: File Module + +## Recap + +We have implemented an upstream server for incoming connections to port 8001. + +## Learning Objectives + +We would be implementing a file server for incoming connections to port 8002. + +## Introduction + +A file server stores and delivers files to clients over a network, enabling remote access. It allows users to download, upload, and modify files. In this stage, we would be implementing a basic file server, which delivers files upon client request. When there are incoming connections to port 8002, the server serves a static file to the client through the pipe mechanism discussed earlier. + +## Design + +Two new modules `xps_file` and `xps_mime` are introduced. In `xps_file`, an `xps_file_s` struct is introduced which stores the information regarding the file including file path, file size, MIME type(describes the format of file), and file structure pointer. `xps_file` has functions for opening a file and creating an instance of `xps_file_s` struct for it, for destruction of file instance, for reading data from file and writing to the pipe, and for closing the file source. Earlier the source was receiving data using `recv()` and writes it to the pipe, but in a file server the source takes data from the file attached to it and writes it to the pipe. Here, the `ptr` field in `xps_source_s` struct points to an instance of `xps_file_s` struct which has to be read, instead of pointing to the connection instance as in earlier stages. `file_souce_handler()` reads data from the file and writes it to pipe. + +The `xps_mime` module is used for getting the MIME type of the file. A MIME type (Multipurpose Internet Mail Extensions type) is a standard that indicates the nature and format of a file. Originally developed for email systems to specify the type of data attached in emails, MIME types are now used extensively on the internet, particularly in HTTP, to describe the content being transferred. We would be exploring more on this in later stages. + +## Implementation + +Modules added/modified in the given order + +- `xps_mime` +- `xps_file` +- `xps_listener` + +Create a new folder disk in src, this would be used for adding necessary modules required for creating a file server.The two modules included are xps_mime and xps_file. + +## `xps_mime` Module + +### `xps_mime.h` + +The code below has the contents of the header file for `xps_mime`. Have a look at it and make a copy of it in your codebase. + +:::details **expserver/src/disc/xps_mime.h** + +```c +#ifndef XPS_MIME_H +#define XPS_MIME_H + +#include "../xps.h" + +const char *xps_get_mime(const char *file_path); + +#endif +``` +::: + +### `xps_mime.c` + +The function `xps_get_mime()` returns the MIME type of a file based on its extension. A MIME type lookup table (`mime_types`) maps file extensions (e.g., ".html", ".jpg") to their corresponding MIME types (e.g., "text/html", "image/jpeg"). This tells the browser how to display or interact with the file. For example, an HTML file is rendered as a web page, while an image is displayed as a picture. We won’t be using this functionality in the present stage but would be looking into in later stages. + +:::details **expserver/src/disc/xps_mime.c** + +```c +#include "../xps.h" +//here, some extension-mime types pairs are given, you can add as required +xps_keyval_t mime_types[] = { + {".c", "text/x-c"}, + {".cc", "text/x-c"}, + {".cpp", "text/x-c"}, + {".dir", "application/x-director"}, + {".dxr", "application/x-director"}, + {".fgd", "application/x-director"}, + {".swa", "application/x-director"}, + {".text", "text/plain"}, + {".txt", "text/plain"}, + {".png", "image/png"}, + {".png", "image/x-png"}, + }; +int n_mimes = sizeof(mime_types) / sizeof(mime_types[0]); + +const char *xps_get_mime(const char *file_path) { + const char *ext = get_file_ext(file_path); + + if (ext == NULL) + return NULL; + + for (int i = 0; i < n_mimes; i++) { + if (strcmp(mime_types[i].key, ext) == 0) + return mime_types[i].val; + } + + return NULL; +} +``` +::: + +As we are mapping the MIME type based on the file extension, a function for finding the file extension is added in `xps_utility`. Add the below given function in utility.c + +```c +const char *get_file_ext(const char *file_path) { + // Find the last occurrence of dot + const char *dot = strrchr(file_path, '.'); + + // Check if dot is present and it is not the first character + return dot && dot > strrchr(file_path, '/') ? dot : NULL; +} +``` + +Also declare the newly created function in utility.h + +## `xps_file` Module + +### `xps_file.h` + +The code below has the contents of the header file for `xps_file`. Have a look at it and make a copy of it in your codebase. + +:::details **expserver/src/disc/xps_file.h** + +```c +#ifndef XPS_FILE_H +#define XPS_FILE_H + +#include "../xps.h" + +struct xps_file_s { + xps_core_t *core; + const char *file_path; + xps_pipe_source_t *source; + FILE *file_struct; + size_t size; + const char *mime_type; +}; + +xps_file_t *xps_file_create(xps_core_t *core, const char *file_path, int *error); +void xps_file_destroy(xps_file_t *file); + +#endif +``` +::: + + +A struct `xps_file_s` is introduced to store the information regarding the file. The fields in the struct are briefly described: + +**`xps_core_t *core`**: pointer to the core instance + +**`const char *file_path`**: used to locate the file on the local disk + +**`xps_pipe_source_t *source`**: a pointer to source, which handles reading data from the file and passing it to a pipe + +**`FILE *file_struct`**: a pointer representing the opened file, it is used to interact with the file, such as reading, writing, seeking(will be explained soon). + +**`size_t size`**: holds the size of the file in bytes + +**`const char *mime_type`**:  represents the MIME type of the file + +### `xps_file.c` + +Several file system-related C standard library functions are used to handle file operations such as opening, reading, seeking, and closing files. Let us look in to the file system call that we would be using: + +- `fopen()` + + ```c + FILE *fopen(const char *filename, const char *mode); + ``` + + Opens a file specified by filename and returns a pointer to a FILE structure that represents the file stream. If mode given as “rb”, it opens the file in binary read mode. **Returns**: A pointer to a FILE structure if successful, or NULL if the file cannot be opened . + +- `fclose()` + + ```c + int fclose(FILE *stream); + ``` + + Closes the file associated with the given FILE stream and releases any resources related to the file. **Returns**: 0 on success, or EOF (End Of File) on error. + +- `fseek()` + + ```c + int fseek(FILE *stream, long offset, int whence); + ``` + + Moves the file pointer to a specific location in the file. + + - offset: The number of bytes to move the file pointer. + - whence: Specifies how the offset is interpreted: + - SEEK_SET: The offset is set relative to the beginning of the file. + - SEEK_CUR: The offset is added to the current position. + - SEEK_END: The offset is set relative to the end of the file. + + **Returns**: 0 on success, or -1 on error. + +- `ftell()` + + ```c + long ftell(FILE *stream); + ``` + + Returns the current position of the file pointer in the file, measured in bytes from the beginning of the file. **Returns**: The current position (in bytes) on success, or -1L on error. + +- `fread()` + + ```c + size_t fread(void *ptr, size_t size, size_t count, FILE *stream); + ``` + + Reads data from the file into a buffer. + + - ptr: The buffer where the data will be stored. + - size: The size of each data element. + - count: The number of elements to read. + - stream: The file stream to read from. + + **Returns**: The number of elements successfully read. If an error occurs, the return value will be less than the requested number of elements. + +- `ferror()` + + ```c + int ferror(FILE *stream); + ``` + + Checks whether an error occurred while performing file I/O operations on the given file stream. **Returns**: 0 if no error has occurred, or a non-zero value if an error has occurred. + +- `feof()` + + ```c + int feof(FILE *stream); + ``` + + Checks whether the end of the file has been reached. **Returns**: A non-zero value if the end of the file has been reached, or 0 otherwise. + + +`errno` determines the specific error when an operation fails. In case of `fopen()`, `EACCES` indicates a permission denied error and `ENOENT` indicates the specified file or directory doesn't exist. + +The functions in xps_file.c are given below: + +1. **`xps_file_create()`** + + Opens the file using `fopen()`, calculates the size by seeking to the end and then getting the current position, creates a `xps_file_s` struct instance and initialize it. + + ```c + xps_file_t *xps_file_create(xps_core_t *core, const char *file_path, int *error) { + /*assert*/ + + *error = E_FAIL; + + // Opening file + FILE *file_struct = fopen(file_path, "rb"); + /*handle EACCES,ENOENT or any other error*/ + if (file_struct == NULL) { + /*logs EACCES,ENOENT or any other error*/ + return NULL; + } + + // Getting size of file + + // Seeking to end + if (/*seek end of file using fseek()*/ != 0) { + /*logs error*/ + /*close file_struct*/ + return NULL; + } + + // Getting curr position which is the size + long temp_size = /*get current position using ftell()*/ + if (temp_size < 0) { + /*logs error*/ + /*close file_struct*/ + return NULL; + } + + // Seek back to start + if (/*seek start of file using fseek()*/ != 0) { + /*logs error*/ + /*close file_struct*/ + return NULL; + } + + const char *mime_type = /*get mime type*/ + + /*Alloc memory for instance of xps_file_t*/ + xps_pipe_source_t *source = + xps_pipe_source_create((void *)file, file_source_handler, file_source_close_handler); + /*if source is null, close file_struct and return*/ + + // Init values + source->ready = true; + /*initialise the fields of file instance*/ + + *error = OK; + + logger(LOG_DEBUG, "xps_file_create()", "created file"); + + return file; + } + ``` + +2. **`xps_file_destroy()`** + + Closes the file, destroys the associated pipe source, and frees the memory allocated for the file structure. + + ```c + void xps_file_destroy(xps_file_t *file) { + /*assert*/ + + /*fill as mentioned above*/ + + logger(LOG_DEBUG, "xps_file_destroy()", "destroyed file"); + } + + ``` + +3. **`file_source_handler()`** + + It reads from the file into the buffer and upon successful reading, writes it to pipe. + + ```c + void file_source_handler(void *ptr) { + /*assert*/ + + xps_pipe_source_t *source = ptr; + /*get file from source ptr*/ + + /*create buffer and handle any error*/ + + // Read from file + size_t read_n = fread(buff->data, 1, buff->size, file->file_struct); + buff->len = read_n; + + // Checking for read errors + if (ferror(file->file_struct)) { + /*destroy buff, file and return*/ + } + + // If end of file reached + if (read_n == 0 && feof(file->file_struct)) { + /*destroy buff, file and return*/ + } + + /*Write to pipe form buff*/ + /*destroy buff*/ + } + ``` + +4. **`file_source_close_handler()`** + + This function is called when the file source is closed, triggering the destruction of the file object. + + ```c + void file_source_close_handler(void *ptr) { + /*assert*/ + xps_pipe_source_t *source = ptr; + /*get file from source ptr*/ + /*destroy file*/ + } + ``` + + +Update the xps.h by adding two newly created structs xps_file_s and + +```c +struct xps_keyval_s { + char *key; + char *val; +}; +``` + +The second struct is for storing the key-value pairs of mime extensions and mime types(`mime_types` lookup table). Create the type defs for the above struct. Also include the header files of both `xps_mime` and `xps_file` modules. + +## `xps_listener` Module - Modifications + +### `listener.c` + +As we have to serve file for the incoming connections on port 8002, the `listener_connection_handler` function has to be modified. The `xps_file_create` function is invoked for opening the file and creating a `xps_file_s` instance for it. The path of file to be opened is specified in the argument. Then pipe is created with the source that is attached to the file instead of that attached to connection. + +```c +if (listener->port == 8001) { + .... + } else if (listener->port == 8002) {// [!code ++] + int error;// [!code ++] + xps_file_t *file = xps_file_create(listener->core, "../public/sample.txt", &error);// [!code ++] + xps_pipe_create(listener->core, DEFAULT_PIPE_BUFF_THRESH, file->source, client->sink);// [!code ++] + } else { + ... + } +``` + +## Milestone #1 + +Update the `build.sh` to include the newly created modules. + +In the expserver folder, create a new folder public. Inside this create a file sample.txt with any content. This path is given while calling the `xps_file_create` function. + +Now start the server as mentioned in previous stages. Connect a client on port 8002 using `netcat localhost 8002`. Verify that the contents in file sample.txt is received by the client in terminal. Thus we have successfully implemented a basic file server which can send files in local disk to the client. + + + +## Conclusion + +Now all the clients connected to port 8002, would be served the specified file. Thus we have implemented a basic file server. The file server is implemented along with the pipe mechanism itself with the only difference being source reading the file attached to its `ptr` field and writing it to pipe. \ No newline at end of file