/** * apr tutorial sample code * http://dev.ariel-networks.com/apr/ */#ifdef HAVE_CONFIG_H#include <config.h>#endif#include <stdio.h>#include <assert.h>#include <apr_general.h>#include <apr_file_io.h>#include <apr_strings.h>#include <apr_network_io.h>#include <apr_poll.h>/* default listen port number */#define DEF_LISTEN_PORT		8081/* default socket backlog number. SOMAXCONN is a system default value */#define DEF_SOCKET_BACKLOG	SOMAXCONN#define DEF_POLLSET_NUM		32/* default socket timeout */#define DEF_POLL_TIMEOUT	(APR_USEC_PER_SEC * 30)/* default buffer size */#define BUFSIZE			4096/* useful macro */#define CRLF_STR		"\r\n"typedef struct _serv_ctx_t serv_ctx_t;/** * network event callback function type */typedef int (*socket_callback_t)(serv_ctx_t *serv_ctx, apr_pollset_t *pollset, apr_socket_t *sock);/** * network server context  */struct _serv_ctx_t {    enum {        SERV_RECV_REQUEST,        SERV_SEND_RESPONSE,    } status;    socket_callback_t cb_func;    apr_pool_t *mp;    /* recv ctx */    struct {        const char *filepath;        int is_firstline;    } recv;    /* send ctx */    struct {        char *send_buf;        apr_off_t offset;    } send;};static apr_socket_t* create_listen_sock(apr_pool_t *mp);static int do_accept(apr_pollset_t *pollset, apr_socket_t *lsock, apr_pool_t *mp);static int recv_req_cb(serv_ctx_t *serv_ctx, apr_pollset_t *pollset, apr_socket_t *sock);static int send_resp_cb(serv_ctx_t *serv_ctx, apr_pollset_t *pollset, apr_socket_t *sock);/** * @remark Error checks omitted */int main(int argc, const char *argv[]){    apr_status_t rv;    apr_pool_t *mp;    apr_socket_t *lsock;/* listening socket */    apr_pollset_t *pollset;    apr_int32_t num;    const apr_pollfd_t *ret_pfd;    apr_initialize();    apr_pool_create(&mp, NULL);    lsock = create_listen_sock(mp);    assert(lsock);        apr_pollset_create(&pollset, DEF_POLLSET_NUM, mp, 0);    {        apr_pollfd_t pfd = { mp, APR_POLL_SOCKET, APR_POLLIN, 0, { NULL }, NULL };        pfd.desc.s = lsock;        apr_pollset_add(pollset, &pfd);    }    while (1) {        rv = apr_pollset_poll(pollset, DEF_POLL_TIMEOUT, &num, &ret_pfd);        if (rv == APR_SUCCESS) {            int i;            assert(num > 0);            /* scan the active sockets */            for (i = 0; i < num; i++) {                if (ret_pfd[i].desc.s == lsock) {                    /* the listen socket is readable. that indicates we accepted a new connection */                    do_accept(pollset, lsock, mp);                } else {                    serv_ctx_t *serv_ctx = ret_pfd[i].client_data;                    socket_callback_t cb_func = serv_ctx->cb_func;                    cb_func(serv_ctx, pollset, ret_pfd[i].desc.s);                }            }        }    }        return 0;}static apr_socket_t* create_listen_sock(apr_pool_t *mp){    apr_status_t rv;    apr_socket_t *s;    apr_sockaddr_t *sa;        rv = apr_sockaddr_info_get(&sa, NULL, APR_INET, DEF_LISTEN_PORT, 0, mp);    if (rv != APR_SUCCESS) {	goto error;    }        rv = apr_socket_create(&s, sa->family, SOCK_STREAM, APR_PROTO_TCP, mp);    if (rv != APR_SUCCESS) {	goto error;    }    /* non-blocking socket */    apr_socket_opt_set(s, APR_SO_NONBLOCK, 1);    apr_socket_timeout_set(s, 0);    apr_socket_opt_set(s, APR_SO_REUSEADDR, 1);/* this is useful for a server(socket listening) process */    rv = apr_socket_bind(s, sa);    if (rv != APR_SUCCESS) {	goto error;    }    rv = apr_socket_listen(s, DEF_SOCKET_BACKLOG);    if (rv != APR_SUCCESS) {	goto error;    }    return s; error:    return NULL;}static int do_accept(apr_pollset_t *pollset, apr_socket_t *lsock, apr_pool_t *mp){    apr_socket_t *ns;/* accepted socket */    apr_status_t rv;                rv = apr_socket_accept(&ns, lsock, mp);    if (rv == APR_SUCCESS) {        serv_ctx_t *serv_ctx = apr_palloc(mp, sizeof(serv_ctx_t));        apr_pollfd_t pfd = { mp, APR_POLL_SOCKET, APR_POLLIN, 0, { NULL }, serv_ctx };        pfd.desc.s = ns;        /* at first, we expect requests, so we poll APR_POLLIN event */        serv_ctx->status = SERV_RECV_REQUEST;        serv_ctx->cb_func = recv_req_cb;        serv_ctx->recv.is_firstline = TRUE;        serv_ctx->mp = mp;        /* non-blocking socket. We can't expect that @ns inherits non-blocking mode from @lsock */        apr_socket_opt_set(ns, APR_SO_NONBLOCK, 1);        apr_socket_timeout_set(ns, 0);                apr_pollset_add(pollset, &pfd);    }    return TRUE;}static int recv_req_cb(serv_ctx_t *serv_ctx, apr_pollset_t *pollset, apr_socket_t *sock){    while (1) {	char buf[BUFSIZE];	apr_size_t len = sizeof(buf) - 1;/* -1 for a null-terminated */	apr_status_t rv = apr_socket_recv(sock, buf, &len);	if (rv == APR_EOF || len == 0) {	    break;        }        buf[len] = '\0';/* apr_socket_recv() doesn't return a null-terminated string */                if (serv_ctx->recv.is_firstline && strstr(buf, CRLF_STR)) {            char **tokens;            apr_tokenize_to_argv(buf, &tokens, serv_ctx->mp);            if (tokens[0] && tokens[1] && strcmp(tokens[0], "GET") == 0) {                serv_ctx->recv.filepath = apr_pstrdup(serv_ctx->mp, tokens[1]);            }            serv_ctx->recv.is_firstline = FALSE;        }        if (strstr(buf, CRLF_STR CRLF_STR)) {/* expect the end of the request. no guarantee */            /* status change (from read to write) */            apr_pollfd_t pfd = { serv_ctx->mp, APR_POLL_SOCKET, APR_POLLIN, 0, { NULL }, serv_ctx };            pfd.desc.s = sock;            apr_pollset_remove(pollset, &pfd);            pfd.reqevents = APR_POLLOUT;            apr_pollset_add(pollset, &pfd);            serv_ctx->status = SERV_SEND_RESPONSE;            serv_ctx->cb_func = send_resp_cb;            break;        }    }    return TRUE;}/** * Generate a response string. * @remark This would consume many memories for a large file. */static void gen_response(serv_ctx_t *serv_ctx){    apr_status_t rv;    apr_file_t *fp;    const char *filepath = serv_ctx->recv.filepath;        if ((rv = apr_file_open(&fp, filepath, APR_READ, APR_OS_DEFAULT, serv_ctx->mp)) == APR_SUCCESS) {        const char *resp_hdr;        apr_size_t len;        const char *resp_body;                apr_finfo_t finfo;        apr_file_info_get(&finfo, APR_FINFO_SIZE, fp);                resp_hdr = apr_psprintf(serv_ctx->mp, "HTTP/1.0 200 OK" CRLF_STR "Content-Length: %" APR_OFF_T_FMT CRLF_STR CRLF_STR, finfo.size);        resp_body = apr_pcalloc(serv_ctx->mp, finfo.size + 1);        len = finfo.size;        apr_file_read(fp, (void*)resp_body, &len);        serv_ctx->send.send_buf = apr_pstrcat(serv_ctx->mp, resp_hdr, resp_body, NULL);    } else {        serv_ctx->send.send_buf = "HTTP/1.0 404 Not Found" CRLF_STR CRLF_STR;    }}/** * Send a response to the client. */static int send_resp_cb(serv_ctx_t *serv_ctx, apr_pollset_t *pollset, apr_socket_t *sock){    if (!serv_ctx->send.send_buf) {        gen_response(serv_ctx);    }    {        apr_off_t offset = serv_ctx->send.offset;        const char *send_pt = &serv_ctx->send.send_buf[offset];        apr_size_t len = strlen(send_pt);        apr_size_t wlen = len;        apr_status_t rv;                rv = apr_socket_send(sock, send_pt, &wlen);        if (wlen == len) {            apr_pollfd_t pfd = { serv_ctx->mp, APR_POLL_SOCKET, APR_POLLOUT, 0, { NULL }, serv_ctx };            pfd.desc.s = sock;            apr_pollset_remove(pollset, &pfd);            apr_socket_close(sock);        } else {            serv_ctx->send.offset += wlen;        }    }        return TRUE;}