C++后端开发入门-HTTP服务器编程

环境配置

先安装并关闭防火墙，安装Iperf工具：

sudo apt install firewalld iperf curl
sudo systemctl stop firewalld
sudo systemctl disable firewalld
sudo firewall-cmd --status #not running

iperf的使用如下，Windows下有Jperf：

#测试TCP
sudo iperf -s -i 1 -w 1M #服务端运行 间隔1s TCP窗口尺寸为1M
sudo iperf -c xxx.xxx.xxx.xxx -i 1 -w 1M #客户端运行

#测试UDP
sudo iperf -u -s #服务端运行
sudo iperf -u -c xxx.xxx.xxx.xxx -b 900M -i 1 -w 1M -t 60 #客户端运行 带宽数量为900M（千兆链路的90%） 测试60s

接下来尝试搭建Apache：

sudo apt install apache2
sudo systemctl status apache2 #running
sudo mkdir /var/www/cgi-bin/

打开/etc/apache2/mods-enabled/mime.load，末尾添加：

LoadModule cgi_module /usr/lib/apache2/modules/mod_cgi.so

打开/etc/apache2/conf-enabled/serve-cgi-bin.conf，修改：

<IfModule mod_alias.c>
    <IfModule mod_cgi.c>
        Define ENABLE_USR_LIB_CGI_BIN
    </IfModule>

    <IfModule mod_cgid.c>
        Define ENABLE_USR_LIB_CGI_BIN
    </IfModule>

    <IfDefine ENABLE_USR_LIB_CGI_BIN>
        ScriptAlias /cgi-bin/ /var/www/cgi-bin/ <!-- 修改 -->
        <Directory "/var/www/cgi-bin"> <!-- 修改 -->
            AllowOverride None
            Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
            Require all granted
            AddHandler cgi-script .cgi .pl .py .sh <!-- 添加 -->
        </Directory>
    </IfDefine>
</IfModule>

接下来例如在/var/www/cgi-bin/下新建aaa.sh并给执行权限，内容为：

#!/bin/bash
echo "Content-type: text/html"
echo ""
echo "Hello World!"
exit 0

重启Apache：

sudo /etc/init.d/apache2 restart
sudo systemctl status apache2.service

访问http://127\.0\.0\.1/cgi\-bin/aaa\.sh 即可。再例如用C++实现如下，编译为test1.cgi，访问http://127\.0\.0\.1/cgi\-bin/test1\.cgi 即可。

#include <stdio.h>
int main() {
    printf("Content-Type: text/html\n\n");
    printf("Hello CGI!\n");
    return 0;
};

接下来需要用到Perl CGI，安装有：

sudo apt install libcgi-ajax-perl libcgi-application-perl libwww-perl libjson-xs-perl liburi-perl libdbi-perl

HTTP服务器

本小节涉及的服务器例子流程如下：

• 服务器启动，指定端口绑定httpd服务。
• 用accept监听端口，收到一个HTTP请求时，派生一个线程运行自己实现的accept_request函数。
• 取出HTTP请求中的方法和URL。对于GET方法，若携带参数，则query_string指向URL中“?”后的GET参数。
• 格式化URL到path数组，表示浏览器请求的服务器文件路径。当URL以“/”结尾时表示是个目录，默认加上index.html。
• 当文件路径合法，对于无参数GET请求，直接输出服务器文件到浏览器，关闭与浏览器的连接。当为带参数GET/POST请求，或URL为可执行文件，则用execute_cgi执行cgi脚本。
• 读取整个HTTP请求并丢弃，若为POST请求则找出Content-Length，将HTTP 200状态码写到套接字。
• 建立管道cgi_input和cgi_output，并fork一个进程。
• 子进程中把标准输出重定向到cgi_output写入端，把标准输入重定向到cgi_input读取端，关闭cgi_input写入端和cgi_output读取端。为了给cgi脚本调用，为GET请求设置query_string环境变量，为POST请求设置content_length环境变量，并用execl运行cgi程序。
• 父进程中把POST数据写入cgi_input写入端，读取cgi_output读取端输出到客户端，关闭cgi_input读取端和cgi_output写入端。然后关闭管道，等待子进程结束。
• 关闭于浏览器连接，完成一次HTTP请求与回应。

