static gboolean
io_handle_sniffing (SoupMessage *msg, gboolean done_reading)
{
SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
SoupMessageIOData *io = priv->io_data;
SoupBuffer *sniffed_buffer;
char *sniffed_mime_type;
GHashTable *params = NULL;
if (!priv->sniffer)
return TRUE;
if (!io->sniff_data) {
io->sniff_data = soup_message_body_new ();
io->need_content_sniffed = TRUE;
}
if (io->need_content_sniffed) {
if (io->sniff_data->length < priv->bytes_for_sniffing &&
!done_reading)
return TRUE;
io->need_content_sniffed = FALSE;
sniffed_buffer = soup_message_body_flatten (io->sniff_data);
sniffed_mime_type = soup_content_sniffer_sniff (priv->sniffer, msg, sniffed_buffer, ¶ms);
SOUP_MESSAGE_IO_PREPARE_FOR_CALLBACK;
soup_message_content_sniffed (msg, sniffed_mime_type, params);
g_free (sniffed_mime_type);
if (params)
g_hash_table_destroy (params);
if (sniffed_buffer)
soup_buffer_free (sniffed_buffer);
SOUP_MESSAGE_IO_RETURN_VAL_IF_CANCELLED_OR_PAUSED (FALSE);
}
if (io->need_got_chunk) {
io->need_got_chunk = FALSE;
sniffed_buffer = soup_message_body_flatten (io->sniff_data);
SOUP_MESSAGE_IO_PREPARE_FOR_CALLBACK;
soup_message_got_chunk (msg, sniffed_buffer);
soup_buffer_free (sniffed_buffer);
SOUP_MESSAGE_IO_RETURN_VAL_IF_CANCELLED_OR_PAUSED (FALSE);
}
return TRUE;
}
static void
_oauth_service_get_access_token_ready_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
OAuthService *self = user_data;
GSimpleAsyncResult *result;
SoupBuffer *body;
result = _web_service_get_result (WEB_SERVICE (self));
if (msg->status_code != 200) {
g_simple_async_result_set_error (result,
SOUP_HTTP_ERROR,
msg->status_code,
"%s",
soup_status_get_phrase (msg->status_code));
g_simple_async_result_complete_in_idle (result);
return;
}
body = soup_message_body_flatten (msg->response_body);
self->priv->consumer->access_token_response (self, msg, body, result);
g_simple_async_result_complete_in_idle (result);
soup_buffer_free (body);
}
static void write_output_file (gpointer data)
{
g_assert (data != NULL);
GError *error = NULL;
GDownloadable *download = G_DOWNLOADABLE (data);
SoupDownload *soup_download = SOUP_DOWNLOAD (data);
if (soup_download->priv->need_to_write) {
GFileOutputStream *ostream = g_file_append_to (download->priv->local_file, G_FILE_CREATE_NONE, NULL, &error);
handle_error (error);
SoupBuffer *buffer = soup_message_body_flatten (soup_download->priv->message->response_body);
g_output_stream_write (G_OUTPUT_STREAM (ostream), buffer->data, buffer->length, NULL, &error);
handle_error (error);
g_output_stream_close (G_OUTPUT_STREAM (ostream), NULL, &error);
handle_error (error);
download->priv->downloaded_size = soup_download->priv->prev_downloaded + buffer->length;
soup_buffer_free (buffer);
soup_download->priv->need_to_write = FALSE;
}
}
JNIEXPORT void JNICALL WebKitGTK_NATIVE(_1soup_1message_1body_1flatten)
(JNIEnv *env, jclass that, jintLong arg0)
{
WebKitGTK_NATIVE_ENTER(env, that, _1soup_1message_1body_1flatten_FUNC);
soup_message_body_flatten((SoupMessageBody *)arg0);
WebKitGTK_NATIVE_EXIT(env, that, _1soup_1message_1body_1flatten_FUNC);
}
static SoupMessage *
ews_create_msg_for_url (const gchar *url,
xmlOutputBuffer *buf)
{
SoupMessage *msg;
gconstpointer buf_content;
gsize buf_size;
msg = soup_message_new (buf != NULL ? "POST" : "GET", url);
soup_message_headers_append (
msg->request_headers, "User-Agent", "libews/0.1");
if (buf != NULL) {
buf_content = compat_libxml_output_buffer_get_content (buf, &buf_size);
soup_message_set_request (
msg, "text/xml; charset=utf-8",
SOUP_MEMORY_COPY,
buf_content, buf_size);
g_signal_connect (
msg, "restarted",
G_CALLBACK (ews_post_restarted_cb), buf);
}
soup_buffer_free (
soup_message_body_flatten (
SOUP_MESSAGE (msg)->request_body));
g_debug ("The request headers");
g_debug ("===================");
g_debug ("%s", SOUP_MESSAGE (msg)->request_body->data);
return msg;
}
static void
get_albums_ready_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
FacebookService *self = user_data;
GSimpleAsyncResult *result;
SoupBuffer *body;
DomDocument *doc = NULL;
GError *error = NULL;
result = facebook_connection_get_result (self->priv->conn);
if (msg->status_code != 200) {
g_simple_async_result_set_error (result,
SOUP_HTTP_ERROR,
msg->status_code,
"%s",
soup_status_get_phrase (msg->status_code));
g_simple_async_result_complete_in_idle (result);
return;
}
body = soup_message_body_flatten (msg->response_body);
if (facebook_utils_parse_response (body, &doc, &error)) {
DomElement *node;
GList *albums = NULL;
for (node = DOM_ELEMENT (doc)->first_child; node; node = node->next_sibling) {
if (g_strcmp0 (node->tag_name, "photos_getAlbums_response") == 0) {
DomElement *child;
for (child = node->first_child; child; child = child->next_sibling) {
if (g_strcmp0 (child->tag_name, "album") == 0) {
FacebookAlbum *album;
album = facebook_album_new ();
dom_domizable_load_from_element (DOM_DOMIZABLE (album), child);
albums = g_list_prepend (albums, album);
}
}
}
}
albums = g_list_reverse (albums);
g_simple_async_result_set_op_res_gpointer (result, albums, (GDestroyNotify) _g_object_list_unref);
g_object_unref (doc);
}
else
g_simple_async_result_set_from_error (result, error);
g_simple_async_result_complete_in_idle (result);
soup_buffer_free (body);
}
static void
get_user_info_ready_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
FacebookService *self = user_data;
GSimpleAsyncResult *result;
SoupBuffer *body;
DomDocument *doc = NULL;
GError *error = NULL;
result = facebook_connection_get_result (self->priv->conn);
if (msg->status_code != 200) {
g_simple_async_result_set_error (result,
SOUP_HTTP_ERROR,
msg->status_code,
"%s",
soup_status_get_phrase (msg->status_code));
g_simple_async_result_complete_in_idle (result);
return;
}
body = soup_message_body_flatten (msg->response_body);
if (facebook_utils_parse_response (body, &doc, &error)) {
DomElement *node;
FacebookUser *user = NULL;
for (node = DOM_ELEMENT (doc)->first_child; node; node = node->next_sibling) {
if (g_strcmp0 (node->tag_name, "users_getInfo_response") == 0) {
DomElement *child;
for (child = node->first_child; child; child = child->next_sibling) {
if (g_strcmp0 (child->tag_name, "user") == 0) {
user = facebook_user_new ();
dom_domizable_load_from_element (DOM_DOMIZABLE (user), child);
g_simple_async_result_set_op_res_gpointer (result, user, (GDestroyNotify) g_object_unref);
}
}
}
}
if (user == NULL) {
error = g_error_new_literal (FACEBOOK_CONNECTION_ERROR, 0, _("Unknown error"));
g_simple_async_result_set_from_error (result, error);
}
g_object_unref (doc);
}
else
g_simple_async_result_set_from_error (result, error);
g_simple_async_result_complete_in_idle (result);
soup_buffer_free (body);
}
static void _process_check_resp(SoupSession *ss, SoupMessage *msg, gpointer user_data)
{
GWQSession *wqs;
const guint8* data;
gsize size;
SoupBuffer *sBuf;
int i;
wqs = (GWQSession*)user_data;
sBuf = soup_message_body_flatten(msg->response_body);
GWQ_DBG("check responsed, retcode=%d, reason:%s\n", msg->status_code, msg->reason_phrase);
if (sBuf) {
soup_buffer_get_data(sBuf, &data, &size);
GWQ_DBG("bodySize=%d\nbody:%s\n", size, data);
if (size>0) {
const gchar *tmpCStr, *vc, *end;
tmpCStr = (const gchar*)data;
end = (gchar*)(data+size-1);
if (tmpCStr
&& (tmpCStr = g_strstr_len(tmpCStr, size, ","))
&& tmpCStr < end
&& *(++tmpCStr)
&& (tmpCStr = g_strstr_len(tmpCStr, size, "'"))
&& tmpCStr < end
&& *(vc = ++tmpCStr)
&& (tmpCStr = g_strstr_len(tmpCStr, size, "'"))
&& tmpCStr < end) {
g_string_assign(wqs->verifyCode, "");
g_string_append_len(wqs->verifyCode, vc, tmpCStr-vc);
GWQ_DBG("vc.verifyCode: %s\n", wqs->verifyCode->str);
}
if (tmpCStr
&& (tmpCStr = g_strstr_len(tmpCStr, size, ","))
&& tmpCStr < end
&& *(++tmpCStr)
&& (tmpCStr = g_strstr_len(tmpCStr, size, "'"))
&& tmpCStr < end
&& *(vc = ++tmpCStr)
&& (tmpCStr = g_strstr_len(tmpCStr, size, "'"))
&& tmpCStr < end) {
g_string_assign(wqs->vcUin, "");
g_string_append_len(wqs->vcUin, vc, tmpCStr-vc);
GWQ_DBG("vc.uin:%s\n", wqs->vcUin->str);
wqs->vcUinAryLen = (wqs->vcUin->len)>>2;
if (wqs->vcUinAryLen < sizeof(wqs->vcUinAry)) {
for (i=0; i<wqs->vcUinAryLen; i++) {
wqs->vcUinAry[i] = DigestCharToChar(wqs->vcUin->str[(i<<2)+2], wqs->vcUin->str[(i<<2)+3]);
GWQ_DBG("%x\n", wqs->vcUinAry[i]);
}
}
}
}
soup_buffer_free(sBuf);
}
static void
upload_photo_ready_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
FacebookService *self = user_data;
SoupBuffer *body;
DomDocument *doc = NULL;
GError *error = NULL;
GthFileData *file_data;
if (msg->status_code != 200) {
GError *error;
error = g_error_new_literal (SOUP_HTTP_ERROR, msg->status_code, soup_status_get_phrase (msg->status_code));
upload_photos_done (self, error);
g_error_free (error);
return;
}
body = soup_message_body_flatten (msg->response_body);
if (facebook_utils_parse_response (body, &doc, &error)) {
DomElement *node;
/* save the photo id */
for (node = DOM_ELEMENT (doc)->first_child; node; node = node->next_sibling) {
if (g_strcmp0 (node->tag_name, "pid") == 0) {
const char *id;
id = dom_element_get_inner_text (node);
self->priv->post_photos->ids = g_list_prepend (self->priv->post_photos->ids, g_strdup (id));
}
}
g_object_unref (doc);
}
else {
soup_buffer_free (body);
upload_photos_done (self, error);
return;
}
soup_buffer_free (body);
file_data = self->priv->post_photos->current->data;
self->priv->post_photos->uploaded_size += g_file_info_get_size (file_data->info);
self->priv->post_photos->current = self->priv->post_photos->current->next;
facebook_service_upload_current_file (self);
}
/*
* If there is a mismatch or an error, then gda_connection_add_event_string() is used
*
* - if all OK, extracs the <challenge> value and replace cdata->next_challenge with it (or simply
* reset cdata->next_challenge to NULL)
*
* Returns: a new #xmlDocPtr, or %NULL on error
*/
xmlDocPtr
_gda_web_decode_response (GdaConnection *cnc, WebConnectionData *cdata, SoupMessageBody *body,
gchar *out_status_chr, guint *out_counter_id)
{
SoupBuffer *sbuffer;
xmlDocPtr doc;
sbuffer = soup_message_body_flatten (body);
#ifdef DEBUG_WEB_PROV
g_print ("=== START of response ===\n%s\n=== END of response ===\n", (gchar*) sbuffer->data);
#endif
doc = decode_buffer_response (cnc, cdata, sbuffer, out_status_chr, out_counter_id);
soup_buffer_free (sbuffer);
return doc;
}
void trex_callback(SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query, const char *dest)
{
SoupMessage *new_msg;
SoupSession *session;
char *uri_str;
struct destination_info *to = malloc(sizeof(struct destination_info));
to->server = server;
to->msg = msg;
session = soup_session_async_new();
uri_str = soup_uri_to_string(soup_message_get_uri(msg), true);
/*
* TODO Memory Leak :-)
*/
uri_str = g_strjoin(NULL, dest, uri_str, NULL);
g_print("[%p] %s %s HTTP/1.%d\n", msg, msg->method, uri_str,
soup_message_get_http_version(msg));
/* build new request */
new_msg = soup_message_new(msg->method, uri_str);
soup_message_headers_foreach(msg->request_headers, copy_header,
new_msg->request_headers);
soup_message_headers_remove(new_msg->request_headers, "Host");
if (msg->request_body->length) {
SoupBuffer *request =
soup_message_body_flatten(msg->request_body);
soup_message_body_append_buffer(new_msg->request_body,
request);
soup_buffer_free(request);
}
soup_message_headers_set_encoding(msg->response_headers,
SOUP_ENCODING_CHUNKED);
soup_server_pause_message(server, msg);
g_signal_connect(new_msg, "got_headers",
G_CALLBACK(recv_headers), to);
g_signal_connect(new_msg, "got_chunk",
G_CALLBACK(recv_chunk), to);
soup_session_queue_message(session, new_msg, finish_msg, to);
g_object_ref(msg);
g_object_unref(session);
}
static void
soup_soap_message_constructed (GObject *object)
{
SoupSoapMessage *msg = SOUP_SOAP_MESSAGE (object);
SoupSoapMessagePrivate *priv = msg->priv;
soup_buffer_free (soup_message_body_flatten (priv->message_body));
xmlNodePtr current_node, op_node;
xmlDocPtr doc = xmlParseDoc (BAD_CAST priv->message_body->data);
if (doc)
{
current_node = xmlDocGetRootElement (doc);
if (current_node &&
current_node->name &&
xmlStrEqual (current_node->name, BAD_CAST "Envelope"))
{
for (current_node = current_node->children;
current_node != NULL;
current_node = current_node->next)
{
if (current_node->type == XML_ELEMENT_NODE)
{
if (xmlStrEqual (current_node->name, BAD_CAST "Header"))
parse_param (priv->header,
current_node);
else if (xmlStrEqual (current_node->name, BAD_CAST "Body"))
{
op_node = current_node->children;
if (op_node)
{
soup_soap_param_set_name (SOUP_SOAP_PARAM (priv->body),
(gchar *) op_node->name);
parse_param (priv->body,
op_node);
}
}
}
}
}
}
xmlFreeDoc (doc);
G_OBJECT_CLASS (soup_soap_message_parent_class)->constructed (object);
}
static void
get_logged_in_user_ready_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
FacebookService *self = user_data;
GSimpleAsyncResult *result;
SoupBuffer *body;
DomDocument *doc = NULL;
GError *error = NULL;
result = facebook_connection_get_result (self->priv->conn);
if (msg->status_code != 200) {
g_simple_async_result_set_error (result,
SOUP_HTTP_ERROR,
msg->status_code,
"%s",
soup_status_get_phrase (msg->status_code));
g_simple_async_result_complete_in_idle (result);
return;
}
body = soup_message_body_flatten (msg->response_body);
if (facebook_utils_parse_response (body, &doc, &error)) {
DomElement *root;
char *uid = NULL;
root = DOM_ELEMENT (doc)->first_child;
if (g_strcmp0 (root->tag_name, "users_getLoggedInUser_response") == 0)
uid = g_strdup (dom_element_get_inner_text (root));
if (uid == NULL) {
error = g_error_new_literal (FACEBOOK_CONNECTION_ERROR, 0, _("Unknown error"));
g_simple_async_result_set_from_error (result, error);
}
else
g_simple_async_result_set_op_res_gpointer (result, uid, g_free);
g_object_unref (doc);
}
else
g_simple_async_result_set_from_error (result, error);
g_simple_async_result_complete_in_idle (result);
soup_buffer_free (body);
}
static gboolean
picasa_web_utils_parse_json_response (SoupMessage *msg,
JsonNode **node,
GError **error)
{
JsonParser *parser;
SoupBuffer *body;
g_return_val_if_fail (msg != NULL, FALSE);
g_return_val_if_fail (node != NULL, FALSE);
*node = NULL;
if ((msg->status_code != 200) && (msg->status_code != 400)) {
*error = g_error_new (SOUP_HTTP_ERROR,
msg->status_code,
"%s",
soup_status_get_phrase (msg->status_code));
return FALSE;
}
body = soup_message_body_flatten (msg->response_body);
parser = json_parser_new ();
if (json_parser_load_from_data (parser, body->data, body->length, error)) {
JsonObject *obj;
*node = json_node_copy (json_parser_get_root (parser));
obj = json_node_get_object (*node);
if (json_object_has_member (obj, "error")) {
JsonObject *error_obj;
error_obj = json_object_get_object_member (obj, "error");
*error = g_error_new (WEB_SERVICE_ERROR,
json_object_get_int_member (error_obj, "code"),
"%s",
json_object_get_string_member (error_obj, "message"));
json_node_free (*node);
*node = NULL;
}
}
g_object_unref (parser);
soup_buffer_free (body);
return *node != NULL;
}
static void
_oauth_service_get_request_token_ready_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
OAuthService *self = user_data;
GSimpleAsyncResult *result;
SoupBuffer *body;
GHashTable *values;
char *token;
char *token_secret;
result = _web_service_get_result (WEB_SERVICE (self));
if (msg->status_code != 200) {
g_simple_async_result_set_error (result,
SOUP_HTTP_ERROR,
msg->status_code,
"%s",
soup_status_get_phrase (msg->status_code));
g_simple_async_result_complete_in_idle (result);
return;
}
body = soup_message_body_flatten (msg->response_body);
values = soup_form_decode (body->data);
token = g_hash_table_lookup (values, "oauth_token");
token_secret = g_hash_table_lookup (values, "oauth_token_secret");
if ((token != NULL) && (token_secret != NULL)) {
oauth_service_set_token (self, token);
oauth_service_set_token_secret (self, token_secret);
g_simple_async_result_set_op_res_gboolean (result, TRUE);
}
else {
GError *error;
error = g_error_new_literal (WEB_SERVICE_ERROR, WEB_SERVICE_ERROR_GENERIC, _("Unknown error"));
g_simple_async_result_set_from_error (result, error);
}
g_simple_async_result_complete_in_idle (result);
g_hash_table_destroy (values);
soup_buffer_free (body);
}
static
void
test_http_callback(
SoupServer* server,
SoupMessage* msg,
const char* path,
GHashTable* query,
SoupClientContext* context,
gpointer data)
{
char* uri = soup_uri_to_string(soup_message_get_uri (msg), FALSE);
MMS_VERBOSE("%s %s HTTP/1.%d", msg->method, uri,
soup_message_get_http_version(msg));
g_free(uri);
if (msg->method == SOUP_METHOD_CONNECT) {
soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
} else {
TestHttp* http = data;
if (msg->request_body->length) {
SoupBuffer* request = soup_message_body_flatten(msg->request_body);
if (http->req_bytes) g_bytes_unref(http->req_bytes);
http->req_bytes = g_bytes_new_with_free_func(request->data,
request->length, (GDestroyNotify)soup_buffer_free, request);
}
soup_message_set_status(msg, http->resp_status);
soup_message_headers_set_content_type(msg->response_headers,
http->resp_content_type ? http->resp_content_type : "text/plain",
NULL);
soup_message_headers_append(msg->response_headers,
"Accept-Ranges", "bytes");
soup_message_headers_append(msg->response_headers,
"Connection", "close");
if (http->resp_file) {
soup_message_headers_set_content_length(msg->response_headers,
g_mapped_file_get_length(http->resp_file));
soup_message_body_append(msg->response_body, SOUP_MEMORY_TEMPORARY,
g_mapped_file_get_contents(http->resp_file),
g_mapped_file_get_length(http->resp_file));
} else {
soup_message_headers_set_content_length(msg->response_headers, 0);
}
}
soup_message_body_complete(msg->request_body);
}
static void
server_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *context, gpointer data)
{
SoupMessage *msg2;
char *uristr;
uristr = soup_uri_to_string (soup_message_get_uri (msg), FALSE);
printf ("[%p] %s %s HTTP/1.%d\n", msg, msg->method, uristr,
soup_message_get_http_version (msg));
if (msg->method == SOUP_METHOD_CONNECT) {
soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
msg2 = soup_message_new (msg->method, uristr);
msg2 = soup_message_new (msg->method, uristr);
soup_message_headers_foreach (msg->request_headers, copy_header,
msg2->request_headers);
soup_message_headers_remove (msg2->request_headers, "Host");
soup_message_headers_remove (msg2->request_headers, "Connection");
if (msg->request_body->length) {
SoupBuffer *request = soup_message_body_flatten (msg->request_body);
soup_message_body_append_buffer (msg2->request_body, request);
soup_buffer_free (request);
}
soup_message_headers_set_encoding (msg->response_headers,
SOUP_ENCODING_CHUNKED);
g_signal_connect (msg2, "got_headers",
G_CALLBACK (send_headers), msg);
g_signal_connect (msg2, "got_chunk",
G_CALLBACK (send_chunk), msg);
g_signal_connect (msg, "finished", G_CALLBACK (client_msg_failed), msg2);
soup_session_queue_message (session, msg2, finish_msg, msg);
g_object_ref (msg);
soup_server_pause_message (server, msg);
}
static void
gdav_request_splice_cb (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
SoupMessage *message;
GTask *task = G_TASK (user_data);
GError *local_error = NULL;
message = g_task_get_task_data (task);
g_output_stream_splice_finish (
G_OUTPUT_STREAM (source_object), result, &local_error);
if (local_error != NULL) {
g_task_return_error (task, local_error);
/* XXX That the input stream's content is not automatically
* copied to the SoupMessage's response_body is a known
* libsoup bug which may be fixed in a future release.
* Check that the response body is empty so we don't
* accidentally duplicate the body. */
} else if (message->response_body->data == NULL) {
GMemoryOutputStream *output_stream;
gpointer data;
gsize size;
output_stream = G_MEMORY_OUTPUT_STREAM (source_object);
size = g_memory_output_stream_get_data_size (output_stream);
data = g_memory_output_stream_steal_data (output_stream);
soup_message_body_append_take (
message->response_body, data, size);
soup_message_body_flatten (message->response_body);
soup_message_finished (message);
g_task_return_boolean (task, TRUE);
} else {
g_task_return_boolean (task, TRUE);
}
g_object_unref (task);
}
void
e_gw_message_write_footer (SoupSoapMessage *msg)
{
soup_soap_message_end_element (msg);
soup_soap_message_end_body (msg);
soup_soap_message_end_envelope (msg);
soup_soap_message_persist (msg);
if (g_getenv ("GROUPWISE_DEBUG") && (atoi (g_getenv ("GROUPWISE_DEBUG")) == 1)) {
const gchar *header = soup_message_headers_get (SOUP_MESSAGE (msg)->request_headers, "SOAPAction");
soup_buffer_free (soup_message_body_flatten (SOUP_MESSAGE (msg)->request_body));
if (header && g_str_equal (header, "loginRequest")) {
gchar *body;
gchar *begin = NULL;
gchar *end = NULL;
body = g_strdup (SOUP_MESSAGE (msg)->request_body->data);
begin = g_strrstr (body, "<types:password>");
if (begin)
begin = begin + strlen ("<types:password>");
end = g_strrstr (body , "</types:password>");
if (begin && end) {
gchar *tmp;
for (tmp = begin; tmp < end; tmp++)
*tmp='X';
}
fputc ('\n', stdout);
fputs (body, stdout);
fputc ('\n', stdout);
g_free (body);
}
else {
/* print request's body */
fputc ('\n', stdout);
fputs (SOUP_MESSAGE (msg)->request_body->data, stdout);
fputc ('\n', stdout);
}
}
}
static void
get_correct_response (const char *uri)
{
SoupSession *session;
SoupMessage *msg;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
msg = soup_message_new (SOUP_METHOD_GET, uri);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_OK) {
fprintf (stderr, "Could not fetch %s: %d %s\n", uri,
msg->status_code, msg->reason_phrase);
exit (1);
}
correct_response = soup_message_body_flatten (msg->response_body);
g_object_unref (msg);
soup_test_session_abort_unref (session);
}
static void
create_album_ready_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
PicasaWebService *self = user_data;
GSimpleAsyncResult *result;
SoupBuffer *body;
DomDocument *doc;
GError *error = NULL;
result = _web_service_get_result (WEB_SERVICE (self));
if (msg->status_code != 201) {
g_simple_async_result_set_error (result,
SOUP_HTTP_ERROR,
msg->status_code,
"%s",
soup_status_get_phrase (msg->status_code));
g_simple_async_result_complete_in_idle (result);
return;
}
body = soup_message_body_flatten (msg->response_body);
doc = dom_document_new ();
if (dom_document_load (doc, body->data, body->length, &error)) {
PicasaWebAlbum *album;
album = picasa_web_album_new ();
dom_domizable_load_from_element (DOM_DOMIZABLE (album), DOM_ELEMENT (doc)->first_child);
g_simple_async_result_set_op_res_gpointer (result, album, (GDestroyNotify) g_object_unref);
}
else {
g_simple_async_result_set_from_error (result, error);
g_error_free (error);
}
g_simple_async_result_complete_in_idle (result);
g_object_unref (doc);
soup_buffer_free (body);
}
static void
server_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *context, gpointer data)
{
SoupMessageBody *md5_body;
char *md5;
if (g_str_has_prefix (path, "/redirect")) {
soup_message_set_status (msg, SOUP_STATUS_FOUND);
soup_message_headers_replace (msg->response_headers,
"Location", "/");
return;
}
if (msg->method == SOUP_METHOD_GET) {
soup_message_set_response (msg, "text/plain",
SOUP_MEMORY_STATIC,
"three\r\ntwo\r\none\r\n",
strlen ("three\r\ntwo\r\none\r\n"));
soup_buffer_free (soup_message_body_flatten (msg->response_body));
md5_body = msg->response_body;
soup_message_set_status (msg, SOUP_STATUS_OK);
} else if (msg->method == SOUP_METHOD_PUT) {
soup_message_set_status (msg, SOUP_STATUS_CREATED);
md5_body = msg->request_body;
} else {
soup_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED);
return;
}
md5 = g_compute_checksum_for_data (G_CHECKSUM_MD5,
(guchar *)md5_body->data,
md5_body->length);
soup_message_headers_append (msg->response_headers,
"Content-MD5", md5);
g_free (md5);
}
static void
ews_client_autodiscover_response_cb (SoupSession *session, SoupMessage *msg, gpointer user_data)
{
GError *error;
AutodiscoverData *data = user_data;
gboolean op_res;
guint status;
gint idx;
gsize size;
xmlDoc *doc;
xmlNode *node;
error = NULL;
op_res = FALSE;
size = sizeof (data->msgs) / sizeof (data->msgs[0]);
for (idx = 0; idx < size; idx++)
{
if (data->msgs[idx] == msg)
break;
}
if (idx == size || data->pending == 0)
return;
data->msgs[idx] = NULL;
status = msg->status_code;
/* status == SOUP_STATUS_CANCELLED, if we are being aborted by the
* GCancellable, an SSL error or another message that was
* successful.
*/
if (status == SOUP_STATUS_CANCELLED)
goto out;
else if (status != SOUP_STATUS_OK)
{
g_set_error (&error,
GOA_ERROR,
GOA_ERROR_FAILED, /* TODO: more specific */
_("Code: %u — Unexpected response from server"),
status);
goto out;
}
soup_buffer_free (soup_message_body_flatten (SOUP_MESSAGE (msg)->response_body));
g_debug ("The response headers");
g_debug ("===================");
g_debug ("%s", SOUP_MESSAGE (msg)->response_body->data);
doc = xmlReadMemory (msg->response_body->data, msg->response_body->length, "autodiscover.xml", NULL, 0);
if (doc == NULL)
{
g_set_error (&error,
GOA_ERROR,
GOA_ERROR_FAILED, /* TODO: more specific */
_("Failed to parse autodiscover response XML"));
goto out;
}
node = xmlDocGetRootElement (doc);
if (g_strcmp0 ((gchar *) node->name, "Autodiscover"))
{
g_set_error (&error,
GOA_ERROR,
GOA_ERROR_FAILED, /* TODO: more specific */
/* Translators: the parameter is an XML element name. */
_("Failed to find ‘%s’ element"), "Autodiscover");
goto out;
}
for (node = node->children; node; node = node->next)
{
if (ews_client_check_node (node, "Response"))
break;
}
if (node == NULL)
{
g_set_error (&error,
GOA_ERROR,
GOA_ERROR_FAILED, /* TODO: more specific */
/* Translators: the parameter is an XML element name. */
_("Failed to find ‘%s’ element"), "Response");
goto out;
}
for (node = node->children; node; node = node->next)
{
if (ews_client_check_node (node, "Account"))
break;
}
if (node == NULL)
{
g_set_error (&error,
GOA_ERROR,
GOA_ERROR_FAILED, /* TODO: more specific */
/* Translators: the parameter is an XML element name. */
_("Failed to find ‘%s’ element"), "Account");
goto out;
}
for (node = node->children; node; node = node->next)
{
if (ews_client_check_node (node, "Protocol"))
{
op_res = ews_client_autodiscover_parse_protocol (node);
/* Since the server may send back multiple <Protocol> nodes
* don't break unless we found the one we want.
*/
if (op_res)
break;
}
}
if (!op_res)
{
g_set_error (&error,
GOA_ERROR,
GOA_ERROR_FAILED, /* TODO: more specific*/
_("Failed to find ASUrl and OABUrl in autodiscover response"));
goto out;
}
for (idx = 0; idx < size; idx++)
{
if (data->msgs[idx] != NULL)
{
/* The callback (ie. this function) will be invoked after we
* have returned to the main loop.
*/
soup_session_cancel_message (data->session, data->msgs[idx], SOUP_STATUS_CANCELLED);
}
}
out:
/* error == NULL, if we are being aborted by the GCancellable, an
* SSL error or another message that was successful.
*/
if (!op_res)
{
/* There's another request outstanding.
* Hope that it has better luck.
*/
if (data->pending > 1)
g_clear_error (&error);
if (error != NULL)
g_simple_async_result_take_error (data->res, error);
}
data->pending--;
if (data->pending == 0)
{
GMainContext *context;
GSource *source;
g_simple_async_result_set_op_res_gboolean (data->res, op_res);
source = g_idle_source_new ();
g_source_set_priority (source, G_PRIORITY_DEFAULT_IDLE);
g_source_set_callback (source, ews_client_autodiscover_data_free, data, NULL);
g_source_set_name (source, "[goa] ews_client_autodiscover_data_free");
context = g_main_context_get_thread_default ();
g_source_attach (source, context);
g_source_unref (source);
}
}
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
print_request (SoupLogger *logger, SoupMessage *msg,
SoupSession *session, SoupSocket *socket,
gboolean restarted)
{
SoupLoggerPrivate *priv = SOUP_LOGGER_GET_PRIVATE (logger);
SoupLoggerLogLevel log_level;
SoupMessageHeadersIter iter;
const char *name, *value;
SoupURI *uri;
if (priv->request_filter) {
log_level = priv->request_filter (logger, msg,
priv->request_filter_data);
} else
log_level = priv->level;
if (log_level == SOUP_LOGGER_LOG_NONE)
return;
uri = soup_message_get_uri (msg);
if (msg->method == SOUP_METHOD_CONNECT) {
soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>',
"CONNECT %s:%u HTTP/1.%d",
uri->host, uri->port,
soup_message_get_http_version (msg));
} else {
soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>',
"%s %s%s%s HTTP/1.%d",
msg->method, uri->path,
uri->query ? "?" : "",
uri->query ? uri->query : "",
soup_message_get_http_version (msg));
}
soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>',
"Soup-Debug-Timestamp: %lu",
(unsigned long)time (0));
soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>',
"Soup-Debug: %s %u (%p), %s %u (%p), %s %u (%p)%s",
g_type_name_from_instance ((GTypeInstance *)session),
soup_logger_get_id (logger, session), session,
g_type_name_from_instance ((GTypeInstance *)msg),
soup_logger_get_id (logger, msg), msg,
g_type_name_from_instance ((GTypeInstance *)socket),
soup_logger_get_id (logger, socket), socket,
restarted ? ", restarted" : "");
if (log_level == SOUP_LOGGER_LOG_MINIMAL)
return;
if (!soup_message_headers_get_one (msg->request_headers, "Host")) {
char *uri_host;
if (strchr (uri->host, ':'))
uri_host = g_strdup_printf ("[%s]", uri->host);
else if (g_hostname_is_non_ascii (uri->host))
uri_host = g_hostname_to_ascii (uri->host);
else
uri_host = uri->host;
soup_logger_print (logger, SOUP_LOGGER_LOG_HEADERS, '>',
"Host: %s%c%u", uri_host,
soup_uri_uses_default_port (uri) ? '\0' : ':',
uri->port);
if (uri_host != uri->host)
g_free (uri_host);
}
soup_message_headers_iter_init (&iter, msg->request_headers);
while (soup_message_headers_iter_next (&iter, &name, &value)) {
if (!g_ascii_strcasecmp (name, "Authorization") &&
!g_ascii_strncasecmp (value, "Basic ", 6))
soup_logger_print_basic_auth (logger, value);
else {
soup_logger_print (logger, SOUP_LOGGER_LOG_HEADERS, '>',
"%s: %s", name, value);
}
}
if (log_level == SOUP_LOGGER_LOG_HEADERS)
return;
if (msg->request_body->length &&
soup_message_body_get_accumulate (msg->request_body)) {
SoupBuffer *request;
request = soup_message_body_flatten (msg->request_body);
g_return_if_fail (request != NULL);
soup_buffer_free (request);
if (soup_message_headers_get_expectations (msg->request_headers) != SOUP_EXPECTATION_CONTINUE) {
soup_logger_print (logger, SOUP_LOGGER_LOG_BODY, '>',
"\n%s", msg->request_body->data);
}
}
}
void
restraint_append_message (SoupSession *session,
SoupMessage *msg,
gpointer msg_data,
MessageFinishCallback finish_callback,
GCancellable *cancellable,
gpointer user_data)
{
ClientData *client_data = (ClientData *) msg_data;
time_t result;
result = time(NULL);
static time_t transaction_id = 0;
// calculate the transaction id. base it off of epoch
// incase the host reboots we shouldn't collide
if (transaction_id == 0) {
transaction_id = result;
}
MessageData *message_data;
message_data = g_slice_new0 (MessageData);
message_data->msg = msg;
message_data->user_data = user_data;
message_data->finish_callback = finish_callback;
if (client_data != NULL) {
GString *body = g_string_new("");
SoupURI *uri = soup_message_get_uri (msg);
soup_message_headers_foreach (msg->request_headers, append_header,
body);
// if we are doing a POST transaction
// increment transaction_id and add it to headers
// populate Location header in msg->reponse_headers
const gchar *path = soup_uri_get_path (uri);
if (g_strcmp0 (msg->method, "POST") == 0) {
g_string_append_printf (body,
"transaction-id: %jd\n", (intmax_t) transaction_id);
gchar *location_url = g_strdup_printf ("%s%jd", path, (intmax_t) transaction_id);
soup_message_headers_append (msg->response_headers, "Location", location_url);
g_free (location_url);
transaction_id++;
}
soup_message_set_status (msg, SOUP_STATUS_OK);
g_string_append_printf (body,
"rstrnt-path: %s\n"
"rstrnt-method: %s\n"
"Content-Length: %d\r\n\r\n",
path,
msg->method,
(guint) msg->request_body->length);
SoupBuffer *request = soup_message_body_flatten (msg->request_body);
body = g_string_append_len (body, request->data,
request->length);
g_string_append_printf (body,
"\r\n--cut-here\n");
soup_buffer_free (request);
soup_message_body_append (client_data->client_msg->response_body,
SOUP_MEMORY_TAKE,
body->str, body->len);
g_string_free (body, FALSE);
soup_server_unpause_message (client_data->server, client_data->client_msg);
}
if (finish_callback) {
g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
message_finish,
message_data,
message_destroy);
} else {
g_object_unref (msg);
message_destroy (message_data);
}
}
static void
list_albums_ready_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
PicasaWebService *self = user_data;
GSimpleAsyncResult *result;
SoupBuffer *body;
DomDocument *doc;
GError *error = NULL;
result = _web_service_get_result (WEB_SERVICE (self));
if (msg->status_code != 200) {
g_simple_async_result_set_error (result,
SOUP_HTTP_ERROR,
msg->status_code,
"%s",
soup_status_get_phrase (msg->status_code));
g_simple_async_result_complete_in_idle (result);
return;
}
body = soup_message_body_flatten (msg->response_body);
doc = dom_document_new ();
if (dom_document_load (doc, body->data, body->length, &error)) {
DomElement *feed_node;
GList *albums = NULL;
feed_node = DOM_ELEMENT (doc)->first_child;
while ((feed_node != NULL) && g_strcmp0 (feed_node->tag_name, "feed") != 0)
feed_node = feed_node->next_sibling;
if (feed_node != NULL) {
DomElement *node;
PicasaWebAlbum *album;
album = NULL;
for (node = feed_node->first_child;
node != NULL;
node = node->next_sibling)
{
if (g_strcmp0 (node->tag_name, "entry") == 0) { /* read the album data */
if (album != NULL)
albums = g_list_prepend (albums, album);
album = picasa_web_album_new ();
dom_domizable_load_from_element (DOM_DOMIZABLE (album), node);
}
else if (g_strcmp0 (node->tag_name, "gphoto:quotalimit") == 0) {
self->priv->quota_limit = g_ascii_strtoull (dom_element_get_inner_text (node), NULL, 10);
}
else if (g_strcmp0 (node->tag_name, "gphoto:quotacurrent") == 0) {
self->priv->quota_used = g_ascii_strtoull (dom_element_get_inner_text (node), NULL, 10);
}
}
if (album != NULL)
albums = g_list_prepend (albums, album);
}
albums = g_list_reverse (albums);
g_simple_async_result_set_op_res_gpointer (result, albums, (GDestroyNotify) _g_object_list_unref);
}
else {
g_simple_async_result_set_from_error (result, error);
g_error_free (error);
}
g_simple_async_result_complete_in_idle (result);
g_object_unref (doc);
soup_buffer_free (body);
}
static void
list_photos_ready_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
PicasaWebService *self = user_data;
GSimpleAsyncResult *result;
SoupBuffer *body;
DomDocument *doc;
GError *error = NULL;
result = _web_service_get_result (WEB_SERVICE (self));
if (msg->status_code != 200) {
g_simple_async_result_set_error (result,
SOUP_HTTP_ERROR,
msg->status_code,
"%s",
soup_status_get_phrase (msg->status_code));
g_simple_async_result_complete_in_idle (result);
return;
}
body = soup_message_body_flatten (msg->response_body);
doc = dom_document_new ();
if (dom_document_load (doc, body->data, body->length, &error)) {
DomElement *feed_node;
GList *photos = NULL;
feed_node = DOM_ELEMENT (doc)->first_child;
while ((feed_node != NULL) && g_strcmp0 (feed_node->tag_name, "feed") != 0)
feed_node = feed_node->next_sibling;
if (feed_node != NULL) {
DomElement *node;
PicasaWebPhoto *photo;
photo = NULL;
for (node = feed_node->first_child;
node != NULL;
node = node->next_sibling)
{
if (g_strcmp0 (node->tag_name, "entry") == 0) { /* read the photo data */
if (photo != NULL)
photos = g_list_prepend (photos, photo);
photo = picasa_web_photo_new ();
dom_domizable_load_from_element (DOM_DOMIZABLE (photo), node);
}
}
if (photo != NULL)
photos = g_list_prepend (photos, photo);
}
photos = g_list_reverse (photos);
g_simple_async_result_set_op_res_gpointer (result, photos, (GDestroyNotify) _g_object_list_unref);
}
else {
g_simple_async_result_set_from_error (result, error);
g_error_free (error);
}
g_simple_async_result_complete_in_idle (result);
g_object_unref (doc);
soup_buffer_free (body);
}
static void
handle_received_chunk (SoupMessage * msg, SoupBuffer * chunk,
SnraClient * client)
{
const gchar *ptr;
gsize length;
SnraClientFlags flag = get_flag_from_msg (msg);
if (client->was_connected & flag) {
g_print ("Successfully connected %s to server %s:%d\n",
flag == SNRA_CLIENT_PLAYER ? "player" : "controller",
client->connected_server, client->connected_port);
client->was_connected |= flag;
}
/* Successful server connection, stop avahi discovery */
if (client->avahi_client) {
avahi_client_free (client->avahi_client);
client->avahi_sb = NULL;
client->avahi_client = NULL;
}
if (client->json == NULL)
client->json = json_parser_new ();
#if 0
{
gchar *tmp = g_strndup (chunk->data, chunk->length);
g_print ("%s\n", tmp);
g_free (tmp);
}
#endif
ptr = memchr (chunk->data, '\0', chunk->length);
if (!ptr)
return;
/* Save remaining portion */
ptr += 1;
length =(chunk->length - (ptr - chunk->data));
chunk = soup_message_body_flatten (msg->response_body);
if (json_parser_load_from_data (client->json, chunk->data, chunk->length,
NULL)) {
JsonNode *root = json_parser_get_root (client->json);
GstStructure *s = snra_json_to_gst_structure (root);
if (s == NULL)
goto end; /* Invalid chunk */
if (flag == SNRA_CLIENT_PLAYER)
handle_player_message (client, s);
else
handle_controller_message (client, s);
gst_structure_free (s);
}
end:
soup_message_body_truncate (msg->response_body);
/* Put back remaining part */
if (length)
soup_message_body_append (msg->response_body, SOUP_MEMORY_COPY, ptr, length);
}
static void
handle_player_info (G_GNUC_UNUSED SoupSession *session, SoupMessage *msg,
SnraClient *client)
{
SoupBuffer *buffer;
if (msg->status_code < 200 || msg->status_code >= 300)
return;
buffer = soup_message_body_flatten (msg->response_body);
if (json_parser_load_from_data (client->json, buffer->data, buffer->length,
NULL)) {
const GValue *v1;
GArray *player_info = NULL;
gsize i;
JsonNode *root = json_parser_get_root (client->json);
GstStructure *s1 = snra_json_to_gst_structure (root);
if (s1 == NULL)
return; /* Invalid chunk */
v1 = gst_structure_get_value (s1, "player-clients");
if (!GST_VALUE_HOLDS_ARRAY (v1))
goto failed;
player_info = g_array_sized_new (TRUE, TRUE,
sizeof (SnraPlayerInfo), gst_value_array_get_size (v1));
for (i = 0; i < gst_value_array_get_size (v1); i++) {
SnraPlayerInfo info;
const GValue *v2 = gst_value_array_get_value (v1, i);
const GstStructure *s2;
gint64 client_id;
if (!GST_VALUE_HOLDS_STRUCTURE (v2))
goto failed;
s2 = gst_value_get_structure (v2);
if (!snra_json_structure_get_int64 (s2, "client-id", &client_id))
goto failed;
info.id = client_id;
if (!snra_json_structure_get_boolean (s2, "enabled", &info.enabled))
goto failed;
if (!snra_json_structure_get_double (s2, "volume", &info.volume))
goto failed;
if (!(info.host = g_strdup (gst_structure_get_string (s2, "host"))))
goto failed;
g_array_append_val (player_info, info);
}
free_player_info (client->player_info);
client->player_info = player_info;
player_info = NULL;
g_signal_emit (client, signals[SIGNAL_PLAYER_INFO_CHANGED], 0);
failed:
if (player_info)
free_player_info (player_info);
gst_structure_free (s1);
}
}