bool XMPPAccountHandler::tearDown() { if (m_pConnection) { // unregister and destroy the message handler callbacks if (m_pPresenceHandler) { lm_connection_unregister_message_handler(m_pConnection, m_pPresenceHandler, LM_MESSAGE_TYPE_PRESENCE); lm_message_handler_unref(m_pPresenceHandler); m_pPresenceHandler = NULL; } if (m_pStreamErrorHandler) { lm_connection_unregister_message_handler(m_pConnection, m_pStreamErrorHandler, LM_MESSAGE_TYPE_STREAM_ERROR); lm_message_handler_unref(m_pStreamErrorHandler); m_pStreamErrorHandler = NULL; } if (m_pChatHandler) { lm_connection_unregister_message_handler(m_pConnection, m_pChatHandler, LM_MESSAGE_TYPE_MESSAGE); lm_message_handler_unref(m_pChatHandler); m_pChatHandler = NULL; } lm_connection_close(m_pConnection, NULL); lm_connection_unref(m_pConnection); m_pConnection = NULL; } m_bLoggedIn = false; return true; }
void ft_register_msg_handlers (LmConnection *conn) { LmMessageHandler *handler = lm_message_handler_new ((LmHandleMessageFunction) ft_msg_msg_handler, NULL, NULL); lm_connection_register_message_handler (conn, handler, LM_MESSAGE_TYPE_MESSAGE, LM_HANDLER_PRIORITY_NORMAL); lm_message_handler_unref (handler); handler = lm_message_handler_new ((LmHandleMessageFunction) ft_msg_presence_handler, NULL, NULL); lm_connection_register_message_handler (conn, handler, LM_MESSAGE_TYPE_PRESENCE, LM_HANDLER_PRIORITY_NORMAL); lm_message_handler_unref (handler); handler = lm_message_handler_new ((LmHandleMessageFunction) ft_msg_iq_handler, NULL, NULL); lm_connection_register_message_handler (conn, handler, LM_MESSAGE_TYPE_IQ, LM_HANDLER_PRIORITY_NORMAL); lm_message_handler_unref (handler); lm_connection_set_disconnect_function (conn, ft_disconnect_function, NULL, NULL); }
static void connection_auth_cb(LmConnection *c, gboolean success, gpointer udata) { if(!success) { ui_print("ERROR: Authentication failed\n"); } else { LmMessageHandler *handler; handler = lm_message_handler_new(xmpp_iq_handler, NULL, NULL); lm_connection_register_message_handler(c, handler, LM_MESSAGE_TYPE_IQ, LM_HANDLER_PRIORITY_NORMAL); lm_message_handler_unref(handler); handler = lm_message_handler_new(xmpp_mesg_handler, NULL, NULL); lm_connection_register_message_handler(c, handler, LM_MESSAGE_TYPE_MESSAGE, LM_HANDLER_PRIORITY_NORMAL); lm_message_handler_unref(handler); handler = lm_message_handler_new(xmpp_pres_handler, NULL, NULL); lm_connection_register_message_handler(c, handler, LM_MESSAGE_TYPE_PRESENCE, LM_HANDLER_PRIORITY_NORMAL); lm_message_handler_unref(handler); xmpp_roster_request(c); g_timeout_add(60000, (GSourceFunc)reconnect, NULL); } lua_post_connect(); UNUSED(udata); } /* connection_auth_cb */
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); }
// 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); }
LM::Account::Account (boost::shared_ptr<Ekiga::PersonalDetails> details_, boost::shared_ptr<Dialect> dialect_, boost::shared_ptr<Cluster> cluster_, xmlNodePtr node_): details(details_), dialect(dialect_), cluster(cluster_), node(node_) { if (node == NULL) throw std::logic_error ("NULL node pointer received"); status = _("inactive"); xmlChar* xml_str = xmlGetProp (node, BAD_CAST "startup"); bool enable_on_startup = false; if (xml_str != NULL) { if (xmlStrEqual (xml_str, BAD_CAST "true")) { enable_on_startup = true; } else { enable_on_startup = false; } } xmlFree (xml_str); connection = lm_connection_new (NULL); LmMessageHandler* iq_lm_handler = lm_message_handler_new ((LmHandleMessageFunction)iq_handler_c, this, NULL); lm_connection_register_message_handler (connection, iq_lm_handler, LM_MESSAGE_TYPE_IQ, LM_HANDLER_PRIORITY_NORMAL); lm_message_handler_unref (iq_lm_handler); LmMessageHandler* presence_lm_handler = lm_message_handler_new ((LmHandleMessageFunction)presence_handler_c, this, NULL); lm_connection_register_message_handler (connection, presence_lm_handler, LM_MESSAGE_TYPE_PRESENCE, LM_HANDLER_PRIORITY_NORMAL); lm_message_handler_unref (presence_lm_handler); LmMessageHandler* message_lm_handler = lm_message_handler_new ((LmHandleMessageFunction)message_handler_c, this, NULL); lm_connection_register_message_handler (connection, message_lm_handler, LM_MESSAGE_TYPE_MESSAGE, LM_HANDLER_PRIORITY_NORMAL); lm_message_handler_unref (message_lm_handler); lm_connection_set_disconnect_function (connection, (LmDisconnectFunction)on_disconnected_c, this, NULL); if (enable_on_startup) { enable (); } }
int main (int argc, char **argv) { GMainLoop *main_loop; LmConnection *connection; LmMessageHandler *handler; gboolean result; UserInfo *info; LmProxy *proxy; guint proxy_port; if (argc < 6) { g_print ("Usage: %s <server> <username> <password> <proxyserver> <proxyport>\n", argv[0]); return 1; } connection = lm_connection_new (argv[1]); proxy = lm_proxy_new (LM_PROXY_TYPE_HTTP); lm_proxy_set_server (proxy, argv[4]); proxy_port = strtol (argv[5], (char **) NULL, 10); lm_proxy_set_port (proxy, proxy_port); lm_connection_set_proxy (connection, proxy); lm_proxy_unref (proxy); handler = lm_message_handler_new (handle_messages, NULL, NULL); lm_connection_register_message_handler (connection, handler, LM_MESSAGE_TYPE_MESSAGE, LM_HANDLER_PRIORITY_NORMAL); lm_message_handler_unref (handler); info = g_new0 (UserInfo, 1); info->name = g_strdup (argv[2]); info->passwd = g_strdup (argv[3]); result = lm_connection_open (connection, (LmResultFunction) connection_open_cb, info, NULL, NULL); if (!result) { g_print ("Opening connection failed: %d\n", result); } else { g_print ("Returned from the connection_open\n"); } main_loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (main_loop); return 0; }
static LmHandlerResult handler_function_c (LmMessageHandler* handler, LmConnection* connection, LmMessage* message, handler_data* data) { LmHandlerResult result = data->callback (connection, message); delete data; lm_message_handler_unref (handler); return result; }
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; }
int main (int argc, char **argv) { GMainLoop *main_loop; LmConnection *connection; LmMessageHandler *handler; gboolean result; UserInfo *info; gchar *jid; if (argc < 6) { g_print ("Usage: %s <server> <username> <password> <connectserver> <connectport>\n", argv[0]); return 1; } connection = lm_connection_new (argv[4]); jid = g_strdup_printf ("%s@%s", argv[2], argv[1]); lm_connection_set_jid (connection, jid); g_free (jid); lm_connection_set_port (connection, strtol (argv[5], (char **) NULL, 10)); handler = lm_message_handler_new (handle_messages, NULL, NULL); lm_connection_register_message_handler (connection, handler, LM_MESSAGE_TYPE_MESSAGE, LM_HANDLER_PRIORITY_NORMAL); lm_message_handler_unref (handler); info = g_new0 (UserInfo, 1); info->name = g_strdup (argv[2]); info->passwd = g_strdup (argv[3]); result = lm_connection_open (connection, (LmResultFunction) connection_open_cb, info, NULL, NULL); if (!result) { g_print ("Opening connection failed: %d\n", result); } else { g_print ("Returned from the connection_open\n"); } main_loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (main_loop); return 0; }
static void unregister_stanzas(XMPP_SERVER_REC *server) { GSList *tmp, *next; if (!IS_XMPP_SERVER(server)) return; for (tmp = server->msg_handlers; tmp != NULL; tmp = next) { next = tmp->next; if (lm_message_handler_is_valid(tmp->data)) lm_message_handler_invalidate(tmp->data); lm_message_handler_unref(tmp->data); server->msg_handlers = g_slist_remove(server->msg_handlers, tmp->data); } }
static void rd_cleanup(struct register_data *rd) { register_data = g_slist_remove(register_data, rd); g_free(rd->username); g_free(rd->domain); g_free(rd->password); g_free(rd->address); g_free(rd->id); if (rd->handler != NULL) { if (lm_message_handler_is_valid(rd->handler)) lm_message_handler_invalidate(rd->handler); lm_message_handler_unref(rd->handler); } if (lm_connection_get_state(rd->lmconn) != LM_CONNECTION_STATE_CLOSED) lm_connection_close(rd->lmconn, NULL); lm_connection_unref(rd->lmconn); g_free(rd); }
//doc Loudmouth connect Connects to the server. Returns <code>self</code>. IoObject *IoLoudmouth_connect(IoLoudmouth *self, IoObject *locals, IoMessage *m) { // Q: Should we io_free() these? IoSeq* username = IoObject_getSlot_(self, IOSYMBOL("username")); IoSeq* password = IoObject_getSlot_(self, IOSYMBOL("password")); IoSeq* resource = IoObject_getSlot_(self, IOSYMBOL("resource")); IoSeq* host = IoObject_getSlot_(self, IOSYMBOL("host")); IoNumber* port = IoObject_getSlot_(self, IOSYMBOL("port")); IoObject* use_ssl = IoObject_getSlot_(self, IOSYMBOL("useSsl")); IOASSERT(ISSEQ(username), "Loudmouth: username should be a Sequence"); IOASSERT(ISSEQ(password), "Loudmouth: password should be a Sequence"); IOASSERT(ISSEQ(resource), "Loudmouth: resource should be a Sequence"); IOASSERT(ISSEQ(host), "Loudmouth: host should be a Sequence"); IOASSERT(ISNUMBER(port), "Loudmouth: port should be a Number"); if(LMCONN(self) == NULL) { LmConnection *connection = lm_connection_new_with_context(CSTRING(host), main_context); IoObject_setDataPointer_(self, connection); lm_connection_set_jid(connection, CSTRING(IoObject_getSlot_(self, IOSYMBOL("jid")))); lm_connection_set_port(connection, CNUMBER(port)); if(ISTRUE(use_ssl) && lm_ssl_is_supported()) { LmSSL *ssl = lm_ssl_new(NULL, onSslError, NULL, NULL); lm_connection_set_ssl(connection, ssl); lm_ssl_unref(ssl); } LmMessageHandler* handler = lm_message_handler_new(onXmppMessage, self, NULL); lm_connection_register_message_handler( connection, handler, LM_MESSAGE_TYPE_MESSAGE, LM_HANDLER_PRIORITY_NORMAL ); lm_message_handler_unref(handler); lm_connection_set_disconnect_function(connection, onXmppDisconnect, NULL, NULL); } lm_connection_open(LMCONN(self), onXmppConnect, self, NULL, NULL); return self; }
// 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; 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; } handler = lm_message_handler_new(iq_request_handlers[i].handler, data, notifier); lm_connection_send_with_reply(lconnection, iq, handler, &error); lm_message_handler_unref(handler); lm_message_unref(iq); if (error) { scr_LogPrint(LPRINT_LOGNORM, "Error sending IQ request: %s.", error->message); g_error_free(error); } }
// Unlock a MUC room // room syntax: "room@server" void xmpp_room_unlock(const char *room) { LmMessageNode *node; LmMessageHandler *handler; LmMessage *iq; if (!xmpp_is_online() || !room) return; iq = lm_message_new_with_sub_type(room, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_SET); node = lm_message_node_add_child(iq->node, "query", NULL); lm_message_node_set_attribute(node, "xmlns", NS_MUC_OWNER); node = lm_message_node_add_child(node, "x", NULL); lm_message_node_set_attributes(node, "xmlns", "jabber:x:data", "type", "submit", NULL); 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); }