+2003-09-03 Dan Winship <danw@ximian.com>
+
+ * libsoup/soup-status.h: Renamed from soup-error.h, with types
+ and defines renamed accordingly.
+
+ * libsoup/soup-message.h (SoupMessage): Rename errorcode to
+ status_code and errorphrase to reason_phrase. Remove errorclass.
+ (SOUP_MESSAGE_IS_ERROR): Remove this. You can't classify redirects
+ as being either "errors" or "not errors", so its semantics are
+ guaranteed to be wrong sometimes.
+
+ * libsoup/soup-message.c (soup_message_set_status,
+ soup_message_set_status_full): Renamed
+
+ * libsoup/soup-message-handlers.c
+ (soup_message_add_status_code_handler,
+ soup_message_add_status_class_handler): Rename.
+
+ * libsoup/soup-session.c (soup_session_send_message): Make this
+ return a status code rather than a status class.
+
+ * libsoup/soup-message-private.h (SoupMessagePrivate): Remove some
+ unrelated unused fields (retries, callback, user_data).
+
+ * ...: Updates
+
2003-09-02 Dan Winship <danw@ximian.com>
* libsoup/soup-session.c: First draft at the new object to
soup-address.h \
soup-connection.h \
soup-context.h \
- soup-error.h \
soup-headers.h \
soup-message.h \
soup-method.h \
soup-server.h \
soup-session.h \
soup-socket.h \
+ soup-status.h \
soup-types.h \
soup-uri.h
soup-context.c \
soup-dns.h \
soup-dns.c \
- soup-error.c \
soup-gnutls.h \
soup-gnutls.c \
soup-headers.c \
soup-socket.c \
soup-ssl.h \
soup-ssl.c \
+ soup-status.c \
soup-uri.c
EXTRA_DIST= soup-marshal.list
static void
-got_addr (SoupDNSHandle handle, SoupKnownErrorCode status,
- struct hostent *h, gpointer data)
+got_addr (SoupDNSHandle handle, guint status, struct hostent *h, gpointer data)
{
SoupAddress *addr = data;
addr->priv->lookup = NULL;
- if (status == SOUP_ERROR_OK) {
+ if (status == SOUP_STATUS_OK) {
if (!SOUP_ADDRESS_FAMILY_IS_VALID (h->h_addrtype)) {
- status = SOUP_ERROR_CANT_RESOLVE;
+ status = SOUP_STATUS_CANT_RESOLVE;
goto done;
}
if (SOUP_ADDRESS_FAMILY_DATA_SIZE (h->h_addrtype) != h->h_length) {
- status = SOUP_ERROR_MALFORMED;
+ status = SOUP_STATUS_MALFORMED;
goto done;
}
}
static void
-got_name (SoupDNSHandle handle, SoupKnownErrorCode status,
- struct hostent *h, gpointer data)
+got_name (SoupDNSHandle handle, guint status, struct hostent *h, gpointer data)
{
SoupAddress *addr = data;
addr->priv->lookup = NULL;
- if (status == SOUP_ERROR_OK)
+ if (status == SOUP_STATUS_OK)
addr->priv->name = g_strdup (h->h_name);
g_signal_emit (addr, signals[DNS_RESULT], 0, status);
SoupAddress *addr = user_data;
addr->priv->idle_id = 0;
- g_signal_emit (addr, signals[DNS_RESULT], 0, SOUP_ERROR_OK);
+ g_signal_emit (addr, signals[DNS_RESULT], 0, SOUP_STATUS_OK);
return FALSE;
}
GObjectClass parent_class;
/* signals */
- void (*dns_result) (SoupAddress *addr, SoupKnownErrorCode);
+ void (*dns_result) (SoupAddress *addr, guint status);
} SoupAddressClass;
typedef enum {
guint port);
typedef void (*SoupAddressCallback) (SoupAddress *addr,
- SoupKnownErrorCode status,
+ guint status,
gpointer data);
void soup_address_resolve (SoupAddress *addr,
SoupAddressCallback cb,
}
static void
-socket_connected (SoupSocket *sock, SoupKnownErrorCode status, gpointer conn)
+socket_connected (SoupSocket *sock, guint status, gpointer conn)
{
g_signal_emit (conn, signals[CONNECT_RESULT], 0, status);
}
}
static void
-proxy_socket_connected (SoupSocket *sock, SoupKnownErrorCode status, gpointer conn)
+proxy_socket_connected (SoupSocket *sock, guint status, gpointer conn)
{
- if (status == SOUP_ERROR_CANT_RESOLVE)
- status = SOUP_ERROR_CANT_RESOLVE_PROXY;
- else if (status == SOUP_ERROR_CANT_CONNECT)
- status = SOUP_ERROR_CANT_CONNECT_PROXY;
+ if (status == SOUP_STATUS_CANT_RESOLVE)
+ status = SOUP_STATUS_CANT_RESOLVE_PROXY;
+ else if (status == SOUP_STATUS_CANT_CONNECT)
+ status = SOUP_STATUS_CANT_CONNECT_PROXY;
g_signal_emit (conn, signals[CONNECT_RESULT], 0, status);
}
{
SoupConnection *conn = user_data;
- if (SOUP_ERROR_IS_SUCCESSFUL (msg->errorcode))
+ if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))
soup_socket_start_ssl (conn->priv->socket);
- proxy_socket_connected (NULL, msg->errorcode, conn);
+ proxy_socket_connected (NULL, msg->status_code, conn);
g_object_unref (msg);
}
tunnel_failed (SoupMessage *msg, gpointer conn)
{
g_signal_emit (conn, signals[CONNECT_RESULT], 0,
- SOUP_ERROR_CANT_CONNECT);
+ SOUP_STATUS_CANT_CONNECT);
g_object_unref (msg);
}
static void
-tunnel_socket_connected (SoupSocket *sock, SoupKnownErrorCode status,
- gpointer user_data)
+tunnel_socket_connected (SoupSocket *sock, guint status, gpointer user_data)
{
SoupConnection *conn = user_data;
SoupMessage *connect_msg;
- if (!SOUP_ERROR_IS_SUCCESSFUL (status)) {
+ if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
socket_connected (sock, status, conn);
return;
}
GObjectClass parent_class;
/* signals */
- void (*connect_result) (SoupConnection *, SoupKnownErrorCode);
+ void (*connect_result) (SoupConnection *, guint);
void (*disconnected) (SoupConnection *);
} SoupConnectionClass;
GType soup_connection_get_type (void);
-typedef void (*SoupConnectionCallback) (SoupConnection *sock,
- SoupKnownErrorCode status,
- gpointer data);
+typedef void (*SoupConnectionCallback) (SoupConnection *sock,
+ guint status,
+ gpointer data);
-SoupConnection *soup_connection_new (const SoupUri *uri,
+SoupConnection *soup_connection_new (const SoupUri *uri,
SoupConnectionCallback,
- gpointer data);
-SoupConnection *soup_connection_new_proxy (const SoupUri *proxy_uri,
+ gpointer data);
+SoupConnection *soup_connection_new_proxy (const SoupUri *proxy_uri,
SoupConnectionCallback,
- gpointer data);
-SoupConnection *soup_connection_new_tunnel (const SoupUri *proxy_uri,
- const SoupUri *dest_uri,
+ gpointer data);
+SoupConnection *soup_connection_new_tunnel (const SoupUri *proxy_uri,
+ const SoupUri *dest_uri,
SoupConnectionCallback,
- gpointer data);
+ gpointer data);
gboolean soup_connection_is_proxy (SoupConnection *conn);
static gboolean retry_connect_timeout_cb (struct SoupConnectData *data);
static void
-soup_context_connect_cb (SoupConnection *conn,
- SoupKnownErrorCode status,
- gpointer user_data)
+soup_context_connect_cb (SoupConnection *conn,
+ guint status,
+ gpointer user_data)
{
struct SoupConnectData *data = user_data;
SoupContext *ctx = data->ctx;
switch (status) {
- case SOUP_ERROR_OK:
+ case SOUP_STATUS_OK:
g_signal_connect (conn, "disconnected",
G_CALLBACK (connection_disconnected),
ctx->priv->server);
break;
- case SOUP_ERROR_CANT_RESOLVE:
+ case SOUP_STATUS_CANT_RESOLVE:
connection_count--;
g_object_unref (conn);
break;
if (!soup_connection_is_in_use (conn) &&
port == ctx->priv->uri->port) {
/* Issue success callback */
- (*cb) (ctx, SOUP_ERROR_OK, conn, user_data);
+ (*cb) (ctx, SOUP_STATUS_OK, conn, user_data);
return TRUE;
}
g_return_val_if_fail (SOUP_IS_CONTEXT (ctx), FALSE);
g_return_val_if_fail (msg != NULL, FALSE);
- if (msg->errorcode == SOUP_ERROR_PROXY_UNAUTHORIZED) {
+ if (msg->status_code == SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED) {
headers = soup_message_get_header_list (msg->response_headers,
"Proxy-Authenticate");
} else {
GType soup_context_get_type (void);
-typedef void (*SoupConnectCallbackFn) (SoupContext *ctx,
- SoupKnownErrorCode err,
- SoupConnection *conn,
- gpointer user_data);
+typedef void (*SoupConnectCallbackFn) (SoupContext *ctx,
+ guint status,
+ SoupConnection *conn,
+ gpointer user_data);
typedef gpointer SoupConnectId;
info = entry->lookups->data;
entry->lookups = g_slist_remove (entry->lookups, info);
- (*info->func) (info, entry->h ? SOUP_ERROR_OK : SOUP_ERROR_CANT_RESOLVE, entry->h, info->data);
+ (*info->func) (info, entry->h ? SOUP_STATUS_OK : SOUP_STATUS_CANT_RESOLVE, entry->h, info->data);
g_free (info);
}
#include <sys/socket.h>
#include <netdb.h>
-#include <libsoup/soup-error.h>
-
typedef gpointer SoupDNSHandle;
typedef void (*SoupGetHostByFn) (SoupDNSHandle handle,
- SoupKnownErrorCode status,
+ guint status,
struct hostent *h,
gpointer user_data);
+++ /dev/null
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*
- * soup-error.c: Errorcode description and class lookup
- *
- * Authors:
- * Alex Graveley (alex@ximian.com)
- *
- * Copyright (C) 2001-2002, Ximian, Inc.
- */
-
-#include <glib.h>
-
-#include "soup-error.h"
-
-struct {
- guint sc;
- const gchar *phrase;
-} error_code_phrases [] = {
- /*
- * SOUP_ERROR_CLASS_TRANSPORT
- */
- { SOUP_ERROR_CANCELLED, "Cancelled" },
- { SOUP_ERROR_CANT_RESOLVE, "Cannot resolve hostname" },
- { SOUP_ERROR_CANT_RESOLVE_PROXY, "Cannot resolve proxy hostname" },
- { SOUP_ERROR_CANT_CONNECT, "Cannot connect to destination" },
- { SOUP_ERROR_CANT_CONNECT_PROXY, "Cannot connect to proxy" },
- { SOUP_ERROR_IO, "Connection terminated "
- "unexpectedly" },
- { SOUP_ERROR_MALFORMED, "Message Corrupt" },
- { SOUP_ERROR_SSL_FAILED, "SSL handshake failed" },
-
- /*
- * SOUP_ERROR_CLASS_INFORMATIONAL
- */
- { SOUP_ERROR_CONTINUE, "Continue" },
- { SOUP_ERROR_PROTOCOL_SWITCH, "Protocol Switch" },
- { SOUP_ERROR_DAV_PROCESSING, "Processing" },
-
- /*
- * SOUP_ERROR_CLASS_SUCCESS
- */
- { SOUP_ERROR_OK, "OK" },
- { SOUP_ERROR_CREATED, "Created" },
- { SOUP_ERROR_ACCEPTED, "Accepted" },
- { SOUP_ERROR_NON_AUTHORITATIVE, "Non-Authoritative" },
- { SOUP_ERROR_NO_CONTENT, "No Content" },
- { SOUP_ERROR_RESET_CONTENT, "Reset Content" },
- { SOUP_ERROR_PARTIAL_CONTENT, "Partial Content" },
- { SOUP_ERROR_DAV_MULTISTATUS, "Multi-Status" },
-
- /*
- * SOUP_ERROR_CLASS_REDIRECT
- */
- { SOUP_ERROR_MULTIPLE_CHOICES, "Multiple Choices" },
- { SOUP_ERROR_MOVED_PERMANENTLY, "Moved Permanently" },
- { SOUP_ERROR_FOUND, "Found" },
- { SOUP_ERROR_SEE_OTHER, "See Other" },
- { SOUP_ERROR_NOT_MODIFIED, "Not Modified" },
- { SOUP_ERROR_USE_PROXY, "Use Proxy" },
- { SOUP_ERROR_TEMPORARY_REDIRECT, "Temporary Redirect" },
-
- /*
- * SOUP_ERROR_CLASS_CLIENT_ERROR
- */
- { SOUP_ERROR_BAD_REQUEST, "Bad Request" },
- { SOUP_ERROR_UNAUTHORIZED, "Unauthorized" },
- { SOUP_ERROR_PAYMENT_REQUIRED, "Payment Required" },
- { SOUP_ERROR_FORBIDDEN, "Forbidden" },
- { SOUP_ERROR_NOT_FOUND, "Not Found" },
- { SOUP_ERROR_METHOD_NOT_ALLOWED, "Method Not Allowed" },
- { SOUP_ERROR_NOT_ACCEPTABLE, "Not Acceptable" },
- { SOUP_ERROR_PROXY_UNAUTHORIZED, "Proxy Unauthorized" },
- { SOUP_ERROR_TIMED_OUT, "Timed Out" },
- { SOUP_ERROR_CONFLICT, "Conflict" },
- { SOUP_ERROR_GONE, "Gone" },
- { SOUP_ERROR_LENGTH_REQUIRED, "Length Required" },
- { SOUP_ERROR_PRECONDITION_FAILED, "Precondition Failed" },
- { SOUP_ERROR_BODY_TOO_LARGE, "Entity Body Too Large" },
- { SOUP_ERROR_URI_TOO_LARGE, "Request-URI Too Large" },
- { SOUP_ERROR_UNKNOWN_MEDIA_TYPE, "Unknown Media Type" },
- { SOUP_ERROR_INVALID_RANGE, "Invalid Range" },
- { SOUP_ERROR_EXPECTATION_FAILED, "Expectation Failed" },
- { SOUP_ERROR_DAV_UNPROCESSABLE, "Unprocessable Entity" },
- { SOUP_ERROR_DAV_LOCKED, "Locked" },
- { SOUP_ERROR_DAV_DEPENDENCY_FAILED, "Dependency Failed" },
-
- /*
- * SOUP_ERROR_CLASS_SERVER_ERROR
- */
- { SOUP_ERROR_INTERNAL, "Internal Server Error" },
- { SOUP_ERROR_NOT_IMPLEMENTED, "Not Implemented" },
- { SOUP_ERROR_BAD_GATEWAY, "Bad Gateway" },
- { SOUP_ERROR_SERVICE_UNAVAILABLE, "Service Unavailable" },
- { SOUP_ERROR_GATEWAY_TIMEOUT, "Gateway Timeout" },
- { SOUP_ERROR_VERSION_UNSUPPORTED, "Version Unsupported" },
- { SOUP_ERROR_DAV_OUT_OF_SPACE, "Out Of Space" },
-
- { 0 }
-};
-
-const gchar *
-soup_error_get_phrase (SoupKnownErrorCode errcode)
-{
- gint i;
-
- for (i = 0; error_code_phrases [i].sc; i++) {
- if (error_code_phrases [i].sc == (guint) errcode)
- return error_code_phrases [i].phrase;
- }
-
- return "Unknown Error";
-}
-
-SoupErrorClass
-soup_error_get_class (SoupKnownErrorCode errcode)
-{
- if (errcode < 100) return SOUP_ERROR_CLASS_TRANSPORT;
- if (errcode < 200) return SOUP_ERROR_CLASS_INFORMATIONAL;
- if (errcode < 300) return SOUP_ERROR_CLASS_SUCCESS;
- if (errcode < 400) return SOUP_ERROR_CLASS_REDIRECT;
- if (errcode < 500) return SOUP_ERROR_CLASS_CLIENT_ERROR;
- if (errcode < 600) return SOUP_ERROR_CLASS_SERVER_ERROR;
- return SOUP_ERROR_CLASS_UNKNOWN;
-}
+++ /dev/null
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/*
- * soup-error.h: HTTP error code and error class definitions
- *
- * Copyright (C) 2001-2003, Ximian, Inc.
- */
-
-#ifndef SOUP_ERROR_H
-#define SOUP_ERROR_H 1
-
-typedef enum {
- SOUP_ERROR_CLASS_TRANSPORT = 1,
- SOUP_ERROR_CLASS_INFORMATIONAL,
- SOUP_ERROR_CLASS_SUCCESS,
- SOUP_ERROR_CLASS_REDIRECT,
- SOUP_ERROR_CLASS_CLIENT_ERROR,
- SOUP_ERROR_CLASS_SERVER_ERROR,
- SOUP_ERROR_CLASS_UNKNOWN,
- SOUP_ERROR_CLASS_HANDLER,
-} SoupErrorClass;
-
-#define SOUP_ERROR_IS_TRANSPORT(x) ((x) > 0 && (x) < 100)
-#define SOUP_ERROR_IS_INFORMATIONAL(x) ((x) >= 100 && (x) < 200)
-#define SOUP_ERROR_IS_SUCCESSFUL(x) ((x) >= 200 && (x) < 300)
-#define SOUP_ERROR_IS_REDIRECTION(x) ((x) >= 300 && (x) < 400)
-#define SOUP_ERROR_IS_CLIENT_ERROR(x) ((x) >= 400 && (x) < 500)
-#define SOUP_ERROR_IS_SERVER_ERROR(x) ((x) >= 500 && (x) < 600)
-#define SOUP_ERROR_IS_UNKNOWN(x) ((x) >= 600)
-
-typedef enum {
- /*
- * Transport Errors
- */
- SOUP_ERROR_CANCELLED = 1,
- SOUP_ERROR_CANT_RESOLVE,
- SOUP_ERROR_CANT_RESOLVE_PROXY,
- SOUP_ERROR_CANT_CONNECT,
- SOUP_ERROR_CANT_CONNECT_PROXY,
- SOUP_ERROR_IO,
- SOUP_ERROR_MALFORMED,
- SOUP_ERROR_SSL_FAILED,
-
- /*
- * HTTP Response Codes
- */
- SOUP_ERROR_CONTINUE = 100,
- SOUP_ERROR_PROTOCOL_SWITCH = 101,
- SOUP_ERROR_DAV_PROCESSING = 102,
-
- SOUP_ERROR_OK = 200,
- SOUP_ERROR_CREATED = 201,
- SOUP_ERROR_ACCEPTED = 202,
- SOUP_ERROR_NON_AUTHORITATIVE = 203,
- SOUP_ERROR_NO_CONTENT = 204,
- SOUP_ERROR_RESET_CONTENT = 205,
- SOUP_ERROR_PARTIAL_CONTENT = 206,
- SOUP_ERROR_DAV_MULTISTATUS = 207,
-
- SOUP_ERROR_MULTIPLE_CHOICES = 300,
- SOUP_ERROR_MOVED_PERMANENTLY = 301,
- SOUP_ERROR_FOUND = 302,
- SOUP_ERROR_MOVED_TEMPORARILY = SOUP_ERROR_FOUND,
- SOUP_ERROR_SEE_OTHER = 303,
- SOUP_ERROR_NOT_MODIFIED = 304,
- SOUP_ERROR_USE_PROXY = 305,
- SOUP_ERROR_TEMPORARY_REDIRECT = 307,
-
- SOUP_ERROR_BAD_REQUEST = 400,
- SOUP_ERROR_UNAUTHORIZED = 401,
- SOUP_ERROR_PAYMENT_REQUIRED = 402,
- SOUP_ERROR_FORBIDDEN = 403,
- SOUP_ERROR_NOT_FOUND = 404,
- SOUP_ERROR_METHOD_NOT_ALLOWED = 405,
- SOUP_ERROR_NOT_ACCEPTABLE = 406,
- SOUP_ERROR_PROXY_UNAUTHORIZED = 407,
- SOUP_ERROR_TIMED_OUT = 408,
- SOUP_ERROR_CONFLICT = 409,
- SOUP_ERROR_GONE = 410,
- SOUP_ERROR_LENGTH_REQUIRED = 411,
- SOUP_ERROR_PRECONDITION_FAILED = 412,
- SOUP_ERROR_BODY_TOO_LARGE = 413,
- SOUP_ERROR_URI_TOO_LARGE = 414,
- SOUP_ERROR_UNKNOWN_MEDIA_TYPE = 415,
- SOUP_ERROR_INVALID_RANGE = 416,
- SOUP_ERROR_EXPECTATION_FAILED = 417,
- SOUP_ERROR_DAV_UNPROCESSABLE = 422,
- SOUP_ERROR_DAV_LOCKED = 423,
- SOUP_ERROR_DAV_DEPENDENCY_FAILED = 423,
-
- SOUP_ERROR_INTERNAL = 500,
- SOUP_ERROR_NOT_IMPLEMENTED = 501,
- SOUP_ERROR_BAD_GATEWAY = 502,
- SOUP_ERROR_SERVICE_UNAVAILABLE = 503,
- SOUP_ERROR_GATEWAY_TIMEOUT = 504,
- SOUP_ERROR_VERSION_UNSUPPORTED = 505,
- SOUP_ERROR_DAV_OUT_OF_SPACE = 507,
- SOUP_ERROR_NOT_EXTENDED = 510,
-} SoupKnownErrorCode;
-
-const char *soup_error_get_phrase (SoupKnownErrorCode errcode);
-SoupErrorClass soup_error_get_class (SoupKnownErrorCode errcode);
-
-#endif /*SOUP_ERROR_H*/
#include "soup-misc.h"
#include "soup-private.h"
-static SoupKnownErrorCode
+static guint
parse_response_headers (SoupMessage *req,
char *headers, guint headers_len,
SoupTransferEncoding *encoding,
if (!soup_headers_parse_response (headers, headers_len,
req->response_headers,
&version,
- &req->errorcode,
- (char **) &req->errorphrase))
- return SOUP_ERROR_MALFORMED;
+ &req->status_code,
+ (char **) &req->reason_phrase))
+ return SOUP_STATUS_MALFORMED;
meth_id = soup_method_get_id (req->method);
resp_hdrs = req->response_headers;
- req->errorclass = soup_error_get_class (req->errorcode);
-
/*
* Special case zero body handling for:
* - HEAD requests (where content-length must be ignored)
*/
if (meth_id == SOUP_METHOD_ID_HEAD ||
meth_id == SOUP_METHOD_ID_CONNECT ||
- req->errorcode == SOUP_ERROR_NO_CONTENT ||
- req->errorcode == SOUP_ERROR_RESET_CONTENT ||
- req->errorcode == SOUP_ERROR_NOT_MODIFIED ||
- req->errorclass == SOUP_ERROR_CLASS_INFORMATIONAL) {
+ req->status_code == SOUP_STATUS_NO_CONTENT ||
+ req->status_code == SOUP_STATUS_RESET_CONTENT ||
+ req->status_code == SOUP_STATUS_NOT_MODIFIED ||
+ SOUP_STATUS_IS_INFORMATIONAL (req->status_code)) {
*encoding = SOUP_TRANSFER_CONTENT_LENGTH;
*content_len = 0;
- return SOUP_ERROR_OK;
+ return SOUP_STATUS_OK;
}
/*
if (enc) {
if (g_strcasecmp (enc, "chunked") == 0) {
*encoding = SOUP_TRANSFER_CHUNKED;
- return SOUP_ERROR_OK;
+ return SOUP_STATUS_OK;
} else
- return SOUP_ERROR_MALFORMED;
+ return SOUP_STATUS_MALFORMED;
}
/*
*encoding = SOUP_TRANSFER_CONTENT_LENGTH;
len = atoi (length);
if (len < 0)
- return SOUP_ERROR_MALFORMED;
+ return SOUP_STATUS_MALFORMED;
else
*content_len = len;
}
- return SOUP_ERROR_OK;
+ return SOUP_STATUS_OK;
}
static void
typedef enum {
SOUP_HANDLER_HEADER = 1,
- SOUP_HANDLER_ERROR_CODE,
- SOUP_HANDLER_ERROR_CLASS
+ SOUP_HANDLER_STATUS_CODE,
+ SOUP_HANDLER_STATUS_CLASS
} SoupHandlerKind;
typedef struct {
SoupHandlerKind kind;
union {
- guint errorcode;
- SoupErrorClass errorclass;
- const char *header;
+ guint status_code;
+ SoupStatusClass status_class;
+ const char *header;
} data;
} SoupHandlerData;
data->data.header))
return;
break;
- case SOUP_HANDLER_ERROR_CODE:
- if (msg->errorcode != data->data.errorcode)
+ case SOUP_HANDLER_STATUS_CODE:
+ if (msg->status_code != data->data.status_code)
return;
break;
- case SOUP_HANDLER_ERROR_CLASS:
- if (msg->errorclass != data->data.errorclass)
+ case SOUP_HANDLER_STATUS_CLASS:
+ if (msg->status_code < data->data.status_class * 100 ||
+ msg->status_code >= (data->data.status_class + 1) * 100)
return;
break;
default:
*
* After running all handlers, if there is an error set or the invoke
* phase was post_body, issue the final callback.
- *
- * FIXME: If the errorcode is changed by a handler, we should restart
- * the processing.
*/
void
soup_message_run_handlers (SoupMessage *msg, SoupHandlerPhase invoke_phase)
gpointer user_data,
SoupHandlerKind kind,
const char *header,
- guint errorcode,
- guint errorclass)
+ guint status_code,
+ SoupStatusClass status_class)
{
SoupHandlerData *data;
case SOUP_HANDLER_HEADER:
data->data.header = header;
break;
- case SOUP_HANDLER_ERROR_CODE:
- data->data.errorcode = errorcode;
+ case SOUP_HANDLER_STATUS_CODE:
+ data->data.status_code = status_code;
break;
- case SOUP_HANDLER_ERROR_CLASS:
- data->data.errorclass = errorclass;
+ case SOUP_HANDLER_STATUS_CLASS:
+ data->data.status_class = status_class;
break;
default:
break;
}
void
-soup_message_add_error_code_handler (SoupMessage *msg,
- guint errorcode,
- SoupHandlerPhase phase,
- SoupCallbackFn handler_cb,
- gpointer user_data)
+soup_message_add_status_code_handler (SoupMessage *msg,
+ guint status_code,
+ SoupHandlerPhase phase,
+ SoupCallbackFn handler_cb,
+ gpointer user_data)
{
g_return_if_fail (SOUP_IS_MESSAGE (msg));
- g_return_if_fail (errorcode != 0);
+ g_return_if_fail (status_code != 0);
g_return_if_fail (handler_cb != NULL);
add_handler (msg, phase, handler_cb, user_data,
- SOUP_HANDLER_ERROR_CODE,
- NULL, errorcode, 0);
+ SOUP_HANDLER_STATUS_CODE,
+ NULL, status_code, 0);
}
void
-soup_message_add_error_class_handler (SoupMessage *msg,
- SoupErrorClass errorclass,
- SoupHandlerPhase phase,
- SoupCallbackFn handler_cb,
- gpointer user_data)
+soup_message_add_status_class_handler (SoupMessage *msg,
+ SoupStatusClass status_class,
+ SoupHandlerPhase phase,
+ SoupCallbackFn handler_cb,
+ gpointer user_data)
{
g_return_if_fail (SOUP_IS_MESSAGE (msg));
- g_return_if_fail (errorclass != 0);
+ g_return_if_fail (status_class != 0);
g_return_if_fail (handler_cb != NULL);
add_handler (msg, phase, handler_cb, user_data,
- SOUP_HANDLER_ERROR_CLASS,
- NULL, 0, errorclass);
+ SOUP_HANDLER_STATUS_CLASS,
+ NULL, 0, status_class);
}
void
return;
}
- soup_message_set_error (msg, SOUP_ERROR_IO);
+ soup_message_set_status (msg, SOUP_STATUS_IO_ERROR);
soup_message_io_finished (msg);
}
g_string_truncate (io->write_buf, 0);
if (io->mode == SOUP_MESSAGE_IO_SERVER &&
- SOUP_ERROR_IS_INFORMATIONAL (msg->errorcode)) {
- if (msg->errorcode == SOUP_ERROR_CONTINUE) {
+ SOUP_STATUS_IS_INFORMATIONAL (msg->status_code)) {
+ if (msg->status_code == SOUP_STATUS_CONTINUE) {
/* Stop and wait for the body now */
io->write_state =
SOUP_MESSAGE_IO_STATE_BLOCKING;
io_read (SoupSocket *sock, SoupMessage *msg)
{
SoupMessageIOData *io = msg->priv->io_data;
- SoupKnownErrorCode err;
+ guint status;
read_more:
switch (io->read_state) {
return;
io->read_meta_buf->len -= SOUP_MESSAGE_IO_DOUBLE_EOL_LEN;
- err = io->parse_headers_cb (msg, io->read_meta_buf->data,
- io->read_meta_buf->len,
- &io->read_encoding,
- &io->read_length,
- io->user_data);
+ status = io->parse_headers_cb (msg, io->read_meta_buf->data,
+ io->read_meta_buf->len,
+ &io->read_encoding,
+ &io->read_length,
+ io->user_data);
g_byte_array_set_size (io->read_meta_buf, 0);
- if (err != SOUP_ERROR_OK) {
+ if (status != SOUP_STATUS_OK) {
/* Either we couldn't parse the headers, or they
* indicated something that would mean we wouldn't
* be able to parse the body. (Eg, unknown
* reading, and make sure the connection gets
* closed when we're done.
*/
- soup_message_set_error (msg, err);
+ soup_message_set_status (msg, status);
soup_message_add_header (msg->request_headers,
"Connection", "close");
io->read_state = SOUP_MESSAGE_IO_STATE_DONE;
}
if (io->mode == SOUP_MESSAGE_IO_CLIENT &&
- SOUP_ERROR_IS_INFORMATIONAL (msg->errorcode)) {
+ SOUP_STATUS_IS_INFORMATIONAL (msg->status_code)) {
/* FIXME: we should clear the existing
- * response headers and errorphrase.
+ * response headers and reason_phrase.
*/
- if (msg->errorcode == SOUP_ERROR_CONTINUE &&
+ if (msg->status_code == SOUP_STATUS_CONTINUE &&
io->write_state == SOUP_MESSAGE_IO_STATE_BLOCKING) {
/* Restart the reader, unpause the writer */
io->read_state =
SoupConnectId connect_tag;
gpointer io_data;
- guint retries;
-
- SoupCallbackFn callback;
- gpointer user_data;
-
guint msg_flags;
GSList *chunks, *last_chunk;
GString *headers,
SoupTransferEncoding *encoding,
gpointer user_data);
-typedef SoupKnownErrorCode
- (*SoupMessageParseHeadersFn)(SoupMessage *msg,
+typedef guint (*SoupMessageParseHeadersFn)(SoupMessage *msg,
char *headers,
guint header_len,
SoupTransferEncoding *encoding,
#include "soup-server.h"
#include "soup-socket.h"
-static SoupKnownErrorCode
+static guint
parse_request_headers (SoupMessage *msg, char *headers, guint headers_len,
SoupTransferEncoding *encoding, guint *content_len,
gpointer sock)
(char **) &msg->method,
&req_path,
&msg->priv->http_version))
- return SOUP_ERROR_BAD_REQUEST;
+ return SOUP_STATUS_BAD_REQUEST;
/* Handle request body encoding */
length = soup_message_get_header (msg->request_headers,
else {
g_warning ("Unknown encoding type in HTTP request.");
g_free (req_path);
- return SOUP_ERROR_NOT_IMPLEMENTED;
+ return SOUP_STATUS_NOT_IMPLEMENTED;
}
} else if (length) {
int len;
len = atoi (length);
if (len < 0) {
g_free (req_path);
- return SOUP_ERROR_BAD_REQUEST;
+ return SOUP_STATUS_BAD_REQUEST;
}
*content_len = len;
} else {
soup_uri_free (absolute);
} else {
g_free (req_path);
- return SOUP_ERROR_BAD_REQUEST;
+ return SOUP_STATUS_BAD_REQUEST;
}
} else if (req_host) {
url = g_strdup_printf ("%s://%s:%d%s",
req_path);
} else {
g_free (req_path);
- return SOUP_ERROR_BAD_REQUEST;
+ return SOUP_STATUS_BAD_REQUEST;
}
ctx = soup_context_get (url);
g_free (req_path);
if (!ctx)
- return SOUP_ERROR_BAD_REQUEST;
+ return SOUP_STATUS_BAD_REQUEST;
soup_message_set_context (msg, ctx);
g_object_unref (ctx);
- return SOUP_ERROR_OK;
+ return SOUP_STATUS_OK;
}
static void
SoupServerMessage *smsg = SOUP_SERVER_MESSAGE (msg);
g_string_append_printf (headers, "HTTP/1.1 %d %s\r\n",
- msg->errorcode, msg->errorphrase);
+ msg->status_code, msg->reason_phrase);
soup_message_foreach_header (msg->response_headers,
write_header, headers);
#include "soup-auth.h"
#include "soup-connection.h"
-#include "soup-error.h"
#include "soup-marshal.h"
#include "soup-message.h"
#include "soup-message-private.h"
g_slist_foreach (msg->priv->content_handlers, (GFunc) g_free, NULL);
g_slist_free (msg->priv->content_handlers);
- g_free ((char *) msg->errorphrase);
+ g_free ((char *) msg->reason_phrase);
g_free (msg->priv);
* @msg: a #SoupMessage currently being processed.
*
* Cancel a running message, and issue completion callback with an
- * error code of %SOUP_ERROR_CANCELLED. If not requeued by the
+ * error code of %SOUP_STATUS_CANCELLED. If not requeued by the
* completion callback, the @msg will be destroyed.
*/
void
soup_message_cancel (SoupMessage *msg)
{
- soup_message_set_error (msg, SOUP_ERROR_CANCELLED);
+ soup_message_set_status (msg, SOUP_STATUS_CANCELLED);
soup_message_disconnect (msg);
soup_message_finished (msg);
}
soup_message_clear_headers (req->response_headers);
- req->errorcode = 0;
- req->errorclass = 0;
-
- if (req->errorphrase) {
- g_free ((char *) req->errorphrase);
- req->errorphrase = NULL;
+ req->status_code = 0;
+ if (req->reason_phrase) {
+ g_free ((char *) req->reason_phrase);
+ req->reason_phrase = NULL;
}
}
}
void
-soup_message_set_error (SoupMessage *msg, SoupKnownErrorCode errcode)
+soup_message_set_status (SoupMessage *msg, guint status_code)
{
g_return_if_fail (SOUP_IS_MESSAGE (msg));
- g_return_if_fail (errcode != 0);
+ g_return_if_fail (status_code != 0);
- g_free ((char *) msg->errorphrase);
+ g_free ((char *) msg->reason_phrase);
- msg->errorcode = errcode;
- msg->errorclass = soup_error_get_class (errcode);
- msg->errorphrase = g_strdup (soup_error_get_phrase (errcode));
+ msg->status_code = status_code;
+ msg->reason_phrase = g_strdup (soup_status_get_phrase (status_code));
}
void
-soup_message_set_error_full (SoupMessage *msg,
- guint errcode,
- const char *errphrase)
+soup_message_set_status_full (SoupMessage *msg,
+ guint status_code,
+ const char *reason_phrase)
{
g_return_if_fail (SOUP_IS_MESSAGE (msg));
- g_return_if_fail (errcode != 0);
- g_return_if_fail (errphrase != NULL);
+ g_return_if_fail (status_code != 0);
+ g_return_if_fail (reason_phrase != NULL);
- g_free ((char *) msg->errorphrase);
+ g_free ((char *) msg->reason_phrase);
- msg->errorcode = errcode;
- msg->errorclass = soup_error_get_class (errcode);
- msg->errorphrase = g_strdup (errphrase);
+ msg->status_code = status_code;
+ msg->reason_phrase = g_strdup (reason_phrase);
}
const char *method;
- guint errorcode;
- SoupErrorClass errorclass;
- const char *errorphrase;
+ guint status_code;
+ const char *reason_phrase;
SoupDataBuffer request;
GHashTable *request_headers;
GType soup_message_get_type (void);
-#define SOUP_MESSAGE_IS_ERROR(msg) \
- (msg->errorclass && \
- msg->errorclass != SOUP_ERROR_CLASS_SUCCESS && \
- msg->errorclass != SOUP_ERROR_CLASS_INFORMATIONAL && \
- msg->errorclass != SOUP_ERROR_CLASS_UNKNOWN)
-
typedef void (*SoupMessageCallbackFn) (SoupMessage *req, gpointer user_data);
/* Backward compat; FIXME */
typedef SoupMessageCallbackFn SoupCallbackFn;
SoupCallbackFn handler_cb,
gpointer user_data);
-void soup_message_add_error_code_handler (
+void soup_message_add_status_code_handler (
SoupMessage *msg,
- guint errorcode,
+ guint status_code,
SoupHandlerPhase type,
SoupCallbackFn handler_cb,
gpointer user_data);
-void soup_message_add_error_class_handler (
+void soup_message_add_status_class_handler (
SoupMessage *msg,
- SoupErrorClass errorclass,
+ SoupStatusClass status_class,
SoupHandlerPhase type,
SoupCallbackFn handler_cb,
gpointer user_data);
gpointer user_data);
/*
- * Error Setting
+ * Status Setting
*/
-void soup_message_set_error (SoupMessage *msg,
- SoupKnownErrorCode errcode);
+void soup_message_set_status (SoupMessage *msg,
+ guint status_code);
-void soup_message_set_error_full (SoupMessage *msg,
- guint errcode,
- const char *errphrase);
+void soup_message_set_status_full (SoupMessage *msg,
+ guint status_code,
+ const char *reason_phrase);
/* Chunked encoding */
g_return_val_if_fail (msg != NULL, NULL);
if (!auth_hdrs && auth_ctx->types) {
- soup_message_set_error (msg, SOUP_ERROR_UNAUTHORIZED);
+ soup_message_set_status (msg, SOUP_STATUS_UNAUTHORIZED);
return NULL;
}
&header);
if (!type && auth_ctx->types) {
- soup_message_set_error (msg, SOUP_ERROR_UNAUTHORIZED);
+ soup_message_set_status (msg, SOUP_STATUS_UNAUTHORIZED);
return NULL;
}
g_free (ret);
- soup_message_set_error (msg, SOUP_ERROR_UNAUTHORIZED);
+ soup_message_set_status (msg, SOUP_STATUS_UNAUTHORIZED);
return NULL;
}
set_response_error (SoupMessage *req, guint code, char *phrase, char *body)
{
if (phrase)
- soup_message_set_error_full (req, code, phrase);
+ soup_message_set_status_full (req, code, phrase);
else
- soup_message_set_error (req, code);
+ soup_message_set_status (req, code);
req->response.owner = SOUP_BUFFER_STATIC;
req->response.body = body;
hand = soup_server_get_handler (server, handler_path);
if (!hand) {
- set_response_error (req, SOUP_ERROR_NOT_FOUND, NULL, NULL);
+ set_response_error (req, SOUP_STATUS_NOT_FOUND, NULL, NULL);
return;
}
req,
"WWW-Authenticate");
- if (!req->errorcode)
- soup_message_set_error (
+ if (!req->status_code)
+ soup_message_set_status (
req,
- SOUP_ERROR_UNAUTHORIZED);
+ SOUP_STATUS_UNAUTHORIZED);
return;
}
- } else if (req->errorcode) {
+ } else if (req->status_code) {
soup_server_auth_context_challenge (
auth_ctx,
req,
SoupSession *session = user_data;
SoupContext *ctx;
- if (msg->errorcode == SOUP_ERROR_PROXY_UNAUTHORIZED)
+ if (msg->status_code == SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED)
ctx = soup_get_proxy ();
else
ctx = msg->priv->context;
return;
INVALID_REDIRECT:
- soup_message_set_error_full (msg,
- SOUP_ERROR_MALFORMED,
- "Invalid Redirect URL");
+ soup_message_set_status_full (msg,
+ SOUP_STATUS_MALFORMED,
+ "Invalid Redirect URL");
}
static void
}
static void
-got_connection (SoupContext *ctx, SoupKnownErrorCode err,
+got_connection (SoupContext *ctx, guint status,
SoupConnection *conn, gpointer user_data)
{
SoupMessage *req = user_data;
req->priv->connect_tag = NULL;
soup_message_set_connection (req, conn);
- switch (err) {
- case SOUP_ERROR_OK:
- start_request (conn, req);
- break;
-
- default:
- soup_message_set_error (req, err);
+ if (status != SOUP_STATUS_OK) {
+ soup_message_set_status (req, status);
soup_message_finished (req);
- break;
+ return;
}
- return;
+ start_request (conn, req);
}
static gboolean
g_signal_connect_after (req, "finished",
G_CALLBACK (final_finished), session);
- soup_message_add_error_code_handler (req, SOUP_ERROR_UNAUTHORIZED,
- SOUP_HANDLER_POST_BODY,
- authorize_handler, session);
- soup_message_add_error_code_handler (req,
- SOUP_ERROR_PROXY_UNAUTHORIZED,
- SOUP_HANDLER_POST_BODY,
- authorize_handler, session);
+ soup_message_add_status_code_handler (req, SOUP_STATUS_UNAUTHORIZED,
+ SOUP_HANDLER_POST_BODY,
+ authorize_handler, session);
+ soup_message_add_status_code_handler (req,
+ SOUP_STATUS_PROXY_UNAUTHORIZED,
+ SOUP_HANDLER_POST_BODY,
+ authorize_handler, session);
if (!(req->priv->msg_flags & SOUP_MESSAGE_NO_REDIRECT)) {
- soup_message_add_error_class_handler (
- req, SOUP_ERROR_CLASS_REDIRECT, SOUP_HANDLER_POST_BODY,
+ soup_message_add_status_class_handler (
+ req, SOUP_STATUS_CLASS_REDIRECT,
+ SOUP_HANDLER_POST_BODY,
redirect_handler, session);
}
*
* @req is not freed upon return.
*
- * Return value: the #SoupErrorClass of the error encountered while
- * sending or reading the response.
+ * Return value: the HTTP status code of the response
*/
-SoupErrorClass
+guint
soup_session_send_message (SoupSession *session, SoupMessage *req)
{
- g_return_val_if_fail (SOUP_IS_SESSION (session), SOUP_ERROR_CLASS_TRANSPORT);
- g_return_val_if_fail (SOUP_IS_MESSAGE (req), SOUP_ERROR_CLASS_TRANSPORT);
+ g_return_val_if_fail (SOUP_IS_SESSION (session), SOUP_STATUS_MALFORMED);
+ g_return_val_if_fail (SOUP_IS_MESSAGE (req), SOUP_STATUS_MALFORMED);
/* Balance out the unref that final_finished will do */
g_object_ref (req);
g_main_iteration (TRUE);
if (req->priv->status == SOUP_MESSAGE_STATUS_FINISHED ||
- SOUP_ERROR_IS_TRANSPORT (req->errorcode))
+ SOUP_STATUS_IS_TRANSPORT (req->status_code))
break;
}
- return req->errorclass;
+ return req->status_code;
}
void soup_session_requeue_message (SoupSession *session,
SoupMessage *req);
-SoupErrorClass soup_session_send_message (SoupSession *session,
+guint soup_session_send_message (SoupSession *session,
SoupMessage *req);
if (sock->priv->ssl)
soup_socket_start_ssl (sock);
- g_signal_emit (sock, signals[CONNECT_RESULT], 0, SOUP_ERROR_OK);
+ g_signal_emit (sock, signals[CONNECT_RESULT], 0, SOUP_STATUS_OK);
return FALSE;
cant_connect:
- g_signal_emit (sock, signals[CONNECT_RESULT], 0, SOUP_ERROR_CANT_CONNECT);
+ g_signal_emit (sock, signals[CONNECT_RESULT], 0, SOUP_STATUS_CANT_CONNECT);
return FALSE;
}
sock->priv->watch = 0;
g_signal_emit (sock, signals[CONNECT_RESULT], 0,
- sock->priv->sockfd != -1 ? SOUP_ERROR_OK : SOUP_ERROR_CANT_CONNECT);
+ sock->priv->sockfd != -1 ? SOUP_STATUS_OK : SOUP_STATUS_CANT_CONNECT);
return FALSE;
}
static void
-got_address (SoupAddress *addr, SoupKnownErrorCode status, gpointer user_data)
+got_address (SoupAddress *addr, guint status, gpointer user_data)
{
SoupSocket *sock = user_data;
- if (!SOUP_ERROR_IS_SUCCESSFUL (status)) {
+ if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
g_signal_emit (sock, signals[CONNECT_RESULT], 0, status);
return;
}
GObjectClass parent_class;
/* signals */
- void (*connect_result) (SoupSocket *, SoupKnownErrorCode);
+ void (*connect_result) (SoupSocket *, guint);
void (*readable) (SoupSocket *);
void (*writable) (SoupSocket *);
void (*disconnected) (SoupSocket *);
gboolean soup_socket_is_connected (SoupSocket *sock);
typedef void (*SoupSocketCallback) (SoupSocket *sock,
- SoupKnownErrorCode status,
+ guint status,
gpointer user_data);
typedef void (*SoupSocketListenerCallback) (SoupSocket *listener,
SoupSocket *sock,
--- /dev/null
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * soup-status.c: Status code descriptions
+ *
+ * Copyright (C) 2001-2003, Ximian, Inc.
+ */
+
+#include <glib.h>
+
+#include "soup-status.h"
+
+struct {
+ guint code;
+ const char *phrase;
+} reason_phrases [] = {
+ /* Transport errors */
+ { SOUP_STATUS_CANCELLED, "Cancelled" },
+ { SOUP_STATUS_CANT_RESOLVE, "Cannot resolve hostname" },
+ { SOUP_STATUS_CANT_RESOLVE_PROXY, "Cannot resolve proxy hostname" },
+ { SOUP_STATUS_CANT_CONNECT, "Cannot connect to destination" },
+ { SOUP_STATUS_CANT_CONNECT_PROXY, "Cannot connect to proxy" },
+ { SOUP_STATUS_SSL_FAILED, "SSL handshake failed" },
+ { SOUP_STATUS_IO_ERROR, "Connection terminated unexpectedly" },
+ { SOUP_STATUS_MALFORMED, "Message Corrupt" },
+
+ /* Informational */
+ { SOUP_STATUS_CONTINUE, "Continue" },
+ { SOUP_STATUS_SWITCHING_PROTOCOLS, "Switching Protocols" },
+ { SOUP_STATUS_PROCESSING, "Processing" },
+
+ /* Success */
+ { SOUP_STATUS_OK, "OK" },
+ { SOUP_STATUS_CREATED, "Created" },
+ { SOUP_STATUS_ACCEPTED, "Accepted" },
+ { SOUP_STATUS_NON_AUTHORITATIVE, "Non-Authoritative Information" },
+ { SOUP_STATUS_NO_CONTENT, "No Content" },
+ { SOUP_STATUS_RESET_CONTENT, "Reset Content" },
+ { SOUP_STATUS_PARTIAL_CONTENT, "Partial Content" },
+ { SOUP_STATUS_MULTI_STATUS, "Multi-Status" },
+
+ /* Redirection */
+ { SOUP_STATUS_MULTIPLE_CHOICES, "Multiple Choices" },
+ { SOUP_STATUS_MOVED_PERMANENTLY, "Moved Permanently" },
+ { SOUP_STATUS_FOUND, "Found" },
+ { SOUP_STATUS_SEE_OTHER, "See Other" },
+ { SOUP_STATUS_NOT_MODIFIED, "Not Modified" },
+ { SOUP_STATUS_USE_PROXY, "Use Proxy" },
+ { SOUP_STATUS_TEMPORARY_REDIRECT, "Temporary Redirect" },
+
+ /* Client error */
+ { SOUP_STATUS_BAD_REQUEST, "Bad Request" },
+ { SOUP_STATUS_UNAUTHORIZED, "Unauthorized" },
+ { SOUP_STATUS_PAYMENT_REQUIRED, "Payment Required" },
+ { SOUP_STATUS_FORBIDDEN, "Forbidden" },
+ { SOUP_STATUS_NOT_FOUND, "Not Found" },
+ { SOUP_STATUS_METHOD_NOT_ALLOWED, "Method Not Allowed" },
+ { SOUP_STATUS_NOT_ACCEPTABLE, "Not Acceptable" },
+ { SOUP_STATUS_PROXY_UNAUTHORIZED, "Proxy Authentication Required" },
+ { SOUP_STATUS_REQUEST_TIMEOUT, "Request Timeout" },
+ { SOUP_STATUS_CONFLICT, "Conflict" },
+ { SOUP_STATUS_GONE, "Gone" },
+ { SOUP_STATUS_LENGTH_REQUIRED, "Length Required" },
+ { SOUP_STATUS_PRECONDITION_FAILED, "Precondition Failed" },
+ { SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE, "Request Entity Too Large" },
+ { SOUP_STATUS_REQUEST_URI_TOO_LONG, "Request-URI Too Long" },
+ { SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE, "Unsupported Media Type" },
+ { SOUP_STATUS_INVALID_RANGE, "Requested Range Not Satisfiable" },
+ { SOUP_STATUS_EXPECTATION_FAILED, "Expectation Failed" },
+ { SOUP_STATUS_UNPROCESSABLE_ENTITY, "Unprocessable Entity" },
+ { SOUP_STATUS_LOCKED, "Locked" },
+ { SOUP_STATUS_FAILED_DEPENDENCY, "Failed Dependency" },
+
+ /* Server error */
+ { SOUP_STATUS_INTERNAL_SERVER_ERROR, "Internal Server Error" },
+ { SOUP_STATUS_NOT_IMPLEMENTED, "Not Implemented" },
+ { SOUP_STATUS_BAD_GATEWAY, "Bad Gateway" },
+ { SOUP_STATUS_SERVICE_UNAVAILABLE, "Service Unavailable" },
+ { SOUP_STATUS_GATEWAY_TIMEOUT, "Gateway Timeout" },
+ { SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED, "HTTP Version Not Supported" },
+ { SOUP_STATUS_INSUFFICIENT_STORAGE, "Insufficient Storage" },
+ { SOUP_STATUS_NOT_EXTENDED, "Not Extended" },
+
+ { 0 }
+};
+
+const char *
+soup_status_get_phrase (guint status_code)
+{
+ int i;
+
+ for (i = 0; reason_phrases [i].code; i++) {
+ if (reason_phrases [i].code == status_code)
+ return reason_phrases [i].phrase;
+ }
+
+ return "Unknown Error";
+}
--- /dev/null
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * soup-status.h: HTTP status code and status class definitions
+ *
+ * Copyright (C) 2001-2003, Ximian, Inc.
+ */
+
+#ifndef SOUP_STATUS_H
+#define SOUP_STATUS_H 1
+
+typedef enum {
+ SOUP_STATUS_CLASS_TRANSPORT = 1,
+ SOUP_STATUS_CLASS_INFORMATIONAL,
+ SOUP_STATUS_CLASS_SUCCESS,
+ SOUP_STATUS_CLASS_REDIRECT,
+ SOUP_STATUS_CLASS_CLIENT_ERROR,
+ SOUP_STATUS_CLASS_SERVER_ERROR,
+} SoupStatusClass;
+
+#define SOUP_STATUS_IS_TRANSPORT(x) (((x) > 0 && (x) < 100) || (x) >= 600)
+#define SOUP_STATUS_IS_INFORMATIONAL(x) ((x) >= 100 && (x) < 200)
+#define SOUP_STATUS_IS_SUCCESSFUL(x) ((x) >= 200 && (x) < 300)
+#define SOUP_STATUS_IS_REDIRECTION(x) ((x) >= 300 && (x) < 400)
+#define SOUP_STATUS_IS_CLIENT_ERROR(x) ((x) >= 400 && (x) < 500)
+#define SOUP_STATUS_IS_SERVER_ERROR(x) ((x) >= 500 && (x) < 600)
+
+typedef enum {
+ /* Transport Errors */
+ SOUP_STATUS_CANCELLED = 1,
+ SOUP_STATUS_CANT_RESOLVE,
+ SOUP_STATUS_CANT_RESOLVE_PROXY,
+ SOUP_STATUS_CANT_CONNECT,
+ SOUP_STATUS_CANT_CONNECT_PROXY,
+ SOUP_STATUS_SSL_FAILED,
+ SOUP_STATUS_IO_ERROR,
+ SOUP_STATUS_MALFORMED,
+
+ /* HTTP Status Codes */
+ SOUP_STATUS_CONTINUE = 100,
+ SOUP_STATUS_SWITCHING_PROTOCOLS = 101,
+ SOUP_STATUS_PROCESSING = 102, /* WebDAV */
+
+ SOUP_STATUS_OK = 200,
+ SOUP_STATUS_CREATED = 201,
+ SOUP_STATUS_ACCEPTED = 202,
+ SOUP_STATUS_NON_AUTHORITATIVE = 203,
+ SOUP_STATUS_NO_CONTENT = 204,
+ SOUP_STATUS_RESET_CONTENT = 205,
+ SOUP_STATUS_PARTIAL_CONTENT = 206,
+ SOUP_STATUS_MULTI_STATUS = 207, /* WebDAV */
+
+ SOUP_STATUS_MULTIPLE_CHOICES = 300,
+ SOUP_STATUS_MOVED_PERMANENTLY = 301,
+ SOUP_STATUS_FOUND = 302,
+ SOUP_STATUS_MOVED_TEMPORARILY = 302, /* RFC 2068 */
+ SOUP_STATUS_SEE_OTHER = 303,
+ SOUP_STATUS_NOT_MODIFIED = 304,
+ SOUP_STATUS_USE_PROXY = 305,
+ SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL = 306, /* (reserved) */
+ SOUP_STATUS_TEMPORARY_REDIRECT = 307,
+
+ SOUP_STATUS_BAD_REQUEST = 400,
+ SOUP_STATUS_UNAUTHORIZED = 401,
+ SOUP_STATUS_PAYMENT_REQUIRED = 402, /* (reserved) */
+ SOUP_STATUS_FORBIDDEN = 403,
+ SOUP_STATUS_NOT_FOUND = 404,
+ SOUP_STATUS_METHOD_NOT_ALLOWED = 405,
+ SOUP_STATUS_NOT_ACCEPTABLE = 406,
+ SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED = 407,
+ SOUP_STATUS_PROXY_UNAUTHORIZED = SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED,
+ SOUP_STATUS_REQUEST_TIMEOUT = 408,
+ SOUP_STATUS_CONFLICT = 409,
+ SOUP_STATUS_GONE = 410,
+ SOUP_STATUS_LENGTH_REQUIRED = 411,
+ SOUP_STATUS_PRECONDITION_FAILED = 412,
+ SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE = 413,
+ SOUP_STATUS_REQUEST_URI_TOO_LONG = 414,
+ SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415,
+ SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+ SOUP_STATUS_INVALID_RANGE = SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE,
+ SOUP_STATUS_EXPECTATION_FAILED = 417,
+ SOUP_STATUS_UNPROCESSABLE_ENTITY = 422, /* WebDAV */
+ SOUP_STATUS_LOCKED = 423, /* WebDAV */
+ SOUP_STATUS_FAILED_DEPENDENCY = 424, /* WebDAV */
+
+ SOUP_STATUS_INTERNAL_SERVER_ERROR = 500,
+ SOUP_STATUS_NOT_IMPLEMENTED = 501,
+ SOUP_STATUS_BAD_GATEWAY = 502,
+ SOUP_STATUS_SERVICE_UNAVAILABLE = 503,
+ SOUP_STATUS_GATEWAY_TIMEOUT = 504,
+ SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED = 505,
+ SOUP_STATUS_INSUFFICIENT_STORAGE = 507, /* WebDAV search */
+ SOUP_STATUS_NOT_EXTENDED = 510 /* RFC 2774 */
+} SoupKnownStatusCode;
+
+const char *soup_status_get_phrase (guint status_code);
+
+#endif /* SOUP_STATUS_H */
#include <glib/gtypes.h>
#include <glib-object.h>
-#include <libsoup/soup-error.h>
+#include <libsoup/soup-status.h>
typedef struct SoupAddress SoupAddress;
typedef struct SoupConnection SoupConnection;
auth = identify_auth (msg);
- printf (" %d %s (using %s)\n", msg->errorcode, msg->errorphrase,
+ printf (" %d %s (using %s)\n", msg->status_code, msg->reason_phrase,
auths[auth]);
if (*expected) {
}
expected = g_strdup (tests[i].expected);
- soup_message_add_error_code_handler (
- msg, SOUP_ERROR_UNAUTHORIZED,
+ soup_message_add_status_code_handler (
+ msg, SOUP_STATUS_UNAUTHORIZED,
SOUP_HANDLER_PRE_BODY, handler, expected);
- soup_message_add_error_code_handler (
- msg, SOUP_ERROR_OK, SOUP_HANDLER_PRE_BODY,
+ soup_message_add_status_code_handler (
+ msg, SOUP_STATUS_OK, SOUP_HANDLER_PRE_BODY,
handler, expected);
soup_session_send_message (session, msg);
- if (msg->errorcode != SOUP_ERROR_UNAUTHORIZED &&
- msg->errorcode != SOUP_ERROR_OK) {
- printf (" %d %s !\n", msg->errorcode,
- msg->errorphrase);
+ if (msg->status_code != SOUP_STATUS_UNAUTHORIZED &&
+ msg->status_code != SOUP_STATUS_OK) {
+ printf (" %d %s !\n", msg->status_code,
+ msg->reason_phrase);
}
if (*expected) {
printf (" expected %d more round(s)\n",
}
g_free (expected);
- if (SOUP_ERROR_IS_SUCCESSFUL (msg->errorcode) !=
+ if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code) !=
tests[i].success) {
printf (" expected %s\n",
tests[i].success ? "success" : "failure");
fprintf (stderr, " Error: not under %s\n", base_uri->path);
goto DONE;
}
- printf ("%s: %d %s\n", name, msg->errorcode, msg->errorphrase);
+ printf ("%s: %d %s\n", name, msg->status_code, msg->reason_phrase);
name += strlen (base_uri->path);
if (*name == '/')
name++;
- if (SOUP_ERROR_IS_REDIRECTION (msg->errorcode)) {
+ if (SOUP_STATUS_IS_REDIRECTION (msg->status_code)) {
unlink (name);
header = soup_message_get_header (msg->response_headers, "Location");
if (header) {
goto DONE;
}
- if (!SOUP_ERROR_IS_SUCCESSFUL (msg->errorcode))
+ if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))
goto DONE;
if (recurse)
printf ("%.*s\n", msg->request.length, msg->request.body);
if (soup_method_get_id (msg->method) != SOUP_METHOD_ID_GET) {
- soup_message_set_error (msg, SOUP_ERROR_NOT_IMPLEMENTED);
+ soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
goto DONE;
}
if (path) {
if (*path != '/') {
- soup_message_set_error (msg, SOUP_ERROR_BAD_REQUEST);
+ soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST);
goto DONE;
}
} else
if (stat (path_to_open, &st) == -1) {
g_free (path_to_open);
if (errno == EPERM)
- soup_message_set_error (msg, SOUP_ERROR_FORBIDDEN);
+ soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
else if (errno == ENOENT)
- soup_message_set_error (msg, SOUP_ERROR_NOT_FOUND);
+ soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
else
- soup_message_set_error (msg, SOUP_ERROR_INTERNAL);
+ soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto DONE;
}
redir_uri = g_strdup_printf ("%s/", uri);
soup_message_add_header (msg->response_headers,
"Location", redir_uri);
- soup_message_set_error (msg, SOUP_ERROR_MOVED_PERMANENTLY);
+ soup_message_set_status (msg, SOUP_STATUS_MOVED_PERMANENTLY);
g_free (redir_uri);
g_free (uri);
g_free (path_to_open);
fd = open (path_to_open, O_RDONLY);
g_free (path_to_open);
if (fd == -1) {
- soup_message_set_error (msg, SOUP_ERROR_INTERNAL);
+ soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto DONE;
}
read (fd, msg->response.body, msg->response.length);
close (fd);
- soup_message_set_error (msg, SOUP_ERROR_OK);
+ soup_message_set_status (msg, SOUP_STATUS_OK);
DONE:
g_free (path);
soup_server_message_set_encoding (SOUP_SERVER_MESSAGE (msg),
SOUP_TRANSFER_CONTENT_LENGTH);
- printf (" -> %d %s\n\n", msg->errorcode, msg->errorphrase);
+ printf (" -> %d %s\n\n", msg->status_code, msg->reason_phrase);
}
static void
{
printf ("[%p] HTTP/1.%d %d %s\n", to,
soup_message_get_http_version (from),
- from->errorcode, from->errorphrase);
+ from->status_code, from->reason_phrase);
- soup_message_set_error_full (to, from->errorcode, from->errorphrase);
+ soup_message_set_status_full (to, from->status_code,
+ from->reason_phrase);
soup_message_foreach_header (from->response_headers, copy_header,
to->response_headers);
soup_message_remove_header (to->response_headers, "Content-Length");
soup_message_get_http_version (msg));
if (soup_method_get_id (msg->method) == SOUP_METHOD_ID_CONNECT) {
- soup_message_set_error (msg, SOUP_ERROR_NOT_IMPLEMENTED);
+ soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
projects / platform / upstream / libsoup.git / commitdiff