接下来基于项目https://github.com/cbsheng/tinyhttpd 进行开发，启动方法如下，其中注意htdocs/index.html的权限必须为600，一定不给写权限。启动后会随机选择端口号，浏览器访问http://localhost:xxxxx/ 即可。

make
sudo ./httpd

目录如下：

.
├── client
├── client.c
├── deploy.sh
├── htdocs
│   ├── check.cgi
│   ├── color.cgi
│   ├── date.cgi
│   ├── date.html
│   ├── index.html
├── httpd
├── httpd.c
├── LICENSE
├── Makefile
└── README.md

httpd.c完整源码为：

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <ctype.h>
#include <strings.h>
#include <string.h>
#include <sys/stat.h>
#include <pthread.h>
#include <sys/wait.h>
#include <stdlib.h>
#define ISspace(x) isspace((int)(x)) //宏定义，是否是空格
#define SERVER_STRING "Server: jdbhttpd/0.1.0\r\n"
void accept_request(void* arg); //每次收到请求，创建一个线程来处理接受到的请求 把client_sock转成地址作为参数传入pthread_create
void bad_request(int); //错误请求
void cat(int, FILE*); //读取文件
void cannot_execute(int); //无法执行
void error_die(const char*); //错误输出
void execute_cgi(int, const char*, const char*, const char*); //执行cig脚本
int get_line(int, char*, int); //得到一行数据,只要发现c为\n,就认为是一行结束，如果读到\r,再用MSG_PEEK的方式读入一个字符，如果是\n，从socket用读出 如果是下个字符则不处理，将c置为\n，结束。如果读到的数据为0中断，或者小于0，也视为结束，c置为\n
void headers(int, const char*); //返回http头
void not_found(int); //没有发现文件
void serve_file(int, const char*); //如果不是CGI文件，直接读取文件返回给请求的http客户端
int startup(u_short*); //开启tcp连接，绑定端口等操作
void unimplemented(int); //如果不是Get或者Post，就报方法没有实现
// Http请求，后续主要是处理这个头
//示例：
// GET / HTTP/1.1
// Host: 192.168.0.23:47310
// Connection: keep-alive
// Upgrade-Insecure-Requests: 1
// User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36
// Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*; q = 0.8
// Accept - Encoding: gzip, deflate, sdch
// Accept - Language : zh - CN, zh; q = 0.8
// Cookie: __guid = 179317988.1576506943281708800.1510107225903.8862; monitor_count = 5
//

// POST / color1.cgi HTTP / 1.1
// Host: 192.168.0.23 : 47310
// Connection : keep - alive
// Content - Length : 10
// Cache - Control : max - age = 0
// Origin : http ://192.168.0.23:40786
// Upgrade - Insecure - Requests : 1
// User - Agent : Mozilla / 5.0 (Windows NT 6.1; WOW64) AppleWebKit / 537.36 (KHTML, like Gecko) Chrome / 55.0.2883.87 Safari / 537.36
// Content - Type : application / x - www - form - urlencoded
// Accept : text / html, application / xhtml + xml, application / xml; q = 0.9, image / webp, */*;q=0.8
// Referer: http://192.168.0.23:47310/
// Accept-Encoding: gzip, deflate
// Accept-Language: zh-CN,zh;q=0.8
// Cookie: __guid=179317988.1576506943281708800.1510107225903.8862; monitor_count=281
// Form Data
// color=gray

