balde.h

Go to the documentation of this file.

/*
 * balde: A microframework for C based on GLib and bad intentions.
 * Copyright (C) 2013-2017 Rafael G. Martins <rafael@rafaelmartins.eng.br>
 *
 * This program can be distributed under the terms of the LGPL-2 License.
 * See the file COPYING.
 */

#ifndef _BALDE_H
#define _BALDE_H

#include <glib.h>
#include <gio/gio.h>
#ifdef WITH_UNIX_SOCKETS
#include <gio/gunixsocketaddress.h>
#endif


#define BALDE_LOG_DOMAIN "balde"

#define balde_log_critical(...)                                               \
    g_log(BALDE_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, __VA_ARGS__)

#define balde_log_warning(...)                                                \
    g_log(BALDE_LOG_DOMAIN, G_LOG_LEVEL_WARNING, __VA_ARGS__)

#define balde_log_message(...)                                                \
    g_log(BALDE_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, __VA_ARGS__)

#define balde_log_info(...)                                                   \
    g_log(BALDE_LOG_DOMAIN, G_LOG_LEVEL_INFO, __VA_ARGS__)

#define balde_log_debug(...)                                                  \
    g_log(BALDE_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, __VA_ARGS__)


typedef enum {
    BALDE_HTTP_NONE    = 0,
    BALDE_HTTP_OPTIONS = 1 << 0,
    BALDE_HTTP_GET     = 1 << 1,
    BALDE_HTTP_HEAD    = 1 << 2,
    BALDE_HTTP_POST    = 1 << 3,
    BALDE_HTTP_PUT     = 1 << 4,
    BALDE_HTTP_PATCH   = 1 << 5,
    BALDE_HTTP_DELETE  = 1 << 6,
    BALDE_HTTP_ANY     = 0xFF,
} balde_http_method_t;


typedef enum {
    BALDE_HTTP_OK                              = 200,
    BALDE_HTTP_MULTIPLE_CHOICES                = 300,
    BALDE_HTTP_MOVED_PERMANENTLY               = 301,
    BALDE_HTTP_FOUND                           = 302,
    BALDE_HTTP_SEE_OTHER                       = 303,
    BALDE_HTTP_NOT_MODIFIED                    = 304,
    BALDE_HTTP_USE_PROXY                       = 305,
    BALDE_HTTP_TEMPORARY_REDIRECT              = 307,
    BALDE_HTTP_BAD_REQUEST                     = 400,
    BALDE_HTTP_UNAUTHORIZED                    = 401,
    BALDE_HTTP_FORBIDDEN                       = 403,
    BALDE_HTTP_NOT_FOUND                       = 404,
    BALDE_HTTP_METHOD_NOT_ALLOWED              = 405,
    BALDE_HTTP_NOT_ACCEPTABLE                  = 406,
    BALDE_HTTP_REQUEST_TIMEOUT                 = 408,
    BALDE_HTTP_CONFLICT                        = 409,
    BALDE_HTTP_GONE                            = 410,
    BALDE_HTTP_LENGTH_REQUIRED                 = 411,
    BALDE_HTTP_PRECONDITION_FAILED             = 412,
    BALDE_HTTP_REQUEST_ENTITY_TOO_LARGE        = 413,
    BALDE_HTTP_REQUEST_URI_TOO_LONG            = 414,
    BALDE_HTTP_UNSUPPORTED_MEDIA_TYPE          = 415,
    BALDE_HTTP_REQUESTED_RANGE_NOT_SATISFIABLE = 416,
    BALDE_HTTP_EXPECTATION_FAILED              = 417,
    BALDE_HTTP_I_M_A_TEAPOT                    = 418,
    BALDE_HTTP_UNPROCESSABLE_ENTITY            = 422,
    BALDE_HTTP_PRECONDITION_REQUIRED           = 428,
    BALDE_HTTP_TOO_MANY_REQUESTS               = 429,
    BALDE_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
    BALDE_HTTP_INTERNAL_SERVER_ERROR           = 500,
    BALDE_HTTP_NOT_IMPLEMENTED                 = 501,
    BALDE_HTTP_BAD_GATEWAY                     = 502,
    BALDE_HTTP_SERVICE_UNAVAILABLE             = 503,
} balde_http_exception_code_t;


typedef struct {

    GError *error;

    struct _balde_app_private_t *priv;

    gboolean copy;

} balde_app_t;


typedef struct {

    const gchar* username;

    const gchar* password;

    // FIXME: Add HTTP digest support

} balde_authorization_t;


typedef struct {

    const gchar *name;

    const gchar *type;

    GString *content;

} balde_file_t;


