subversion/libsvn_subr/stream.c

   1 /*
   2  * stream.c:   svn_stream operations
   3  *
   4  * ====================================================================
   5  * Copyright (c) 2000-2004, 2006 CollabNet.  All rights reserved.
   6  *
   7  * This software is licensed as described in the file COPYING, which
   8  * you should have received as part of this distribution.  The terms
   9  * are also available at http://subversion.tigris.org/license-1.html.
  10  * If newer versions of this license are posted there, you may use a
  11  * newer version instead, at your option.
  12  *
  13  * This software consists of voluntary contributions made by many
  14  * individuals.  For exact contribution history, see the revision
  15  * history and logs, available at http://subversion.tigris.org/.
  16  * ====================================================================
  17  */
  18
  19 #include "svn_private_config.h"
  20
  21 #include <assert.h>
  22 #include <stdio.h>
  23
  24 #include <apr.h>
  25 #include <apr_pools.h>
  26 #include <apr_strings.h>
  27 #include <apr_file_io.h>
  28 #include <apr_errno.h>
  29 #include <apr_md5.h>
  30
  31 #include <zlib.h>
  32
  33 #include "svn_pools.h"
  34 #include "svn_io.h"
  35 #include "svn_error.h"
  36 #include "svn_string.h"
  37 #include "svn_utf.h"
  38
  39
  40 struct svn_stream_t {
  41   void *baton;
  42   svn_read_fn_t read_fn;
  43   svn_write_fn_t write_fn;
  44   svn_close_fn_t close_fn;
  45 };
  46
  47
  48 \f
  49 /*** Generic streams. ***/
  50
  51 svn_stream_t *
  52 svn_stream_create(void *baton, apr_pool_t *pool)
  53 {
  54   svn_stream_t *stream;
  55
  56   stream = apr_palloc(pool, sizeof(*stream));
  57   stream->baton = baton;
  58   stream->read_fn = NULL;
  59   stream->write_fn = NULL;
  60   stream->close_fn = NULL;
  61   return stream;
  62 }
  63
  64
  65 void
  66 svn_stream_set_baton(svn_stream_t *stream, void *baton)
  67 {
  68   stream->baton = baton;
  69 }
  70
  71
  72 void
  73 svn_stream_set_read(svn_stream_t *stream, svn_read_fn_t read_fn)
  74 {
  75   stream->read_fn = read_fn;
  76 }
  77
  78
  79 void
  80 svn_stream_set_write(svn_stream_t *stream, svn_write_fn_t write_fn)
  81 {
  82   stream->write_fn = write_fn;
  83 }
  84
  85
  86 void
  87 svn_stream_set_close(svn_stream_t *stream, svn_close_fn_t close_fn)
  88 {
  89   stream->close_fn = close_fn;
  90 }
  91
  92
  93 svn_error_t *
  94 svn_stream_read(svn_stream_t *stream, char *buffer, apr_size_t *len)
  95 {
  96   assert(stream->read_fn != NULL);
  97   return stream->read_fn(stream->baton, buffer, len);
  98 }
  99
 100
 101 svn_error_t *
 102 svn_stream_write(svn_stream_t *stream, const char *data, apr_size_t *len)
 103 {
 104   assert(stream->write_fn != NULL);
 105   return stream->write_fn(stream->baton, data, len);
 106 }
 107
 108
 109 svn_error_t *
 110 svn_stream_close(svn_stream_t *stream)
 111 {
 112   if (stream->close_fn == NULL)
 113     return SVN_NO_ERROR;
 114   return stream->close_fn(stream->baton);
 115 }
 116
 117
 118 svn_error_t *
 119 svn_stream_printf(svn_stream_t *stream,
 120                   apr_pool_t *pool,
 121                   const char *fmt,
 122                   ...)
 123 {
 124   const char *message;
 125   va_list ap;
 126   apr_size_t len;
 127
 128   va_start(ap, fmt);
 129   message = apr_pvsprintf(pool, fmt, ap);
 130   va_end(ap);
 131
 132   len = strlen(message);
 133   return svn_stream_write(stream, message, &len);
 134 }
 135
 136
 137 svn_error_t *
 138 svn_stream_printf_from_utf8(svn_stream_t *stream,
 139                             const char *encoding,
 140                             apr_pool_t *pool,
 141                             const char *fmt,
 142                             ...)
 143 {
 144   const char *message, *translated;
 145   va_list ap;
 146   apr_size_t len;
 147
 148   va_start(ap, fmt);
 149   message = apr_pvsprintf(pool, fmt, ap);
 150   va_end(ap);
 151
 152   SVN_ERR(svn_utf_cstring_from_utf8_ex2(&translated, message, encoding,
 153                                         pool));
 154
 155   len = strlen(translated);
 156
 157   return svn_stream_write(stream, translated, &len);
 158 }
 159
 160
 161 svn_error_t *
 162 svn_stream_readline(svn_stream_t *stream,
 163                     svn_stringbuf_t **stringbuf,
 164                     const char *eol,
 165                     svn_boolean_t *eof,
 166                     apr_pool_t *pool)
 167 {
 168   apr_size_t numbytes;
 169   const char *match;
 170   char c;
 171   svn_stringbuf_t *str = svn_stringbuf_create("", pool);
 172
 173   /* Since we're reading one character at a time, let's at least
 174      optimize for the 90% case.  90% of the time, we can avoid the
 175      stringbuf ever having to realloc() itself if we start it out at
 176      80 chars.  */
 177   svn_stringbuf_ensure(str, 80);
 178
 179   match = eol;
 180   while (*match)
 181     {
 182       numbytes = 1;
 183       SVN_ERR(svn_stream_read(stream, &c, &numbytes));
 184       if (numbytes != 1)
 185         {
 186           /* a 'short' read means the stream has run out. */
 187           *eof = TRUE;
 188           *stringbuf = str;
 189           return SVN_NO_ERROR;
 190         }
 191
 192       if (c == *match)
 193         match++;
 194       else
 195         match = eol;
 196
 197       svn_stringbuf_appendbytes(str, &c, 1);
 198     }
 199
 200   *eof = FALSE;
 201   svn_stringbuf_chop(str, match - eol);
 202   *stringbuf = str;
 203   return SVN_NO_ERROR;
 204 }
 205
 206
 207 svn_error_t *svn_stream_copy2(svn_stream_t *from, svn_stream_t *to,
 208                               svn_cancel_func_t cancel_func,
 209                               void *cancel_baton,
 210                               apr_pool_t *pool)
 211 {
 212   char *buf = apr_palloc(pool, SVN__STREAM_CHUNK_SIZE);
 213   apr_size_t len;
 214
 215   /* Read and write chunks until we get a short read, indicating the
 216      end of the stream.  (We can't get a short write without an
 217      associated error.) */
 218   while (1)
 219     {
 220       len = SVN__STREAM_CHUNK_SIZE;
 221
 222       if (cancel_func)
 223         SVN_ERR(cancel_func(cancel_baton));
 224
 225       SVN_ERR(svn_stream_read(from, buf, &len));
 226       if (len > 0)
 227         SVN_ERR(svn_stream_write(to, buf, &len));
 228       if (len != SVN__STREAM_CHUNK_SIZE)
 229         break;
 230     }
 231   return SVN_NO_ERROR;
 232 }
 233
 234 svn_error_t *svn_stream_copy(svn_stream_t *from, svn_stream_t *to,
 235                              apr_pool_t *pool)
 236 {
 237   return svn_stream_copy2(from, to, NULL, NULL, pool);
 238 }
 239
 240 svn_error_t *
 241 svn_stream_contents_same(svn_boolean_t *same,
 242                          svn_stream_t *stream1,
 243                          svn_stream_t *stream2,
 244                          apr_pool_t *pool)
 245 {
 246   char *buf1 = apr_palloc(pool, SVN__STREAM_CHUNK_SIZE);
 247   char *buf2 = apr_palloc(pool, SVN__STREAM_CHUNK_SIZE);
 248   apr_size_t bytes_read1 = SVN__STREAM_CHUNK_SIZE;
 249   apr_size_t bytes_read2 = SVN__STREAM_CHUNK_SIZE;
 250
 251   *same = TRUE;  /* assume TRUE, until disproved below */
 252   while (bytes_read1 == SVN__STREAM_CHUNK_SIZE
 253          && bytes_read2 == SVN__STREAM_CHUNK_SIZE)
 254     {
 255       SVN_ERR(svn_stream_read(stream1, buf1, &bytes_read1));
 256       SVN_ERR(svn_stream_read(stream2, buf2, &bytes_read2));
 257
 258       if ((bytes_read1 != bytes_read2)
 259           || (memcmp(buf1, buf2, bytes_read1)))
 260         {
 261           *same = FALSE;
 262           break;
 263         }
 264     }
 265
 266   return SVN_NO_ERROR;
 267 }
 268
 269
 270 \f
 271 /*** Generic readable empty stream ***/
 272
 273 static svn_error_t *
 274 read_handler_empty(void *baton, char *buffer, apr_size_t *len)
 275 {
 276   *len = 0;
 277   return SVN_NO_ERROR;
 278 }
 279
 280
 281 static svn_error_t *
 282 write_handler_empty(void *baton, const char *data, apr_size_t *len)
 283 {
 284   return SVN_NO_ERROR;
 285 }
 286
 287
 288 svn_stream_t *
 289 svn_stream_empty(apr_pool_t *pool)
 290 {
 291   svn_stream_t *stream;
 292
 293   stream = svn_stream_create(NULL, pool);
 294   svn_stream_set_read(stream, read_handler_empty);
 295   svn_stream_set_write(stream, write_handler_empty);
 296   return stream;
 297 }
 298
 299
 300
 301 \f
 302 /*** Ownership detaching stream ***/
 303
 304 static svn_error_t *
 305 read_handler_disown(void *baton, char *buffer, apr_size_t *len)
 306 {
 307   return svn_stream_read((svn_stream_t *)baton, buffer, len);
 308 }
 309
 310 static svn_error_t *
 311 write_handler_disown(void *baton, const char *buffer, apr_size_t *len)
 312 {
 313   return svn_stream_write((svn_stream_t *)baton, buffer, len);
 314 }
 315
 316
 317 svn_stream_t *
 318 svn_stream_disown(svn_stream_t *stream, apr_pool_t *pool)
 319 {
 320   svn_stream_t *s = svn_stream_create(stream, pool);
 321
 322   svn_stream_set_read(s, read_handler_disown);
 323   svn_stream_set_write(s, write_handler_disown);
 324
 325   return s;
 326 }
 327
 328
 329 \f
 330 /*** Generic stream for APR files ***/
 331 struct baton_apr {
 332   apr_file_t *file;
 333   apr_pool_t *pool;
 334 };
 335
 336
 337 static svn_error_t *
 338 read_handler_apr(void *baton, char *buffer, apr_size_t *len)
 339 {
 340   struct baton_apr *btn = baton;
 341   svn_error_t *err;
 342
 343   err = svn_io_file_read_full(btn->file, buffer, *len, len, btn->pool);
 344   if (err && APR_STATUS_IS_EOF(err->apr_err))
 345     {
 346       svn_error_clear(err);
 347       err = SVN_NO_ERROR;
 348     }
 349
 350   return err;
 351 }
 352
 353
 354 static svn_error_t *
 355 write_handler_apr(void *baton, const char *data, apr_size_t *len)
 356 {
 357   struct baton_apr *btn = baton;
 358
 359   return svn_io_file_write_full(btn->file, data, *len, len, btn->pool);
 360 }
 361
 362 static svn_error_t *
 363 close_handler_apr(void *baton)
 364 {
 365   struct baton_apr *btn = baton;
 366
 367   return svn_io_file_close(btn->file, btn->pool);
 368 }
 369
 370
 371 svn_stream_t *
 372 svn_stream_from_aprfile2(apr_file_t *file,
 373                          svn_boolean_t disown,
 374                          apr_pool_t *pool)
 375 {
 376   struct baton_apr *baton;
 377   svn_stream_t *stream;
 378
 379   if (file == NULL)
 380     return svn_stream_empty(pool);
 381
 382   baton = apr_palloc(pool, sizeof(*baton));
 383   baton->file = file;
 384   baton->pool = pool;
 385   stream = svn_stream_create(baton, pool);
 386   svn_stream_set_read(stream, read_handler_apr);
 387   svn_stream_set_write(stream, write_handler_apr);
 388
 389   if (! disown)
 390     svn_stream_set_close(stream, close_handler_apr);
 391
 392   return stream;
 393 }
 394
 395 svn_stream_t *
 396 svn_stream_from_aprfile(apr_file_t *file, apr_pool_t *pool)
 397 {
 398   return svn_stream_from_aprfile2(file, TRUE, pool);
 399 }
 400
 401
 402 \f
 403 /* Compressed stream support */
 404
 405 #define ZBUFFER_SIZE 4096       /* The size of the buffer the
 406                                    compressed stream uses to read from
 407                                    the substream. Basically an
 408                                    arbitrary value, picked to be about
 409                                    page-sized. */
 410
 411 struct zbaton {
 412   z_stream *in;                 /* compressed stream for reading */
 413   z_stream *out;                /* compressed stream for writing */
 414   svn_read_fn_t read;           /* substream's read function */
 415   svn_write_fn_t write;         /* substream's write function */
 416   svn_close_fn_t close;         /* substream's close function */
 417   void *read_buffer;            /* buffer   used   for  reading   from
 418                                    substream */
 419   int read_flush;               /* what flush mode to use while
 420                                    reading */
 421   apr_pool_t *pool;             /* The pool this baton is allocated
 422                                    on */
 423   void *subbaton;               /* The substream's baton */
 424 };
 425
 426 /* zlib alloc function. opaque is the pool we need. */
 427 static voidpf
 428 zalloc(voidpf opaque, uInt items, uInt size)
 429 {
 430   apr_pool_t *pool = opaque;
 431
 432   return apr_palloc(pool, items * size);
 433 }
 434
 435 /* zlib free function */
 436 static void
 437 zfree(voidpf opaque, voidpf address)
 438 {
 439   /* Empty, since we allocate on the pool */
 440 }
 441
 442 /* Converts a zlib error to an svn_error_t. zerr is the error code,
 443    function is the function name, and stream is the z_stream we are
 444    using.  */
 445 static svn_error_t *
 446 zerr_to_svn_error(int zerr, const char *function, z_stream *stream)
 447 {
 448   apr_status_t status;
 449   const char *message;
 450
 451   if (zerr == Z_OK)
 452     return SVN_NO_ERROR;
 453
 454   switch (zerr)
 455     {
 456     case Z_STREAM_ERROR:
 457       status = SVN_ERR_STREAM_MALFORMED_DATA;
 458       message = "stream error";
 459       break;
 460
 461     case Z_MEM_ERROR:
 462       status = APR_ENOMEM;
 463       message = "out of memory";
 464       break;
 465
 466     case Z_BUF_ERROR:
 467       status = APR_ENOMEM;
 468       message = "buffer error";
 469       break;
 470
 471     case Z_VERSION_ERROR:
 472       status = SVN_ERR_STREAM_UNRECOGNIZED_DATA;
 473       message = "version error";
 474       break;
 475
 476     case Z_DATA_ERROR:
 477       status = SVN_ERR_STREAM_MALFORMED_DATA;
 478       message = "corrupted data";
 479       break;
 480
 481     default:
 482       status = SVN_ERR_STREAM_UNRECOGNIZED_DATA;
 483       message = "error";
 484       break;
 485     }
 486
 487   if (stream->msg != NULL)
 488     return svn_error_createf(status, NULL, "zlib (%s): %s: %s", function,
 489                              message, stream->msg);
 490   else
 491     return svn_error_createf(status, NULL, "zlib (%s): %s", function,
 492                              message);
 493 }
 494
 495 /* Helper function to figure out the sync mode */
 496 static svn_error_t *
 497 read_helper_gz(svn_read_fn_t read_fn,
 498                void *baton,
 499                char *buffer,
 500                uInt *len, int *zflush)
 501 {
 502   uInt orig_len = *len;
 503
 504   /* There's no reason this value should grow bigger than the range of
 505      uInt, but Subversion's API requires apr_size_t. */
 506   apr_size_t apr_len = (apr_size_t) *len;
 507
 508   SVN_ERR((*read_fn)(baton, buffer, &apr_len));
 509
 510   /* Type cast back to uInt type that zlib uses.  On LP64 platforms
 511      apr_size_t will be bigger than uInt. */
 512   *len = (uInt) apr_len;
 513
 514   /* I wanted to use Z_FINISH here, but we need to know our buffer is
 515      big enough */
 516   *zflush = (*len) < orig_len ? Z_SYNC_FLUSH : Z_SYNC_FLUSH;
 517
 518   return SVN_NO_ERROR;
 519 }
 520
 521 /* Handle reading from a compressed stream */
 522 static svn_error_t *
 523 read_handler_gz(void *baton, char *buffer, apr_size_t *len)
 524 {
 525   struct zbaton *btn = baton;
 526   int zerr;
 527
 528   if (btn->in == NULL)
 529     {
 530       btn->in = apr_palloc(btn->pool, sizeof(z_stream));
 531       btn->in->zalloc = zalloc;
 532       btn->in->zfree = zfree;
 533       btn->in->opaque = btn->pool;
 534       btn->read_buffer = apr_palloc(btn->pool, ZBUFFER_SIZE);
 535       btn->in->next_in = btn->read_buffer;
 536       btn->in->avail_in = ZBUFFER_SIZE;
 537
 538       SVN_ERR(read_helper_gz(btn->read, btn->subbaton, btn->read_buffer,
 539                              &btn->in->avail_in, &btn->read_flush));
 540
 541       zerr = inflateInit(btn->in);
 542       SVN_ERR(zerr_to_svn_error(zerr, "inflateInit", btn->in));
 543     }
 544
 545   btn->in->next_out = (Bytef *) buffer;
 546   btn->in->avail_out = *len;
 547
 548   while (btn->in->avail_out > 0)
 549     {
 550       if (btn->in->avail_in <= 0)
 551         {
 552           btn->in->avail_in = ZBUFFER_SIZE;
 553           btn->in->next_in = btn->read_buffer;
 554           SVN_ERR(read_helper_gz(btn->read, btn->subbaton, btn->read_buffer,
 555                                  &btn->in->avail_in, &btn->read_flush));
 556         }
 557
 558       zerr = inflate(btn->in, btn->read_flush);
 559       if (zerr == Z_STREAM_END)
 560         break;
 561       else if (zerr != Z_OK)
 562         return zerr_to_svn_error(zerr, "inflate", btn->in);
 563     }
 564
 565   *len -= btn->in->avail_out;
 566   return SVN_NO_ERROR;
 567 }
 568
 569 /* Compress data and write it to the substream */
 570 static svn_error_t *
 571 write_handler_gz(void *baton, const char *buffer, apr_size_t *len)
 572 {
 573   struct zbaton *btn = baton;
 574   apr_pool_t *subpool;
 575   void *write_buf;
 576   apr_size_t buf_size, write_len;
 577   int zerr;
 578
 579   if (btn->out == NULL)
 580     {
 581       btn->out = apr_palloc(btn->pool, sizeof(z_stream));
 582       btn->out->zalloc = zalloc;
 583       btn->out->zfree = zfree;
 584       btn->out->opaque =  btn->pool;
 585
 586       zerr = deflateInit(btn->out, Z_DEFAULT_COMPRESSION);
 587       SVN_ERR(zerr_to_svn_error(zerr, "deflateInit", btn->out));
 588     }
 589
 590   /* The largest buffer we should need is 0.1% larger than the
 591      compressed data, + 12 bytes. This info comes from zlib.h.  */
 592   buf_size = *len + (*len / 1000) + 13;
 593   subpool = svn_pool_create(btn->pool);
 594   write_buf = apr_palloc(subpool, buf_size);
 595
 596   btn->out->next_in = (Bytef *) buffer;  /* Casting away const! */
 597   btn->out->avail_in = *len;
 598
 599   while (btn->out->avail_in > 0)
 600     {
 601       btn->out->next_out = write_buf;
 602       btn->out->avail_out = buf_size;
 603
 604       zerr = deflate(btn->out, Z_NO_FLUSH);
 605       SVN_ERR(zerr_to_svn_error(zerr, "deflate", btn->out));
 606       write_len = buf_size - btn->out->avail_out;
 607       if (write_len > 0)
 608         SVN_ERR(btn->write(btn->subbaton, write_buf, &write_len));
 609     }
 610
 611   svn_pool_destroy(subpool);
 612
 613   return SVN_NO_ERROR;
 614 }
 615
 616 /* Handle flushing and closing the stream */
 617 static svn_error_t *
 618 close_handler_gz(void *baton)
 619 {
 620   struct zbaton *btn = baton;
 621   int zerr;
 622
 623   if (btn->in != NULL)
 624     {
 625       zerr = inflateEnd(btn->in);
 626       SVN_ERR(zerr_to_svn_error(zerr, "inflateEnd", btn->in));
 627     }
 628
 629   if (btn->out != NULL)
 630     {
 631       void *buf;
 632       apr_size_t write_len;
 633
 634       buf = apr_palloc(btn->pool, ZBUFFER_SIZE);
 635
 636       while (TRUE)
 637         {
 638           btn->out->next_out = buf;
 639           btn->out->avail_out = ZBUFFER_SIZE;
 640
 641           zerr = deflate(btn->out, Z_FINISH);
 642           if (zerr != Z_STREAM_END && zerr != Z_OK)
 643             return zerr_to_svn_error(zerr, "deflate", btn->out);
 644           write_len = ZBUFFER_SIZE - btn->out->avail_out;
 645           if (write_len > 0)
 646             SVN_ERR(btn->write(btn->subbaton, buf, &write_len));
 647           if (zerr == Z_STREAM_END)
 648             break;
 649         }
 650
 651       zerr = deflateEnd(btn->out);
 652       SVN_ERR(zerr_to_svn_error(zerr, "deflateEnd", btn->out));
 653     }
 654
 655   if (btn->close != NULL)
 656     return btn->close(btn->subbaton);
 657   else
 658     return SVN_NO_ERROR;
 659 }
 660
 661
 662 svn_stream_t *
 663 svn_stream_compressed(svn_stream_t *stream, apr_pool_t *pool)
 664 {
 665   struct svn_stream_t *zstream;
 666   struct zbaton *baton;
 667
 668   assert(stream != NULL);
 669
 670   baton = apr_palloc(pool, sizeof(*baton));
 671   baton->in = baton->out = NULL;
 672   baton->read = stream->read_fn;
 673   baton->write = stream->write_fn;
 674   baton->close = stream->close_fn;
 675   baton->subbaton = stream->baton;
 676   baton->pool = pool;
 677   baton->read_buffer = NULL;
 678   baton->read_flush = Z_SYNC_FLUSH;
 679
 680   zstream = svn_stream_create(baton, pool);
 681   svn_stream_set_read(zstream, read_handler_gz);
 682   svn_stream_set_write(zstream, write_handler_gz);
 683   svn_stream_set_close(zstream, close_handler_gz);
 684
 685   return zstream;
 686 }
 687
 688 \f
 689 /* MD5 checked stream support */
 690
 691 struct md5_stream_baton
 692 {
 693   apr_md5_ctx_t read_ctx, write_ctx;
 694   const unsigned char **read_digest;
 695   const unsigned char **write_digest;
 696   unsigned char read_digest_buf[APR_MD5_DIGESTSIZE];
 697   unsigned char write_digest_buf[APR_MD5_DIGESTSIZE];
 698   svn_stream_t *proxy;
 699
 700   /* True if more data should be read when closing the stream. */
 701   svn_boolean_t read_more;
 702
 703   /* Pool to allocate read buffer from. */
 704   apr_pool_t *pool;
 705 };
 706
 707 static svn_error_t *
 708 read_handler_md5(void *baton, char *buffer, apr_size_t *len)
 709 {
 710   struct md5_stream_baton *btn = baton;
 711   apr_size_t saved_len = *len;
 712
 713   SVN_ERR(svn_stream_read(btn->proxy, buffer, len));
 714
 715   if (btn->read_digest)
 716     {
 717       apr_status_t apr_err = apr_md5_update(&btn->read_ctx, buffer, *len);
 718
 719       if (apr_err)
 720         return svn_error_create(apr_err, NULL, NULL);
 721     }
 722
 723   if (saved_len != *len)
 724     btn->read_more = FALSE;
 725
 726   return SVN_NO_ERROR;
 727 }
 728
 729
 730 static svn_error_t *
 731 write_handler_md5(void *baton, const char *buffer, apr_size_t *len)
 732 {
 733   struct md5_stream_baton *btn = baton;
 734
 735   if (btn->write_digest && *len > 0)
 736     {
 737       apr_status_t apr_err = apr_md5_update(&btn->write_ctx, buffer, *len);
 738
 739       if (apr_err)
 740         return svn_error_create(apr_err, NULL, NULL);
 741     }
 742
 743   return svn_stream_write(btn->proxy, buffer, len);
 744 }
 745
 746
 747 static svn_error_t *
 748 close_handler_md5(void *baton)
 749 {
 750   struct md5_stream_baton *btn = baton;
 751
 752   /* If we're supposed to drain the stream, do so before finalizing the
 753      checksum. */
 754   if (btn->read_more)
 755     {
 756       char *buf = apr_palloc(btn->pool, SVN__STREAM_CHUNK_SIZE);
 757       apr_size_t len = SVN__STREAM_CHUNK_SIZE;
 758
 759       do
 760         {
 761           SVN_ERR(read_handler_md5(baton, buf, &len));
 762         }
 763       while (btn->read_more);
 764     }
 765
 766   if (btn->read_digest)
 767     {
 768       apr_status_t apr_err
 769         = apr_md5_final(btn->read_digest_buf, &btn->read_ctx);
 770
 771       if (apr_err)
 772         return svn_error_create(apr_err, NULL, NULL);
 773
 774       *btn->read_digest = btn->read_digest_buf;
 775     }
 776
 777   if (btn->write_digest)
 778     {
 779       apr_status_t apr_err
 780         = apr_md5_final(btn->write_digest_buf, &btn->write_ctx);
 781
 782       if (apr_err)
 783         return svn_error_create(apr_err, NULL, NULL);
 784
 785       *btn->write_digest = btn->write_digest_buf;
 786     }
 787
 788   return svn_stream_close(btn->proxy);
 789 }
 790
 791
 792 svn_stream_t *
 793 svn_stream_checksummed(svn_stream_t *stream,
 794                        const unsigned char **read_digest,
 795                        const unsigned char **write_digest,
 796                        svn_boolean_t read_all,
 797                        apr_pool_t *pool)
 798 {
 799   svn_stream_t *s;
 800   struct md5_stream_baton *baton;
 801
 802   if (! read_digest && ! write_digest)
 803     return stream;
 804
 805   baton = apr_palloc(pool, sizeof(*baton));
 806   apr_md5_init(&baton->read_ctx);
 807   apr_md5_init(&baton->write_ctx);
 808   baton->read_digest = read_digest;
 809   baton->write_digest = write_digest;
 810   baton->proxy = stream;
 811   baton->read_more = read_all;
 812   baton->pool = pool;
 813
 814   s = svn_stream_create(baton, pool);
 815   svn_stream_set_read(s, read_handler_md5);
 816   svn_stream_set_write(s, write_handler_md5);
 817   svn_stream_set_close(s, close_handler_md5);
 818   return s;
 819 }
 820
 821
 822
 823 \f
 824 /* Miscellaneous stream functions. */
 825 struct string_stream_baton
 826 {
 827   svn_stringbuf_t *str;
 828   apr_size_t amt_read;
 829 };
 830
 831 static svn_error_t *
 832 read_handler_string(void *baton, char *buffer, apr_size_t *len)
 833 {
 834   struct string_stream_baton *btn = baton;
 835   apr_size_t left_to_read = btn->str->len - btn->amt_read;
 836
 837   *len = (*len > left_to_read) ? left_to_read : *len;
 838   memcpy(buffer, btn->str->data + btn->amt_read, *len);
 839   btn->amt_read += *len;
 840   return SVN_NO_ERROR;
 841 }
 842
 843 static svn_error_t *
 844 write_handler_string(void *baton, const char *data, apr_size_t *len)
 845 {
 846   struct string_stream_baton *btn = baton;
 847
 848   svn_stringbuf_appendbytes(btn->str, data, *len);
 849   return SVN_NO_ERROR;
 850 }
 851
 852 svn_stream_t *
 853 svn_stream_from_stringbuf(svn_stringbuf_t *str,
 854                           apr_pool_t *pool)
 855 {
 856   svn_stream_t *stream;
 857   struct string_stream_baton *baton;
 858
 859   if (! str)
 860     return svn_stream_empty(pool);
 861
 862   baton = apr_palloc(pool, sizeof(*baton));
 863   baton->str = str;
 864   baton->amt_read = 0;
 865   stream = svn_stream_create(baton, pool);
 866   svn_stream_set_read(stream, read_handler_string);
 867   svn_stream_set_write(stream, write_handler_string);
 868   return stream;
 869 }
 870
 871
 872 svn_error_t *
 873 svn_stream_for_stdout(svn_stream_t **out, apr_pool_t *pool)
 874 {
 875   apr_file_t *stdout_file;
 876   apr_status_t apr_err;
 877
 878   apr_err = apr_file_open_stdout(&stdout_file, pool);
 879   if (apr_err)
 880     return svn_error_wrap_apr(apr_err, "Can't open stdout");
 881
 882   *out = svn_stream_from_aprfile(stdout_file, pool);
 883
 884   return SVN_NO_ERROR;
 885 }