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); }