lib/sendf.c

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