evrpc.c

/*
 * Copyright (c) 2000-2004 Niels Provos <provos@citi.umich.edu>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef WIN32
#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <windows.h>
#undef WIN32_LEAN_AND_MEAN
#endif

#include <sys/types.h>
#ifndef WIN32
#include <sys/socket.h>
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#include <sys/queue.h>
#include <stdio.h>
#include <stdlib.h>
#ifndef WIN32
#include <unistd.h>
#endif
#include <errno.h>
#include <signal.h>
#include <string.h>
#include <assert.h>

#include "event.h"
#include "evrpc.h"
#include "evrpc-internal.h"
#include "evhttp.h"
#include "evutil.h"
#include "log.h"

struct evrpc_base*
evrpc_init(struct evhttp* http_server)
{
    struct evrpc_base* base = calloc(1, sizeof(struct evrpc_base));
    if (base == NULL)
        return (NULL);

    /* we rely on the tagging sub system */
    evtag_init();

    TAILQ_INIT(&base->registered_rpcs);
    TAILQ_INIT(&base->input_hooks);
    TAILQ_INIT(&base->output_hooks);
    base->http_server = http_server;

    return (base);
}

void
evrpc_free(struct evrpc_base* base)
{
    struct evrpc* rpc;
    struct evrpc_hook* hook;

    while ((rpc = TAILQ_FIRST(&base->registered_rpcs)) != NULL) {
        assert(evrpc_unregister_rpc(base, rpc->uri));
    }
    while ((hook = TAILQ_FIRST(&base->input_hooks)) != NULL) {
        assert(evrpc_remove_hook(base, EVRPC_INPUT, hook));
    }
    while ((hook = TAILQ_FIRST(&base->output_hooks)) != NULL) {
        assert(evrpc_remove_hook(base, EVRPC_OUTPUT, hook));
    }
    free(base);
}

void*
evrpc_add_hook(void* vbase,
               enum EVRPC_HOOK_TYPE hook_type,
               int (*cb)(struct evhttp_request*, struct evbuffer*, void*),
               void* cb_arg)
{
    struct _evrpc_hooks* base = vbase;
    struct evrpc_hook_list* head = NULL;
    struct evrpc_hook* hook = NULL;
    switch (hook_type) {
    case EVRPC_INPUT:
        head = &base->in_hooks;
        break;
    case EVRPC_OUTPUT:
        head = &base->out_hooks;
        break;
    default:
        assert(hook_type == EVRPC_INPUT || hook_type == EVRPC_OUTPUT);
    }

    hook = calloc(1, sizeof(struct evrpc_hook));
    assert(hook != NULL);

    hook->process = cb;
    hook->process_arg = cb_arg;
    TAILQ_INSERT_TAIL(head, hook, next);

    return (hook);
}

static int
evrpc_remove_hook_internal(struct evrpc_hook_list* head, void* handle)
{
    struct evrpc_hook* hook = NULL;
    TAILQ_FOREACH(hook, head, next) {
        if (hook == handle) {
            TAILQ_REMOVE(head, hook, next);
            free(hook);
            return (1);
        }
    }

    return (0);
}

/*
 * remove the hook specified by the handle
 */

int
evrpc_remove_hook(void* vbase, enum EVRPC_HOOK_TYPE hook_type, void* handle)
{
    struct _evrpc_hooks* base = vbase;
    struct evrpc_hook_list* head = NULL;
    switch (hook_type) {
    case EVRPC_INPUT:
        head = &base->in_hooks;
        break;
    case EVRPC_OUTPUT:
        head = &base->out_hooks;
        break;
    default:
        assert(hook_type == EVRPC_INPUT || hook_type == EVRPC_OUTPUT);
    }

    return (evrpc_remove_hook_internal(head, handle));
}

static int
evrpc_process_hooks(struct evrpc_hook_list* head,
                    struct evhttp_request* req, struct evbuffer* evbuf)
{
    struct evrpc_hook* hook;
    TAILQ_FOREACH(hook, head, next) {
        if (hook->process(req, evbuf, hook->process_arg) == -1)
            return (-1);
    }

    return (0);
}

static void evrpc_pool_schedule(struct evrpc_pool* pool);
static void evrpc_request_cb(struct evhttp_request*, void*);
void evrpc_request_done(struct evrpc_req_generic*);

/*
 * Registers a new RPC with the HTTP server.   The evrpc object is expected
 * to have been filled in via the EVRPC_REGISTER_OBJECT macro which in turn
 * calls this function.
 */

