1 /*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel (at) 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 #include <curl/curl.h> 26 27 #include "urldata.h" 28 #include "sendf.h" 29 #include "connect.h" 30 #include "vtls/vtls.h" 31 #include "ssh.h" 32 #include "multiif.h" 33 #include "non-ascii.h" 34 #include "strerror.h" 35 #include "select.h" 36 37 /* The last 3 #include files should be in this order */ 38 #include "curl_printf.h" 39 #include "curl_memory.h" 40 #include "memdebug.h" 41 42 #ifdef CURL_DO_LINEEND_CONV 43 /* 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. 48 */ 49 static size_t convert_lineends(struct Curl_easy *data, 50 char *startPtr, size_t size) 51 { 52 char *inPtr, *outPtr; 53 54 /* sanity check */ 55 if((startPtr == NULL) || (size < 1)) { 56 return size; 57 } 58 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); 66 size--; 67 /* and it wasn't a bare CR but a CRLF conversion instead */ 68 data->state.crlf_conversions++; 69 } 70 data->state.prev_block_had_trailing_cr = FALSE; /* reset the flag */ 71 } 72 73 /* find 1st CR, if any */ 74 inPtr = outPtr = memchr(startPtr, '\r', size); 75 if(inPtr) { 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 */ 81 inPtr++; 82 *outPtr = *inPtr; 83 /* keep track of how many CRLFs we converted */ 84 data->state.crlf_conversions++; 85 } 86 else { 87 if(*inPtr == '\r') { 88 /* lone CR, move LF instead */ 89 *outPtr = '\n'; 90 } 91 else { 92 /* not a CRLF nor a CR, just copy whatever it is */ 93 *outPtr = *inPtr; 94 } 95 } 96 outPtr++; 97 inPtr++; 98 } /* end of while loop */ 99 100 if(inPtr < startPtr+size) { 101 /* handle last byte */ 102 if(*inPtr == '\r') { 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; 107 } 108 else { 109 /* copy last byte */ 110 *outPtr = *inPtr; 111 } 112 outPtr++; 113 } 114 if(outPtr < startPtr+size) 115 /* tidy up by null terminating the now shorter data */ 116 *outPtr = '\0'; 117 118 return (outPtr - startPtr); 119 } 120 return size; 121 } 122 #endif /* CURL_DO_LINEEND_CONV */ 123 124 #ifdef USE_RECV_BEFORE_SEND_WORKAROUND 125 static void pre_receive_plain(struct connectdata *conn, int num) 126 { 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 131 failed. 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, 139 CURL_SOCKET_BAD, 0); 140 if(readymask != -1 && (readymask & CURL_CSELECT_IN) != 0) { 141 /* Have some incoming data */ 142 if(!psnd->buffer) { 143 /* Use buffer double default size for intermediate buffer */ 144 psnd->allocated_size = 2 * BUFSIZE; 145 psnd->buffer = malloc(psnd->allocated_size); 146 psnd->recv_size = 0; 147 psnd->recv_processed = 0; 148 #ifdef DEBUGBUILD 149 psnd->bindsock = sockfd; /* Used only for DEBUGASSERT */ 150 #endif /* DEBUGBUILD */ 151 bytestorecv = psnd->allocated_size; 152 } 153 if(psnd->buffer) { 154 ssize_t recvedbytes; 155 DEBUGASSERT(psnd->bindsock == sockfd); 156 recvedbytes = sread(sockfd, psnd->buffer + psnd->recv_size, 157 bytestorecv); 158 if(recvedbytes > 0) 159 psnd->recv_size += recvedbytes; 160 } 161 else 162 psnd->allocated_size = 0; 163 } 164 } 165 } 166 167 static ssize_t get_pre_recved(struct connectdata *conn, int num, char *buf, 168 size_t len) 169 { 170 struct postponed_data * const psnd = &(conn->postponed[num]); 171 size_t copysize; 172 if(!psnd->buffer) 173 return 0; 174 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; 185 } 186 else 187 copysize = 0; /* buffer was allocated, but nothing was received */ 188 189 /* Free intermediate buffer if it has no unprocessed data */ 190 if(psnd->recv_processed == psnd->recv_size) { 191 free(psnd->buffer); 192 psnd->buffer = NULL; 193 psnd->allocated_size = 0; 194 psnd->recv_size = 0; 195 psnd->recv_processed = 0; 196 #ifdef DEBUGBUILD 197 psnd->bindsock = CURL_SOCKET_BAD; 198 #endif /* DEBUGBUILD */ 199 } 200 return (ssize_t)copysize; 201 } 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 */ 207 208 /* Curl_infof() is for info message along the way */ 209 210 void Curl_infof(struct Curl_easy *data, const char *fmt, ...) 211 { 212 if(data && data->set.verbose) { 213 va_list ap; 214 size_t len; 215 char print_buffer[2048 + 1]; 216 va_start(ap, fmt); 217 vsnprintf(print_buffer, sizeof(print_buffer), fmt, ap); 218 va_end(ap); 219 len = strlen(print_buffer); 220 Curl_debug(data, CURLINFO_TEXT, print_buffer, len, NULL); 221 } 222 } 223 224 /* Curl_failf() is for messages stating why we failed. 225 * The message SHALL NOT include any LF or CR. 226 */ 227 228 void Curl_failf(struct Curl_easy *data, const char *fmt, ...) 229 { 230 va_list ap; 231 size_t len; 232 va_start(ap, fmt); 233 234 vsnprintf(data->state.buffer, BUFSIZE, fmt, ap); 235 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 */ 239 } 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'; 245 } 246 Curl_debug(data, CURLINFO_TEXT, data->state.buffer, len, NULL); 247 } 248 249 va_end(ap); 250 } 251 252 /* Curl_sendf() sends formated data to the server */ 253 CURLcode Curl_sendf(curl_socket_t sockfd, struct connectdata *conn, 254 const char *fmt, ...) 255 { 256 struct Curl_easy *data = conn->data; 257 ssize_t bytes_written; 258 size_t write_len; 259 CURLcode result = CURLE_OK; 260 char *s; 261 char *sptr; 262 va_list ap; 263 va_start(ap, fmt); 264 s = vaprintf(fmt, ap); /* returns an allocated string */ 265 va_end(ap); 266 if(!s) 267 return CURLE_OUT_OF_MEMORY; /* failure */ 268 269 bytes_written=0; 270 write_len = strlen(s); 271 sptr = s; 272 273 for(;;) { 274 /* Write the buffer to the socket */ 275 result = Curl_write(conn, sockfd, sptr, write_len, &bytes_written); 276 277 if(result) 278 break; 279 280 if(data->set.verbose) 281 Curl_debug(data, CURLINFO_DATA_OUT, sptr, (size_t)bytes_written, conn); 282 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; 288 } 289 else 290 break; 291 } 292 293 free(s); /* free the output string */ 294 295 return result; 296 } 297 298 /* 299 * Curl_write() is an internal write function that sends data to the 300 * server. Works with plain sockets, SCP, SSL or kerberos. 301 * 302 * If the write would block (CURLE_AGAIN), we return CURLE_OK and 303 * (*written == 0). Otherwise we return regular CURLcode value. 304 */ 305 CURLcode Curl_write(struct connectdata *conn, 306 curl_socket_t sockfd, 307 const void *mem, 308 size_t len, 309 ssize_t *written) 310 { 311 ssize_t bytes_written; 312 CURLcode result = CURLE_OK; 313 int num = (sockfd == conn->sock[SECONDARYSOCKET]); 314 315 bytes_written = conn->send[num](conn, num, mem, len, &result); 316 317 *written = bytes_written; 318 if(bytes_written >= 0) 319 /* we completely ignore the curlcode value when subzero is not returned */ 320 return CURLE_OK; 321 322 /* handle CURLE_AGAIN or a send failure */ 323 switch(result) { 324 case CURLE_AGAIN: 325 *written = 0; 326 return CURLE_OK; 327 328 case CURLE_OK: 329 /* general send failure */ 330 return CURLE_SEND_ERROR; 331 332 default: 333 /* we got a specific curlcode, forward it */ 334 return result; 335 } 336 } 337 338 ssize_t Curl_send_plain(struct connectdata *conn, int num, 339 const void *mem, size_t len, CURLcode *code) 340 { 341 curl_socket_t sockfd = conn->sock[num]; 342 ssize_t bytes_written; 343 /* WinSock will destroy unread received data if send() is 344 failed. 345 To avoid lossage of received data, recv() must be 346 performed before every send() if any incoming data is 347 available. */ 348 pre_receive_plain(conn, num); 349 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; 355 } 356 else 357 #endif 358 bytes_written = swrite(sockfd, mem, len); 359 360 *code = CURLE_OK; 361 if(-1 == bytes_written) { 362 int err = SOCKERRNO; 363 364 if( 365 #ifdef WSAEWOULDBLOCK 366 /* This is how Windows does it */ 367 (WSAEWOULDBLOCK == err) 368 #else 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) || 373 (EINPROGRESS == err) 374 #endif 375 ) { 376 /* this is just a case of EWOULDBLOCK */ 377 bytes_written=0; 378 *code = CURLE_AGAIN; 379 } 380 else { 381 failf(conn->data, "Send failure: %s", 382 Curl_strerror(conn, err)); 383 conn->data->state.os_errno = err; 384 *code = CURLE_SEND_ERROR; 385 } 386 } 387 return bytes_written; 388 } 389 390 /* 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() 394 */ 395 CURLcode Curl_write_plain(struct connectdata *conn, 396 curl_socket_t sockfd, 397 const void *mem, 398 size_t len, 399 ssize_t *written) 400 { 401 ssize_t bytes_written; 402 CURLcode result; 403 int num = (sockfd == conn->sock[SECONDARYSOCKET]); 404 405 bytes_written = Curl_send_plain(conn, num, mem, len, &result); 406 407 *written = bytes_written; 408 409 return result; 410 } 411 412 ssize_t Curl_recv_plain(struct connectdata *conn, int num, char *buf, 413 size_t len, CURLcode *code) 414 { 415 curl_socket_t sockfd = conn->sock[num]; 416 ssize_t nread; 417 /* Check and return data that already received and storied in internal 418 intermediate buffer */ 419 nread = get_pre_recved(conn, num, buf, len); 420 if(nread > 0) { 421 *code = CURLE_OK; 422 return nread; 423 } 424 425 nread = sread(sockfd, buf, len); 426 427 *code = CURLE_OK; 428 if(-1 == nread) { 429 int err = SOCKERRNO; 430 431 if( 432 #ifdef WSAEWOULDBLOCK 433 /* This is how Windows does it */ 434 (WSAEWOULDBLOCK == err) 435 #else 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) 440 #endif 441 ) { 442 /* this is just a case of EWOULDBLOCK */ 443 *code = CURLE_AGAIN; 444 } 445 else { 446 failf(conn->data, "Recv failure: %s", 447 Curl_strerror(conn, err)); 448 conn->data->state.os_errno = err; 449 *code = CURLE_RECV_ERROR; 450 } 451 } 452 return nread; 453 } 454 455 static CURLcode pausewrite(struct Curl_easy *data, 456 int type, /* what type of data */ 457 const char *ptr, 458 size_t len) 459 { 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 462 is again enabled */ 463 struct SingleRequest *k = &data->req; 464 char *dupl = malloc(len); 465 if(!dupl) 466 return CURLE_OUT_OF_MEMORY; 467 468 memcpy(dupl, ptr, len); 469 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; 474 475 /* mark the connection as RECV paused */ 476 k->keepon |= KEEP_RECV_PAUSE; 477 478 DEBUGF(infof(data, "Pausing with %zu bytes in buffer for type %02x\n", 479 len, type)); 480 481 return CURLE_OK; 482 } 483 484 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. 488 */ 489 CURLcode Curl_client_chop_write(struct connectdata *conn, 490 int type, 491 char * ptr, 492 size_t len) 493 { 494 struct Curl_easy *data = conn->data; 495 curl_write_callback writeheader = NULL; 496 curl_write_callback writebody = NULL; 497 498 if(!len) 499 return CURLE_OK; 500 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) { 505 size_t newlen; 506 char *newptr; 507 if(type != data->state.tempwritetype) 508 /* major internal confusion */ 509 return CURLE_RECV_ERROR; 510 511 DEBUGASSERT(data->state.tempwrite); 512 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); 517 if(!newptr) 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; 524 return CURLE_OK; 525 } 526 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)) { 532 /* 533 * Write headers to the same callback or to the especially setup 534 * header callback function (added after version 7.7.1). 535 */ 536 writeheader = 537 data->set.fwrite_header? data->set.fwrite_header: data->set.fwrite_func; 538 } 539 540 /* Chop data, write chunks. */ 541 while(len) { 542 size_t chunklen = len <= CURL_MAX_WRITE_SIZE? len: CURL_MAX_WRITE_SIZE; 543 544 if(writebody) { 545 size_t wrote = writebody(ptr, 1, chunklen, data->set.out); 546 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; 554 } 555 else 556 return pausewrite(data, type, ptr, len); 557 } 558 else if(wrote != chunklen) { 559 failf(data, "Failed writing body (%zu != %zu)", wrote, chunklen); 560 return CURLE_WRITE_ERROR; 561 } 562 } 563 564 if(writeheader) { 565 size_t wrote = writeheader(ptr, 1, chunklen, data->set.writeheader); 566 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); 572 573 if(wrote != chunklen) { 574 failf (data, "Failed writing header"); 575 return CURLE_WRITE_ERROR; 576 } 577 } 578 579 ptr += chunklen; 580 len -= chunklen; 581 } 582 583 return CURLE_OK; 584 } 585 586 587 /* Curl_client_write() sends data to the write callback(s) 588 589 The bit pattern defines to what "streams" to write to. Body and/or header. 590 The defines are in sendf.h of course. 591 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. 595 */ 596 CURLcode Curl_client_write(struct connectdata *conn, 597 int type, 598 char *ptr, 599 size_t len) 600 { 601 struct Curl_easy *data = conn->data; 602 603 if(0 == len) 604 len = strlen(ptr); 605 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 */ 613 if(result) 614 return result; 615 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 */ 620 } 621 622 return Curl_client_chop_write(conn, type, ptr, len); 623 } 624 625 CURLcode Curl_read_plain(curl_socket_t sockfd, 626 char *buf, 627 size_t bytesfromsocket, 628 ssize_t *n) 629 { 630 ssize_t nread = sread(sockfd, buf, bytesfromsocket); 631 632 if(-1 == nread) { 633 int err = SOCKERRNO; 634 int return_error; 635 #ifdef USE_WINSOCK 636 return_error = WSAEWOULDBLOCK == err; 637 #else 638 return_error = EWOULDBLOCK == err || EAGAIN == err || EINTR == err; 639 #endif 640 if(return_error) 641 return CURLE_AGAIN; 642 else 643 return CURLE_RECV_ERROR; 644 } 645 646 /* we only return number of bytes read when we return OK */ 647 *n = nread; 648 return CURLE_OK; 649 } 650 651 /* 652 * Internal read-from-socket function. This is meant to deal with plain 653 * sockets, SSL sockets and kerberos sockets. 654 * 655 * Returns a regular CURLcode value. 656 */ 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 */ 662 { 663 CURLcode result = CURLE_RECV_ERROR; 664 ssize_t nread = 0; 665 size_t bytesfromsocket = 0; 666 char *buffertofill = NULL; 667 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); 671 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]); 676 677 *n=0; /* reset amount to zero */ 678 679 /* If session can pipeline, check connection buffer */ 680 if(pipelining) { 681 size_t bytestocopy = CURLMIN(conn->buf_len - conn->read_pos, 682 sizerequested); 683 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; 689 690 *n = (ssize_t)bytestocopy; 691 return CURLE_OK; 692 } 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; 697 } 698 else { 699 bytesfromsocket = CURLMIN((long)sizerequested, 700 conn->data->set.buffer_size ? 701 conn->data->set.buffer_size : BUFSIZE); 702 buffertofill = buf; 703 } 704 705 nread = conn->recv[num](conn, num, buffertofill, bytesfromsocket, &result); 706 if(nread < 0) 707 return result; 708 709 if(pipelining) { 710 memcpy(buf, conn->master_buffer, nread); 711 conn->buf_len = nread; 712 conn->read_pos = nread; 713 } 714 715 *n += nread; 716 717 return CURLE_OK; 718 } 719 720 /* return 0 on success */ 721 static int showit(struct Curl_easy *data, curl_infotype type, 722 char *ptr, size_t size) 723 { 724 static const char s_infotype[CURLINFO_END][3] = { 725 "* ", "< ", "> ", "{ ", "} ", "{ ", "} " }; 726 727 #ifdef CURL_DOES_CONVERSIONS 728 char buf[BUFSIZE+1]; 729 size_t conv_size = 0; 730 731 switch(type) { 732 case CURLINFO_HEADER_OUT: 733 /* assume output headers are ASCII */ 734 /* copy the data into my buffer so the original is unchanged */ 735 if(size > BUFSIZE) { 736 size = BUFSIZE; /* truncate if necessary */ 737 buf[BUFSIZE] = '\0'; 738 } 739 conv_size = size; 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. 744 */ 745 if(size > 4) { 746 size_t i; 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 */ 750 conv_size = i + 4; 751 break; 752 } 753 } 754 } 755 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 */ 760 break; 761 default: 762 /* leave everything else as-is */ 763 break; 764 } 765 #endif /* CURL_DOES_CONVERSIONS */ 766 767 if(data->set.fdebug) 768 return (*data->set.fdebug)(data, type, ptr, size, 769 data->set.debugdata); 770 771 switch(type) { 772 case CURLINFO_TEXT: 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); 781 } 782 #endif 783 break; 784 default: /* nada */ 785 break; 786 } 787 return 0; 788 } 789 790 int Curl_debug(struct Curl_easy *data, curl_infotype type, 791 char *ptr, size_t size, 792 struct connectdata *conn) 793 { 794 int rc; 795 if(data->set.printhost && conn && conn->host.dispname) { 796 char buffer[160]; 797 const char *t=NULL; 798 const char *w="Data"; 799 switch (type) { 800 case CURLINFO_HEADER_IN: 801 w = "Header"; 802 /* FALLTHROUGH */ 803 case CURLINFO_DATA_IN: 804 t = "from"; 805 break; 806 case CURLINFO_HEADER_OUT: 807 w = "Header"; 808 /* FALLTHROUGH */ 809 case CURLINFO_DATA_OUT: 810 t = "to"; 811 break; 812 default: 813 break; 814 } 815 816 if(t) { 817 snprintf(buffer, sizeof(buffer), "[%s %s %s]", w, t, 818 conn->host.dispname); 819 rc = showit(data, CURLINFO_TEXT, buffer, strlen(buffer)); 820 if(rc) 821 return rc; 822 } 823 } 824 rc = showit(data, type, ptr, size); 825 return rc; 826 } 827
