httpd_response.c

Go to the documentation of this file.

/*
 * Copyright 2011 Aalborg University. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY Aalborg University ''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 Aalborg University OR
 * CONTRIBUTORS 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.
 *
 * The views and conclusions contained in the software and documentation are those of the
 * authors and should not be interpreted as representing official policies, either expressed
 */

#include "httpd_request.h"
#include "hpd/hpd_shared_api.h"

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

#define HTTPD_HTTP_VERSION "HTTP/1.1 "
#define HTTPD_CRLF "\r\n"

struct hpd_httpd_response
{
    const hpd_module_t *context;
    hpd_tcpd_conn_t *conn; 
    char *msg;            
    hpd_status_t status;
};

static char* httpd_status_codes_to_str(hpd_status_t status)
{
#define XX(num, str) if(status == num) {return #str;}
    HPD_HTTP_STATUS_CODE_MAP(XX)
#undef XX
    return NULL;
}

hpd_error_t hpd_httpd_response_destroy(hpd_httpd_response_t *res)
{
    if (!res) return  HPD_E_NULL;

    hpd_error_t rc = hpd_tcpd_conn_close(res->conn);
    free(res->msg);
    free(res);
    return rc;
}

hpd_error_t hpd_httpd_response_create(hpd_httpd_response_t **response, hpd_httpd_request_t *req, hpd_status_t status)
{
    if (!req) return HPD_E_NULL;
    hpd_error_t rc, rc2;
    const hpd_module_t *context;
    if ((rc = http_request_get_context(req, &context))) return rc;
    if (!response) HPD_LOG_RETURN_E_NULL(context);

    int len;

    // Get data
    char *status_str = httpd_status_codes_to_str(status);

    // Calculate msg length
    len = 1;
    len += strlen(HTTPD_HTTP_VERSION);
    // TODO Problem if this if is NULL !
    if (status_str) len += strlen(status_str);
    len += 4;
    len += strlen(HTTPD_CRLF);

    // Allocate space
    (*response) = malloc(sizeof(hpd_httpd_response_t));
    if (!(*response)) HPD_LOG_RETURN_E_ALLOC(context);
    (*response)->status = status;
    (*response)->msg = malloc(len*sizeof(char));
    if (!(*response)->msg) {
        if ((rc = hpd_httpd_response_destroy((*response))))
            HPD_LOG_ERROR(context, "Failed to destroy response (code: %d).", rc);
        HPD_LOG_RETURN_E_ALLOC(context);
    }

    // Init struct
    (*response)->context = context;
    if ((rc = http_request_get_connection(req, &(*response)->conn))) return rc;

    // Construct msg
    strcpy((*response)->msg, HTTPD_HTTP_VERSION);
    sprintf(&(*response)->msg[strlen(HTTPD_HTTP_VERSION)], "%i ", status);
    if (status_str) strcat((*response)->msg, status_str);
    strcat((*response)->msg, HTTPD_CRLF);

    // Real persistent connections is not supported, so tell client that we close connection after response has been sent
    rc = hpd_httpd_response_add_header((*response), "Connection", "close");
    if (rc && (rc2 = hpd_httpd_response_destroy(*response)))
        HPD_LOG_ERROR(context, "Failed to destroy response (code: %d).", rc2);;
    return rc;
}

hpd_error_t hpd_httpd_response_add_header(hpd_httpd_response_t *res, const char *field, const char *value)
{
    if (!res) return HPD_E_NULL;
    if (!field || !value) HPD_LOG_RETURN_E_NULL(res->context);

    // Headers already sent
    if (!res->msg)
        HPD_LOG_RETURN(res->context, HPD_E_STATE, "Cannot add header, they have already been sent to client.");

    char *msg;
    size_t msg_len = strlen(res->msg)+strlen(field)+2+strlen(value)+strlen(HTTPD_CRLF)+1;

    msg = realloc(res->msg, msg_len*sizeof(char));
    if (!msg) HPD_LOG_RETURN_E_ALLOC(res->context);
    res->msg = msg;

    strcat(res->msg, field);
    strcat(res->msg, ": ");
    strcat(res->msg, value);
    strcat(res->msg, HTTPD_CRLF);

    return HPD_E_SUCCESS;
}

