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 void
send_part(MUC_REC *channel, const char *reason)
{
LmMessage *lmsg;
LmMessageNode *node;
char *channame, *recoded;
if (!channel->server->connected)
return;
channame = g_strconcat(channel->name, "/", channel->nick, NULL);
recoded = xmpp_recode_out(channame);
g_free(channame);
lmsg = lm_message_new_with_sub_type(recoded,
LM_MESSAGE_TYPE_PRESENCE, LM_MESSAGE_SUB_TYPE_UNAVAILABLE);
g_free(recoded);
node = lm_message_node_add_child(lmsg->node, "x", NULL);
lm_message_node_set_attribute(node, XMLNS, XMLNS_MUC);
if (reason != NULL) {
recoded = xmpp_recode_out(reason);
lm_message_node_add_child(lmsg->node, "status", recoded);
g_free(recoded);
}
signal_emit("xmpp send presence", 2, channel->server, lmsg);
lm_message_unref(lmsg);
}
static void
send_register(struct register_data *rd)
{
LmMessage *lmsg;
LmMessageNode *node;
char *recoded;
lmsg = lm_message_new_with_sub_type(rd->domain,
LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_SET);
node = lm_message_node_add_child(lmsg->node, "query", NULL);
lm_message_node_set_attribute(node, XMLNS, XMLNS_REGISTER);
recoded = xmpp_recode_out(rd->username);
lm_message_node_add_child(node, "username", recoded);
g_free(recoded);
recoded = xmpp_recode_out(rd->password);
lm_message_node_add_child(node, "password", recoded);
g_free(recoded);
rd->id = g_strdup(lm_message_node_get_attribute(lmsg->node, "id"));
if (!lm_connection_send_with_reply(rd->lmconn, lmsg, rd->handler,
NULL)) {
signal_emit("xmpp registration failed", 3, rd->username,
rd->domain, REGISTRATION_ERROR_INFO);
rd_cleanup(rd);
}
lm_message_unref(lmsg);
}
/* SYNTAX: XMPPPASSWD -yes <old_password> <new_password> */
static void
cmd_xmpppasswd(const char *data, SERVER_REC *server, WI_ITEM_REC *item)
{
GHashTable *optlist;
char *old_password, *new_password, *recoded;
LmMessage *lmsg;
LmMessageNode *node;
void *free_arg;
CMD_XMPP_SERVER(server);
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_OPTIONS,
"xmpppasswd", &optlist, &old_password, &new_password))
return;
if (g_hash_table_lookup(optlist, "yes") == NULL)
cmd_param_error(CMDERR_NOT_GOOD_IDEA);
if (strcmp(old_password, server->connrec->password) != 0)
cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
lmsg = lm_message_new_with_sub_type(XMPP_SERVER(server)->domain,
LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_SET);
node = lm_message_node_add_child(lmsg->node, "query", NULL);
lm_message_node_set_attribute(node, XMLNS, XMLNS_REGISTER);
recoded = xmpp_recode_out(XMPP_SERVER(server)->user);
lm_message_node_add_child(node, "username", recoded);
g_free(recoded);
recoded = xmpp_recode_out(new_password);
lm_message_node_add_child(node, "password", recoded);
g_free(recoded);
signal_emit("xmpp send iq", 2, server, lmsg);
lm_message_unref(lmsg);
cmd_params_free(free_arg);
}
/* SYNTAX: PRESENCE SUBSCRIBE <jid> [<reason>] */
static void
cmd_presence_subscribe(const char *data, XMPP_SERVER_REC *server)
{
LmMessage *lmsg;
const char *jid, *reason;
char *recoded;
void *free_arg;
CMD_XMPP_SERVER(server);
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST, &jid,
&reason))
return;
if (*jid == '\0')
cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
recoded = xmpp_recode_out(jid);
lmsg = lm_message_new_with_sub_type(recoded,
LM_MESSAGE_TYPE_PRESENCE, LM_MESSAGE_SUB_TYPE_SUBSCRIBE);
g_free(recoded);
if (*reason != '\0') {
recoded = xmpp_recode_out(reason);
lm_message_node_add_child(lmsg->node, "status", recoded);
g_free(recoded);
}
signal_emit("xmpp send presence", 2, server, lmsg);
lm_message_unref(lmsg);
cmd_params_free(free_arg);
}
static void
lm_open_cb(LmConnection *connection, gboolean success,
gpointer user_data)
{
XMPP_SERVER_REC *server;
IPADDR ip;
char *host;
char *recoded_user, *recoded_password, *recoded_resource;
if ((server = XMPP_SERVER(user_data)) == NULL || !success)
return;
/* get the server address */
host = lm_connection_get_local_host(server->lmconn);
if (host != NULL) {
net_host2ip(host, &ip);
signal_emit("server connecting", 2, server, &ip);
g_free(host);
} else
signal_emit("server connecting", 1, server);
if (server->connrec->use_ssl)
signal_emit("xmpp server status", 2, server,
"Using SSL encryption.");
else if (lm_ssl_get_use_starttls(lm_connection_get_ssl(server->lmconn)))
signal_emit("xmpp server status", 2, server,
"Using STARTTLS encryption.");
recoded_user = xmpp_recode_out(server->user);
/* prompt for password or re-use typed password */
if (server->connrec->prompted_password != NULL) {
g_free_not_null(server->connrec->password);
server->connrec->password =
g_strdup(server->connrec->prompted_password);
} else if (server->connrec->password == NULL
|| *(server->connrec->password) == '\0'
|| *(server->connrec->password) == '\r') {
g_free_not_null(server->connrec->password);
server->connrec->prompted_password = get_password();
signal_emit("send command", 1, "redraw");
if (server->connrec->prompted_password != NULL)
server->connrec->password =
g_strdup(server->connrec->prompted_password);
else
server->connrec->password = g_strdup("");
}
recoded_password = xmpp_recode_out(server->connrec->password);
recoded_resource = xmpp_recode_out(server->resource);
lm_connection_authenticate(connection, recoded_user,
recoded_password, recoded_resource, lm_auth_cb, server,
NULL, NULL);
g_free(recoded_user);
g_free(recoded_password);
g_free(recoded_resource);
}
gboolean
set_proxy(LmConnection *lmconn, GError **error)
{
LmProxy *proxy;
LmProxyType type;
const char *str;
char *recoded;
str = settings_get_str("xmpp_proxy_type");
if (str != NULL && g_ascii_strcasecmp(str, XMPP_PROXY_HTTP) == 0)
type = LM_PROXY_TYPE_HTTP;
else {
if (error != NULL) {
*error = g_new(GError, 1);
(*error)->message = g_strdup("Invalid proxy type");
}
return FALSE;
}
str = settings_get_str("xmpp_proxy_address");
if (str == NULL || *str == '\0') {
if (error != NULL) {
*error = g_new(GError, 1);
(*error)->message =
g_strdup("Proxy address not specified");
}
return FALSE;
}
int port = settings_get_int("xmpp_proxy_port");
if (port <= 0) {
if (error != NULL) {
*error = g_new(GError, 1);
(*error)->message =
g_strdup("Invalid proxy port range");
}
return FALSE;
}
proxy = lm_proxy_new_with_server(type, str, port);
str = settings_get_str("xmpp_proxy_user");
if (str != NULL && *str != '\0') {
recoded = xmpp_recode_out(str);
lm_proxy_set_username(proxy, recoded);
g_free(recoded);
}
str = settings_get_str("xmpp_proxy_password");
if (str != NULL && *str != '\0') {
recoded = xmpp_recode_out(str);
lm_proxy_set_password(proxy, recoded);
g_free(recoded);
}
lm_connection_set_proxy(lmconn, proxy);
lm_proxy_unref(proxy);
return TRUE;
}
/* SYNTAX: ROSTER ADD <jid> */
static void
cmd_roster_add(const char *data, XMPP_SERVER_REC *server)
{
LmMessage *lmsg;
LmMessageNode *query_node, *item_node;
GHashTable *optlist;
const char *jid;
char *jid_recoded;
void *free_arg;
CMD_XMPP_SERVER(server);
if (!cmd_get_params(data, &free_arg, 1 | PARAM_FLAG_OPTIONS,
"roster add", &optlist, &jid))
return;
if (*jid == '\0')
cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
lmsg = lm_message_new_with_sub_type(NULL,
LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_SET);
query_node = lm_message_node_add_child(lmsg->node, "query", NULL);
lm_message_node_set_attribute(query_node, "xmlns", "jabber:iq:roster");
jid_recoded = xmpp_recode_out(jid);
item_node = lm_message_node_add_child(query_node, "item", NULL);
lm_message_node_set_attribute(item_node, "jid", jid_recoded);
signal_emit("xmpp send iq", 2, server, lmsg);
lm_message_unref(lmsg);
if (g_hash_table_lookup(optlist, "nosub") == NULL) {
lmsg = lm_message_new_with_sub_type(jid_recoded,
LM_MESSAGE_TYPE_PRESENCE, LM_MESSAGE_SUB_TYPE_SUBSCRIBE);
signal_emit("xmpp send presence", 2, server, lmsg);
lm_message_unref(lmsg);
}
g_free(jid_recoded);
cmd_params_free(free_arg);
}
static void
send_disco(XMPP_SERVER_REC *server, const char *dest)
{
LmMessage *lmsg;
LmMessageNode *node, *child;
GSList *tmp;
char *recoded;
recoded = xmpp_recode_out(dest);
lmsg = lm_message_new_with_sub_type(recoded, LM_MESSAGE_TYPE_IQ,
LM_MESSAGE_SUB_TYPE_RESULT);
g_free(recoded);
node = lm_message_node_add_child(lmsg->node, "query", NULL);
lm_message_node_set_attribute(node, XMLNS, XMLNS_DISCO);
child = lm_message_node_add_child(node, "identity", NULL);
lm_message_node_set_attribute(child, "category", "client");
lm_message_node_set_attribute(child, "type", "console");
lm_message_node_set_attribute(child, "name", IRSSI_XMPP_PACKAGE);
for (tmp = my_features; tmp != NULL; tmp = tmp->next) {
child = lm_message_node_add_child(node, "feature", NULL);
lm_message_node_set_attribute(child, "var", tmp->data);
}
signal_emit("xmpp send iq", 2, server, lmsg);
lm_message_unref(lmsg);
}
/* SYNTAX: ROSTER REMOVE <jid> */
static void
cmd_roster_remove(const char *data, XMPP_SERVER_REC *server)
{
LmMessage *lmsg;
LmMessageNode *query_node, *item_node;
XMPP_ROSTER_USER_REC *user;
const char *jid;
char *recoded;
void *free_arg;
CMD_XMPP_SERVER(server);
if (!cmd_get_params(data, &free_arg, 1, &jid))
return;
if (*jid == '\0')
cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
user = rosters_find_user(server->roster, jid, NULL, NULL);
if (user == NULL) {
signal_emit("xmpp not in roster", 2, server, jid);
goto out;
}
lmsg = lm_message_new_with_sub_type(NULL,
LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_SET);
query_node = lm_message_node_add_child(lmsg->node, "query", NULL);
lm_message_node_set_attribute(query_node, "xmlns", "jabber:iq:roster");
item_node = lm_message_node_add_child(query_node, "item", NULL);
recoded = xmpp_recode_out(jid);
lm_message_node_set_attribute(item_node, "jid", recoded);
g_free(recoded);
lm_message_node_set_attribute(item_node, "subscription", "remove");
signal_emit("xmpp send iq", 2, server, lmsg);
lm_message_unref(lmsg);
out:
cmd_params_free(free_arg);
}
static void
send_version(XMPP_SERVER_REC *server, const char *dest,
const char *id)
{
LmMessage *lmsg;
LmMessageNode *node;
struct utsname u;
char *recoded;
recoded = xmpp_recode_out(dest);
lmsg = lm_message_new_with_sub_type(recoded, LM_MESSAGE_TYPE_IQ,
LM_MESSAGE_SUB_TYPE_RESULT);
g_free(recoded);
if (id != NULL)
lm_message_node_set_attribute(lmsg->node, "id", id);
node = lm_message_node_add_child(lmsg->node, "query", NULL);
lm_message_node_set_attribute(node, XMLNS, XMLNS_VERSION);
if (settings_get_bool("xmpp_send_version")) {
lm_message_node_add_child(node, "name",
IRSSI_XMPP_PACKAGE);
lm_message_node_add_child(node, "version",
IRSSI_XMPP_VERSION);
if (uname(&u) == 0)
lm_message_node_add_child(node, "os", u.sysname);
}
signal_emit("xmpp send iq", 2, server, lmsg);
lm_message_unref(lmsg);
}
void
muc_nick(MUC_REC *channel, const char *nick)
{
LmMessage *lmsg;
LmMessageNode *node;
char *recoded, *str;
g_return_if_fail(IS_MUC(channel));
if (!channel->server->connected)
return;
str = g_strconcat(channel->name, "/", nick, NULL);
recoded = xmpp_recode_out(str);
g_free(str);
lmsg = lm_message_new(recoded, LM_MESSAGE_TYPE_PRESENCE);
g_free(recoded);
node = lm_message_node_add_child(lmsg->node, "x", NULL);
lm_message_node_set_attribute(node, XMLNS, XMLNS_MUC);
if (!channel->joined) {
if (channel->key != NULL) {
recoded = xmpp_recode_out(channel->key);
lm_message_node_add_child(node, "password", recoded);
g_free(recoded);
}
node = lm_message_node_add_child(node, "history", NULL);
str = g_strdup_printf("%d",
settings_get_int("xmpp_history_maxstanzas"));
lm_message_node_set_attribute(node, "maxstanzas", str);
g_free(str);
if (channel->server->show != XMPP_PRESENCE_AVAILABLE) {
recoded = xmpp_recode_out(
xmpp_presence_show[channel->server->show]);
lm_message_node_add_child(lmsg->node, "show", recoded);
g_free(recoded);
}
if (channel->server->away_reason != NULL) {
recoded = xmpp_recode_out(
channel->server->away_reason);
lm_message_node_add_child(lmsg->node, "status",
recoded);
g_free(recoded);
}
}
signal_emit("xmpp send presence", 2, channel->server, lmsg);
lm_message_unref(lmsg);
}
static void
send_muc_presence(MUC_REC *channel, const int show, const char *status)
{
LmMessage *lmsg;
char *channame, *str;
channame = g_strconcat(channel->name, "/", channel->nick, NULL);
str = xmpp_recode_out(channame);
g_free(channame);
lmsg = lm_message_new(str, LM_MESSAGE_TYPE_PRESENCE);
g_free(str);
if (show != XMPP_PRESENCE_AVAILABLE)
lm_message_node_add_child(lmsg->node, "show",
xmpp_presence_show[show]);
if (status != NULL) {
str = xmpp_recode_out(status);
lm_message_node_add_child(lmsg->node, "status", str);
g_free(str);
}
signal_emit("xmpp send presence", 2, channel->server, lmsg);
lm_message_unref(lmsg);
}
static void
request_version(XMPP_SERVER_REC *server, const char *dest)
{
LmMessage *lmsg;
LmMessageNode *node;
char *recoded;
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_VERSION);
signal_emit("xmpp send iq", 2, server, lmsg);
lm_message_unref(lmsg);
}
/* SYNTAX: QUOTE <raw_command> */
static void
cmd_quote(const char *data, XMPP_SERVER_REC *server)
{
char *recoded;
CMD_XMPP_SERVER(server);
if (*data == '\0')
cmd_return_error(CMDERR_NOT_ENOUGH_PARAMS);
g_strstrip((char *)data);
if (*data == '\0')
cmd_return_error(CMDERR_NOT_ENOUGH_PARAMS);
signal_emit("xmpp xml out", 2, server, data);
recoded = xmpp_recode_out(data);
lm_connection_send_raw(server->lmconn, recoded, NULL);
g_free(recoded);
}
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);
}
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);
}
static void
send_composing_event(XMPP_SERVER_REC *server, const char *dest, const char *id,
gboolean composing)
{
LmMessage *lmsg;
LmMessageNode *node;
char *recoded;
recoded = xmpp_recode_out(dest);
lmsg = lm_message_new_with_sub_type(recoded,
LM_MESSAGE_TYPE_MESSAGE, LM_MESSAGE_SUB_TYPE_CHAT);
g_free(recoded);
node = lm_message_node_add_child(lmsg->node, "x", NULL);
lm_message_node_set_attribute(node, XMLNS, XMLNS_EVENT);
if (composing)
lm_message_node_add_child(node, "composing", NULL);
if (id != NULL)
lm_message_node_add_child(node, "id", id);
signal_emit("xmpp send message", 2, server, lmsg);
lm_message_unref(lmsg);
}
/* SYNTAX: PRESENCE UNSUBSCRIBE <jid> */
static void
cmd_presence_unsubscribe(const char *data, XMPP_SERVER_REC *server)
{
LmMessage *lmsg;
const char *jid;
char *recoded;
void *free_arg;
CMD_XMPP_SERVER(server);
if (!cmd_get_params(data, &free_arg, 1, &jid))
return;
if (*jid == '\0')
cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
recoded = xmpp_recode_out(jid);
lmsg = lm_message_new_with_sub_type(recoded,
LM_MESSAGE_TYPE_PRESENCE, LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE);
g_free(recoded);
signal_emit("xmpp send presence", 2, server, lmsg);
lm_message_unref(lmsg);
cmd_params_free(free_arg);
}
SERVER_REC *
xmpp_server_init_connect(SERVER_CONNECT_REC *connrec)
{
XMPP_SERVER_REC *server;
XMPP_SERVER_CONNECT_REC *conn = (XMPP_SERVER_CONNECT_REC *)connrec;
char *recoded;
if (conn->address == NULL || conn->address[0] == '\0')
return NULL;
if (conn->nick == NULL || conn->nick[0] == '\0')
return NULL;
g_return_val_if_fail(IS_XMPP_SERVER_CONNECT(conn), NULL);
server = g_new0(XMPP_SERVER_REC, 1);
server->chat_type = XMPP_PROTOCOL;
server->user = xmpp_extract_user(conn->nick);
server->domain = xmpp_have_domain(conn->nick) ?
xmpp_extract_domain(conn->nick) : g_strdup(conn->address);
server->jid = xmpp_have_domain(conn->nick) ?
xmpp_strip_resource(conn->nick)
: g_strconcat(server->user, "@", server->domain, (void *)NULL);
server->resource = xmpp_extract_resource(conn->nick);
if (server->resource == NULL)
server->resource = g_strdup("irssi-xmpp");
server->priority = settings_get_int("xmpp_priority");
if (xmpp_priority_out_of_bound(server->priority))
server->priority = 0;
server->ping_id = NULL;
server->server_features = NULL;
server->my_resources = NULL;
server->roster = NULL;
server->msg_handlers = NULL;
server->channels_join = channels_join;
server->isnickflag = isnickflag_func;
server->ischannel = ischannel_func;
server->get_nick_flags = get_nick_flags;
server->send_message = send_message;
server->connrec = (XMPP_SERVER_CONNECT_REC *)conn;
server_connect_ref(connrec);
/* don't use irssi's sockets */
server->connrec->no_connect = TRUE;
server->connect_pid = -1;
if (server->connrec->port <= 0)
server->connrec->port = (server->connrec->use_ssl) ?
LM_CONNECTION_DEFAULT_PORT_SSL : LM_CONNECTION_DEFAULT_PORT;
if (conn->real_jid == NULL)
conn->real_jid = conn->nick;
else
g_free(conn->nick);
conn->nick = g_strdup(settings_get_bool("xmpp_set_nick_as_username") ?
server->user : server->jid);
/* init loudmouth connection structure */
server->lmconn = lm_connection_new(NULL);
lm_connection_set_server(server->lmconn, server->connrec->address);
lm_connection_set_port(server->lmconn, server->connrec->port);
recoded = xmpp_recode_out(server->jid);
lm_connection_set_jid(server->lmconn, recoded);
g_free(recoded);
lm_connection_set_keep_alive_rate(server->lmconn, 30);
server->timeout_tag = 0;
server_connect_init((SERVER_REC *)server);
server->connect_tag = 1;
return (SERVER_REC *)server;
}