static char*
evrpc_construct_uri(const char* uri)
{
    char* constructed_uri;
    int constructed_uri_len;

    constructed_uri_len = strlen(EVRPC_URI_PREFIX) + strlen(uri) + 1;
    if ((constructed_uri = malloc(constructed_uri_len)) == NULL)
        event_err(1, "%s: failed to register rpc at %s",
                  __func__, uri);
    memcpy(constructed_uri, EVRPC_URI_PREFIX, strlen(EVRPC_URI_PREFIX));
    memcpy(constructed_uri + strlen(EVRPC_URI_PREFIX), uri, strlen(uri));
    constructed_uri[constructed_uri_len - 1] = '\0';

    return (constructed_uri);
}

int
evrpc_register_rpc(struct evrpc_base* base, struct evrpc* rpc,
                   void (*cb)(struct evrpc_req_generic*, void*), void* cb_arg)
{
    char* constructed_uri = evrpc_construct_uri(rpc->uri);

    rpc->base = base;
    rpc->cb = cb;
    rpc->cb_arg = cb_arg;

    TAILQ_INSERT_TAIL(&base->registered_rpcs, rpc, next);

    evhttp_set_cb(base->http_server,
                  constructed_uri,
                  evrpc_request_cb,
                  rpc);

    free(constructed_uri);

    return (0);
}

int
evrpc_unregister_rpc(struct evrpc_base* base, const char* name)
{
    char* registered_uri = NULL;
    struct evrpc* rpc;

    /* find the right rpc; linear search might be slow */
    TAILQ_FOREACH(rpc, &base->registered_rpcs, next) {
        if (strcmp(rpc->uri, name) == 0)
            break;
    }
    if (rpc == NULL) {
        /* We did not find an RPC with this name */
        return (-1);
    }
    TAILQ_REMOVE(&base->registered_rpcs, rpc, next);

    free((char*)rpc->uri);
    free(rpc);

    registered_uri = evrpc_construct_uri(name);

    /* remove the http server callback */
    assert(evhttp_del_cb(base->http_server, registered_uri) == 0);

    free(registered_uri);
    return (0);
}

static void
evrpc_request_cb(struct evhttp_request* req, void* arg)
{
    struct evrpc* rpc = arg;
    struct evrpc_req_generic* rpc_state = NULL;

    /* let's verify the outside parameters */
    if (req->type != EVHTTP_REQ_POST ||
        EVBUFFER_LENGTH(req->input_buffer) <= 0)
        goto error;

    /*
     * we might want to allow hooks to suspend the processing,
     * but at the moment, we assume that they just act as simple
     * filters.
     */
    if (evrpc_process_hooks(&rpc->base->input_hooks,
                            req, req->input_buffer) == -1)
        goto error;

    rpc_state = calloc(1, sizeof(struct evrpc_req_generic));
    if (rpc_state == NULL)
        goto error;

    /* let's check that we can parse the request */
    rpc_state->request = rpc->request_new();
    if (rpc_state->request == NULL)
        goto error;

    rpc_state->rpc = rpc;

    if (rpc->request_unmarshal(
            rpc_state->request, req->input_buffer) == -1) {
        /* we failed to parse the request; that's a bummer */
        goto error;
    }

    /* at this point, we have a well formed request, prepare the reply */

    rpc_state->reply = rpc->reply_new();
    if (rpc_state->reply == NULL)
        goto error;

    rpc_state->http_req = req;
    rpc_state->done = evrpc_request_done;

    /* give the rpc to the user; they can deal with it */
    rpc->cb(rpc_state, rpc->cb_arg);

    return;

error:
    evrpc_reqstate_free(rpc_state);
    evhttp_send_error(req, HTTP_SERVUNAVAIL, "Service Error");
    return;
}

void
evrpc_reqstate_free(struct evrpc_req_generic* rpc_state)
{
    /* clean up all memory */
    if (rpc_state != NULL) {
        struct evrpc* rpc = rpc_state->rpc;

        if (rpc_state->request != NULL)
            rpc->request_free(rpc_state->request);
        if (rpc_state->reply != NULL)
            rpc->reply_free(rpc_state->reply);
        free(rpc_state);
    }
}

