Home | History | Annotate | Download | only in lib
      1 #ifndef HEADER_CURL_MULTIHANDLE_H
      2 #define HEADER_CURL_MULTIHANDLE_H
      3 /***************************************************************************
      4  *                                  _   _ ____  _
      5  *  Project                     ___| | | |  _ \| |
      6  *                             / __| | | | |_) | |
      7  *                            | (__| |_| |  _ <| |___
      8  *                             \___|\___/|_| \_\_____|
      9  *
     10  * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel (at) haxx.se>, et al.
     11  *
     12  * This software is licensed as described in the file COPYING, which
     13  * you should have received as part of this distribution. The terms
     14  * are also available at http://curl.haxx.se/docs/copyright.html.
     15  *
     16  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
     17  * copies of the Software, and permit persons to whom the Software is
     18  * furnished to do so, under the terms of the COPYING file.
     19  *
     20  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
     21  * KIND, either express or implied.
     22  *
     23  ***************************************************************************/
     24 
     25 #include "conncache.h"
     26 
     27 struct Curl_message {
     28   /* the 'CURLMsg' is the part that is visible to the external user */
     29   struct CURLMsg extmsg;
     30 };
     31 
     32 /* NOTE: if you add a state here, add the name to the statename[] array as
     33    well!
     34 */
     35 typedef enum {
     36   CURLM_STATE_INIT,         /* 0 - start in this state */
     37   CURLM_STATE_CONNECT_PEND, /* 1 - no connections, waiting for one */
     38   CURLM_STATE_CONNECT,      /* 2 - resolve/connect has been sent off */
     39   CURLM_STATE_WAITRESOLVE,  /* 3 - awaiting the resolve to finalize */
     40   CURLM_STATE_WAITCONNECT,  /* 4 - awaiting the TCP connect to finalize */
     41   CURLM_STATE_WAITPROXYCONNECT, /* 5 - awaiting proxy CONNECT to finalize */
     42   CURLM_STATE_SENDPROTOCONNECT, /* 6 - initiate protocol connect procedure */
     43   CURLM_STATE_PROTOCONNECT, /* 7 - completing the protocol-specific connect
     44                                    phase */
     45   CURLM_STATE_WAITDO,       /* 8 - wait for our turn to send the request */
     46   CURLM_STATE_DO,           /* 9 - start send off the request (part 1) */
     47   CURLM_STATE_DOING,        /* 10 - sending off the request (part 1) */
     48   CURLM_STATE_DO_MORE,      /* 11 - send off the request (part 2) */
     49   CURLM_STATE_DO_DONE,      /* 12 - done sending off request */
     50   CURLM_STATE_WAITPERFORM,  /* 13 - wait for our turn to read the response */
     51   CURLM_STATE_PERFORM,      /* 14 - transfer data */
     52   CURLM_STATE_TOOFAST,      /* 15 - wait because limit-rate exceeded */
     53   CURLM_STATE_DONE,         /* 16 - post data transfer operation */
     54   CURLM_STATE_COMPLETED,    /* 17 - operation complete */
     55   CURLM_STATE_MSGSENT,      /* 18 - the operation complete message is sent */
     56   CURLM_STATE_LAST          /* 19 - not a true state, never use this */
     57 } CURLMstate;
     58 
     59 /* we support N sockets per easy handle. Set the corresponding bit to what
     60    action we should wait for */
     61 #define MAX_SOCKSPEREASYHANDLE 5
     62 #define GETSOCK_READABLE (0x00ff)
     63 #define GETSOCK_WRITABLE (0xff00)
     64 
     65 #define CURLPIPE_ANY (CURLPIPE_HTTP1 | CURLPIPE_MULTIPLEX)
     66 
     67 /* This is the struct known as CURLM on the outside */
     68 struct Curl_multi {
     69   /* First a simple identifier to easier detect if a user mix up
     70      this multi handle with an easy handle. Set this to CURL_MULTI_HANDLE. */
     71   long type;
     72 
     73   /* We have a doubly-linked circular list with easy handles */
     74   struct SessionHandle *easyp;
     75   struct SessionHandle *easylp; /* last node */
     76 
     77   int num_easy; /* amount of entries in the linked list above. */
     78   int num_alive; /* amount of easy handles that are added but have not yet
     79                     reached COMPLETE state */
     80 
     81   struct curl_llist *msglist; /* a list of messages from completed transfers */
     82 
     83   struct curl_llist *pending; /* SessionHandles that are in the
     84                                  CURLM_STATE_CONNECT_PEND state */
     85 
     86   /* callback function and user data pointer for the *socket() API */
     87   curl_socket_callback socket_cb;
     88   void *socket_userp;
     89 
     90   /* Hostname cache */
     91   struct curl_hash hostcache;
     92 
     93   /* timetree points to the splay-tree of time nodes to figure out expire
     94      times of all currently set timers */
     95   struct Curl_tree *timetree;
     96 
     97   /* 'sockhash' is the lookup hash for socket descriptor => easy handles (note
     98      the pluralis form, there can be more than one easy handle waiting on the
     99      same actual socket) */
    100   struct curl_hash sockhash;
    101 
    102   /* pipelining wanted bits (CURLPIPE*) */
    103   long pipelining;
    104 
    105   bool recheckstate; /* see Curl_multi_connchanged */
    106 
    107   /* Shared connection cache (bundles)*/
    108   struct conncache conn_cache;
    109 
    110   /* This handle will be used for closing the cached connections in
    111      curl_multi_cleanup() */
    112   struct SessionHandle *closure_handle;
    113 
    114   long maxconnects; /* if >0, a fixed limit of the maximum number of entries
    115                        we're allowed to grow the connection cache to */
    116 
    117   long max_host_connections; /* if >0, a fixed limit of the maximum number
    118                                 of connections per host */
    119 
    120   long max_total_connections; /* if >0, a fixed limit of the maximum number
    121                                  of connections in total */
    122 
    123   long max_pipeline_length; /* if >0, maximum number of requests in a
    124                                pipeline */
    125 
    126   long content_length_penalty_size; /* a connection with a
    127                                        content-length bigger than
    128                                        this is not considered
    129                                        for pipelining */
    130 
    131   long chunk_length_penalty_size; /* a connection with a chunk length
    132                                      bigger than this is not
    133                                      considered for pipelining */
    134 
    135   struct curl_llist *pipelining_site_bl; /* List of sites that are blacklisted
    136                                             from pipelining */
    137 
    138   struct curl_llist *pipelining_server_bl; /* List of server types that are
    139                                               blacklisted from pipelining */
    140 
    141   /* timer callback and user data pointer for the *socket() API */
    142   curl_multi_timer_callback timer_cb;
    143   void *timer_userp;
    144   struct timeval timer_lastcall; /* the fixed time for the timeout for the
    145                                     previous callback */
    146 };
    147 
    148 #endif /* HEADER_CURL_MULTIHANDLE_H */
    149