static inline void
http_server_request_debug(struct http_server_request *req,
- const char *format, ...) ATTR_FORMAT(2, 3);
+ const char *format, ...) ATTR_FORMAT(2, 3);
static inline void
http_server_request_debug(struct http_server_request *req,
- const char *format, ...)
+ const char *format, ...)
{
struct http_server *server = req->server;
va_list args;
static inline void
http_server_request_error(struct http_server_request *req,
- const char *format, ...) ATTR_FORMAT(2, 3);
+ const char *format, ...) ATTR_FORMAT(2, 3);
static inline void
http_server_request_error(struct http_server_request *req,
- const char *format, ...)
+ const char *format, ...)
{
va_list args;
static inline void
http_server_request_client_error(struct http_server_request *req,
- const char *format, ...) ATTR_FORMAT(2, 3);
+ const char *format, ...) ATTR_FORMAT(2, 3);
static inline void
http_server_request_client_error(struct http_server_request *req,
- const char *format, ...)
+ const char *format, ...)
{
va_list args;
pool_t pool;
struct http_server_request *req;
- pool = pool_alloconly_create(MEMPOOL_GROWING"http_server_request", 4096);
+ pool = pool_alloconly_create(
+ MEMPOOL_GROWING"http_server_request", 4096);
req = p_new(pool, struct http_server_request, 1);
req->pool = pool;
req->refcount = 1;
}
void http_server_request_connection_close(struct http_server_request *req,
- bool close)
+ bool close)
{
i_assert(req->state < HTTP_SERVER_REQUEST_STATE_SENT_RESPONSE);
req->connection_close = close;
http_server_request_debug(req, "Destroy");
- /* just make sure the request ends in a proper state */
+ /* Just make sure the request ends in a proper state */
if (req->state < HTTP_SERVER_REQUEST_STATE_FINISHED)
req->state = HTTP_SERVER_REQUEST_STATE_ABORTED;
}
void http_server_request_abort(struct http_server_request **_req,
- const char *reason)
+ const char *reason)
{
struct http_server_request *req = *_req;
struct http_server_connection *conn = req->conn;
http_server_connection_remove_request(conn, req);
if (!conn->closed) {
- /* send best-effort response if appropriate */
+ /* Send best-effort response if appropriate */
if (!conn->output_locked &&
- req->state >= HTTP_SERVER_REQUEST_STATE_PROCESSING &&
- req->state < HTTP_SERVER_REQUEST_STATE_SENT_RESPONSE) {
+ req->state >= HTTP_SERVER_REQUEST_STATE_PROCESSING &&
+ req->state < HTTP_SERVER_REQUEST_STATE_SENT_RESPONSE) {
static const char *response =
"HTTP/1.1 500 Internal Server Error\r\n"
"Content-Length: 0\r\n"
"\r\n";
o_stream_nsend(conn->conn.output,
- response, strlen(response));
+ response, strlen(response));
(void)o_stream_flush(conn->conn.output);
}
- /* close the connection */
+ /* Close the connection */
http_server_connection_close(&conn, reason);
}
}
req->state = HTTP_SERVER_REQUEST_STATE_ABORTED;
}
-
- if (req->response != NULL &&
- !req->response->payload_blocking) {
+
+ if (req->response != NULL && !req->response->payload_blocking) {
http_server_response_free(req->response);
req->response = NULL;
}
return &req->req;
}
-pool_t
-http_server_request_get_pool(struct http_server_request *req)
+pool_t http_server_request_get_pool(struct http_server_request *req)
{
return req->pool;
}
}
int http_server_request_get_auth(struct http_server_request *req,
- struct http_auth_credentials *credentials)
+ struct http_auth_credentials *credentials)
{
const char *auth;
if (auth == NULL)
return 0;
- if (http_auth_parse_credentials
- ((const unsigned char *)auth, strlen(auth), credentials) < 0)
+ if (http_auth_parse_credentials((const unsigned char *)auth,
+ strlen(auth), credentials) < 0)
return -1;
-
+
return 1;
}
bool http_server_request_is_finished(struct http_server_request *req)
{
- return req->response != NULL ||
- req->state == HTTP_SERVER_REQUEST_STATE_ABORTED;
+ return (req->response != NULL ||
+ req->state == HTTP_SERVER_REQUEST_STATE_ABORTED);
}
bool http_server_request_is_complete(struct http_server_request *req)
{
struct http_server_connection *conn = req->conn;
- i_assert(conn != NULL && req->response != NULL && req->response->submitted);
+ i_assert(conn != NULL && req->response != NULL &&
+ req->response->submitted);
http_server_request_ref(req);
if (tunnel_callback == NULL) {
if (req->connection_close) {
http_server_connection_close(&conn,
- t_strdup_printf("Server closed connection: %u %s",
+ t_strdup_printf(
+ "Server closed connection: %u %s",
resp->status, resp->reason));
http_server_request_destroy(&req);
return;
} else if (req->conn->input_broken) {
- http_server_connection_close(&conn,
- "Connection input is broken");
+ http_server_connection_close(
+ &conn, "Connection input is broken");
http_server_request_destroy(&req);
return;
} else if (req->req.connection_close) {
- http_server_connection_close(&conn,
- "Client requested connection close");
+ http_server_connection_close(
+ &conn, "Client requested connection close");
http_server_request_destroy(&req);
return;
}
http_server_request_destroy(&req);
if (tunnel_callback != NULL) {
- http_server_connection_tunnel(&conn, tunnel_callback, tunnel_context);
+ http_server_connection_tunnel(&conn, tunnel_callback,
+ tunnel_context);
return;
}
-
+
http_server_connection_trigger_responses(conn);
}
static struct http_server_response *
http_server_request_create_fail_response(struct http_server_request *req,
- unsigned int status, const char *reason, const char *text)
- ATTR_NULL(4)
+ unsigned int status,
+ const char *reason, const char *text)
+ ATTR_NULL(4)
{
struct http_server_response *resp;
resp = http_server_response_create(req, status, reason);
if (!http_request_method_is(&req->req, "HEAD")) {
- http_server_response_add_header
- (resp, "Content-Type", "text/plain; charset=utf-8");
+ http_server_response_add_header(resp, "Content-Type",
+ "text/plain; charset=utf-8");
if (text == NULL)
text = reason;
text = t_strconcat(text, "\r\n", NULL);
- http_server_response_set_payload_data
- (resp, (const unsigned char *)text, strlen(text));
+ http_server_response_set_payload_data(
+ resp, (const unsigned char *)text, strlen(text));
}
return resp;
static void
http_server_request_fail_full(struct http_server_request *req,
- unsigned int status, const char *reason, const char *text)
- ATTR_NULL(4)
+ unsigned int status, const char *reason,
+ const char *text) ATTR_NULL(4)
{
struct http_server_response *resp;
req->failed = TRUE;
- resp = http_server_request_create_fail_response(req,
- status, reason, text);
+ resp = http_server_request_create_fail_response(req, status, reason,
+ text);
http_server_response_submit(resp);
if (req->conn->input_broken)
req->connection_close = TRUE;
}
void http_server_request_fail(struct http_server_request *req,
- unsigned int status, const char *reason)
+ unsigned int status, const char *reason)
{
http_server_request_fail_full(req, status, reason, NULL);
}
void http_server_request_fail_close(struct http_server_request *req,
- unsigned int status, const char *reason)
+ unsigned int status, const char *reason)
{
http_server_request_connection_close(req, TRUE);
http_server_request_fail_full(req, status, reason, NULL);
}
void http_server_request_fail_text(struct http_server_request *req,
- unsigned int status, const char *reason, const char *format, ...)
+ unsigned int status, const char *reason,
+ const char *format, ...)
{
va_list args;
}
void http_server_request_fail_auth(struct http_server_request *req,
- const char *reason, const struct http_auth_challenge *chlng)
+ const char *reason,
+ const struct http_auth_challenge *chlng)
{
struct http_server_response *resp;
if (reason == NULL)
reason = "Unauthenticated";
- resp = http_server_request_create_fail_response(req,
- 401, reason, reason);
+ resp = http_server_request_create_fail_response(req, 401, reason,
+ reason);
http_server_response_add_auth(resp, chlng);
http_server_response_submit(resp);
}
void http_server_request_fail_auth_basic(struct http_server_request *req,
- const char *reason, const char *realm)
+ const char *reason, const char *realm)
{
struct http_auth_challenge chlng;
struct http_server *server = hsristream->req->server;
ssize_t ret;
- if ((ret=i_stream_read_copy_from_parent
- (&stream->istream)) > 0) {
+ if ((ret = i_stream_read_copy_from_parent(&stream->istream)) > 0) {
hsristream->read_status = ret;
io_loop_stop(server->ioloop);
}
ssize_t ret;
if (req == NULL) {
- /* request already gone (we shouldn't get here) */
+ /* Request already gone (we shouldn't get here) */
stream->istream.stream_errno = EINVAL;
return -1;
}
http_server_connection_switch_ioloop(conn);
if (blocking && req->req.expect_100_continue &&
- !req->sent_100_continue)
+ !req->sent_100_continue)
http_server_connection_trigger_responses(conn);
hsristream->read_status = 0;
io = io_add_istream(&stream->istream,
- http_server_istream_read_any, hsristream);
+ http_server_istream_read_any, hsristream);
while (req->state < HTTP_SERVER_REQUEST_STATE_FINISHED &&
hsristream->read_status == 0) {
io_loop_run(server->ioloop);
v_offset = hsristream->istream.parent_start_offset +
hsristream->istream.istream.v_offset;
if (hsristream->istream.parent->seekable ||
- v_offset > hsristream->istream.parent->v_offset) {
- /* get to same position in parent stream */
+ v_offset > hsristream->istream.parent->v_offset) {
+ /* Get to same position in parent stream */
i_stream_seek(hsristream->istream.parent, v_offset);
}
}
struct istream *
http_server_request_get_payload_input(struct http_server_request *req,
- bool blocking)
+ bool blocking)
{
struct http_server_istream *hsristream;
struct istream *payload = req->req.payload;
hsristream->istream.stream_size_passthrough = TRUE;
hsristream->istream.read = http_server_istream_read;
- hsristream->istream.switch_ioloop_to = http_server_istream_switch_ioloop_to;
+ hsristream->istream.switch_ioloop_to =
+ http_server_istream_switch_ioloop_to;
hsristream->istream.iostream.destroy = http_server_istream_destroy;
hsristream->istream.istream.readable_fd = FALSE;
hsristream->istream.istream.blocking = blocking;
hsristream->istream.istream.seekable = FALSE;
- req->payload_input = i_stream_create
- (&hsristream->istream, payload, i_stream_get_fd(payload), 0);
+ req->payload_input = i_stream_create(&hsristream->istream, payload,
+ i_stream_get_fd(payload), 0);
i_stream_unref(&req->req.payload);
return req->payload_input;
}
*/
static void
-http_server_payload_handler_init(
- struct http_server_payload_handler *handler ,
- struct http_server_request *req)
+http_server_payload_handler_init(struct http_server_payload_handler *handler,
+ struct http_server_request *req)
{
struct http_server_connection *conn = req->conn;
struct http_server_connection *conn = handler->req->conn;
if (handler->in_callback) {
- /* don't destroy handler while in callback */
+ /* Don't destroy handler while in callback */
return;
}
handler->switch_ioloop(handler);
}
-/* pump-based */
+/* Pump-based */
struct http_server_payload_handler_pump {
struct http_server_payload_handler handler;
};
static void
-payload_handler_pump_destroy(
- struct http_server_payload_handler *handler)
+payload_handler_pump_destroy(struct http_server_payload_handler *handler)
{
struct http_server_payload_handler_pump *phandler =
(struct http_server_payload_handler_pump *)handler;
}
static void
-payload_handler_pump_switch_ioloop(
- struct http_server_payload_handler *handler)
+payload_handler_pump_switch_ioloop(struct http_server_payload_handler *handler)
{
struct http_server_payload_handler_pump *phandler =
(struct http_server_payload_handler_pump *)handler;
static void
payload_handler_pump_callback(enum iostream_pump_status status,
- struct http_server_payload_handler_pump *phandler)
+ struct http_server_payload_handler_pump *phandler)
{
struct http_server_payload_handler *handler = &phandler->handler;
struct http_server_request *req = handler->req;
switch (status) {
case IOSTREAM_PUMP_STATUS_INPUT_EOF:
if (!i_stream_read_eof(conn->incoming_payload)) {
- http_server_request_fail_close(req,
- 413, "Payload Too Large");
+ http_server_request_fail_close(req, 413,
+ "Payload Too Large");
} else {
unsigned int old_refcount = req->refcount;
handler->in_callback = FALSE;
i_assert(req->callback_refcount > 0 ||
- (req->response != NULL && req->response->submitted));
+ (req->response != NULL &&
+ req->response->submitted));
}
break;
case IOSTREAM_PUMP_STATUS_INPUT_ERROR:
- http_server_request_client_error(req,
- "iostream_pump: read(%s) failed: %s",
- i_stream_get_name(input),
- i_stream_get_error(input));
- http_server_request_fail_close(req,
- 400, "Bad Request");
+ http_server_request_client_error(
+ req, "iostream_pump: read(%s) failed: %s",
+ i_stream_get_name(input), i_stream_get_error(input));
+ http_server_request_fail_close(req, 400, "Bad Request");
break;
case IOSTREAM_PUMP_STATUS_OUTPUT_ERROR:
if (output->stream_errno != 0) {
- http_server_request_error(req,
- "iostream_pump: write(%s) failed: %s",
+ http_server_request_error(
+ req, "iostream_pump: write(%s) failed: %s",
o_stream_get_name(output),
o_stream_get_error(output));
}
- http_server_request_fail_close(req,
- 500, "Internal Server Error");
+ http_server_request_fail_close(req, 500,
+ "Internal Server Error");
break;
}
#undef http_server_request_forward_payload
void http_server_request_forward_payload(struct http_server_request *req,
- struct ostream *output, uoff_t max_size,
- void (*callback)(void *), void *context)
+ struct ostream *output,
+ uoff_t max_size,
+ void (*callback)(void *),
+ void *context)
{
struct http_server_connection *conn = req->conn;
struct istream *input = conn->incoming_payload;
if (max_size == (uoff_t)-1) {
i_stream_ref(input);
} else {
- if ((ret = i_stream_get_size(input, TRUE, &payload_size)) != 0) {
+ if ((ret = i_stream_get_size(input, TRUE,
+ &payload_size)) != 0) {
if (ret < 0) {
- http_server_request_error(req,
- "i_stream_get_size(%s) failed: %s",
- i_stream_get_name(input), i_stream_get_error(input));
- http_server_request_fail_close(req,
- 500, "Internal Server Error");
+ http_server_request_error(
+ req, "i_stream_get_size(%s) failed: %s",
+ i_stream_get_name(input),
+ i_stream_get_error(input));
+ http_server_request_fail_close(
+ req, 500, "Internal Server Error");
return;
}
if (payload_size > max_size) {
- http_server_request_fail_close(req,
- 413, "Payload Too Large");
+ http_server_request_fail_close(
+ req, 413, "Payload Too Large");
return;
}
}
phandler->pump = iostream_pump_create(input, output);
iostream_pump_set_completion_callback(phandler->pump,
- payload_handler_pump_callback, phandler);
+ payload_handler_pump_callback,
+ phandler);
iostream_pump_start(phandler->pump);
i_stream_unref(&input);
}
#undef http_server_request_buffer_payload
void http_server_request_buffer_payload(struct http_server_request *req,
- buffer_t *buffer, uoff_t max_size,
- void (*callback)(void *), void *context)
+ buffer_t *buffer, uoff_t max_size,
+ void (*callback)(void *),
+ void *context)
{
struct ostream *output;
o_stream_unref(&output);
}
-/* raw */
+/* Raw */
struct http_server_payload_handler_raw {
struct http_server_payload_handler handler;
};
static void
-payload_handler_raw_destroy(
- struct http_server_payload_handler *handler)
+payload_handler_raw_destroy(struct http_server_payload_handler *handler)
{
struct http_server_payload_handler_raw *rhandler =
(struct http_server_payload_handler_raw *)handler;
}
static void
-payload_handler_raw_switch_ioloop(
- struct http_server_payload_handler *handler)
+payload_handler_raw_switch_ioloop(struct http_server_payload_handler *handler)
{
struct http_server_payload_handler_raw *rhandler =
(struct http_server_payload_handler_raw *)handler;
}
static void
-payload_handler_raw_input(
- struct http_server_payload_handler_raw *rhandler)
+payload_handler_raw_input(struct http_server_payload_handler_raw *rhandler)
{
struct http_server_payload_handler *handler = &rhandler->handler;
struct http_server_request *req = handler->req;
if (input != NULL && input->stream_errno != 0) {
if (req->response == NULL) {
- http_server_request_client_error(req,
- "read(%s) failed: %s",
+ http_server_request_client_error(
+ req, "read(%s) failed: %s",
i_stream_get_name(input),
i_stream_get_error(input));
- http_server_request_fail_close(req,
- 400, "Bad Request");
+ http_server_request_fail_close(req, 400, "Bad Request");
}
- } else if (input == NULL ||
- !i_stream_have_bytes_left(input)) {
+ } else if (input == NULL || !i_stream_have_bytes_left(input)) {
i_assert(req->callback_refcount > 0 ||
- (req->response != NULL && req->response->submitted));
+ (req->response != NULL && req->response->submitted));
} else {
return;
}
#undef http_server_request_handle_payload
void http_server_request_handle_payload(struct http_server_request *req,
- void (*callback)(void *context), void *context)
+ void (*callback)(void *context),
+ void *context)
{
struct http_server_payload_handler_raw *rhandler;
struct http_server_connection *conn = req->conn;
rhandler->context = context;
rhandler->io = io_add_istream(conn->incoming_payload,
- payload_handler_raw_input, rhandler);
+ payload_handler_raw_input, rhandler);
i_stream_set_input_pending(conn->incoming_payload, TRUE);
}
projects / thirdparty / dovecot / core.git / commitdiff
