luo980/curl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
a182327b35
curl/lib/multihandle.h
Stefan Eissing 9b1037ea73
Split shutdown handling from connection pool 
Further testing with timeouts in event based processing
    revealed that our current shutdown handling in the connection
    pool was not clear enough. Graceful shutdowns can only happen
    inside a multi handle and it was confusing to track in the code
    which situation actually applies. It seems better to split
    the shutdown handling off and have that code always be part
    of a multi handle.

    Add `cshutdn.[ch]` with its own struct to maintain connections
    being shut down. A `cshutdn` always belongs to a multi handle
    and uses that for socket/timeout monitoring.

    The `cpool`, which can be part of a multi or share, either
    passes connections to a `cshutdn` or terminates them with a
    one-time, best effort.

    Add an `admin` easy handle to each multi and share. This is
    used to perform all maintenance operations where no "real"
    easy handle is available.  This solves the problem
    that the multi admin handle requires some additional
    initialisation (e.g. timeout list).

    The share needs its admin handle as it is often cleaned up
    when no other transfer or multi handle exists any more. But
    we need a `data` in almost every call.

    Fix file:// handling of errors when adding a new connection
    to the pool.

    Changes in `curl` itself:
    - for parallel transfers, do not set a connection pool in the share,
      rely on the multi's connection pool instead.
      While not a requirement for the new `cshutdn` to work, this is
      a) helpful in testing to trigger graceful shutdowns
      b) a broader code coverage of libcurl via the curl tool
    - on test_event with uv, cleanup the multi handle before returning
      from parallel_event(). The uv struct is on the stack, cleanup
      of the multi later will crash when it tries to register sockets.
      This is a "eat your own dogfoof" related fix.
2025-02-28 11:18:12 +01:00

196 lines
7.7 KiB
C
Raw Blame History

