/Users/maurits/Documents/studie/afstuderen/biosphere/daemon/http.c

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: mar 21, 2007
 * 
 * Function:
 * HTTP handling code for the daemon.
 * 
 * License information:
 * 
 * Copyright (c) 2006 Maurits Hartman
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 * 
 */
 
#include "http.h"
#include "settings.h"
#include "service.h"
#include <copy.h>
#include <xml.h>

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


static char *get_remote_endpoint(apr_socket_t *sock, apr_pool_t *mp)
{
        char *remote_ipaddr;
        /* apr_port_t remote_port; */
        apr_sockaddr_t *remote_sa;
        
        apr_socket_addr_get(&remote_sa, APR_REMOTE, sock);
        apr_sockaddr_ip_get(&remote_ipaddr, remote_sa);
        /* remote_port = remote_sa->port; */
        
        /*return apr_psprintf(mp, "%s:%u", remote_ipaddr, remote_port); */
        return remote_ipaddr;
}


bs_status handle_http_get(apr_socket_t *sock, apr_pool_t *mp)
{
        apr_status_t rv;
        bs_status rv2;
        bs_definition *def;
        char *contentbuf, *headerbuf, timebuf[APR_RFC822_DATE_LEN + 1];
        char *remote_client;
        apr_size_t len;
        bs_uint64 size;
        
        /* Gather all the definitions and translate them to XML: */
        remote_client = get_remote_endpoint(sock, mp);
        printf("Handling incoming HTTP GET request from %s\n", remote_client);
        rv2 = get_services(&def, mp);
        if (rv2 != BS_OK){
                send_http_error(sock, "HTTP/1.0 500 Internal Server Error", mp);
                fprintf(stderr, "%d Error while gathering services\n", rv2);
                return BS_ERROR;
        }
        rv2 = xlate_definition_to_xml(&contentbuf, &size, def, mp);
        if (rv2 != BS_OK){
                send_http_error(sock, "HTTP/1.0 500 Internal Server Error", mp);
                fprintf(stderr, "%d Error while creating WSDL of services\n", rv2);
                return BS_ERROR;
        }
        
        /* Create the HTTP headers and send: */
        apr_rfc822_date(timebuf, apr_time_now());
        headerbuf = apr_psprintf(mp,
                        "HTTP/1.0 200 OK\r\n"
                        "Date: %s\r\n"
                        "Server: " BIOSPHERE_VERSION_STRING "\r\n"
                        "Content-Length: %" BS_UINT64_FMT "\r\n"
                        "Content-Type: application/wsdl+xml\r\n"
                        "Content-Disposition: attachment; filename=\"services.wsdl\"\r\n\r\n",
                        timebuf, size);
        headerbuf = apr_pstrcat(mp, headerbuf, contentbuf, NULL);
        len = strlen(headerbuf);
        rv = apr_socket_send(sock, headerbuf, &len);
        if (rv != APR_SUCCESS || len == 0) {
                char err[256];
        apr_strerror(rv, err, sizeof(err));
                fprintf(stderr, "Error while sending data: %s\n", err);
                return BS_ERROR;
        }
        
        return BS_OK;
}


static bs_status get_remaining_content(apr_socket_t *sock, char **result,
                const char *initial, unsigned size, bs_uint64 remaining,
                apr_pool_t *mp)
{
        char *collect;
        char buf[HTTP_BUFFER_SIZE];
        apr_size_t buflen;

        /* Continuously try to receive the remaining data: */
        collect = apr_pstrndup(mp, initial, size);
        while (remaining > 0) {
                apr_status_t rv;
                
                buflen = sizeof(buf) - 1;
                memset(buf, '\0', sizeof(buf));
                rv = apr_socket_recv(sock, buf, &buflen);
                if (rv == APR_EOF || buflen == 0) {
                        apr_socket_close(sock);
                        return BS_ERROR;
                }
                
                /* Chop all data more than the specified content-length: */
                if (buflen > remaining) {
                        char *tmp;
                        tmp = apr_pstrndup(mp, buf, remaining);
                        collect = apr_pstrcat(mp, collect, tmp, NULL);
                        break;
                }
                else collect = apr_pstrcat(mp, collect, buf, NULL);
                
                remaining -= buflen;
        }
        
        *result = collect;
        return BS_OK;
}


static bs_status check_for_http_errors(apr_socket_t *sock,
                http_header_info *info, apr_pool_t *mp)
{
        if (info->content_length == 0) {
                send_http_error(sock, "HTTP/1.0 411 Length Required", mp);
                return BS_ERROR;
        }
        else if (info->content_length > BIOSPHERED_MAX_CONTENT_LENGTH) {
                send_http_error(sock, "HTTP/1.0 413 Request Entity Too Large", mp);
                return BS_ERROR;
        }
        else if (info->content_type == NULL ||
                        apr_strnatcmp(info->content_type, "text/xml") != 0) {
                send_http_error(sock, "HTTP/1.0 415 Unsupported Media Type", mp);
                return BS_ERROR;                
        }
        
        return BS_OK;
}


