gboolean jabber_chat_kick_user(JabberChat *chat, const char *who, const char *why)
{
JabberIq *iq;
JabberChatMember *jcm = g_hash_table_lookup(chat->members, who);
char *to;
xmlnode *query, *item, *reason;
if(!jcm || !jcm->jid)
return FALSE;
iq = jabber_iq_new_query(chat->js, JABBER_IQ_SET,
"http://jabber.org/protocol/muc#admin");
to = g_strdup_printf("%s@%s", chat->room, chat->server);
xmlnode_set_attrib(iq->node, "to", to);
g_free(to);
query = xmlnode_get_child(iq->node, "query");
item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "jid", jcm->jid);
xmlnode_set_attrib(item, "role", "none");
if(why) {
reason = xmlnode_new_child(item, "reason");
xmlnode_insert_data(reason, why, -1);
}
jabber_iq_send(iq);
return TRUE;
}
static void
jabber_si_bytestreams_connect_cb(gpointer data, gint source, const gchar *error_message)
{
GaimXfer *xfer = data;
JabberSIXfer *jsx = xfer->data;
JabberIq *iq;
xmlnode *query, *su;
struct bytestreams_streamhost *streamhost = jsx->streamhosts->data;
gaim_proxy_info_destroy(jsx->gpi);
jsx->connect_data = NULL;
if(source < 0) {
jsx->streamhosts = g_list_remove(jsx->streamhosts, streamhost);
g_free(streamhost->jid);
g_free(streamhost->host);
g_free(streamhost);
jabber_si_bytestreams_attempt_connect(xfer);
return;
}
iq = jabber_iq_new_query(jsx->js, JABBER_IQ_RESULT, "http://jabber.org/protocol/bytestreams");
xmlnode_set_attrib(iq->node, "to", xfer->who);
jabber_iq_set_id(iq, jsx->iq_id);
query = xmlnode_get_child(iq->node, "query");
su = xmlnode_new_child(query, "streamhost-used");
xmlnode_set_attrib(su, "jid", streamhost->jid);
jabber_iq_send(iq);
gaim_xfer_start(xfer, source, NULL, -1);
}
gboolean jabber_chat_affiliate_user(JabberChat *chat, const char *who, const char *affiliation)
{
JabberChatMember *jcm;
const char *jid;
char *to;
JabberIq *iq;
xmlnode *query, *item;
jcm = g_hash_table_lookup(chat->members, who);
if (jcm && jcm->jid)
jid = jcm->jid;
else if (strchr(who, '@') != NULL)
jid = who;
else
return FALSE;
iq = jabber_iq_new_query(chat->js, JABBER_IQ_SET,
"http://jabber.org/protocol/muc#admin");
to = g_strdup_printf("%s@%s", chat->room, chat->server);
xmlnode_set_attrib(iq->node, "to", to);
g_free(to);
query = xmlnode_get_child(iq->node, "query");
item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "jid", jid);
xmlnode_set_attrib(item, "affiliation", affiliation);
jabber_iq_send(iq);
return TRUE;
}
void
jabber_data_parse(JabberStream *js, const char *who, JabberIqType type,
const char *id, xmlnode *data_node)
{
JabberIq *result = NULL;
const char *cid = xmlnode_get_attrib(data_node, "cid");
const JabberData *data = cid ? jabber_data_find_local_by_cid(cid) : NULL;
if (!data) {
xmlnode *item_not_found = xmlnode_new("item-not-found");
result = jabber_iq_new(js, JABBER_IQ_ERROR);
if (who)
xmlnode_set_attrib(result->node, "to", who);
xmlnode_set_attrib(result->node, "id", id);
xmlnode_insert_child(result->node, item_not_found);
} else {
result = jabber_iq_new(js, JABBER_IQ_RESULT);
if (who)
xmlnode_set_attrib(result->node, "to", who);
xmlnode_set_attrib(result->node, "id", id);
xmlnode_insert_child(result->node,
jabber_data_get_xml_definition(data));
}
jabber_iq_send(result);
}
static void jabber_iq_last_parse(JabberStream *js, xmlnode *packet)
{
JabberIq *iq;
const char *type;
const char *from;
const char *id;
xmlnode *query;
char *idle_time;
type = xmlnode_get_attrib(packet, "type");
from = xmlnode_get_attrib(packet, "from");
id = xmlnode_get_attrib(packet, "id");
if(type && !strcmp(type, "get")) {
iq = jabber_iq_new_query(js, JABBER_IQ_RESULT, "jabber:iq:last");
jabber_iq_set_id(iq, id);
xmlnode_set_attrib(iq->node, "to", from);
query = xmlnode_get_child(iq->node, "query");
idle_time = g_strdup_printf("%ld", js->idle ? time(NULL) - js->idle : 0);
xmlnode_set_attrib(query, "seconds", idle_time);
g_free(idle_time);
jabber_iq_send(iq);
}
}
void jabber_roster_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy,
PurpleGroup *group) {
GSList *buddies = purple_find_buddies(gc->account, buddy->name);
buddies = g_slist_remove(buddies, buddy);
if(buddies != NULL) {
PurpleBuddy *tmpbuddy;
PurpleGroup *tmpgroup;
GSList *groups = NULL;
while(buddies) {
tmpbuddy = buddies->data;
tmpgroup = purple_buddy_get_group(tmpbuddy);
groups = g_slist_append(groups, tmpgroup->name);
buddies = g_slist_remove(buddies, tmpbuddy);
}
jabber_roster_update(gc->proto_data, buddy->name, groups);
g_slist_free(groups);
} else {
JabberIq *iq = jabber_iq_new_query(gc->proto_data, JABBER_IQ_SET,
"jabber:iq:roster");
xmlnode *query = xmlnode_get_child(iq->node, "query");
xmlnode *item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "jid", buddy->name);
xmlnode_set_attrib(item, "subscription", "remove");
jabber_iq_send(iq);
}
}
static void
google_session_stream_info_cb(PurpleMedia *media, PurpleMediaInfoType type,
gchar *sid, gchar *name, gboolean local,
GoogleSession *session)
{
if (sid != NULL || name != NULL)
return;
if (type == PURPLE_MEDIA_INFO_HANGUP) {
xmlnode *sess;
JabberIq *iq = jabber_iq_new(session->js, JABBER_IQ_SET);
xmlnode_set_attrib(iq->node, "to", session->remote_jid);
sess = google_session_create_xmlnode(session, "terminate");
xmlnode_insert_child(iq->node, sess);
jabber_iq_send(iq);
} else if (type == PURPLE_MEDIA_INFO_REJECT) {
xmlnode *sess;
JabberIq *iq = jabber_iq_new(session->js, JABBER_IQ_SET);
xmlnode_set_attrib(iq->node, "to", session->remote_jid);
sess = google_session_create_xmlnode(session, "reject");
xmlnode_insert_child(iq->node, sess);
jabber_iq_send(iq);
} else if (type == PURPLE_MEDIA_INFO_ACCEPT && local == TRUE) {
google_session_ready(session);
}
}
void GetBuddyInfo(struct fetion_account_data *sip, const char *who)
{
gint xml_len;
xmlnode *root, *son, *item;
gchar *body;
root = xmlnode_new("args");
g_return_if_fail(root != NULL);
son = xmlnode_new_child(root, "contacts");
xmlnode_set_attrib(son, "attributes", "all");
//xmlnode_set_attrib(son,"extended-attributes","score-level");
g_return_if_fail(son != NULL);
item = xmlnode_new_child(son, "contact");
g_return_if_fail(item != NULL);
xmlnode_set_attrib(item, "uri", who);
body = g_strdup_printf("%s",xmlnode_to_str(root, &xml_len));
purple_debug_info("fetion:", "GetBuddyInfo:body=[%s]", body);
send_sip_request(sip->gc, "S", "", "", "N: GetContactsInfo\r\n", body,
NULL, (TransCallback) GetBuddyInfo_cb);
xmlnode_free(root);
g_free(body);
}
gboolean jabber_chat_role_user(JabberChat *chat, const char *who, const char *role)
{
char *to;
JabberIq *iq;
xmlnode *query, *item;
JabberChatMember *jcm;
jcm = g_hash_table_lookup(chat->members, who);
if (!jcm || !jcm->handle)
return FALSE;
iq = jabber_iq_new_query(chat->js, JABBER_IQ_SET,
"http://jabber.org/protocol/muc#admin");
to = g_strdup_printf("%s@%s", chat->room, chat->server);
xmlnode_set_attrib(iq->node, "to", to);
g_free(to);
query = xmlnode_get_child(iq->node, "query");
item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "nick", jcm->handle);
xmlnode_set_attrib(item, "role", role);
jabber_iq_send(iq);
return TRUE;
}
void
jabber_data_parse(JabberStream *js, xmlnode *packet)
{
JabberIq *result = NULL;
const char *who = xmlnode_get_attrib(packet, "from");
xmlnode *data_node = xmlnode_get_child(packet, "data");
const JabberData *data =
jabber_data_find_local_by_cid(xmlnode_get_attrib(data_node, "cid"));
if (!data) {
xmlnode *item_not_found = xmlnode_new("item-not-found");
result = jabber_iq_new(js, JABBER_IQ_ERROR);
xmlnode_set_attrib(result->node, "to", who);
xmlnode_set_attrib(result->node, "id", xmlnode_get_attrib(packet, "id"));
xmlnode_insert_child(result->node, item_not_found);
} else {
result = jabber_iq_new(js, JABBER_IQ_RESULT);
xmlnode_set_attrib(result->node, "to", who);
xmlnode_set_attrib(result->node, "id", xmlnode_get_attrib(packet, "id"));
xmlnode_insert_child(result->node,
jabber_data_get_xml_definition(data));
}
jabber_iq_send(result);
}
static xmlnode *
google_session_create_xmlnode(GoogleSession *session, const char *type)
{
xmlnode *node = xmlnode_new("session");
xmlnode_set_namespace(node, NS_GOOGLE_SESSION);
xmlnode_set_attrib(node, "id", session->id.id);
xmlnode_set_attrib(node, "initiator", session->id.initiator);
xmlnode_set_attrib(node, "type", type);
return node;
}
static void
jabber_si_xfer_bytestreams_listen_cb(int sock, gpointer data)
{
GaimXfer *xfer = data;
JabberSIXfer *jsx;
JabberIq *iq;
xmlnode *query, *streamhost;
char *jid, *port;
jsx = xfer->data;
jsx->listen_data = NULL;
if (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_CANCEL_LOCAL) {
gaim_xfer_unref(xfer);
return;
}
gaim_xfer_unref(xfer);
if (sock < 0) {
gaim_xfer_cancel_local(xfer);
return;
}
iq = jabber_iq_new_query(jsx->js, JABBER_IQ_SET,
"http://jabber.org/protocol/bytestreams");
xmlnode_set_attrib(iq->node, "to", xfer->who);
query = xmlnode_get_child(iq->node, "query");
xmlnode_set_attrib(query, "sid", jsx->stream_id);
streamhost = xmlnode_new_child(query, "streamhost");
jid = g_strdup_printf("%s@%s/%s", jsx->js->user->node,
jsx->js->user->domain, jsx->js->user->resource);
xmlnode_set_attrib(streamhost, "jid", jid);
g_free(jid);
/* XXX: shouldn't we use the public IP or something? here */
xmlnode_set_attrib(streamhost, "host",
gaim_network_get_my_ip(jsx->js->fd));
xfer->local_port = gaim_network_get_port_from_fd(sock);
port = g_strdup_printf("%hu", xfer->local_port);
xmlnode_set_attrib(streamhost, "port", port);
g_free(port);
xfer->watcher = gaim_input_add(sock, GAIM_INPUT_READ,
jabber_si_xfer_bytestreams_send_connected_cb, xfer);
/* XXX: insert proxies here */
/* XXX: callback to find out which streamhost they used, or see if they
* screwed it up */
jabber_iq_send(iq);
}
static void jabber_roster_update(JabberStream *js, const char *name,
GSList *grps)
{
PurpleBuddy *b;
PurpleGroup *g;
GSList *groups = NULL, *l;
JabberIq *iq;
xmlnode *query, *item, *group;
if (js->currently_parsing_roster_push)
return;
if(!(b = purple_find_buddy(js->gc->account, name)))
return;
if(grps) {
groups = grps;
} else {
GSList *buddies = purple_find_buddies(js->gc->account, name);
if(!buddies)
return;
while(buddies) {
b = buddies->data;
g = purple_buddy_get_group(b);
groups = g_slist_append(groups, g->name);
buddies = g_slist_remove(buddies, b);
}
}
iq = jabber_iq_new_query(js, JABBER_IQ_SET, "jabber:iq:roster");
query = xmlnode_get_child(iq->node, "query");
item = xmlnode_new_child(query, "item");
xmlnode_set_attrib(item, "jid", name);
xmlnode_set_attrib(item, "name", b->alias ? b->alias : "");
for(l = groups; l; l = l->next) {
group = xmlnode_new_child(item, "group");
xmlnode_insert_data(group, l->data, -1);
}
if(!grps)
g_slist_free(groups);
if (js->server_caps & JABBER_CAP_GOOGLE_ROSTER) {
jabber_google_roster_outgoing(js, query, item);
xmlnode_set_attrib(query, "xmlns:gr", "google:roster");
xmlnode_set_attrib(query, "gr:ext", "2");
}
jabber_iq_send(iq);
}
void jabber_chat_invite(PurpleConnection *gc, int id, const char *msg,
const char *name)
{
JabberStream *js = gc->proto_data;
JabberChat *chat;
xmlnode *message, *body, *x, *invite;
char *room_jid;
chat = jabber_chat_find_by_id(js, id);
if(!chat)
return;
message = xmlnode_new("message");
room_jid = g_strdup_printf("%s@%s", chat->room, chat->server);
if(chat->muc) {
xmlnode_set_attrib(message, "to", room_jid);
x = xmlnode_new_child(message, "x");
xmlnode_set_namespace(x, "http://jabber.org/protocol/muc#user");
invite = xmlnode_new_child(x, "invite");
xmlnode_set_attrib(invite, "to", name);
if (msg) {
body = xmlnode_new_child(invite, "reason");
xmlnode_insert_data(body, msg, -1);
}
} else {
xmlnode_set_attrib(message, "to", name);
/*
* Putting the reason into the body was an 'undocumented protocol,
* ...not part of "groupchat 1.0"'.
* http://xmpp.org/extensions/attic/jep-0045-1.16.html#invite
*
* Left here for compatibility.
*/
if (msg) {
body = xmlnode_new_child(message, "body");
xmlnode_insert_data(body, msg, -1);
}
x = xmlnode_new_child(message, "x");
xmlnode_set_attrib(x, "jid", room_jid);
/* The better place for it! XEP-0249 style. */
if (msg)
xmlnode_set_attrib(x, "reason", msg);
xmlnode_set_namespace(x, "jabber:x:conference");
}
jabber_send(js, message);
xmlnode_free(message);
g_free(room_jid);
}
xmlnode *
jabber_data_get_xhtml_im(const JabberData *data, const gchar *alt)
{
xmlnode *img = xmlnode_new("img");
char src[128];
xmlnode_set_attrib(img, "alt", alt);
g_snprintf(src, sizeof(src), "cid:%s", data->cid);
xmlnode_set_attrib(img, "src", src);
return img;
}
void jabber_mam_request(JabberStream *js, const char* after)
{
if (!js->mam)
return;
JabberIq *iq = jabber_iq_new_query(js, JABBER_IQ_SET, NS_XMPP_MAM);
xmlnode *query = xmlnode_get_child(iq->node, "query");
xmlnode *x = xmlnode_new_child(query, "x");
xmlnode_set_namespace(x, "jabber:x:data");
xmlnode *field = xmlnode_new_child(x, "field");
xmlnode_set_attrib(field, "type", "hidden");
xmlnode_set_attrib(field, "var", "FORM_TYPE");
xmlnode *value = xmlnode_new_child(field, "value");
xmlnode_insert_data(value, NS_XMPP_MAM, -1);
if (after) {
xmlnode *set = xmlnode_new_child(query, "set");
xmlnode_set_namespace(set, NS_RSM);
value = xmlnode_new_child(set, "after");
xmlnode_insert_data(value, after, -1);
}
if (js->mam->current->start) {
field = xmlnode_new_child(x, "field");
xmlnode_set_attrib(field, "var", "start");
value = xmlnode_new_child(field, "value");
xmlnode_insert_data(value, js->mam->current->start, -1);
}
if (js->mam->current->end) {
field = xmlnode_new_child(x, "field");
xmlnode_set_attrib(field, "var", "end");
value = xmlnode_new_child(field, "value");
xmlnode_insert_data(value, js->mam->current->end, -1);
}
if (js->mam->current->with) {
field = xmlnode_new_child(x, "field");
xmlnode_set_attrib(field, "var", "with");
value = xmlnode_new_child(field, "value");
xmlnode_insert_data(value, js->mam->current->with, -1);
}
jabber_iq_send(iq);
}
static void
bonjour_bytestreams_listen(int sock, gpointer data)
{
PurpleXfer *xfer = data;
XepXfer *xf;
XepIq *iq;
xmlnode *query, *streamhost;
gchar *port;
GSList *local_ips;
BonjourData *bd;
purple_debug_info("bonjour", "Bonjour-bytestreams-listen. sock=%d.\n", sock);
if (sock < 0 || xfer == NULL) {
/*purple_xfer_cancel_local(xfer);*/
return;
}
xfer->watcher = purple_input_add(sock, PURPLE_INPUT_READ,
bonjour_sock5_request_cb, xfer);
xf = (XepXfer*)xfer->data;
xf->listen_data = NULL;
bd = xf->data;
iq = xep_iq_new(bd, XEP_IQ_SET, xfer->who, bonjour_get_jid(bd->jabber_data->account), xf->sid);
query = xmlnode_new_child(iq->node, "query");
xmlnode_set_namespace(query, "http://jabber.org/protocol/bytestreams");
xmlnode_set_attrib(query, "sid", xf->sid);
xmlnode_set_attrib(query, "mode", "tcp");
xfer->local_port = purple_network_get_port_from_fd(sock);
local_ips = bonjour_jabber_get_local_ips(sock);
port = g_strdup_printf("%hu", (guint16)purple_xfer_get_local_port(xfer));
while(local_ips) {
streamhost = xmlnode_new_child(query, "streamhost");
xmlnode_set_attrib(streamhost, "jid", xf->sid);
xmlnode_set_attrib(streamhost, "host", local_ips->data);
xmlnode_set_attrib(streamhost, "port", port);
g_free(local_ips->data);
local_ips = g_slist_delete_link(local_ips, local_ips);
}
g_free(port);
xep_iq_send_and_free(iq);
}
/**
* Tries to append an interface scope to an IPv6 link local address.
*
* If the given address is a link local IPv6 address (with no
* interface scope) then we try to determine all fitting interfaces
* from our Bonjour IP address list.
*
* For any such found matches we insert a copy of our current xml
* streamhost entry right after this streamhost entry and append
* the determined interface to the host address of this copy.
*
* @param cur_streamhost The XML streamhost node we examine
* @param host The host address to examine in text form
* @param pb Buddy to get the list of link local IPv6 addresses
* and their interface from
* @return Returns TRUE if the specified 'host' address is a
* link local IPv6 address with no interface scope.
* Otherwise returns FALSE.
*/
static gboolean
add_ipv6_link_local_ifaces(xmlnode *cur_streamhost, const char *host,
const PurpleBuddy *pb) {
xmlnode *new_streamhost = NULL;
struct in6_addr in6_addr;
BonjourBuddy *bb;
GSList *ip_elem;
if (inet_pton(AF_INET6, host, &in6_addr) != 1 ||
!IN6_IS_ADDR_LINKLOCAL(&in6_addr) ||
strchr(host, '%'))
return FALSE;
bb = purple_buddy_get_protocol_data(pb);
for (ip_elem = bb->ips;
(ip_elem = g_slist_find_custom(ip_elem, host, (GCompareFunc)&xep_addr_differ));
ip_elem = ip_elem->next) {
purple_debug_info("bonjour", "Inserting an xmlnode twin copy for %s with new host address %s\n",
host, (char*)ip_elem->data);
new_streamhost = xmlnode_insert_twin_copy(cur_streamhost);
xmlnode_set_attrib(new_streamhost, "host", ip_elem->data);
}
if (!new_streamhost)
purple_debug_info("bonjour", "No interface for this IPv6 link local address found: %s\n",
host);
return TRUE;
}
void jabber_chat_request_room_configure(JabberChat *chat) {
JabberIq *iq;
char *room_jid;
if(!chat)
return;
chat->config_dialog_handle = NULL;
if(!chat->muc) {
purple_notify_error(chat->js->gc, _("Room Configuration Error"), _("Room Configuration Error"),
_("This room is not capable of being configured"));
return;
}
iq = jabber_iq_new_query(chat->js, JABBER_IQ_GET,
"http://jabber.org/protocol/muc#owner");
room_jid = g_strdup_printf("%s@%s", chat->room, chat->server);
xmlnode_set_attrib(iq->node, "to", room_jid);
jabber_iq_set_callback(iq, jabber_chat_room_configure_cb, NULL);
jabber_iq_send(iq);
g_free(room_jid);
}
void CreateTempGroup(PurpleConnection * gc, PurpleBuddy * buddy)
{
gchar *body, *hdr;
gint xml_len;
xmlnode *root, *son, *item;
struct fetion_account_data *sip = gc->proto_data;
root = xmlnode_new("args");
g_return_if_fail(root != NULL);
son = xmlnode_new_child(root, "participants");
g_return_if_fail(son != NULL);
son = xmlnode_new_child(son, "participant");
g_return_if_fail(son != NULL);
xmlnode_set_attrib(son, "uri", buddy->name);
hdr = g_strdup("N: CreateTemporaryGroup\r\nK: text/html-fragment\r\n");
body = g_strdup_printf(xmlnode_to_str(root, &xml_len));
purple_debug(PURPLE_DEBUG_MISC, "fetion", "in CreateTempGroup[%s]\n",
body);
send_sip_request(sip->gc, "S", "", "", hdr, body, NULL,
CreateTempGroup_cb);
g_free(body);
g_free(hdr);
xmlnode_free(root);
}
xmlnode *
jabber_data_get_xml_definition(const JabberData *data)
{
xmlnode *tag = xmlnode_new("data");
char *base64data = purple_base64_encode(data->data, data->size);
xmlnode_set_namespace(tag, NS_BOB);
xmlnode_set_attrib(tag, "cid", data->cid);
xmlnode_set_attrib(tag, "type", data->type);
xmlnode_insert_data(tag, base64data, -1);
g_free(base64data);
return tag;
}
void jabber_roster_request(JabberStream *js)
{
JabberIq *iq;
xmlnode *query;
iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:roster");
query = xmlnode_get_child(iq->node, "query");
if (js->server_caps & JABBER_CAP_GOOGLE_ROSTER) {
xmlnode_set_attrib(query, "xmlns:gr", NS_GOOGLE_ROSTER);
xmlnode_set_attrib(query, "gr:ext", "2");
}
jabber_iq_set_callback(iq, roster_request_cb, NULL);
jabber_iq_send(iq);
}
static xmlnode *gfire_game_configuration_to_xmlnode(const gfire_game_configuration *p_gconf)
{
xmlnode *ret = xmlnode_new("game");
gchar *id_str = g_strdup_printf("%u", p_gconf->game_id);
xmlnode_set_attrib(ret, "id", id_str);
g_free(id_str);
xmlnode *command_node = xmlnode_new_child(ret, "command");
if(p_gconf->detect_file)
{
xmlnode *detect_node = xmlnode_new_child(command_node, "detect");
xmlnode_insert_data(detect_node, p_gconf->detect_file, -1);
}
if(p_gconf->launch_file)
{
xmlnode *launch_node = xmlnode_new_child(command_node, "launch");
xmlnode_insert_data(launch_node, p_gconf->launch_file, -1);
}
if(p_gconf->launch_prefix)
{
xmlnode *prefix_node = xmlnode_new_child(command_node, "prefix");
xmlnode_insert_data(prefix_node, p_gconf->launch_prefix, -1);
}
return ret;
}
void jabber_gmail_init(JabberStream *js) {
JabberIq *iq;
xmlnode *usersetting, *mailnotifications;
if (!purple_account_get_check_mail(purple_connection_get_account(js->gc)))
return;
/*
* Quoting http://code.google.com/apis/talk/jep_extensions/usersettings.html:
* To ensure better compatibility with other clients, rather than
* setting this value to "false" to turn off notifications, it is
* recommended that a client set this to "true" and filter incoming
* email notifications itself.
*/
iq = jabber_iq_new(js, JABBER_IQ_SET);
usersetting = xmlnode_new_child(iq->node, "usersetting");
xmlnode_set_namespace(usersetting, "google:setting");
mailnotifications = xmlnode_new_child(usersetting, "mailnotifications");
xmlnode_set_attrib(mailnotifications, "value", "true");
jabber_iq_send(iq);
iq = jabber_iq_new_query(js, JABBER_IQ_GET, NS_GOOGLE_MAIL_NOTIFY);
jabber_iq_set_callback(iq, jabber_gmail_parse, NULL);
jabber_iq_send(iq);
}
static JabberSaslState
fb_start(JabberStream *js, xmlnode *packet, xmlnode **response, char **error)
{
PurpleAccount *account;
const char *username;
gchar **parts;
account = purple_connection_get_account(js->gc);
username = purple_account_get_username(account);
purple_debug_error("auth_fb", "account name is %s", username);
parts = g_strsplit(username, "@", 0);
if (parts[0] && strlen(parts[0]) && g_str_has_prefix(parts[0], "-")) {
/* When connecting with X-FACEBOOK-PLATFORM, the password field must be set to the
* OAUTH 2.0 session key.
*
* X-FACEBOOK-PLATFORM is only valid for a facebook userID, which is prefixed with '-'
*/
xmlnode *auth = xmlnode_new("auth");
xmlnode_set_namespace(auth, "urn:ietf:params:xml:ns:xmpp-sasl");
xmlnode_set_attrib(auth, "mechanism", "X-FACEBOOK-PLATFORM");
*response = auth;
g_strfreev(parts);
return JABBER_SASL_STATE_CONTINUE;
} else {
g_strfreev(parts);
return JABBER_SASL_STATE_FAIL;
}
}
void jabber_chat_change_nick(JabberChat *chat, const char *nick)
{
xmlnode *presence;
char *full_jid;
PurplePresence *gpresence;
PurpleStatus *status;
JabberBuddyState state;
char *msg;
int priority;
if(!chat->muc) {
purple_conv_chat_write(PURPLE_CONV_CHAT(chat->conv), "",
_("Nick changing not supported in non-MUC chatrooms"),
PURPLE_MESSAGE_SYSTEM, time(NULL));
return;
}
gpresence = purple_account_get_presence(chat->js->gc->account);
status = purple_presence_get_active_status(gpresence);
purple_status_to_jabber(status, &state, &msg, &priority);
presence = jabber_presence_create(state, msg, priority);
full_jid = g_strdup_printf("%s@%s/%s", chat->room, chat->server, nick);
xmlnode_set_attrib(presence, "to", full_jid);
g_free(full_jid);
g_free(msg);
jabber_send(chat->js, presence);
xmlnode_free(presence);
}
static void jabber_iq_version_parse(JabberStream *js, xmlnode *packet)
{
JabberIq *iq;
const char *type, *from, *id;
xmlnode *query;
type = xmlnode_get_attrib(packet, "type");
if(type && !strcmp(type, "get")) {
GHashTable *ui_info;
const char *ui_name = NULL, *ui_version = NULL;
#if 0
char *os = NULL;
if(!purple_prefs_get_bool("/plugins/prpl/jabber/hide_os")) {
struct utsname osinfo;
uname(&osinfo);
os = g_strdup_printf("%s %s %s", osinfo.sysname, osinfo.release,
osinfo.machine);
}
#endif
from = xmlnode_get_attrib(packet, "from");
id = xmlnode_get_attrib(packet, "id");
iq = jabber_iq_new_query(js, JABBER_IQ_RESULT, "jabber:iq:version");
xmlnode_set_attrib(iq->node, "to", from);
jabber_iq_set_id(iq, id);
query = xmlnode_get_child(iq->node, "query");
ui_info = purple_core_get_ui_info();
if(NULL != ui_info) {
ui_name = g_hash_table_lookup(ui_info, "name");
ui_version = g_hash_table_lookup(ui_info, "version");
}
if(NULL != ui_name && NULL != ui_version) {
char *version_complete = g_strdup_printf("%s (libpurple " VERSION ")", ui_version);
xmlnode_insert_data(xmlnode_new_child(query, "name"), ui_name, -1);
xmlnode_insert_data(xmlnode_new_child(query, "version"), version_complete, -1);
g_free(version_complete);
} else {
xmlnode_insert_data(xmlnode_new_child(query, "name"), "libpurple", -1);
xmlnode_insert_data(xmlnode_new_child(query, "version"), VERSION, -1);
}
#if 0
if(os) {
xmlnode_insert_data(xmlnode_new_child(query, "os"), os, -1);
g_free(os);
}
#endif
jabber_iq_send(iq);
}
}
void jabber_chat_part(JabberChat *chat, const char *msg)
{
char *room_jid;
xmlnode *presence;
room_jid = g_strdup_printf("%s@%s/%s", chat->room, chat->server,
chat->handle);
presence = xmlnode_new("presence");
xmlnode_set_attrib(presence, "to", room_jid);
xmlnode_set_attrib(presence, "type", "unavailable");
if(msg) {
xmlnode *status = xmlnode_new_child(presence, "status");
xmlnode_insert_data(status, msg, -1);
}
jabber_send(chat->js, presence);
xmlnode_free(presence);
g_free(room_jid);
}
static xmlnode *
jingle_content_to_xml_internal(JingleContent *content, xmlnode *jingle, JingleActionType action)
{
xmlnode *node = xmlnode_new_child(jingle, "content");
gchar *creator = jingle_content_get_creator(content);
gchar *name = jingle_content_get_name(content);
gchar *senders = jingle_content_get_senders(content);
gchar *disposition = jingle_content_get_disposition(content);
xmlnode_set_attrib(node, "creator", creator);
xmlnode_set_attrib(node, "name", name);
xmlnode_set_attrib(node, "senders", senders);
if (strcmp("session", disposition))
xmlnode_set_attrib(node, "disposition", disposition);
g_free(disposition);
g_free(senders);
g_free(name);
g_free(creator);
if (action != JINGLE_CONTENT_REMOVE) {
JingleTransport *transport;
if (action != JINGLE_TRANSPORT_ACCEPT &&
action != JINGLE_TRANSPORT_INFO &&
action != JINGLE_TRANSPORT_REJECT &&
action != JINGLE_TRANSPORT_REPLACE) {
xmlnode *description = xmlnode_new_child(node, "description");
xmlnode_set_namespace(description,
jingle_content_get_description_type(content));
}
if (action != JINGLE_TRANSPORT_REJECT && action == JINGLE_TRANSPORT_REPLACE)
transport = jingle_content_get_pending_transport(content);
else
transport = jingle_content_get_transport(content);
jingle_transport_to_xml(transport, node, action);
g_object_unref(transport);
}
return node;
}
xmlnode *
jabber_data_get_xml_request(const gchar *cid)
{
xmlnode *tag = xmlnode_new("data");
xmlnode_set_namespace(tag, NS_BOB);
xmlnode_set_attrib(tag, "cid", cid);
return tag;
}
