/*
* Инициализация
*/
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;
}
static void
inject_candidates (GabbleJingleTransportIface *obj,
LmMessageNode *transport_node)
{
GabbleJingleTransportRawUdp *self = GABBLE_JINGLE_TRANSPORT_RAWUDP (obj);
GabbleJingleTransportRawUdpPrivate *priv = self->priv;
JingleCandidate *c;
GList *li;
gchar port_str[16], comp_str[16];
LmMessageNode *cnode;
/* If we don't have the local candidates yet, we should've waited with
* the session initiation, or can_accept would have returned FALSE.
*/
g_assert (priv->local_candidates != NULL);
for (li = priv->local_candidates; li != NULL; li = li->next)
{
c = (JingleCandidate *) li->data;
sprintf (port_str, "%d", c->port);
sprintf (comp_str, "%d", c->component);
cnode = lm_message_node_add_child (transport_node, "candidate", NULL);
lm_message_node_set_attributes (cnode,
"ip", c->address,
"port", port_str,
"generation", "0",
"id", c->id,
"component", comp_str,
NULL);
}
}
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);
}
static gboolean
sasl_digest_md5_send_initial_response (LmSASL *sasl, GHashTable *challenge)
{
LmMessage *msg;
gchar *response;
gchar *response64;
int result;
response = sasl_md5_prepare_response(sasl, challenge);
if (response == NULL) {
return FALSE;
}
response64 = base64_encode ((gchar *)response, strlen(response));
msg = lm_message_new (NULL, LM_MESSAGE_TYPE_RESPONSE);
lm_message_node_set_attributes (msg->node,
"xmlns", XMPP_NS_SASL_AUTH,
NULL);
lm_message_node_set_value (msg->node, response64);
result = lm_connection_send (sasl->connection, msg, NULL);
g_free (response);
g_free (response64);
lm_message_unref (msg);
if (!result) {
return FALSE;
}
sasl->state = SASL_AUTH_STATE_DIGEST_MD5_SENT_AUTH_RESPONSE;
return TRUE;
}
/*
* Вход в конферецию
*/
gboolean join_room(LmConnection *connect,
const gchar* room_name, const gchar* nick) {
LmMessage *m;
LmMessageNode *query;
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(room_jid, LM_MESSAGE_TYPE_PRESENCE);
query = lm_message_node_add_child(m->node, "x", NULL);
lm_message_node_set_attributes(query, "xmlns",
"http://jabber.org/protocol/muc", NULL);
// Заходим...
if(!lm_connection_send(connect, m, &error)) {
g_print("Failed join to '%s' due to: %s\n",
room_jid, error->message);
free(room_jid); //FIXME
return FALSE;
}
fprintf(stderr, "Join to %s as %s\n", room_name, nick);
free(room_jid);
lm_message_unref(m);
return TRUE;
}
// disco_info_set_caps(ansquery, entitycaps)
// Add features attributes to ansquery. entitycaps should either be a
// valid capabilities hash or NULL. If it is NULL, the node attribute won't
// be added to the query child and Entity Capabilities will be announced
// as a feature.
// Please change the entity version string if you modify mcabber disco
// source code, so that it doesn't conflict with the upstream client.
static void disco_info_set_caps(LmMessageNode *ansquery,
const char *entitycaps)
{
if (entitycaps) {
char *eversion;
eversion = g_strdup_printf("%s#%s", MCABBER_CAPS_NODE, entitycaps);
lm_message_node_set_attribute(ansquery, "node", eversion);
g_free(eversion);
}
lm_message_node_set_attributes
(lm_message_node_add_child(ansquery, "identity", NULL),
"category", "client",
"name", PACKAGE_STRING,
"type", "pc",
NULL);
if (entitycaps)
caps_foreach_feature(entitycaps, _disco_add_feature_helper, ansquery);
else {
caps_foreach_feature(entity_version(xmpp_getstatus()),
_disco_add_feature_helper,
ansquery);
lm_message_node_set_attribute
(lm_message_node_add_child(ansquery, "feature", NULL),
"var", NS_CAPS);
}
}
static void lm_message_node_add_dataform_result(LmMessageNode *node,
const char *message)
{
LmMessageNode *x, *field;
x = lm_message_node_add_child(node, "x", NULL);
lm_message_node_set_attributes(x,
"type", "result",
"xmlns", "jabber:x:data",
NULL);
field = lm_message_node_add_child(x, "field", NULL);
lm_message_node_set_attributes(field,
"type", "text-single",
"var", "message",
NULL);
lm_message_node_add_child(field, "value", message);
}
//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);
}
void LM::Presentity::ask_to ()
{
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", "subscribe",
NULL);
lm_connection_send_with_reply (connection, message, get_ignore_answer_handler (), NULL);
lm_message_unref (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;
}
void
LM::HeapRoster::add_item_form_submitted (bool submitted,
Ekiga::Form& result)
{
if ( !submitted)
return;
const std::string jid = result.text ("jid");
const std::string contact_name = result.text ("name");
const std::list<std::string> groups = result.editable_set ("groups");
if ( !jid.empty ()) {
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", jid.c_str (),
NULL);
if ( !contact_name.empty ()) {
gchar* escaped = g_markup_escape_text (contact_name.c_str (), -1);
lm_message_node_set_attributes (node,
"name", escaped,
NULL);
}
for (std::list<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);
}
items_added_by_me.insert (jid);
lm_connection_send (connection, message, NULL);
lm_message_unref (message);
}
}
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::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);
}
/**
* lm_message_new_with_sub_type:
* @to: receipient jid
* @type: message type
* @sub_type: message sub type
*
* Creates a new #LmMessage with sub type set. See lm_message_new() for more
* information.
*
* Return value: a newly created #LmMessage
**/
LmMessage *
lm_message_new_with_sub_type (const gchar *to,
LmMessageType type,
LmMessageSubType sub_type)
{
LmMessage *m;
const gchar *type_str;
m = lm_message_new (to, type);
type_str = _lm_message_sub_type_to_string (sub_type);
if (type_str) {
lm_message_node_set_attributes (m->node,
"type", type_str, NULL);
PRIV(m)->sub_type = sub_type;
}
return m;
}
static LmHandlerResult handle_iq_commands_list(LmMessageHandler *h,
LmConnection *c,
LmMessage *m, gpointer ud)
{
LmMessage *iq;
LmMessageNode *query;
const char *requester_jid;
const struct adhoc_command *command;
const char *node;
gboolean from_self;
iq = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_RESULT);
query = lm_message_node_add_child(iq->node, "query", NULL);
lm_message_node_set_attribute(query, "xmlns", NS_COMMANDS);
node = lm_message_node_get_attribute
(lm_message_node_get_child(m->node, "query"),
"node");
if (node)
lm_message_node_set_attribute(query, "node", node);
requester_jid = lm_message_get_from(m);
from_self = jid_equal(lm_connection_get_jid(c), requester_jid);
for (command = adhoc_command_list ; command->name ; command++) {
if (!command->only_for_self || from_self) {
lm_message_node_set_attributes
(lm_message_node_add_child(query, "item", NULL),
"node", command->name,
"name", command->description,
"jid", lm_connection_get_jid(c),
NULL);
}
}
lm_connection_send(c, iq, NULL);
lm_message_unref(iq);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
// 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);
}
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 ();
}
static gboolean
sasl_start (LmSASL *sasl)
{
LmMessage *auth_msg;
gboolean result;
const char *mech = NULL;
auth_msg = lm_message_new (NULL, LM_MESSAGE_TYPE_AUTH);
if (sasl->auth_type == AUTH_TYPE_PLAIN) {
GString *str;
gchar *cstr;
str = g_string_new ("");
mech = "PLAIN";
sasl->state = SASL_AUTH_STATE_PLAIN_STARTED;
if (sasl->username == NULL || sasl->password == NULL) {
g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SASL,
"%s: no username or password provided",
G_STRFUNC);
if (sasl->handler) {
sasl->handler (sasl, sasl->connection, FALSE, "no username/password provided");
}
return FALSE;
}
g_string_append_c (str, '\0');
g_string_append (str, sasl->username);
g_string_append_c (str, '\0');
g_string_append (str, sasl->password);
cstr = base64_encode ((gchar *)str->str, str->len);
lm_message_node_set_value (auth_msg->node, cstr);
g_string_free (str, TRUE);
g_free (cstr);
/* Here we say the Google magic word. Bad Google. */
lm_message_node_set_attributes (auth_msg->node,
"xmlns:ga", "http://www.google.com/talk/protocol/auth",
"ga:client-uses-full-bind-result", "true",
NULL);
}
else if (sasl->auth_type == AUTH_TYPE_DIGEST) {
mech = "DIGEST-MD5";
sasl->state = SASL_AUTH_STATE_DIGEST_MD5_STARTED;
}
lm_message_node_set_attributes (auth_msg->node,
"xmlns", XMPP_NS_SASL_AUTH,
"mechanism", mech,
NULL);
result = lm_connection_send (sasl->connection, auth_msg, NULL);
lm_message_unref (auth_msg);
if (!result) {
return FALSE;
}
return TRUE;
}
gboolean jid_reg(struct _jid *jid, GMainContext *context) {
LmConnection *reg_connect;
LmMessage *m, *reply;
LmMessageNode *query, *node;
GError *error = NULL;
// Проверяем context
if(!context)
context = g_main_context_default();
// Подключаемся
reg_connect = lm_connection_new_with_context(jid->server, context);
// Настраиваем ssl
/* if(jid->use_ssl) {
LmSSL *ssl;
// Проверяем поддержку ssl
if(!lm_ssl_is_supported()) {
g_print("Your Loudmouth doesn't support SSL. Reinstall loudmouth.\n");
jid->use_ssl = FALSE;
}
g_print("Configure ssl\n");
ssl = lm_ssl_new(NULL, LM_SSL_RESPONSE_CONTINUE, NULL, NULL);
lm_connection_set_ssl(reg_connect, ssl);
lm_ssl_unref(ssl);
lm_connection_set_port(reg_connect, LM_CONNECTION_DEFAULT_PORT_SSL);
}
*/
// Проверяем коннект
if(!lm_connection_open_and_block(reg_connect, &error)) {
fprintf(stderr, "Failed to open connection: %s\n", error->message);
return FALSE;
}
// Определяем сообщение
m = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ,
LM_MESSAGE_SUB_TYPE_SET);
// Составляем запрос
query = lm_message_node_add_child(m->node, "query", NULL);
lm_message_node_set_attributes(query, "xmlns", "jabber:iq:register", NULL);
lm_message_node_add_child(query, "username", jid->username);
lm_message_node_add_child(query, "password", jid->password);
// Отпревляем сообщение и ждём ответ
reply = lm_connection_send_with_reply_and_block(reg_connect, m, &error);
if(!reply) {
fprintf(stderr, "Failed to send registration request on server \"%s\":\n %s\n",
jid->server, error->message);
return FALSE;
}
//Закрываем соединение
lm_connection_close(reg_connect, NULL);
lm_connection_unref(reg_connect);
// Проверяем ответ
switch(lm_message_get_sub_type(reply)) {
case LM_MESSAGE_SUB_TYPE_RESULT:
g_print("Succeeded in register account '%s@%s'\n",
jid->username, jid->server);
break;
case LM_MESSAGE_SUB_TYPE_ERROR:
default:
g_print("Failed to register account '%s@%s' due to: ",
jid->username, jid->server);
node = lm_message_node_find_child(reply->node, "error");
if(node)
g_print("%s\n", lm_message_node_get_value (node));
else
g_print("Unknown error\n");
return FALSE;
break;
}
return TRUE;
}
static LmHandlerResult handle_iq_command_set_status(LmMessageHandler *h,
LmConnection *c,
LmMessage *m, gpointer ud)
{
const char *action, *node;
char *sessionid;
LmMessage *iq;
LmMessageNode *command, *x, *y;
const struct adhoc_status *s;
x = lm_message_node_get_child(m->node, "command");
action = lm_message_node_get_attribute(x, "action");
node = lm_message_node_get_attribute(x, "node");
sessionid = (char *)lm_message_node_get_attribute(x, "sessionid");
iq = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_RESULT);
command = lm_message_node_add_child(iq->node, "command", NULL);
lm_message_node_set_attribute(command, "node", node);
lm_message_node_set_attribute(command, "xmlns", NS_COMMANDS);
if (!sessionid) {
sessionid = generate_session_id("set-status");
lm_message_node_set_attribute(command, "sessionid", sessionid);
g_free(sessionid);
sessionid = NULL;
lm_message_node_set_attribute(command, "status", "executing");
x = lm_message_node_add_child(command, "x", NULL);
lm_message_node_set_attribute(x, "type", "form");
lm_message_node_set_attribute(x, "xmlns", "jabber:x:data");
lm_message_node_add_child(x, "title", "Change Status");
lm_message_node_add_child(x, "instructions",
"Choose the status and status message");
// TODO see if factorisation is possible
y = lm_message_node_add_child(x, "field", NULL);
lm_message_node_set_attribute(y, "type", "hidden");
lm_message_node_set_attribute(y, "var", "FORM_TYPE");
lm_message_node_add_child(y, "value", "http://jabber.org/protocol/rc");
y = lm_message_node_add_child(x, "field", NULL);
lm_message_node_set_attributes(y,
"type", "list-single",
"var", "status",
"label", "Status",
NULL);
lm_message_node_add_child(y, "required", NULL);
// XXX: ugly
lm_message_node_add_child(y, "value",
adhoc_status_list[xmpp_getstatus()].name);
for (s = adhoc_status_list; s->name; s++) {
LmMessageNode *option = lm_message_node_add_child(y, "option", NULL);
lm_message_node_add_child(option, "value", s->name);
lm_message_node_set_attribute(option, "label", s->description);
}
// TODO add priority ?
// I do not think this is useful, user should not have to care of the
// priority like gossip and gajim do (misc)
lm_message_node_set_attributes
(lm_message_node_add_child(x, "field", NULL),
"type", "text-multi",
"var", "status-message",
"label", "Message",
NULL);
} else if (action && !strcmp(action, "cancel")) {
lm_message_node_set_attribute(command, "status", "canceled");
} else { // (if sessionid and not canceled)
y = lm_message_node_find_xmlns(x, "jabber:x:data"); //x?xmlns=jabber:x:data
if (y) {
const char *value=NULL, *message=NULL;
LmMessageNode *fields, *field;
field = fields = lm_message_node_get_child(y, "field"); //field?var=status
while (field && strcmp("status",
lm_message_node_get_attribute(field, "var")))
field = field->next;
field = lm_message_node_get_child(field, "value");
if (field)
value = lm_message_node_get_value(field);
field = fields; //field?var=status-message
while (field && strcmp("status-message",
lm_message_node_get_attribute(field, "var")))
field = field->next;
field = lm_message_node_get_child(field, "value");
if (field)
message = lm_message_node_get_value(field);
if (value) {
for (s = adhoc_status_list; !s->name || strcmp(s->name, value); s++);
if (s->name) {
char *status = g_strdup_printf("%s %s", s->status,
message ? message : "");
cmd_setstatus(NULL, status);
g_free(status);
lm_message_node_set_attribute(command, "status", "completed");
lm_message_node_add_dataform_result(command,
"Status has been changed");
}
}
}
}
if (sessionid)
lm_message_node_set_attribute(command, "sessionid", sessionid);
lm_connection_send(c, iq, NULL);
lm_message_unref(iq);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
static LmHandlerResult handle_iq_command_leave_groupchats(LmMessageHandler *h,
LmConnection *c,
LmMessage *m,
gpointer ud)
{
const char *action, *node;
char *sessionid;
LmMessage *iq;
LmMessageNode *command, *x;
x = lm_message_node_get_child(m->node, "command");
if (!x)
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
action = lm_message_node_get_attribute(x, "action");
node = lm_message_node_get_attribute(x, "node");
sessionid = (char*)lm_message_node_get_attribute(x, "sessionid");
iq = lm_message_new_iq_from_query(m, LM_MESSAGE_SUB_TYPE_RESULT);
command = lm_message_node_add_child(iq->node, "command", NULL);
lm_message_node_set_attributes(command,
"node", node,
"xmlns", NS_COMMANDS,
NULL);
if (!sessionid) {
LmMessageNode *field;
sessionid = generate_session_id("leave-groupchats");
lm_message_node_set_attribute(command, "sessionid", sessionid);
g_free(sessionid);
sessionid = NULL;
lm_message_node_set_attribute(command, "status", "executing");
x = lm_message_node_add_child(command, "x", NULL);
lm_message_node_set_attributes(x,
"type", "form",
"xmlns", "jabber:x:data",
NULL);
lm_message_node_add_child(x, "title", "Leave groupchat(s)");
lm_message_node_add_child(x, "instructions",
"What groupchats do you want to leave?");
field = lm_message_node_add_child(x, "field", NULL);
lm_message_node_set_attributes(field,
"type", "hidden",
"var", "FORM_TYPE",
NULL);
lm_message_node_add_child(field, "value",
"http://jabber.org/protocol/rc");
field = lm_message_node_add_child(x, "field", NULL);
lm_message_node_set_attributes(field,
"type", "list-multi",
"var", "groupchats",
"label", "Groupchats: ",
NULL);
lm_message_node_add_child(field, "required", NULL);
foreach_buddy(ROSTER_TYPE_ROOM, &_callback_foreach_buddy_groupchat, field);
// TODO: return an error if we are not connected to groupchats
} else if (action && !strcmp(action, "cancel")) {
lm_message_node_set_attribute(command, "status", "canceled");
} else { // (if sessionid and not canceled)
LmMessageNode *form = lm_message_node_find_xmlns(x, "jabber:x:data");// TODO
if (form) {
LmMessageNode *field;
lm_message_node_set_attribute(command, "status", "completed");
// TODO: implement sth. like "field?var=groupchats" in xmlnode...
field = lm_message_node_get_child(form, "field");
while (field && strcmp("groupchats",
lm_message_node_get_attribute(field, "var")))
field = field->next;
if (field)
for (x = field->children ; x ; x = x->next)
{
if (!strcmp (x->name, "value")) {
GList* b = buddy_search_jid(lm_message_node_get_value(x));
if (b)
cmd_room_leave(b->data, "Requested by remote command");
}
}
lm_message_node_add_dataform_result(command,
"Groupchats have been left");
}
}
if (sessionid)
lm_message_node_set_attribute(command, "sessionid", sessionid);
lm_connection_send(c, iq, NULL);
lm_message_unref(iq);
return LM_HANDLER_RESULT_REMOVE_MESSAGE;
}
static void
parser_start_node_cb (GMarkupParseContext *context,
const gchar *node_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer user_data,
GError **error)
{
LmParser *parser;
gint i;
const gchar *node_name_unq;
const gchar *xmlns = NULL;
parser = LM_PARSER (user_data);;
/* parser->cur_depth++; */
//strip namespace prefix other than "stream:" from node_name
node_name_unq = strrchr(node_name, ':');
if (!node_name_unq || !strncmp(node_name, "stream:", 7))
node_name_unq = node_name;
else
++node_name_unq;
if (!parser->cur_root) {
/* New toplevel element */
parser->cur_root = _lm_message_node_new (node_name_unq);
parser->cur_node = parser->cur_root;
} else {
LmMessageNode *parent_node;
parent_node = parser->cur_node;
parser->cur_node = _lm_message_node_new (node_name_unq);
_lm_message_node_add_child_node (parent_node,
parser->cur_node);
}
for (i = 0; attribute_names[i]; ++i) {
g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_PARSER,
"ATTRIBUTE: %s = %s\n",
attribute_names[i],
attribute_values[i]);
//FIXME: strip namespace suffix from xmlns: attribute if exists
lm_message_node_set_attributes (parser->cur_node,
attribute_names[i],
attribute_values[i],
NULL);
if (!strncmp(attribute_names[i], "xmlns:", 6))
xmlns = attribute_values[i];
}
if (xmlns && !lm_message_node_get_attribute(parser->cur_node, "xmlns")) {
lm_message_node_set_attribute (parser->cur_node, "xmlns", xmlns);
g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_PARSER,
"ATTRIBUTE: %s = %s\n",
"xmlns", xmlns);
}
if (strcmp ("stream:stream", node_name) == 0) {
parser_end_node_cb (context,
"stream:stream",
user_data,
error);
}
}
static void
transmit_candidates (GabbleJingleTransportGoogle *transport,
const gchar *name,
GList *candidates)
{
GabbleJingleTransportGooglePrivate *priv = transport->priv;
GList *li;
LmMessage *msg;
LmMessageNode *trans_node, *sess_node;
if (candidates == NULL)
return;
msg = gabble_jingle_session_new_message (priv->content->session,
JINGLE_ACTION_TRANSPORT_INFO, &sess_node);
gabble_jingle_content_produce_node (priv->content, sess_node, FALSE, TRUE,
&trans_node);
for (li = candidates; li; li = li->next)
{
JingleCandidate *c = (JingleCandidate *) li->data;
gchar port_str[16], pref_str[16], comp_str[16], *type_str, *proto_str;
LmMessageNode *cnode;
sprintf (port_str, "%d", c->port);
sprintf (pref_str, "%lf", c->preference / 65536.0);
sprintf (comp_str, "%d", c->component);
switch (c->type) {
case JINGLE_CANDIDATE_TYPE_LOCAL:
type_str = "local";
break;
case JINGLE_CANDIDATE_TYPE_STUN:
type_str = "stun";
break;
case JINGLE_CANDIDATE_TYPE_RELAY:
type_str = "relay";
break;
default:
g_assert_not_reached ();
}
switch (c->protocol) {
case JINGLE_TRANSPORT_PROTOCOL_UDP:
proto_str = "udp";
break;
case JINGLE_TRANSPORT_PROTOCOL_TCP:
if ((c->port == 443) && (c->type == JINGLE_CANDIDATE_TYPE_RELAY))
proto_str = "ssltcp";
else
proto_str = "tcp";
break;
default:
g_assert_not_reached ();
}
cnode = lm_message_node_add_child (trans_node, "candidate", NULL);
lm_message_node_set_attributes (cnode,
"address", c->address,
"port", port_str,
"username", c->username,
"password", c->password != NULL ? c->password : "",
"preference", pref_str,
"protocol", proto_str,
"type", type_str,
"component", comp_str,
"network", "0",
"generation", "0",
NULL);
lm_message_node_set_attribute (cnode, "name", name);
}
_gabble_connection_send_with_reply (priv->content->conn, msg, NULL, NULL,
NULL, NULL);
lm_message_unref (msg);
}
void
LM::HeapRoster::parse_roster (LmMessageNode* query)
{
for (LmMessageNode* node = query->children; node != NULL; node = node->next) {
if (g_strcmp0 (node->name, "item") != 0) {
continue;
}
const gchar* jid = lm_message_node_get_attribute (node, "jid");
bool found = false;
for (iterator iter = begin (); !found && iter != end (); ++iter) {
if ((*iter)->get_jid () == jid) {
found = true;
const gchar* subscription = lm_message_node_get_attribute (node, "subscription");
if (subscription != NULL && g_strcmp0 (subscription, "remove") == 0) {
(*iter)->removed ();
} else {
(*iter)->update (node);
}
}
}
if ( !found) {
PresentityPtr presentity(new Presentity (connection, node));
presentity->chat_requested.connect (boost::bind (&LM::HeapRoster::on_chat_requested, this, presentity));
add_presentity (presentity);
const gchar* subscription = lm_message_node_get_attribute (node, "subscription");
if (subscription != NULL && g_strcmp0 (subscription, "none") == 0) {
const gchar* ask = lm_message_node_get_attribute (node, "ask");
if (ask == NULL || (ask != NULL && g_strcmp0 (ask, "subscribe") != 0)) {
std::set<std::string>::iterator iter = items_added_by_me.find (presentity->get_jid ());
if (iter != items_added_by_me.end ()) {
/* if we're here then this is a new contact, we are not subscribed to it,
* and we did not ask to be subscribed to it and we added it recently:
* let's ask for subscription!
*
* Beware that the first three actions could have been done from another client,
* so that last condition is important so we don't start doing things
* in the back of the user!
*/
items_added_by_me.erase (iter);
LmMessage* subscribe = lm_message_new (NULL, LM_MESSAGE_TYPE_PRESENCE);
lm_message_node_set_attributes (lm_message_get_node (subscribe),
"to", presentity->get_jid ().c_str (),
"type", "subscribe",
NULL);
lm_connection_send (connection, subscribe, NULL);
lm_message_unref (subscribe);
}
}
}
}
}
}
