LmHandlerResult handle_iq_last(LmMessageHandler *h, LmConnection *c,
LmMessage *m, gpointer ud)
{
LmMessage *r;
LmMessageNode *query;
char *seconds;
if (!settings_opt_get_int("iq_hide_requests")) {
scr_LogPrint(LPRINT_LOGNORM, "Received an IQ last time request from <%s>",
lm_message_get_from(m));
}
if (settings_opt_get_int("iq_last_disable") ||
(settings_opt_get_int("iq_last_disable_when_notavail") &&
xmpp_getstatus() == notavail))
{
send_iq_error(c, m, XMPP_ERROR_SERVICE_UNAVAILABLE);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
r = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_RESULT);
query = lm_message_node_add_child(r->node, "query", NULL);
lm_message_node_set_attribute(query, "xmlns", NS_LAST);
seconds = g_strdup_printf("%.0f", seconds_since_last_use());
lm_message_node_set_attribute(query, "seconds", seconds);
g_free(seconds);
lm_connection_send(c, r, NULL);
lm_message_unref(r);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
/* 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);
}
/* 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_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);
}
/**
* lm_message_new:
* @to: receipient jid
* @type: message type
*
* Creates a new #LmMessage which can be sent with lm_connection_send() or
* lm_connection_send_with_reply(). If @to is %NULL the message is sent to the
* server. The returned message should be unreferenced with lm_message_unref()
* when caller is finished with it.
*
* Return value: a newly created #LmMessage
**/
LmMessage *
lm_message_new (const gchar *to, LmMessageType type)
{
LmMessage *m;
gchar *id;
m = g_new0 (LmMessage, 1);
m->priv = g_new0 (LmMessagePriv, 1);
PRIV(m)->ref_count = 1;
PRIV(m)->type = type;
PRIV(m)->sub_type = message_sub_type_when_unset (type);
m->node = _lm_message_node_new (_lm_message_type_to_string (type));
if (type != LM_MESSAGE_TYPE_STREAM) {
id = _lm_utils_generate_id ();
lm_message_node_set_attribute (m->node, "id", id);
g_free (id);
}
if (to) {
lm_message_node_set_attribute (m->node, "to", to);
}
if (type == LM_MESSAGE_TYPE_IQ) {
lm_message_node_set_attribute (m->node, "type", "get");
}
return m;
}
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 xmpp_request_storage(const gchar *storage)
{
LmMessage *iq;
LmMessageNode *query;
LmMessageHandler *handler;
int i;
iq = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ,
LM_MESSAGE_SUB_TYPE_GET);
query = lm_message_node_add_child(iq->node, "query", NULL);
lm_message_node_set_attribute(query, "xmlns", NS_PRIVATE);
lm_message_node_set_attribute(lm_message_node_add_child
(query, "storage", NULL),
"xmlns", storage);
for (i = 0;
g_strcmp0(iq_request_storage_handlers[i].storagens, storage) != 0;
++i) ;
handler = lm_message_handler_new(iq_request_storage_handlers[i].handler,
NULL, FALSE);
lm_connection_send_with_reply(lconnection, iq, handler, NULL);
lm_message_handler_unref(handler);
lm_message_unref(iq);
}
// disco_info_set_caps(ansquery, entitycaps)
// Add features attributes to ansquery. entitycaps should either be a
// valid capabilities hash or NULL. If it is NULL, the node attribute won't
// be added to the query child and Entity Capabilities will be announced
// as a feature.
// Please change the entity version string if you modify mcabber disco
// source code, so that it doesn't conflict with the upstream client.
static void disco_info_set_caps(LmMessageNode *ansquery,
const char *entitycaps)
{
if (entitycaps) {
char *eversion;
eversion = g_strdup_printf("%s#%s", MCABBER_CAPS_NODE, entitycaps);
lm_message_node_set_attribute(ansquery, "node", eversion);
g_free(eversion);
}
lm_message_node_set_attributes
(lm_message_node_add_child(ansquery, "identity", NULL),
"category", "client",
"name", PACKAGE_STRING,
"type", "pc",
NULL);
if (entitycaps)
caps_foreach_feature(entitycaps, _disco_add_feature_helper, ansquery);
else {
caps_foreach_feature(entity_version(xmpp_getstatus()),
_disco_add_feature_helper,
ansquery);
lm_message_node_set_attribute
(lm_message_node_add_child(ansquery, "feature", NULL),
"var", NS_CAPS);
}
}
// Destroy a MUC room
// room syntax: "room@server"
void xmpp_room_destroy(const char *room, const char *venue, const char *reason)
{
LmMessage *iq;
LmMessageHandler *handler;
LmMessageNode *query, *x;
if (!xmpp_is_online() || !room)
return;
iq = lm_message_new_with_sub_type(room, LM_MESSAGE_TYPE_IQ,
LM_MESSAGE_SUB_TYPE_SET);
query = lm_message_node_add_child(iq->node, "query", NULL);
lm_message_node_set_attribute(query, "xmlns", NS_MUC_OWNER);
x = lm_message_node_add_child(query, "destroy", NULL);
if (venue && *venue)
lm_message_node_set_attribute(x, "jid", venue);
if (reason)
lm_message_node_add_child(x, "reason", reason);
handler = lm_message_handler_new(handle_iq_dummy, NULL, FALSE);
lm_connection_send_with_reply(lconnection, iq, handler, NULL);
lm_message_handler_unref(handler);
lm_message_unref(iq);
}
int xmpp_room_setattrib(const char *roomid, const char *fjid,
const char *nick, struct role_affil ra,
const char *reason)
{
LmMessage *iq;
LmMessageHandler *handler;
LmMessageNode *query, *x;
if (!xmpp_is_online() || !roomid)
return 1;
if (!fjid && !nick) return 1;
if (check_jid_syntax((char*)roomid)) {
scr_LogPrint(LPRINT_NORMAL, "<%s> is not a valid Jabber id", roomid);
return 1;
}
if (fjid && check_jid_syntax((char*)fjid)) {
scr_LogPrint(LPRINT_NORMAL, "<%s> is not a valid Jabber id", fjid);
return 1;
}
if (ra.type == type_affil && ra.val.affil == affil_outcast && !fjid)
return 1; // Shouldn't happen (jid mandatory when banning)
iq = lm_message_new_with_sub_type(roomid, LM_MESSAGE_TYPE_IQ,
LM_MESSAGE_SUB_TYPE_SET);
query = lm_message_node_add_child(iq->node, "query", NULL);
lm_message_node_set_attribute(query, "xmlns", NS_MUC_ADMIN);
x = lm_message_node_add_child(query, "item", NULL);
if (fjid) {
lm_message_node_set_attribute(x, "jid", fjid);
} else { // nickname
lm_message_node_set_attribute(x, "nick", nick);
}
if (ra.type == type_affil)
lm_message_node_set_attribute(x, "affiliation", straffil[ra.val.affil]);
else if (ra.type == type_role)
lm_message_node_set_attribute(x, "role", strrole[ra.val.role]);
if (reason)
lm_message_node_add_child(x, "reason", reason);
handler = lm_message_handler_new(handle_iq_dummy, NULL, FALSE);
lm_connection_send_with_reply(lconnection, iq, handler, NULL);
lm_message_handler_unref(handler);
lm_message_unref(iq);
return 0;
}
// Warning!! xmlns has to be a namespace from iq_request_handlers[].xmlns
void xmpp_iq_request(const char *fulljid, const char *xmlns)
{
LmMessage *iq;
LmMessageNode *query;
LmMessageHandler *handler;
gpointer data = NULL;
GDestroyNotify notifier = NULL;
GError *error = NULL;
int i;
iq = lm_message_new_with_sub_type(fulljid, LM_MESSAGE_TYPE_IQ,
LM_MESSAGE_SUB_TYPE_GET);
for (i = 0; iq_request_handlers[i].xmlns &&
strcmp(iq_request_handlers[i].xmlns, xmlns) != 0 ; ++i)
;
query = lm_message_node_add_child(iq->node,
iq_request_handlers[i].querytag,
NULL);
lm_message_node_set_attribute(query, "xmlns", xmlns);
if (!g_strcmp0(xmlns, NS_PING)) { // Create handler for ping queries
struct timeval *now = g_new(struct timeval, 1);
gettimeofday(now, NULL);
data = (gpointer)now;
notifier = g_free;
} else if (!g_strcmp0(xmlns, NS_DISCO_INFO)) {
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);
}
LmHandlerResult handle_iq_disco_info(LmMessageHandler *h,
LmConnection *c,
LmMessage *m, gpointer ud)
{
LmMessage *r;
LmMessageNode *query, *tmp;
const char *node = NULL;
const char *param = NULL;
if (lm_message_get_sub_type(m) == LM_MESSAGE_SUB_TYPE_RESULT)
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
r = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_RESULT);
query = lm_message_node_add_child(r->node, "query", NULL);
lm_message_node_set_attribute(query, "xmlns", NS_DISCO_INFO);
tmp = lm_message_node_find_child(m->node, "query");
if (tmp) {
node = lm_message_node_get_attribute(tmp, "node");
param = node+strlen(MCABBER_CAPS_NODE)+1;
}
if (node && startswith(node, MCABBER_CAPS_NODE "#", FALSE))
disco_info_set_caps(query, param); // client#version
else
// Basic discovery request
disco_info_set_caps(query, NULL);
lm_connection_send(c, r, NULL);
lm_message_unref(r);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
void
LM::Presentity::edit_presentity_form_submitted (bool submitted,
Ekiga::Form& result)
{
if (!submitted)
return;
const std::string name = result.text ("name");
const std::set<std::string> groups = result.editable_set ("groups");
LmMessage* message = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_SET);
LmMessageNode* query = lm_message_node_add_child (lm_message_get_node (message), "query", NULL);
lm_message_node_set_attribute (query, "xmlns", "jabber:iq:roster");
LmMessageNode* node = lm_message_node_add_child (query, "item", NULL);
{
gchar* escaped = g_markup_escape_text (name.c_str (), -1);
lm_message_node_set_attributes (node,
"jid", get_jid ().c_str (),
"name", escaped,
NULL);
g_free (escaped);
}
for (std::set<std::string>::const_iterator iter = groups.begin (); iter != groups.end (); ++iter) {
gchar* escaped = g_markup_escape_text (iter->c_str (), -1);
lm_message_node_add_child (node, "group", escaped);
g_free (escaped);
}
lm_connection_send_with_reply (connection, message,
build_message_handler (boost::bind(&LM::Presentity::handle_edit_reply, this, _1, _2)), NULL);
lm_message_unref (message);
}
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);
}
// This function borrows some code from the Pidgin project
LmHandlerResult handle_iq_time202(LmMessageHandler *h, LmConnection *c,
LmMessage *m, gpointer ud)
{
LmMessage *r;
LmMessageNode *query;
char *buf, *utf8_buf;
time_t now_t;
struct tm *now;
char const *sign;
int diff = 0;
time(&now_t);
if (!settings_opt_get_int("iq_hide_requests")) {
scr_LogPrint(LPRINT_LOGNORM, "Received an IQ time request from <%s>",
lm_message_get_from(m));
}
buf = g_new0(char, 512);
r = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_RESULT);
query = lm_message_node_add_child(r->node, "time", NULL);
lm_message_node_set_attribute(query, "xmlns", NS_XMPP_TIME);
now = localtime(&now_t);
if (now->tm_isdst >= 0) {
#if defined HAVE_TM_GMTOFF
diff = now->tm_gmtoff;
#elif defined HAVE_TIMEZONE
tzset();
diff = -timezone;
#endif
}
if (diff < 0) {
sign = "-";
diff = -diff;
} else {
sign = "+";
}
diff /= 60;
snprintf(buf, 512, "%c%02d:%02d", *sign, diff / 60, diff % 60);
if ((utf8_buf = to_utf8(buf))) {
lm_message_node_add_child(query, "tzo", utf8_buf);
g_free(utf8_buf);
}
now = gmtime(&now_t);
strftime(buf, 512, "%Y-%m-%dT%TZ", now);
lm_message_node_add_child(query, "utc", buf);
lm_connection_send(c, r, NULL);
lm_message_unref(r);
g_free(buf);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
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);
}
void harmony_success_reply(LmConnection *connection, LmMessage *message, GError **err) {
LmMessage *message_out;
LmMessageNode *harmony_download_node;
LmMessageNode *message_out_node;
message_out = lm_message_new_with_sub_type(MP3TUNES_HARMONY_CONDUCTOR, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_RESULT);
lm_message_node_set_attribute(message_out->node, "id", lm_message_node_get_attribute(message->node, "id"));
message_out_node = lm_message_node_add_child(message_out->node, "success", NULL);
harmony_download_node = lm_message_node_get_child(message->node, "download");
if (harmony_download_node) {
lm_message_node_set_attribute(message_out_node, "messageId", lm_message_node_get_attribute(harmony_download_node, "messageId"));
}
lm_message_node_set_attribute(message_out_node, "xmlns", MP3TUNES_HARMONY_XMLNS);
lm_connection_send(connection, message_out, err);
lm_message_unref(message_out);
}
static LmMessage *lm_message_new_iq_error(LmMessage *m, guint error)
{
LmMessage *r;
LmMessageNode *err;
int i;
for (i = 0; xmpp_errors[i].code; ++i)
if (xmpp_errors[i].code == error)
break;
g_return_val_if_fail(xmpp_errors[i].code > 0, NULL);
r = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_ERROR);
err = lm_message_node_add_child(r->node, "error", NULL);
lm_message_node_set_attribute(err, "code", xmpp_errors[i].code_str);
lm_message_node_set_attribute(err, "type", xmpp_errors[i].type);
lm_message_node_set_attribute
(lm_message_node_add_child(err,
xmpp_errors[i].condition, NULL),
"xmlns", NS_XMPP_STANZAS);
return r;
}
// Invite a user to a MUC room
// room syntax: "room@server"
// reason can be null.
void xmpp_room_invite(const char *room, const char *fjid, const char *reason)
{
LmMessage *msg;
LmMessageNode *x, *y;
if (!xmpp_is_online() || !room || !fjid)
return;
msg = lm_message_new(room, LM_MESSAGE_TYPE_MESSAGE);
x = lm_message_node_add_child(msg->node, "x", NULL);
lm_message_node_set_attribute(x, "xmlns", NS_MUC_USER);
y = lm_message_node_add_child(x, "invite", NULL);
lm_message_node_set_attribute(y, "to", fjid);
if (reason)
lm_message_node_add_child(y, "reason", reason);
lm_connection_send(lconnection, msg, NULL);
lm_message_unref(msg);
}
void jabber_fetch_roster(gpointer user_data)
{
LmMessage *m = NULL;
LmMessageNode *node = NULL;
print_debug("jabber_fetch_roster a");
print_debug("jabber: Fetching roster. %s", lm_connection_get_server(jabber_data.connection));
m = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_GET);
node = lm_message_node_add_child(m->node, "query", NULL);
lm_message_node_set_attribute(m->node, "id", "fetch_roster");
lm_message_node_set_attribute(node, "xmlns", "jabber:iq:roster");
if (!lm_connection_send(jabber_data.connection, m, NULL))
print_debug("jabber: Can't fetch roster (lm_connection_send() failed).\n");
else
action_queue_add("fetch_roster", "result", action_roster_fetch_result, user_data, FALSE);
print_debug("jabber_fetch_roster b");
lm_message_unref(m);
print_debug("jabber_fetch_roster c");
}
// This function borrows some code from the Pidgin project
LmHandlerResult handle_iq_time(LmMessageHandler *h, LmConnection *c,
LmMessage *m, gpointer ud)
{
LmMessage *r;
LmMessageNode *query;
char *buf, *utf8_buf;
time_t now_t;
struct tm *now;
time(&now_t);
if (!settings_opt_get_int("iq_hide_requests")) {
scr_LogPrint(LPRINT_LOGNORM, "Received an IQ time request from <%s>",
lm_message_get_from(m));
}
if (settings_opt_get_int("iq_time_hide")) {
send_iq_error(c, m, XMPP_ERROR_SERVICE_UNAVAILABLE);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
buf = g_new0(char, 512);
r = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_RESULT);
query = lm_message_node_add_child(r->node, "query", NULL);
lm_message_node_set_attribute(query, "xmlns", NS_TIME);
now = gmtime(&now_t);
strftime(buf, 512, "%Y%m%dT%T", now);
lm_message_node_add_child(query, "utc", buf);
now = localtime(&now_t);
strftime(buf, 512, "%Z", now);
if ((utf8_buf = to_utf8(buf))) {
lm_message_node_add_child(query, "tz", utf8_buf);
g_free(utf8_buf);
}
strftime(buf, 512, "%d %b %Y %T", now);
if ((utf8_buf = to_utf8(buf))) {
lm_message_node_add_child(query, "display", utf8_buf);
g_free(utf8_buf);
}
lm_connection_send(c, r, NULL);
lm_message_unref(r);
g_free(buf);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
LmHandlerResult handle_iq_commands(LmMessageHandler *h,
LmConnection *c,
LmMessage *m, gpointer ud)
{
const char *requester_jid = NULL;
LmMessageNode *cmd;
const struct adhoc_command *command;
// mcabber has only partial XEP-0146 support...
if (LM_MESSAGE_SUB_TYPE_SET != lm_message_get_sub_type(m))
return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
requester_jid = lm_message_get_from(m);
cmd = lm_message_node_get_child(m->node, "command");
if (!cmd) {
//send_iq_error(c, m, XMPP_ERROR_BAD_REQUEST);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
if (jid_equal(lm_connection_get_jid(c), requester_jid)) {
const char *action, *node;
action = lm_message_node_get_attribute(cmd, "action");
node = lm_message_node_get_attribute(cmd, "node");
// action can be NULL, in which case it seems to take the default,
// ie execute
if (!action || !strcmp(action, "execute") || !strcmp(action, "cancel")
|| !strcmp(action, "next") || !strcmp(action, "complete")) {
for (command = adhoc_command_list; command->name; command++) {
if (!strcmp(node, command->name))
command->callback(h, c, m, ud);
}
// "prev" action will get there, as we do not implement it,
// and do not authorize it
} else {
LmMessage *r;
LmMessageNode *err;
r = lm_message_new_iq_error(m, XMPP_ERROR_BAD_REQUEST);
if (r) {
err = lm_message_node_get_child(r->node, "error");
lm_message_node_set_attribute
(lm_message_node_add_child(err, "malformed-action", NULL),
"xmlns", NS_COMMANDS);
lm_connection_send(c, r, NULL);
lm_message_unref(r);
}
}
} else {
send_iq_error(c, m, XMPP_ERROR_FORBIDDEN);
}
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
static LmHandlerResult handle_iq_commands_list(LmMessageHandler *h,
LmConnection *c,
LmMessage *m, gpointer ud)
{
LmMessage *iq;
LmMessageNode *query;
const char *requester_jid;
const struct adhoc_command *command;
const char *node;
gboolean from_self;
iq = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_RESULT);
query = lm_message_node_add_child(iq->node, "query", NULL);
lm_message_node_set_attribute(query, "xmlns", NS_COMMANDS);
node = lm_message_node_get_attribute
(lm_message_node_get_child(m->node, "query"),
"node");
if (node)
lm_message_node_set_attribute(query, "node", node);
requester_jid = lm_message_get_from(m);
from_self = jid_equal(lm_connection_get_jid(c), requester_jid);
for (command = adhoc_command_list ; command->name ; command++) {
if (!command->only_for_self || from_self) {
lm_message_node_set_attributes
(lm_message_node_add_child(query, "item", NULL),
"node", command->name,
"name", command->description,
"jid", lm_connection_get_jid(c),
NULL);
}
}
lm_connection_send(c, iq, NULL);
lm_message_unref(iq);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
static void decline_invitation(event_muc_invitation *invitation, const char *reason)
{
// cut and paste from xmpp_room_invite
LmMessage *m;
LmMessageNode *x, *y;
if (!invitation) return;
if (!invitation->to || !invitation->from) return;
m = lm_message_new(invitation->to, LM_MESSAGE_TYPE_MESSAGE);
x = lm_message_node_add_child(m->node, "x", NULL);
lm_message_node_set_attribute(x, "xmlns", NS_MUC_USER);
y = lm_message_node_add_child(x, "decline", NULL);
lm_message_node_set_attribute(y, "to", invitation->from);
if (reason)
lm_message_node_add_child(y, "reason", reason);
lm_connection_send(lconnection, m, NULL);
lm_message_unref(m);
}
void mp3tunes_harmony_send_device_status(MP3tunesHarmony *harmony, GError **err) {
LmMessage *message_out;
/*LmMessageHandler *handler;*/
LmMessageNode* status_message;
GList *current = NULL;
mp3tunes_harmony_device_attribute_t *da;
char* name = NULL;
char* value = NULL;
/*handler = lm_message_handler_new(harmony_get_device_email_callback, (gpointer)harmony, NULL);*/
message_out = lm_message_new_with_sub_type(MP3TUNES_HARMONY_CONDUCTOR, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_SET);
status_message = lm_message_node_add_child(message_out->node, "deviceStatus", NULL);
lm_message_node_set_attribute(status_message, "xmlns", MP3TUNES_HARMONY_XMLNS);
current = g_list_first(harmony->device_attributes);
while (current != NULL) {
da = (mp3tunes_harmony_device_attribute_t*) current->data;
name = da->attribute_name;
if (da->attribute_value_type == MP3TUNES_HARMONY_DEVICE_ATTRIBUTE_TYPE_STRING) {
value = g_strdup(da->attribute_string_value);
} else if (da->attribute_value_type == MP3TUNES_HARMONY_DEVICE_ATTRIBUTE_TYPE_INT) {
value = g_strdup_printf("%lld", da->attribute_int_value);
}
lm_message_node_set_attribute(status_message, name, value);
g_free(value);
current = g_list_next(current);
}
lm_connection_send(harmony->connection, message_out, err);
lm_message_unref(message_out);
if (err != NULL) {
return;
}
}
void jabber_get_version(gpointer user_data)
{
LmMessage *m;
LmMessageNode *node;
GGaduContact *k = user_data;
GGaduContact *k0;
GSList *roster = ggadu_repo_get_as_slist("jabber", REPO_VALUE_CONTACT);
GSList *temp = roster;
gchar *string0, *string1;
while (temp)
{
k0 = temp->data;
if (!ggadu_strcasecmp(k->id, k0->id))
break;
temp = temp->next;
}
string0 = g_strconcat(k0->id, "/", k0->resource, NULL);
m = lm_message_new_with_sub_type(string0, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_GET);
string1 = g_strconcat(ggadu_config_var_get(jabber_handler, "jid"), "/",
ggadu_config_var_get(jabber_handler, "resource") ? ggadu_config_var_get(jabber_handler, "resource") : JABBER_DEFAULT_RESOURCE, NULL);
lm_message_node_set_attribute(m->node, "from", string1);
lm_message_node_set_attribute(m->node, "id", "version_1");
node = lm_message_node_add_child(m->node, "query", NULL);
lm_message_node_set_attribute(node, "xmlns", "jabber:iq:version");
print_debug(lm_message_node_to_string(m->node));
lm_connection_send(jabber_data.connection, m, NULL);
lm_message_unref(m);
g_free(string0);
g_free(string1);
g_slist_free(roster);
return;
}
void
LM::Presentity::remove_presentity ()
{
LmMessage* message = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_SET);
LmMessageNode* query = lm_message_node_add_child (lm_message_get_node (message), "query", NULL);
lm_message_node_set_attribute (query, "xmlns", "jabber:iq:roster");
LmMessageNode* node = lm_message_node_add_child (query, "item", NULL);
lm_message_node_set_attributes (node,
"jid", get_jid ().c_str (),
"subscription", "remove",
NULL);
lm_connection_send_with_reply (connection, message, get_ignore_answer_handler (), NULL);
lm_message_unref (message);
}
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);
}
