| 1 | #ifndef HEADER_CURL_HTTP_H
|
|---|
| 2 | #define HEADER_CURL_HTTP_H
|
|---|
| 3 | /***************************************************************************
|
|---|
| 4 | * _ _ ____ _
|
|---|
| 5 | * Project ___| | | | _ \| |
|
|---|
| 6 | * / __| | | | |_) | |
|
|---|
| 7 | * | (__| |_| | _ <| |___
|
|---|
| 8 | * \___|\___/|_| \_\_____|
|
|---|
| 9 | *
|
|---|
| 10 | * Copyright (C) Daniel Stenberg, <[email protected]>, 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 https://curl.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 | * SPDX-License-Identifier: curl
|
|---|
| 24 | *
|
|---|
| 25 | ***************************************************************************/
|
|---|
| 26 | #include "curl_setup.h"
|
|---|
| 27 |
|
|---|
| 28 | #if defined(USE_MSH3) && !defined(_WIN32)
|
|---|
| 29 | #include <pthread.h>
|
|---|
| 30 | #endif
|
|---|
| 31 |
|
|---|
| 32 | #include "bufq.h"
|
|---|
| 33 | #include "dynhds.h"
|
|---|
| 34 | #include "ws.h"
|
|---|
| 35 |
|
|---|
| 36 | typedef enum {
|
|---|
| 37 | HTTPREQ_GET,
|
|---|
| 38 | HTTPREQ_POST,
|
|---|
| 39 | HTTPREQ_POST_FORM, /* we make a difference internally */
|
|---|
| 40 | HTTPREQ_POST_MIME, /* we make a difference internally */
|
|---|
| 41 | HTTPREQ_PUT,
|
|---|
| 42 | HTTPREQ_HEAD
|
|---|
| 43 | } Curl_HttpReq;
|
|---|
| 44 |
|
|---|
| 45 | #ifndef CURL_DISABLE_HTTP
|
|---|
| 46 |
|
|---|
| 47 | #if defined(USE_HTTP3)
|
|---|
| 48 | #include <stdint.h>
|
|---|
| 49 | #endif
|
|---|
| 50 |
|
|---|
| 51 | extern const struct Curl_handler Curl_handler_http;
|
|---|
| 52 |
|
|---|
| 53 | #ifdef USE_SSL
|
|---|
| 54 | extern const struct Curl_handler Curl_handler_https;
|
|---|
| 55 | #endif
|
|---|
| 56 |
|
|---|
| 57 | struct dynhds;
|
|---|
| 58 |
|
|---|
| 59 | CURLcode Curl_bump_headersize(struct Curl_easy *data,
|
|---|
| 60 | size_t delta,
|
|---|
| 61 | bool connect_only);
|
|---|
| 62 |
|
|---|
| 63 | /* Header specific functions */
|
|---|
| 64 | bool Curl_compareheader(const char *headerline, /* line to check */
|
|---|
| 65 | const char *header, /* header keyword _with_ colon */
|
|---|
| 66 | const size_t hlen, /* len of the keyword in bytes */
|
|---|
| 67 | const char *content, /* content string to find */
|
|---|
| 68 | const size_t clen); /* len of the content in bytes */
|
|---|
| 69 |
|
|---|
| 70 | char *Curl_copy_header_value(const char *header);
|
|---|
| 71 |
|
|---|
| 72 | char *Curl_checkProxyheaders(struct Curl_easy *data,
|
|---|
| 73 | const struct connectdata *conn,
|
|---|
| 74 | const char *thisheader,
|
|---|
| 75 | const size_t thislen);
|
|---|
| 76 |
|
|---|
| 77 | CURLcode Curl_add_timecondition(struct Curl_easy *data,
|
|---|
| 78 | #ifndef USE_HYPER
|
|---|
| 79 | struct dynbuf *req
|
|---|
| 80 | #else
|
|---|
| 81 | void *headers
|
|---|
| 82 | #endif
|
|---|
| 83 | );
|
|---|
| 84 | CURLcode Curl_add_custom_headers(struct Curl_easy *data,
|
|---|
| 85 | bool is_connect,
|
|---|
| 86 | #ifndef USE_HYPER
|
|---|
| 87 | struct dynbuf *req
|
|---|
| 88 | #else
|
|---|
| 89 | void *headers
|
|---|
| 90 | #endif
|
|---|
| 91 | );
|
|---|
| 92 |
|
|---|
| 93 | void Curl_http_method(struct Curl_easy *data, struct connectdata *conn,
|
|---|
| 94 | const char **method, Curl_HttpReq *);
|
|---|
| 95 | CURLcode Curl_http_useragent(struct Curl_easy *data);
|
|---|
| 96 | CURLcode Curl_http_host(struct Curl_easy *data, struct connectdata *conn);
|
|---|
| 97 | CURLcode Curl_http_target(struct Curl_easy *data, struct connectdata *conn,
|
|---|
| 98 | struct dynbuf *req);
|
|---|
| 99 | CURLcode Curl_http_statusline(struct Curl_easy *data,
|
|---|
| 100 | struct connectdata *conn);
|
|---|
| 101 | CURLcode Curl_http_header(struct Curl_easy *data,
|
|---|
| 102 | const char *hd, size_t hdlen);
|
|---|
| 103 | CURLcode Curl_transferencode(struct Curl_easy *data);
|
|---|
| 104 | CURLcode Curl_http_req_set_reader(struct Curl_easy *data,
|
|---|
| 105 | Curl_HttpReq httpreq,
|
|---|
| 106 | const char **tep);
|
|---|
| 107 | CURLcode Curl_http_req_complete(struct Curl_easy *data,
|
|---|
| 108 | struct dynbuf *r, Curl_HttpReq httpreq);
|
|---|
| 109 | bool Curl_use_http_1_1plus(const struct Curl_easy *data,
|
|---|
| 110 | const struct connectdata *conn);
|
|---|
| 111 | #ifndef CURL_DISABLE_COOKIES
|
|---|
| 112 | CURLcode Curl_http_cookies(struct Curl_easy *data,
|
|---|
| 113 | struct connectdata *conn,
|
|---|
| 114 | struct dynbuf *r);
|
|---|
| 115 | #else
|
|---|
| 116 | #define Curl_http_cookies(a,b,c) CURLE_OK
|
|---|
| 117 | #endif
|
|---|
| 118 | CURLcode Curl_http_range(struct Curl_easy *data,
|
|---|
| 119 | Curl_HttpReq httpreq);
|
|---|
| 120 | CURLcode Curl_http_firstwrite(struct Curl_easy *data);
|
|---|
| 121 |
|
|---|
| 122 | /* protocol-specific functions set up to be called by the main engine */
|
|---|
| 123 | CURLcode Curl_http_setup_conn(struct Curl_easy *data,
|
|---|
| 124 | struct connectdata *conn);
|
|---|
| 125 | CURLcode Curl_http(struct Curl_easy *data, bool *done);
|
|---|
| 126 | CURLcode Curl_http_done(struct Curl_easy *data, CURLcode, bool premature);
|
|---|
| 127 | CURLcode Curl_http_connect(struct Curl_easy *data, bool *done);
|
|---|
| 128 | int Curl_http_getsock_do(struct Curl_easy *data, struct connectdata *conn,
|
|---|
| 129 | curl_socket_t *socks);
|
|---|
| 130 | CURLcode Curl_http_write_resp(struct Curl_easy *data,
|
|---|
| 131 | const char *buf, size_t blen,
|
|---|
| 132 | bool is_eos);
|
|---|
| 133 | CURLcode Curl_http_write_resp_hd(struct Curl_easy *data,
|
|---|
| 134 | const char *hd, size_t hdlen,
|
|---|
| 135 | bool is_eos);
|
|---|
| 136 |
|
|---|
| 137 | /* These functions are in http.c */
|
|---|
| 138 | CURLcode Curl_http_input_auth(struct Curl_easy *data, bool proxy,
|
|---|
| 139 | const char *auth);
|
|---|
| 140 | CURLcode Curl_http_auth_act(struct Curl_easy *data);
|
|---|
| 141 |
|
|---|
| 142 | /* If only the PICKNONE bit is set, there has been a round-trip and we
|
|---|
| 143 | selected to use no auth at all. Ie, we actively select no auth, as opposed
|
|---|
| 144 | to not having one selected. The other CURLAUTH_* defines are present in the
|
|---|
| 145 | public curl/curl.h header. */
|
|---|
| 146 | #define CURLAUTH_PICKNONE (1<<30) /* do not use auth */
|
|---|
| 147 |
|
|---|
| 148 | /* MAX_INITIAL_POST_SIZE indicates the number of bytes that will make the POST
|
|---|
| 149 | data get included in the initial data chunk sent to the server. If the
|
|---|
| 150 | data is larger than this, it will automatically get split up in multiple
|
|---|
| 151 | system calls.
|
|---|
| 152 |
|
|---|
| 153 | This value used to be fairly big (100K), but we must take into account that
|
|---|
| 154 | if the server rejects the POST due for authentication reasons, this data
|
|---|
| 155 | will always be unconditionally sent and thus it may not be larger than can
|
|---|
| 156 | always be afforded to send twice.
|
|---|
| 157 |
|
|---|
| 158 | It must not be greater than 64K to work on VMS.
|
|---|
| 159 | */
|
|---|
| 160 | #ifndef MAX_INITIAL_POST_SIZE
|
|---|
| 161 | #define MAX_INITIAL_POST_SIZE (64*1024)
|
|---|
| 162 | #endif
|
|---|
| 163 |
|
|---|
| 164 | /* EXPECT_100_THRESHOLD is the request body size limit for when libcurl will
|
|---|
| 165 | * automatically add an "Expect: 100-continue" header in HTTP requests. When
|
|---|
| 166 | * the size is unknown, it will always add it.
|
|---|
| 167 | *
|
|---|
| 168 | */
|
|---|
| 169 | #ifndef EXPECT_100_THRESHOLD
|
|---|
| 170 | #define EXPECT_100_THRESHOLD (1024*1024)
|
|---|
| 171 | #endif
|
|---|
| 172 |
|
|---|
| 173 | /* MAX_HTTP_RESP_HEADER_SIZE is the maximum size of all response headers
|
|---|
| 174 | combined that libcurl allows for a single HTTP response, any HTTP
|
|---|
| 175 | version. This count includes CONNECT response headers. */
|
|---|
| 176 | #define MAX_HTTP_RESP_HEADER_SIZE (300*1024)
|
|---|
| 177 |
|
|---|
| 178 | bool Curl_http_exp100_is_selected(struct Curl_easy *data);
|
|---|
| 179 | void Curl_http_exp100_got100(struct Curl_easy *data);
|
|---|
| 180 |
|
|---|
| 181 | #endif /* CURL_DISABLE_HTTP */
|
|---|
| 182 |
|
|---|
| 183 | /****************************************************************************
|
|---|
| 184 | * HTTP unique setup
|
|---|
| 185 | ***************************************************************************/
|
|---|
| 186 |
|
|---|
| 187 | CURLcode Curl_http_size(struct Curl_easy *data);
|
|---|
| 188 |
|
|---|
| 189 | CURLcode Curl_http_write_resp_hds(struct Curl_easy *data,
|
|---|
| 190 | const char *buf, size_t blen,
|
|---|
| 191 | size_t *pconsumed);
|
|---|
| 192 |
|
|---|
| 193 | /**
|
|---|
| 194 | * Curl_http_output_auth() setups the authentication headers for the
|
|---|
| 195 | * host/proxy and the correct authentication
|
|---|
| 196 | * method. data->state.authdone is set to TRUE when authentication is
|
|---|
| 197 | * done.
|
|---|
| 198 | *
|
|---|
| 199 | * @param data all information about the current transfer
|
|---|
| 200 | * @param conn all information about the current connection
|
|---|
| 201 | * @param request pointer to the request keyword
|
|---|
| 202 | * @param httpreq is the request type
|
|---|
| 203 | * @param path pointer to the requested path
|
|---|
| 204 | * @param proxytunnel boolean if this is the request setting up a "proxy
|
|---|
| 205 | * tunnel"
|
|---|
| 206 | *
|
|---|
| 207 | * @returns CURLcode
|
|---|
| 208 | */
|
|---|
| 209 | CURLcode
|
|---|
| 210 | Curl_http_output_auth(struct Curl_easy *data,
|
|---|
| 211 | struct connectdata *conn,
|
|---|
| 212 | const char *request,
|
|---|
| 213 | Curl_HttpReq httpreq,
|
|---|
| 214 | const char *path,
|
|---|
| 215 | bool proxytunnel); /* TRUE if this is the request setting
|
|---|
| 216 | up the proxy tunnel */
|
|---|
| 217 |
|
|---|
| 218 | /* Decode HTTP status code string. */
|
|---|
| 219 | CURLcode Curl_http_decode_status(int *pstatus, const char *s, size_t len);
|
|---|
| 220 |
|
|---|
| 221 |
|
|---|
| 222 | /**
|
|---|
| 223 | * All about a core HTTP request, excluding body and trailers
|
|---|
| 224 | */
|
|---|
| 225 | struct httpreq {
|
|---|
| 226 | char method[24];
|
|---|
| 227 | char *scheme;
|
|---|
| 228 | char *authority;
|
|---|
| 229 | char *path;
|
|---|
| 230 | struct dynhds headers;
|
|---|
| 231 | struct dynhds trailers;
|
|---|
| 232 | };
|
|---|
| 233 |
|
|---|
| 234 | /**
|
|---|
| 235 | * Create an HTTP request struct.
|
|---|
| 236 | */
|
|---|
| 237 | CURLcode Curl_http_req_make(struct httpreq **preq,
|
|---|
| 238 | const char *method, size_t m_len,
|
|---|
| 239 | const char *scheme, size_t s_len,
|
|---|
| 240 | const char *authority, size_t a_len,
|
|---|
| 241 | const char *path, size_t p_len);
|
|---|
| 242 |
|
|---|
| 243 | CURLcode Curl_http_req_make2(struct httpreq **preq,
|
|---|
| 244 | const char *method, size_t m_len,
|
|---|
| 245 | CURLU *url, const char *scheme_default);
|
|---|
| 246 |
|
|---|
| 247 | void Curl_http_req_free(struct httpreq *req);
|
|---|
| 248 |
|
|---|
| 249 | #define HTTP_PSEUDO_METHOD ":method"
|
|---|
| 250 | #define HTTP_PSEUDO_SCHEME ":scheme"
|
|---|
| 251 | #define HTTP_PSEUDO_AUTHORITY ":authority"
|
|---|
| 252 | #define HTTP_PSEUDO_PATH ":path"
|
|---|
| 253 | #define HTTP_PSEUDO_STATUS ":status"
|
|---|
| 254 |
|
|---|
| 255 | /**
|
|---|
| 256 | * Create the list of HTTP/2 headers which represent the request,
|
|---|
| 257 | * using HTTP/2 pseudo headers preceding the `req->headers`.
|
|---|
| 258 | *
|
|---|
| 259 | * Applies the following transformations:
|
|---|
| 260 | * - if `authority` is set, any "Host" header is removed.
|
|---|
| 261 | * - if `authority` is unset and a "Host" header is present, use
|
|---|
| 262 | * that as `authority` and remove "Host"
|
|---|
| 263 | * - removes and Connection header fields as defined in rfc9113 ch. 8.2.2
|
|---|
| 264 | * - lower-cases the header field names
|
|---|
| 265 | *
|
|---|
| 266 | * @param h2_headers will contain the HTTP/2 headers on success
|
|---|
| 267 | * @param req the request to transform
|
|---|
| 268 | * @param data the handle to lookup defaults like ' :scheme' from
|
|---|
| 269 | */
|
|---|
| 270 | CURLcode Curl_http_req_to_h2(struct dynhds *h2_headers,
|
|---|
| 271 | struct httpreq *req, struct Curl_easy *data);
|
|---|
| 272 |
|
|---|
| 273 | /**
|
|---|
| 274 | * All about a core HTTP response, excluding body and trailers
|
|---|
| 275 | */
|
|---|
| 276 | struct http_resp {
|
|---|
| 277 | int status;
|
|---|
| 278 | char *description;
|
|---|
| 279 | struct dynhds headers;
|
|---|
| 280 | struct dynhds trailers;
|
|---|
| 281 | struct http_resp *prev;
|
|---|
| 282 | };
|
|---|
| 283 |
|
|---|
| 284 | /**
|
|---|
| 285 | * Create an HTTP response struct.
|
|---|
| 286 | */
|
|---|
| 287 | CURLcode Curl_http_resp_make(struct http_resp **presp,
|
|---|
| 288 | int status,
|
|---|
| 289 | const char *description);
|
|---|
| 290 |
|
|---|
| 291 | void Curl_http_resp_free(struct http_resp *resp);
|
|---|
| 292 |
|
|---|
| 293 | #endif /* HEADER_CURL_HTTP_H */
|
|---|
