static void
sig_get_active_channel(const char **name)
{
*name = IS_XMPP_SERVER(active_win->active_server)
&& IS_CHANNEL(active_win->active) ?
((CHANNEL_REC *)active_win->active)->name : NULL;
}
static void
set_away(XMPP_SERVER_REC *server, const char *data)
{
char **tmp;
const char *reason;
int show, priority;
if (!IS_XMPP_SERVER(server))
return;
priority = settings_get_int("xmpp_priority");
tmp = g_strsplit(data, " ", 2);
if (*data == '\0') {
show = XMPP_PRESENCE_AVAILABLE;
reason = NULL;
} else {
show = xmpp_get_show(tmp[0]);
if (show == XMPP_PRESENCE_AVAILABLE && g_ascii_strcasecmp(
xmpp_presence_show[XMPP_PRESENCE_ONLINE], tmp[0]) != 0) {
show = xmpp_get_show(
settings_get_str("xmpp_default_away_mode"));
reason = data;
} else
reason = tmp[1];
if (show == XMPP_PRESENCE_AWAY)
priority = settings_get_int("xmpp_priority_away");
}
signal_emit("xmpp set presence", 4, server, show, reason,
priority);
g_strfreev(tmp);
}
static void
send_message(SERVER_REC *server, const char *target, const char *msg,
int target_type)
{
LmMessage *lmsg;
char *str, *recoded;
if (!IS_XMPP_SERVER(server))
return;
g_return_if_fail(target != NULL);
g_return_if_fail(msg != NULL);
if (target_type == SEND_TARGET_CHANNEL) {
recoded = xmpp_recode_out(target);
lmsg = lm_message_new_with_sub_type(recoded,
LM_MESSAGE_TYPE_MESSAGE, LM_MESSAGE_SUB_TYPE_GROUPCHAT);
} else {
str = rosters_resolve_name(XMPP_SERVER(server), target);
recoded = xmpp_recode_out(str != NULL ? str : target);
g_free(str);
lmsg = lm_message_new_with_sub_type(recoded,
LM_MESSAGE_TYPE_MESSAGE, LM_MESSAGE_SUB_TYPE_CHAT);
}
g_free(recoded);
/* ugly from irssi: recode the sent message back */
str = recode_in(server, msg, target);
recoded = xmpp_recode_out(str);
g_free(str);
lm_message_node_add_child(lmsg->node, "body", recoded);
g_free(recoded);
signal_emit("xmpp send message", 2, server, lmsg);
lm_message_unref(lmsg);
}
static GList *
get_resources(XMPP_SERVER_REC *server, const char *nick,
const char *resource_name, gboolean quoted)
{
GSList *rl;
GList *list;
XMPP_ROSTER_USER_REC *user;
XMPP_ROSTER_RESOURCE_REC *resource;
size_t len;
g_return_val_if_fail(IS_XMPP_SERVER(server), NULL);
g_return_val_if_fail(nick != NULL, NULL);
len = resource_name != NULL ? strlen(resource_name) : 0;
list = NULL;
user = rosters_find_user(server->roster, nick, NULL, NULL);
if (user == NULL)
return NULL;
for(rl = user->resources; rl != NULL; rl = rl->next) {
resource = rl->data;
if (resource_name == NULL
|| g_ascii_strncasecmp(resource->name, resource_name, len) == 0)
list = g_list_append(list, quoted ?
quoted_if_space(nick, resource->name) :
g_strconcat(nick, "/", resource->name, (void *)NULL));
}
return list;
}
static void
sig_presence_changed(XMPP_SERVER_REC *server, const char *full_jid,
int show, const char *status)
{
XMPP_ROSTER_USER_REC *user;
WINDOW_REC *window;
const char *msg;
char *name;
g_return_if_fail(IS_XMPP_SERVER(server));
g_return_if_fail(full_jid != NULL);
g_return_if_fail(0 <= show && show < XMPP_PRESENCE_SHOW_LEN);
window = fe_xmpp_status_get_window(server);
msg = fe_xmpp_presence_show[show];
user = rosters_find_user(server->roster, full_jid, NULL, NULL);
name = user != NULL && user->name != NULL ?
format_get_text(MODULE_NAME, NULL, server, NULL,
XMPPTXT_FORMAT_NAME, user->name, full_jid) :
format_get_text(MODULE_NAME, NULL, server, NULL,
XMPPTXT_FORMAT_JID, full_jid);
if (status != NULL)
printformat_module_window(MODULE_NAME, window, MSGLEVEL_CRAP,
XMPPTXT_PRESENCE_CHANGE_REASON, name, msg, status);
else
printformat_module_window(MODULE_NAME, window, MSGLEVEL_CRAP,
XMPPTXT_PRESENCE_CHANGE, name, msg);
g_free(name);
}
void
muc_join(XMPP_SERVER_REC *server, const char *data, gboolean automatic)
{
MUC_REC *channel;
char *chanline, *channame, *nick, *key;
void *free_arg;
g_return_if_fail(IS_XMPP_SERVER(server));
g_return_if_fail(data != NULL);
if (!server->connected)
return;
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST,
&chanline, &key))
return;
nick = muc_extract_nick(chanline);
channame = muc_extract_channel(chanline);
if (muc_find(server, channame) == NULL) {
channel = (MUC_REC *)muc_create(server,
channame, NULL, automatic, nick);
channel->key = (key == NULL || *key == '\0') ?
NULL : g_strdup(key);
send_join(channel);
}
g_free(nick);
g_free(channame);
cmd_params_free(free_arg);
}
static GList *
get_channels(XMPP_SERVER_REC *server, const char *word)
{
GSList *tmp;
GList *list;
CHANNEL_REC *channel;
CHANNEL_SETUP_REC *channel_setup;
int len;
g_return_val_if_fail(IS_XMPP_SERVER(server), NULL);
g_return_val_if_fail(word != NULL, NULL);
len = strlen(word);
list = NULL;
for (tmp = server->channels; tmp != NULL; tmp = tmp->next) {
channel = CHANNEL(tmp->data);
if (channel != NULL &&
g_ascii_strncasecmp(channel->name, word, len) == 0)
list = g_list_append(list, g_strdup(channel->name));
}
for (tmp = setupchannels; tmp != NULL; tmp = tmp->next) {
channel_setup = tmp->data;
if ((PROTO_CHECK_CAST(channel_setup, CHANNEL_SETUP_REC,
chat_type, XMPP_PROTOCOL_NAME)
|| *channel_setup->name != '#')
&& g_ascii_strncasecmp(channel_setup->name, word, len) == 0
&& glist_find_string(list, channel_setup->name) == NULL)
list = g_list_append(list,
g_strdup(channel_setup->name));
}
return list;
}
static void
sig_connected(XMPP_SERVER_REC *server)
{
if (!IS_XMPP_SERVER(server) || !server->connrec->reconnection)
return;
restore_channels(server);
}
static void
sig_roster_show(XMPP_SERVER_REC *server)
{
GSList *gl, *ul;
XMPP_ROSTER_GROUP_REC *group;
XMPP_ROSTER_USER_REC *user;
g_return_if_fail(IS_XMPP_SERVER(server));
show_begin_of_roster(server);
for (gl = server->roster; gl != NULL; gl = gl->next) {
group = gl->data;
/* don't show groups with only offline users */
for (ul = group->users; ul != NULL
&& !user_is_shown(ul->data); ul = ul->next);
if (ul == NULL)
continue;
show_group(server, group);
for (ul = group->users; ul != NULL; ul = ul->next) {
user = ul->data;
if (user_is_shown(user))
show_user(server, user);
}
}
printformat_module(MODULE_NAME, server, NULL, MSGLEVEL_CRAP,
XMPPTXT_END_OF_ROSTER);
}
static void
show_begin_of_roster(XMPP_SERVER_REC *server)
{
char *show, *status, *priority, *text, *resources, *pgp_keyid;
g_return_if_fail(IS_XMPP_SERVER(server));
show = (server->show == XMPP_PRESENCE_AVAILABLE) ? NULL :
format_get_text(MODULE_NAME, NULL, server, NULL,
XMPPTXT_FORMAT_RESOURCE_SHOW,
xmpp_presence_show[server->show]);
status = (server->away_reason == NULL
|| strcmp(server->away_reason, " ") == 0) ? NULL :
format_get_text(MODULE_NAME, NULL, server, NULL,
XMPPTXT_FORMAT_RESOURCE_STATUS, server->away_reason);
priority = g_strdup_printf("%d", server->priority);
pgp_keyid = !settings_get_str("xmpp_pgp") ? NULL : \
format_get_text(MODULE_NAME, NULL, server, NULL,
XMPPTXT_FORMAT_PGP_KEYID, settings_get_str("xmpp_pgp"));
text = format_get_text(MODULE_NAME, NULL, server, NULL,
XMPPTXT_FORMAT_RESOURCE, show, server->resource, priority,
status, pgp_keyid);
g_free(show);
g_free(status);
g_free(priority);
resources = get_resources(server, server->my_resources);
printformat_module(MODULE_NAME, server, NULL, MSGLEVEL_CRAP,
XMPPTXT_BEGIN_OF_ROSTER, server->jid, text, resources);
g_free(text);
g_free(resources);
}
static void
disconnect_all(void)
{
GSList *tmp, *next;
for (tmp = lookup_servers; tmp != NULL; tmp = next) {
next = tmp->next;
if (IS_XMPP_SERVER(tmp->data))
server_connect_failed(SERVER(tmp->data), NULL);
}
for (tmp = servers; tmp != NULL; tmp = next) {
next = tmp->next;
if (IS_XMPP_SERVER(tmp->data))
server_disconnect(SERVER(tmp->data));
}
}
static void
sig_server_connecting(XMPP_SERVER_REC *server)
{
if (!IS_XMPP_SERVER(server))
return;
if (settings_get_bool("xmpp_status_window"))
fe_xmpp_status_get_window(server);
}
static void
sig_disconnected(XMPP_SERVER_REC *server)
{
if (!IS_XMPP_SERVER(server))
return;
cleanup_features(server->server_features);
server->server_features = NULL;
}
static char *
get_window_name(XMPP_SERVER_REC *server)
{
g_return_val_if_fail(IS_XMPP_SERVER(server), NULL);
return g_strconcat("(", (server->connrec->chatnet == NULL ||
*server->connrec->chatnet == '\0') ? server->jid :
server->connrec->chatnet, ")", (void *)NULL);
}
static void
sig_connected(XMPP_SERVER_REC *server)
{
if (!IS_XMPP_SERVER(server) || !server->connrec->reconnection)
return;
signal_emit("xmpp set presence", 4, server, server->connrec->show,
server->connrec->away_reason, server->connrec->priority);
g_free_and_null(server->connrec->away_reason);
}
static void
sig_save_status(XMPP_SERVER_CONNECT_REC *conn,
XMPP_SERVER_REC *server)
{
if (!IS_XMPP_SERVER_CONNECT(conn) || !IS_XMPP_SERVER(server)
|| !server->connected)
return;
save_channels(server, conn);
}
static void
sig_save_status(XMPP_SERVER_CONNECT_REC *conn, XMPP_SERVER_REC *server)
{
if (!IS_XMPP_SERVER_CONNECT(conn) || !IS_XMPP_SERVER(server)
|| !server->connected)
return;
conn->show = server->show;
conn->priority = server->priority;
}
static void
sig_composing_stop(XMPP_SERVER_REC *server, const char *dest)
{
DATALIST_REC *rec;
g_return_if_fail(IS_XMPP_SERVER(server));
g_return_if_fail(dest != NULL);
if ((rec = datalist_find(composings, server, dest)) != NULL)
send_stop(server, dest, rec->data);
}
char *
fe_xmpp_status_get_window_name(XMPP_SERVER_REC *server)
{
WINDOW_REC *window;
char *name;
g_return_val_if_fail(IS_XMPP_SERVER(server), NULL);
if ((name = get_window_name(server)) == NULL)
return NULL;
window = window_find_name(name);
g_free(name);
return (window != NULL) ? window->name : NULL;
}
static void
send_stanza(XMPP_SERVER_REC *server, LmMessage *lmsg)
{
char *xml, *recoded;
g_return_if_fail(IS_XMPP_SERVER(server));
g_return_if_fail(lmsg != NULL);
xml = lm_message_node_to_string(lmsg->node);
recoded = xmpp_recode_in(xml);
g_free(xml);
signal_emit("xmpp xml out", 2, server, recoded);
g_free(recoded);
lm_connection_send(server->lmconn, lmsg, NULL);
}
static void
sig_set_presence(XMPP_SERVER_REC *server, const int show, const char *status,
const int priority)
{
GSList *tmp;
MUC_REC *channel;
g_return_if_fail(IS_XMPP_SERVER(server));
if (!server->connected)
return;
for (tmp = server->channels; tmp != NULL; tmp = tmp->next) {
channel = MUC(tmp->data);
send_muc_presence(channel, show, status);
}
}
static void
unregister_stanzas(XMPP_SERVER_REC *server)
{
GSList *tmp, *next;
if (!IS_XMPP_SERVER(server))
return;
for (tmp = server->msg_handlers; tmp != NULL; tmp = next) {
next = tmp->next;
if (lm_message_handler_is_valid(tmp->data))
lm_message_handler_invalidate(tmp->data);
lm_message_handler_unref(tmp->data);
server->msg_handlers =
g_slist_remove(server->msg_handlers, tmp->data);
}
}
WINDOW_REC *
fe_xmpp_status_get_window(XMPP_SERVER_REC *server)
{
WINDOW_REC *window;
char *name;
g_return_val_if_fail(IS_XMPP_SERVER(server), NULL);
name = get_window_name(server);
if ((window = window_find_name(name)) == NULL) {
window = window_create(NULL, TRUE);
window_set_name(window, name);
window_change_server(window, server);
}
g_free(name);
return window;
}
static void
sig_disconnected(XMPP_SERVER_REC *server)
{
GSList *tmp;
XMPP_QUERY_REC *query;
if (!IS_XMPP_SERVER(server))
return;
for (tmp = queries; tmp != NULL; tmp = tmp->next) {
query = XMPP_QUERY(tmp->data);
if (query == NULL)
continue;
if (query->server == server)
g_source_remove_by_user_data(query);
}
}
static void
sig_server_quit(XMPP_SERVER_REC *server, char *reason)
{
LmMessage *lmsg;
char *str;
if (!IS_XMPP_SERVER(server))
return;
lmsg = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_PRESENCE,
LM_MESSAGE_SUB_TYPE_UNAVAILABLE);
str = xmpp_recode_out((reason != NULL) ?
reason : settings_get_str("quit_message"));
lm_message_node_add_child(lmsg->node, "status", str);
g_free(str);
signal_emit("xmpp send presence", 2, server, lmsg);
lm_message_unref(lmsg);
}
static void
server_cleanup(XMPP_SERVER_REC *server)
{
if (!IS_XMPP_SERVER(server))
return;
if (server->timeout_tag)
g_source_remove(server->timeout_tag);
if (lm_connection_get_state(server->lmconn) !=
LM_CONNECTION_STATE_CLOSED)
lm_connection_close(server->lmconn, NULL);
lm_connection_unref(server->lmconn);
g_free(server->jid);
g_free(server->user);
g_free(server->domain);
g_free(server->resource);
g_free(server->ping_id);
}
static void
register_stanzas(XMPP_SERVER_REC *server)
{
LmMessageHandler *h;
int i;
if (!IS_XMPP_SERVER(server))
return;
if (server->msg_handlers != NULL &&
g_slist_length(server->msg_handlers) != 0)
unregister_stanzas(server);
for(i = 0; message_types[i] != -1; ++i) {
h = lm_message_handler_new(handle_stanza, server, NULL);
lm_connection_register_message_handler(server->lmconn, h,
message_types[i], LM_HANDLER_PRIORITY_NORMAL);
server->msg_handlers = g_slist_prepend(server->msg_handlers, h);
}
}
CHANNEL_REC *
muc_create(XMPP_SERVER_REC *server, const char *name,
const char *visible_name, int automatic, const char *nick)
{
MUC_REC *rec;
g_return_val_if_fail(IS_XMPP_SERVER(server), NULL);
g_return_val_if_fail(name != NULL, NULL);
rec = g_new0(MUC_REC, 1);
rec->chat_type = XMPP_PROTOCOL;
rec->nick = g_strdup((nick != NULL) ? nick :
(*settings_get_str("nick") != '\0') ?
settings_get_str("nick") : server->user);
channel_init((CHANNEL_REC *)rec, SERVER(server), name, visible_name,
automatic);
rec->get_join_data = (char *(*)(CHANNEL_REC *))get_join_data;
return (CHANNEL_REC *)rec;
}
void
disco_request(XMPP_SERVER_REC *server, const char *dest)
{
LmMessage *lmsg;
LmMessageNode *node;
char *recoded;
g_return_if_fail(IS_XMPP_SERVER(server));
g_return_if_fail(dest != NULL && dest != '\0');
recoded = xmpp_recode_out(dest);
lmsg = lm_message_new_with_sub_type(recoded, LM_MESSAGE_TYPE_IQ,
LM_MESSAGE_SUB_TYPE_GET);
g_free(recoded);
node = lm_message_node_add_child(lmsg->node, "query", NULL);
lm_message_node_set_attribute(node, XMLNS, XMLNS_DISCO);
signal_emit("xmpp send iq", 2, server, lmsg);
lm_message_unref(lmsg);
}
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);
}
