1: #ifndef HEADER_CURL_HTTP_H
2: #define HEADER_CURL_HTTP_H
3: /***************************************************************************
4: * _ _ ____ _
5: * Project ___| | | | _ \| |
6: * / __| | | | |_) | |
7: * | (__| |_| | _ <| |___
8: * \___|\___/|_| \_\_____|
9: *
10: * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@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 https://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: #include "curl_setup.h"
25:
26: #ifndef CURL_DISABLE_HTTP
27:
28: #ifdef USE_NGHTTP2
29: #include <nghttp2/nghttp2.h>
30: #endif
31:
32: extern const struct Curl_handler Curl_handler_http;
33:
34: #ifdef USE_SSL
35: extern const struct Curl_handler Curl_handler_https;
36: #endif
37:
38: /* Header specific functions */
39: bool Curl_compareheader(const char *headerline, /* line to check */
40: const char *header, /* header keyword _with_ colon */
41: const char *content); /* content string to find */
42:
43: char *Curl_copy_header_value(const char *header);
44:
45: char *Curl_checkProxyheaders(const struct connectdata *conn,
46: const char *thisheader);
47: /* ------------------------------------------------------------------------- */
48: /*
49: * The add_buffer series of functions are used to build one large memory chunk
50: * from repeated function invokes. Used so that the entire HTTP request can
51: * be sent in one go.
52: */
53: struct Curl_send_buffer {
54: char *buffer;
55: size_t size_max;
56: size_t size_used;
57: };
58: typedef struct Curl_send_buffer Curl_send_buffer;
59:
60: Curl_send_buffer *Curl_add_buffer_init(void);
61: void Curl_add_buffer_free(Curl_send_buffer **inp);
62: CURLcode Curl_add_bufferf(Curl_send_buffer **inp, const char *fmt, ...)
63: WARN_UNUSED_RESULT;
64: CURLcode Curl_add_buffer(Curl_send_buffer **inp, const void *inptr,
65: size_t size) WARN_UNUSED_RESULT;
66: CURLcode Curl_add_buffer_send(Curl_send_buffer **inp,
67: struct connectdata *conn,
68: curl_off_t *bytes_written,
69: size_t included_body_bytes,
70: int socketindex);
71:
72: CURLcode Curl_add_timecondition(const struct connectdata *conn,
73: Curl_send_buffer *buf);
74: CURLcode Curl_add_custom_headers(struct connectdata *conn,
75: bool is_connect,
76: Curl_send_buffer *req_buffer);
77: CURLcode Curl_http_compile_trailers(struct curl_slist *trailers,
78: Curl_send_buffer **buffer,
79: struct Curl_easy *handle);
80:
81: /* protocol-specific functions set up to be called by the main engine */
82: CURLcode Curl_http(struct connectdata *conn, bool *done);
83: CURLcode Curl_http_done(struct connectdata *, CURLcode, bool premature);
84: CURLcode Curl_http_connect(struct connectdata *conn, bool *done);
85:
86: /* These functions are in http.c */
87: CURLcode Curl_http_input_auth(struct connectdata *conn, bool proxy,
88: const char *auth);
89: CURLcode Curl_http_auth_act(struct connectdata *conn);
90:
91: /* If only the PICKNONE bit is set, there has been a round-trip and we
92: selected to use no auth at all. Ie, we actively select no auth, as opposed
93: to not having one selected. The other CURLAUTH_* defines are present in the
94: public curl/curl.h header. */
95: #define CURLAUTH_PICKNONE (1<<30) /* don't use auth */
96:
97: /* MAX_INITIAL_POST_SIZE indicates the number of bytes that will make the POST
98: data get included in the initial data chunk sent to the server. If the
99: data is larger than this, it will automatically get split up in multiple
100: system calls.
101:
102: This value used to be fairly big (100K), but we must take into account that
103: if the server rejects the POST due for authentication reasons, this data
104: will always be unconditionally sent and thus it may not be larger than can
105: always be afforded to send twice.
106:
107: It must not be greater than 64K to work on VMS.
108: */
109: #ifndef MAX_INITIAL_POST_SIZE
110: #define MAX_INITIAL_POST_SIZE (64*1024)
111: #endif
112:
113: /* EXPECT_100_THRESHOLD is the request body size limit for when libcurl will
114: * automatically add an "Expect: 100-continue" header in HTTP requests. When
115: * the size is unknown, it will always add it.
116: *
117: */
118: #ifndef EXPECT_100_THRESHOLD
119: #define EXPECT_100_THRESHOLD (1024*1024)
120: #endif
121:
122: #endif /* CURL_DISABLE_HTTP */
123:
124: #ifdef USE_NGHTTP3
125: struct h3out; /* see ngtcp2 */
126: #endif
127:
128: /****************************************************************************
129: * HTTP unique setup
130: ***************************************************************************/
131: struct HTTP {
132: curl_mimepart *sendit;
133: curl_off_t postsize; /* off_t to handle large file sizes */
134: const char *postdata;
135:
136: const char *p_pragma; /* Pragma: string */
137: const char *p_accept; /* Accept: string */
138:
139: /* For FORM posting */
140: curl_mimepart form;
141:
142: struct back {
143: curl_read_callback fread_func; /* backup storage for fread pointer */
144: void *fread_in; /* backup storage for fread_in pointer */
145: const char *postdata;
146: curl_off_t postsize;
147: } backup;
148:
149: enum {
150: HTTPSEND_NADA, /* init */
151: HTTPSEND_REQUEST, /* sending a request */
152: HTTPSEND_BODY, /* sending body */
153: HTTPSEND_LAST /* never use this */
154: } sending;
155:
156: #ifndef CURL_DISABLE_HTTP
157: Curl_send_buffer *send_buffer; /* used if the request couldn't be sent in
158: one chunk, points to an allocated
159: send_buffer struct */
160: #endif
161: #ifdef USE_NGHTTP2
162: /*********** for HTTP/2 we store stream-local data here *************/
163: int32_t stream_id; /* stream we are interested in */
164:
165: bool bodystarted;
166: /* We store non-final and final response headers here, per-stream */
167: Curl_send_buffer *header_recvbuf;
168: size_t nread_header_recvbuf; /* number of bytes in header_recvbuf fed into
169: upper layer */
170: Curl_send_buffer *trailer_recvbuf;
171: int status_code; /* HTTP status code */
172: const uint8_t *pausedata; /* pointer to data received in on_data_chunk */
173: size_t pauselen; /* the number of bytes left in data */
174: bool close_handled; /* TRUE if stream closure is handled by libcurl */
175:
176: char **push_headers; /* allocated array */
177: size_t push_headers_used; /* number of entries filled in */
178: size_t push_headers_alloc; /* number of entries allocated */
179: #endif
180: #if defined(USE_NGHTTP2) || defined(USE_NGHTTP3)
181: bool closed; /* TRUE on HTTP2 stream close */
182: char *mem; /* points to a buffer in memory to store received data */
183: size_t len; /* size of the buffer 'mem' points to */
184: size_t memlen; /* size of data copied to mem */
185: #endif
186: #if defined(USE_NGHTTP2) || defined(ENABLE_QUIC)
187: /* fields used by both HTTP/2 and HTTP/3 */
188: const uint8_t *upload_mem; /* points to a buffer to read from */
189: size_t upload_len; /* size of the buffer 'upload_mem' points to */
190: curl_off_t upload_left; /* number of bytes left to upload */
191: #endif
192:
193: #ifdef ENABLE_QUIC
194: /*********** for HTTP/3 we store stream-local data here *************/
195: int64_t stream3_id; /* stream we are interested in */
196: bool firstheader; /* FALSE until headers arrive */
197: bool firstbody; /* FALSE until body arrives */
198: bool h3req; /* FALSE until request is issued */
199: bool upload_done;
200: #endif
201: #ifdef USE_NGHTTP3
202: size_t unacked_window;
203: struct h3out *h3out; /* per-stream buffers for upload */
204: char *overflow_buf; /* excess data received during a single Curl_read */
205: size_t overflow_buflen; /* amount of data currently in overflow_buf */
206: size_t overflow_bufsize; /* size of the overflow_buf allocation */
207: #endif
208: };
209:
210: #ifdef USE_NGHTTP2
211: /* h2 settings for this connection */
212: struct h2settings {
213: uint32_t max_concurrent_streams;
214: bool enable_push;
215: };
216: #endif
217:
218: struct http_conn {
219: #ifdef USE_NGHTTP2
220: #define H2_BINSETTINGS_LEN 80
221: nghttp2_session *h2;
222: uint8_t binsettings[H2_BINSETTINGS_LEN];
223: size_t binlen; /* length of the binsettings data */
224: Curl_send *send_underlying; /* underlying send Curl_send callback */
225: Curl_recv *recv_underlying; /* underlying recv Curl_recv callback */
226: char *inbuf; /* buffer to receive data from underlying socket */
227: size_t inbuflen; /* number of bytes filled in inbuf */
228: size_t nread_inbuf; /* number of bytes read from in inbuf */
229: /* We need separate buffer for transmission and reception because we
230: may call nghttp2_session_send() after the
231: nghttp2_session_mem_recv() but mem buffer is still not full. In
232: this case, we wrongly sends the content of mem buffer if we share
233: them for both cases. */
234: int32_t pause_stream_id; /* stream ID which paused
235: nghttp2_session_mem_recv */
236: size_t drain_total; /* sum of all stream's UrlState.drain */
237:
238: /* this is a hash of all individual streams (Curl_easy structs) */
239: struct h2settings settings;
240:
241: /* list of settings that will be sent */
242: nghttp2_settings_entry local_settings[3];
243: size_t local_settings_num;
244: uint32_t error_code; /* HTTP/2 error code */
245: #else
246: int unused; /* prevent a compiler warning */
247: #endif
248: };
249:
250: CURLcode Curl_http_readwrite_headers(struct Curl_easy *data,
251: struct connectdata *conn,
252: ssize_t *nread,
253: bool *stop_reading);
254:
255: /**
256: * Curl_http_output_auth() setups the authentication headers for the
257: * host/proxy and the correct authentication
258: * method. conn->data->state.authdone is set to TRUE when authentication is
259: * done.
260: *
261: * @param conn all information about the current connection
262: * @param request pointer to the request keyword
263: * @param path pointer to the requested path
264: * @param proxytunnel boolean if this is the request setting up a "proxy
265: * tunnel"
266: *
267: * @returns CURLcode
268: */
269: CURLcode
270: Curl_http_output_auth(struct connectdata *conn,
271: const char *request,
272: const char *path,
273: bool proxytunnel); /* TRUE if this is the request setting
274: up the proxy tunnel */
275:
276: #endif /* HEADER_CURL_HTTP_H */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib