sol-http.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2015 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <sol-arena.h>
#include <sol-buffer.h>
#include <sol-macros.h>
#include <sol-str-slice.h>
#include <sol-vector.h>
#include <inttypes.h>

#ifdef __cplusplus
extern "C" {
#endif

enum sol_http_method {
    SOL_HTTP_METHOD_GET,
    SOL_HTTP_METHOD_POST,
    SOL_HTTP_METHOD_HEAD,
    SOL_HTTP_METHOD_DELETE,
    SOL_HTTP_METHOD_PUT,
    SOL_HTTP_METHOD_CONNECT,
    SOL_HTTP_METHOD_OPTIONS,
    SOL_HTTP_METHOD_TRACE,
    SOL_HTTP_METHOD_PATCH,
    SOL_HTTP_METHOD_INVALID
};

enum sol_http_param_type {
    SOL_HTTP_PARAM_QUERY_PARAM,
    SOL_HTTP_PARAM_COOKIE,
    SOL_HTTP_PARAM_POST_FIELD,
    SOL_HTTP_PARAM_POST_DATA,
    SOL_HTTP_PARAM_HEADER,
    SOL_HTTP_PARAM_AUTH_BASIC,
    SOL_HTTP_PARAM_ALLOW_REDIR,
    SOL_HTTP_PARAM_TIMEOUT,
    SOL_HTTP_PARAM_VERBOSE,
    SOL_HTTP_PARAM_FRAGMENT /* TODO: Should we keep this as sol_http_param_value ? */
};

enum sol_http_status_code {
    SOL_HTTP_STATUS_OK = 200,
    SOL_HTTP_STATUS_FOUND = 302,
    SOL_HTTP_STATUS_SEE_OTHER = 303,
    SOL_HTTP_STATUS_NOT_MODIFIED = 304,
    SOL_HTTP_STATUS_BAD_REQUEST = 400,
    SOL_HTTP_STATUS_FORBIDDEN = 403,
    SOL_HTTP_STATUS_NOT_FOUND = 404,
    SOL_HTTP_STATUS_METHOD_NOT_ALLOWED = 405,
    SOL_HTTP_STATUS_INTERNAL_SERVER_ERROR = 500,
    SOL_HTTP_STATUS_NOT_IMPLEMENTED = 501
};

typedef struct sol_http_params {
#ifndef SOL_NO_API_VERSION
#define SOL_HTTP_PARAM_API_VERSION (1)
    uint16_t api_version;
#endif

    struct sol_vector params; 
    struct sol_arena *arena; 
} sol_http_params;

struct sol_http_content_type_priority {
    struct sol_str_slice content_type; 
    struct sol_str_slice type; 
    struct sol_str_slice sub_type; 
    struct sol_vector tokens; 
    double qvalue; 
    uint16_t index; 
};

typedef struct sol_http_param_value {
    enum sol_http_param_type type;
    union {
        struct {
            struct sol_str_slice key;
            struct sol_str_slice value;
        } key_value;
        struct {
            struct sol_str_slice user;
            struct sol_str_slice password;
        } auth;
        struct {
            bool value;
        } boolean;
        struct {
            int32_t value;
        } integer;
        struct {
            struct sol_str_slice key;
            struct sol_str_slice value;
            struct sol_str_slice filename;
        } data;
    } value;
} sol_http_param_value;

typedef struct sol_http_response {
#ifndef SOL_NO_API_VERSION
#define SOL_HTTP_RESPONSE_API_VERSION (1)
    uint16_t api_version;
#endif

    const char *content_type;
    const char *url;
    struct sol_buffer content;
    struct sol_http_params param;
    int response_code;
} sol_http_response;

typedef struct sol_http_url {
    struct sol_str_slice scheme;
    struct sol_str_slice user;
    struct sol_str_slice password;
    struct sol_str_slice host;
    struct sol_str_slice path;
    struct sol_str_slice query;
    struct sol_str_slice fragment;
    uint32_t port; 
} sol_http_url;

#ifndef SOL_NO_API_VERSION

#define SOL_HTTP_RESPONSE_CHECK_API_VERSION(response_, ...) \
    if (SOL_UNLIKELY((response_)->api_version != \
        SOL_HTTP_RESPONSE_API_VERSION)) { \
        SOL_ERR("Unexpected API version (response is %" PRIu16 ", expected %" PRIu16 ")", \
            (response_)->api_version, SOL_HTTP_RESPONSE_API_VERSION); \
        return __VA_ARGS__; \
    }
#else
#define SOL_HTTP_RESPONSE_CHECK_API_VERSION(response_, ...)
#endif

#define SOL_HTTP_RESPONSE_CHECK_API(response_, ...) \
    do { \
        if (SOL_UNLIKELY(!(response_))) { \
            SOL_WRN("Error while reaching service."); \
            return __VA_ARGS__; \
        } \
        SOL_HTTP_RESPONSE_CHECK_API_VERSION((response_), __VA_ARGS__) \
    } while (0)

#ifndef SOL_NO_API_VERSION

#define SOL_HTTP_RESPONSE_CHECK_API_VERSION_GOTO(response_, label) \
    if (SOL_UNLIKELY((response_)->api_version != \
        SOL_HTTP_RESPONSE_API_VERSION)) { \
        SOL_ERR("Unexpected API version (response is %" PRIu16 ", expected %" PRIu16 ")", \
            (response_)->api_version, SOL_HTTP_RESPONSE_API_VERSION); \
        goto label; \
    }
#else
#define SOL_HTTP_RESPONSE_CHECK_API_VERSION_GOTO(response_, label)
#endif

#define SOL_HTTP_RESPONSE_CHECK_API_GOTO(response_, label) \
    do { \
        if (SOL_UNLIKELY(!(response_))) { \
            SOL_WRN("Error while reaching service."); \
            goto label; \
        } \
        SOL_HTTP_RESPONSE_CHECK_API_VERSION_GOTO((response_), label) \
    } while (0)

#define SOL_HTTP_REQUEST_PARAMS_INIT \
    (struct sol_http_params) { \
        SOL_SET_API_VERSION(.api_version = SOL_HTTP_PARAM_API_VERSION, ) \
        .params = SOL_VECTOR_INIT(struct sol_http_param_value), \
        .arena = NULL \
    }

#ifndef SOL_NO_API_VERSION

#define SOL_HTTP_PARAMS_CHECK_API_VERSION(params_, ...) \
    if (SOL_UNLIKELY((params_)->api_version != \
        SOL_HTTP_PARAM_API_VERSION)) { \
        SOL_ERR("Unexpected API version (response is %" PRIu16 ", expected %" PRIu16 ")", \
            (params_)->api_version, SOL_HTTP_PARAM_API_VERSION); \
        return __VA_ARGS__; \
    }
#else
#define SOL_HTTP_PARAMS_CHECK_API_VERSION(params_, ...)
#endif

#ifndef SOL_NO_API_VERSION

#define SOL_HTTP_PARAMS_CHECK_API_VERSION_GOTO(params_, label_) \
    if (SOL_UNLIKELY((params_)->api_version != \
        SOL_HTTP_PARAM_API_VERSION)) { \
        SOL_ERR("Unexpected API version (params is %" PRIu16 ", expected %" PRIu16 ")", \
            (params_)->api_version, SOL_HTTP_PARAM_API_VERSION); \
        goto label_; \
    }
#else
#define SOL_HTTP_PARAMS_CHECK_API_VERSION_GOTO(params_, label_)
#endif

#define SOL_HTTP_REQUEST_PARAM_KEY_VALUE(type_, key_, value_) \
    (struct sol_http_param_value) { \
        .type = type_, \
        .value = { \
            .key_value = { \
                .key = sol_str_slice_from_str((key_ ? : "")), \
                .value = sol_str_slice_from_str((value_ ? : "")) \
            } \
        } \
    }

#define SOL_HTTP_REQUEST_PARAM_BOOL(type_, setting_) \
    (struct sol_http_param_value) { \
        .type = type_, \
        .value = { .boolean = { .value = (setting_) } } \
    }

#define SOL_HTTP_REQUEST_PARAM_COOKIE(key_, value_) \
    SOL_HTTP_REQUEST_PARAM_KEY_VALUE(SOL_HTTP_PARAM_COOKIE, key_, value_)

#define SOL_HTTP_REQUEST_PARAM_HEADER(header_, content_) \
    SOL_HTTP_REQUEST_PARAM_KEY_VALUE(SOL_HTTP_PARAM_HEADER, header_, content_)

#define SOL_HTTP_REQUEST_PARAM_AUTH_BASIC(username_, password_) \
    (struct sol_http_param_value) { \
        .type = SOL_HTTP_PARAM_AUTH_BASIC, \
        .value = { \
            .auth = { \
                .user = sol_str_slice_from_str((username_ ? : "")), \
                .password = sol_str_slice_from_str((password_ ? : "")) \
            } \
        } \
    }

#define SOL_HTTP_REQUEST_PARAM_QUERY(key_, value_) \
    SOL_HTTP_REQUEST_PARAM_KEY_VALUE(SOL_HTTP_PARAM_QUERY_PARAM, key_, value_)

#define SOL_HTTP_REQUEST_PARAM_POST_FIELD(key_, value_) \
    SOL_HTTP_REQUEST_PARAM_KEY_VALUE(SOL_HTTP_PARAM_POST_FIELD, key_, value_)

#define SOL_HTTP_REQUEST_PARAM_ALLOW_REDIR(setting_) \
    SOL_HTTP_REQUEST_PARAM_BOOL(SOL_HTTP_PARAM_ALLOW_REDIR, setting_)

#define SOL_HTTP_REQUEST_PARAM_VERBOSE(setting_) \
    SOL_HTTP_REQUEST_PARAM_BOOL(SOL_HTTP_PARAM_VERBOSE, setting_)

#define SOL_HTTP_REQUEST_PARAM_TIMEOUT(setting_) \
    (struct sol_http_param_value) { \
        .type = SOL_HTTP_PARAM_TIMEOUT, \
        .value = { \
            .integer = { .value = (setting_) } \
        } \
    }


#define SOL_HTTP_REQUEST_PARAM_POST_DATA_FILE(key_, filename_) \
    (struct sol_http_param_value) { \
        .type = SOL_HTTP_PARAM_POST_DATA, \
        .value = { \
            .data = { \
                .key = sol_str_slice_from_str((key_ ? : "")), \
                .value = SOL_STR_SLICE_EMPTY, \
                .filename = sol_str_slice_from_str((filename_ ? : "")) \
            } \
        } \
    }

#define SOL_HTTP_REQUEST_PARAM_POST_DATA_CONTENTS(key_, value_) \
    (struct sol_http_param_value) { \
        .type = SOL_HTTP_PARAM_POST_DATA, \
        .value = { \
            .data = { \
                .key = sol_str_slice_from_str((key_ ? : "")), \
                .value = (value_), \
                .filename = SOL_STR_SLICE_EMPTY, \
            } \
        } \
    }

#define SOL_HTTP_PARAMS_FOREACH_IDX(param, itrvar, idx) \
    for (idx = 0; \
        param && idx < (param)->params.len && (itrvar = (struct sol_http_param_value *)sol_vector_get(&(param)->params, idx), true); \
        idx++)

static inline void
sol_http_params_init(struct sol_http_params *params)
{
    sol_vector_init(&params->params, sizeof(struct sol_http_param_value));
    params->arena = NULL;
    SOL_SET_API_VERSION(params->api_version = SOL_HTTP_PARAM_API_VERSION; )
}

int sol_http_params_add(struct sol_http_params *params,
    struct sol_http_param_value value)
#ifndef DOXYGEN_RUN
    SOL_ATTR_WARN_UNUSED_RESULT
#endif
    ;

int sol_http_params_add_copy(struct sol_http_params *params, struct sol_http_param_value value);

void sol_http_params_clear(struct sol_http_params *params);

int sol_http_encode_slice(struct sol_buffer *buf, const struct sol_str_slice value);

int sol_http_decode_slice(struct sol_buffer *buf, const struct sol_str_slice value);

int sol_http_create_full_uri(struct sol_buffer *buf, const struct sol_http_url url, const struct sol_http_params *params);

int sol_http_create_uri(struct sol_buffer *buf, const struct sol_str_slice base_uri, const struct sol_http_params *params);

int sol_http_encode_params(struct sol_buffer *buf, enum sol_http_param_type type, const struct sol_http_params *params);

int sol_http_decode_params(const struct sol_str_slice params_slice, enum sol_http_param_type type, struct sol_http_params *params);

int sol_http_split_uri(const struct sol_str_slice full_uri, struct sol_http_url *url);

static inline int
sol_http_create_uri_from_str(struct sol_buffer *buf, const char *base_url, const struct sol_http_params *params)
{
    return sol_http_create_uri(buf, sol_str_slice_from_str(base_url ? base_url : ""), params);
}

int sol_http_split_query(const char *query, struct sol_http_params *params);

int sol_http_split_post_field(const char *query, struct sol_http_params *params);

int sol_http_parse_content_type_priorities(const struct sol_str_slice content_type, struct sol_vector *priorities);

void sol_http_content_type_priorities_array_clear(struct sol_vector *priorities);

#ifdef __cplusplus
}
#endif