/* A request has caused a call to accept() on the server port to return.  Process the request appropriately. Parameters: the socket connected to the client */
void accept_request(void* arg) {
    int client = (intptr_t)arg; //socket
    char buf[1024];
    int numchars;
    char method[255];
    char url[255];
    char path[512];
    size_t i, j;
    struct stat st;
    int cgi = 0;      /* becomes true if server decides this is a CGI program */
    char* query_string = NULL;
    numchars = get_line(client, buf, sizeof(buf)); //处理第一行http信息 "GET / HTTP/1.1\n"
    i = 0;
    j = 0;
    while (!ISspace(buf[j]) && (i < sizeof(method) - 1)) { //第一行字符串提取Get
        method[i] = buf[j];
        i++; j++;
    };
    method[i] = '\0'; //结束
    if (strcasecmp(method, "GET") && strcasecmp(method, "POST")) { //判断是Get还是Post
        unimplemented(client);
        return;
    };
    if (strcasecmp(method, "POST") == 0) //如果是POST，cgi置为1
        cgi = 1;
    i = 0;
    while (ISspace(buf[j]) && (j < sizeof(buf))) //跳过空格
        j++;
    //得到 "/"   注意：如果你的http的网址为http://192.168.0.23:47310/index.html 那么你得到的第一条http信息为GET /index.html HTTP/1.1，那么解析得到的就是/index.html
    while (!ISspace(buf[j]) && (i < sizeof(url) - 1) && (j < sizeof(buf))) {
        url[i] = buf[j];
        i++; j++;
    };
    url[i] = '\0';
    if (strcasecmp(method, "GET") == 0) { //判断Get请求
        query_string = url;
        while ((*query_string != '?') && (*query_string != '\0'))
            query_string++;
        if (*query_string == '?') {
            cgi = 1;
            *query_string = '\0';
            query_string++;
        };
    };
    sprintf(path, "htdocs%s", url); //文件路径
    if (path[strlen(path) - 1] == '/') //默认地址，解析到的路径如果为/，则自动加上index.html
        strcat(path, "index.html");
    if (stat(path, &st) == -1) { //获得文件信息
        while ((numchars > 0) && strcmp("\n", buf))  /* read & discard headers */ //把所有http信息读出然后丢弃
            numchars = get_line(client, buf, sizeof(buf));
        not_found(client); //没有找到
    }
    else {
        if ((st.st_mode & S_IFMT) == S_IFDIR)
            strcat(path, "/index.html");
        if ((st.st_mode & S_IXUSR) || (st.st_mode & S_IXGRP) || (st.st_mode & S_IXOTH)) //如果你的文件默认是有执行权限的，自动解析成cgi程序，如果有执行权限但是不能执行，会收到到报错信号
            cgi = 1;
        if (!cgi)
            serve_file(client, path); //(对于GET请求)返回.html文件给http客户端
        else
            execute_cgi(client, path, method, query_string); //(对于POST请求)执行cgi文件
    };
    close(client); //执行完毕关闭socket
    return;
};
/* Inform the client that a request it has made has a problem. Parameters: client socket */
void bad_request(int client) {
    char buf[1024];
    sprintf(buf, "HTTP/1.0 400 BAD REQUEST\r\n");
    send(client, buf, sizeof(buf), 0);
    sprintf(buf, "Content-type: text/html\r\n");
    send(client, buf, sizeof(buf), 0);
    sprintf(buf, "\r\n");
    send(client, buf, sizeof(buf), 0);
    sprintf(buf, "<P>Your browser sent a bad request, ");
    send(client, buf, sizeof(buf), 0);
    sprintf(buf, "such as a POST without a Content-Length.\r\n");
    send(client, buf, sizeof(buf), 0);
    return;
};
/* Put the entire contents of a file out on a socket.  This function is named after the UNIX "cat" command, because it might have been easier just to do something like pipe, fork, and exec("cat"). Parameters: the client socket descriptor FILE pointer for the file to cat */
void cat(int client, FILE* resource) { //得到文件内容，发送
    char buf[1024];
    fgets(buf, sizeof(buf), resource);
    while (!feof(resource)) { //循环读
        send(client, buf, strlen(buf), 0);
        fgets(buf, sizeof(buf), resource);
    };
    return;
};
/* Inform the client that a CGI script could not be executed. Parameter: the client socket descriptor. */
void cannot_execute(int client) {
    char buf[1024];
    sprintf(buf, "HTTP/1.0 500 Internal Server Error\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "Content-type: text/html\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "<P>Error prohibited CGI execution.\r\n");
    send(client, buf, strlen(buf), 0);
    return;
};
/* Print out an error message with perror() (for system errors; based on value of errno, which indicates system call errors) and exit the program indicating an error. */
void error_die(const char* sc) {
    perror(sc);
    exit(1);
    return;
};
/* Execute a CGI script.  Will need to set environment variables as appropriate. Parameters: client socket descriptor path to the CGI script */
void execute_cgi(int client, const char* path, const char* method, const char* query_string) {
    char buf[1024]; //缓冲区
    int cgi_output[2]; //2根管道
    int cgi_input[2];
    pid_t pid; //进程pid和状态
    int status;
    int i;
    char c;
    int numchars = 1; //读取的字符数
    int content_length = -1; //http的content_length
    buf[0] = 'A'; //默认字符
    buf[1] = '\0';
    if (strcasecmp(method, "GET") == 0) //忽略大小写比较字符串
        while ((numchars > 0) && strcmp("\n", buf))  /* read & discard headers */ //读取数据，把整个header都读掉，以为Get写死了直接读取index.html，没有必要分析余下的http信息了
            numchars = get_line(client, buf, sizeof(buf));
    else {    /* POST */
        numchars = get_line(client, buf, sizeof(buf));
        while ((numchars > 0) && strcmp("\n", buf)) { //如果是POST请求，就需要得到Content-Length，Content-Length：这个字符串一共长为15位，所以取出头部一句后，将第16位设置结束符，进行比较第16位置为结束
            buf[15] = '\0';
            if (strcasecmp(buf, "Content-Length:") == 0) //内存从第17位开始就是长度，将17位开始的所有字符串转成整数就是content_length
                content_length = atoi(&(buf[16]));
            numchars = get_line(client, buf, sizeof(buf));
        };
        if (content_length == -1) {
            bad_request(client);
            return;
        };
    };
    sprintf(buf, "HTTP/1.0 200 OK\r\n");
    send(client, buf, strlen(buf), 0);
    if (pipe(cgi_output) < 0) { //建立output管道
        cannot_execute(client);
        return;
    };
    if (pipe(cgi_input) < 0) { //建立input管道
        cannot_execute(client);
        return;
    };
    //fork后管道都复制了一份，都是一样的 子进程关闭2个无用的端口，避免浪费
    //×<------------------------->1    output
    //0<-------------------------->×   input
    //父进程关闭2个无用的端口，避免浪费
    //0<-------------------------->×   output
    //×<------------------------->1    input
    //此时父子进程已经可以通信
    if ((pid = fork()) < 0) { //fork进程，子进程用于执行CGI 父进程用于收数据以及发送子进程处理的回复数据
        cannot_execute(client);
        return;
    };
    if (pid == 0) { /* child: CGI script */
        char meth_env[255];
        char query_env[255];
        char length_env[255];
        dup2(cgi_output[1], 1); //子进程输出重定向到output管道的1端
        dup2(cgi_input[0], 0); //子进程输入重定向到input管道的0端
        close(cgi_output[0]); //关闭无用管道口
        close(cgi_input[1]);
        sprintf(meth_env, "REQUEST_METHOD=%s", method); //CGI环境变量
        putenv(meth_env);
        if (strcasecmp(method, "GET") == 0) {
            sprintf(query_env, "QUERY_STRING=%s", query_string);
            putenv(query_env);
        }
        else {   /* POST */
            sprintf(length_env, "CONTENT_LENGTH=%d", content_length);
            putenv(length_env);
        };
        execl(path, path, NULL); //替换执行path
        //int m = execl(path, path, NULL);
        //如果path有问题，例如将html网页改成可执行的，但是执行后m为-1 退出子进程，管道被破坏，但是父进程还在往里面写东西，触发Program received signal SIGPIPE, Broken pipe.
        exit(0);
    }
    else {    /* parent */
        close(cgi_output[1]); //关闭无用管道口
        close(cgi_input[0]);
        if (strcasecmp(method, "POST") == 0)
            for (i = 0; i < content_length; i++) {
                recv(client, &c, 1, 0); //得到post请求数据，写到input管道中，供子进程使用
                write(cgi_input[1], &c, 1);
            }
        while (read(cgi_output[0], &c, 1) > 0) //从output管道读到子进程处理后的信息，然后send出去
            send(client, &c, 1, 0);
        close(cgi_output[0]); //完成操作后关闭管道
        close(cgi_input[1]);
        waitpid(pid, &status, 0); //等待子进程返回
    };
    return;
};
/* Get a line from a socket, whether the line ends in a newline, carriage return, or a CRLF combination.  Terminates the string read with a null character.  If no newline indicator is found before the end of the buffer, the string is terminated with a null.  If any of the above three line terminators is read, the last character of the string will be a linefeed and the string will be terminated with a null character.
 * Parameters: the socket descriptor
 *             the buffer to save the data in
 *             the size of the buffer
 * Returns: the number of bytes stored (excluding null) */
