/Users/maurits/Documents/studie/afstuderen/biosphere/common/http_common.c

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: apr 12, 2007
 * 
 * Function:
 * General HTTP network functions.
 * 
 * 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_common.h"
#include "xml.h"
#include <biosphere.h>

#include <apr_strings.h>
#include <apr_lib.h>
#include <apr_network_io.h>
#include <stdlib.h>


bs_bool received_full_headers(const char *headerbuf)
{
        unsigned i;
        apr_size_t headerlen;
        
        /* Scan the buffer to see if there is an header ending (\r\n\r\n or \n\n): */
        if (headerbuf == NULL) return FALSE;
        else headerlen = strlen(headerbuf);
        
        for (i = 0; i < headerlen - 2; i++) {
                if (headerbuf[i] == '\n') {
                        if (headerbuf[i + 1] == '\r' && headerbuf[i + 2] == '\n')
                                return TRUE;
                        else if (headerbuf[i + 1] == '\n')
                                return TRUE;
                }
        }
        return FALSE;
}


static bs_status extract_http_header_info(char *header,
                http_header_info *hinfo, apr_pool_t *mp)
{
        char *token, *q;
        
        /* Split the line: */
        token = apr_strtok(header, " :\r\n/", &q);
        if (apr_strnatcasecmp(token, "Content-Type") == 0) {
                token = apr_strtok(NULL, " \r\n", &q);
                hinfo->content_type = apr_pstrdup(mp, token);
        }
        else if (apr_strnatcasecmp(token, "Content-Length") == 0) {
                token = apr_strtok(NULL, " \r\n", &q);
                hinfo->content_length = apr_strtoi64(token, NULL, 0);
        }
        else if (apr_strnatcasecmp(token, "User-Agent") == 0) {
                token = apr_strtok(NULL, "\r\n", &q);
                if (token[0] == ' ') token++;
                hinfo->user_agent = apr_pstrdup(mp, token);
        }
        else if (apr_strnatcmp(token, "HTTP") == 0) {
                token = apr_strtok(NULL, " \r\n", &q); /* Remove HTTP version info */
                token = apr_strtok(NULL, " \r\n", &q);
                if (apr_isdigit(token[0]) && apr_isdigit(token[1]) && apr_isdigit(token[2]))
                        hinfo->http_code = (bs_uint32) strtol(token, NULL, 0);
        }
        
        return BS_OK;   
}


bs_status parse_http_headers(const char *headerbuf, apr_size_t headerlen,
                http_header_info **info, apr_pool_t *mp)
{
        unsigned buf_pos = 0;
        http_header_info *hinfo;
        
        hinfo = (http_header_info *) apr_pcalloc(mp, sizeof(http_header_info));
        
        /* Parse all the lines in the headerbuf: */
        while (1) {
                unsigned begin_pos = buf_pos;
                char *line = (char *) (headerbuf + buf_pos);
                bs_status rv;

                /* Extract a single line delimited by \n: */
                while (headerbuf[buf_pos] != '\n' && buf_pos < headerlen) buf_pos++;
                line = apr_pstrndup(mp, line, buf_pos - begin_pos);
                rv = extract_http_header_info(line, hinfo, mp);
                if (rv != BS_OK) return BS_HTTP_ERROR;
                
                /* Check to see if we found the end of the headers: */
                if (buf_pos + 2 < headerlen && headerbuf[buf_pos + 1] == '\r' &&
                                headerbuf[buf_pos + 2] == '\n') {
                        buf_pos += 3;
                        break;
                }
                else if (buf_pos + 1 < headerlen && headerbuf[buf_pos + 1] == '\n') {
                        buf_pos += 2;
                        break;  
                }
                else if (buf_pos >= headerlen) return BS_HTTP_ERROR;
                
                buf_pos++; /* For the line ending... */
        }
        
        /* Final checks and wrapup: */
        hinfo->content_offset = buf_pos;
        if (hinfo->content_length == 0 || hinfo->content_offset > hinfo->content_length)
                return BS_HTTP_ERROR;
        *info = hinfo;
        return BS_OK;
}


