Lines Matching defs:conn
29 serf_connection_t *conn = data;
32 if (conn->skt) {
33 serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt, "cleanup - ");
34 status = apr_socket_close(conn->skt);
35 conn->skt = NULL;
75 serf_connection_t *conn = data;
78 conn);
79 serf_connection_close(conn);
94 request_or_data_pending(serf_request_t **next_req, serf_connection_t *conn)
96 serf_request_t *request = conn->requests;
107 } else if (conn->ostream_head) {
112 status = serf_bucket_peek(conn->ostream_head, &dummy,
115 serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,
129 apr_status_t serf__conn_update_pollset(serf_connection_t *conn)
131 serf_context_t *ctx = conn->ctx;
135 if (!conn->skt) {
141 desc.desc.s = conn->skt;
142 desc.reqevents = conn->reqevents;
145 &desc, conn);
151 if (conn->requests &&
152 conn->state != SERF_CONN_INIT) {
158 if (conn->stop_writing != 1) {
165 if (conn->vec_len &&
166 conn->state != SERF_CONN_CLOSING)
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)) {
177 else if (request_or_data_pending(NULL, conn)) {
185 if (conn->async_responses) {
190 conn->reqevents = desc.reqevents;
196 &desc, &conn->baton);
202 static void check_buckets_drained(serf_connection_t *conn)
204 serf_request_t *request = conn->requests;
212 /* ### for now, pretend we closed the conn (resets the tracking) */
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;
231 serf_connection_t *conn = baton;
232 conn->hit_eof = 1;
236 static apr_status_t do_conn_setup(serf_connection_t *conn)
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,
248 conn);
251 ostream = conn->ostream_tail;
253 status = (*conn->setup)(conn->skt,
254 &conn->stream,
256 conn->setup_baton,
257 conn->pool);
260 serf_bucket_destroy(conn->ostream_tail);
261 destroy_ostream(conn);
265 serf_bucket_aggregate_append(conn->ostream_head,
281 static apr_status_t prepare_conn_streams(serf_connection_t *conn,
288 if (conn->stream == NULL) {
289 conn->latency = apr_time_now() - conn->connect_time;
293 if (conn->state == SERF_CONN_CONNECTED) {
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;
309 if (conn->stream == NULL) {
310 *istream = serf_bucket_socket_create(conn->skt,
311 conn->allocator);
316 *ostreamt = *ostreamh = conn->ssltunnel_ostream;
330 serf_connection_t *conn = GET_CONN(ctx, i);
335 conn->seen_in_pollset = 0;
337 if (conn->skt != NULL) {
339 check_buckets_drained(conn);
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,
357 conn->skt_pool);
359 "created socket for conn 0x%x, status %d\n", conn, status);
373 conn->skt = skt;
377 conn->connect_time = apr_time_now();
382 status = apr_socket_connect(skt, conn->address);
384 "connected socket for conn 0x%x, status %d\n",
385 conn, status);
392 conn->dirty_conn = 1;
402 conn, conn->pool);
406 authn_info = serf__get_authn_info_for_server(conn);
409 conn, conn->pool);
413 if (ctx->proxy_address && strcmp(conn->host_info.scheme, "https") == 0)
414 serf__ssltunnel_connect(conn);
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)
434 conn->state = SERF_CONN_CLOSING;
435 serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,
436 "stop writing on conn 0x%x\n", conn);
439 conn->vec_len = 0;
444 conn->dirty_conn = 1;
445 conn->ctx->dirty_pollset = 1;
484 serf_connection_t *conn = request->conn;
505 serf_bucket_mem_free(conn->allocator, request);
541 serf_connection_t *conn)
546 desc.desc.s = conn->skt;
547 desc.reqevents = conn->reqevents;
550 &desc, conn);
554 static void handle_conn_closed(serf_connection_t *conn, apr_status_t status)
556 (*conn->closed)(conn, conn->closed_baton, status,
557 conn->pool);
560 static apr_status_t reset_connection(serf_connection_t *conn,
563 serf_context_t *ctx = conn->ctx;
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;
590 link_requests(&conn->requests, &conn->requests_tail, req);
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,
606 if (conn->closed != NULL) {
607 handle_conn_closed(conn, status);
609 conn->skt = NULL;
612 if (conn->stream != NULL) {
613 serf_bucket_destroy(conn->stream);
614 conn->stream = NULL;
617 destroy_ostream(conn);
620 conn->vec_len = 0;
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;
631 conn->seen_in_pollset |= APR_POLLHUP;
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);
645 serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt,
653 serf__log_skt(SOCK_MSG_VERBOSE, __FILE__, conn->skt,
656 for (i = 0; i < conn->vec_len; i++) {
657 len += conn->vec[i].iov_len;
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));
665 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;
672 conn->vec[i].iov_len, conn->vec[i].iov_base);
676 conn->vec_len = 0;
681 serf__context_progress_delta(conn->ctx, 0, written);
689 serf_connection_t *conn = request->conn;
693 apr_pool_create(&request->respool, conn->pool);
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;
733 int max_outstanding_requests = conn->max_outstanding_requests;
739 if (conn->state != SERF_CONN_CONNECTED)
743 conn->completed_requests -
744 conn->completed_responses >= max_outstanding_requests) {
750 while (conn->vec_len) {
751 status = socket_writev(conn);
761 return no_more_writes(conn);
772 if (!request_or_data_pending(&request, conn)) {
778 conn->dirty_conn = 1;
779 conn->ctx->dirty_pollset = 1;
783 status = prepare_conn_streams(conn, &conn->stream, &ostreamt, &ostreamh);
811 conn->vec,
812 &conn->vec_len);
814 if (!conn->hit_eof) {
830 conn->stop_writing = 1;
831 conn->dirty_conn = 1;
832 conn->ctx->dirty_pollset = 1;
842 if (conn->vec_len > 0) {
843 status = socket_writev(conn);
851 return no_more_writes(conn);
854 return no_more_writes(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) {
876 conn->hit_eof = 0;
883 if (conn->async_responses) {
884 conn->requests = request->next;
888 conn->completed_requests++;
890 if (conn->probable_keepalive_limit &&
891 conn->completed_requests > conn->probable_keepalive_limit) {
918 if (request->conn->ctx->cred_cb) {
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);
962 serf_bucket_destroy(conn->current_async_response);
963 conn->current_async_response = NULL;
980 serf_connection_t *conn = request->conn;
985 conn->state == SERF_CONN_SETUP_SSLTUNNEL) {
1022 static apr_status_t read_from_connection(serf_connection_t *conn)
1031 serf_request_t *request = conn->requests;
1035 if (conn->stop_writing) {
1036 conn->stop_writing = 0;
1037 conn->dirty_conn = 1;
1038 conn->ctx->dirty_pollset = 1;
1043 if ((status = apr_pool_create(&tmppool, conn->pool)) != APR_SUCCESS)
1053 status = prepare_conn_streams(conn, &conn->stream, &dummy1, &dummy2);
1059 if (conn->async_responses) {
1061 status = handle_async_response(conn, tmppool);
1097 status = serf_bucket_peek(conn->stream, &data, &len);
1100 reset_connection(conn, 1);
1120 request->resp_bkt = (*request->acceptor)(request, conn->stream,
1137 if (conn->completed_responses) {
1138 reset_connection(conn, 1);
1155 if (request_or_data_pending(&request, conn) && !request) {
1156 conn->dirty_conn = 1;
1157 conn->ctx->dirty_pollset = 1;
1184 conn->requests = request->next;
1188 request = conn->requests;
1192 conn->requests_tail = NULL;
1195 conn->completed_responses++;
1198 conn->dirty_conn = 1;
1199 conn->ctx->dirty_pollset = 1;
1203 reset_connection(conn, 1);
1214 if (conn->probable_keepalive_limit &&
1215 conn->completed_responses > conn->probable_keepalive_limit) {
1216 conn->probable_keepalive_limit = 0;
1224 conn->dirty_conn = 1;
1225 conn->ctx->dirty_pollset = 1;
1237 apr_status_t serf__process_connection(serf_connection_t *conn,
1247 if ((status = read_from_connection(conn)) != APR_SUCCESS)
1253 if ((conn->seen_in_pollset & APR_POLLHUP) != 0) {
1263 if (conn->completed_responses) {
1264 return reset_connection(conn, 1);
1276 if (conn->completed_requests && !conn->probable_keepalive_limit) {
1277 return reset_connection(conn, 1);
1284 if (!apr_os_sock_get(&osskt, conn->skt)) {
1299 if (conn->completed_requests == 0
1300 && conn->address->next != NULL
1305 conn->address = conn->address->next;
1306 return reset_connection(conn, 1);
1317 if ((status = write_to_connection(conn)) != APR_SUCCESS)
1332 serf_connection_t *conn = apr_pcalloc(pool, sizeof(*conn));
1334 conn->ctx = ctx;
1335 conn->status = APR_SUCCESS;
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;
1342 conn->pool = pool;
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;
1349 conn->hit_eof = 0;
1350 conn->state = SERF_CONN_INIT;
1351 conn->latency = -1; /* unknown */
1354 apr_pool_create(&conn->skt_pool, conn->pool);
1357 apr_pool_cleanup_register(conn->pool, conn, clean_conn,
1361 *(serf_connection_t **)apr_array_push(ctx->conns) = conn;
1364 conn);
1366 return conn;
1370 serf_connection_t **conn,
1413 *conn = c;
1419 serf_connection_t *conn)
1421 return reset_connection(conn, 0);
1426 serf_connection_t *conn)
1429 serf_context_t *ctx = conn->ctx;
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,
1445 if (conn->closed != NULL) {
1446 handle_conn_closed(conn, status);
1448 conn->skt = NULL;
1450 if (conn->stream != NULL) {
1451 serf_bucket_destroy(conn->stream);
1452 conn->stream = NULL;
1455 destroy_ostream(conn);
1470 conn);
1484 serf_connection_t *conn,
1488 serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,
1492 serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,
1496 conn->max_outstanding_requests = max_requests;
1501 serf_connection_t *conn,
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;
1515 create_request(serf_connection_t *conn,
1523 request = serf_bucket_mem_alloc(conn->allocator, sizeof(*request));
1524 request->conn = conn;
1541 serf_connection_t *conn,
1547 request = create_request(conn, setup, setup_baton,
1552 link_requests(&conn->requests, &conn->requests_tail, request);
1555 conn->ctx->dirty_pollset = 1;
1556 conn->dirty_conn = 1;
1562 priority_request_create(serf_connection_t *conn,
1570 request = create_request(conn, setup, setup_baton,
1575 iter = conn->requests;
1602 conn->requests = request;
1606 conn->ctx->dirty_pollset = 1;
1607 conn->dirty_conn = 1;
1613 serf_connection_t *conn,
1617 return priority_request_create(conn,
1622 serf_request_t *serf__ssltunnel_request_create(serf_connection_t *conn,
1626 return priority_request_create(conn,
1633 return cancel_request(request, &request->conn->requests, 0);
1660 return request->conn;
1682 serf_connection_t *conn = request->conn;
1683 serf_context_t *ctx = conn->ctx;
1687 (strcmp(conn->host_info.scheme, "https") == 0);
1694 if (ctx->proxy_address && conn->host_url &&
1697 serf_bucket_request_set_root(req_bkt, conn->host_url);
1700 if (conn->host_info.hostinfo)
1702 conn->host_info.hostinfo);
1707 authn_info = serf__get_authn_info_for_server(conn);
1709 authn_info->scheme->setup_request_func(HOST, 0, conn, request,
1718 if (strcmp(conn->host_info.scheme, "https") == 0) {
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) {
1743 return conn->latency;