hg-fast-export: support new --hgtags option
[python/fast-export.git] / svn-archive.c
1 /*
2  * svn-archive.c
3  * ----------
4  *  Walk through a given revision of a local Subversion repository and export 
5  *  all of the contents as a tarfile.
6  *
7  * Author: Chris Lee <clee@kde.org>
8  * License: MIT <http://www.opensource.org/licenses/mit-license.php>
9  */
10
11 #define _XOPEN_SOURCE
12 #include <unistd.h>
13 #include <string.h>
14 #include <stdio.h>
15 #include <time.h>
16
17 #ifndef PATH_MAX
18 #define PATH_MAX 4096
19 #endif
20
21 #include <apr_general.h>
22 #include <apr_strings.h>
23 #include <apr_getopt.h>
24 #include <apr_lib.h>
25
26 #include <svn_types.h>
27 #include <svn_pools.h>
28 #include <svn_repos.h>
29 #include <svn_fs.h>
30
31 #undef SVN_ERR
32 #define SVN_ERR(expr) SVN_INT_ERR(expr)
33 #define apr_sane_push(arr, contents) *(char **)apr_array_push(arr) = contents
34
35 #define TRUNK "/trunk"
36
37 static time_t archive_time;
38
39 time_t get_epoch(char *svn_date)
40 {
41     struct tm tm = {0};
42     char *date = malloc(strlen(svn_date) * sizeof(char *));
43     strncpy(date, svn_date, strlen(svn_date) - 8);
44     strptime(date, "%Y-%m-%dT%H:%M:%S", &tm);
45     free(date);
46     return mktime(&tm);
47 }
48
49 int tar_header(apr_pool_t *pool, char *path, char *node, size_t f_size)
50 {
51     char          buf[512];
52     unsigned int  i, checksum;
53     svn_boolean_t is_dir;
54
55     memset(buf, 0, sizeof(buf));
56
57     if ((strlen(path) == 0) && (strlen(node) == 0)) {
58         return 0;
59     }
60
61     if (strlen(node) == 0) {
62         is_dir = 1;
63     } else {
64         is_dir = 0;
65     }
66
67     if (strlen(path) == 0) {
68         strncpy(buf, apr_psprintf(pool, "%s", node), 99);
69     } else if (strlen(path) + strlen(node) < 100) {
70         strncpy(buf, apr_psprintf(pool, "%s/%s", path+1, node), 99);
71     } else {
72         fprintf(stderr, "really long file path...\n");
73         strncpy(&buf[0], node, 99);
74         strncpy(&buf[345], path+1, 154);
75     }
76
77     strncpy(&buf[100], apr_psprintf(pool, "%07o", (is_dir ? 0755 : 0644)), 7);
78     strncpy(&buf[108], apr_psprintf(pool, "%07o", 1000), 7);
79     strncpy(&buf[116], apr_psprintf(pool, "%07o", 1000), 7);
80     strncpy(&buf[124], apr_psprintf(pool, "%011lo", f_size), 11);
81     strncpy(&buf[136], apr_psprintf(pool, "%011lo", archive_time), 11);
82     strncpy(&buf[156], (is_dir ? "5" : "0"), 1);
83     strncpy(&buf[257], "ustar  ", 8);
84     strncpy(&buf[265], "clee", 31);
85     strncpy(&buf[297], "clee", 31);
86     // strncpy(&buf[329], apr_psprintf(pool, "%07o", 0), 7);
87     // strncpy(&buf[337], apr_psprintf(pool, "%07o", 0), 7);
88
89     strncpy(&buf[148], "        ", 8);
90     checksum = 0;
91     for (i = 0; i < sizeof(buf); i++) {
92         checksum += buf[i];
93     }
94     strncpy(&buf[148], apr_psprintf(pool, "%07o", checksum & 0x1fffff), 7);
95
96     fwrite(buf, sizeof(char), sizeof(buf), stdout);
97
98     return 0;
99 }
100
101 int tar_footer()
102 {
103     char block[1024];
104     memset(block, 0, sizeof(block));
105     fwrite(block, sizeof(char), sizeof(block), stdout);
106 }
107
108 int dump_blob(svn_fs_root_t *root, char *prefix, char *path, char *node, apr_pool_t *pool)
109 {
110     char           *full_path, buf[512];
111     apr_size_t     len;
112     svn_stream_t   *stream;
113     svn_filesize_t stream_length;
114
115     full_path = apr_psprintf(pool, "%s%s/%s", prefix, path, node);
116
117     SVN_ERR(svn_fs_file_length(&stream_length, root, full_path, pool));
118     SVN_ERR(svn_fs_file_contents(&stream, root, full_path, pool));
119
120     tar_header(pool, path, node, stream_length);
121
122     do {
123         len = sizeof(buf);
124         memset(buf, '\0', sizeof(buf));
125         SVN_ERR(svn_stream_read(stream, buf, &len));
126         fwrite(buf, sizeof(char), sizeof(buf), stdout);
127     } while (len == sizeof(buf));
128
129     return 0;
130 }
131
132 int dump_tree(svn_fs_root_t *root, char *prefix, char *path, apr_pool_t *pool)
133 {
134     const void       *key;
135     void             *val;
136     char             *node, *subpath, *full_path;
137
138     apr_pool_t       *subpool;
139     apr_hash_t       *dir_entries;
140     apr_hash_index_t *i;
141
142     svn_boolean_t    is_dir;
143
144     tar_header(pool, path, "", 0);
145
146     SVN_ERR(svn_fs_dir_entries(&dir_entries, root, apr_psprintf(pool, "%s/%s", prefix, path), pool));
147
148     subpool = svn_pool_create(pool);
149
150     for (i = apr_hash_first(pool, dir_entries); i; i = apr_hash_next(i)) {
151         svn_pool_clear(subpool);
152         apr_hash_this(i, &key, NULL, &val);
153         node = (char *)key;
154
155         subpath = apr_psprintf(subpool, "%s/%s", path, node);
156         full_path = apr_psprintf(subpool, "%s%s", prefix, subpath);
157
158         svn_fs_is_dir(&is_dir, root, full_path, subpool);
159
160         if (is_dir) {
161             dump_tree(root, prefix, subpath, subpool);
162         } else {
163             dump_blob(root, prefix, path, node, subpool);
164         }
165     }
166
167     svn_pool_destroy(subpool);
168
169     return 0;
170 }
171
172 int crawl_filesystem(char *repos_path, char *root_path, apr_pool_t *pool)
173 {
174     char                 *path;
175
176     apr_hash_t           *props;
177     apr_hash_index_t     *i;
178
179     svn_repos_t          *repos;
180     svn_fs_t             *fs;
181     svn_string_t         *svndate;
182     svn_revnum_t         youngest_rev, export_rev;
183     svn_fs_root_t        *fs_root;
184
185     SVN_ERR(svn_fs_initialize(pool));
186     SVN_ERR(svn_repos_open(&repos, repos_path, pool));
187     if ((fs = svn_repos_fs(repos)) == NULL)
188       return -1;
189     SVN_ERR(svn_fs_youngest_rev(&youngest_rev, fs, pool));
190
191     export_rev = youngest_rev;
192
193     SVN_ERR(svn_fs_revision_root(&fs_root, fs, export_rev, pool));
194     SVN_ERR(svn_fs_revision_proplist(&props, fs, export_rev, pool));
195
196     svndate = apr_hash_get(props, "svn:date", APR_HASH_KEY_STRING);
197     archive_time = get_epoch((char *)svndate->data);
198
199     fprintf(stderr, "Exporting archive of r%ld... \n", export_rev);
200
201     dump_tree(fs_root, root_path, "", pool);
202
203     tar_footer();
204
205     fprintf(stderr, "done!\n");
206
207     return 0;
208 }
209
210 int main(int argc, char *argv[])
211 {
212     apr_pool_t           *pool;
213     apr_getopt_t         *options;
214
215     apr_getopt_option_t long_options[] = {
216         { "help",     'h', 0 },
217         { "prefix",   'p', 0 },
218         { "basename", 'b', 0 },
219         { "revision", 'r', 0 },
220         { NULL,       0,   0 }
221     };
222
223     if (argc < 2) {
224         fprintf(stderr, "usage: %s REPOS_PATH [prefix]\n", argv[0]);
225         return -1;
226     }
227
228     if (apr_initialize() != APR_SUCCESS) {
229         fprintf(stderr, "You lose at apr_initialize().\n");
230         return -1;
231     }
232
233     pool = svn_pool_create(NULL);
234
235     crawl_filesystem(argv[1], (argc == 3 ? argv[2] : TRUNK), pool);
236
237     apr_terminate();
238
239     return 0;
240 }