script/Vss2Svn/Dumpfile.pm

   1 package Vss2Svn::Dumpfile;
   2
   3 use Vss2Svn::Dumpfile::Node;
   4 use Encode qw(from_to);
   5
   6 use warnings;
   7 use strict;
   8
   9 our %gHandlers =
  10     (
  11      ADD        => \&_add_handler,
  12      COMMIT     => \&_commit_handler,
  13      RENAME     => \&_rename_handler,
  14      SHARE      => \&_share_handler,
  15      BRANCH     => \&_branch_handler,
  16      MOVE       => \&_move_handler,
  17      DELETE     => \&_delete_handler,
  18      RECOVER    => \&_recover_handler,
  19     );
  20
  21 # Keep track of when paths were modified or deleted, for subsequent copies
  22 # or recovers.
  23
  24 our %gModified = ();
  25 our %gDeleted = ();
  26
  27 ###############################################################################
  28 #  new
  29 ###############################################################################
  30 sub new {
  31     my($class, $fh) = @_;
  32
  33     my $self =
  34         {
  35          fh => $fh,
  36          revision => 0,
  37          errors => [],
  38          modified_cache => {},
  39          deleted_cache => {},
  40          svn_items => {},
  41          junk_itempaths => {},
  42          need_junkdir => 0,
  43          need_missing_dirs => [],
  44         };
  45
  46     # prevent perl from doing line-ending conversions
  47     binmode($fh);
  48
  49     my $old = select($fh);
  50     $| = 1;
  51     select($old);
  52
  53     print $fh "SVN-fs-dump-format-version: 2\n\n";
  54
  55     $self = bless($self, $class);
  56     return $self;
  57
  58 }  #  End new
  59
  60 ###############################################################################
  61 #  finish
  62 ###############################################################################
  63 sub finish {
  64     my($self) = @_;
  65
  66     my $fh = $self->{fh};
  67
  68     print $fh "\n\n";
  69
  70 }  #  End finish
  71
  72 ###############################################################################
  73 #  begin_revision
  74 ###############################################################################
  75 sub begin_revision {
  76     my($self, $data) = @_;
  77     my($revision, $author, $timestamp, $comment) =
  78         @{ $data }{qw(revision_id author timestamp comment)};
  79
  80     my $props = [];
  81     my $fh = $self->{fh};
  82
  83     print $fh "\nRevision-number: $revision\n";
  84
  85     $comment = '' if !defined($comment);
  86     $author = '' if !defined($author);
  87
  88     # convert to utf8
  89     from_to ($comment, "windows-1252", "utf8");
  90     from_to ($author, "windows-1252", "utf8");
  91
  92     if ($revision > 0) {
  93         push @$props, ['svn:log', $comment];
  94         push @$props, ['svn:author', $author];
  95     }
  96
  97     push @$props, ['svn:date', $self->svn_timestamp($timestamp)];
  98
  99     $self->output_content($props);
 100     $self->{revision} = $revision;
 101
 102 }  #  End begin_revision
 103
 104 ###############################################################################
 105 #  do_action
 106 ###############################################################################
 107 sub do_action {
 108     my($self, $data, $expdir) = @_;
 109
 110     my $action = $data->{action};
 111
 112     my $nodes = [];
 113
 114     # Temporary hack to prevent shared files from stepping on the "modified"
 115     # flag for other than the first commit. Ideally, we should keep all paths
 116     # for a given physical file's last modified flags, and use the best match
 117     # if we need to copy or recover one.
 118
 119     $self->{is_primary} = 1;
 120     $self->{modified_cache} = {};
 121     $self->{deleted_cache} = {};
 122
 123     my($handler, $this_action);
 124
 125     foreach my $itempath (split "\t", $data->{itempaths}) {
 126         $this_action = $action;
 127
 128         if(defined($itempath)) {
 129             ($this_action, $itempath) =
 130                 $self->_action_path_sanity_check($this_action, $itempath, $data);
 131
 132             return 0 unless defined($itempath);
 133
 134         } else {
 135             # if the item's path isn't defined, its real name was corrupted in
 136             # vss, so we'll check it in to the junk drawer as an add
 137             if (defined $main::gCfg{junkdir}) {
 138                 $itempath = $self->_get_junk_itempath($main::gCfg{junkdir},
 139                     join('.', @$data{ qw(physname version revision_id) }));
 140
 141                 $self->add_error("Using filename '$itempath' for item with "
 142                     . "unrecoverable name at revision $data->{revision_id}");
 143
 144                 $this_action = 'ADD';
 145             } else {
 146                 return 0;
 147             }
 148         }
 149
 150         # if need_junkdir = 1, the first item is just about to be added to the
 151         # junk drawer, so create the dumpfile node to add this directory
 152         if ($self->{need_junkdir} == 1) {
 153             $self->_add_svn_dir($nodes, $main::gCfg{junkdir});
 154             $self->{need_junkdir} = -1;
 155         }
 156
 157         foreach my $dir (@{ $self->{need_missing_dirs} }) {
 158             $self->_add_svn_dir($nodes, $dir);
 159             $self->add_error("Creating missing directory '$dir' for item "
 160                 . "'$itempath' at revision $data->{revision_id}");
 161         }
 162
 163         $handler = $gHandlers{$this_action};
 164
 165         $self->$handler($itempath, $nodes, $data, $expdir);
 166         $self->{is_primary} = 0;
 167     }
 168
 169     foreach my $node (@$nodes) {
 170         $self->output_node($node);
 171     }
 172
 173     my($physname, $cache);
 174     while(($physname, $cache) = each %{ $self->{modified_cache} }) {
 175         $gModified{$physname} = $cache;
 176     }
 177
 178     while(($physname, $cache) = each %{ $self->{deleted_cache} }) {
 179         $gDeleted{$physname} = $cache;
 180     }
 181
 182 }  #  End do_action
 183
 184 ###############################################################################
 185 #  _get_junk_itempath
 186 ###############################################################################
 187 sub _get_junk_itempath {
 188     my($self, $dir, $base) = @_;
 189
 190     $base =~ s:.*/::;
 191     my $itempath = "$dir/$base";
 192     my $count = 1;
 193
 194     if($self->{need_junkdir} == 0) {
 195         $self->{need_junkdir} = 1;
 196     }
 197
 198     if(!defined($self->{junk_itempaths}->{$itempath})) {
 199         $self->{junk_itempaths}->{$itempath} = 1;
 200         return $itempath;
 201     }
 202
 203     my($file, $ext);
 204
 205     if($base =~ m/^(.*)\.(.*)/) {
 206         ($file, $ext) = ($1, ".$2");
 207     } else {
 208         ($file, $ext) = ($base, '');
 209     }
 210
 211     while(defined($self->{junk_itempaths}->{$itempath})) {
 212         $itempath = "$dir/$file.$count$ext";
 213         $count++;
 214     }
 215
 216     return $itempath;
 217 }  #  End _get_junk_itempath
 218
 219 ###############################################################################
 220 #  _action_path_sanity_check
 221 ###############################################################################
 222 sub _action_path_sanity_check {
 223     my($self, $action, $itempath, $data) = @_;
 224
 225     my($itemtype, $revision_id) = @{ $data }{qw(itemtype revision_id)};
 226
 227     return($action, $itempath) if ($itempath eq '' || $itempath eq '/');
 228
 229     my($newaction, $newpath) = ($action, $itempath);
 230     my $success;
 231
 232     $self->{need_missing_dirs} = [];
 233
 234     if($action eq 'ADD' || $action eq 'SHARE' || $action eq 'RECOVER') {
 235         $success = $self->_add_svn_struct_item($itempath, $itemtype);
 236
 237         if(!defined($success)) {
 238             $newpath = undef;
 239             $self->add_error("Path consistency failure while trying to add "
 240                 . "item '$itempath' at revision $revision_id; skipping");
 241
 242         } elsif($success == 0) {
 243             # trying to re-add existing item; if file, change it to a commit
 244             if ($itemtype == 1) {
 245
 246                 $newpath = undef;
 247                 $self->add_error("Attempt to re-add directory '$itempath' at "
 248                 . "revision $revision_id; possibly missing delete");
 249
 250             } else {
 251
 252                 $newaction = 'COMMIT';
 253                 $self->add_error("Attempt to re-add file '$itempath' at "
 254                     . "revision $revision_id, changing to modify; possibly "
 255                     . "missing delete");
 256
 257             }
 258         }
 259
 260     } elsif ($action eq 'DELETE') {
 261         $success = $self->_delete_svn_struct_item($itempath, $itemtype);
 262
 263         if(!$success) {
 264             $newpath = undef;
 265             $self->add_error("Attempt to delete non-existent item '$itempath' "
 266                 . "at revision $revision_id; skipping...");
 267         }
 268
 269     } elsif ($action eq 'RENAME') {
 270         $success = $self->_rename_svn_struct_item($itempath, $itemtype,
 271             $data->{info});
 272
 273         if(!$success) {
 274             $newpath = undef;
 275             $self->add_error("Attempt to rename non-existent item '$itempath' "
 276                 . "at revision $revision_id; skipping...");
 277         }
 278     } elsif ($action eq 'MOVE') {
 279         my ($ref, $item) = $self->_get_svn_struct_ref_for_move($itempath);
 280
 281         if(!$ref) {
 282             $newpath = undef;
 283             $self->add_error("Attempt to move non-existent directory '$itempath' "
 284                 . "at revision $revision_id; skipping...");
 285         }
 286
 287         $success = $self->_add_svn_struct_item($data->{info}, 1, $ref->{$item});
 288
 289         if(!$success) {
 290             $newpath = undef;
 291             $self->add_error("Error while attempting to move directory '$itempath' "
 292                 . "at revision $revision_id; skipping...");
 293         }
 294
 295         delete $ref->{$item};
 296     }
 297
 298     return($newaction, $newpath);
 299
 300 }  #  End _action_path_sanity_check
 301
 302 ###############################################################################
 303 #  _add_svn_struct_item
 304 ###############################################################################
 305 sub _add_svn_struct_item {
 306     my($self, $itempath, $itemtype, $newref) = @_;
 307
 308     $itempath =~ s:^/::;
 309     my @subdirs = split '/', $itempath;
 310
 311     my $item = pop(@subdirs);
 312     my $ref = $self->{svn_items};
 313
 314     my $thispath = '';
 315
 316     foreach my $subdir (@subdirs) {
 317         $thispath .= "$subdir/";
 318
 319         if(ref($ref) ne 'HASH') {
 320             return undef;
 321         }
 322         if(!defined($ref->{$subdir})) {
 323             # parent directory doesn't exist; add it to list of missing dirs
 324             # to build up
 325             push @{ $self->{need_missing_dirs} }, $thispath;
 326
 327             $ref->{$subdir} = {};
 328         }
 329
 330         $ref = $ref->{$subdir};
 331     }
 332
 333     if(ref($ref) ne 'HASH') {
 334         # parent "directory" is actually a file
 335         return undef;
 336     }
 337
 338     if(defined($ref->{$item})) {
 339         # item already exists; can't add it
 340         return 0;
 341     }
 342
 343     if(defined($newref)) {
 344         $ref->{$item} = $newref;
 345     } else {
 346         $ref->{$item} = ($itemtype == 1)? {} : 1;
 347     }
 348
 349     return 1;
 350
 351 }  #  End _add_svn_struct_item
 352
 353 ###############################################################################
 354 #  _delete_svn_struct_item
 355 ###############################################################################
 356 sub _delete_svn_struct_item {
 357     my($self, $itempath, $itemtype) = @_;
 358
 359     return $self->_delete_rename_svn_struct_item($itempath, $itemtype);
 360 }  #  End _delete_svn_struct_item
 361
 362 ###############################################################################
 363 #  _rename_svn_struct_item
 364 ###############################################################################
 365 sub _rename_svn_struct_item {
 366     my($self, $itempath, $itemtype, $newname) = @_;
 367
 368     return $self->_delete_rename_svn_struct_item($itempath, $itemtype, $newname);
 369 }  #  End _rename_svn_struct_item
 370
 371 ###############################################################################
 372 #  _delete_rename_svn_struct_item
 373 ###############################################################################
 374 sub _delete_rename_svn_struct_item {
 375     my($self, $itempath, $itemtype, $newname, $movedref) = @_;
 376
 377     $itempath =~ s:^/::;
 378     $newname =~ s:/$:: if defined($newname);
 379     my @subdirs = split '/', $itempath;
 380
 381     my $item = pop(@subdirs);
 382     my $ref = $self->{svn_items};
 383
 384     foreach my $subdir (@subdirs) {
 385         if(!(ref($ref) eq 'HASH') || !defined($ref->{$subdir})) {
 386             # can't get to item because a parent directory doesn't exist; give up
 387             return undef;
 388         }
 389
 390         $ref = $ref->{$subdir};
 391     }
 392
 393     if((ref($ref) ne 'HASH') || !defined($ref->{$item})) {
 394         # item doesn't exist; can't delete/rename it
 395         return 0;
 396     }
 397
 398     if(defined $newname) {
 399         $ref->{$newname} = $ref->{$item};
 400     }
 401
 402     delete $ref->{$item};
 403
 404     return 1;
 405
 406 }  #  End _delete_rename_svn_struct_item
 407
 408 ###############################################################################
 409 #  _get_svn_struct_ref_for_move
 410 ###############################################################################
 411 sub _get_svn_struct_ref_for_move {
 412     my($self, $itempath) = @_;
 413
 414     $itempath =~ s:^/::;
 415     my @subdirs = split '/', $itempath;
 416
 417     my $item = pop(@subdirs);
 418     my $ref = $self->{svn_items};
 419
 420     my $thispath = '';
 421
 422     foreach my $subdir (@subdirs) {
 423         $thispath .= "$subdir/";
 424
 425         if(ref($ref) ne 'HASH') {
 426             return undef;
 427         }
 428         if(!defined($ref->{$subdir})) {
 429             return undef;
 430         }
 431
 432         $ref = $ref->{$subdir};
 433     }
 434
 435     if((ref($ref) ne 'HASH') || !defined($ref->{$item}) ||
 436        (ref($ref->{$item} ne 'HASH'))) {
 437         return undef;
 438     }
 439
 440     return ($ref, $item);
 441
 442 }  #  End _get_svn_struct_ref_for_move
 443
 444 ###############################################################################
 445 #  _add_svn_dir
 446 ###############################################################################
 447 sub _add_svn_dir {
 448     my($self, $nodes, $dir) = @_;
 449
 450     my $node = Vss2Svn::Dumpfile::Node->new();
 451     my $data = { itemtype => 1, is_binary => 0 };
 452
 453     $node->set_initial_props($dir, $data);
 454     $node->{action} = 'add';
 455
 456     push @$nodes, $node;
 457     $self->_add_svn_struct_item($dir, 1);
 458
 459 }  #  End _add_svn_dir
 460
 461 ###############################################################################
 462 #  _add_handler
 463 ###############################################################################
 464 sub _add_handler {
 465     my($self, $itempath, $nodes, $data, $expdir) = @_;
 466
 467     my $node = Vss2Svn::Dumpfile::Node->new();
 468     $node->set_initial_props($itempath, $data);
 469     $node->{action} = 'add';
 470
 471     if ($data->{itemtype} == 2) {
 472         $self->get_export_contents($node, $data, $expdir);
 473     }
 474
 475     $self->track_modified($data->{physname}, $data->{revision_id}, $itempath);
 476
 477     push @$nodes, $node;
 478
 479 }  #  End _add_handler
 480
 481 ###############################################################################
 482 #  _commit_handler
 483 ###############################################################################
 484 sub _commit_handler {
 485     my($self, $itempath, $nodes, $data, $expdir) = @_;
 486
 487     my $node = Vss2Svn::Dumpfile::Node->new();
 488     $node->set_initial_props($itempath, $data);
 489     $node->{action} = 'change';
 490
 491     if ($data->{itemtype} == 2) {
 492         $self->get_export_contents($node, $data, $expdir);
 493     }
 494
 495     $self->track_modified($data->{physname}, $data->{revision_id}, $itempath);
 496
 497     push @$nodes, $node;
 498
 499 }  #  End _commit_handler
 500
 501 ###############################################################################
 502 #  _rename_handler
 503 ###############################################################################
 504 sub _rename_handler {
 505     my($self, $itempath, $nodes, $data, $expdir) = @_;
 506
 507     # to rename a file in SVN, we must add "with history" then delete the orig.
 508
 509     my $newname = $data->{info};
 510
 511     my $newpath = $itempath;
 512
 513     $newpath =~ s:(.*/)?.*:$1$newname:;
 514
 515     my $node = Vss2Svn::Dumpfile::Node->new();
 516     $node->set_initial_props($newpath, $data);
 517     $node->{action} = 'add';
 518
 519     my($copyrev, $copypath);
 520
 521     # ideally, we should be finding the last time the file was modified and
 522     # copy it from there, but that becomes difficult to track...
 523     $copyrev = $data->{revision_id} - 1;
 524     $copypath = $itempath;
 525
 526     $node->{copyrev} = $copyrev;
 527     $node->{copypath} = $copypath;
 528
 529     push @$nodes, $node;
 530
 531     $self->track_modified($data->{physname}, $data->{revision_id}, $newpath);
 532
 533     $node = Vss2Svn::Dumpfile::Node->new();
 534     $node->{path} = $itempath;
 535     $node->{action} = 'delete';
 536     $node->{hideprops} = 1;
 537
 538     push @$nodes, $node;
 539
 540     # We don't add this to %gDeleted since VSS doesn't treat a rename as an
 541     # add/delete and therefore we wouldn't recover from this point
 542
 543 }  #  End _rename_handler
 544
 545 ###############################################################################
 546 #  _share_handler
 547 ###############################################################################
 548 sub _share_handler {
 549     my($self, $itempath, $nodes, $data, $expdir) = @_;
 550
 551     my $node = Vss2Svn::Dumpfile::Node->new();
 552     $node->set_initial_props($itempath, $data);
 553     $node->{action} = 'add';
 554
 555     @{ $node }{ qw(copyrev copypath) }
 556         = $self->last_modified_rev_path($data->{physname});
 557
 558     return unless defined($node->{copyrev});
 559
 560     push @$nodes, $node;
 561
 562 }  #  End _share_handler
 563
 564 ###############################################################################
 565 #  _branch_handler
 566 ###############################################################################
 567 sub _branch_handler {
 568     my($self, $itempath, $nodes, $data, $expdir) = @_;
 569
 570     # branching is a no-op in SVN
 571
 572     # if the file is copied later, we need to track, the revision of this branch
 573     # see the shareBranchShareModify Test
 574     $self->track_modified($data->{physname}, $data->{revision_id}, $itempath);
 575
 576 }  #  End _branch_handler
 577
 578 ###############################################################################
 579 #  _move_handler
 580 ###############################################################################
 581 sub _move_handler {
 582     my($self, $itempath, $nodes, $data, $expdir) = @_;
 583
 584     # moving in SVN is the same as renaming; add the new and delete the old
 585
 586     my $newpath = $data->{info};
 587
 588     my $node = Vss2Svn::Dumpfile::Node->new();
 589     $node->set_initial_props($newpath, $data);
 590     $node->{action} = 'add';
 591
 592     my($copyrev, $copypath);
 593
 594     $copyrev = $data->{revision_id} - 1;
 595     $copypath = $itempath;
 596
 597     $node->{copyrev} = $copyrev;
 598     $node->{copypath} = $copypath;
 599
 600     push @$nodes, $node;
 601
 602     $self->track_modified($data->{physname}, $data->{revision_id}, $newpath);
 603
 604     $node = Vss2Svn::Dumpfile::Node->new();
 605     $node->{path} = $itempath;
 606     $node->{action} = 'delete';
 607     $node->{hideprops} = 1;
 608
 609     push @$nodes, $node;
 610
 611 }  #  End _move_handler
 612
 613 ###############################################################################
 614 #  _delete_handler
 615 ###############################################################################
 616 sub _delete_handler {
 617     my($self, $itempath, $nodes, $data, $expdir) = @_;
 618
 619     my $node = Vss2Svn::Dumpfile::Node->new();
 620     $node->{path} = $itempath;
 621     $node->{action} = 'delete';
 622     $node->{hideprops} = 1;
 623
 624     push @$nodes, $node;
 625
 626     $self->track_deleted($data->{physname}, $data->{revision_id},
 627                          $itempath);
 628
 629 }  #  End _delete_handler
 630
 631 ###############################################################################
 632 #  _recover_handler
 633 ###############################################################################
 634 sub _recover_handler {
 635     my($self, $itempath, $nodes, $data, $expdir) = @_;
 636
 637     my $node = Vss2Svn::Dumpfile::Node->new();
 638     $node->set_initial_props($itempath, $data);
 639     $node->{action} = 'add';
 640
 641     my($copyrev, $copypath) = $self->last_deleted_rev_path($data->{physname});
 642
 643     if (!defined $copyrev) {
 644         $self->add_error(
 645             "Could not recover path $itempath at revision $data->{revision_id};"
 646             . " unable to determine deleted revision");
 647         return 0;
 648     }
 649
 650     $node->{copyrev} = $copyrev - 1;
 651     $node->{copypath} = $copypath;
 652
 653     push @$nodes, $node;
 654
 655 }  #  End _recover_handler
 656
 657 ###############################################################################
 658 #  track_modified
 659 ###############################################################################
 660 sub track_modified {
 661     my($self, $physname, $revision, $path) = @_;
 662
 663     return unless $self->{is_primary};
 664
 665     $self->{modified_cache}->{$physname} =
 666         {
 667          revision => $revision,
 668          path => $path,
 669         };
 670
 671 }  #  End track_modified
 672
 673 ###############################################################################
 674 #  track_deleted
 675 ###############################################################################
 676 sub track_deleted {
 677     my($self, $physname, $revision, $path) = @_;
 678
 679     $self->{deleted_cache}->{$physname} =
 680         {
 681          revision => $revision,
 682          path => $path,
 683         };
 684
 685 }  #  End track_deleted
 686
 687 ###############################################################################
 688 #  last_modified_rev_path
 689 ###############################################################################
 690 sub last_modified_rev_path {
 691     my($self, $physname) = @_;
 692
 693     if (!defined($gModified{$physname})) {
 694         return (undef, undef);
 695     }
 696
 697     return @{ $gModified{$physname} }{ qw(revision path) };
 698 }  #  End last_modified_rev_path
 699
 700 ###############################################################################
 701 #  last_deleted_rev_path
 702 ###############################################################################
 703 sub last_deleted_rev_path {
 704     my($self, $physname) = @_;
 705
 706     if (!defined($gDeleted{$physname})) {
 707         return (undef, undef);
 708     }
 709
 710     return @{ $gDeleted{$physname} }{ qw(revision path) };
 711 }  #  End last_deleted_rev_path
 712
 713 ###############################################################################
 714 #  get_export_contents
 715 ###############################################################################
 716 sub get_export_contents {
 717     my($self, $node, $data, $expdir) = @_;
 718
 719     if (!defined($expdir)) {
 720         return 0;
 721     } elsif (!defined($data->{version})) {
 722         $self->add_error(
 723             "Attempt to retrieve file contents with unknown version number");
 724         return 0;
 725     }
 726
 727     my $file = "$expdir\\$data->{physname}.$data->{version}";
 728
 729     if (!open EXP, "$file") {
 730         $self->add_error("Could not open export file '$file'");
 731         return 0;
 732     }
 733
 734     binmode(EXP);
 735
 736 #   $node->{text} = join('', <EXP>);
 737     $node->{text} = do { local( $/ ) ; <EXP> } ;
 738
 739     close EXP;
 740
 741     return 1;
 742
 743 }  #  End get_export_contents
 744
 745 ###############################################################################
 746 #  output_node
 747 ###############################################################################
 748 sub output_node {
 749     my($self, $node) = @_;
 750     my $fh = $self->{fh};
 751
 752     my $string = $node->get_headers();
 753     from_to ($string, "windows-1252", "utf8");
 754     print $fh $string;
 755     $self->output_content($node->{hideprops}? undef : $node->{props},
 756                           $node->{text});
 757 }  #  End output_node
 758
 759 ###############################################################################
 760 #  output_content
 761 ###############################################################################
 762 sub output_content {
 763     my($self, $props, $text) = @_;
 764
 765     my $fh = $self->{fh};
 766
 767     $text = '' unless defined $text;
 768
 769     my $proplen = 0;
 770     my $textlen = 0;
 771     my($propout, $textout) = ('') x 2;
 772
 773     my($key, $value);
 774
 775     if (defined($props)) {
 776         foreach my $prop (@$props) {
 777             ($key, $value) = @$prop;
 778             $propout .= 'K ' . length($key) . "\n$key\nV " . length($value)
 779                 . "\n$value\n";
 780         }
 781
 782         $propout .= "PROPS-END\n";
 783         $proplen = length($propout);
 784     }
 785
 786     $textlen = length($text);
 787     return if ($textlen + $proplen == 0);
 788
 789     if ($proplen > 0) {
 790         print $fh "Prop-content-length: $proplen\n";
 791     }
 792
 793     if ($textlen > 0) {
 794         print $fh "Text-content-length: $textlen\n";
 795     }
 796
 797     print $fh "Content-length: " . ($proplen + $textlen)
 798         . "\n\n$propout$text\n";
 799
 800 }  #  End output_content
 801
 802 ###############################################################################
 803 #  svn_timestamp
 804 ###############################################################################
 805 sub svn_timestamp {
 806     my($self, $vss_timestamp) = @_;
 807
 808     return &SvnTimestamp($vss_timestamp);
 809
 810 }  #  End svn_timestamp
 811
 812 ###############################################################################
 813 #  SvnTimestamp
 814 ###############################################################################
 815 sub SvnTimestamp {
 816     my($vss_timestamp) = @_;
 817
 818     my($sec, $min, $hour, $day, $mon, $year) = gmtime($vss_timestamp);
 819
 820     $year += 1900;
 821     $mon += 1;
 822
 823     return sprintf("%4.4i-%2.2i-%2.2iT%2.2i:%2.2i:%2.2i.%6.6iZ",
 824         $year, $mon, $day, $hour, $min, $sec, 0);
 825
 826 }  #  End SvnTimestamp
 827
 828 ###############################################################################
 829 #  add_error
 830 ###############################################################################
 831 sub add_error {
 832     my($self, $msg) = @_;
 833
 834     push @{ $self->{errors} }, $msg;
 835 }  #  End add_error
 836
 837
 838
 839 1;