static LmHandlerResult handle_register(LmMessageHandler *handler, LmConnection *connection, LmMessage *lmsg, gpointer user_data) { LmMessageNode *node; struct register_data *rd; const char *id; char *cmd; int error; rd = user_data; id = lm_message_node_get_attribute(lmsg->node, "id"); if (id == NULL || (id != NULL && strcmp(id, rd->id) != 0)) return LM_HANDLER_RESULT_REMOVE_MESSAGE; if ((node = lm_message_node_get_child(lmsg->node, "error")) != NULL) { error = atoi(lm_message_node_get_attribute(node, "code")); signal_emit("xmpp registration failed", 3, rd->username, rd->domain, GINT_TO_POINTER(error)); } else { signal_emit("xmpp registration succeed", 2, rd->username, rd->domain); cmd = g_strdup_printf( "%sXMPPCONNECT %s-host %s -port %d %s@%s %s", settings_get_str("cmdchars"), rd->use_ssl ? "-ssl " : "", rd->address, rd->port, rd->username, rd->domain, rd->password); signal_emit("send command", 3, cmd, NULL, NULL); g_free(cmd); } rd_cleanup(rd); return LM_HANDLER_RESULT_REMOVE_MESSAGE; }
void action_search_form(LmConnection * connection, LmMessage * message, gpointer data) { GGaduDialog *dialog; LmMessageNode *node; dialog = ggadu_dialog_new_full(GGADU_DIALOG_GENERIC,_("Jabber search: form"),"search", (gpointer) g_strdup(lm_message_node_get_attribute(message->node, "from"))); node = lm_message_node_get_child(message->node, "query"); if (!strcmp(lm_message_node_get_attribute(node, "xmlns"), "jabber:iq:search")) { /* child_instr = lm_message_node_get_child(node, "instructions"); */ if (lm_message_node_get_child(node, "first")) ggadu_dialog_add_entry(dialog, GGADU_SEARCH_FIRSTNAME, _("First name:"), VAR_STR, NULL, VAR_FLAG_NONE); if (lm_message_node_get_child(node, "last")) ggadu_dialog_add_entry(dialog, GGADU_SEARCH_LASTNAME, _("Last name:"), VAR_STR, NULL, VAR_FLAG_NONE); if (lm_message_node_get_child(node, "nick")) ggadu_dialog_add_entry(dialog, GGADU_SEARCH_NICKNAME, _("Nick:"), VAR_STR, NULL, VAR_FLAG_NONE); if (lm_message_node_get_child(node, "email")) ggadu_dialog_add_entry(dialog, GGADU_SEARCH_EMAIL, _("Email:"), VAR_STR, NULL, VAR_FLAG_NONE); signal_emit("jabber", "gui show dialog", dialog, "main-gui"); } }
static LmHandlerResult presence_handler(LmMessageHandler* /*handler*/, LmConnection * /*connection*/, LmMessage* m, gpointer /*user_data*/) { // XMPPAccountHandler * pHandler = static_cast<XMPPAccountHandler *>(user_data); LmMessageNode* node = lm_message_get_node(m); if (node) { const char* from = static_cast<const char*>(lm_message_node_get_attribute (node, "from")); if (from) { const gchar* type = lm_message_node_get_attribute (node, "type"); if (type && strcmp(type, "unavailable") == 0) { UT_DEBUGMSG(("Disconnect presence from %s\n", from)); // TODO: handle this } else { UT_DEBUGMSG(("Connect presence from %s\n", from)); // TODO: handle this } } else { UT_DEBUGMSG(("presence message without from\n")); } } return LM_HANDLER_RESULT_REMOVE_MESSAGE; }
boolean xmpp_connect (const char *user, const char * passwd, const char * server, unsigned short port) { GError * error = NULL; LmMessage * m; LmMessage * reply; LmMessageNode * query; LmMessageNode * item; gboolean success; lm_connection_set_server (connection, server); lm_connection_set_port (connection, port); g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Connecting to %s..."), server); success = lm_connection_open_and_block (connection, &error); if (!success) goto error; g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Authenticating with JID %s..."), user); success = lm_connection_authenticate_and_block (connection, user, passwd, CONN_XMPP_RESOURCE, &error); if (!success) goto error; g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Connected successfully."), user); /* Fetch roster */ m = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_GET); query = lm_message_node_add_child (m->node, "query", NULL); lm_message_node_set_attributes (query, "xmlns", "jabber:iq:roster", NULL); reply = lm_connection_send_with_reply_and_block (connection, m, &error); query = lm_message_node_get_child (reply->node, "query"); item = lm_message_node_get_child (query, "item"); while (item) { xmpp_user_t user; const gchar *jid, *name; jid = lm_message_node_get_attribute (item, "jid"); name = lm_message_node_get_attribute (item, "name"); user = intern_user (jid); user->name = g_strdup (name); user->status = OFFLINE; item = item->next; } lm_message_unref (reply); lm_message_unref (m); m = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_PRESENCE, LM_MESSAGE_SUB_TYPE_AVAILABLE); lm_connection_send(connection, m, NULL); lm_message_unref (m); return TRUE; /* Error handling */ error: g_message ("%s", error->message); return FALSE; }
const std::string LM::Presentity::get_name () const { const gchar* result = lm_message_node_get_attribute (item, "name"); if (result == NULL) { result = lm_message_node_get_attribute (item, "jid"); } return result; }
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; }
void action_search_result(LmConnection * connection, LmMessage * message, gpointer data) { LmMessageNode *node; LmMessageNode *child; GSList *list = NULL; node = lm_message_node_get_child(message->node, "query"); if (!strcmp(lm_message_node_get_attribute(node, "xmlns"), "jabber:iq:search")) { child = lm_message_node_get_child(node, "item"); if (!child) { signal_emit("jabber", "gui show message", g_strdup(_("No users have been found!")), "main-gui"); return; } while (child) { gchar *jid = (gchar *) lm_message_node_get_attribute(child, "jid"); GGaduContact *k; LmMessageNode *child_node; k = g_new0(GGaduContact, 1); k->id = g_strdup(jid ? jid : "?"); child_node = lm_message_node_get_child(node, "first"); if (child_node) k->first_name = g_strdup((gchar *) lm_message_node_get_value(child_node)); child_node = lm_message_node_get_child(node, "last"); if (child_node) k->last_name = g_strdup((gchar *) lm_message_node_get_value(child_node)); child_node = lm_message_node_get_child(node, "nick"); if (child_node) k->nick = g_strdup((gchar *) lm_message_node_get_value(child_node)); child_node = lm_message_node_get_child(node, "email"); if (child_node) k->email = g_strdup((gchar *) lm_message_node_get_value(child_node)); k->status = JABBER_STATUS_UNAVAILABLE; list = g_slist_append(list, k); child = child->next; } signal_emit("jabber", "gui show search results", list, "main-gui"); } }
static LmHandlerResult chat_handler(LmMessageHandler* /*handler*/, LmConnection* /*connection*/, LmMessage* m, gpointer user_data) { XMPPAccountHandler * pHandler = static_cast<XMPPAccountHandler *>(user_data); UT_return_val_if_fail(pHandler, LM_HANDLER_RESULT_REMOVE_MESSAGE); /* TODO: we should run run through all the nodes to find the message node */ LmMessageNode* node = lm_message_get_node(m); if (strcmp(node->name, "message") == 0) { for (LmMessageNode* child = node->children; child != 0; child = child->next) { if (strcmp(child->name, "body") == 0) { /* Note: we don't trust a message body with a from-address in it, as it could be forged. Instead get the from-address directly from the LmMessage */ std::string buddy = lm_message_node_get_attribute (m->node, "from"); std::string::size_type pos = buddy.find_last_of("/"); if (pos != std::string::npos) buddy.resize(pos); // TODO: check the resource as an additional sanity check UT_DEBUGMSG(("chat_handler(): Got a message from buddy: %s\n", buddy.c_str())); pHandler->handleMessage(child->value, buddy); break; } } } return LM_HANDLER_RESULT_REMOVE_MESSAGE; }
static LmHandlerResult sasl_failure_cb (LmMessageHandler *handler, LmConnection *connection, LmMessage *message, gpointer user_data) { LmSASL *sasl; const gchar *ns; const gchar *reason = "unknown reason"; ns = lm_message_node_get_attribute (message->node, "xmlns"); if (!ns || strcmp (ns, XMPP_NS_SASL_AUTH) != 0) { return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; } sasl = (LmSASL *) user_data; if (message->node->children) { const gchar *r; r = lm_message_node_get_value (message->node->children); if (r) { reason = r; } } g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SASL, "%s: SASL authentication failed: %s", G_STRFUNC, reason); if (sasl->handler) { sasl->handler (sasl, sasl->connection, FALSE, reason); } return LM_HANDLER_RESULT_REMOVE_MESSAGE; }
static LmHandlerResult xmpp_presence_callback (LmMessageHandler * handler, LmConnection * connection, LmMessage * message, gpointer user_data) { LmMessageNode * node = message->node; xmpp_user_t user; gchar * jid; gchar * resource = NULL; gchar * delimit; jid = g_strdup (lm_message_node_get_attribute (node, "from")); delimit = strchr (jid, '/'); if (delimit != NULL) { *delimit = '\0'; resource = delimit+1; } switch (lm_message_get_sub_type (message)) { case LM_MESSAGE_SUB_TYPE_AVAILABLE: user = intern_user (jid); user->resource = g_strdup (resource); user->status = ONLINE; break; case LM_MESSAGE_SUB_TYPE_UNAVAILABLE: remuser (jid); break; } g_free (jid); }
static LmHandlerResult ft_msg_iq_handler (LmMessageHandler *handler, LmConnection *conn, LmMessage *msg, gpointer user_data) { /* Currently the only IQ message we'll handle is the roster */ LmMessageNode *query = lm_message_node_get_child (msg->node, "query"); int type = lm_message_get_sub_type (msg); if (query) { const char *ns = lm_message_node_get_attribute (query, "xmlns"); if (ns && !g_ascii_strcasecmp (ns, "jabber:iq:roster")) ft_roster_cb (msg); else if (ns && !g_ascii_strcasecmp (ns, "jabber:iq:version")) { if (type == LM_MESSAGE_SUB_TYPE_GET) ft_msg_iq_version_cb (msg); } else if (ns && !g_ascii_strcasecmp (ns, "jabber:iq:last")) { if (type == LM_MESSAGE_SUB_TYPE_GET) ft_msg_iq_last_cb (msg); } else PRINTF (_("[iq received: %s (unhandled yet)]"), ns); } return LM_HANDLER_RESULT_REMOVE_MESSAGE; }
static void sig_recv_iq(XMPP_SERVER_REC *server, LmMessage *lmsg, const int type, const char *id, const char *from, const char *to) { LmMessageNode *node; GSList *features; if (type == LM_MESSAGE_SUB_TYPE_RESULT) { node = lm_find_node(lmsg->node, "query", XMLNS, XMLNS_DISCO); if (node == NULL) return; features = NULL; for (node = node->children; node != NULL; node = node->next) { if (strcmp(node->name, "feature") == 0) { features = g_slist_prepend(features, xmpp_recode_in( lm_message_node_get_attribute(node, "var"))); } } signal_emit("xmpp features", 3, server, from, features); if (strcmp(from, server->domain) == 0) { cleanup_features(server->server_features); server->server_features = features; signal_emit("xmpp server features", 1, server); } else cleanup_features(features); } else if (type == LM_MESSAGE_SUB_TYPE_GET) { node = lm_find_node(lmsg->node, "query", XMLNS, XMLNS_DISCO); if (node != NULL) send_disco(server, from); } }
LmMessage * _lm_message_new_from_node (LmMessageNode *node) { LmMessage *m; LmMessageType type; LmMessageSubType sub_type; const gchar *sub_type_str; type = message_type_from_string (node->name); if (type == LM_MESSAGE_TYPE_UNKNOWN) { return NULL; } sub_type_str = lm_message_node_get_attribute (node, "type"); if (sub_type_str) { sub_type = message_sub_type_from_string (sub_type_str); } else { sub_type = message_sub_type_when_unset (type); } m = g_new0 (LmMessage, 1); m->priv = g_new0 (LmMessagePriv, 1); PRIV(m)->ref_count = 1; PRIV(m)->type = type; PRIV(m)->sub_type = sub_type; m->node = lm_message_node_ref (node); return m; }
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; }
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); }
/* * Получение аттрибута одного из нодов */ gchar* lm_message_node_get_child_attribute(LmMessageNode *node, const gchar *child, const gchar *attribute) { LmMessageNode *tmp; tmp = lm_message_node_find_child(node, child); if(tmp) return (gchar*)lm_message_node_get_attribute(tmp, attribute); else return NULL; }
LmHandlerResult harmony_iq_callback(LmMessageHandler* handler, LmConnection *connection, LmMessage *message, gpointer void_harmony) { GError *err = NULL; MP3tunesHarmony *harmony = MP3TUNES_HARMONY(void_harmony); LmMessageNode *harmony_download_node, *harmony_email_node; mp3tunes_harmony_download_t *download; gchar *email; (void)handler; harmony_download_node = lm_message_node_get_child(message->node, "download"); if (harmony_download_node) { mp3tunes_harmony_download_init(&download); mp3tunes_harmony_download_set_file_key(download, (char*)lm_message_node_get_attribute(harmony_download_node, "fileKey")); mp3tunes_harmony_download_set_file_name(download, (char*)lm_message_node_get_attribute(harmony_download_node, "fileName")); mp3tunes_harmony_download_set_file_format(download, (char*)lm_message_node_get_attribute(harmony_download_node, "fileFormat")); mp3tunes_harmony_download_set_file_size(download, atoi(lm_message_node_get_attribute(harmony_download_node, "fileSize"))); mp3tunes_harmony_download_set_track_title(download, (char*)lm_message_node_get_attribute(harmony_download_node, "trackTitle")); mp3tunes_harmony_download_set_artist_name(download, (char*)lm_message_node_get_attribute(harmony_download_node, "artistName")); mp3tunes_harmony_download_set_album_title(download, (char*)lm_message_node_get_attribute(harmony_download_node, "albumTitle")); mp3tunes_harmony_download_set_device_bitrate(download, (char*)lm_message_node_get_attribute(harmony_download_node, "deviceBitrate")); mp3tunes_harmony_download_set_file_bitrate(download, (char*)lm_message_node_get_attribute(harmony_download_node, "fileBitrate")); download_pending_emit(harmony, download); mp3tunes_harmony_add_download_to_queue(harmony, download); harmony_success_reply(connection, message, &err); if (err != NULL) { error_emit(harmony, MP3TUNES_HARMONY_ERROR_MISC, "Sending success reply failed", err); } return LM_HANDLER_RESULT_REMOVE_MESSAGE; } harmony_email_node = lm_message_node_get_child(message->node, "email"); if (harmony_email_node) { email = g_strdup(lm_message_node_get_value(harmony_email_node)); mp3tunes_harmony_set_email(harmony, email); g_free(email); harmony_success_reply(connection, message, &err); if (err != NULL) { error_emit(harmony, MP3TUNES_HARMONY_ERROR_MISC, "Sending success reply failed", err); } close_connection(harmony); open_connection(harmony); return LM_HANDLER_RESULT_REMOVE_MESSAGE; } return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; }
static LmHandlerResult handle_stanza(LmMessageHandler *handler, LmConnection *connection, LmMessage *lmsg, gpointer user_data) { XMPP_SERVER_REC *server; int type; const char *id; char *from, *to, *raw; if ((server = XMPP_SERVER(user_data)) == NULL) return LM_HANDLER_RESULT_REMOVE_MESSAGE; raw = xmpp_recode_in(lm_message_node_to_string(lmsg->node)); signal_emit("xmpp xml in", 2, server, raw); g_free(raw); type = lm_message_get_sub_type(lmsg); id = lm_message_node_get_attribute(lmsg->node, "id"); if (id == NULL) id = ""; from = xmpp_recode_in(lm_message_node_get_attribute(lmsg->node, "from")); if (from == NULL) from = g_strdup(""); to = xmpp_recode_in(lm_message_node_get_attribute(lmsg->node, "to")); if (to == NULL) to = g_strdup(""); switch(lm_message_get_type(lmsg)) { case LM_MESSAGE_TYPE_MESSAGE: signal_emit("xmpp recv message", 6, server, lmsg, type, id, from, to); break; case LM_MESSAGE_TYPE_PRESENCE: signal_emit("xmpp recv presence", 6, server, lmsg, type, id, from, to); break; case LM_MESSAGE_TYPE_IQ: signal_emit("xmpp recv iq", 6, server, lmsg, type, id, from, to); break; default: signal_emit("xmpp recv others", 6, server, lmsg, type, id, from, to); break; } g_free(from); g_free(to); return LM_HANDLER_RESULT_REMOVE_MESSAGE; }
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); }
bool LM::Presentity::populate_menu (Ekiga::MenuBuilder& builder) { const gchar* subscription = lm_message_node_get_attribute (item, "subscription"); const gchar* ask = lm_message_node_get_attribute (item, "ask"); if ( !has_chat) { builder.add_action ("im-message-new", _("Start chat"), boost::ref (chat_requested)); } else { builder.add_action ("im-message-new", _("Continue chat"), boost::ref (chat_requested)); } builder.add_separator (); builder.add_action ("edit", _("_Edit"), boost::bind (&LM::Presentity::edit_presentity, this)); if (g_strcmp0 (subscription, "none") == 0) { builder.add_action ("ask", _("Ask him/her to see his/her status"), boost::bind (&LM::Presentity::ask_to, this)); } if (g_strcmp0 (subscription, "from") == 0) { builder.add_action ("stop", _("Forbid him/her to see my status"), boost::bind (&LM::Presentity::revoke_from, this)); if (ask == NULL) builder.add_action ("ask", _("Ask him/her to see his/her status"), boost::bind (&LM::Presentity::ask_to, this)); else builder.add_ghost ("ask", _("Ask him/her to see his/her status (pending)")); } if (g_strcmp0 (subscription, "to") == 0) { builder.add_action ("stop", _("Stop getting his/her status"), boost::bind (&LM::Presentity::stop_to, this)); } if (g_strcmp0 (subscription, "both") == 0) { builder.add_action ("stop", _("Forbid him/her to see my status"), boost::bind (&LM::Presentity::revoke_from, this)); builder.add_action ("stop", _("Stop getting his/her status"), boost::bind (&LM::Presentity::stop_to, this)); } builder.add_action ("remove", _("_Remove"), boost::bind (&LM::Presentity::remove_presentity, this)); return true; }
static void sig_recv_message(XMPP_SERVER_REC *server, LmMessage *lmsg, const int type, const char *id, const char *from, const char *to) { LmMessageNode *node; MUC_REC *channel; const char *stamp; char *nick, *str; time_t t; node = lm_find_node(lmsg->node, "delay", "xmlns", XMLNS_DELAY); if (node == NULL) { /* XEP-0091: Delayed Delivery (deprecated) */ node = lm_find_node(lmsg->node, "x", "xmlns", XMLNS_OLD_DELAY); if (node == NULL) return; } stamp = lm_message_node_get_attribute(node, "stamp"); if ((t = xep82_datetime(stamp)) == (time_t)-1) return; node = lm_message_node_get_child(lmsg->node, "body"); if (node == NULL || node->value == NULL || *node->value == '\0') return; if (type == LM_MESSAGE_SUB_TYPE_GROUPCHAT && (channel = get_muc(server, from)) != NULL && (nick = muc_extract_nick(from)) != NULL) { str = xmpp_recode_in(node->value); if (g_ascii_strncasecmp(str, "/me ", 4) == 0) signal_emit("message xmpp delay action", 6, server, str+4, nick, channel->name, &t, GINT_TO_POINTER(SEND_TARGET_CHANNEL)); else signal_emit("message xmpp delay", 6, server, str, nick, channel->name, &t, GINT_TO_POINTER(SEND_TARGET_CHANNEL)); g_free(str); g_free(nick); } else if ((type == LM_MESSAGE_SUB_TYPE_NOT_SET || type == LM_MESSAGE_SUB_TYPE_HEADLINE || type == LM_MESSAGE_SUB_TYPE_NORMAL || type == LM_MESSAGE_SUB_TYPE_CHAT)) { str = xmpp_recode_in(node->value); if (g_ascii_strncasecmp(str, "/me ", 4) == 0) signal_emit("message xmpp delay action", 6, server, str+4, from, from, &t, GINT_TO_POINTER(SEND_TARGET_NICK)); else signal_emit("message xmpp delay", 6, server, str+4, from, from, &t, GINT_TO_POINTER(SEND_TARGET_NICK)); g_free(str); } else return; signal_stop(); }
static LmHandlerResult sasl_success_cb (LmMessageHandler *handler, LmConnection *connection, LmMessage *message, gpointer user_data) { LmSASL *sasl; const gchar *ns; ns = lm_message_node_get_attribute (message->node, "xmlns"); if (!ns || strcmp (ns, XMPP_NS_SASL_AUTH) != 0) { return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; } sasl = (LmSASL *) user_data; switch (sasl->auth_type) { case AUTH_TYPE_PLAIN: if (sasl->state != SASL_AUTH_STATE_PLAIN_STARTED) { g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SASL, "%s: server sent success before finishing auth", G_STRFUNC); if (sasl->handler) { sasl->handler (sasl, sasl->connection, FALSE, "server error"); } } break; case AUTH_TYPE_DIGEST: if (sasl->state != SASL_AUTH_STATE_DIGEST_MD5_SENT_AUTH_RESPONSE && sasl->state != SASL_AUTH_STATE_DIGEST_MD5_SENT_FINAL_RESPONSE) { g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SASL, "%s: server sent success before finishing auth", G_STRFUNC); if (sasl->handler) { sasl->handler (sasl, sasl->connection, FALSE, "server error"); } } break; default: g_warning ("Wrong auth type"); break; } g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SASL, "%s: SASL authentication successful", G_STRFUNC); if (sasl->handler) { sasl->handler (sasl, sasl->connection, TRUE, NULL); } return LM_HANDLER_RESULT_REMOVE_MESSAGE; }
void LM::Presentity::push_presence (const std::string resource, LmMessageNode* presence) { if (resource.empty ()) return; ResourceInfo info; LmMessageNode* priority = lm_message_node_find_child (presence, "priority"); if (priority != NULL) { info.priority = atoi (lm_message_node_get_value (priority)); } else { info.priority = 50; } LmMessageNode* status = lm_message_node_find_child (presence, "status"); if (status != NULL) { const gchar* status_str = lm_message_node_get_value (status); if (status_str != NULL) info.status = status_str; } LmMessageNode* away = lm_message_node_find_child (presence, "show"); if (away != NULL) { info.presence = lm_message_node_get_value (away); } else { info.presence = "available"; } const gchar* oftype = lm_message_node_get_attribute (presence, "type"); if (oftype != NULL) { if (oftype == std::string ("unavailable")) { info.presence = "unavailable"; } } infos[resource] = info; if (info.presence == "unavailable") { infos.erase (resource); } updated (); }
static LmHandlerResult handle_messages (LmMessageHandler *handler, LmConnection *connection, LmMessage *m, gpointer user_data) { g_print ("Incoming message from: %s\n", lm_message_node_get_attribute (m->node, "from")); return LM_HANDLER_RESULT_REMOVE_MESSAGE; }
/* * Обработчик входящих сообщений */ LmHandlerResult handle_messages(LmMessageHandler *handler, LmConnection *connect, LmMessage *m, gpointer data) { printf("\nОбрабатываю событие LM_MESSAGE_TYPE_MESSAGE\n"); const gchar *from, *to, *body, *xmlns; gchar *str, *sstr = NULL; LmMessageSubType mstype; xmlns = lm_message_node_get_child_attribute(m->node, "x", "xmlns"); if(!xmlns) xmlns = ""; if(!strstr(xmlns, "delay")) { from = lm_message_node_get_attribute(m->node, "from"); to = lm_message_node_get_attribute(m->node, "to"); body = lm_message_node_get_child_value(m->node, "body"); mstype = lm_message_get_sub_type(m); if(body) { str = g_strdup(body); sstr = g_strdup(strtok(str, " ")); } if(sstr) { printf("Incoming message\n\tfrom: %s\n\tto: %s\n\tbody: %s\n", from, to, body); handler_cmd(connect, sstr, strchr(body, ' ')); } free(str); free(sstr); } usleep(100000); lm_message_unref(m); return LM_HANDLER_RESULT_REMOVE_MESSAGE; }
LmHandlerResult xmpp_mesg_handler(LmMessageHandler *h, LmConnection *c, LmMessage *m, gpointer udata) { const char *from, *to, *body; LmMessageNode *node; from = lm_message_node_get_attribute(m->node, "from"); to = lm_message_node_get_attribute(m->node, "to"); node = lm_message_node_get_child(m->node, "body"); if(node && (body = lm_message_node_get_value(node))) { ui_tab_print_message(from, body); lua_msg_callback(from, to, body); } /* we're actually ignoring <subject> and <thread> elements, * as I've never actually seen them being used. If you do, and you care, * feel obliged to mail me and yell at me */ return LM_HANDLER_RESULT_REMOVE_MESSAGE; UNUSED(h); UNUSED(c); UNUSED(udata); } /* xmpp_mesg_handler */
/** * @brief A function to handle incoming jingle action * @param action The action which have been received * @param data Contain the JingleFT of the content concerned * @param node The node himself * @return TRUE if the action was handled, FALSE otherwise */ static JingleHandleStatus handle(JingleAction action, gconstpointer data, LmMessageNode *node, GError **err) { if (action == JINGLE_SESSION_INFO) { if (!g_strcmp0(lm_message_node_get_attribute(node, "xmlns"), NS_JINGLE_APP_FT_INFO) && !g_strcmp0(node->name, "hash")) { ((JingleFT *)data)->hash = g_strdup(lm_message_node_get_value(node)); return JINGLE_STATUS_HANDLED; } return JINGLE_STATUS_NOT_HANDLED; } return JINGLE_STATUS_NOT_HANDLED; }
LmHandlerResult LM::HeapRoster::handle_message (LmConnection* /*connection*/, LmMessage* message) { LmHandlerResult result = LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; LmMessageNode* node = lm_message_get_node (message); const gchar* from_c = lm_message_node_get_attribute (node, "from"); const gchar* type_attr = lm_message_node_get_attribute (node, "type"); std::string base_jid; if (from_c != 0) { std::string from (from_c); std::string::size_type index = from.find ('/'); base_jid = std::string (from, 0, index); } PresentityPtr item = find_item (base_jid); if (item && (type_attr == NULL || (type_attr != NULL && g_strcmp0 (type_attr, "normal") == 0) || (type_attr != NULL && g_strcmp0 (type_attr, "chat") == 0))) { // let's imagine it's a basic chat message LmMessageNode* body = lm_message_node_find_child (node, "body"); if (body && lm_message_node_get_value (body) != NULL) { result = LM_HANDLER_RESULT_REMOVE_MESSAGE; Ekiga::Message::payload_type payload; payload["text/plain"] = lm_message_node_get_value (body); dialect->push_message (item, payload); } // it could also be an avatar or a pubsub event or... } return result; }
static void handle_event(LmMessage* message) { LmMessageNode *child = NULL; XML_Parser p; char *buf = NULL; const char *new_node = NULL; int ret; #ifdef DB_DEBUG printf("message:%s\n",lm_message_node_to_string(message->node)); #endif //If message is a DeviceCreation message, subscribe to new event node child = lm_message_node_find_child(message->node,"Created"); if(child != NULL) { new_node = lm_message_node_get_attribute(child,"name"); #ifdef DB_DEBUG printf("Got DeviceCreation message for '%s'\n",new_node); #endif g_print("Got DeviceCreation message for '%s'\n",new_node); if((ret = subscribe_to_node(xmpp_connection,new_node)) != XMPP_NO_ERROR) printf("Could not subscribe to event node '%s'\n",new_node); return; } //Look for SensorNode in message, and invoke parser to update database entries child = lm_message_node_find_child(message->node,"Device"); if(child == NULL) { return; } buf = lm_message_node_to_string(child); p = XML_ParserCreate(NULL); if(!p) { printf("Couldnt allocate memory for XML Parser\n"); return; } XML_SetElementHandler(p,startElement,endElement); if(XML_Parse(p,buf,strlen(buf),1) == XML_STATUS_ERROR) { printf("Parse Error at line %u:\n%s\n", XML_GetCurrentLineNumber(p), XML_ErrorString(XML_GetErrorCode(p))); return; } XML_ParserFree(p); }
// muc_get_item_info(...) // Get room member's information from xmlndata. // The variables must be initialized before calling this function, // because they are not touched if the relevant information is missing. // Note that *actor should be freed by the caller. static void muc_get_item_info(const char *from, LmMessageNode *xmldata, enum imrole *mbrole, enum imaffiliation *mbaffil, const char **mbjid, const char **mbnick, char **actor, const char **reason) { LmMessageNode *y, *z; const char *p, *actorjid, *actornick; y = lm_message_node_find_child(xmldata, "item"); if (!y) return; p = lm_message_node_get_attribute(y, "affiliation"); if (p) { if (!strcmp(p, "owner")) *mbaffil = affil_owner; else if (!strcmp(p, "admin")) *mbaffil = affil_admin; else if (!strcmp(p, "member")) *mbaffil = affil_member; else if (!strcmp(p, "outcast")) *mbaffil = affil_outcast; else if (!strcmp(p, "none")) *mbaffil = affil_none; else scr_LogPrint(LPRINT_LOGNORM, "<%s>: Unknown affiliation \"%s\"", from, p); } p = lm_message_node_get_attribute(y, "role"); if (p) { if (!strcmp(p, "moderator")) *mbrole = role_moderator; else if (!strcmp(p, "participant")) *mbrole = role_participant; else if (!strcmp(p, "visitor")) *mbrole = role_visitor; else if (!strcmp(p, "none")) *mbrole = role_none; else scr_LogPrint(LPRINT_LOGNORM, "<%s>: Unknown role \"%s\"", from, p); } *mbjid = lm_message_node_get_attribute(y, "jid"); *mbnick = lm_message_node_get_attribute(y, "nick"); // For kick/ban, there can be actor and reason tags z = lm_message_node_find_child(y, "actor"); if (z) { actornick = lm_message_node_get_attribute(z, "nick"); actorjid = lm_message_node_get_attribute(z, "jid"); if (actorjid) { if (actornick) { // We have both the actor's jid and nick *actor = g_strdup_printf("%s <%s>", actornick, actorjid); } else { *actor = g_strdup(actorjid); // jid only } } else if (!actorjid && actornick) { // We only have the nickname *actor = g_strdup(actornick); } } *reason = lm_message_node_get_child_value(y, "reason"); if (*reason && !**reason) *reason = NULL; }