/*************************************************************************** * _ _ ____ _ * Project ___| | | | _ \| | * / __| | | | |_) | | * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * * Copyright (C) Linus Nielsen Feltzing, * Copyright (C) Daniel Stenberg, , et al. * * This software is licensed as described in the file COPYING, which * you should have received as part of this distribution. The terms * are also available at https://curl.se/docs/copyright.html. * * You may opt to use, copy, modify, merge, publish, distribute and/or sell * copies of the Software, and permit persons to whom the Software is * furnished to do so, under the terms of the COPYING file. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * * SPDX-License-Identifier: curl * ***************************************************************************/ #include "curl_setup.h" #include "urldata.h" #include "url.h" #include "cfilters.h" #include "progress.h" #include "multiif.h" #include "multi_ev.h" #include "curl_trc.h" #include "cshutdn.h" #include "sigpipe.h" #include "connect.h" #include "select.h" #include "curlx/strparse.h" #define DEFAULT_SHUTDOWN_TIMEOUT_MS (2 * 1000) void Curl_cshutdn_start_timer(struct Curl_easy *data, int8_t sockindex, int timeout_ms) { struct connectdata *conn = data->conn; const struct curltime *pnow = Curl_pgrs_now(data); DEBUGASSERT(conn); conn->shutdown.start_ms[sockindex] = curlx_ptimediff_ms(pnow, &conn->created); conn->shutdown.timeout_ms = (timeout_ms > 0) ? (timediff_t)timeout_ms : ((data->set.shutdowntimeout > 0) ? data->set.shutdowntimeout : DEFAULT_SHUTDOWN_TIMEOUT_MS); CURL_TRC_M(data, "shutdown start on%s connection", sockindex ? " secondary" : ""); } timediff_t Curl_cshutdn_timeleft_ms(struct Curl_easy *data, struct connectdata *conn, int8_t sockindex) { timediff_t left_ms; if(conn->shutdown.start_ms[sockindex] < 0) return 0; /* not started or no limits */ left_ms = conn->shutdown.timeout_ms - (curlx_ptimediff_ms(Curl_pgrs_now(data), &conn->created) - conn->shutdown.start_ms[sockindex]); return left_ms ? left_ms : -1; } static timediff_t cshutdn_conn_timeleft(struct Curl_easy *data, struct connectdata *conn) { timediff_t left_ms = 0, ms; int8_t i; for(i = 0; conn->shutdown.timeout_ms && (i < 2); ++i) { if(conn->shutdown.start_ms[i] < 0) continue; ms = Curl_cshutdn_timeleft_ms(data, conn, i); if(ms && (!left_ms || ms < left_ms)) left_ms = ms; } return left_ms; } void Curl_cshutdn_clear_timer(struct Curl_easy *data, int8_t sockindex) { data->conn->shutdown.start_ms[sockindex] = -1; } static void cshutdn_run_conn_handler(struct Curl_easy *data, struct connectdata *conn) { if(!conn->bits.shutdown_handler) { if(conn->scheme && conn->scheme->run->disconnect) { /* Some disconnect handlers do a blocking wait on server responses. * FTP/IMAP/SMTP and SFTP are among them. When using the internal * handle, set an overall short timeout so we do not hang for the * default 120 seconds. */ if(data->state.internal) { data->set.timeout = DEFAULT_SHUTDOWN_TIMEOUT_MS; Curl_pgrsTime(data, TIMER_STARTOP); } /* This is set if protocol-specific cleanups should be made */ DEBUGF(infof(data, "connection #%" FMT_OFF_T ", shutdown protocol handler (aborted=%d)", conn->connection_id, conn->bits.aborted)); /* There are protocol handlers that block on retrieving * server responses here (FTP). Set a short timeout. */ conn->scheme->run->disconnect(data, conn, (bool)conn->bits.aborted); } conn->bits.shutdown_handler = TRUE; } } static CURLcode cshutdn_try_once_idx(struct Curl_easy *data, int8_t sockindex, bool *done) { struct Curl_cfilter *cf; CURLcode result = CURLE_OK; timediff_t timeout_ms; DEBUGASSERT(data->conn); if(!CONN_SOCK_IDX_VALID(sockindex)) return CURLE_BAD_FUNCTION_ARGUMENT; /* Get the first connected filter that is not shut down already. */ cf = data->conn->cfilter[sockindex]; while(cf && (!cf->connected || cf->shutdown)) cf = cf->next; if(!cf) { *done = TRUE; return CURLE_OK; } *done = FALSE; if(!CURL_CONN_IN_SHUTDOWN(data->conn, sockindex)) { Curl_cshutdn_start_timer(data, sockindex, 0); } else { timeout_ms = Curl_cshutdn_timeleft_ms(data, data->conn, sockindex); if(timeout_ms < 0) { /* info message, since this might be regarded as acceptable */ infof(data, "shutdown timeout"); return CURLE_OPERATION_TIMEDOUT; } } while(cf) { if(!cf->shutdown) { bool cfdone = FALSE; result = cf->cft->do_shutdown(cf, data, &cfdone); if(result) { CURL_TRC_CF(data, cf, "shut down failed with %d", (int)result); return result; } else if(!cfdone) { CURL_TRC_CF(data, cf, "shut down not done yet"); return CURLE_OK; } CURL_TRC_CF(data, cf, "shut down successfully"); cf->shutdown = TRUE; } cf = cf->next; } *done = (!result); return result; } CURLcode Curl_cshutdn_try_once_idx(struct Curl_easy *data, int8_t sockindex, bool *done) { CURLcode result = cshutdn_try_once_idx(data, sockindex, done); /* Set a timer if shutdown is ongoing */ if(!result && !*done) { timediff_t ms = cshutdn_conn_timeleft(data, data->conn); if(ms) Curl_expire_set(data, EXPIRE_SHUTDOWN, ms, Curl_pgrs_now(data)); } return result; } static void cshutdn_run_once(struct Curl_easy *data, struct connectdata *conn, bool *done) { CURLcode r1, r2; bool done1, done2; /* We expect to be attached when called */ DEBUGASSERT(data->conn == conn); if(!CURL_CONN_IN_SHUTDOWN(conn, FIRSTSOCKET)) { Curl_cshutdn_start_timer(data, FIRSTSOCKET, 0); } cshutdn_run_conn_handler(data, conn); if(conn->bits.shutdown_filters) { *done = TRUE; return; } if(!conn->bits.connect_only && Curl_conn_is_connected(conn, FIRSTSOCKET)) r1 = cshutdn_try_once_idx(data, FIRSTSOCKET, &done1); else { r1 = CURLE_OK; done1 = TRUE; } if(!conn->bits.connect_only && Curl_conn_is_connected(conn, SECONDARYSOCKET)) r2 = cshutdn_try_once_idx(data, SECONDARYSOCKET, &done2); else { r2 = CURLE_OK; done2 = TRUE; } /* we are done when any failed or both report success */ *done = (r1 || r2 || (done1 && done2)); if(*done) conn->bits.shutdown_filters = TRUE; } void Curl_cshutdn_try_once(struct Curl_easy *admin, struct connectdata *conn, bool *done) { DEBUGASSERT(!admin->conn); DEBUGASSERT(!admin->mid); Curl_attach_connection(admin, conn, FALSE); cshutdn_run_once(admin, conn, done); CURL_TRC_M(admin, "[SHUTDOWN] shutdown, done=%d", *done); Curl_detach_connection(admin); } void Curl_cshutdn_terminate(struct Curl_easy *admin, struct connectdata *conn, bool do_shutdown) { bool done; /* there must be a connection to close */ DEBUGASSERT(conn); /* it must be removed from the connection pool */ DEBUGASSERT(conn->cpid == UINT32_MAX); /* the transfer must be detached from the connection */ DEBUGASSERT(admin && !admin->conn); DEBUGASSERT(!admin->mid); Curl_attach_connection(admin, conn, FALSE); cshutdn_run_conn_handler(admin, conn); if(do_shutdown) { /* Make a last attempt to shutdown handlers and filters, if * not done so already. */ cshutdn_run_once(admin, conn, &done); } CURL_TRC_M(admin, "[SHUTDOWN] %sclosing connection #%" FMT_OFF_T, conn->bits.shutdown_filters ? "" : "force ", conn->connection_id); Curl_conn_cf_discard_all(admin, conn, SECONDARYSOCKET); Curl_conn_cf_discard_all(admin, conn, FIRSTSOCKET); Curl_detach_connection(admin); if(admin->multi) Curl_multi_ev_conn_done(admin->multi, admin, conn); Curl_conn_free(admin, conn); if(admin->multi) { CURL_TRC_M(admin, "[SHUTDOWN] trigger multi connchanged"); Curl_multi_connchanged(admin->multi); } } static size_t cshutdn_destroy_oldest(struct cshutdn *cshutdn, struct Curl_easy *admin, const char *destination, size_t count) { struct Curl_sigpipe_ctx sigpipe_ctx; size_t removed = 0; uint32_t i = 0; sigpipe_init(&sigpipe_ctx); while((removed < count) && (i < CURL_PTRARRAY_COUNT(&cshutdn->conns))) { struct connectdata *conn = CURL_PTRARRAY_GET(&cshutdn->conns, i); if(!destination || !strcmp(destination, conn->destination)) { Curl_ptrarray_remove(&cshutdn->conns, i); sigpipe_apply(admin, &sigpipe_ctx); Curl_cshutdn_terminate(admin, conn, FALSE); ++removed; } else ++i; } sigpipe_restore(&sigpipe_ctx); return removed; } size_t Curl_cshutdn_close_oldest(struct cshutdn *cshutdn, struct Curl_easy *admin, const char *destination, size_t count) { if(cshutdn) { return cshutdn_destroy_oldest(cshutdn, admin, destination, count); } return 0; } #define NUM_POLLS_ON_STACK 10 static CURLcode cshutdn_wait(struct cshutdn *cshutdn, struct Curl_easy *admin, int timeout_ms) { struct pollfd a_few_on_stack[NUM_POLLS_ON_STACK]; struct curl_pollfds cpfds; CURLcode result; Curl_pollfds_init(&cpfds, a_few_on_stack, NUM_POLLS_ON_STACK); result = Curl_cshutdn_add_pollfds(cshutdn, admin, &cpfds); if(result) goto out; Curl_poll(cpfds.pfds, cpfds.n, CURLMIN(timeout_ms, 1000)); out: Curl_pollfds_cleanup(&cpfds); return result; } static void cshutdn_perform(struct cshutdn *cshutdn, struct Curl_easy *admin, struct Curl_sigpipe_ctx *sigpipe_ctx) { struct connectdata *conn; timediff_t next_expire_ms = 0, ms; uint32_t i = 0; bool done; if(!CURL_PTRARRAY_COUNT(&cshutdn->conns)) return; CURL_TRC_M(admin, "[SHUTDOWN] perform on %u connections", CURL_PTRARRAY_COUNT(&cshutdn->conns)); sigpipe_apply(admin, sigpipe_ctx); while(i < CURL_PTRARRAY_COUNT(&cshutdn->conns)) { conn = CURL_PTRARRAY_GET(&cshutdn->conns, i); Curl_cshutdn_try_once(admin, conn, &done); if(done) { Curl_ptrarray_remove(&cshutdn->conns, i); Curl_cshutdn_terminate(admin, conn, FALSE); } else { ++i; /* idata has one timer list, but maybe more than one connection. * Set EXPIRE_SHUTDOWN to the smallest time left for all. */ ms = cshutdn_conn_timeleft(admin, conn); if(ms && (!next_expire_ms || (ms < next_expire_ms))) next_expire_ms = ms; } } if(next_expire_ms) Curl_expire(admin, next_expire_ms, EXPIRE_SHUTDOWN); } static void cshutdn_terminate_all(struct cshutdn *cshutdn, struct Curl_easy *admin, int timeout_ms) { struct curltime started = *Curl_pgrs_now(admin); struct Curl_sigpipe_ctx sigpipe_ctx; CURL_TRC_M(admin, "[SHUTDOWN] shutdown all"); sigpipe_init(&sigpipe_ctx); while(CURL_PTRARRAY_COUNT(&cshutdn->conns)) { timediff_t spent_ms; int remain_ms; cshutdn_perform(cshutdn, admin, &sigpipe_ctx); if(!CURL_PTRARRAY_COUNT(&cshutdn->conns)) { CURL_TRC_M(admin, "[SHUTDOWN] shutdown finished cleanly"); break; } /* wait for activity, timeout or "nothing" */ spent_ms = curlx_ptimediff_ms(Curl_pgrs_now(admin), &started); if(spent_ms >= (timediff_t)timeout_ms) { CURL_TRC_M(admin, "[SHUTDOWN] shutdown finished, %s", (timeout_ms > 0) ? "timeout" : "best effort done"); break; } remain_ms = timeout_ms - (int)spent_ms; if(cshutdn_wait(cshutdn, admin, remain_ms)) { CURL_TRC_M(admin, "[SHUTDOWN] shutdown finished, aborted"); break; } } /* Terminate any remaining. */ while(CURL_PTRARRAY_COUNT(&cshutdn->conns)) { struct connectdata *conn = Curl_ptrarray_remove(&cshutdn->conns, 0); Curl_cshutdn_terminate(admin, conn, FALSE); } DEBUGASSERT(!CURL_PTRARRAY_COUNT(&cshutdn->conns)); sigpipe_restore(&sigpipe_ctx); } void Curl_cshutdn_init(struct cshutdn *cshutdn) { Curl_ptrarray_init(&cshutdn->conns); } void Curl_cshutdn_destroy(struct cshutdn *cshutdn, struct Curl_easy *admin) { if(admin) { int timeout_ms = 0; /* for testing, run graceful shutdown */ #ifdef DEBUGBUILD { const char *p = getenv("CURL_GRACEFUL_SHUTDOWN"); if(p) { curl_off_t l; if(!curlx_str_number(&p, &l, INT_MAX)) timeout_ms = (int)l; } } #endif if(CURL_PTRARRAY_COUNT(&cshutdn->conns)) { CURL_TRC_M(admin, "[SHUTDOWN] destroy, %u connections, timeout=%dms", CURL_PTRARRAY_COUNT(&cshutdn->conns), timeout_ms); cshutdn_terminate_all(cshutdn, admin, timeout_ms); } } } size_t Curl_cshutdn_count(struct cshutdn *cshutdn) { if(cshutdn) { return CURL_PTRARRAY_COUNT(&cshutdn->conns); } return 0; } size_t Curl_cshutdn_dest_count(struct cshutdn *cshutdn, const char *destination) { if(cshutdn) { size_t n = 0; uint32_t i = 0; for(i = 0; i < CURL_PTRARRAY_COUNT(&cshutdn->conns); ++i) { struct connectdata *conn = CURL_PTRARRAY_GET(&cshutdn->conns, i); if(!strcmp(destination, conn->destination)) ++n; } return n; } return 0; } static CURLMcode cshutdn_update_ev(struct Curl_multi *multi, struct connectdata *conn) { CURLMcode mresult; Curl_attach_connection(multi->admin, conn, FALSE); mresult = Curl_multi_ev_assess_conn(multi, multi->admin, conn); Curl_detach_connection(multi->admin); return mresult; } void Curl_cshutdn_add(struct cshutdn *cshutdn, struct Curl_multi *multi, struct connectdata *conn, size_t max_shutdowns) { struct Curl_easy *admin = multi->admin; /* Add the connection to our shutdown list for non-blocking shutdown * during multi processing. */ if(max_shutdowns <= CURL_PTRARRAY_COUNT(&cshutdn->conns)) { CURL_TRC_M(admin, "[SHUTDOWN] discarding oldest shutdown connection " "due to shutdown limit of %zu", max_shutdowns); cshutdn_destroy_oldest(cshutdn, admin, NULL, 1); } if(multi->socket_cb && cshutdn_update_ev(multi, conn)) { CURL_TRC_M(admin, "[SHUTDOWN] update events failed, discarding #%" FMT_OFF_T, conn->connection_id); Curl_cshutdn_terminate(admin, conn, FALSE); return; } if(Curl_ptrarray_add(&cshutdn->conns, conn)) { CURL_TRC_M(admin, "[SHUTDOWN] adding failed, discarding #%" FMT_OFF_T, conn->connection_id); Curl_cshutdn_terminate(admin, conn, FALSE); return; } CURL_TRC_M(admin, "[SHUTDOWN] added #%" FMT_OFF_T " to shutdowns, now %u conns in shutdown", conn->connection_id, CURL_PTRARRAY_COUNT(&cshutdn->conns)); Curl_multi_mark_dirty(admin); } void Curl_cshutdn_perform(struct cshutdn *cshutdn, struct Curl_easy *admin, struct Curl_sigpipe_ctx *sigpipe_ctx) { cshutdn_perform(cshutdn, admin, sigpipe_ctx); } /* return fd_set info about the shutdown connections */ void Curl_cshutdn_setfds(struct cshutdn *cshutdn, struct Curl_easy *admin, fd_set *read_fd_set, fd_set *write_fd_set, int *maxfd) { if(CURL_PTRARRAY_COUNT(&cshutdn->conns)) { struct easy_pollset ps; uint32_t i; Curl_pollset_init(&ps); for(i = 0; i < CURL_PTRARRAY_COUNT(&cshutdn->conns); ++i) { unsigned int j; struct connectdata *conn = CURL_PTRARRAY_GET(&cshutdn->conns, i); CURLcode result; Curl_pollset_reset(&ps); Curl_attach_connection(admin, conn, FALSE); result = Curl_conn_adjust_pollset(admin, conn, &ps); Curl_detach_connection(admin); if(result) continue; for(j = 0; j < ps.n; j++) { curl_socket_t sock = ps.sockets[j]; if(!FDSET_SOCK(sock)) continue; if(ps.actions[j] & CURL_POLL_IN) FD_SET(sock, read_fd_set); if(ps.actions[j] & CURL_POLL_OUT) FD_SET(sock, write_fd_set); if((ps.actions[j] & (CURL_POLL_OUT | CURL_POLL_IN)) && ((int)sock > *maxfd)) *maxfd = (int)sock; } } Curl_pollset_cleanup(&ps); } } /* return information about the shutdown connections */ unsigned int Curl_cshutdn_add_waitfds(struct cshutdn *cshutdn, struct Curl_easy *admin, struct Curl_waitfds *cwfds) { unsigned int need = 0; if(CURL_PTRARRAY_COUNT(&cshutdn->conns)) { struct easy_pollset ps; struct connectdata *conn; uint32_t i; CURLcode result; Curl_pollset_init(&ps); for(i = 0; i < CURL_PTRARRAY_COUNT(&cshutdn->conns); ++i) { conn = CURL_PTRARRAY_GET(&cshutdn->conns, i); Curl_pollset_reset(&ps); Curl_attach_connection(admin, conn, FALSE); result = Curl_conn_adjust_pollset(admin, conn, &ps); Curl_detach_connection(admin); if(!result) need += Curl_waitfds_add_ps(cwfds, &ps); } Curl_pollset_cleanup(&ps); } return need; } CURLcode Curl_cshutdn_add_pollfds(struct cshutdn *cshutdn, struct Curl_easy *admin, struct curl_pollfds *cpfds) { CURLcode result = CURLE_OK; if(CURL_PTRARRAY_COUNT(&cshutdn->conns)) { struct easy_pollset ps; struct connectdata *conn; uint32_t i; Curl_pollset_init(&ps); for(i = 0; i < CURL_PTRARRAY_COUNT(&cshutdn->conns); ++i) { conn = CURL_PTRARRAY_GET(&cshutdn->conns, i); Curl_pollset_reset(&ps); Curl_attach_connection(admin, conn, FALSE); result = Curl_conn_adjust_pollset(admin, conn, &ps); Curl_detach_connection(admin); if(!result) result = Curl_pollfds_add_ps(cpfds, &ps); if(result) { Curl_pollset_cleanup(&ps); Curl_pollfds_cleanup(cpfds); goto out; } } Curl_pollset_cleanup(&ps); } out: return result; }