static void
_init(char *log_level)
{
setlocale(LC_ALL, "");
// ignore SIGPIPE
signal(SIGPIPE, SIG_IGN);
signal(SIGINT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGWINCH, ui_sigwinch_handler);
if (pthread_mutex_init(&lock, NULL) != 0) {
log_error("Mutex init failed");
exit(1);
}
pthread_mutex_lock(&lock);
files_create_directories();
log_level_t prof_log_level = log_level_from_string(log_level);
prefs_load();
log_init(prof_log_level);
log_stderr_init(PROF_LEVEL_ERROR);
if (strcmp(PACKAGE_STATUS, "development") == 0) {
#ifdef HAVE_GIT_VERSION
log_info("Starting Profanity (%sdev.%s.%s)...", PACKAGE_VERSION, PROF_GIT_BRANCH, PROF_GIT_REVISION);
#else
log_info("Starting Profanity (%sdev)...", PACKAGE_VERSION);
#endif
} else {
log_info("Starting Profanity (%s)...", PACKAGE_VERSION);
}
chat_log_init();
groupchat_log_init();
accounts_load();
char *theme = prefs_get_string(PREF_THEME);
theme_init(theme);
prefs_free_string(theme);
ui_init();
session_init();
cmd_init();
log_info("Initialising contact list");
muc_init();
tlscerts_init();
scripts_init();
#ifdef HAVE_LIBOTR
otr_init();
#endif
#ifdef HAVE_LIBGPGME
p_gpg_init();
#endif
atexit(_shutdown);
plugins_init();
#ifdef HAVE_GTK
tray_init();
#endif
inp_nonblocking(TRUE);
ui_resize();
}
void
handle_contact_online(char *barejid, Resource *resource,
GDateTime *last_activity)
{
gboolean updated = roster_update_presence(barejid, resource, last_activity);
if (updated) {
char *show_console = prefs_get_string(PREF_STATUSES_CONSOLE);
char *show_chat_win = prefs_get_string(PREF_STATUSES_CHAT);
PContact contact = roster_get_contact(barejid);
if (p_contact_subscription(contact) != NULL) {
if (strcmp(p_contact_subscription(contact), "none") != 0) {
// show in console if "all"
if (g_strcmp0(show_console, "all") == 0) {
cons_show_contact_online(contact, resource, last_activity);
// show in console of "online" and presence online
} else if (g_strcmp0(show_console, "online") == 0 &&
resource->presence == RESOURCE_ONLINE) {
cons_show_contact_online(contact, resource, last_activity);
}
// show in chat win if "all"
if (g_strcmp0(show_chat_win, "all") == 0) {
ui_chat_win_contact_online(contact, resource, last_activity);
// show in char win if "online" and presence online
} else if (g_strcmp0(show_chat_win, "online") == 0 &&
resource->presence == RESOURCE_ONLINE) {
ui_chat_win_contact_online(contact, resource, last_activity);
}
}
}
prefs_free_string(show_console);
prefs_free_string(show_chat_win);
}
ui_roster();
}
void
handle_room_member_offline(const char * const room, const char * const nick,
const char * const show, const char * const status)
{
muc_remove_from_roster(room, nick);
char *muc_status_pref = prefs_get_string(PREF_STATUSES_MUC);
if (g_strcmp0(muc_status_pref, "none") != 0) {
ui_room_member_offline(room, nick);
}
prefs_free_string(muc_status_pref);
}
prof_otrpolicy_t
otr_get_policy(const char *const recipient)
{
char *account_name = jabber_get_account_name();
ProfAccount *account = accounts_get_account(account_name);
// check contact specific setting
if (g_list_find_custom(account->otr_manual, recipient, (GCompareFunc)g_strcmp0)) {
account_free(account);
return PROF_OTRPOLICY_MANUAL;
}
if (g_list_find_custom(account->otr_opportunistic, recipient, (GCompareFunc)g_strcmp0)) {
account_free(account);
return PROF_OTRPOLICY_OPPORTUNISTIC;
}
if (g_list_find_custom(account->otr_always, recipient, (GCompareFunc)g_strcmp0)) {
account_free(account);
return PROF_OTRPOLICY_ALWAYS;
}
// check default account setting
if (account->otr_policy) {
prof_otrpolicy_t result;
if (g_strcmp0(account->otr_policy, "manual") == 0) {
result = PROF_OTRPOLICY_MANUAL;
}
if (g_strcmp0(account->otr_policy, "opportunistic") == 0) {
result = PROF_OTRPOLICY_OPPORTUNISTIC;
}
if (g_strcmp0(account->otr_policy, "always") == 0) {
result = PROF_OTRPOLICY_ALWAYS;
}
account_free(account);
return result;
}
account_free(account);
// check global setting
char *pref_otr_policy = prefs_get_string(PREF_OTR_POLICY);
// pref defaults to manual
prof_otrpolicy_t result = PROF_OTRPOLICY_MANUAL;
if (strcmp(pref_otr_policy, "opportunistic") == 0) {
result = PROF_OTRPOLICY_OPPORTUNISTIC;
} else if (strcmp(pref_otr_policy, "always") == 0) {
result = PROF_OTRPOLICY_ALWAYS;
}
prefs_free_string(pref_otr_policy);
return result;
}
static void
_init(char *log_level)
{
setlocale(LC_ALL, "");
// ignore SIGPIPE
signal(SIGPIPE, SIG_IGN);
signal(SIGINT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGWINCH, ui_sigwinch_handler);
_create_directories();
log_level_t prof_log_level = log_level_from_string(log_level);
prefs_load();
log_init(prof_log_level);
log_stderr_init(PROF_LEVEL_ERROR);
if (strcmp(PROF_PACKAGE_STATUS, "development") == 0) {
#ifdef PROF_HAVE_GIT_VERSION
log_info("Starting Profanity (%sdev.%s.%s)...", PROF_PACKAGE_VERSION, PROF_GIT_BRANCH, PROF_GIT_REVISION);
#else
log_info("Starting Profanity (%sdev)...", PROF_PACKAGE_VERSION);
#endif
} else {
log_info("Starting Profanity (%s)...", PROF_PACKAGE_VERSION);
}
chat_log_init();
groupchat_log_init();
accounts_load();
char *theme = prefs_get_string(PREF_THEME);
theme_init(theme);
prefs_free_string(theme);
ui_init();
jabber_init();
cmd_init();
log_info("Initialising contact list");
muc_init();
tlscerts_init();
scripts_init();
#ifdef PROF_HAVE_LIBOTR
otr_init();
#endif
#ifdef PROF_HAVE_LIBGPGME
p_gpg_init();
#endif
atexit(_shutdown);
plugins_init();
#ifdef PROF_HAVE_GTK
if (gtk_ready) {
log_debug("Building GTK icon");
create_tray();
}
#endif
inp_nonblocking(TRUE);
}
void
sv_ev_room_occupant_offline(const char * const room, const char * const nick,
const char * const show, const char * const status)
{
muc_roster_remove(room, nick);
char *muc_status_pref = prefs_get_string(PREF_STATUSES_MUC);
if (g_strcmp0(muc_status_pref, "none") != 0) {
ui_room_member_offline(room, nick);
}
prefs_free_string(muc_status_pref);
occupantswin_occupants(room);
}
static void
_connect_default(const char * const account)
{
if (account) {
cmd_execute_connect(account);
} else {
char *pref_connect_account = prefs_get_string(PREF_CONNECT_ACCOUNT);
if (pref_connect_account) {
cmd_execute_connect(pref_connect_account);
prefs_free_string(pref_connect_account);
}
}
}
void
handle_contact_offline(char *barejid, char *resource, char *status)
{
gboolean updated = roster_contact_offline(barejid, resource, status);
if (resource != NULL && updated) {
char *show_console = prefs_get_string(PREF_STATUSES_CONSOLE);
char *show_chat_win = prefs_get_string(PREF_STATUSES_CHAT);
Jid *jid = jid_create_from_bare_and_resource(barejid, resource);
PContact contact = roster_get_contact(barejid);
if (p_contact_subscription(contact) != NULL) {
if (strcmp(p_contact_subscription(contact), "none") != 0) {
// show in console if "all"
if (g_strcmp0(show_console, "all") == 0) {
cons_show_contact_offline(contact, resource, status);
// show in console of "online"
} else if (g_strcmp0(show_console, "online") == 0) {
cons_show_contact_offline(contact, resource, status);
}
// show in chat win if "all"
if (g_strcmp0(show_chat_win, "all") == 0) {
ui_chat_win_contact_offline(contact, resource, status);
// show in char win if "online" and presence online
} else if (g_strcmp0(show_chat_win, "online") == 0) {
ui_chat_win_contact_offline(contact, resource, status);
}
}
}
prefs_free_string(show_console);
prefs_free_string(show_chat_win);
jid_destroy(jid);
}
ui_roster();
}
static void
_connect_default(const char *const account)
{
ProfWin *window = wins_get_current();
if (account) {
cmd_execute_connect(window, account);
} else {
char *pref_connect_account = prefs_get_string(PREF_CONNECT_ACCOUNT);
if (pref_connect_account) {
cmd_execute_connect(window, pref_connect_account);
prefs_free_string(pref_connect_account);
}
}
}
void
handle_room_member_presence(const char * const room,
const char * const nick, const char * const show,
const char * const status)
{
gboolean updated = muc_add_to_roster(room, nick, show, status);
if (updated) {
char *muc_status_pref = prefs_get_string(PREF_STATUSES_MUC);
if (g_strcmp0(muc_status_pref, "all") == 0) {
ui_room_member_presence(room, nick, show, status);
}
prefs_free_string(muc_status_pref);
}
}
void
chat_log_pgp_msg_in(const char * const barejid, const char * const msg)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char *jid = jabber_get_fulljid();
Jid *jidp = jid_create(jid);
char *pref_pgp_log = prefs_get_string(PREF_PGP_LOG);
if (strcmp(pref_pgp_log, "on") == 0) {
_chat_log_chat(jidp->barejid, barejid, msg, PROF_IN_LOG, NULL);
} else if (strcmp(pref_pgp_log, "redact") == 0) {
_chat_log_chat(jidp->barejid, barejid, "[redacted]", PROF_IN_LOG, NULL);
}
prefs_free_string(pref_pgp_log);
jid_destroy(jidp);
}
}
void
status_bar_resize(void)
{
int rows, cols;
getmaxyx(stdscr, rows, cols);
werase(status_bar);
int bracket_attrs = theme_attrs(THEME_STATUS_BRACKET);
mvwin(status_bar, rows-2, 0);
wresize(status_bar, 1, cols);
wbkgd(status_bar, theme_attrs(THEME_STATUS_TEXT));
wattron(status_bar, bracket_attrs);
mvwprintw(status_bar, 0, cols - 34, _active);
mvwprintw(status_bar, 0, cols - 34 + ((current - 1) * 3), bracket);
wattroff(status_bar, bracket_attrs);
if (message) {
char *time_pref = prefs_get_string(PREF_TIME_STATUSBAR);
gchar *date_fmt = NULL;
if (g_strcmp0(time_pref, "off") == 0) {
date_fmt = g_strdup("");
} else {
date_fmt = g_date_time_format(last_time, time_pref);
}
assert(date_fmt != NULL);
size_t len = strlen(date_fmt);
g_free(date_fmt);
if (g_strcmp0(time_pref, "off") != 0) {
/* 01234567890123456
* [HH:MM] message */
mvwprintw(status_bar, 0, 5 + len, message);
} else {
mvwprintw(status_bar, 0, 1, message);
}
prefs_free_string(time_pref);
}
if (last_time) {
g_date_time_unref(last_time);
}
last_time = g_date_time_new_now_local();
_status_bar_draw();
}
void
win_show_status_string(ProfWin *window, const char *const from,
const char *const show, const char *const status,
GDateTime *last_activity, const char *const pre,
const char *const default_show)
{
theme_item_t presence_colour;
if (show) {
presence_colour = theme_main_presence_attrs(show);
} else if (strcmp(default_show, "online") == 0) {
presence_colour = THEME_ONLINE;
} else {
presence_colour = THEME_OFFLINE;
}
win_vprint(window, '-', 0, NULL, NO_EOL, presence_colour, "", "%s %s", pre, from);
if (show)
win_vprint(window, '-', 0, NULL, NO_DATE | NO_EOL, presence_colour, "", " is %s", show);
else
win_vprint(window, '-', 0, NULL, NO_DATE | NO_EOL, presence_colour, "", " is %s", default_show);
if (last_activity) {
gchar *date_fmt = NULL;
char *time_pref = prefs_get_string(PREF_TIME_LASTACTIVITY);
date_fmt = g_date_time_format(last_activity, time_pref);
prefs_free_string(time_pref);
assert(date_fmt != NULL);
win_vprint(window, '-', 0, NULL, NO_DATE | NO_EOL, presence_colour, "", ", last activity: %s", date_fmt);
g_free(date_fmt);
}
if (status)
win_vprint(window, '-', 0, NULL, NO_DATE | NO_EOL, presence_colour, "", ", \"%s\"", status);
win_print(window, '-', 0, NULL, NO_DATE, presence_colour, "", "");
}
static void
_init(const int disable_tls, char *log_level)
{
setlocale(LC_ALL, "");
// ignore SIGPIPE
signal(SIGPIPE, SIG_IGN);
signal(SIGINT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
_create_directories();
log_level_t prof_log_level = log_level_from_string(log_level);
prefs_load();
log_init(prof_log_level);
if (strcmp(PACKAGE_STATUS, "development") == 0) {
#ifdef HAVE_GIT_VERSION
log_info("Starting Profanity (%sdev.%s.%s)...", PACKAGE_VERSION, PROF_GIT_BRANCH, PROF_GIT_REVISION);
#else
log_info("Starting Profanity (%sdev)...", PACKAGE_VERSION);
#endif
} else {
log_info("Starting Profanity (%s)...", PACKAGE_VERSION);
}
chat_log_init();
groupchat_log_init();
accounts_load();
char *theme = prefs_get_string(PREF_THEME);
theme_init(theme);
prefs_free_string(theme);
ui_init();
jabber_init(disable_tls);
cmd_init();
log_info("Initialising contact list");
roster_init();
muc_init();
#ifdef HAVE_LIBOTR
otr_init();
#endif
atexit(_shutdown);
ui_input_nonblocking(TRUE);
}
void
status_bar_print_message(const char * const msg)
{
werase(status_bar);
if (message) {
free(message);
}
message = strdup(msg);
char *time_pref = prefs_get_string(PREF_TIME_STATUSBAR);
gchar *date_fmt = NULL;
if (g_strcmp0(time_pref, "off") == 0) {
date_fmt = g_strdup("");
} else {
date_fmt = g_date_time_format(last_time, time_pref);
}
assert(date_fmt != NULL);
size_t len = strlen(date_fmt);
g_free(date_fmt);
if (g_strcmp0(time_pref, "off") != 0) {
mvwprintw(status_bar, 0, 5 + len, message);
} else {
mvwprintw(status_bar, 0, 1, message);
}
prefs_free_string(time_pref);
int cols = getmaxx(stdscr);
int bracket_attrs = theme_attrs(THEME_STATUS_BRACKET);
wattron(status_bar, bracket_attrs);
mvwprintw(status_bar, 0, cols - 34, _active);
mvwprintw(status_bar, 0, cols - 34 + ((current - 1) * 3), bracket);
wattroff(status_bar, bracket_attrs);
_status_bar_draw();
}
void
sv_ev_room_occupant_offline(const char *const room, const char *const nick,
const char *const show, const char *const status)
{
muc_roster_remove(room, nick);
char *muc_status_pref = prefs_get_string(PREF_STATUSES_MUC);
ProfMucWin *mucwin = wins_get_muc(room);
if (mucwin && (g_strcmp0(muc_status_pref, "none") != 0)) {
mucwin_occupant_offline(mucwin, nick);
}
prefs_free_string(muc_status_pref);
Jid *jidp = jid_create_from_bare_and_resource(room, nick);
ProfPrivateWin *privwin = wins_get_private(jidp->fulljid);
jid_destroy(jidp);
if (privwin != NULL) {
privwin_occupant_offline(privwin);
}
occupantswin_occupants(room);
rosterwin_roster();
}
void
mucwin_message(ProfMucWin *mucwin, const char *const nick, const char *const message)
{
assert(mucwin != NULL);
ProfWin *window = (ProfWin*)mucwin;
int num = wins_get_num(window);
char *my_nick = muc_nick(mucwin->roomjid);
if (g_strcmp0(nick, my_nick) != 0) {
if (g_strrstr(message, my_nick)) {
win_print(window, '-', 0, NULL, NO_ME, THEME_ROOMMENTION, nick, message);
} else {
win_print(window, '-', 0, NULL, NO_ME, THEME_TEXT_THEM, nick, message);
}
} else {
win_print(window, '-', 0, NULL, 0, THEME_TEXT_ME, nick, message);
}
// currently in groupchat window
if (wins_is_current(window)) {
status_bar_active(num);
// not currently on groupchat window
} else {
status_bar_new(num);
cons_show_incoming_message(nick, num);
if (prefs_get_boolean(PREF_FLASH) && (strcmp(nick, my_nick) != 0)) {
flash();
}
mucwin->unread++;
}
int ui_index = num;
if (ui_index == 10) {
ui_index = 0;
}
// don't notify self messages
if (strcmp(nick, my_nick) == 0) {
return;
}
if (prefs_get_boolean(PREF_BEEP)) {
beep();
}
gboolean notify = FALSE;
char *room_setting = prefs_get_string(PREF_NOTIFY_ROOM);
if (g_strcmp0(room_setting, "on") == 0) {
notify = TRUE;
}
if (g_strcmp0(room_setting, "mention") == 0) {
char *message_lower = g_utf8_strdown(message, -1);
char *nick_lower = g_utf8_strdown(nick, -1);
if (g_strrstr(message_lower, nick_lower)) {
notify = TRUE;
}
g_free(message_lower);
g_free(nick_lower);
}
prefs_free_string(room_setting);
if (notify) {
gboolean is_current = wins_is_current(window);
if ( !is_current || (is_current && prefs_get_boolean(PREF_NOTIFY_ROOM_CURRENT)) ) {
Jid *jidp = jid_create(mucwin->roomjid);
if (prefs_get_boolean(PREF_NOTIFY_ROOM_TEXT)) {
notify_room_message(nick, jidp->localpart, ui_index, message);
} else {
notify_room_message(nick, jidp->localpart, ui_index, NULL);
}
jid_destroy(jidp);
}
}
}
void
handle_incoming_message(char *from, char *message, gboolean priv)
{
#ifdef HAVE_LIBOTR
gboolean was_decrypted = FALSE;
char *newmessage;
prof_otrpolicy_t policy = otr_get_policy(from);
char *whitespace_base = strstr(message,OTRL_MESSAGE_TAG_BASE);
if (!priv) {
//check for OTR whitespace (opportunistic or always)
if (policy == PROF_OTRPOLICY_OPPORTUNISTIC || policy == PROF_OTRPOLICY_ALWAYS) {
if (whitespace_base) {
if (strstr(message, OTRL_MESSAGE_TAG_V2) || strstr(message, OTRL_MESSAGE_TAG_V1)) {
// Remove whitespace pattern for proper display in UI
// Handle both BASE+TAGV1/2(16+8) and BASE+TAGV1+TAGV2(16+8+8)
int tag_length = 24;
if (strstr(message, OTRL_MESSAGE_TAG_V2) && strstr(message, OTRL_MESSAGE_TAG_V1)) {
tag_length = 32;
}
memmove(whitespace_base, whitespace_base+tag_length, tag_length);
char *otr_query_message = otr_start_query();
cons_show("OTR Whitespace pattern detected. Attempting to start OTR session...");
message_send(otr_query_message, from);
}
}
}
newmessage = otr_decrypt_message(from, message, &was_decrypted);
// internal OTR message
if (newmessage == NULL) {
return;
}
} else {
newmessage = message;
}
if (policy == PROF_OTRPOLICY_ALWAYS && !was_decrypted && !whitespace_base) {
char *otr_query_message = otr_start_query();
cons_show("Attempting to start OTR session...");
message_send(otr_query_message, from);
}
ui_incoming_msg(from, newmessage, NULL, priv);
if (prefs_get_boolean(PREF_CHLOG) && !priv) {
Jid *from_jid = jid_create(from);
const char *jid = jabber_get_fulljid();
Jid *jidp = jid_create(jid);
char *pref_otr_log = prefs_get_string(PREF_OTR_LOG);
if (!was_decrypted || (strcmp(pref_otr_log, "on") == 0)) {
chat_log_chat(jidp->barejid, from_jid->barejid, newmessage, PROF_IN_LOG, NULL);
} else if (strcmp(pref_otr_log, "redact") == 0) {
chat_log_chat(jidp->barejid, from_jid->barejid, "[redacted]", PROF_IN_LOG, NULL);
}
prefs_free_string(pref_otr_log);
jid_destroy(jidp);
jid_destroy(from_jid);
}
if (!priv)
otr_free_message(newmessage);
#else
ui_incoming_msg(from, message, NULL, priv);
if (prefs_get_boolean(PREF_CHLOG) && !priv) {
Jid *from_jid = jid_create(from);
const char *jid = jabber_get_fulljid();
Jid *jidp = jid_create(jid);
chat_log_chat(jidp->barejid, from_jid->barejid, message, PROF_IN_LOG, NULL);
jid_destroy(jidp);
jid_destroy(from_jid);
}
#endif
}
static void
_check_autoaway()
{
jabber_conn_status_t conn_status = jabber_get_connection_status();
if (conn_status != JABBER_CONNECTED) {
return;
}
char *mode = prefs_get_string(PREF_AUTOAWAY_MODE);
gboolean check = prefs_get_boolean(PREF_AUTOAWAY_CHECK);
gint away_time = prefs_get_autoaway_time();
gint xa_time = prefs_get_autoxa_time();
int away_time_ms = away_time * 60000;
int xa_time_ms = xa_time * 60000;
char *account = jabber_get_account_name();
resource_presence_t curr_presence = accounts_get_last_presence(account);
char *curr_status = accounts_get_last_status(account);
unsigned long idle_ms = ui_get_idle_time();
switch (activity_state) {
case ACTIVITY_ST_ACTIVE:
if (idle_ms >= away_time_ms) {
if (g_strcmp0(mode, "away") == 0) {
if ((curr_presence == RESOURCE_ONLINE) || (curr_presence == RESOURCE_CHAT) || (curr_presence == RESOURCE_DND)) {
activity_state = ACTIVITY_ST_AWAY;
// save current presence
saved_presence = curr_presence;
if (saved_status) {
free(saved_status);
}
saved_status = curr_status;
// send away presence with last activity
char *message = prefs_get_string(PREF_AUTOAWAY_MESSAGE);
if (prefs_get_boolean(PREF_LASTACTIVITY)) {
cl_ev_presence_send(RESOURCE_AWAY, message, idle_ms / 1000);
} else {
cl_ev_presence_send(RESOURCE_AWAY, message, 0);
}
int pri = accounts_get_priority_for_presence_type(account, RESOURCE_AWAY);
if (message) {
cons_show("Idle for %d minutes, status set to away (priority %d), \"%s\".", away_time, pri, message);
} else {
cons_show("Idle for %d minutes, status set to away (priority %d).", away_time, pri);
}
prefs_free_string(message);
ui_titlebar_presence(CONTACT_AWAY);
}
} else if (g_strcmp0(mode, "idle") == 0) {
activity_state = ACTIVITY_ST_IDLE;
// send current presence with last activity
cl_ev_presence_send(curr_presence, curr_status, idle_ms / 1000);
}
}
break;
case ACTIVITY_ST_IDLE:
if (check && (idle_ms < away_time_ms)) {
activity_state = ACTIVITY_ST_ACTIVE;
cons_show("No longer idle.");
// send current presence without last activity
cl_ev_presence_send(curr_presence, curr_status, 0);
}
break;
case ACTIVITY_ST_AWAY:
if (xa_time_ms > 0 && (idle_ms >= xa_time_ms)) {
activity_state = ACTIVITY_ST_XA;
// send extended away presence with last activity
char *message = prefs_get_string(PREF_AUTOXA_MESSAGE);
if (prefs_get_boolean(PREF_LASTACTIVITY)) {
cl_ev_presence_send(RESOURCE_XA, message, idle_ms / 1000);
} else {
cl_ev_presence_send(RESOURCE_XA, message, 0);
}
int pri = accounts_get_priority_for_presence_type(account, RESOURCE_XA);
if (message) {
cons_show("Idle for %d minutes, status set to xa (priority %d), \"%s\".", xa_time, pri, message);
} else {
cons_show("Idle for %d minutes, status set to xa (priority %d).", xa_time, pri);
}
prefs_free_string(message);
ui_titlebar_presence(CONTACT_XA);
} else if (check && (idle_ms < away_time_ms)) {
activity_state = ACTIVITY_ST_ACTIVE;
cons_show("No longer idle.");
// send saved presence without last activity
cl_ev_presence_send(saved_presence, saved_status, 0);
contact_presence_t contact_pres = contact_presence_from_resource_presence(saved_presence);
ui_titlebar_presence(contact_pres);
}
break;
case ACTIVITY_ST_XA:
if (check && (idle_ms < away_time_ms)) {
activity_state = ACTIVITY_ST_ACTIVE;
cons_show("No longer idle.");
// send saved presence without last activity
cl_ev_presence_send(saved_presence, saved_status, 0);
contact_presence_t contact_pres = contact_presence_from_resource_presence(saved_presence);
ui_titlebar_presence(contact_pres);
}
break;
}
prefs_free_string(mode);
}
void
prefs_load(void)
{
GError *err;
prefs_loc = _get_preferences_file();
if (g_file_test(prefs_loc, G_FILE_TEST_EXISTS)) {
g_chmod(prefs_loc, S_IRUSR | S_IWUSR);
}
prefs = g_key_file_new();
g_key_file_load_from_file(prefs, prefs_loc, G_KEY_FILE_KEEP_COMMENTS,
NULL);
err = NULL;
log_maxsize = g_key_file_get_integer(prefs, PREF_GROUP_LOGGING, "maxsize", &err);
if (err) {
log_maxsize = 0;
g_error_free(err);
}
// move pre 0.4.7 otr.warn to enc.warn
err = NULL;
gboolean otr_warn = g_key_file_get_boolean(prefs, PREF_GROUP_UI, "otr.warn", &err);
if (err == NULL) {
g_key_file_set_boolean(prefs, PREF_GROUP_UI, _get_key(PREF_ENC_WARN), otr_warn);
g_key_file_remove_key(prefs, PREF_GROUP_UI, "otr.warn", NULL);
} else {
g_error_free(err);
}
// migrate pre 0.4.7 time settings format
if (g_key_file_has_key(prefs, PREF_GROUP_UI, "time", NULL)) {
char *time = g_key_file_get_string(prefs, PREF_GROUP_UI, "time", NULL);
if (g_strcmp0(time, "minutes") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time", "%H:%M");
} else if (g_strcmp0(time, "seconds") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time", "%H:%M:%S");
} else if (g_strcmp0(time, "off") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time", "");
}
prefs_free_string(time);
}
if (g_key_file_has_key(prefs, PREF_GROUP_UI, "time.statusbar", NULL)) {
char *time = g_key_file_get_string(prefs, PREF_GROUP_UI, "time.statusbar", NULL);
if (g_strcmp0(time, "minutes") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.statusbar", "%H:%M");
} else if (g_strcmp0(time, "seconds") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.statusbar", "%H:%M:%S");
} else if (g_strcmp0(time, "off") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.statusbar", "");
}
prefs_free_string(time);
}
_save_prefs();
boolean_choice_ac = autocomplete_new();
autocomplete_add(boolean_choice_ac, "on");
autocomplete_add(boolean_choice_ac, "off");
}
void
sv_ev_muc_occupant_online(const char *const room, const char *const nick, const char *const jid,
const char *const role, const char *const affiliation, const char *const actor, const char *const reason,
const char *const show, const char *const status)
{
Occupant *occupant = muc_roster_item(room, nick);
const char *old_role = NULL;
const char *old_affiliation = NULL;
if (occupant) {
old_role = muc_occupant_role_str(occupant);
old_affiliation = muc_occupant_affiliation_str(occupant);
}
gboolean updated = muc_roster_add(room, nick, jid, role, affiliation, show, status);
// not yet finished joining room
if (!muc_roster_complete(room)) {
return;
}
// handle nickname change
char *old_nick = muc_roster_nick_change_complete(room, nick);
if (old_nick) {
ProfMucWin *mucwin = wins_get_muc(room);
if (mucwin) {
mucwin_occupant_nick_change(mucwin, old_nick, nick);
}
wins_private_nick_change(mucwin->roomjid, old_nick, nick);
free(old_nick);
occupantswin_occupants(room);
rosterwin_roster();
return;
}
// joined room
if (!occupant) {
char *muc_status_pref = prefs_get_string(PREF_STATUSES_MUC);
ProfMucWin *mucwin = wins_get_muc(room);
if (mucwin && g_strcmp0(muc_status_pref, "none") != 0) {
mucwin_occupant_online(mucwin, nick, role, affiliation, show, status);
}
prefs_free_string(muc_status_pref);
Jid *jidp = jid_create_from_bare_and_resource(mucwin->roomjid, nick);
ProfPrivateWin *privwin = wins_get_private(jidp->fulljid);
jid_destroy(jidp);
if (privwin) {
privwin_occupant_online(privwin);
}
occupantswin_occupants(room);
rosterwin_roster();
return;
}
// presence updated
if (updated) {
char *muc_status_pref = prefs_get_string(PREF_STATUSES_MUC);
ProfMucWin *mucwin = wins_get_muc(room);
if (mucwin && (g_strcmp0(muc_status_pref, "all") == 0)) {
mucwin_occupant_presence(mucwin, nick, show, status);
}
prefs_free_string(muc_status_pref);
occupantswin_occupants(room);
// presence unchanged, check for role/affiliation change
} else {
ProfMucWin *mucwin = wins_get_muc(room);
if (mucwin && prefs_get_boolean(PREF_MUC_PRIVILEGES)) {
// both changed
if ((g_strcmp0(role, old_role) != 0) && (g_strcmp0(affiliation, old_affiliation) != 0)) {
mucwin_occupant_role_and_affiliation_change(mucwin, nick, role, affiliation, actor, reason);
// role changed
} else if (g_strcmp0(role, old_role) != 0) {
mucwin_occupant_role_change(mucwin, nick, role, actor, reason);
// affiliation changed
} else if (g_strcmp0(affiliation, old_affiliation) != 0) {
mucwin_occupant_affiliation_change(mucwin, nick, affiliation, actor, reason);
}
}
occupantswin_occupants(room);
}
rosterwin_roster();
}
void
sv_ev_muc_occupant_online(const char * const room, const char * const nick, const char * const jid,
const char * const role, const char * const affiliation, const char * const actor, const char * const reason,
const char * const show, const char * const status)
{
Occupant *occupant = muc_roster_item(room, nick);
const char *old_role = NULL;
const char *old_affiliation = NULL;
if (occupant) {
old_role = muc_occupant_role_str(occupant);
old_affiliation = muc_occupant_affiliation_str(occupant);
}
gboolean updated = muc_roster_add(room, nick, jid, role, affiliation, show, status);
// not yet finished joining room
if (!muc_roster_complete(room)) {
return;
}
// handle nickname change
char *old_nick = muc_roster_nick_change_complete(room, nick);
if (old_nick) {
ui_room_member_nick_change(room, old_nick, nick);
free(old_nick);
occupantswin_occupants(room);
return;
}
// joined room
if (!occupant) {
char *muc_status_pref = prefs_get_string(PREF_STATUSES_MUC);
if (g_strcmp0(muc_status_pref, "none") != 0) {
ui_room_member_online(room, nick, role, affiliation, show, status);
}
prefs_free_string(muc_status_pref);
occupantswin_occupants(room);
return;
}
// presence updated
if (updated) {
char *muc_status_pref = prefs_get_string(PREF_STATUSES_MUC);
if (g_strcmp0(muc_status_pref, "all") == 0) {
ui_room_member_presence(room, nick, show, status);
}
prefs_free_string(muc_status_pref);
occupantswin_occupants(room);
// presence unchanged, check for role/affiliation change
} else {
if (prefs_get_boolean(PREF_MUC_PRIVILEGES)) {
// both changed
if ((g_strcmp0(role, old_role) != 0) && (g_strcmp0(affiliation, old_affiliation) != 0)) {
ui_room_occupant_role_and_affiliation_change(room, nick, role, affiliation, actor, reason);
// role changed
} else if (g_strcmp0(role, old_role) != 0) {
ui_room_occupant_role_change(room, nick, role, actor, reason);
// affiliation changed
} else if (g_strcmp0(affiliation, old_affiliation) != 0) {
ui_room_occupant_affiliation_change(room, nick, affiliation, actor, reason);
}
}
occupantswin_occupants(room);
}
}
void
sv_ev_lastactivity_response(const char *const from, const int seconds, const char *const msg)
{
Jid *jidp = jid_create(from);
if (!jidp) {
return;
}
GDateTime *now = g_date_time_new_now_local();
GDateTime *active = g_date_time_add_seconds(now, 0 - seconds);
gchar *date_fmt = NULL;
char *time_pref = prefs_get_string(PREF_TIME_LASTACTIVITY);
date_fmt = g_date_time_format(active, time_pref);
prefs_free_string(time_pref);
assert(date_fmt != NULL);
// full jid - last activity
if (jidp->resourcepart) {
if (seconds == 0) {
if (msg) {
cons_show("%s currently active, status: %s", from, msg);
} else {
cons_show("%s currently active", from);
}
} else {
if (msg) {
cons_show("%s last active %s, status: %s", from, date_fmt, msg);
} else {
cons_show("%s last active %s", from, date_fmt);
}
}
// barejid - last logged in
} else if (jidp->localpart) {
if (seconds == 0) {
if (msg) {
cons_show("%s currently logged in, status: %s", from, msg);
} else {
cons_show("%s currently logged in", from);
}
} else {
if (msg) {
cons_show("%s last logged in %s, status: %s", from, date_fmt, msg);
} else {
cons_show("%s last logged in %s", from, date_fmt);
}
}
// domain only - uptime
} else {
int left = seconds;
int days = seconds / 86400;
left = left - days * 86400;
int hours = left / 3600;
left = left - hours * 3600;
int minutes = left / 60;
left = left - minutes * 60;
int seconds = left;
cons_show("%s up since %s, uptime %d days, %d hrs, %d mins, %d secs", from, date_fmt, days, hours, minutes, seconds);
}
g_date_time_unref(now);
g_date_time_unref(active);
g_free(date_fmt);
jid_destroy(jidp);
}
static void
_win_print(ProfWin *window, const char show_char, int pad_indent, GDateTime *time,
int flags, theme_item_t theme_item, const char *const from, const char *const message, DeliveryReceipt *receipt)
{
// flags : 1st bit = 0/1 - me/not me
// 2nd bit = 0/1 - date/no date
// 3rd bit = 0/1 - eol/no eol
// 4th bit = 0/1 - color from/no color from
// 5th bit = 0/1 - color date/no date
gboolean me_message = FALSE;
int offset = 0;
int colour = theme_attrs(THEME_ME);
size_t indent = 0;
char *time_pref = NULL;
switch (window->type) {
case WIN_CHAT:
time_pref = prefs_get_string(PREF_TIME_CHAT);
break;
case WIN_MUC:
time_pref = prefs_get_string(PREF_TIME_MUC);
break;
case WIN_MUC_CONFIG:
time_pref = prefs_get_string(PREF_TIME_MUCCONFIG);
break;
case WIN_PRIVATE:
time_pref = prefs_get_string(PREF_TIME_PRIVATE);
break;
case WIN_XML:
time_pref = prefs_get_string(PREF_TIME_XMLCONSOLE);
break;
default:
time_pref = prefs_get_string(PREF_TIME_CONSOLE);
break;
}
gchar *date_fmt = NULL;
if (g_strcmp0(time_pref, "off") == 0) {
date_fmt = g_strdup("");
} else {
date_fmt = g_date_time_format(time, time_pref);
}
prefs_free_string(time_pref);
assert(date_fmt != NULL);
if(strlen(date_fmt) != 0){
indent = 3 + strlen(date_fmt);
}
if ((flags & NO_DATE) == 0) {
if (date_fmt && strlen(date_fmt)) {
if ((flags & NO_COLOUR_DATE) == 0) {
wbkgdset(window->layout->win, theme_attrs(THEME_TIME));
wattron(window->layout->win, theme_attrs(THEME_TIME));
}
wprintw(window->layout->win, "%s %c ", date_fmt, show_char);
if ((flags & NO_COLOUR_DATE) == 0) {
wattroff(window->layout->win, theme_attrs(THEME_TIME));
}
}
}
if (from && strlen(from) > 0) {
if (flags & NO_ME) {
colour = theme_attrs(THEME_THEM);
}
if (flags & NO_COLOUR_FROM) {
colour = 0;
}
if (receipt && !receipt->received) {
colour = theme_attrs(THEME_RECEIPT_SENT);
}
wbkgdset(window->layout->win, colour);
wattron(window->layout->win, colour);
if (strncmp(message, "/me ", 4) == 0) {
wprintw(window->layout->win, "*%s ", from);
offset = 4;
me_message = TRUE;
} else {
wprintw(window->layout->win, "%s: ", from);
wattroff(window->layout->win, colour);
}
}
if (!me_message) {
if (receipt && !receipt->received) {
wbkgdset(window->layout->win, theme_attrs(THEME_RECEIPT_SENT));
wattron(window->layout->win, theme_attrs(THEME_RECEIPT_SENT));
} else {
wbkgdset(window->layout->win, theme_attrs(theme_item));
wattron(window->layout->win, theme_attrs(theme_item));
}
}
if (prefs_get_boolean(PREF_WRAP)) {
_win_print_wrapped(window->layout->win, message+offset, indent, pad_indent);
} else {
wprintw(window->layout->win, "%s", message+offset);
}
if ((flags & NO_EOL) == 0) {
int curx = getcurx(window->layout->win);
if (curx != 0) {
wprintw(window->layout->win, "\n");
}
}
if (me_message) {
wattroff(window->layout->win, colour);
} else {
if (receipt && !receipt->received) {
wattroff(window->layout->win, theme_attrs(THEME_RECEIPT_SENT));
} else {
wattroff(window->layout->win, theme_attrs(theme_item));
}
}
g_free(date_fmt);
}
void
prefs_load(void)
{
GError *err;
prefs_loc = _get_preferences_file();
if (g_file_test(prefs_loc, G_FILE_TEST_EXISTS)) {
g_chmod(prefs_loc, S_IRUSR | S_IWUSR);
}
prefs = g_key_file_new();
g_key_file_load_from_file(prefs, prefs_loc, G_KEY_FILE_KEEP_COMMENTS,
NULL);
err = NULL;
log_maxsize = g_key_file_get_integer(prefs, PREF_GROUP_LOGGING, "maxsize", &err);
if (err) {
log_maxsize = 0;
g_error_free(err);
}
// move pre 0.4.8 autoaway.time to autoaway.awaytime
if (g_key_file_has_key(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL)) {
gint time = g_key_file_get_integer(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL);
g_key_file_set_integer(prefs, PREF_GROUP_PRESENCE, "autoaway.awaytime", time);
g_key_file_remove_key(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL);
}
// move pre 0.4.8 autoaway.message to autoaway.awaymessage
if (g_key_file_has_key(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL)) {
char *message = g_key_file_get_string(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL);
g_key_file_set_string(prefs, PREF_GROUP_PRESENCE, "autoaway.awaymessage", message);
g_key_file_remove_key(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL);
prefs_free_string(message);
}
// migrate pre 0.4.8 time settings
if (g_key_file_has_key(prefs, PREF_GROUP_UI, "time", NULL)) {
char *time = g_key_file_get_string(prefs, PREF_GROUP_UI, "time", NULL);
char *val = NULL;
if (time) {
val = time;
} else {
val = "off";
}
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.console", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.chat", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.muc", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.mucconfig", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.private", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.xmlconsole", val);
g_key_file_remove_key(prefs, PREF_GROUP_UI, "time", NULL);
prefs_free_string(time);
}
_save_prefs();
boolean_choice_ac = autocomplete_new();
autocomplete_add(boolean_choice_ac, "on");
autocomplete_add(boolean_choice_ac, "off");
}
void
prefs_load(void)
{
GError *err;
prefs_loc = _get_preferences_file();
if (g_file_test(prefs_loc, G_FILE_TEST_EXISTS)) {
g_chmod(prefs_loc, S_IRUSR | S_IWUSR);
}
prefs = g_key_file_new();
g_key_file_load_from_file(prefs, prefs_loc, G_KEY_FILE_KEEP_COMMENTS, NULL);
err = NULL;
log_maxsize = g_key_file_get_integer(prefs, PREF_GROUP_LOGGING, "maxsize", &err);
if (err) {
log_maxsize = 0;
g_error_free(err);
}
// move pre 0.5.0 autoaway.time to autoaway.awaytime
if (g_key_file_has_key(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL)) {
gint time = g_key_file_get_integer(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL);
g_key_file_set_integer(prefs, PREF_GROUP_PRESENCE, "autoaway.awaytime", time);
g_key_file_remove_key(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL);
}
// move pre 0.5.0 autoaway.message to autoaway.awaymessage
if (g_key_file_has_key(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL)) {
char *message = g_key_file_get_string(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL);
g_key_file_set_string(prefs, PREF_GROUP_PRESENCE, "autoaway.awaymessage", message);
g_key_file_remove_key(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL);
prefs_free_string(message);
}
// migrate pre 0.5.0 time settings
if (g_key_file_has_key(prefs, PREF_GROUP_UI, "time", NULL)) {
char *time = g_key_file_get_string(prefs, PREF_GROUP_UI, "time", NULL);
char *val = NULL;
if (time) {
val = time;
} else {
val = "off";
}
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.console", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.chat", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.muc", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.mucconfig", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.private", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.xmlconsole", val);
g_key_file_remove_key(prefs, PREF_GROUP_UI, "time", NULL);
prefs_free_string(time);
}
// move pre 0.5.0 notify settings
if (g_key_file_has_key(prefs, PREF_GROUP_NOTIFICATIONS, "room", NULL)) {
char *value = g_key_file_get_string(prefs, PREF_GROUP_NOTIFICATIONS, "room", NULL);
if (g_strcmp0(value, "on") == 0) {
g_key_file_set_boolean(prefs, PREF_GROUP_NOTIFICATIONS, "room", TRUE);
} else if (g_strcmp0(value, "off") == 0) {
g_key_file_set_boolean(prefs, PREF_GROUP_NOTIFICATIONS, "room", FALSE);
} else if (g_strcmp0(value, "mention") == 0) {
g_key_file_set_boolean(prefs, PREF_GROUP_NOTIFICATIONS, "room", FALSE);
g_key_file_set_boolean(prefs, PREF_GROUP_NOTIFICATIONS, "room.mention", TRUE);
}
prefs_free_string(value);
}
_save_prefs();
boolean_choice_ac = autocomplete_new();
autocomplete_add(boolean_choice_ac, "on");
autocomplete_add(boolean_choice_ac, "off");
room_trigger_ac = autocomplete_new();
gsize len = 0;
gchar **triggers = g_key_file_get_string_list(prefs, PREF_GROUP_NOTIFICATIONS, "room.trigger.list", &len, NULL);
int i = 0;
for (i = 0; i < len; i++) {
autocomplete_add(room_trigger_ac, triggers[i]);
}
g_strfreev(triggers);
}
void
prof_run(const int disable_tls, char *log_level, char *account_name)
{
_init(disable_tls, log_level);
log_info("Starting main event loop");
ui_input_nonblocking();
GTimer *timer = g_timer_new();
gboolean cmd_result = TRUE;
jabber_conn_status_t conn_status = jabber_get_connection_status();
char inp[INP_WIN_MAX];
int size = 0;
char *pref_connect_account = prefs_get_string(PREF_CONNECT_ACCOUNT);
if (account_name != NULL) {
char *cmd = "/connect";
snprintf(inp, sizeof(inp), "%s %s", cmd, account_name);
process_input(inp);
} else if (pref_connect_account != NULL) {
char *cmd = "/connect";
snprintf(inp, sizeof(inp), "%s %s", cmd, pref_connect_account);
process_input(inp);
}
prefs_free_string(pref_connect_account);
ui_update();
while(cmd_result == TRUE) {
wint_t ch = ERR;
int result;
size = 0;
while(ch != '\n') {
conn_status = jabber_get_connection_status();
if (conn_status == JABBER_CONNECTED) {
_handle_idle_time();
}
gdouble elapsed = g_timer_elapsed(timer, NULL);
gint remind_period = prefs_get_notify_remind();
if (remind_period > 0 && elapsed >= remind_period) {
notify_remind();
g_timer_start(timer);
}
ui_handle_special_keys(&ch, result, inp, size);
#ifdef HAVE_LIBOTR
otr_poll();
#endif
jabber_process_events();
ui_update();
ch = ui_get_char(inp, &size, &result);
}
inp[size++] = '\0';
cmd_result = process_input(inp);
}
g_timer_destroy(timer);
}
jabber_conn_status_t
connection_connect(const char *const fulljid, const char *const passwd, const char *const altdomain, int port,
const char *const tls_policy)
{
assert(fulljid != NULL);
assert(passwd != NULL);
Jid *jid = jid_create(fulljid);
if (jid == NULL) {
log_error("Malformed JID not able to connect: %s", fulljid);
conn.conn_status = JABBER_DISCONNECTED;
return conn.conn_status;
} else if (jid->fulljid == NULL) {
log_error("Full JID required to connect, received: %s", fulljid);
conn.conn_status = JABBER_DISCONNECTED;
jid_destroy(jid);
return conn.conn_status;
}
jid_destroy(jid);
log_info("Connecting as %s", fulljid);
if (conn.xmpp_log) {
free(conn.xmpp_log);
}
conn.xmpp_log = _xmpp_get_file_logger();
if (conn.xmpp_conn) {
xmpp_conn_release(conn.xmpp_conn);
}
if (conn.xmpp_ctx) {
xmpp_ctx_free(conn.xmpp_ctx);
}
conn.xmpp_ctx = xmpp_ctx_new(NULL, conn.xmpp_log);
if (conn.xmpp_ctx == NULL) {
log_warning("Failed to get libstrophe ctx during connect");
return JABBER_DISCONNECTED;
}
conn.xmpp_conn = xmpp_conn_new(conn.xmpp_ctx);
if (conn.xmpp_conn == NULL) {
log_warning("Failed to get libstrophe conn during connect");
return JABBER_DISCONNECTED;
}
xmpp_conn_set_jid(conn.xmpp_conn, fulljid);
xmpp_conn_set_pass(conn.xmpp_conn, passwd);
if (!tls_policy || (g_strcmp0(tls_policy, "force") == 0)) {
xmpp_conn_set_flags(conn.xmpp_conn, XMPP_CONN_FLAG_MANDATORY_TLS);
} else if (g_strcmp0(tls_policy, "disable") == 0) {
xmpp_conn_set_flags(conn.xmpp_conn, XMPP_CONN_FLAG_DISABLE_TLS);
}
#ifdef HAVE_LIBMESODE
char *cert_path = prefs_get_string(PREF_TLS_CERTPATH);
if (cert_path) {
xmpp_conn_tlscert_path(conn.xmpp_conn, cert_path);
}
prefs_free_string(cert_path);
int connect_status = xmpp_connect_client(
conn.xmpp_conn,
altdomain,
port,
_connection_certfail_cb,
_connection_handler,
conn.xmpp_ctx);
#else
int connect_status = xmpp_connect_client(
conn.xmpp_conn,
altdomain,
port,
_connection_handler,
conn.xmpp_ctx);
#endif
if (connect_status == 0) {
conn.conn_status = JABBER_CONNECTING;
} else {
conn.conn_status = JABBER_DISCONNECTED;
}
return conn.conn_status;
}
