static void
rspamd_http_client_func (const gchar *path, rspamd_inet_addr_t *addr,
gpointer kp, gpointer peer_kp, struct rspamd_keypair_cache *c,
struct event_base *ev_base, double *latency)
{
struct rspamd_http_message *msg;
struct rspamd_http_connection *conn;
gchar urlbuf[PATH_MAX];
struct client_cbdata *cb;
gint fd;
g_assert ((fd = rspamd_inet_address_connect (addr, SOCK_STREAM, TRUE)) != -1);
conn = rspamd_http_connection_new (rspamd_client_body, rspamd_client_err,
rspamd_client_finish, RSPAMD_HTTP_CLIENT_SIMPLE,
RSPAMD_HTTP_CLIENT, c);
rspamd_snprintf (urlbuf, sizeof (urlbuf), "http://127.0.0.1/%s", path);
msg = rspamd_http_message_from_url (urlbuf);
g_assert (conn != NULL && msg != NULL);
if (kp != NULL) {
g_assert (peer_kp != NULL);
rspamd_http_connection_set_key (conn, kp);
msg->peer_key = rspamd_http_connection_key_ref (peer_kp);
}
cb = g_malloc (sizeof (*cb));
clock_gettime (CLOCK_MONOTONIC, &cb->ts);
cb->lat = latency;
rspamd_http_connection_write_message (conn, msg, NULL, NULL, cb,
fd, NULL, ev_base);
}
/**
* Write HTTP request
*/
static void
write_http_request (struct http_callback_data *cbd)
{
gchar datebuf[128];
struct rspamd_http_message *msg;
struct rspamd_map *map;
map = cbd->map;
if (cbd->fd != -1) {
close (cbd->fd);
}
cbd->fd = rspamd_inet_address_connect (cbd->addr, SOCK_STREAM, TRUE);
if (cbd->fd != -1) {
msg = rspamd_http_new_message (HTTP_REQUEST);
if (cbd->bk->protocol == MAP_PROTO_HTTPS) {
msg->flags |= RSPAMD_HTTP_FLAG_SSL;
}
if (cbd->check) {
msg->method = HTTP_HEAD;
}
if (cbd->stage == map_load_file) {
msg->url = rspamd_fstring_new_init (cbd->data->path, strlen (cbd->data->path));
if (cbd->check &&
cbd->data->last_checked != 0 && cbd->stage == map_load_file) {
rspamd_http_date_format (datebuf, sizeof (datebuf),
cbd->data->last_checked);
rspamd_http_message_add_header (msg, "If-Modified-Since", datebuf);
}
}
else if (cbd->stage == map_load_pubkey) {
msg->url = rspamd_fstring_new_init (cbd->data->path, strlen (cbd->data->path));
msg->url = rspamd_fstring_append (msg->url, ".pub", 4);
}
else if (cbd->stage == map_load_signature) {
msg->url = rspamd_fstring_new_init (cbd->data->path, strlen (cbd->data->path));
msg->url = rspamd_fstring_append (msg->url, ".sig", 4);
}
else {
g_assert_not_reached ();
}
rspamd_http_connection_write_message (cbd->conn, msg, cbd->data->host,
NULL, cbd, cbd->fd, &cbd->tv, cbd->ev_base);
MAP_RETAIN (cbd, "http_callback_data");
}
else {
msg_err_map ("cannot connect to %s: %s", cbd->data->host,
strerror (errno));
cbd->periodic->errored = TRUE;
}
}
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");
}
/**
* Write HTTP request
*/
static void
write_http_request (struct http_callback_data *cbd)
{
gchar datebuf[128];
struct rspamd_http_message *msg;
rspamd_mempool_t *pool;
pool = cbd->map->pool;
if (cbd->fd != -1) {
close (cbd->fd);
}
cbd->fd = rspamd_inet_address_connect (cbd->addr, SOCK_STREAM, TRUE);
if (cbd->fd != -1) {
msg = rspamd_http_new_message (HTTP_REQUEST);
if (cbd->stage == map_load_file) {
msg->url = rspamd_fstring_new_init (cbd->data->path, strlen (cbd->data->path));
if (cbd->data->last_checked != 0 && cbd->stage == map_load_file) {
rspamd_http_date_format (datebuf, sizeof (datebuf),
cbd->data->last_checked);
rspamd_http_message_add_header (msg, "If-Modified-Since", datebuf);
}
}
else if (cbd->stage == map_load_pubkey) {
msg->url = rspamd_fstring_new_init (cbd->data->path, strlen (cbd->data->path));
msg->url = rspamd_fstring_append (msg->url, ".pub", 4);
}
else if (cbd->stage == map_load_signature) {
msg->url = rspamd_fstring_new_init (cbd->data->path, strlen (cbd->data->path));
msg->url = rspamd_fstring_append (msg->url, ".sig", 4);
}
else {
g_assert_not_reached ();
}
rspamd_http_connection_write_message (cbd->conn, msg, cbd->data->host,
NULL, cbd, cbd->fd, &cbd->tv, cbd->ev_base);
REF_RETAIN (cbd);
}
else {
msg_err_pool ("cannot connect to %s: %s", cbd->data->host,
strerror (errno));
}
}
static gboolean
lua_tcp_make_connection (struct lua_tcp_cbdata *cbd)
{
int fd;
rspamd_inet_address_set_port (cbd->addr, cbd->port);
fd = rspamd_inet_address_connect (cbd->addr, SOCK_STREAM, TRUE);
if (fd == -1) {
msg_info ("cannot connect to %s", rspamd_inet_address_to_string (cbd->addr));
return FALSE;
}
cbd->fd = fd;
event_set (&cbd->ev, cbd->fd, EV_WRITE, lua_tcp_handler, cbd);
event_base_set (cbd->ev_base, &cbd->ev);
event_add (&cbd->ev, &cbd->tv);
return TRUE;
}
gboolean
create_smtp_upstream_connection (struct smtp_session *session)
{
struct upstream *selected;
/* Try to select upstream */
selected = rspamd_upstream_get (session->ctx->upstreams,
RSPAMD_UPSTREAM_ROUND_ROBIN);
if (selected == NULL) {
msg_err ("no upstreams suitable found");
return FALSE;
}
session->upstream = selected;
/* Now try to create socket */
session->upstream_sock = rspamd_inet_address_connect (
rspamd_upstream_addr (selected), SOCK_STREAM, TRUE);
if (session->upstream_sock == -1) {
msg_err ("cannot make a connection to %s", rspamd_upstream_name (selected));
rspamd_upstream_fail (selected);
return FALSE;
}
/* Create a dispatcher for upstream connection */
session->upstream_dispatcher = rspamd_create_dispatcher (session->ev_base,
session->upstream_sock,
BUFFER_LINE,
smtp_upstream_read_socket,
smtp_upstream_write_socket,
smtp_upstream_err_socket,
&session->ctx->smtp_timeout,
session);
session->state = SMTP_STATE_WAIT_UPSTREAM;
session->upstream_state = SMTP_STATE_GREETING;
register_async_event (session->s,
(event_finalizer_t)smtp_upstream_finalize_connection,
session,
g_quark_from_static_string ("smtp proxy"));
return TRUE;
}
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);
}
