luna - curl/lib/sendf.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) 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.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 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "curl_setup.h"
  25
  26#ifdef HAVE_NETINET_IN_H
  27#include <netinet/in.h>
  28#endif
  29
  30#ifdef HAVE_LINUX_TCP_H
  31#include <linux/tcp.h>
  32#elif defined(HAVE_NETINET_TCP_H)
  33#include <netinet/tcp.h>
  34#endif
  35
  36#include "urldata.h"
  37#include "sendf.h"
  38#include "curl_trc.h"
  39#include "transfer.h"
  40#include "cfilters.h"
  41#include "connect.h"
  42#include "cw-out.h"
  43#include "cw-pause.h"
  44#include "multiif.h"
  45#include "progress.h"
  46
  47static void cl_reset_writer(struct Curl_easy *data)
  48{
  49  struct Curl_cwriter *writer = data->req.writer_stack;
  50  while(writer) {
  51    data->req.writer_stack = writer->next;
  52    writer->cwt->do_close(data, writer);
  53    curlx_free(writer);
  54    writer = data->req.writer_stack;
  55  }
  56}
  57
  58static void cl_reset_reader(struct Curl_easy *data)
  59{
  60  struct Curl_creader *reader = data->req.reader_stack;
  61  data->req.reader_started = FALSE;
  62  while(reader) {
  63    data->req.reader_stack = reader->next;
  64    reader->crt->do_close(data, reader);
  65    curlx_free(reader);
  66    reader = data->req.reader_stack;
  67  }
  68}
  69
  70void Curl_client_cleanup(struct Curl_easy *data)
  71{
  72  cl_reset_reader(data);
  73  cl_reset_writer(data);
  74
  75  data->req.bytecount = 0;
  76  data->req.headerline = 0;
  77}
  78
  79void Curl_client_reset(struct Curl_easy *data)
  80{
  81  if(data->req.rewind_read) {
  82    /* already requested */
  83    CURL_TRC_READ(data, "client_reset, will rewind reader");
  84  }
  85  else {
  86    CURL_TRC_READ(data, "client_reset, clear readers");
  87    cl_reset_reader(data);
  88  }
  89  cl_reset_writer(data);
  90
  91  data->req.bytecount = 0;
  92  data->req.headerline = 0;
  93}
  94
  95CURLcode Curl_client_start(struct Curl_easy *data)
  96{
  97  if(data->req.rewind_read) {
  98    struct Curl_creader *r = data->req.reader_stack;
  99    CURLcode result = CURLE_OK;
 100
 101    CURL_TRC_READ(data, "client start, rewind readers");
 102    while(r) {
 103      result = r->crt->cntrl(data, r, CURL_CRCNTRL_REWIND);
 104      if(result) {
 105        failf(data, "rewind of client reader '%s' failed: %d",
 106              r->crt->name, result);
 107        return result;
 108      }
 109      r = r->next;
 110    }
 111    data->req.rewind_read = FALSE;
 112    cl_reset_reader(data);
 113  }
 114  return CURLE_OK;
 115}
 116
 117bool Curl_creader_will_rewind(struct Curl_easy *data)
 118{
 119  return (bool)data->req.rewind_read;
 120}
 121
 122void Curl_creader_set_rewind(struct Curl_easy *data, bool enable)
 123{
 124  data->req.rewind_read = !!enable;
 125}
 126
 127/* Write data using an unencoding writer stack. */
 128CURLcode Curl_cwriter_write(struct Curl_easy *data,
 129                            struct Curl_cwriter *writer, int type,
 130                            const char *buf, size_t nbytes)
 131{
 132  if(!writer)
 133    return CURLE_WRITE_ERROR;
 134  return writer->cwt->do_write(data, writer, type, buf, nbytes);
 135}
 136
 137CURLcode Curl_cwriter_def_init(struct Curl_easy *data,
 138                               struct Curl_cwriter *writer)
 139{
 140  (void)data;
 141  (void)writer;
 142  return CURLE_OK;
 143}
 144
 145CURLcode Curl_cwriter_def_write(struct Curl_easy *data,
 146                                struct Curl_cwriter *writer, int type,
 147                                const char *buf, size_t nbytes)
 148{
 149  return Curl_cwriter_write(data, writer->next, type, buf, nbytes);
 150}
 151
 152void Curl_cwriter_def_close(struct Curl_easy *data,
 153                            struct Curl_cwriter *writer)
 154{
 155  (void)data;
 156  (void)writer;
 157}
 158
 159static size_t get_max_body_write_len(struct Curl_easy *data, curl_off_t limit)
 160{
 161  if(limit != -1) {
 162    /* How much more are we allowed to write? */
 163    return curlx_sotouz_range(limit - data->req.bytecount, 0, SIZE_MAX);
 164  }
 165  return SIZE_MAX;
 166}
 167
 168struct cw_download_ctx {
 169  struct Curl_cwriter super;
 170  BIT(started_response);
 171  BIT(started_body);
 172};
 173
 174/* Download client writer in phase CURL_CW_PROTOCOL that
 175 * sees the "real" download body data. */
 176static CURLcode cw_download_write(struct Curl_easy *data,
 177                                  struct Curl_cwriter *writer, int type,
 178                                  const char *buf, size_t nbytes)
 179{
 180  struct cw_download_ctx *ctx = writer->ctx;
 181  CURLcode result;
 182  size_t nwrite, excess_len = 0;
 183  bool is_connect = !!(type & CLIENTWRITE_CONNECT);
 184
 185  if(!ctx->started_response &&
 186     !(type & (CLIENTWRITE_INFO | CLIENTWRITE_CONNECT))) {
 187    Curl_pgrsTime(data, TIMER_STARTTRANSFER);
 188    ctx->started_response = TRUE;
 189  }
 190
 191  if(!(type & CLIENTWRITE_BODY)) {
 192    if(is_connect && data->set.suppress_connect_headers)
 193      return CURLE_OK;
 194    result = Curl_cwriter_write(data, writer->next, type, buf, nbytes);
 195    CURL_TRC_WRITE(data, "download_write header(type=%x, blen=%zu) -> %d",
 196                   type, nbytes, result);
 197    return result;
 198  }
 199
 200  if(!ctx->started_body &&
 201     !(type & (CLIENTWRITE_INFO | CLIENTWRITE_CONNECT))) {
 202    Curl_rlimit_start(&data->progress.dl.rlimit, Curl_pgrs_now(data),
 203                      data->req.size);
 204    ctx->started_body = TRUE;
 205  }
 206
 207  /* Here, we deal with REAL BODY bytes. All filtering and transfer
 208   * encodings have been applied and only the true content, e.g. BODY,
 209   * bytes are passed here.
 210   * This allows us to check sizes, update stats, etc. independent
 211   * from the protocol in play. */
 212
 213  if(data->req.no_body && nbytes > 0) {
 214    /* BODY arrives although we want none, bail out */
 215    streamclose(data->conn, "ignoring body");
 216    CURL_TRC_WRITE(data, "download_write body(type=%x, blen=%zu), "
 217                   "did not want a BODY", type, nbytes);
 218    data->req.download_done = TRUE;
 219    if(data->info.header_size)
 220      /* if headers have been received, this is fine */
 221      return CURLE_OK;
 222    return CURLE_WEIRD_SERVER_REPLY;
 223  }
 224
 225  /* Determine if we see any bytes in excess to what is allowed.
 226   * We write the allowed bytes and handle excess further below.
 227   * This gives deterministic BODY writes on varying buffer receive
 228   * lengths. */
 229  nwrite = nbytes;
 230  if(data->req.maxdownload != -1) {
 231    size_t wmax = get_max_body_write_len(data, data->req.maxdownload);
 232    if(nwrite > wmax) {
 233      excess_len = nbytes - wmax;
 234      nwrite = wmax;
 235    }
 236
 237    if(nwrite == wmax) {
 238      data->req.download_done = TRUE;
 239    }
 240
 241    if((type & CLIENTWRITE_EOS) && !data->req.no_body &&
 242       (data->req.size > data->req.bytecount)) {
 243      failf(data, "end of response with %" FMT_OFF_T " bytes missing",
 244            data->req.size - data->req.bytecount);
 245      return CURLE_PARTIAL_FILE;
 246    }
 247  }
 248
 249  /* Error on too large filesize is handled below, after writing
 250   * the permitted bytes */
 251  if(data->set.max_filesize && !data->req.ignorebody) {
 252    size_t wmax = get_max_body_write_len(data, data->set.max_filesize);
 253    if(nwrite > wmax) {
 254      nwrite = wmax;
 255    }
 256  }
 257
 258  if(!data->req.ignorebody && (nwrite || (type & CLIENTWRITE_EOS))) {
 259    result = Curl_cwriter_write(data, writer->next, type, buf, nwrite);
 260    CURL_TRC_WRITE(data, "download_write body(type=%x, blen=%zu) -> %d",
 261                   type, nbytes, result);
 262    if(result)
 263      return result;
 264  }
 265
 266  /* Update stats, write and report progress */
 267  if(nwrite) {
 268    data->req.bytecount += nwrite;
 269    Curl_pgrs_download_inc(data, nwrite);
 270  }
 271
 272  if(excess_len) {
 273    if(!data->req.ignorebody) {
 274      infof(data,
 275            "Excess found writing body:"
 276            " excess = %zu"
 277            ", size = %" FMT_OFF_T
 278            ", maxdownload = %" FMT_OFF_T
 279            ", bytecount = %" FMT_OFF_T,
 280            excess_len, data->req.size, data->req.maxdownload,
 281            data->req.bytecount);
 282      connclose(data->conn, "excess found in a read");
 283    }
 284  }
 285  else if((nwrite < nbytes) && !data->req.ignorebody) {
 286    failf(data, "Exceeded the maximum allowed file size "
 287          "(%" FMT_OFF_T ") with %" FMT_OFF_T " bytes",
 288          data->set.max_filesize, data->req.bytecount);
 289    return CURLE_FILESIZE_EXCEEDED;
 290  }
 291
 292  return CURLE_OK;
 293}
 294
 295static const struct Curl_cwtype cw_download = {
 296  "protocol",
 297  NULL,
 298  Curl_cwriter_def_init,
 299  cw_download_write,
 300  Curl_cwriter_def_close,
 301  sizeof(struct cw_download_ctx)
 302};
 303
 304/* RAW client writer in phase CURL_CW_RAW that
 305 * enabled tracing of raw data. */
 306static CURLcode cw_raw_write(struct Curl_easy *data,
 307                             struct Curl_cwriter *writer, int type,
 308                             const char *buf, size_t nbytes)
 309{
 310  if(type & CLIENTWRITE_BODY && data->set.verbose && !data->req.ignorebody) {
 311    Curl_debug(data, CURLINFO_DATA_IN, buf, nbytes);
 312  }
 313  return Curl_cwriter_write(data, writer->next, type, buf, nbytes);
 314}
 315
 316static const struct Curl_cwtype cw_raw = {
 317  "raw",
 318  NULL,
 319  Curl_cwriter_def_init,
 320  cw_raw_write,
 321  Curl_cwriter_def_close,
 322  sizeof(struct Curl_cwriter)
 323};
 324
 325static CURLcode do_init_writer_stack(struct Curl_easy *data)
 326{
 327  struct Curl_cwriter *writer;
 328  CURLcode result;
 329
 330  DEBUGASSERT(!data->req.writer_stack);
 331  result = Curl_cwriter_create(&data->req.writer_stack,
 332                               data, &Curl_cwt_out, CURL_CW_CLIENT);
 333  if(result)
 334    return result;
 335
 336  /* This places the "pause" writer behind the "download" writer that
 337   * is added below. Meaning the "download" can do checks on content length
 338   * and other things *before* write outs are buffered for paused transfers. */
 339  result = Curl_cwriter_create(&writer, data, &Curl_cwt_pause,
 340                               CURL_CW_PROTOCOL);
 341  if(!result) {
 342    result = Curl_cwriter_add(data, writer);
 343    if(result)
 344      Curl_cwriter_free(data, writer);
 345  }
 346  if(result)
 347    return result;
 348
 349  result = Curl_cwriter_create(&writer, data, &cw_download, CURL_CW_PROTOCOL);
 350  if(!result) {
 351    result = Curl_cwriter_add(data, writer);
 352    if(result)
 353      Curl_cwriter_free(data, writer);
 354  }
 355  if(result)
 356    return result;
 357
 358  result = Curl_cwriter_create(&writer, data, &cw_raw, CURL_CW_RAW);
 359  if(!result) {
 360    result = Curl_cwriter_add(data, writer);
 361    if(result)
 362      Curl_cwriter_free(data, writer);
 363  }
 364  if(result)
 365    return result;
 366
 367  return result;
 368}
 369
 370/* Curl_client_write() sends data to the write callback(s)
 371
 372   The bit pattern defines to what "streams" to write to. Body and/or header.
 373   The defines are in sendf.h of course.
 374 */
 375CURLcode Curl_client_write(struct Curl_easy *data, int type, const char *buf,
 376                           size_t len)
 377{
 378  CURLcode result;
 379
 380  /* it is one of those, at least */
 381  DEBUGASSERT(type &
 382              (CLIENTWRITE_BODY | CLIENTWRITE_HEADER | CLIENTWRITE_INFO));
 383  /* BODY is only BODY (with optional EOS) */
 384  DEBUGASSERT(!(type & CLIENTWRITE_BODY) ||
 385              ((type & ~(CLIENTWRITE_BODY | CLIENTWRITE_EOS)) == 0));
 386  /* INFO is only INFO (with optional EOS) */
 387  DEBUGASSERT(!(type & CLIENTWRITE_INFO) ||
 388              ((type & ~(CLIENTWRITE_INFO | CLIENTWRITE_EOS)) == 0));
 389
 390  if(!data->req.writer_stack) {
 391    result = do_init_writer_stack(data);
 392    if(result)
 393      return result;
 394    DEBUGASSERT(data->req.writer_stack);
 395  }
 396
 397  result = Curl_cwriter_write(data, data->req.writer_stack, type, buf, len);
 398  CURL_TRC_WRITE(data, "client_write(type=%x, len=%zu) -> %d",
 399                 type, len, result);
 400  return result;
 401}
 402
 403/* Create an unencoding writer stage using the given handler. */
 404CURLcode Curl_cwriter_create(struct Curl_cwriter **pwriter,
 405                             struct Curl_easy *data,
 406                             const struct Curl_cwtype *cwt,
 407                             Curl_cwriter_phase phase)
 408{
 409  struct Curl_cwriter *writer = NULL;
 410  CURLcode result = CURLE_OUT_OF_MEMORY;
 411  void *p;
 412
 413  DEBUGASSERT(cwt->cwriter_size >= sizeof(struct Curl_cwriter));
 414  p = curlx_calloc(1, cwt->cwriter_size);
 415  if(!p)
 416    goto out;
 417
 418  writer = (struct Curl_cwriter *)p;
 419  writer->cwt = cwt;
 420  writer->ctx = p;
 421  writer->phase = phase;
 422  result = cwt->do_init(data, writer);
 423
 424out:
 425  *pwriter = result ? NULL : writer;
 426  if(result)
 427    curlx_free(writer);
 428  return result;
 429}
 430
 431void Curl_cwriter_free(struct Curl_easy *data,
 432                       struct Curl_cwriter *writer)
 433{
 434  if(writer) {
 435    writer->cwt->do_close(data, writer);
 436    curlx_free(writer);
 437  }
 438}
 439
 440size_t Curl_cwriter_count(struct Curl_easy *data, Curl_cwriter_phase phase)
 441{
 442  struct Curl_cwriter *w;
 443  size_t n = 0;
 444
 445  for(w = data->req.writer_stack; w; w = w->next) {
 446    if(w->phase == phase)
 447      ++n;
 448  }
 449  return n;
 450}
 451
 452CURLcode Curl_cwriter_add(struct Curl_easy *data,
 453                          struct Curl_cwriter *writer)
 454{
 455  CURLcode result;
 456  struct Curl_cwriter **anchor = &data->req.writer_stack;
 457
 458  if(!*anchor) {
 459    result = do_init_writer_stack(data);
 460    if(result)
 461      return result;
 462  }
 463
 464  /* Insert the writer as first in its phase.
 465   * Skip existing writers of lower phases. */
 466  while(*anchor && (*anchor)->phase < writer->phase)
 467    anchor = &((*anchor)->next);
 468  writer->next = *anchor;
 469  *anchor = writer;
 470  return CURLE_OK;
 471}
 472
 473struct Curl_cwriter *Curl_cwriter_get_by_name(struct Curl_easy *data,
 474                                              const char *name)
 475{
 476  struct Curl_cwriter *writer;
 477  for(writer = data->req.writer_stack; writer; writer = writer->next) {
 478    if(!strcmp(name, writer->cwt->name))
 479      return writer;
 480  }
 481  return NULL;
 482}
 483
 484struct Curl_cwriter *Curl_cwriter_get_by_type(struct Curl_easy *data,
 485                                              const struct Curl_cwtype *cwt)
 486{
 487  struct Curl_cwriter *writer;
 488  for(writer = data->req.writer_stack; writer; writer = writer->next) {
 489    if(writer->cwt == cwt)
 490      return writer;
 491  }
 492  return NULL;
 493}
 494
 495bool Curl_cwriter_is_content_decoding(struct Curl_easy *data)
 496{
 497  struct Curl_cwriter *writer;
 498  for(writer = data->req.writer_stack; writer; writer = writer->next) {
 499    if(writer->phase == CURL_CW_CONTENT_DECODE)
 500      return TRUE;
 501  }
 502  return FALSE;
 503}
 504
 505bool Curl_cwriter_is_paused(struct Curl_easy *data)
 506{
 507  return Curl_cw_out_is_paused(data);
 508}
 509
 510CURLcode Curl_cwriter_unpause(struct Curl_easy *data)
 511{
 512  return Curl_cw_out_unpause(data);
 513}
 514
 515CURLcode Curl_creader_read(struct Curl_easy *data,
 516                           struct Curl_creader *reader,
 517                           char *buf, size_t blen, size_t *nread, bool *eos)
 518{
 519  *nread = 0;
 520  *eos = FALSE;
 521  if(!reader)
 522    return CURLE_READ_ERROR;
 523  return reader->crt->do_read(data, reader, buf, blen, nread, eos);
 524}
 525
 526void Curl_creader_clear_eos(struct Curl_easy *data,
 527                            struct Curl_creader *reader)
 528{
 529  while(reader) {
 530    (void)reader->crt->cntrl(data, reader, CURL_CRCNTRL_CLEAR_EOS);
 531    reader = reader->next;
 532  }
 533}
 534
 535CURLcode Curl_creader_def_init(struct Curl_easy *data,
 536                               struct Curl_creader *reader)
 537{
 538  (void)data;
 539  (void)reader;
 540  return CURLE_OK;
 541}
 542
 543void Curl_creader_def_close(struct Curl_easy *data,
 544                            struct Curl_creader *reader)
 545{
 546  (void)data;
 547  (void)reader;
 548}
 549
 550CURLcode Curl_creader_def_read(struct Curl_easy *data,
 551                               struct Curl_creader *reader,
 552                               char *buf, size_t blen,
 553                               size_t *nread, bool *eos)
 554{
 555  if(reader->next)
 556    return reader->next->crt->do_read(data, reader->next, buf, blen,
 557                                      nread, eos);
 558  else {
 559    *nread = 0;
 560    *eos = FALSE;
 561    return CURLE_READ_ERROR;
 562  }
 563}
 564
 565bool Curl_creader_def_needs_rewind(struct Curl_easy *data,
 566                                   struct Curl_creader *reader)
 567{
 568  (void)data;
 569  (void)reader;
 570  return FALSE;
 571}
 572
 573curl_off_t Curl_creader_def_total_length(struct Curl_easy *data,
 574                                         struct Curl_creader *reader)
 575{
 576  return reader->next ?
 577         reader->next->crt->total_length(data, reader->next) : -1;
 578}
 579
 580CURLcode Curl_creader_def_resume_from(struct Curl_easy *data,
 581                                      struct Curl_creader *reader,
 582                                      curl_off_t offset)
 583{
 584  (void)data;
 585  (void)reader;
 586  (void)offset;
 587  return CURLE_READ_ERROR;
 588}
 589
 590CURLcode Curl_creader_def_cntrl(struct Curl_easy *data,
 591                                struct Curl_creader *reader,
 592                                Curl_creader_cntrl opcode)
 593{
 594  (void)data;
 595  (void)reader;
 596  (void)opcode;
 597  return CURLE_OK;
 598}
 599
 600bool Curl_creader_def_is_paused(struct Curl_easy *data,
 601                                struct Curl_creader *reader)
 602{
 603  (void)data;
 604  (void)reader;
 605  return FALSE;
 606}
 607
 608void Curl_creader_def_done(struct Curl_easy *data,
 609                           struct Curl_creader *reader, int premature)
 610{
 611  (void)data;
 612  (void)reader;
 613  (void)premature;
 614}
 615
 616struct cr_in_ctx {
 617  struct Curl_creader super;
 618  curl_read_callback read_cb;
 619  void *cb_user_data;
 620  curl_off_t total_len;
 621  curl_off_t read_len;
 622  CURLcode error_result;
 623  BIT(seen_eos);
 624  BIT(errored);
 625  BIT(has_used_cb);
 626  BIT(is_paused);
 627};
 628
 629static CURLcode cr_in_init(struct Curl_easy *data, struct Curl_creader *reader)
 630{
 631  struct cr_in_ctx *ctx = reader->ctx;
 632  ctx->read_cb = data->state.fread_func;
 633  ctx->cb_user_data = data->state.in;
 634  ctx->total_len = -1;
 635  ctx->read_len = 0;
 636  return CURLE_OK;
 637}
 638
 639/* Real client reader to installed client callbacks. */
 640static CURLcode cr_in_read(struct Curl_easy *data,
 641                           struct Curl_creader *reader,
 642                           char *buf, size_t blen,
 643                           size_t *pnread, bool *peos)
 644{
 645  struct cr_in_ctx *ctx = reader->ctx;
 646  CURLcode result = CURLE_OK;
 647  size_t nread;
 648
 649  ctx->is_paused = FALSE;
 650
 651  /* Once we have errored, we will return the same error forever */
 652  if(ctx->errored) {
 653    *pnread = 0;
 654    *peos = FALSE;
 655    return ctx->error_result;
 656  }
 657  if(ctx->seen_eos) {
 658    *pnread = 0;
 659    *peos = TRUE;
 660    return CURLE_OK;
 661  }
 662  /* respect length limitations */
 663  if(ctx->total_len >= 0) {
 664    blen = curlx_sotouz_range(ctx->total_len - ctx->read_len, 0, blen);
 665  }
 666  nread = 0;
 667  if(ctx->read_cb && blen) {
 668    Curl_set_in_callback(data, TRUE);
 669    nread = ctx->read_cb(buf, 1, blen, ctx->cb_user_data);
 670    Curl_set_in_callback(data, FALSE);
 671    ctx->has_used_cb = TRUE;
 672  }
 673
 674  switch(nread) {
 675  case 0:
 676    if((ctx->total_len >= 0) && (ctx->read_len < ctx->total_len)) {
 677      failf(data, "client read function EOF fail, "
 678            "only %" FMT_OFF_T "/%" FMT_OFF_T " of needed bytes read",
 679            ctx->read_len, ctx->total_len);
 680      result = CURLE_READ_ERROR;
 681      break;
 682    }
 683    *pnread = 0;
 684    *peos = TRUE;
 685    ctx->seen_eos = TRUE;
 686    break;
 687
 688  case CURL_READFUNC_ABORT:
 689    failf(data, "operation aborted by callback");
 690    *pnread = 0;
 691    *peos = FALSE;
 692    ctx->errored = TRUE;
 693    ctx->error_result = CURLE_ABORTED_BY_CALLBACK;
 694    result = CURLE_ABORTED_BY_CALLBACK;
 695    break;
 696
 697  case CURL_READFUNC_PAUSE:
 698    if(data->conn->scheme->flags & PROTOPT_NONETWORK) {
 699      /* protocols that work without network cannot be paused. This is
 700         actually only FILE:// now, and it cannot pause since the transfer
 701         is not done using the "normal" procedure. */
 702      failf(data, "Read callback asked for PAUSE when not supported");
 703      result = CURLE_READ_ERROR;
 704      break;
 705    }
 706    /* CURL_READFUNC_PAUSE pauses read callbacks that feed socket writes */
 707    CURL_TRC_READ(data, "cr_in_read, callback returned CURL_READFUNC_PAUSE");
 708    ctx->is_paused = TRUE;
 709    *pnread = 0;
 710    *peos = FALSE;
 711    result = Curl_xfer_pause_send(data, TRUE);
 712    break; /* nothing was read */
 713
 714  default:
 715    if(nread > blen) {
 716      /* the read function returned a too large value */
 717      failf(data, "read function returned funny value");
 718      *pnread = 0;
 719      *peos = FALSE;
 720      ctx->errored = TRUE;
 721      ctx->error_result = CURLE_READ_ERROR;
 722      result = CURLE_READ_ERROR;
 723      break;
 724    }
 725    ctx->read_len += nread;
 726    if(ctx->total_len >= 0)
 727      ctx->seen_eos = (ctx->read_len >= ctx->total_len);
 728    *pnread = nread;
 729    *peos = (bool)ctx->seen_eos;
 730    break;
 731  }
 732  CURL_TRC_READ(data, "cr_in_read(len=%zu, total=%" FMT_OFF_T
 733                ", read=%" FMT_OFF_T ") -> %d, nread=%zu, eos=%d",
 734                blen, ctx->total_len, ctx->read_len, result,
 735                *pnread, *peos);
 736  return result;
 737}
 738
 739static bool cr_in_needs_rewind(struct Curl_easy *data,
 740                               struct Curl_creader *reader)
 741{
 742  struct cr_in_ctx *ctx = reader->ctx;
 743  (void)data;
 744  return (bool)ctx->has_used_cb;
 745}
 746
 747static curl_off_t cr_in_total_length(struct Curl_easy *data,
 748                                     struct Curl_creader *reader)
 749{
 750  struct cr_in_ctx *ctx = reader->ctx;
 751  (void)data;
 752  return ctx->total_len;
 753}
 754
 755static CURLcode cr_in_resume_from(struct Curl_easy *data,
 756                                  struct Curl_creader *reader,
 757                                  curl_off_t offset)
 758{
 759  struct cr_in_ctx *ctx = reader->ctx;
 760  int seekerr = CURL_SEEKFUNC_CANTSEEK;
 761
 762  DEBUGASSERT(data->conn);
 763  /* already started reading? */
 764  if(ctx->read_len)
 765    return CURLE_READ_ERROR;
 766
 767  if(data->set.seek_func) {
 768    Curl_set_in_callback(data, TRUE);
 769    seekerr = data->set.seek_func(data->set.seek_client, offset, SEEK_SET);
 770    Curl_set_in_callback(data, FALSE);
 771  }
 772
 773  if(seekerr != CURL_SEEKFUNC_OK) {
 774    curl_off_t passed = 0;
 775
 776    if(seekerr != CURL_SEEKFUNC_CANTSEEK) {
 777      failf(data, "Could not seek stream");
 778      return CURLE_READ_ERROR;
 779    }
 780    /* when seekerr == CURL_SEEKFUNC_CANTSEEK (cannot seek to offset) */
 781    do {
 782      char scratch[4 * 1024];
 783      size_t readthisamountnow =
 784        (offset - passed > (curl_off_t)sizeof(scratch)) ?
 785        sizeof(scratch) :
 786        curlx_sotouz(offset - passed);
 787      size_t actuallyread;
 788
 789      Curl_set_in_callback(data, TRUE);
 790      actuallyread = ctx->read_cb(scratch, 1, readthisamountnow,
 791                                  ctx->cb_user_data);
 792      Curl_set_in_callback(data, FALSE);
 793
 794      passed += actuallyread;
 795      if((actuallyread == 0) || (actuallyread > readthisamountnow)) {
 796        /* this checks for greater-than only to make sure that the
 797           CURL_READFUNC_ABORT return code still aborts */
 798        failf(data, "Could only read %" FMT_OFF_T " bytes from the input",
 799              passed);
 800        return CURLE_READ_ERROR;
 801      }
 802    } while(passed < offset);
 803  }
 804
 805  /* now, decrease the size of the read */
 806  if(ctx->total_len > 0) {
 807    ctx->total_len -= offset;
 808
 809    if(ctx->total_len <= 0) {
 810      failf(data, "File already completely uploaded");
 811      return CURLE_PARTIAL_FILE;
 812    }
 813  }
 814  /* we have passed, proceed as normal */
 815  return CURLE_OK;
 816}
 817
 818static CURLcode cr_in_rewind(struct Curl_easy *data,
 819                             struct Curl_creader *reader)
 820{
 821  struct cr_in_ctx *ctx = reader->ctx;
 822
 823  /* If we never invoked the callback, there is noting to rewind */
 824  if(!ctx->has_used_cb)
 825    return CURLE_OK;
 826
 827  if(data->set.seek_func) {
 828    int err;
 829
 830    Curl_set_in_callback(data, TRUE);
 831    err = (data->set.seek_func)(data->set.seek_client, 0, SEEK_SET);
 832    Curl_set_in_callback(data, FALSE);
 833    CURL_TRC_READ(data, "cr_in, rewind via set.seek_func -> %d", err);
 834    if(err) {
 835      failf(data, "seek callback returned error %d", err);
 836      return CURLE_SEND_FAIL_REWIND;
 837    }
 838  }
 839  else if(data->set.ioctl_func) {
 840    curlioerr err;
 841
 842    Curl_set_in_callback(data, TRUE);
 843    err = (data->set.ioctl_func)(data, CURLIOCMD_RESTARTREAD,
 844                                 data->set.ioctl_client);
 845    Curl_set_in_callback(data, FALSE);
 846    CURL_TRC_READ(data, "cr_in, rewind via set.ioctl_func -> %d", (int)err);
 847    if(err) {
 848      failf(data, "ioctl callback returned error %d", (int)err);
 849      return CURLE_SEND_FAIL_REWIND;
 850    }
 851  }
 852  else {
 853    /* If no CURLOPT_READFUNCTION is used, we know that we operate on a
 854       given FILE * stream and we can actually attempt to rewind that
 855       ourselves with fseek() */
 856#if defined(__clang__) && __clang_major__ >= 16
 857#pragma clang diagnostic push
 858#pragma clang diagnostic ignored "-Wcast-function-type-strict"
 859#endif
 860    if(data->state.fread_func == (curl_read_callback)fread) {
 861#if defined(__clang__) && __clang_major__ >= 16
 862#pragma clang diagnostic pop
 863#endif
 864      int err = fseek(data->state.in, 0, SEEK_SET);
 865      CURL_TRC_READ(data, "cr_in, rewind via fseek -> %d(%d)",
 866                    (int)err, (int)errno);
 867      if(err != -1)
 868        /* successful rewind */
 869        return CURLE_OK;
 870    }
 871
 872    /* no callback set or failure above, makes us fail at once */
 873    failf(data, "necessary data rewind was not possible");
 874    return CURLE_SEND_FAIL_REWIND;
 875  }
 876  return CURLE_OK;
 877}
 878
 879static CURLcode cr_in_cntrl(struct Curl_easy *data,
 880                            struct Curl_creader *reader,
 881                            Curl_creader_cntrl opcode)
 882{
 883  struct cr_in_ctx *ctx = reader->ctx;
 884
 885  switch(opcode) {
 886  case CURL_CRCNTRL_REWIND:
 887    return cr_in_rewind(data, reader);
 888  case CURL_CRCNTRL_UNPAUSE:
 889    ctx->is_paused = FALSE;
 890    break;
 891  case CURL_CRCNTRL_CLEAR_EOS:
 892    ctx->seen_eos = FALSE;
 893    break;
 894  default:
 895    break;
 896  }
 897  return CURLE_OK;
 898}
 899
 900static bool cr_in_is_paused(struct Curl_easy *data,
 901                            struct Curl_creader *reader)
 902{
 903  struct cr_in_ctx *ctx = reader->ctx;
 904  (void)data;
 905  return (bool)ctx->is_paused;
 906}
 907
 908static const struct Curl_crtype cr_in = {
 909  "cr-in",
 910  cr_in_init,
 911  cr_in_read,
 912  Curl_creader_def_close,
 913  cr_in_needs_rewind,
 914  cr_in_total_length,
 915  cr_in_resume_from,
 916  cr_in_cntrl,
 917  cr_in_is_paused,
 918  Curl_creader_def_done,
 919  sizeof(struct cr_in_ctx)
 920};
 921
 922CURLcode Curl_creader_create(struct Curl_creader **preader,
 923                             struct Curl_easy *data,
 924                             const struct Curl_crtype *crt,
 925                             Curl_creader_phase phase)
 926{
 927  struct Curl_creader *reader = NULL;
 928  CURLcode result = CURLE_OUT_OF_MEMORY;
 929  void *p;
 930
 931  DEBUGASSERT(crt->creader_size >= sizeof(struct Curl_creader));
 932  p = curlx_calloc(1, crt->creader_size);
 933  if(!p)
 934    goto out;
 935
 936  reader = (struct Curl_creader *)p;
 937  reader->crt = crt;
 938  reader->ctx = p;
 939  reader->phase = phase;
 940  result = crt->do_init(data, reader);
 941
 942out:
 943  *preader = result ? NULL : reader;
 944  if(result)
 945    curlx_free(reader);
 946  return result;
 947}
 948
 949void Curl_creader_free(struct Curl_easy *data, struct Curl_creader *reader)
 950{
 951  if(reader) {
 952    reader->crt->do_close(data, reader);
 953    curlx_free(reader);
 954  }
 955}
 956
 957struct cr_lc_ctx {
 958  struct Curl_creader super;
 959  struct bufq buf;
 960  BIT(read_eos);  /* we read an EOS from the next reader */
 961  BIT(eos);       /* we have returned an EOS */
 962  BIT(prev_cr);   /* the last byte was a CR */
 963};
 964
 965static CURLcode cr_lc_init(struct Curl_easy *data, struct Curl_creader *reader)
 966{
 967  struct cr_lc_ctx *ctx = reader->ctx;
 968  (void)data;
 969  Curl_bufq_init2(&ctx->buf, (16 * 1024), 1, BUFQ_OPT_SOFT_LIMIT);
 970  return CURLE_OK;
 971}
 972
 973static void cr_lc_close(struct Curl_easy *data, struct Curl_creader *reader)
 974{
 975  struct cr_lc_ctx *ctx = reader->ctx;
 976  (void)data;
 977  Curl_bufq_free(&ctx->buf);
 978}
 979
 980/* client reader doing line end conversions. */
 981static CURLcode cr_lc_read(struct Curl_easy *data,
 982                           struct Curl_creader *reader,
 983                           char *buf, size_t blen,
 984                           size_t *pnread, bool *peos)
 985{
 986  struct cr_lc_ctx *ctx = reader->ctx;
 987  CURLcode result;
 988  size_t nread, i, start, n;
 989  bool eos;
 990
 991  if(ctx->eos) {
 992    *pnread = 0;
 993    *peos = TRUE;
 994    return CURLE_OK;
 995  }
 996
 997  if(Curl_bufq_is_empty(&ctx->buf)) {
 998    if(ctx->read_eos) {
 999      ctx->eos = TRUE;
1000      *pnread = 0;
1001      *peos = TRUE;
1002      return CURLE_OK;
1003    }
1004    /* Still getting data form the next reader, ctx->buf is empty */
1005    result = Curl_creader_read(data, reader->next, buf, blen, &nread, &eos);
1006    if(result)
1007      return result;
1008    ctx->read_eos = eos;
1009
1010    if(!nread || !memchr(buf, '\n', nread)) {
1011      /* nothing to convert, return this right away */
1012      if(nread)
1013        ctx->prev_cr = (buf[nread - 1] == '\r');
1014      if(ctx->read_eos)
1015        ctx->eos = TRUE;
1016      *pnread = nread;
1017      *peos = (bool)ctx->eos;
1018      goto out;
1019    }
1020
1021    /* at least one \n might need conversion to '\r\n', place into ctx->buf */
1022    for(i = start = 0; i < nread; ++i) {
1023      /* if this byte is not an LF character, or if the preceding character is
1024         a CR (meaning this already is a CRLF pair), go to next */
1025      if((buf[i] != '\n') || ctx->prev_cr) {
1026        ctx->prev_cr = (buf[i] == '\r');
1027        continue;
1028      }
1029      ctx->prev_cr = FALSE;
1030      /* on a soft limit bufq, we do not need to check length */
1031      result = Curl_bufq_cwrite(&ctx->buf, buf + start, i - start, &n);
1032      if(!result)
1033        result = Curl_bufq_cwrite(&ctx->buf, STRCONST("\r\n"), &n);
1034      if(result)
1035        return result;
1036      start = i + 1;
1037    }
1038
1039    if(start < i) { /* leftover */
1040      result = Curl_bufq_cwrite(&ctx->buf, buf + start, i - start, &n);
1041      if(result)
1042        return result;
1043    }
1044  }
1045
1046  DEBUGASSERT(!Curl_bufq_is_empty(&ctx->buf));
1047  *peos = FALSE;
1048  result = Curl_bufq_cread(&ctx->buf, buf, blen, pnread);
1049  if(!result && ctx->read_eos && Curl_bufq_is_empty(&ctx->buf)) {
1050    /* no more data, read all, done. */
1051    ctx->eos = TRUE;
1052    *peos = TRUE;
1053  }
1054
1055out:
1056  CURL_TRC_READ(data, "cr_lc_read(len=%zu) -> %d, nread=%zu, eos=%d",
1057                blen, result, *pnread, *peos);
1058  return result;
1059}
1060
1061static curl_off_t cr_lc_total_length(struct Curl_easy *data,
1062                                     struct Curl_creader *reader)
1063{
1064  /* this reader changes length depending on input */
1065  (void)data;
1066  (void)reader;
1067  return -1;
1068}
1069
1070static const struct Curl_crtype cr_lc = {
1071  "cr-lineconv",
1072  cr_lc_init,
1073  cr_lc_read,
1074  cr_lc_close,
1075  Curl_creader_def_needs_rewind,
1076  cr_lc_total_length,
1077  Curl_creader_def_resume_from,
1078  Curl_creader_def_cntrl,
1079  Curl_creader_def_is_paused,
1080  Curl_creader_def_done,
1081  sizeof(struct cr_lc_ctx)
1082};
1083
1084static CURLcode cr_lc_add(struct Curl_easy *data)
1085{
1086  struct Curl_creader *reader = NULL;
1087  CURLcode result;
1088
1089  result = Curl_creader_create(&reader, data, &cr_lc, CURL_CR_CONTENT_ENCODE);
1090  if(!result)
1091    result = Curl_creader_add(data, reader);
1092
1093  if(result && reader)
1094    Curl_creader_free(data, reader);
1095  return result;
1096}
1097
1098static CURLcode do_init_reader_stack(struct Curl_easy *data,
1099                                     struct Curl_creader *r)
1100{
1101  CURLcode result = CURLE_OK;
1102  curl_off_t clen;
1103
1104  DEBUGASSERT(r);
1105  DEBUGASSERT(r->crt);
1106  DEBUGASSERT(r->phase == CURL_CR_CLIENT);
1107  DEBUGASSERT(!data->req.reader_stack);
1108
1109  data->req.reader_stack = r;
1110  clen = r->crt->total_length(data, r);
1111  /* if we do not have 0 length init, and crlf conversion is wanted,
1112   * add the reader for it */
1113  if(clen && (data->set.crlf
1114#ifdef CURL_PREFER_LF_LINEENDS
1115     || data->state.prefer_ascii
1116#endif
1117    )) {
1118    result = cr_lc_add(data);
1119    if(result)
1120      return result;
1121  }
1122
1123  return result;
1124}
1125
1126CURLcode Curl_creader_set_fread(struct Curl_easy *data, curl_off_t len)
1127{
1128  CURLcode result;
1129  struct Curl_creader *r;
1130  struct cr_in_ctx *ctx;
1131
1132  result = Curl_creader_create(&r, data, &cr_in, CURL_CR_CLIENT);
1133  if(result || !r)
1134    goto out;
1135  ctx = r->ctx;
1136  ctx->total_len = len;
1137
1138  cl_reset_reader(data);
1139  result = do_init_reader_stack(data, r);
1140out:
1141  CURL_TRC_READ(data, "add fread reader, len=%" FMT_OFF_T " -> %d",
1142                len, result);
1143  return result;
1144}
1145
1146CURLcode Curl_creader_add(struct Curl_easy *data,
1147                          struct Curl_creader *reader)
1148{
1149  CURLcode result;
1150  struct Curl_creader **anchor = &data->req.reader_stack;
1151
1152  if(!*anchor) {
1153    result = Curl_creader_set_fread(data, data->state.infilesize);
1154    if(result)
1155      return result;
1156  }
1157
1158  /* Insert the writer as first in its phase.
1159   * Skip existing readers of lower phases. */
1160  while(*anchor && (*anchor)->phase < reader->phase)
1161    anchor = &((*anchor)->next);
1162  reader->next = *anchor;
1163  *anchor = reader;
1164  return CURLE_OK;
1165}
1166
1167CURLcode Curl_creader_set(struct Curl_easy *data, struct Curl_creader *r)
1168{
1169  CURLcode result;
1170
1171  DEBUGASSERT(r);
1172  DEBUGASSERT(r->crt);
1173  DEBUGASSERT(r->phase == CURL_CR_CLIENT);
1174
1175  cl_reset_reader(data);
1176  result = do_init_reader_stack(data, r);
1177  if(result)
1178    Curl_creader_free(data, r);
1179  return result;
1180}
1181
1182CURLcode Curl_client_read(struct Curl_easy *data, char *buf, size_t blen,
1183                          size_t *nread, bool *eos)
1184{
1185  CURLcode result;
1186
1187  DEBUGASSERT(buf);
1188  DEBUGASSERT(blen);
1189  DEBUGASSERT(nread);
1190  DEBUGASSERT(eos);
1191  *nread = 0;
1192
1193  if(!data->req.reader_stack) {
1194    result = Curl_creader_set_fread(data, data->state.infilesize);
1195    if(result)
1196      return result;
1197    DEBUGASSERT(data->req.reader_stack);
1198  }
1199  if(!data->req.reader_started) {
1200    Curl_rlimit_start(&data->progress.ul.rlimit, Curl_pgrs_now(data), -1);
1201    data->req.reader_started = TRUE;
1202  }
1203
1204  if(Curl_rlimit_active(&data->progress.ul.rlimit)) {
1205    curl_off_t ul_avail = Curl_rlimit_avail(&data->progress.ul.rlimit,
1206                                            Curl_pgrs_now(data));
1207    if(ul_avail <= 0) {
1208      result = CURLE_OK;
1209      *eos = FALSE;
1210      goto out;
1211    }
1212    if(ul_avail < (curl_off_t)blen)
1213      blen = (size_t)ul_avail;
1214  }
1215  result = Curl_creader_read(data, data->req.reader_stack, buf, blen,
1216                             nread, eos);
1217
1218out:
1219  CURL_TRC_READ(data, "client_read(len=%zu) -> %d, nread=%zu, eos=%d",
1220                blen, result, *nread, *eos);
1221  return result;
1222}
1223
1224bool Curl_creader_needs_rewind(struct Curl_easy *data)
1225{
1226  struct Curl_creader *reader = data->req.reader_stack;
1227  while(reader) {
1228    if(reader->crt->needs_rewind(data, reader)) {
1229      CURL_TRC_READ(data, "client reader needs rewind before next request");
1230      return TRUE;
1231    }
1232    reader = reader->next;
1233  }
1234  return FALSE;
1235}
1236
1237static CURLcode cr_null_read(struct Curl_easy *data,
1238                             struct Curl_creader *reader,
1239                             char *buf, size_t blen,
1240                             size_t *pnread, bool *peos)
1241{
1242  (void)data;
1243  (void)reader;
1244  (void)buf;
1245  (void)blen;
1246  *pnread = 0;
1247  *peos = TRUE;
1248  return CURLE_OK;
1249}
1250
1251static curl_off_t cr_null_total_length(struct Curl_easy *data,
1252                                       struct Curl_creader *reader)
1253{
1254  /* this reader changes length depending on input */
1255  (void)data;
1256  (void)reader;
1257  return 0;
1258}
1259
1260static const struct Curl_crtype cr_null = {
1261  "cr-null",
1262  Curl_creader_def_init,
1263  cr_null_read,
1264  Curl_creader_def_close,
1265  Curl_creader_def_needs_rewind,
1266  cr_null_total_length,
1267  Curl_creader_def_resume_from,
1268  Curl_creader_def_cntrl,
1269  Curl_creader_def_is_paused,
1270  Curl_creader_def_done,
1271  sizeof(struct Curl_creader)
1272};
1273
1274CURLcode Curl_creader_set_null(struct Curl_easy *data)
1275{
1276  struct Curl_creader *r;
1277  CURLcode result;
1278
1279  result = Curl_creader_create(&r, data, &cr_null, CURL_CR_CLIENT);
1280  if(result)
1281    return result;
1282
1283  cl_reset_reader(data);
1284  return do_init_reader_stack(data, r);
1285}
1286
1287struct cr_buf_ctx {
1288  struct Curl_creader super;
1289  const char *buf;
1290  size_t blen;
1291  size_t index;
1292};
1293
1294static CURLcode cr_buf_read(struct Curl_easy *data,
1295                            struct Curl_creader *reader,
1296                            char *buf, size_t blen,
1297                            size_t *pnread, bool *peos)
1298{
1299  struct cr_buf_ctx *ctx = reader->ctx;
1300  size_t nread = ctx->blen - ctx->index;
1301
1302  if(!nread || !ctx->buf) {
1303    *pnread = 0;
1304    *peos = TRUE;
1305  }
1306  else {
1307    if(nread > blen)
1308      nread = blen;
1309    memcpy(buf, ctx->buf + ctx->index, nread);
1310    *pnread = nread;
1311    ctx->index += nread;
1312    *peos = (ctx->index == ctx->blen);
1313  }
1314  CURL_TRC_READ(data, "cr_buf_read(len=%zu) -> 0, nread=%zu, eos=%d",
1315                blen, *pnread, *peos);
1316  return CURLE_OK;
1317}
1318
1319static bool cr_buf_needs_rewind(struct Curl_easy *data,
1320                                struct Curl_creader *reader)
1321{
1322  struct cr_buf_ctx *ctx = reader->ctx;
1323  (void)data;
1324  return ctx->index > 0;
1325}
1326
1327static CURLcode cr_buf_cntrl(struct Curl_easy *data,
1328                             struct Curl_creader *reader,
1329                             Curl_creader_cntrl opcode)
1330{
1331  struct cr_buf_ctx *ctx = reader->ctx;
1332  (void)data;
1333  switch(opcode) {
1334  case CURL_CRCNTRL_REWIND:
1335    ctx->index = 0;
1336    break;
1337  default:
1338    break;
1339  }
1340  return CURLE_OK;
1341}
1342
1343static curl_off_t cr_buf_total_length(struct Curl_easy *data,
1344                                      struct Curl_creader *reader)
1345{
1346  struct cr_buf_ctx *ctx = reader->ctx;
1347  (void)data;
1348  return (curl_off_t)ctx->blen;
1349}
1350
1351static CURLcode cr_buf_resume_from(struct Curl_easy *data,
1352                                   struct Curl_creader *reader,
1353                                   curl_off_t offset)
1354{
1355  struct cr_buf_ctx *ctx = reader->ctx;
1356  size_t boffset;
1357
1358  (void)data;
1359  DEBUGASSERT(data->conn);
1360  /* already started reading? */
1361  if(ctx->index)
1362    return CURLE_READ_ERROR;
1363  boffset = curlx_sotouz_range(offset, 0, SIZE_MAX);
1364  if(!boffset)
1365    return CURLE_OK;
1366  if(boffset > ctx->blen)
1367    return CURLE_READ_ERROR;
1368
1369  ctx->buf += boffset;
1370  ctx->blen -= boffset;
1371  return CURLE_OK;
1372}
1373
1374static const struct Curl_crtype cr_buf = {
1375  "cr-buf",
1376  Curl_creader_def_init,
1377  cr_buf_read,
1378  Curl_creader_def_close,
1379  cr_buf_needs_rewind,
1380  cr_buf_total_length,
1381  cr_buf_resume_from,
1382  cr_buf_cntrl,
1383  Curl_creader_def_is_paused,
1384  Curl_creader_def_done,
1385  sizeof(struct cr_buf_ctx)
1386};
1387
1388CURLcode Curl_creader_set_buf(struct Curl_easy *data,
1389                              const char *buf, size_t blen)
1390{
1391  CURLcode result;
1392  struct Curl_creader *r;
1393  struct cr_buf_ctx *ctx;
1394
1395  result = Curl_creader_create(&r, data, &cr_buf, CURL_CR_CLIENT);
1396  if(result)
1397    goto out;
1398  ctx = r->ctx;
1399  ctx->buf = buf;
1400  ctx->blen = blen;
1401  ctx->index = 0;
1402
1403  cl_reset_reader(data);
1404  result = do_init_reader_stack(data, r);
1405out:
1406  CURL_TRC_READ(data, "add buf reader, len=%zu -> %d", blen, result);
1407  return result;
1408}
1409
1410curl_off_t Curl_creader_total_length(struct Curl_easy *data)
1411{
1412  struct Curl_creader *r = data->req.reader_stack;
1413  return r ? r->crt->total_length(data, r) : -1;
1414}
1415
1416curl_off_t Curl_creader_client_length(struct Curl_easy *data)
1417{
1418  struct Curl_creader *r = data->req.reader_stack;
1419  while(r && r->phase != CURL_CR_CLIENT)
1420    r = r->next;
1421  return r ? r->crt->total_length(data, r) : -1;
1422}
1423
1424CURLcode Curl_creader_resume_from(struct Curl_easy *data, curl_off_t offset)
1425{
1426  struct Curl_creader *r = data->req.reader_stack;
1427  while(r && r->phase != CURL_CR_CLIENT)
1428    r = r->next;
1429  return r ? r->crt->resume_from(data, r, offset) : CURLE_READ_ERROR;
1430}
1431
1432CURLcode Curl_creader_unpause(struct Curl_easy *data)
1433{
1434  struct Curl_creader *reader = data->req.reader_stack;
1435  CURLcode result = CURLE_OK;
1436
1437  while(reader) {
1438    result = reader->crt->cntrl(data, reader, CURL_CRCNTRL_UNPAUSE);
1439    CURL_TRC_READ(data, "unpausing %s -> %d", reader->crt->name, result);
1440    if(result)
1441      break;
1442    reader = reader->next;
1443  }
1444  return result;
1445}
1446
1447bool Curl_creader_is_paused(struct Curl_easy *data)
1448{
1449  struct Curl_creader *reader = data->req.reader_stack;
1450
1451  while(reader) {
1452    if(reader->crt->is_paused(data, reader))
1453      return TRUE;
1454    reader = reader->next;
1455  }
1456  return FALSE;
1457}
1458
1459void Curl_creader_done(struct Curl_easy *data, int premature)
1460{
1461  struct Curl_creader *reader = data->req.reader_stack;
1462  while(reader) {
1463    reader->crt->done(data, reader, premature);
1464    reader = reader->next;
1465  }
1466}
1467
1468struct Curl_creader *Curl_creader_get_by_type(struct Curl_easy *data,
1469                                              const struct Curl_crtype *crt)
1470{
1471  struct Curl_creader *r;
1472  for(r = data->req.reader_stack; r; r = r->next) {
1473    if(r->crt == crt)
1474      return r;
1475  }
1476  return NULL;
1477}