diff --git a/lab3/Makefile b/lab3/Makefile
new file mode 100644
index 00000000..8d8cd2a5
--- /dev/null
+++ b/lab3/Makefile
@@ -0,0 +1,27 @@
+CC = gcc
+CFLAGS = -Wall -std=gnu99 -g # "curl-config --cflags" output is empty  
+LD = gcc
+LDFLAGS = -std=gnu99 -g
+LDLIBS = -lz -lcurl -pthread       # "curl-config --libs" output 
+
+SRCS   = paster2.c zutil.c crc.c
+OBJS   = paster2.o zutil.o crc.o
+TARGETS= paster2
+
+all: ${TARGETS}
+
+paster2: $(OBJS)
+    $(LD) -o $@ $^ $(LDLIBS) $(LDFLAGS)  
+
+%.o: %.c
+    $(CC) $(CFLAGS) -c $< 
+
+%.d: %.c
+    gcc -MM -MF $@ $<
+
+-include $(SRCS:.c=.d)
+
+.PHONY: clean
+clean:
+    rm -f *~ *.d *.o *~ $(TARGETS) *.png
+~                     
\ No newline at end of file
diff --git a/lab3/crc.c b/lab3/crc.c
new file mode 100644
index 00000000..905ad7b0
--- /dev/null
+++ b/lab3/crc.c
@@ -0,0 +1,54 @@
+/********************************************************************
+ * @file: crc.c
+ * @brief: PNG crc calculation
+ * Reference: https://www.w3.org/TR/PNG-CRCAppendix.html
+ */
+
+/* Table of CRCs of all 8-bit messages. */
+unsigned long crc_table[256];
+
+/* Flag: has the table been computed? Initially false. */
+int crc_table_computed = 0;
+
+/* Make the table for a fast CRC. */
+void make_crc_table(void)
+{
+    unsigned long c;
+    int n, k;
+
+    for (n = 0; n < 256; n++) {
+        c = (unsigned long) n;
+        for (k = 0; k < 8; k++) {
+            if (c & 1)
+                c = 0xedb88320L ^ (c >> 1);
+            else
+                c = c >> 1;
+        }
+        crc_table[n] = c;
+    }
+    crc_table_computed = 1;
+}
+
+/* Update a running CRC with the bytes buf[0..len-1]--the CRC
+   should be initialized to all 1's, and the transmitted value
+   is the 1's complement of the final running CRC (see the
+   crc() routine below)). */
+
+unsigned long update_crc(unsigned long crc, unsigned char *buf, int len)
+{
+    unsigned long c = crc;
+    int n;
+
+    if (!crc_table_computed)
+        make_crc_table();
+    for (n = 0; n < len; n++) {
+        c = crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
+    }
+    return c;
+}
+
+/* Return the CRC of the bytes buf[0..len-1]. */
+unsigned long crc(unsigned char *buf, int len)
+{
+    return update_crc(0xffffffffL, buf, len) ^ 0xffffffffL;
+}
diff --git a/lab3/crc.h b/lab3/crc.h
new file mode 100644
index 00000000..7f581a9f
--- /dev/null
+++ b/lab3/crc.h
@@ -0,0 +1,10 @@
+/**
+ * @file: crc.h
+ * @brief: crc calculation functions for PNG file
+ */
+
+#pragma once
+
+void make_crc_table(void);
+unsigned long update_crc(unsigned long crc, unsigned char *buf, int len);
+unsigned long crc(unsigned char *buf, int len);
diff --git a/lab3/lab3_eceubuntu1.csv b/lab3/lab3_eceubuntu1.csv
new file mode 100644
index 00000000..2603ac06
--- /dev/null
+++ b/lab3/lab3_eceubuntu1.csv
@@ -0,0 +1,40 @@
+B,P,C,X,N,Time
+5,1,1,0,1,11.031589
+5,1,5,0,1,16.740917
+5,5,1,0,1,2.379882
+5,5,5,0,1,3.559238
+10,1,1,0,1,10.849649
+10,1,5,0,1,14.668302
+10,1,10,0,1,18.287099
+10,5,1,0,1,2.185177
+10,5,5,0,1,3.189513
+10,5,10,0,1,4.437578
+10,10,1,0,1,1.179276
+10,10,5,0,1,1.513533
+10,10,10,0,1,1.901437
+5,1,1,200,1,10.478608
+5,1,5,200,1,10.845563
+5,5,1,200,1,
+5,5,5,200,1,2.95628
+10,1,1,200,1,10.488353
+10,1,5,200,1,10.824044
+10,1,10,200,1,10.901582
+10,5,1,200,1,
+10,5,5,200,1,2.508308
+10,5,10,200,1,2.5136
+10,10,1,200,1,
+10,10,5,200,1,
+10,10,10,200,1,1.720996
+5,1,1,400,1,20.07438
+5,1,5,400,1,10.747398
+5,5,1,400,1,
+5,5,5,400,1,4.502687
+10,1,1,400,1,20.104304
+10,1,5,400,1,10.760721
+10,1,10,400,1,10.815564
+10,5,1,400,1,
+10,5,5,400,1,4.515022
+10,5,10,400,1,2.949063
+10,10,1,400,1,
+10,10,5,400,1,
+10,10,10,400,1,2.562455
\ No newline at end of file
diff --git a/lab3/paster2.c b/lab3/paster2.c
new file mode 100644
index 00000000..8cd7dc9b
--- /dev/null
+++ b/lab3/paster2.c
@@ -0,0 +1,707 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <curl/curl.h>
+#include <sys/shm.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <semaphore.h>
+#include <errno.h>
+#include <arpa/inet.h>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include "crc.h"
+#include "zutil.h"
+
+#define IMG_URL "http://ece252-1.uwaterloo.ca:2530/image?img="
+#define IMG_URL2 "http://ece252-2.uwaterloo.ca:2530/image?img="
+#define IMG_URL3 "http://ece252-3.uwaterloo.ca:2530/image?img="
+#define ECE252_HEADER "X-Ece252-Fragment: "
+
+#define PNG_SIG_SIZE    8 /* number of bytes of png image signature data */
+#define CHUNK_LEN_SIZE  4 /* chunk length field size in bytes */          
+#define CHUNK_TYPE_SIZE 4 /* chunk type field size in bytes */
+#define CHUNK_CRC_SIZE  4 /* chunk CRC field size in bytes */
+#define DATA_IHDR_SIZE 13 /* IHDR chunk data field size */
+
+#define NUM_SEMS 11
+#define SEM_PROC 1
+#define BUF_SIZE 10240  /* 1024*10 = 10K */
+#define MAX_SIZE 1000000
+
+int B = 1;
+int PROD_NUM = 1;
+int CONS_NUM = 1;
+int DELAY = 0;
+int IMG_NUM = 1;
+
+sem_t *sems;
+
+typedef unsigned char U8;
+typedef unsigned int  U32;
+typedef unsigned long int U64;
+
+
+// URL : http://ece252-1.uwaterloo.ca:2530/image?img=n&part=m
+// n - image number
+// m - fragment number
+
+// B - buffer size
+// P - # of producers
+// C - # of consumers
+// X - # of millseconds consumer sleeps before processing data
+// N - image number
+
+// ./paster2 B P C X N
+// B≥1,P=1,C=1,X≥0,andN=1,2,3
+// use gettimeofday (record time before creating first process + after last image segment is consumed and all.png generated)
+// output: paster2 execution time: <time in seconds> seconds
+// 2, 4, or 6 time decimals acceptable
+
+// redirect output to a file: ./your_program > somefile.txt
+
+// producers make requests + fetch 50 image segments
+// placed in buffer of size B (shared with consumer tasks)
+// when B image segments are in buffer, producers stop producing
+// producers terminate when all segments downloaded
+// consumer reads segments out of buffer + sleeps for X ms before each one + processes received data - validate segment + inflate + copy data into memory
+// sleep() in seconds
+// usleep() in microseconds
+
+// remember - consumer cannot get from buffer if empty, producer cannot add to full buffer
+// access to buffer => critical section
+// need to create mechanism that determines if a producer has placed the last image segment into buffer
+// need to create mechanism that determines if a consumer has read out the last image from the buffer
+
+typedef struct recv_buf_flat {
+    unsigned char *buf;       /* memory to hold a copy of received data */
+    size_t size;     /* size of valid data in buf in bytes*/
+    size_t max_size; /* max capacity of buf in bytes*/
+    int seq;         /* >=0 sequence number extracted from http header */
+                     /* <0 indicates an invalid seq number */
+} RECV_BUF;
+
+typedef struct recv_buf_shr_mem {
+    unsigned char *buf;
+    size_t size;
+    size_t max_size;
+    int seq;
+} RECV_BUF_MEM;
+
+size_t header_cb_curl(char *p_recv, size_t size, size_t nmemb, void *userdata);
+size_t write_cb_curl(char *p_recv, size_t size, size_t nmemb, void *p_userdata);
+int recv_buf_init(RECV_BUF *ptr, size_t max_size);
+int recv_buf_cleanup(RECV_BUF *ptr);
+int fragmentsCollected(int *fragment);
+int allInflated(int *count);
+
+int fragmentsCollected(int *fragment) {
+    int tf = 0;
+    sem_wait(&sems[2]);
+    if (*fragment > 49) {
+        tf = 1;
+    }
+    sem_post(&sems[2]);
+    return tf;
+}
+
+int allInflated(int * count) {
+    int tf = 0;
+    sem_wait(&sems[6]);
+    if (*count > 49) {
+        tf = 1;
+    }
+    sem_post(&sems[6]);
+    return tf;
+}
+
+int recv_buf_cleanup(RECV_BUF *ptr)
+{
+    if (ptr == NULL) {
+	    return 1;
+    }
+
+    free(ptr->buf);
+    ptr->size = 0;
+    ptr->max_size = 0;
+    return 0;
+}
+
+size_t header_cb_curl(char *p_recv, size_t size, size_t nmemb, void *userdata)
+{
+    int realsize = size * nmemb;
+    RECV_BUF *p = userdata;
+    
+    if (realsize > strlen(ECE252_HEADER) &&
+	strncmp(p_recv, ECE252_HEADER, strlen(ECE252_HEADER)) == 0) {
+
+        /* extract img sequence number */
+	p->seq = atoi(p_recv + strlen(ECE252_HEADER));
+
+    }
+    return realsize;
+}
+
+size_t write_cb_curl(char *p_recv, size_t size, size_t nmemb, void *p_userdata)
+{
+    size_t realsize = size * nmemb;
+    RECV_BUF *p = (RECV_BUF *)p_userdata;
+ 
+    if (p->size + realsize + 1 > p->max_size) {/* hope this rarely happens */ 
+        abort();
+    }
+
+    memcpy(p->buf + p->size, p_recv, realsize); /*copy data from libcurl*/
+    p->size += realsize;
+    p->buf[p->size] = 0;
+
+    return realsize;
+}
+
+int sizeof_shm_recv_buf(size_t nbytes)
+{
+    return (sizeof(RECV_BUF_MEM) + sizeof(char) * nbytes);
+}
+
+int recv_buf_init(RECV_BUF *ptr, size_t max_size)
+{
+    void *p = NULL;
+    
+    if (ptr == NULL) {
+        return 1;
+    }
+
+    p = malloc(max_size);
+    if (p == NULL) {
+	    return 2;
+    }
+    
+    ptr->buf = p;
+    ptr->size = 0;
+    ptr->max_size = max_size;
+    ptr->seq = -1;              /* valid seq should be non-negative */
+    return 0;
+}
+
+int main( int argc, char** argv ) {
+
+    double times[2];
+    struct timeval tv;
+
+    /* check if all arguments are provided */
+    if (argc != 6) {
+        printf("usage: ./paster2 <B> <P> <C> <X> <N>\n");
+        return 1;
+    }
+
+    /* collect and verify arguments B, P, C, X, N */
+    B = atoi(argv[1]);
+    PROD_NUM = atoi(argv[2]);
+    CONS_NUM = atoi(argv[3]);
+    DELAY = atoi(argv[4]);
+    IMG_NUM = atoi(argv[5]);
+
+    if (B <= 0) {
+        printf("Buffer size must be greater than 0\n");
+        return 1;
+    }
+
+    if (PROD_NUM <= 0) {
+        printf("Number of producers must be greater than 0\n");
+        return 1;
+    }
+
+    if (CONS_NUM <= 0) {
+        printf("Number of consumers must be greater than 0\n");
+        return 1;
+    }
+
+    if (DELAY < 0) {
+        printf("Delay must be at least 0\n");
+        return 1;
+    }
+
+    if (IMG_NUM < 1 || IMG_NUM > 3) {
+        printf("Image number must be 1, 2, or 3\n");
+        return 1;
+    }
+ 
+    /* declare variables for CURL, shared memory, process ids */
+
+    RECV_BUF_MEM *p_shm_recv_buf;
+    unsigned char *png_buf;
+    int *fragment;
+    int *front;
+    int *rear;
+    int *count;
+    U64 *total_len_inf;
+    U8 *idat_data;
+    unsigned char *first_buf;
+
+    unsigned int *idat_length1;
+
+    int shmid;
+    int shmid_png_buf;
+    int shmid_sems;
+    int shmid_fragment;
+    int shmid_front;
+    int shmid_rear;
+    int shmid_count;
+    int shmid_total_len_inf;
+    int shmid_idat_data;
+    int shmid_idat_length1;
+    int shmid_first_buf;
+
+    int shm_size = sizeof_shm_recv_buf(BUF_SIZE);
+
+    pid_t pid = 0;
+    pid_t ppids[PROD_NUM];
+    pid_t cpids[CONS_NUM];
+    
+    /* create shared memory segment */
+    shmid = shmget(IPC_PRIVATE, B * shm_size, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+    shmid_png_buf = shmget(IPC_PRIVATE, B * BUF_SIZE, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+    shmid_sems = shmget(IPC_PRIVATE, sizeof(sem_t) * NUM_SEMS, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+    shmid_fragment = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+    shmid_front = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+    shmid_rear = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+    shmid_count = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+    shmid_total_len_inf = shmget(IPC_PRIVATE, sizeof(U64), IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+    shmid_total_len_inf = shmget(IPC_PRIVATE, sizeof(char) * BUF_SIZE, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+    shmid_idat_data = shmget(IPC_PRIVATE, MAX_SIZE, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+    shmid_idat_length1 = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+    shmid_first_buf = shmget(IPC_PRIVATE, BUF_SIZE, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
+
+    if (shmid_idat_data == -1 || shmid == -1 || shmid_png_buf == -1 || shmid_sems == -1 || shmid_fragment == -1 || shmid_front == -1 || shmid_rear == -1 || shmid_count == -1 || shmid_total_len_inf == -1) {
+        perror("shmget");
+        abort();
+    }
+
+    /* attach to shared memory regions and initialize buffer */
+    p_shm_recv_buf = shmat(shmid, NULL, 0);
+    png_buf = shmat(shmid_png_buf, NULL, 0);
+    sems = shmat(shmid_sems, NULL, 0);
+    fragment = shmat(shmid_fragment, NULL, 0);
+    front = shmat(shmid_front, NULL, 0);
+    rear = shmat(shmid_rear, NULL, 0);
+    count = shmat(shmid_count, NULL, 0);
+    total_len_inf = shmat(shmid_total_len_inf, NULL, 0);
+    idat_data = shmat(shmid_idat_data, NULL, 0);
+    idat_length1 = shmat(shmid_idat_length1, NULL, 0);
+    first_buf = shmat(shmid_first_buf, NULL, 0);
+
+    if (idat_data == (void *) -1 || p_shm_recv_buf == (void *) -1 || png_buf == (void *) -1 || sems == (void *) -1 || fragment == (void *) -1 || front == (void *) -1 || rear == (void *) -1 || count == (void *) -1 || total_len_inf == (void *) -1 || idat_length1 == (void *)-1) {
+        perror("shmat");
+        abort();
+    }
+
+    /* initialize semaphore for spaces */
+    sem_init(&sems[0], SEM_PROC, B);
+
+    /* initialize semaphore for items */
+    sem_init(&sems[1], SEM_PROC, 0);
+
+    /* initialize semaphore for fragment number */
+    sem_init(&sems[2], SEM_PROC, 1);
+
+    /* initialize semaphore for front number */
+    sem_init(&sems[3], SEM_PROC, 1);
+
+    /* initialize semaphore for rear number */
+    sem_init(&sems[4], SEM_PROC, 1);
+
+    /* initialize semaphore for png_buf */
+    sem_init(&sems[5], SEM_PROC, 1);
+
+    /* initialize semaphore for count */
+    sem_init(&sems[6], SEM_PROC, 1);
+
+    /* initialize semaphore for total_len_inf */
+    sem_init(&sems[7], SEM_PROC, 1);
+
+    /* initialize semaphore for idat_data */
+    sem_init(&sems[8], SEM_PROC, 1);
+
+    /* initialize semaphore for idat_length1 & first buf*/
+    sem_init(&sems[9], SEM_PROC, 1);
+
+    sem_init(&sems[10], SEM_PROC, 1);
+
+    /* initialize fragment number to 0 */
+    sem_wait(&sems[2]);
+    *fragment = 0;
+    sem_post(&sems[2]);
+
+    /* initialize front to 0 */
+    sem_wait(&sems[3]);
+    *front = 0;
+    sem_post(&sems[3]);
+
+    /* initialize rear to 0 */
+    sem_wait(&sems[4]);
+    *rear = 0;
+    sem_post(&sems[4]);
+
+    /* initialize png_buf */
+    sem_wait(&sems[5]);
+    memset(png_buf, 0, B * BUF_SIZE);
+    sem_post(&sems[5]);
+
+    /* initialize count to 0 */
+    sem_wait(&sems[6]);
+    *count = 0;
+    sem_post(&sems[6]);
+
+    /* initialize file and idat length to 0 */
+    sem_wait(&sems[7]);
+    *total_len_inf = 0;
+    sem_post(&sems[7]);
+
+    sem_wait(&sems[9]);
+    *idat_length1 = 0;
+    sem_post(&sems[9]);
+
+    for (int i=0; i<B; i++) {
+        p_shm_recv_buf[i].seq = -1;
+    }
+
+    /* declare variables for catpng logic in consumer */
+    U8 *p_buffer = NULL;
+
+    int idat_init = 0;
+    
+    curl_global_init(CURL_GLOBAL_DEFAULT);
+
+    /* timing */
+    if (gettimeofday(&tv, NULL) != 0) {
+        perror("gettimeofday");
+        abort();
+    }
+
+    times[0] = (tv.tv_sec) + tv.tv_usec/1000000.;
+
+    for (int i = 0; i < (PROD_NUM + CONS_NUM); i++) {
+
+        pid = fork();
+
+        if (i < PROD_NUM) {
+
+            if ( pid == 0 ) {          /* child proc */
+
+                /* run as a producer */
+
+                while (!fragmentsCollected(fragment)) {
+
+                    sem_wait(&sems[0]);
+
+                    CURL *curl_handle;
+                    CURLcode res;
+                    char url[256];
+
+                    /* init a curl session */
+                    curl_handle = curl_easy_init();
+
+                    if (curl_handle == NULL) {
+                        fprintf(stderr, "curl_easy_init: returned NULL\n");
+                        return 1;
+                    }
+
+                    /* assign one of the three servers to the url */
+                    if (i % 3 == 0) {
+                        strcpy(url, IMG_URL3);
+                    } else if (i % 3 == 1) {
+                        strcpy(url, IMG_URL);
+                    } else {  
+                        strcpy(url, IMG_URL2);
+                    }
+
+                    sprintf(url + strlen(IMG_URL), "%d", IMG_NUM);
+                    char part_string[] = "&part=";
+                    sem_wait(&sems[2]);
+                    sprintf((url + strlen(IMG_URL) + 1), "%s%d", part_string, *fragment);
+                    (*fragment)++;
+                    sem_post(&sems[2]);
+
+                    RECV_BUF recv_buf;
+                    recv_buf_init(&recv_buf, BUF_SIZE);
+
+                    /* specify URL to get */
+                    curl_easy_setopt(curl_handle, CURLOPT_URL, url);
+
+                    /* register write call back function to process received data */
+                    curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_cb_curl); 
+                    /* user defined data structure passed to the call back function */
+                    curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&recv_buf);
+
+                    /* register header call back function to process received header data */
+                    curl_easy_setopt(curl_handle, CURLOPT_HEADERFUNCTION, header_cb_curl); 
+                    /* user defined data structure passed to the call back function */
+                    curl_easy_setopt(curl_handle, CURLOPT_HEADERDATA, (void *)&recv_buf);
+
+                    /* some servers requires a user-agent field */
+                    curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
+
+                    /* get it! */
+                    res = curl_easy_perform(curl_handle);
+
+                    if( res != CURLE_OK) {
+                        fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
+                    }
+
+                    sem_wait(&sems[10]);
+                    
+                    p_shm_recv_buf[*rear].size = recv_buf.size;
+                    p_shm_recv_buf[*rear].max_size = recv_buf.max_size;
+                    p_shm_recv_buf[*rear].seq = recv_buf.seq;
+
+                    memcpy(png_buf + ((*rear)*BUF_SIZE), recv_buf.buf, recv_buf.size);
+
+                    *rear = (*rear + 1) % B;
+                    sem_post(&sems[10]);
+
+                    recv_buf_cleanup(&recv_buf);
+
+                    curl_easy_cleanup(curl_handle);
+                    
+                    sem_post(&sems[1]);
+                    
+                }
+                exit(0);
+
+            } else if ( pid > 0 ) {    /* parent proc */
+                ppids[i] = pid;
+            } else {
+                perror("fork");
+                abort();
+            }
+        
+        } else {
+
+            if ( pid == 0 ) {          /* child proc */
+
+                /* run as a consumer */
+
+                while(!allInflated(count)) {
+
+                    usleep(DELAY * 1000);
+
+                    U64 len_inf = 0;
+
+                    sem_wait(&sems[10]);
+
+                    sem_wait(&sems[6]);
+                    int valid = 0;
+                    for (int k=0; k<B; k++) {
+                        if ((p_shm_recv_buf[k].seq) == *count) {
+                            *front = k;
+                            valid = 1;
+                        }
+                    }
+                    sem_post(&sems[6]);
+                    
+
+                    if (!valid) {
+                        usleep(10000);
+                    } else {
+                        sem_wait(&sems[1]);
+
+                        unsigned int file_length = p_shm_recv_buf[*front].size;
+
+                        p_buffer = malloc(file_length * sizeof(unsigned char));
+
+                        if (p_buffer == NULL) {
+                            perror("malloc");
+                            return errno;
+                        }
+
+                        memcpy(p_buffer, png_buf + ((*front)*BUF_SIZE), file_length);
+
+                        /* calculate data length */
+
+                        U8 data_length[9];
+                        sprintf(data_length, "%02x%02x%02x%02x", p_buffer[33], p_buffer[34], p_buffer[35], p_buffer[36]);
+                        unsigned int len = strtol(data_length, NULL, 16);
+
+                        if (p_shm_recv_buf[*front].seq == 0) {
+                            *idat_length1 = len;
+                            memcpy(first_buf, png_buf + ((*front)*BUF_SIZE), file_length);
+                        }
+
+                        *front = (*front + 1) % B;
+
+                        U8 width[9];
+                        sprintf(width, "%02x%02x%02x%02x", p_buffer[16], p_buffer[17], p_buffer[18], p_buffer[19]);
+                        int w = strtol(width, NULL, 16);
+
+                        /* calculate height */
+
+                        U8 height[9];
+                        sprintf(height, "%02x%02x%02x%02x", p_buffer[20], p_buffer[21], p_buffer[22], p_buffer[23]);
+                        int h = strtol(height, NULL, 16);
+
+                        U8 *buf_inf = malloc(h * (w * 4 + 1));
+
+                        /* inflate data */
+                        int ret = mem_inf(buf_inf, &len_inf, (p_buffer + 41), len);
+
+                        if (ret != 0) { /* failure */
+                            fprintf(stderr,"mem_inf failed. ret = %d.\n", ret);
+                            return ret;
+                        }
+
+                        /* PUT INFLATED DATA IN IDAT_DATA */
+
+                        sem_wait(&sems[7]);
+                        memcpy((idat_data + (*total_len_inf)), buf_inf, len_inf);
+                        *total_len_inf += len_inf;
+                        sem_post(&sems[7]);
+
+                        sem_wait(&sems[6]);
+                        (*count)++;
+                        sem_post(&sems[6]);
+
+                        free(buf_inf);
+                        free(p_buffer);
+
+                        sem_post(&sems[0]);
+                    }
+                    sem_post(&sems[10]);
+                }
+
+                exit(0);
+
+            } else if ( pid > 0 ) {    /* parent proc */
+                cpids[i - PROD_NUM] = pid;
+            } else {
+                perror("fork");
+                abort();
+            }
+        }
+    }
+
+    int state;
+
+    if ( pid > 0 ) {            /* parent process */
+        for (int i = 0; i < PROD_NUM; i++ ) {
+            waitpid(ppids[i], &state, 0);
+        }
+        for (int i = 0; i < CONS_NUM; i++ ) {
+            waitpid(cpids[i], &state, 0);
+        }
+    }
+
+    /* catpng logic */
+
+    char *outputFile = "all.png";
+    FILE *out_fp = fopen(outputFile, "wb+");
+
+    U32 crc_val = 0;
+
+    /* deflate data */
+    U64 len_def = 0;
+    sem_wait(&sems[7]);
+    U8 *gp_buf_def = malloc((*total_len_inf));
+
+    sem_wait(&sems[8]);
+    int ret = mem_def(gp_buf_def, &len_def, idat_data, *total_len_inf, Z_DEFAULT_COMPRESSION);
+    sem_post(&sems[8]);
+
+    sem_post(&sems[7]);
+
+     /* failure */
+    if (ret != 0) { 
+        fprintf(stderr,"mem_def failed. ret = %d.\n", ret);
+        return ret;
+    }
+
+    sem_wait(&sems[9]);
+
+    U8 *png_buffer = malloc((57+len_def)*sizeof(U8));
+    memcpy(png_buffer, first_buf, 20);
+
+    /* copy IHDR height to buffer */
+    unsigned int total_height = 6*50;
+    unsigned int total_width = 400*50;
+
+    total_height = htonl(total_height);
+    memcpy((png_buffer + 20), &total_height, 4);
+
+    /* copy rest of IHDR to buffer */
+    memcpy((png_buffer + 24), (first_buf + 24), 5);
+
+    /* calculate and copy IHDR CRC to file */
+    crc_val = crc((png_buffer + 12), (CHUNK_LEN_SIZE + DATA_IHDR_SIZE));
+    U32 transform_crc = htonl(crc_val);
+    memcpy((png_buffer + 29), &transform_crc, 4);
+
+    /* write IDAT length to file */
+    U32 transform_len_def = htonl(len_def);
+    memcpy((png_buffer + 33), &transform_len_def, 4);
+
+    /* copy IDAT type to buffer */
+    memcpy((png_buffer + 37), (first_buf + 37), CHUNK_TYPE_SIZE);
+
+    /* copy IDAT data to buffer */
+    memcpy((png_buffer + 41), gp_buf_def, len_def);
+
+    /* calculate and copy IDAT CRC to buffer */
+    crc_val = crc((png_buffer + 37), (len_def + CHUNK_TYPE_SIZE));
+    U32 transform_idat_crc = htonl(crc_val);
+    memcpy((png_buffer + 41 + len_def), &transform_idat_crc, CHUNK_CRC_SIZE);
+
+    /* copy IEND chunk to buffer */
+    memcpy((png_buffer + 45 + len_def), (first_buf + 45 + *idat_length1) , 12);
+
+    sem_post(&sems[9]);
+
+    /* write IEND chunk to file */
+    fwrite(png_buffer, (57+len_def)*sizeof(U8), 1, out_fp);
+
+    fclose(out_fp);
+
+    /* timing */
+    if (gettimeofday(&tv, NULL) != 0) {
+        perror("gettimeofday");
+        abort();
+    }
+    times[1] = (tv.tv_sec) + tv.tv_usec/1000000.;
+    printf("paster2 execution time: %.6lf seconds\n", (times[1] - times[0]));
+
+    free(p_buffer);
+    free(gp_buf_def);
+    free(png_buffer);
+
+    /* detach from shared memory */
+    shmdt(p_shm_recv_buf);
+    shmdt(png_buf);
+    shmdt(sems);
+    shmdt(fragment);
+    shmdt(front);
+    shmdt(rear);
+    shmdt(count);
+    shmdt(total_len_inf);
+    shmdt(idat_length1);
+
+    shmctl(shmid, IPC_RMID, NULL);
+    shmctl(shmid_png_buf, IPC_RMID, NULL);
+    shmctl(shmid_sems, IPC_RMID, NULL);
+    shmctl(shmid_fragment, IPC_RMID, NULL);
+    shmctl(shmid_front, IPC_RMID, NULL);
+    shmctl(shmid_rear, IPC_RMID, NULL);
+    shmctl(shmid_count, IPC_RMID, NULL);
+    shmctl(shmid_total_len_inf, IPC_RMID, NULL);
+    shmctl(shmid_idat_length1, IPC_RMID, NULL);
+
+    for (int i = 0; i < NUM_SEMS; i++) {
+        sem_destroy(&sems[i]);
+    }
+
+    curl_global_cleanup();
+
+    return 0;
+
+}
\ No newline at end of file
diff --git a/lab3/zutil.c b/lab3/zutil.c
new file mode 100644
index 00000000..e47da01d
--- /dev/null
+++ b/lab3/zutil.c
@@ -0,0 +1,159 @@
+/**
+ * @brief: in memory deflation (zip) and inflation (unzip) routines 
+ *
+ * Based on the zlib example zpipe.c at https://www.zlib.net/zlib_how.html
+ *
+ * Modification is
+ * Copyright 2018-2020 Yiqing Huang
+ *
+ * This software may be freely redistributed under the terms of MIT License
+ */
+
+#include <stdio.h>
+#include "zutil.h"
+
+/**
+ * @brief: deflate in memory data from source to dest.
+ *         The memory areas must not overlap.
+ * @param: dest U8* output buffer, caller supplies, should be big enough
+ *         to hold the deflated data
+ * @param: dest_len, U64* output parameter, points to length of deflated data
+ * @param: source U8* source buffer, contains data to be deflated
+ * @param: source_len U64 length of source data
+ * @param: level int compression levels (https://www.zlib.net/manual.html)
+ *    Z_NO_COMPRESSION, Z_BEST_SPEED, Z_BEST_COMPRESSION, Z_DEFAULT_COMPRESSION
+ * @return =0  on success 
+ *         <>0 on error
+ * NOTE: 1. the compressed data length may be longer than the input data length,
+ *          especially when the input data size is very small.
+ */
+int mem_def(U8 *dest, U64 *dest_len, U8 *source,  U64 source_len, int level)
+{
+    z_stream strm;    /* pass info. to and from zlib routines   */
+    U8 out[CHUNK];    /* output buffer for deflate()            */
+    int ret = 0;      /* zlib return code                       */
+    int have = 0;     /* amount of data returned from deflate() */
+    int def_len = 0;  /* accumulated deflated data length       */
+    U8 *p_dest = dest;/* first empty slot in dest buffer        */
+
+    
+    strm.zalloc = Z_NULL;
+    strm.zfree  = Z_NULL;
+    strm.opaque = Z_NULL;
+
+    ret = deflateInit(&strm, level);
+    if (ret != Z_OK) {
+        return ret;
+    }
+
+    /* set input data stream */
+    strm.avail_in = source_len;
+    strm.next_in = source;
+
+    /* call deflate repetitively since the out buffer size is fixed
+       and the deflated output data length is not known ahead of time */
+
+    do {
+        strm.avail_out = CHUNK;
+        strm.next_out = out;
+        ret = deflate(&strm, Z_FINISH); /* source contains the whole data */
+        assert(ret != Z_STREAM_ERROR);
+        have = CHUNK - strm.avail_out; 
+        memcpy(p_dest, out, have);
+        p_dest += have;  /* advance to the next free byte to write */
+        def_len += have; /* increment deflated data length         */
+    } while (strm.avail_out == 0);
+
+    assert(strm.avail_in == 0);   /* all input will be used  */
+    assert(ret == Z_STREAM_END);  /* stream will be complete */
+
+    /* clean up and return */
+    (void) deflateEnd(&strm);
+    *dest_len = def_len;
+    return Z_OK;
+}
+
+/**
+ * @brief: inflate in memory data from source to dest 
+ * @param: dest U8* output buffer, caller supplies, should be big enough
+ *         to hold the deflated data
+ * @param: dest_len, U64* output parameter, length of inflated data
+ * @param: source U8* source buffer, contains zlib data to be inflated
+ * @param: source_len U64 length of source data
+ * 
+ * @return =0  on success
+ *         <>0 error
+ */
+int mem_inf(U8 *dest, U64 *dest_len, U8 *source,  U64 source_len)
+{
+    z_stream strm;    /* pass info. to and from zlib routines   */
+    U8 out[CHUNK];    /* output buffer for inflate()            */
+    int ret = 0;      /* zlib return code                       */
+    int have = 0;     /* amount of data returned from inflate() */
+    int inf_len = 0;  /* accumulated inflated data length       */
+    U8 *p_dest = dest;/* first empty slot in dest buffer        */
+
+    /* allocate inflate state 8 */
+    strm.zalloc = Z_NULL;
+    strm.zfree = Z_NULL;
+    strm.opaque = Z_NULL;
+    strm.avail_in = 0;        /* no input data being provided   */
+    strm.next_in = Z_NULL;    /* no input data being provided   */
+    ret = inflateInit(&strm);
+    if (ret != Z_OK) {
+        return ret;
+    }
+
+    /* set input data stream */
+    strm.avail_in = source_len;
+    strm.next_in = source;
+
+    /* run inflate() on input until output buffer not full */
+    do {
+        strm.avail_out = CHUNK;
+        strm.next_out = out;
+
+        /* zlib format is self-terminating, no need to flush */
+        ret = inflate(&strm, Z_NO_FLUSH);
+        assert(ret != Z_STREAM_ERROR);    /* state no t clobbered */
+        switch(ret) {
+        case Z_NEED_DICT:
+            ret = Z_DATA_ERROR;  /* and fall through */
+        case Z_DATA_ERROR:
+        case Z_MEM_ERROR:
+            (void) inflateEnd(&strm);
+			return ret;
+        }
+        have = CHUNK - strm.avail_out;
+        memcpy(p_dest, out, have);
+        p_dest += have;  /* advance to the next free byte to write */
+        inf_len += have; /* increment inflated data length         */
+    } while (strm.avail_out == 0 );
+
+    /* clean up and return */
+    (void) inflateEnd(&strm);
+    *dest_len = inf_len;
+    
+    return (ret == Z_STREAM_END) ? Z_OK : Z_DATA_ERROR;
+}
+
+/* report a zlib or i/o error */
+void zerr(int ret)
+{
+    fputs("zutil: ", stderr);
+    switch (ret) {
+    case Z_STREAM_ERROR:
+        fputs("invalid compression level\n", stderr);
+        break;
+    case Z_DATA_ERROR:
+        fputs("invalid or incomplete deflate data\n", stderr);
+        break;
+    case Z_MEM_ERROR:
+        fputs("out of memory\n", stderr);
+        break;
+    case Z_VERSION_ERROR:
+        fputs("zlib version mismatch!\n", stderr);
+    default:
+	fprintf(stderr, "zlib returns err %d!\n", ret);
+    }
+}
diff --git a/lab3/zutil.h b/lab3/zutil.h
new file mode 100644
index 00000000..f914fbc2
--- /dev/null
+++ b/lab3/zutil.h
@@ -0,0 +1,38 @@
+/**
+ * @brief: header file of in memory deflation and inflation using zlib. 
+ * Based on the zlib example zpipe.c at https://www.zlib.net/zlib_how.html
+ *
+ * Modification is
+ * Copyright 2018-2020 Yiqing Huang
+ *
+ * This software may be freely redistributed under the terms of MIT License
+ *            https://www.zlib.net/zlib_how.html
+ */
+
+#pragma once
+
+/* INCLUDES */
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include "zlib.h"
+
+/* DEFINES */
+#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
+#  include <fcntl.h>
+#  include <io.h>
+#  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
+#else
+#  define SET_BINARY_MODE(file)
+#endif
+
+#define CHUNK 16384  /* =256*64 on the order of 128K or 256K should be used */
+
+/* TYPEDEFS */
+typedef unsigned char U8;
+typedef unsigned long int U64;
+
+/* FUNCTION PROTOTYPES */
+int mem_def(U8 *dest, U64 *dest_len, U8 *source,  U64 source_len, int level);
+int mem_inf(U8 *dest, U64 *dest_len, U8 *source,  U64 source_len);
+void zerr(int ret);
diff --git a/lab4/Makefile b/lab4/Makefile
new file mode 100644
index 00000000..537be4ad
--- /dev/null
+++ b/lab4/Makefile
@@ -0,0 +1,33 @@
+# Makefile, ECE252  
+# Cindy Huang and Samuel Liu
+
+CC = gcc 
+CFLAGS_XML2 = $(shell xml2-config --cflags)
+CFLAGS_CURL = $(shell curl-config --cflags)
+CFLAGS = -Wall $(CFLAGS_XML2) $(CFLAGS_CURL) -std=gnu99 -g -DDEBUG1_
+LD = gcc
+LDFLAGS = -std=gnu99 -g 
+LDLIBS_XML2 = $(shell xml2-config --libs)
+LDLIBS_CURL = $(shell curl-config --libs)
+LDLIBS = $(LDLIBS_XML2) $(LDLIBS_CURL) 
+
+SRCS   = findpng2.c
+OBJS3  = findpng2.o
+TARGETS= findpng2
+
+all: ${TARGETS}
+
+main.out: $(OBJS3) 
+	$(LD) -o $@ $^ $(LDLIBS) $(LDFLAGS) 
+
+%.o: %.c 
+	$(CC) $(CFLAGS) -c $< 
+
+%.d: %.c
+	gcc -MM -MF $@ $<
+
+-include $(SRCS:.c=.d)
+
+.PHONY: clean
+clean:
+	rm -f *~ *.d *.o $(TARGETS) *.png *.html
diff --git a/lab4/findpng2.c b/lab4/findpng2.c
new file mode 100644
index 00000000..78ba100f
--- /dev/null
+++ b/lab4/findpng2.c
@@ -0,0 +1,516 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <curl/curl.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/parser.h>
+#include <libxml/xpath.h>
+#include <libxml/uri.h>
+
+// #include <sys/shm.h>
+// #include <sys/stat.h>
+// #include <sys/wait.h>
+// #include <semaphore.h>
+// #include <errno.h>
+// #include <arpa/inet.h>
+// #include <time.h>
+// #include <sys/time.h>
+// #include <sys/ipc.h>
+
+#define SEED_URL "http://ece252-1.uwaterloo.ca/lab4/"
+#define ECE252_HEADER "X-Ece252-Fragment: "
+#define BUF_SIZE 1048576  /* 1024*1024 = 1M */
+#define BUF_INC  524288   /* 1024*512  = 0.5M */
+
+#define CT_PNG  "image/png"
+#define CT_HTML "text/html"
+#define CT_PNG_LEN  9
+#define CT_HTML_LEN 9
+
+#define max(a, b) \
+   ({ __typeof__ (a) _a = (a); \
+       __typeof__ (b) _b = (b); \
+     _a > _b ? _a : _b; })
+
+typedef struct recv_buf2 {
+    char *buf;       /* memory to hold a copy of received data */
+    size_t size;     /* size of valid data in buf in bytes*/
+    size_t max_size; /* max capacity of buf in bytes*/
+    int seq;         /* >=0 sequence number extracted from http header */
+                     /* <0 indicates an invalid seq number */
+} RECV_BUF;
+
+
+htmlDocPtr mem_getdoc(char *buf, int size, const char *url);
+xmlXPathObjectPtr getnodeset (xmlDocPtr doc, xmlChar *xpath);
+int find_http(char *fname, int size, int follow_relative_links, const char *base_url);
+size_t header_cb_curl(char *p_recv, size_t size, size_t nmemb, void *userdata);
+size_t write_cb_curl3(char *p_recv, size_t size, size_t nmemb, void *p_userdata);
+int recv_buf_init(RECV_BUF *ptr, size_t max_size);
+int recv_buf_cleanup(RECV_BUF *ptr);
+void cleanup(CURL *curl, RECV_BUF *ptr);
+int write_file(const char *path, const void *in, size_t len);
+CURL *easy_handle_init(RECV_BUF *ptr, const char *url);
+int process_data(CURL *curl_handle, RECV_BUF *p_recv_buf);
+
+
+htmlDocPtr mem_getdoc(char *buf, int size, const char *url)
+{
+    int opts = HTML_PARSE_NOBLANKS | HTML_PARSE_NOERROR | \
+               HTML_PARSE_NOWARNING | HTML_PARSE_NONET;
+    htmlDocPtr doc = htmlReadMemory(buf, size, url, NULL, opts);
+    
+    if ( doc == NULL ) {
+        fprintf(stderr, "Document not parsed successfully.\n");
+        return NULL;
+    }
+    return doc;
+}
+
+xmlXPathObjectPtr getnodeset (xmlDocPtr doc, xmlChar *xpath)
+{
+	
+    xmlXPathContextPtr context;
+    xmlXPathObjectPtr result;
+
+    context = xmlXPathNewContext(doc);
+    if (context == NULL) {
+        printf("Error in xmlXPathNewContext\n");
+        return NULL;
+    }
+    result = xmlXPathEvalExpression(xpath, context);
+    xmlXPathFreeContext(context);
+    if (result == NULL) {
+        printf("Error in xmlXPathEvalExpression\n");
+        return NULL;
+    }
+    if(xmlXPathNodeSetIsEmpty(result->nodesetval)){
+        xmlXPathFreeObject(result);
+        printf("No result\n");
+        return NULL;
+    }
+    return result;
+}
+
+int find_http(char *buf, int size, int follow_relative_links, const char *base_url)
+{
+
+    int i;
+    htmlDocPtr doc;
+    xmlChar *xpath = (xmlChar*) "//a/@href";
+    xmlNodeSetPtr nodeset;
+    xmlXPathObjectPtr result;
+    xmlChar *href;
+		
+    if (buf == NULL) {
+        return 1;
+    }
+
+    doc = mem_getdoc(buf, size, base_url);
+    result = getnodeset (doc, xpath);
+    if (result) {
+        nodeset = result->nodesetval;
+        for (i=0; i < nodeset->nodeNr; i++) {
+            href = xmlNodeListGetString(doc, nodeset->nodeTab[i]->xmlChildrenNode, 1);
+            if ( follow_relative_links ) {
+                xmlChar *old = href;
+                href = xmlBuildURI(href, (xmlChar *) base_url);
+                xmlFree(old);
+            }
+            if ( href != NULL && !strncmp((const char *)href, "http", 4) ) {
+                printf("href: %s\n", href);
+            }
+            xmlFree(href);
+        }
+        xmlXPathFreeObject (result);
+    }
+    xmlFreeDoc(doc);
+    xmlCleanupParser();
+    return 0;
+}
+/**
+ * @brief  cURL header call back function to extract image sequence number from 
+ *         http header data. An example header for image part n (assume n = 2) is:
+ *         X-Ece252-Fragment: 2
+ * @param  char *p_recv: header data delivered by cURL
+ * @param  size_t size size of each memb
+ * @param  size_t nmemb number of memb
+ * @param  void *userdata user defined data structurea
+ * @return size of header data received.
+ * @details this routine will be invoked multiple times by the libcurl until the full
+ * header data are received.  we are only interested in the ECE252_HEADER line 
+ * received so that we can extract the image sequence number from it. This
+ * explains the if block in the code.
+ */
+size_t header_cb_curl(char *p_recv, size_t size, size_t nmemb, void *userdata)
+{
+    int realsize = size * nmemb;
+    RECV_BUF *p = userdata;
+
+#ifdef DEBUG1_
+    printf("%s", p_recv);
+#endif /* DEBUG1_ */
+    if (realsize > strlen(ECE252_HEADER) &&
+	strncmp(p_recv, ECE252_HEADER, strlen(ECE252_HEADER)) == 0) {
+
+        /* extract img sequence number */
+	p->seq = atoi(p_recv + strlen(ECE252_HEADER));
+
+    }
+    return realsize;
+}
+
+
+/**
+ * @brief write callback function to save a copy of received data in RAM.
+ *        The received libcurl data are pointed by p_recv, 
+ *        which is provided by libcurl and is not user allocated memory.
+ *        The user allocated memory is at p_userdata. One needs to
+ *        cast it to the proper struct to make good use of it.
+ *        This function maybe invoked more than once by one invokation of
+ *        curl_easy_perform().
+ */
+
+size_t write_cb_curl3(char *p_recv, size_t size, size_t nmemb, void *p_userdata)
+{
+    size_t realsize = size * nmemb;
+    RECV_BUF *p = (RECV_BUF *)p_userdata;
+ 
+    if (p->size + realsize + 1 > p->max_size) {/* hope this rarely happens */ 
+        /* received data is not 0 terminated, add one byte for terminating 0 */
+        size_t new_size = p->max_size + max(BUF_INC, realsize + 1);   
+        char *q = realloc(p->buf, new_size);
+        if (q == NULL) {
+            perror("realloc"); /* out of memory */
+            return -1;
+        }
+        p->buf = q;
+        p->max_size = new_size;
+    }
+
+    memcpy(p->buf + p->size, p_recv, realsize); /*copy data from libcurl*/
+    p->size += realsize;
+    p->buf[p->size] = 0;
+
+    return realsize;
+}
+
+
+int recv_buf_init(RECV_BUF *ptr, size_t max_size)
+{
+    void *p = NULL;
+    
+    if (ptr == NULL) {
+        return 1;
+    }
+
+    p = malloc(max_size);
+    if (p == NULL) {
+	return 2;
+    }
+    
+    ptr->buf = p;
+    ptr->size = 0;
+    ptr->max_size = max_size;
+    ptr->seq = -1;              /* valid seq should be positive */
+    return 0;
+}
+
+int recv_buf_cleanup(RECV_BUF *ptr)
+{
+    if (ptr == NULL) {
+	return 1;
+    }
+    
+    free(ptr->buf);
+    ptr->size = 0;
+    ptr->max_size = 0;
+    return 0;
+}
+
+void cleanup(CURL *curl, RECV_BUF *ptr)
+{
+        curl_easy_cleanup(curl);
+        curl_global_cleanup();
+        recv_buf_cleanup(ptr);
+}
+/**
+ * @brief output data in memory to a file
+ * @param path const char *, output file path
+ * @param in  void *, input data to be written to the file
+ * @param len size_t, length of the input data in bytes
+ */
+
+int write_file(const char *path, const void *in, size_t len)
+{
+    FILE *fp = NULL;
+
+    if (path == NULL) {
+        fprintf(stderr, "write_file: file name is null!\n");
+        return -1;
+    }
+
+    if (in == NULL) {
+        fprintf(stderr, "write_file: input data is null!\n");
+        return -1;
+    }
+
+    fp = fopen(path, "wb");
+    if (fp == NULL) {
+        perror("fopen");
+        return -2;
+    }
+
+    if (fwrite(in, 1, len, fp) != len) {
+        fprintf(stderr, "write_file: imcomplete write!\n");
+        return -3; 
+    }
+    return fclose(fp);
+}
+
+/**
+ * @brief create a curl easy handle and set the options.
+ * @param RECV_BUF *ptr points to user data needed by the curl write call back function
+ * @param const char *url is the target url to fetch resoruce
+ * @return a valid CURL * handle upon sucess; NULL otherwise
+ * Note: the caller is responsbile for cleaning the returned curl handle
+ */
+
+CURL *easy_handle_init(RECV_BUF *ptr, const char *url)
+{
+    CURL *curl_handle = NULL;
+
+    if ( ptr == NULL || url == NULL) {
+        return NULL;
+    }
+
+    /* init user defined call back function buffer */
+    if ( recv_buf_init(ptr, BUF_SIZE) != 0 ) {
+        return NULL;
+    }
+    /* init a curl session */
+    curl_handle = curl_easy_init();
+
+    if (curl_handle == NULL) {
+        fprintf(stderr, "curl_easy_init: returned NULL\n");
+        return NULL;
+    }
+
+    /* specify URL to get */
+    curl_easy_setopt(curl_handle, CURLOPT_URL, url);
+
+    /* register write call back function to process received data */
+    curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, write_cb_curl3); 
+    /* user defined data structure passed to the call back function */
+    curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)ptr);
+
+    /* register header call back function to process received header data */
+    curl_easy_setopt(curl_handle, CURLOPT_HEADERFUNCTION, header_cb_curl); 
+    /* user defined data structure passed to the call back function */
+    curl_easy_setopt(curl_handle, CURLOPT_HEADERDATA, (void *)ptr);
+
+    /* some servers requires a user-agent field */
+    curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "ece252 lab4 crawler");
+
+    /* follow HTTP 3XX redirects */
+    curl_easy_setopt(curl_handle, CURLOPT_FOLLOWLOCATION, 1L);
+    /* continue to send authentication credentials when following locations */
+    curl_easy_setopt(curl_handle, CURLOPT_UNRESTRICTED_AUTH, 1L);
+    /* max numbre of redirects to follow sets to 5 */
+    curl_easy_setopt(curl_handle, CURLOPT_MAXREDIRS, 5L);
+    /* supports all built-in encodings */ 
+    curl_easy_setopt(curl_handle, CURLOPT_ACCEPT_ENCODING, "");
+
+    /* Max time in seconds that the connection phase to the server to take */
+    //curl_easy_setopt(curl_handle, CURLOPT_CONNECTTIMEOUT, 5L);
+    /* Max time in seconds that libcurl transfer operation is allowed to take */
+    //curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, 10L);
+    /* Time out for Expect: 100-continue response in milliseconds */
+    //curl_easy_setopt(curl_handle, CURLOPT_EXPECT_100_TIMEOUT_MS, 0L);
+
+    /* Enable the cookie engine without reading any initial cookies */
+    curl_easy_setopt(curl_handle, CURLOPT_COOKIEFILE, "");
+    /* allow whatever auth the proxy speaks */
+    curl_easy_setopt(curl_handle, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
+    /* allow whatever auth the server speaks */
+    curl_easy_setopt(curl_handle, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
+
+    return curl_handle;
+}
+
+int process_html(CURL *curl_handle, RECV_BUF *p_recv_buf)
+{
+    char fname[256];
+    int follow_relative_link = 1;
+    char *url = NULL; 
+    pid_t pid =getpid();
+
+    curl_easy_getinfo(curl_handle, CURLINFO_EFFECTIVE_URL, &url);
+    find_http(p_recv_buf->buf, p_recv_buf->size, follow_relative_link, url); 
+    sprintf(fname, "./output_%d.html", pid);
+    return write_file(fname, p_recv_buf->buf, p_recv_buf->size);
+}
+
+int process_png(CURL *curl_handle, RECV_BUF *p_recv_buf)
+{
+    pid_t pid =getpid();
+    char fname[256];
+    char *eurl = NULL;          /* effective URL */
+    curl_easy_getinfo(curl_handle, CURLINFO_EFFECTIVE_URL, &eurl);
+    if ( eurl != NULL) {
+        printf("The PNG url is: %s\n", eurl);
+    }
+
+    sprintf(fname, "./output_%d_%d.png", p_recv_buf->seq, pid);
+    return write_file(fname, p_recv_buf->buf, p_recv_buf->size);
+}
+/**
+ * @brief process teh download data by curl
+ * @param CURL *curl_handle is the curl handler
+ * @param RECV_BUF p_recv_buf contains the received data. 
+ * @return 0 on success; non-zero otherwise
+ */
+
+int process_data(CURL *curl_handle, RECV_BUF *p_recv_buf)
+{
+    CURLcode res;
+    char fname[256];
+    pid_t pid =getpid();
+    long response_code;
+
+    res = curl_easy_getinfo(curl_handle, CURLINFO_RESPONSE_CODE, &response_code);
+    if ( res == CURLE_OK ) {
+	    printf("Response code: %ld\n", response_code);
+    }
+
+    if ( response_code >= 400 ) { 
+    	fprintf(stderr, "Error.\n");
+        return 1;
+    }
+
+    char *ct = NULL;
+    res = curl_easy_getinfo(curl_handle, CURLINFO_CONTENT_TYPE, &ct);
+    if ( res == CURLE_OK && ct != NULL ) {
+    	printf("Content-Type: %s, len=%ld\n", ct, strlen(ct));
+    } else {
+        fprintf(stderr, "Failed obtain Content-Type\n");
+        return 2;
+    }
+
+    if ( strstr(ct, CT_HTML) ) {
+        return process_html(curl_handle, p_recv_buf);
+    } else if ( strstr(ct, CT_PNG) ) {
+        return process_png(curl_handle, p_recv_buf);
+    } else {
+        sprintf(fname, "./output_%d", pid);
+    }
+
+    return write_file(fname, p_recv_buf->buf, p_recv_buf->size);
+}
+
+int main( int argc, char** argv ) {
+
+    int c;
+    int t = 1;
+    int m = 50;
+    int v = 0;
+    char *log_file = NULL;
+    char *seed_url = NULL;
+    char *png_file = "png_urls.txt";
+
+    char *str = "option requires an argument";
+
+    while ((c = getopt(argc, argv, "t:m:v:")) != -1) {
+        switch (c) {
+        case 't':
+            t = strtoul(optarg, NULL, 10);
+            printf("option -t specifies a value of %d.\n", t);
+            if (t <= 0) {
+                fprintf(stderr, "%s: %s > 0 -- 't'\n", argv[0], str);
+                return -1;
+            }
+            break;
+        case 'm':
+            m = strtoul(optarg, NULL, 10);
+	        printf("option -m specifies a value of %d.\n", m);
+            if (m < 0) {
+                fprintf(stderr, "%s: %s >= 0 -- 'm'\n", argv[0], str);
+                return -1;
+            }
+            break;
+        case 'v':
+            v = 1;
+            log_file = optarg;
+	        printf("option -n specifies a value of %s.\n", log_file);
+            break;
+        default:
+            return -1;
+        }
+    }
+
+    seed_url = argv[optind];
+    if (seed_url == NULL) {
+        printf("Usage: findpng2 <url>\n");
+        return 1;
+    }
+    printf("t: %d, m: %d, v: %d, log_file: %s\n", t, m, v, log_file);
+
+    if (t == 1) {
+        printf("running single-threaded version\n");
+
+        CURL *curl_handle;
+        CURLcode res;
+        RECV_BUF recv_buf;
+            
+        printf("URL is %s\n", seed_url);
+
+        // curl_global_init(CURL_GLOBAL_DEFAULT);
+        // curl_handle = easy_handle_init(&recv_buf, url);
+
+        // if ( curl_handle == NULL ) {
+        //     fprintf(stderr, "Curl initialization failed. Exiting...\n");
+        //     curl_global_cleanup();
+        //     abort();
+        // }
+        // /* get it! */
+        // res = curl_easy_perform(curl_handle);
+
+        // if( res != CURLE_OK) {
+        //     fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
+        //     cleanup(curl_handle, &recv_buf);
+        //     exit(1);
+        // } else {
+        // printf("%lu bytes received in memory %p, seq=%d.\n", recv_buf.size, recv_buf.buf, recv_buf.seq);
+        // }
+
+        // /* process the download data */
+        // process_data(curl_handle, &recv_buf);
+
+        // /* cleaning up */
+        // cleanup(curl_handle, &recv_buf);
+    }
+    return 0;
+}
+
+// lists:
+// visited URLs
+// PNG URLs
+// lists shared between threads
+// reading - multiple threads
+// writing - one thread
+// terminate when no more URLs in frontier (to be visited) or number of PNGs found
+// counters - PNG URLs found, threads waiting for new URL
+
+// hash table for visited URLs list - gclib hsearch(3)
+// if visited, don't add to frontier
+
+
+
+// empty png_urls.txt file if empty search result
+// -t: number of threads (single-threaded if not specified)
+// -m: number of unique PNG URLs to find (50 is not specified)
+// -v: name of file - log URLs visited in file (don't when not specified)
+
+// print: findpng2 execution time: S seconds
\ No newline at end of file
diff --git a/lab4/lab4_eceubuntu1.csv b/lab4/lab4_eceubuntu1.csv
new file mode 100644
index 00000000..158f09bf
--- /dev/null
+++ b/lab4/lab4_eceubuntu1.csv
@@ -0,0 +1 @@
+T,M,Time