int get_line(int sock, char* buf, int size) { //得到一行数据,只要发现c为\n,就认为是一行结束，如果读到\r,再用MSG_PEEK的方式读入一个字符，如果是\n，从socket用读出 如果是下个字符则不处理，将c置为\n，结束。如果读到的数据为0中断，或者小于0，也视为结束，c置为\n
    int i = 0;
    char c = '\0';
    int n;
    while ((i < size - 1) && (c != '\n')) {
        n = recv(sock, &c, 1, 0);
        if (n > 0) {
            if (c == '\r') {
                n = recv(sock, &c, 1, MSG_PEEK); //窥看一个字节，如果是\n就读走
                if ((n > 0) && (c == '\n'))
                    recv(sock, &c, 1, 0);
                else
                    c = '\n'; //不是\n（读到下一行的字符）或者没读到，置c为\n 跳出循环,完成一行读取
            };
            buf[i] = c;
            i++;
        }
        else
            c = '\n';
    };
    buf[i] = '\0';
    return i;
};
/* Return the informational HTTP headers about a file.
   Parameters: the socket to print the headers on
 *             the name of the file */
void headers(int client, const char* filename) { //加入http的headers
    char buf[1024];
    (void)filename;  /* could use filename to determine file type */
    strcpy(buf, "HTTP/1.0 200 OK\r\n");
    send(client, buf, strlen(buf), 0);
    strcpy(buf, SERVER_STRING);
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "Content-Type: text/html\r\n");
    send(client, buf, strlen(buf), 0);
    strcpy(buf, "\r\n");
    send(client, buf, strlen(buf), 0);
    return;
};
/* Give a client a 404 not found status message. */

