init

Author: ahmeducf

Makefile

@@ -0,0 +1,18 @@
+# Makefile for Proxy Lab 
+
+
+CC = gcc
+CFLAGS = -g -Werror
+LDFLAGS = -lpthread
+
+proxy: proxy.c cache.c ./proxy_helpers/error_handling.c service.c robust_io.c ./thread_helpers/sbuf.c ./thread_helpers/semaphore.c socket.c thread.c ./proxy_helpers/url_parser.c ./proxy_helpers/wrappers.c cache.h constants.h ./proxy_helpers/error_handling.h service.h robust_io.h ./thread_helpers/sbuf.h ./thread_helpers/semaphore.h socket.h thread.h ./proxy_helpers/url_parser.h ./proxy_helpers/wrappers.h
+	$(CC) $(CFLAGS) -o proxy service.c cache.c ./proxy_helpers/error_handling.c robust_io.c ./thread_helpers/sbuf.c ./thread_helpers/semaphore.c socket.c thread.c ./proxy_helpers/url_parser.c ./proxy_helpers/wrappers.c proxy.c $(LDFLAGS)
+
+
+# Creates a tarball in ../proxylab-handin.tar that you can then
+# hand in. DO NOT MODIFY THIS!
+
+
+clean:
+	rm -f *~ *.o proxy
+

README.md

