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,
 108                       int hash_size, int nolock)
 109 {
 110         TDB_CONTEXT *tdb;
 111         TDB_CONTEXT *tdb_new;
 112         char *tmp_name;
 113         struct stat st;
 114         int count1, count2;
 115
 116         tmp_name = add_suffix(new_name, ".tmp");
 117
 118         /* stat the old tdb to find its permissions */
 119         if (stat(old_name, &st) != 0) {
 120                 perror(old_name);
 121                 free(tmp_name);
 122                 return 1;
 123         }
 124
 125         /* open the old tdb */
 126         tdb = tdb_open_ex(old_name, 0,
 127                           TDB_DEFAULT | (nolock ? TDB_NOLOCK : 0),
 128                           O_RDWR, 0, &log_ctx, NULL);
 129         if (!tdb) {
 130                 printf("Failed to open %s\n", old_name);
 131                 free(tmp_name);
 132                 return 1;
 133         }
 134
 135         /* create the new tdb */
 136         unlink(tmp_name);
 137         tdb_new = tdb_open_ex(tmp_name,
 138                               hash_size ? hash_size : tdb_hash_size(tdb),
 139                               TDB_DEFAULT,
 140                               O_RDWR|O_CREAT|O_EXCL, st.st_mode & 0777,
 141                               &log_ctx, NULL);
 142         if (!tdb_new) {
 143                 perror(tmp_name);
 144                 free(tmp_name);
 145                 return 1;
 146         }
 147
 148         if (tdb_transaction_start(tdb) != 0) {
 149                 printf("Failed to start transaction on old tdb\n");
 150                 tdb_close(tdb);
 151                 tdb_close(tdb_new);
 152                 unlink(tmp_name);
 153                 free(tmp_name);
 154                 return 1;
 155         }
 156
 157         /* lock the backup tdb so that nobody else can change it */
 158         if (tdb_lockall(tdb_new) != 0) {
 159                 printf("Failed to lock backup tdb\n");
 160                 tdb_close(tdb);
 161                 tdb_close(tdb_new);
 162                 unlink(tmp_name);
 163                 free(tmp_name);
 164                 return 1;
 165         }
 166
 167         failed = 0;
 168
 169         /* traverse and copy */
 170         count1 = tdb_traverse(tdb, copy_fn, (void *)tdb_new);
 171         if (count1 < 0 || failed) {
 172                 fprintf(stderr,"failed to copy %s\n", old_name);
 173                 tdb_close(tdb);
 174                 tdb_close(tdb_new);
 175                 unlink(tmp_name);
 176                 free(tmp_name);
 177                 return 1;
 178         }
 179
 180         /* close the old tdb */
 181         tdb_close(tdb);
 182
 183         /* copy done, unlock the backup tdb */
 184         tdb_unlockall(tdb_new);
 185
 186 #ifdef HAVE_FDATASYNC
 187         if (fdatasync(tdb_fd(tdb_new)) != 0) {
 188 #else
 189         if (fsync(tdb_fd(tdb_new)) != 0) {
 190 #endif
 191                 /* not fatal */
 192                 fprintf(stderr, "failed to fsync backup file\n");
 193         }
 194
 195         /* close the new tdb and re-open read-only */
 196         tdb_close(tdb_new);
 197         tdb_new = tdb_open_ex(tmp_name,
 198                               0,
 199                               TDB_DEFAULT,
 200                               O_RDONLY, 0,
 201                               &log_ctx, NULL);
 202         if (!tdb_new) {
 203                 fprintf(stderr,"failed to reopen %s\n", tmp_name);
 204                 unlink(tmp_name);
 205                 perror(tmp_name);
 206                 free(tmp_name);
 207                 return 1;
 208         }
 209
 210         /* traverse the new tdb to confirm */
 211         count2 = tdb_traverse(tdb_new, test_fn, NULL);
 212         if (count2 != count1) {
 213                 fprintf(stderr,"failed to copy %s\n", old_name);
 214                 tdb_close(tdb_new);
 215                 unlink(tmp_name);
 216                 free(tmp_name);
 217                 return 1;
 218         }
 219
 220         /* close the new tdb and rename it to .bak */
 221         tdb_close(tdb_new);
 222         if (rename(tmp_name, new_name) != 0) {
 223                 perror(new_name);
 224                 free(tmp_name);
 225                 return 1;
 226         }
 227
 228         free(tmp_name);
 229
 230         return 0;
 231 }
 232
 233 /*
 234   verify a tdb and if it is corrupt then restore from *.bak
 235 */
 236 static int verify_tdb(const char *fname, const char *bak_name)
 237 {
 238         TDB_CONTEXT *tdb;
 239         int count = -1;
 240
 241         /* open the tdb */
 242         tdb = tdb_open_ex(fname, 0, 0,
 243                           O_RDONLY, 0, &log_ctx, NULL);
 244
 245         /* traverse the tdb, then close it */
 246         if (tdb) {
 247                 count = tdb_traverse(tdb, test_fn, NULL);
 248                 tdb_close(tdb);
 249         }
 250
 251         /* count is < 0 means an error */
 252         if (count < 0) {
 253                 printf("restoring %s\n", fname);
 254                 return backup_tdb(bak_name, fname, 0, 0);
 255         }
 256
 257         printf("%s : %d records\n", fname, count);
 258
 259         return 0;
 260 }
 261
 262 /*
 263   see if one file is newer than another
 264 */
 265 static int file_newer(const char *fname1, const char *fname2)
 266 {
 267         struct stat st1, st2;
 268         if (stat(fname1, &st1) != 0) {
 269                 return 0;
 270         }
 271         if (stat(fname2, &st2) != 0) {
 272                 return 1;
 273         }
 274         return (st1.st_mtime > st2.st_mtime);
 275 }
 276
 277 static void usage(void)
 278 {
 279         printf("Usage: tdbbackup [options] <fname...>\n\n");
 280         printf("   -h            this help message\n");
 281         printf("   -s suffix     set the backup suffix\n");
 282         printf("   -v            verify mode (restore if corrupt)\n");
 283         printf("   -n hashsize   set the new hash size for the backup\n");
 284         printf("   -l            open without locking to back up mutex dbs\n");
 285 }
 286
 287  int main(int argc, char *argv[])
 288 {
 289         int i;
 290         int ret = 0;
 291         int c;
 292         int verify = 0;
 293         int hashsize = 0;
 294         int nolock = 0;
 295         const char *suffix = ".bak";
 296
 297         log_ctx.log_fn = tdb_log;
 298
 299         while ((c = getopt(argc, argv, "vhs:n:l")) != -1) {
 300                 switch (c) {
 301                 case 'h':
 302                         usage();
 303                         exit(0);
 304                 case 'v':
 305                         verify = 1;
 306                         break;
 307                 case 's':
 308                         suffix = optarg;
 309                         break;
 310                 case 'n':
 311                         hashsize = atoi(optarg);
 312                         break;
 313                 case 'l':
 314                         nolock = 1;
 315                         break;
 316                 }
 317         }
 318
 319         argc -= optind;
 320         argv += optind;
 321
 322         if (argc < 1) {
 323                 usage();
 324                 exit(1);
 325         }
 326
 327         for (i=0; i<argc; i++) {
 328                 const char *fname = argv[i];
 329                 char *bak_name;
 330
 331                 bak_name = add_suffix(fname, suffix);
 332
 333                 if (verify) {
 334                         if (verify_tdb(fname, bak_name) != 0) {
 335                                 ret = 1;
 336                         }
 337                 } else {
 338                         if (file_newer(fname, bak_name) &&
 339                             backup_tdb(fname, bak_name, hashsize,
 340                                        nolock) != 0) {
 341                                 ret = 1;
 342                         }
 343                 }
 344
 345                 free(bak_name);
 346         }
 347
 348         return ret;
 349 }