void
evrpc_request_done(struct evrpc_req_generic* rpc_state)
{
    struct evhttp_request* req = rpc_state->http_req;
    struct evrpc* rpc = rpc_state->rpc;
    struct evbuffer* data = NULL;

    if (rpc->reply_complete(rpc_state->reply) == -1) {
        /* the reply was not completely filled in.  error out */
        goto error;
    }

    if ((data = evbuffer_new()) == NULL) {
        /* out of memory */
        goto error;
    }

    /* serialize the reply */
    rpc->reply_marshal(data, rpc_state->reply);

    /* do hook based tweaks to the request */
    if (evrpc_process_hooks(&rpc->base->output_hooks,
                            req, data) == -1)
        goto error;

    /* on success, we are going to transmit marshaled binary data */
    if (evhttp_find_header(req->output_headers, "Content-Type") == NULL) {
        evhttp_add_header(req->output_headers,
                          "Content-Type", "application/octet-stream");
    }

    evhttp_send_reply(req, HTTP_OK, "OK", data);

    evbuffer_free(data);

    evrpc_reqstate_free(rpc_state);

    return;

error:
    if (data != NULL)
        evbuffer_free(data);
    evrpc_reqstate_free(rpc_state);
    evhttp_send_error(req, HTTP_SERVUNAVAIL, "Service Error");
    return;
}

/* Client implementation of RPC site */

static int evrpc_schedule_request(struct evhttp_connection* connection,
                                  struct evrpc_request_wrapper* ctx);

struct evrpc_pool*
evrpc_pool_new(struct event_base* base)
{
    struct evrpc_pool* pool = calloc(1, sizeof(struct evrpc_pool));
    if (pool == NULL)
        return (NULL);

    TAILQ_INIT(&pool->connections);
    TAILQ_INIT(&pool->requests);

    TAILQ_INIT(&pool->input_hooks);
    TAILQ_INIT(&pool->output_hooks);

    pool->base = base;
    pool->timeout = -1;

    return (pool);
}

static void
evrpc_request_wrapper_free(struct evrpc_request_wrapper* request)
{
    free(request->name);
    free(request);
}

void
evrpc_pool_free(struct evrpc_pool* pool)
{
    struct evhttp_connection* connection;
    struct evrpc_request_wrapper* request;
    struct evrpc_hook* hook;

    while ((request = TAILQ_FIRST(&pool->requests)) != NULL) {
        TAILQ_REMOVE(&pool->requests, request, next);
        /* if this gets more complicated we need our own function */
        evrpc_request_wrapper_free(request);
    }

    while ((connection = TAILQ_FIRST(&pool->connections)) != NULL) {
        TAILQ_REMOVE(&pool->connections, connection, next);
        evhttp_connection_free(connection);
    }

    while ((hook = TAILQ_FIRST(&pool->input_hooks)) != NULL) {
        assert(evrpc_remove_hook(pool, EVRPC_INPUT, hook));
    }

    while ((hook = TAILQ_FIRST(&pool->output_hooks)) != NULL) {
        assert(evrpc_remove_hook(pool, EVRPC_OUTPUT, hook));
    }

    free(pool);
}

/*
 * Add a connection to the RPC pool.   A request scheduled on the pool
 * may use any available connection.
 */

void
evrpc_pool_add_connection(struct evrpc_pool* pool,
                          struct evhttp_connection* connection)
{
    assert(connection->http_server == NULL);
    TAILQ_INSERT_TAIL(&pool->connections, connection, next);

    /*
     * associate an event base with this connection
     */
    if (pool->base != NULL)
        evhttp_connection_set_base(connection, pool->base);

    /*
     * unless a timeout was specifically set for a connection,
     * the connection inherits the timeout from the pool.
     */
    if (connection->timeout == -1)
        connection->timeout = pool->timeout;

    /*
     * if we have any requests pending, schedule them with the new
     * connections.
     */

    if (TAILQ_FIRST(&pool->requests) != NULL) {
        struct evrpc_request_wrapper* request =
            TAILQ_FIRST(&pool->requests);
        TAILQ_REMOVE(&pool->requests, request, next);
        evrpc_schedule_request(connection, request);
    }
}

void
evrpc_pool_set_timeout(struct evrpc_pool* pool, int timeout_in_secs)
{
    struct evhttp_connection* evcon;
    TAILQ_FOREACH(evcon, &pool->connections, next) {
        evcon->timeout = timeout_in_secs;
    }
    pool->timeout = timeout_in_secs;
}


static void evrpc_reply_done(struct evhttp_request*, void*);
static void evrpc_request_timeout(int, short, void*);

/*
 * Finds a connection object associated with the pool that is currently
 * idle and can be used to make a request.
 */
static struct evhttp_connection*
evrpc_pool_find_connection(struct evrpc_pool* pool)
{
    struct evhttp_connection* connection;
    TAILQ_FOREACH(connection, &pool->connections, next) {
        if (TAILQ_FIRST(&connection->requests) == NULL)
            return (connection);
    }

    return (NULL);
}

/*
 * We assume that the ctx is no longer queued on the pool.
 */
