Lines Matching refs:data
99 char *Curl_checkheaders(const struct Curl_easy *data,
107 for(head = data->set.headers; head; head = head->next) {
108 if(strncasecompare(head->data, thisheader, thislen) &&
109 Curl_headersep(head->data[thislen]) )
110 return head->data;
117 CURLcode Curl_get_upload_buffer(struct Curl_easy *data)
119 if(!data->state.ulbuf) {
120 data->state.ulbuf = malloc(data->set.upload_buffer_size);
121 if(!data->state.ulbuf)
130 * until no more data is available for sending.
135 struct Curl_easy *data = (struct Curl_easy *)raw;
136 struct dynbuf *trailers_buf = &data->state.trailers_buf;
138 data->state.trailers_bytes_sent;
142 Curl_dyn_ptr(trailers_buf) + data->state.trailers_bytes_sent,
144 data->state.trailers_bytes_sent += to_copy;
151 struct Curl_easy *data = (struct Curl_easy *)raw;
152 struct dynbuf *trailers_buf = &data->state.trailers_buf;
153 return Curl_dyn_len(trailers_buf) - data->state.trailers_bytes_sent;
158 * This function will call the read callback to fill our buffer with data
161 CURLcode Curl_fillreadbuffer(struct Curl_easy *data, size_t bytes,
171 if(data->state.trailers_state == TRAILERS_INITIALIZED) {
178 infof(data,
180 data->state.trailers_state = TRAILERS_SENDING;
181 Curl_dyn_init(&data->state.trailers_buf, DYN_TRAILERS);
183 data->state.trailers_bytes_sent = 0;
184 Curl_set_in_callback(data, true);
185 trailers_ret_code = data->set.trailer_callback(&trailers,
186 data->set.trailer_data);
187 Curl_set_in_callback(data, false);
189 result = Curl_http_compile_trailers(trailers, &data->state.trailers_buf,
190 data);
193 failf(data, "operation aborted by trailing headers callback");
198 Curl_dyn_free(&data->state.trailers_buf);
202 infof(data, "Successfully compiled trailers.");
208 /* if we are transmitting trailing data, we don't need to write
210 if(data->req.upload_chunky &&
211 data->state.trailers_state == TRAILERS_NONE) {
214 data->req.upload_fromhere += (8 + 2); /* 32bit hex + CRLF */
217 if(data->state.trailers_state == TRAILERS_SENDING) {
220 pulling trailing data until we have no more at which point we
225 extra_data = (void *)data;
231 readfunc = data->state.fread_func;
232 extra_data = data->state.in;
235 if(!data->req.fread_eof[eof_index]) {
236 Curl_set_in_callback(data, true);
237 nread = readfunc(data->req.upload_fromhere, 1, buffersize, extra_data);
238 Curl_set_in_callback(data, false);
240 data->req.fread_eof[eof_index] = !nread;
246 failf(data, "operation aborted by callback");
251 struct SingleRequest *k = &data->req;
253 if(data->conn->handler->flags & PROTOPT_NONETWORK) {
257 failf(data, "Read callback asked for PAUSE when not supported");
263 if(data->req.upload_chunky) {
265 data->req.upload_fromhere -= (8 + 2);
274 failf(data, "read function returned funny value");
279 if(!data->req.forbidchunk && data->req.upload_chunky) {
302 (data->state.prefer_ascii) ||
304 (data->set.crlf)) {
314 /* if we're not handling trailing data, proceed as usual */
315 if(data->state.trailers_state != TRAILERS_SENDING) {
321 data->req.upload_fromhere -= hexlen;
325 memcpy(data->req.upload_fromhere, hexbuffer, hexlen);
327 /* always append ASCII CRLF to the data unless
330 data->set.trailer_callback != NULL &&
331 data->state.trailers_state == TRAILERS_NONE) {
332 data->state.trailers_state = TRAILERS_INITIALIZED;
335 memcpy(data->req.upload_fromhere + nread,
342 if(data->state.trailers_state == TRAILERS_SENDING &&
343 !trailers_left(data)) {
344 Curl_dyn_free(&data->state.trailers_buf);
345 data->state.trailers_state = TRAILERS_DONE;
346 data->set.trailer_data = NULL;
347 data->set.trailer_callback = NULL;
349 data->req.upload_done = TRUE;
350 infof(data, "Signaling end of chunked upload after trailers.");
354 data->state.trailers_state != TRAILERS_INITIALIZED) {
356 data->req.upload_done = TRUE;
357 infof(data,
371 static int data_pending(struct Curl_easy *data)
373 struct connectdata *conn = data->conn;
376 return Curl_conn_data_pending(data, SECONDARYSOCKET);
381 Curl_conn_data_pending(data, FIRSTSOCKET);
388 bool Curl_meets_timecondition(struct Curl_easy *data, time_t timeofdoc)
390 if((timeofdoc == 0) || (data->set.timevalue == 0))
393 switch(data->set.timecondition) {
396 if(timeofdoc <= data->set.timevalue) {
397 infof(data,
399 data->info.timecond = TRUE;
404 if(timeofdoc >= data->set.timevalue) {
405 infof(data,
407 data->info.timecond = TRUE;
417 * Receive raw response data for the transfer.
418 * @param data the transfer
419 * @param buf buffer to keep response data received
425 static ssize_t Curl_xfer_recv_resp(struct Curl_easy *data,
433 /* If we are reading BODY data and the connection does NOT handle EOF
434 * and we know the size of the BODY data, limit the read amount */
435 if(!eos_reliable && !data->req.header && data->req.size != -1) {
436 curl_off_t totalleft = data->req.size - data->req.bytecount;
445 DEBUGF(infof(data, "readwrite_data: we're done"));
450 *err = Curl_read(data, data->conn->sockfd, buf, blen, &nread);
460 * the stream was rewound (in which case we have data in a
463 static CURLcode readwrite_data(struct Curl_easy *data,
467 struct connectdata *conn = data->conn;
475 DEBUGASSERT(data->state.buffer);
492 buf = data->state.buffer;
493 bytestoread = data->set.buffer_size;
496 if(bytestoread && data->set.max_recv_speed) {
497 curl_off_t net_limit = data->set.max_recv_speed - total_received;
504 nread = Curl_xfer_recv_resp(data, buf, bytestoread,
520 /* if we receive 0 or less here, either the data transfer is done or the
523 DEBUGF(infof(data, "nread == 0, stream closed, bailing"));
525 DEBUGF(infof(data, "nread <= 0, server closed connection, bailing"));
533 result = Curl_xfer_write_resp(data, buf, blen, is_eos, done);
538 * we should read the EOS. Which may arrive as meta data after
540 if((!is_multiplex && data->req.download_done) || is_eos) {
541 data->req.keepon &= ~KEEP_RECV;
547 } while(maxloops-- && data_pending(data));
551 data->state.select_bits = CURL_CSELECT_IN;
553 data->state.select_bits |= CURL_CSELECT_OUT;
561 infof(data, "we are done reading and this is set to close, stop send");
568 DEBUGF(infof(data, "readwrite_data() -> %d", result));
572 CURLcode Curl_done_sending(struct Curl_easy *data,
578 Curl_conn_ev_data_done_send(data);
604 #define curl_upload_refill_watermark(data) \
605 ((ssize_t)((data)->set.upload_buffer_size >> 5))
608 * Send data to upload to the server, when the socket is writable.
610 static CURLcode readwrite_upload(struct Curl_easy *data,
619 struct SingleRequest *k = &data->req;
628 k->upload_present < curl_upload_refill_watermark(data) &&
632 data->state.infilesize)) {
636 /* only read more data if there's no upload data already
639 result = Curl_get_upload_buffer(data);
642 if(offset && k->upload_fromhere != data->state.ulbuf)
643 memmove(data->state.ulbuf, k->upload_fromhere, offset);
645 k->upload_fromhere = data->state.ulbuf;
655 /* If this call is to send body data, we must take some action:
663 Curl_expire(data, data->set.expect_100_timeout, EXPIRE_100_TIMEOUT);
669 /* We're sending the HTTP request headers, not the data.
677 result = Curl_fillreadbuffer(data, data->set.upload_buffer_size-offset,
693 result = Curl_done_sending(data, k);
706 (data->state.prefer_ascii) ||
708 (data->set.crlf))) {
710 if(!data->state.scratch) {
711 data->state.scratch = malloc(2 * data->set.upload_buffer_size);
712 if(!data->state.scratch) {
713 failf(data, "Failed to alloc scratch buffer");
721 * transfer so the data should already be in ASCII.
726 memcpy(data->state.scratch, k->upload_fromhere, offset);
729 data->state.scratch[si++] = 0x0d;
730 data->state.scratch[si] = 0x0a;
731 if(!data->set.crlf) {
734 if(data->state.infilesize != -1)
735 data->state.infilesize++;
739 data->state.scratch[si] = k->upload_fromhere[i];
748 k->upload_fromhere = data->state.scratch;
757 result = Curl_smtp_escape_eob(data, nread, offset);
765 that instead of reading more data */
768 /* write to socket (send away data) */
769 result = Curl_write(data,
790 /* show the data before we change the pointer upload_fromhere */
791 Curl_debug(data, CURLINFO_HEADER_OUT, k->upload_fromhere, (size_t)n);
799 /* show the data before we change the pointer upload_fromhere */
800 Curl_debug(data, CURLINFO_DATA_OUT,
805 Curl_pgrsSetUploadCounter(data, k->writebytecount);
809 (k->writebytecount == data->state.infilesize)) {
810 /* we have sent all data we were supposed to */
812 infof(data, "We are completely uploaded and fine");
827 result = Curl_get_upload_buffer(data);
830 k->upload_fromhere = data->state.ulbuf;
834 result = Curl_done_sending(data, k);
846 static int select_bits_paused(struct Curl_easy *data, int select_bits)
854 /* if there is data in a direction not paused, return false */
856 !(data->req.keepon & KEEP_RECV_PAUSE)) ||
858 !(data->req.keepon & KEEP_SEND_PAUSE)))
861 return (data->req.keepon & (KEEP_RECV_PAUSE|KEEP_SEND_PAUSE));
865 * Curl_readwrite() is the low-level function to be called when data is to
868 CURLcode Curl_readwrite(struct Curl_easy *data,
871 struct connectdata *conn = data->conn;
872 struct SingleRequest *k = &data->req;
878 if(data->state.select_bits) {
879 if(select_bits_paused(data, data->state.select_bits)) {
882 DEBUGF(infof(data, "readwrite, select_bits, early return on PAUSED"));
886 select_bits = data->state.select_bits;
887 data->state.select_bits = 0;
908 failf(data, "select/poll returned error");
915 result = conn->datastream(data, conn, &didwhat, done, select_bits);
922 the stream was rewound (in which case we have data in a
925 result = readwrite_data(data, k, &didwhat, done);
934 result = readwrite_upload(data, conn, &didwhat);
960 if(ms >= data->set.expect_100_timeout) {
964 Curl_expire_done(data, EXPIRE_100_TIMEOUT);
965 infof(data, "Done waiting for 100-continue");
969 result = Curl_conn_ev_data_idle(data);
974 if(Curl_pgrsUpdate(data))
977 result = Curl_speedcheck(data, now);
982 if(0 > Curl_timeleft(data, &now, FALSE)) {
984 failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T
987 Curl_timediff(now, data->progress.t_startsingle),
991 failf(data, "Operation timed out after %" CURL_FORMAT_TIMEDIFF_T
993 Curl_timediff(now, data->progress.t_startsingle),
1006 if(!(data->req.no_body) && (k->size != -1) &&
1013 (k->bytecount != (k->size + data->state.crlf_conversions)) &&
1016 failf(data, "transfer closed with %" CURL_FORMAT_CURL_OFF_T
1021 if(Curl_pgrsUpdate(data)) {
1031 DEBUGF(infof(data, "Curl_readwrite() -> %d", result));
1037 void Curl_init_CONNECT(struct Curl_easy *data)
1039 data->state.fread_func = data->set.fread_func_set;
1040 data->state.in = data->set.in_set;
1041 data->state.upload = (data->state.httpreq == HTTPREQ_PUT);
1049 CURLcode Curl_pretransfer(struct Curl_easy *data)
1053 if(!data->state.url && !data->set.uh) {
1055 failf(data, "No URL set");
1060 if(data->state.url_alloc) {
1062 Curl_safefree(data->state.url);
1063 data->state.url_alloc = FALSE;
1066 if(!data->state.url && data->set.uh) {
1068 free(data->set.str[STRING_SET_URL]);
1069 uc = curl_url_get(data->set.uh,
1070 CURLUPART_URL, &data->set.str[STRING_SET_URL], 0);
1072 failf(data, "No URL set");
1077 if(data->set.postfields && data->set.set_resume_from) {
1079 failf(data, "cannot mix POSTFIELDS with RESUME_FROM");
1083 data->state.prefer_ascii = data->set.prefer_ascii;
1085 data->state.list_only = data->set.list_only;
1087 data->state.httpreq = data->set.method;
1088 data->state.url = data->set.str[STRING_SET_URL];
1093 result = Curl_ssl_initsessions(data, data->set.general_ssl.max_ssl_sessions);
1097 data->state.requests = 0;
1098 data->state.followlocation = 0; /* reset the location-follow counter */
1099 data->state.this_is_a_follow = FALSE; /* reset this */
1100 data->state.errorbuf = FALSE; /* no error has occurred */
1101 data->state.httpwant = data->set.httpwant;
1102 data->state.httpversion = 0;
1103 data->state.authproblem = FALSE;
1104 data->state.authhost.want = data->set.httpauth;
1105 data->state.authproxy.want = data->set.proxyauth;
1106 Curl_safefree(data->info.wouldredirect);
1107 Curl_data_priority_clear_state(data);
1109 if(data->state.httpreq == HTTPREQ_PUT)
1110 data->state.infilesize = data->set.filesize;
1111 else if((data->state.httpreq != HTTPREQ_GET) &&
1112 (data->state.httpreq != HTTPREQ_HEAD)) {
1113 data->state.infilesize = data->set.postfieldsize;
1114 if(data->set.postfields && (data->state.infilesize == -1))
1115 data->state.infilesize = (curl_off_t)strlen(data->set.postfields);
1118 data->state.infilesize = 0;
1121 Curl_cookie_loadfiles(data);
1124 if(data->state.resolve)
1125 result = Curl_loadhostpairs(data);
1128 Curl_hsts_loadfiles(data);
1131 /* Allow data->set.use_port to set which port to use. This needs to be
1134 data->state.allow_port = TRUE;
1140 if(!data->set.no_signal)
1141 data->state.prev_signal = signal(SIGPIPE, SIG_IGN);
1144 Curl_initinfo(data); /* reset session-specific information "variables" */
1145 Curl_pgrsResetTransferSizes(data);
1146 Curl_pgrsStartNow(data);
1151 data->state.authhost.picked &= data->state.authhost.want;
1152 data->state.authproxy.picked &= data->state.authproxy.want;
1155 data->state.wildcardmatch = data->set.wildcard_enabled;
1156 if(data->state.wildcardmatch) {
1158 if(!data->wildcard) {
1159 data->wildcard = calloc(1, sizeof(struct WildcardData));
1160 if(!data->wildcard)
1163 wc = data->wildcard;
1175 result = Curl_hsts_loadcb(data, data->hsts);
1183 if(data->set.str[STRING_USERAGENT]) {
1184 Curl_safefree(data->state.aptr.uagent);
1185 data->state.aptr.uagent =
1186 aprintf("User-Agent: %s\r\n", data->set.str[STRING_USERAGENT]);
1187 if(!data->state.aptr.uagent)
1192 result = Curl_setstropt(&data->state.aptr.user,
1193 data->set.str[STRING_USERNAME]);
1195 result = Curl_setstropt(&data->state.aptr.passwd,
1196 data->set.str[STRING_PASSWORD]);
1198 result = Curl_setstropt(&data->state.aptr.proxyuser,
1199 data->set.str[STRING_PROXYUSERNAME]);
1201 result = Curl_setstropt(&data->state.aptr.proxypasswd,
1202 data->set.str[STRING_PROXYPASSWORD]);
1204 data->req.headerbytecount = 0;
1205 Curl_headers_cleanup(data);
1212 CURLcode Curl_posttransfer(struct Curl_easy *data)
1216 if(!data->set.no_signal)
1217 signal(SIGPIPE, data->state.prev_signal);
1219 (void)data; /* unused parameter */
1231 CURLcode Curl_follow(struct Curl_easy *data,
1236 (void)data;
1251 data->state.requests++; /* count all real follows */
1253 if((data->set.maxredirs != -1) &&
1254 (data->state.followlocation >= data->set.maxredirs)) {
1260 data->state.followlocation++; /* count redirect-followings, including
1263 if(data->set.http_auto_referer) {
1271 if(data->state.referer_alloc) {
1272 Curl_safefree(data->state.referer);
1273 data->state.referer_alloc = FALSE;
1281 uc = curl_url_set(u, CURLUPART_URL, data->state.url, 0);
1296 data->state.referer = referer;
1297 data->state.referer_alloc = TRUE; /* yes, free this later */
1303 (data->req.httpcode != 401) && (data->req.httpcode != 407) &&
1310 DEBUGASSERT(data->state.uh);
1311 uc = curl_url_set(data->state.uh, CURLUPART_URL, newurl,
1315 (data->set.path_as_is ? CURLU_PATH_AS_IS : 0));
1318 failf(data, "The redirect target URL could not be parsed: %s",
1330 uc = curl_url_get(data->state.uh, CURLUPART_URL, &newurl, 0);
1336 if(!data->set.allow_auth_to_other_hosts && (type != FOLLOW_FAKE)) {
1341 if(data->set.use_port && data->state.allow_port)
1343 port = (int)data->set.use_port;
1345 uc = curl_url_get(data->state.uh, CURLUPART_PORT, &portnum,
1354 if(port != data->info.conn_remote_port) {
1355 infof(data, "Clear auth, redirects to port from %u to %u",
1356 data->info.conn_remote_port, port);
1362 uc = curl_url_get(data->state.uh, CURLUPART_SCHEME, &scheme, 0);
1369 if(p && (p->protocol != data->info.conn_protocol)) {
1370 infof(data, "Clear auth, redirects scheme from %s to %s",
1371 data->info.conn_scheme, scheme);
1377 Curl_safefree(data->state.aptr.user);
1378 Curl_safefree(data->state.aptr.passwd);
1386 data->info.wouldredirect = newurl;
1389 failf(data, "Maximum (%ld) redirects followed", data->set.maxredirs);
1396 data->state.allow_port = FALSE;
1398 if(data->state.url_alloc)
1399 Curl_safefree(data->state.url);
1401 data->state.url = newurl;
1402 data->state.url_alloc = TRUE;
1404 infof(data, "Issue another request to this URL: '%s'", data->state.url);
1413 switch(data->info.httpcode) {
1443 if((data->state.httpreq == HTTPREQ_POST
1444 || data->state.httpreq == HTTPREQ_POST_FORM
1445 || data->state.httpreq == HTTPREQ_POST_MIME)
1446 && !(data->set.keep_post & CURL_REDIR_POST_301)) {
1447 infof(data, "Switch from POST to GET");
1448 data->state.httpreq = HTTPREQ_GET;
1468 if((data->state.httpreq == HTTPREQ_POST
1469 || data->state.httpreq == HTTPREQ_POST_FORM
1470 || data->state.httpreq == HTTPREQ_POST_MIME)
1471 && !(data->set.keep_post & CURL_REDIR_POST_302)) {
1472 infof(data, "Switch from POST to GET");
1473 data->state.httpreq = HTTPREQ_GET;
1483 if(data->state.httpreq != HTTPREQ_GET &&
1484 ((data->state.httpreq != HTTPREQ_POST &&
1485 data->state.httpreq != HTTPREQ_POST_FORM &&
1486 data->state.httpreq != HTTPREQ_POST_MIME) ||
1487 !(data->set.keep_post & CURL_REDIR_POST_303))) {
1488 data->state.httpreq = HTTPREQ_GET;
1489 infof(data, "Switch to %s",
1490 data->req.no_body?"HEAD":"GET");
1508 Curl_pgrsTime(data, TIMER_REDIRECT);
1509 Curl_pgrsResetTransferSizes(data);
1518 CURLcode Curl_retry_request(struct Curl_easy *data, char **url)
1520 struct connectdata *conn = data->conn;
1526 if(data->state.upload &&
1530 if((data->req.bytecount + data->req.headerbytecount == 0) &&
1532 (!data->req.no_body || (conn->handler->protocol & PROTO_FAMILY_HTTP))
1534 && (data->set.rtspreq != RTSPREQ_RECEIVE)
1537 /* We got no data, we attempted to reuse a connection. For HTTP this
1545 else if(data->state.refused_stream &&
1546 (data->req.bytecount + data->req.headerbytecount == 0) ) {
1550 streams as well, which is why this adds the check the data counters
1552 infof(data, "REFUSED_STREAM, retrying a fresh connect");
1553 data->state.refused_stream = FALSE; /* clear again */
1558 if(data->state.retrycount++ >= CONN_MAX_RETRIES) {
1559 failf(data, "Connection died, tried %d times before giving up",
1561 data->state.retrycount = 0;
1564 infof(data, "Connection died, retrying a fresh connect (retry count: %d)",
1565 data->state.retrycount);
1566 *url = strdup(data->state.url);
1579 data->req.writebytecount) {
1580 data->state.rewindbeforesend = TRUE;
1581 infof(data, "state.rewindbeforesend = TRUE");
1593 struct Curl_easy *data, /* transfer */
1601 struct SingleRequest *k = &data->req;
1602 struct connectdata *conn = data->conn;
1603 struct HTTP *http = data->req.p.http;
1639 Curl_pgrsSetDownloadSize(data, size);
1642 if(k->getheader || !data->req.no_body) {
1650 Even if we require a 100-return code before uploading data, we might
1651 need to write data before that since the REQUEST may not have been
1657 if((data->state.expect100header) &&
1666 Curl_expire(data, data->set.expect_100_timeout, EXPIRE_100_TIMEOUT);
1669 if(data->state.expect100header)
1678 } /* if(k->getheader || !data->req.no_body) */
1682 CURLcode Curl_xfer_write_resp(struct Curl_easy *data,
1688 if(data->conn->handler->write_resp) {
1690 * for writing all received download data to the client. */
1691 result = data->conn->handler->write_resp(data, buf, blen, is_eos, done);
1694 /* No special handling by protocol handler, write all received data
1702 if(blen && data->conn->handler->protocol & PROTO_FAMILY_POP3) {
1703 result = data->req.ignorebody? CURLE_OK :
1704 Curl_pop3_write(data, buf, blen);
1708 result = Curl_client_write(data, cwtype, buf, blen);
1714 data->req.eos_written = TRUE;
1715 data->req.download_done = TRUE;