1 /* Copyright 2002-2004 Justin Erenkrantz and Greg Stein
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
16 #include <apr_pools.h>
18 #include <apr_version.h>
19 #include <apr_portable.h>
22 #include "serf_bucket_util.h"
24 #include "serf_private.h"
26 /* cleanup for sockets */
27 static apr_status_t clean_skt(void *data)
29 serf_connection_t *conn = data;
30 apr_status_t status = APR_SUCCESS;
33 serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt, "cleanup - ");
34 status = apr_socket_close(conn->skt);
36 serf__log_nopref(SOCK_VERBOSE, "closed socket, status %d\n", status);
42 static apr_status_t clean_resp(void *data)
44 serf_request_t *request = data;
46 /* The request's RESPOOL is being cleared. */
48 /* If the response has allocated some buckets, then destroy them (since
49 the bucket may hold resources other than memory in RESPOOL). Also
50 make sure to set their fields to NULL so connection closure does
51 not attempt to free them again. */
52 if (request->resp_bkt) {
53 serf_bucket_destroy(request->resp_bkt);
54 request->resp_bkt = NULL;
56 if (request->req_bkt) {
57 serf_bucket_destroy(request->req_bkt);
58 request->req_bkt = NULL;
61 /* ### should we worry about debug stuff, like that performed in
62 ### destroy_request()? should we worry about calling req->handler
63 ### to notify this "cancellation" due to pool clearing? */
65 /* This pool just got cleared/destroyed. Don't try to destroy the pool
66 (again) when the request is canceled. */
67 request->respool = NULL;
72 /* cleanup for conns */
73 static apr_status_t clean_conn(void *data)
75 serf_connection_t *conn = data;
77 serf__log(CONN_VERBOSE, __FILE__, "cleaning up connection 0x%x\n",
79 serf_connection_close(conn);
84 /* Check if there is data waiting to be sent over the socket. This can happen
86 - The connection queue has atleast one request with unwritten data.
87 - All requests are written and the ssl layer wrote some data while reading
88 the response. This can happen when the server triggers a renegotiation,
89 e.g. after the first and only request on that connection was received.
90 Returns 1 if data is pending on CONN, NULL if not.
91 If NEXT_REQ is not NULL, it will be filled in with the next available request
92 with unwritten data. */
94 request_or_data_pending(serf_request_t **next_req, serf_connection_t *conn)
96 serf_request_t *request = conn->requests;
98 while (request != NULL && request->req_bkt == NULL &&
99 request->writing_started)
100 request = request->next;
105 if (request != NULL) {
107 } else if (conn->ostream_head) {
112 status = serf_bucket_peek(conn->ostream_head, &dummy,
114 if (!SERF_BUCKET_READ_ERROR(status) && len) {
115 serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,
116 "All requests written but still data pending.\n");
124 /* Update the pollset for this connection. We tweak the pollset based on
125 * whether we want to read and/or write, given conditions within the
126 * connection. If the connection is not (yet) in the pollset, then it
129 apr_status_t serf__conn_update_pollset(serf_connection_t *conn)
131 serf_context_t *ctx = conn->ctx;
133 apr_pollfd_t desc = { 0 };
139 /* Remove the socket from the poll set. */
140 desc.desc_type = APR_POLL_SOCKET;
141 desc.desc.s = conn->skt;
142 desc.reqevents = conn->reqevents;
144 status = ctx->pollset_rm(ctx->pollset_baton,
146 if (status && !APR_STATUS_IS_NOTFOUND(status))
149 /* Now put it back in with the correct read/write values. */
150 desc.reqevents = APR_POLLHUP | APR_POLLERR;
151 if (conn->requests &&
152 conn->state != SERF_CONN_INIT) {
153 /* If there are any outstanding events, then we want to read. */
154 /* ### not true. we only want to read IF we have sent some data */
155 desc.reqevents |= APR_POLLIN;
157 /* Don't write if OpenSSL told us that it needs to read data first. */
158 if (conn->stop_writing != 1) {
160 /* If the connection is not closing down and
161 * has unwritten data or
162 * there are any requests that still have buckets to write out,
163 * then we want to write.
166 conn->state != SERF_CONN_CLOSING)
167 desc.reqevents |= APR_POLLOUT;
170 if ((conn->probable_keepalive_limit &&
171 conn->completed_requests > conn->probable_keepalive_limit) ||
172 (conn->max_outstanding_requests &&
173 conn->completed_requests - conn->completed_responses >=
174 conn->max_outstanding_requests)) {
175 /* we wouldn't try to write any way right now. */
177 else if (request_or_data_pending(NULL, conn)) {
178 desc.reqevents |= APR_POLLOUT;
184 /* If we can have async responses, always look for something to read. */
185 if (conn->async_responses) {
186 desc.reqevents |= APR_POLLIN;
189 /* save our reqevents, so we can pass it in to remove later. */
190 conn->reqevents = desc.reqevents;
192 /* Note: even if we don't want to read/write this socket, we still
193 * want to poll it for hangups and errors.
195 return ctx->pollset_add(ctx->pollset_baton,
196 &desc, &conn->baton);
199 #ifdef SERF_DEBUG_BUCKET_USE
201 /* Make sure all response buckets were drained. */
202 static void check_buckets_drained(serf_connection_t *conn)
204 serf_request_t *request = conn->requests;
206 for ( ; request ; request = request->next ) {
207 if (request->resp_bkt != NULL) {
208 /* ### crap. can't do this. this allocator may have un-drained
209 * ### REQUEST buckets.
211 /* serf_debug__entered_loop(request->resp_bkt->allocator); */
212 /* ### for now, pretend we closed the conn (resets the tracking) */
213 serf_debug__closed_conn(request->resp_bkt->allocator);
220 static void destroy_ostream(serf_connection_t *conn)
222 if (conn->ostream_head != NULL) {
223 serf_bucket_destroy(conn->ostream_head);
224 conn->ostream_head = NULL;
225 conn->ostream_tail = NULL;
229 static apr_status_t detect_eof(void *baton, serf_bucket_t *aggregate_bucket)
231 serf_connection_t *conn = baton;
236 static apr_status_t do_conn_setup(serf_connection_t *conn)
239 serf_bucket_t *ostream;
241 if (conn->ostream_head == NULL) {
242 conn->ostream_head = serf_bucket_aggregate_create(conn->allocator);
245 if (conn->ostream_tail == NULL) {
246 conn->ostream_tail = serf__bucket_stream_create(conn->allocator,
251 ostream = conn->ostream_tail;
253 status = (*conn->setup)(conn->skt,
259 /* extra destroy here since it wasn't added to the head bucket yet. */
260 serf_bucket_destroy(conn->ostream_tail);
261 destroy_ostream(conn);
265 serf_bucket_aggregate_append(conn->ostream_head,
271 /* Set up the input and output stream buckets.
272 When a tunnel over an http proxy is needed, create a socket bucket and
273 empty aggregate bucket for sending and receiving unencrypted requests
276 After the tunnel is there, or no tunnel was needed, ask the application
277 to create the input and output buckets, which should take care of the
281 static apr_status_t prepare_conn_streams(serf_connection_t *conn,
282 serf_bucket_t **istream,
283 serf_bucket_t **ostreamt,
284 serf_bucket_t **ostreamh)
288 if (conn->stream == NULL) {
289 conn->latency = apr_time_now() - conn->connect_time;
292 /* Do we need a SSL tunnel first? */
293 if (conn->state == SERF_CONN_CONNECTED) {
294 /* If the connection does not have an associated bucket, then
295 * call the setup callback to get one.
297 if (conn->stream == NULL) {
298 status = do_conn_setup(conn);
303 *ostreamt = conn->ostream_tail;
304 *ostreamh = conn->ostream_head;
305 *istream = conn->stream;
307 /* SSL tunnel needed and not set up yet, get a direct unencrypted
308 stream for this socket */
309 if (conn->stream == NULL) {
310 *istream = serf_bucket_socket_create(conn->skt,
313 /* Don't create the ostream bucket chain including the ssl_encrypt
314 bucket yet. This ensure the CONNECT request is sent unencrypted
316 *ostreamt = *ostreamh = conn->ssltunnel_ostream;
322 /* Create and connect sockets for any connections which don't have them
323 * yet. This is the core of our lazy-connect behavior.
325 apr_status_t serf__open_connections(serf_context_t *ctx)
329 for (i = ctx->conns->nelts; i--; ) {
330 serf_connection_t *conn = GET_CONN(ctx, i);
331 serf__authn_info_t *authn_info;
335 conn->seen_in_pollset = 0;
337 if (conn->skt != NULL) {
338 #ifdef SERF_DEBUG_BUCKET_USE
339 check_buckets_drained(conn);
344 /* Delay opening until we have something to deliver! */
345 if (conn->requests == NULL) {
349 apr_pool_clear(conn->skt_pool);
350 apr_pool_cleanup_register(conn->skt_pool, conn, clean_skt, clean_skt);
352 status = apr_socket_create(&skt, conn->address->family,
354 #if APR_MAJOR_VERSION > 0
358 serf__log(SOCK_VERBOSE, __FILE__,
359 "created socket for conn 0x%x, status %d\n", conn, status);
360 if (status != APR_SUCCESS)
363 /* Set the socket to be non-blocking */
364 if ((status = apr_socket_timeout_set(skt, 0)) != APR_SUCCESS)
367 /* Disable Nagle's algorithm */
368 if ((status = apr_socket_opt_set(skt,
369 APR_TCP_NODELAY, 1)) != APR_SUCCESS)
372 /* Configured. Store it into the connection now. */
375 /* Remember time when we started connecting to server to calculate
377 conn->connect_time = apr_time_now();
379 /* Now that the socket is set up, let's connect it. This should
380 * return immediately.
382 status = apr_socket_connect(skt, conn->address);
383 serf__log_skt(SOCK_VERBOSE, __FILE__, skt,
384 "connected socket for conn 0x%x, status %d\n",
386 if (status != APR_SUCCESS) {
387 if (!APR_STATUS_IS_EINPROGRESS(status))
391 /* Flag our pollset as dirty now that we have a new socket. */
392 conn->dirty_conn = 1;
393 ctx->dirty_pollset = 1;
395 /* If the authentication was already started on another connection,
396 prepare this connection (it might be possible to skip some
397 part of the handshaking). */
398 if (ctx->proxy_address) {
399 authn_info = &ctx->proxy_authn_info;
400 if (authn_info->scheme) {
401 authn_info->scheme->init_conn_func(authn_info->scheme, 407,
406 authn_info = serf__get_authn_info_for_server(conn);
407 if (authn_info->scheme) {
408 authn_info->scheme->init_conn_func(authn_info->scheme, 401,
412 /* Does this connection require a SSL tunnel over the proxy? */
413 if (ctx->proxy_address && strcmp(conn->host_info.scheme, "https") == 0)
414 serf__ssltunnel_connect(conn);
416 serf_bucket_t *dummy1, *dummy2;
418 conn->state = SERF_CONN_CONNECTED;
420 status = prepare_conn_streams(conn, &conn->stream,
431 static apr_status_t no_more_writes(serf_connection_t *conn)
433 /* Note that we should hold new requests until we open our new socket. */
434 conn->state = SERF_CONN_CLOSING;
435 serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,
436 "stop writing on conn 0x%x\n", conn);
438 /* Clear our iovec. */
441 /* Update the pollset to know we don't want to write on this socket any
444 conn->dirty_conn = 1;
445 conn->ctx->dirty_pollset = 1;
449 /* Read the 'Connection' header from the response. Return SERF_ERROR_CLOSING if
450 * the header contains value 'close' indicating the server is closing the
451 * connection right after this response.
452 * Otherwise returns APR_SUCCESS.
454 static apr_status_t is_conn_closing(serf_bucket_t *response)
459 hdrs = serf_bucket_response_get_headers(response);
460 val = serf_bucket_headers_get(hdrs, "Connection");
461 if (val && strcasecmp("close", val) == 0)
463 return SERF_ERROR_CLOSING;
469 static void link_requests(serf_request_t **list, serf_request_t **tail,
470 serf_request_t *request)
477 (*tail)->next = request;
482 static apr_status_t destroy_request(serf_request_t *request)
484 serf_connection_t *conn = request->conn;
486 /* The request and response buckets are no longer needed,
487 nor is the request's pool. */
488 if (request->resp_bkt) {
489 serf_debug__closed_conn(request->resp_bkt->allocator);
490 serf_bucket_destroy(request->resp_bkt);
491 request->resp_bkt = NULL;
493 if (request->req_bkt) {
494 serf_debug__closed_conn(request->req_bkt->allocator);
495 serf_bucket_destroy(request->req_bkt);
496 request->req_bkt = NULL;
499 serf_debug__bucket_alloc_check(request->allocator);
500 if (request->respool) {
501 /* ### unregister the pool cleanup for self? */
502 apr_pool_destroy(request->respool);
505 serf_bucket_mem_free(conn->allocator, request);
510 static apr_status_t cancel_request(serf_request_t *request,
511 serf_request_t **list,
514 /* If we haven't run setup, then we won't have a handler to call. */
515 if (request->handler && notify_request) {
516 /* We actually don't care what the handler returns.
517 * We have bigger matters at hand.
519 (*request->handler)(request, NULL, request->handler_baton,
523 if (*list == request) {
524 *list = request->next;
527 serf_request_t *scan = *list;
529 while (scan->next && scan->next != request)
533 scan->next = scan->next->next;
537 return destroy_request(request);
540 static apr_status_t remove_connection(serf_context_t *ctx,
541 serf_connection_t *conn)
543 apr_pollfd_t desc = { 0 };
545 desc.desc_type = APR_POLL_SOCKET;
546 desc.desc.s = conn->skt;
547 desc.reqevents = conn->reqevents;
549 return ctx->pollset_rm(ctx->pollset_baton,
553 /* A socket was closed, inform the application. */
554 static void handle_conn_closed(serf_connection_t *conn, apr_status_t status)
556 (*conn->closed)(conn, conn->closed_baton, status,
560 static apr_status_t reset_connection(serf_connection_t *conn,
561 int requeue_requests)
563 serf_context_t *ctx = conn->ctx;
565 serf_request_t *old_reqs;
567 conn->probable_keepalive_limit = conn->completed_responses;
568 conn->completed_requests = 0;
569 conn->completed_responses = 0;
571 old_reqs = conn->requests;
573 conn->requests = NULL;
574 conn->requests_tail = NULL;
576 /* Handle all outstanding requests. These have either not been written yet,
577 or have been written but the expected reply wasn't received yet. */
579 /* If we haven't started to write the connection, bring it over
580 * unchanged to our new socket.
581 * Do not copy a CONNECT request to the new connection, the ssl tunnel
582 * setup code will create a new CONNECT request already.
584 if (requeue_requests && !old_reqs->writing_started &&
585 !old_reqs->ssltunnel) {
587 serf_request_t *req = old_reqs;
588 old_reqs = old_reqs->next;
590 link_requests(&conn->requests, &conn->requests_tail, req);
593 /* Request has been consumed, or we don't want to requeue the
594 request. Either way, inform the application that the request
596 cancel_request(old_reqs, &old_reqs, requeue_requests);
600 /* Requests queue has been prepared for a new socket, close the old one. */
601 if (conn->skt != NULL) {
602 remove_connection(ctx, conn);
603 status = apr_socket_close(conn->skt);
604 serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt,
605 "closed socket, status %d\n", status);
606 if (conn->closed != NULL) {
607 handle_conn_closed(conn, status);
612 if (conn->stream != NULL) {
613 serf_bucket_destroy(conn->stream);
617 destroy_ostream(conn);
619 /* Don't try to resume any writes */
622 conn->dirty_conn = 1;
623 conn->ctx->dirty_pollset = 1;
624 conn->state = SERF_CONN_INIT;
626 serf__log(CONN_VERBOSE, __FILE__, "reset connection 0x%x\n", conn);
628 conn->status = APR_SUCCESS;
630 /* Let our context know that we've 'reset' the socket already. */
631 conn->seen_in_pollset |= APR_POLLHUP;
633 /* Found the connection. Closed it. All done. */
637 static apr_status_t socket_writev(serf_connection_t *conn)
642 status = apr_socket_sendv(conn->skt, conn->vec,
643 conn->vec_len, &written);
644 if (status && !APR_STATUS_IS_EAGAIN(status))
645 serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt,
646 "socket_sendv error %d\n", status);
648 /* did we write everything? */
653 serf__log_skt(SOCK_MSG_VERBOSE, __FILE__, conn->skt,
654 "--- socket_sendv:\n");
656 for (i = 0; i < conn->vec_len; i++) {
657 len += conn->vec[i].iov_len;
659 serf__log_nopref(SOCK_MSG_VERBOSE, "%.*s",
660 conn->vec[i].iov_len - (len - written),
661 conn->vec[i].iov_base);
663 memmove(conn->vec, &conn->vec[i],
664 sizeof(struct iovec) * (conn->vec_len - i));
667 conn->vec[0].iov_base = (char *)conn->vec[0].iov_base + (conn->vec[0].iov_len - (len - written));
668 conn->vec[0].iov_len = len - written;
671 serf__log_nopref(SOCK_MSG_VERBOSE, "%.*s",
672 conn->vec[i].iov_len, conn->vec[i].iov_base);
675 if (len == written) {
678 serf__log_nopref(SOCK_MSG_VERBOSE, "-(%d)-\n", written);
680 /* Log progress information */
681 serf__context_progress_delta(conn->ctx, 0, written);
687 static apr_status_t setup_request(serf_request_t *request)
689 serf_connection_t *conn = request->conn;
692 /* Now that we are about to serve the request, allocate a pool. */
693 apr_pool_create(&request->respool, conn->pool);
694 request->allocator = serf_bucket_allocator_create(request->respool,
696 apr_pool_cleanup_register(request->respool, request,
697 clean_resp, clean_resp);
699 /* Fill in the rest of the values for the request. */
700 status = request->setup(request, request->setup_baton,
703 &request->acceptor_baton,
705 &request->handler_baton,
710 /* write data out to the connection */
711 static apr_status_t write_to_connection(serf_connection_t *conn)
713 if (conn->probable_keepalive_limit &&
714 conn->completed_requests > conn->probable_keepalive_limit) {
716 conn->dirty_conn = 1;
717 conn->ctx->dirty_pollset = 1;
719 /* backoff for now. */
723 /* Keep reading and sending until we run out of stuff to read, or
724 * writing would block.
727 serf_request_t *request;
728 int stop_reading = 0;
730 apr_status_t read_status;
731 serf_bucket_t *ostreamt;
732 serf_bucket_t *ostreamh;
733 int max_outstanding_requests = conn->max_outstanding_requests;
735 /* If we're setting up an ssl tunnel, we can't send real requests
736 at yet, as they need to be encrypted and our encrypt buckets
737 aren't created yet as we still need to read the unencrypted
738 response of the CONNECT request. */
739 if (conn->state != SERF_CONN_CONNECTED)
740 max_outstanding_requests = 1;
742 if (max_outstanding_requests &&
743 conn->completed_requests -
744 conn->completed_responses >= max_outstanding_requests) {
745 /* backoff for now. */
749 /* If we have unwritten data, then write what we can. */
750 while (conn->vec_len) {
751 status = socket_writev(conn);
753 /* If the write would have blocked, then we're done. Don't try
754 * to write anything else to the socket.
756 if (APR_STATUS_IS_EAGAIN(status))
758 if (APR_STATUS_IS_EPIPE(status) ||
759 APR_STATUS_IS_ECONNRESET(status) ||
760 APR_STATUS_IS_ECONNABORTED(status))
761 return no_more_writes(conn);
765 /* ### can we have a short write, yet no EAGAIN? a short write
766 ### would imply unwritten_len > 0 ... */
767 /* assert: unwritten_len == 0. */
769 /* We may need to move forward to a request which has something
772 if (!request_or_data_pending(&request, conn)) {
773 /* No more requests (with data) are registered with the
774 * connection, and no data is pending on the outgoing stream.
775 * Let's update the pollset so that we don't try to write to this
778 conn->dirty_conn = 1;
779 conn->ctx->dirty_pollset = 1;
783 status = prepare_conn_streams(conn, &conn->stream, &ostreamt, &ostreamh);
789 if (request->req_bkt == NULL) {
790 read_status = setup_request(request);
792 /* Something bad happened. Propagate any errors. */
797 if (!request->writing_started) {
798 request->writing_started = 1;
799 serf_bucket_aggregate_append(ostreamt, request->req_bkt);
803 /* ### optimize at some point by using read_for_sendfile */
804 /* TODO: now that read_iovec will effectively try to return as much
805 data as available, we probably don't want to read ALL_AVAIL, but
806 a lower number, like the size of one or a few TCP packets, the
807 available TCP buffer size ... */
808 read_status = serf_bucket_read_iovec(ostreamh,
814 if (!conn->hit_eof) {
815 if (APR_STATUS_IS_EAGAIN(read_status)) {
816 /* We read some stuff, but should not try to read again. */
819 else if (read_status == SERF_ERROR_WAIT_CONN) {
820 /* The bucket told us that it can't provide more data until
821 more data is read from the socket. This normally happens
822 during a SSL handshake.
824 We should avoid looking for writability for a while so
825 that (hopefully) something will appear in the bucket so
826 we can actually write something. otherwise, we could
827 end up in a CPU spin: socket wants something, but we
828 don't have anything (and keep returning EAGAIN)
830 conn->stop_writing = 1;
831 conn->dirty_conn = 1;
832 conn->ctx->dirty_pollset = 1;
834 else if (read_status && !APR_STATUS_IS_EOF(read_status)) {
835 /* Something bad happened. Propagate any errors. */
840 /* If we got some data, then deliver it. */
841 /* ### what to do if we got no data?? is that a problem? */
842 if (conn->vec_len > 0) {
843 status = socket_writev(conn);
845 /* If we can't write any more, or an error occurred, then
848 if (APR_STATUS_IS_EAGAIN(status))
850 if (APR_STATUS_IS_EPIPE(status))
851 return no_more_writes(conn);
852 if (APR_STATUS_IS_ECONNRESET(status) ||
853 APR_STATUS_IS_ECONNABORTED(status)) {
854 return no_more_writes(conn);
860 if (read_status == SERF_ERROR_WAIT_CONN) {
862 conn->stop_writing = 1;
863 conn->dirty_conn = 1;
864 conn->ctx->dirty_pollset = 1;
866 else if (request && read_status && conn->hit_eof &&
867 conn->vec_len == 0) {
868 /* If we hit the end of the request bucket and all of its data has
869 * been written, then clear it out to signify that we're done
870 * sending the request. On the next iteration through this loop:
871 * - if there are remaining bytes they will be written, and as the
872 * request bucket will be completely read it will be destroyed then.
873 * - we'll see if there are other requests that need to be sent
877 serf_bucket_destroy(request->req_bkt);
878 request->req_bkt = NULL;
880 /* If our connection has async responses enabled, we're not
881 * going to get a reply back, so kill the request.
883 if (conn->async_responses) {
884 conn->requests = request->next;
885 destroy_request(request);
888 conn->completed_requests++;
890 if (conn->probable_keepalive_limit &&
891 conn->completed_requests > conn->probable_keepalive_limit) {
892 /* backoff for now. */
904 /* A response message was received from the server, so call
905 the handler as specified on the original request. */
906 static apr_status_t handle_response(serf_request_t *request,
909 apr_status_t status = APR_SUCCESS;
910 int consumed_response = 0;
912 /* Only enable the new authentication framework if the program has
913 * registered an authentication credential callback.
915 * This permits older Serf apps to still handle authentication
916 * themselves by not registering credential callbacks.
918 if (request->conn->ctx->cred_cb) {
919 status = serf__handle_auth_response(&consumed_response,
922 request->handler_baton,
925 /* If there was an error reading the response (maybe there wasn't
926 enough data available), don't bother passing the response to the
929 If the authentication was tried, but failed, pass the response
930 to the application, maybe it can do better. */
936 if (!consumed_response) {
937 return (*request->handler)(request,
939 request->handler_baton,
946 /* An async response message was received from the server. */
947 static apr_status_t handle_async_response(serf_connection_t *conn,
952 if (conn->current_async_response == NULL) {
953 conn->current_async_response =
954 (*conn->async_acceptor)(NULL, conn->stream,
955 conn->async_acceptor_baton, pool);
958 status = (*conn->async_handler)(NULL, conn->current_async_response,
959 conn->async_handler_baton, pool);
961 if (APR_STATUS_IS_EOF(status)) {
962 serf_bucket_destroy(conn->current_async_response);
963 conn->current_async_response = NULL;
964 status = APR_SUCCESS;
972 serf__provide_credentials(serf_context_t *ctx,
975 serf_request_t *request, void *baton,
976 int code, const char *authn_type,
980 serf_connection_t *conn = request->conn;
981 serf_request_t *authn_req = request;
984 if (request->ssltunnel == 1 &&
985 conn->state == SERF_CONN_SETUP_SSLTUNNEL) {
986 /* This is a CONNECT request to set up an SSL tunnel over a proxy.
987 This request is created by serf, so if the proxy requires
988 authentication, we can't ask the application for credentials with
991 Solution: setup the first request created by the application on
992 this connection, and use that request and its handler_baton to
993 call back to the application. */
995 authn_req = request->next;
996 /* assert: app_request != NULL */
1000 if (!authn_req->req_bkt) {
1001 apr_status_t status;
1003 status = setup_request(authn_req);
1004 /* If we can't setup a request, don't bother setting up the
1011 /* Ask the application. */
1012 status = (*ctx->cred_cb)(username, password,
1013 authn_req, authn_req->handler_baton,
1014 code, authn_type, realm, pool);
1021 /* read data from the connection */
1022 static apr_status_t read_from_connection(serf_connection_t *conn)
1024 apr_status_t status;
1025 apr_pool_t *tmppool;
1026 int close_connection = FALSE;
1028 /* Whatever is coming in on the socket corresponds to the first request
1031 serf_request_t *request = conn->requests;
1033 /* If the stop_writing flag was set on the connection, reset it now because
1034 there is some data to read. */
1035 if (conn->stop_writing) {
1036 conn->stop_writing = 0;
1037 conn->dirty_conn = 1;
1038 conn->ctx->dirty_pollset = 1;
1041 /* assert: request != NULL */
1043 if ((status = apr_pool_create(&tmppool, conn->pool)) != APR_SUCCESS)
1046 /* Invoke response handlers until we have no more work. */
1048 serf_bucket_t *dummy1, *dummy2;
1050 apr_pool_clear(tmppool);
1052 /* Only interested in the input stream here. */
1053 status = prepare_conn_streams(conn, &conn->stream, &dummy1, &dummy2);
1058 /* We have a different codepath when we can have async responses. */
1059 if (conn->async_responses) {
1060 /* TODO What about socket errors? */
1061 status = handle_async_response(conn, tmppool);
1062 if (APR_STATUS_IS_EAGAIN(status)) {
1063 status = APR_SUCCESS;
1072 /* We are reading a response for a request we haven't
1075 * This shouldn't normally happen EXCEPT:
1077 * 1) when the other end has closed the socket and we're
1078 * pending an EOF return.
1079 * 2) Doing the initial SSL handshake - we'll get EAGAIN
1080 * as the SSL buckets will hide the handshake from us
1081 * but not return any data.
1082 * 3) When the server sends us an SSL alert.
1084 * In these cases, we should not receive any actual user data.
1086 * 4) When the server sends a error response, like 408 Request timeout.
1087 * This response should be passed to the application.
1089 * If we see an EOF (due to either an expired timeout or the server
1090 * sending the SSL 'close notify' shutdown alert), we'll reset the
1091 * connection and open a new one.
1093 if (request->req_bkt || !request->writing_started) {
1097 status = serf_bucket_peek(conn->stream, &data, &len);
1099 if (APR_STATUS_IS_EOF(status)) {
1100 reset_connection(conn, 1);
1101 status = APR_SUCCESS;
1104 else if (APR_STATUS_IS_EAGAIN(status) && !len) {
1105 status = APR_SUCCESS;
1107 } else if (status && !APR_STATUS_IS_EAGAIN(status)) {
1112 /* Unexpected response from the server */
1116 /* If the request doesn't have a response bucket, then call the
1117 * acceptor to get one created.
1119 if (request->resp_bkt == NULL) {
1120 request->resp_bkt = (*request->acceptor)(request, conn->stream,
1121 request->acceptor_baton,
1123 apr_pool_clear(tmppool);
1126 status = handle_response(request, tmppool);
1128 /* Some systems will not generate a HUP poll event so we have to
1129 * handle the ECONNRESET issue and ECONNABORT here.
1131 if (APR_STATUS_IS_ECONNRESET(status) ||
1132 APR_STATUS_IS_ECONNABORTED(status) ||
1133 status == SERF_ERROR_REQUEST_LOST) {
1134 /* If the connection had ever been good, be optimistic & try again.
1135 * If it has never tried again (incl. a retry), fail.
1137 if (conn->completed_responses) {
1138 reset_connection(conn, 1);
1139 status = APR_SUCCESS;
1141 else if (status == SERF_ERROR_REQUEST_LOST) {
1142 status = SERF_ERROR_ABORTED_CONNECTION;
1147 /* If our response handler says it can't do anything more, we now
1148 * treat that as a success.
1150 if (APR_STATUS_IS_EAGAIN(status)) {
1151 /* It is possible that while reading the response, the ssl layer
1152 has prepared some data to send. If this was the last request,
1153 serf will not check for socket writability, so force this here.
1155 if (request_or_data_pending(&request, conn) && !request) {
1156 conn->dirty_conn = 1;
1157 conn->ctx->dirty_pollset = 1;
1159 status = APR_SUCCESS;
1163 /* If we received APR_SUCCESS, run this loop again. */
1168 close_connection = is_conn_closing(request->resp_bkt);
1170 if (!APR_STATUS_IS_EOF(status) &&
1171 close_connection != SERF_ERROR_CLOSING) {
1172 /* Whether success, or an error, there is no more to do unless
1173 * this request has been completed.
1178 /* The response has been fully-read, so that means the request has
1179 * either been fully-delivered (most likely), or that we don't need to
1180 * write the rest of it anymore, e.g. when a 408 Request timeout was
1182 * Remove it from our queue and loop to read another response.
1184 conn->requests = request->next;
1186 destroy_request(request);
1188 request = conn->requests;
1190 /* If we're truly empty, update our tail. */
1191 if (request == NULL) {
1192 conn->requests_tail = NULL;
1195 conn->completed_responses++;
1197 /* We've to rebuild pollset since completed_responses is changed. */
1198 conn->dirty_conn = 1;
1199 conn->ctx->dirty_pollset = 1;
1201 /* This means that we're being advised that the connection is done. */
1202 if (close_connection == SERF_ERROR_CLOSING) {
1203 reset_connection(conn, 1);
1204 if (APR_STATUS_IS_EOF(status))
1205 status = APR_SUCCESS;
1209 /* The server is suddenly deciding to serve more responses than we've
1212 * Let our requests go.
1214 if (conn->probable_keepalive_limit &&
1215 conn->completed_responses > conn->probable_keepalive_limit) {
1216 conn->probable_keepalive_limit = 0;
1219 /* If we just ran out of requests or have unwritten requests, then
1220 * update the pollset. We don't want to read from this socket any
1221 * more. We are definitely done with this loop, too.
1223 if (request == NULL || !request->writing_started) {
1224 conn->dirty_conn = 1;
1225 conn->ctx->dirty_pollset = 1;
1226 status = APR_SUCCESS;
1232 apr_pool_destroy(tmppool);
1236 /* process all events on the connection */
1237 apr_status_t serf__process_connection(serf_connection_t *conn,
1240 apr_status_t status;
1242 /* POLLHUP/ERR should come after POLLIN so if there's an error message or
1243 * the like sitting on the connection, we give the app a chance to read
1244 * it before we trigger a reset condition.
1246 if ((events & APR_POLLIN) != 0) {
1247 if ((status = read_from_connection(conn)) != APR_SUCCESS)
1250 /* If we decided to reset our connection, return now as we don't
1253 if ((conn->seen_in_pollset & APR_POLLHUP) != 0) {
1257 if ((events & APR_POLLHUP) != 0) {
1258 /* The connection got reset by the server. On Windows this can happen
1259 when all data is read, so just cleanup the connection and open
1261 If we haven't had any successful responses on this connection,
1262 then error out as it is likely a server issue. */
1263 if (conn->completed_responses) {
1264 return reset_connection(conn, 1);
1266 return SERF_ERROR_ABORTED_CONNECTION;
1268 if ((events & APR_POLLERR) != 0) {
1269 /* We might be talking to a buggy HTTP server that doesn't
1270 * do lingering-close. (httpd < 2.1.8 does this.)
1274 * http://issues.apache.org/bugzilla/show_bug.cgi?id=35292
1276 if (conn->completed_requests && !conn->probable_keepalive_limit) {
1277 return reset_connection(conn, 1);
1280 /* If possible, get the error from the platform's socket layer and
1281 convert it to an APR status code. */
1283 apr_os_sock_t osskt;
1284 if (!apr_os_sock_get(&osskt, conn->skt)) {
1286 apr_socklen_t l = sizeof(error);
1288 if (!getsockopt(osskt, SOL_SOCKET, SO_ERROR, (char*)&error,
1290 status = APR_FROM_OS_ERROR(error);
1292 /* Handle fallback for multi-homed servers.
1294 ### Improve algorithm to find better than just 'next'?
1296 Current Windows versions already handle re-ordering for
1297 api users by using statistics on the recently failed
1298 connections to order the list of addresses. */
1299 if (conn->completed_requests == 0
1300 && conn->address->next != NULL
1301 && (APR_STATUS_IS_ECONNREFUSED(status)
1302 || APR_STATUS_IS_TIMEUP(status)
1303 || APR_STATUS_IS_ENETUNREACH(status))) {
1305 conn->address = conn->address->next;
1306 return reset_connection(conn, 1);
1314 return APR_EGENERAL;
1316 if ((events & APR_POLLOUT) != 0) {
1317 if ((status = write_to_connection(conn)) != APR_SUCCESS)
1323 serf_connection_t *serf_connection_create(
1324 serf_context_t *ctx,
1325 apr_sockaddr_t *address,
1326 serf_connection_setup_t setup,
1328 serf_connection_closed_t closed,
1332 serf_connection_t *conn = apr_pcalloc(pool, sizeof(*conn));
1335 conn->status = APR_SUCCESS;
1336 /* Ignore server address if proxy was specified. */
1337 conn->address = ctx->proxy_address ? ctx->proxy_address : address;
1338 conn->setup = setup;
1339 conn->setup_baton = setup_baton;
1340 conn->closed = closed;
1341 conn->closed_baton = closed_baton;
1343 conn->allocator = serf_bucket_allocator_create(pool, NULL, NULL);
1344 conn->stream = NULL;
1345 conn->ostream_head = NULL;
1346 conn->ostream_tail = NULL;
1347 conn->baton.type = SERF_IO_CONN;
1348 conn->baton.u.conn = conn;
1350 conn->state = SERF_CONN_INIT;
1351 conn->latency = -1; /* unknown */
1353 /* Create a subpool for our connection. */
1354 apr_pool_create(&conn->skt_pool, conn->pool);
1356 /* register a cleanup */
1357 apr_pool_cleanup_register(conn->pool, conn, clean_conn,
1358 apr_pool_cleanup_null);
1360 /* Add the connection to the context. */
1361 *(serf_connection_t **)apr_array_push(ctx->conns) = conn;
1363 serf__log(CONN_VERBOSE, __FILE__, "created connection 0x%x\n",
1369 apr_status_t serf_connection_create2(
1370 serf_connection_t **conn,
1371 serf_context_t *ctx,
1372 apr_uri_t host_info,
1373 serf_connection_setup_t setup,
1375 serf_connection_closed_t closed,
1379 apr_status_t status = APR_SUCCESS;
1380 serf_connection_t *c;
1381 apr_sockaddr_t *host_address = NULL;
1383 /* Set the port number explicitly, needed to create the socket later. */
1384 if (!host_info.port) {
1385 host_info.port = apr_uri_port_of_scheme(host_info.scheme);
1388 /* Only lookup the address of the server if no proxy server was
1390 if (!ctx->proxy_address) {
1391 status = apr_sockaddr_info_get(&host_address,
1393 APR_UNSPEC, host_info.port, 0, pool);
1398 c = serf_connection_create(ctx, host_address, setup, setup_baton,
1399 closed, closed_baton, pool);
1401 /* We're not interested in the path following the hostname. */
1402 c->host_url = apr_uri_unparse(c->pool,
1404 APR_URI_UNP_OMITPATHINFO |
1405 APR_URI_UNP_OMITUSERINFO);
1407 /* Store the host info without the path on the connection. */
1408 (void)apr_uri_parse(c->pool, c->host_url, &(c->host_info));
1409 if (!c->host_info.port) {
1410 c->host_info.port = apr_uri_port_of_scheme(c->host_info.scheme);
1418 apr_status_t serf_connection_reset(
1419 serf_connection_t *conn)
1421 return reset_connection(conn, 0);
1425 apr_status_t serf_connection_close(
1426 serf_connection_t *conn)
1429 serf_context_t *ctx = conn->ctx;
1430 apr_status_t status;
1432 for (i = ctx->conns->nelts; i--; ) {
1433 serf_connection_t *conn_seq = GET_CONN(ctx, i);
1435 if (conn_seq == conn) {
1436 while (conn->requests) {
1437 serf_request_cancel(conn->requests);
1439 if (conn->skt != NULL) {
1440 remove_connection(ctx, conn);
1441 status = apr_socket_close(conn->skt);
1442 serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt,
1443 "closed socket, status %d\n",
1445 if (conn->closed != NULL) {
1446 handle_conn_closed(conn, status);
1450 if (conn->stream != NULL) {
1451 serf_bucket_destroy(conn->stream);
1452 conn->stream = NULL;
1455 destroy_ostream(conn);
1457 /* Remove the connection from the context. We don't want to
1458 * deal with it any more.
1460 if (i < ctx->conns->nelts - 1) {
1461 /* move later connections over this one. */
1464 &GET_CONN(ctx, i + 1),
1465 (ctx->conns->nelts - i - 1) * sizeof(serf_connection_t *));
1467 --ctx->conns->nelts;
1469 serf__log(CONN_VERBOSE, __FILE__, "closed connection 0x%x\n",
1472 /* Found the connection. Closed it. All done. */
1477 /* We didn't find the specified connection. */
1478 /* ### doc talks about this w.r.t poll structures. use something else? */
1479 return APR_NOTFOUND;
1483 void serf_connection_set_max_outstanding_requests(
1484 serf_connection_t *conn,
1485 unsigned int max_requests)
1487 if (max_requests == 0)
1488 serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,
1489 "Set max. nr. of outstanding requests for this "
1490 "connection to unlimited.\n");
1492 serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,
1493 "Limit max. nr. of outstanding requests for this "
1494 "connection to %u.\n", max_requests);
1496 conn->max_outstanding_requests = max_requests;
1500 void serf_connection_set_async_responses(
1501 serf_connection_t *conn,
1502 serf_response_acceptor_t acceptor,
1503 void *acceptor_baton,
1504 serf_response_handler_t handler,
1505 void *handler_baton)
1507 conn->async_responses = 1;
1508 conn->async_acceptor = acceptor;
1509 conn->async_acceptor_baton = acceptor_baton;
1510 conn->async_handler = handler;
1511 conn->async_handler_baton = handler_baton;
1514 static serf_request_t *
1515 create_request(serf_connection_t *conn,
1516 serf_request_setup_t setup,
1521 serf_request_t *request;
1523 request = serf_bucket_mem_alloc(conn->allocator, sizeof(*request));
1524 request->conn = conn;
1525 request->setup = setup;
1526 request->setup_baton = setup_baton;
1527 request->handler = NULL;
1528 request->respool = NULL;
1529 request->req_bkt = NULL;
1530 request->resp_bkt = NULL;
1531 request->priority = priority;
1532 request->writing_started = 0;
1533 request->ssltunnel = ssltunnel;
1534 request->next = NULL;
1535 request->auth_baton = NULL;
1540 serf_request_t *serf_connection_request_create(
1541 serf_connection_t *conn,
1542 serf_request_setup_t setup,
1545 serf_request_t *request;
1547 request = create_request(conn, setup, setup_baton,
1549 0 /* ssl tunnel */);
1551 /* Link the request to the end of the request chain. */
1552 link_requests(&conn->requests, &conn->requests_tail, request);
1554 /* Ensure our pollset becomes writable in context run */
1555 conn->ctx->dirty_pollset = 1;
1556 conn->dirty_conn = 1;
1561 static serf_request_t *
1562 priority_request_create(serf_connection_t *conn,
1564 serf_request_setup_t setup,
1567 serf_request_t *request;
1568 serf_request_t *iter, *prev;
1570 request = create_request(conn, setup, setup_baton,
1574 /* Link the new request after the last written request. */
1575 iter = conn->requests;
1578 /* Find a request that has data which needs to be delivered. */
1579 while (iter != NULL && iter->req_bkt == NULL && iter->writing_started) {
1584 /* A CONNECT request to setup an ssltunnel has absolute priority over all
1585 other requests on the connection, so:
1586 a. add it first to the queue
1587 b. ensure that other priority requests are added after the CONNECT
1589 if (!request->ssltunnel) {
1590 /* Advance to next non priority request */
1591 while (iter != NULL && iter->priority) {
1598 request->next = iter;
1599 prev->next = request;
1601 request->next = iter;
1602 conn->requests = request;
1605 /* Ensure our pollset becomes writable in context run */
1606 conn->ctx->dirty_pollset = 1;
1607 conn->dirty_conn = 1;
1612 serf_request_t *serf_connection_priority_request_create(
1613 serf_connection_t *conn,
1614 serf_request_setup_t setup,
1617 return priority_request_create(conn,
1618 0, /* not a ssltunnel CONNECT request */
1619 setup, setup_baton);
1622 serf_request_t *serf__ssltunnel_request_create(serf_connection_t *conn,
1623 serf_request_setup_t setup,
1626 return priority_request_create(conn,
1627 1, /* This is a ssltunnel CONNECT request */
1628 setup, setup_baton);
1631 apr_status_t serf_request_cancel(serf_request_t *request)
1633 return cancel_request(request, &request->conn->requests, 0);
1636 apr_status_t serf_request_is_written(serf_request_t *request)
1638 if (request->writing_started && !request->req_bkt)
1644 apr_pool_t *serf_request_get_pool(const serf_request_t *request)
1646 return request->respool;
1650 serf_bucket_alloc_t *serf_request_get_alloc(
1651 const serf_request_t *request)
1653 return request->allocator;
1657 serf_connection_t *serf_request_get_conn(
1658 const serf_request_t *request)
1660 return request->conn;
1664 void serf_request_set_handler(
1665 serf_request_t *request,
1666 const serf_response_handler_t handler,
1667 const void **handler_baton)
1669 request->handler = handler;
1670 request->handler_baton = handler_baton;
1674 serf_bucket_t *serf_request_bucket_request_create(
1675 serf_request_t *request,
1678 serf_bucket_t *body,
1679 serf_bucket_alloc_t *allocator)
1681 serf_bucket_t *req_bkt, *hdrs_bkt;
1682 serf_connection_t *conn = request->conn;
1683 serf_context_t *ctx = conn->ctx;
1686 ssltunnel = ctx->proxy_address &&
1687 (strcmp(conn->host_info.scheme, "https") == 0);
1689 req_bkt = serf_bucket_request_create(method, uri, body, allocator);
1690 hdrs_bkt = serf_bucket_request_get_headers(req_bkt);
1692 /* Use absolute uri's in requests to a proxy. USe relative uri's in
1693 requests directly to a server or sent through an SSL tunnel. */
1694 if (ctx->proxy_address && conn->host_url &&
1695 !(ssltunnel && !request->ssltunnel)) {
1697 serf_bucket_request_set_root(req_bkt, conn->host_url);
1700 if (conn->host_info.hostinfo)
1701 serf_bucket_headers_setn(hdrs_bkt, "Host",
1702 conn->host_info.hostinfo);
1704 /* Setup server authorization headers, unless this is a CONNECT request. */
1705 if (!request->ssltunnel) {
1706 serf__authn_info_t *authn_info;
1707 authn_info = serf__get_authn_info_for_server(conn);
1708 if (authn_info->scheme)
1709 authn_info->scheme->setup_request_func(HOST, 0, conn, request,
1714 /* Setup proxy authorization headers.
1715 Don't set these headers on the requests to the server if we're using
1716 an SSL tunnel, only on the CONNECT request to setup the tunnel. */
1717 if (ctx->proxy_authn_info.scheme) {
1718 if (strcmp(conn->host_info.scheme, "https") == 0) {
1719 if (request->ssltunnel)
1720 ctx->proxy_authn_info.scheme->setup_request_func(PROXY, 0, conn,
1725 ctx->proxy_authn_info.scheme->setup_request_func(PROXY, 0, conn,
1735 apr_interval_time_t serf_connection_get_latency(serf_connection_t *conn)
1737 if (conn->ctx->proxy_address) {
1738 /* Detecting network latency for proxied connection is not implemented
1743 return conn->latency;