2003-08-25 Dan Winship <danw@ximian.com>
+ * libsoup/soup-message-io.c (soup_message_read,
+ soup_message_write, soup_message_write_simple): Add a "user_data"
+ arg, pass it to the callbacks.
+
+ * libsoup/soup-message.c (soup_message_requeue,
+ requeue_read_finished, requeue_read_error): Update for that
+
+ * libsoup/soup-queue.c: Likewise
+
+ * libsoup/soup-server.c: Likewise
+
+2003-08-25 Dan Winship <danw@ximian.com>
+
* libsoup/soup-message.c (soup_message_new): Take a uri string
instead of a context. Also, swap the args (so the method comes
before the URI, just like in the protocol).
SoupMessageReadChunkFn read_chunk_cb;
SoupMessageReadBodyFn read_body_cb;
SoupMessageReadErrorFn error_cb;
+ gpointer user_data;
} SoupMessageReadState;
/* Put these around callback invocation if there is code afterward
* that depends on the read not having been cancelled.
*/
+#define dummy_to_make_emacs_happy {
#define SOUP_MESSAGE_READ_PREPARE_FOR_CALLBACK { gboolean cancelled; g_object_ref (msg);
#define SOUP_MESSAGE_READ_RETURN_IF_CANCELLED cancelled = (msg->priv->read_state != r); g_object_unref (msg); if (cancelled) return; }
#define SOUP_MESSAGE_READ_RETURN_VAL_IF_CANCELLED(val) cancelled = (msg->priv->read_state != r); g_object_unref (msg); if (cancelled) return val; }
SoupMessageReadHeadersFn read_headers_cb,
SoupMessageReadChunkFn read_chunk_cb,
SoupMessageReadBodyFn read_body_cb,
- SoupMessageReadErrorFn error_cb)
+ SoupMessageReadErrorFn error_cb,
+ gpointer user_data)
{
SoupMessageReadState *r = msg->priv->read_state;
r->read_chunk_cb = read_chunk_cb;
r->read_body_cb = read_body_cb;
r->error_cb = error_cb;
+ r->user_data = user_data;
}
static void
{
SoupMessageReadState *r = msg->priv->read_state;
SoupMessageReadBodyFn read_body_cb = r->read_body_cb;
+ gpointer user_data = r->user_data;
char *body;
guint len;
}
soup_message_read_cancel (msg);
- read_body_cb (msg, body, len);
+ read_body_cb (msg, body, len, user_data);
}
static void
{
SoupMessageReadState *r = msg->priv->read_state;
SoupMessageReadErrorFn error_cb = r->error_cb;
+ gpointer user_data = r->user_data;
/* Closing the connection to signify EOF is valid if content
* length is unknown, but only if headers have been sent.
}
soup_message_read_cancel (msg);
- error_cb (msg);
+ error_cb (msg, user_data);
}
static gboolean
if (r->read_chunk_cb) {
SOUP_MESSAGE_READ_PREPARE_FOR_CALLBACK;
- r->read_chunk_cb (msg, read_buf, nread);
+ r->read_chunk_cb (msg, read_buf, nread, r->user_data);
SOUP_MESSAGE_READ_RETURN_VAL_IF_CANCELLED (FALSE);
}
r->meta_buf->data,
r->meta_buf->len,
&r->encoding,
- &r->read_length);
+ &r->read_length,
+ r->user_data);
SOUP_MESSAGE_READ_RETURN_IF_CANCELLED;
}
g_byte_array_set_size (r->meta_buf, 0);
}
void
-soup_message_read (SoupMessage *msg,
- SoupMessageReadHeadersFn read_headers_cb,
- SoupMessageReadChunkFn read_chunk_cb,
- SoupMessageReadBodyFn read_body_cb,
- SoupMessageReadErrorFn error_cb)
+soup_message_read (SoupMessage *msg,
+ SoupMessageReadHeadersFn read_headers_cb,
+ SoupMessageReadChunkFn read_chunk_cb,
+ SoupMessageReadBodyFn read_body_cb,
+ SoupMessageReadErrorFn error_cb,
+ gpointer user_data)
{
SoupMessageReadState *r;
r->read_chunk_cb = read_chunk_cb;
r->read_body_cb = read_body_cb;
r->error_cb = error_cb;
+ r->user_data = user_data;
r->encoding = SOUP_TRANSFER_UNKNOWN;
r->meta_buf = g_byte_array_new ();
SoupMessageWriteGetChunkFn get_chunk_cb;
SoupMessageWriteDoneFn write_done_cb;
SoupMessageWriteErrorFn error_cb;
+ gpointer user_data;
} SoupMessageWriteState;
/* Put these around callback invocation if there is code afterward
{
SoupMessageWriteState *w = msg->priv->write_state;
SoupMessageWriteErrorFn error_cb = w->error_cb;
+ gpointer user_data = w->user_data;
soup_message_write_cancel (msg);
- error_cb (msg);
+ error_cb (msg, user_data);
}
static gboolean
{
SoupMessageWriteState *w = msg->priv->write_state;
SoupMessageWriteDoneFn write_done_cb = w->write_done_cb;
+ gpointer user_data = w->user_data;
while (1) {
switch (msg->priv->status) {
case SOUP_MESSAGE_STATUS_WRITING_HEADERS:
if (w->get_header_cb) {
SOUP_MESSAGE_WRITE_PREPARE_FOR_CALLBACK;
- w->get_header_cb (msg, w->buf);
+ w->get_header_cb (msg, w->buf, user_data);
SOUP_MESSAGE_WRITE_RETURN_IF_CANCELLED;
w->get_header_cb = NULL;
gboolean got_chunk;
SOUP_MESSAGE_WRITE_PREPARE_FOR_CALLBACK;
- got_chunk =
- w->get_chunk_cb (msg, &w->chunk);
+ got_chunk = w->get_chunk_cb (msg,
+ &w->chunk,
+ user_data);
SOUP_MESSAGE_WRITE_RETURN_IF_CANCELLED;
if (!got_chunk) {
done:
msg->priv->status = SOUP_MESSAGE_STATUS_FINISHED_WRITING;
soup_message_write_cancel (msg);
- write_done_cb (msg);
+ write_done_cb (msg, user_data);
}
static gboolean
SoupTransferEncoding encoding,
SoupMessageWriteGetHeaderFn get_header_cb,
SoupMessageWriteDoneFn write_done_cb,
- SoupMessageWriteErrorFn error_cb)
+ SoupMessageWriteErrorFn error_cb,
+ gpointer user_data)
{
SoupMessageWriteState *w;
w->get_header_cb = get_header_cb;
w->write_done_cb = write_done_cb;
w->error_cb = error_cb;
+ w->user_data = user_data;
w->write_tag =
g_signal_connect (msg->priv->socket, "writable",
const SoupDataBuffer *body,
SoupMessageWriteGetHeaderFn get_header_cb,
SoupMessageWriteDoneFn write_done_cb,
- SoupMessageWriteErrorFn error_cb)
+ SoupMessageWriteErrorFn error_cb,
+ gpointer user_data)
{
SoupMessageWriteState *w;
w = create_writer (msg, SOUP_TRANSFER_CONTENT_LENGTH,
- get_header_cb, write_done_cb, error_cb);
+ get_header_cb, write_done_cb,
+ error_cb, user_data);
w->body = body;
}
SoupMessageWriteGetHeaderFn get_header_cb,
SoupMessageWriteGetChunkFn get_chunk_cb,
SoupMessageWriteDoneFn write_done_cb,
- SoupMessageWriteErrorFn error_cb)
+ SoupMessageWriteErrorFn error_cb,
+ gpointer user_data)
{
SoupMessageWriteState *w;
w = create_writer (msg, encoding, get_header_cb,
- write_done_cb, error_cb);
+ write_done_cb, error_cb, user_data);
w->get_chunk_cb = get_chunk_cb;
}
char *headers,
guint header_len,
SoupTransferEncoding *encoding,
- int *content_len);
+ int *content_len,
+ gpointer user_data);
typedef void (*SoupMessageReadChunkFn) (SoupMessage *msg,
const char *chunk,
- guint len);
+ guint len,
+ gpointer user_data);
typedef void (*SoupMessageReadBodyFn) (SoupMessage *msg,
char *body,
- guint len);
+ guint len,
+ gpointer user_data);
-typedef void (*SoupMessageReadErrorFn) (SoupMessage *msg);
+typedef void (*SoupMessageReadErrorFn) (SoupMessage *msg,
+ gpointer user_data);
void soup_message_read (SoupMessage *msg,
SoupMessageReadHeadersFn read_headers_cb,
SoupMessageReadChunkFn read_chunk_cb,
SoupMessageReadBodyFn read_body_cb,
- SoupMessageReadErrorFn error_cb);
+ SoupMessageReadErrorFn error_cb,
+ gpointer user_data);
void soup_message_read_set_callbacks (SoupMessage *msg,
SoupMessageReadHeadersFn read_headers_cb,
SoupMessageReadChunkFn read_chunk_cb,
SoupMessageReadBodyFn read_body_cb,
- SoupMessageReadErrorFn error_cb);
+ SoupMessageReadErrorFn error_cb,
+ gpointer user_data);
void soup_message_read_cancel (SoupMessage *msg);
typedef void (*SoupMessageWriteGetHeaderFn) (SoupMessage *msg,
- GString *out_hdr);
+ GString *out_hdr,
+ gpointer user_data);
typedef gboolean (*SoupMessageWriteGetChunkFn) (SoupMessage *msg,
- SoupDataBuffer *out_next);
+ SoupDataBuffer *out_next,
+ gpointer user_data);
-typedef void (*SoupMessageWriteDoneFn) (SoupMessage *msg);
+typedef void (*SoupMessageWriteDoneFn) (SoupMessage *msg,
+ gpointer user_data);
-typedef void (*SoupMessageWriteErrorFn) (SoupMessage *msg);
+typedef void (*SoupMessageWriteErrorFn) (SoupMessage *msg,
+ gpointer user_data);
void soup_message_write (SoupMessage *msg,
SoupTransferEncoding encoding,
SoupMessageWriteGetHeaderFn get_header_cb,
SoupMessageWriteGetChunkFn get_chunk_cb,
SoupMessageWriteDoneFn write_done_cb,
- SoupMessageWriteErrorFn error_cb);
+ SoupMessageWriteErrorFn error_cb,
+ gpointer user_data);
void soup_message_write_simple (SoupMessage *msg,
const SoupDataBuffer *body,
SoupMessageWriteGetHeaderFn get_header_cb,
SoupMessageWriteDoneFn write_done_cb,
- SoupMessageWriteErrorFn error_cb);
+ SoupMessageWriteErrorFn error_cb,
+ gpointer user_data);
void soup_message_write_cancel (SoupMessage *msg);
void soup_message_write_pause (SoupMessage *msg);
}
static void
-requeue_read_error (SoupMessage *msg)
+requeue_read_error (SoupMessage *msg, gpointer user_data)
{
soup_message_disconnect (msg);
queue_message (msg);
}
static void
-requeue_read_finished (SoupMessage *msg, char *body, guint len)
+requeue_read_finished (SoupMessage *msg, char *body, guint len,
+ gpointer user_data)
{
SoupConnection *conn = msg->priv->connection;
if (req->priv->connection && req->priv->read_state) {
soup_message_read_set_callbacks (req, NULL, NULL,
requeue_read_finished,
- requeue_read_error);
+ requeue_read_error, NULL);
if (req->priv->write_state)
soup_message_write_cancel (req);
}
static void
-soup_queue_error_cb (SoupMessage *req)
+soup_queue_error_cb (SoupMessage *req, gpointer user_data)
{
SoupConnection *conn = soup_message_get_connection (req);
const SoupUri *uri;
}
static void
-soup_queue_read_headers_cb (SoupMessage *req,
- char *headers,
- guint headers_len,
- SoupTransferEncoding *encoding,
- int *content_len)
+soup_queue_read_headers_cb (SoupMessage *req, char *headers, guint headers_len,
+ SoupTransferEncoding *encoding, int *content_len,
+ gpointer user_data)
{
const char *length, *enc;
SoupHttpVersion version;
}
static void
-soup_queue_read_chunk_cb (SoupMessage *req,
- const char *chunk,
- guint len)
+soup_queue_read_chunk_cb (SoupMessage *req, const char *chunk, guint len,
+ gpointer user_data)
{
req->response.owner = SOUP_BUFFER_STATIC;
req->response.length = len;
}
static void
-soup_queue_read_done_cb (SoupMessage *req, char *body, guint len)
+soup_queue_read_done_cb (SoupMessage *req, char *body, guint len,
+ gpointer user_data)
{
if (soup_message_is_keepalive (req))
soup_connection_mark_old (soup_message_get_connection (req));
soup_queue_read_headers_cb,
soup_queue_read_chunk_cb,
soup_queue_read_done_cb,
- soup_queue_error_cb);
+ soup_queue_error_cb,
+ NULL);
} else
req->priv->status = SOUP_MESSAGE_STATUS_FINISHED;
}
static void
-soup_queue_get_request_header_cb (SoupMessage *req, GString *header)
+soup_queue_get_request_header_cb (SoupMessage *req, GString *header,
+ gpointer user_data)
{
char *uri;
SoupContext *proxy;
}
static void
-soup_queue_write_done_cb (SoupMessage *req)
+soup_queue_write_done_cb (SoupMessage *req, gpointer user_data)
{
soup_message_read (req,
soup_queue_read_headers_cb,
soup_queue_read_chunk_cb,
soup_queue_read_done_cb,
- soup_queue_error_cb);
+ soup_queue_error_cb,
+ NULL);
}
static void
soup_message_write_simple (req, &req->request,
soup_queue_get_request_header_cb,
soup_queue_write_done_cb,
- soup_queue_error_cb);
+ soup_queue_error_cb,
+ NULL);
}
static void
static void start_request (SoupServer *, SoupSocket *);
static void
-error_cb (SoupMessage *msg)
+error_cb (SoupMessage *msg, gpointer user_data)
{
g_object_unref (msg);
}
static void
-write_done_cb (SoupMessage *msg)
+write_done_cb (SoupMessage *msg, gpointer user_data)
{
SoupServerMessage *smsg = SOUP_SERVER_MESSAGE (msg);
}
static void
-get_response_header_cb (SoupMessage *msg,
- GString *headers)
+get_response_header_cb (SoupMessage *msg, GString *headers,
+ gpointer user_data)
{
SoupServerMessage *smsg = SOUP_SERVER_MESSAGE (msg);
SoupTransferEncoding encoding =
}
static inline void
-set_response_error (SoupMessage *req,
- guint code,
- char *phrase,
- char *body)
+set_response_error (SoupMessage *req, guint code, char *phrase, char *body)
{
if (phrase)
soup_message_set_error_full (req, code, phrase);
soup_message_write_simple (msg, &msg->response,
get_response_header_cb,
- write_done_cb, error_cb);
+ write_done_cb, error_cb,
+ NULL);
}
static void
-read_headers_cb (SoupMessage *msg,
- char *headers,
- guint headers_len,
- SoupTransferEncoding *encoding,
- int *content_len)
+read_headers_cb (SoupMessage *msg, char *headers, guint headers_len,
+ SoupTransferEncoding *encoding, int *content_len,
+ gpointer user_data)
{
SoupContext *ctx;
char *req_path = NULL, *url;
}
static gboolean
-get_chunk_cb (SoupMessage *msg, SoupDataBuffer *out_next)
+get_chunk_cb (SoupMessage *msg, SoupDataBuffer *out_next, gpointer user_data)
{
SoupServerMessage *smsg = SOUP_SERVER_MESSAGE (msg);
SoupDataBuffer *next;
}
static void
-read_done_cb (SoupMessage *req,
- char *body,
- guint len)
+read_done_cb (SoupMessage *req, char *body, guint len, gpointer user_data)
{
SoupServerMessage *smsg = SOUP_SERVER_MESSAGE (req);
SoupTransferEncoding encoding;
if (encoding == SOUP_TRANSFER_CONTENT_LENGTH) {
soup_message_write_simple (req, &req->response,
get_response_header_cb,
- write_done_cb, error_cb);
+ write_done_cb, error_cb,
+ NULL);
soup_server_message_start (smsg);
} else {
soup_message_write (req, encoding,
get_response_header_cb, get_chunk_cb,
- write_done_cb, error_cb);
+ write_done_cb, error_cb, NULL);
}
return;
/* Listen for another request on this connection */
msg = (SoupMessage *)soup_server_message_new (server, server_sock);
soup_message_read (msg, read_headers_cb, NULL,
- read_done_cb, error_cb);
+ read_done_cb, error_cb, NULL);
}
static void