| /* Copyright 2002-2004 Justin Erenkrantz and Greg Stein |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <apr_pools.h> |
| #include <apr_poll.h> |
| #include <apr_version.h> |
| |
| #include "serf.h" |
| #include "serf_bucket_util.h" |
| |
| #include "serf_private.h" |
| |
| /* Older versions of APR do not have the APR_VERSION_AT_LEAST macro. Those |
| implementations are safe. |
| |
| If the macro *is* defined, and we're on WIN32, and APR is version 1.4.0, |
| then we have a broken WSAPoll() implementation. |
| |
| See serf_context_create_ex() below. */ |
| #if defined(APR_VERSION_AT_LEAST) && defined(WIN32) |
| #if APR_VERSION_AT_LEAST(1,4,0) |
| #define BROKEN_WSAPOLL |
| #endif |
| #endif |
| |
| |
| /** |
| * Callback function (implements serf_progress_t). Takes a number of bytes |
| * read @a read and bytes written @a written, adds those to the total for this |
| * context and notifies an interested party (if any). |
| */ |
| void serf__context_progress_delta( |
| void *progress_baton, |
| apr_off_t read, |
| apr_off_t written) |
| { |
| serf_context_t *ctx = progress_baton; |
| |
| ctx->progress_read += read; |
| ctx->progress_written += written; |
| |
| if (ctx->progress_func) |
| ctx->progress_func(ctx->progress_baton, |
| ctx->progress_read, |
| ctx->progress_written); |
| } |
| |
| |
| /* Check for dirty connections and update their pollsets accordingly. */ |
| static apr_status_t check_dirty_pollsets(serf_context_t *ctx) |
| { |
| int i; |
| |
| /* if we're not dirty, return now. */ |
| if (!ctx->dirty_pollset) { |
| return APR_SUCCESS; |
| } |
| |
| for (i = ctx->conns->nelts; i--; ) { |
| serf_connection_t *conn = GET_CONN(ctx, i); |
| apr_status_t status; |
| |
| /* if this connection isn't dirty, skip it. */ |
| if (!conn->dirty_conn) { |
| continue; |
| } |
| |
| /* reset this connection's flag before we update. */ |
| conn->dirty_conn = 0; |
| |
| if ((status = serf__conn_update_pollset(conn)) != APR_SUCCESS) |
| return status; |
| } |
| |
| /* reset our context flag now */ |
| ctx->dirty_pollset = 0; |
| |
| return APR_SUCCESS; |
| } |
| |
| |
| static apr_status_t pollset_add(void *user_baton, |
| apr_pollfd_t *pfd, |
| void *serf_baton) |
| { |
| serf_pollset_t *s = (serf_pollset_t*)user_baton; |
| pfd->client_data = serf_baton; |
| return apr_pollset_add(s->pollset, pfd); |
| } |
| |
| static apr_status_t pollset_rm(void *user_baton, |
| apr_pollfd_t *pfd, |
| void *serf_baton) |
| { |
| serf_pollset_t *s = (serf_pollset_t*)user_baton; |
| pfd->client_data = serf_baton; |
| return apr_pollset_remove(s->pollset, pfd); |
| } |
| |
| |
| void serf_config_proxy(serf_context_t *ctx, |
| apr_sockaddr_t *address) |
| { |
| ctx->proxy_address = address; |
| } |
| |
| |
| void serf_config_credentials_callback(serf_context_t *ctx, |
| serf_credentials_callback_t cred_cb) |
| { |
| ctx->cred_cb = cred_cb; |
| } |
| |
| |
| void serf_config_authn_types(serf_context_t *ctx, |
| int authn_types) |
| { |
| ctx->authn_types = authn_types; |
| } |
| |
| |
| serf_context_t *serf_context_create_ex( |
| void *user_baton, |
| serf_socket_add_t addf, |
| serf_socket_remove_t rmf, |
| apr_pool_t *pool) |
| { |
| serf_context_t *ctx = apr_pcalloc(pool, sizeof(*ctx)); |
| |
| ctx->pool = pool; |
| |
| if (user_baton != NULL) { |
| ctx->pollset_baton = user_baton; |
| ctx->pollset_add = addf; |
| ctx->pollset_rm = rmf; |
| } |
| else { |
| /* build the pollset with a (default) number of connections */ |
| serf_pollset_t *ps = apr_pcalloc(pool, sizeof(*ps)); |
| #ifdef BROKEN_WSAPOLL |
| /* APR 1.4.x switched to using WSAPoll() on Win32, but it does not |
| * properly handle errors on a non-blocking sockets (such as |
| * connecting to a server where no listener is active). |
| * |
| * So, sadly, we must force using select() on Win32. |
| * |
| * http://mail-archives.apache.org/mod_mbox/apr-dev/201105.mbox/%3CBANLkTin3rBCecCBRvzUA5B-14u-NWxR_Kg@mail.gmail.com%3E |
| */ |
| (void) apr_pollset_create_ex(&ps->pollset, MAX_CONN, pool, 0, |
| APR_POLLSET_SELECT); |
| #else |
| (void) apr_pollset_create(&ps->pollset, MAX_CONN, pool, 0); |
| #endif |
| ctx->pollset_baton = ps; |
| ctx->pollset_add = pollset_add; |
| ctx->pollset_rm = pollset_rm; |
| } |
| |
| /* default to a single connection since that is the typical case */ |
| ctx->conns = apr_array_make(pool, 1, sizeof(serf_connection_t *)); |
| |
| /* Initialize progress status */ |
| ctx->progress_read = 0; |
| ctx->progress_written = 0; |
| |
| ctx->authn_types = SERF_AUTHN_ALL; |
| |
| return ctx; |
| } |
| |
| |
| serf_context_t *serf_context_create(apr_pool_t *pool) |
| { |
| return serf_context_create_ex(NULL, NULL, NULL, pool); |
| } |
| |
| apr_status_t serf_context_prerun(serf_context_t *ctx) |
| { |
| apr_status_t status = APR_SUCCESS; |
| if ((status = serf__open_connections(ctx)) != APR_SUCCESS) |
| return status; |
| |
| if ((status = check_dirty_pollsets(ctx)) != APR_SUCCESS) |
| return status; |
| return status; |
| } |
| |
| |
| apr_status_t serf_event_trigger( |
| serf_context_t *s, |
| void *serf_baton, |
| const apr_pollfd_t *desc) |
| { |
| apr_pollfd_t tdesc = { 0 }; |
| apr_status_t status = APR_SUCCESS; |
| serf_io_baton_t *io = serf_baton; |
| |
| if (io->type == SERF_IO_CONN) { |
| serf_connection_t *conn = io->u.conn; |
| serf_context_t *ctx = conn->ctx; |
| |
| /* If this connection has already failed, return the error again, and try |
| * to remove it from the pollset again |
| */ |
| if (conn->status) { |
| tdesc.desc_type = APR_POLL_SOCKET; |
| tdesc.desc.s = conn->skt; |
| tdesc.reqevents = conn->reqevents; |
| ctx->pollset_rm(ctx->pollset_baton, |
| &tdesc, conn); |
| return conn->status; |
| } |
| /* apr_pollset_poll() can return a conn multiple times... */ |
| if ((conn->seen_in_pollset & desc->rtnevents) != 0 || |
| (conn->seen_in_pollset & APR_POLLHUP) != 0) { |
| return APR_SUCCESS; |
| } |
| |
| conn->seen_in_pollset |= desc->rtnevents; |
| |
| if ((conn->status = serf__process_connection(conn, |
| desc->rtnevents)) != APR_SUCCESS) { |
| |
| /* it's possible that the connection was already reset and thus the |
| socket cleaned up. */ |
| if (conn->skt) { |
| tdesc.desc_type = APR_POLL_SOCKET; |
| tdesc.desc.s = conn->skt; |
| tdesc.reqevents = conn->reqevents; |
| ctx->pollset_rm(ctx->pollset_baton, |
| &tdesc, conn); |
| } |
| return conn->status; |
| } |
| } |
| else if (io->type == SERF_IO_LISTENER) { |
| serf_listener_t *l = io->u.listener; |
| |
| status = serf__process_listener(l); |
| |
| if (status) { |
| return status; |
| } |
| } |
| else if (io->type == SERF_IO_CLIENT) { |
| serf_incoming_t *c = io->u.client; |
| |
| status = serf__process_client(c, desc->rtnevents); |
| |
| if (status) { |
| return status; |
| } |
| } |
| return status; |
| } |
| |
| |
| apr_status_t serf_context_run( |
| serf_context_t *ctx, |
| apr_short_interval_time_t duration, |
| apr_pool_t *pool) |
| { |
| apr_status_t status; |
| apr_int32_t num; |
| const apr_pollfd_t *desc; |
| serf_pollset_t *ps = (serf_pollset_t*)ctx->pollset_baton; |
| |
| if ((status = serf_context_prerun(ctx)) != APR_SUCCESS) { |
| return status; |
| } |
| |
| if ((status = apr_pollset_poll(ps->pollset, duration, &num, |
| &desc)) != APR_SUCCESS) { |
| /* ### do we still need to dispatch stuff here? |
| ### look at the potential return codes. map to our defined |
| ### return values? ... |
| */ |
| return status; |
| } |
| |
| while (num--) { |
| serf_connection_t *conn = desc->client_data; |
| |
| status = serf_event_trigger(ctx, conn, desc); |
| if (status) { |
| return status; |
| } |
| |
| desc++; |
| } |
| |
| return APR_SUCCESS; |
| } |
| |
| |
| void serf_context_set_progress_cb( |
| serf_context_t *ctx, |
| const serf_progress_t progress_func, |
| void *progress_baton) |
| { |
| ctx->progress_func = progress_func; |
| ctx->progress_baton = progress_baton; |
| } |
| |
| |
| serf_bucket_t *serf_context_bucket_socket_create( |
| serf_context_t *ctx, |
| apr_socket_t *skt, |
| serf_bucket_alloc_t *allocator) |
| { |
| serf_bucket_t *bucket = serf_bucket_socket_create(skt, allocator); |
| |
| /* Use serf's default bytes read/written callback */ |
| serf_bucket_socket_set_read_progress_cb(bucket, |
| serf__context_progress_delta, |
| ctx); |
| |
| return bucket; |
| } |
| |
| |
| /* ### this really ought to go somewhere else, but... meh. */ |
| void serf_lib_version(int *major, int *minor, int *patch) |
| { |
| *major = SERF_MAJOR_VERSION; |
| *minor = SERF_MINOR_VERSION; |
| *patch = SERF_PATCH_VERSION; |
| } |
| |
| |
| const char *serf_error_string(apr_status_t errcode) |
| { |
| switch (errcode) |
| { |
| case SERF_ERROR_CLOSING: |
| return "The connection is closing"; |
| case SERF_ERROR_REQUEST_LOST: |
| return "A request has been lost"; |
| case SERF_ERROR_WAIT_CONN: |
| return "The connection is blocked, pending further action"; |
| case SERF_ERROR_DECOMPRESSION_FAILED: |
| return "An error occurred during decompression"; |
| case SERF_ERROR_BAD_HTTP_RESPONSE: |
| return "The server sent an improper HTTP response"; |
| case SERF_ERROR_AUTHN_FAILED: |
| return "An error occurred during authentication"; |
| case SERF_ERROR_AUTHN_NOT_SUPPORTED: |
| return "The requested authentication type(s) are not supported"; |
| case SERF_ERROR_AUTHN_MISSING_ATTRIBUTE: |
| return "An authentication attribute is missing"; |
| case SERF_ERROR_AUTHN_INITALIZATION_FAILED: |
| return "Initialization of an authentication type failed"; |
| |
| default: |
| return NULL; |
| } |
| |
| /* NOTREACHED */ |
| } |