1 /***************************************************************************
3 * Project ___| | | | _ \| |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
8 * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.haxx.se/docs/copyright.html.
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.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
21 ***************************************************************************/
23 #include "curl_setup.h"
25 #include <curl/curl.h>
30 #include "vtls/vtls.h"
33 #include "non-ascii.h"
37 /* The last 3 #include files should be in this order */
38 #include "curl_printf.h"
39 #include "curl_memory.h"
42 #ifdef CURL_DO_LINEEND_CONV
44 * convert_lineends() changes CRLF (\r\n) end-of-line markers to a single LF
45 * (\n), with special processing for CRLF sequences that are split between two
46 * blocks of data. Remaining, bare CRs are changed to LFs. The possibly new
47 * size of the data is returned.
49 static size_t convert_lineends(struct Curl_easy *data,
50 char *startPtr, size_t size)
55 if((startPtr == NULL) || (size < 1)) {
59 if(data->state.prev_block_had_trailing_cr) {
60 /* The previous block of incoming data
61 had a trailing CR, which was turned into a LF. */
62 if(*startPtr == '\n') {
63 /* This block of incoming data starts with the
64 previous block's LF so get rid of it */
65 memmove(startPtr, startPtr+1, size-1);
67 /* and it wasn't a bare CR but a CRLF conversion instead */
68 data->state.crlf_conversions++;
70 data->state.prev_block_had_trailing_cr = FALSE; /* reset the flag */
73 /* find 1st CR, if any */
74 inPtr = outPtr = memchr(startPtr, '\r', size);
76 /* at least one CR, now look for CRLF */
77 while(inPtr < (startPtr+size-1)) {
78 /* note that it's size-1, so we'll never look past the last byte */
79 if(memcmp(inPtr, "\r\n", 2) == 0) {
80 /* CRLF found, bump past the CR and copy the NL */
83 /* keep track of how many CRLFs we converted */
84 data->state.crlf_conversions++;
88 /* lone CR, move LF instead */
92 /* not a CRLF nor a CR, just copy whatever it is */
98 } /* end of while loop */
100 if(inPtr < startPtr+size) {
101 /* handle last byte */
103 /* deal with a CR at the end of the buffer */
104 *outPtr = '\n'; /* copy a NL instead */
105 /* note that a CRLF might be split across two blocks */
106 data->state.prev_block_had_trailing_cr = TRUE;
114 if(outPtr < startPtr+size)
115 /* tidy up by null terminating the now shorter data */
118 return (outPtr - startPtr);
122 #endif /* CURL_DO_LINEEND_CONV */
124 #ifdef USE_RECV_BEFORE_SEND_WORKAROUND
125 static void pre_receive_plain(struct connectdata *conn, int num)
127 const curl_socket_t sockfd = conn->sock[num];
128 struct postponed_data * const psnd = &(conn->postponed[num]);
129 size_t bytestorecv = psnd->allocated_size - psnd->recv_size;
130 /* WinSock will destroy unread received data if send() is
132 To avoid lossage of received data, recv() must be
133 performed before every send() if any incoming data is
134 available. However, skip this, if buffer is already full. */
135 if((conn->handler->protocol&PROTO_FAMILY_HTTP) != 0 &&
136 conn->recv[num] == Curl_recv_plain &&
137 (!psnd->buffer || bytestorecv)) {
138 const int readymask = Curl_socket_check(sockfd, CURL_SOCKET_BAD,
140 if(readymask != -1 && (readymask & CURL_CSELECT_IN) != 0) {
141 /* Have some incoming data */
143 /* Use buffer double default size for intermediate buffer */
144 psnd->allocated_size = 2 * BUFSIZE;
145 psnd->buffer = malloc(psnd->allocated_size);
147 psnd->recv_processed = 0;
149 psnd->bindsock = sockfd; /* Used only for DEBUGASSERT */
150 #endif /* DEBUGBUILD */
151 bytestorecv = psnd->allocated_size;
155 DEBUGASSERT(psnd->bindsock == sockfd);
156 recvedbytes = sread(sockfd, psnd->buffer + psnd->recv_size,
159 psnd->recv_size += recvedbytes;
162 psnd->allocated_size = 0;
167 static ssize_t get_pre_recved(struct connectdata *conn, int num, char *buf,
170 struct postponed_data * const psnd = &(conn->postponed[num]);
175 DEBUGASSERT(psnd->allocated_size > 0);
176 DEBUGASSERT(psnd->recv_size <= psnd->allocated_size);
177 DEBUGASSERT(psnd->recv_processed <= psnd->recv_size);
178 /* Check and process data that already received and storied in internal
179 intermediate buffer */
180 if(psnd->recv_size > psnd->recv_processed) {
181 DEBUGASSERT(psnd->bindsock == conn->sock[num]);
182 copysize = CURLMIN(len, psnd->recv_size - psnd->recv_processed);
183 memcpy(buf, psnd->buffer + psnd->recv_processed, copysize);
184 psnd->recv_processed += copysize;
187 copysize = 0; /* buffer was allocated, but nothing was received */
189 /* Free intermediate buffer if it has no unprocessed data */
190 if(psnd->recv_processed == psnd->recv_size) {
193 psnd->allocated_size = 0;
195 psnd->recv_processed = 0;
197 psnd->bindsock = CURL_SOCKET_BAD;
198 #endif /* DEBUGBUILD */
200 return (ssize_t)copysize;
202 #else /* ! USE_RECV_BEFORE_SEND_WORKAROUND */
203 /* Use "do-nothing" macros instead of functions when workaround not used */
204 #define pre_receive_plain(c,n) do {} WHILE_FALSE
205 #define get_pre_recved(c,n,b,l) 0
206 #endif /* ! USE_RECV_BEFORE_SEND_WORKAROUND */
208 /* Curl_infof() is for info message along the way */
210 void Curl_infof(struct Curl_easy *data, const char *fmt, ...)
212 if(data && data->set.verbose) {
215 char print_buffer[2048 + 1];
217 vsnprintf(print_buffer, sizeof(print_buffer), fmt, ap);
219 len = strlen(print_buffer);
220 Curl_debug(data, CURLINFO_TEXT, print_buffer, len, NULL);
224 /* Curl_failf() is for messages stating why we failed.
225 * The message SHALL NOT include any LF or CR.
228 void Curl_failf(struct Curl_easy *data, const char *fmt, ...)
234 vsnprintf(data->state.buffer, BUFSIZE, fmt, ap);
236 if(data->set.errorbuffer && !data->state.errorbuf) {
237 snprintf(data->set.errorbuffer, CURL_ERROR_SIZE, "%s", data->state.buffer);
238 data->state.errorbuf = TRUE; /* wrote error string */
240 if(data->set.verbose) {
241 len = strlen(data->state.buffer);
242 if(len < BUFSIZE - 1) {
243 data->state.buffer[len] = '\n';
244 data->state.buffer[++len] = '\0';
246 Curl_debug(data, CURLINFO_TEXT, data->state.buffer, len, NULL);
252 /* Curl_sendf() sends formated data to the server */
253 CURLcode Curl_sendf(curl_socket_t sockfd, struct connectdata *conn,
254 const char *fmt, ...)
256 struct Curl_easy *data = conn->data;
257 ssize_t bytes_written;
259 CURLcode result = CURLE_OK;
264 s = vaprintf(fmt, ap); /* returns an allocated string */
267 return CURLE_OUT_OF_MEMORY; /* failure */
270 write_len = strlen(s);
274 /* Write the buffer to the socket */
275 result = Curl_write(conn, sockfd, sptr, write_len, &bytes_written);
280 if(data->set.verbose)
281 Curl_debug(data, CURLINFO_DATA_OUT, sptr, (size_t)bytes_written, conn);
283 if((size_t)bytes_written != write_len) {
284 /* if not all was written at once, we must advance the pointer, decrease
285 the size left and try again! */
286 write_len -= bytes_written;
287 sptr += bytes_written;
293 free(s); /* free the output string */
299 * Curl_write() is an internal write function that sends data to the
300 * server. Works with plain sockets, SCP, SSL or kerberos.
302 * If the write would block (CURLE_AGAIN), we return CURLE_OK and
303 * (*written == 0). Otherwise we return regular CURLcode value.
305 CURLcode Curl_write(struct connectdata *conn,
306 curl_socket_t sockfd,
311 ssize_t bytes_written;
312 CURLcode result = CURLE_OK;
313 int num = (sockfd == conn->sock[SECONDARYSOCKET]);
315 bytes_written = conn->send[num](conn, num, mem, len, &result);
317 *written = bytes_written;
318 if(bytes_written >= 0)
319 /* we completely ignore the curlcode value when subzero is not returned */
322 /* handle CURLE_AGAIN or a send failure */
329 /* general send failure */
330 return CURLE_SEND_ERROR;
333 /* we got a specific curlcode, forward it */
338 ssize_t Curl_send_plain(struct connectdata *conn, int num,
339 const void *mem, size_t len, CURLcode *code)
341 curl_socket_t sockfd = conn->sock[num];
342 ssize_t bytes_written;
343 /* WinSock will destroy unread received data if send() is
345 To avoid lossage of received data, recv() must be
346 performed before every send() if any incoming data is
348 pre_receive_plain(conn, num);
350 #ifdef MSG_FASTOPEN /* Linux */
351 if(conn->bits.tcp_fastopen) {
352 bytes_written = sendto(sockfd, mem, len, MSG_FASTOPEN,
353 conn->ip_addr->ai_addr, conn->ip_addr->ai_addrlen);
354 conn->bits.tcp_fastopen = FALSE;
358 bytes_written = swrite(sockfd, mem, len);
361 if(-1 == bytes_written) {
365 #ifdef WSAEWOULDBLOCK
366 /* This is how Windows does it */
367 (WSAEWOULDBLOCK == err)
369 /* errno may be EWOULDBLOCK or on some systems EAGAIN when it returned
370 due to its inability to send off data without blocking. We therefor
371 treat both error codes the same here */
372 (EWOULDBLOCK == err) || (EAGAIN == err) || (EINTR == err) ||
376 /* this is just a case of EWOULDBLOCK */
381 failf(conn->data, "Send failure: %s",
382 Curl_strerror(conn, err));
383 conn->data->state.os_errno = err;
384 *code = CURLE_SEND_ERROR;
387 return bytes_written;
391 * Curl_write_plain() is an internal write function that sends data to the
392 * server using plain sockets only. Otherwise meant to have the exact same
393 * proto as Curl_write()
395 CURLcode Curl_write_plain(struct connectdata *conn,
396 curl_socket_t sockfd,
401 ssize_t bytes_written;
403 int num = (sockfd == conn->sock[SECONDARYSOCKET]);
405 bytes_written = Curl_send_plain(conn, num, mem, len, &result);
407 *written = bytes_written;
412 ssize_t Curl_recv_plain(struct connectdata *conn, int num, char *buf,
413 size_t len, CURLcode *code)
415 curl_socket_t sockfd = conn->sock[num];
417 /* Check and return data that already received and storied in internal
418 intermediate buffer */
419 nread = get_pre_recved(conn, num, buf, len);
425 nread = sread(sockfd, buf, len);
432 #ifdef WSAEWOULDBLOCK
433 /* This is how Windows does it */
434 (WSAEWOULDBLOCK == err)
436 /* errno may be EWOULDBLOCK or on some systems EAGAIN when it returned
437 due to its inability to send off data without blocking. We therefor
438 treat both error codes the same here */
439 (EWOULDBLOCK == err) || (EAGAIN == err) || (EINTR == err)
442 /* this is just a case of EWOULDBLOCK */
446 failf(conn->data, "Recv failure: %s",
447 Curl_strerror(conn, err));
448 conn->data->state.os_errno = err;
449 *code = CURLE_RECV_ERROR;
455 static CURLcode pausewrite(struct Curl_easy *data,
456 int type, /* what type of data */
460 /* signalled to pause sending on this connection, but since we have data
461 we want to send we need to dup it to save a copy for when the sending
463 struct SingleRequest *k = &data->req;
464 char *dupl = malloc(len);
466 return CURLE_OUT_OF_MEMORY;
468 memcpy(dupl, ptr, len);
470 /* store this information in the state struct for later use */
471 data->state.tempwrite = dupl;
472 data->state.tempwritesize = len;
473 data->state.tempwritetype = type;
475 /* mark the connection as RECV paused */
476 k->keepon |= KEEP_RECV_PAUSE;
478 DEBUGF(infof(data, "Pausing with %zu bytes in buffer for type %02x\n",
485 /* Curl_client_chop_write() writes chunks of data not larger than
486 * CURL_MAX_WRITE_SIZE via client write callback(s) and
487 * takes care of pause requests from the callbacks.
489 CURLcode Curl_client_chop_write(struct connectdata *conn,
494 struct Curl_easy *data = conn->data;
495 curl_write_callback writeheader = NULL;
496 curl_write_callback writebody = NULL;
501 /* If reading is actually paused, we're forced to append this chunk of data
502 to the already held data, but only if it is the same type as otherwise it
503 can't work and it'll return error instead. */
504 if(data->req.keepon & KEEP_RECV_PAUSE) {
507 if(type != data->state.tempwritetype)
508 /* major internal confusion */
509 return CURLE_RECV_ERROR;
511 DEBUGASSERT(data->state.tempwrite);
513 /* figure out the new size of the data to save */
514 newlen = len + data->state.tempwritesize;
515 /* allocate the new memory area */
516 newptr = realloc(data->state.tempwrite, newlen);
518 return CURLE_OUT_OF_MEMORY;
519 /* copy the new data to the end of the new area */
520 memcpy(newptr + data->state.tempwritesize, ptr, len);
521 /* update the pointer and the size */
522 data->state.tempwrite = newptr;
523 data->state.tempwritesize = newlen;
527 /* Determine the callback(s) to use. */
528 if(type & CLIENTWRITE_BODY)
529 writebody = data->set.fwrite_func;
530 if((type & CLIENTWRITE_HEADER) &&
531 (data->set.fwrite_header || data->set.writeheader)) {
533 * Write headers to the same callback or to the especially setup
534 * header callback function (added after version 7.7.1).
537 data->set.fwrite_header? data->set.fwrite_header: data->set.fwrite_func;
540 /* Chop data, write chunks. */
542 size_t chunklen = len <= CURL_MAX_WRITE_SIZE? len: CURL_MAX_WRITE_SIZE;
545 size_t wrote = writebody(ptr, 1, chunklen, data->set.out);
547 if(CURL_WRITEFUNC_PAUSE == wrote) {
548 if(conn->handler->flags & PROTOPT_NONETWORK) {
549 /* Protocols that work without network cannot be paused. This is
550 actually only FILE:// just now, and it can't pause since the
551 transfer isn't done using the "normal" procedure. */
552 failf(data, "Write callback asked for PAUSE when not supported!");
553 return CURLE_WRITE_ERROR;
556 return pausewrite(data, type, ptr, len);
558 else if(wrote != chunklen) {
559 failf(data, "Failed writing body (%zu != %zu)", wrote, chunklen);
560 return CURLE_WRITE_ERROR;
565 size_t wrote = writeheader(ptr, 1, chunklen, data->set.writeheader);
567 if(CURL_WRITEFUNC_PAUSE == wrote)
568 /* here we pass in the HEADER bit only since if this was body as well
569 then it was passed already and clearly that didn't trigger the
570 pause, so this is saved for later with the HEADER bit only */
571 return pausewrite(data, CLIENTWRITE_HEADER, ptr, len);
573 if(wrote != chunklen) {
574 failf (data, "Failed writing header");
575 return CURLE_WRITE_ERROR;
587 /* Curl_client_write() sends data to the write callback(s)
589 The bit pattern defines to what "streams" to write to. Body and/or header.
590 The defines are in sendf.h of course.
592 If CURL_DO_LINEEND_CONV is enabled, data is converted IN PLACE to the
593 local character encoding. This is a problem and should be changed in
594 the future to leave the original data alone.
596 CURLcode Curl_client_write(struct connectdata *conn,
601 struct Curl_easy *data = conn->data;
606 /* FTP data may need conversion. */
607 if((type & CLIENTWRITE_BODY) &&
608 (conn->handler->protocol & PROTO_FAMILY_FTP) &&
609 conn->proto.ftpc.transfertype == 'A') {
610 /* convert from the network encoding */
611 CURLcode result = Curl_convert_from_network(data, ptr, len);
612 /* Curl_convert_from_network calls failf if unsuccessful */
616 #ifdef CURL_DO_LINEEND_CONV
617 /* convert end-of-line markers */
618 len = convert_lineends(data, ptr, len);
619 #endif /* CURL_DO_LINEEND_CONV */
622 return Curl_client_chop_write(conn, type, ptr, len);
625 CURLcode Curl_read_plain(curl_socket_t sockfd,
627 size_t bytesfromsocket,
630 ssize_t nread = sread(sockfd, buf, bytesfromsocket);
636 return_error = WSAEWOULDBLOCK == err;
638 return_error = EWOULDBLOCK == err || EAGAIN == err || EINTR == err;
643 return CURLE_RECV_ERROR;
646 /* we only return number of bytes read when we return OK */
652 * Internal read-from-socket function. This is meant to deal with plain
653 * sockets, SSL sockets and kerberos sockets.
655 * Returns a regular CURLcode value.
657 CURLcode Curl_read(struct connectdata *conn, /* connection data */
658 curl_socket_t sockfd, /* read from this socket */
659 char *buf, /* store read data here */
660 size_t sizerequested, /* max amount to read */
661 ssize_t *n) /* amount bytes read */
663 CURLcode result = CURLE_RECV_ERROR;
665 size_t bytesfromsocket = 0;
666 char *buffertofill = NULL;
668 /* if HTTP/1 pipelining is both wanted and possible */
669 bool pipelining = Curl_pipeline_wanted(conn->data->multi, CURLPIPE_HTTP1) &&
670 (conn->bundle->multiuse == BUNDLE_PIPELINING);
672 /* Set 'num' to 0 or 1, depending on which socket that has been sent here.
673 If it is the second socket, we set num to 1. Otherwise to 0. This lets
674 us use the correct ssl handle. */
675 int num = (sockfd == conn->sock[SECONDARYSOCKET]);
677 *n=0; /* reset amount to zero */
679 /* If session can pipeline, check connection buffer */
681 size_t bytestocopy = CURLMIN(conn->buf_len - conn->read_pos,
684 /* Copy from our master buffer first if we have some unread data there*/
685 if(bytestocopy > 0) {
686 memcpy(buf, conn->master_buffer + conn->read_pos, bytestocopy);
687 conn->read_pos += bytestocopy;
688 conn->bits.stream_was_rewound = FALSE;
690 *n = (ssize_t)bytestocopy;
693 /* If we come here, it means that there is no data to read from the buffer,
694 * so we read from the socket */
695 bytesfromsocket = CURLMIN(sizerequested, BUFSIZE * sizeof (char));
696 buffertofill = conn->master_buffer;
699 bytesfromsocket = CURLMIN((long)sizerequested,
700 conn->data->set.buffer_size ?
701 conn->data->set.buffer_size : BUFSIZE);
705 nread = conn->recv[num](conn, num, buffertofill, bytesfromsocket, &result);
710 memcpy(buf, conn->master_buffer, nread);
711 conn->buf_len = nread;
712 conn->read_pos = nread;
720 /* return 0 on success */
721 static int showit(struct Curl_easy *data, curl_infotype type,
722 char *ptr, size_t size)
724 static const char s_infotype[CURLINFO_END][3] = {
725 "* ", "< ", "> ", "{ ", "} ", "{ ", "} " };
727 #ifdef CURL_DOES_CONVERSIONS
729 size_t conv_size = 0;
732 case CURLINFO_HEADER_OUT:
733 /* assume output headers are ASCII */
734 /* copy the data into my buffer so the original is unchanged */
736 size = BUFSIZE; /* truncate if necessary */
740 memcpy(buf, ptr, size);
741 /* Special processing is needed for this block if it
742 * contains both headers and data (separated by CRLFCRLF).
743 * We want to convert just the headers, leaving the data as-is.
747 for(i = 0; i < size-4; i++) {
748 if(memcmp(&buf[i], "\x0d\x0a\x0d\x0a", 4) == 0) {
749 /* convert everything through this CRLFCRLF but no further */
756 Curl_convert_from_network(data, buf, conv_size);
757 /* Curl_convert_from_network calls failf if unsuccessful */
758 /* we might as well continue even if it fails... */
759 ptr = buf; /* switch pointer to use my buffer instead */
762 /* leave everything else as-is */
765 #endif /* CURL_DOES_CONVERSIONS */
768 return (*data->set.fdebug)(data, type, ptr, size,
769 data->set.debugdata);
773 case CURLINFO_HEADER_OUT:
774 case CURLINFO_HEADER_IN:
775 fwrite(s_infotype[type], 2, 1, data->set.err);
776 fwrite(ptr, size, 1, data->set.err);
777 #ifdef CURL_DOES_CONVERSIONS
778 if(size != conv_size) {
779 /* we had untranslated data so we need an explicit newline */
780 fwrite("\n", 1, 1, data->set.err);
790 int Curl_debug(struct Curl_easy *data, curl_infotype type,
791 char *ptr, size_t size,
792 struct connectdata *conn)
795 if(data->set.printhost && conn && conn->host.dispname) {
798 const char *w="Data";
800 case CURLINFO_HEADER_IN:
803 case CURLINFO_DATA_IN:
806 case CURLINFO_HEADER_OUT:
809 case CURLINFO_DATA_OUT:
817 snprintf(buffer, sizeof(buffer), "[%s %s %s]", w, t,
818 conn->host.dispname);
819 rc = showit(data, CURLINFO_TEXT, buffer, strlen(buffer));
824 rc = showit(data, type, ptr, size);