.gitmodules

@@ -1,3 +0,0 @@
-[submodule "parslib"]
-	path = parslib
-	url = http://git.0xdeadbeer.xyz/0xdeadbeer/parslib

Makefile

@@ -1,16 +1,14 @@
 CC=bear --append -- gcc
 CFLAGS= -g3 -Wall -Werror
-CFILES=proxlib.c 
-CFILES_PARSLIB=parslib/parslib.final.o
-OUT=proxlib
 
 all: proxlib
 
-proxlib: $(CFILES) $(CFILES_PARSLIB)
+proxy: proxlib.c
-	$(CC) $(CFLAGS) -o $(OUT) $^
+	$(CC) $(CFLAGS) -o proxlib.o -c proxlib.c
+	$(CC) $(CFLAGS) -o proxlib proxlib.o
 
 clean:
-	rm -f $(OUT)
+	rm -f proxlib *.o
 
 tar:
-	tar -cvzf proxlib.tgz $(CFILES) README Makefile 
+	tar -cvzf proxlib.tgz proxlib.c proxlib.h README Makefile 

parslib

@@ -1 +0,0 @@
-Subproject commit 678a44228fe0c5b24b2d1b96576da0e44211c364

proxlib.c

@@ -7,94 +7,207 @@
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <netdb.h>
+#include <regex.h>
 #include "proxlib.h"
-#include "parslib/parslib.h"
 
 int on = 1; 
-int debug = 2;
+int debug = 1; 
+struct request *clt_data;
+regex_t preg; 
+regmatch_t pmatch[REGEX_MATCHN];
+
 int statem; 
 
