1/***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
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
12 * are also available at https://curl.haxx.se/docs/copyright.html.
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 ***************************************************************************/
22
23#include "curl_setup.h"
24
25#ifdef HAVE_NETINET_IN_H
26#include <netinet/in.h>
27#endif
28
29#ifdef HAVE_LINUX_TCP_H
30#include <linux/tcp.h>
31#endif
32
33#include <curl/curl.h>
34
35#include "urldata.h"
36#include "sendf.h"
37#include "connect.h"
38#include "vtls/vtls.h"
39#include "vssh/ssh.h"
40#include "easyif.h"
41#include "multiif.h"
42#include "non-ascii.h"
43#include "strerror.h"
44#include "select.h"
45#include "strdup.h"
46
47/* The last 3 #include files should be in this order */
48#include "curl_printf.h"
49#include "curl_memory.h"
50#include "memdebug.h"
51
52#ifdef CURL_DO_LINEEND_CONV
53/*
54 * convert_lineends() changes CRLF (\r\n) end-of-line markers to a single LF
55 * (\n), with special processing for CRLF sequences that are split between two
56 * blocks of data. Remaining, bare CRs are changed to LFs. The possibly new
57 * size of the data is returned.
58 */
59static size_t convert_lineends(struct Curl_easy *data,
60 char *startPtr, size_t size)
61{
62 char *inPtr, *outPtr;
63
64 /* sanity check */
65 if((startPtr == NULL) || (size < 1)) {
66 return size;
67 }
68
69 if(data->state.prev_block_had_trailing_cr) {
70 /* The previous block of incoming data
71 had a trailing CR, which was turned into a LF. */
72 if(*startPtr == '\n') {
73 /* This block of incoming data starts with the
74 previous block's LF so get rid of it */
75 memmove(startPtr, startPtr + 1, size-1);
76 size--;
77 /* and it wasn't a bare CR but a CRLF conversion instead */
78 data->state.crlf_conversions++;
79 }
80 data->state.prev_block_had_trailing_cr = FALSE; /* reset the flag */
81 }
82
83 /* find 1st CR, if any */
84 inPtr = outPtr = memchr(startPtr, '\r', size);
85 if(inPtr) {
86 /* at least one CR, now look for CRLF */
87 while(inPtr < (startPtr + size-1)) {
88 /* note that it's size-1, so we'll never look past the last byte */
89 if(memcmp(inPtr, "\r\n", 2) == 0) {
90 /* CRLF found, bump past the CR and copy the NL */
91 inPtr++;
92 *outPtr = *inPtr;
93 /* keep track of how many CRLFs we converted */
94 data->state.crlf_conversions++;
95 }
96 else {
97 if(*inPtr == '\r') {
98 /* lone CR, move LF instead */
99 *outPtr = '\n';
100 }
101 else {
102 /* not a CRLF nor a CR, just copy whatever it is */
103 *outPtr = *inPtr;
104 }
105 }
106 outPtr++;
107 inPtr++;
108 } /* end of while loop */
109
110 if(inPtr < startPtr + size) {
111 /* handle last byte */
112 if(*inPtr == '\r') {
113 /* deal with a CR at the end of the buffer */
114 *outPtr = '\n'; /* copy a NL instead */
115 /* note that a CRLF might be split across two blocks */
116 data->state.prev_block_had_trailing_cr = TRUE;
117 }
118 else {
119 /* copy last byte */
120 *outPtr = *inPtr;
121 }
122 outPtr++;
123 }
124 if(outPtr < startPtr + size)
125 /* tidy up by null terminating the now shorter data */
126 *outPtr = '\0';
127
128 return (outPtr - startPtr);
129 }
130 return size;
131}
132#endif /* CURL_DO_LINEEND_CONV */
133
134#ifdef USE_RECV_BEFORE_SEND_WORKAROUND
135bool Curl_recv_has_postponed_data(struct connectdata *conn, int sockindex)
136{
137 struct postponed_data * const psnd = &(conn->postponed[sockindex]);
138 return psnd->buffer && psnd->allocated_size &&
139 psnd->recv_size > psnd->recv_processed;
140}
141
142static void pre_receive_plain(struct connectdata *conn, int num)
143{
144 const curl_socket_t sockfd = conn->sock[num];
145 struct postponed_data * const psnd = &(conn->postponed[num]);
146 size_t bytestorecv = psnd->allocated_size - psnd->recv_size;
147 /* WinSock will destroy unread received data if send() is
148 failed.
149 To avoid lossage of received data, recv() must be
150 performed before every send() if any incoming data is
151 available. However, skip this, if buffer is already full. */
152 if((conn->handler->protocol&PROTO_FAMILY_HTTP) != 0 &&
153 conn->recv[num] == Curl_recv_plain &&
154 (!psnd->buffer || bytestorecv)) {
155 const int readymask = Curl_socket_check(sockfd, CURL_SOCKET_BAD,
156 CURL_SOCKET_BAD, 0);
157 if(readymask != -1 && (readymask & CURL_CSELECT_IN) != 0) {
158 /* Have some incoming data */
159 if(!psnd->buffer) {
160 /* Use buffer double default size for intermediate buffer */
161 psnd->allocated_size = 2 * conn->data->set.buffer_size;
162 psnd->buffer = malloc(psnd->allocated_size);
163 psnd->recv_size = 0;
164 psnd->recv_processed = 0;
165#ifdef DEBUGBUILD
166 psnd->bindsock = sockfd; /* Used only for DEBUGASSERT */
167#endif /* DEBUGBUILD */
168 bytestorecv = psnd->allocated_size;
169 }
170 if(psnd->buffer) {
171 ssize_t recvedbytes;
172 DEBUGASSERT(psnd->bindsock == sockfd);
173 recvedbytes = sread(sockfd, psnd->buffer + psnd->recv_size,
174 bytestorecv);
175 if(recvedbytes > 0)
176 psnd->recv_size += recvedbytes;
177 }
178 else
179 psnd->allocated_size = 0;
180 }
181 }
182}
183
184static ssize_t get_pre_recved(struct connectdata *conn, int num, char *buf,
185 size_t len)
186{
187 struct postponed_data * const psnd = &(conn->postponed[num]);
188 size_t copysize;
189 if(!psnd->buffer)
190 return 0;
191
192 DEBUGASSERT(psnd->allocated_size > 0);
193 DEBUGASSERT(psnd->recv_size <= psnd->allocated_size);
194 DEBUGASSERT(psnd->recv_processed <= psnd->recv_size);
195 /* Check and process data that already received and storied in internal
196 intermediate buffer */
197 if(psnd->recv_size > psnd->recv_processed) {
198 DEBUGASSERT(psnd->bindsock == conn->sock[num]);
199 copysize = CURLMIN(len, psnd->recv_size - psnd->recv_processed);
200 memcpy(buf, psnd->buffer + psnd->recv_processed, copysize);
201 psnd->recv_processed += copysize;
202 }
203 else
204 copysize = 0; /* buffer was allocated, but nothing was received */
205
206 /* Free intermediate buffer if it has no unprocessed data */
207 if(psnd->recv_processed == psnd->recv_size) {
208 free(psnd->buffer);
209 psnd->buffer = NULL;
210 psnd->allocated_size = 0;
211 psnd->recv_size = 0;
212 psnd->recv_processed = 0;
213#ifdef DEBUGBUILD
214 psnd->bindsock = CURL_SOCKET_BAD;
215#endif /* DEBUGBUILD */
216 }
217 return (ssize_t)copysize;
218}
219#else /* ! USE_RECV_BEFORE_SEND_WORKAROUND */
220/* Use "do-nothing" macros instead of functions when workaround not used */
221bool Curl_recv_has_postponed_data(struct connectdata *conn, int sockindex)
222{
223 (void)conn;
224 (void)sockindex;
225 return false;
226}
227#define pre_receive_plain(c,n) do {} WHILE_FALSE
228#define get_pre_recved(c,n,b,l) 0
229#endif /* ! USE_RECV_BEFORE_SEND_WORKAROUND */
230
231/* Curl_infof() is for info message along the way */
232
233void Curl_infof(struct Curl_easy *data, const char *fmt, ...)
234{
235 if(data && data->set.verbose) {
236 va_list ap;
237 size_t len;
238 char print_buffer[2048 + 1];
239 va_start(ap, fmt);
240 len = mvsnprintf(print_buffer, sizeof(print_buffer), fmt, ap);
241 /*
242 * Indicate truncation of the input by replacing the last 3 characters
243 * with "...", and transfer the newline over in case the format had one.
244 */
245 if(len >= sizeof(print_buffer)) {
246 len = strlen(fmt);
247 if(fmt[--len] == '\n')
248 msnprintf(print_buffer + (sizeof(print_buffer) - 5), 5, "...\n");
249 else
250 msnprintf(print_buffer + (sizeof(print_buffer) - 4), 4, "...");
251 }
252 va_end(ap);
253 len = strlen(print_buffer);
254 Curl_debug(data, CURLINFO_TEXT, print_buffer, len);
255 }
256}
257
258/* Curl_failf() is for messages stating why we failed.
259 * The message SHALL NOT include any LF or CR.
260 */
261
262void Curl_failf(struct Curl_easy *data, const char *fmt, ...)
263{
264 if(data->set.verbose || data->set.errorbuffer) {
265 va_list ap;
266 size_t len;
267 char error[CURL_ERROR_SIZE + 2];
268 va_start(ap, fmt);
269 mvsnprintf(error, CURL_ERROR_SIZE, fmt, ap);
270 len = strlen(error);
271
272 if(data->set.errorbuffer && !data->state.errorbuf) {
273 strcpy(data->set.errorbuffer, error);
274 data->state.errorbuf = TRUE; /* wrote error string */
275 }
276 if(data->set.verbose) {
277 error[len] = '\n';
278 error[++len] = '\0';
279 Curl_debug(data, CURLINFO_TEXT, error, len);
280 }
281 va_end(ap);
282 }
283}
284
285/* Curl_sendf() sends formatted data to the server */
286CURLcode Curl_sendf(curl_socket_t sockfd, struct connectdata *conn,
287 const char *fmt, ...)
288{
289 struct Curl_easy *data = conn->data;
290 ssize_t bytes_written;
291 size_t write_len;
292 CURLcode result = CURLE_OK;
293 char *s;
294 char *sptr;
295 va_list ap;
296 va_start(ap, fmt);
297 s = vaprintf(fmt, ap); /* returns an allocated string */
298 va_end(ap);
299 if(!s)
300 return CURLE_OUT_OF_MEMORY; /* failure */
301
302 bytes_written = 0;
303 write_len = strlen(s);
304 sptr = s;
305
306 for(;;) {
307 /* Write the buffer to the socket */
308 result = Curl_write(conn, sockfd, sptr, write_len, &bytes_written);
309
310 if(result)
311 break;
312
313 if(data->set.verbose)
314 Curl_debug(data, CURLINFO_DATA_OUT, sptr, (size_t)bytes_written);
315
316 if((size_t)bytes_written != write_len) {
317 /* if not all was written at once, we must advance the pointer, decrease
318 the size left and try again! */
319 write_len -= bytes_written;
320 sptr += bytes_written;
321 }
322 else
323 break;
324 }
325
326 free(s); /* free the output string */
327
328 return result;
329}
330
331/*
332 * Curl_write() is an internal write function that sends data to the
333 * server. Works with plain sockets, SCP, SSL or kerberos.
334 *
335 * If the write would block (CURLE_AGAIN), we return CURLE_OK and
336 * (*written == 0). Otherwise we return regular CURLcode value.
337 */
338CURLcode Curl_write(struct connectdata *conn,
339 curl_socket_t sockfd,
340 const void *mem,
341 size_t len,
342 ssize_t *written)
343{
344 ssize_t bytes_written;
345 CURLcode result = CURLE_OK;
346 int num = (sockfd == conn->sock[SECONDARYSOCKET]);
347
348 bytes_written = conn->send[num](conn, num, mem, len, &result);
349
350 *written = bytes_written;
351 if(bytes_written >= 0)
352 /* we completely ignore the curlcode value when subzero is not returned */
353 return CURLE_OK;
354
355 /* handle CURLE_AGAIN or a send failure */
356 switch(result) {
357 case CURLE_AGAIN:
358 *written = 0;
359 return CURLE_OK;
360
361 case CURLE_OK:
362 /* general send failure */
363 return CURLE_SEND_ERROR;
364
365 default:
366 /* we got a specific curlcode, forward it */
367 return result;
368 }
369}
370
371ssize_t Curl_send_plain(struct connectdata *conn, int num,
372 const void *mem, size_t len, CURLcode *code)
373{
374 curl_socket_t sockfd = conn->sock[num];
375 ssize_t bytes_written;
376 /* WinSock will destroy unread received data if send() is
377 failed.
378 To avoid lossage of received data, recv() must be
379 performed before every send() if any incoming data is
380 available. */
381 pre_receive_plain(conn, num);
382
383#if defined(MSG_FASTOPEN) && !defined(TCP_FASTOPEN_CONNECT) /* Linux */
384 if(conn->bits.tcp_fastopen) {
385 bytes_written = sendto(sockfd, mem, len, MSG_FASTOPEN,
386 conn->ip_addr->ai_addr, conn->ip_addr->ai_addrlen);
387 conn->bits.tcp_fastopen = FALSE;
388 }
389 else
390#endif
391 bytes_written = swrite(sockfd, mem, len);
392
393 *code = CURLE_OK;
394 if(-1 == bytes_written) {
395 int err = SOCKERRNO;
396
397 if(
398#ifdef WSAEWOULDBLOCK
399 /* This is how Windows does it */
400 (WSAEWOULDBLOCK == err)
401#else
402 /* errno may be EWOULDBLOCK or on some systems EAGAIN when it returned
403 due to its inability to send off data without blocking. We therefore
404 treat both error codes the same here */
405 (EWOULDBLOCK == err) || (EAGAIN == err) || (EINTR == err) ||
406 (EINPROGRESS == err)
407#endif
408 ) {
409 /* this is just a case of EWOULDBLOCK */
410 bytes_written = 0;
411 *code = CURLE_AGAIN;
412 }
413 else {
414 char buffer[STRERROR_LEN];
415 failf(conn->data, "Send failure: %s",
416 Curl_strerror(err, buffer, sizeof(buffer)));
417 conn->data->state.os_errno = err;
418 *code = CURLE_SEND_ERROR;
419 }
420 }
421 return bytes_written;
422}
423
424/*
425 * Curl_write_plain() is an internal write function that sends data to the
426 * server using plain sockets only. Otherwise meant to have the exact same
427 * proto as Curl_write()
428 */
429CURLcode Curl_write_plain(struct connectdata *conn,
430 curl_socket_t sockfd,
431 const void *mem,
432 size_t len,
433 ssize_t *written)
434{
435 ssize_t bytes_written;
436 CURLcode result;
437 int num = (sockfd == conn->sock[SECONDARYSOCKET]);
438
439 bytes_written = Curl_send_plain(conn, num, mem, len, &result);
440
441 *written = bytes_written;
442
443 return result;
444}
445
446ssize_t Curl_recv_plain(struct connectdata *conn, int num, char *buf,
447 size_t len, CURLcode *code)
448{
449 curl_socket_t sockfd = conn->sock[num];
450 ssize_t nread;
451 /* Check and return data that already received and storied in internal
452 intermediate buffer */
453 nread = get_pre_recved(conn, num, buf, len);
454 if(nread > 0) {
455 *code = CURLE_OK;
456 return nread;
457 }
458
459 nread = sread(sockfd, buf, len);
460
461 *code = CURLE_OK;
462 if(-1 == nread) {
463 int err = SOCKERRNO;
464
465 if(
466#ifdef WSAEWOULDBLOCK
467 /* This is how Windows does it */
468 (WSAEWOULDBLOCK == err)
469#else
470 /* errno may be EWOULDBLOCK or on some systems EAGAIN when it returned
471 due to its inability to send off data without blocking. We therefore
472 treat both error codes the same here */
473 (EWOULDBLOCK == err) || (EAGAIN == err) || (EINTR == err)
474#endif
475 ) {
476 /* this is just a case of EWOULDBLOCK */
477 *code = CURLE_AGAIN;
478 }
479 else {
480 char buffer[STRERROR_LEN];
481 failf(conn->data, "Recv failure: %s",
482 Curl_strerror(err, buffer, sizeof(buffer)));
483 conn->data->state.os_errno = err;
484 *code = CURLE_RECV_ERROR;
485 }
486 }
487 return nread;
488}
489
490static CURLcode pausewrite(struct Curl_easy *data,
491 int type, /* what type of data */
492 const char *ptr,
493 size_t len)
494{
495 /* signalled to pause sending on this connection, but since we have data
496 we want to send we need to dup it to save a copy for when the sending
497 is again enabled */
498 struct SingleRequest *k = &data->req;
499 struct UrlState *s = &data->state;
500 char *dupl;
501 unsigned int i;
502 bool newtype = TRUE;
503
504 if(s->tempcount) {
505 for(i = 0; i< s->tempcount; i++) {
506 if(s->tempwrite[i].type == type) {
507 /* data for this type exists */
508 newtype = FALSE;
509 break;
510 }
511 }
512 DEBUGASSERT(i < 3);
513 }
514 else
515 i = 0;
516
517 if(!newtype) {
518 /* append new data to old data */
519
520 /* figure out the new size of the data to save */
521 size_t newlen = len + s->tempwrite[i].len;
522 /* allocate the new memory area */
523 char *newptr = realloc(s->tempwrite[i].buf, newlen);
524 if(!newptr)
525 return CURLE_OUT_OF_MEMORY;
526 /* copy the new data to the end of the new area */
527 memcpy(newptr + s->tempwrite[i].len, ptr, len);
528
529 /* update the pointer and the size */
530 s->tempwrite[i].buf = newptr;
531 s->tempwrite[i].len = newlen;
532 }
533 else {
534 dupl = Curl_memdup(ptr, len);
535 if(!dupl)
536 return CURLE_OUT_OF_MEMORY;
537
538 /* store this information in the state struct for later use */
539 s->tempwrite[i].buf = dupl;
540 s->tempwrite[i].len = len;
541 s->tempwrite[i].type = type;
542
543 if(newtype)
544 s->tempcount++;
545 }
546
547 /* mark the connection as RECV paused */
548 k->keepon |= KEEP_RECV_PAUSE;
549
550 DEBUGF(infof(data, "Paused %zu bytes in buffer for type %02x\n",
551 len, type));
552
553 return CURLE_OK;
554}
555
556
557/* chop_write() writes chunks of data not larger than CURL_MAX_WRITE_SIZE via
558 * client write callback(s) and takes care of pause requests from the
559 * callbacks.
560 */
561static CURLcode chop_write(struct connectdata *conn,
562 int type,
563 char *optr,
564 size_t olen)
565{
566 struct Curl_easy *data = conn->data;
567 curl_write_callback writeheader = NULL;
568 curl_write_callback writebody = NULL;
569 char *ptr = optr;
570 size_t len = olen;
571
572 if(!len)
573 return CURLE_OK;
574
575 /* If reading is paused, append this data to the already held data for this
576 type. */
577 if(data->req.keepon & KEEP_RECV_PAUSE)
578 return pausewrite(data, type, ptr, len);
579
580 /* Determine the callback(s) to use. */
581 if(type & CLIENTWRITE_BODY)
582 writebody = data->set.fwrite_func;
583 if((type & CLIENTWRITE_HEADER) &&
584 (data->set.fwrite_header || data->set.writeheader)) {
585 /*
586 * Write headers to the same callback or to the especially setup
587 * header callback function (added after version 7.7.1).
588 */
589 writeheader =
590 data->set.fwrite_header? data->set.fwrite_header: data->set.fwrite_func;
591 }
592
593 /* Chop data, write chunks. */
594 while(len) {
595 size_t chunklen = len <= CURL_MAX_WRITE_SIZE? len: CURL_MAX_WRITE_SIZE;
596
597 if(writebody) {
598 size_t wrote;
599 Curl_set_in_callback(data, true);
600 wrote = writebody(ptr, 1, chunklen, data->set.out);
601 Curl_set_in_callback(data, false);
602
603 if(CURL_WRITEFUNC_PAUSE == wrote) {
604 if(conn->handler->flags & PROTOPT_NONETWORK) {
605 /* Protocols that work without network cannot be paused. This is
606 actually only FILE:// just now, and it can't pause since the
607 transfer isn't done using the "normal" procedure. */
608 failf(data, "Write callback asked for PAUSE when not supported!");
609 return CURLE_WRITE_ERROR;
610 }
611 return pausewrite(data, type, ptr, len);
612 }
613 if(wrote != chunklen) {
614 failf(data, "Failed writing body (%zu != %zu)", wrote, chunklen);
615 return CURLE_WRITE_ERROR;
616 }
617 }
618
619 ptr += chunklen;
620 len -= chunklen;
621 }
622
623 if(writeheader) {
624 size_t wrote;
625 ptr = optr;
626 len = olen;
627 Curl_set_in_callback(data, true);
628 wrote = writeheader(ptr, 1, len, data->set.writeheader);
629 Curl_set_in_callback(data, false);
630
631 if(CURL_WRITEFUNC_PAUSE == wrote)
632 /* here we pass in the HEADER bit only since if this was body as well
633 then it was passed already and clearly that didn't trigger the
634 pause, so this is saved for later with the HEADER bit only */
635 return pausewrite(data, CLIENTWRITE_HEADER, ptr, len);
636
637 if(wrote != len) {
638 failf(data, "Failed writing header");
639 return CURLE_WRITE_ERROR;
640 }
641 }
642
643 return CURLE_OK;
644}
645
646
647/* Curl_client_write() sends data to the write callback(s)
648
649 The bit pattern defines to what "streams" to write to. Body and/or header.
650 The defines are in sendf.h of course.
651
652 If CURL_DO_LINEEND_CONV is enabled, data is converted IN PLACE to the
653 local character encoding. This is a problem and should be changed in
654 the future to leave the original data alone.
655 */
656CURLcode Curl_client_write(struct connectdata *conn,
657 int type,
658 char *ptr,
659 size_t len)
660{
661 struct Curl_easy *data = conn->data;
662
663 if(0 == len)
664 len = strlen(ptr);
665
666 DEBUGASSERT(type <= 3);
667
668 /* FTP data may need conversion. */
669 if((type & CLIENTWRITE_BODY) &&
670 (conn->handler->protocol & PROTO_FAMILY_FTP) &&
671 conn->proto.ftpc.transfertype == 'A') {
672 /* convert from the network encoding */
673 CURLcode result = Curl_convert_from_network(data, ptr, len);
674 /* Curl_convert_from_network calls failf if unsuccessful */
675 if(result)
676 return result;
677
678#ifdef CURL_DO_LINEEND_CONV
679 /* convert end-of-line markers */
680 len = convert_lineends(data, ptr, len);
681#endif /* CURL_DO_LINEEND_CONV */
682 }
683
684 return chop_write(conn, type, ptr, len);
685}
686
687CURLcode Curl_read_plain(curl_socket_t sockfd,
688 char *buf,
689 size_t bytesfromsocket,
690 ssize_t *n)
691{
692 ssize_t nread = sread(sockfd, buf, bytesfromsocket);
693
694 if(-1 == nread) {
695 int err = SOCKERRNO;
696 int return_error;
697#ifdef USE_WINSOCK
698 return_error = WSAEWOULDBLOCK == err;
699#else
700 return_error = EWOULDBLOCK == err || EAGAIN == err || EINTR == err;
701#endif
702 if(return_error)
703 return CURLE_AGAIN;
704 return CURLE_RECV_ERROR;
705 }
706
707 /* we only return number of bytes read when we return OK */
708 *n = nread;
709 return CURLE_OK;
710}
711
712/*
713 * Internal read-from-socket function. This is meant to deal with plain
714 * sockets, SSL sockets and kerberos sockets.
715 *
716 * Returns a regular CURLcode value.
717 */
718CURLcode Curl_read(struct connectdata *conn, /* connection data */
719 curl_socket_t sockfd, /* read from this socket */
720 char *buf, /* store read data here */
721 size_t sizerequested, /* max amount to read */
722 ssize_t *n) /* amount bytes read */
723{
724 CURLcode result = CURLE_RECV_ERROR;
725 ssize_t nread = 0;
726 size_t bytesfromsocket = 0;
727 char *buffertofill = NULL;
728 struct Curl_easy *data = conn->data;
729
730 /* Set 'num' to 0 or 1, depending on which socket that has been sent here.
731 If it is the second socket, we set num to 1. Otherwise to 0. This lets
732 us use the correct ssl handle. */
733 int num = (sockfd == conn->sock[SECONDARYSOCKET]);
734
735 *n = 0; /* reset amount to zero */
736
737 bytesfromsocket = CURLMIN(sizerequested, (size_t)data->set.buffer_size);
738 buffertofill = buf;
739
740 nread = conn->recv[num](conn, num, buffertofill, bytesfromsocket, &result);
741 if(nread < 0)
742 return result;
743
744 *n += nread;
745
746 return CURLE_OK;
747}
748
749/* return 0 on success */
750int Curl_debug(struct Curl_easy *data, curl_infotype type,
751 char *ptr, size_t size)
752{
753 static const char s_infotype[CURLINFO_END][3] = {
754 "* ", "< ", "> ", "{ ", "} ", "{ ", "} " };
755 int rc = 0;
756
757#ifdef CURL_DOES_CONVERSIONS
758 char *buf = NULL;
759 size_t conv_size = 0;
760
761 switch(type) {
762 case CURLINFO_HEADER_OUT:
763 buf = Curl_memdup(ptr, size);
764 if(!buf)
765 return 1;
766 conv_size = size;
767
768 /* Special processing is needed for this block if it
769 * contains both headers and data (separated by CRLFCRLF).
770 * We want to convert just the headers, leaving the data as-is.
771 */
772 if(size > 4) {
773 size_t i;
774 for(i = 0; i < size-4; i++) {
775 if(memcmp(&buf[i], "\x0d\x0a\x0d\x0a", 4) == 0) {
776 /* convert everything through this CRLFCRLF but no further */
777 conv_size = i + 4;
778 break;
779 }
780 }
781 }
782
783 Curl_convert_from_network(data, buf, conv_size);
784 /* Curl_convert_from_network calls failf if unsuccessful */
785 /* we might as well continue even if it fails... */
786 ptr = buf; /* switch pointer to use my buffer instead */
787 break;
788 default:
789 /* leave everything else as-is */
790 break;
791 }
792#endif /* CURL_DOES_CONVERSIONS */
793
794 if(data->set.fdebug) {
795 Curl_set_in_callback(data, true);
796 rc = (*data->set.fdebug)(data, type, ptr, size, data->set.debugdata);
797 Curl_set_in_callback(data, false);
798 }
799 else {
800 switch(type) {
801 case CURLINFO_TEXT:
802 case CURLINFO_HEADER_OUT:
803 case CURLINFO_HEADER_IN:
804 fwrite(s_infotype[type], 2, 1, data->set.err);
805 fwrite(ptr, size, 1, data->set.err);
806#ifdef CURL_DOES_CONVERSIONS
807 if(size != conv_size) {
808 /* we had untranslated data so we need an explicit newline */
809 fwrite("\n", 1, 1, data->set.err);
810 }
811#endif
812 break;
813 default: /* nada */
814 break;
815 }
816 }
817#ifdef CURL_DOES_CONVERSIONS
818 free(buf);
819#endif
820 return rc;
821}
822