static void
gst_soup_http_src_parse_status (SoupMessage * msg, GstSoupHTTPSrc * src)
{
if (SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code)) {
switch (msg->status_code) {
case SOUP_STATUS_CANT_RESOLVE:
case SOUP_STATUS_CANT_RESOLVE_PROXY:
SOUP_HTTP_SRC_ERROR (src, msg, RESOURCE, NOT_FOUND,
_("Could not resolve server name."));
src->ret = GST_FLOW_ERROR;
break;
case SOUP_STATUS_CANT_CONNECT:
case SOUP_STATUS_CANT_CONNECT_PROXY:
SOUP_HTTP_SRC_ERROR (src, msg, RESOURCE, OPEN_READ,
_("Could not establish connection to server."));
src->ret = GST_FLOW_ERROR;
break;
case SOUP_STATUS_SSL_FAILED:
SOUP_HTTP_SRC_ERROR (src, msg, RESOURCE, OPEN_READ,
_("Secure connection setup failed."));
src->ret = GST_FLOW_ERROR;
break;
case SOUP_STATUS_IO_ERROR:
SOUP_HTTP_SRC_ERROR (src, msg, RESOURCE, READ,
_("A network error occured, or the server closed the connection "
"unexpectedly."));
src->ret = GST_FLOW_ERROR;
break;
case SOUP_STATUS_MALFORMED:
SOUP_HTTP_SRC_ERROR (src, msg, RESOURCE, READ,
_("Server sent bad data."));
src->ret = GST_FLOW_ERROR;
break;
case SOUP_STATUS_CANCELLED:
/* No error message when interrupted by program. */
break;
}
} else if (SOUP_STATUS_IS_CLIENT_ERROR (msg->status_code) ||
SOUP_STATUS_IS_REDIRECTION (msg->status_code) ||
SOUP_STATUS_IS_SERVER_ERROR (msg->status_code)) {
/* Report HTTP error. */
/* FIXME: reason_phrase is not translated and not suitable for user
* error dialog according to libsoup documentation.
* FIXME: error code (OPEN_READ vs. READ) should depend on http status? */
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
("%s", msg->reason_phrase),
("%s (%d), URL: %s", msg->reason_phrase, msg->status_code,
src->location));
src->ret = GST_FLOW_ERROR;
}
}
const char *
network_strerror (gint netstatus, gint httpstatus)
{
const gchar *tmp = NULL;
int status = netstatus?netstatus:httpstatus;
switch (status) {
/* Some libsoup transport errors */
case SOUP_STATUS_NONE: tmp = _("The update request was cancelled"); break;
case SOUP_STATUS_CANT_RESOLVE: tmp = _("Unable to resolve destination host name"); break;
case SOUP_STATUS_CANT_RESOLVE_PROXY: tmp = _("Unable to resolve proxy host name"); break;
case SOUP_STATUS_CANT_CONNECT: tmp = _("Unable to connect to remote host"); break;
case SOUP_STATUS_CANT_CONNECT_PROXY: tmp = _("Unable to connect to proxy"); break;
case SOUP_STATUS_SSL_FAILED: tmp = _("A network error occurred, or the other end closed the connection unexpectedly"); break;
/* http 3xx redirection */
case SOUP_STATUS_MOVED_PERMANENTLY: tmp = _("The resource moved permanently to a new location"); break;
/* http 4xx client error */
case SOUP_STATUS_UNAUTHORIZED: tmp = _("You are unauthorized to download this feed. Please update your username and "
"password in the feed properties dialog box"); break;
case SOUP_STATUS_PAYMENT_REQUIRED: tmp = _("Payment required"); break;
case SOUP_STATUS_FORBIDDEN: tmp = _("You're not allowed to access this resource"); break;
case SOUP_STATUS_NOT_FOUND: tmp = _("Resource Not Found"); break;
case SOUP_STATUS_METHOD_NOT_ALLOWED: tmp = _("Method Not Allowed"); break;
case SOUP_STATUS_NOT_ACCEPTABLE: tmp = _("Not Acceptable"); break;
case SOUP_STATUS_PROXY_UNAUTHORIZED: tmp = _("Proxy authentication required"); break;
case SOUP_STATUS_REQUEST_TIMEOUT: tmp = _("Request timed out"); break;
case SOUP_STATUS_GONE: tmp = _("Gone. Resource doesn't exist. Please unsubscribe!"); break;
}
if (!tmp) {
if (SOUP_STATUS_IS_TRANSPORT_ERROR (status)) {
tmp = _("There was an internal error in the update process");
} else if (SOUP_STATUS_IS_REDIRECTION (status)) {
tmp = _("Feed not available: Server requested unsupported redirection!");
} else if (SOUP_STATUS_IS_CLIENT_ERROR (status)) {
tmp = _("Client Error");
} else if (SOUP_STATUS_IS_SERVER_ERROR (status)) {
tmp = _("Server Error");
} else {
tmp = _("An unknown networking error happened!");
}
}
g_assert (tmp);
return tmp;
}
static void
message_complete (SoupSession *sesison, SoupMessage *msg, gpointer user_data)
{
//g_print ("message_complete->enter\n");
MessageData *message_data = (MessageData *) user_data;
static gint delay = 2;
if (SOUP_STATUS_IS_SUCCESSFUL (message_data->msg->status_code) ||
SOUP_STATUS_IS_CLIENT_ERROR (message_data->msg->status_code)) {
delay = 2;
if (message_data->finish_callback) {
message_data->finish_callback (message_data->session,
message_data->msg,
message_data->user_data);
}
g_slice_free (MessageData, message_data);
//g_print ("message_complete->add message_handler\n");
g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
message_handler,
NULL,
NULL);
} else {
// failed to send message
delay = (gint ) (delay * 1.5);
// Don't wait more than 10 minutes between retries.
if (delay > 625) {
delay = 625;
}
gchar *uri = soup_uri_to_string(soup_message_get_uri(message_data->msg), TRUE);
g_warning("%s: Unable to send %s, delaying %d seconds..",
message_data->msg->reason_phrase,
uri,
delay);
g_free(uri);
// push it back onto the queue.
(void)g_object_ref (message_data->msg);
g_queue_push_head (message_queue, message_data);
//g_print ("message_complete->add delay_handler\n");
g_timeout_add_seconds_full (G_PRIORITY_DEFAULT_IDLE,
delay,
message_handler,
NULL,
NULL);
}
//g_print ("message_complete->exit\n");
}
static void
aws_s3_client_read_got_headers (SoupMessage *message,
GTask *task)
{
AwsS3Client *client;
g_assert (SOUP_IS_MESSAGE(message));
g_assert (G_IS_TASK (task));
client = g_task_get_source_object (task);
g_assert (AWS_IS_S3_CLIENT (client));
if (!SOUP_STATUS_IS_SUCCESSFUL (message->status_code))
{
/*
* Extract the given error type.
*/
if (message->status_code == SOUP_STATUS_NOT_FOUND)
{
g_task_return_new_error (task,
AWS_S3_CLIENT_ERROR,
AWS_S3_CLIENT_ERROR_NOT_FOUND,
"The requested object was not found.");
soup_session_cancel_message (SOUP_SESSION (client), message, message->status_code);
}
else if (SOUP_STATUS_IS_CLIENT_ERROR (message->status_code))
{
g_task_return_new_error (task,
AWS_S3_CLIENT_ERROR,
AWS_S3_CLIENT_ERROR_BAD_REQUEST,
"The request was invalid.");
soup_session_cancel_message (SOUP_SESSION (client), message, message->status_code);
}
else
{
g_task_return_new_error (task,
AWS_S3_CLIENT_ERROR,
AWS_S3_CLIENT_ERROR_UNKNOWN,
"An unknown error occurred.");
soup_session_cancel_message (SOUP_SESSION (client), message, SOUP_STATUS_CANCELLED);
}
}
}
static gboolean
is_authorization_error (GError *error)
{
gboolean ret;
g_return_val_if_fail (error != NULL, FALSE);
ret = FALSE;
if (error->domain == REST_PROXY_ERROR || error->domain == SOUP_HTTP_ERROR)
{
if (SOUP_STATUS_IS_CLIENT_ERROR (error->code))
ret = TRUE;
}
else if (error->domain == GOA_ERROR)
{
if (error->code == GOA_ERROR_NOT_AUTHORIZED)
ret = TRUE;
}
return ret;
}