-#define SEGMENT_LEN 512
+int clt_sock = -1;
-#define MAX_BUFF_LEN 128 * 1024
+int srv_sock = -1;
-int _read_line(int fd, char **outbuff) {
+char *clt_msg = NULL;
-    char tmp_buff[SEGMENT_LEN]; 
+char *srv_msg = NULL;
-    int tmp_buff_len = 0; 
+int clt_msg_len = 0; 
-    char *output_buff = NULL;
+int srv_msg_len = 0;
-    int output_buff_len = 0;
-    char *ptr = NULL;
-    int whead_pos = 0;
-    char *whead = NULL;
-    int diff = 0;
-    int ret = 0;
-    int end = 0;
 
-    while (!end) {
+void *extractsub(const char *msg, regmatch_t match) {
-        ret = recv(fd, tmp_buff, SEGMENT_LEN, MSG_PEEK);
+    void *buf = NULL;
-        if (ret <= 0) {
+    int buflen = match.rm_eo - match.rm_so;
-            break;
+    if (!buflen)
-        }
+        goto _return;
 
-        ptr = strstr(tmp_buff, "\r\n");  
+    buf = (void *) calloc(1, buflen);
-        if (ptr >= tmp_buff+SEGMENT_LEN) {
+    if (buf == NULL) 
-            diff = ret; 
+        goto _return;
-        } else {
-            diff = ptr - tmp_buff + 2;
-            end = 1;
-        }
 
-        tmp_buff_len = diff;
+    sprintf(buf, "%.*s", buflen, &msg[match.rm_so]); 
-        whead_pos = output_buff_len;
-        output_buff_len += tmp_buff_len;
 
-        if (tmp_buff_len > MAX_BUFF_LEN) {
+_return:
-            return -1;
+    return buf;
-        }
-
-        output_buff = (char *) realloc(output_buff, output_buff_len);
-        if (!output_buff) {
-            return -1;
-        }
-
-        whead = output_buff+whead_pos;
-        ret = recv(fd, whead, diff, 0);
-        if (ret <= 0) {
-            break;
-        }
-    }
-
-    *outbuff = output_buff;
-    return output_buff_len;
 }
 
-/* easy wrapper for _read_line(int fd, void **outbuff) */ 
+int parse_header(char *msgbuff) {
-int read_line(int fd, 
+    int ret; 
-              int *line_len, char **line, 
-              int *msgbuff_len, char **msgbuff) {
-    int ret = 0; 
 
-    ret = *line_len = _read_line(fd, line);
+    ret = regcomp(&preg, REGEX_HEADER, REG_EXTENDED);
-    if (ret < 0) {
+    if (ret != 0) 
-        return -1;
+        goto _err; 
-    }
 
-    *msgbuff = (char *) realloc(*msgbuff, *msgbuff_len+*line_len);
+    ret = regexec(&preg, msgbuff, REGEX_MATCHN, pmatch, 0); 
-    if (!*msgbuff) {
+    if (ret != 0) 
-        free(*line);
+        goto _ok; 
-        return -1;
-    }
 
-    memcpy(*msgbuff+*msgbuff_len, *line, *line_len);
+    char *key = extractsub(msgbuff, pmatch[1]);
+    if (key == NULL) 
+        goto _err; 
 
-    *msgbuff_len += *line_len;
+    char *value = extractsub(msgbuff, pmatch[2]);
-    ((char *) *line)[(*line_len)-2] = '\0';
+    if (value == NULL) 
-    *line_len -= 2;
+        goto _err;
 
+    struct header new_header = {
+        .key = key,
+        .value = value
+    };
+
+    int last_index = clt_data->header_num;
+
+    clt_data->header_num++;
+    clt_data->headers = (void *) realloc(clt_data->headers,
+            clt_data->header_num*sizeof(struct header));
+
+    clt_data->headers[last_index] = new_header;
+
+_ok:
+    regfree(&preg);
     return 0;
+
+_err: 
+    regfree(&preg);
+    return -1; 
+}
+
+int parse_host(char *buff) {
+    int ret; 
+
+    ret = regcomp(&preg, REGEX_HOST, REG_EXTENDED); 
+    if (ret != 0) 
+        goto _err;
+
+    ret = regexec(&preg, buff, REGEX_MATCHN, pmatch, 0);
+    if (ret != 0) 
+        goto _err;
+
+    char *host_name = extractsub(buff, pmatch[1]);
+    if (!host_name) 
+        goto _err; 
+
+    char *host_port = extractsub(buff, pmatch[2]);
+    if (!host_port) {
+        host_port = PROXY_DEF_PORT;
+    }
+
+    clt_data->host_name = host_name;
+    clt_data->host_port = host_port;
+
+    regfree(&preg); 
+    return 0;
+
+_err:
+    regfree(&preg);
+    return -1;
+}
+
+int parse_title(char *msgbuff) {
+    int ret; 
+
+    ret = regcomp(&preg, REGEX_TITLE, REG_EXTENDED);
+    if (ret != 0)
+        goto _err;
+
+    ret = regexec(&preg, msgbuff, REGEX_MATCHN, pmatch, 0);
+    if (ret != 0)
+        goto _err;
+
+    clt_data->method = extractsub(msgbuff, pmatch[1]);
+    if (clt_data->method == NULL) 
+        goto _err;
+
+    clt_data->uri = extractsub(msgbuff, pmatch[2]);
+    if (clt_data->uri == NULL) 
+        goto _err;
+
+    clt_data->ver = extractsub(msgbuff, pmatch[3]); 
+    if (clt_data->ver == NULL)
+        goto _err;
+
+    regfree(&preg);
+    return 0;
+
+_err: 
+    regfree(&preg);
+    return -1; 
+
+}
+
+void free_host(void) {
+    free(clt_data->host_name);
+    free(clt_data->host_port);
+}
+
+void free_title(void) {
+    free(clt_data->method);
+    free(clt_data->uri);
+    free(clt_data->ver);
+}
+
+void free_headers(void) {
+    for (int i = 0; i < clt_data->header_num; i++) {
+        struct header *header = &clt_data->headers[i];
+        free(header->key);
+        free(header->value);
+    }
+    free(clt_data->headers);
+}
+
+void free_clt_data(void) {
+    free_host();
+    free_title();
+    free_headers();
+    free(clt_data);
+}
+
+void free_srv_data(void) {
+
+}
+
+void free_msg_buffs(void) {
+    free(clt_msg);
+    free(srv_msg);
+}
+
+void free_data(void) {
+    free_clt_data();
+    free_srv_data();
 }
 
 int parse_line(char *line, int line_count) {
     int ret = 0; 
 
+    if (line_count == 0) {
+        ret = parse_title(line);
+    } else {
+        ret = parse_header(line);
+    }
+
+    return ret;
+}
+
+char *getheader(char *key) {
+    char *ret = NULL; 
+    for (int i = 0; i < clt_data->header_num; i++) {
+        struct header *hdr = &clt_data->headers[i];
+        if (strcmp(hdr->key, key)) 
+            continue; 
+
+        ret = hdr->value; 
+    }
+
     return ret; 
 }
 
@@ -105,7 +218,7 @@ void do_err(void) {
 }
 
 int do_fwd_clt(void) {
-    /*int bytes = 0; 
+    int bytes = 0; 
     int ret = 0; 
     while (bytes < srv_msg_len) {
         ret = write(clt_sock, srv_msg+bytes, srv_msg_len-bytes);
@@ -113,7 +226,7 @@ int do_fwd_clt(void) {
             return -1;
 
         bytes += ret;
-    }*/
+    }
 
     return 0;
 }
@@ -125,7 +238,7 @@ int do_prs_srv(void) {
 }
 
 int do_rcv_srv(void) {
-    /*int bytes = 0;
+    int bytes = 0;
     int ret = 0; 
     while (bytes < PROXY_MAX_MSGLEN) {
         ret = recv(srv_sock, srv_msg+bytes, PROXY_MAX_MSGLEN-bytes, MSG_PEEK);
@@ -140,41 +253,21 @@ int do_rcv_srv(void) {
 
     srv_msg_len = bytes;
 
-    if (debug == 1)
+    if (debug)
         fprintf(stdout, "[%d] Received server message of size %d bytes\n", statem, srv_msg_len);
-    */
 
     return 0; 
 }
 
-// TODO
+int do_con_srv(void) {
-int do_con_srv(struct conn *conn) {
+    int ret;
-    int ret = 0;
+    char *host = getheader("Host");
-    struct httpareq *req = &conn->cltreq;
+    if (!host)
-    struct point *host = &req->hentries[header_host];
+        return -1;
-    if (host->er == NULL) {
-        if (debug <= 2) {
-            fprintf(stderr, "debug - request does not have HOST header\n");
-        }
-        goto _exit;
-    }
 
-    struct hostinfo *info = (struct hostinfo *) calloc(1, sizeof(struct hostinfo));
+    ret = parse_host(host);
-    if (!info) {
+    if (ret < 0)
-        goto _exit;
+        return -1;
-    }
-
-    ret = pahostinfo(host->er, host->len, info);
-    if (ret < 0) {
-        if (debug <= 2) {
-            fprintf(stderr, "Failed parsing upstream host header\n");
-        }
-        goto _exit_hostinfo;
-    }
-
-    if (debug <= 2) {
-        fprintf(stdout, "Establishing connection with upstream: %.*s : %.*s\n", info->hostname_len, info->hostname, info->service_len, info->service);
-    }
     
     struct addrinfo hints; 
     struct addrinfo *res;
@@ -183,34 +276,24 @@ int do_con_srv(struct conn *conn) {
     hints.ai_family = AF_INET; 
     hints.ai_socktype = SOCK_STREAM;
 
-    ret = getaddrinfo(info->hostname, info->service, &hints, &res);
+    ret = getaddrinfo(clt_data->host_name, clt_data->host_port, &hints, &res);
-    if (ret < 0) {
+    if (ret < 0) 
-        goto _exit_hostinfo;
+        return -1;
-    }
 
-    ret = conn->srvfd = socket(res->ai_family, res->ai_socktype,
+    ret = srv_sock = socket(res->ai_family, res->ai_socktype,
             res->ai_protocol);
-    if (ret < 0) {
+    if (ret < 0)
-        goto _exit_getaddrinfo;
+        return -1;
-    }
 
-    ret = connect(conn->srvfd, res->ai_addr, res->ai_addrlen);
+    ret = connect(srv_sock, res->ai_addr, res->ai_addrlen);
-    if (ret < 0) {
+    if (ret < 0)
-        goto _exit_getaddrinfo;
+        return -1;
-    }
 
-_exit_getaddrinfo:
+    return 0;
-    freeaddrinfo(res);
-_exit_hostinfo:
-    free(info->hostname);
-    free(info->service);
-    free(info);
-_exit:
-    return ret;
 }
 
 int do_fwd_srv(void) {
-    /*int bytes = 0;
+    int bytes = 0;
     int ret = 0;
     while (bytes < clt_msg_len) {
         ret = write(srv_sock, clt_msg+bytes, clt_msg_len-bytes);
@@ -218,102 +301,114 @@ int do_fwd_srv(void) {
             return -1;
 
         bytes += ret;
-    }*/
+    }
 
     return 0;
 }
 
-int do_rcv_clt(struct conn *conn) {
+int do_prs_clt(void) {
+    int ret;
+    int ln_cnt = 0;
+
+    char *ln = strdup(clt_msg);
+    if (!ln)
+        return -1;
+
+    ln = strtok(ln, "\n");
+    while (ln) {
+        ret = parse_line(ln, ln_cnt);
+        if (ret < 0)
+            return -1;
+
+        ln_cnt++;
+        ln = strtok(NULL, "\n");
+    }
+
+    return 0; 
+}
+
+int do_rcv_clt(void) {
+    int bytes = 0; 
     int ret = 0;
-    char *line = NULL; 
+    while (bytes < PROXY_MAX_MSGLEN) {
-    char *msgbuff = NULL;
+        ret = recv(clt_sock, clt_msg+bytes, PROXY_MAX_MSGLEN-bytes, MSG_PEEK);
-    int line_len = 0; 
+        if (ret < 0) 
-    int msgbuff_len = 0;
-
-    // request line 
-    ret = read_line(conn->cltfd, &line_len, &line, &msgbuff_len, &msgbuff);
-    if (ret < 0) {
-        fprintf(stderr, "Failed receiving request line\n");
-        return -1;
-    }
-
-    if (debug == 1) {
-        fprintf(stdout, "debug - received line: %s\n", line);
-    }
-
-    ret = pareqtitl(line, line_len, &(conn->cltreq.titl));    
-    if (ret < 0) {
-        fprintf(stderr, "Failed parsing request line\n");
-        return -1;
-    }
-
-    if (debug == 1) {
-        fprintf(stdout, "debug - parsed request line\n");
-    }
-
-    free(line);
-
-    // headers
-    int next_header = 1; 
-    while (next_header) {
-        ret = read_line(conn->cltfd, &line_len, &line, &msgbuff_len, &msgbuff);
-        if (ret < 0) {
-            fprintf(stderr, "Failed receiving header line\n");
             return -1;
-        }
+        if (!ret) 
+            break;
 
-        if (line_len == 0) {
+        ret = recv(clt_sock, clt_msg+bytes, PROXY_MAX_MSGLEN-bytes, 0);
-            if (debug == 1) {
-                fprintf(stdout, "debug - reached end of headers\n");
-            }
-            next_header = 0;
-            continue;
-        }
 
-        if (debug == 1) {
+        bytes += ret;
-            fprintf(stdout, "debug - received line: %s\n", line);
-        }
-
-        ret = parshfield(line, line_len, conn->cltreq.hentries);
-        if (ret < 0) {
-            fprintf(stderr, "Failed parsing header field\n");
-            return -1;
-        }
-
-        if (debug == 1) {
-            fprintf(stdout, "debug - parsed header field\n");
-        }
-
-        free(line);
     }
 
-    // body
+    clt_msg_len = bytes;
-    // TODO
 
-    if (debug <= 2) {
+    if (debug)
-        fprintf(stdout, "printing parsed request\n");
+        fprintf(stdout, "[%d] Received client message of size %d bytes\n", statem, clt_msg_len);
-        printfpareq(&conn->cltreq);
-    }
 
     return 0; 
 }
 
-void do_clear(struct conn *conn) {
+int do_alloc(void) {
+    clt_msg = (char *) calloc(1, PROXY_MAX_MSGLEN);
+    if (!clt_msg)
+        return -1;
+
+    srv_msg = (char *) calloc(1, PROXY_MAX_MSGLEN);
+    if (!srv_msg) 
+        return -1;
+
+    clt_data = (struct request *) calloc(1, sizeof(struct request));
+    if (!clt_data) 
+        return -1;
+
+    return 0;
+}
+
+void do_clear(void) {
     statem = STATEM_RCV_CLT;
-    frepareq(&conn->cltreq);
+
-    frepares(&conn->srvres);
+    memset(clt_msg, 0, PROXY_MAX_MSGLEN);
+    memset(srv_msg, 0, PROXY_MAX_MSGLEN);
+    memset(clt_data, 0, sizeof(struct request));
+
+    clt_msg_len = 0;
+    srv_msg_len = 0;
 } 
 
-void do_statem(struct conn *conn) {
+void do_statem() {
-    int ret = 0;
+    int ret = do_alloc(); 
+    if (ret < 0) {
+        do_err();
+        return;
+    }
         
     for (int counter = 0; counter < MAX_BOUND; counter++) {
         switch (statem & (~STATEM_ERR)) {
         case STATEM_RCV_CLT:
-            ret = do_rcv_clt(conn);
+            ret = do_rcv_clt();
+            break;
+        case STATEM_PRS_CLT: 
+            ret = do_prs_clt();
             break; 
         case STATEM_CON_SRV: 
-            ret = do_con_srv(conn);
+            ret = do_con_srv();
+            break;
+        case STATEM_FWD_SRV: 
+            ret = do_fwd_srv();
+            break; 
+        case STATEM_RCV_SRV: 
+            ret = do_rcv_srv();
+            break;
+        case STATEM_PRS_SRV: 
+            ret = do_prs_srv();
+            break; 
+        case STATEM_FWD_CLT:
+            ret = do_fwd_clt();
+            break;
+        default: 
+            ret = -1; 
             break; 
         }
 
@@ -326,12 +421,28 @@ void do_statem(struct conn *conn) {
         }
 
         if (statem & STATEM_FWD_CLT) {
-            do_clear(conn);
+            do_clear();
             continue;
         }
 
         statem <<= 1;
     }
+
+    free_msg_buffs();
+    free_data();
+}
+
+void dohelp() {
+    printf(
+        "+====================+\n"
+        "|   HTTP/1.0 PROXY   |\n"
+        "+=====@0xdeadbeer====+\n"
+        "usage:\n"
+        " ./proxy [mode]\n"
+        "mode:\n"
+        " * server -> start listening as proxy\n"
+        " * client -> send test requests to server\n"
+    );
 }
 
 int do_srv(void) {
@@ -391,42 +502,78 @@ int do_srv(void) {
             return -1; 
         } 
 
-        if (ret > 0) {
+        if (!ret) {
-            fprintf(stdout, "[PROGRAM] Successfully forked a new child process"
+            clt_sock = new_clt_sock;
-                            " with PID %d\n", ret);
+            statem = STATEM_RCV_CLT;
-            continue;
+            do_statem();
+            return 0;
         }
 
-        // child 
+        fprintf(stdout, "[PROGRAM] Successfully forked a new child process"
-        struct conn *conn = (struct conn *) calloc(1, sizeof(struct conn));
+                        " with PID %d\n", ret);
-        if (!conn) {
-            fprintf(stderr, "Not enough dynamic memory to establish connection\n");
-            return -1;
-        }
-
-        conn->cltfd = new_clt_sock;
-        statem = STATEM_RCV_CLT;
-        do_statem(conn);
-        free(conn);
-
-        if (debug == 1) {
-            fprintf(stdout, "Finished proxying client\n");
-        }
-
-        return 0;
 	}
 
 	return 0;
 }
 
+int do_clt(void) {
+    int ret = 0;
+    int client_socket; 
+	struct sockaddr_in serv_addr;
+
+    ret = client_socket = socket(AF_INET, SOCK_STREAM, 0); 
+	if(ret < 0)
+	{
+        fprintf(stderr, "Failed creating socket\n");
+		return -1;
+	}
+
+	memset(&serv_addr, '0', sizeof(serv_addr));
+
+	serv_addr.sin_family = AF_INET;
+	serv_addr.sin_port = htons(PROXY_PORT);
+
+    ret = inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr);
+	if(ret <= 0)
+	{
+        fprintf(stderr, "Inet_pton error\n");
+		return -1;
+	}
+
+    ret = connect(client_socket, (struct sockaddr *) &serv_addr,
+            sizeof(serv_addr));
+	if(ret < 0)
+	{
+        fprintf(stderr, "Failed connecting to remote server\n");
+		return -1;
+	}
+
+    int bytes = 0; 
+    do {
+        bytes += send(client_socket, CLIENT_MESSAGE, 
+                sizeof(CLIENT_MESSAGE), 0);
+    } while (bytes != sizeof(CLIENT_MESSAGE));
+
+    fprintf(stdout, "Sent %d bytes to server\n", bytes);
+
+    return 0;
+}
+
 int main(int argc, char *argv[]) {
-    int ret = initres();
+	int ret; 
-    if (ret < 0) {
+    if (argc != 2) {
-        fprintf(stderr, "Failed generating trees\n");
+        dohelp();
-        return -1;
+        return 0;
     }
 
-    return do_srv();
+    const char *mode = argv[1]; 
+    ret = strcmp(mode, SERVER_MODE);
+    if (ret == 0)
+        return do_srv();
 
-    fretres();
+    ret = strcmp(mode, CLIENT_MODE); 
+    if (ret == 0)
+        return do_clt();
+
+    fprintf(stderr, "Unknown proxy mode\n");
 }

proxlib.h

@@ -1,28 +1,49 @@
 #ifndef STRUCTS_H
 #define STRUCTS_H
 
-#include "parslib/parslib.h"
-
-#ifndef MAX_BOUND
 #define MAX_BOUND 10000
-#endif
+
+#define SERVER_MODE "server"
+#define CLIENT_MODE "client"
 
 #define PROXY_PORT 2020
 #define PROXY_CONN 20
+#define PROXY_MAX_MSGLEN 10000*1024
+#define PROXY_DEF_PORT "80"
+#define PROXY_BASE_PORT 10
+
+#define REGEX_MATCHN 4
+#define REGEX_TITLE "^([A-Z]+)[ ]+([a-zA-Z0-9\\:/_.,-]+)"\
+                    "[ ]+([a-zA-Z0-9_.,/-]+)[\n\r]*$"
+#define REGEX_HEADER "^([a-zA-Z0-9_-]*):[ \t]+([^\r\n]*)"
+#define REGEX_HOST "^([a-zA-Z0-9_/,.-]+)(:[0-9]+)?$"
+
+#define CLIENT_MESSAGE "GET http://archive.0xdeadbeer.org/ HTTP/1.0\r\n\r\n"\
+                       "Host: archive.0xdeadbeer.org\r\n"\
 
 #define STATEM_RCV_CLT 0b00000001
-#define STATEM_CON_SRV 0b00000010
+#define STATEM_PRS_CLT 0b00000010
-#define STATEM_FWD_SRV 0b00000100
+#define STATEM_CON_SRV 0b00000100
-#define STATEM_RCV_SRV 0b00001000
+#define STATEM_FWD_SRV 0b00001000
-#define STATEM_FWD_CLT 0b00010000
+#define STATEM_RCV_SRV 0b00010000
-#define STATEM_ERR     0b00100000
+#define STATEM_PRS_SRV 0b00100000
+#define STATEM_FWD_CLT 0b01000000
+#define STATEM_ERR     0b10000000
 
-struct conn {
+struct header {
-    int cltfd; 
+    char *key; 
-    int srvfd; 
+    char *value; 
+};
 
-    struct httpareq cltreq;
+struct request {
-    struct httpares srvres; 
+    char *host_name;
+    char *host_port;
+
+    char *method; 
+    char *uri; 
+    char *ver; 
+    int header_num;
+    struct header *headers;
 };
 
 #endif