2002-09-03 19:52:59 +08:00
|
|
|
/***************************************************************************
|
2004-07-02 16:28:31 +08:00
|
|
|
* _ _ ____ _
|
|
|
|
|
* Project ___| | | | _ \| |
|
|
|
|
|
* / __| | | | |_) | |
|
|
|
|
|
* | (__| |_| | _ <| |___
|
2002-08-13 22:20:47 +08:00
|
|
|
* \___|\___/|_| \_\_____|
|
|
|
|
|
*
|
2023-01-02 20:51:48 +08:00
|
|
|
* Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
|
2002-08-13 22:20:47 +08:00
|
|
|
*
|
2002-09-03 19:52:59 +08:00
|
|
|
* This software is licensed as described in the file COPYING, which
|
|
|
|
|
* you should have received as part of this distribution. The terms
|
2020-11-04 21:02:01 +08:00
|
|
|
* are also available at https://curl.se/docs/copyright.html.
|
2004-07-02 16:28:31 +08:00
|
|
|
*
|
2002-08-13 22:20:47 +08:00
|
|
|
* 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
|
2002-09-03 19:52:59 +08:00
|
|
|
* furnished to do so, under the terms of the COPYING file.
|
2002-08-13 22:20:47 +08:00
|
|
|
*
|
|
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
|
* KIND, either express or implied.
|
|
|
|
|
*
|
2002-09-03 19:52:59 +08:00
|
|
|
* SPDX-License-Identifier: curl
|
2022-05-17 17:16:50 +08:00
|
|
|
*
|
2002-09-03 19:52:59 +08:00
|
|
|
***************************************************************************/
|
2002-08-13 22:20:47 +08:00
|
|
|
|
2013-01-07 02:06:49 +08:00
|
|
|
#include "curl_setup.h"
|
2011-07-26 23:23:27 +08:00
|
|
|
|
2002-08-13 22:20:47 +08:00
|
|
|
#include <curl/curl.h>
|
2013-01-04 09:50:28 +08:00
|
|
|
#include "urldata.h"
|
lib: graceful connection shutdown
When libcurl discards a connection there are two phases this may go
through: "shutdown" and "closing". If a connection is aborted, the
shutdown phase is skipped and it is closed right away.
The connection filters attached to the connection implement the phases
in their `do_shutdown()` and `do_close()` callbacks. Filters carry now a
`shutdown` flags next to `connected` to keep track of the shutdown
operation.
Filters are shut down from top to bottom. If a filter is not connected,
its shutdown is skipped. Notable filters that *do* something during
shutdown are HTTP/2 and TLS. HTTP/2 sends the GOAWAY frame. TLS sends
its close notify and expects to receive a close notify from the server.
As sends and receives may EAGAIN on the network, a shutdown is often not
successful right away and needs to poll the connection's socket(s). To
facilitate this, such connections are placed on a new shutdown list
inside the connection cache.
Since managing this list requires the cooperation of a multi handle,
only the connection cache belonging to a multi handle is used. If a
connection was in another cache when being discarded, it is removed
there and added to the multi's cache. If no multi handle is available at
that time, the connection is shutdown and closed in a one-time,
best-effort attempt.
When a multi handle is destroyed, all connection still on the shutdown
list are discarded with a final shutdown attempt and close. In curl
debug builds, the environment variable `CURL_GRACEFUL_SHUTDOWN` can be
set to make this graceful with a timeout in milliseconds given by the
variable.
The shutdown list is limited to the max number of connections configured
for a multi cache. Set via CURLMOPT_MAX_TOTAL_CONNECTIONS. When the
limit is reached, the oldest connection on the shutdown list is
discarded.
- In multi_wait() and multi_waitfds(), collect all connection caches
involved (each transfer might carry its own) into a temporary list.
Let each connection cache on the list contribute sockets and
POLLIN/OUT events it's connections are waiting for.
- in multi_perform() collect the connection caches the same way and let
them peform their maintenance. This will make another non-blocking
attempt to shutdown all connections on its shutdown list.
- for event based multis (multi->socket_cb set), add the sockets and
their poll events via the callback. When `multi_socket()` is invoked
for a socket not known by an active transfer, forward this to the
multi's cache for processing. On closing a connection, remove its
socket(s) via the callback.
TLS connection filters MUST NOT send close nofity messages in their
`do_close()` implementation. The reason is that a TLS close notify
signals a success. When a connection is aborted and skips its shutdown
phase, the server needs to see a missing close notify to detect
something has gone wrong.
A graceful shutdown of FTP's data connection is performed implicitly
before regarding the upload/download as complete and continuing on the
control connection. For FTP without TLS, there is just the socket close
happening. But with TLS, the sent/received close notify signals that the
transfer is complete and healthy. Servers like `vsftpd` verify that and
reject uploads without a TLS close notify.
- added test_19_* for shutdown related tests
- test_19_01 and test_19_02 test for TCP RST packets
which happen without a graceful shutdown and should
no longer appear otherwise.
- add test_19_03 for handling shutdowns by the server
- add test_19_04 for handling shutdowns by curl
- add test_19_05 for event based shutdowny by server
- add test_30_06/07 and test_31_06/07 for shutdown checks
on FTP up- and downloads.
Closes #13976
2024-06-19 18:40:06 +08:00
|
|
|
#include "connect.h"
|
2013-01-04 09:50:28 +08:00
|
|
|
#include "share.h"
|
2018-05-29 02:29:15 +08:00
|
|
|
#include "psl.h"
|
2013-12-18 06:32:47 +08:00
|
|
|
#include "vtls/vtls.h"
|
2022-12-27 18:50:20 +08:00
|
|
|
#include "hsts.h"
|
2002-08-13 22:20:47 +08:00
|
|
|
|
2022-12-27 18:50:20 +08:00
|
|
|
/* The last 3 #include files should be in this order */
|
|
|
|
|
#include "curl_printf.h"
|
|
|
|
|
#include "curl_memory.h"
|
2013-01-04 09:50:28 +08:00
|
|
|
#include "memdebug.h"
|
2002-08-13 22:20:47 +08:00
|
|
|
|
2016-06-22 01:31:24 +08:00
|
|
|
struct Curl_share *
|
2003-01-09 18:21:03 +08:00
|
|
|
curl_share_init(void)
|
2002-08-13 22:20:47 +08:00
|
|
|
{
|
2009-11-18 18:33:54 +08:00
|
|
|
struct Curl_share *share = calloc(1, sizeof(struct Curl_share));
|
2015-05-22 22:26:14 +08:00
|
|
|
if(share) {
|
2021-01-19 15:23:52 +08:00
|
|
|
share->magic = CURL_GOOD_SHARE;
|
2003-08-11 14:30:02 +08:00
|
|
|
share->specifier |= (1<<CURL_LOCK_DATA_SHARE);
|
2022-08-27 20:48:13 +08:00
|
|
|
Curl_init_dnscache(&share->hostcache, 23);
|
2015-05-12 15:46:53 +08:00
|
|
|
}
|
|
|
|
|
|
2002-08-13 22:20:47 +08:00
|
|
|
return share;
|
|
|
|
|
}
|
|
|
|
|
|
2008-03-18 16:14:37 +08:00
|
|
|
#undef curl_share_setopt
|
2003-01-09 18:21:03 +08:00
|
|
|
CURLSHcode
|
2016-06-22 01:31:24 +08:00
|
|
|
curl_share_setopt(struct Curl_share *share, CURLSHoption option, ...)
|
2002-08-13 22:20:47 +08:00
|
|
|
{
|
2003-01-09 18:21:03 +08:00
|
|
|
va_list param;
|
|
|
|
|
int type;
|
|
|
|
|
curl_lock_function lockfunc;
|
|
|
|
|
curl_unlock_function unlockfunc;
|
|
|
|
|
void *ptr;
|
2012-06-16 04:37:19 +08:00
|
|
|
CURLSHcode res = CURLSHE_OK;
|
2003-01-09 18:21:03 +08:00
|
|
|
|
2021-01-19 15:23:52 +08:00
|
|
|
if(!GOOD_SHARE_HANDLE(share))
|
|
|
|
|
return CURLSHE_INVALID;
|
|
|
|
|
|
2007-11-07 17:21:35 +08:00
|
|
|
if(share->dirty)
|
2024-07-01 22:47:21 +08:00
|
|
|
/* do not allow setting options while one or more handles are already
|
2003-01-09 18:21:03 +08:00
|
|
|
using this share */
|
|
|
|
|
return CURLSHE_IN_USE;
|
|
|
|
|
|
|
|
|
|
va_start(param, option);
|
|
|
|
|
|
|
|
|
|
switch(option) {
|
|
|
|
|
case CURLSHOPT_SHARE:
|
|
|
|
|
/* this is a type this share will share */
|
|
|
|
|
type = va_arg(param, int);
|
2020-06-11 16:16:32 +08:00
|
|
|
|
2016-04-04 02:28:34 +08:00
|
|
|
switch(type) {
|
2004-05-13 23:18:29 +08:00
|
|
|
case CURL_LOCK_DATA_DNS:
|
|
|
|
|
break;
|
2004-06-09 16:23:55 +08:00
|
|
|
|
2004-05-13 23:18:29 +08:00
|
|
|
case CURL_LOCK_DATA_COOKIE:
|
2011-10-04 04:32:36 +08:00
|
|
|
#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_COOKIES)
|
2007-11-07 17:21:35 +08:00
|
|
|
if(!share->cookies) {
|
2016-04-04 02:28:34 +08:00
|
|
|
share->cookies = Curl_cookie_init(NULL, NULL, NULL, TRUE);
|
2004-05-13 23:18:29 +08:00
|
|
|
if(!share->cookies)
|
2012-06-16 04:37:19 +08:00
|
|
|
res = CURLSHE_NOMEM;
|
2004-05-13 23:18:29 +08:00
|
|
|
}
|
2011-10-04 04:32:36 +08:00
|
|
|
#else /* CURL_DISABLE_HTTP */
|
2012-06-16 04:37:19 +08:00
|
|
|
res = CURLSHE_NOT_BUILT_IN;
|
2011-10-04 04:32:36 +08:00
|
|
|
#endif
|
2012-06-16 04:37:19 +08:00
|
|
|
break;
|
2003-02-05 07:48:46 +08:00
|
|
|
|
2022-12-27 18:50:20 +08:00
|
|
|
case CURL_LOCK_DATA_HSTS:
|
|
|
|
|
#ifndef CURL_DISABLE_HSTS
|
|
|
|
|
if(!share->hsts) {
|
|
|
|
|
share->hsts = Curl_hsts_init();
|
|
|
|
|
if(!share->hsts)
|
|
|
|
|
res = CURLSHE_NOMEM;
|
|
|
|
|
}
|
|
|
|
|
#else /* CURL_DISABLE_HSTS */
|
|
|
|
|
res = CURLSHE_NOT_BUILT_IN;
|
|
|
|
|
#endif
|
|
|
|
|
break;
|
|
|
|
|
|
2011-09-20 23:43:54 +08:00
|
|
|
case CURL_LOCK_DATA_SSL_SESSION:
|
2011-10-04 04:32:36 +08:00
|
|
|
#ifdef USE_SSL
|
2011-09-20 23:43:54 +08:00
|
|
|
if(!share->sslsession) {
|
2012-01-19 06:39:30 +08:00
|
|
|
share->max_ssl_sessions = 8;
|
|
|
|
|
share->sslsession = calloc(share->max_ssl_sessions,
|
2020-09-02 18:17:49 +08:00
|
|
|
sizeof(struct Curl_ssl_session));
|
2011-11-18 06:34:38 +08:00
|
|
|
share->sessionage = 0;
|
2011-09-20 23:43:54 +08:00
|
|
|
if(!share->sslsession)
|
2012-06-16 04:37:19 +08:00
|
|
|
res = CURLSHE_NOMEM;
|
2011-09-20 23:43:54 +08:00
|
|
|
}
|
2011-10-04 04:32:36 +08:00
|
|
|
#else
|
2012-06-16 04:37:19 +08:00
|
|
|
res = CURLSHE_NOT_BUILT_IN;
|
2011-10-04 04:32:36 +08:00
|
|
|
#endif
|
2012-06-16 04:37:19 +08:00
|
|
|
break;
|
2011-09-20 23:43:54 +08:00
|
|
|
|
2020-06-11 16:16:32 +08:00
|
|
|
case CURL_LOCK_DATA_CONNECT:
|
lib: graceful connection shutdown
When libcurl discards a connection there are two phases this may go
through: "shutdown" and "closing". If a connection is aborted, the
shutdown phase is skipped and it is closed right away.
The connection filters attached to the connection implement the phases
in their `do_shutdown()` and `do_close()` callbacks. Filters carry now a
`shutdown` flags next to `connected` to keep track of the shutdown
operation.
Filters are shut down from top to bottom. If a filter is not connected,
its shutdown is skipped. Notable filters that *do* something during
shutdown are HTTP/2 and TLS. HTTP/2 sends the GOAWAY frame. TLS sends
its close notify and expects to receive a close notify from the server.
As sends and receives may EAGAIN on the network, a shutdown is often not
successful right away and needs to poll the connection's socket(s). To
facilitate this, such connections are placed on a new shutdown list
inside the connection cache.
Since managing this list requires the cooperation of a multi handle,
only the connection cache belonging to a multi handle is used. If a
connection was in another cache when being discarded, it is removed
there and added to the multi's cache. If no multi handle is available at
that time, the connection is shutdown and closed in a one-time,
best-effort attempt.
When a multi handle is destroyed, all connection still on the shutdown
list are discarded with a final shutdown attempt and close. In curl
debug builds, the environment variable `CURL_GRACEFUL_SHUTDOWN` can be
set to make this graceful with a timeout in milliseconds given by the
variable.
The shutdown list is limited to the max number of connections configured
for a multi cache. Set via CURLMOPT_MAX_TOTAL_CONNECTIONS. When the
limit is reached, the oldest connection on the shutdown list is
discarded.
- In multi_wait() and multi_waitfds(), collect all connection caches
involved (each transfer might carry its own) into a temporary list.
Let each connection cache on the list contribute sockets and
POLLIN/OUT events it's connections are waiting for.
- in multi_perform() collect the connection caches the same way and let
them peform their maintenance. This will make another non-blocking
attempt to shutdown all connections on its shutdown list.
- for event based multis (multi->socket_cb set), add the sockets and
their poll events via the callback. When `multi_socket()` is invoked
for a socket not known by an active transfer, forward this to the
multi's cache for processing. On closing a connection, remove its
socket(s) via the callback.
TLS connection filters MUST NOT send close nofity messages in their
`do_close()` implementation. The reason is that a TLS close notify
signals a success. When a connection is aborted and skips its shutdown
phase, the server needs to see a missing close notify to detect
something has gone wrong.
A graceful shutdown of FTP's data connection is performed implicitly
before regarding the upload/download as complete and continuing on the
control connection. For FTP without TLS, there is just the socket close
happening. But with TLS, the sent/received close notify signals that the
transfer is complete and healthy. Servers like `vsftpd` verify that and
reject uploads without a TLS close notify.
- added test_19_* for shutdown related tests
- test_19_01 and test_19_02 test for TCP RST packets
which happen without a graceful shutdown and should
no longer appear otherwise.
- add test_19_03 for handling shutdowns by the server
- add test_19_04 for handling shutdowns by curl
- add test_19_05 for event based shutdowny by server
- add test_30_06/07 and test_31_06/07 for shutdown checks
on FTP up- and downloads.
Closes #13976
2024-06-19 18:40:06 +08:00
|
|
|
if(Curl_conncache_init(&share->conn_cache, NULL, 103))
|
2017-11-10 21:59:19 +08:00
|
|
|
res = CURLSHE_NOMEM;
|
2012-06-16 04:37:19 +08:00
|
|
|
break;
|
2003-02-05 07:48:46 +08:00
|
|
|
|
2018-05-29 02:29:15 +08:00
|
|
|
case CURL_LOCK_DATA_PSL:
|
|
|
|
|
#ifndef USE_LIBPSL
|
|
|
|
|
res = CURLSHE_NOT_BUILT_IN;
|
|
|
|
|
#endif
|
|
|
|
|
break;
|
|
|
|
|
|
2004-05-13 23:18:29 +08:00
|
|
|
default:
|
2012-06-16 04:37:19 +08:00
|
|
|
res = CURLSHE_BAD_OPTION;
|
2003-02-05 07:48:46 +08:00
|
|
|
}
|
2020-06-11 16:16:32 +08:00
|
|
|
if(!res)
|
2023-12-09 10:45:19 +08:00
|
|
|
share->specifier |= (unsigned int)(1<<type);
|
2003-01-09 18:21:03 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CURLSHOPT_UNSHARE:
|
|
|
|
|
/* this is a type this share will no longer share */
|
|
|
|
|
type = va_arg(param, int);
|
2023-12-09 10:45:19 +08:00
|
|
|
share->specifier &= ~(unsigned int)(1<<type);
|
2016-04-04 02:28:34 +08:00
|
|
|
switch(type) {
|
2011-04-20 21:17:42 +08:00
|
|
|
case CURL_LOCK_DATA_DNS:
|
|
|
|
|
break;
|
2003-02-05 07:48:46 +08:00
|
|
|
|
2011-04-20 21:17:42 +08:00
|
|
|
case CURL_LOCK_DATA_COOKIE:
|
2011-10-04 04:32:36 +08:00
|
|
|
#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_COOKIES)
|
2011-04-20 21:17:42 +08:00
|
|
|
if(share->cookies) {
|
|
|
|
|
Curl_cookie_cleanup(share->cookies);
|
|
|
|
|
share->cookies = NULL;
|
|
|
|
|
}
|
2011-10-04 04:32:36 +08:00
|
|
|
#else /* CURL_DISABLE_HTTP */
|
2012-06-16 04:37:19 +08:00
|
|
|
res = CURLSHE_NOT_BUILT_IN;
|
2011-10-04 04:32:36 +08:00
|
|
|
#endif
|
2012-06-16 04:37:19 +08:00
|
|
|
break;
|
2003-02-05 07:48:46 +08:00
|
|
|
|
2022-12-27 18:50:20 +08:00
|
|
|
case CURL_LOCK_DATA_HSTS:
|
|
|
|
|
#ifndef CURL_DISABLE_HSTS
|
|
|
|
|
if(share->hsts) {
|
|
|
|
|
Curl_hsts_cleanup(&share->hsts);
|
|
|
|
|
}
|
|
|
|
|
#else /* CURL_DISABLE_HSTS */
|
|
|
|
|
res = CURLSHE_NOT_BUILT_IN;
|
|
|
|
|
#endif
|
|
|
|
|
break;
|
|
|
|
|
|
2011-04-20 21:17:42 +08:00
|
|
|
case CURL_LOCK_DATA_SSL_SESSION:
|
2011-10-04 04:32:36 +08:00
|
|
|
#ifdef USE_SSL
|
2012-01-19 06:39:30 +08:00
|
|
|
Curl_safefree(share->sslsession);
|
2011-10-04 04:32:36 +08:00
|
|
|
#else
|
2012-06-16 04:37:19 +08:00
|
|
|
res = CURLSHE_NOT_BUILT_IN;
|
2011-10-04 04:32:36 +08:00
|
|
|
#endif
|
2012-06-16 04:37:19 +08:00
|
|
|
break;
|
2003-02-05 07:48:46 +08:00
|
|
|
|
2011-04-20 21:17:42 +08:00
|
|
|
case CURL_LOCK_DATA_CONNECT:
|
|
|
|
|
break;
|
2003-02-05 07:48:46 +08:00
|
|
|
|
2011-04-20 21:17:42 +08:00
|
|
|
default:
|
2012-06-16 04:37:19 +08:00
|
|
|
res = CURLSHE_BAD_OPTION;
|
|
|
|
|
break;
|
2003-02-05 07:48:46 +08:00
|
|
|
}
|
2003-01-09 18:21:03 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CURLSHOPT_LOCKFUNC:
|
|
|
|
|
lockfunc = va_arg(param, curl_lock_function);
|
|
|
|
|
share->lockfunc = lockfunc;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CURLSHOPT_UNLOCKFUNC:
|
|
|
|
|
unlockfunc = va_arg(param, curl_unlock_function);
|
2004-07-02 16:28:31 +08:00
|
|
|
share->unlockfunc = unlockfunc;
|
2003-01-09 18:21:03 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CURLSHOPT_USERDATA:
|
|
|
|
|
ptr = va_arg(param, void *);
|
|
|
|
|
share->clientdata = ptr;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
2012-06-16 04:37:19 +08:00
|
|
|
res = CURLSHE_BAD_OPTION;
|
|
|
|
|
break;
|
2002-08-13 22:20:47 +08:00
|
|
|
}
|
|
|
|
|
|
2012-06-16 04:37:19 +08:00
|
|
|
va_end(param);
|
|
|
|
|
|
|
|
|
|
return res;
|
2002-08-13 22:20:47 +08:00
|
|
|
}
|
|
|
|
|
|
2003-08-11 14:30:02 +08:00
|
|
|
CURLSHcode
|
2016-06-22 01:31:24 +08:00
|
|
|
curl_share_cleanup(struct Curl_share *share)
|
2002-08-13 22:20:47 +08:00
|
|
|
{
|
2021-01-19 15:23:52 +08:00
|
|
|
if(!GOOD_SHARE_HANDLE(share))
|
2003-08-11 14:30:02 +08:00
|
|
|
return CURLSHE_INVALID;
|
2004-07-02 16:28:31 +08:00
|
|
|
|
|
|
|
|
if(share->lockfunc)
|
|
|
|
|
share->lockfunc(NULL, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE,
|
|
|
|
|
share->clientdata);
|
|
|
|
|
|
2007-11-07 17:21:35 +08:00
|
|
|
if(share->dirty) {
|
2004-07-02 16:28:31 +08:00
|
|
|
if(share->unlockfunc)
|
|
|
|
|
share->unlockfunc(NULL, CURL_LOCK_DATA_SHARE, share->clientdata);
|
2003-01-09 18:21:03 +08:00
|
|
|
return CURLSHE_IN_USE;
|
2003-08-11 14:30:02 +08:00
|
|
|
}
|
2002-08-13 22:20:47 +08:00
|
|
|
|
2017-11-02 06:37:45 +08:00
|
|
|
Curl_conncache_close_all_connections(&share->conn_cache);
|
|
|
|
|
Curl_conncache_destroy(&share->conn_cache);
|
2015-05-03 02:49:55 +08:00
|
|
|
Curl_hash_destroy(&share->hostcache);
|
2003-08-04 23:02:42 +08:00
|
|
|
|
2011-10-21 08:54:18 +08:00
|
|
|
#if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_COOKIES)
|
2015-03-12 01:15:33 +08:00
|
|
|
Curl_cookie_cleanup(share->cookies);
|
2011-10-21 08:54:18 +08:00
|
|
|
#endif
|
2003-08-04 23:02:42 +08:00
|
|
|
|
2022-12-27 18:50:20 +08:00
|
|
|
#ifndef CURL_DISABLE_HSTS
|
|
|
|
|
Curl_hsts_cleanup(&share->hsts);
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-10-04 04:32:36 +08:00
|
|
|
#ifdef USE_SSL
|
2011-09-20 23:43:54 +08:00
|
|
|
if(share->sslsession) {
|
2012-01-19 06:39:30 +08:00
|
|
|
size_t i;
|
|
|
|
|
for(i = 0; i < share->max_ssl_sessions; i++)
|
2011-09-20 23:43:54 +08:00
|
|
|
Curl_ssl_kill_session(&(share->sslsession[i]));
|
|
|
|
|
free(share->sslsession);
|
|
|
|
|
}
|
2011-10-04 04:32:36 +08:00
|
|
|
#endif
|
2011-09-20 23:43:54 +08:00
|
|
|
|
2018-05-29 02:29:15 +08:00
|
|
|
Curl_psl_destroy(&share->psl);
|
|
|
|
|
|
2004-07-02 16:28:31 +08:00
|
|
|
if(share->unlockfunc)
|
|
|
|
|
share->unlockfunc(NULL, CURL_LOCK_DATA_SHARE, share->clientdata);
|
2021-01-19 15:23:52 +08:00
|
|
|
share->magic = 0;
|
2004-07-02 16:28:31 +08:00
|
|
|
free(share);
|
|
|
|
|
|
2003-01-09 18:21:03 +08:00
|
|
|
return CURLSHE_OK;
|
2002-08-13 22:20:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2003-01-09 18:21:03 +08:00
|
|
|
CURLSHcode
|
2016-06-21 21:47:12 +08:00
|
|
|
Curl_share_lock(struct Curl_easy *data, curl_lock_data type,
|
2004-01-29 21:56:45 +08:00
|
|
|
curl_lock_access accesstype)
|
2002-08-13 22:20:47 +08:00
|
|
|
{
|
2003-01-09 18:21:03 +08:00
|
|
|
struct Curl_share *share = data->share;
|
2002-08-13 22:20:47 +08:00
|
|
|
|
2021-04-19 16:46:11 +08:00
|
|
|
if(!share)
|
2003-01-09 18:21:03 +08:00
|
|
|
return CURLSHE_INVALID;
|
2002-08-13 22:20:47 +08:00
|
|
|
|
2023-12-09 10:45:19 +08:00
|
|
|
if(share->specifier & (unsigned int)(1<<type)) {
|
2004-02-26 19:39:38 +08:00
|
|
|
if(share->lockfunc) /* only call this if set! */
|
|
|
|
|
share->lockfunc(data, type, accesstype, share->clientdata);
|
2002-08-13 22:20:47 +08:00
|
|
|
}
|
2024-07-01 22:47:21 +08:00
|
|
|
/* else if we do not share this, pretend successful lock */
|
2002-08-13 22:20:47 +08:00
|
|
|
|
2003-01-09 18:21:03 +08:00
|
|
|
return CURLSHE_OK;
|
2002-08-13 22:20:47 +08:00
|
|
|
}
|
|
|
|
|
|
2003-01-09 18:21:03 +08:00
|
|
|
CURLSHcode
|
2016-06-21 21:47:12 +08:00
|
|
|
Curl_share_unlock(struct Curl_easy *data, curl_lock_data type)
|
2002-08-13 22:20:47 +08:00
|
|
|
{
|
2003-01-09 18:21:03 +08:00
|
|
|
struct Curl_share *share = data->share;
|
2002-08-13 22:20:47 +08:00
|
|
|
|
2021-04-19 16:46:11 +08:00
|
|
|
if(!share)
|
2003-01-09 18:21:03 +08:00
|
|
|
return CURLSHE_INVALID;
|
2002-08-13 22:20:47 +08:00
|
|
|
|
2023-12-09 10:45:19 +08:00
|
|
|
if(share->specifier & (unsigned int)(1<<type)) {
|
2004-02-26 19:39:38 +08:00
|
|
|
if(share->unlockfunc) /* only call this if set! */
|
|
|
|
|
share->unlockfunc (data, type, share->clientdata);
|
2002-08-13 22:20:47 +08:00
|
|
|
}
|
|
|
|
|
|
2003-01-09 18:21:03 +08:00
|
|
|
return CURLSHE_OK;
|
2002-08-13 22:20:47 +08:00
|
|
|
}
|