void not_found(int client) { //如果资源没有找到得返回给客户端下面的信息
    char buf[1024];
    sprintf(buf, "HTTP/1.0 404 NOT FOUND\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, SERVER_STRING);
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "Content-Type: text/html\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "<HTML><TITLE>Not Found</TITLE>\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "<BODY><P>The server could not fulfill\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "your request because the resource specified\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "is unavailable or nonexistent.\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "</BODY></HTML>\r\n");
    send(client, buf, strlen(buf), 0);
    return;
};
/* Send a regular file to the client.  Use headers, and report errors to client if they occur.
 * Parameters: a pointer to a file structure produced from the socket file descriptor
 *             the name of the file to serve */
void serve_file(int client, const char* filename) { //读取server的文件返回给请求的http客户端
    FILE* resource = NULL;
    int numchars = 1;
    char buf[1024];
    buf[0] = 'A'; //默认字符
    buf[1] = '\0';
    while ((numchars > 0) && strcmp("\n", buf))  /* read & discard headers */
        numchars = get_line(client, buf, sizeof(buf));
    resource = fopen(filename, "r");
    if (resource == NULL)
        not_found(client);
    else {
        headers(client, filename);
        cat(client, resource);
    };
    fclose(resource);
    return;
};
/* This function starts the process of listening for web connections on a specified port.  If the port is 0, then dynamically allocate a port and modify the original port variable to reflect the actual port.
   Parameters: pointer to variable containing the port to connect on
   Returns: the socket */
int startup(u_short* port) {
    int httpd = 0;
    struct sockaddr_in name;
    httpd = socket(PF_INET, SOCK_STREAM, 0);
    if (httpd == -1)
        error_die("socket");
    memset(&name, 0, sizeof(name));
    name.sin_family = AF_INET;
    name.sin_port = htons(*port);
    name.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(httpd, (struct sockaddr*)&name, sizeof(name)) < 0) //绑定socket
        error_die("bind");
    if (*port == 0) {  /* if dynamically allocating a port */ //如果端口没有设置，获取可用端口
        socklen_t  namelen = sizeof(name);
        if (getsockname(httpd, (struct sockaddr*)&name, &namelen) == -1)
            error_die("getsockname");
        *port = ntohs(name.sin_port);
    };
    //监听
    if (listen(httpd, 5) < 0)
        error_die("listen");
    return httpd;
};
/* Inform the client that the requested web method has not been implemented.
 * Parameter: the client socket */
