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; }