static int
evrpc_schedule_request(struct evhttp_connection* connection,
                       struct evrpc_request_wrapper* ctx)
{
    struct evhttp_request* req = NULL;
    struct evrpc_pool* pool = ctx->pool;
    struct evrpc_status status;
    char* uri = NULL;
    int res = 0;

    if ((req = evhttp_request_new(evrpc_reply_done, ctx)) == NULL)
        goto error;

    /* serialize the request data into the output buffer */
    ctx->request_marshal(req->output_buffer, ctx->request);

    uri = evrpc_construct_uri(ctx->name);
    if (uri == NULL)
        goto error;

    /* we need to know the connection that we might have to abort */
    ctx->evcon = connection;

    /* apply hooks to the outgoing request */
    if (evrpc_process_hooks(&pool->output_hooks,
                            req, req->output_buffer) == -1)
        goto error;

    if (pool->timeout > 0) {
        /*
         * a timeout after which the whole rpc is going to be aborted.
         */
        struct timeval tv;
        evutil_timerclear(&tv);
        tv.tv_sec = pool->timeout;
        evtimer_add(&ctx->ev_timeout, &tv);
    }

    /* start the request over the connection */
    res = evhttp_make_request(connection, req, EVHTTP_REQ_POST, uri);
    free(uri);

    if (res == -1)
        goto error;

    return (0);

error:
    memset(&status, 0, sizeof(status));
    status.error = EVRPC_STATUS_ERR_UNSTARTED;
    (*ctx->cb)(&status, ctx->request, ctx->reply, ctx->cb_arg);
    evrpc_request_wrapper_free(ctx);
    return (-1);
}

int
evrpc_make_request(struct evrpc_request_wrapper* ctx)
{
    struct evrpc_pool* pool = ctx->pool;

    /* initialize the event structure for this rpc */
    evtimer_set(&ctx->ev_timeout, evrpc_request_timeout, ctx);
    if (pool->base != NULL)
        event_base_set(pool->base, &ctx->ev_timeout);

    /* we better have some available connections on the pool */
    assert(TAILQ_FIRST(&pool->connections) != NULL);

    /*
     * if no connection is available, we queue the request on the pool,
     * the next time a connection is empty, the rpc will be send on that.
     */
    TAILQ_INSERT_TAIL(&pool->requests, ctx, next);

    evrpc_pool_schedule(pool);

    return (0);
}

static void
evrpc_reply_done(struct evhttp_request* req, void* arg)
{
    struct evrpc_request_wrapper* ctx = arg;
    struct evrpc_pool* pool = ctx->pool;
    struct evrpc_status status;
    int res = -1;

    /* cancel any timeout we might have scheduled */
    event_del(&ctx->ev_timeout);

    memset(&status, 0, sizeof(status));
    status.http_req = req;

    /* we need to get the reply now */
    if (req != NULL) {
        /* apply hooks to the incoming request */
        if (evrpc_process_hooks(&pool->input_hooks,
                                req, req->input_buffer) == -1) {
            status.error = EVRPC_STATUS_ERR_HOOKABORTED;
            res = -1;
        } else {
            res = ctx->reply_unmarshal(ctx->reply,
                                       req->input_buffer);
            if (res == -1) {
                status.error = EVRPC_STATUS_ERR_BADPAYLOAD;
            }
        }
    } else {
        status.error = EVRPC_STATUS_ERR_TIMEOUT;
    }

    if (res == -1) {
        /* clear everything that we might have written previously */
        ctx->reply_clear(ctx->reply);
    }

    (*ctx->cb)(&status, ctx->request, ctx->reply, ctx->cb_arg);

    evrpc_request_wrapper_free(ctx);

    /* the http layer owns the request structure */

    /* see if we can schedule another request */
    evrpc_pool_schedule(pool);
}

static void
evrpc_pool_schedule(struct evrpc_pool* pool)
{
    struct evrpc_request_wrapper* ctx = TAILQ_FIRST(&pool->requests);
    struct evhttp_connection* evcon;

    /* if no requests are pending, we have no work */
    if (ctx == NULL)
        return;

    if ((evcon = evrpc_pool_find_connection(pool)) != NULL) {
        TAILQ_REMOVE(&pool->requests, ctx, next);
        evrpc_schedule_request(evcon, ctx);
    }
}

static void
evrpc_request_timeout(int fd, short what, void* arg)
{
    struct evrpc_request_wrapper* ctx = arg;
    struct evhttp_connection* evcon = ctx->evcon;
    assert(evcon != NULL);

    evhttp_connection_fail(evcon, EVCON_HTTP_TIMEOUT);
}