2012-12-28 19:03:09 +08:00
|
|
|
#ifndef HEADER_CURL_HTTP_H
|
|
|
|
#define HEADER_CURL_HTTP_H
|
2002-09-03 19:52:59 +08:00
|
|
|
/***************************************************************************
|
2004-06-15 16:45:22 +08:00
|
|
|
* _ _ ____ _
|
|
|
|
* Project ___| | | | _ \| |
|
|
|
|
* / __| | | | |_) | |
|
|
|
|
* | (__| |_| | _ <| |___
|
1999-12-29 22:20:26 +08:00
|
|
|
* \___|\___/|_| \_\_____|
|
|
|
|
*
|
2021-01-01 07:48:40 +08:00
|
|
|
* Copyright (C) 1998 - 2021, Daniel Stenberg, <daniel@haxx.se>, et al.
|
1999-12-29 22:20:26 +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-06-15 16:45:22 +08:00
|
|
|
*
|
2001-01-03 17:29:33 +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.
|
1999-12-29 22:20:26 +08:00
|
|
|
*
|
2001-01-03 17:29:33 +08:00
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
* KIND, either express or implied.
|
1999-12-29 22:20:26 +08:00
|
|
|
*
|
2002-09-03 19:52:59 +08:00
|
|
|
***************************************************************************/
|
2013-09-07 19:01:43 +08:00
|
|
|
#include "curl_setup.h"
|
|
|
|
|
2020-12-18 20:18:14 +08:00
|
|
|
typedef enum {
|
|
|
|
HTTPREQ_GET,
|
|
|
|
HTTPREQ_POST,
|
|
|
|
HTTPREQ_POST_FORM, /* we make a difference internally */
|
|
|
|
HTTPREQ_POST_MIME, /* we make a difference internally */
|
|
|
|
HTTPREQ_PUT,
|
2021-01-08 23:17:12 +08:00
|
|
|
HTTPREQ_HEAD
|
2020-12-18 20:18:14 +08:00
|
|
|
} Curl_HttpReq;
|
|
|
|
|
2002-06-11 19:13:01 +08:00
|
|
|
#ifndef CURL_DISABLE_HTTP
|
2007-10-12 21:36:37 +08:00
|
|
|
|
2013-09-07 19:01:43 +08:00
|
|
|
#ifdef USE_NGHTTP2
|
|
|
|
#include <nghttp2/nghttp2.h>
|
|
|
|
#endif
|
|
|
|
|
2007-10-12 21:36:37 +08:00
|
|
|
extern const struct Curl_handler Curl_handler_http;
|
|
|
|
|
|
|
|
#ifdef USE_SSL
|
|
|
|
extern const struct Curl_handler Curl_handler_https;
|
|
|
|
#endif
|
|
|
|
|
2013-11-03 18:17:26 +08:00
|
|
|
/* Header specific functions */
|
2007-08-26 13:53:26 +08:00
|
|
|
bool Curl_compareheader(const char *headerline, /* line to check */
|
2002-11-28 23:48:23 +08:00
|
|
|
const char *header, /* header keyword _with_ colon */
|
|
|
|
const char *content); /* content string to find */
|
2014-01-31 15:10:07 +08:00
|
|
|
|
2013-11-03 18:17:26 +08:00
|
|
|
char *Curl_copy_header_value(const char *header);
|
2010-01-21 21:58:30 +08:00
|
|
|
|
2021-01-09 00:58:15 +08:00
|
|
|
char *Curl_checkProxyheaders(struct Curl_easy *data,
|
|
|
|
const struct connectdata *conn,
|
2014-01-31 15:10:07 +08:00
|
|
|
const char *thisheader);
|
2020-12-14 21:10:33 +08:00
|
|
|
#ifndef USE_HYPER
|
2020-05-02 23:04:08 +08:00
|
|
|
CURLcode Curl_buffer_send(struct dynbuf *in,
|
2021-01-09 00:58:15 +08:00
|
|
|
struct Curl_easy *data,
|
2020-05-02 23:04:08 +08:00
|
|
|
curl_off_t *bytes_written,
|
2021-03-26 17:06:51 +08:00
|
|
|
curl_off_t included_body_bytes,
|
2020-05-02 23:04:08 +08:00
|
|
|
int socketindex);
|
2020-12-14 21:10:33 +08:00
|
|
|
#else
|
|
|
|
#define Curl_buffer_send(a,b,c,d,e) CURLE_OK
|
|
|
|
#endif
|
2010-01-21 21:58:30 +08:00
|
|
|
|
2021-01-09 00:58:15 +08:00
|
|
|
CURLcode Curl_add_timecondition(struct Curl_easy *data,
|
2021-01-01 07:48:40 +08:00
|
|
|
#ifndef USE_HYPER
|
2021-01-09 00:58:15 +08:00
|
|
|
struct dynbuf *req
|
2021-01-01 07:48:40 +08:00
|
|
|
#else
|
2021-01-09 00:58:15 +08:00
|
|
|
void *headers
|
2021-01-01 07:48:40 +08:00
|
|
|
#endif
|
|
|
|
);
|
2021-01-09 00:58:15 +08:00
|
|
|
CURLcode Curl_add_custom_headers(struct Curl_easy *data,
|
2014-01-31 15:10:07 +08:00
|
|
|
bool is_connect,
|
2020-12-14 21:10:33 +08:00
|
|
|
#ifndef USE_HYPER
|
|
|
|
struct dynbuf *req
|
|
|
|
#else
|
|
|
|
void *headers
|
|
|
|
#endif
|
|
|
|
);
|
2018-12-06 17:18:03 +08:00
|
|
|
CURLcode Curl_http_compile_trailers(struct curl_slist *trailers,
|
2020-05-02 23:04:08 +08:00
|
|
|
struct dynbuf *buf,
|
2018-12-06 17:18:03 +08:00
|
|
|
struct Curl_easy *handle);
|
2010-01-21 21:58:30 +08:00
|
|
|
|
2020-12-14 21:10:33 +08:00
|
|
|
void Curl_http_method(struct Curl_easy *data, struct connectdata *conn,
|
|
|
|
const char **method, Curl_HttpReq *);
|
2021-01-09 00:58:15 +08:00
|
|
|
CURLcode Curl_http_useragent(struct Curl_easy *data);
|
2020-12-14 21:10:33 +08:00
|
|
|
CURLcode Curl_http_host(struct Curl_easy *data, struct connectdata *conn);
|
|
|
|
CURLcode Curl_http_target(struct Curl_easy *data, struct connectdata *conn,
|
|
|
|
struct dynbuf *req);
|
|
|
|
CURLcode Curl_http_statusline(struct Curl_easy *data,
|
|
|
|
struct connectdata *conn);
|
|
|
|
CURLcode Curl_http_header(struct Curl_easy *data, struct connectdata *conn,
|
|
|
|
char *headp);
|
2021-07-05 21:52:39 +08:00
|
|
|
CURLcode Curl_transferencode(struct Curl_easy *data);
|
2020-12-14 21:10:33 +08:00
|
|
|
CURLcode Curl_http_body(struct Curl_easy *data, struct connectdata *conn,
|
|
|
|
Curl_HttpReq httpreq,
|
|
|
|
const char **teep);
|
|
|
|
CURLcode Curl_http_bodysend(struct Curl_easy *data, struct connectdata *conn,
|
|
|
|
struct dynbuf *r, Curl_HttpReq httpreq);
|
|
|
|
#ifndef CURL_DISABLE_COOKIES
|
|
|
|
CURLcode Curl_http_cookies(struct Curl_easy *data,
|
|
|
|
struct connectdata *conn,
|
|
|
|
struct dynbuf *r);
|
|
|
|
#else
|
|
|
|
#define Curl_http_cookies(a,b,c) CURLE_OK
|
|
|
|
#endif
|
|
|
|
CURLcode Curl_http_resume(struct Curl_easy *data,
|
|
|
|
struct connectdata *conn,
|
|
|
|
Curl_HttpReq httpreq);
|
|
|
|
CURLcode Curl_http_range(struct Curl_easy *data,
|
|
|
|
Curl_HttpReq httpreq);
|
|
|
|
CURLcode Curl_http_firstwrite(struct Curl_easy *data,
|
|
|
|
struct connectdata *conn,
|
|
|
|
bool *done);
|
|
|
|
|
2000-09-14 22:05:01 +08:00
|
|
|
/* protocol-specific functions set up to be called by the main engine */
|
2021-01-09 00:58:15 +08:00
|
|
|
CURLcode Curl_http(struct Curl_easy *data, bool *done);
|
|
|
|
CURLcode Curl_http_done(struct Curl_easy *data, CURLcode, bool premature);
|
|
|
|
CURLcode Curl_http_connect(struct Curl_easy *data, bool *done);
|
1999-12-29 22:20:26 +08:00
|
|
|
|
2013-01-04 09:50:28 +08:00
|
|
|
/* These functions are in http.c */
|
2021-01-09 00:58:15 +08:00
|
|
|
CURLcode Curl_http_input_auth(struct Curl_easy *data, bool proxy,
|
2013-11-03 18:17:26 +08:00
|
|
|
const char *auth);
|
2021-01-09 00:58:15 +08:00
|
|
|
CURLcode Curl_http_auth_act(struct Curl_easy *data);
|
2004-03-30 14:40:01 +08:00
|
|
|
|
2004-06-15 16:45:22 +08:00
|
|
|
/* If only the PICKNONE bit is set, there has been a round-trip and we
|
|
|
|
selected to use no auth at all. Ie, we actively select no auth, as opposed
|
|
|
|
to not having one selected. The other CURLAUTH_* defines are present in the
|
|
|
|
public curl/curl.h header. */
|
|
|
|
#define CURLAUTH_PICKNONE (1<<30) /* don't use auth */
|
|
|
|
|
2004-11-25 00:11:35 +08:00
|
|
|
/* MAX_INITIAL_POST_SIZE indicates the number of bytes that will make the POST
|
|
|
|
data get included in the initial data chunk sent to the server. If the
|
|
|
|
data is larger than this, it will automatically get split up in multiple
|
|
|
|
system calls.
|
|
|
|
|
|
|
|
This value used to be fairly big (100K), but we must take into account that
|
|
|
|
if the server rejects the POST due for authentication reasons, this data
|
2018-03-16 10:51:03 +08:00
|
|
|
will always be unconditionally sent and thus it may not be larger than can
|
2004-11-25 00:11:35 +08:00
|
|
|
always be afforded to send twice.
|
|
|
|
|
|
|
|
It must not be greater than 64K to work on VMS.
|
|
|
|
*/
|
2004-11-05 22:43:35 +08:00
|
|
|
#ifndef MAX_INITIAL_POST_SIZE
|
2006-08-19 06:54:57 +08:00
|
|
|
#define MAX_INITIAL_POST_SIZE (64*1024)
|
|
|
|
#endif
|
|
|
|
|
2017-07-06 17:20:57 +08:00
|
|
|
/* EXPECT_100_THRESHOLD is the request body size limit for when libcurl will
|
|
|
|
* automatically add an "Expect: 100-continue" header in HTTP requests. When
|
|
|
|
* the size is unknown, it will always add it.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#ifndef EXPECT_100_THRESHOLD
|
2020-01-14 22:34:56 +08:00
|
|
|
#define EXPECT_100_THRESHOLD (1024*1024)
|
2004-11-05 22:43:35 +08:00
|
|
|
#endif
|
|
|
|
|
2009-12-13 06:17:51 +08:00
|
|
|
#endif /* CURL_DISABLE_HTTP */
|
|
|
|
|
2019-08-22 20:08:18 +08:00
|
|
|
#ifdef USE_NGHTTP3
|
|
|
|
struct h3out; /* see ngtcp2 */
|
|
|
|
#endif
|
|
|
|
|
2009-12-13 06:17:51 +08:00
|
|
|
/****************************************************************************
|
|
|
|
* HTTP unique setup
|
|
|
|
***************************************************************************/
|
|
|
|
struct HTTP {
|
2017-09-05 17:45:21 +08:00
|
|
|
curl_mimepart *sendit;
|
2009-12-13 06:17:51 +08:00
|
|
|
curl_off_t postsize; /* off_t to handle large file sizes */
|
|
|
|
const char *postdata;
|
|
|
|
|
|
|
|
const char *p_pragma; /* Pragma: string */
|
|
|
|
|
|
|
|
/* For FORM posting */
|
2017-09-05 17:45:21 +08:00
|
|
|
curl_mimepart form;
|
2009-12-13 06:17:51 +08:00
|
|
|
|
|
|
|
struct back {
|
|
|
|
curl_read_callback fread_func; /* backup storage for fread pointer */
|
|
|
|
void *fread_in; /* backup storage for fread_in pointer */
|
|
|
|
const char *postdata;
|
|
|
|
curl_off_t postsize;
|
|
|
|
} backup;
|
|
|
|
|
|
|
|
enum {
|
|
|
|
HTTPSEND_NADA, /* init */
|
|
|
|
HTTPSEND_REQUEST, /* sending a request */
|
2021-05-06 19:04:03 +08:00
|
|
|
HTTPSEND_BODY /* sending body */
|
2009-12-13 06:17:51 +08:00
|
|
|
} sending;
|
|
|
|
|
2018-09-14 17:48:53 +08:00
|
|
|
#ifndef CURL_DISABLE_HTTP
|
2020-05-02 23:04:08 +08:00
|
|
|
struct dynbuf send_buffer; /* used if the request couldn't be sent in one
|
|
|
|
chunk, points to an allocated send_buffer
|
|
|
|
struct */
|
2018-09-14 17:48:53 +08:00
|
|
|
#endif
|
2015-05-19 08:53:58 +08:00
|
|
|
#ifdef USE_NGHTTP2
|
2015-04-29 20:19:39 +08:00
|
|
|
/*********** for HTTP/2 we store stream-local data here *************/
|
2015-04-27 19:54:47 +08:00
|
|
|
int32_t stream_id; /* stream we are interested in */
|
2015-04-29 02:39:47 +08:00
|
|
|
|
2015-04-29 20:19:39 +08:00
|
|
|
bool bodystarted;
|
2015-04-29 02:39:47 +08:00
|
|
|
/* We store non-final and final response headers here, per-stream */
|
2020-05-02 23:04:08 +08:00
|
|
|
struct dynbuf header_recvbuf;
|
2015-04-29 02:39:47 +08:00
|
|
|
size_t nread_header_recvbuf; /* number of bytes in header_recvbuf fed into
|
|
|
|
upper layer */
|
2020-08-03 18:19:09 +08:00
|
|
|
struct dynbuf trailer_recvbuf;
|
2015-04-29 20:19:39 +08:00
|
|
|
int status_code; /* HTTP status code */
|
2015-05-11 21:10:21 +08:00
|
|
|
const uint8_t *pausedata; /* pointer to data received in on_data_chunk */
|
|
|
|
size_t pauselen; /* the number of bytes left in data */
|
2016-08-28 22:44:03 +08:00
|
|
|
bool close_handled; /* TRUE if stream closure is handled by libcurl */
|
2015-05-18 20:01:38 +08:00
|
|
|
|
2015-06-01 21:52:46 +08:00
|
|
|
char **push_headers; /* allocated array */
|
|
|
|
size_t push_headers_used; /* number of entries filled in */
|
|
|
|
size_t push_headers_alloc; /* number of entries allocated */
|
2021-04-19 19:15:05 +08:00
|
|
|
uint32_t error; /* HTTP/2 stream error code */
|
2015-05-19 08:53:58 +08:00
|
|
|
#endif
|
2019-08-12 17:10:56 +08:00
|
|
|
#if defined(USE_NGHTTP2) || defined(USE_NGHTTP3)
|
2019-08-24 16:45:18 +08:00
|
|
|
bool closed; /* TRUE on HTTP2 stream close */
|
2019-08-12 17:10:56 +08:00
|
|
|
char *mem; /* points to a buffer in memory to store received data */
|
|
|
|
size_t len; /* size of the buffer 'mem' points to */
|
|
|
|
size_t memlen; /* size of data copied to mem */
|
|
|
|
#endif
|
2019-08-05 21:17:31 +08:00
|
|
|
#if defined(USE_NGHTTP2) || defined(ENABLE_QUIC)
|
|
|
|
/* fields used by both HTTP/2 and HTTP/3 */
|
|
|
|
const uint8_t *upload_mem; /* points to a buffer to read from */
|
|
|
|
size_t upload_len; /* size of the buffer 'upload_mem' points to */
|
|
|
|
curl_off_t upload_left; /* number of bytes left to upload */
|
|
|
|
#endif
|
2019-08-05 16:19:48 +08:00
|
|
|
|
|
|
|
#ifdef ENABLE_QUIC
|
|
|
|
/*********** for HTTP/3 we store stream-local data here *************/
|
|
|
|
int64_t stream3_id; /* stream we are interested in */
|
2019-11-16 15:57:45 +08:00
|
|
|
bool firstheader; /* FALSE until headers arrive */
|
2019-08-05 21:17:31 +08:00
|
|
|
bool firstbody; /* FALSE until body arrives */
|
2019-08-09 05:13:57 +08:00
|
|
|
bool h3req; /* FALSE until request is issued */
|
2019-08-22 20:08:18 +08:00
|
|
|
bool upload_done;
|
|
|
|
#endif
|
|
|
|
#ifdef USE_NGHTTP3
|
2019-11-12 18:39:41 +08:00
|
|
|
size_t unacked_window;
|
2019-08-22 20:08:18 +08:00
|
|
|
struct h3out *h3out; /* per-stream buffers for upload */
|
2020-05-04 17:37:12 +08:00
|
|
|
struct dynbuf overflow; /* excess data received during a single Curl_read */
|
2019-08-05 16:19:48 +08:00
|
|
|
#endif
|
2009-12-13 06:17:51 +08:00
|
|
|
};
|
|
|
|
|
2015-05-19 08:53:58 +08:00
|
|
|
#ifdef USE_NGHTTP2
|
2015-05-07 22:44:00 +08:00
|
|
|
/* h2 settings for this connection */
|
|
|
|
struct h2settings {
|
|
|
|
uint32_t max_concurrent_streams;
|
|
|
|
bool enable_push;
|
|
|
|
};
|
2015-05-19 08:53:58 +08:00
|
|
|
#endif
|
2015-05-07 22:44:00 +08:00
|
|
|
|
2013-09-07 19:01:43 +08:00
|
|
|
struct http_conn {
|
|
|
|
#ifdef USE_NGHTTP2
|
2014-01-30 21:26:00 +08:00
|
|
|
#define H2_BINSETTINGS_LEN 80
|
|
|
|
uint8_t binsettings[H2_BINSETTINGS_LEN];
|
|
|
|
size_t binlen; /* length of the binsettings data */
|
2021-02-15 15:35:32 +08:00
|
|
|
|
|
|
|
/* We associate the connnectdata struct with the connection, but we need to
|
|
|
|
make sure we can identify the current "driving" transfer. This is a
|
|
|
|
work-around for the lack of nghttp2_session_set_user_data() in older
|
|
|
|
nghttp2 versions that we want to support. (Added in 1.31.0) */
|
|
|
|
struct Curl_easy *trnsfr;
|
|
|
|
|
|
|
|
nghttp2_session *h2;
|
2018-05-14 15:38:56 +08:00
|
|
|
Curl_send *send_underlying; /* underlying send Curl_send callback */
|
|
|
|
Curl_recv *recv_underlying; /* underlying recv Curl_recv callback */
|
2014-02-04 21:57:29 +08:00
|
|
|
char *inbuf; /* buffer to receive data from underlying socket */
|
2015-05-07 16:22:57 +08:00
|
|
|
size_t inbuflen; /* number of bytes filled in inbuf */
|
|
|
|
size_t nread_inbuf; /* number of bytes read from in inbuf */
|
2014-02-14 21:02:44 +08:00
|
|
|
/* We need separate buffer for transmission and reception because we
|
|
|
|
may call nghttp2_session_send() after the
|
|
|
|
nghttp2_session_mem_recv() but mem buffer is still not full. In
|
|
|
|
this case, we wrongly sends the content of mem buffer if we share
|
|
|
|
them for both cases. */
|
2015-05-07 23:52:48 +08:00
|
|
|
int32_t pause_stream_id; /* stream ID which paused
|
|
|
|
nghttp2_session_mem_recv */
|
2016-04-12 12:37:44 +08:00
|
|
|
size_t drain_total; /* sum of all stream's UrlState.drain */
|
2015-04-28 19:10:04 +08:00
|
|
|
|
2016-06-21 21:47:12 +08:00
|
|
|
/* this is a hash of all individual streams (Curl_easy structs) */
|
2015-05-07 22:44:00 +08:00
|
|
|
struct h2settings settings;
|
2016-12-10 21:54:59 +08:00
|
|
|
|
|
|
|
/* list of settings that will be sent */
|
|
|
|
nghttp2_settings_entry local_settings[3];
|
|
|
|
size_t local_settings_num;
|
2013-09-07 23:00:11 +08:00
|
|
|
#else
|
|
|
|
int unused; /* prevent a compiler warning */
|
2013-09-07 19:01:43 +08:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2016-06-21 21:47:12 +08:00
|
|
|
CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
|
2009-12-30 05:45:02 +08:00
|
|
|
struct connectdata *conn,
|
|
|
|
ssize_t *nread,
|
|
|
|
bool *stop_reading);
|
|
|
|
|
2011-04-04 22:24:37 +08:00
|
|
|
/**
|
|
|
|
* Curl_http_output_auth() setups the authentication headers for the
|
|
|
|
* host/proxy and the correct authentication
|
2021-01-25 01:57:02 +08:00
|
|
|
* method. data->state.authdone is set to TRUE when authentication is
|
2011-04-04 22:24:37 +08:00
|
|
|
* done.
|
|
|
|
*
|
2021-01-25 01:57:02 +08:00
|
|
|
* @param data all information about the current transfer
|
2011-04-04 22:24:37 +08:00
|
|
|
* @param conn all information about the current connection
|
|
|
|
* @param request pointer to the request keyword
|
2021-01-08 23:17:12 +08:00
|
|
|
* @param httpreq is the request type
|
2011-04-04 22:24:37 +08:00
|
|
|
* @param path pointer to the requested path
|
|
|
|
* @param proxytunnel boolean if this is the request setting up a "proxy
|
|
|
|
* tunnel"
|
|
|
|
*
|
|
|
|
* @returns CURLcode
|
|
|
|
*/
|
|
|
|
CURLcode
|
2021-01-09 00:58:15 +08:00
|
|
|
Curl_http_output_auth(struct Curl_easy *data,
|
|
|
|
struct connectdata *conn,
|
2011-04-04 22:24:37 +08:00
|
|
|
const char *request,
|
2021-01-08 23:17:12 +08:00
|
|
|
Curl_HttpReq httpreq,
|
2011-04-04 22:24:37 +08:00
|
|
|
const char *path,
|
|
|
|
bool proxytunnel); /* TRUE if this is the request setting
|
|
|
|
up the proxy tunnel */
|
|
|
|
|
2012-12-28 19:03:09 +08:00
|
|
|
#endif /* HEADER_CURL_HTTP_H */
|