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  int main(int argc, char *argv[])
 285 {
 286         int i;
 287         int ret = 0;
 288         int c;
 289         int verify = 0;
 290         int hashsize = 0;
 291         const char *suffix = ".bak";
 292
 293         log_ctx.log_fn = tdb_log;
 294
 295         while ((c = getopt(argc, argv, "vhs:n:")) != -1) {
 296                 switch (c) {
 297                 case 'h':
 298                         usage();
 299                         exit(0);
 300                 case 'v':
 301                         verify = 1;
 302                         break;
 303                 case 's':
 304                         suffix = optarg;
 305                         break;
 306                 case 'n':
 307                         hashsize = atoi(optarg);
 308                         break;
 309                 }
 310         }
 311
 312         argc -= optind;
 313         argv += optind;
 314
 315         if (argc < 1) {
 316                 usage();
 317                 exit(1);
 318         }
 319
 320         for (i=0; i<argc; i++) {
 321                 const char *fname = argv[i];
 322                 char *bak_name;
 323
 324                 bak_name = add_suffix(fname, suffix);
 325
 326                 if (verify) {
 327                         if (verify_tdb(fname, bak_name) != 0) {
 328                                 ret = 1;
 329                         }
 330                 } else {
 331                         if (file_newer(fname, bak_name) &&
 332                             backup_tdb(fname, bak_name, hashsize) != 0) {
 333                                 ret = 1;
 334                         }
 335                 }
 336
 337                 free(bak_name);
 338         }
 339
 340         return ret;
 341 }