static void read_settings(void)
{
if (notify_tag != -1) g_source_remove(notify_tag);
notify_tag = g_timeout_add(settings_get_time("notify_check_time"),
(GSourceFunc) notifylist_timeout_func, NULL);
notify_whois_time = settings_get_time("notify_whois_time")/1000;
}
static void item_lag(SBAR_ITEM_REC *item, int get_size_only)
{
SERVER_REC *server;
char str[MAX_INT_STRLEN+10];
int lag, lag_unknown;
server = active_win == NULL ? NULL : active_win->active_server;
lag = get_lag(server, &lag_unknown);
if (lag <= 0 || lag < settings_get_time("lag_min_show")) {
/* don't print the lag item */
if (get_size_only)
item->min_size = item->max_size = 0;
return;
}
lag /= 10;
last_lag = lag;
last_lag_unknown = lag_unknown;
if (lag_unknown) {
/* "??)" in C becomes ']'
See: https://en.wikipedia.org/wiki/Digraphs_and_trigraphs#C */
g_snprintf(str, sizeof(str), "%d (?""?)", lag / 100);
} else {
if (lag % 100 == 0)
g_snprintf(str, sizeof(str), "%d", lag / 100);
else
g_snprintf(str, sizeof(str), "%d.%02d", lag / 100, lag % 100);
}
statusbar_item_default_handler(item, get_size_only,
NULL, str, TRUE);
}
static void read_settings(void)
{
querycreate_level = settings_get_level("autocreate_query_level");
query_auto_close = settings_get_time("autoclose_query")/1000;
if (query_auto_close > 0 && queryclose_tag == -1)
queryclose_tag = g_timeout_add(5000, (GSourceFunc) sig_query_autoclose, NULL);
else if (query_auto_close <= 0 && queryclose_tag != -1) {
g_source_remove(queryclose_tag);
queryclose_tag = -1;
}
}
int fts_indexer_init(struct fts_backend *backend, struct mailbox *box,
struct fts_indexer_context **ctx_r)
{
struct fts_indexer_context *ctx;
struct mailbox_status status;
uint32_t last_uid, seq1, seq2;
const char *path, *cmd, *value, *error;
int fd;
if (fts_backend_get_last_uid(backend, box, &last_uid) < 0)
return -1;
mailbox_get_open_status(box, STATUS_UIDNEXT, &status);
if (status.uidnext == last_uid+1) {
/* everything is already indexed */
return 0;
}
mailbox_get_seq_range(box, last_uid+1, (uint32_t)-1, &seq1, &seq2);
if (seq1 == 0) {
/* no new messages (last messages in mailbox were expunged) */
return 0;
}
cmd = t_strdup_printf("PREPEND\t1\t%s\t%s\t0\t%s\n",
str_tabescape(box->storage->user->username),
str_tabescape(box->vname),
str_tabescape(box->storage->user->session_id));
fd = fts_indexer_cmd(box->storage->user, cmd, &path);
if (fd == -1)
return -1;
/* connect to indexer and request immediate indexing of the mailbox */
ctx = i_new(struct fts_indexer_context, 1);
ctx->box = box;
ctx->path = i_strdup(path);
ctx->fd = fd;
ctx->input = i_stream_create_fd(fd, 128, FALSE);
ctx->search_start_time = ioloop_timeval;
value = mail_user_plugin_getenv(box->storage->user, "fts_index_timeout");
if (value != NULL) {
if (settings_get_time(value, &ctx->timeout_secs, &error) < 0)
i_error("Invalid fts_index_timeout setting: %s", error);
}
*ctx_r = ctx;
return 1;
}
static void lag_check_update(void)
{
SERVER_REC *server;
int lag, lag_unknown;
server = active_win == NULL ? NULL : active_win->active_server;
lag = get_lag(server, &lag_unknown)/10;
if (lag < settings_get_time("lag_min_show"))
lag = 0;
else
lag /= 10;
if (lag != last_lag || (lag > 0 && lag_unknown != last_lag_unknown))
statusbar_items_redraw("lag");
}
static void event_nick_collision(IRC_SERVER_REC *server, const char *data)
{
time_t new_connect;
if (!IS_IRC_SERVER(server))
return;
/* after server kills us because of nick collision, we want to
connect back immediately. but no matter how hard they kill us,
don't connect to the server more than once in every 10 seconds. */
new_connect = server->connect_time+10 -
settings_get_time("server_reconnect_time")/1000;
if (server->connect_time > new_connect)
server->connect_time = new_connect;
server->nick_collision = TRUE;
}
void
xmpp_server_connect(XMPP_SERVER_REC *server)
{
GError *error;
const char *err_msg;
if (!IS_XMPP_SERVER(server))
return;
error = NULL;
err_msg = NULL;
if (server->connrec->use_ssl) {
if (!set_ssl(server->lmconn, &error, server, FALSE)) {
err_msg = "Cannot init ssl";
goto err;
}
} else
set_ssl(server->lmconn, &error, server, TRUE);
if (settings_get_bool("xmpp_use_proxy")
&& !set_proxy(server->lmconn, &error)) {
err_msg = "Cannot set proxy";
goto err;
}
lm_connection_set_disconnect_function(server->lmconn,
lm_close_cb, server, NULL);
lookup_servers = g_slist_append(lookup_servers, server);
signal_emit("server looking", 1, server);
server->timeout_tag = g_timeout_add(
settings_get_time("server_connect_timeout"),
(GSourceFunc)check_connection_timeout, server);
if (!lm_connection_open(server->lmconn, lm_open_cb, server,
NULL, &error)) {
err_msg = "Connection failed";
goto err;
}
return;
err:
server->connection_lost = TRUE;
if (error != NULL) {
server_connect_failed(SERVER(server), error->message);
g_error_free(error);
} else
server_connect_failed(SERVER(server), err_msg);
}
SERVER_REC *irc_server_init_connect(SERVER_CONNECT_REC *conn)
{
IRC_SERVER_CONNECT_REC *ircconn;
IRC_SERVER_REC *server;
g_return_val_if_fail(IS_IRC_SERVER_CONNECT(conn), NULL);
if (conn->address == NULL || *conn->address == '\0') return NULL;
if (conn->nick == NULL || *conn->nick == '\0') return NULL;
server = g_new0(IRC_SERVER_REC, 1);
server->chat_type = IRC_PROTOCOL;
ircconn = (IRC_SERVER_CONNECT_REC *) conn;
server->connrec = ircconn;
server_connect_ref(conn);
if (server->connrec->port <= 0) {
server->connrec->port =
server->connrec->use_ssl ? 6697 : 6667;
}
server->cmd_queue_speed = ircconn->cmd_queue_speed > 0 ?
ircconn->cmd_queue_speed : settings_get_time("cmd_queue_speed");
server->max_cmds_at_once = ircconn->max_cmds_at_once > 0 ?
ircconn->max_cmds_at_once : settings_get_int("cmds_max_at_once");
server->max_query_chans = ircconn->max_query_chans > 0 ?
ircconn->max_query_chans : DEFAULT_MAX_QUERY_CHANS;
server->max_kicks_in_cmd = ircconn->max_kicks > 0 ?
ircconn->max_kicks : DEFAULT_MAX_KICKS;
server->max_modes_in_cmd = ircconn->max_modes > 0 ?
ircconn->max_modes : DEFAULT_MAX_MODES;
server->max_whois_in_cmd = ircconn->max_whois > 0 ?
ircconn->max_whois : DEFAULT_MAX_WHOIS;
server->max_msgs_in_cmd = ircconn->max_msgs > 0 ?
ircconn->max_msgs : DEFAULT_MAX_MSGS;
server->connrec->use_ssl = conn->use_ssl;
modes_server_init(server);
server_connect_init((SERVER_REC *) server);
return (SERVER_REC *) server;
}
static int dcc_timeout_func(void)
{
GSList *tmp, *next;
time_t now;
now = time(NULL)-settings_get_time("dcc_timeout")/1000;
for (tmp = dcc_conns; tmp != NULL; tmp = next) {
DCC_REC *dcc = tmp->data;
next = tmp->next;
if (dcc->tagread == -1 && now > dcc->created && !IS_DCC_SERVER(dcc)) {
/* Timed out - don't send DCC REJECT CTCP so CTCP
flooders won't affect us and it really doesn't
matter that much anyway if the other side doen't
get it..
We don't want dcc servers to time out. */
dcc_close(dcc);
}
}
return 1;
}
static void read_settings(void)
{
reconnect_time = settings_get_time("server_reconnect_time")/1000;
connect_timeout = settings_get_time("server_connect_timeout")/1000;
}
/* SYNTAX: KNOCKOUT [<time>] <nicks> <reason> */
static void cmd_knockout(const char *data, IRC_SERVER_REC *server,
IRC_CHANNEL_REC *channel)
{
KNOCKOUT_REC *rec;
char *nicks, *reason, *timeoutstr, *kickcmd, *bancmd, *recoded;
char **nicklist, *spacenicks, *banmasks;
void *free_arg;
int timeleft;
GSList *ptr;
CMD_IRC_SERVER(server);
if (!IS_IRC_CHANNEL(channel))
cmd_return_error(CMDERR_NOT_JOINED);
if (!channel->wholist)
cmd_return_error(CMDERR_CHAN_NOT_SYNCED);
if (i_isdigit(*data)) {
/* first argument is the timeout */
if (!cmd_get_params(data, &free_arg, 3 | PARAM_FLAG_GETREST,
&timeoutstr, &nicks, &reason))
return;
if (!parse_time_interval(timeoutstr, &timeleft))
cmd_param_error(CMDERR_INVALID_TIME);
} else {
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST,
&nicks, &reason))
return;
timeleft = settings_get_time("knockout_time");
}
if (*nicks == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
nicklist = g_strsplit(nicks, ",", -1);
spacenicks = g_strjoinv(" ", nicklist);
g_strfreev(nicklist);
banmasks = ban_get_masks(channel, spacenicks, 0);
g_free(spacenicks);
recoded = recode_out(SERVER(server), reason, channel->name);
kickcmd = g_strdup_printf("%s %s %s", channel->name, nicks, recoded);
g_free(recoded);
bancmd = *banmasks == '\0'? NULL :
g_strdup_printf("%s %s", channel->name, banmasks);
if (settings_get_bool("kick_first_on_kickban")) {
signal_emit("command kick", 3, kickcmd, server, channel);
if (bancmd != NULL)
signal_emit("command ban", 3, bancmd, server, channel);
} else {
if (bancmd != NULL)
signal_emit("command ban", 3, bancmd, server, channel);
signal_emit("command kick", 3, kickcmd, server, channel);
}
g_free(kickcmd);
g_free_not_null(bancmd);
if (*banmasks == '\0')
g_free(banmasks);
else {
/* check if we already have this knockout */
for (ptr = server->knockoutlist; ptr != NULL; ptr = ptr->next) {
rec = ptr->data;
if (channel == rec->channel &&
!strcmp(rec->ban, banmasks))
break;
}
if (ptr == NULL) {
rec = g_new(KNOCKOUT_REC, 1);
rec->channel = channel;
rec->ban = banmasks;
server->knockoutlist = g_slist_append(server->knockoutlist, rec);
}
rec->unban_time = time(NULL)+timeleft/1000;
}
cmd_params_free(free_arg);
}
static void stats_user_created(struct mail_user *user)
{
struct ioloop_context *ioloop_ctx =
io_loop_get_current_context(current_ioloop);
struct stats_user *suser;
struct mail_user_vfuncs *v = user->vlast;
const char *path, *str, *error;
unsigned int refresh_secs;
if (ioloop_ctx == NULL) {
/* we're probably running some test program, or at least
mail-storage-service wasn't used to create this user.
disable stats tracking. */
return;
}
if (user->autocreated) {
/* lda / shared user. we're not tracking this one. */
return;
}
/* get refresh time */
str = mail_user_plugin_getenv(user, "stats_refresh");
if (str == NULL)
return;
if (settings_get_time(str, &refresh_secs, &error) < 0) {
i_error("stats: Invalid stats_refresh setting: %s", error);
return;
}
if (refresh_secs == 0)
return;
if (refresh_secs > SESSION_STATS_FORCE_REFRESH_SECS) {
i_warning("stats: stats_refresh too large, changing to %u",
SESSION_STATS_FORCE_REFRESH_SECS);
refresh_secs = SESSION_STATS_FORCE_REFRESH_SECS;
}
if (global_stats_conn == NULL) {
path = t_strconcat(user->set->base_dir,
"/"MAIL_STATS_SOCKET_NAME, NULL);
global_stats_conn = stats_connection_create(path);
}
stats_connection_ref(global_stats_conn);
if (stats_user_count == 0) {
/* first user connection */
stats_global_user = user;
} else if (stats_user_count == 1) {
/* second user connection. we'll need to start doing
per-io callback tracking now. (we might have been doing it
also previously but just temporarily quickly dropped to
having 1 user, in which case stats_global_user=NULL) */
if (stats_global_user != NULL) {
stats_add_session(stats_global_user);
stats_global_user = NULL;
}
}
stats_user_count++;
suser = p_new(user->pool, struct stats_user, 1);
suser->module_ctx.super = *v;
user->vlast = &suser->module_ctx.super;
v->deinit = stats_user_deinit;
v->stats_fill = stats_user_stats_fill;
suser->refresh_secs = refresh_secs;
str = mail_user_plugin_getenv(user, "stats_track_cmds");
if (str != NULL && strcmp(str, "yes") == 0)
suser->track_commands = TRUE;
suser->stats_conn = global_stats_conn;
if (user->session_id != NULL && user->session_id[0] != '\0')
suser->stats_session_id = user->session_id;
else {
guid_128_t guid;
guid_128_generate(guid);
suser->stats_session_id =
p_strdup(user->pool, guid_128_to_string(guid));
}
suser->last_session_update = time(NULL);
user->stats_enabled = TRUE;
suser->ioloop_ctx = ioloop_ctx;
io_loop_context_add_callbacks(ioloop_ctx,
stats_io_activate,
stats_io_deactivate, user);
suser->pre_io_stats = stats_alloc(user->pool);
suser->session_stats = stats_alloc(user->pool);
suser->last_sent_session_stats = stats_alloc(user->pool);
MODULE_CONTEXT_SET(user, stats_user_module, suser);
mail_stats_connection_connect(suser->stats_conn, user);
suser->to_stats_timeout =
timeout_add(suser->refresh_secs*1000,
session_stats_refresh_timeout, user);
/* fill the initial values. this is necessary for the process-global
values (e.g. getrusage()) if the process is reused for multiple
users. otherwise the next user will start with the previous one's
last values. */
mail_user_stats_fill(user, suser->pre_io_stats);
}
static void stats_user_created(struct mail_user *user)
{
struct ioloop_context *ioloop_ctx =
io_loop_get_current_context(current_ioloop);
struct stats_user *suser;
struct mail_user_vfuncs *v = user->vlast;
const char *path, *str, *error;
unsigned int refresh_secs;
if (ioloop_ctx == NULL) {
/* we're probably running some test program, or at least
mail-storage-service wasn't used to create this user.
disable stats tracking. */
return;
}
if (user->autocreated) {
/* lda / shared user. we're not tracking this one. */
return;
}
/* get refresh time */
str = mail_user_plugin_getenv(user, "stats_refresh");
if (str == NULL)
return;
if (settings_get_time(str, &refresh_secs, &error) < 0) {
i_error("stats: Invalid stats_refresh setting: %s", error);
return;
}
if (refresh_secs == 0)
return;
if (global_stats_conn == NULL) {
path = t_strconcat(user->set->base_dir,
"/"MAIL_STATS_SOCKET_NAME, NULL);
global_stats_conn = stats_connection_create(path);
}
stats_connection_ref(global_stats_conn);
if (stats_user_count == 0) {
/* first user connection */
stats_global_user = user;
} else if (stats_user_count == 1) {
/* second user connection. we'll need to start doing
per-io callback tracking now. (we might have been doing it
also previously but just temporarily quickly dropped to
having 1 user, in which case stats_global_user=NULL) */
if (stats_global_user != NULL) {
stats_add_session(stats_global_user);
stats_global_user = NULL;
}
}
stats_user_count++;
suser = p_new(user->pool, struct stats_user, 1);
suser->module_ctx.super = *v;
user->vlast = &suser->module_ctx.super;
v->deinit = stats_user_deinit;
suser->refresh_secs = refresh_secs;
str = mail_user_plugin_getenv(user, "stats_track_cmds");
if (str != NULL && strcmp(str, "yes") == 0)
suser->track_commands = TRUE;
suser->stats_conn = global_stats_conn;
guid_128_generate(suser->session_guid);
suser->last_session_update = time(NULL);
suser->ioloop_ctx = ioloop_ctx;
io_loop_context_add_callbacks(ioloop_ctx,
stats_io_activate,
stats_io_deactivate, user);
MODULE_CONTEXT_SET(user, stats_user_module, suser);
stats_connection_connect(suser->stats_conn, user);
}
static void read_settings(void)
{
scrollback_lines = settings_get_int("scrollback_lines");
scrollback_time = settings_get_time("scrollback_time")/1000;
scrollback_burst_remove = settings_get_int("scrollback_burst_remove");
}
static void test_settings_get_time(void)
{
struct {
const char *input;
unsigned int output;
} tests[] = {
{ "0", 0 },
{ "59s", 59 },
{ "59 s", 59 },
{ "59se", 59 },
{ "59sec", 59 },
{ "59secs", 59 },
{ "59seco", 59 },
{ "59secon", 59 },
{ "59second", 59 },
{ "59seconds", 59 },
{ "123456 seconds", 123456 },
{ "123m", 123*60 },
{ "123 m", 123*60 },
{ "123 mi", 123*60 },
{ "123 min", 123*60 },
{ "123 mins", 123*60 },
{ "123 minu", 123*60 },
{ "123 minut", 123*60 },
{ "123 minute", 123*60 },
{ "123 minutes", 123*60 },
{ "123h", 123*60*60 },
{ "123 h", 123*60*60 },
{ "123 ho", 123*60*60 },
{ "123 hou", 123*60*60 },
{ "123 hour", 123*60*60 },
{ "123 hours", 123*60*60 },
{ "12d", 12*60*60*24 },
{ "12 d", 12*60*60*24 },
{ "12 da", 12*60*60*24 },
{ "12 day", 12*60*60*24 },
{ "12 days", 12*60*60*24 },
{ "3w", 3*60*60*24*7 },
{ "3 w", 3*60*60*24*7 },
{ "3 we", 3*60*60*24*7 },
{ "3 wee", 3*60*60*24*7 },
{ "3 week", 3*60*60*24*7 },
{ "3 weeks", 3*60*60*24*7 },
{ "1000ms", 1 },
{ "50000ms", 50 },
};
struct {
const char *input;
unsigned int output;
} msecs_tests[] = {
{ "0ms", 0 },
{ "1ms", 1 },
{ "123456ms", 123456 },
{ "123456 ms", 123456 },
{ "123456mse", 123456 },
{ "123456msec", 123456 },
{ "123456msecs", 123456 },
{ "123456mseco", 123456 },
{ "123456msecon", 123456 },
{ "123456msecond", 123456 },
{ "123456mseconds", 123456 },
{ "123456mil", 123456 },
{ "123456mill", 123456 },
{ "123456milli", 123456 },
{ "123456millis", 123456 },
{ "123456millisec", 123456 },
{ "123456millisecs", 123456 },
{ "123456milliseco", 123456 },
{ "123456millisecon", 123456 },
{ "123456millisecond", 123456 },
{ "123456milliseconds", 123456 },
{ "4294967295 ms", 4294967295 },
};
const char *secs_errors[] = {
"-1",
"1",
/* wrong spellings: */
"1ss",
"1secss",
"1secondss",
"1ma",
"1minsa",
"1hu",
"1hoursa",
"1dd",
"1days?",
"1wa",
"1weeksb",
/* milliseconds: */
"1ms",
"999ms",
"1001ms",
/* overflows: */
"7102 w",
"4294967296 s",
};
const char *msecs_errors[] = {
"-1",
"1",
/* wrong spellings: */
"1mis",
"1mss",
/* overflows: */
"8 w",
"4294967296 ms",
};
unsigned int i, secs, msecs;
const char *error;
test_begin("settings_get_time()");
for (i = 0; i < N_ELEMENTS(tests); i++) {
test_assert_idx(settings_get_time(tests[i].input, &secs, &error) == 0, i);
test_assert_idx(secs == tests[i].output, i);
test_assert_idx(settings_get_time_msecs(tests[i].input, &msecs, &error) == 0, i);
test_assert_idx(msecs == tests[i].output*1000, i);
}
for (i = 0; i < N_ELEMENTS(msecs_tests); i++) {
test_assert_idx(settings_get_time_msecs(msecs_tests[i].input, &msecs, &error) == 0, i);
test_assert_idx(msecs == msecs_tests[i].output, i);
}
for (i = 0; i < N_ELEMENTS(secs_errors); i++)
test_assert_idx(settings_get_time(secs_errors[i], &secs, &error) < 0, i);
for (i = 0; i < N_ELEMENTS(msecs_errors); i++)
test_assert_idx(settings_get_time_msecs(msecs_errors[i], &msecs, &error) < 0, i);
test_end();
}
