/*
* Вход в конферецию
*/
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;
}
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;
}
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;
}
bool XMPPAccountHandler::_send(const char* base64data, XMPPBuddyPtr pBuddy)
{
UT_return_val_if_fail(base64data, false);
UT_return_val_if_fail(pBuddy, false);
if (!m_pConnection)
return false;
GError* error = NULL;
// TODO: make sure these properties are always there
const std::string resource = getProperty("resource");
const std::string server = getProperty("server");
// fully qualified address
std::string fqa = pBuddy->getAddress() + "/" + resource;
UT_DEBUGMSG(("Sending packet |%s| to |%s|\n", base64data, fqa.c_str()));
LmMessage* m = lm_message_new (fqa.c_str(), LM_MESSAGE_TYPE_MESSAGE);
lm_message_node_add_child (m->node, "body", base64data);
if (!lm_connection_send (m_pConnection, m, &error))
{
UT_DEBUGMSG(("Error while sending message to '%s':\n%s\n",
base64data, (error ? error->message : "") ));
lm_message_unref(m);
return false;
}
lm_message_unref(m);
return true;
}
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);
}
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);
}
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::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
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);
}
/*
* Установка статуса и приоритета
*/
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;
}
/**
* 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 void
send_muc_presence(MUC_REC *channel, const int show, const char *status)
{
LmMessage *lmsg;
char *channame, *str;
channame = g_strconcat(channel->name, "/", channel->nick, NULL);
str = xmpp_recode_out(channame);
g_free(channame);
lmsg = lm_message_new(str, LM_MESSAGE_TYPE_PRESENCE);
g_free(str);
if (show != XMPP_PRESENCE_AVAILABLE)
lm_message_node_add_child(lmsg->node, "show",
xmpp_presence_show[show]);
if (status != NULL) {
str = xmpp_recode_out(status);
lm_message_node_add_child(lmsg->node, "status", str);
g_free(str);
}
signal_emit("xmpp send presence", 2, channel->server, lmsg);
lm_message_unref(lmsg);
}
void harmony_get_session_id(MP3tunesHarmony *harmony) {
LmMessage *message_out;
LmMessageHandler *handler;
LmMessageNode *message_out_node;
GError *err = NULL;
handler = lm_message_handler_new(harmony_get_session_id_callback, (gpointer)harmony, NULL);
message_out = lm_message_new(MP3TUNES_HARMONY_CONDUCTOR, LM_MESSAGE_TYPE_IQ);
message_out_node = lm_message_node_add_child(message_out->node, "sessionId", NULL);
lm_message_node_set_attribute(message_out_node, "xmlns", MP3TUNES_HARMONY_XMLNS);
lm_connection_send_with_reply(harmony->connection,
message_out,
handler,
&err);
lm_message_unref(message_out);
if (err != NULL) {
error_emit(harmony, MP3TUNES_HARMONY_ERROR_MISC, "Sending session id request failed", err);
return;
}
harmony->sid_state = MP3TUNES_HARMONY_SID_STATE_WAITING;
}
// Invite a user to a MUC room
// room syntax: "room@server"
// reason can be null.
void xmpp_room_invite(const char *room, const char *fjid, const char *reason)
{
LmMessage *msg;
LmMessageNode *x, *y;
if (!xmpp_is_online() || !room || !fjid)
return;
msg = lm_message_new(room, LM_MESSAGE_TYPE_MESSAGE);
x = lm_message_node_add_child(msg->node, "x", NULL);
lm_message_node_set_attribute(x, "xmlns", NS_MUC_USER);
y = lm_message_node_add_child(x, "invite", NULL);
lm_message_node_set_attribute(y, "to", fjid);
if (reason)
lm_message_node_add_child(y, "reason", reason);
lm_connection_send(lconnection, msg, NULL);
lm_message_unref(msg);
}
static void decline_invitation(event_muc_invitation *invitation, const char *reason)
{
// cut and paste from xmpp_room_invite
LmMessage *m;
LmMessageNode *x, *y;
if (!invitation) return;
if (!invitation->to || !invitation->from) return;
m = lm_message_new(invitation->to, LM_MESSAGE_TYPE_MESSAGE);
x = lm_message_node_add_child(m->node, "x", NULL);
lm_message_node_set_attribute(x, "xmlns", NS_MUC_USER);
y = lm_message_node_add_child(x, "decline", NULL);
lm_message_node_set_attribute(y, "to", invitation->from);
if (reason)
lm_message_node_add_child(y, "reason", reason);
lm_connection_send(lconnection, m, NULL);
lm_message_unref(m);
}
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;
}
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);
}
}
}
}
}
}