typedef struct {

    balde_authorization_t *authorization;

    const gchar *server_name;

    const gchar *script_name;

    const gchar *path;

    balde_http_method_t method;

    gboolean https;

    struct _balde_request_private_t *priv;

} balde_request_t;


typedef struct {

    balde_http_exception_code_t status_code;

    struct _balde_response_private_t *priv;

} balde_response_t;


typedef balde_response_t* (*balde_view_func_t) (balde_app_t*, balde_request_t*);

typedef void (*balde_before_request_func_t) (balde_app_t*, balde_request_t*);

balde_app_t* balde_app_init(void);


void balde_app_set_config(balde_app_t *app, const gchar *name, const gchar *value);


void balde_app_set_config_from_envvar(balde_app_t *app, const gchar *name,
    const gchar *env_name, gboolean silent);


const gchar* balde_app_get_config(balde_app_t *app, const gchar *name);


void balde_app_set_user_data(balde_app_t *app, gpointer user_data);


gpointer balde_app_get_user_data(balde_app_t *app);


void balde_app_set_user_data_destroy_func(balde_app_t *app,
    GDestroyNotify destroy_func);


void balde_app_free_user_data(balde_app_t *app);


void balde_app_free(balde_app_t *app);


void balde_app_add_url_rule(balde_app_t *app, const gchar *endpoint,
    const gchar *rule, const balde_http_method_t method,
    balde_view_func_t view_func);


void balde_app_add_before_request(balde_app_t *app,
    balde_before_request_func_t hook_func);


gchar* balde_app_url_for(balde_app_t *app, balde_request_t *request,
    const gchar *endpoint, gboolean external, ...);


void balde_app_run(balde_app_t *app, gint argc, gchar **argv);


void balde_response_set_header(balde_response_t *response, const gchar *name,
    const gchar *value);

void balde_response_set_etag_header(balde_response_t *response,
    gboolean weak);

void balde_response_etag_matching(balde_request_t *request,
    balde_response_t *response);

void balde_response_append_body(balde_response_t *response,
    const gchar *content);


void balde_response_append_body_len(balde_response_t *response,
    const gchar *content, const gssize len);


void balde_response_truncate_body(balde_response_t *response);


balde_response_t* balde_make_response(const gchar *content);


balde_response_t* balde_make_response_len(const gchar *content, const gssize len);


void balde_response_set_tmpl_var(balde_response_t *response, const gchar* name,
    const gchar* value);


const gchar* balde_response_get_tmpl_var(balde_response_t *response,
    const gchar* name);


const gchar* balde_response_get_tmpl_var_or_empty(balde_response_t *response,
    const gchar *name);


void balde_response_set_cookie(balde_response_t *response, const gchar *name,
    const gchar *value, const gint max_age, const gint64 expires,
    const gchar *path, const gchar *domain, const gboolean secure,
    const gboolean http_only);


void balde_response_delete_cookie(balde_response_t *response, const gchar *name,
    const gchar *path, const gchar *domain);


const gchar* balde_request_get_header(balde_request_t *request,
    const gchar *name);


const gchar* balde_request_get_arg(balde_request_t *request, const gchar *name);


const gchar* balde_request_get_form(balde_request_t *request, const gchar *name);


const balde_file_t* balde_request_get_file(balde_request_t *request, const gchar *name);


const gchar* balde_request_get_view_arg(balde_request_t *request,
    const gchar *name);


const gchar* balde_request_get_cookie(balde_request_t *request, const gchar *name);


const GString* balde_request_get_body(balde_request_t *request);


gchar* balde_file_save_to_disk(const balde_file_t *file, const gchar *destdir,
    const gchar *name);


void balde_abort_set_error(balde_app_t *app,
    const balde_http_exception_code_t code);


void balde_abort_set_error_with_description(balde_app_t *app,
    const balde_http_exception_code_t code, const gchar* description);


balde_response_t* balde_abort(balde_app_t *app,
    const balde_http_exception_code_t code);


balde_response_t* balde_abort_with_description(balde_app_t *app,
    const balde_http_exception_code_t code, const gchar *description);


void balde_session_open(balde_app_t *app, balde_request_t *request);


void balde_session_save(balde_request_t *request, balde_response_t *response);


const gchar* balde_session_get(balde_request_t *request, const gchar *key);


void balde_session_set(balde_request_t *request, const gchar *key, const gchar *value);


void balde_session_delete(balde_request_t *request, const gchar *key);


void balde_resources_load(balde_app_t *app, GResource *resources);


gchar* balde_tmpl_url_for(balde_app_t *app, balde_request_t *request,
    const gchar *endpoint, gboolean external, ...);

#endif /* _BALDE_H */