svndump.c

   1 /******************************************************************************
   2  *
   3  * Copyright (C) 2005 Stefan Hegny, hydrografix Consulting GmbH,
   4  * Frankfurt/Main, Germany
   5  * and others, see http://svn2cc.sarovar.org
   6  *
   7  * Copyright (C) 2010 David Barr <david.barr@cordelta.com>.
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice(s), this list of conditions and the following disclaimer
  15  *    unmodified other than the allowable addition of one or more
  16  *    copyright notices.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice(s), this list of conditions and the following disclaimer in
  19  *    the documentation and/or other materials provided with the
  20  *    distribution.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
  23  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  25  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
  26  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  29  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  30  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  31  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  32  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  *
  34   ******************************************************************************/
  35
  36 /*
  37  * Parse and rearrange a svnadmin dump.
  38  * Create the dump with:
  39  * svnadmin dump --incremental -r<startrev>:<endrev> <repository> >outfile
  40  */
  41
  42 #include <stdint.h>
  43 #include <string.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <time.h>
  47
  48 #include "repo_tree.h"
  49 #include "line_buffer.h"
  50
  51 /**
  52  * node was replaced
  53  */
  54 #define NODEACT_REPLACE 3
  55
  56 /**
  57  * node was deleted
  58  */
  59 #define NODEACT_DELETE 2
  60
  61 /**
  62  * node was added or copied from other location
  63  */
  64 #define NODEACT_ADD 1
  65
  66 /**
  67  * node was modified
  68  */
  69 #define NODEACT_CHANGE 0
  70
  71 /**
  72  * unknown action
  73  */
  74 #define NODEACT_UNKNOWN -1
  75
  76 static uint32_t next_blob_mark(void)
  77 {
  78     static int32_t mark = 1000000000;
  79     return mark++;
  80 }
  81
  82 /**
  83  * read a modified file (node) within a revision
  84  */
  85 static void svnnode_read(char *fname)
  86 {
  87     int type = 0;
  88     int action = NODEACT_UNKNOWN;
  89     int propLength = -1;
  90     int textLength = -1;
  91     char *src = NULL;
  92     int srcRev = 0;
  93     uint32_t srcMode;
  94     char *dst = strdup(fname);
  95     char *t;
  96     int len;
  97     char *key;
  98     char *val;
  99     uint32_t mark = 0;
 100
 101     fprintf(stderr, "Node path: %s\n", fname);
 102
 103     for (t = buffer_read_line();
 104          t && *t;
 105          t = buffer_read_line()) {
 106         if (!strncmp(t, "Node-kind:", 10)) {
 107             val = &t[11];
 108             if (!strncasecmp(val, "dir", 3)) {
 109                 type = REPO_MODE_DIR;
 110             } else if (!strncasecmp(val, "file", 4)) {
 111                 type = REPO_MODE_BLB;
 112             } else {
 113                 fprintf(stderr, "Unknown node-kind: %s\n", val);
 114             }
 115         } else if (!strncmp(t, "Node-action", 11)) {
 116             val = &t[13];
 117             if (!strncasecmp(val, "delete", 6))
 118                 action = NODEACT_DELETE;
 119
 120             else if (!strncasecmp(val, "add", 3))
 121                 action = NODEACT_ADD;
 122
 123             else if (!strncasecmp(val, "change", 6))
 124                 action = NODEACT_CHANGE;
 125
 126             else if (!strncasecmp(val, "replace", 6))
 127                 action = NODEACT_REPLACE;
 128
 129             else
 130                 action = NODEACT_UNKNOWN;
 131         } else if (!strncmp(t, "Node-copyfrom-path", 18)) {
 132             src = strdup(&t[20]);
 133             fprintf(stderr, "Node copy path: %s\n", src);
 134         } else if (!strncmp(t, "Node-copyfrom-rev", 17)) {
 135             val = &t[19];
 136             srcRev = atoi(val);
 137             fprintf(stderr, "Node copy revision: %d\n", srcRev);
 138         } else if (!strncmp(t, "Text-content-length:", 20)) {
 139             val = &t[21];
 140             textLength = atoi(val);
 141             fprintf(stderr, "Text content length: %d\n", textLength);
 142         } else if (!strncmp(t, "Prop-content-length:", 20)) {
 143             val = &t[21];
 144             propLength = atoi(val);
 145             fprintf(stderr, "Prop content length: %d\n", propLength);
 146         }
 147     }
 148
 149     if (propLength > 0) {
 150         for (t = buffer_read_line();
 151              t && strncasecmp(t, "PROPS-END", 9);
 152              t = buffer_read_line()) {
 153             if (!strncmp(t, "K ", 2)) {
 154                 len = atoi(&t[2]);
 155                 key = buffer_read_string(len);
 156                 buffer_read_line();
 157             } else if (!strncmp(t, "V ", 2)) {
 158                 len = atoi(&t[2]);
 159                 val = buffer_read_string(len);
 160                 if (!strcmp(key, "svn:executable")) {
 161                     if (type == REPO_MODE_BLB) {
 162                         type = REPO_MODE_EXE;
 163                     }
 164                     fprintf(stderr, "Executable: %s\n", val);
 165                 } else if (!strcmp(key, "svn:special")) {
 166                     if (type == REPO_MODE_BLB) {
 167                         type = REPO_MODE_LNK;
 168                     }
 169                     fprintf(stderr, "Special: %s\n", val);
 170                 }
 171                 key = "";
 172                 buffer_read_line();
 173             }
 174         }
 175     }
 176
 177     if (src && srcRev) {
 178         srcMode = repo_copy(srcRev, src, dst);
 179     }
 180
 181     if (textLength >= 0 && type != REPO_MODE_DIR) {
 182         mark = next_blob_mark();
 183     }
 184
 185     if (action == NODEACT_DELETE) {
 186         repo_delete(dst);
 187     } else if (action == NODEACT_CHANGE ||
 188                action == NODEACT_REPLACE) {
 189         if (propLength >= 0 && textLength >= 0) {
 190             repo_modify(dst, type, mark);
 191         } else if (textLength >= 0) {
 192             srcMode = repo_replace(dst, mark);
 193         }
 194     } else if (action == NODEACT_ADD) {
 195         if (src && srcRev && propLength < 0 && textLength >= 0) {
 196             srcMode = repo_replace(dst, mark);
 197         } else if(type == REPO_MODE_DIR || textLength >= 0){
 198             repo_add(dst, type, mark);
 199         }
 200     }
 201
 202     if (propLength < 0 && srcMode) {
 203         type = srcMode;
 204     }
 205
 206     if(textLength == -1) textLength = 0;
 207
 208     if (mark) {
 209         if (type == REPO_MODE_LNK) {
 210             /* svn symlink blobs start with "link " */
 211             buffer_skip_bytes(5);
 212             textLength -= 5;
 213         }
 214         printf("blob\nmark :%d\ndata %d\n", mark, textLength);
 215         buffer_copy_bytes(textLength);
 216         fputc('\n', stdout);
 217     } else {
 218         buffer_skip_bytes(textLength);
 219     }
 220 }
 221
 222 static char *uuid = NULL;
 223 static char *url = NULL;
 224
 225
 226 /**
 227  * create revision reading from stdin
 228  * param number revision number
 229  */
 230 static void svnrev_read(uint32_t number)
 231 {
 232     struct tm tm;
 233     time_t timestamp = 0;
 234     char *descr = "";
 235     char *author = "nobody";
 236     char *date = "now";
 237     char *t;
 238     int len;
 239     char *key = "";
 240     char *val = "";
 241
 242     fprintf(stderr, "Revision: %d\n", number);
 243
 244     for (t = buffer_read_line();
 245          t && strncasecmp(t, "PROPS-END", 9);
 246          t = buffer_read_line()) {
 247         if (!strncmp(t, "K ", 2)) {
 248             len = atoi(&t[2]);
 249             key = buffer_read_string(len);
 250             buffer_read_line();
 251         } else if (!strncmp(t, "V ", 2)) {
 252             len = atoi(&t[2]);
 253             val = buffer_read_string(len);
 254             if (!strcmp(key, "svn:log")) {
 255                 descr = val;
 256                 fprintf(stderr, "Log: %s\n", descr);
 257             } else if (!strcmp(key, "svn:author")) {
 258                 author = val;
 259                 fprintf(stderr, "Author: %s\n", author);
 260             } else if (!strcmp(key, "svn:date")) {
 261                 date = val;
 262                 fprintf(stderr, "Date: %s\n", date);
 263                 strptime(date, "%FT%T", &tm);
 264                 timezone = 0;
 265                 tm.tm_isdst = 0;
 266                 timestamp = mktime(&tm);
 267             }
 268             key = "";
 269             buffer_read_line();
 270         }
 271     }
 272
 273     for ( ;
 274          t && strncmp(t, "Revision-number:", 16);
 275          t = buffer_read_line()) {
 276         if (!strncmp(t, "Node-path:", 10)) {
 277             svnnode_read(&t[11]);
 278         }
 279     }
 280     if (t)
 281         buffer_push_line();
 282
 283     repo_commit(number, author, descr, uuid, url, timestamp);
 284 }
 285
 286 /*
 287  * create dump representation by importing dump file
 288  */
 289 static void svndump_read(void)
 290 {
 291     char *t;
 292     int revision;
 293     for (t = buffer_read_line(); t; t = buffer_read_line()) {
 294         if (!strncmp(t, "Revision-number:", 16)) {
 295             revision = atoi(&t[17]);
 296             svnrev_read(revision);
 297         } else if(!strncmp(t, "UUID:", 5)) {
 298             uuid = strdup(&t[6]);
 299         }
 300     }
 301 }
 302
 303 int main(int argc, char **argv)
 304 {
 305     if (argc > 1) url = argv[1];
 306     svndump_read();
 307     return 0;
 308 }