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 struct tdb_logging_context log_ctx;
  57
  58 #ifdef PRINTF_ATTRIBUTE
  59 static void tdb_log(struct tdb_context *tdb, enum tdb_debug_level level, const char *format, ...) PRINTF_ATTRIBUTE(3,4);
  60 #endif
  61 static void tdb_log(struct tdb_context *tdb, enum tdb_debug_level level, const char *format, ...)
  62 {
  63         va_list ap;
  64
  65         va_start(ap, format);
  66         vfprintf(stdout, format, ap);
  67         va_end(ap);
  68         fflush(stdout);
  69 }
  70
  71 static char *add_suffix(const char *name, const char *suffix)
  72 {
  73         char *ret;
  74         int len = strlen(name) + strlen(suffix) + 1;
  75         ret = (char *)malloc(len);
  76         if (!ret) {
  77                 fprintf(stderr,"Out of memory!\n");
  78                 exit(1);
  79         }
  80         snprintf(ret, len, "%s%s", name, suffix);
  81         return ret;
  82 }
  83
  84 static int copy_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
  85 {
  86         TDB_CONTEXT *tdb_new = (TDB_CONTEXT *)state;
  87
  88         if (tdb_store(tdb_new, key, dbuf, TDB_INSERT) != 0) {
  89                 fprintf(stderr,"Failed to insert into %s\n", tdb_name(tdb_new));
  90                 failed = 1;
  91                 return 1;
  92         }
  93         return 0;
  94 }
  95
  96
  97 static int test_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
  98 {
  99         return 0;
 100 }
 101
 102 /*
 103   carefully backup a tdb, validating the contents and
 104   only doing the backup if its OK
 105   this function is also used for restore
 106 */
 107 static int backup_tdb(const char *old_name, const char *new_name, int hash_size)
 108 {
 109         TDB_CONTEXT *tdb;
 110         TDB_CONTEXT *tdb_new;
 111         char *tmp_name;
 112         struct stat st;
 113         int count1, count2;
 114
 115         tmp_name = add_suffix(new_name, ".tmp");
 116
 117         /* stat the old tdb to find its permissions */
 118         if (stat(old_name, &st) != 0) {
 119                 perror(old_name);
 120                 free(tmp_name);
 121                 return 1;
 122         }
 123
 124         /* open the old tdb */
 125         tdb = tdb_open_ex(old_name, 0, 0,
 126                           O_RDWR, 0, &log_ctx, NULL);
 127         if (!tdb) {
 128                 printf("Failed to open %s\n", old_name);
 129                 free(tmp_name);
 130                 return 1;
 131         }
 132
 133         /* create the new tdb */
 134         unlink(tmp_name);
 135         tdb_new = tdb_open_ex(tmp_name,
 136                               hash_size ? hash_size : tdb_hash_size(tdb),
 137                               TDB_DEFAULT,
 138                               O_RDWR|O_CREAT|O_EXCL, st.st_mode & 0777,
 139                               &log_ctx, NULL);
 140         if (!tdb_new) {
 141                 perror(tmp_name);
 142                 free(tmp_name);
 143                 return 1;
 144         }
 145
 146         if (tdb_transaction_start(tdb) != 0) {
 147                 printf("Failed to start transaction on old tdb\n");
 148                 tdb_close(tdb);
 149                 tdb_close(tdb_new);
 150                 unlink(tmp_name);
 151                 free(tmp_name);
 152                 return 1;
 153         }
 154
 155         /* lock the backup tdb so that nobody else can change it */
 156         if (tdb_lockall(tdb_new) != 0) {
 157                 printf("Failed to lock backup tdb\n");
 158                 tdb_close(tdb);
 159                 tdb_close(tdb_new);
 160                 unlink(tmp_name);
 161                 free(tmp_name);
 162                 return 1;
 163         }
 164
 165         failed = 0;
 166
 167         /* traverse and copy */
 168         count1 = tdb_traverse(tdb, copy_fn, (void *)tdb_new);
 169         if (count1 < 0 || failed) {
 170                 fprintf(stderr,"failed to copy %s\n", old_name);
 171                 tdb_close(tdb);
 172                 tdb_close(tdb_new);
 173                 unlink(tmp_name);
 174                 free(tmp_name);
 175                 return 1;
 176         }
 177
 178         /* close the old tdb */
 179         tdb_close(tdb);
 180
 181         /* copy done, unlock the backup tdb */
 182         tdb_unlockall(tdb_new);
 183
 184 #ifdef HAVE_FDATASYNC
 185         if (fdatasync(tdb_fd(tdb_new)) != 0) {
 186 #else
 187         if (fsync(tdb_fd(tdb_new)) != 0) {
 188 #endif
 189                 /* not fatal */
 190                 fprintf(stderr, "failed to fsync backup file\n");
 191         }
 192
 193         /* close the new tdb and re-open read-only */
 194         tdb_close(tdb_new);
 195         tdb_new = tdb_open_ex(tmp_name,
 196                               0,
 197                               TDB_DEFAULT,
 198                               O_RDONLY, 0,
 199                               &log_ctx, NULL);
 200         if (!tdb_new) {
 201                 fprintf(stderr,"failed to reopen %s\n", tmp_name);
 202                 unlink(tmp_name);
 203                 perror(tmp_name);
 204                 free(tmp_name);
 205                 return 1;
 206         }
 207
 208         /* traverse the new tdb to confirm */
 209         count2 = tdb_traverse(tdb_new, test_fn, NULL);
 210         if (count2 != count1) {
 211                 fprintf(stderr,"failed to copy %s\n", old_name);
 212                 tdb_close(tdb_new);
 213                 unlink(tmp_name);
 214                 free(tmp_name);
 215                 return 1;
 216         }
 217
 218         /* close the new tdb and rename it to .bak */
 219         tdb_close(tdb_new);
 220         if (rename(tmp_name, new_name) != 0) {
 221                 perror(new_name);
 222                 free(tmp_name);
 223                 return 1;
 224         }
 225
 226         free(tmp_name);
 227
 228         return 0;
 229 }
 230
 231 /*
 232   verify a tdb and if it is corrupt then restore from *.bak
 233 */
 234 static int verify_tdb(const char *fname, const char *bak_name)
 235 {
 236         TDB_CONTEXT *tdb;
 237         int count = -1;
 238
 239         /* open the tdb */
 240         tdb = tdb_open_ex(fname, 0, 0,
 241                           O_RDONLY, 0, &log_ctx, NULL);
 242
 243         /* traverse the tdb, then close it */
 244         if (tdb) {
 245                 count = tdb_traverse(tdb, test_fn, NULL);
 246                 tdb_close(tdb);
 247         }
 248
 249         /* count is < 0 means an error */
 250         if (count < 0) {
 251                 printf("restoring %s\n", fname);
 252                 return backup_tdb(bak_name, fname, 0);
 253         }
 254
 255         printf("%s : %d records\n", fname, count);
 256
 257         return 0;
 258 }
 259
 260 /*
 261   see if one file is newer than another
 262 */
 263 static int file_newer(const char *fname1, const char *fname2)
 264 {
 265         struct stat st1, st2;
 266         if (stat(fname1, &st1) != 0) {
 267                 return 0;
 268         }
 269         if (stat(fname2, &st2) != 0) {
 270                 return 1;
 271         }
 272         return (st1.st_mtime > st2.st_mtime);
 273 }
 274
 275 static void usage(void)
 276 {
 277         printf("Usage: tdbbackup [options] <fname...>\n\n");
 278         printf("   -h            this help message\n");
 279         printf("   -s suffix     set the backup suffix\n");
 280         printf("   -v            verify mode (restore if corrupt)\n");
 281         printf("   -n hashsize   set the new hash size for the backup\n");
 282 }
 283
 284
 285  int main(int argc, char *argv[])
 286 {
 287         int i;
 288         int ret = 0;
 289         int c;
 290         int verify = 0;
 291         int hashsize = 0;
 292         const char *suffix = ".bak";
 293
 294         log_ctx.log_fn = tdb_log;
 295
 296         while ((c = getopt(argc, argv, "vhs:n:")) != -1) {
 297                 switch (c) {
 298                 case 'h':
 299                         usage();
 300                         exit(0);
 301                 case 'v':
 302                         verify = 1;
 303                         break;
 304                 case 's':
 305                         suffix = optarg;
 306                         break;
 307                 case 'n':
 308                         hashsize = atoi(optarg);
 309                         break;
 310                 }
 311         }
 312
 313         argc -= optind;
 314         argv += optind;
 315
 316         if (argc < 1) {
 317                 usage();
 318                 exit(1);
 319         }
 320
 321         for (i=0; i<argc; i++) {
 322                 const char *fname = argv[i];
 323                 char *bak_name;
 324
 325                 bak_name = add_suffix(fname, suffix);
 326
 327                 if (verify) {
 328                         if (verify_tdb(fname, bak_name) != 0) {
 329                                 ret = 1;
 330                         }
 331                 } else {
 332                         if (file_newer(fname, bak_name) &&
 333                             backup_tdb(fname, bak_name, hashsize) != 0) {
 334                                 ret = 1;
 335                         }
 336                 }
 337
 338                 free(bak_name);
 339         }
 340
 341         return ret;
 342 }