hpd_error_t hpd_httpd_response_add_cookie(hpd_httpd_response_t *res,
                                          const char *field, const char *value,
                                          const char *expires, const char *max_age,
                                          const char *domain, const char *path,
                                          int secure, int http_only,
                                          const char *extension)
{
    if (!res) return HPD_E_NULL;
    if (!field || !value) HPD_LOG_RETURN_E_NULL(res->context);

    // Headers already sent
    if (!res->msg) return HPD_E_STATE;

    char *msg;
    size_t msg_len = strlen(res->msg) + 12 + strlen(field) + 1 + strlen(value) + strlen(HTTPD_CRLF) + 1;

    // Calculate length
    if (expires)   msg_len += 10 + strlen(expires);
    if (max_age)   msg_len += 10 + strlen(max_age);
    if (domain)    msg_len +=  9 + strlen(domain);
    if (path)      msg_len +=  7 + strlen(path);
    if (secure)    msg_len +=  8;
    if (http_only) msg_len += 10;
    if (extension) msg_len +=  2 + strlen(extension);

    // Reallocate message
    msg = realloc(res->msg, msg_len*sizeof(char));
    if (!msg) HPD_LOG_RETURN_E_ALLOC(res->context);
    res->msg = msg;

    // Apply header
    strcat(res->msg, "Set-Cookie: ");
    strcat(res->msg, field);
    strcat(res->msg, "=");
    strcat(res->msg, value);
    strcat(res->msg, HTTPD_CRLF);
    if (expires) {
        strcat(res->msg, "; Expires=");
        strcat(res->msg, expires);
    }
    if (max_age) {
        strcat(res->msg, "; Max-Age=");
        strcat(res->msg, max_age);
    }
    if (domain) {
        strcat(res->msg, "; Domain=");
        strcat(res->msg, domain);
    }
    if (path) {
        strcat(res->msg, "; Domain=");
        strcat(res->msg, domain);
    }
    if (secure) strcat(res->msg, "; Secure");
    if (http_only) strcat(res->msg, "; HttpOnly");
    if (extension) {
        strcat(res->msg, "; ");
        strcat(res->msg, extension);
    }

    return HPD_E_SUCCESS;
}

hpd_error_t hpd_httpd_response_sendf(hpd_httpd_response_t *res, const char *fmt, ...)
{
    if (!res) return HPD_E_NULL;

    va_list arg;
    va_start(arg, fmt);
    hpd_error_t rc = hpd_httpd_response_vsendf(res, fmt, arg);
    va_end(arg);
    return rc;
}

hpd_error_t hpd_httpd_response_vsendf(hpd_httpd_response_t *res, const char *fmt, va_list arg)
{
    if (!res) return HPD_E_NULL;

    hpd_error_t rc;

    if (res->msg) {
        const char *ip;
        if ((rc = hpd_tcpd_conn_get_ip(res->conn, &ip))) {
            HPD_LOG_WARN(res->context, "Failed to get ip [code: %i].", rc);
            ip = "(unknown)";
        }
        HPD_LOG_VERBOSE(res->context, "Sending response to %s: %i %s.", ip, res->status, httpd_status_codes_to_str(res->status));
        if ((rc = hpd_tcpd_conn_sendf(res->conn, "%s%s", res->msg, HTTPD_CRLF))) return rc;
        free(res->msg);
        res->msg = NULL;
    }

    if (fmt) {
        return hpd_tcpd_conn_vsendf(res->conn, fmt, arg);
    }

    return HPD_E_SUCCESS;
}