dump_editor.c

   1 /* Licensed under a two-clause BSD-style license.
   2  * See LICENSE for details.
   3  */
   4
   5 #include "svn_pools.h"
   6 #include "svn_repos.h"
   7 #include "svn_path.h"
   8 #include "svn_props.h"
   9 #include "svn_dirent_uri.h"
  10
  11 #include "dumpr_util.h"
  12
  13 #define ARE_VALID_COPY_ARGS(p,r) ((p) && SVN_IS_VALID_REVNUM(r))
  14
  15 /* Make a directory baton to represent the directory was path
  16    (relative to EDIT_BATON's path) is PATH.
  17
  18    CMP_PATH/CMP_REV are the path/revision against which this directory
  19    should be compared for changes.  If either is omitted (NULL for the
  20    path, SVN_INVALID_REVNUM for the rev), just compare this directory
  21    PATH against itself in the previous revision.
  22
  23    PARENT_DIR_BATON is the directory baton of this directory's parent,
  24    or NULL if this is the top-level directory of the edit.  ADDED
  25    indicated if this directory is newly added in this revision.
  26    Perform all allocations in POOL.  */
  27 static struct dir_baton *make_dir_baton(const char *path,
  28                                         const char *cmp_path,
  29                                         svn_revnum_t cmp_rev,
  30                                         void *edit_baton,
  31                                         void *parent_dir_baton,
  32                                         svn_boolean_t added,
  33                                         apr_pool_t *pool)
  34 {
  35         struct dump_edit_baton *eb = edit_baton;
  36         struct dir_baton *pb = parent_dir_baton;
  37         struct dir_baton *new_db = apr_pcalloc(pool, sizeof(*new_db));
  38         const char *full_path;
  39         apr_array_header_t *compose_path = apr_array_make(pool, 2, sizeof(const char *));
  40
  41         /* A path relative to nothing?  I don't think so. */
  42         SVN_ERR_ASSERT_NO_RETURN(!path || pb);
  43
  44         /* Construct the full path of this node. */
  45         if (pb) {
  46                 APR_ARRAY_PUSH(compose_path, const char *) = "/";
  47                 APR_ARRAY_PUSH(compose_path, const char *) = path;
  48                 full_path = svn_path_compose(compose_path, pool);
  49         }
  50         else
  51                 full_path = apr_pstrdup(pool, "/");
  52
  53         /* Remove leading slashes from copyfrom paths. */
  54         if (cmp_path)
  55                 cmp_path = ((*cmp_path == '/') ? cmp_path + 1 : cmp_path);
  56
  57         new_db->eb = eb;
  58         new_db->parent_dir_baton = pb;
  59         new_db->path = full_path;
  60         new_db->cmp_path = cmp_path ? apr_pstrdup(pool, cmp_path) : NULL;
  61         new_db->cmp_rev = cmp_rev;
  62         new_db->added = added;
  63         new_db->written_out = FALSE;
  64         new_db->deleted_entries = apr_hash_make(pool);
  65         new_db->pool = pool;
  66
  67         return new_db;
  68 }
  69
  70 /*
  71  * Write out a node record for PATH of type KIND under EB->FS_ROOT.
  72  * ACTION describes what is happening to the node (see enum svn_node_action).
  73  * Write record to writable EB->STREAM, using EB->BUFFER to write in chunks.
  74  *
  75  * If the node was itself copied, IS_COPY is TRUE and the
  76  * path/revision of the copy source are in CMP_PATH/CMP_REV.  If
  77  * IS_COPY is FALSE, yet CMP_PATH/CMP_REV are valid, this node is part
  78  * of a copied subtree.
  79  */
  80 static svn_error_t *dump_node(struct dump_edit_baton *eb,
  81                               const char *path,    /* an absolute path. */
  82                               svn_node_kind_t kind,
  83                               enum svn_node_action action,
  84                               const char *cmp_path,
  85                               svn_revnum_t cmp_rev,
  86                               apr_pool_t *pool)
  87 {
  88         /* Write out metadata headers for this file node. */
  89         SVN_ERR(svn_stream_printf(eb->stream, pool,
  90                                   SVN_REPOS_DUMPFILE_NODE_PATH ": %s\n",
  91                                   (*path == '/') ? path + 1 : path));
  92
  93         if (kind == svn_node_file)
  94                 SVN_ERR(svn_stream_printf(eb->stream, pool,
  95                                           SVN_REPOS_DUMPFILE_NODE_KIND ": file\n"));
  96         else if (kind == svn_node_dir)
  97                 SVN_ERR(svn_stream_printf(eb->stream, pool,
  98                                           SVN_REPOS_DUMPFILE_NODE_KIND ": dir\n"));
  99
 100         /* Remove leading slashes from copyfrom paths. */
 101         if (cmp_path)
 102                 cmp_path = ((*cmp_path == '/') ? cmp_path + 1 : cmp_path);
 103
 104         switch (action) {
 105                 /* Appropriately handle the four svn_node_action actions */
 106
 107         case svn_node_action_change:
 108                 SVN_ERR(svn_stream_printf(eb->stream, pool,
 109                                           SVN_REPOS_DUMPFILE_NODE_ACTION
 110                                           ": change\n"));
 111                 break;
 112
 113         case svn_node_action_replace:
 114                 if (!eb->is_copy) {
 115                         /* a simple delete+add, implied by a single 'replace' action. */
 116                         SVN_ERR(svn_stream_printf(eb->stream, pool,
 117                                                   SVN_REPOS_DUMPFILE_NODE_ACTION
 118                                                   ": replace\n"));
 119
 120                         eb->dump_props_pending = TRUE;
 121                         break;
 122                 }
 123                 /* More complex case: eb->is_copy is true, and
 124                    cmp_path/ cmp_rev are present: delete the original,
 125                    and then re-add it */
 126
 127                 /* the path & kind headers have already been printed;  just
 128                    add a delete action, and end the current record.*/
 129                 SVN_ERR(svn_stream_printf(eb->stream, pool,
 130                                           SVN_REPOS_DUMPFILE_NODE_ACTION
 131                                           ": delete\n\n"));
 132
 133                 /* recurse:  print an additional add-with-history record. */
 134                 SVN_ERR(dump_node(eb, path, kind, svn_node_action_add,
 135                                   cmp_path, cmp_rev, pool));
 136
 137                 /* we can leave this routine quietly now, don't need to dump
 138                    any content;  that was already done in the second record. */
 139                 eb->must_dump_props = FALSE;
 140                 eb->is_copy = FALSE;
 141                 break;
 142
 143         case svn_node_action_delete:
 144                 SVN_ERR(svn_stream_printf(eb->stream, pool,
 145                                           SVN_REPOS_DUMPFILE_NODE_ACTION
 146                                           ": delete\n"));
 147
 148                 /* we can leave this routine quietly now, don't need to dump
 149                    any content. */
 150                 SVN_ERR(svn_stream_printf(eb->stream, pool, "\n\n"));
 151                 eb->must_dump_props = FALSE;
 152                 break;
 153
 154         case svn_node_action_add:
 155                 SVN_ERR(svn_stream_printf(eb->stream, pool,
 156                                           SVN_REPOS_DUMPFILE_NODE_ACTION ": add\n"));
 157
 158                 if (!eb->is_copy) {
 159                         /* eb->dump_props_pending for files is handled in
 160                            close_file which is called immediately.
 161                            However, directories are not closed until
 162                            all the work inside them have been done;
 163                            eb->dump_props_pending for directories is
 164                            handled in all the functions that can
 165                            possibly be called after add_directory:
 166                            add_directory, open_directory,
 167                            delete_entry, close_directory, add_file,
 168                            open_file and change_dir_prop;
 169                            change_dir_prop is a special case
 170                            ofcourse */
 171
 172                         eb->dump_props_pending = TRUE;
 173                         break;
 174                 }
 175
 176                 SVN_ERR(svn_stream_printf(eb->stream, pool,
 177                                           SVN_REPOS_DUMPFILE_NODE_COPYFROM_REV
 178                                           ": %ld\n"
 179                                           SVN_REPOS_DUMPFILE_NODE_COPYFROM_PATH
 180                                           ": %s\n",
 181                                           cmp_rev, cmp_path));
 182
 183                 /* Dump the text only if apply_textdelta sets
 184                    eb->must_dump_text */
 185
 186                 /* UGLY hack: If a directory was copied from a
 187                    previous revision, nothing else can be done, and
 188                    close_file won't be called to write two blank
 189                    lines; write them here */
 190                 if (kind == svn_node_dir)
 191                         SVN_ERR(svn_stream_printf(eb->stream, pool, "\n\n"));
 192
 193                 eb->is_copy = FALSE;
 194
 195                 break;
 196         }
 197
 198         /* Dump property headers */
 199         SVN_ERR(dump_props(eb, &(eb->must_dump_props), FALSE, pool));
 200
 201         return SVN_NO_ERROR;
 202 }
 203
 204 static svn_error_t *open_root(void *edit_baton,
 205                               svn_revnum_t base_revision,
 206                               apr_pool_t *pool,
 207                               void **root_baton)
 208 {
 209         /* Allocate a special pool for the edit_baton to avoid pool
 210            lifetime issues */
 211         struct dump_edit_baton *eb = edit_baton;
 212         eb->pool = svn_pool_create(pool);
 213         eb->properties = apr_hash_make(eb->pool);
 214         eb->del_properties = apr_hash_make(eb->pool);
 215         eb->propstring = svn_stringbuf_create("", eb->pool);
 216         eb->is_copy = FALSE;
 217
 218         *root_baton = make_dir_baton(NULL, NULL, SVN_INVALID_REVNUM,
 219                                      edit_baton, NULL, FALSE, pool);
 220         return SVN_NO_ERROR;
 221 }
 222
 223 static svn_error_t *delete_entry(const char *path,
 224                                  svn_revnum_t revision,
 225                                  void *parent_baton,
 226                                  apr_pool_t *pool)
 227 {
 228         struct dir_baton *pb = parent_baton;
 229         const char *mypath = apr_pstrdup(pb->pool, path);
 230
 231         /* Some pending properties to dump? */
 232         SVN_ERR(dump_props(pb->eb, &(pb->eb->dump_props_pending), TRUE, pool));
 233
 234         /* remember this path needs to be deleted */
 235         apr_hash_set(pb->deleted_entries, mypath, APR_HASH_KEY_STRING, pb);
 236
 237         return SVN_NO_ERROR;
 238 }
 239
 240 static svn_error_t *add_directory(const char *path,
 241                                   void *parent_baton,
 242                                   const char *copyfrom_path,
 243                                   svn_revnum_t copyfrom_rev,
 244                                   apr_pool_t *pool,
 245                                   void **child_baton)
 246 {
 247         struct dir_baton *pb = parent_baton;
 248         void *val;
 249         struct dir_baton *new_db
 250                 = make_dir_baton(path, copyfrom_path, copyfrom_rev, pb->eb, pb, TRUE, pool);
 251
 252         /* Some pending properties to dump? */
 253         SVN_ERR(dump_props(pb->eb, &(pb->eb->dump_props_pending), TRUE, pool));
 254
 255         /* This might be a replacement -- is the path already deleted? */
 256         val = apr_hash_get(pb->deleted_entries, path, APR_HASH_KEY_STRING);
 257
 258         /* Detect an add-with-history */
 259         pb->eb->is_copy = ARE_VALID_COPY_ARGS(copyfrom_path, copyfrom_rev);
 260
 261         /* Dump the node */
 262         SVN_ERR(dump_node(pb->eb, path,
 263                           svn_node_dir,
 264                           val ? svn_node_action_replace : svn_node_action_add,
 265                           pb->eb->is_copy ? copyfrom_path : NULL,
 266                           pb->eb->is_copy ? copyfrom_rev : SVN_INVALID_REVNUM,
 267                           pool));
 268
 269         if (val)
 270                 /* Delete the path, it's now been dumped */
 271                 apr_hash_set(pb->deleted_entries, path, APR_HASH_KEY_STRING, NULL);
 272
 273         new_db->written_out = TRUE;
 274
 275         *child_baton = new_db;
 276         return SVN_NO_ERROR;
 277 }
 278
 279 static svn_error_t *open_directory(const char *path,
 280                                    void *parent_baton,
 281                                    svn_revnum_t base_revision,
 282                                    apr_pool_t *pool,
 283                                    void **child_baton)
 284 {
 285         struct dir_baton *pb = parent_baton;
 286         struct dir_baton *new_db;
 287         const char *cmp_path = NULL;
 288         svn_revnum_t cmp_rev = SVN_INVALID_REVNUM;
 289         apr_array_header_t *compose_path = apr_array_make(pool, 2, sizeof(const char *));
 290
 291         /* Some pending properties to dump? */
 292         SVN_ERR(dump_props(pb->eb, &(pb->eb->dump_props_pending), TRUE, pool));
 293
 294         /* If the parent directory has explicit comparison path and rev,
 295            record the same for this one. */
 296         if (pb && ARE_VALID_COPY_ARGS(pb->cmp_path, pb->cmp_rev)) {
 297                 APR_ARRAY_PUSH(compose_path, const char *) = pb->cmp_path;
 298                 APR_ARRAY_PUSH(compose_path, const char *) = svn_relpath_basename(path, pool);
 299                 cmp_path = svn_path_compose(compose_path, pool);
 300                 cmp_rev = pb->cmp_rev;
 301         }
 302
 303         new_db = make_dir_baton(path, cmp_path, cmp_rev, pb->eb, pb, FALSE, pool);
 304         *child_baton = new_db;
 305         return SVN_NO_ERROR;
 306 }
 307
 308 static svn_error_t *close_directory(void *dir_baton,
 309                                     apr_pool_t *pool)
 310 {
 311         struct dir_baton *db = dir_baton;
 312         struct dump_edit_baton *eb = db->eb;
 313         apr_hash_index_t *hi;
 314         apr_pool_t *subpool = svn_pool_create(pool);
 315
 316         /* Some pending properties to dump? */
 317         SVN_ERR(dump_props(eb, &(eb->dump_props_pending), TRUE, pool));
 318
 319         /* Dump the directory entries */
 320         for (hi = apr_hash_first(pool, db->deleted_entries); hi;
 321              hi = apr_hash_next(hi)) {
 322                 const void *key;
 323                 const char *path;
 324                 apr_hash_this(hi, &key, NULL, NULL);
 325                 path = key;
 326
 327                 svn_pool_clear(subpool);
 328
 329                 SVN_ERR(dump_node(db->eb, path,
 330                                   svn_node_unknown, svn_node_action_delete,
 331                                   NULL, SVN_INVALID_REVNUM, subpool));
 332         }
 333
 334         svn_pool_destroy(subpool);
 335         return SVN_NO_ERROR;
 336 }
 337
 338 static svn_error_t *add_file(const char *path,
 339                              void *parent_baton,
 340                              const char *copyfrom_path,
 341                              svn_revnum_t copyfrom_rev,
 342                              apr_pool_t *pool,
 343                              void **file_baton)
 344 {
 345         struct dir_baton *pb = parent_baton;
 346         void *val;
 347
 348         /* Some pending properties to dump? */
 349         SVN_ERR(dump_props(pb->eb, &(pb->eb->dump_props_pending), TRUE, pool));
 350
 351         /* This might be a replacement -- is the path already deleted? */
 352         val = apr_hash_get(pb->deleted_entries, path, APR_HASH_KEY_STRING);
 353
 354         /* Detect add-with-history. */
 355         pb->eb->is_copy = ARE_VALID_COPY_ARGS(copyfrom_path, copyfrom_rev);
 356
 357         /* Dump the node. */
 358         SVN_ERR(dump_node(pb->eb, path,
 359                           svn_node_file,
 360                           val ? svn_node_action_replace : svn_node_action_add,
 361                           pb->eb->is_copy ? copyfrom_path : NULL,
 362                           pb->eb->is_copy ? copyfrom_rev : SVN_INVALID_REVNUM,
 363                           pool));
 364
 365         if (val)
 366                 /* delete the path, it's now been dumped. */
 367                 apr_hash_set(pb->deleted_entries, path, APR_HASH_KEY_STRING, NULL);
 368
 369         /* Build a nice file baton to pass to change_file_prop and apply_textdelta */
 370         pb->eb->changed_path = path;
 371         *file_baton = pb->eb;
 372
 373         return SVN_NO_ERROR;
 374 }
 375
 376 static svn_error_t *open_file(const char *path,
 377                               void *parent_baton,
 378                               svn_revnum_t ancestor_revision,
 379                               apr_pool_t *pool,
 380                               void **file_baton)
 381 {
 382         struct dir_baton *pb = parent_baton;
 383         const char *cmp_path = NULL;
 384         svn_revnum_t cmp_rev = SVN_INVALID_REVNUM;
 385
 386         /* Some pending properties to dump? */
 387         SVN_ERR(dump_props(pb->eb, &(pb->eb->dump_props_pending), TRUE, pool));
 388
 389         apr_array_header_t *compose_path = apr_array_make(pool, 2, sizeof(const char *));
 390         /* If the parent directory has explicit comparison path and rev,
 391            record the same for this one. */
 392         if (pb && ARE_VALID_COPY_ARGS(pb->cmp_path, pb->cmp_rev)) {
 393                 APR_ARRAY_PUSH(compose_path, const char *) = pb->cmp_path;
 394                 APR_ARRAY_PUSH(compose_path, const char *) = svn_relpath_basename(path, pool);
 395                 cmp_path = svn_path_compose(compose_path, pool);
 396                 cmp_rev = pb->cmp_rev;
 397         }
 398
 399         SVN_ERR(dump_node(pb->eb, path,
 400                           svn_node_file, svn_node_action_change,
 401                           cmp_path, cmp_rev, pool));
 402
 403         /* Build a nice file baton to pass to change_file_prop and apply_textdelta */
 404         pb->eb->changed_path = path;
 405         *file_baton = pb->eb;
 406
 407         return SVN_NO_ERROR;
 408 }
 409
 410 static svn_error_t *change_dir_prop(void *parent_baton,
 411                                     const char *name,
 412                                     const svn_string_t *value,
 413                                     apr_pool_t *pool)
 414 {
 415         struct dir_baton *db = parent_baton;
 416
 417         if (svn_property_kind(NULL, name) != svn_prop_regular_kind)
 418                 return SVN_NO_ERROR;
 419
 420         value ? apr_hash_set(db->eb->properties, apr_pstrdup(pool, name),
 421                              APR_HASH_KEY_STRING, svn_string_dup(value, pool)) :
 422                 apr_hash_set(db->eb->del_properties, apr_pstrdup(pool, name),
 423                              APR_HASH_KEY_STRING, (void *)0x1);
 424
 425         /* This function is what distinguishes between a directory that is
 426            opened to merely get somewhere, vs. one that is opened because it
 427            actually changed by itself  */
 428         if (! db->written_out) {
 429                 /* If eb->dump_props_pending was set, it means that the
 430                    node information corresponding to add_directory has already
 431                    been written; just don't unset it and dump_node will dump
 432                    the properties before doing anything else. If it wasn't
 433                    set, node information hasn't been written yet: so dump the
 434                    node itself before dumping the props */
 435
 436                 SVN_ERR(dump_node(db->eb, db->path,
 437                                   svn_node_dir, svn_node_action_change,
 438                                   db->cmp_path, db->cmp_rev, pool));
 439
 440                 SVN_ERR(dump_props(db->eb, NULL, TRUE, pool));
 441                 db->written_out = TRUE;
 442         }
 443         return SVN_NO_ERROR;
 444 }
 445
 446 static svn_error_t *change_file_prop(void *file_baton,
 447                                      const char *name,
 448                                      const svn_string_t *value,
 449                                      apr_pool_t *pool)
 450 {
 451         struct dump_edit_baton *eb = file_baton;
 452
 453         if (svn_property_kind(NULL, name) != svn_prop_regular_kind)
 454                 return SVN_NO_ERROR;
 455
 456         apr_hash_set(eb->properties, apr_pstrdup(pool, name),
 457                      APR_HASH_KEY_STRING, value ?
 458                      svn_string_dup(value, pool): (void *)0x1);
 459
 460         /* Dump the property headers and wait; close_file might need
 461            to write text headers too depending on whether
 462            apply_textdelta is called */
 463         eb->dump_props_pending = TRUE;
 464
 465         return SVN_NO_ERROR;
 466 }
 467
 468 static svn_error_t *window_handler(svn_txdelta_window_t *window, void *baton)
 469 {
 470         struct handler_baton *hb = baton;
 471         struct dump_edit_baton *eb = hb->eb;
 472         static svn_error_t *err;
 473
 474         err = hb->apply_handler(window, hb->apply_baton);
 475         if (window != NULL && !err)
 476                 return SVN_NO_ERROR;
 477
 478         if (err)
 479                 SVN_ERR(err);
 480
 481         /* Write information about the filepath to hb->eb */
 482         eb->temp_filepath = apr_pstrdup(eb->pool,
 483                                         hb->temp_filepath);
 484
 485         /* Cleanup */
 486         SVN_ERR(svn_io_file_close(hb->temp_file, hb->pool));
 487         SVN_ERR(svn_stream_close(hb->temp_filestream));
 488         svn_pool_destroy(hb->pool);
 489         return SVN_NO_ERROR;
 490 }
 491
 492 static svn_error_t *apply_textdelta(void *file_baton, const char *base_checksum,
 493                                     apr_pool_t *pool,
 494                                     svn_txdelta_window_handler_t *handler,
 495                                     void **handler_baton)
 496 {
 497         struct dump_edit_baton *eb = file_baton;
 498         apr_status_t apr_err;
 499         const char *tempdir;
 500
 501         /* Custom handler_baton allocated in a separate pool */
 502         apr_pool_t *handler_pool = svn_pool_create(pool);
 503         struct handler_baton *hb = apr_pcalloc(handler_pool, sizeof(*hb));
 504         hb->pool = handler_pool;
 505         hb->eb = eb;
 506
 507         /* Use a temporary file to measure the text-content-length */
 508         SVN_ERR(svn_io_temp_dir(&tempdir, hb->pool));
 509
 510         hb->temp_filepath = svn_dirent_join(tempdir, "XXXXXX", hb->pool);
 511         apr_err = apr_file_mktemp(&(hb->temp_file), hb->temp_filepath,
 512                                   APR_CREATE | APR_READ | APR_WRITE | APR_EXCL,
 513                                   hb->pool);
 514         if (apr_err != APR_SUCCESS)
 515                 SVN_ERR(svn_error_wrap_apr(apr_err, NULL));
 516
 517         hb->temp_filestream = svn_stream_from_aprfile2(hb->temp_file, TRUE, hb->pool);
 518
 519         /* Prepare to write the delta to the temporary file */
 520         svn_txdelta_to_svndiff2(&(hb->apply_handler), &(hb->apply_baton),
 521                                 hb->temp_filestream, 0, hb->pool);
 522         eb->must_dump_text = TRUE;
 523
 524         /* The actual writing takes place when this function has finished */
 525         /* Set the handler and handler_baton */
 526         *handler = window_handler;
 527         *handler_baton = hb;
 528
 529         return SVN_NO_ERROR;
 530 }
 531
 532 static svn_error_t *close_file(void *file_baton,
 533                                const char *text_checksum,
 534                                apr_pool_t *pool)
 535 {
 536         struct dump_edit_baton *eb = file_baton;
 537         apr_file_t *temp_file;
 538         svn_stream_t *temp_filestream;
 539         apr_finfo_t *info = apr_pcalloc(pool, sizeof(apr_finfo_t));
 540
 541         /* We didn't write the property headers because we were
 542            waiting for file_prop_change; write them now */
 543         SVN_ERR(dump_props(eb, &(eb->dump_props_pending), FALSE, pool));
 544
 545         /* The prop headers have already been dumped in dump_node */
 546         /* Dump the text headers */
 547         if (eb->must_dump_text) {
 548                 /* text-delta header */
 549                 SVN_ERR(svn_stream_printf(eb->stream, pool,
 550                                           SVN_REPOS_DUMPFILE_TEXT_DELTA
 551                                           ": true\n"));
 552
 553                 /* Measure the length */
 554                 SVN_ERR(svn_io_stat(info, eb->temp_filepath, APR_FINFO_SIZE, pool));
 555
 556                 /* text-content-length header */
 557                 SVN_ERR(svn_stream_printf(eb->stream, pool,
 558                                           SVN_REPOS_DUMPFILE_TEXT_CONTENT_LENGTH
 559                                           ": %lu\n",
 560                                           (unsigned long)info->size));
 561                 /* text-content-md5 header */
 562                 SVN_ERR(svn_stream_printf(eb->stream, pool,
 563                                           SVN_REPOS_DUMPFILE_TEXT_CONTENT_MD5
 564                                           ": %s\n",
 565                                           text_checksum));
 566         }
 567
 568         /* content-length header: if both text and props are absent,
 569            skip this block */
 570         if (eb->must_dump_props || eb->dump_props_pending)
 571                 SVN_ERR(svn_stream_printf(eb->stream, pool,
 572                                           SVN_REPOS_DUMPFILE_CONTENT_LENGTH
 573                                           ": %ld\n\n",
 574                                           (unsigned long)info->size + eb->propstring->len));
 575         else if (eb->must_dump_text)
 576                 SVN_ERR(svn_stream_printf(eb->stream, pool,
 577                                           SVN_REPOS_DUMPFILE_CONTENT_LENGTH
 578                                           ": %ld\n\n",
 579                                           (unsigned long)info->size));
 580
 581         /* Dump the props; the propstring should have already been
 582            written in dump_node or above */
 583         if (eb->must_dump_props || eb->dump_props_pending) {
 584                 SVN_ERR(svn_stream_write(eb->stream, eb->propstring->data,
 585                                          &(eb->propstring->len)));
 586
 587                 /* Cleanup */
 588                 eb->must_dump_props = eb->dump_props_pending = FALSE;
 589                 apr_hash_clear(eb->properties);
 590                 apr_hash_clear(eb->del_properties);
 591         }
 592
 593         /* Dump the text */
 594         if (eb->must_dump_text) {
 595
 596                 /* Open the temporary file, map it to a stream, copy
 597                    the stream to eb->stream, close and delete the
 598                    file */
 599                 SVN_ERR(svn_io_file_open(&temp_file, eb->temp_filepath, APR_READ, 0600, pool));
 600                 temp_filestream = svn_stream_from_aprfile2(temp_file, TRUE, pool);
 601                 SVN_ERR(svn_stream_copy3(temp_filestream, eb->stream, NULL, NULL, pool));
 602
 603                 /* Cleanup */
 604                 SVN_ERR(svn_io_file_close(temp_file, pool));
 605                 SVN_ERR(svn_stream_close(temp_filestream));
 606                 SVN_ERR(svn_io_remove_file2(eb->temp_filepath, TRUE, pool));
 607                 eb->must_dump_text = FALSE;
 608         }
 609
 610         SVN_ERR(svn_stream_printf(eb->stream, pool, "\n\n"));
 611
 612         return SVN_NO_ERROR;
 613 }
 614
 615 static svn_error_t *close_edit(void *edit_baton, apr_pool_t *pool)
 616 {
 617         struct dump_edit_baton *eb = edit_baton;
 618         svn_pool_destroy(eb->pool);
 619         (eb->current_rev) ++;
 620
 621         return SVN_NO_ERROR;
 622 }
 623
 624 svn_error_t *get_dump_editor(const svn_delta_editor_t **editor,
 625                              void **edit_baton,
 626                              svn_revnum_t from_rev,
 627                              apr_pool_t *pool)
 628 {
 629         struct dump_edit_baton *eb = apr_pcalloc(pool, sizeof(struct dump_edit_baton));
 630         eb->current_rev = from_rev;
 631         SVN_ERR(svn_stream_for_stdout(&(eb->stream), pool));
 632         svn_delta_editor_t *de = svn_delta_default_editor(pool);
 633
 634         de->open_root = open_root;
 635         de->delete_entry = delete_entry;
 636         de->add_directory = add_directory;
 637         de->open_directory = open_directory;
 638         de->close_directory = close_directory;
 639         de->change_dir_prop = change_dir_prop;
 640         de->change_file_prop = change_file_prop;
 641         de->apply_textdelta = apply_textdelta;
 642         de->add_file = add_file;
 643         de->open_file = open_file;
 644         de->close_file = close_file;
 645         de->close_edit = close_edit;
 646
 647         /* Set the edit_baton and editor */
 648         *edit_baton = eb;
 649         *editor = de;
 650
 651         return SVN_NO_ERROR;
 652 }