httpopt.c

Go to the documentation of this file.

/*
 * Copyright (C) 2008 by egnite GmbH. All rights reserved.
 * Copyright (C) 2001-2007 by egnite Software GmbH. 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. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``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
 * COPYRIGHT OWNER 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.
 *
 * For additional information see http://www.ethernut.de/
 */

#include <cfg/arch.h>

#include <string.h>
#include <io.h>
#include <fcntl.h>
#include <ctype.h>
#include <stdlib.h>
#include <memdebug.h>

#include <sys/heap.h>
#include <sys/version.h>

#include "dencode.h"

#include <pro/httpd.h>


extern MIMETYPES mimeTypes[];
extern char *http_root;

uint8_t NutSetMimeHandler(char *extension, void (*handler)(FILE *stream, int fd, int file_len, char *http_root, REQUEST *req))
{
    size_t i;

    if (extension == NULL)
        return 1;
    for (i = 0; mimeTypes[i].mtyp_ext; i++)
        if (strcasecmp(extension, mimeTypes[i].mtyp_ext) == 0) {
            mimeTypes[i].mtyp_handler = handler;
            return 0;
        }
    return 1;
}

char *NutHttpURLEncode(char *str)
{
    static char *hexdigits = "0123456789ABCDEF";
    register char *ptr1, *ptr2;
    char *encstring;
    int numEncs = 0;

    if (!str)
        return NULL;

    /* Calculate how many characters we need to encode */
    for (ptr1 = str; *ptr1; ptr1++) {
        if (!isalnum((unsigned char)*ptr1) || *ptr1 == '%' || *ptr1 == '&'|| *ptr1 == '+' ||
                *ptr1 == ',' || *ptr1 == ':' || *ptr1 == ';'|| *ptr1 == '='|| *ptr1 == '?'|| *ptr1 == '@')
            numEncs++;
    }
    /* Now we can calculate the encoded string length */
    encstring = (char *) malloc(strlen(str) + 2 * numEncs + 1);
    if (encstring) {
        /* Encode the string. ptr1 refers to the original string,
         * and ptr2 refers to the new string. */
        ptr2 = encstring;
        for (ptr1 = str; *ptr1; ptr1++) {
                    if (isalnum((unsigned char)*ptr1) || *ptr1 == '%' || *ptr1 == '&'|| *ptr1 == '+' ||
                    *ptr1 == ',' || *ptr1 == ':' || *ptr1 == ';'|| *ptr1 == '='|| *ptr1 == '?'|| *ptr1 == '@')
                *ptr2++ = *ptr1;
            else {
                *ptr2++ = '%';
                *ptr2++ = hexdigits[(*ptr1 >> 4)];
                *ptr2++ = hexdigits[*ptr1 & 0x0F];
            }
        }
        *ptr2++ = 0;
    }
    return encstring;
}

void NutHttpProcessPostQuery(FILE *stream, REQUEST * req)
{
    int got;
    register int i;
    register char *ptr;

    if (req->req_query != NULL)
        return;

    if (!stream)
        return;

    if (req->req_method == METHOD_POST) {
        req->req_query = malloc(req->req_length+1);
        if (req->req_query == NULL) {
            /* Out of memory */
            req->req_numqptrs = 0;
            return;
        }
        memset(req->req_query, 0, req->req_length+1);
        i = 0;
        while (i < req->req_length) {
            got = fread(&req->req_query[i], 1, req->req_length-i, stream);
            if (got <= 0) {
                free(req->req_query);
                req->req_numqptrs = 0;
                req->req_query = NULL;
                return;
            }
            i += got;
        }
    } else return;

    req->req_numqptrs = 1;
    for (ptr = req->req_query; *ptr; ptr++)
        if (*ptr == '&')
            req->req_numqptrs++;

    req->req_qptrs = (char **) malloc(sizeof(char *) * (req->req_numqptrs * 2));
    if (!req->req_qptrs) {
        /* Out of memory */
        free(req->req_query);
        req->req_numqptrs = 0;
        req->req_query = NULL;
        return;
    }
    req->req_qptrs[0] = req->req_query;
    req->req_qptrs[1] = 0;
    for (ptr = req->req_query, i = 2; *ptr; ptr++) {
        if (*ptr == '&') {
            req->req_qptrs[i] = ptr + 1;
            req->req_qptrs[i + 1] = NULL;
            *ptr = 0;
            i += 2;
        }
    }

    for (i = 0; i < req->req_numqptrs; i++) {
        for (ptr = req->req_qptrs[i * 2]; *ptr; ptr++) {
            if (*ptr == '=') {
                req->req_qptrs[i * 2 + 1] = ptr + 1;
                *ptr = 0;
                NutHttpURLDecode(req->req_qptrs[i * 2 + 1]);
                break;
            }
        }
        NutHttpURLDecode(req->req_qptrs[i * 2]);
    }
}

char *NutHttpGetParameter(REQUEST * req, char *name)
{
    int i;
    for (i = 0; i < req->req_numqptrs; i++)
        if (strcmp(req->req_qptrs[i * 2], name) == 0)
            return req->req_qptrs[i * 2 + 1];
    return NULL;
}

int NutHttpGetParameterCount(REQUEST * req)
{
    return req->req_numqptrs;
}

char *NutHttpGetParameterName(REQUEST * req, int index)
{
    if (index < 0 || index >= NutHttpGetParameterCount(req))
        return NULL;
    return req->req_qptrs[index * 2];
}

char *NutHttpGetParameterValue(REQUEST * req, int index)
{
    if (index < 0 || index >= NutHttpGetParameterCount(req))
        return NULL;
    return req->req_qptrs[index * 2 + 1];
}