static gint
rspamd_control_finish_handler (struct rspamd_http_connection *conn,
struct rspamd_http_message *msg)
{
struct ucl_parser *parser;
ucl_object_t *obj;
rspamd_fstring_t *out;
const gchar *body;
gsize body_len;
struct rspamadm_control_cbdata *cbdata = conn->ud;
body = rspamd_http_message_get_body (msg, &body_len);
parser = ucl_parser_new (0);
if (!body || !ucl_parser_add_chunk (parser, body, body_len)) {
rspamd_fprintf (stderr, "cannot parse server's reply: %s\n",
ucl_parser_get_error (parser));
ucl_parser_free (parser);
}
else {
obj = ucl_parser_get_object (parser);
out = rspamd_fstring_new ();
if (json) {
rspamd_ucl_emit_fstring (obj, UCL_EMIT_JSON, &out);
}
else if (compact) {
rspamd_ucl_emit_fstring (obj, UCL_EMIT_JSON_COMPACT, &out);
}
else {
if (strcmp (cbdata->path, "/fuzzystat") == 0) {
rspamadm_execute_lua_ucl_subr (cbdata->L,
cbdata->argc,
cbdata->argv,
obj,
rspamadm_script_fuzzy_stat);
rspamd_fstring_free (out);
ucl_object_unref (obj);
ucl_parser_free (parser);
return 0;
}
else {
rspamd_ucl_emit_fstring (obj, UCL_EMIT_CONFIG, &out);
}
}
rspamd_fprintf (stdout, "%V", out);
rspamd_fstring_free (out);
ucl_object_unref (obj);
ucl_parser_free (parser);
}
return 0;
}
static int
pkg_load_message_from_file(int fd, struct pkg *pkg, const char *path)
{
char *buf = NULL;
off_t size = 0;
int ret;
ucl_object_t *obj;
assert(pkg != NULL);
assert(path != NULL);
if (faccessat(fd, path, F_OK, 0) == 0) {
pkg_debug(1, "Reading message: '%s'", path);
if ((ret = file_to_bufferat(fd, path, &buf, &size)) != EPKG_OK) {
return (ret);
}
if (*buf == '[') {
ret = pkg_message_from_str(pkg, buf, size);
free(buf);
return (ret);
} else {
obj = ucl_object_fromstring_common(buf, size,
UCL_STRING_RAW|UCL_STRING_TRIM);
ret = pkg_message_from_ucl(pkg, obj);
ucl_object_unref(obj);
free(buf);
return (ret);
}
}
return (EPKG_FATAL);
}
static PyObject *
_internal_load_ucl (char *uclstr)
{
PyObject *ret;
struct ucl_parser *parser = ucl_parser_new (UCL_PARSER_NO_TIME);
bool r = ucl_parser_add_string(parser, uclstr, 0);
if (r) {
if (ucl_parser_get_error (parser)) {
PyErr_SetString(PyExc_ValueError, ucl_parser_get_error(parser));
ucl_parser_free(parser);
ret = NULL;
goto return_with_parser;
} else {
ucl_object_t *uclobj = ucl_parser_get_object(parser);
ret = _iterate_valid_ucl(uclobj);
ucl_object_unref(uclobj);
goto return_with_parser;
}
}
else {
PyErr_SetString(PyExc_ValueError, ucl_parser_get_error (parser));
ret = NULL;
goto return_with_parser;
}
return_with_parser:
ucl_parser_free(parser);
return ret;
}
static int
read_conf_file(const char *confpath, pkg_conf_file_t conftype)
{
struct ucl_parser *p;
ucl_object_t *obj = NULL;
p = ucl_parser_new(0);
if (!ucl_parser_add_file(p, confpath)) {
if (errno != ENOENT)
errx(EXIT_FAILURE, "Unable to parse configuration "
"file %s: %s", confpath, ucl_parser_get_error(p));
ucl_parser_free(p);
/* no configuration present */
return (1);
}
obj = ucl_parser_get_object(p);
if (obj->type != UCL_OBJECT)
warnx("Invalid configuration format, ignoring the "
"configuration file %s", confpath);
else {
if (conftype == CONFFILE_PKG)
config_parse(obj, conftype);
else if (conftype == CONFFILE_REPO)
parse_repo_file(obj);
}
ucl_object_unref(obj);
ucl_parser_free(p);
return (0);
}
void
pkg_free(struct pkg *pkg)
{
if (pkg == NULL)
return;
ucl_object_unref(pkg->fields);
for (int i = 0; i < PKG_NUM_SCRIPTS; i++)
sbuf_free(pkg->scripts[i]);
pkg_list_free(pkg, PKG_DEPS);
pkg_list_free(pkg, PKG_RDEPS);
pkg_list_free(pkg, PKG_FILES);
pkg_list_free(pkg, PKG_DIRS);
pkg_list_free(pkg, PKG_OPTIONS);
pkg_list_free(pkg, PKG_USERS);
pkg_list_free(pkg, PKG_GROUPS);
pkg_list_free(pkg, PKG_SHLIBS_REQUIRED);
pkg_list_free(pkg, PKG_SHLIBS_PROVIDED);
if (pkg->rootfd != -1)
close(pkg->rootfd);
free(pkg);
}
void
pkg_reset(struct pkg *pkg, pkg_t type)
{
int i;
if (pkg == NULL)
return;
ucl_object_unref(pkg->fields);
pkg->fields = ucl_object_typed_new(UCL_OBJECT);
pkg->flags &= ~PKG_LOAD_CATEGORIES;
pkg->flags &= ~PKG_LOAD_LICENSES;
pkg->flags &= ~PKG_LOAD_ANNOTATIONS;
for (i = 0; i < PKG_NUM_SCRIPTS; i++)
sbuf_reset(pkg->scripts[i]);
pkg_list_free(pkg, PKG_DEPS);
pkg_list_free(pkg, PKG_RDEPS);
pkg_list_free(pkg, PKG_FILES);
pkg_list_free(pkg, PKG_DIRS);
pkg_list_free(pkg, PKG_OPTIONS);
pkg_list_free(pkg, PKG_USERS);
pkg_list_free(pkg, PKG_GROUPS);
pkg_list_free(pkg, PKG_SHLIBS_REQUIRED);
pkg_list_free(pkg, PKG_SHLIBS_PROVIDED);
pkg->type = type;
}
void
cleanup()
{
if (parser != NULL) {
ucl_parser_free(parser);
}
if (setparser != NULL) {
ucl_parser_free(setparser);
}
if (root_obj != NULL) {
ucl_object_unref(root_obj);
}
if (set_obj != NULL) {
ucl_object_unref(set_obj);
}
}
static void
load_repo_file(const char *repofile, pkg_init_flags flags)
{
struct ucl_parser *p;
ucl_object_t *obj = NULL;
const char *myarch = NULL;
const char *myarch_legacy = NULL;
p = ucl_parser_new(0);
myarch = pkg_object_string(pkg_config_get("ABI"));
ucl_parser_register_variable (p, "ABI", myarch);
myarch_legacy = pkg_object_string(pkg_config_get("ALTABI"));
ucl_parser_register_variable (p, "ALTABI", myarch_legacy);
pkg_debug(1, "PKgConfig: loading %s", repofile);
if (!ucl_parser_add_file(p, repofile)) {
pkg_emit_error("Error parsing: %s: %s", repofile,
ucl_parser_get_error(p));
ucl_parser_free(p);
return;
}
obj = ucl_parser_get_object(p);
if (obj == NULL)
return;
if (obj->type == UCL_OBJECT)
walk_repo_obj(obj, repofile, flags);
ucl_object_unref(obj);
}
static gint
lua_util_config_from_ucl (lua_State *L)
{
struct rspamd_config *cfg, **pcfg;
struct rspamd_rcl_section *top;
GError *err = NULL;
ucl_object_t *obj;
obj = ucl_object_lua_import (L, 1);
if (obj) {
cfg = g_malloc0 (sizeof (struct rspamd_config));
rspamd_init_cfg (cfg, FALSE);
cfg->lua_state = L;
cfg->rcl_obj = obj;
cfg->cache = rspamd_symbols_cache_new ();
top = rspamd_rcl_config_init ();
if (!rspamd_rcl_parse (top, cfg, cfg->cfg_pool, cfg->rcl_obj, &err)) {
msg_err ("rcl parse error: %s", err->message);
ucl_object_unref (obj);
lua_pushnil (L);
}
else {
rspamd_config_post_load (cfg);
rspamd_symbols_cache_init (cfg->cache, cfg);
pcfg = lua_newuserdata (L, sizeof (struct rspamd_config *));
rspamd_lua_setclass (L, "rspamd{config}", -1);
*pcfg = cfg;
}
}
return 1;
}
static gint
lua_util_process_message (lua_State *L)
{
struct rspamd_config *cfg = lua_check_config (L, 1);
const gchar *message;
gsize mlen;
struct rspamd_task *task;
struct event_base *base;
ucl_object_t *res = NULL;
message = luaL_checklstring (L, 2, &mlen);
if (cfg != NULL && message != NULL) {
base = event_init ();
rspamd_init_filters (cfg, FALSE);
task = rspamd_task_new (NULL);
task->cfg = cfg;
task->ev_base = base;
task->msg.start = rspamd_mempool_alloc (task->task_pool, mlen + 1);
rspamd_strlcpy ((gpointer)task->msg.start, message, mlen + 1);
task->msg.len = mlen;
task->fin_callback = lua_util_task_fin;
task->fin_arg = &res;
task->resolver = dns_resolver_init (NULL, base, cfg);
task->s = rspamd_session_create (task->task_pool, rspamd_task_fin,
rspamd_task_restore, rspamd_task_free_hard, task);
if (!rspamd_task_load_message (task, NULL, message, mlen)) {
lua_pushnil (L);
}
else {
if (rspamd_task_process (task, RSPAMD_TASK_PROCESS_ALL)) {
event_base_loop (base, 0);
if (res != NULL) {
ucl_object_push_lua (L, res, true);
ucl_object_unref (res);
}
else {
ucl_object_push_lua (L, rspamd_protocol_write_ucl (task, NULL),
true);
rdns_resolver_release (task->resolver->r);
rspamd_task_free_hard (task);
}
}
else {
lua_pushnil (L);
}
}
event_base_free (base);
}
else {
lua_pushnil (L);
}
return 1;
}
/***
* @function rspamd_cryptobox_keypair.load(file)
* Loads public key from UCL file
* @param {string} file filename to load
* @return {cryptobox_keypair} new keypair
*/
static gint
lua_cryptobox_keypair_load (lua_State *L)
{
struct rspamd_cryptobox_keypair *kp, **pkp;
const gchar *filename;
struct ucl_parser *parser;
ucl_object_t *obj;
filename = luaL_checkstring (L, 1);
if (filename != NULL) {
parser = ucl_parser_new (0);
if (!ucl_parser_add_file (parser, filename)) {
msg_err ("cannot open keypair from file: %s, %s",
filename,
ucl_parser_get_error (parser));
ucl_parser_free (parser);
lua_pushnil (L);
}
else {
obj = ucl_parser_get_object (parser);
kp = rspamd_keypair_from_ucl (obj);
ucl_parser_free (parser);
if (kp == NULL) {
msg_err ("cannot open keypair from file: %s",
filename);
ucl_object_unref (obj);
lua_pushnil (L);
}
else {
pkp = lua_newuserdata (L, sizeof (gpointer));
*pkp = kp;
rspamd_lua_setclass (L, "rspamd{cryptobox_keypair}", -1);
ucl_object_unref (obj);
}
}
}
else {
return luaL_error (L, "bad input arguments");
}
return 1;
}
/***
* @function rspamd_cryptobox_keypair.create(ucl_data)
* Loads public key from UCL data
* @param {string} ucl_data ucl to load
* @return {cryptobox_keypair} new keypair
*/
static gint
lua_cryptobox_keypair_create (lua_State *L)
{
struct rspamd_cryptobox_keypair *kp, **pkp;
const gchar *buf;
gsize len;
struct ucl_parser *parser;
ucl_object_t *obj;
buf = luaL_checklstring (L, 1, &len);
if (buf != NULL) {
parser = ucl_parser_new (0);
if (!ucl_parser_add_chunk (parser, buf, len)) {
msg_err ("cannot open keypair from data: %s",
ucl_parser_get_error (parser));
ucl_parser_free (parser);
lua_pushnil (L);
}
else {
obj = ucl_parser_get_object (parser);
kp = rspamd_keypair_from_ucl (obj);
ucl_parser_free (parser);
if (kp == NULL) {
msg_err ("cannot load keypair from data");
ucl_object_unref (obj);
lua_pushnil (L);
}
else {
pkp = lua_newuserdata (L, sizeof (gpointer));
*pkp = kp;
rspamd_lua_setclass (L, "rspamd{cryptobox_keypair}", -1);
ucl_object_unref (obj);
}
}
}
else {
luaL_error (L, "bad input arguments");
}
return 1;
}
static void
rspamd_ucl_fin_cb (rspamd_mempool_t * pool, struct map_cb_data *data)
{
struct rspamd_ucl_map_cbdata *cbdata = data->cur_data, *prev =
data->prev_data;
ucl_object_t *obj;
struct ucl_parser *parser;
guint32 checksum;
ucl_object_iter_t it = NULL;
const ucl_object_t *cur;
struct rspamd_config *cfg = data->map->cfg;
if (prev != NULL) {
if (prev->buf != NULL) {
g_string_free (prev->buf, TRUE);
}
g_free (prev);
}
if (cbdata == NULL) {
msg_err_config ("map fin error: new data is NULL");
return;
}
checksum = XXH64 (cbdata->buf->str, cbdata->buf->len, 0);
if (data->map->checksum != checksum) {
/* New data available */
parser = ucl_parser_new (0);
if (!ucl_parser_add_chunk (parser, cbdata->buf->str,
cbdata->buf->len)) {
msg_err_config ("cannot parse map %s: %s",
data->map->uri,
ucl_parser_get_error (parser));
ucl_parser_free (parser);
}
else {
obj = ucl_parser_get_object (parser);
ucl_parser_free (parser);
it = NULL;
while ((cur = ucl_iterate_object (obj, &it, true))) {
ucl_object_replace_key (cbdata->cfg->rcl_obj, (ucl_object_t *)cur,
cur->key, cur->keylen, false);
}
ucl_object_unref (obj);
data->map->checksum = checksum;
}
}
else {
msg_info_config ("do not reload map %s, checksum is the same: %d",
data->map->uri,
checksum);
}
}
static void
rspamd_redis_async_cbdata_cleanup (struct rspamd_redis_stat_cbdata *cbdata)
{
guint i;
gchar *k;
if (cbdata && !cbdata->wanna_die) {
/* Avoid double frees */
cbdata->wanna_die = TRUE;
redisAsyncFree (cbdata->redis);
for (i = 0; i < cbdata->cur_keys->len; i ++) {
k = g_ptr_array_index (cbdata->cur_keys, i);
g_free (k);
}
g_ptr_array_free (cbdata->cur_keys, TRUE);
if (cbdata->elt) {
cbdata->elt->cbdata = NULL;
/* Re-enable parent event */
cbdata->elt->async->enabled = TRUE;
/* Replace ucl object */
if (cbdata->cur) {
if (cbdata->elt->stat) {
ucl_object_unref (cbdata->elt->stat);
}
cbdata->elt->stat = cbdata->cur;
cbdata->cur = NULL;
}
}
if (cbdata->cur) {
ucl_object_unref (cbdata->cur);
}
g_slice_free1 (sizeof (*cbdata), cbdata);
}
}
static void
load_repo_file(const char *repofile)
{
struct ucl_parser *p;
ucl_object_t *obj = NULL;
bool fallback = false;
const char *myarch = NULL;
p = ucl_parser_new(0);
myarch = pkg_object_string(pkg_config_get("ABI"));
ucl_parser_register_variable (p, "ABI", myarch);
pkg_debug(1, "PKgConfig: loading %s", repofile);
if (!ucl_parser_add_file(p, repofile)) {
pkg_emit_error("Error parsing: %s: %s", repofile,
ucl_parser_get_error(p));
if (errno == ENOENT) {
ucl_parser_free(p);
return;
}
fallback = true;
}
if (fallback) {
obj = yaml_to_ucl(repofile, NULL, 0);
if (obj == NULL)
return;
}
if (fallback) {
pkg_emit_error("%s file is using a deprecated format. "
"Please replace it with the following:\n"
"====== BEGIN %s ======\n"
"%s"
"\n====== END %s ======\n",
repofile, repofile,
ucl_object_emit(obj, UCL_EMIT_YAML),
repofile);
}
obj = ucl_parser_get_object(p);
if (obj->type == UCL_OBJECT)
walk_repo_obj(obj, repofile);
ucl_object_unref(obj);
}
void
pkg_shutdown(void)
{
if (!parsed) {
pkg_emit_error("pkg_shutdown() must be called after pkg_init()");
_exit(EX_SOFTWARE);
/* NOTREACHED */
}
ucl_object_unref(config);
HASH_FREE(repos, pkg_repo_free);
parsed = false;
return;
}
static PyObject *
ucl_dump (PyObject *self, PyObject *args)
{
PyObject *obj;
ucl_emitter_t emitter;
ucl_object_t *root = NULL;
emitter = UCL_EMIT_CONFIG;
if (!PyArg_ParseTuple(args, "O|i", &obj, &emitter)) {
PyErr_SetString(PyExc_TypeError, "Unhandled object type");
return NULL;
}
if (emitter >= UCL_EMIT_MAX) {
PyErr_SetString(PyExc_TypeError, "Invalid emitter type");
return NULL;
}
if (obj == Py_None) {
Py_RETURN_NONE;
}
if (!PyDict_Check(obj)) {
PyErr_SetString(PyExc_TypeError, "Argument must be dict");
return NULL;
}
root = _iterate_python(obj);
if (root) {
PyObject *ret;
char *buf;
buf = (char *) ucl_object_emit (root, emitter);
ucl_object_unref (root);
#if PY_MAJOR_VERSION < 3
ret = PyString_FromString (buf);
#else
ret = PyUnicode_FromString (buf);
#endif
free(buf);
return ret;
}
return NULL;
}
int
main(int argc, char **argv, char **envp)
{
char const *error;
ucl_object_t *obj;
ucl_object_t const *kobj;
struct ucl_parser *parser;
int status = 0;
parseopt(argc, argv);
parser = ucl_parser_new(UCL_PARSER_NO_IMPLICIT_ARRAYS | UCL_PARSER_ZEROCOPY);
if (parser == NULL) {
err(EX_OSERR, "cannot create parser");
}
addvars(parser, envp);
parse_file(parser);
if ((error = ucl_parser_get_error(parser))) {
errx(EX_DATAERR, "cannot load %s: %s", file, error);
}
obj = ucl_parser_get_object(parser);
if (key != NULL && strcmp(key, ".") != 0)
kobj = ucl_object_lookup_path(obj, key);
else
kobj = obj;
if (env) {
int nlen = 0;
char *s;
if (name != NULL)
nlen = strlcpy(envkey, name, MAX_KEY_LEN);
else if ((s = strrchr(key, '.')) != NULL)
nlen = strlcpy(envkey, s + 1, MAX_KEY_LEN);
if (kobj != NULL)
expand(nlen, kobj);
status = run(argv + cmdarg);
} else if (kobj != NULL) {
print(kobj);
}
ucl_object_unref(obj);
ucl_parser_free(parser);
exit(status);
}
int
main (int argc, char **argv)
{
char inbuf[8192], *test_in = NULL;
struct ucl_parser *parser = NULL, *parser2 = NULL;
ucl_object_t *obj;
FILE *in, *out;
unsigned char *emitted = NULL;
const char *fname_in = NULL, *fname_out = NULL;
int ret = 0, inlen, opt, json = 0, compact = 0, yaml = 0;
while ((opt = getopt(argc, argv, "jcy")) != -1) {
switch (opt) {
case 'j':
json = 1;
break;
case 'c':
compact = 1;
break;
case 'y':
yaml = 1;
break;
default: /* '?' */
fprintf (stderr, "Usage: %s [-jcy] [in] [out]\n",
argv[0]);
exit (EXIT_FAILURE);
}
}
argc -= optind;
argv += optind;
switch (argc) {
case 1:
fname_in = argv[0];
break;
case 2:
fname_in = argv[0];
fname_out = argv[1];
break;
}
if (fname_in != NULL) {
in = fopen (fname_in, "r");
if (in == NULL) {
exit (-errno);
}
}
else {
in = stdin;
}
parser = ucl_parser_new (UCL_PARSER_KEY_LOWERCASE);
ucl_parser_register_variable (parser, "ABI", "unknown");
if (fname_in != NULL) {
ucl_parser_set_filevars (parser, fname_in, true);
}
while (!feof (in)) {
memset (inbuf, 0, sizeof (inbuf));
if (fread (inbuf, 1, sizeof (inbuf) - 1, in) == 0) {
break;
}
inlen = strlen (inbuf);
test_in = malloc (inlen);
memcpy (test_in, inbuf, inlen);
ucl_parser_add_chunk (parser, test_in, inlen);
}
fclose (in);
if (fname_out != NULL) {
out = fopen (fname_out, "w");
if (out == NULL) {
exit (-errno);
}
}
else {
out = stdout;
}
if (ucl_parser_get_error (parser) != NULL) {
fprintf (out, "Error occurred: %s\n", ucl_parser_get_error(parser));
ret = 1;
goto end;
}
obj = ucl_parser_get_object (parser);
if (json) {
if (compact) {
emitted = ucl_object_emit (obj, UCL_EMIT_JSON_COMPACT);
}
else {
emitted = ucl_object_emit (obj, UCL_EMIT_JSON);
}
}
else if (yaml) {
emitted = ucl_object_emit (obj, UCL_EMIT_YAML);
}
else {
emitted = ucl_object_emit (obj, UCL_EMIT_CONFIG);
}
ucl_parser_free (parser);
ucl_object_unref (obj);
parser2 = ucl_parser_new (UCL_PARSER_KEY_LOWERCASE);
ucl_parser_add_string (parser2, emitted, 0);
if (ucl_parser_get_error(parser2) != NULL) {
fprintf (out, "Error occurred: %s\n", ucl_parser_get_error(parser2));
fprintf (out, "%s\n", emitted);
ret = 1;
goto end;
}
if (emitted != NULL) {
free (emitted);
}
obj = ucl_parser_get_object (parser2);
if (json) {
if (compact) {
emitted = ucl_object_emit (obj, UCL_EMIT_JSON_COMPACT);
}
else {
emitted = ucl_object_emit (obj, UCL_EMIT_JSON);
}
}
else if (yaml) {
emitted = ucl_object_emit (obj, UCL_EMIT_YAML);
}
else {
emitted = ucl_object_emit (obj, UCL_EMIT_CONFIG);
}
fprintf (out, "%s\n", emitted);
ucl_object_unref (obj);
end:
if (emitted != NULL) {
free (emitted);
}
if (parser2 != NULL) {
ucl_parser_free (parser2);
}
if (test_in != NULL) {
free (test_in);
}
fclose (out);
return ret;
}
static void
rspamadm_rescore (gint argc, gchar **argv) {
GOptionContext *context;
GError *error = NULL;
lua_State *L;
ucl_object_t *obj;
context = g_option_context_new (
"rescore - Estimate optimal symbol weights from log files");
g_option_context_set_summary (context,
"Summary:\n Rspamd administration utility version "
RVERSION
"\n Release id: "
RID);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
rspamd_fprintf (stderr, "option parsing failed: %s\n", error->message);
g_error_free (error);
exit (EXIT_FAILURE);
}
if (!HAS_TORCH) {
rspamd_fprintf (stderr, "Torch is not enabled. "
"Use -DENABLE_TORCH=ON option while running cmake.\n");
exit (EXIT_FAILURE);
}
if (logdir == NULL) {
rspamd_fprintf (stderr, "Please specify log directory.\n");
exit (EXIT_FAILURE);
}
L = rspamd_lua_init ();
rspamd_lua_set_path (L, NULL, NULL);
obj = ucl_object_typed_new (UCL_OBJECT);
ucl_object_insert_key (obj, ucl_object_fromstring (logdir),
"logdir", 0, false);
ucl_object_insert_key (obj, ucl_object_fromstring (output),
"output", 0, false);
ucl_object_insert_key (obj, ucl_object_fromdouble (threshold),
"threshold", 0, false);
ucl_object_insert_key (obj, ucl_object_fromint (iters),
"iters", 0, false);
ucl_object_insert_key (obj, ucl_object_frombool (score_diff),
"diff", 0, false);
rspamadm_execute_lua_ucl_subr (L,
argc,
argv,
obj,
"rescore");
lua_close (L);
ucl_object_unref (obj);
}
int
rtpp_cfile_process(struct rtpp_cfg_stable *csp)
{
struct ucl_parser *parser;
ucl_object_t *conf_root;
ucl_object_iter_t it_conf;
const ucl_object_t *obj_file;
const char *cf_key;
int fd, ecode;
ecode = 0;
fd = open(csp->cfile, O_RDONLY);
if (fd < 0) {
RTPP_ELOG(csp->glog, RTPP_LOG_ERR, "open failed: %s", csp->cfile);
ecode = -1;
goto e0;
}
parser = ucl_parser_new(UCL_PARSER_NO_FILEVARS);
if (parser == NULL) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "ucl_parser_new() failed");
ecode = -1;
goto e1;
}
ucl_parser_add_fd(parser, fd);
conf_root = ucl_parser_get_object(parser);
if (conf_root == NULL) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "ucl_parser_get_object() failed");
ecode = -1;
goto e2;
}
if (ucl_parser_get_error(parser)) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "Parse Error occured: %s", ucl_parser_get_error(parser));
ecode = -1;
goto e3;
}
it_conf = ucl_object_iterate_new(conf_root);
if (it_conf == NULL) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "ucl_object_iterate_new() failed");
ecode = -1;
goto e3;
}
while ((obj_file = ucl_object_iterate_safe(it_conf, true)) != NULL) {
cf_key = ucl_object_key(obj_file);
RTPP_LOG(csp->glog, RTPP_LOG_DBUG, "Entry: %s", cf_key);
if (strcasecmp(cf_key, "modules") == 0) {
if (parse_modules(csp, obj_file) < 0) {
RTPP_LOG(csp->glog, RTPP_LOG_ERR, "parse_modules() failed");
ecode = -1;
goto e4;
}
}
}
if (ucl_object_iter_chk_excpn(it_conf)) {
ecode = -1;
}
e4:
ucl_object_iterate_free(it_conf);
e3:
ucl_object_unref(conf_root);
e2:
ucl_parser_free(parser);
e1:
close(fd);
e0:
return (ecode);
}
int
main(int argc, char **argv)
{
const char *fn = NULL;
unsigned char *inbuf;
struct ucl_parser *parser;
int k, ret = 0, r = 0;
ssize_t bufsize;
ucl_object_t *obj = NULL;
const ucl_object_t *par;
FILE *in;
if (argc > 1) {
fn = argv[1];
}
if (fn != NULL) {
in = fopen (fn, "r");
if (in == NULL) {
exit (-errno);
}
}
else {
in = stdin;
}
parser = ucl_parser_new (0);
inbuf = malloc (BUFSIZ);
bufsize = BUFSIZ;
r = 0;
while (!feof (in) && !ferror (in)) {
if (r == bufsize) {
inbuf = realloc (inbuf, bufsize * 2);
bufsize *= 2;
if (inbuf == NULL) {
perror ("realloc");
exit (EXIT_FAILURE);
}
}
r += fread (inbuf + r, 1, bufsize - r, in);
}
if (ferror (in)) {
fprintf (stderr, "Failed to read the input file.\n");
exit (EXIT_FAILURE);
}
ucl_parser_add_chunk (parser, inbuf, r);
fclose (in);
if (ucl_parser_get_error(parser)) {
printf ("Error occured: %s\n", ucl_parser_get_error(parser));
ret = 1;
goto end;
}
obj = ucl_parser_get_object (parser);
if (ucl_parser_get_error (parser)) {
printf ("Error occured: %s\n", ucl_parser_get_error(parser));
ret = 1;
goto end;
}
if (argc > 2) {
for (k = 2; k < argc; k++) {
printf ("search for \"%s\"... ", argv[k]);
par = ucl_object_find_key (obj, argv[k]);
printf ("%sfound\n", (par == NULL )?"not ":"");
ucl_obj_dump (par, 0);
}
}
else {
ucl_obj_dump (obj, 0);
}
end:
if (parser != NULL) {
ucl_parser_free (parser);
}
if (obj != NULL) {
ucl_object_unref (obj);
}
return ret;
}
gboolean
rspamd_task_load_message (struct rspamd_task *task,
struct rspamd_http_message *msg, const gchar *start, gsize len)
{
guint control_len, r;
struct ucl_parser *parser;
ucl_object_t *control_obj;
gchar filepath[PATH_MAX], *fp;
gint fd, flen;
gpointer map;
struct stat st;
if (msg) {
rspamd_protocol_handle_headers (task, msg);
}
if (task->flags & RSPAMD_TASK_FLAG_FILE) {
g_assert (task->msg.len > 0);
r = rspamd_strlcpy (filepath, task->msg.start,
MIN (sizeof (filepath), task->msg.len + 1));
rspamd_decode_url (filepath, filepath, r + 1);
flen = strlen (filepath);
if (filepath[0] == '"' && flen > 2) {
/* We need to unquote filepath */
fp = &filepath[1];
fp[flen - 2] = '\0';
}
else {
fp = &filepath[0];
}
if (access (fp, R_OK) == -1 || stat (fp, &st) == -1) {
g_set_error (&task->err, rspamd_task_quark(), RSPAMD_PROTOCOL_ERROR,
"Invalid file (%s): %s", fp, strerror (errno));
return FALSE;
}
fd = open (fp, O_RDONLY);
if (fd == -1) {
g_set_error (&task->err, rspamd_task_quark(), RSPAMD_PROTOCOL_ERROR,
"Cannot open file (%s): %s", fp, strerror (errno));
return FALSE;
}
map = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (map == MAP_FAILED) {
close (fd);
g_set_error (&task->err, rspamd_task_quark(), RSPAMD_PROTOCOL_ERROR,
"Cannot mmap file (%s): %s", fp, strerror (errno));
return FALSE;
}
close (fd);
task->msg.start = map;
task->msg.len = st.st_size;
rspamd_mempool_add_destructor (task->task_pool, rspamd_task_unmapper, task);
}
else {
debug_task ("got input of length %z", task->msg.len);
task->msg.start = start;
task->msg.len = len;
if (task->msg.len == 0) {
msg_warn_task ("message has invalid message length: %ud",
task->msg.len);
g_set_error (&task->err, rspamd_task_quark(), RSPAMD_PROTOCOL_ERROR,
"Invalid length");
return FALSE;
}
if (task->flags & RSPAMD_TASK_FLAG_HAS_CONTROL) {
/* We have control chunk, so we need to process it separately */
if (task->msg.len < task->message_len) {
msg_warn_task ("message has invalid message length: %ud and total len: %ud",
task->message_len, task->msg.len);
g_set_error (&task->err, rspamd_task_quark(), RSPAMD_PROTOCOL_ERROR,
"Invalid length");
return FALSE;
}
control_len = task->msg.len - task->message_len;
if (control_len > 0) {
parser = ucl_parser_new (UCL_PARSER_KEY_LOWERCASE);
if (!ucl_parser_add_chunk (parser, task->msg.start, control_len)) {
msg_warn_task ("processing of control chunk failed: %s",
ucl_parser_get_error (parser));
ucl_parser_free (parser);
}
else {
control_obj = ucl_parser_get_object (parser);
ucl_parser_free (parser);
rspamd_protocol_handle_control (task, control_obj);
ucl_object_unref (control_obj);
}
task->msg.start += control_len;
task->msg.len -= control_len;
}
}
}
return TRUE;
}
void
pkg_object_free(pkg_object *o)
{
ucl_object_unref(o);
}
static void
rspamadm_statconvert (gint argc, gchar **argv)
{
GOptionContext *context;
GError *error = NULL;
lua_State *L;
ucl_object_t *obj;
context = g_option_context_new (
"statconvert - converts statistics from sqlite3 to redis");
g_option_context_set_summary (context,
"Summary:\n Rspamd administration utility version "
RVERSION
"\n Release id: "
RID);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
rspamd_fprintf (stderr, "option parsing failed: %s\n", error->message);
g_error_free (error);
exit (1);
}
if (!source_db) {
rspamd_fprintf (stderr, "source db is missing\n");
exit (1);
}
if (!redis_host) {
rspamd_fprintf (stderr, "redis host is missing\n");
exit (1);
}
if (!symbol) {
rspamd_fprintf (stderr, "symbol is missing\n");
exit (1);
}
L = rspamd_lua_init ();
obj = ucl_object_typed_new (UCL_OBJECT);
ucl_object_insert_key (obj, ucl_object_fromstring (source_db),
"source_db", 0, false);
ucl_object_insert_key (obj, ucl_object_fromstring (redis_host),
"redis_host", 0, false);
ucl_object_insert_key (obj, ucl_object_fromstring (symbol),
"symbol", 0, false);
if (cache_db != NULL) {
ucl_object_insert_key (obj, ucl_object_fromstring (cache_db),
"cache_db", 0, false);
}
rspamadm_execute_lua_ucl_subr (L,
argc,
argv,
obj,
rspamadm_script_stat_convert);
lua_close (L);
ucl_object_unref (obj);
}
int
pkg_ini(const char *path, const char *reposdir, pkg_init_flags flags)
{
struct ucl_parser *p = NULL;
size_t i;
const char *val = NULL;
const char *buf, *walk, *value, *key, *k;
const char *evkey = NULL;
const char *nsname = NULL;
const char *evpipe = NULL;
const ucl_object_t *cur, *object;
ucl_object_t *obj = NULL, *o, *ncfg;
ucl_object_iter_t it = NULL;
struct sbuf *ukey = NULL;
bool fatal_errors = false;
k = NULL;
o = NULL;
pkg_get_myarch(myabi, BUFSIZ);
pkg_get_myarch_legacy(myabi_legacy, BUFSIZ);
if (parsed != false) {
pkg_emit_error("pkg_init() must only be called once");
return (EPKG_FATAL);
}
if (((flags & PKG_INIT_FLAG_USE_IPV4) == PKG_INIT_FLAG_USE_IPV4) &&
((flags & PKG_INIT_FLAG_USE_IPV6) == PKG_INIT_FLAG_USE_IPV6)) {
pkg_emit_error("Invalid flags for pkg_init()");
return (EPKG_FATAL);
}
config = ucl_object_typed_new(UCL_OBJECT);
for (i = 0; i < c_size; i++) {
switch (c[i].type) {
case PKG_STRING:
obj = ucl_object_fromstring_common(
c[i].def != NULL ? c[i].def : "", 0, UCL_STRING_TRIM);
ucl_object_insert_key(config, obj,
c[i].key, strlen(c[i].key), false);
break;
case PKG_INT:
ucl_object_insert_key(config,
ucl_object_fromstring_common(c[i].def, 0, UCL_STRING_PARSE_INT),
c[i].key, strlen(c[i].key), false);
break;
case PKG_BOOL:
ucl_object_insert_key(config,
ucl_object_fromstring_common(c[i].def, 0, UCL_STRING_PARSE_BOOLEAN),
c[i].key, strlen(c[i].key), false);
break;
case PKG_OBJECT:
obj = ucl_object_typed_new(UCL_OBJECT);
if (c[i].def != NULL) {
walk = buf = c[i].def;
while ((buf = strchr(buf, ',')) != NULL) {
key = walk;
value = walk;
while (*value != ',') {
if (*value == '=')
break;
value++;
}
ucl_object_insert_key(obj,
ucl_object_fromstring_common(value + 1, buf - value - 1, UCL_STRING_TRIM),
key, value - key, false);
buf++;
walk = buf;
}
key = walk;
value = walk;
while (*value != ',') {
if (*value == '=')
break;
value++;
}
if (o == NULL)
o = ucl_object_typed_new(UCL_OBJECT);
ucl_object_insert_key(o,
ucl_object_fromstring_common(value + 1, strlen(value + 1), UCL_STRING_TRIM),
key, value - key, false);
}
ucl_object_insert_key(config, obj,
c[i].key, strlen(c[i].key), false);
break;
case PKG_ARRAY:
obj = ucl_object_typed_new(UCL_ARRAY);
if (c[i].def != NULL) {
walk = buf = c[i].def;
while ((buf = strchr(buf, ',')) != NULL) {
ucl_array_append(obj,
ucl_object_fromstring_common(walk, buf - walk, UCL_STRING_TRIM));
buf++;
walk = buf;
}
ucl_array_append(obj,
ucl_object_fromstring_common(walk, strlen(walk), UCL_STRING_TRIM));
}
ucl_object_insert_key(config, obj,
c[i].key, strlen(c[i].key), false);
break;
}
}
if (path == NULL)
path = PREFIX"/etc/pkg.conf";
p = ucl_parser_new(0);
errno = 0;
obj = NULL;
if (!ucl_parser_add_file(p, path)) {
if (errno != ENOENT)
pkg_emit_error("Invalid configuration file: %s", ucl_parser_get_error(p));
} else {
obj = ucl_parser_get_object(p);
}
ncfg = NULL;
while (obj != NULL && (cur = ucl_iterate_object(obj, &it, true))) {
sbuf_init(&ukey);
key = ucl_object_key(cur);
for (i = 0; key[i] != '\0'; i++)
sbuf_putc(ukey, toupper(key[i]));
sbuf_finish(ukey);
object = ucl_object_find_keyl(config, sbuf_data(ukey), sbuf_len(ukey));
if (strncasecmp(sbuf_data(ukey), "PACKAGESITE", sbuf_len(ukey))
== 0 || strncasecmp(sbuf_data(ukey), "PUBKEY",
sbuf_len(ukey)) == 0 || strncasecmp(sbuf_data(ukey),
"MIRROR_TYPE", sbuf_len(ukey)) == 0) {
pkg_emit_error("%s in pkg.conf is no longer "
"supported. Convert to the new repository style."
" See pkg.conf(5)", sbuf_data(ukey));
fatal_errors = true;
continue;
}
/* ignore unknown keys */
if (object == NULL)
continue;
if (object->type != cur->type) {
pkg_emit_error("Malformed key %s, ignoring", key);
continue;
}
if (ncfg == NULL)
ncfg = ucl_object_typed_new(UCL_OBJECT);
ucl_object_insert_key(ncfg, ucl_object_copy(cur), sbuf_data(ukey), sbuf_len(ukey), true);
}
if (fatal_errors) {
ucl_object_unref(ncfg);
ucl_parser_free(p);
return (EPKG_FATAL);
}
if (ncfg != NULL) {
it = NULL;
while (( cur = ucl_iterate_object(ncfg, &it, true))) {
key = ucl_object_key(cur);
ucl_object_replace_key(config, ucl_object_ref(cur), key, strlen(key), true);
}
ucl_object_unref(ncfg);
}
ncfg = NULL;
it = NULL;
while ((cur = ucl_iterate_object(config, &it, true))) {
o = NULL;
key = ucl_object_key(cur);
val = getenv(key);
if (val == NULL)
continue;
switch (cur->type) {
case UCL_STRING:
o = ucl_object_fromstring_common(val, 0, UCL_STRING_TRIM);
break;
case UCL_INT:
o = ucl_object_fromstring_common(val, 0, UCL_STRING_PARSE_INT);
if (o->type != UCL_INT) {
pkg_emit_error("Invalid type for environment "
"variable %s, got %s, while expecting an integer",
key, val);
ucl_object_unref(o);
continue;
}
break;
case UCL_BOOLEAN:
o = ucl_object_fromstring_common(val, 0, UCL_STRING_PARSE_BOOLEAN);
if (o->type != UCL_BOOLEAN) {
pkg_emit_error("Invalid type for environment "
"variable %s, got %s, while expecting a boolean",
key, val);
ucl_object_unref(o);
continue;
}
break;
case UCL_OBJECT:
o = ucl_object_typed_new(UCL_OBJECT);
walk = buf = val;
while ((buf = strchr(buf, ',')) != NULL) {
k = walk;
value = walk;
while (*value != ',') {
if (*value == '=')
break;
value++;
}
ucl_object_insert_key(o,
ucl_object_fromstring_common(value + 1, buf - value - 1, UCL_STRING_TRIM),
k, value - k, false);
buf++;
walk = buf;
}
key = walk;
value = walk;
while (*value != '\0') {
if (*value == '=')
break;
value++;
}
ucl_object_insert_key(o,
ucl_object_fromstring_common(value + 1, strlen(value + 1), UCL_STRING_TRIM),
k, value - k, false);
break;
case UCL_ARRAY:
o = ucl_object_typed_new(UCL_ARRAY);
walk = buf = val;
while ((buf = strchr(buf, ',')) != NULL) {
ucl_array_append(o,
ucl_object_fromstring_common(walk, buf - walk, UCL_STRING_TRIM));
buf++;
walk = buf;
}
ucl_array_append(o,
ucl_object_fromstring_common(walk, strlen(walk), UCL_STRING_TRIM));
break;
default:
/* ignore other types */
break;
}
if (o != NULL) {
if (ncfg == NULL)
ncfg = ucl_object_typed_new(UCL_OBJECT);
ucl_object_insert_key(ncfg, o, key, strlen(key), true);
}
}
if (ncfg != NULL) {
it = NULL;
while (( cur = ucl_iterate_object(ncfg, &it, true))) {
key = ucl_object_key(cur);
ucl_object_replace_key(config, ucl_object_ref(cur), key, strlen(key), true);
}
ucl_object_unref(ncfg);
}
disable_plugins_if_static();
parsed = true;
ucl_object_unref(obj);
ucl_parser_free(p);
if (strcmp(pkg_object_string(pkg_config_get("ABI")), "unknown") == 0) {
pkg_emit_error("Unable to determine ABI");
return (EPKG_FATAL);
}
pkg_debug(1, "%s", "pkg initialized");
/* Start the event pipe */
evpipe = pkg_object_string(pkg_config_get("EVENT_PIPE"));
if (evpipe != NULL)
connect_evpipe(evpipe);
debug_level = pkg_object_int(pkg_config_get("DEBUG_LEVEL"));
it = NULL;
object = ucl_object_find_key(config, "PKG_ENV");
while ((cur = ucl_iterate_object(object, &it, true))) {
evkey = ucl_object_key(cur);
pkg_debug(1, "Setting env var: %s", evkey);
if (evkey != NULL && evkey[0] != '\0')
setenv(evkey, ucl_object_tostring_forced(cur), 1);
}
/* load the repositories */
load_repositories(reposdir, flags);
setenv("HTTP_USER_AGENT", "pkg/"PKGVERSION, 1);
/* bypass resolv.conf with specified NAMESERVER if any */
nsname = pkg_object_string(pkg_config_get("NAMESERVER"));
if (nsname != NULL)
set_nameserver(ucl_object_tostring_forced(o));
return (EPKG_OK);
}
static void
rspamadm_confighelp (gint argc, gchar **argv, const struct rspamadm_command *cmd)
{
struct rspamd_config *cfg;
ucl_object_t *doc_obj;
const ucl_object_t *elt;
GOptionContext *context;
GError *error = NULL;
module_t *mod, **pmod;
worker_t **pworker;
struct module_ctx *mod_ctx;
gint i, ret = 0, processed_args = 0;
context = g_option_context_new (
"confighelp - displays help for the configuration options");
g_option_context_set_summary (context,
"Summary:\n Rspamd administration utility version "
RVERSION
"\n Release id: "
RID);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
rspamd_fprintf (stderr, "option parsing failed: %s\n", error->message);
g_error_free (error);
exit (1);
}
pworker = &workers[0];
while (*pworker) {
/* Init string quarks */
(void) g_quark_from_static_string ((*pworker)->name);
pworker++;
}
cfg = rspamd_config_new (RSPAMD_CONFIG_INIT_SKIP_LUA);
cfg->lua_state = rspamd_main->cfg->lua_state;
cfg->compiled_modules = modules;
cfg->compiled_workers = workers;
rspamd_rcl_config_init (cfg, NULL);
lua_pushboolean (cfg->lua_state, true);
lua_setglobal (cfg->lua_state, "confighelp");
rspamd_rcl_add_lua_plugins_path (cfg, plugins_path, FALSE, NULL, NULL);
/* Init modules to get documentation strings */
i = 0;
for (pmod = cfg->compiled_modules; pmod != NULL && *pmod != NULL; pmod++) {
mod = *pmod;
mod_ctx = g_malloc0 (sizeof (struct module_ctx));
if (mod->module_init_func (cfg, &mod_ctx) == 0) {
g_ptr_array_add (cfg->c_modules, mod_ctx);
mod_ctx->mod = mod;
mod->ctx_offset = i++;
mod_ctx->mod = mod;
}
}
/* Also init all workers */
for (pworker = cfg->compiled_workers; *pworker != NULL; pworker ++) {
(*pworker)->worker_init_func (cfg);
}
/* Init lua modules */
rspamd_lua_set_path (cfg->lua_state, cfg->rcl_obj, ucl_vars);
rspamd_init_lua_filters (cfg, TRUE);
if (argc > 1) {
for (i = 1; i < argc; i ++) {
if (argv[i][0] != '-') {
if (keyword) {
doc_obj = rspamadm_confighelp_search_word (cfg->doc_strings,
argv[i]);
}
else {
doc_obj = ucl_object_typed_new (UCL_OBJECT);
elt = ucl_object_lookup_path (cfg->doc_strings, argv[i]);
if (elt) {
ucl_object_insert_key (doc_obj, ucl_object_ref (elt),
argv[i], 0, false);
}
}
if (doc_obj != NULL) {
rspamadm_confighelp_show (cfg, argc, argv, argv[i], doc_obj);
ucl_object_unref (doc_obj);
}
else {
rspamd_fprintf (stderr,
"Cannot find help for %s\n",
argv[i]);
ret = EXIT_FAILURE;
}
processed_args ++;
}
}
}
if (processed_args == 0) {
/* Show all documentation strings */
rspamadm_confighelp_show (cfg, argc, argv, NULL, cfg->doc_strings);
}
rspamd_config_free (cfg);
exit (ret);
}
int
main(int argc, char **argv)
{
const char *fn = NULL;
char inbuf[8192];
struct ucl_parser *parser;
int k, ret = 0, r = 0;
ucl_object_t *obj = NULL;
const ucl_object_t *par;
FILE *in;
if (argc > 1) {
fn = argv[1];
}
if (fn != NULL) {
in = fopen (fn, "r");
if (in == NULL) {
exit (-errno);
}
}
else {
in = stdin;
}
parser = ucl_parser_new (0);
while (!feof (in) && r < (int)sizeof (inbuf)) {
r += fread (inbuf + r, 1, sizeof (inbuf) - r, in);
}
ucl_parser_add_chunk (parser, inbuf, r);
fclose (in);
if (ucl_parser_get_error(parser)) {
printf ("Error occured: %s\n", ucl_parser_get_error(parser));
ret = 1;
goto end;
}
obj = ucl_parser_get_object (parser);
if (ucl_parser_get_error (parser)) {
printf ("Error occured: %s\n", ucl_parser_get_error(parser));
ret = 1;
goto end;
}
if (argc > 2) {
for (k = 2; k < argc; k++) {
printf ("search for \"%s\"... ", argv[k]);
par = ucl_object_find_key (obj, argv[k]);
printf ("%sfound\n", (par == NULL )?"not ":"");
ucl_obj_dump (par, 0);
}
}
else {
ucl_obj_dump (obj, 0);
}
end:
if (parser != NULL) {
ucl_parser_free (parser);
}
if (obj != NULL) {
ucl_object_unref (obj);
}
return ret;
}
static void
add_repo(const ucl_object_t *obj, struct pkg_repo *r, const char *rname)
{
const ucl_object_t *cur;
ucl_object_t *tmp = NULL;
ucl_object_iter_t it = NULL;
bool enable = true;
const char *url = NULL, *pubkey = NULL, *mirror_type = NULL;
const char *signature_type = NULL, *fingerprints = NULL;
const char *key;
pkg_debug(1, "PkgConfig: parsing repository object %s", rname);
while ((cur = ucl_iterate_object(obj, &it, true))) {
key = ucl_object_key(cur);
if (key == NULL)
continue;
if (strcasecmp(key, "url") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
url = ucl_object_tostring(cur);
} else if (strcasecmp(key, "pubkey") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
pubkey = ucl_object_tostring(cur);
} else if (strcasecmp(key, "enabled") == 0) {
if (cur->type == UCL_STRING)
tmp = ucl_object_fromstring_common(ucl_object_tostring(cur),
strlen(ucl_object_tostring(cur)), UCL_STRING_PARSE_BOOLEAN);
if (cur->type != UCL_BOOLEAN && (tmp != NULL && tmp->type != UCL_BOOLEAN)) {
pkg_emit_error("Expecting a boolean for the "
"'%s' key of the '%s' repo",
key, rname);
if (tmp != NULL)
ucl_object_unref(tmp);
return;
}
if (tmp != NULL)
pkg_emit_error("Warning: expecting a boolean for the '%s' key of the '%s' repo, "
" the value has been correctly converted, please consider fixing", key, rname);
enable = ucl_object_toboolean(tmp != NULL ? tmp : cur);
if (tmp != NULL)
ucl_object_unref(tmp);
} else if (strcasecmp(key, "mirror_type") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
mirror_type = ucl_object_tostring(cur);
} else if (strcasecmp(key, "signature_type") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
signature_type = ucl_object_tostring(cur);
} else if (strcasecmp(key, "fingerprints") == 0) {
if (cur->type != UCL_STRING) {
pkg_emit_error("Expecting a string for the "
"'%s' key of the '%s' repo",
key, rname);
return;
}
fingerprints = ucl_object_tostring(cur);
}
}
if (r == NULL && url == NULL) {
pkg_debug(1, "No repo and no url for %s", rname);
return;
}
if (r == NULL)
r = pkg_repo_new(rname, url);
if (signature_type != NULL) {
if (strcasecmp(signature_type, "pubkey") == 0)
r->signature_type = SIG_PUBKEY;
else if (strcasecmp(signature_type, "fingerprints") == 0)
r->signature_type = SIG_FINGERPRINT;
else
r->signature_type = SIG_NONE;
}
if (fingerprints != NULL) {
free(r->fingerprints);
r->fingerprints = strdup(fingerprints);
}
if (pubkey != NULL) {
free(r->pubkey);
r->pubkey = strdup(pubkey);
}
r->enable = enable;
if (mirror_type != NULL) {
if (strcasecmp(mirror_type, "srv") == 0)
r->mirror_type = SRV;
else if (strcasecmp(mirror_type, "http") == 0)
r->mirror_type = HTTP;
else
r->mirror_type = NOMIRROR;
}
}
int
main (int argc, char **argv)
{
ucl_object_t *obj, *cur, *ar, *ref;
const ucl_object_t *found;
FILE *out;
unsigned char *emitted;
const char *fname_out = NULL;
int ret = 0;
switch (argc) {
case 2:
fname_out = argv[1];
break;
}
if (fname_out != NULL) {
out = fopen (fname_out, "w");
if (out == NULL) {
exit (-errno);
}
}
else {
out = stdout;
}
obj = ucl_object_typed_new (UCL_OBJECT);
/* Create some strings */
cur = ucl_object_fromstring_common (" test string ", 0, UCL_STRING_TRIM);
ucl_object_insert_key (obj, cur, "key1", 0, false);
cur = ucl_object_fromstring_common (" test \nstring\n ", 0, UCL_STRING_TRIM | UCL_STRING_ESCAPE);
ucl_object_insert_key (obj, cur, "key2", 0, false);
cur = ucl_object_fromstring_common (" test string \n", 0, 0);
ucl_object_insert_key (obj, cur, "key3", 0, false);
/* Array of numbers */
ar = ucl_object_typed_new (UCL_ARRAY);
cur = ucl_object_fromint (10);
ucl_array_append (ar, cur);
cur = ucl_object_fromdouble (10.1);
ucl_array_append (ar, cur);
cur = ucl_object_fromdouble (9.999);
ucl_array_prepend (ar, cur);
/* Removing from an array */
cur = ucl_object_fromdouble (1.0);
ucl_array_append (ar, cur);
cur = ucl_array_delete (ar, cur);
assert (ucl_object_todouble (cur) == 1.0);
ucl_object_unref (cur);
cur = ucl_object_fromdouble (2.0);
ucl_array_append (ar, cur);
cur = ucl_array_pop_last (ar);
assert (ucl_object_todouble (cur) == 2.0);
ucl_object_unref (cur);
cur = ucl_object_fromdouble (3.0);
ucl_array_prepend (ar, cur);
cur = ucl_array_pop_first (ar);
assert (ucl_object_todouble (cur) == 3.0);
ucl_object_unref (cur);
ucl_object_insert_key (obj, ar, "key4", 0, false);
cur = ucl_object_frombool (true);
/* Ref object to test refcounts */
ref = ucl_object_ref (cur);
ucl_object_insert_key (obj, cur, "key4", 0, false);
/* Empty strings */
cur = ucl_object_fromstring_common (" ", 0, UCL_STRING_TRIM);
ucl_object_insert_key (obj, cur, "key5", 0, false);
cur = ucl_object_fromstring_common ("", 0, UCL_STRING_ESCAPE);
ucl_object_insert_key (obj, cur, "key6", 0, false);
cur = ucl_object_fromstring_common (" \n", 0, UCL_STRING_ESCAPE);
ucl_object_insert_key (obj, cur, "key7", 0, false);
/* Numbers and booleans */
cur = ucl_object_fromstring_common ("1mb", 0, UCL_STRING_ESCAPE | UCL_STRING_PARSE);
ucl_object_insert_key (obj, cur, "key8", 0, false);
cur = ucl_object_fromstring_common ("3.14", 0, UCL_STRING_PARSE);
ucl_object_insert_key (obj, cur, "key9", 0, false);
cur = ucl_object_fromstring_common ("true", 0, UCL_STRING_PARSE);
ucl_object_insert_key (obj, cur, "key10", 0, false);
cur = ucl_object_fromstring_common (" off ", 0, UCL_STRING_PARSE | UCL_STRING_TRIM);
ucl_object_insert_key (obj, cur, "key11", 0, false);
cur = ucl_object_fromstring_common ("*****@*****.**", 0, UCL_STRING_PARSE_INT);
ucl_object_insert_key (obj, cur, "key12", 0, false);
cur = ucl_object_fromstring_common ("#test", 0, UCL_STRING_PARSE_INT);
ucl_object_insert_key (obj, cur, "key13", 0, false);
cur = ucl_object_frombool (true);
ucl_object_insert_key (obj, cur, "k=3", 0, false);
/* Try to find using path */
/* Should exist */
found = ucl_lookup_path (obj, "key4.1");
assert (found != NULL && ucl_object_toint (found) == 10);
/* . should be ignored */
found = ucl_lookup_path (obj, ".key4.1");
assert (found != NULL && ucl_object_toint (found) == 10);
/* moar dots... */
found = ucl_lookup_path (obj, ".key4........1...");
assert (found != NULL && ucl_object_toint (found) == 10);
/* No such index */
found = ucl_lookup_path (obj, ".key4.3");
assert (found == NULL);
/* No such key */
found = ucl_lookup_path (obj, "key9..key1");
assert (found == NULL);
emitted = ucl_object_emit (obj, UCL_EMIT_CONFIG);
fprintf (out, "%s\n", emitted);
ucl_object_unref (obj);
if (emitted != NULL) {
free (emitted);
}
fclose (out);
/* Ref should still be accessible */
ref->value.iv = 100500;
ucl_object_unref (ref);
return ret;
}
