static void
handle_signout_request (LiaWebview *self,
EvdHttpConnection *conn,
EvdHttpRequest *request,
AuthData *auth_data)
{
SoupMessageHeaders *headers;
gchar *cookie;
if (auth_data != NULL)
g_hash_table_remove (self->priv->auth_sessions, auth_data->session_id);
headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_RESPONSE);
cookie = g_strdup_printf ("%s=; Expires=Sat, 01 Jan 2000 00:00:00 GMT",
self->priv->sid_cookie_name);
soup_message_headers_append (headers, "Set-Cookie", cookie);
g_free (cookie);
evd_web_service_respond (self->priv->web_service,
conn,
SOUP_STATUS_OK,
headers,
NULL,
0,
NULL);
soup_message_headers_free (headers);
}
static void
on_auth_response (GObject *obj,
GAsyncResult *res,
gpointer user_data)
{
LoginData *data = user_data;
GError *error = NULL;
GVariant *result;
gchar *user_id;
gint16 _bus_type;
LiaBusType bus_type;
gchar *auth_token;
const gchar *session_id;
SoupMessageHeaders *headers;
gchar *cookie;
result = g_dbus_connection_call_finish (G_DBUS_CONNECTION (obj),
res,
&error);
if (! result)
{
/* @TODO: Authentication failed */
g_debug ("Error, authentication failed: %s", error->message);
respond_login_failed (data, error);
g_error_free (error);
goto out;
}
g_variant_get (result,
"(ssn)",
&user_id,
&auth_token,
&_bus_type);
g_variant_unref (result);
/* save session! */
bus_type = (LiaBusType) _bus_type;
session_id = new_auth_session_data (data->self, user_id, bus_type, auth_token);
headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_RESPONSE);
cookie = g_strdup_printf ("%s=%s; path=%s; Secure; HttpOnly",
data->self->priv->sid_cookie_name,
session_id,
data->self->priv->base_path);
soup_message_headers_append (headers, "Set-Cookie", cookie);
g_free (cookie);
evd_web_service_respond (data->self->priv->web_service,
data->conn,
SOUP_STATUS_OK,
headers,
NULL,
0,
NULL);
soup_message_headers_free (headers);
out:
free_login_data (data);
}
/**
* youtube_proxy_upload_async:
* @self: a #YoutubeProxy
* @filename: filename
* @fields: fields
* @incomplete: incomplete
* @callback: (scope async): callback to invoke upon completion
* @weak_object: an object instance used to tie the life cycle of the proxy to
* @user_data: user data to pass to the callback
* @error: a #GError pointer, or %NULL
*
* Upload a file.
*
* Returns: %TRUE, or %FALSE if the file could not be opened
*/
gboolean
youtube_proxy_upload_async (YoutubeProxy *self,
const gchar *filename,
GHashTable *fields,
gboolean incomplete,
YoutubeProxyUploadCallback callback,
GObject *weak_object,
gpointer user_data,
GError **error)
{
SoupMultipart *mp;
SoupMessage *message;
SoupMessageHeaders *part_headers;
SoupBuffer *sb;
gchar *content_type;
gchar *atom_xml;
GMappedFile *map;
YoutubeProxyUploadClosure *closure;
map = g_mapped_file_new (filename, FALSE, error);
if (*error != NULL) {
g_warning ("Error opening file %s: %s", filename, (*error)->message);
return FALSE;
}
mp = soup_multipart_new ("multipart/related");
atom_xml = _construct_upload_atom_xml (fields, incomplete);
sb = soup_buffer_new_with_owner (atom_xml,
strlen(atom_xml),
atom_xml,
(GDestroyNotify) g_free);
part_headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_MULTIPART);
soup_message_headers_append (part_headers, "Content-Type",
"application/atom+xml; charset=UTF-8");
soup_multipart_append_part (mp, part_headers, sb);
soup_buffer_free (sb);
content_type = g_content_type_guess (
filename,
(const guchar*) g_mapped_file_get_contents (map),
g_mapped_file_get_length (map),
NULL);
sb = soup_buffer_new_with_owner (g_mapped_file_get_contents (map),
g_mapped_file_get_length (map),
map,
(GDestroyNotify) g_mapped_file_unref);
soup_message_headers_replace (part_headers, "Content-Type", content_type);
soup_multipart_append_part (mp, part_headers, sb);
soup_buffer_free (sb);
soup_message_headers_free (part_headers);
message = soup_form_request_new_from_multipart (UPLOAD_URL, mp);
soup_multipart_free (mp);
_set_upload_headers (self, message->request_headers, filename);
closure = _upload_async_closure_new (self, callback, message, weak_object,
user_data);
g_signal_connect (message,
"wrote-body-data",
(GCallback) _message_wrote_data_cb,
closure);
_rest_proxy_queue_message (REST_PROXY (self), message, _upload_completed_cb,
closure);
return TRUE;
}
static void
handle_partial_get (SoupMessage *msg)
{
SoupRange *ranges;
int nranges;
SoupBuffer *full_response;
/* Make sure the message is set up right for us to return a
* partial response; it has to be a GET, the status must be
* 200 OK (and in particular, NOT already 206 Partial
* Content), and the SoupServer must have already filled in
* the response body
*/
if (msg->method != SOUP_METHOD_GET ||
msg->status_code != SOUP_STATUS_OK ||
soup_message_headers_get_encoding (msg->response_headers) !=
SOUP_ENCODING_CONTENT_LENGTH ||
msg->response_body->length == 0 ||
!soup_message_body_get_accumulate (msg->response_body))
return;
/* Oh, and there has to have been a valid Range header on the
* request, of course.
*/
if (!soup_message_headers_get_ranges (msg->request_headers,
msg->response_body->length,
&ranges, &nranges))
return;
full_response = soup_message_body_flatten (msg->response_body);
if (!full_response) {
soup_message_headers_free_ranges (msg->request_headers, ranges);
return;
}
soup_message_set_status (msg, SOUP_STATUS_PARTIAL_CONTENT);
soup_message_body_truncate (msg->response_body);
if (nranges == 1) {
SoupBuffer *range_buf;
/* Single range, so just set Content-Range and fix the body. */
soup_message_headers_set_content_range (msg->response_headers,
ranges[0].start,
ranges[0].end,
full_response->length);
range_buf = soup_buffer_new_subbuffer (full_response,
ranges[0].start,
ranges[0].end - ranges[0].start + 1);
soup_message_body_append_buffer (msg->response_body, range_buf);
soup_buffer_free (range_buf);
} else {
SoupMultipart *multipart;
SoupMessageHeaders *part_headers;
SoupBuffer *part_body;
const char *content_type;
int i;
/* Multiple ranges, so build a multipart/byteranges response
* to replace msg->response_body with.
*/
multipart = soup_multipart_new ("multipart/byteranges");
content_type = soup_message_headers_get_one (msg->response_headers,
"Content-Type");
for (i = 0; i < nranges; i++) {
part_headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_MULTIPART);
if (content_type) {
soup_message_headers_append (part_headers,
"Content-Type",
content_type);
}
soup_message_headers_set_content_range (part_headers,
ranges[i].start,
ranges[i].end,
full_response->length);
part_body = soup_buffer_new_subbuffer (full_response,
ranges[i].start,
ranges[i].end - ranges[i].start + 1);
soup_multipart_append_part (multipart, part_headers,
part_body);
soup_message_headers_free (part_headers);
soup_buffer_free (part_body);
}
soup_multipart_to_message (multipart, msg->response_headers,
msg->response_body);
soup_multipart_free (multipart);
}
soup_buffer_free (full_response);
soup_message_headers_free_ranges (msg->request_headers, ranges);
}
static void
post_photo_file_buffer_ready_cb (void **buffer,
gsize count,
GError *error,
gpointer user_data)
{
PicasaWebService *self = user_data;
OAuthAccount *account;
GthFileData *file_data;
SoupMultipart *multipart;
const char *filename;
char *value;
GObject *metadata;
DomDocument *doc;
DomElement *entry;
char *entry_buffer;
gsize entry_len;
SoupMessageHeaders *headers;
SoupBuffer *body;
void *resized_buffer;
gsize resized_count;
char *url;
SoupMessage *msg;
if (error != NULL) {
post_photos_done (self, error);
return;
}
account = web_service_get_current_account (WEB_SERVICE (self));
file_data = self->priv->post_photos->current->data;
multipart = soup_multipart_new ("multipart/related");
/* the metadata part */
doc = dom_document_new ();
entry = dom_document_create_element (doc, "entry",
"xmlns", "http://www.w3.org/2005/Atom",
"xmlns:gphoto", "http://schemas.google.com/photos/2007",
"xmlns:media", "http://search.yahoo.com/mrss/",
NULL);
filename = g_file_info_get_display_name (file_data->info);
dom_element_append_child (entry,
dom_document_create_element_with_text (doc, filename, "title", NULL));
value = gth_file_data_get_attribute_as_string (file_data, "general::description");
if (value == NULL)
value = gth_file_data_get_attribute_as_string (file_data, "general::title");
dom_element_append_child (entry,
dom_document_create_element_with_text (doc, value, "summary", NULL));
value = gth_file_data_get_attribute_as_string (file_data, "general::location");
if (value != NULL)
dom_element_append_child (entry,
dom_document_create_element_with_text (doc, value, "gphoto:location", NULL));
metadata = g_file_info_get_attribute_object (file_data->info, "general::tags");
if (metadata != NULL)
value = gth_string_list_join (GTH_STRING_LIST (gth_metadata_get_string_list (GTH_METADATA (metadata))), ", ");
if (value != NULL) {
DomElement *group;
group = dom_document_create_element (doc, "media:group", NULL);
dom_element_append_child (group,
dom_document_create_element_with_text (doc, value, "media:keywords", NULL));
dom_element_append_child (entry, group);
g_free (value);
}
dom_element_append_child (entry,
dom_document_create_element (doc, "category",
"scheme", "http://schemas.google.com/g/2005#kind",
"term", "http://schemas.google.com/photos/2007#photo",
NULL));
dom_element_append_child (DOM_ELEMENT (doc), entry);
entry_buffer = dom_document_dump (doc, &entry_len);
headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_REQUEST);
soup_message_headers_append (headers, "Content-Type", "application/atom+xml");
body = soup_buffer_new (SOUP_MEMORY_TAKE, entry_buffer, entry_len);
soup_multipart_append_part (multipart, headers, body);
soup_buffer_free (body);
soup_message_headers_free (headers);
g_object_unref (doc);
/* the file part */
if (_g_buffer_resize_image (*buffer,
count,
file_data,
self->priv->post_photos->max_width,
self->priv->post_photos->max_height,
&resized_buffer,
&resized_count,
self->priv->post_photos->cancellable,
&error))
{
body = soup_buffer_new (SOUP_MEMORY_TAKE, resized_buffer, resized_count);
}
else if (error == NULL) {
body = soup_buffer_new (SOUP_MEMORY_TEMPORARY, *buffer, count);
}
else {
soup_multipart_free (multipart);
post_photos_done (self, error);
return;
}
soup_multipart_append_form_file (multipart,
"file",
NULL,
gth_file_data_get_mime_type (file_data),
body);
soup_buffer_free (body);
/* send the file */
self->priv->post_photos->wrote_body_data_size = 0;
url = g_strconcat ("https://picasaweb.google.com/data/feed/api/user/",
account->id,
"/albumid/",
self->priv->post_photos->album->id,
NULL);
msg = soup_form_request_new_from_multipart (url, multipart);
g_signal_connect (msg,
"wrote-body-data",
(GCallback) upload_photo_wrote_body_data_cb,
self);
_picasa_web_service_add_headers (self, msg);
_web_service_send_message (WEB_SERVICE (self),
msg,
self->priv->post_photos->cancellable,
self->priv->post_photos->callback,
self->priv->post_photos->user_data,
picasa_web_service_post_photos,
post_photo_ready_cb,
self);
g_free (url);
soup_multipart_free (multipart);
}
template <> void freeOwnedGPtr<SoupMessageHeaders>(SoupMessageHeaders* ptr)
{
if (ptr)
soup_message_headers_free(ptr);
}