#ifndef HEADER_CURL_MULTIHANDLE_H
#define HEADER_CURL_MULTIHANDLE_H
/***************************************************************************
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
* Copyright (C) Daniel Stenberg, <daniel@haxx.se>, 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 "llist.h"
#include "hash.h"
#include "conncache.h"
#include "cshutdn.h"
#include "multi_ev.h"
#include "psl.h"
#include "socketpair.h"
struct connectdata;
struct Curl_easy;
struct Curl_message {
struct Curl_llist_node list;
/* the 'CURLMsg' is the part that is visible to the external user */
struct CURLMsg extmsg;
};
/* NOTE: if you add a state here, add the name to the statenames[] array
* in curl_trc.c as well!
*/
typedef enum {
MSTATE_INIT, /* 0 - start in this state */
MSTATE_PENDING, /* 1 - no connections, waiting for one */
MSTATE_SETUP, /* 2 - start a new transfer */
MSTATE_CONNECT, /* 3 - resolve/connect has been sent off */
MSTATE_RESOLVING, /* 4 - awaiting the resolve to finalize */
MSTATE_CONNECTING, /* 5 - awaiting the TCP connect to finalize */
MSTATE_TUNNELING, /* 6 - awaiting HTTPS proxy SSL initialization to
complete and/or proxy CONNECT to finalize */
MSTATE_PROTOCONNECT, /* 7 - initiate protocol connect procedure */
MSTATE_PROTOCONNECTING, /* 8 - completing the protocol-specific connect
phase */
MSTATE_DO, /* 9 - start send off the request (part 1) */
MSTATE_DOING, /* 10 - sending off the request (part 1) */
MSTATE_DOING_MORE, /* 11 - send off the request (part 2) */
MSTATE_DID, /* 12 - done sending off request */
MSTATE_PERFORMING, /* 13 - transfer data */
MSTATE_RATELIMITING, /* 14 - wait because limit-rate exceeded */
MSTATE_DONE, /* 15 - post data transfer operation */
MSTATE_COMPLETED, /* 16 - operation complete */
MSTATE_MSGSENT, /* 17 - the operation complete message is sent */
MSTATE_LAST /* 18 - not a true state, never use this */
} CURLMstate;
/* we support N sockets per easy handle. Set the corresponding bit to what
action we should wait for */
#define MAX_SOCKSPEREASYHANDLE 5
#define GETSOCK_READABLE (0x00ff)
#define GETSOCK_WRITABLE (0xff00)
#define CURLPIPE_ANY (CURLPIPE_MULTIPLEX)
#if !defined(CURL_DISABLE_SOCKETPAIR)
#define ENABLE_WAKEUP
#endif
/* value for MAXIMUM CONCURRENT STREAMS upper limit */
#define INITIAL_MAX_CONCURRENT_STREAMS ((1U << 31) - 1)
/* This is the struct known as CURLM on the outside */
struct Curl_multi {
/* First a simple identifier to easier detect if a user mix up
this multi handle with an easy handle. Set this to CURL_MULTI_HANDLE. */
unsigned int magic;
unsigned int num_easy; /* amount of entries in the linked list above. */
unsigned int num_alive; /* amount of easy handles that are added but have
not yet reached COMPLETE state */
struct Curl_llist msglist; /* a list of messages from completed transfers */
/* Each added easy handle is added to ONE of these three lists */
struct Curl_llist process; /* not in PENDING or MSGSENT */
struct Curl_llist pending; /* in PENDING */
struct Curl_llist msgsent; /* in MSGSENT */
curl_off_t next_easy_mid; /* next multi-id for easy handle added */
struct Curl_easy *admin; /* internal easy handle for admin operations */
/* callback function and user data pointer for the *socket() API */
curl_socket_callback socket_cb;
void *socket_userp;
/* callback function and user data pointer for server push */
curl_push_callback push_cb;
void *push_userp;
struct Curl_hash hostcache; /* Hostname cache */
struct Curl_ssl_scache *ssl_scache; /* TLS session pool */
#ifdef USE_LIBPSL
/* PSL cache. */
struct PslCache psl;
#endif
/* timetree points to the splay-tree of time nodes to figure out expire
times of all currently set timers */
struct Curl_tree *timetree;
/* buffer used for transfer data, lazy initialized */
char *xfer_buf; /* the actual buffer */
size_t xfer_buf_len; /* the allocated length */
/* buffer used for upload data, lazy initialized */
char *xfer_ulbuf; /* the actual buffer */
size_t xfer_ulbuf_len; /* the allocated length */
/* buffer used for socket I/O operations, lazy initialized */
char *xfer_sockbuf; /* the actual buffer */
size_t xfer_sockbuf_len; /* the allocated length */
/* multi event related things */
struct curl_multi_ev ev;
/* `proto_hash` is a general key-value store for protocol implementations
* with the lifetime of the multi handle. The number of elements kept here
* should be in the order of supported protocols (and sub-protocols like
* TLS), *not* in the order of connections or current transfers!
* Elements need to be added with their own destructor to be invoked when
* the multi handle is cleaned up (see Curl_hash_add2()).*/
struct Curl_hash proto_hash;
struct cshutdn cshutdn; /* connection shutdown handling */
struct cpool cpool; /* connection pool (bundles) */
long max_host_connections; /* if >0, a fixed limit of the maximum number
of connections per host */
long max_total_connections; /* if >0, a fixed limit of the maximum number
of connections in total */
/* timer callback and user data pointer for the *socket() API */
curl_multi_timer_callback timer_cb;
void *timer_userp;
long last_timeout_ms; /* the last timeout value set via timer_cb */
struct curltime last_expire_ts; /* timestamp of last expiry */
#ifdef USE_WINSOCK
WSAEVENT wsa_event; /* Winsock event used for waits */
#else
#ifdef ENABLE_WAKEUP
curl_socket_t wakeup_pair[2]; /* eventfd()/pipe()/socketpair() used for
wakeup 0 is used for read, 1 is used
for write */
#endif
#endif
unsigned int max_concurrent_streams;
unsigned int maxconnects; /* if >0, a fixed limit of the maximum number of
entries we are allowed to grow the connection
cache to */
#define IPV6_UNKNOWN 0
#define IPV6_DEAD 1
#define IPV6_WORKS 2
unsigned char ipv6_up; /* IPV6_* defined */
BIT(multiplexing); /* multiplexing wanted */
BIT(recheckstate); /* see Curl_multi_connchanged */
BIT(in_callback); /* true while executing a callback */
#ifdef USE_OPENSSL
BIT(ssl_seeded);
#endif
BIT(dead); /* a callback returned error, everything needs to crash and
burn */
BIT(xfer_buf_borrowed); /* xfer_buf is currently being borrowed */
BIT(xfer_ulbuf_borrowed); /* xfer_ulbuf is currently being borrowed */
BIT(xfer_sockbuf_borrowed); /* xfer_sockbuf is currently being borrowed */
#ifdef DEBUGBUILD
BIT(warned); /* true after user warned of DEBUGBUILD */
#endif
};
#endif /* HEADER_CURL_MULTIHANDLE_H */
Reference in New Issue View Git Blame Copy Permalink