static void url_fetched(PurpleHttpConnection *http_conn, PurpleHttpResponse *response, gpointer _data) { CbInfo *data = (CbInfo *)_data; PurpleConversation *conv = data->conv; GList *convs = purple_conversations_get_all(); const gchar *url; if (purple_http_response_is_successful(response)) { url = purple_http_response_get_data(response, NULL); g_hash_table_insert(tinyurl_cache, data->original_url, g_strdup(url)); } else { url = _("Error while querying TinyURL"); g_free(data->original_url); } /* ensure the conversation still exists */ for (; convs; convs = convs->next) { if ((PurpleConversation *)(convs->data) == conv) { FinchConv *fconv = FINCH_CONV(conv); gchar *str = g_strdup_printf("[%d] %s", data->num, url); GntTextView *tv = GNT_TEXT_VIEW(fconv->tv); gnt_text_view_tag_change(tv, data->tag, str, FALSE); g_free(str); g_free(data->tag); g_free(data); return; } } g_free(data->tag); g_free(data); purple_debug_info("TinyURL", "Conversation no longer exists... :(\n"); }
static void ggp_edisc_xfer_recv_done(PurpleHttpConnection *hc, PurpleHttpResponse *response, gpointer _xfer) { PurpleXfer *xfer = _xfer; ggp_edisc_xfer *edisc_xfer = purple_xfer_get_protocol_data(xfer); if (purple_xfer_is_cancelled(xfer)) return; g_return_if_fail(edisc_xfer != NULL); edisc_xfer->hc = NULL; if (!purple_http_response_is_successful(response)) { ggp_edisc_xfer_error(xfer, _("Error while receiving a file")); return; } if (purple_xfer_get_bytes_remaining(xfer) == 0) { purple_xfer_set_completed(xfer, TRUE); purple_xfer_end(xfer); ggp_edisc_xfer_free(xfer); } else { purple_debug_warning("gg", "ggp_edisc_xfer_recv_done: didn't " "received everything\n"); ggp_edisc_xfer_error(xfer, _("Error while receiving a file")); } }
static void ggp_ggdrive_auth_done(PurpleHttpConnection *hc, PurpleHttpResponse *response, gpointer user_data) { PurpleConnection *gc = purple_http_conn_get_purple_connection(hc); ggp_edisc_session_data *sdata = ggp_edisc_get_sdata(gc); JsonParser *parser; JsonObject *result; int status = -1; g_return_if_fail(sdata != NULL); sdata->auth_request = NULL; if (!purple_http_response_is_successful(response)) { purple_debug_misc("gg", "ggp_ggdrive_auth_done: authentication " "failed due to unsuccessful request (code = %d)\n", purple_http_response_get_code(response)); ggp_ggdrive_auth_results(gc, FALSE); return; } parser = ggp_json_parse(purple_http_response_get_data(response, NULL)); result = json_node_get_object(json_parser_get_root(parser)); result = json_object_get_object_member(result, "result"); if (json_object_has_member(result, "status")) status = json_object_get_int_member(result, "status"); g_object_unref(parser); if (status != 0 ) { purple_debug_misc("gg", "ggp_ggdrive_auth_done: authentication " "failed due to bad result (status=%d)\n", status); if (purple_debug_is_verbose()) purple_debug_misc("gg", "ggp_ggdrive_auth_done: " "result = %s\n", purple_http_response_get_data(response, NULL)); ggp_ggdrive_auth_results(gc, FALSE); return; } sdata->security_token = g_strdup(purple_http_response_get_header( response, "X-gged-security-token")); if (!sdata->security_token) { purple_debug_misc("gg", "ggp_ggdrive_auth_done: authentication " "failed due to missing security token header\n"); ggp_ggdrive_auth_results(gc, FALSE); return; } if (purple_debug_is_unsafe()) purple_debug_misc("gg", "ggp_ggdrive_auth_done: " "security_token=%s\n", sdata->security_token); ggp_ggdrive_auth_results(gc, TRUE); }
static void ggp_pubdir_set_info_got_response(PurpleHttpConnection *http_conn, PurpleHttpResponse *response, gpointer user_data) { if (!purple_http_response_is_successful(response)) { purple_debug_error("gg", "ggp_pubdir_set_info_got_response: " "failed\n"); return; } purple_debug_info("gg", "ggp_pubdir_set_info_got_response: [%s]\n", purple_http_response_get_data(response, NULL)); /* <result><status>0</status></result> */ /* TODO: notify about failure */ }
static void ggp_avatar_buddy_update_received(PurpleHttpConnection *http_conn, PurpleHttpResponse *response, gpointer _pending_update) { ggp_avatar_buddy_update_req *pending_update = _pending_update; PurpleBuddy *buddy; PurpleAccount *account; PurpleConnection *gc = pending_update->gc; ggp_avatar_session_data *avdata; gchar timestamp_str[20]; const gchar *got_data; size_t got_len; PURPLE_ASSERT_CONNECTION_IS_VALID(gc); avdata = ggp_avatar_get_avdata(gc); g_assert(pending_update == avdata->current_update); avdata->current_update = NULL; if (!purple_http_response_is_successful(response)) { purple_debug_error("gg", "ggp_avatar_buddy_update_received: bad" " response while getting avatar for %u: %s\n", pending_update->uin, purple_http_response_get_error(response)); g_free(pending_update); return; } account = purple_connection_get_account(gc); buddy = purple_blist_find_buddy(account, ggp_uin_to_str(pending_update->uin)); if (!buddy) { purple_debug_warning("gg", "ggp_avatar_buddy_update_received: " "buddy %u disappeared\n", pending_update->uin); g_free(pending_update); return; } g_snprintf(timestamp_str, sizeof(timestamp_str), "%lu", pending_update->timestamp); got_data = purple_http_response_get_data(response, &got_len); purple_buddy_icons_set_for_user(account, purple_buddy_get_name(buddy), g_memdup(got_data, got_len), got_len, timestamp_str); purple_debug_info("gg", "ggp_avatar_buddy_update_received: " "got avatar for buddy %u [ts=%lu]\n", pending_update->uin, pending_update->timestamp); g_free(pending_update); }
static void ggp_avatar_own_sent(PurpleHttpConnection *http_conn, PurpleHttpResponse *response, gpointer user_data) { PurpleConnection *gc = purple_http_conn_get_purple_connection(http_conn); PURPLE_ASSERT_CONNECTION_IS_VALID(gc); if (!purple_http_response_is_successful(response)) { purple_debug_error("gg", "ggp_avatar_own_sent: " "avatar not sent. %s\n", purple_http_response_get_error(response)); return; } purple_debug_info("gg", "ggp_avatar_own_sent: %s\n", purple_http_response_get_data(response, NULL)); }
static void hangouts_oauth_with_code_cb(PurpleHttpConnection *http_conn, PurpleHttpResponse *response, gpointer user_data) { HangoutsAccount *ha = user_data; JsonObject *obj; const gchar *raw_response; gsize response_len; PurpleAccount *account = ha->account; raw_response = purple_http_response_get_data(response, &response_len); obj = json_decode_object(raw_response, response_len); if (purple_http_response_is_successful(response) && obj) { ha->access_token = g_strdup(json_object_get_string_member(obj, "access_token")); ha->refresh_token = g_strdup(json_object_get_string_member(obj, "refresh_token")); purple_account_set_remember_password(account, TRUE); hangouts_save_refresh_token_password(account, ha->refresh_token); hangouts_auth_get_session_cookies(ha); } else { if (obj != NULL) { if (json_object_has_member(obj, "error")) { if (g_strcmp0(json_object_get_string_member(obj, "error"), "invalid_grant") == 0) { hangouts_save_refresh_token_password(ha->account, NULL); purple_connection_error(ha->pc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, json_object_get_string_member(obj, "error_description")); } else { purple_connection_error(ha->pc, PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED, json_object_get_string_member(obj, "error_description")); } } else { purple_connection_error(ha->pc, PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED, _("Invalid response")); } } purple_connection_error(ha->pc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, _("Invalid response")); } json_object_unref(obj); }
static void ggp_edisc_xfer_recv_ack_done(PurpleHttpConnection *hc, PurpleHttpResponse *response, gpointer _xfer) { PurpleXfer *xfer = _xfer; ggp_edisc_xfer *edisc_xfer; if (purple_xfer_is_cancelled(xfer)) g_return_if_reached(); edisc_xfer = purple_xfer_get_protocol_data(xfer); edisc_xfer->hc = NULL; if (!purple_http_response_is_successful(response)) { ggp_edisc_xfer_error(xfer, _("Cannot confirm file transfer.")); return; } purple_debug_info("gg", "ggp_edisc_xfer_recv_ack_done: [%s]\n", purple_http_response_get_data(response, NULL)); }
static void fetched_user_display(PurpleHttpConnection *http_conn, PurpleHttpResponse *response, gpointer _data) { MsnFetchUserDisplayData *data = _data; MsnSession *session = data->session; if (purple_http_response_is_successful(response)) { size_t len; const gchar *icon_data; icon_data = purple_http_response_get_data(response, &len); purple_buddy_icons_set_for_user(session->account, data->remote_user, g_memdup(icon_data, len), len, data->sha1); } end_user_display(NULL, session); g_free(data); }
static void tinyurl_notify_fetch_cb(PurpleHttpConnection *http_conn, PurpleHttpResponse *response, gpointer _win) { GntWidget *win = _win; const gchar *url; const gchar *original_url; if (!purple_http_response_is_successful(response)) return; original_url = g_object_get_data(G_OBJECT(win), "gnttinyurl-original"); url = purple_http_response_get_data(response, NULL); g_hash_table_insert(tinyurl_cache, g_strdup(original_url), g_strdup(url)); tinyurl_notify_tinyuri(win, url); g_signal_handlers_disconnect_matched(G_OBJECT(win), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, G_CALLBACK(purple_http_conn_cancel), NULL); }
static PurpleXmlNode * jabber_bosh_connection_parse(PurpleJabberBOSHConnection *conn, PurpleHttpResponse *response) { PurpleXmlNode *root; const gchar *data; size_t data_len; const gchar *type; g_return_val_if_fail(conn != NULL, NULL); g_return_val_if_fail(response != NULL, NULL); if (conn->is_terminating || purple_account_is_disconnecting( purple_connection_get_account(conn->js->gc))) { return NULL; } if (!purple_http_response_is_successful(response)) { purple_connection_error(conn->js->gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, _("Unable to connect")); return NULL; } data = purple_http_response_get_data(response, &data_len); root = purple_xmlnode_from_str(data, data_len); type = purple_xmlnode_get_attrib(root, "type"); if (g_strcmp0(type, "terminate") == 0) { purple_connection_error(conn->js->gc, PURPLE_CONNECTION_ERROR_OTHER_ERROR, _("The BOSH " "connection manager terminated your session.")); purple_xmlnode_free(root); return NULL; } return root; }
static void yahoo_process_filetrans_info_15_got(PurpleHttpConnection *hc, PurpleHttpResponse *response, gpointer _xfer) { PurpleXfer *xfer = _xfer; struct yahoo_xfer_data *xd; YahooData *yd; xd = purple_xfer_get_protocol_data(xfer); yd = purple_connection_get_protocol_data(xd->gc); xd->hc = NULL; if (!purple_http_response_is_successful(response)) { purple_notify_error(yd->gc, NULL, _("File Transfer Failed"), _("Unable to get file header."), purple_request_cpar_from_connection(yd->gc)); purple_xfer_cancel_remote(xfer); return; } purple_xfer_start(xfer, -1, NULL, 0); }
static void jabber_google_relay_fetch_cb(PurpleHttpConnection *http_conn, PurpleHttpResponse *response, gpointer user_data) { JabberGoogleRelayCallbackData *data = (JabberGoogleRelayCallbackData *) user_data; GoogleSession *session = data->session; JabberGoogleRelayCallback *cb = data->cb; gchar *relay_ip = NULL; guint relay_udp = 0; guint relay_tcp = 0; guint relay_ssltcp = 0; gchar *relay_username = NULL; gchar *relay_password = NULL; g_free(data); purple_debug_info("jabber", "got response on HTTP request to relay server\n"); if (purple_http_response_is_successful(response)) { const gchar *got_data = purple_http_response_get_data(response, NULL); purple_debug_info("jabber", "got Google relay request response:\n%s\n", got_data); jabber_google_relay_parse_response(got_data, &relay_ip, &relay_udp, &relay_tcp, &relay_ssltcp, &relay_username, &relay_password); } if (cb) cb(session, relay_ip, relay_udp, relay_tcp, relay_ssltcp, relay_username, relay_password); g_free(relay_ip); g_free(relay_username); g_free(relay_password); }
static void yahoo_process_filetrans_15_downloaded(PurpleHttpConnection *hc, PurpleHttpResponse *response, gpointer _xfer) { PurpleXfer *xfer = _xfer; struct yahoo_xfer_data *xd; xd = purple_xfer_get_protocol_data(xfer); xd->hc = NULL; if (purple_xfer_is_cancelled(xfer)) return; if (!purple_http_response_is_successful(response) || purple_xfer_get_bytes_remaining(xfer) > 0) { purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_REMOTE); purple_xfer_end(xfer); } else { purple_xfer_set_completed(xfer, TRUE); purple_xfer_end(xfer); } }
static void ggp_edisc_xfer_send_done(PurpleHttpConnection *hc, PurpleHttpResponse *response, gpointer _xfer) { PurpleXfer *xfer = _xfer; ggp_edisc_xfer *edisc_xfer = purple_xfer_get_protocol_data(xfer); const gchar *data = purple_http_response_get_data(response, NULL); JsonParser *parser; JsonObject *result; int result_status = -1; if (purple_xfer_is_cancelled(xfer)) return; g_return_if_fail(edisc_xfer != NULL); edisc_xfer->hc = NULL; if (!purple_http_response_is_successful(response)) { ggp_edisc_xfer_error(xfer, _("Error while sending a file")); return; } parser = ggp_json_parse(data); result = json_node_get_object(json_parser_get_root(parser)); result = json_object_get_object_member(result, "result"); if (json_object_has_member(result, "status")) result_status = json_object_get_int_member(result, "status"); g_object_unref(parser); if (result_status == 0) { purple_xfer_set_completed(xfer, TRUE); purple_xfer_end(xfer); ggp_edisc_xfer_free(xfer); } else ggp_edisc_xfer_error(xfer, _("Error while sending a file")); }
static void ggp_edisc_xfer_send_init_ticket_created(PurpleHttpConnection *hc, PurpleHttpResponse *response, gpointer _xfer) { ggp_edisc_session_data *sdata = ggp_edisc_get_sdata( purple_http_conn_get_purple_connection(hc)); PurpleXfer *xfer = _xfer; ggp_edisc_xfer *edisc_xfer = purple_xfer_get_protocol_data(xfer); const gchar *data = purple_http_response_get_data(response, NULL); ggp_edisc_xfer_ack_status ack_status; JsonParser *parser; JsonObject *ticket; if (purple_xfer_is_cancelled(xfer)) return; g_return_if_fail(sdata != NULL); edisc_xfer->hc = NULL; if (!purple_http_response_is_successful(response)) { int error_id = ggp_edisc_parse_error(data); if (error_id == 206) /* recipient not logged in */ ggp_edisc_xfer_error(xfer, _("Recipient not logged in")); else if (error_id == 207) /* bad sender recipient relation */ ggp_edisc_xfer_error(xfer, _("You aren't on the " "recipient's buddy list")); else ggp_edisc_xfer_error(xfer, _("Unable to send file")); return; } parser = ggp_json_parse(data); ticket = json_node_get_object(json_parser_get_root(parser)); ticket = json_object_get_object_member(ticket, "result"); ticket = json_object_get_object_member(ticket, "send_ticket"); edisc_xfer->ticket_id = g_strdup(json_object_get_string_member( ticket, "id")); ack_status = ggp_edisc_xfer_parse_ack_status( json_object_get_string_member(ticket, "ack_status")); /* send_mode: "normal", "publink" (for legacy clients) */ g_object_unref(parser); if (edisc_xfer->ticket_id == NULL) { purple_debug_error("gg", "ggp_edisc_xfer_send_init_ticket_created: " "couldn't get ticket id\n"); return; } purple_debug_info("gg", "ggp_edisc_xfer_send_init_ticket_created: " "ticket \"%s\" created\n", edisc_xfer->ticket_id); g_hash_table_insert(sdata->xfers_initialized, edisc_xfer->ticket_id, xfer); g_hash_table_insert(sdata->xfers_history, g_strdup(edisc_xfer->ticket_id), GINT_TO_POINTER(1)); if (ack_status != GGP_EDISC_XFER_ACK_STATUS_UNKNOWN) ggp_edisc_xfer_send_ticket_changed(edisc_xfer->gc, xfer, ack_status == GGP_EDISC_XFER_ACK_STATUS_ALLOWED); }
static void ggp_edisc_xfer_recv_ticket_update_got(PurpleHttpConnection *hc, PurpleHttpResponse *response, gpointer user_data) { PurpleConnection *gc = purple_http_conn_get_purple_connection(hc); PurpleXfer *xfer; ggp_edisc_xfer *edisc_xfer; JsonParser *parser; JsonObject *result; int status = -1; ggp_edisc_session_data *sdata; const gchar *ticket_id, *file_name, *send_mode_str; uin_t sender, recipient; int file_size; if (!purple_http_response_is_successful(response)) { purple_debug_error("gg", "ggp_edisc_xfer_recv_ticket_update_got: " "cannot fetch update for ticket (code=%d)\n", purple_http_response_get_code(response)); return; } sdata = ggp_edisc_get_sdata(gc); g_return_if_fail(sdata != NULL); parser = ggp_json_parse(purple_http_response_get_data(response, NULL)); result = json_node_get_object(json_parser_get_root(parser)); result = json_object_get_object_member(result, "result"); if (json_object_has_member(result, "status")) status = json_object_get_int_member(result, "status"); result = json_object_get_object_member(result, "send_ticket"); if (status != 0) { purple_debug_warning("gg", "ggp_edisc_xfer_recv_ticket_update_got: failed to get " "update (status=%d)\n", status); g_object_unref(parser); return; } ticket_id = json_object_get_string_member(result, "id"); sender = ggp_str_to_uin(json_object_get_string_member(result, "sender")); recipient = ggp_str_to_uin(json_object_get_string_member(result, "recipient")); file_size = g_ascii_strtoll(json_object_get_string_member(result, "file_size"), NULL, 10); file_name = json_object_get_string_member(result, "file_name"); /* GG11: normal * AQQ 2.4.2.10: direct_inbox */ send_mode_str = json_object_get_string_member(result, "send_mode"); /* more fields: * send_progress (float), ack_status, send_status */ if (purple_debug_is_verbose() && purple_debug_is_unsafe()) purple_debug_info("gg", "Got ticket update: id=%s, sender=%u, " "recipient=%u, file name=\"%s\", file size=%d, " "send mode=%s)\n", ticket_id, sender, recipient, file_name, file_size, send_mode_str); xfer = g_hash_table_lookup(sdata->xfers_initialized, ticket_id); if (xfer != NULL) { purple_debug_misc("gg", "ggp_edisc_xfer_recv_ticket_update_got:" " ticket %s already updated\n", purple_debug_is_unsafe() ? ticket_id : ""); g_object_unref(parser); return; } if (recipient != ggp_get_my_uin(gc)) { purple_debug_misc("gg", "ggp_edisc_xfer_recv_ticket_update_got:" " ticket %s is not for incoming transfer " "(its from %u to %u)\n", purple_debug_is_unsafe() ? ticket_id : "", sender, recipient); g_object_unref(parser); return; } xfer = ggp_edisc_xfer_recv_new(gc, ggp_uin_to_str(sender)); purple_xfer_set_filename(xfer, file_name); purple_xfer_set_size(xfer, file_size); purple_xfer_request(xfer); edisc_xfer = purple_xfer_get_protocol_data(xfer); edisc_xfer->ticket_id = g_strdup(ticket_id); g_hash_table_insert(sdata->xfers_initialized, edisc_xfer->ticket_id, xfer); g_hash_table_insert(sdata->xfers_history, g_strdup(ticket_id), GINT_TO_POINTER(1)); g_object_unref(parser); }