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
push_gcm_client_deliver_cb (SoupSession *session,
SoupMessage *message,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
const gchar *str;
JsonObject *obj;
JsonParser *p = NULL;
JsonArray *ar;
JsonNode *root;
JsonNode *node;
gboolean removed;
GError *error = NULL;
GList *list;
gsize length;
guint i;
ENTRY;
g_assert(SOUP_IS_SESSION(session));
g_assert(SOUP_IS_MESSAGE(message));
g_assert(G_IS_SIMPLE_ASYNC_RESULT(simple));
switch (message->status_code) {
case SOUP_STATUS_OK:
break;
case SOUP_STATUS_BAD_REQUEST:
/*
* TODO: Log that there was a JSON encoding error likely.
*/
break;
case SOUP_STATUS_UNAUTHORIZED:
g_simple_async_result_set_error(simple,
SOUP_HTTP_ERROR,
message->status_code,
_("GCM request unauthorized."));
GOTO(failure);
default:
if (SOUP_STATUS_IS_SERVER_ERROR(message->status_code) &&
(str = soup_message_headers_get_one(message->response_headers,
"Retry-After"))) {
/*
* TODO: Implement exponential back-off.
*/
}
g_simple_async_result_set_error(simple,
SOUP_HTTP_ERROR,
message->status_code,
_("Unknown failure occurred."));
break;
}
if (!message->response_body->data || !message->response_body->length) {
g_simple_async_result_set_error(simple,
SOUP_HTTP_ERROR,
SOUP_STATUS_IO_ERROR,
_("No data was received from GCM."));
GOTO(failure);
}
p = json_parser_new();
if (!json_parser_load_from_data(p,
message->response_body->data,
message->response_body->length,
&error)) {
g_simple_async_result_take_error(simple, error);
GOTO(failure);
}
list = g_object_get_data(G_OBJECT(simple), "identities");
if ((root = json_parser_get_root(p)) &&
JSON_NODE_HOLDS_OBJECT(root) &&
(obj = json_node_get_object(root)) &&
json_object_has_member(obj, "results") &&
(node = json_object_get_member(obj, "results")) &&
JSON_NODE_HOLDS_ARRAY(node) &&
(ar = json_node_get_array(node))) {
length = json_array_get_length(ar);
for (i = 0; i < length && list; i++, list = list->next) {
/*
* TODO: Handle the case that the device_token has been renamed.
*/
removed = FALSE;
if ((obj = json_array_get_object_element(ar, i)) &&
json_object_has_member(obj, "error") &&
(node = json_object_get_member(obj, "error")) &&
JSON_NODE_HOLDS_VALUE(node) &&
(str = json_node_get_string(node))) {
if (!g_strcmp0(str, "MissingRegistration")) {
removed = TRUE;
} else if (!g_strcmp0(str, "InvalidRegistration")) {
removed = TRUE;
} else if (!g_strcmp0(str, "MismatchSenderId")) {
} else if (!g_strcmp0(str, "NotRegistered")) {
removed = TRUE;
} else if (!g_strcmp0(str, "MessageTooBig")) {
} else if (!g_strcmp0(str, "InvalidDataKey")) {
} else if (!g_strcmp0(str, "InvalidTtl")) {
}
if (removed) {
g_assert(PUSH_IS_GCM_IDENTITY(list->data));
g_signal_emit(session, gSignals[IDENTITY_REMOVED], 0, list->data);
}
}
}
}
g_simple_async_result_set_op_res_gboolean(simple, TRUE);
failure:
g_simple_async_result_complete_in_idle(simple);
g_object_unref(simple);
if (p) {
g_object_unref(p);
}
EXIT;
}
