Fork 0

170 lines
5.1 KiB

struct plugin;
typedef struct plugin plugin;
struct plugin_option;
typedef struct plugin_option plugin_option;
struct server_option;
typedef struct server_option server_option;
struct plugin_action;
typedef struct plugin_action plugin_action;
struct server_action;
typedef struct server_action server_action;
struct plugin_setup;
typedef struct plugin_setup plugin_setup;
struct server_setup;
typedef struct server_setup server_setup;
#define INIT_FUNC(x) \
LI_EXPORT void * x(server *srv, plugin *)
#define PLUGIN_DATA \
size_t id; \
ssize_t option_base_ndx
#include "base.h"
#include "options.h"
#include "actions.h"
#include "module.h"
typedef void (*PluginInit) (server *srv, plugin *p);
typedef void (*PluginFree) (server *srv, plugin *p);
typedef gboolean (*PluginParseOption) (server *srv, plugin *p, size_t ndx, value *val, option_value *oval);
typedef void (*PluginFreeOption) (server *srv, plugin *p, size_t ndx, option_value oval);
typedef action* (*PluginCreateAction) (server *srv, plugin *p, value *val);
typedef gboolean (*PluginSetup) (server *srv, plugin *p, value *val);
typedef void (*PluginHandleContent) (connection *con, plugin *p);
typedef void (*PluginHandleClose) (connection *con, plugin *p);
struct plugin {
size_t version;
const gchar *name; /**< name of the plugin */
gpointer data; /**< private plugin data */
size_t opt_base_index;
PluginFree free; /**< called before plugin is unloaded */
/** called if plugin registered as indirect handler with connection_handle_indirect(srv, con, p)
* - after response headers are created:
* connection_set_state(con, CON_STATE_HANDLE_RESPONSE_HEADER)
* - after content is generated close output queue:
* con->out->is_closed = TRUE
PluginHandleContent handle_content;
/** called for every plugin after connection got closed (response end, reset by peer, error)
* the plugins code must not depend on any order of plugins loaded
PluginHandleClose handle_close;
const plugin_option *options;
const plugin_action *actions;
const plugin_setup *setups;
struct plugin_option {
const gchar *name;
value_type type;
gpointer default_value;
PluginParseOption parse_option;
PluginFreeOption free_option;
struct plugin_action {
const gchar *name;
PluginCreateAction create_action;
struct plugin_setup {
const gchar *name;
PluginSetup setup;
/* Internal structures */
struct server_option {
plugin *p;
/** the value is freed with value_free after the parse call, so you
* probably want to extract the content via value_extract*
* val is zero to get the global default value if nothing is specified
* save result in value
* Default behaviour (NULL) is to extract the inner value from val
PluginParseOption parse_option;
/** the free_option handler has to free all allocated resources;
* it may get called with 0 initialized options, so you have to
* check the value.
PluginFreeOption free_option;
/** if parse_option is NULL, the default_value is used; it is only used
* for the following value types:
* - BOOLEAN, NUMBER: casted with GPOINTER_TO_INT, i.e. set it with GINT_TO_POINTER
* the numbers are limited to the 32-bit range according to the glib docs
* - STRING: used for g_string_new, i.e. a const char*
gpointer default_value;
size_t index, module_index;
value_type type;
struct server_action {
plugin *p;
PluginCreateAction create_action;
struct server_setup {
plugin *p;
PluginSetup setup;
/* Needed by modules to register their plugin(s) */
LI_API gboolean plugin_register(server *srv, const gchar *name, PluginInit init);
/* Internal needed functions */
LI_API void plugin_free(server *srv, plugin *p);
LI_API void server_plugins_free(server *srv);
/** free val after call (val may be modified by parser) */
LI_API gboolean parse_option(server *srv, const char *name, value *val, option_set *mark);
LI_API void release_option(server *srv, option_set *mark); /**< Does not free the option_set memory */
LI_API void plugins_prepare_callbacks(server *srv);
LI_API void plugins_handle_close(connection *con);
/* Needed for config frontends */
/** For parsing 'somemod.option = "somevalue"', free value after call */
LI_API action* option_action(server *srv, const gchar *name, value *value);
/** For parsing 'somemod.action value', e.g. 'rewrite "/url" => "/destination"'
* free value after call
LI_API action* create_action(server *srv, const gchar *name, value *value);
/** For setup function, e.g. 'listen ""'; free value after call */
LI_API gboolean call_setup(server *srv, const char *name, value *val);
LI_API void plugins_free_default_options(server *srv);
LI_API gboolean plugin_load_default_option(server *srv, server_option *sopt);
LI_API gboolean plugin_set_default_option(server *srv, const gchar* name, value *val);
/* needs connection *con and plugin *p */
#define OPTION(idx) _OPTION(con, p, idx)
#define _OPTION(con, p, idx) (con->options[p->opt_base_index + idx])
#define _OPTION_ABS(con, idx) (con->options[idx])