void yahoo_fetch_aliases(PurpleConnection *gc) { YahooData *yd = gc->proto_data; const char *url; gchar *request, *webpage, *webaddress; PurpleUtilFetchUrlData *url_data; /* use whole URL if using HTTP Proxy */ gboolean use_whole_url = yahoo_account_use_http_proxy(gc); /* Build all the info to make the web request */ url = yd->jp ? YAHOOJP_ALIAS_FETCH_URL : YAHOO_ALIAS_FETCH_URL; purple_url_parse(url, &webaddress, NULL, &webpage, NULL, NULL); request = g_strdup_printf("GET %s%s/%s HTTP/1.1\r\n" "User-Agent: " YAHOO_CLIENT_USERAGENT "\r\n" "Cookie: T=%s; Y=%s\r\n" "Host: %s\r\n" "Cache-Control: no-cache\r\n\r\n", use_whole_url ? "http://" : "", use_whole_url ? webaddress : "", webpage, yd->cookie_t, yd->cookie_y, webaddress); /* We have a URL and some header information, let's connect and get some aliases */ url_data = purple_util_fetch_url_request_len_with_account(purple_connection_get_account(gc), url, use_whole_url, NULL, 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(request); }
void twitter_conv_icon_got_user_icon(PurpleAccount * account, const char *user_name, const gchar * url, time_t icon_time) { /* look local icon cache for the requested icon */ PurpleConnection *gc = purple_account_get_connection(account); TwitterConnectionData *twitter = gc->proto_data; TwitterConvIcon *conv_icon = NULL; GHashTable *hash = twitter->icons; if (!hash) return; /* since this function is called after mark_icon_for_user(), data * must exist here. */ conv_icon = twitter_conv_icon_find(account, user_name); if (!conv_icon) { conv_icon = twitter_conv_icon_new(account, user_name); g_hash_table_insert(hash, g_strdup(purple_normalize(account, user_name)), conv_icon); conv_icon->mtime = icon_time; } else { //A new icon is one posted with a tweet later than the current saved icon time //and with a different url gboolean new_icon = !conv_icon->icon_url || (strcmp(url, conv_icon->icon_url) && icon_time > conv_icon->mtime); purple_debug_info(PLUGIN_ID, "Have icon %s (%lld) for user %s, looking for %s (%lld)\n", conv_icon->icon_url, (long long int) conv_icon->mtime, user_name, url, (long long int) icon_time); if (icon_time > conv_icon->mtime) conv_icon->mtime = icon_time; //Return if the image is cached already and it's the same one if (conv_icon->pixbuf && !new_icon) return; /* Return if user's icon has been requested already. */ if (conv_icon->requested && !new_icon) return; //If we're already requesting, but it's a different url, cancel the fetch if (conv_icon->fetch_data) purple_util_fetch_url_cancel(conv_icon->fetch_data); conv_icon_clear(conv_icon); } conv_icon->icon_url = g_strdup(url); //For buddies, we don't want to retrieve the icon here, we'll //let the twitter_buddy fetch the icon and let us know when it's done if (purple_find_buddy(account, user_name)) return; conv_icon->requested = TRUE; /* Create the URL for an user's icon. */ if (url) { BuddyIconContext *ctx = twitter_buddy_icon_context_new(account, user_name, url); purple_debug_info(PLUGIN_ID, "requesting %s for %s\n", url, user_name); conv_icon->fetch_data = purple_util_fetch_url_request_len_with_account(account, url, TRUE, NULL, FALSE, NULL, TRUE, -1, got_page_cb, ctx); } }
static void pb_fetch_url(PushBulletAccount *pba, const gchar *url, const gchar *postdata, PushBulletProxyCallbackFunc callback, gpointer user_data) { PurpleAccount *account; GString *headers; gchar *host = NULL, *path = NULL, *user = NULL, *password = NULL; int port; PushBulletProxyConnection *conn; account = pba->account; if (purple_account_is_disconnected(account)) return; conn = g_new0(PushBulletProxyConnection, 1); conn->pba = pba; conn->callback = callback; conn->user_data = user_data; purple_url_parse(url, &host, &port, &path, &user, &password); purple_debug_info("pushbullet", "Fetching url %s\n", url); headers = g_string_new(NULL); //Use the full 'url' until libpurple can handle path's longer than 256 chars g_string_append_printf(headers, "%s /%s HTTP/1.0\r\n", (postdata ? "POST" : "GET"), path); //g_string_append_printf(headers, "%s %s HTTP/1.0\r\n", (postdata ? "POST" : "GET"), url); g_string_append_printf(headers, "Connection: close\r\n"); g_string_append_printf(headers, "Host: %s\r\n", host); g_string_append_printf(headers, "Accept: */*\r\n"); g_string_append_printf(headers, "User-Agent: Pidgin\r\n"); if(pba->access_token && *(pba->access_token)) { g_string_append_printf(headers, "Authorization: Bearer %s\r\n", pba->access_token); } if(postdata) { purple_debug_info("mightytext", "With postdata %s\n", postdata); if (postdata[0] == '{') { g_string_append(headers, "Content-Type: application/json\r\n"); } else { g_string_append(headers, "Content-Type: application/x-www-form-urlencoded\r\n"); } g_string_append_printf(headers, "Content-Length: %d\r\n", strlen(postdata)); g_string_append(headers, "\r\n"); g_string_append(headers, postdata); } else { g_string_append(headers, "\r\n"); } g_free(host); g_free(path); g_free(user); g_free(password); purple_util_fetch_url_request_len_with_account(pba->account, url, FALSE, "Pidgin", TRUE, headers->str, FALSE, 6553500, pb_response_callback, conn); g_string_free(headers, TRUE); }
/** * This function sends a request to * https://api.screenname.aol.com/auth/clientLogin with the user's * username and password and receives the user's session key, which is * used to request a connection to the BOSS server. */ void send_client_login(OscarData *od, const char *username) { PurpleConnection *gc; GString *request, *body; const char *tmp; char *password; int password_len; gc = od->gc; /* * We truncate ICQ passwords to 8 characters. There is probably a * limit for AIM passwords, too, but we really only need to do * this for ICQ because older ICQ clients let you enter a password * as long as you wanted and then they truncated it silently. * * And we can truncate based on the number of bytes and not the * number of characters because passwords for AIM and ICQ are * supposed to be plain ASCII (I don't know if this has always been * the case, though). */ tmp = purple_connection_get_password(gc); password_len = strlen(tmp); password = g_strndup(tmp, od->icq ? MIN(password_len, MAXICQPASSLEN) : password_len); /* Construct the body of the HTTP POST request */ body = g_string_new(""); g_string_append_printf(body, "devId=%s", get_client_key(od)); g_string_append_printf(body, "&f=xml"); g_string_append_printf(body, "&pwd=%s", purple_url_encode(password)); g_string_append_printf(body, "&s=%s", purple_url_encode(username)); g_free(password); /* Construct an HTTP POST request */ request = g_string_new("POST /auth/clientLogin HTTP/1.0\r\n" "Connection: close\r\n" "Accept: */*\r\n"); /* Tack on the body */ g_string_append_printf(request, "Content-Type: application/x-www-form-urlencoded; charset=UTF-8\r\n"); g_string_append_printf(request, "Content-Length: %" G_GSIZE_FORMAT "\r\n\r\n", body->len); g_string_append_len(request, body->str, body->len); g_string_free(body, TRUE); /* Send the POST request */ od->url_data = purple_util_fetch_url_request_len_with_account( purple_connection_get_account(gc), URL_CLIENT_LOGIN, TRUE, NULL, FALSE, request->str, FALSE, -1, client_login_cb, od); g_string_free(request, TRUE); }
static void send_start_oscar_session(OscarData *od, const char *token, const char *session_key, time_t hosttime) { char *query_string, *signature, *url; PurpleAccount *account; gboolean use_tls; account = purple_connection_get_account(od->gc); use_tls = purple_account_get_bool(account, "use_ssl", OSCAR_DEFAULT_USE_SSL); /* * Construct the GET parameters. 0x00000611 is the distid given to * us by AOL for use as the default libpurple distid. */ query_string = g_strdup_printf("a=%s" "&distId=%d" "&f=xml" "&k=%s" "&ts=%" PURPLE_TIME_T_MODIFIER "&useTLS=%d", purple_url_encode(token), oscar_get_ui_info_int(od->icq ? "prpl-icq-distid" : "prpl-aim-distid", 0x00000611), get_client_key(od), hosttime, use_tls); signature = generate_signature("GET", URL_START_OSCAR_SESSION, query_string, session_key); url = g_strdup_printf(URL_START_OSCAR_SESSION "?%s&sig_sha256=%s", query_string, signature); g_free(query_string); g_free(signature); /* Make the request */ od->url_data = purple_util_fetch_url_request_len_with_account(account, url, TRUE, NULL, FALSE, NULL, FALSE, -1, start_oscar_session_cb, od); g_free(url); }
static gpointer twitter_send_request_querystring(TwitterRequestor * r, gboolean post, const char *url, const char *query_string, char **header_fields, TwitterSendRequestSuccessFunc success_callback, TwitterSendRequestErrorFunc error_callback, gpointer data) { PurpleAccount *account = r->account; gchar *request; gboolean use_https = twitter_option_use_https(account) && purple_ssl_is_supported(); char *slash = strchr(url, '/'); TwitterSendRequestData *request_data = g_new0(TwitterSendRequestData, 1); char *host = slash ? g_strndup(url, slash - url) : g_strdup(url); char *full_url = g_strdup_printf("%s://%s", use_https ? "https" : "http", url); char *header_fields_text = (header_fields ? g_strjoinv("\r\n", header_fields) : NULL); purple_debug_info(purple_account_get_protocol_id(account), "Sending %s request to: %s ? %s\n", post ? "POST" : "GET", full_url, query_string ? query_string : ""); request_data->requestor = r; request_data->user_data = data; request_data->success_func = success_callback; request_data->error_func = error_callback; request = g_strdup_printf("%s %s%s%s HTTP/1.0\r\n" "User-Agent: " USER_AGENT "\r\n" "Host: %s\r\n" "%s" //Content-Type if post "%s%s" //extra header fields, if any "Content-Length: %lu\r\n\r\n" "%s", post ? "POST" : "GET", full_url, (!post && query_string ? "?" : ""), (!post && query_string ? query_string : ""), host, header_fields_text ? header_fields_text : "", header_fields_text ? "\r\n" : "", post ? "Content-Type: application/x-www-form-urlencoded\r\n" : "", query_string && post ? (unsigned long) strlen(query_string) : 0, query_string && post ? query_string : ""); #ifdef _DEBUG_ purple_debug_info(purple_account_get_protocol_id(account), "Sending request: %s\n", request); #endif request_data->request_id = purple_util_fetch_url_request_len_with_account(account, full_url, TRUE, USER_AGENT, TRUE, request, TRUE, -1, twitter_send_request_cb, request_data); g_free(full_url); g_free(request); g_free(host); g_free(header_fields_text); return request_data; }
static void pb_download_image_to_conv(const gchar *url, PurpleConversation *conv) { purple_util_fetch_url_request_len_with_account(purple_conversation_get_account(conv), url, TRUE, "Pidgin", TRUE, NULL, FALSE, 6553500, pb_got_conv_image, conv); }
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); }
void yahoo_update_alias(PurpleConnection *gc, const char *who, const char *alias) { YahooData *yd; const char *url; gchar *content, *request, *webpage, *webaddress; struct callback_data *cb; PurpleUtilFetchUrlData *url_data; YahooFriend *f; /* use whole URL if using HTTP Proxy */ gboolean use_whole_url = yahoo_account_use_http_proxy(gc); g_return_if_fail(who != NULL); g_return_if_fail(gc != NULL); if (alias == NULL) alias = ""; f = yahoo_friend_find(gc, who); if (f == NULL) { purple_debug_error("yahoo", "Missing YahooFriend. Unable to set server alias.\n"); return; } yd = gc->proto_data; /* Using callback_data so I have access to gc in the callback function */ cb = g_new0(struct callback_data, 1); cb->who = g_strdup(who); cb->id = g_strdup(yahoo_friend_get_alias_id(f)); cb->gc = gc; /* Build all the info to make the web request */ url = yd->jp ? YAHOOJP_ALIAS_UPDATE_URL: YAHOO_ALIAS_UPDATE_URL; purple_url_parse(url, &webaddress, NULL, &webpage, NULL, NULL); if (cb->id == NULL) { /* No id for this buddy, so create an address book entry */ purple_debug_info("yahoo", "Creating '%s' as new alias for user '%s'\n", alias, who); if (yd->jp) { gchar *alias_jp = g_convert(alias, -1, "EUC-JP", "UTF-8", NULL, NULL, NULL); gchar *converted_alias_jp = yahoo_convert_to_numeric(alias_jp); content = g_strdup_printf("<ab k=\"%s\" cc=\"9\">\n" "<ct a=\"1\" yi='%s' nn='%s' />\n</ab>\r\n", purple_account_get_username(gc->account), who, converted_alias_jp); g_free(converted_alias_jp); g_free(alias_jp); } else { gchar *escaped_alias = g_markup_escape_text(alias, -1); content = g_strdup_printf("<?xml version=\"1.0\" encoding=\"utf-8\"?><ab k=\"%s\" cc=\"9\">\n" "<ct a=\"1\" yi='%s' nn='%s' />\n</ab>\r\n", purple_account_get_username(gc->account), who, escaped_alias); g_free(escaped_alias); } } else { purple_debug_info("yahoo", "Updating '%s' as new alias for user '%s'\n", alias, who); if (yd->jp) { gchar *alias_jp = g_convert(alias, -1, "EUC-JP", "UTF-8", NULL, NULL, NULL); gchar *converted_alias_jp = yahoo_convert_to_numeric(alias_jp); content = g_strdup_printf("<ab k=\"%s\" cc=\"1\">\n" "<ct e=\"1\" yi='%s' id='%s' nn='%s' pr='0' />\n</ab>\r\n", purple_account_get_username(gc->account), who, cb->id, converted_alias_jp); g_free(converted_alias_jp); g_free(alias_jp); } else { gchar *escaped_alias = g_markup_escape_text(alias, -1); content = g_strdup_printf("<?xml version=\"1.0\" encoding=\"utf-8\"?><ab k=\"%s\" cc=\"1\">\n" "<ct e=\"1\" yi='%s' id='%s' nn='%s' pr='0' />\n</ab>\r\n", purple_account_get_username(gc->account), who, cb->id, escaped_alias); g_free(escaped_alias); } } request = g_strdup_printf("POST %s%s/%s HTTP/1.1\r\n" "User-Agent: " YAHOO_CLIENT_USERAGENT "\r\n" "Cookie: T=%s; Y=%s\r\n" "Host: %s\r\n" "Content-Length: %" G_GSIZE_FORMAT "\r\n" "Cache-Control: no-cache\r\n\r\n" "%s", use_whole_url ? "http://" : "", use_whole_url ? webaddress : "", webpage, yd->cookie_t, yd->cookie_y, webaddress, strlen(content), content); /* We have a URL and some header information, let's connect and update the alias */ url_data = purple_util_fetch_url_request_len_with_account( purple_connection_get_account(gc), url, use_whole_url, NULL, TRUE, request, FALSE, -1, yahoo_update_alias_cb, cb); if (url_data != NULL) yd->url_datas = g_slist_prepend(yd->url_datas, url_data); g_free(webpage); g_free(webaddress); g_free(content); g_free(request); }