static bs_status receive_response(apr_socket_t *sock, char **response_data,
                bs_uint64 *length, apr_pool_t *mp)
{
        bs_status rv;
        http_header_info *info;
        char *buf = NULL;
        int tries = 4; /* Number of tries to receive full HTTP headers */
        bs_uint64 remaining;
        
        /* First receiving until a buffer with complete header data is received: */
        while (!received_full_headers(buf) && tries > 0) {
                apr_status_t rv2;
                apr_size_t len;
                char tmpbuf[HTTP_BUFFER_SIZE];
                
                /* Read from the socket and add to buffer: */
                len = sizeof(tmpbuf) - 1; /* Always null-terminated */
                memset(tmpbuf, '\0', sizeof(tmpbuf));
                rv2 = apr_socket_recv(sock, tmpbuf, &len);
                if (rv2 != APR_SUCCESS || len == 0) break;
                
                if (!buf) buf = apr_pstrdup(mp, tmpbuf);
                else buf = apr_pstrcat(mp, buf, tmpbuf, NULL);
                tries--;
        }
        
        /* Parse the HTTP headers: */
        if (!received_full_headers(buf)) return BS_HTTP_ERROR;
        rv = parse_http_headers(buf, strlen(buf), &info, mp);
        if (rv != BS_OK || !HTTP_CORRECT(info) || info->content_offset == 0)
                return BS_HTTP_ERROR; /* TODO more checks */
        
        /* Continue receiving until EOF or all the bytes are received: */
        buf += info->content_offset;
        remaining = info->content_length - strlen(buf);
        while (remaining > 0) {
                apr_status_t rv2;
                apr_size_t len;
                char tmpbuf[HTTP_BUFFER_SIZE];
                
                /* Read from the socket and add to buffer: */
                len = (remaining > sizeof(tmpbuf) - 1) ? sizeof(tmpbuf) - 1 : remaining;
                memset(tmpbuf, '\0', sizeof(tmpbuf));
                rv2 = apr_socket_recv(sock, tmpbuf, &len);
                if (rv2 != APR_SUCCESS || len == 0) break;
                buf = apr_pstrcat(mp, buf, tmpbuf, NULL);
                remaining -= len;
        }
        
        *length = strlen(buf);
        if (*length != info->content_length) return BS_HTTP_ERROR; /* TODO maybe too strict? */

        *response_data = buf;
        return BS_OK;
}


bs_status connect_and_post(const bs_service_request *request,
                bs_service_response **response, const char *addr,
                bs_uint16 port, apr_pool_t *mp)
{
        bs_status rv;
        apr_status_t rv2;
        apr_sockaddr_t *sa;
        apr_socket_t *sock;
        char *buf, *xml, timebuf[APR_RFC822_DATE_LEN + 1];
        bs_uint64 size;
        apr_size_t size2;
        unsigned type;
        bs_service_response *resp = NULL;
        
        /* Create HTTP request in buffer: */
        rv = xlate_request_to_xml(&xml, &size, request, mp);
        if (rv != BS_OK) return rv;
        apr_rfc822_date(timebuf, apr_time_now());
        buf = apr_psprintf(mp,
                        "POST /service_request HTTP/1.0\r\n"
                        "User-Agent: " BIOSPHERE_VERSION_STRING "\r\n"
                        "Date: %s\r\n"
                        "Content-Length: %" BS_UINT64_FMT "\r\n"
                        "Content-Type: text/xml\r\n\r\n",
                        timebuf, size);
        buf = apr_pstrcat(mp, buf, xml, NULL);
        
        /* Connect to the daemon and send the data: */
        apr_sockaddr_info_get(&sa, addr, APR_INET, port, 0, mp);
        rv2 = apr_socket_create(&sock, sa->family, SOCK_STREAM, APR_PROTO_TCP, mp);
        if (rv2 != APR_SUCCESS) return BS_ERROR;
        rv2 = apr_socket_connect(sock, sa);
        if (rv2 != APR_SUCCESS) return BS_ERROR;
        size2 = strlen(buf);
        rv2 = apr_socket_send(sock, buf, &size2);
        if (rv2 != APR_SUCCESS || size == 0) return BS_ERROR;
        
        /* Wait for the response */
        rv = receive_response(sock, &buf, &size, mp);
        if (rv != BS_OK) return rv;
        rv = xlate_from_xml(buf, size, (void **) &resp, &type, mp);
        if (rv != BS_OK) return rv;
        
        apr_socket_close(sock);
        *response = resp;
        return BS_OK;   
}


bs_status connect_and_get(bs_definition **result, const char *addr,
                bs_uint16 port, apr_pool_t *mp)
{
        apr_status_t rv;
        apr_sockaddr_t *sa;
        apr_socket_t *sock;
        apr_size_t len;
        char *requestbuf, *xmlbuf, timebuf[APR_RFC822_DATE_LEN + 1];
        bs_status rv2;
        bs_uint64 size;
        unsigned type;
        bs_definition *def;
        
        /* Create a HTTP GET request for the daemon: */
        apr_rfc822_date(timebuf, apr_time_now());
        requestbuf = apr_psprintf(mp,
                        "GET /service_definitions HTTP/1.0\r\n"
                        "User-Agent: " BIOSPHERE_VERSION_STRING "\r\n"
                        "Date: %s\r\n\r\n",
                        timebuf);
        
        /* Connect to the daemon and send the data: */
        apr_sockaddr_info_get(&sa, "localhost", APR_INET, port, 0, mp);
        rv = apr_socket_create(&sock, sa->family, SOCK_STREAM, APR_PROTO_TCP, mp);
        if (rv != APR_SUCCESS) return BS_ERROR;
        rv = apr_socket_connect(sock, sa);
        if (rv != APR_SUCCESS) return BS_ERROR;
        len = strlen(requestbuf);
        rv = apr_socket_send(sock, requestbuf, &len);
        if (rv != APR_SUCCESS || len == 0) return BS_ERROR;
        
        /* Wait for the response, translate XML and close socket: */
        rv2 = receive_response(sock, &xmlbuf, &size, mp);
        if (rv2 != BS_OK) return rv;
        rv2 = xlate_from_xml(xmlbuf, size, (void **) &def, &type, mp);
        if (rv2 != BS_OK || type != SERVICE_DEF_FROM_XML) return rv;
        apr_socket_close(sock);

        *result = def;
        return BS_OK;           
}

---