void unimplemented(int client) {//如果方法没有实现，就返回此信息
    char buf[1024];
    sprintf(buf, "HTTP/1.0 501 Method Not Implemented\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, SERVER_STRING);
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "Content-Type: text/html\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "<HTML><HEAD><TITLE>Method Not Implemented\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "</TITLE></HEAD>\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "<BODY><P>HTTP request method not supported.\r\n");
    send(client, buf, strlen(buf), 0);
    sprintf(buf, "</BODY></HTML>\r\n");
    send(client, buf, strlen(buf), 0);
    return;
};
int main(void) {
    int server_sock = -1;
    u_short port = 0; //0: 自动分配，也可以指定
    int client_sock = -1;
    struct sockaddr_in client_name;
    socklen_t client_name_len = sizeof(client_name);
    pthread_t newthread;
    server_sock = startup(&port); //初始化server socket, sock-bind-listen三连
    printf("httpd running on port %d\n", port);
    while (1) {
        client_sock = accept(server_sock, (struct sockaddr*)&client_name, &client_name_len); //接受客户端请求
        if (client_sock == -1)
            error_die("accept");
        if (pthread_create(&newthread, NULL, (void*)accept_request, (void*)(intptr_t)client_sock) != 0) //每次收到请求，创建一个线程来处理该请求 把client_sock转成地址作为参数传入pthread_create
            perror("pthread_create");
    };
    close(server_sock);
    return 0;
};

index.html为：

<HTML>
    <TITLE>Index</TITLE>
    <BODY>
        <P>Welcome to J. David's webserver.
        <H1>CGI demo: get color
        <FORM ACTION="color.cgi" METHOD="POST">
            Enter color(example: red, pink, blue): 
            <INPUT TYPE="text" NAME="color">
            <INPUT TYPE="submit">
        </FORM>
    </BODY>
</HTML>

其中color.cgi如下，换成.sh、C++编写的.cgi等都可以：

#!/usr/bin/perl -Tw
use strict;
use CGI;
my($cgi) = new CGI;
print $cgi->header;
my($color) = "blue";
$color = $cgi->param('color') if defined $cgi->param('color');
print $cgi->start_html(-title => uc($color),-BGCOLOR => $color);
print $cgi->h1("This is $color");
print $cgi->end_html;

Makefile如下：

CFLAGS= -g -W -Wall
LIBS= -pthread #-lsocket
#用编译选项定义宏
ifeq ($(test_sock), y)
CFLAGS+= -D TEST_SOCK
endif
all: httpd client
httpd: httpd.c
    gcc $(CFLAGS) -o $@ $< $(LIBS)
client: client.c
    gcc $(CFLAGS) -o $@ $<
.PHONY: clean    
clean:
    rm -rf httpd client