static void ggp_edisc_xfer_recv_ack(PurpleXfer *xfer, gboolean accept)
{
ggp_edisc_xfer *edisc_xfer = purple_xfer_get_protocol_data(xfer);
ggp_edisc_session_data *sdata = ggp_edisc_get_sdata(edisc_xfer->gc);
PurpleHttpRequest *req;
g_return_if_fail(sdata != NULL);
edisc_xfer->allowed = accept;
req = purple_http_request_new(ggp_edisc_xfer_ticket_url(
edisc_xfer->ticket_id));
purple_http_request_set_method(req, "PUT");
ggp_edisc_set_defaults(req);
purple_http_request_set_cookie_jar(req, sdata->cookies);
purple_http_request_header_set(req, "X-gged-security-token",
sdata->security_token);
purple_http_request_header_set(req, "X-gged-ack-status",
accept ? "allow" : "reject");
edisc_xfer->hc = purple_http_request(edisc_xfer->gc, req,
accept ? ggp_edisc_xfer_recv_ack_done : NULL, xfer);
purple_http_request_unref(req);
if (!accept) {
edisc_xfer->hc = NULL;
ggp_edisc_xfer_free(xfer);
}
}
static void ggp_pubdir_set_info_got_token(PurpleConnection *gc,
const gchar *token, gpointer _record)
{
PurpleHttpRequest *req;
ggp_pubdir_record *record = _record;
gchar *request_data;
gchar *name, *surname, *city;
uin_t uin = record->uin;
PURPLE_ASSERT_CONNECTION_IS_VALID(gc);
if (!token) {
/* TODO: notify about failure */
ggp_pubdir_record_free(record, 1);
return;
}
name = g_uri_escape_string(record->first_name, NULL, FALSE);
surname = g_uri_escape_string(record->last_name, NULL, FALSE);
city = g_uri_escape_string(record->city, NULL, FALSE);
request_data = g_strdup_printf(
"name=%s&"
"surname=%s&"
"birth=%sT10:00:00%%2B00:00&"
"birth_priv=2&"
"gender=%d&"
"gender_priv=2&"
"city=%s&"
"province=%d",
name, surname,
ggp_date_strftime("%Y-%m-%d", record->birth),
record->gender,
city,
record->province);
if (purple_debug_is_verbose() && purple_debug_is_unsafe()) {
purple_debug_misc("gg", "ggp_pubdir_set_info_got_token: "
"query [%s]\n", request_data);
}
req = purple_http_request_new(NULL);
purple_http_request_set_method(req, "PUT");
purple_http_request_set_url_printf(req,
"http://api.gadu-gadu.pl/users/%u.xml", uin);
purple_http_request_header_set(req, "Authorization", token);
purple_http_request_header_set(req, "Content-Type",
"application/x-www-form-urlencoded");
purple_http_request_set_contents(req, request_data, -1);
purple_http_request(gc, req, ggp_pubdir_set_info_got_response, NULL);
purple_http_request_unref(req);
g_free(request_data);
ggp_pubdir_record_free(record, 1);
}
static void ggp_pubdir_search_got_token(PurpleConnection *gc,
const gchar *token, gpointer _request)
{
PurpleHttpRequest *req;
ggp_pubdir_request *request = _request;
gchar *query;
PURPLE_ASSERT_CONNECTION_IS_VALID(gc);
if (!token) {
request->cb(gc, -1, NULL, 0, request->user_data);
ggp_pubdir_request_free(request);
return;
}
purple_debug_misc("gg", "ggp_pubdir_search_got_token\n");
query = ggp_pubdir_search_make_query(request->params.search_form);
req = purple_http_request_new(NULL);
purple_http_request_set_url_printf(req, "http://api.gadu-gadu.pl%s", query);
purple_http_request_header_set(req, "Authorization", token);
purple_http_request(gc, req, ggp_pubdir_got_data, request);
purple_http_request_unref(req);
g_free(query);
}
void
hangouts_oauth_with_code(HangoutsAccount *ha, const gchar *auth_code)
{
PurpleHttpRequest *request;
PurpleConnection *pc;
GString *postdata;
pc = ha->pc;
postdata = g_string_new(NULL);
g_string_append_printf(postdata, "client_id=%s&", purple_url_encode(GOOGLE_CLIENT_ID));
g_string_append_printf(postdata, "client_secret=%s&", purple_url_encode(GOOGLE_CLIENT_SECRET));
g_string_append_printf(postdata, "code=%s&", purple_url_encode(auth_code));
g_string_append_printf(postdata, "redirect_uri=%s&", purple_url_encode(HANGOUTS_API_OAUTH2_REDIRECT_URI));
g_string_append(postdata, "grant_type=authorization_code&");
request = purple_http_request_new(HANGOUTS_API_OAUTH2_TOKEN_URL);
purple_http_request_set_cookie_jar(request, ha->cookie_jar);
purple_http_request_set_method(request, "POST");
purple_http_request_header_set(request, "Content-Type", "application/x-www-form-urlencoded");
purple_http_request_set_contents(request, postdata->str, postdata->len);
purple_http_request(pc, request, hangouts_oauth_with_code_cb, ha);
purple_http_request_unref(request);
g_string_free(postdata, TRUE);
}
void
hangouts_oauth_refresh_token(HangoutsAccount *ha)
{
PurpleHttpRequest *request;
PurpleConnection *pc;
GString *postdata;
pc = ha->pc;
postdata = g_string_new(NULL);
g_string_append_printf(postdata, "client_id=%s&", purple_url_encode(GOOGLE_CLIENT_ID));
g_string_append_printf(postdata, "client_secret=%s&", purple_url_encode(GOOGLE_CLIENT_SECRET));
g_string_append_printf(postdata, "refresh_token=%s&", purple_url_encode(ha->refresh_token));
g_string_append(postdata, "grant_type=refresh_token&");
request = purple_http_request_new(HANGOUTS_API_OAUTH2_TOKEN_URL);
purple_http_request_set_cookie_jar(request, ha->cookie_jar);
purple_http_request_set_method(request, "POST");
purple_http_request_header_set(request, "Content-Type", "application/x-www-form-urlencoded");
purple_http_request_set_contents(request, postdata->str, postdata->len);
purple_http_request(pc, request, hangouts_oauth_refresh_token_cb, ha);
purple_http_request_unref(request);
purple_debug_info("hangouts", "Postdata: %s\n", postdata->str);
g_string_free(postdata, TRUE);
}
static void ggp_edisc_xfer_recv_ticket_update_authenticated(
PurpleConnection *gc, gboolean success, gpointer _ticket)
{
ggp_edisc_session_data *sdata = ggp_edisc_get_sdata(gc);
PurpleHttpRequest *req;
gchar *ticket = _ticket;
g_return_if_fail(sdata != NULL);
if (!success) {
purple_debug_warning("gg",
"ggp_edisc_xfer_recv_ticket_update_authenticated: "
"update of ticket %s aborted due to authentication "
"failure\n", ticket);
g_free(ticket);
return;
}
req = purple_http_request_new(ggp_edisc_xfer_ticket_url(ticket));
g_free(ticket);
ggp_edisc_set_defaults(req);
purple_http_request_set_cookie_jar(req, sdata->cookies);
purple_http_request_header_set(req, "X-gged-security-token",
sdata->security_token);
purple_http_request(gc, req, ggp_edisc_xfer_recv_ticket_update_got,
NULL);
purple_http_request_unref(req);
}
static void ggp_ggdrive_auth(PurpleConnection *gc, ggp_ggdrive_auth_cb cb,
gpointer user_data)
{
GGPInfo *accdata = purple_connection_get_protocol_data(gc);
ggp_edisc_session_data *sdata = ggp_edisc_get_sdata(gc);
ggp_edisc_auth_data *auth;
const gchar *imtoken;
gchar *metadata;
PurpleHttpRequest *req;
g_return_if_fail(sdata != NULL);
imtoken = ggp_get_imtoken(gc);
if (!imtoken) {
cb(gc, FALSE, user_data);
return;
}
if (sdata->auth_done) {
cb(gc, sdata->security_token != NULL, user_data);
return;
}
auth = g_new0(ggp_edisc_auth_data, 1);
auth->cb = cb;
auth->user_data = user_data;
sdata->auth_pending = g_list_prepend(sdata->auth_pending, auth);
if (sdata->auth_request)
return;
purple_debug_info("gg", "ggp_ggdrive_auth(gc=%p)\n", gc);
req = purple_http_request_new("https://drive.mpa.gg.pl/signin");
purple_http_request_set_method(req, "PUT");
ggp_edisc_set_defaults(req);
purple_http_request_set_cookie_jar(req, sdata->cookies);
metadata = g_strdup_printf("{"
"\"id\": \"%032x\", "
"\"name\": \"%s\", "
"\"os_version\": \"" GGP_EDISC_OS "\", "
"\"client_version\": \"%s\", "
"\"type\": \"" GGP_EDISC_TYPE "\"}",
g_random_int_range(1, 1 << 16),
purple_get_host_name(),
ggp_libgaduw_version(gc));
purple_http_request_header_set_printf(req, "Authorization",
"IMToken %s", imtoken);
purple_http_request_header_set_printf(req, "X-gged-user",
"gg/pl:%u", accdata->session->uin);
purple_http_request_header_set(req, "X-gged-client-metadata", metadata);
g_free(metadata);
sdata->auth_request = purple_http_request(gc, req,
ggp_ggdrive_auth_done, NULL);
purple_http_request_unref(req);
}
static void ggp_edisc_xfer_send_start(PurpleXfer *xfer)
{
ggp_edisc_session_data *sdata;
ggp_edisc_xfer *edisc_xfer;
gchar *upload_url, *filename_e;
PurpleHttpRequest *req;
g_return_if_fail(xfer != NULL);
edisc_xfer = purple_xfer_get_protocol_data(xfer);
g_return_if_fail(edisc_xfer != NULL);
sdata = ggp_edisc_get_sdata(edisc_xfer->gc);
g_return_if_fail(sdata != NULL);
filename_e = purple_strreplace(edisc_xfer->filename, " ", "%20");
upload_url = g_strdup_printf("https://drive.mpa.gg.pl/me/file/outbox/"
"%s%%2C%s", edisc_xfer->ticket_id, filename_e);
g_free(filename_e);
req = purple_http_request_new(upload_url);
g_free(upload_url);
purple_http_request_set_method(req, "PUT");
purple_http_request_set_timeout(req, -1);
ggp_edisc_set_defaults(req);
purple_http_request_set_cookie_jar(req, sdata->cookies);
purple_http_request_header_set(req, "X-gged-local-revision", "0");
purple_http_request_header_set(req, "X-gged-security-token",
sdata->security_token);
purple_http_request_header_set(req, "X-gged-metadata",
"{\"node_type\": \"file\"}");
purple_http_request_set_contents_reader(req, ggp_edisc_xfer_send_reader,
purple_xfer_get_size(xfer), xfer);
edisc_xfer->hc = purple_http_request(edisc_xfer->gc, req,
ggp_edisc_xfer_send_done, xfer);
purple_http_request_unref(req);
purple_http_conn_set_progress_watcher(edisc_xfer->hc,
ggp_edisc_xfer_progress_watcher, xfer, 250000);
}
static PurpleHttpRequest *
jabber_bosh_connection_http_request_new(PurpleJabberBOSHConnection *conn,
const GString *data)
{
PurpleHttpRequest *req;
jabber_stream_restart_inactivity_timer(conn->js);
req = purple_http_request_new(conn->url);
purple_http_request_set_keepalive_pool(req, conn->kapool);
purple_http_request_set_method(req, "POST");
purple_http_request_set_timeout(req, JABBER_BOSH_TIMEOUT + 2);
purple_http_request_header_set(req, "User-Agent",
jabber_bosh_useragent);
purple_http_request_header_set(req, "Content-Encoding",
"text/xml; charset=utf-8");
purple_http_request_set_contents(req, data->str, data->len);
return req;
}
static void
ggp_avatar_own_got_token(PurpleConnection *gc, const gchar *token,
gpointer _img)
{
PurpleHttpRequest *req;
PurpleImage *img = _img;
ggp_avatar_own_data *own_data = ggp_avatar_get_avdata(gc)->own_data;
gchar *img_data, *img_data_e, *request_data;
PurpleAccount *account = purple_connection_get_account(gc);
uin_t uin = ggp_str_to_uin(purple_account_get_username(account));
if (img != own_data->img) {
purple_debug_warning("gg", "ggp_avatar_own_got_token: "
"avatar was changed in meantime\n");
return;
}
own_data->img = NULL;
img_data = purple_base64_encode(purple_image_get_data(img),
purple_image_get_size(img));
img_data_e = g_uri_escape_string(img_data, NULL, FALSE);
g_free(img_data);
request_data = g_strdup_printf("uin=%d&photo=%s", uin, img_data_e);
g_free(img_data_e);
purple_debug_misc("gg", "ggp_avatar_own_got_token: "
"uploading new avatar...\n");
req = purple_http_request_new("http://avatars.nowe.gg/upload");
purple_http_request_set_max_len(req, GGP_AVATAR_RESPONSE_MAX);
purple_http_request_set_method(req, "POST");
purple_http_request_header_set(req, "Authorization", token);
purple_http_request_header_set(req, "From", "avatars to avatars");
purple_http_request_header_set(req, "Content-Type",
"application/x-www-form-urlencoded");
purple_http_request_set_contents(req, request_data, -1);
purple_http_request(gc, req, ggp_avatar_own_sent, NULL);
purple_http_request_unref(req);
g_free(request_data);
}
void
jabber_google_do_relay_request(JabberStream *js, GoogleSession *session,
JabberGoogleRelayCallback cb)
{
PurpleHttpRequest *req;
JabberGoogleRelayCallbackData *data = g_new0(JabberGoogleRelayCallbackData, 1);
data->session = session;
data->cb = cb;
purple_debug_info("jabber", "sending Google relay request\n");
req = purple_http_request_new(NULL);
purple_http_request_set_url_printf(req, "http://%s/create_session",
js->google_relay_host);
/* yes, the relay token is included twice as different request headers,
this is apparently needed to make Google's relay servers work... */
purple_http_request_header_set(req, "X-Talk-Google-Relay-Auth", js->google_relay_token);
purple_http_request_header_set(req, "X-Google-Relay-Auth", js->google_relay_token);
purple_http_request(js->gc, req, jabber_google_relay_fetch_cb, data);
purple_http_request_unref(req);
}
static PurpleHttpRequest *
yahoo_ft_new_req(struct yahoo_xfer_data *xd)
{
PurpleHttpRequest *req;
YahooData *yd;
g_return_val_if_fail(xd != NULL, NULL);
yd = purple_connection_get_protocol_data(xd->gc);
req = purple_http_request_new(xd->url);
purple_http_request_header_set(req, "User-Agent",
YAHOO_CLIENT_USERAGENT);
purple_http_request_header_set(req, "Cache-Control", "no-cache");
if (xd->is_relay) {
PurpleHttpCookieJar *cjar;
cjar = purple_http_request_get_cookie_jar(req);
purple_http_cookie_jar_set(cjar, "Y", yd->cookie_y);
purple_http_cookie_jar_set(cjar, "T", yd->cookie_t);
}
return req;
}
static void ggp_edisc_xfer_send_init_authenticated(PurpleConnection *gc,
gboolean success, gpointer _xfer)
{
ggp_edisc_session_data *sdata = ggp_edisc_get_sdata(gc);
PurpleHttpRequest *req;
PurpleXfer *xfer = _xfer;
ggp_edisc_xfer *edisc_xfer = purple_xfer_get_protocol_data(xfer);
gchar *data;
if (purple_xfer_is_cancelled(xfer))
return;
if (!success) {
ggp_edisc_xfer_error(xfer, _("Authentication failed"));
return;
}
g_return_if_fail(sdata != NULL);
req = purple_http_request_new("https://drive.mpa.gg.pl/send_ticket");
purple_http_request_set_method(req, "PUT");
ggp_edisc_set_defaults(req);
purple_http_request_set_cookie_jar(req, sdata->cookies);
purple_http_request_header_set(req, "X-gged-security-token",
sdata->security_token);
data = g_strdup_printf("{\"send_ticket\":{"
"\"recipient\":\"%s\","
"\"file_name\":\"%s\","
"\"file_size\":\"%u\""
"}}",
purple_xfer_get_remote_user(xfer),
edisc_xfer->filename,
(int)purple_xfer_get_size(xfer));
purple_http_request_set_contents(req, data, -1);
g_free(data);
edisc_xfer->hc = purple_http_request(gc, req,
ggp_edisc_xfer_send_init_ticket_created, xfer);
purple_http_request_unref(req);
}
static void ggp_pubdir_get_info_got_token(PurpleConnection *gc,
const gchar *token, gpointer _request)
{
PurpleHttpRequest *req;
ggp_pubdir_request *request = _request;
PURPLE_ASSERT_CONNECTION_IS_VALID(gc);
if (!token) {
request->cb(gc, -1, NULL, 0, request->user_data);
ggp_pubdir_request_free(request);
return;
}
req = purple_http_request_new(NULL);
purple_http_request_set_url_printf(req,
"http://api.gadu-gadu.pl/users/%u",
request->params.user_info.uin);
purple_http_request_header_set(req, "Authorization", token);
purple_http_request(gc, req, ggp_pubdir_got_data, request);
purple_http_request_unref(req);
}
static void ggp_edisc_set_defaults(PurpleHttpRequest *req)
{
purple_http_request_set_max_len(req, GGP_EDISC_RESPONSE_MAX);
purple_http_request_header_set(req, "X-gged-api-version",
GGP_EDISC_API);
/* optional fields */
purple_http_request_header_set(req, "User-Agent", "Mozilla/5.0 (Windows"
" NT 6.1; rv:11.0) Gecko/20120613 GG/11.0.0.8169 (WINNT_x86-msv"
"c; pl; beta; standard)");
purple_http_request_header_set(req, "Accept", "text/html,application/xh"
"tml+xml,application/xml;q=0.9,*/*;q=0.8");
purple_http_request_header_set(req, "Accept-Language",
"pl,en-us;q=0.7,en;q=0.3");
/* purple_http_request_header_set(req, "Accept-Encoding",
* "gzip, deflate"); */
purple_http_request_header_set(req, "Accept-Charset",
"ISO-8859-2,utf-8;q=0.7,*;q=0.7");
purple_http_request_header_set(req, "Connection", "keep-alive");
purple_http_request_header_set(req, "Content-Type",
"application/x-www-form-urlencoded; charset=UTF-8");
}
/* return TRUE if avatar update was performed or there is no new requests,
FALSE if we can request another one immediately */
static gboolean ggp_avatar_buddy_update_next(PurpleConnection *gc)
{
PurpleHttpRequest *req;
ggp_avatar_session_data *avdata = ggp_avatar_get_avdata(gc);
GList *pending_update_it;
ggp_avatar_buddy_update_req *pending_update;
PurpleBuddy *buddy;
PurpleAccount *account = purple_connection_get_account(gc);
time_t old_timestamp;
const char *old_timestamp_str;
pending_update_it = g_list_first(avdata->pending_updates);
if (pending_update_it == NULL)
return TRUE;
pending_update = pending_update_it->data;
avdata->pending_updates = g_list_remove(avdata->pending_updates,
pending_update);
buddy = purple_blist_find_buddy(account, ggp_uin_to_str(pending_update->uin));
if (!buddy) {
if (ggp_str_to_uin(purple_account_get_username(account)) ==
pending_update->uin)
{
purple_debug_misc("gg",
"ggp_avatar_buddy_update_next(%p): own "
"avatar update requested, but we don't have "
"ourselves on buddy list\n", gc);
} else {
purple_debug_warning("gg",
"ggp_avatar_buddy_update_next(%p): "
"%u update requested, but he's not on buddy "
"list\n", gc, pending_update->uin);
}
return FALSE;
}
old_timestamp_str = purple_buddy_icons_get_checksum_for_user(buddy);
old_timestamp = old_timestamp_str ? g_ascii_strtoull(
old_timestamp_str, NULL, 10) : 0;
if (old_timestamp == pending_update->timestamp) {
if (purple_debug_is_verbose()) {
purple_debug_misc("gg",
"ggp_avatar_buddy_update_next(%p): "
"%u have up to date avatar with ts=%lu\n", gc,
pending_update->uin, pending_update->timestamp);
}
return FALSE;
}
if (old_timestamp > pending_update->timestamp) {
purple_debug_warning("gg",
"ggp_avatar_buddy_update_next(%p): "
"saved timestamp for %u is newer than received "
"(%lu > %lu)\n", gc, pending_update->uin, old_timestamp,
pending_update->timestamp);
}
purple_debug_info("gg",
"ggp_avatar_buddy_update_next(%p): "
"updating %u with ts=%lu...\n", gc, pending_update->uin,
pending_update->timestamp);
pending_update->gc = gc;
avdata->current_update = pending_update;
req = purple_http_request_new(NULL);
purple_http_request_set_url_printf(req, GGP_AVATAR_BUDDY_URL,
pending_update->uin);
purple_http_request_header_set(req, "User-Agent", GGP_AVATAR_USERAGENT);
purple_http_request_set_max_len(req, GGP_AVATAR_SIZE_MAX);
pending_update->request = purple_http_request(gc, req,
ggp_avatar_buddy_update_received, pending_update);
purple_http_request_unref(req);
return TRUE;
}