bs_status handle_http_post(apr_socket_t *sock, const char *headerbuf,
                apr_size_t headerlen, apr_pool_t *mp)
{
        http_header_info *hinfo;
        bs_status rv;
        apr_status_t rv2;
        apr_size_t len;
        char *content_buf, *hbuf, *remote_client, timebuf[APR_RFC822_DATE_LEN + 1];
        bs_service_request *request = NULL;
        bs_service_response *response = NULL;
        unsigned type;
        bs_uint64 size;
        
        /* Parse HTTP headers, check content length and other preconditions: */
        remote_client = get_remote_endpoint(sock, mp);
        /*printf("Handling incoming HTTP POST request from %s\n", remote_client);*/
        rv = parse_http_headers(headerbuf, headerlen, &hinfo, mp);
        if (rv != BS_OK) {
                fprintf(stderr, "%d Error while parsing HTTP headers\n", rv);
                return rv;
        }
        rv = check_for_http_errors(sock, hinfo, mp);
        if (rv != BS_OK) {
                fprintf(stderr, "%d Error while checking for HTTP errors\n", rv);
                return rv;
        }
        headerbuf += hinfo->content_offset;
        
        /* Process the content data into a buffer: */
        if (hinfo->content_length < headerlen - hinfo->content_offset)
                content_buf = apr_pstrndup(mp, headerbuf, hinfo->content_length);
        else { /* Still some data bound to arrive: */
                bs_uint64 remaining;
                content_buf = apr_pstrndup(mp, headerbuf, headerlen - hinfo->content_offset);
                remaining = hinfo->content_length - headerlen + hinfo->content_offset;
                rv = get_remaining_content(sock, &content_buf, content_buf,
                                headerlen - hinfo->content_offset, remaining, mp);
                if (rv != BS_OK) {
                        fprintf(stderr, "%d Unable to receive remaining content\n", rv);
                        return rv;
                }
        }
        
        /* Parse the incoming xml data: */
        rv = xlate_from_xml(content_buf, strlen(content_buf), (void **) &request, &type, mp);
        if (rv != BS_OK || type != SERVICE_REQUEST_FROM_XML) {
                send_http_error(sock, "HTTP/1.0 406 Not Acceptable", mp);
                fprintf(stderr, "%d Error while translating XML service request\n", rv);
                return rv;
        }
        
        
        /* Try to handle the service request: */
        rv = handle_service_request(request, &response, mp);
        if (rv != BS_OK) {
                send_http_error(sock, "HTTP/1.0 503 Service Unavailable", mp);
                fprintf(stderr, "%d Error while handling service request\n", rv);
                delete_response(response);
                return rv;
        }
        
        /* Translate the result to xml: */
        rv = xlate_response_to_xml(&content_buf, &size, response, mp);
        delete_response(response);
        if (rv != BS_OK) {
                send_http_error(sock, "HTTP/1.0 500 Internal Server Error", mp);
                fprintf(stderr, "%d Error while translating service response to XML\n", rv);
                return rv;
        }
        
        /* Create headers and send on its way: */
        apr_rfc822_date(timebuf, apr_time_now());
        hbuf = apr_psprintf(mp,
                        "HTTP/1.0 200 OK\r\n"
                        "Date: %s\r\n"
                        "Server: " BIOSPHERE_VERSION_STRING "\r\n"
                        "Content-Length: %" BS_UINT64_FMT "\r\n"
                        "Content-Type: text/xml\r\n\r\n",
                        timebuf, size);
        hbuf = apr_pstrcat(mp, hbuf, content_buf, NULL);
        len = strlen(hbuf);
        rv2 = apr_socket_send(sock, hbuf, &len);
        if (rv2 != APR_SUCCESS || len == 0) {
                fprintf(stderr, "%d Error while sending service response\n", rv);
                return BS_ERROR;
        }
        
        return BS_OK;
}


bs_status send_http_error(apr_socket_t *sock, const char *errstring, apr_pool_t *mp)
{
        apr_status_t rv;
        char *buf, timebuf[APR_RFC822_DATE_LEN + 1];
        apr_size_t len;
        
        apr_rfc822_date(timebuf, apr_time_now());
        buf = apr_psprintf(mp,
                        "%s\r\n"
                        "Date: %s\r\n"
                        "Server: " BIOSPHERE_VERSION_STRING "\r\n\r\n",
                        errstring,
                        timebuf);
        len = strlen(buf);
        rv = apr_socket_send(sock, buf, &len);
        if (rv != APR_SUCCESS) return BS_ERROR;
        
        return BS_OK;   
}

---