@@ -0,0 +1,109 @@
+# Proxy Server
+Proxy is a simple concurrent HTTP proxy server that caches web objects.
+
+It's an application for learning about *Network Programming* and *Concurrent Programming*.
+
+
+## Table of contents
+
+|                                        Table of contents                                       |
+|:----------------------------------------------------------------------------------------------:|
+|                                      [Overview](#Overview)                                     |
+|                          [How does proxy work?](#How-does-proxy-work)                          |
+| [How does proxy deal with concurrent requests?](#How-does-proxy-deal-with-concurrent-requests) |
+| [How does proxy synchronize accesses to cache?](#How-does-proxy-synchronize-accesses-to-cache) |
+|                                  [Requirements](#Requirements)                                 |
+|                            [How to test proxy?](#How-to-test-proxy?)                           |
+|                           [My thoughts about the project](#Thoughts)                           |
+
+
+
+
+
+
+
+
+## Overview
+A web proxy is a program that acts as a middleman between a Web browser and an end server.
+- Instead of contacting the end server directly to get a Web page, the browser contacts the proxy, which forwards the request on to the end server. When the end server replies to the proxy, the proxy sends the reply on to the browser.
+- It can deal with multiple concurrent connections using multi-threading.
+- It can also cache web objects by storing local copies of objects from servers then responding to future requests by reading them out of its cache rather than by communicating again with remote servers.
+
+
+## How does proxy work?
+
+It has the following detailed behavior:
+- Set up the proxy to accept incoming connections:
+    - Proxy creates a listening descriptor that is ready to receive connection requests on port ***port*** by calling ***Open_listenfd()*** funciton defined in **socket.c** file.
+
+- Set up the proxy to deal with multiple concurrent connections using **prethreading** technique:
+    - After initializing buffer ***sbuf*** declared in **sbuf.h** file, the main thread creates the set of worker threads by calling ***Pthread_create()*** defined in **thread.c** file.
+    - Main thread then enters an infinite loop, waiting for connection requests using ***Accept()*** function defined in **socket.c** file.
+    - It then inserts the resulting connected descriptors in ***sbuf***.
+    - Each worker thread waits until it is able to remove a connected descriptor from the buffer and then calls the ***serve_client()*** function to serve the client.
+- ***serve_client()*** routine:
+    - Read and parse the **HTTP** request sent from the client by calling ***read_HTTP_request()*** function defined in **serve.c** file.
+    - using ***hash()*** function defined in **cache.c** file, generate ***HTTP_request_hash*** that will be used to check if the cache contains the requested web object.
+    - If the object is cached then read the object out of the cache rather than communicating again with the server by calling ***service_from_cache()*** function defined in **service.c** file.
+    - Otherwise, using ***service_from_server()*** function, Try to connect the server then send it the ***parsed_request***, read its response, write it back to the client, and save it in an internal buffer for possible caching.
+    - If ***object_size*** is less than ***MAX_OBJECT_SIZE*** write the object in a suitable cahce line.
+
+
+## How does proxy deal with concurrent requests?
+- We incur non-trivial cost of creating a new thread for each new client.
+- A proxy based on *prethreading* tries to reduce this overhead by using the **producer-consumer** model shown in the figure.
+- The proxy consists of a ***main thread*** and a set of ***worker threads***, the main thread repeatedly accepts connection requests from clients and places the resulting connected descriptors in a bounded buffer.
+- Each worker thread repeatedly removes a descriptor from the buffer, services the client, and then waits for the next descriptor.
+
+<p align="center"><img src="https://i.ibb.co/jfNwR5n/producer-consumer-model.png"></p>
+
+
+## How does proxy synchronize accesses to cache?
+- Accesses to the cache must be thread-safe, and free of race conditions, So as a matter of fact we have these special requirements:
+    1. Multiple threads must be able to simultaneously read from the cache.
+    2. No thread can write to specific object while another thread is reading it.
+    3. Only one thread should be permitted to write to the object at a time, but that restriction mustn't exist for readers.
+
+- As such, protecting accesses to the cache with *one large exclusive lock* was not an acceptable solution. ***We partioned the cache into lines***, each line associated with ***read_cnt*** that count the number of current readers of that cache line, and ***mutex_writing_cache_line*** semaphore that ***lock only the cache line associated with it*** instead of locking the whole cache.
+
+- A **writer thread** locks the write mutex each time it writes to the cache line associtaed with it, and unlocks it each time it finishes writing. This guarantees that there is at most one writer in that cache line at any point of time.
+
+- On the other hand, only the first **reader thread** to read a cache line locks write mutex for that cache line, and only the last reader to finish reading unlocks it. The write mutex is ignored by readers who enter and leave while other readers are present.
+- This means that as long as a single reader holds the write mutex for a particular cahce line, an unbounded number of readers can read this cache line at the same time unimpeded.
+
+
+
+## Requirements
+- Git
+- GCC
+- make
+
+## How to test proxy?
+1) **Compile source code and run proxy**
+
+    Run the following commands in a terminal:
+    ```console
+    git clone https://github.com/ahmed-salah-ucf/proxy-server.git
+    ```
+    ```console
+    make
+    ```
+    ```console
+    .\proxy <port>
+    ```
+
+2) **Send HTTP requests using** *telnet* **or** *curl* **tools to test the proxy**
+
+    **telnet:**
+    ```console
+    telnet localhost <port>
+    ```
+    **curl:**
+    ```console
+    curl --proxy  http://localhost:<port> www.example.com
+    ```
+
+## Thoughts
+- The Project helped me become more familiar with the concepts of **network programming** and **concurrent programming**.
+- I learned about **HTTP operation** and how to use **sockets** to write programs that communicate over network connections.
+- This introduced me to dealing with **concurrency**, and how to write **thread-safe** routines.

cache.c

@@ -0,0 +1,105 @@
+#include "cache.h"
+
+unsigned long cur_time = 0;     /* Used to update timestamp */
+
+/*
+ * cache_init - initialize proxy's cache by allocating
+ *              memory for it and initializing it to zeros.
+ */
+void cache_init(cache_line_t **cache_p) {
+    int i;
+    cache_line_t *p;
+
+    *cache_p = Calloc(CACHE_LINE_NUM, sizeof(cache_line_t));
+    for (p = *cache_p, i = 0; i < CACHE_LINE_NUM; ++i, ++p) {
+        p->length = 0;
+        p->timestamp = 0;
+        p->hash = 0;
+        p->valid_bit = 0;
+    }
+}
+
+/*
+ * is_cached - Check if a web object target is cached. It searches cache by
+ *             checking valid bit and hash value. Return the index of cache
+ *             line if there is a match. Otherwise, return -1.
+ *             If there is a cache hit, the timestamp in the corresponding
+ *             cache line would be updated.
+ */
+int is_cached(cache_line_t *cache, size_t target) {
+    int i;
+    cache_line_t *p;
+    for (p = cache, i = 0; i < CACHE_LINE_NUM; ++i, ++p) {
+        if (p->valid_bit == 1 && p->hash == target) {
+            P(&mutex_writing_cache_line[i]);
+            p->timestamp = cur_time;
+            V(&mutex_writing_cache_line[i]);
+            return i;
+        }
+
+    }
+    return -1;
+}
+
+/*
+ * get_write_index - Helper function searches the cache for an empty cache
+ *                   line. if found one returns its index. otherwise,
+ *                   returns the index of least-recent-used line.
+ */
+static int get_write_idx(cache_line_t *cache) {
+    int i;
+    cache_line_t *p;
+    unsigned long lru_time = __UINT64_MAX__;
+    int lru_idx;
+
+    for (p = cache, i = 0; i < CACHE_LINE_NUM; ++i, ++p) {
+        if (p->valid_bit == 0) {
+            return i;
+        } else {
+            if (p->timestamp < lru_time) {
+                lru_time = p->timestamp;
+                lru_idx = i;
+            }
+        }
+    }
+    return lru_idx;
+}
+
+/*
+ * write_cache - Search for write index in the cache and write cache_buf in the
+ *               cache line at this index. it uses mutex semaphore to lock
+ *               writing at this cache line from other threads.
+ */
+void write_cache(cache_line_t *cache, char *cache_buf, int object_size, size_t hash)
+{
+    int write_idx = get_write_idx(cache);
+
+    P(&mutex_writing_cache_line[write_idx]);
+    memcpy((cache + write_idx)->content, cache_buf, object_size);
+    (cache + write_idx)->length = object_size;
+    (cache + write_idx)->timestamp = cur_time;
+    (cache + write_idx)->hash = hash;
+    (cache + write_idx)->valid_bit = 1;
+    V(&mutex_writing_cache_line[write_idx]);
+}
+
+/*
+ * hash_func - Helper function generates hash value from string
+ */
+static size_t hash_func(char *str) {
+    unsigned long res = 5381;
+    int c;
+
+    while ((c = *(str++)))
+        res = ((res << 5) + res) + c; /* hash * 33 + c */
+
+    return res;
+}
+
+/*
+ * hash - Generate hash value for HTTP request
+ */
+size_t hash(char *HTTP_request)
+{
+    return hash_func(HTTP_request);
+}

cache.h

@@ -0,0 +1,29 @@
+#ifndef CACHE_H
+#define CACHE_H
+#include <stdio.h>
+#include <stdlib.h>
+#include "constants.h"
+#include "proxy_helpers/wrappers.h"
+#include "thread_helpers/semaphore.h"
+
+/* Global variables */
+extern unsigned long cur_time;        /* Used to update timestamp */
+
+typedef struct cache_line {
+    char content[MAX_OBJECT_SIZE];    /* Stored web object */
+    int length;                       /* Actual length of web object */
+    unsigned long long timestamp;     /* To perform LRU */
+    size_t hash;                      /* Hash value of the request header */
+    int valid_bit;                    /* Valid bit */
+} cache_line_t;
+
+/* Helper functions prototypes */
+static int get_write_idx(cache_line_t *cache);
+static size_t hash_func(char *str);
+
+/* Functions prototypes */
+void cache_init(cache_line_t **cache_p);
+void write_cache(cache_line_t *cache, char *cache_buf, int object_size, size_t hash);
+int is_cached(cache_line_t *cache, size_t target);
+size_t hash(char *HTTP_request);
+#endif

constants.h

@@ -0,0 +1,14 @@
+#ifndef CONSTANTS_H
+#define CONSTANTS_H
+/* Misc constants */
+#define	MAXLINE	 8192     /* Max text line length */
+#define MAXBUF   1048576  /* Max I/O buffer size */
+
+/* Max cache and object sizes */
+#define MAX_CACHE_SIZE 1049000
+#define MAX_OBJECT_SIZE 102400
+#define CACHE_LINE_NUM (MAX_CACHE_SIZE / MAX_OBJECT_SIZE)
+
+#define LISTENQ  1024  /* Second argument to listen() */
+
+#endif

producer-consumer-model.png

@@ -0,0 +1,50 @@
+#include "service.h"
+
+
+int main(int argc, char *argv[])
+{
+    int listenfd, connfd;
+    char hostname[MAXLINE], port[MAXLINE];
+    socklen_t clientlen;
+    struct sockaddr_storage clientaddr;
+    pthread_t tid;
+    cache_line_t *cache = NULL;
+
+    /* Check command line args */
+    if (argc != 2) {
+        fprintf(stderr, "usage: %s <port>\n", argv[0]);
+        exit(1);
+    }
+
+    /* Ignore SIGPIPE signal */
+    Signal(SIGPIPE, SIG_IGN);
+
+    listenfd = Open_listenfd(argv[1]);
+    printf("Proxy listening on port: %d\n", listenfd);
+
+    /* Initialize cache */
+    cache_init(&cache);
+
+    /* Initialize semaphores */
+    semaphore_init();
+
+    sbuf_init(&sbuf, SBUFSIZE);
+    for (int i = 0; i < NTHREADS; ++i)  /* Create worker threads */
+        Pthread_create(&tid, NULL, thread, cache);
+
+    while (1) {
+        clientlen = sizeof(clientaddr);
+        connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
+        Getnameinfo((SA *) &clientaddr, clientlen,
+                    hostname, MAXLINE, port, MAXLINE, 0);
+        printf("Accepted connection from (%s, %s)\n", hostname, port);
+        ++cur_time;        /* Update time */
+        sbuf_insert(&sbuf, connfd);
+    }
+    Free(cache);
+    Close(listenfd);
+    exit(0);
+}
+
+
+

proxy

@@ -0,0 +1,39 @@
+#include "error_handling.h"
+
+
+
+/************************** 
+ * Error-handling functions
+ **************************/
+ /*
+  * unix_error - Report error message for unix-functions errors.
+  */
+void unix_error(char *msg) /* Unix-style error */
+{
+    if (errno)
+        fprintf(stderr, "%s: %s\n", msg, strerror(errno));
+}
+
+/*
+ * posix_error - Report error message for posix-functions errors.
+ */
+void posix_error(int code, char *msg) /* Posix-style error */
+{
+    fprintf(stderr, "%s: %s\n", msg, strerror(code));
+}
+
+/*
+ * gai_error - Report error message for getaddrinfo function errors.
+ */
+void gai_error(int code, char *msg) /* Getaddrinfo-style error */
+{
+    fprintf(stderr, "%s: %s\n", msg, gai_strerror(code));
+}
+
+/*
+ * app_error - Report error messages.
+ */
+void app_error(char *msg) /* Application error */
+{
+    fprintf(stderr, "%s\n", msg);
+}

proxy.c

@@ -0,0 +1,15 @@
+#ifndef ERROR_HANDLING_H
+#define ERROR_HANDLING_H
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <netdb.h>
+#include "../constants.h"
+
+/* error-handling functions prototypes */
+void unix_error(char *msg);
+void posix_error(int code, char *msg);
+void gai_error(int code, char *msg);
+void app_error(char *msg);
+
+#endif