libevent(六)http server

客户端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>

#include <event2/event.h>
#include <event2/http.h>
#include <event2/http_struct.h>
#include <event2/bufferevent.h>
#include <event2/buffer.h>

#define DEFAULT_URL  "http://127.0.0.1:8080"

void http_request_done(struct evhttp_request *req, void *arg){
    char buffer[];
    int nread;

    if (req == NULL) {
        printf("request failed\n");
        return;
    }
    fprintf(stderr, "Response line: %d %s\n",
            evhttp_request_get_response_code(req),req->response_code_line);

    while ((nread = evbuffer_remove(evhttp_request_get_input_buffer(req),
                                    buffer, sizeof(buffer)))
           > ) {
        fwrite(buffer, nread, , stdout);
    }
}

int main(int argc, char **argv){
    char *url = DEFAULT_URL;
    if (argc == ) {
        url = argv[];
    }

    struct evhttp_uri *http_uri = NULL;
    const char *scheme, *host, *path, *query;
    char uri[];
    int port;

    http_uri = evhttp_uri_parse(url);

    scheme = evhttp_uri_get_scheme(http_uri);
    if (scheme == NULL || (strcasecmp(scheme, "https") !=  &&
                           strcasecmp(scheme, "http") != )) {
        printf("url must be http or https\n");
        return ;
    }

    host = evhttp_uri_get_host(http_uri);
    port = evhttp_uri_get_port(http_uri);
    if (port == -) {
        port = (strcasecmp(scheme, "http") == ) ?  : ;
    }

    path = evhttp_uri_get_path(http_uri);
    if (strlen(path) == ) {
        path = "/";
    }

    query = evhttp_uri_get_query(http_uri);
    if (query == NULL) {
        snprintf(uri, sizeof(uri) - , "%s", path);
    } else {
        snprintf(uri, sizeof(uri) - , "%s?%s", path, query);
    }
    uri[sizeof(uri) - ] = '\0';

    printf("url: %s\n", url);
    printf("scheme: %s\n", scheme);
    printf("host: %s\n", host);
    printf("port: %d\n", port);
    printf("path: %s\n", path);
    printf("uri: %s\n", uri);

    struct event_base *base;
    struct evhttp_connection *conn;
    struct evhttp_request *req;

    base = event_base_new();
    conn = evhttp_connection_base_new(base, NULL, host, port);
    req = evhttp_request_new(http_request_done, base);

    evhttp_add_header(req->output_headers, "Host", host);
    //evhttp_add_header(req->output_headers, "Connection", "close");

    evhttp_make_request(conn, req, EVHTTP_REQ_GET, uri);

    event_base_dispatch(base);

    return ;
}

服务器：

#include <stdio.h>
#include <stdlib.h>
#include <event2/keyvalq_struct.h>
#include <event2/http.h>
#include <event2/event.h>
#include <event2/buffer.h>

#define DEFAULT_PORT 8080

void http_request_cb(struct evhttp_request *req, void *arg);
void print_request(struct evhttp_request *req, void *arg);
void php_request_cb(struct evhttp_request *req, void *arg);

int main(int argc, char **argv) {
    int port = DEFAULT_PORT;
    if (argc == ) {
        port = atoi(argv[]);
    }

    struct event_base *base = event_base_new();

    struct evhttp *http = evhttp_new(base);
    evhttp_set_gencb(http, http_request_cb, NULL);
    evhttp_set_cb(http, "/index.php", php_request_cb, NULL);
    evhttp_bind_socket(http, "0.0.0.0", port);

    event_base_dispatch(base);

    return ;
}

void php_request_cb(struct evhttp_request *req, void *arg) {
    printf("run php_request_cb...\n");
}

void http_request_cb(struct evhttp_request *req, void *arg) {
    printf("run http_request_cb...\n");

    print_request(req, arg);

    const char *uri = evhttp_request_get_uri(req);
    printf("uri: %s\n", uri);
    const char *decoded_uri = evhttp_decode_uri(uri);
    printf("decoded_uri: %s\n", decoded_uri);

    struct evhttp_uri *decoded = NULL;
    const char *path;

    /* Decode the URI */
    decoded = evhttp_uri_parse(uri);
    if (!decoded) {
        printf("It's not a good URI. Sending BADREQUEST\n");
        evhttp_send_error(req, HTTP_BADREQUEST, );
        return;
    }

    /* Let's see what path the user asked for. */
    path = evhttp_uri_get_path(decoded);
    if (!path) path = "/";
    printf("path: %s\n", path);

    struct evbuffer *evb = evbuffer_new();

    evbuffer_add_printf(evb, "Server response");
    evhttp_send_reply(req, HTTP_OK, "OK", evb);

    evbuffer_free(evb);
}

void print_request(struct evhttp_request *req, void *arg) {
    const char *cmdtype;
    struct evkeyvalq *headers;
    struct evkeyval *header;
    struct evbuffer *buf;

    switch (evhttp_request_get_command(req)) {
        case EVHTTP_REQ_GET: cmdtype = "GET"; break;
        case EVHTTP_REQ_POST: cmdtype = "POST"; break;
        case EVHTTP_REQ_HEAD: cmdtype = "HEAD"; break;
        case EVHTTP_REQ_PUT: cmdtype = "PUT"; break;
        case EVHTTP_REQ_DELETE: cmdtype = "DELETE"; break;
        case EVHTTP_REQ_OPTIONS: cmdtype = "OPTIONS"; break;
        case EVHTTP_REQ_TRACE: cmdtype = "TRACE"; break;
        case EVHTTP_REQ_CONNECT: cmdtype = "CONNECT"; break;
        case EVHTTP_REQ_PATCH: cmdtype = "PATCH"; break;
        default: cmdtype = "unknown"; break;
    }

    printf("Received a %s request for %s\nHeaders:\n",
           cmdtype, evhttp_request_get_uri(req));

    headers = evhttp_request_get_input_headers(req);
    for (header = headers->tqh_first; header;
         header = header->next.tqe_next) {
        printf("  %s: %s\n", header->key, header->value);
    }

    buf = evhttp_request_get_input_buffer(req);
    puts("Input data: <<<");
    while (evbuffer_get_length(buf)) {
        int n;
        char cbuf[];
        n = evbuffer_remove(buf, cbuf, sizeof(cbuf));
        if (n > )
            (void) fwrite(cbuf, , n, stdout);
    }
    puts(">>>");
}