rspamd_client_destroy (conn);
g_free (cbdata->filename);
- g_slice_free1 (sizeof (struct rspamc_callback_data), cbdata);
+ g_free (cbdata);
}
static void
conn = rspamd_client_init (ev_base, hostbuf, port, timeout, key);
if (conn != NULL) {
- cbdata = g_slice_alloc (sizeof (struct rspamc_callback_data));
+ cbdata = g_malloc0 (sizeof (struct rspamc_callback_data));
cbdata->cmd = cmd;
cbdata->filename = g_strdup (name);
g_string_free (req->input, TRUE);
}
- g_slice_free1 (sizeof (*req), req);
+ g_free (req);
}
}
return NULL;
}
- conn = g_slice_alloc0 (sizeof (struct rspamd_client_connection));
+ conn = g_malloc0 (sizeof (struct rspamd_client_connection));
conn->ev_base = ev_base;
conn->fd = fd;
conn->req_sent = FALSE;
void *dict = NULL;
ZSTD_CCtx *zctx;
- req = g_slice_alloc0 (sizeof (struct rspamd_client_request));
+ req = g_malloc0 (sizeof (struct rspamd_client_request));
req->conn = conn;
req->cb = cb;
req->ud = ud;
if (ferror (in) != 0) {
g_set_error (err, RCLIENT_ERROR, ferror (
in), "input IO error: %s", strerror (ferror (in)));
- g_slice_free1 (sizeof (struct rspamd_client_request), req);
+ g_free (req);
g_string_free (input, TRUE);
return FALSE;
}
"cannot open dictionary %s: %s",
comp_dictionary,
strerror (errno));
- g_slice_free1 (sizeof (struct rspamd_client_request), req);
+ g_free (req);
g_string_free (input, TRUE);
return FALSE;
"cannot open dictionary %s: %s",
comp_dictionary,
strerror (errno));
- g_slice_free1 (sizeof (struct rspamd_client_request), req);
+ g_free (req);
g_string_free (input, TRUE);
munmap (dict, dict_len);
if (ZSTD_isError (body->len)) {
g_set_error (err, RCLIENT_ERROR, ferror (
in), "compression error");
- g_slice_free1 (sizeof (struct rspamd_client_request), req);
+ g_free (req);
g_string_free (input, TRUE);
rspamd_fstring_free (body);
ZSTD_freeCCtx (zctx);
rspamd_keypair_unref (conn->keypair);
}
g_string_free (conn->server_name, TRUE);
- g_slice_free1 (sizeof (struct rspamd_client_connection), conn);
+ g_free (conn);
}
}
size);
}
- new_file = g_slice_alloc0 (sizeof (rspamd_mmaped_file_t));
+ new_file = g_malloc0 (sizeof (rspamd_mmaped_file_t));
if ((new_file->fd = open (filename, O_RDWR)) == -1) {
msg_info_pool ("cannot open file %s, error %d, %s",
filename,
errno,
strerror (errno));
- g_slice_free1 (sizeof (*new_file), new_file);
+ g_free (new_file);
return NULL;
}
filename,
errno,
strerror (errno));
- g_slice_free1 (sizeof (*new_file), new_file);
+ g_free (new_file);
return NULL;
}
filename,
errno,
strerror (errno));
- g_slice_free1 (sizeof (*new_file), new_file);
+ g_free (new_file);
return NULL;
}
close (new_file->fd);
rspamd_file_unlock (new_file->fd, FALSE);
munmap (new_file->map, st.st_size);
- g_slice_free1 (sizeof (*new_file), new_file);
+ g_free (new_file);
return NULL;
}
close (file->fd);
}
- g_slice_free1 (sizeof (*file), file);
+ g_free (file);
return 0;
}
.tv_nsec = 1000000
};
- bk = g_slice_alloc0 (sizeof (*bk));
+ bk = g_malloc0 (sizeof (*bk));
bk->sqlite = rspamd_sqlite3_open_or_create (pool, path, create_tables_sql,
0, err);
bk->pool = pool;
if (bk->sqlite == NULL) {
- g_slice_free1 (sizeof (*bk), bk);
+ g_free (bk);
return NULL;
}
if (bk->prstmt == NULL) {
sqlite3_close (bk->sqlite);
- g_slice_free1 (sizeof (*bk), bk);
+ g_free (bk);
return NULL;
}
msg_err_pool ("failed to stard transaction: %d, %s", ret,
sqlite3_errmsg (bk->sqlite));
sqlite3_close (bk->sqlite);
- g_slice_free1 (sizeof (*bk), bk);
+ g_free (bk);
return NULL;
}
(gint64)strlen (tok_conf_encoded),
tok_conf_encoded) != SQLITE_OK) {
sqlite3_close (bk->sqlite);
- g_slice_free1 (sizeof (*bk), bk);
+ g_free (bk);
g_free (tok_conf_encoded);
return NULL;
rspamd_sqlite3_close_prstmt (bk->sqlite, bk->prstmt);
sqlite3_close (bk->sqlite);
g_free (bk->fname);
- g_slice_free1 (sizeof (*bk), bk);
+ g_free (bk);
}
}
const ucl_object_t *obj;
gboolean ret = FALSE;
- cache_ctx = g_slice_alloc0 (sizeof (*cache_ctx));
+ cache_ctx = g_malloc0 (sizeof (*cache_ctx));
/* First search in backend configuration */
obj = ucl_object_lookup (st->classifier->cfg->opts, "backend");
if (!ret) {
msg_err_config ("cannot init redis cache for %s", stf->symbol);
- g_slice_free1 (sizeof (*cache_ctx), cache_ctx);
+ g_free (cache_ctx);
return NULL;
}
err = NULL;
}
else {
- new = g_slice_alloc (sizeof (*new));
+ new = g_malloc0 (sizeof (*new));
new->db = sqlite;
new->prstmt = rspamd_sqlite3_init_prstmt (sqlite, prepared_stmts,
RSPAMD_STAT_CACHE_MAX, &err);
g_error_free (err);
err = NULL;
sqlite3_close (sqlite);
- g_slice_free1 (sizeof (*new), new);
+ g_free (new);
new = NULL;
}
}
if (ctx != NULL) {
rspamd_sqlite3_close_prstmt (ctx->db, ctx->prstmt);
sqlite3_close (ctx->db);
- g_slice_free1 (sizeof (*ctx), ctx);
+ g_free (ctx);
}
}
* | len | allocated | <data> -- fstring_t
* <begin> -- tok
*
- * tok is expected to be allocated with g_slice_alloc
+ * tok is expected to be allocated with g_malloc
*/
void rspamd_fstring_mapped_ftok_free (gpointer p);
/**
- * Map token to a specified string. Token must be freed using g_slice_free1
+ * Map token to a specified string. Token must be freed using g_free
*/
rspamd_ftok_t *rspamd_ftok_map (const rspamd_fstring_t *s);
/* Init modules to get documentation strings */
for (pmod = cfg->compiled_modules; pmod != NULL && *pmod != NULL; pmod++) {
mod = *pmod;
- mod_ctx = g_slice_alloc0 (sizeof (struct module_ctx));
+ mod_ctx = g_malloc0 (sizeof (struct module_ctx));
if (mod->module_init_func (cfg, &mod_ctx) == 0) {
g_hash_table_insert (cfg->c_modules,
* local one then we replace dest value with the src value
*/
if (src_value > value && src_flag == flag) {
- nop = g_slice_alloc (sizeof (*nop));
+ nop = g_malloc0 (sizeof (*nop));
nop->op = OP_UPDATE;
memcpy (nop->digest, digest,
sizeof (nop->digest));
else {
ndup_other ++;
}
- g_slice_free1 (sizeof (*nop), nop);
+ g_free (nop);
}
}
else {
/* Digest has not been found, but maybe we have the same in other
* sources ?
*/
- nop = g_slice_alloc (sizeof (*nop));
+ nop = g_malloc0 (sizeof (*nop));
nop->op = OP_INSERT;
memcpy (nop->digest, digest,
sizeof (nop->digest));
else {
ndup_other++;
}
- g_slice_free1 (sizeof (*nop), nop);
+ g_free (nop);
}
}
}
if ((op = g_hash_table_lookup (digests_id, &id)) != NULL) {
/* value, number, digest_id */
- nop = g_slice_alloc (sizeof (*nop));
+ nop = g_malloc0 (sizeof (*nop));
nop->op = OP_INSERT_SHINGLE;
memcpy (nop->digest, op->digest, sizeof (nop->digest));
nop->data.shgl.number = sqlite3_column_int64 (shgl_stmt, 1);
sqlite3_close (dest_db);
for (i = 0; i < ops->len; i++) {
op = g_ptr_array_index (ops, i);
- g_slice_free1 (sizeof (*op), op);
+ g_free (op);
}
g_ptr_array_free (ops, TRUE);
rspamd_mempool_delete (pool);
sqlite3_close (dest_db);
for (i = 0; i < ops->len; i++) {
op = g_ptr_array_index (ops, i);
- g_slice_free1 (sizeof (*op), op);
+ g_free (op);
}
g_ptr_array_free (ops, TRUE);
rspamd_mempool_delete (pool);
return;
}
- session = g_slice_alloc0 (sizeof (*session));
+ session = g_malloc0 (sizeof (*session));
session->rt = ctx->rt;
session->ctx = ctx;
session->addr = addr;
{
struct rspamadm_lua_repl_session *session = conn_ent->ud;
- g_slice_free1 (sizeof (*session), session);
+ g_free (session);
}
/*
}
ev_base = event_init ();
- ctx = g_slice_alloc0 (sizeof (*ctx));
+ ctx = g_malloc0 (sizeof (*ctx));
http = rspamd_http_router_new (rspamadm_lua_error_handler,
rspamadm_lua_finish_handler,
NULL, ev_base,
if (fd != -1) {
struct event *ev;
- ev = g_slice_alloc0 (sizeof (*ev));
+ ev = g_malloc0 (sizeof (*ev));
event_set (ev, fd, EV_READ|EV_PERSIST, rspamadm_lua_accept_cb,
ctx);
event_base_set (ev_base, ev);
projects / thirdparty / rspamd.git / commitdiff
