static PurpleXmlNode *
pounce_to_xmlnode(PurplePounce *pounce)
{
PurpleXmlNode *node, *child;
PurpleAccount *pouncer;
PurplePounceEvent events;
PurplePounceOption options;
pouncer = purple_pounce_get_pouncer(pounce);
events = purple_pounce_get_events(pounce);
options = purple_pounce_get_options(pounce);
node = purple_xmlnode_new("pounce");
purple_xmlnode_set_attrib(node, "ui", pounce->ui_type);
child = purple_xmlnode_new_child(node, "account");
purple_xmlnode_set_attrib(child, "protocol", purple_account_get_protocol_id(pouncer));
purple_xmlnode_insert_data(child,
purple_normalize(pouncer, purple_account_get_username(pouncer)), -1);
child = purple_xmlnode_new_child(node, "pouncee");
purple_xmlnode_insert_data(child, purple_pounce_get_pouncee(pounce), -1);
/* Write pounce options */
child = purple_xmlnode_new_child(node, "options");
if (options & PURPLE_POUNCE_OPTION_AWAY)
add_option_to_xmlnode(child, "on-away");
/* Write pounce events */
child = purple_xmlnode_new_child(node, "events");
if (events & PURPLE_POUNCE_SIGNON)
add_event_to_xmlnode(child, "sign-on");
if (events & PURPLE_POUNCE_SIGNOFF)
add_event_to_xmlnode(child, "sign-off");
if (events & PURPLE_POUNCE_AWAY)
add_event_to_xmlnode(child, "away");
if (events & PURPLE_POUNCE_AWAY_RETURN)
add_event_to_xmlnode(child, "return-from-away");
if (events & PURPLE_POUNCE_IDLE)
add_event_to_xmlnode(child, "idle");
if (events & PURPLE_POUNCE_IDLE_RETURN)
add_event_to_xmlnode(child, "return-from-idle");
if (events & PURPLE_POUNCE_TYPING)
add_event_to_xmlnode(child, "start-typing");
if (events & PURPLE_POUNCE_TYPED)
add_event_to_xmlnode(child, "typed");
if (events & PURPLE_POUNCE_TYPING_STOPPED)
add_event_to_xmlnode(child, "stop-typing");
if (events & PURPLE_POUNCE_MESSAGE_RECEIVED)
add_event_to_xmlnode(child, "message-received");
/* Write pounce actions */
child = purple_xmlnode_new_child(node, "actions");
g_hash_table_foreach(pounce->actions, action_parameter_list_to_xmlnode, child);
if (purple_pounce_get_save(pounce))
purple_xmlnode_new_child(node, "save");
return node;
}
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) {
PurpleXmlNode *sess;
JabberIq *iq = jabber_iq_new(session->js, JABBER_IQ_SET);
purple_xmlnode_set_attrib(iq->node, "to", session->remote_jid);
sess = google_session_create_xmlnode(session, "terminate");
purple_xmlnode_insert_child(iq->node, sess);
jabber_iq_send(iq);
} else if (type == PURPLE_MEDIA_INFO_REJECT) {
PurpleXmlNode *sess;
JabberIq *iq = jabber_iq_new(session->js, JABBER_IQ_SET);
purple_xmlnode_set_attrib(iq->node, "to", session->remote_jid);
sess = google_session_create_xmlnode(session, "reject");
purple_xmlnode_insert_child(iq->node, sess);
jabber_iq_send(iq);
} else if (type == PURPLE_MEDIA_INFO_ACCEPT && local == TRUE) {
google_session_ready(session);
}
}
static PurpleXmlNode *
google_session_create_xmlnode(GoogleSession *session, const char *type)
{
PurpleXmlNode *node = purple_xmlnode_new("session");
purple_xmlnode_set_namespace(node, NS_GOOGLE_SESSION);
purple_xmlnode_set_attrib(node, "id", session->id.id);
purple_xmlnode_set_attrib(node, "initiator", session->id.initiator);
purple_xmlnode_set_attrib(node, "type", type);
return node;
}
JabberIq *
jingle_session_create_ack(JingleSession *session, const PurpleXmlNode *jingle)
{
JabberIq *result = jabber_iq_new(
jingle_session_get_js(session),
JABBER_IQ_RESULT);
PurpleXmlNode *packet = purple_xmlnode_get_parent(jingle);
jabber_iq_set_id(result, purple_xmlnode_get_attrib(packet, "id"));
purple_xmlnode_set_attrib(result->node, "from", purple_xmlnode_get_attrib(packet, "to"));
purple_xmlnode_set_attrib(result->node, "to", purple_xmlnode_get_attrib(packet, "from"));
return result;
}
static JabberIq *
jingle_create_iq(JingleSession *session)
{
JabberStream *js = jingle_session_get_js(session);
JabberIq *result = jabber_iq_new(js, JABBER_IQ_SET);
gchar *from = jingle_session_get_local_jid(session);
gchar *to = jingle_session_get_remote_jid(session);
purple_xmlnode_set_attrib(result->node, "from", from);
purple_xmlnode_set_attrib(result->node, "to", to);
g_free(from);
g_free(to);
return result;
}
static void
bonjour_bytestreams_listen(int sock, gpointer data)
{
PurpleXfer *xfer = data;
XepXfer *xf;
XepIq *iq;
PurpleXmlNode *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;
}
purple_xfer_set_watcher(xfer, purple_input_add(sock, PURPLE_INPUT_READ,
bonjour_sock5_request_cb, xfer));
xf = purple_xfer_get_protocol_data(xfer);
xf->listen_data = NULL;
bd = xf->data;
iq = xep_iq_new(bd, XEP_IQ_SET, purple_xfer_get_remote_user(xfer), bonjour_get_jid(bd->jabber_data->account), xf->sid);
query = purple_xmlnode_new_child(iq->node, "query");
purple_xmlnode_set_namespace(query, "http://jabber.org/protocol/bytestreams");
purple_xmlnode_set_attrib(query, "sid", xf->sid);
purple_xmlnode_set_attrib(query, "mode", "tcp");
purple_xfer_set_local_port(xfer, purple_network_get_port_from_fd(sock));
local_ips = bonjour_jabber_get_local_ips(sock);
port = g_strdup_printf("%hu", purple_xfer_get_local_port(xfer));
while(local_ips) {
streamhost = purple_xmlnode_new_child(query, "streamhost");
purple_xmlnode_set_attrib(streamhost, "jid", xf->sid);
purple_xmlnode_set_attrib(streamhost, "host", local_ips->data);
purple_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);
}
void jabber_gmail_init(JabberStream *js) {
JabberIq *iq;
PurpleXmlNode *usersetting, *mailnotifications;
if (!purple_account_get_check_mail(purple_connection_get_account(js->gc)))
return;
/*
* Quoting https://developers.google.com/talk/jep_extensions/usersettings:
* 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 = purple_xmlnode_new_child(iq->node, "usersetting");
purple_xmlnode_set_namespace(usersetting, "google:setting");
mailnotifications = purple_xmlnode_new_child(usersetting, "mailnotifications");
purple_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);
}
/**
* 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(PurpleXmlNode *cur_streamhost, const char *host,
const PurpleBuddy *pb) {
PurpleXmlNode *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 PurpleXmlNode twin copy for %s with new host address %s\n",
host, (char*)ip_elem->data);
new_streamhost = purple_xmlnode_insert_twin_copy(cur_streamhost);
purple_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;
}
static void
add_option_to_xmlnode(PurpleXmlNode *node, const char *type)
{
PurpleXmlNode *child;
child = purple_xmlnode_new_child(node, "option");
purple_xmlnode_set_attrib(child, "type", type);
}
static void
jabber_ibb_send_error_response(JabberStream *js, const char *to, const char *id)
{
JabberIq *result = jabber_iq_new(js, JABBER_IQ_ERROR);
PurpleXmlNode *error = purple_xmlnode_new("error");
PurpleXmlNode *item_not_found = purple_xmlnode_new("item-not-found");
purple_xmlnode_set_namespace(item_not_found, NS_XMPP_STANZAS);
purple_xmlnode_set_attrib(error, "code", "440");
purple_xmlnode_set_attrib(error, "type", "cancel");
jabber_iq_set_id(result, id);
purple_xmlnode_set_attrib(result->node, "to", to);
purple_xmlnode_insert_child(error, item_not_found);
purple_xmlnode_insert_child(result->node, error);
jabber_iq_send(result);
}
void
jabber_ibb_session_send_data(JabberIBBSession *sess, gconstpointer data,
gsize size)
{
JabberIBBSessionState state = jabber_ibb_session_get_state(sess);
purple_debug_info("jabber", "sending data block of %" G_GSIZE_FORMAT " bytes on IBB stream\n",
size);
if (state != JABBER_IBB_SESSION_OPENED) {
purple_debug_error("jabber",
"trying to send data on a non-open IBB session\n");
} else if (size > jabber_ibb_session_get_max_data_size(sess)) {
purple_debug_error("jabber",
"trying to send a too large packet in the IBB session\n");
} else {
JabberIq *set = jabber_iq_new(jabber_ibb_session_get_js(sess),
JABBER_IQ_SET);
PurpleXmlNode *data_element = purple_xmlnode_new("data");
char *base64 = purple_base64_encode(data, size);
char seq[10];
g_snprintf(seq, sizeof(seq), "%u", jabber_ibb_session_get_send_seq(sess));
purple_xmlnode_set_attrib(set->node, "to", jabber_ibb_session_get_who(sess));
purple_xmlnode_set_namespace(data_element, NS_IBB);
purple_xmlnode_set_attrib(data_element, "sid", jabber_ibb_session_get_sid(sess));
purple_xmlnode_set_attrib(data_element, "seq", seq);
purple_xmlnode_insert_data(data_element, base64, -1);
purple_xmlnode_insert_child(set->node, data_element);
purple_debug_info("jabber",
"IBB: setting send <iq/> callback for session %p %s\n", sess,
sess->sid);
jabber_iq_set_callback(set, jabber_ibb_session_send_acknowledge_cb, sess);
sess->last_iq_id = g_strdup(purple_xmlnode_get_attrib(set->node, "id"));
purple_debug_info("jabber", "IBB: set sess->last_iq_id: %s\n",
sess->last_iq_id);
jabber_iq_send(set);
g_free(base64);
(sess->send_seq)++;
}
}
static void jabber_iq_version_parse(JabberStream *js, const char *from,
JabberIqType type, const char *id,
PurpleXmlNode *packet)
{
JabberIq *iq;
PurpleXmlNode *query;
if(type == JABBER_IQ_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
iq = jabber_iq_new_query(js, JABBER_IQ_RESULT, "jabber:iq:version");
if (from)
purple_xmlnode_set_attrib(iq->node, "to", from);
jabber_iq_set_id(iq, id);
query = purple_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);
purple_xmlnode_insert_data(purple_xmlnode_new_child(query, "name"), ui_name, -1);
purple_xmlnode_insert_data(purple_xmlnode_new_child(query, "version"), version_complete, -1);
g_free(version_complete);
} else {
purple_xmlnode_insert_data(purple_xmlnode_new_child(query, "name"), "libpurple", -1);
purple_xmlnode_insert_data(purple_xmlnode_new_child(query, "version"), VERSION, -1);
}
#if 0
if(os) {
purple_xmlnode_insert_data(purple_xmlnode_new_child(query, "os"), os, -1);
g_free(os);
}
#endif
jabber_iq_send(iq);
}
}
void
jabber_ibb_session_accept(JabberIBBSession *sess)
{
JabberIq *result = jabber_iq_new(jabber_ibb_session_get_js(sess),
JABBER_IQ_RESULT);
purple_xmlnode_set_attrib(result->node, "to", jabber_ibb_session_get_who(sess));
jabber_iq_set_id(result, sess->id);
jabber_iq_send(result);
sess->state = JABBER_IBB_SESSION_OPENED;
}
static JabberSaslState
digest_md5_start(JabberStream *js, PurpleXmlNode *packet, PurpleXmlNode **response,
char **error)
{
PurpleXmlNode *auth = purple_xmlnode_new("auth");
purple_xmlnode_set_namespace(auth, NS_XMPP_SASL);
purple_xmlnode_set_attrib(auth, "mechanism", "DIGEST-MD5");
*response = auth;
return JABBER_SASL_STATE_CONTINUE;
}
void jabber_iq_set_id(JabberIq *iq, const char *id)
{
g_free(iq->id);
if(id) {
purple_xmlnode_set_attrib(iq->node, "id", id);
iq->id = g_strdup(id);
} else {
purple_xmlnode_remove_attrib(iq->node, "id");
iq->id = NULL;
}
}
static PurpleXmlNode *
jingle_add_jingle_packet(JingleSession *session,
JabberIq *iq, JingleActionType action)
{
PurpleXmlNode *jingle = iq ?
purple_xmlnode_new_child(iq->node, "jingle") :
purple_xmlnode_new("jingle");
gchar *local_jid = jingle_session_get_local_jid(session);
gchar *remote_jid = jingle_session_get_remote_jid(session);
gchar *sid = jingle_session_get_sid(session);
purple_xmlnode_set_namespace(jingle, JINGLE);
purple_xmlnode_set_attrib(jingle, "action", jingle_get_action_name(action));
if (jingle_session_is_initiator(session)) {
purple_xmlnode_set_attrib(jingle, "initiator", local_jid);
purple_xmlnode_set_attrib(jingle, "responder", remote_jid);
} else {
purple_xmlnode_set_attrib(jingle, "initiator", remote_jid);
purple_xmlnode_set_attrib(jingle, "responder", local_jid);
}
purple_xmlnode_set_attrib(jingle, "sid", sid);
g_free(local_jid);
g_free(remote_jid);
g_free(sid);
return jingle;
}
static void
xep_ft_si_result(PurpleXfer *xfer, const char *to)
{
PurpleXmlNode *si_node, *feature, *field, *value, *x;
XepIq *iq;
XepXfer *xf;
BonjourData *bd;
if(!to || !xfer)
return;
xf = purple_xfer_get_protocol_data(xfer);
if(!xf)
return;
bd = xf->data;
purple_debug_info("bonjour", "xep file transfer stream initialization result.\n");
iq = xep_iq_new(bd, XEP_IQ_RESULT, to, bonjour_get_jid(bd->jabber_data->account), xf->iq_id);
if(iq == NULL)
return;
si_node = purple_xmlnode_new_child(iq->node, "si");
purple_xmlnode_set_namespace(si_node, "http://jabber.org/protocol/si");
/*purple_xmlnode_set_attrib(si_node, "profile", "http://jabber.org/protocol/si/profile/file-transfer");*/
feature = purple_xmlnode_new_child(si_node, "feature");
purple_xmlnode_set_namespace(feature, "http://jabber.org/protocol/feature-neg");
x = purple_xmlnode_new_child(feature, "x");
purple_xmlnode_set_namespace(x, "jabber:x:data");
purple_xmlnode_set_attrib(x, "type", "submit");
field = purple_xmlnode_new_child(x, "field");
purple_xmlnode_set_attrib(field, "var", "stream-method");
value = purple_xmlnode_new_child(field, "value");
purple_xmlnode_insert_data(value, "http://jabber.org/protocol/bytestreams", -1);
xep_iq_send_and_free(iq);
}
void
jabber_ibb_session_close(JabberIBBSession *sess)
{
JabberIBBSessionState state = jabber_ibb_session_get_state(sess);
if (state != JABBER_IBB_SESSION_OPENED && state != JABBER_IBB_SESSION_ERROR) {
purple_debug_error("jabber",
"jabber_ibb_session_close called on a session that has not been"
"opened\n");
} else {
JabberIq *set = jabber_iq_new(jabber_ibb_session_get_js(sess),
JABBER_IQ_SET);
PurpleXmlNode *close = purple_xmlnode_new("close");
purple_xmlnode_set_attrib(set->node, "to", jabber_ibb_session_get_who(sess));
purple_xmlnode_set_namespace(close, NS_IBB);
purple_xmlnode_set_attrib(close, "sid", jabber_ibb_session_get_sid(sess));
purple_xmlnode_insert_child(set->node, close);
jabber_iq_send(set);
sess->state = JABBER_IBB_SESSION_CLOSED;
}
}
static void
action_parameter_to_xmlnode(gpointer key, gpointer value, gpointer user_data)
{
const char *name, *param_value;
PurpleXmlNode *node, *child;
name = (const char *)key;
param_value = (const char *)value;
node = (PurpleXmlNode *)user_data;
child = purple_xmlnode_new_child(node, "param");
purple_xmlnode_set_attrib(child, "name", name);
purple_xmlnode_insert_data(child, param_value, -1);
}
static void jabber_iq_last_parse(JabberStream *js, const char *from,
JabberIqType type, const char *id,
PurpleXmlNode *packet)
{
JabberIq *iq;
PurpleXmlNode *query;
char *idle_time;
if(type == JABBER_IQ_GET) {
iq = jabber_iq_new_query(js, JABBER_IQ_RESULT, NS_LAST_ACTIVITY);
jabber_iq_set_id(iq, id);
if (from)
purple_xmlnode_set_attrib(iq->node, "to", from);
query = purple_xmlnode_get_child(iq->node, "query");
idle_time = g_strdup_printf("%ld", js->idle ? time(NULL) - js->idle : 0);
purple_xmlnode_set_attrib(query, "seconds", idle_time);
g_free(idle_time);
jabber_iq_send(iq);
}
}
static void
xep_ft_si_reject(BonjourData *bd, const char *id, const char *to, const char *error_code, const char *error_type)
{
PurpleXmlNode *error_node;
XepIq *iq;
g_return_if_fail(error_code != NULL);
g_return_if_fail(error_type != NULL);
if(!to || !id) {
purple_debug_info("bonjour", "xep file transfer stream initialization error.\n");
return;
}
iq = xep_iq_new(bd, XEP_IQ_ERROR, to, bonjour_get_jid(bd->jabber_data->account), id);
if(iq == NULL)
return;
error_node = purple_xmlnode_new_child(iq->node, "error");
purple_xmlnode_set_attrib(error_node, "code", error_code);
purple_xmlnode_set_attrib(error_node, "type", error_type);
/* TODO: Make this better */
if (!strcmp(error_code, "403")) {
PurpleXmlNode *tmp_node = purple_xmlnode_new_child(error_node, "forbidden");
purple_xmlnode_set_namespace(tmp_node, "urn:ietf:params:xml:ns:xmpp-stanzas");
tmp_node = purple_xmlnode_new_child(error_node, "text");
purple_xmlnode_set_namespace(tmp_node, "urn:ietf:params:xml:ns:xmpp-stanzas");
purple_xmlnode_insert_data(tmp_node, "Offer Declined", -1);
} else if (!strcmp(error_code, "404")) {
PurpleXmlNode *tmp_node = purple_xmlnode_new_child(error_node, "item-not-found");
purple_xmlnode_set_namespace(tmp_node, "urn:ietf:params:xml:ns:xmpp-stanzas");
}
xep_iq_send_and_free(iq);
}
void
jabber_gmail_poke(JabberStream *js, const char *from, JabberIqType type,
const char *id, PurpleXmlNode *new_mail)
{
PurpleXmlNode *query;
JabberIq *iq;
/* bail if the user isn't interested */
if (!purple_account_get_check_mail(purple_connection_get_account(js->gc)))
return;
/* Is this an initial incoming mail notification? If so, send a request for more info */
if (type != JABBER_IQ_SET)
return;
/* Acknowledge the notification */
iq = jabber_iq_new(js, JABBER_IQ_RESULT);
if (from)
purple_xmlnode_set_attrib(iq->node, "to", from);
purple_xmlnode_set_attrib(iq->node, "id", id);
jabber_iq_send(iq);
purple_debug_misc("jabber",
"Got new mail notification. Sending request for more info\n");
iq = jabber_iq_new_query(js, JABBER_IQ_GET, NS_GOOGLE_MAIL_NOTIFY);
jabber_iq_set_callback(iq, jabber_gmail_parse, NULL);
query = purple_xmlnode_get_child(iq->node, "query");
if (js->gmail_last_time)
purple_xmlnode_set_attrib(query, "newer-than-time", js->gmail_last_time);
if (js->gmail_last_tid)
purple_xmlnode_set_attrib(query, "newer-than-tid", js->gmail_last_tid);
jabber_iq_send(iq);
return;
}
JabberIq *jabber_iq_new(JabberStream *js, JabberIqType type)
{
JabberIq *iq;
iq = g_new0(JabberIq, 1);
iq->type = type;
iq->node = purple_xmlnode_new("iq");
switch(iq->type) {
case JABBER_IQ_SET:
purple_xmlnode_set_attrib(iq->node, "type", "set");
break;
case JABBER_IQ_GET:
purple_xmlnode_set_attrib(iq->node, "type", "get");
break;
case JABBER_IQ_ERROR:
purple_xmlnode_set_attrib(iq->node, "type", "error");
break;
case JABBER_IQ_RESULT:
purple_xmlnode_set_attrib(iq->node, "type", "result");
break;
case JABBER_IQ_NONE:
/* this shouldn't ever happen */
break;
}
iq->js = js;
if(type == JABBER_IQ_GET || type == JABBER_IQ_SET) {
iq->id = jabber_get_next_id(js);
purple_xmlnode_set_attrib(iq->node, "id", iq->id);
}
return iq;
}
static PurpleXmlNode *
smiley_to_xmlnode(PurpleSmiley *smiley)
{
PurpleSmileyPrivate *priv = NULL;
PurpleXmlNode *smiley_node = NULL;
smiley_node = purple_xmlnode_new(XML_SMILEY_TAG);
if (!smiley_node)
return NULL;
priv = PURPLE_SMILEY_GET_PRIVATE(smiley);
purple_xmlnode_set_attrib(smiley_node, XML_SHORTCUT_ATTRIB_TAG,
priv->shortcut);
purple_xmlnode_set_attrib(smiley_node, XML_CHECKSUM_ATRIB_TAG,
priv->checksum);
purple_xmlnode_set_attrib(smiley_node, XML_FILENAME_ATRIB_TAG,
purple_imgstore_get_filename(priv->img));
return smiley_node;
}
static PurpleXmlNode *
smileys_to_xmlnode(void)
{
PurpleXmlNode *root_node, *profile_node, *smileyset_node;
root_node = purple_xmlnode_new(XML_ROOT_TAG);
purple_xmlnode_set_attrib(root_node, "version", "1.0");
/* See the top comments above to understand why initial tag elements
* are not being considered by now. */
profile_node = purple_xmlnode_new(XML_PROFILE_TAG);
if (profile_node) {
purple_xmlnode_set_attrib(profile_node, XML_PROFILE_NAME_ATTRIB_TAG, "Default");
purple_xmlnode_insert_child(root_node, profile_node);
smileyset_node = purple_xmlnode_new(XML_SMILEY_SET_TAG);
if (smileyset_node) {
purple_xmlnode_insert_child(profile_node, smileyset_node);
g_hash_table_foreach(smiley_shortcut_index, add_smiley_to_main_node, smileyset_node);
}
}
return root_node;
}
static void do_nick_set(JabberStream *js, const char *nick) {
PurpleXmlNode *publish, *nicknode;
publish = purple_xmlnode_new("publish");
purple_xmlnode_set_attrib(publish,"node","http://jabber.org/protocol/nick");
nicknode = purple_xmlnode_new_child(purple_xmlnode_new_child(publish, "item"), "nick");
purple_xmlnode_set_namespace(nicknode, "http://jabber.org/protocol/nick");
if(nick && nick[0] != '\0')
purple_xmlnode_insert_data(nicknode, nick, -1);
jabber_pep_publish(js, publish);
/* publish is freed by jabber_pep_publish -> jabber_iq_send -> jabber_iq_free
(yay for well-defined memory management rules) */
}
void
jabber_ibb_session_open(JabberIBBSession *sess)
{
if (jabber_ibb_session_get_state(sess) != JABBER_IBB_SESSION_NOT_OPENED) {
purple_debug_error("jabber",
"jabber_ibb_session called on an already open stream\n");
} else {
JabberIq *set = jabber_iq_new(sess->js, JABBER_IQ_SET);
PurpleXmlNode *open = purple_xmlnode_new("open");
gchar block_size[10];
purple_xmlnode_set_attrib(set->node, "to", jabber_ibb_session_get_who(sess));
purple_xmlnode_set_namespace(open, NS_IBB);
purple_xmlnode_set_attrib(open, "sid", jabber_ibb_session_get_sid(sess));
g_snprintf(block_size, sizeof(block_size), "%" G_GSIZE_FORMAT,
jabber_ibb_session_get_block_size(sess));
purple_xmlnode_set_attrib(open, "block-size", block_size);
purple_xmlnode_insert_child(set->node, open);
jabber_iq_set_callback(set, jabber_ibb_session_opened_cb, sess);
jabber_iq_send(set);
}
}
static gboolean
msn_oim_request_helper(MsnOimRequestData *data)
{
MsnSession *session = data->oim->session;
if (data->send) {
/* The Sending of OIM's uses a different token for some reason. */
PurpleXmlNode *ticket;
ticket = purple_xmlnode_get_child(data->body, "Header/Ticket");
purple_xmlnode_set_attrib(ticket, "passport",
msn_nexus_get_token_str(session->nexus, MSN_AUTH_LIVE_SECURE));
}
else
{
PurpleXmlNode *passport;
PurpleXmlNode *xml_t;
PurpleXmlNode *xml_p;
GHashTable *token;
const char *msn_t;
const char *msn_p;
token = msn_nexus_get_token(session->nexus, MSN_AUTH_MESSENGER_WEB);
g_return_val_if_fail(token != NULL, FALSE);
msn_t = g_hash_table_lookup(token, "t");
msn_p = g_hash_table_lookup(token, "p");
g_return_val_if_fail(msn_t != NULL, FALSE);
g_return_val_if_fail(msn_p != NULL, FALSE);
passport = purple_xmlnode_get_child(data->body, "Header/PassportCookie");
xml_t = purple_xmlnode_get_child(passport, "t");
xml_p = purple_xmlnode_get_child(passport, "p");
/* frees old token text, or the 'EMPTY' text if first time */
purple_xmlnode_free(xml_t->child);
purple_xmlnode_free(xml_p->child);
purple_xmlnode_insert_data(xml_t, msn_t, -1);
purple_xmlnode_insert_data(xml_p, msn_p, -1);
}
msn_soap_service_send_message(session->soap,
msn_soap_message_new(data->action, purple_xmlnode_copy(data->body)),
data->host, data->url, FALSE, msn_oim_request_cb, data);
return FALSE;
}
static PurpleXmlNode *
pounces_to_xmlnode(void)
{
PurpleXmlNode *node, *child;
GList *cur;
node = purple_xmlnode_new("pounces");
purple_xmlnode_set_attrib(node, "version", "1.0");
for (cur = purple_pounces_get_all(); cur != NULL; cur = cur->next)
{
child = pounce_to_xmlnode(cur->data);
purple_xmlnode_insert_child(node, child);
}
return node;
}
static void
action_parameter_list_to_xmlnode(gpointer key, gpointer value, gpointer user_data)
{
const char *action;
PurplePounceActionData *action_data;
PurpleXmlNode *node, *child;
action = (const char *)key;
action_data = (PurplePounceActionData *)value;
node = (PurpleXmlNode *)user_data;
if (!action_data->enabled)
return;
child = purple_xmlnode_new_child(node, "action");
purple_xmlnode_set_attrib(child, "type", action);
g_hash_table_foreach(action_data->atts, action_parameter_to_xmlnode, child);
}
