Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 1 | /*************************************************************************** |
| 2 | * _ _ ____ _ |
| 3 | * Project ___| | | | _ \| | |
| 4 | * / __| | | | |_) | | |
| 5 | * | (__| |_| | _ <| |___ |
| 6 | * \___|\___/|_| \_\_____| |
| 7 | * |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 8 | * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al. |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 9 | * |
| 10 | * This software is licensed as described in the file COPYING, which |
| 11 | * you should have received as part of this distribution. The terms |
Alex Deymo | d15eaac | 2016-06-28 14:49:26 -0700 | [diff] [blame] | 12 | * are also available at https://curl.haxx.se/docs/copyright.html. |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 13 | * |
| 14 | * You may opt to use, copy, modify, merge, publish, distribute and/or sell |
| 15 | * copies of the Software, and permit persons to whom the Software is |
| 16 | * furnished to do so, under the terms of the COPYING file. |
| 17 | * |
| 18 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
| 19 | * KIND, either express or implied. |
| 20 | * |
| 21 | * 'pingpong' is for generic back-and-forth support functions used by FTP, |
| 22 | * IMAP, POP3, SMTP and whatever more that likes them. |
| 23 | * |
| 24 | ***************************************************************************/ |
| 25 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 26 | #include "curl_setup.h" |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 27 | |
| 28 | #include "urldata.h" |
| 29 | #include "sendf.h" |
| 30 | #include "select.h" |
| 31 | #include "progress.h" |
| 32 | #include "speedcheck.h" |
| 33 | #include "pingpong.h" |
| 34 | #include "multiif.h" |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 35 | #include "non-ascii.h" |
| 36 | #include "vtls/vtls.h" |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 37 | |
Alex Deymo | d15eaac | 2016-06-28 14:49:26 -0700 | [diff] [blame] | 38 | /* The last 3 #include files should be in this order */ |
| 39 | #include "curl_printf.h" |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 40 | #include "curl_memory.h" |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 41 | #include "memdebug.h" |
| 42 | |
| 43 | #ifdef USE_PINGPONG |
| 44 | |
| 45 | /* Returns timeout in ms. 0 or negative number means the timeout has already |
| 46 | triggered */ |
Elliott Hughes | cee0338 | 2017-06-23 12:17:18 -0700 | [diff] [blame] | 47 | time_t Curl_pp_state_timeout(struct pingpong *pp) |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 48 | { |
| 49 | struct connectdata *conn = pp->conn; |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 50 | struct Curl_easy *data = conn->data; |
Elliott Hughes | cee0338 | 2017-06-23 12:17:18 -0700 | [diff] [blame] | 51 | time_t timeout_ms; /* in milliseconds */ |
| 52 | time_t timeout2_ms; /* in milliseconds */ |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 53 | long response_time = (data->set.server_response_timeout)? |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 54 | data->set.server_response_timeout: pp->response_time; |
| 55 | |
| 56 | /* if CURLOPT_SERVER_RESPONSE_TIMEOUT is set, use that to determine |
| 57 | remaining time, or use pp->response because SERVER_RESPONSE_TIMEOUT is |
| 58 | supposed to govern the response for any given server response, not for |
| 59 | the time from connect to the given server response. */ |
| 60 | |
| 61 | /* Without a requested timeout, we only wait 'response_time' seconds for the |
| 62 | full response to arrive before we bail out */ |
| 63 | timeout_ms = response_time - |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 64 | Curl_timediff(Curl_now(), pp->response); /* spent time */ |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 65 | |
| 66 | if(data->set.timeout) { |
| 67 | /* if timeout is requested, find out how much remaining time we have */ |
| 68 | timeout2_ms = data->set.timeout - /* timeout time */ |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 69 | Curl_timediff(Curl_now(), conn->now); /* spent time */ |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 70 | |
| 71 | /* pick the lowest number */ |
| 72 | timeout_ms = CURLMIN(timeout_ms, timeout2_ms); |
| 73 | } |
| 74 | |
| 75 | return timeout_ms; |
| 76 | } |
| 77 | |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 78 | /* |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 79 | * Curl_pp_statemach() |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 80 | */ |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 81 | CURLcode Curl_pp_statemach(struct pingpong *pp, bool block) |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 82 | { |
| 83 | struct connectdata *conn = pp->conn; |
| 84 | curl_socket_t sock = conn->sock[FIRSTSOCKET]; |
| 85 | int rc; |
Elliott Hughes | cee0338 | 2017-06-23 12:17:18 -0700 | [diff] [blame] | 86 | time_t interval_ms; |
| 87 | time_t timeout_ms = Curl_pp_state_timeout(pp); |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 88 | struct Curl_easy *data = conn->data; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 89 | CURLcode result = CURLE_OK; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 90 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 91 | if(timeout_ms <= 0) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 92 | failf(data, "server response timeout"); |
| 93 | return CURLE_OPERATION_TIMEDOUT; /* already too little time */ |
| 94 | } |
| 95 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 96 | if(block) { |
| 97 | interval_ms = 1000; /* use 1 second timeout intervals */ |
| 98 | if(timeout_ms < interval_ms) |
| 99 | interval_ms = timeout_ms; |
| 100 | } |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 101 | else |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 102 | interval_ms = 0; /* immediate */ |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 103 | |
Elliott Hughes | cee0338 | 2017-06-23 12:17:18 -0700 | [diff] [blame] | 104 | if(Curl_ssl_data_pending(conn, FIRSTSOCKET)) |
| 105 | rc = 1; |
| 106 | else if(Curl_pp_moredata(pp)) |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 107 | /* We are receiving and there is data in the cache so just read it */ |
| 108 | rc = 1; |
| 109 | else if(!pp->sendleft && Curl_ssl_data_pending(conn, FIRSTSOCKET)) |
| 110 | /* We are receiving and there is data ready in the SSL library */ |
| 111 | rc = 1; |
| 112 | else |
Elliott Hughes | cee0338 | 2017-06-23 12:17:18 -0700 | [diff] [blame] | 113 | rc = Curl_socket_check(pp->sendleft?CURL_SOCKET_BAD:sock, /* reading */ |
| 114 | CURL_SOCKET_BAD, |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 115 | pp->sendleft?sock:CURL_SOCKET_BAD, /* writing */ |
| 116 | interval_ms); |
| 117 | |
| 118 | if(block) { |
| 119 | /* if we didn't wait, we don't have to spend time on this now */ |
| 120 | if(Curl_pgrsUpdate(conn)) |
| 121 | result = CURLE_ABORTED_BY_CALLBACK; |
| 122 | else |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 123 | result = Curl_speedcheck(data, Curl_now()); |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 124 | |
| 125 | if(result) |
| 126 | return result; |
| 127 | } |
| 128 | |
| 129 | if(rc == -1) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 130 | failf(data, "select/poll error"); |
| 131 | result = CURLE_OUT_OF_MEMORY; |
| 132 | } |
| 133 | else if(rc) |
| 134 | result = pp->statemach_act(conn); |
| 135 | |
| 136 | return result; |
| 137 | } |
| 138 | |
| 139 | /* initialize stuff to prepare for reading a fresh new response */ |
| 140 | void Curl_pp_init(struct pingpong *pp) |
| 141 | { |
| 142 | struct connectdata *conn = pp->conn; |
| 143 | pp->nread_resp = 0; |
| 144 | pp->linestart_resp = conn->data->state.buffer; |
| 145 | pp->pending_resp = TRUE; |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 146 | pp->response = Curl_now(); /* start response time-out now! */ |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 147 | } |
| 148 | |
| 149 | |
| 150 | |
| 151 | /*********************************************************************** |
| 152 | * |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 153 | * Curl_pp_vsendf() |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 154 | * |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 155 | * Send the formatted string as a command to a pingpong server. Note that |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 156 | * the string should not have any CRLF appended, as this function will |
| 157 | * append the necessary things itself. |
| 158 | * |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 159 | * made to never block |
| 160 | */ |
| 161 | CURLcode Curl_pp_vsendf(struct pingpong *pp, |
| 162 | const char *fmt, |
| 163 | va_list args) |
| 164 | { |
| 165 | ssize_t bytes_written; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 166 | size_t write_len; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 167 | char *fmt_crlf; |
| 168 | char *s; |
| 169 | CURLcode result; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 170 | struct connectdata *conn = pp->conn; |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 171 | struct Curl_easy *data; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 172 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 173 | #ifdef HAVE_GSSAPI |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 174 | enum protection_level data_sec; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 175 | #endif |
| 176 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 177 | DEBUGASSERT(pp->sendleft == 0); |
| 178 | DEBUGASSERT(pp->sendsize == 0); |
| 179 | DEBUGASSERT(pp->sendthis == NULL); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 180 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 181 | if(!conn) |
| 182 | /* can't send without a connection! */ |
| 183 | return CURLE_SEND_ERROR; |
| 184 | |
| 185 | data = conn->data; |
| 186 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 187 | fmt_crlf = aprintf("%s\r\n", fmt); /* append a trailing CRLF */ |
| 188 | if(!fmt_crlf) |
| 189 | return CURLE_OUT_OF_MEMORY; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 190 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 191 | s = vaprintf(fmt_crlf, args); /* trailing CRLF appended */ |
| 192 | free(fmt_crlf); |
| 193 | if(!s) |
| 194 | return CURLE_OUT_OF_MEMORY; |
| 195 | |
| 196 | bytes_written = 0; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 197 | write_len = strlen(s); |
| 198 | |
| 199 | Curl_pp_init(pp); |
| 200 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 201 | result = Curl_convert_to_network(data, s, write_len); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 202 | /* Curl_convert_to_network calls failf if unsuccessful */ |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 203 | if(result) { |
| 204 | free(s); |
| 205 | return result; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 206 | } |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 207 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 208 | #ifdef HAVE_GSSAPI |
| 209 | conn->data_prot = PROT_CMD; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 210 | #endif |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 211 | result = Curl_write(conn, conn->sock[FIRSTSOCKET], s, write_len, |
| 212 | &bytes_written); |
| 213 | #ifdef HAVE_GSSAPI |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 214 | data_sec = conn->data_prot; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 215 | DEBUGASSERT(data_sec > PROT_NONE && data_sec < PROT_LAST); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 216 | conn->data_prot = data_sec; |
| 217 | #endif |
| 218 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 219 | if(result) { |
| 220 | free(s); |
| 221 | return result; |
| 222 | } |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 223 | |
| 224 | if(conn->data->set.verbose) |
| 225 | Curl_debug(conn->data, CURLINFO_HEADER_OUT, |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 226 | s, (size_t)bytes_written, conn); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 227 | |
| 228 | if(bytes_written != (ssize_t)write_len) { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 229 | /* the whole chunk was not sent, keep it around and adjust sizes */ |
| 230 | pp->sendthis = s; |
| 231 | pp->sendsize = write_len; |
| 232 | pp->sendleft = write_len - bytes_written; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 233 | } |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 234 | else { |
| 235 | free(s); |
| 236 | pp->sendthis = NULL; |
| 237 | pp->sendleft = pp->sendsize = 0; |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 238 | pp->response = Curl_now(); |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 239 | } |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 240 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 241 | return CURLE_OK; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 242 | } |
| 243 | |
| 244 | |
| 245 | /*********************************************************************** |
| 246 | * |
| 247 | * Curl_pp_sendf() |
| 248 | * |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 249 | * Send the formatted string as a command to a pingpong server. Note that |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 250 | * the string should not have any CRLF appended, as this function will |
| 251 | * append the necessary things itself. |
| 252 | * |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 253 | * made to never block |
| 254 | */ |
| 255 | CURLcode Curl_pp_sendf(struct pingpong *pp, |
| 256 | const char *fmt, ...) |
| 257 | { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 258 | CURLcode result; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 259 | va_list ap; |
| 260 | va_start(ap, fmt); |
| 261 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 262 | result = Curl_pp_vsendf(pp, fmt, ap); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 263 | |
| 264 | va_end(ap); |
| 265 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 266 | return result; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 267 | } |
| 268 | |
| 269 | /* |
| 270 | * Curl_pp_readresp() |
| 271 | * |
| 272 | * Reads a piece of a server response. |
| 273 | */ |
| 274 | CURLcode Curl_pp_readresp(curl_socket_t sockfd, |
| 275 | struct pingpong *pp, |
| 276 | int *code, /* return the server code if done */ |
| 277 | size_t *size) /* size of the response */ |
| 278 | { |
| 279 | ssize_t perline; /* count bytes per line */ |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 280 | bool keepon = TRUE; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 281 | ssize_t gotbytes; |
| 282 | char *ptr; |
| 283 | struct connectdata *conn = pp->conn; |
Alex Deymo | e3149cc | 2016-10-05 11:18:42 -0700 | [diff] [blame] | 284 | struct Curl_easy *data = conn->data; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 285 | char * const buf = data->state.buffer; |
| 286 | CURLcode result = CURLE_OK; |
| 287 | |
| 288 | *code = 0; /* 0 for errors or not done */ |
| 289 | *size = 0; |
| 290 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 291 | ptr = buf + pp->nread_resp; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 292 | |
| 293 | /* number of bytes in the current line, so far */ |
| 294 | perline = (ssize_t)(ptr-pp->linestart_resp); |
| 295 | |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 296 | while((pp->nread_resp < (size_t)data->set.buffer_size) && |
| 297 | (keepon && !result)) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 298 | |
| 299 | if(pp->cache) { |
| 300 | /* we had data in the "cache", copy that instead of doing an actual |
| 301 | * read |
| 302 | * |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 303 | * pp->cache_size is cast to ssize_t here. This should be safe, because |
| 304 | * it would have been populated with something of size int to begin |
| 305 | * with, even though its datatype may be larger than an int. |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 306 | */ |
Elliott Hughes | 1ef06ba | 2018-05-30 15:43:58 -0700 | [diff] [blame] | 307 | if((ptr + pp->cache_size) > (buf + data->set.buffer_size + 1)) { |
| 308 | failf(data, "cached response data too big to handle"); |
| 309 | return CURLE_RECV_ERROR; |
| 310 | } |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 311 | memcpy(ptr, pp->cache, pp->cache_size); |
Lucas Eckels | 9bd90e6 | 2012-08-06 15:07:02 -0700 | [diff] [blame] | 312 | gotbytes = (ssize_t)pp->cache_size; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 313 | free(pp->cache); /* free the cache */ |
| 314 | pp->cache = NULL; /* clear the pointer */ |
| 315 | pp->cache_size = 0; /* zero the size just in case */ |
| 316 | } |
| 317 | else { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 318 | #ifdef HAVE_GSSAPI |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 319 | enum protection_level prot = conn->data_prot; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 320 | conn->data_prot = PROT_CLEAR; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 321 | #endif |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 322 | DEBUGASSERT((ptr + data->set.buffer_size - pp->nread_resp) <= |
| 323 | (buf + data->set.buffer_size + 1)); |
| 324 | result = Curl_read(conn, sockfd, ptr, |
| 325 | data->set.buffer_size - pp->nread_resp, |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 326 | &gotbytes); |
| 327 | #ifdef HAVE_GSSAPI |
| 328 | DEBUGASSERT(prot > PROT_NONE && prot < PROT_LAST); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 329 | conn->data_prot = prot; |
| 330 | #endif |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 331 | if(result == CURLE_AGAIN) |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 332 | return CURLE_OK; /* return */ |
| 333 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 334 | if(!result && (gotbytes > 0)) |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 335 | /* convert from the network encoding */ |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 336 | result = Curl_convert_from_network(data, ptr, gotbytes); |
| 337 | /* Curl_convert_from_network calls failf if unsuccessful */ |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 338 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 339 | if(result) |
| 340 | /* Set outer result variable to this error. */ |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 341 | keepon = FALSE; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 342 | } |
| 343 | |
| 344 | if(!keepon) |
| 345 | ; |
| 346 | else if(gotbytes <= 0) { |
| 347 | keepon = FALSE; |
| 348 | result = CURLE_RECV_ERROR; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 349 | failf(data, "response reading failed"); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 350 | } |
| 351 | else { |
| 352 | /* we got a whole chunk of data, which can be anything from one |
| 353 | * byte to a set of lines and possible just a piece of the last |
| 354 | * line */ |
| 355 | ssize_t i; |
| 356 | ssize_t clipamount = 0; |
| 357 | bool restart = FALSE; |
| 358 | |
| 359 | data->req.headerbytecount += (long)gotbytes; |
| 360 | |
| 361 | pp->nread_resp += gotbytes; |
| 362 | for(i = 0; i < gotbytes; ptr++, i++) { |
| 363 | perline++; |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 364 | if(*ptr == '\n') { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 365 | /* a newline is CRLF in pp-talk, so the CR is ignored as |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 366 | the line isn't really terminated until the LF comes */ |
| 367 | |
| 368 | /* output debug output if that is requested */ |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 369 | #ifdef HAVE_GSSAPI |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 370 | if(!conn->sec_complete) |
| 371 | #endif |
| 372 | if(data->set.verbose) |
Lucas Eckels | 9bd90e6 | 2012-08-06 15:07:02 -0700 | [diff] [blame] | 373 | Curl_debug(data, CURLINFO_HEADER_IN, |
| 374 | pp->linestart_resp, (size_t)perline, conn); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 375 | |
| 376 | /* |
| 377 | * We pass all response-lines to the callback function registered |
| 378 | * for "headers". The response lines can be seen as a kind of |
| 379 | * headers. |
| 380 | */ |
| 381 | result = Curl_client_write(conn, CLIENTWRITE_HEADER, |
| 382 | pp->linestart_resp, perline); |
| 383 | if(result) |
| 384 | return result; |
| 385 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 386 | if(pp->endofresp(conn, pp->linestart_resp, perline, code)) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 387 | /* This is the end of the last line, copy the last line to the |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 388 | start of the buffer and zero terminate, for old times sake */ |
| 389 | size_t n = ptr - pp->linestart_resp; |
| 390 | memmove(buf, pp->linestart_resp, n); |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 391 | buf[n] = 0; /* zero terminate */ |
| 392 | keepon = FALSE; |
| 393 | pp->linestart_resp = ptr + 1; /* advance pointer */ |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 394 | i++; /* skip this before getting out */ |
| 395 | |
| 396 | *size = pp->nread_resp; /* size of the response */ |
| 397 | pp->nread_resp = 0; /* restart */ |
| 398 | break; |
| 399 | } |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 400 | perline = 0; /* line starts over here */ |
| 401 | pp->linestart_resp = ptr + 1; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 402 | } |
| 403 | } |
| 404 | |
| 405 | if(!keepon && (i != gotbytes)) { |
| 406 | /* We found the end of the response lines, but we didn't parse the |
| 407 | full chunk of data we have read from the server. We therefore need |
| 408 | to store the rest of the data to be checked on the next invoke as |
| 409 | it may actually contain another end of response already! */ |
| 410 | clipamount = gotbytes - i; |
| 411 | restart = TRUE; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 412 | DEBUGF(infof(data, "Curl_pp_readresp_ %d bytes of trailing " |
| 413 | "server response left\n", |
| 414 | (int)clipamount)); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 415 | } |
| 416 | else if(keepon) { |
| 417 | |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 418 | if((perline == gotbytes) && (gotbytes > data->set.buffer_size/2)) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 419 | /* We got an excessive line without newlines and we need to deal |
| 420 | with it. We keep the first bytes of the line then we throw |
| 421 | away the rest. */ |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 422 | infof(data, "Excessive server response line length received, " |
| 423 | "%zd bytes. Stripping\n", gotbytes); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 424 | restart = TRUE; |
| 425 | |
| 426 | /* we keep 40 bytes since all our pingpong protocols are only |
| 427 | interested in the first piece */ |
| 428 | clipamount = 40; |
| 429 | } |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 430 | else if(pp->nread_resp > (size_t)data->set.buffer_size/2) { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 431 | /* We got a large chunk of data and there's potentially still |
| 432 | trailing data to take care of, so we put any such part in the |
| 433 | "cache", clear the buffer to make space and restart. */ |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 434 | clipamount = perline; |
| 435 | restart = TRUE; |
| 436 | } |
| 437 | } |
| 438 | else if(i == gotbytes) |
| 439 | restart = TRUE; |
| 440 | |
| 441 | if(clipamount) { |
| 442 | pp->cache_size = clipamount; |
| 443 | pp->cache = malloc(pp->cache_size); |
| 444 | if(pp->cache) |
| 445 | memcpy(pp->cache, pp->linestart_resp, pp->cache_size); |
| 446 | else |
| 447 | return CURLE_OUT_OF_MEMORY; |
| 448 | } |
| 449 | if(restart) { |
| 450 | /* now reset a few variables to start over nicely from the start of |
| 451 | the big buffer */ |
| 452 | pp->nread_resp = 0; /* start over from scratch in the buffer */ |
| 453 | ptr = pp->linestart_resp = buf; |
| 454 | perline = 0; |
| 455 | } |
| 456 | |
| 457 | } /* there was data */ |
| 458 | |
| 459 | } /* while there's buffer left and loop is requested */ |
| 460 | |
| 461 | pp->pending_resp = FALSE; |
| 462 | |
| 463 | return result; |
| 464 | } |
| 465 | |
| 466 | int Curl_pp_getsock(struct pingpong *pp, |
| 467 | curl_socket_t *socks, |
| 468 | int numsocks) |
| 469 | { |
| 470 | struct connectdata *conn = pp->conn; |
| 471 | |
| 472 | if(!numsocks) |
| 473 | return GETSOCK_BLANK; |
| 474 | |
| 475 | socks[0] = conn->sock[FIRSTSOCKET]; |
| 476 | |
| 477 | if(pp->sendleft) { |
| 478 | /* write mode */ |
| 479 | return GETSOCK_WRITESOCK(0); |
| 480 | } |
| 481 | |
| 482 | /* read mode */ |
| 483 | return GETSOCK_READSOCK(0); |
| 484 | } |
| 485 | |
| 486 | CURLcode Curl_pp_flushsend(struct pingpong *pp) |
| 487 | { |
| 488 | /* we have a piece of a command still left to send */ |
| 489 | struct connectdata *conn = pp->conn; |
| 490 | ssize_t written; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 491 | curl_socket_t sock = conn->sock[FIRSTSOCKET]; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 492 | CURLcode result = Curl_write(conn, sock, pp->sendthis + pp->sendsize - |
| 493 | pp->sendleft, pp->sendleft, &written); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 494 | if(result) |
| 495 | return result; |
| 496 | |
| 497 | if(written != (ssize_t)pp->sendleft) { |
| 498 | /* only a fraction was sent */ |
| 499 | pp->sendleft -= written; |
| 500 | } |
| 501 | else { |
| 502 | free(pp->sendthis); |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 503 | pp->sendthis = NULL; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 504 | pp->sendleft = pp->sendsize = 0; |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 505 | pp->response = Curl_now(); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 506 | } |
| 507 | return CURLE_OK; |
| 508 | } |
| 509 | |
| 510 | CURLcode Curl_pp_disconnect(struct pingpong *pp) |
| 511 | { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 512 | free(pp->cache); |
| 513 | pp->cache = NULL; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 514 | return CURLE_OK; |
| 515 | } |
| 516 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 517 | bool Curl_pp_moredata(struct pingpong *pp) |
| 518 | { |
| 519 | return (!pp->sendleft && pp->cache && pp->nread_resp < pp->cache_size) ? |
| 520 | TRUE : FALSE; |
| 521 | } |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 522 | |
| 523 | #endif |