/* 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);
}
static void
send_message(SERVER_REC *server, const char *target, const char *msg,
int target_type)
{
LmMessage *lmsg;
char *str, *recoded;
if (!IS_XMPP_SERVER(server))
return;
g_return_if_fail(target != NULL);
g_return_if_fail(msg != NULL);
if (target_type == SEND_TARGET_CHANNEL) {
recoded = xmpp_recode_out(target);
lmsg = lm_message_new_with_sub_type(recoded,
LM_MESSAGE_TYPE_MESSAGE, LM_MESSAGE_SUB_TYPE_GROUPCHAT);
} else {
str = rosters_resolve_name(XMPP_SERVER(server), target);
recoded = xmpp_recode_out(str != NULL ? str : target);
g_free(str);
lmsg = lm_message_new_with_sub_type(recoded,
LM_MESSAGE_TYPE_MESSAGE, LM_MESSAGE_SUB_TYPE_CHAT);
}
g_free(recoded);
/* ugly from irssi: recode the sent message back */
str = recode_in(server, msg, target);
recoded = xmpp_recode_out(str);
g_free(str);
lm_message_node_add_child(lmsg->node, "body", recoded);
g_free(recoded);
signal_emit("xmpp send message", 2, server, lmsg);
lm_message_unref(lmsg);
}
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;
}
/*
* Инициализация
*/
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;
}
/* 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);
}
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);
}
// 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);
}
/* SYNTAX: PRESENCE SUBSCRIBE <jid> [<reason>] */
static void
cmd_presence_subscribe(const char *data, XMPP_SERVER_REC *server)
{
LmMessage *lmsg;
const char *jid, *reason;
char *recoded;
void *free_arg;
CMD_XMPP_SERVER(server);
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST, &jid,
&reason))
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_SUBSCRIBE);
g_free(recoded);
if (*reason != '\0') {
recoded = xmpp_recode_out(reason);
lm_message_node_add_child(lmsg->node, "status", recoded);
g_free(recoded);
}
signal_emit("xmpp send presence", 2, server, lmsg);
lm_message_unref(lmsg);
cmd_params_free(free_arg);
}
VALUE
msg_initialize (int argc, VALUE *argv, VALUE self)
{
LmMessage *m;
VALUE to, type, sub_type;
char *to_str = NULL;
rb_scan_args (argc, argv, "21", &to, &type, &sub_type);
/* To can be nil */
if (!NIL_P (to)) {
if (!rb_respond_to (to, rb_intern ("to_s"))) {
rb_raise (rb_eArgError, "to should respond to to_s");
} else {
VALUE str_val = rb_funcall (to, rb_intern ("to_s"), 0);
to_str = StringValuePtr (str_val);
}
}
if (NIL_P (sub_type)) {
/* Without sub_type */
m = lm_message_new (to_str, FIX2INT (type));
} else {
m = lm_message_new_with_sub_type (to_str,
FIX2INT (type),
FIX2INT (sub_type));
}
DATA_PTR (self) = m;
return self;
}
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);
}
// 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)) {
/* 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_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);
}
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);
}
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);
}
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);
}
/*
* Выход из конференции
*/
gboolean leave_room(LmConnection *connect,
const gchar* room_name, const gchar* nick, const gchar* leave_status) {
LmMessage *m;
gchar *room_jid;
GError *error = NULL;
room_jid = (gchar*)xcalloc(strlen(room_name)+strlen(nick)+2, sizeof(gchar));
strcat(room_jid, room_name);
strcat(room_jid, "/");
strcat(room_jid, nick);
// Создаём и отправляем сообщение о выходе
m = lm_message_new_with_sub_type(room_jid, LM_MESSAGE_TYPE_PRESENCE,
LM_MESSAGE_SUB_TYPE_UNAVAILABLE);
free(room_jid);
if(leave_status)
lm_message_node_add_child(m->node, "status", leave_status);
if(!lm_connection_send(connect, m, &error)) {
g_print("Failed leave to '%s' due to: %s\n",
room_name, error->message);
return FALSE;
}
fprintf(stderr, "Leave to %s\n", room_name);
lm_message_unref(m);
return TRUE;
}
//doc Loudmouth registerAccount(server, username, password) Registers a new account at XMPP server. Returns <code>true</code> or <code>false</code>.
IoObject *IoLoudmouth_registerAccount(IoLoudmouth *self, IoObject *locals, IoMessage *m) {
char *server = IoMessage_locals_cStringArgAt_(m, locals, 0),
*username = IoMessage_locals_cStringArgAt_(m, locals, 1),
*password = IoMessage_locals_cStringArgAt_(m, locals, 2),
*error_message = "Unknown error";
LmConnection *connection = lm_connection_new(server);
LmMessage *xmpp_msg, *xmpp_reply;
LmMessageNode *query, *node;
int success = 0;
if(!lm_connection_open_and_block(connection, NULL)) {
error_message = "Could not open connection";
success = 0;
} else {
xmpp_msg = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_SET);
query = lm_message_node_add_child(xmpp_msg->node, "query", NULL);
lm_message_node_set_attributes(query,
"xmlns", "jabber:iq:register",
NULL);
lm_message_node_add_child(query, "username", username);
lm_message_node_add_child(query, "password", password);
xmpp_reply = lm_connection_send_with_reply_and_block(connection, xmpp_msg, NULL);
lm_connection_close(connection, NULL);
lm_connection_unref(connection);
if(!xmpp_reply) {
success = 0;
error_message = "No reply from server";
} else {
switch(lm_message_get_sub_type(xmpp_reply)) {
case LM_MESSAGE_SUB_TYPE_RESULT:
success = 1;
break;
case LM_MESSAGE_SUB_TYPE_ERROR:
default:
success = 0;
node = lm_message_node_find_child(xmpp_reply->node, "error");
error_message = (node == NULL) ? lm_message_node_get_value(node) : "Unknown error";
lm_message_node_unref(node);
}
}
lm_message_unref(xmpp_reply);
lm_message_unref(xmpp_msg);
lm_message_node_unref(query);
}
free(server);
free(username);
free(password);
IOASSERT(success, error_message);
free(error_message);
return IOBOOL(self, success);
}
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;
}
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 */
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);
}
//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);
}
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
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);
}
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);
}
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);
}
