static void
rspamd_server_accept (gint fd, short what, void *arg)
{
struct event_base *ev_base = arg;
struct rspamd_http_server_session *session;
rspamd_inet_addr_t *addr;
gint nfd;
do {
if ((nfd =
rspamd_accept_from_socket (fd, &addr)) == -1) {
rspamd_fprintf (stderr, "accept failed: %s", strerror (errno));
return;
}
/* Check for EAGAIN */
if (nfd == 0) {
return;
}
rspamd_inet_address_destroy (addr);
session = g_slice_alloc (sizeof (*session));
session->conn = rspamd_http_connection_new (NULL, rspamd_server_error,
rspamd_server_finish, 0, RSPAMD_HTTP_SERVER, c);
rspamd_http_connection_set_key (session->conn, server_key);
rspamd_http_connection_read_message (session->conn,
session,
nfd,
&io_tv,
ev_base);
session->reply = FALSE;
session->fd = nfd;
session->ev_base = ev_base;
} while (nfd > 0);
}
static void
rspamd_map_dns_callback (struct rdns_reply *reply, void *arg)
{
struct http_callback_data *cbd = arg;
struct rspamd_map *map;
guint flags = RSPAMD_HTTP_CLIENT_SIMPLE|RSPAMD_HTTP_CLIENT_SHARED;
map = cbd->map;
if (reply->code == RDNS_RC_NOERROR) {
/*
* We just get the first address hoping that a resolver performs
* round-robin rotation well
*/
if (cbd->addr == NULL) {
cbd->addr = rspamd_inet_address_from_rnds (reply->entries);
if (cbd->addr != NULL) {
rspamd_inet_address_set_port (cbd->addr, cbd->data->port);
/* Try to open a socket */
cbd->fd = rspamd_inet_address_connect (cbd->addr, SOCK_STREAM,
TRUE);
if (cbd->fd != -1) {
cbd->stage = map_load_file;
cbd->conn = rspamd_http_connection_new (NULL,
http_map_error,
http_map_finish,
flags,
RSPAMD_HTTP_CLIENT,
NULL,
cbd->map->cfg->libs_ctx->ssl_ctx);
write_http_request (cbd);
}
else {
rspamd_inet_address_destroy (cbd->addr);
cbd->addr = NULL;
}
}
}
}
else if (cbd->stage < map_load_file) {
if (cbd->stage == map_resolve_host2) {
/* We have still one request pending */
cbd->stage = map_resolve_host1;
}
else {
/* We could not resolve host, so cowardly fail here */
msg_err_map ("cannot resolve %s", cbd->data->host);
}
}
MAP_RELEASE (cbd, "http_callback_data");
}
/**
* Callback for destroying HTTP callback data
*/
static void
free_http_cbdata_common (struct http_callback_data *cbd, gboolean plan_new)
{
char fpath[PATH_MAX];
struct stat st;
struct map_periodic_cbdata *periodic = cbd->periodic;
if (cbd->out_fd != -1) {
close (cbd->out_fd);
}
rspamd_snprintf (fpath, sizeof (fpath), "%s", cbd->tmpfile);
if (stat (fpath, &st) != -1 && S_ISREG (st.st_mode)) {
(void)unlink (fpath);
}
rspamd_snprintf (fpath, sizeof (fpath), "%s.pub", cbd->tmpfile);
if (stat (fpath, &st) != -1 && S_ISREG (st.st_mode)) {
(void)unlink (fpath);
}
rspamd_snprintf (fpath, sizeof (fpath), "%s.sig", cbd->tmpfile);
if (stat (fpath, &st) != -1 && S_ISREG (st.st_mode)) {
(void)unlink (fpath);
}
if (cbd->pk) {
rspamd_pubkey_unref (cbd->pk);
}
if (cbd->conn) {
rspamd_http_connection_unref (cbd->conn);
cbd->conn = NULL;
}
if (cbd->fd != -1) {
close (cbd->fd);
}
if (cbd->addr) {
rspamd_inet_address_destroy (cbd->addr);
}
MAP_RELEASE (cbd->bk);
MAP_RELEASE (periodic);
g_slice_free1 (sizeof (struct http_callback_data), cbd);
}
/**
* Callback for destroying HTTP callback data
*/
static void
free_http_cbdata_common (struct http_callback_data *cbd)
{
char fpath[PATH_MAX];
struct stat st;
if (cbd->out_fd != -1) {
close (cbd->out_fd);
}
rspamd_snprintf (fpath, sizeof (fpath), "%s", cbd->tmpfile);
if (stat (fpath, &st) != -1 && S_ISREG (st.st_mode)) {
(void)unlink (fpath);
}
rspamd_snprintf (fpath, sizeof (fpath), "%s.pub", cbd->tmpfile);
if (stat (fpath, &st) != -1 && S_ISREG (st.st_mode)) {
(void)unlink (fpath);
}
rspamd_snprintf (fpath, sizeof (fpath), "%s.sig", cbd->tmpfile);
if (stat (fpath, &st) != -1 && S_ISREG (st.st_mode)) {
(void)unlink (fpath);
}
if (cbd->pk) {
rspamd_pubkey_unref (cbd->pk);
}
if (cbd->conn) {
rspamd_http_connection_unref (cbd->conn);
cbd->conn = NULL;
}
if (cbd->fd != -1) {
close (cbd->fd);
}
if (cbd->addr) {
rspamd_inet_address_destroy (cbd->addr);
}
g_atomic_int_set (cbd->map->locked, 0);
g_slice_free1 (sizeof (struct http_callback_data), cbd);
}
static void
lua_tcp_fin (gpointer arg)
{
struct lua_tcp_cbdata *cbd = (struct lua_tcp_cbdata *)arg;
luaL_unref (cbd->L, LUA_REGISTRYINDEX, cbd->cbref);
if (cbd->fd != -1) {
event_del (&cbd->ev);
close (cbd->fd);
}
if (cbd->addr) {
rspamd_inet_address_destroy (cbd->addr);
}
g_slice_free1 (sizeof (struct lua_tcp_cbdata), cbd);
}
static void
rspamd_server_accept (gint fd, short what, void *arg)
{
struct rspamd_http_connection_router *rt = arg;
rspamd_inet_addr_t *addr;
gint nfd;
if ((nfd =
rspamd_accept_from_socket (fd, &addr, NULL)) == -1) {
msg_warn ("accept failed: %s", strerror (errno));
return;
}
/* Check for EAGAIN */
if (nfd == 0) {
return;
}
rspamd_inet_address_destroy (addr);
rspamd_http_router_handle_socket (rt, nfd, NULL);
}
/**
* Callback for destroying HTTP callback data
*/
static void
free_http_cbdata_common (struct http_callback_data *cbd, gboolean plan_new)
{
struct map_periodic_cbdata *periodic = cbd->periodic;
if (cbd->shmem_sig) {
rspamd_http_message_shmem_unref (cbd->shmem_sig);
}
if (cbd->shmem_pubkey) {
rspamd_http_message_shmem_unref (cbd->shmem_pubkey);
}
if (cbd->shmem_data) {
rspamd_http_message_shmem_unref (cbd->shmem_data);
}
if (cbd->pk) {
rspamd_pubkey_unref (cbd->pk);
}
if (cbd->conn) {
rspamd_http_connection_unref (cbd->conn);
cbd->conn = NULL;
}
if (cbd->fd != -1) {
close (cbd->fd);
}
if (cbd->addr) {
rspamd_inet_address_destroy (cbd->addr);
}
MAP_RELEASE (cbd->bk, "rspamd_map_backend");
MAP_RELEASE (periodic, "periodic");
g_slice_free1 (sizeof (struct http_callback_data), cbd);
}
static void
rspamadm_control (gint argc, gchar **argv)
{
GOptionContext *context;
GError *error = NULL;
struct event_base *ev_base;
const gchar *cmd, *path = NULL;
struct rspamd_http_connection *conn;
struct rspamd_http_message *msg;
rspamd_inet_addr_t *addr;
struct timeval tv;
static struct rspamadm_control_cbdata cbdata;
lua_State *L;
gint sock;
context = g_option_context_new (
"control - manage rspamd main control interface");
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 (argc <= 1) {
rspamd_fprintf (stderr, "command required\n");
exit (1);
}
cmd = argv[1];
if (g_ascii_strcasecmp (cmd, "stat") == 0) {
path = "/stat";
}
else if (g_ascii_strcasecmp (cmd, "reload") == 0) {
path = "/reload";
}
else if (g_ascii_strcasecmp (cmd, "reresolve") == 0) {
path = "/reresolve";
}
else if (g_ascii_strcasecmp (cmd, "recompile") == 0) {
path = "/recompile";
}
else if (g_ascii_strcasecmp (cmd, "fuzzystat") == 0 ||
g_ascii_strcasecmp (cmd, "fuzzy_stat") == 0) {
path = "/fuzzystat";
}
else if (g_ascii_strcasecmp (cmd, "fuzzysync") == 0 ||
g_ascii_strcasecmp (cmd, "fuzzy_sync") == 0) {
path = "/fuzzysync";
}
else {
rspamd_fprintf (stderr, "unknown command: %s\n", cmd);
exit (1);
}
if (!rspamd_parse_inet_address (&addr, control_path, 0)) {
rspamd_fprintf (stderr, "bad control path: %s\n", control_path);
exit (1);
}
ev_base = event_init ();
sock = rspamd_inet_address_connect (addr, SOCK_STREAM, TRUE);
if (sock == -1) {
rspamd_fprintf (stderr, "cannot connect to: %s\n", control_path);
rspamd_inet_address_destroy (addr);
exit (1);
}
L = rspamd_lua_init ();
conn = rspamd_http_connection_new (NULL,
rspamd_control_error_handler,
rspamd_control_finish_handler,
RSPAMD_HTTP_CLIENT_SIMPLE,
RSPAMD_HTTP_CLIENT,
NULL,
NULL);
msg = rspamd_http_new_message (HTTP_REQUEST);
msg->url = rspamd_fstring_new_init (path, strlen (path));
double_to_tv (timeout, &tv);
cbdata.L = L;
cbdata.argc = argc;
cbdata.argv = argv;
cbdata.path = path;
rspamd_http_connection_write_message (conn, msg, NULL, NULL, &cbdata, sock,
&tv, ev_base);
event_base_loop (ev_base, 0);
rspamd_http_connection_unref (conn);
rspamd_inet_address_destroy (addr);
lua_close (L);
close (sock);
}
/*
* Free all structures of worker_task
*/
void
rspamd_task_free (struct rspamd_task *task, gboolean is_soft)
{
struct mime_part *p;
struct mime_text_part *tp;
guint i;
if (task) {
debug_task ("free pointer %p", task);
for (i = 0; i < task->parts->len; i ++) {
p = g_ptr_array_index (task->parts, i);
g_byte_array_free (p->content, TRUE);
}
for (i = 0; i < task->text_parts->len; i ++) {
tp = g_ptr_array_index (task->text_parts, i);
if (tp->words) {
g_array_free (tp->words, TRUE);
}
if (tp->normalized_words) {
g_array_free (tp->normalized_words, TRUE);
}
}
if (task->images) {
g_list_free (task->images);
}
if (task->messages) {
g_list_free (task->messages);
}
if (task->http_conn != NULL) {
rspamd_http_connection_unref (task->http_conn);
}
if (task->sock != -1) {
close (task->sock);
}
if (task->settings != NULL) {
ucl_object_unref (task->settings);
}
if (task->client_addr) {
rspamd_inet_address_destroy (task->client_addr);
}
if (task->from_addr) {
rspamd_inet_address_destroy (task->from_addr);
}
if (task->err) {
g_error_free (task->err);
}
rspamd_mempool_delete (task->task_pool);
g_slice_free1 (sizeof (struct rspamd_task), task);
}
}
