void
LM::HeapRoster::on_personal_details_updated ()
{
LmMessage* message = lm_message_new (NULL, LM_MESSAGE_TYPE_PRESENCE);
lm_message_node_add_child (lm_message_get_node (message), "show", details->get_presence ().c_str ());
lm_message_node_add_child (lm_message_get_node (message), "status", details->get_status ().c_str ());
lm_connection_send (connection, message, NULL);
lm_message_unref (message);
}
static void
send_message (LmConnection *conn, Arguments *arguments)
{
LmMessage *m;
m = lm_message_new (arguments->test_contact, LM_MESSAGE_TYPE_MESSAGE);
lm_message_node_add_child (m->node, "body", arguments->test_message);
lm_connection_send (conn, m, NULL);
lm_message_unref (m);
}
void
LM::Presentity::revoke_from ()
{
LmMessage* message = lm_message_new (NULL, LM_MESSAGE_TYPE_PRESENCE);
lm_message_node_set_attributes (lm_message_get_node (message),
"to", get_jid ().c_str (),
"type", "unsubscribed",
NULL);
lm_connection_send_with_reply (connection, message, get_ignore_answer_handler (), NULL);
lm_message_unref (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;
}
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;
}
// 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;
}
/* TODO: large messages are not sent. (?)
maybe I'll be splitting messages.
*/
gboolean xmpp_send_message(Xinb *x, LmMessageSubType subtype)
{
LmMessage *m;
if(x->state != LM_CONNECTION_STATE_AUTHENTICATED) {
log_record(x, LOGS_ERR,
"Unable to send message: not authenticated");
return FALSE;
}
m = lm_message_new_with_sub_type(x->to, LM_MESSAGE_TYPE_MESSAGE, subtype);
lm_message_node_add_child(m->node, "body", x->message);
if(!lm_connection_send(x->conn, m, &(x->gerror))) {
log_record(x, LOGS_ERR, "Unable to send message to '%s': %s",
x->to, x->gerror->message);
g_clear_error(&(x->gerror));
lm_message_unref(m);
return FALSE;
}
lm_message_unref(m);
return TRUE;
}
/*
* Инициализация
*/
gboolean jid_init(LmConnection *connect, const struct _jid *jid) {
LmMessage *m;
LmMessageNode *query, *storage;
GError *error = NULL;
// <iq type='get'><query xmlns='jabber:iq:roster'/></iq>
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);
if(!lm_connection_send(connect, m, &error)) {
g_print ("Failed sent query 'xmlns=jabber:iq:roster', due to: %s\n",
error->message);
return FALSE;
}
// <iq type='get'><query xmlns='jabber:iq:private'><storage xmlns='storage:bookmarks'/></query></iq>
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);
storage = lm_message_node_add_child(m->node, "storage", NULL);
lm_message_node_set_attributes(query, "xmlns", "jabber:iq:private", NULL);
lm_message_node_set_attributes(storage, "xmlns", "storage:bookmarks", NULL);
if(!lm_connection_send(connect, m, &error)) {
g_print ("Failed sent query 'jabber:iq:private', due to: %s\n",
error->message);
return FALSE;
}
// <iq type='get'><query xmlns='jabber:iq:private'><storage xmlns='storage:rosternotes'/></query></iq>
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);
storage = lm_message_node_add_child(m->node, "storage", NULL);
lm_message_node_set_attributes(query, "xmlns", "jabber:iq:private", NULL);
lm_message_node_set_attributes(storage, "xmlns", "storage:rosternotes", NULL);
if(!lm_connection_send(connect, m, &error)) {
g_print ("Failed sent second query 'jabber:iq:private', due to: %s\n",
error->message);
return FALSE;
}
lm_message_unref(m);
return TRUE;
}
void
LM::HeapRoster::subscribe_from_form_submitted (bool submitted,
Ekiga::Form& result)
{
if ( !submitted)
return;
const std::string jid = result.hidden ("jid");
const std::string answer = result.single_choice ("answer");
if (answer == "grant") {
LmMessage* message = lm_message_new (NULL, LM_MESSAGE_TYPE_PRESENCE);
lm_message_node_set_attributes (lm_message_get_node (message),
"to", jid.c_str (),
"type", "subscribed",
NULL);
lm_connection_send (connection, message, NULL);
lm_message_unref (message);
LmMessage* subscribe = lm_message_new (NULL, LM_MESSAGE_TYPE_PRESENCE);
lm_message_node_set_attributes (lm_message_get_node (subscribe),
"to", jid.c_str (),
"type", "subscribe",
NULL);
lm_connection_send (connection, subscribe, NULL);
lm_message_unref (subscribe);
} else if (answer == "refuse") {
LmMessage* message = lm_message_new (NULL, LM_MESSAGE_TYPE_PRESENCE);
lm_message_node_set_attributes (lm_message_get_node (message),
"to", jid.c_str (),
"type", "unsubscribed",
NULL);
lm_connection_send (connection, message, NULL);
lm_message_unref (message);
}
}
static gboolean
sasl_digest_md5_check_server_response(LmSASL *sasl, GHashTable *challenge)
{
LmMessage *msg;
const gchar *rspauth;
int result;
rspauth = g_hash_table_lookup (challenge, "rspauth");
if (rspauth == NULL) {
g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SSL,
"%s: server sent an invalid reply (no rspauth)\n",
G_STRFUNC);
if (sasl->handler) {
sasl->handler (sasl, sasl->connection,
TRUE, "server error");
}
return FALSE;
}
if (strcmp (sasl->digest_md5_rspauth, rspauth) != 0) {
g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SSL,
"%s: server sent an invalid reply (rspauth not matching)\n",
G_STRFUNC);
if (sasl->handler) {
sasl->handler (sasl, sasl->connection,
TRUE, "server error");
}
return FALSE;
}
msg = lm_message_new (NULL, LM_MESSAGE_TYPE_RESPONSE);
lm_message_node_set_attributes (msg->node,
"xmlns", XMPP_NS_SASL_AUTH,
NULL);
result = lm_connection_send (sasl->connection, msg, NULL);
lm_message_unref (msg);
if (!result) {
g_warning ("Failed to send SASL response\n");
return FALSE;
}
sasl->state = SASL_AUTH_STATE_DIGEST_MD5_SENT_FINAL_RESPONSE;
return TRUE;
}
void
LM::HeapRoster::handle_up (LmConnection* connection_,
const std::string name_)
{
connection = connection_;
name = name_;
{ // populate the roster
LmMessage* roster_request = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_GET);
LmMessageNode* node = lm_message_node_add_child (lm_message_get_node (roster_request), "query", NULL);
lm_message_node_set_attributes (node, "xmlns", "jabber:iq:roster", NULL);
lm_connection_send_with_reply (connection, roster_request,
build_message_handler (boost::bind (&LM::HeapRoster::handle_initial_roster_reply, this, _1, _2)), NULL);
lm_message_unref (roster_request);
}
{ // initial presence push
LmMessage* presence_push = lm_message_new (NULL, LM_MESSAGE_TYPE_PRESENCE);
lm_connection_send (connection, presence_push, NULL);
lm_message_unref (presence_push);
}
on_personal_details_updated (); // fake, but if we start as dnd, we want it known
updated ();
}
void
xmpp_mesg_send(const char *to, const char *msg)
{
LmMessage *m;
GError *err = NULL;
m = lm_message_new_with_sub_type(to, LM_MESSAGE_TYPE_MESSAGE,
LM_MESSAGE_SUB_TYPE_CHAT);
lm_message_node_add_child(m->node, "body", msg);
if(!lm_connection_send(xmpp_connection_get(), m, &err)) {
ui_print("Error sending message: %s\n", err->message);
g_error_free(err);
}
lua_msg_callback(NULL, to, msg);
lm_message_unref(m);
} /* xmpp_send_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);
}
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);
}
/* SYNTAX: ROSTER GROUP <jid> [<group>] */
static void
cmd_roster_group(const char *data, XMPP_SERVER_REC *server)
{
LmMessage *lmsg;
LmMessageNode *query_node, *item_node;
XMPP_ROSTER_USER_REC *user;
XMPP_ROSTER_GROUP_REC *group;
const char *jid, *group_name;
char *recoded;
void *free_arg;
CMD_XMPP_SERVER(server);
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST, &jid,
&group_name))
return;
if (*jid == '\0')
cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
user = rosters_find_user(server->roster, jid, &group, 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);
if (*group_name != '\0') {
recoded = xmpp_recode_out(group_name);
lm_message_node_add_child(item_node, "group", recoded);
g_free(recoded);
}
if (user->name != NULL) {
recoded = xmpp_recode_out(user->name);
lm_message_node_set_attribute(item_node, "name", recoded);
g_free(recoded);
}
signal_emit("xmpp send iq", 2, server, lmsg);
lm_message_unref(lmsg);
out:
cmd_params_free(free_arg);
}
//doc Loudmouth send(toJid, message) Sends a message (<code>Sequence</code>) to provided JID (<code>Sequence</code>). Returns <code>true</code> or <code>false</code>.
IoObject *IoLoudmouth_send(IoLoudmouth *self, IoObject *locals, IoMessage *m) {
char *to = IoMessage_locals_cStringArgAt_(m, locals, 0);
char *msg_body = IoMessage_locals_cStringArgAt_(m, locals, 1);
int success = 0;
LmMessage *xmpp_msg = lm_message_new_with_sub_type(
to, LM_MESSAGE_TYPE_MESSAGE, LM_MESSAGE_SUB_TYPE_CHAT
);
lm_message_node_add_child(xmpp_msg->node, "body", msg_body);
success = lm_connection_send(LMCONN(self), xmpp_msg, NULL);
lm_message_unref(xmpp_msg);
free(to);
free(msg_body);
return IOBOOL(self, success);
}
// Join a MUC room
void xmpp_room_join(const char *room, const char *nickname, const char *passwd)
{
LmMessage *x;
LmMessageNode *y;
gchar *roomid;
GSList *room_elt;
if (!xmpp_is_online() || !room)
return;
if (!nickname) return;
roomid = g_strdup_printf("%s/%s", room, nickname);
if (check_jid_syntax(roomid)) {
scr_LogPrint(LPRINT_NORMAL, "<%s/%s> is not a valid Jabber room", room,
nickname);
g_free(roomid);
return;
}
room_elt = roster_find(room, jidsearch, ROSTER_TYPE_USER|ROSTER_TYPE_ROOM);
// Add room if it doesn't already exist
if (!room_elt) {
room_elt = roster_add_user(room, NULL, NULL, ROSTER_TYPE_ROOM,
sub_none, -1);
} else {
// Make sure this is a room (it can be a conversion user->room)
buddy_settype(room_elt->data, ROSTER_TYPE_ROOM);
}
// If insideroom is TRUE, this is a nickname change and we don't care here
if (!buddy_getinsideroom(room_elt->data)) {
// We're trying to enter a room
buddy_setnickname(room_elt->data, nickname);
}
// Send the XML request
x = lm_message_new_presence(mystatus, roomid, mystatusmsg);
xmpp_insert_entity_capabilities(x->node, mystatus); // Entity Caps (XEP-0115)
y = lm_message_node_add_child(x->node, "x", NULL);
lm_message_node_set_attribute(y, "xmlns", NS_MUC);
if (passwd)
lm_message_node_add_child(y, "password", passwd);
lm_connection_send(lconnection, x, NULL);
lm_message_unref(x);
g_free(roomid);
}
static void
sig_server_quit(XMPP_SERVER_REC *server, char *reason)
{
LmMessage *lmsg;
char *str;
if (!IS_XMPP_SERVER(server))
return;
lmsg = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_PRESENCE,
LM_MESSAGE_SUB_TYPE_UNAVAILABLE);
str = xmpp_recode_out((reason != NULL) ?
reason : settings_get_str("quit_message"));
lm_message_node_add_child(lmsg->node, "status", str);
g_free(str);
signal_emit("xmpp send presence", 2, server, lmsg);
lm_message_unref(lmsg);
}
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);
}
LmHandlerResult handle_iq_version(LmMessageHandler *h, LmConnection *c,
LmMessage *m, gpointer ud)
{
LmMessage *r;
LmMessageNode *query;
if (!settings_opt_get_int("iq_hide_requests")) {
scr_LogPrint(LPRINT_LOGNORM, "Received an IQ version request from <%s>",
lm_message_get_from(m));
}
if (settings_opt_get_int("iq_version_hide")) {
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_VERSION);
lm_message_node_add_child(query, "name", PACKAGE_NAME);
// MCabber version
if (!settings_opt_get_int("iq_version_hide_version")) {
char *ver = mcabber_version();
lm_message_node_add_child(query, "version", ver);
g_free(ver);
}
// OS details
if (!settings_opt_get_int("iq_version_hide_os")) {
char *os;
struct utsname osinfo;
uname(&osinfo);
os = g_strdup_printf("%s %s %s", osinfo.sysname, osinfo.release,
osinfo.machine);
lm_message_node_add_child(query, "os", os);
g_free(os);
}
lm_connection_send(c, r, NULL);
lm_message_unref(r);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
/*
* Установка статуса и приоритета
*/
gboolean set_status(LmConnection *connect, const struct _jid *jid,
const gchar *status, const gchar *priority) {
LmMessage *m;
GError *error = NULL;
// Создаём и отправляем сообщение
m = lm_message_new(NULL, LM_MESSAGE_TYPE_PRESENCE);
lm_message_node_add_child(m->node, "status", status);
lm_message_node_add_child(m->node, "priority", priority);
if(!lm_connection_send(connect, m, &error)) {
g_print ("Failed set status and priority, due to: %s\n",
error->message);
return FALSE;
}
lm_message_unref(m);
return TRUE;
}
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);
}
void
disco_request(XMPP_SERVER_REC *server, const char *dest)
{
LmMessage *lmsg;
LmMessageNode *node;
char *recoded;
g_return_if_fail(IS_XMPP_SERVER(server));
g_return_if_fail(dest != NULL && dest != '\0');
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_DISCO);
signal_emit("xmpp send iq", 2, server, lmsg);
lm_message_unref(lmsg);
}
IoObject *IoLoudmouth_setPresence(IoLoudmouth *self, IoObject *locals, IoMessage *m) {
char *pres_c = IoMessage_locals_cStringArgAt_(m, locals, 0);
IoSeq *status = IoMessage_locals_valueArgAt_(m, locals, 1);
int success = 0;
LmMessage *xmpp_msg = lm_message_new_with_sub_type(
NULL,
LM_MESSAGE_TYPE_PRESENCE,
str2msg_subtype(pres_c)
);
if(ISSEQ(status))
lm_message_node_add_child(xmpp_msg->node, "status", CSTRING(status));
success = lm_connection_send(LMCONN(self), xmpp_msg, NULL);
lm_message_unref(xmpp_msg);
free(pres_c);
return IOBOOL(self, success);
}
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);
}
}
/*
* Отправка сообщения на другой jid
*/
gboolean jid_message(LmConnection *connect,
const gchar* to_jid, const gchar* text) {
LmMessage *m;
GError *error = NULL;
// Создаём сообщение
m = lm_message_new_with_sub_type(to_jid, LM_MESSAGE_TYPE_MESSAGE,
LM_MESSAGE_SUB_TYPE_CHAT);
lm_message_node_add_child(m->node, "body", text);
if(!lm_connection_send(connect, m, &error)) {
g_print ("Failed sent message to '%s' due to: %s\n",
to_jid, error->message);
return FALSE;
}
printf("Send message to %s\n", to_jid);
lm_message_unref(m);
return TRUE;
}
static void
sig_connected(XMPP_SERVER_REC *server)
{
LmMessage *lmsg;
char *str;
if (!IS_XMPP_SERVER(server) || (server->connrec->reconnection
&& xmpp_presence_changed(server->connrec->show, server->show,
server->connrec->away_reason, server->away_reason,
server->connrec->priority, server->priority)))
return;
/* set presence available */
lmsg = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_PRESENCE,
LM_MESSAGE_SUB_TYPE_AVAILABLE);
str = g_strdup_printf("%d", server->priority);
lm_message_node_add_child(lmsg->node, "priority", str);
g_free(str);
signal_emit("xmpp send presence", 2, server, lmsg);
lm_message_unref(lmsg);
}
/*
* Обработчик входящих сообщений
*/
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;
}
static void
send_composing_event(XMPP_SERVER_REC *server, const char *dest, const char *id,
gboolean composing)
{
LmMessage *lmsg;
LmMessageNode *node;
char *recoded;
recoded = xmpp_recode_out(dest);
lmsg = lm_message_new_with_sub_type(recoded,
LM_MESSAGE_TYPE_MESSAGE, LM_MESSAGE_SUB_TYPE_CHAT);
g_free(recoded);
node = lm_message_node_add_child(lmsg->node, "x", NULL);
lm_message_node_set_attribute(node, XMLNS, XMLNS_EVENT);
if (composing)
lm_message_node_add_child(node, "composing", NULL);
if (id != NULL)
lm_message_node_add_child(node, "id", id);
signal_emit("xmpp send message", 2, server, lmsg);
lm_message_unref(lmsg);
}
/* SYNTAX: PRESENCE UNSUBSCRIBE <jid> */
static void
cmd_presence_unsubscribe(const char *data, XMPP_SERVER_REC *server)
{
LmMessage *lmsg;
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);
recoded = xmpp_recode_out(jid);
lmsg = lm_message_new_with_sub_type(recoded,
LM_MESSAGE_TYPE_PRESENCE, LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE);
g_free(recoded);
signal_emit("xmpp send presence", 2, server, lmsg);
lm_message_unref(lmsg);
cmd_params_free(free_arg);
}
