Merge branch 'singlecompression' into single
[kai/samba-autobuild/.git] / lib / tdb / tools / tdbbackup.c
1 /* 
2    Unix SMB/CIFS implementation.
3    low level tdb backup and restore utility
4    Copyright (C) Andrew Tridgell              2002
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 /*
21
22   This program is meant for backup/restore of tdb databases. Typical usage would be:
23      tdbbackup *.tdb
24   when Samba shuts down cleanly, which will make a backup of all the local databases
25   to *.bak files. Then on Samba startup you would use:
26      tdbbackup -v *.tdb
27   and this will check the databases for corruption and if corruption is detected then
28   the backup will be restored.
29
30   You may also like to do a backup on a regular basis while Samba is
31   running, perhaps using cron.
32
33   The reason this program is needed is to cope with power failures
34   while Samba is running. A power failure could lead to database
35   corruption and Samba will then not start correctly.
36
37   Note that many of the databases in Samba are transient and thus
38   don't need to be backed up, so you can optimise the above a little
39   by only running the backup on the critical databases.
40
41  */
42
43 #include "replace.h"
44 #include "system/locale.h"
45 #include "system/time.h"
46 #include "system/filesys.h"
47 #include "system/wait.h"
48 #include "tdb.h"
49
50 #ifdef HAVE_GETOPT_H
51 #include <getopt.h>
52 #endif
53
54 static int failed;
55
56 static char *add_suffix(const char *name, const char *suffix)
57 {
58         char *ret;
59         int len = strlen(name) + strlen(suffix) + 1;
60         ret = (char *)malloc(len);
61         if (!ret) {
62                 fprintf(stderr,"Out of memory!\n");
63                 exit(1);
64         }
65         snprintf(ret, len, "%s%s", name, suffix);
66         return ret;
67 }
68
69 static int copy_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
70 {
71         TDB_CONTEXT *tdb_new = (TDB_CONTEXT *)state;
72
73         if (tdb_store(tdb_new, key, dbuf, TDB_INSERT) != 0) {
74                 fprintf(stderr,"Failed to insert into %s\n", tdb_name(tdb_new));
75                 failed = 1;
76                 return 1;
77         }
78         return 0;
79 }
80
81
82 static int test_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
83 {
84         return 0;
85 }
86
87 /*
88   carefully backup a tdb, validating the contents and
89   only doing the backup if its OK
90   this function is also used for restore
91 */
92 static int backup_tdb(const char *old_name, const char *new_name, int hash_size)
93 {
94         TDB_CONTEXT *tdb;
95         TDB_CONTEXT *tdb_new;
96         char *tmp_name;
97         struct stat st;
98         int count1, count2;
99
100         tmp_name = add_suffix(new_name, ".tmp");
101
102         /* stat the old tdb to find its permissions */
103         if (stat(old_name, &st) != 0) {
104                 perror(old_name);
105                 free(tmp_name);
106                 return 1;
107         }
108
109         /* open the old tdb */
110         tdb = tdb_open(old_name, 0, 0, O_RDWR, 0);
111         if (!tdb) {
112                 printf("Failed to open %s\n", old_name);
113                 free(tmp_name);
114                 return 1;
115         }
116
117         /* create the new tdb */
118         unlink(tmp_name);
119         tdb_new = tdb_open(tmp_name,
120                            hash_size ? hash_size : tdb_hash_size(tdb),
121                            TDB_DEFAULT, O_RDWR|O_CREAT|O_EXCL, 
122                            st.st_mode & 0777);
123         if (!tdb_new) {
124                 perror(tmp_name);
125                 free(tmp_name);
126                 return 1;
127         }
128
129         /* lock the old tdb */
130         if (tdb_lockall(tdb) != 0) {
131                 fprintf(stderr,"Failed to lock %s\n", old_name);
132                 tdb_close(tdb);
133                 tdb_close(tdb_new);
134                 unlink(tmp_name);
135                 free(tmp_name);
136                 return 1;
137         }
138
139         failed = 0;
140
141         /* traverse and copy */
142         count1 = tdb_traverse(tdb, copy_fn, (void *)tdb_new);
143         if (count1 < 0 || failed) {
144                 fprintf(stderr,"failed to copy %s\n", old_name);
145                 tdb_close(tdb);
146                 tdb_close(tdb_new);
147                 unlink(tmp_name);
148                 free(tmp_name);
149                 return 1;
150         }
151
152         /* close the old tdb */
153         tdb_close(tdb);
154
155         /* close the new tdb and re-open read-only */
156         tdb_close(tdb_new);
157         tdb_new = tdb_open(tmp_name, 0, TDB_DEFAULT, O_RDONLY, 0);
158         if (!tdb_new) {
159                 fprintf(stderr,"failed to reopen %s\n", tmp_name);
160                 unlink(tmp_name);
161                 perror(tmp_name);
162                 free(tmp_name);
163                 return 1;
164         }
165         
166         /* traverse the new tdb to confirm */
167         count2 = tdb_traverse(tdb_new, test_fn, NULL);
168         if (count2 != count1) {
169                 fprintf(stderr,"failed to copy %s\n", old_name);
170                 tdb_close(tdb_new);
171                 unlink(tmp_name);
172                 free(tmp_name);
173                 return 1;
174         }
175
176         /* make sure the new tdb has reached stable storage */
177         fsync(tdb_fd(tdb_new));
178
179         /* close the new tdb and rename it to .bak */
180         tdb_close(tdb_new);
181         if (rename(tmp_name, new_name) != 0) {
182                 perror(new_name);
183                 free(tmp_name);
184                 return 1;
185         }
186
187         free(tmp_name);
188
189         return 0;
190 }
191
192 /*
193   verify a tdb and if it is corrupt then restore from *.bak
194 */
195 static int verify_tdb(const char *fname, const char *bak_name)
196 {
197         TDB_CONTEXT *tdb;
198         int count = -1;
199
200         /* open the tdb */
201         tdb = tdb_open(fname, 0, 0, O_RDONLY, 0);
202
203         /* traverse the tdb, then close it */
204         if (tdb) {
205                 count = tdb_traverse(tdb, test_fn, NULL);
206                 tdb_close(tdb);
207         }
208
209         /* count is < 0 means an error */
210         if (count < 0) {
211                 printf("restoring %s\n", fname);
212                 return backup_tdb(bak_name, fname, 0);
213         }
214
215         printf("%s : %d records\n", fname, count);
216
217         return 0;
218 }
219
220 /*
221   see if one file is newer than another
222 */
223 static int file_newer(const char *fname1, const char *fname2)
224 {
225         struct stat st1, st2;
226         if (stat(fname1, &st1) != 0) {
227                 return 0;
228         }
229         if (stat(fname2, &st2) != 0) {
230                 return 1;
231         }
232         return (st1.st_mtime > st2.st_mtime);
233 }
234
235 static void usage(void)
236 {
237         printf("Usage: tdbbackup [options] <fname...>\n\n");
238         printf("   -h            this help message\n");
239         printf("   -s suffix     set the backup suffix\n");
240         printf("   -v            verify mode (restore if corrupt)\n");
241         printf("   -n hashsize   set the new hash size for the backup\n");
242 }
243                 
244
245  int main(int argc, char *argv[])
246 {
247         int i;
248         int ret = 0;
249         int c;
250         int verify = 0;
251         int hashsize = 0;
252         const char *suffix = ".bak";
253
254         while ((c = getopt(argc, argv, "vhs:n:")) != -1) {
255                 switch (c) {
256                 case 'h':
257                         usage();
258                         exit(0);
259                 case 'v':
260                         verify = 1;
261                         break;
262                 case 's':
263                         suffix = optarg;
264                         break;
265                 case 'n':
266                         hashsize = atoi(optarg);
267                         break;
268                 }
269         }
270
271         argc -= optind;
272         argv += optind;
273
274         if (argc < 1) {
275                 usage();
276                 exit(1);
277         }
278
279         for (i=0; i<argc; i++) {
280                 const char *fname = argv[i];
281                 char *bak_name;
282
283                 bak_name = add_suffix(fname, suffix);
284
285                 if (verify) {
286                         if (verify_tdb(fname, bak_name) != 0) {
287                                 ret = 1;
288                         }
289                 } else {
290                         if (file_newer(fname, bak_name) &&
291                             backup_tdb(fname, bak_name, hashsize) != 0) {
292                                 ret = 1;
293                         }
294                 }
295
296                 free(bak_name);
297         }
298
299         return ret;
300 }