gboolean jabber_chat_role_user(JabberChat *chat, const char *who,
const char *role, const char *why)
{
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);
if (why) {
xmlnode *reason = xmlnode_new_child(item, "reason");
xmlnode_insert_data(reason, why, -1);
}
jabber_iq_send(iq);
return TRUE;
}
static void
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. */
xmlnode *ticket;
ticket = xmlnode_get_child(data->body, "Header/Ticket");
xmlnode_set_attrib(ticket, "passport",
msn_nexus_get_token_str(session->nexus, MSN_AUTH_LIVE_SECURE));
}
else
{
xmlnode *passport;
xmlnode *xml_t;
xmlnode *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_if_fail(token != NULL);
msn_t = g_hash_table_lookup(token, "t");
msn_p = g_hash_table_lookup(token, "p");
g_return_if_fail(msn_t != NULL);
g_return_if_fail(msn_p != NULL);
passport = xmlnode_get_child(data->body, "Header/PassportCookie");
xml_t = xmlnode_get_child(passport, "t");
xml_p = xmlnode_get_child(passport, "p");
/* frees old token text, or the 'EMPTY' text if first time */
xmlnode_free(xml_t->child);
xmlnode_free(xml_p->child);
xmlnode_insert_data(xml_t, msn_t, -1);
xmlnode_insert_data(xml_p, msn_p, -1);
}
msn_soap_message_send(session,
msn_soap_message_new(data->action, xmlnode_copy(data->body)),
data->host, data->url, FALSE,
msn_oim_request_cb, data);
}
static JabberSaslState
jabber_cyrus_handle_challenge(JabberStream *js, xmlnode *packet,
xmlnode **reply, char **error)
{
char *enc_in = xmlnode_get_data(packet);
unsigned char *dec_in;
char *enc_out;
const char *c_out;
unsigned int clen;
gsize declen;
dec_in = purple_base64_decode(enc_in, &declen);
js->sasl_state = sasl_client_step(js->sasl, (char*)dec_in, declen,
NULL, &c_out, &clen);
g_free(enc_in);
g_free(dec_in);
if (js->sasl_state != SASL_CONTINUE && js->sasl_state != SASL_OK) {
gchar *tmp = g_strdup_printf(_("SASL error: %s"),
sasl_errdetail(js->sasl));
purple_debug_error("jabber", "Error is %d : %s\n",
js->sasl_state, sasl_errdetail(js->sasl));
*error = tmp;
return JABBER_SASL_STATE_FAIL;
} else {
xmlnode *response = xmlnode_new("response");
xmlnode_set_namespace(response, NS_XMPP_SASL);
if (clen > 0) {
/* Cyrus SASL 2.1.22 appears to contain code to add the charset
* to the response for DIGEST-MD5 but there is no possibility
* it will be executed.
*
* My reading of the digestmd5 plugin indicates the username and
* realm are always encoded in UTF-8 (they seem to be the values
* we pass in), so we need to ensure charset=utf-8 is set.
*/
if (!purple_strequal(js->current_mech, "DIGEST-MD5") ||
strstr(c_out, ",charset="))
/* If we're not using DIGEST-MD5 or Cyrus SASL is fixed */
enc_out = purple_base64_encode((unsigned char*)c_out, clen);
else {
char *tmp = g_strdup_printf("%s,charset=utf-8", c_out);
enc_out = purple_base64_encode((unsigned char*)tmp, clen + 14);
g_free(tmp);
}
xmlnode_insert_data(response, enc_out, -1);
g_free(enc_out);
}
*reply = response;
return JABBER_SASL_STATE_CONTINUE;
}
}
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
xmlnode_parser_element_text_libxml(void *user_data, const xmlChar *text, int text_len)
{
struct _xmlnode_parser_data *xpd = user_data;
if(!xpd->current || xpd->error)
return;
if(!text || !text_len)
return;
xmlnode_insert_data(xpd->current, (const char*) text, text_len);
}
static void
xmlnode_parser_element_text(GMarkupParseContext *context, const char *text,
gsize text_len, gpointer user_data, GError **error)
{
struct _xmlnode_parser_data *xpd = user_data;
if(!xpd->current)
return;
if(!text || !text_len)
return;
xmlnode_insert_data(xpd->current, text, text_len);
}
/*
* WLM media PSM info build prcedure
*
* Result can like:
* <CurrentMedia>\0Music\01\0{0} - {1}\0Song Title\0Song Artist\0Song Album\0\0</CurrentMedia>\
* <CurrentMedia>\0Games\01\0Playing {0}\0Game Name\0</CurrentMedia>\
* <CurrentMedia>\0Office\01\0Office Message\0Office App Name\0</CurrentMedia>"
*/
static char *
msn_build_psm(const char *psmstr,const char *mediastr, const char *guidstr, guint protocol_ver)
{
xmlnode *dataNode,*psmNode,*mediaNode,*guidNode;
char *result;
int length;
dataNode = xmlnode_new("Data");
psmNode = xmlnode_new("PSM");
if(psmstr != NULL){
xmlnode_insert_data(psmNode, psmstr, -1);
}
xmlnode_insert_child(dataNode, psmNode);
mediaNode = xmlnode_new("CurrentMedia");
if(mediastr != NULL){
xmlnode_insert_data(mediaNode, mediastr, -1);
}
xmlnode_insert_child(dataNode, mediaNode);
guidNode = xmlnode_new("MachineGuid");
if(guidstr != NULL){
xmlnode_insert_data(guidNode, guidstr, -1);
}
xmlnode_insert_child(dataNode, guidNode);
if (protocol_ver >= 16) {
/* TODO: What is this for? */
xmlnode *ddpNode = xmlnode_new("DDP");
xmlnode_insert_child(dataNode, ddpNode);
}
result = xmlnode_to_str(dataNode, &length);
xmlnode_free(dataNode);
return result;
}
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);
body = xmlnode_new_child(invite, "reason");
xmlnode_insert_data(body, msg, -1);
} else {
xmlnode_set_attrib(message, "to", name);
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);
xmlnode_set_namespace(x, "jabber:x:conference");
}
jabber_send(js, message);
xmlnode_free(message);
g_free(room_jid);
}
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 do_nick_set(JabberStream *js, const char *nick) {
xmlnode *publish, *nicknode;
publish = xmlnode_new("publish");
xmlnode_set_attrib(publish,"node","http://jabber.org/protocol/nick");
nicknode = xmlnode_new_child(xmlnode_new_child(publish, "item"), "nick");
xmlnode_set_namespace(nicknode, "http://jabber.org/protocol/nick");
if(nick && nick[0] != '\0')
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) */
}
xmlnode *jabber_presence_create(const char *state, const char *msg)
{
xmlnode *show, *status, *presence;
presence = xmlnode_new("presence");
if(state) {
const char *show_string = NULL;
if(!strcmp(state, _("Chatty")))
show_string = "chat";
else if(!strcmp(state, _("Away")) ||
(msg && !strcmp(state, GAIM_AWAY_CUSTOM)))
show_string = "away";
else if(!strcmp(state, _("Extended Away")))
show_string = "xa";
else if(!strcmp(state, _("Do Not Disturb")))
show_string = "dnd";
else if(!strcmp(state, _("Invisible")))
xmlnode_set_attrib(presence, "type", "invisible");
else if(!strcmp(state, "unavailable"))
xmlnode_set_attrib(presence, "type", "unavailable");
if(show_string) {
show = xmlnode_new_child(presence, "show");
xmlnode_insert_data(show, show_string, -1);
}
}
if(msg && *msg) {
status = xmlnode_new_child(presence, "status");
xmlnode_insert_data(status, msg, -1);
}
return presence;
}
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;
}
JabberChat *jabber_join_chat(JabberStream *js, const char *room,
const char *server, const char *handle,
const char *password, GHashTable *data)
{
JabberChat *chat;
PurpleConnection *gc;
PurpleAccount *account;
PurpleStatus *status;
xmlnode *presence, *x;
JabberBuddyState state;
char *msg;
int priority;
char *jid;
chat = jabber_chat_new(js, room, server, handle, password, data);
if (chat == NULL)
return NULL;
gc = js->gc;
account = purple_connection_get_account(gc);
status = purple_account_get_active_status(account);
purple_status_to_jabber(status, &state, &msg, &priority);
presence = jabber_presence_create_js(js, state, msg, priority);
g_free(msg);
jid = g_strdup_printf("%s@%s/%s", room, server, handle);
xmlnode_set_attrib(presence, "to", jid);
g_free(jid);
x = xmlnode_new_child(presence, "x");
xmlnode_set_namespace(x, "http://jabber.org/protocol/muc");
if (password && *password) {
xmlnode *p = xmlnode_new_child(x, "password");
xmlnode_insert_data(p, password, -1);
}
jabber_send(js, presence);
xmlnode_free(presence);
return chat;
}
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 void
xep_ft_si_result(PurpleXfer *xfer, char *to)
{
xmlnode *si_node, *feature, *field, *value, *x;
XepIq *iq;
XepXfer *xf;
BonjourData *bd;
if(!to || !xfer)
return;
xf = xfer->data;
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 = xmlnode_new_child(iq->node, "si");
xmlnode_set_namespace(si_node, "http://jabber.org/protocol/si");
/*xmlnode_set_attrib(si_node, "profile", "http://jabber.org/protocol/si/profile/file-transfer");*/
feature = xmlnode_new_child(si_node, "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", "submit");
field = xmlnode_new_child(x, "field");
xmlnode_set_attrib(field, "var", "stream-method");
value = xmlnode_new_child(field, "value");
xmlnode_insert_data(value, "http://jabber.org/protocol/bytestreams", -1);
xep_iq_send_and_free(iq);
}
static void
xep_ft_si_reject(BonjourData *bd, const char *id, const char *to, const char *error_code, const char *error_type)
{
xmlnode *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 = xmlnode_new_child(iq->node, "error");
xmlnode_set_attrib(error_node, "code", error_code);
xmlnode_set_attrib(error_node, "type", error_type);
/* TODO: Make this better */
if (purple_strequal(error_code, "403")) {
xmlnode *tmp_node = xmlnode_new_child(error_node, "forbidden");
xmlnode_set_namespace(tmp_node, "urn:ietf:params:xml:ns:xmpp-stanzas");
tmp_node = xmlnode_new_child(error_node, "text");
xmlnode_set_namespace(tmp_node, "urn:ietf:params:xml:ns:xmpp-stanzas");
xmlnode_insert_data(tmp_node, "Offer Declined", -1);
} else if (purple_strequal(error_code, "404")) {
xmlnode *tmp_node = xmlnode_new_child(error_node, "item-not-found");
xmlnode_set_namespace(tmp_node, "urn:ietf:params:xml:ns:xmpp-stanzas");
}
xep_iq_send_and_free(iq);
}
gboolean jabber_chat_ban_user(JabberChat *chat, const char *who, const char *why)
{
JabberChatMember *jcm;
const char *jid;
char *to;
JabberIq *iq;
xmlnode *query, *item, *reason;
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", "outcast");
if(why) {
reason = xmlnode_new_child(item, "reason");
xmlnode_insert_data(reason, why, -1);
}
jabber_iq_send(iq);
return TRUE;
}
static void
xep_ft_si_offer(PurpleXfer *xfer, const gchar *to)
{
xmlnode *si_node, *feature, *field, *file, *x;
XepIq *iq;
XepXfer *xf = xfer->data;
BonjourData *bd = NULL;
char buf[32];
if(!xf)
return;
bd = xf->data;
if(!bd)
return;
purple_debug_info("bonjour", "xep file transfer stream initialization offer-id=%d.\n", next_id);
/* Assign stream id. */
g_free(xf->iq_id);
xf->iq_id = g_strdup_printf("%u", next_id++);
iq = xep_iq_new(xf->data, XEP_IQ_SET, to, bonjour_get_jid(bd->jabber_data->account), xf->iq_id);
if(iq == NULL)
return;
/*Construct Stream initialization offer message.*/
si_node = xmlnode_new_child(iq->node, "si");
xmlnode_set_namespace(si_node, "http://jabber.org/protocol/si");
xmlnode_set_attrib(si_node, "profile", "http://jabber.org/protocol/si/profile/file-transfer");
g_free(xf->sid);
xf->sid = g_strdup(xf->iq_id);
xmlnode_set_attrib(si_node, "id", xf->sid);
file = xmlnode_new_child(si_node, "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);
feature = xmlnode_new_child(si_node, "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");
if (xf->mode & XEP_BYTESTREAMS) {
xmlnode *option = xmlnode_new_child(field, "option");
xmlnode *value = xmlnode_new_child(option, "value");
xmlnode_insert_data(value, "http://jabber.org/protocol/bytestreams", -1);
}
if (xf->mode & XEP_IBB) {
xmlnode *option = xmlnode_new_child(field, "option");
xmlnode *value = xmlnode_new_child(option, "value");
xmlnode_insert_data(value, "http://jabber.org/protocol/ibb", -1);
}
xep_iq_send_and_free(iq);
}
/* jabber_roster_update frees the GSList* passed in */
static void jabber_roster_update(JabberStream *js, const char *name,
GSList *groups)
{
PurpleBuddy *b;
PurpleGroup *g;
GSList *l;
JabberIq *iq;
xmlnode *query, *item, *group;
const char *balias;
if (js->currently_parsing_roster_push)
return;
if(!(b = purple_find_buddy(js->gc->account, name)))
return;
if (groups) {
char *tmp = roster_groups_join(groups);
purple_debug_info("jabber", "jabber_roster_update(%s): [Source: "
"groups]: groups: %s\n", name, tmp);
g_free(tmp);
} else {
GSList *buddies = purple_find_buddies(js->gc->account, name);
char *tmp;
if(!buddies)
return;
while(buddies) {
b = buddies->data;
g = purple_buddy_get_group(b);
groups = g_slist_append(groups, (char *)purple_group_get_name(g));
buddies = g_slist_remove(buddies, b);
}
tmp = roster_groups_join(groups);
purple_debug_info("jabber", "jabber_roster_update(%s): [Source: local blist]: groups: %s\n",
name, tmp);
g_free(tmp);
}
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);
balias = purple_buddy_get_local_buddy_alias(b);
xmlnode_set_attrib(item, "name", balias ? balias : "");
for(l = groups; l; l = l->next) {
group = xmlnode_new_child(item, "group");
xmlnode_insert_data(group, l->data, -1);
}
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
got_file_send_progress(PurpleUtilFetchUrlData *url_data, gpointer user_data, const gchar *url_text, gsize len, const gchar *error_message)
{
SkypeWebFileTransfer *swft = user_data;
PurpleXfer *xfer = swft->xfer;
SkypeWebAccount *sa = swft->sa;
JsonParser *parser;
JsonNode *node;
JsonObject *obj;
sa->url_datas = g_slist_remove(sa->url_datas, url_data);
//{"content_length":0,"content_full_length":0,"view_length":0,"content_state":"no content","view_state":"none","view_location":"https://nus1-api.asm.skype.com/v1/objects/0-cus-d1-61121cfae8cf601944627a66afdb77ad/views/original","status_location":"https://nus1-api.asm.skype.com/v1/objects/0-cus-d1-61121cfae8cf601944627a66afdb77ad/views/original/status"}
parser = json_parser_new();
if (!json_parser_load_from_data(parser, url_text, len, NULL)) {
//probably bad
poll_file_send_progress(swft);
return;
}
node = json_parser_get_root(parser);
if (node == NULL || json_node_get_node_type(node) != JSON_NODE_OBJECT) {
//probably bad
poll_file_send_progress(swft);
return;
}
obj = json_node_get_object(node);
if (json_object_has_member(obj, "status_location")) {
g_free(swft->url);
swft->url = g_strdup(json_object_get_string_member(obj, "status_location"));
}
if (json_object_has_member(obj, "content_state") && g_str_equal(json_object_get_string_member(obj, "content_state"), "ready")) {
xmlnode *uriobject = xmlnode_new("URIObject");
xmlnode *title = xmlnode_new_child(uriobject, "Title");
xmlnode *description = xmlnode_new_child(uriobject, "Description");
xmlnode *anchor = xmlnode_new_child(uriobject, "a");
xmlnode *originalname = xmlnode_new_child(uriobject, "OriginalName");
xmlnode *filesize = xmlnode_new_child(uriobject, "FileSize");
gchar *message, *temp;
//We finally did it!
// May the pesants rejoyce
purple_xfer_set_completed(xfer, TRUE);
// Don't forget to let the other end know about it
xmlnode_set_attrib(uriobject, "type", "File.1");
temp = g_strconcat("https://" SKYPEWEB_XFER_HOST "/v1/objects/", purple_url_encode(swft->id), NULL);
xmlnode_set_attrib(uriobject, "uri", temp);
g_free(temp);
temp = g_strconcat("https://" SKYPEWEB_XFER_HOST "/v1/objects/", purple_url_encode(swft->id), "/views/thumbnail", NULL);
xmlnode_set_attrib(uriobject, "url_thumbnail", temp);
g_free(temp);
xmlnode_insert_data(title, purple_xfer_get_filename(xfer), -1);
xmlnode_insert_data(description, "Description: ", -1);
temp = g_strconcat("https://login.skype.com/login/sso?go=webclient.xmm&docid=", purple_url_encode(swft->id), NULL);
xmlnode_set_attrib(anchor, "href", temp);
xmlnode_insert_data(anchor, temp, -1);
g_free(temp);
xmlnode_set_attrib(originalname, "v", purple_xfer_get_filename(xfer));
temp = g_strdup_printf("%d", purple_xfer_get_size(xfer));
xmlnode_set_attrib(filesize, "v", temp);
g_free(temp);
message = xmlnode_to_str(uriobject, NULL);
skypeweb_send_im(sa->pc, swft->from, message, PURPLE_MESSAGE_SEND);
g_free(message);
skypeweb_free_xfer(xfer);
purple_xfer_unref(xfer);
xmlnode_free(uriobject);
g_object_unref(parser);
return;
}
g_object_unref(parser);
// probably good
poll_file_send_progress(swft);
}
xmlnode *jabber_presence_create_js(JabberStream *js, JabberBuddyState state, const char *msg, int priority)
{
xmlnode *show, *status, *presence, *pri, *c;
const char *show_string = NULL;
#ifdef USE_VV
gboolean audio_enabled, video_enabled;
#endif
presence = xmlnode_new("presence");
if(state == JABBER_BUDDY_STATE_UNAVAILABLE)
xmlnode_set_attrib(presence, "type", "unavailable");
else if(state != JABBER_BUDDY_STATE_ONLINE &&
state != JABBER_BUDDY_STATE_UNKNOWN &&
state != JABBER_BUDDY_STATE_ERROR)
show_string = jabber_buddy_state_get_show(state);
if(show_string) {
show = xmlnode_new_child(presence, "show");
xmlnode_insert_data(show, show_string, -1);
}
if(msg) {
status = xmlnode_new_child(presence, "status");
xmlnode_insert_data(status, msg, -1);
}
if(priority) {
char *pstr = g_strdup_printf("%d", priority);
pri = xmlnode_new_child(presence, "priority");
xmlnode_insert_data(pri, pstr, -1);
g_free(pstr);
}
/* if we are idle and not offline, include idle */
if (js->idle && state != JABBER_BUDDY_STATE_UNAVAILABLE) {
xmlnode *query = xmlnode_new_child(presence, "query");
gchar seconds[10];
g_snprintf(seconds, 10, "%d", (int) (time(NULL) - js->idle));
xmlnode_set_namespace(query, NS_LAST_ACTIVITY);
xmlnode_set_attrib(query, "seconds", seconds);
}
/* JEP-0115 */
/* calculate hash */
jabber_caps_calculate_own_hash(js);
/* create xml */
c = xmlnode_new_child(presence, "c");
xmlnode_set_namespace(c, "http://jabber.org/protocol/caps");
xmlnode_set_attrib(c, "node", CAPS0115_NODE);
xmlnode_set_attrib(c, "hash", "sha-1");
xmlnode_set_attrib(c, "ver", jabber_caps_get_own_hash(js));
#ifdef USE_VV
/*
* MASSIVE HUGE DISGUSTING HACK
* This is a huge hack. As far as I can tell, Google Talk's gmail client
* doesn't bother to check the actual features we advertise; they
* just assume that if we specify a 'voice-v1' ext (ignoring that
* these are to be assigned no semantic value), we support receiving voice
* calls.
*
* Ditto for 'video-v1'.
*/
audio_enabled = jabber_audio_enabled(js, NULL /* unused */);
video_enabled = jabber_video_enabled(js, NULL /* unused */);
if (audio_enabled && video_enabled)
xmlnode_set_attrib(c, "ext", "voice-v1 camera-v1 video-v1");
else if (audio_enabled)
xmlnode_set_attrib(c, "ext", "voice-v1");
else if (video_enabled)
xmlnode_set_attrib(c, "ext", "camera-v1 video-v1");
#endif
return presence;
}
void jabber_presence_send(JabberStream *js, gboolean force)
{
PurpleAccount *account;
xmlnode *presence, *x, *photo;
char *stripped = NULL;
JabberBuddyState state;
int priority;
const char *artist = NULL, *title = NULL, *source = NULL, *uri = NULL, *track = NULL;
int length = -1;
gboolean allowBuzz;
PurplePresence *p;
PurpleStatus *status, *tune;
account = purple_connection_get_account(js->gc);
p = purple_account_get_presence(account);
status = purple_presence_get_active_status(p);
/* we don't want to send presence before we've gotten our roster */
if (js->state != JABBER_STREAM_CONNECTED) {
purple_debug_misc("jabber", "attempt to send presence before roster retrieved\n");
return;
}
purple_status_to_jabber(status, &state, &stripped, &priority);
/* check for buzz support */
allowBuzz = purple_status_get_attr_boolean(status,"buzz");
/* changing the buzz state has to trigger a re-broadcasting of the presence for caps */
tune = purple_presence_get_status(p, "tune");
if (js->googletalk && !stripped && purple_status_is_active(tune)) {
stripped = jabber_google_presence_outgoing(tune);
}
#define CHANGED(a,b) ((!a && b) || (a && a[0] == '\0' && b && b[0] != '\0') || \
(a && !b) || (a && a[0] != '\0' && b && b[0] == '\0') || (a && b && strcmp(a,b)))
/* check if there are any differences to the <presence> and send them in that case */
if (force || allowBuzz != js->allowBuzz || js->old_state != state ||
CHANGED(js->old_msg, stripped) || js->old_priority != priority ||
CHANGED(js->old_avatarhash, js->avatar_hash) || js->old_idle != js->idle) {
/* Need to update allowBuzz before creating the presence (with caps) */
js->allowBuzz = allowBuzz;
presence = jabber_presence_create_js(js, state, stripped, priority);
/* Per XEP-0153 4.1, we must always send the <x> */
x = xmlnode_new_child(presence, "x");
xmlnode_set_namespace(x, "vcard-temp:x:update");
/*
* FIXME: Per XEP-0153 4.3.2 bullet 2, we must not publish our
* image hash if another resource has logged in and updated the
* vcard avatar. Requires changes in jabber_presence_parse.
*/
if (js->vcard_fetched) {
/* Always publish a <photo>; it's empty if we have no image. */
photo = xmlnode_new_child(x, "photo");
if (js->avatar_hash)
xmlnode_insert_data(photo, js->avatar_hash, -1);
}
jabber_send(js, presence);
g_hash_table_foreach(js->chats, chats_send_presence_foreach, presence);
xmlnode_free(presence);
/* update old values */
if(js->old_msg)
g_free(js->old_msg);
if(js->old_avatarhash)
g_free(js->old_avatarhash);
js->old_msg = g_strdup(stripped);
js->old_avatarhash = g_strdup(js->avatar_hash);
js->old_state = state;
js->old_priority = priority;
js->old_idle = js->idle;
}
g_free(stripped);
/* next, check if there are any changes to the tune values */
if (purple_status_is_active(tune)) {
artist = purple_status_get_attr_string(tune, PURPLE_TUNE_ARTIST);
title = purple_status_get_attr_string(tune, PURPLE_TUNE_TITLE);
source = purple_status_get_attr_string(tune, PURPLE_TUNE_ALBUM);
uri = purple_status_get_attr_string(tune, PURPLE_TUNE_URL);
track = purple_status_get_attr_string(tune, PURPLE_TUNE_TRACK);
length = (!purple_status_get_attr_value(tune, PURPLE_TUNE_TIME)) ? -1 :
purple_status_get_attr_int(tune, PURPLE_TUNE_TIME);
}
if(CHANGED(artist, js->old_artist) || CHANGED(title, js->old_title) || CHANGED(source, js->old_source) ||
CHANGED(uri, js->old_uri) || CHANGED(track, js->old_track) || (length != js->old_length)) {
PurpleJabberTuneInfo tuneinfo = {
(char*)artist,
(char*)title,
(char*)source,
(char*)track,
length,
(char*)uri
};
jabber_tune_set(js->gc, &tuneinfo);
/* update old values */
g_free(js->old_artist);
g_free(js->old_title);
g_free(js->old_source);
g_free(js->old_uri);
g_free(js->old_track);
js->old_artist = g_strdup(artist);
js->old_title = g_strdup(title);
js->old_source = g_strdup(source);
js->old_uri = g_strdup(uri);
js->old_length = length;
js->old_track = g_strdup(track);
}
#undef CHANGED
jabber_presence_fake_to_self(js, status);
}
/* ------------------
* called on every sent packet
* ------------------ */
void jabber_send_signal_cb(PurpleConnection *pc, xmlnode **packet,
gpointer unused)
{
if (NULL == packet)
return;
g_return_if_fail(PURPLE_CONNECTION_IS_VALID(pc));
// if we are sending a presence stanza, add new child node
// so others know we support openpgp
if (g_str_equal((*packet)->name, "presence"))
{
const char* status_str = NULL;
xmlnode* status_node;
// check if user selected a main key
const char* fpr = purple_prefs_get_string(PREF_MY_KEY);
if (fpr == NULL)
fpr = "";
if (strcmp(fpr,"") != 0)
{// user did select a key
// get status message from packet
status_node = xmlnode_get_child(*packet,"status");
if (status_node != NULL)
{
status_str = xmlnode_get_data(status_node);
}
// sign status message
if (status_str == NULL)
status_str = "";
purple_debug_info(PLUGIN_ID, "signing status '%s' with key %s\n",status_str,fpr);
char* sig_str = sign(status_str,fpr);
if (sig_str == NULL)
{
purple_debug_error(PLUGIN_ID,"sign failed\n");
return;
}
// create special "x" childnode
purple_debug_info(PLUGIN_ID, "sending presence with signature\n");
xmlnode *x_node = xmlnode_new_child(*packet,"x");
xmlnode_set_namespace(x_node, NS_SIGNED);
xmlnode_insert_data(x_node, sig_str,-1);
}else
{
purple_debug_info(PLUGIN_ID, "no key selecteded!\n");
}
}else
if (g_str_equal((*packet)->name, "message"))
{
const char* to = xmlnode_get_attrib(*packet,"to");
xmlnode* body_node = xmlnode_get_child(*packet,"body");
if (body_node != NULL && to != NULL)
{
// get message
char* message = g_strdup(xmlnode_get_data(body_node));
char* enc_str = NULL;
char* bare_jid = get_bare_jid(to);
// get encryption key
struct list_item *item = g_hash_table_lookup(list_fingerprints,bare_jid);
if (item == NULL)
{
purple_debug_info(PLUGIN_ID, "there is no key for encrypting message to %s\n",bare_jid);
return;
}
// do not encrypt if mode_sec is disabled
if (item->mode_sec == FALSE)
return;
char* fpr_to = item->fpr;
purple_debug_info(PLUGIN_ID, "found key for encryption to user %s: %s\n",bare_jid,fpr_to);
free(bare_jid);
// encrypt message
enc_str = encrypt(message,fpr_to);
if (enc_str != NULL)
{
// remove message from body
xmlnode_clear_data(body_node);
xmlnode_insert_data(body_node,"[ERROR: This message is encrypted, and you are unable to decrypt it.]",-1);
// add special "x" childnode for encrypted text
purple_debug_info(PLUGIN_ID, "sending encrypted message\n");
xmlnode *x_node = xmlnode_new_child(*packet,"x");
xmlnode_set_namespace(x_node, NS_ENC);
xmlnode_insert_data(x_node, enc_str,-1);
}else
{
purple_debug_error(PLUGIN_ID, "could not encrypt message\n");
}
}else
{
// ignore this type of messages
//purple_debug_warning(PLUGIN_ID, "empty message or empty 'to'\n");
}
}
}
static JabberSaslState
digest_md5_handle_challenge(JabberStream *js, xmlnode *packet,
xmlnode **response, char **msg)
{
xmlnode *reply = NULL;
char *enc_in = xmlnode_get_data(packet);
char *dec_in;
char *enc_out;
GHashTable *parts;
JabberSaslState state = JABBER_SASL_STATE_CONTINUE;
if (!enc_in) {
*msg = g_strdup(_("Invalid response from server"));
return JABBER_SASL_STATE_FAIL;
}
dec_in = (char *)purple_base64_decode(enc_in, NULL);
purple_debug_misc("jabber", "decoded challenge (%"
G_GSIZE_FORMAT "): %s\n",
dec_in != NULL ? strlen(dec_in) : 0,
dec_in != NULL ? dec_in : "(null)");
parts = jabber_auth_digest_md5_parse(dec_in);
if (g_hash_table_lookup(parts, "rspauth")) {
char *rspauth = g_hash_table_lookup(parts, "rspauth");
char *expected_rspauth = js->auth_mech_data;
if (rspauth && purple_strequal(rspauth, expected_rspauth)) {
reply = xmlnode_new("response");
xmlnode_set_namespace(reply, NS_XMPP_SASL);
} else {
*msg = g_strdup(_("Invalid challenge from server"));
state = JABBER_SASL_STATE_FAIL;
}
g_free(js->auth_mech_data);
js->auth_mech_data = NULL;
} else {
/* assemble a response, and send it */
/* see RFC 2831 */
char *realm;
char *nonce;
/* Make sure the auth string contains everything that should be there.
This isn't everything in RFC2831, but it is what we need. */
nonce = g_hash_table_lookup(parts, "nonce");
/* we're actually supposed to prompt the user for a realm if
* the server doesn't send one, but that really complicates things,
* so i'm not gonna worry about it until is poses a problem to
* someone, or I get really bored */
realm = g_hash_table_lookup(parts, "realm");
if(!realm)
realm = js->user->domain;
if (nonce == NULL || realm == NULL) {
*msg = g_strdup(_("Invalid challenge from server"));
state = JABBER_SASL_STATE_FAIL;
} else {
GString *response = g_string_new("");
char *a2;
char *auth_resp;
char *cnonce;
cnonce = g_strdup_printf("%x%u%x", g_random_int(), (int)time(NULL),
g_random_int());
a2 = g_strdup_printf("AUTHENTICATE:xmpp/%s", realm);
auth_resp = generate_response_value(js->user,
purple_connection_get_password(js->gc), nonce, cnonce, a2, realm);
g_free(a2);
a2 = g_strdup_printf(":xmpp/%s", realm);
js->auth_mech_data = generate_response_value(js->user,
purple_connection_get_password(js->gc), nonce, cnonce, a2, realm);
g_free(a2);
g_string_append_printf(response, "username=\"%s\"", js->user->node);
g_string_append_printf(response, ",realm=\"%s\"", realm);
g_string_append_printf(response, ",nonce=\"%s\"", nonce);
g_string_append_printf(response, ",cnonce=\"%s\"", cnonce);
g_string_append_printf(response, ",nc=00000001");
g_string_append_printf(response, ",qop=auth");
g_string_append_printf(response, ",digest-uri=\"xmpp/%s\"", realm);
g_string_append_printf(response, ",response=%s", auth_resp);
g_string_append_printf(response, ",charset=utf-8");
g_free(auth_resp);
g_free(cnonce);
enc_out = purple_base64_encode((guchar *)response->str, response->len);
purple_debug_misc("jabber", "decoded response (%"
G_GSIZE_FORMAT "): %s\n",
response->len, response->str);
reply = xmlnode_new("response");
xmlnode_set_namespace(reply, NS_XMPP_SASL);
xmlnode_insert_data(reply, enc_out, -1);
g_free(enc_out);
g_string_free(response, TRUE);
}
}
g_free(enc_in);
g_free(dec_in);
g_hash_table_destroy(parts);
*response = reply;
return state;
}
static void
yahoo_set_userinfo_cb(PurpleConnection *gc, PurpleRequestFields *fields)
{
xmlnode *node = xmlnode_new("ab");
xmlnode *ct = xmlnode_new_child(node, "ct");
YahooData *yd = purple_connection_get_protocol_data(gc);
PurpleAccount *account;
PurpleUtilFetchUrlData *url_data;
char *webaddress, *webpage;
char *request, *content;
int len;
int i;
char * yfields[] = { "fn", "ln", "nn", "mn", "hp", "wp", "mo", NULL };
account = purple_connection_get_account(gc);
xmlnode_set_attrib(node, "k", purple_connection_get_display_name(gc));
xmlnode_set_attrib(node, "cc", "1"); /* XXX: ? */
xmlnode_set_attrib(ct, "e", "1");
xmlnode_set_attrib(ct, "yi", purple_request_fields_get_string(fields, "yname"));
xmlnode_set_attrib(ct, "id", purple_request_fields_get_string(fields, "yid"));
xmlnode_set_attrib(ct, "pr", "0");
for (i = 0; yfields[i]; i++) {
const char *v = purple_request_fields_get_string(fields, yfields[i]);
xmlnode_set_attrib(ct, yfields[i], v ? v : "");
}
content = xmlnode_to_formatted_str(node, &len);
xmlnode_free(node);
purple_url_parse(yd->jp ? YAHOOJP_USERINFO_URL : YAHOO_USERINFO_URL, &webaddress, NULL, &webpage, NULL, NULL);
request = g_strdup_printf("POST %s HTTP/1.1\r\n"
"User-Agent: " YAHOO_CLIENT_USERAGENT "\r\n"
"Cookie: T=%s; path=/; domain=.yahoo.com; Y=%s;\r\n"
"Host: %s\r\n"
"Content-Length: %d\r\n"
"Cache-Control: no-cache\r\n\r\n"
"%s\r\n\r\n",
webpage,
yd->cookie_t, yd->cookie_y,
webaddress,
len + 4,
content);
#if 0
{
/* This is if we wanted to send our contact details to everyone
* in the buddylist. But this cannot be done now, because in the
* official messenger, doing this pops a conversation window at
* the receiver's end, which is stupid, and thus not really
* surprising. */
struct yahoo_userinfo *ui = g_new(struct yahoo_userinfo, 1);
node = xmlnode_new("contact");
for (i = 0; yfields[i]; i++) {
const char *v = purple_request_fields_get_string(fields, yfields[i]);
if (v) {
xmlnode *nd = xmlnode_new_child(node, yfields[i]);
xmlnode_insert_data(nd, v, -1);
}
}
ui->yd = yd;
ui->xml = xmlnode_to_str(node, NULL);
xmlnode_free(node);
}
#endif
url_data = purple_util_fetch_url_request_len_with_account(account, webaddress, FALSE,
YAHOO_CLIENT_USERAGENT, TRUE, request, FALSE, -1,
yahoo_fetch_aliases_cb, gc);
if (url_data != NULL)
yd->url_datas = g_slist_prepend(yd->url_datas, url_data);
g_free(webaddress);
g_free(webpage);
g_free(content);
g_free(request);
}
static void jabber_si_xfer_init(GaimXfer *xfer)
{
JabberSIXfer *jsx = xfer->data;
JabberIq *iq;
if(gaim_xfer_get_type(xfer) == GAIM_XFER_SEND) {
JabberBuddy *jb;
JabberBuddyResource *jbr = NULL;
jb = jabber_buddy_find(jsx->js, xfer->who, TRUE);
/* XXX */
if(!jb)
return;
/* XXX: for now, send to the first resource available */
if(g_list_length(jb->resources) >= 1) {
char **who_v = g_strsplit(xfer->who, "/", 2);
char *who;
jbr = jabber_buddy_find_resource(jb, NULL);
who = g_strdup_printf("%s/%s", who_v[0], jbr->name);
g_strfreev(who_v);
g_free(xfer->who);
xfer->who = who;
jabber_disco_info_do(jsx->js, who,
jabber_si_xfer_send_disco_cb, xfer);
} else {
return; /* XXX: ick */
}
} else {
xmlnode *si, *feature, *x, *field, *value;
iq = jabber_iq_new(jsx->js, JABBER_IQ_RESULT);
xmlnode_set_attrib(iq->node, "to", xfer->who);
if(jsx->iq_id)
jabber_iq_set_id(iq, jsx->iq_id);
jsx->accepted = TRUE;
si = xmlnode_new_child(iq->node, "si");
xmlnode_set_namespace(si, "http://jabber.org/protocol/si");
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", "submit");
field = xmlnode_new_child(x, "field");
xmlnode_set_attrib(field, "var", "stream-method");
value = xmlnode_new_child(field, "value");
if(jsx->stream_method & STREAM_METHOD_BYTESTREAMS)
xmlnode_insert_data(value, "http://jabber.org/protocol/bytestreams", -1);
/*
else if(jsx->stream_method & STREAM_METHOD_IBB)
xmlnode_insert_data(value, "http://jabber.org/protocol/ibb", -1);
*/
jabber_iq_send(iq);
}
}
static JabberSaslState
jabber_auth_start_cyrus(JabberStream *js, xmlnode **reply, char **error)
{
PurpleAccount *account;
const char *clientout = NULL;
char *enc_out;
unsigned coutlen = 0;
sasl_security_properties_t secprops;
gboolean again;
gboolean plaintext = TRUE;
/* Set up security properties and options */
secprops.min_ssf = 0;
secprops.security_flags = SASL_SEC_NOANONYMOUS;
account = purple_connection_get_account(js->gc);
if (!jabber_stream_is_ssl(js)) {
secprops.max_ssf = -1;
secprops.maxbufsize = 4096;
plaintext = purple_account_get_bool(account, "auth_plain_in_clear", FALSE);
if (!plaintext)
secprops.security_flags |= SASL_SEC_NOPLAINTEXT;
} else {
secprops.max_ssf = 0;
secprops.maxbufsize = 0;
plaintext = TRUE;
}
secprops.property_names = 0;
secprops.property_values = 0;
do {
again = FALSE;
js->sasl_state = sasl_client_new("xmpp", js->serverFQDN, NULL, NULL, js->sasl_cb, 0, &js->sasl);
if (js->sasl_state==SASL_OK) {
sasl_setprop(js->sasl, SASL_SEC_PROPS, &secprops);
purple_debug_info("sasl", "Mechs found: %s\n", js->sasl_mechs->str);
js->sasl_state = sasl_client_start(js->sasl, js->sasl_mechs->str, NULL, &clientout, &coutlen, &js->current_mech);
}
switch (js->sasl_state) {
/* Success */
case SASL_OK:
case SASL_CONTINUE:
break;
case SASL_NOMECH:
/* No mechanisms have offered to help */
/* Firstly, if we don't have a password try
* to get one
*/
if (!purple_account_get_password(account)) {
purple_account_request_password(account, G_CALLBACK(auth_pass_cb), G_CALLBACK(auth_no_pass_cb), js->gc);
return JABBER_SASL_STATE_CONTINUE;
/* If we've got a password, but aren't sending
* it in plaintext, see if we can turn on
* plaintext auth
*/
/* XXX Should we just check for PLAIN/LOGIN being offered mechanisms? */
} else if (!plaintext) {
char *msg = g_strdup_printf(_("%s may require plaintext authentication over an unencrypted connection. Allow this and continue authentication?"),
purple_account_get_username(account));
purple_request_yes_no(js->gc, _("Plaintext Authentication"),
_("Plaintext Authentication"),
msg,
1, account, NULL, NULL, account,
allow_cyrus_plaintext_auth,
disallow_plaintext_auth);
g_free(msg);
return JABBER_SASL_STATE_CONTINUE;
} else
js->auth_fail_count++;
if (js->auth_fail_count == 1 &&
(js->sasl_mechs->str && g_str_equal(js->sasl_mechs->str, "GSSAPI"))) {
/* If we tried GSSAPI first, it failed, and it was the only method we had to try, try jabber:iq:auth
* for compatibility with iChat 10.5 Server and other jabberd based servers.
*
* iChat Server 10.5 and certain other corporate servers offer SASL GSSAPI by default, which is often
* not configured on the client side, and expects a fallback to jabber:iq:auth when it (predictably) fails.
*
* Note: xep-0078 points out that using jabber:iq:auth after a sasl failure is wrong. However,
* I believe this refers to actual authentication failure, not a simple lack of concordant mechanisms.
* Doing otherwise means that simply compiling with SASL support renders the client unable to connect to servers
* which would connect without issue otherwise. -evands
*/
js->auth_mech = NULL;
jabber_auth_start_old(js);
return JABBER_SASL_STATE_CONTINUE;
}
break;
/* Fatal errors. Give up and go home */
case SASL_BADPARAM:
case SASL_NOMEM:
*error = g_strdup(_("SASL authentication failed"));
break;
/* For everything else, fail the mechanism and try again */
default:
purple_debug_info("sasl", "sasl_state is %d, failing the mech and trying again\n", js->sasl_state);
js->auth_fail_count++;
/*
* DAA: is this right?
* The manpage says that "mech" will contain the chosen mechanism on success.
* Presumably, if we get here that isn't the case and we shouldn't try again?
* I suspect that this never happens.
*/
/*
* SXW: Yes, this is right. What this handles is the situation where a
* mechanism, say GSSAPI, is tried. If that mechanism fails, it may be
* due to mechanism specific issues, so we want to try one of the other
* supported mechanisms. This code handles that case
*/
if (js->current_mech && *js->current_mech) {
char *pos;
if ((pos = strstr(js->sasl_mechs->str, js->current_mech))) {
g_string_erase(js->sasl_mechs, pos-js->sasl_mechs->str, strlen(js->current_mech));
}
/* Remove space which separated this mech from the next */
if ((js->sasl_mechs->str)[0] == ' ') {
g_string_erase(js->sasl_mechs, 0, 1);
}
again = TRUE;
}
sasl_dispose(&js->sasl);
}
} while (again);
if (js->sasl_state == SASL_CONTINUE || js->sasl_state == SASL_OK) {
xmlnode *auth = xmlnode_new("auth");
xmlnode_set_namespace(auth, NS_XMPP_SASL);
xmlnode_set_attrib(auth, "mechanism", js->current_mech);
xmlnode_set_attrib(auth, "xmlns:ga", "http://www.google.com/talk/protocol/auth");
xmlnode_set_attrib(auth, "ga:client-uses-full-bind-result", "true");
if (clientout) {
if (coutlen == 0) {
xmlnode_insert_data(auth, "=", -1);
} else {
enc_out = purple_base64_encode((unsigned char*)clientout, coutlen);
xmlnode_insert_data(auth, enc_out, -1);
g_free(enc_out);
}
}
*reply = auth;
return JABBER_SASL_STATE_CONTINUE;
} else {
return JABBER_SASL_STATE_FAIL;
}
}
static void jabber_x_data_ok_cb(struct jabber_x_data_data *data, GaimRequestFields *fields) {
xmlnode *result = xmlnode_new("x");
jabber_x_data_cb cb = data->cb;
gpointer user_data = data->user_data;
JabberStream *js = data->js;
GList *groups, *flds;
xmlnode_set_namespace(result, "jabber:x:data");
xmlnode_set_attrib(result, "type", "submit");
for(groups = gaim_request_fields_get_groups(fields); groups; groups = groups->next) {
for(flds = gaim_request_field_group_get_fields(groups->data); flds; flds = flds->next) {
xmlnode *fieldnode, *valuenode;
GaimRequestField *field = flds->data;
const char *id = gaim_request_field_get_id(field);
jabber_x_data_field_type type = GPOINTER_TO_INT(g_hash_table_lookup(data->fields, id));
switch(type) {
case JABBER_X_DATA_TEXT_SINGLE:
case JABBER_X_DATA_JID_SINGLE:
{
const char *value = gaim_request_field_string_get_value(field);
fieldnode = xmlnode_new_child(result, "field");
xmlnode_set_attrib(fieldnode, "var", id);
valuenode = xmlnode_new_child(fieldnode, "value");
if(value)
xmlnode_insert_data(valuenode, value, -1);
break;
}
case JABBER_X_DATA_TEXT_MULTI:
{
char **pieces, **p;
const char *value = gaim_request_field_string_get_value(field);
fieldnode = xmlnode_new_child(result, "field");
xmlnode_set_attrib(fieldnode, "var", id);
pieces = g_strsplit(value, "\n", -1);
for(p = pieces; *p != NULL; p++) {
valuenode = xmlnode_new_child(fieldnode, "value");
xmlnode_insert_data(valuenode, *p, -1);
}
g_strfreev(pieces);
}
break;
case JABBER_X_DATA_LIST_SINGLE:
case JABBER_X_DATA_LIST_MULTI:
{
const GList *selected = gaim_request_field_list_get_selected(field);
char *value;
fieldnode = xmlnode_new_child(result, "field");
xmlnode_set_attrib(fieldnode, "var", id);
while(selected) {
value = gaim_request_field_list_get_data(field, selected->data);
valuenode = xmlnode_new_child(fieldnode, "value");
if(value)
xmlnode_insert_data(valuenode, value, -1);
selected = selected->next;
}
}
break;
case JABBER_X_DATA_BOOLEAN:
fieldnode = xmlnode_new_child(result, "field");
xmlnode_set_attrib(fieldnode, "var", id);
valuenode = xmlnode_new_child(fieldnode, "value");
if(gaim_request_field_bool_get_value(field))
xmlnode_insert_data(valuenode, "1", -1);
else
xmlnode_insert_data(valuenode, "0", -1);
break;
case JABBER_X_DATA_IGNORE:
break;
}
}
}
g_hash_table_destroy(data->fields);
while(data->values) {
g_free(data->values->data);
data->values = g_slist_delete_link(data->values, data->values);
}
g_free(data);
cb(js, result, user_data);
}
void jabber_chat_join(PurpleConnection *gc, GHashTable *data)
{
JabberChat *chat;
char *room, *server, *handle, *passwd;
xmlnode *presence, *x;
char *tmp, *room_jid, *full_jid;
JabberStream *js = gc->proto_data;
PurplePresence *gpresence;
PurpleStatus *status;
JabberBuddyState state;
char *msg;
int priority;
room = g_hash_table_lookup(data, "room");
server = g_hash_table_lookup(data, "server");
handle = g_hash_table_lookup(data, "handle");
passwd = g_hash_table_lookup(data, "password");
if(!room || !server)
return;
if(!handle)
handle = js->user->node;
if(!jabber_nodeprep_validate(room)) {
char *buf = g_strdup_printf(_("%s is not a valid room name"), room);
purple_notify_error(gc, _("Invalid Room Name"), _("Invalid Room Name"),
buf);
g_free(buf);
return;
} else if(!jabber_nameprep_validate(server)) {
char *buf = g_strdup_printf(_("%s is not a valid server name"), server);
purple_notify_error(gc, _("Invalid Server Name"),
_("Invalid Server Name"), buf);
g_free(buf);
return;
} else if(!jabber_resourceprep_validate(handle)) {
char *buf = g_strdup_printf(_("%s is not a valid room handle"), handle);
purple_notify_error(gc, _("Invalid Room Handle"),
_("Invalid Room Handle"), buf);
}
if(jabber_chat_find(js, room, server))
return;
tmp = g_strdup_printf("%s@%s", room, server);
room_jid = g_strdup(jabber_normalize(NULL, tmp));
g_free(tmp);
chat = g_new0(JabberChat, 1);
chat->js = gc->proto_data;
chat->room = g_strdup(room);
chat->server = g_strdup(server);
chat->handle = g_strdup(handle);
chat->members = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
(GDestroyNotify)jabber_chat_member_free);
g_hash_table_insert(js->chats, room_jid, chat);
gpresence = purple_account_get_presence(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", room_jid, handle);
xmlnode_set_attrib(presence, "to", full_jid);
g_free(full_jid);
g_free(msg);
x = xmlnode_new_child(presence, "x");
xmlnode_set_namespace(x, "http://jabber.org/protocol/muc");
if(passwd && *passwd) {
xmlnode *password = xmlnode_new_child(x, "password");
xmlnode_insert_data(password, passwd, -1);
}
jabber_send(js, presence);
xmlnode_free(presence);
}
/* ------------------
* called on received message
* ------------------ */
static gboolean
jabber_message_received(PurpleConnection *pc, const char *type, const char *id,
const char *from, const char *to, xmlnode *message)
{
const xmlnode* parent_node = message;
xmlnode* x_node = NULL;
xmlnode* body_node = NULL;
if (parent_node == NULL)
return FALSE;
// check if message is a key
body_node = xmlnode_get_child(parent_node,"body");
if (body_node != NULL)
{
char* data = xmlnode_get_data(body_node);
if (data != NULL)
{
char* header = "-----BEGIN PGP PUBLIC KEY BLOCK-----";
if (strncmp(data,header,strlen(header)) == 0)
{
// if we received a ascii armored key
// try to import it
//purple_conversation_write(conv,"","received key",PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG,time(NULL));
if (import_key(data) == TRUE)
{
xmlnode_clear_data(body_node);
xmlnode_insert_data(body_node,"key import ok",-1);
}
else
{
xmlnode_clear_data(body_node);
xmlnode_insert_data(body_node,"key import failed",-1);
}
}
}
}
// check if the user with the jid=from has signed his presence
char* bare_jid = get_bare_jid(from);
// get stored info about user
struct list_item* item = g_hash_table_lookup(list_fingerprints,bare_jid);
if (item == NULL)
{
//TODO: maybe create item in list?
}else
{
// set default value to "not encrypted mode"
item->mode_sec = FALSE;
}
free(bare_jid);
// check if message has special "x" child node => encrypted message
x_node = xmlnode_get_child_with_namespace(parent_node,"x",NS_ENC);
if (x_node != NULL)
{
purple_debug_info(PLUGIN_ID, "user %s sent us an encrypted message\n",from);
// get data of "x" node
char* cipher_str = xmlnode_get_data(x_node);
if (cipher_str != NULL)
{
// try to decrypt
char* plain_str = decrypt(cipher_str);
if (plain_str != NULL)
{
purple_debug_info(PLUGIN_ID, "decrypted message: %s\n",plain_str);
// find body node
xmlnode *body_node = xmlnode_get_child(parent_node,"body");
if (body_node != NULL)
{
// clear body node data if it is found
xmlnode_clear_data(body_node);
}else
{
// add body node if it is not found
body_node = xmlnode_new_child(message,"body");
}
// set "body" content node to decrypted string
//xmlnode_insert_data(body_node,"Encrypted message: ",-1);
xmlnode_insert_data(body_node,plain_str,-1);
// only set to encrypted mode, if we know other users key fingerprint
if (item != NULL)
{
// all went well, we received an encrypted message
item->mode_sec = TRUE;
}
}else
{
purple_debug_error(PLUGIN_ID, "could not decrypt message!\n");
}
}else
{
purple_debug_error(PLUGIN_ID, "xml token had no data!\n");
}
}
/* We don't want the plugin to stop processing */
return FALSE;
}