static void
connection_auth_cb (LmConnection *connection,
gboolean success,
gpointer user_data)
{
if (success) {
GError *error = NULL;
LmMessage *m;
g_print ("LmSendAsync: Authenticated successfully\n");
m = lm_message_new (recipient, LM_MESSAGE_TYPE_MESSAGE);
lm_message_node_add_child (m->node, "body", message);
if (!lm_connection_send (connection, m, &error)) {
g_printerr ("LmSendAsync: Failed to send message:'%s'\n",
lm_message_node_to_string (m->node));
} else {
g_print ("LmSendAsync: Sent message:'%s'\n",
lm_message_node_to_string (m->node));
test_success = TRUE;
}
lm_message_unref (m);
} else {
g_printerr ("LmSendAsync: Failed to authenticate\n");
}
lm_connection_close (connection, NULL);
g_main_loop_quit (main_loop);
}
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);
}
LmHandlerResult
LM::Presentity::handle_edit_reply (LmConnection* /*connection*/,
LmMessage* message)
{
if (lm_message_get_sub_type (message) == LM_MESSAGE_SUB_TYPE_ERROR) {
std::cout << "Don't know how to handle : " << lm_message_node_to_string (lm_message_get_node (message)) << std::endl;
}
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
static void
send_stanza(XMPP_SERVER_REC *server, LmMessage *lmsg)
{
char *xml, *recoded;
g_return_if_fail(IS_XMPP_SERVER(server));
g_return_if_fail(lmsg != NULL);
xml = lm_message_node_to_string(lmsg->node);
recoded = xmpp_recode_in(xml);
g_free(xml);
signal_emit("xmpp xml out", 2, server, recoded);
g_free(recoded);
lm_connection_send(server->lmconn, lmsg, NULL);
}
LmHandlerResult onXmppMessage
(LmMessageHandler *handler, LmConnection *connection, LmMessage *m, void* data)
{
IoObject *self = data;
IoList_rawAppend_(
(IoList *)IoObject_getSlot_(self, IOSYMBOL("_msgsBuffer")),
IOSYMBOL(lm_message_node_to_string(m->node))
);
IoMessage *io_m = IoMessage_newWithName_label_(IOSTATE, IOSYMBOL("parseMessage"), IOSYMBOL("Loudmouth"));
IoMessage_locals_performOn_(io_m, self, self);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
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;
}
static void
authentication_cb (LmConnection *connection, gboolean result, gpointer ud)
{
g_print ("Auth: %d\n", result);
free_user_info ((UserInfo *) ud);
if (result == TRUE) {
LmMessage *m;
m = lm_message_new_with_sub_type (NULL,
LM_MESSAGE_TYPE_PRESENCE,
LM_MESSAGE_SUB_TYPE_AVAILABLE);
g_print (":: %s\n", lm_message_node_to_string (m->node));
lm_connection_send (connection, m, NULL);
lm_message_unref (m);
}
}
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;
}
LmHandlerResult
LM::Account::handle_presence (LmMessage* message)
{
LmHandlerResult result = LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
if (result == LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS) {
result = dialect->handle_presence (connection, message);
}
if (result == LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS) {
result = cluster->handle_presence (connection, message);
}
#if DEBUG
if (result == LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS) {
std::cout << "Nobody cared about : " << lm_message_node_to_string (lm_message_get_node (message)) << std::endl;
}
#endif
return result;
}
static LmHandlerResult
xmp_message_callback (LmMessageHandler * handler, LmConnection * connection,
LmMessage * message, gpointer user_data)
{
g_print ("%s\n", lm_message_node_to_string (message->node));
}
void jabber_change_status(GGaduStatusPrototype *sp, gboolean keep_desc)
{
enum states status;
LmMessage *m = NULL;
gchar *show = NULL;
gchar *show_away = "away";
gchar *show_xa = "xa";
gchar *show_dnd = "dnd";
gchar *show_chat = "chat";
print_debug("jabber_change_status start");
if (!sp)
return;
status = sp->status;
/* Just a simple esthetic functionality */
if((jabber_data.status == JABBER_STATUS_UNAVAILABLE) && sp->status == JABBER_STATUS_UNAVAILABLE)
{
GGaduStatusPrototype *sp_temp = ggadu_find_status_prototype(p, jabber_data.status);
sp_temp->status = JABBER_STATUS_UNAVAILABLE;
if(sp_temp->status_description)
{
g_free(sp_temp->status_description);
sp_temp->status_description = NULL;
}
signal_emit("jabber", "gui status changed", sp_temp, "main-gui");
GGaduStatusPrototype_free(sp_temp);
return;
}
if (status == JABBER_STATUS_UNAVAILABLE)
{
lm_connection_close(jabber_data.connection, NULL);
return;
}
/* connect if switched to any other than unavailable */
if ((jabber_data.status == JABBER_STATUS_UNAVAILABLE) && (status != JABBER_STATUS_UNAVAILABLE) &&
(!jabber_data.connection || !lm_connection_is_open(jabber_data.connection) ||
!lm_connection_is_authenticated(jabber_data.connection)))
{
g_thread_create(jabber_login_connect, (gpointer) status, FALSE, NULL);
return;
}
if (jabber_data.connection && !lm_connection_is_authenticated(jabber_data.connection))
{
print_debug("You are not yet authenticated!");
return;
}
m = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_PRESENCE,
(status == JABBER_STATUS_UNAVAILABLE) ?
LM_MESSAGE_SUB_TYPE_UNAVAILABLE : LM_MESSAGE_SUB_TYPE_AVAILABLE);
/* switch (status == JABBER_STATUS_DESCR ? jabber_data.status : status) */
switch (status)
{
case JABBER_STATUS_AWAY:
show = show_away;
break;
case JABBER_STATUS_XA:
show = show_xa;
break;
case JABBER_STATUS_DND:
show = show_dnd;
break;
case JABBER_STATUS_CHAT:
show = show_chat;
break;
case JABBER_STATUS_AVAILABLE:
show = NULL;
break;
default:
break;
}
if (show)
lm_message_node_add_child(m->node, "show", show);
if(keep_desc)
{
if(sp->status_description) g_free(sp->status_description);
sp->status_description = g_strdup(jabber_data.description);
}
if(jabber_data.description)
{
g_free(jabber_data.description);
jabber_data.description = NULL;
}
if (sp->status_description)
{
print_debug("jabber: status description %s %s",sp->status_description,show);
lm_message_node_add_child(m->node, "status", sp->status_description);
jabber_data.description = g_strdup(sp->status_description);
}
print_debug(lm_message_node_to_string(m->node));
if (!lm_connection_send(jabber_data.connection, m, NULL))
{
print_debug("jabber: Couldn't change status!\n");
}
else
{
jabber_data.status = status;
signal_emit("jabber", "gui status changed", sp, "main-gui");
}
lm_message_unref(m);
print_debug("jabber_change_status end");
}
