Lines Matching refs: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);
89 apr_status_t serf__conn_update_pollset(serf_connection_t *conn)
91 serf_context_t *ctx = conn->ctx;
95 if (!conn->skt) {
101 desc.desc.s = conn->skt;
102 desc.reqevents = conn->reqevents;
105 &desc, conn);
111 if (conn->requests &&
112 conn->state != SERF_CONN_INIT) {
118 if (conn->stop_writing != 1) {
125 if (conn->vec_len &&
126 conn->state != SERF_CONN_CLOSING)
129 serf_request_t *request = conn->requests;
131 if ((conn->probable_keepalive_limit &&
132 conn->completed_requests > conn->probable_keepalive_limit) ||
133 (conn->max_outstanding_requests &&
134 conn->completed_requests - conn->completed_responses >=
135 conn->max_outstanding_requests)) {
150 if (conn->async_responses) {
155 conn->reqevents = desc.reqevents;
161 &desc, &conn->baton);
167 static void check_buckets_drained(serf_connection_t *conn)
169 serf_request_t *request = conn->requests;
177 /* ### for now, pretend we closed the conn (resets the tracking) */
185 static void destroy_ostream(serf_connection_t *conn)
187 if (conn->ostream_head != NULL) {
188 serf_bucket_destroy(conn->ostream_head);
189 conn->ostream_head = NULL;
190 conn->ostream_tail = NULL;
196 serf_connection_t *conn = baton;
197 conn->hit_eof = 1;
201 static apr_status_t do_conn_setup(serf_connection_t *conn)
206 if (conn->ostream_head == NULL) {
207 conn->ostream_head = serf_bucket_aggregate_create(conn->allocator);
210 if (conn->ostream_tail == NULL) {
211 conn->ostream_tail = serf__bucket_stream_create(conn->allocator,
213 conn);
216 ostream = conn->ostream_tail;
218 status = (*conn->setup)(conn->skt,
219 &conn->stream,
221 conn->setup_baton,
222 conn->pool);
225 serf_bucket_destroy(conn->ostream_tail);
226 destroy_ostream(conn);
230 serf_bucket_aggregate_append(conn->ostream_head,
246 static apr_status_t prepare_conn_streams(serf_connection_t *conn,
253 if (conn->stream == NULL) {
254 conn->latency = apr_time_now() - conn->connect_time;
258 if (conn->state == SERF_CONN_CONNECTED) {
262 if (conn->stream == NULL) {
263 status = do_conn_setup(conn);
268 *ostreamt = conn->ostream_tail;
269 *ostreamh = conn->ostream_head;
270 *istream = conn->stream;
274 if (conn->stream == NULL) {
275 *istream = serf_bucket_socket_create(conn->skt,
276 conn->allocator);
281 *ostreamt = *ostreamh = conn->ssltunnel_ostream;
295 serf_connection_t *conn = GET_CONN(ctx, i);
300 conn->seen_in_pollset = 0;
302 if (conn->skt != NULL) {
304 check_buckets_drained(conn);
310 if (conn->requests == NULL) {
314 apr_pool_clear(conn->skt_pool);
315 apr_pool_cleanup_register(conn->skt_pool, conn, clean_skt, clean_skt);
317 status = apr_socket_create(&skt, conn->address->family,
322 conn->skt_pool);
324 "created socket for conn 0x%x, status %d\n", conn, status);
338 conn->skt = skt;
342 conn->connect_time = apr_time_now();
347 status = apr_socket_connect(skt, conn->address);
349 "connected socket for conn 0x%x, status %d\n",
350 conn, status);
357 conn->dirty_conn = 1;
367 conn, conn->pool);
371 authn_info = serf__get_authn_info_for_server(conn);
374 conn, conn->pool);
378 if (ctx->proxy_address && strcmp(conn->host_info.scheme, "https") == 0)
379 serf__ssltunnel_connect(conn);
383 conn->state = SERF_CONN_CONNECTED;
385 status = prepare_conn_streams(conn, &conn->stream,
396 static apr_status_t no_more_writes(serf_connection_t *conn,
400 conn->state = SERF_CONN_CLOSING;
401 serf__log(CONN_VERBOSE, __FILE__, "stop writing on conn 0x%x\n",
402 conn);
405 conn->vec_len = 0;
410 conn->dirty_conn = 1;
411 conn->ctx->dirty_pollset = 1;
450 serf_connection_t *conn = request->conn;
471 serf_bucket_mem_free(conn->allocator, request);
507 serf_connection_t *conn)
512 desc.desc.s = conn->skt;
513 desc.reqevents = conn->reqevents;
516 &desc, conn);
520 static void handle_conn_closed(serf_connection_t *conn, apr_status_t status)
522 (*conn->closed)(conn, conn->closed_baton, status,
523 conn->pool);
526 static apr_status_t reset_connection(serf_connection_t *conn,
529 serf_context_t *ctx = conn->ctx;
533 conn->probable_keepalive_limit = conn->completed_responses;
534 conn->completed_requests = 0;
535 conn->completed_responses = 0;
537 old_reqs = conn->requests;
539 conn->requests = NULL;
540 conn->requests_tail = NULL;
552 link_requests(&conn->requests, &conn->requests_tail, req);
563 if (conn->skt != NULL) {
564 remove_connection(ctx, conn);
565 status = apr_socket_close(conn->skt);
566 serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt,
568 if (conn->closed != NULL) {
569 handle_conn_closed(conn, status);
571 conn->skt = NULL;
574 if (conn->stream != NULL) {
575 serf_bucket_destroy(conn->stream);
576 conn->stream = NULL;
579 destroy_ostream(conn);
582 conn->vec_len = 0;
584 conn->dirty_conn = 1;
585 conn->ctx->dirty_pollset = 1;
586 conn->state = SERF_CONN_INIT;
588 serf__log(CONN_VERBOSE, __FILE__, "reset connection 0x%x\n", conn);
590 conn->status = APR_SUCCESS;
593 conn->seen_in_pollset |= APR_POLLHUP;
599 static apr_status_t socket_writev(serf_connection_t *conn)
604 status = apr_socket_sendv(conn->skt, conn->vec,
605 conn->vec_len, &written);
607 serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt,
615 serf__log_skt(SOCK_MSG_VERBOSE, __FILE__, conn->skt,
618 for (i = 0; i < conn->vec_len; i++) {
619 len += conn->vec[i].iov_len;
622 conn->vec[i].iov_len - (len - written),
623 conn->vec[i].iov_base);
625 memmove(conn->vec, &conn->vec[i],
626 sizeof(struct iovec) * (conn->vec_len - i));
627 conn->vec_len -= i;
629 conn->vec[0].iov_base = (char *)conn->vec[0].iov_base + (conn->vec[0].iov_len - (len - written));
630 conn->vec[0].iov_len = len - written;
634 conn->vec[i].iov_len, conn->vec[i].iov_base);
638 conn->vec_len = 0;
643 serf__context_progress_delta(conn->ctx, 0, written);
651 serf_connection_t *conn = request->conn;
655 apr_pool_create(&request->respool, conn->pool);
673 static apr_status_t write_to_connection(serf_connection_t *conn)
675 serf_request_t *request = conn->requests;
677 if (conn->probable_keepalive_limit &&
678 conn->completed_requests > conn->probable_keepalive_limit) {
680 conn->dirty_conn = 1;
681 conn->ctx->dirty_pollset = 1;
692 /* assert: request != NULL || conn->vec_len */
702 int max_outstanding_requests = conn->max_outstanding_requests;
708 if (conn->state != SERF_CONN_CONNECTED)
712 conn->completed_requests -
713 conn->completed_responses >= max_outstanding_requests) {
719 while (conn->vec_len) {
720 status = socket_writev(conn);
730 return no_more_writes(conn, request);
750 conn->dirty_conn = 1;
751 conn->ctx->dirty_pollset = 1;
755 status = prepare_conn_streams(conn, &conn->stream, &ostreamt, &ostreamh);
781 conn->vec,
782 &conn->vec_len);
784 if (!conn->hit_eof) {
800 conn->stop_writing = 1;
801 conn->dirty_conn = 1;
802 conn->ctx->dirty_pollset = 1;
812 if (conn->vec_len > 0) {
813 status = socket_writev(conn);
821 return no_more_writes(conn, request);
824 return no_more_writes(conn, request);
832 conn->stop_writing = 1;
833 conn->dirty_conn = 1;
834 conn->ctx->dirty_pollset = 1;
836 else if (read_status && conn->hit_eof && conn->vec_len == 0) {
845 conn->hit_eof = 0;
852 if (conn->async_responses) {
853 conn->requests = request->next;
857 conn->completed_requests++;
859 if (conn->probable_keepalive_limit &&
860 conn->completed_requests > conn->probable_keepalive_limit) {
887 if (request->conn->ctx->cred_cb) {
917 static apr_status_t handle_async_response(serf_connection_t *conn,
922 if (conn->current_async_response == NULL) {
923 conn->current_async_response =
924 (*conn->async_acceptor)(NULL, conn->stream,
925 conn->async_acceptor_baton, pool);
928 status = (*conn->async_handler)(NULL, conn->current_async_response,
929 conn->async_handler_baton, pool);
932 serf_bucket_destroy(conn->current_async_response);
933 conn->current_async_response = NULL;
950 serf_connection_t *conn = request->conn;
955 conn->state == SERF_CONN_SETUP_SSLTUNNEL) {
992 static apr_status_t read_from_connection(serf_connection_t *conn)
1001 serf_request_t *request = conn->requests;
1005 if (conn->stop_writing) {
1006 conn->stop_writing = 0;
1007 conn->dirty_conn = 1;
1008 conn->ctx->dirty_pollset = 1;
1013 if ((status = apr_pool_create(&tmppool, conn->pool)) != APR_SUCCESS)
1023 status = prepare_conn_streams(conn, &conn->stream, &dummy1, &dummy2);
1029 if (conn->async_responses) {
1031 status = handle_async_response(conn, tmppool);
1067 status = serf_bucket_peek(conn->stream, &data, &len);
1070 reset_connection(conn, 1);
1090 request->resp_bkt = (*request->acceptor)(request, conn->stream,
1107 if (conn->completed_responses) {
1108 reset_connection(conn, 1);
1146 conn->requests = request->next;
1150 request = conn->requests;
1154 conn->requests_tail = NULL;
1157 conn->completed_responses++;
1160 conn->dirty_conn = 1;
1161 conn->ctx->dirty_pollset = 1;
1165 reset_connection(conn, 1);
1176 if (conn->probable_keepalive_limit &&
1177 conn->completed_responses > conn->probable_keepalive_limit) {
1178 conn->probable_keepalive_limit = 0;
1186 conn->dirty_conn = 1;
1187 conn->ctx->dirty_pollset = 1;
1199 apr_status_t serf__process_connection(serf_connection_t *conn,
1209 if ((status = read_from_connection(conn)) != APR_SUCCESS)
1215 if ((conn->seen_in_pollset & APR_POLLHUP) != 0) {
1225 if (conn->completed_responses) {
1226 return reset_connection(conn, 1);
1238 if (conn->completed_requests && !conn->probable_keepalive_limit) {
1239 return reset_connection(conn, 1);
1246 if (!apr_os_sock_get(&osskt, conn->skt)) {
1258 if ((status = write_to_connection(conn)) != APR_SUCCESS)
1273 serf_connection_t *conn = apr_pcalloc(pool, sizeof(*conn));
1275 conn->ctx = ctx;
1276 conn->status = APR_SUCCESS;
1278 conn->address = ctx->proxy_address ? ctx->proxy_address : address;
1279 conn->setup = setup;
1280 conn->setup_baton = setup_baton;
1281 conn->closed = closed;
1282 conn->closed_baton = closed_baton;
1283 conn->pool = pool;
1284 conn->allocator = serf_bucket_allocator_create(pool, NULL, NULL);
1285 conn->stream = NULL;
1286 conn->ostream_head = NULL;
1287 conn->ostream_tail = NULL;
1288 conn->baton.type = SERF_IO_CONN;
1289 conn->baton.u.conn = conn;
1290 conn->hit_eof = 0;
1291 conn->state = SERF_CONN_INIT;
1292 conn->latency = -1; /* unknown */
1295 apr_pool_create(&conn->skt_pool, conn->pool);
1298 apr_pool_cleanup_register(conn->pool, conn, clean_conn,
1302 *(serf_connection_t **)apr_array_push(ctx->conns) = conn;
1305 conn);
1307 return conn;
1311 serf_connection_t **conn,
1353 *conn = c;
1359 serf_connection_t *conn)
1361 return reset_connection(conn, 0);
1366 serf_connection_t *conn)
1369 serf_context_t *ctx = conn->ctx;
1375 if (conn_seq == conn) {
1376 while (conn->requests) {
1377 serf_request_cancel(conn->requests);
1379 if (conn->skt != NULL) {
1380 remove_connection(ctx, conn);
1381 status = apr_socket_close(conn->skt);
1382 serf__log_skt(SOCK_VERBOSE, __FILE__, conn->skt,
1385 if (conn->closed != NULL) {
1386 handle_conn_closed(conn, status);
1388 conn->skt = NULL;
1390 if (conn->stream != NULL) {
1391 serf_bucket_destroy(conn->stream);
1392 conn->stream = NULL;
1395 destroy_ostream(conn);
1410 conn);
1424 serf_connection_t *conn,
1428 serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,
1432 serf__log_skt(CONN_VERBOSE, __FILE__, conn->skt,
1436 conn->max_outstanding_requests = max_requests;
1441 serf_connection_t *conn,
1447 conn->async_responses = 1;
1448 conn->async_acceptor = acceptor;
1449 conn->async_acceptor_baton = acceptor_baton;
1450 conn->async_handler = handler;
1451 conn->async_handler_baton = handler_baton;
1455 create_request(serf_connection_t *conn,
1463 request = serf_bucket_mem_alloc(conn->allocator, sizeof(*request));
1464 request->conn = conn;
1480 serf_connection_t *conn,
1486 request = create_request(conn, setup, setup_baton,
1491 link_requests(&conn->requests, &conn->requests_tail, request);
1494 conn->ctx->dirty_pollset = 1;
1495 conn->dirty_conn = 1;
1501 priority_request_create(serf_connection_t *conn,
1509 request = create_request(conn, setup, setup_baton,
1514 iter = conn->requests;
1541 conn->requests = request;
1545 conn->ctx->dirty_pollset = 1;
1546 conn->dirty_conn = 1;
1552 serf_connection_t *conn,
1556 return priority_request_create(conn,
1561 serf_request_t *serf__ssltunnel_request_create(serf_connection_t *conn,
1565 return priority_request_create(conn,
1572 return cancel_request(request, &request->conn->requests, 0);
1599 return request->conn;
1621 serf_connection_t *conn = request->conn;
1622 serf_context_t *ctx = conn->ctx;
1626 (strcmp(conn->host_info.scheme, "https") == 0);
1633 if (ctx->proxy_address && conn->host_url &&
1636 serf_bucket_request_set_root(req_bkt, conn->host_url);
1639 if (conn->host_info.hostinfo)
1641 conn->host_info.hostinfo);
1646 authn_info = serf__get_authn_info_for_server(conn);
1648 authn_info->scheme->setup_request_func(HOST, 0, conn, request,
1657 if (strcmp(conn->host_info.scheme, "https") == 0) {
1659 ctx->proxy_authn_info.scheme->setup_request_func(PROXY, 0, conn,
1664 ctx->proxy_authn_info.scheme->setup_request_func(PROXY, 0, conn,
1674 apr_interval_time_t serf_connection_get_latency(serf_connection_t *conn)
1676 if (conn->ctx->proxy_address) {
1682 return conn->latency;