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); }
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); } }
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); }
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); }
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; }
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_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); }
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_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); } }
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); }
void jabber_roster_request(JabberStream *js) { JabberIq *iq; iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:roster"); jabber_iq_send(iq); }
void jabber_auth_start_old(JabberStream *js) { PurpleAccount *account; JabberIq *iq; PurpleXmlNode *query, *username; account = purple_connection_get_account(js->gc); /* * We can end up here without encryption if the server doesn't support * <stream:features/> and we're not using old-style SSL. If the user * is requiring SSL/TLS, we need to enforce it. */ if (!jabber_stream_is_ssl(js) && g_str_equal("require_tls", purple_account_get_string(account, "connection_security", JABBER_DEFAULT_REQUIRE_TLS))) { purple_connection_error(js->gc, PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR, _("You require encryption, but it is not available on this server.")); return; } if (js->registration) { jabber_register_start(js); return; } /* * IQ Auth doesn't have support for resource binding, so we need to pick a * default resource so it will work properly. jabberd14 throws an error and * iChat server just fails silently. */ if (!js->user->resource || *js->user->resource == '\0') { g_free(js->user->resource); js->user->resource = g_strdup("Home"); } #ifdef HAVE_CYRUS_SASL /* If we have Cyrus SASL, then passwords will have been set * to OPTIONAL for this protocol. So, we need to do our own * password prompting here */ if (!purple_connection_get_password(js->gc)) { purple_account_request_password(account, G_CALLBACK(auth_old_pass_cb), G_CALLBACK(auth_no_pass_cb), js->gc); return; } #endif iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:auth"); query = purple_xmlnode_get_child(iq->node, "query"); username = purple_xmlnode_new_child(query, "username"); purple_xmlnode_insert_data(username, js->user->node, -1); jabber_iq_set_callback(iq, auth_old_cb, NULL); jabber_iq_send(iq); }
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); } }
static void jingle_handle_session_terminate(JingleSession *session, xmlnode *jingle) { jabber_iq_send(jingle_session_create_ack(session, jingle)); jingle_session_handle_action(session, jingle, JINGLE_SESSION_TERMINATE); /* display reason? */ g_object_unref(session); }
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); }
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; }
void jabber_google_send_jingle_info(JabberStream *js) { JabberIq *jingle_info = jabber_iq_new_query(js, JABBER_IQ_GET, NS_GOOGLE_JINGLE_INFO); jabber_iq_set_callback(jingle_info, jabber_google_jingle_info_cb, NULL); purple_debug_info("jabber", "sending google:jingleinfo query\n"); jabber_iq_send(jingle_info); }
static void jingle_handle_session_initiate(JingleSession *session, xmlnode *jingle) { xmlnode *content = xmlnode_get_child(jingle, "content"); for (; content; content = xmlnode_get_next_twin(content)) { JingleContent *parsed_content = jingle_content_parse(content); if (parsed_content == NULL) { purple_debug_error("jingle", "Error parsing content\n"); jabber_iq_send(jingle_session_terminate_packet(session, "unsupported-applications")); } else { jingle_session_add_content(session, parsed_content); jingle_content_handle_action(parsed_content, content, JINGLE_SESSION_INITIATE); } } jabber_iq_send(jingle_session_create_ack(session, jingle)); }
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); }
static void jingle_handle_transport_info(JingleSession *session, xmlnode *jingle) { xmlnode *content = xmlnode_get_child(jingle, "content"); jabber_iq_send(jingle_session_create_ack(session, jingle)); for (; content; content = xmlnode_get_next_twin(content)) { const gchar *name = xmlnode_get_attrib(content, "name"); const gchar *creator = xmlnode_get_attrib(content, "creator"); JingleContent *parsed_content = jingle_session_find_content(session, name, creator); if (parsed_content == NULL) { purple_debug_error("jingle", "Error parsing content\n"); jabber_iq_send(jingle_session_terminate_packet(session, "unsupported-applications")); } else { jingle_content_handle_action(parsed_content, content, JINGLE_TRANSPORT_INFO); } } }
static void jingle_handle_content_accept(JingleSession *session, xmlnode *jingle) { xmlnode *content = xmlnode_get_child(jingle, "content"); jabber_iq_send(jingle_session_create_ack(session, jingle)); for (; content; content = xmlnode_get_next_twin(content)) { const gchar *name = xmlnode_get_attrib(content, "name"); const gchar *creator = xmlnode_get_attrib(content, "creator"); jingle_session_accept_content(session, name, creator); /* signal here */ } }
static void jabber_oob_xfer_end(PurpleXfer *xfer) { JabberOOBXfer *jox = xfer->data; JabberIq *iq; iq = jabber_iq_new(jox->js, JABBER_IQ_RESULT); xmlnode_set_attrib(iq->node, "to", xfer->who); jabber_iq_set_id(iq, jox->iq_id); jabber_iq_send(iq); jabber_oob_xfer_free(xfer); }
static void jingle_handle_content_add(JingleSession *session, xmlnode *jingle) { xmlnode *content = xmlnode_get_child(jingle, "content"); jabber_iq_send(jingle_session_create_ack(session, jingle)); for (; content; content = xmlnode_get_next_twin(content)) { JingleContent *pending_content = jingle_content_parse(content); if (pending_content == NULL) { purple_debug_error("jingle", "Error parsing \"content-add\" content.\n"); jabber_iq_send(jingle_session_terminate_packet(session, "unsupported-applications")); } else { jingle_session_add_pending_content(session, pending_content); } } /* XXX: signal here */ }
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 jabber_iq_time_parse(JabberStream *js, xmlnode *packet) { const char *type, *from, *id, *xmlns; JabberIq *iq; xmlnode *query; time_t now_t; struct tm *now; time(&now_t); now = localtime(&now_t); type = xmlnode_get_attrib(packet, "type"); from = xmlnode_get_attrib(packet, "from"); id = xmlnode_get_attrib(packet, "id"); /* we're gonna throw this away in a moment, but we need it * to get the xmlns, so we can figure out if this is * jabber:iq:time or urn:xmpp:time */ query = xmlnode_get_child(packet, "query"); xmlns = xmlnode_get_namespace(query); if(type && !strcmp(type, "get")) { xmlnode *utc; const char *date; iq = jabber_iq_new_query(js, JABBER_IQ_RESULT, xmlns); jabber_iq_set_id(iq, id); xmlnode_set_attrib(iq->node, "to", from); query = xmlnode_get_child(iq->node, "query"); date = purple_utf8_strftime("%Y%m%dT%T", now); utc = xmlnode_new_child(query, "utc"); xmlnode_insert_data(utc, date, -1); if(!strcmp("urn:xmpp:time", xmlns)) { xmlnode_insert_data(utc, "Z", 1); /* of COURSE the thing that is the same is different */ date = purple_get_tzoff_str(now, TRUE); xmlnode_insert_data(xmlnode_new_child(query, "tzo"), date, -1); } else { /* jabber:iq:time */ date = purple_utf8_strftime("%Z", now); xmlnode_insert_data(xmlnode_new_child(query, "tz"), date, -1); date = purple_utf8_strftime("%d %b %Y %T", now); xmlnode_insert_data(xmlnode_new_child(query, "display"), date, -1); } jabber_iq_send(iq); } }
static void jingle_handle_transport_reject(JingleSession *session, xmlnode *jingle) { xmlnode *content = xmlnode_get_child(jingle, "content"); jabber_iq_send(jingle_session_create_ack(session, jingle)); for (; content; content = xmlnode_get_next_twin(content)) { const gchar *name = xmlnode_get_attrib(content, "name"); const gchar *creator = xmlnode_get_attrib(content, "creator"); JingleContent *content = jingle_session_find_content(session, name, creator); jingle_content_remove_pending_transport(content); } }
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; }
static void jabber_si_xfer_send_request(GaimXfer *xfer) { JabberSIXfer *jsx = xfer->data; JabberIq *iq; xmlnode *si, *file, *feature, *x, *field, *option, *value; char buf[32]; xfer->filename = g_path_get_basename(xfer->local_filename); iq = jabber_iq_new(jsx->js, JABBER_IQ_SET); xmlnode_set_attrib(iq->node, "to", xfer->who); si = xmlnode_new_child(iq->node, "si"); xmlnode_set_namespace(si, "http://jabber.org/protocol/si"); jsx->stream_id = jabber_get_next_id(jsx->js); xmlnode_set_attrib(si, "id", jsx->stream_id); xmlnode_set_attrib(si, "profile", "http://jabber.org/protocol/si/profile/file-transfer"); file = xmlnode_new_child(si, "file"); xmlnode_set_namespace(file, "http://jabber.org/protocol/si/profile/file-transfer"); xmlnode_set_attrib(file, "name", xfer->filename); g_snprintf(buf, sizeof(buf), "%" G_GSIZE_FORMAT, xfer->size); xmlnode_set_attrib(file, "size", buf); /* maybe later we'll do hash and date attribs */ feature = xmlnode_new_child(si, "feature"); xmlnode_set_namespace(feature, "http://jabber.org/protocol/feature-neg"); x = xmlnode_new_child(feature, "x"); xmlnode_set_namespace(x, "jabber:x:data"); xmlnode_set_attrib(x, "type", "form"); field = xmlnode_new_child(x, "field"); xmlnode_set_attrib(field, "var", "stream-method"); xmlnode_set_attrib(field, "type", "list-single"); option = xmlnode_new_child(field, "option"); value = xmlnode_new_child(option, "value"); xmlnode_insert_data(value, "http://jabber.org/protocol/bytestreams", -1); /* option = xmlnode_new_child(field, "option"); value = xmlnode_new_child(option, "value"); xmlnode_insert_data(value, "http://jabber.org/protocol/ibb", -1); */ jabber_iq_set_callback(iq, jabber_si_xfer_send_method_cb, xfer); jabber_iq_send(iq); }
static void jingle_handle_content_modify(JingleSession *session, xmlnode *jingle) { xmlnode *content = xmlnode_get_child(jingle, "content"); jabber_iq_send(jingle_session_create_ack(session, jingle)); for (; content; content = xmlnode_get_next_twin(content)) { const gchar *name = xmlnode_get_attrib(content, "name"); const gchar *creator = xmlnode_get_attrib(content, "creator"); JingleContent *local_content = jingle_session_find_content(session, name, creator); if (local_content != NULL) { const gchar *senders = xmlnode_get_attrib(content, "senders"); gchar *local_senders = jingle_content_get_senders(local_content); if (!purple_strequal(senders, local_senders)) jingle_content_modify(local_content, senders); g_free(local_senders); } else { purple_debug_error("jingle", "content_modify: unknown content\n"); jabber_iq_send(jingle_session_terminate_packet(session, "unknown-applications")); } } }