source/lib/tdb/common/tdbback.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 2 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, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #ifdef STANDALONE
  22 #if HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <errno.h>
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31 #include <string.h>
  32 #include <fcntl.h>
  33 #include <time.h>
  34 #include <sys/mman.h>
  35
  36 #include <sys/stat.h>
  37 #include <sys/time.h>
  38 #include <ctype.h>
  39 #include <signal.h>
  40
  41 #else
  42 #include "includes.h"
  43
  44 #ifdef malloc
  45 #undef malloc
  46 #endif
  47
  48 #ifdef realloc
  49 #undef realloc
  50 #endif
  51
  52 #ifdef calloc
  53 #undef calloc
  54 #endif
  55
  56 #endif
  57
  58 #include "tdb.h"
  59
  60 static int failed;
  61
  62 char *add_suffix(const char *name, const char *suffix)
  63 {
  64         char *ret;
  65         int len = strlen(name) + strlen(suffix) + 1;
  66         ret = (char *)malloc(len);
  67         if (!ret) {
  68                 fprintf(stderr,"Out of memory!\n");
  69                 exit(1);
  70         }
  71         snprintf(ret, len, "%s%s", name, suffix);
  72         return ret;
  73 }
  74
  75 static int copy_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
  76 {
  77         TDB_CONTEXT *tdb_new = (TDB_CONTEXT *)state;
  78
  79         if (tdb_store(tdb_new, key, dbuf, TDB_INSERT) != 0) {
  80                 fprintf(stderr,"Failed to insert into %s\n", tdb_name(tdb));
  81                 failed = 1;
  82                 return 1;
  83         }
  84         return 0;
  85 }
  86
  87
  88 static int test_fn(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, void *state)
  89 {
  90         return 0;
  91 }
  92
  93 /*
  94   carefully backup a tdb, validating the contents and
  95   only doing the backup if its OK
  96   this function is also used for restore
  97 */
  98 int backup_tdb(const char *old_name, const char *new_name, int hash_size)
  99 {
 100         TDB_CONTEXT *tdb;
 101         TDB_CONTEXT *tdb_new;
 102         char *tmp_name;
 103         struct stat st;
 104         int count1, count2;
 105
 106         tmp_name = add_suffix(new_name, ".tmp");
 107
 108         /* stat the old tdb to find its permissions */
 109         if (stat(old_name, &st) != 0) {
 110                 perror(old_name);
 111                 free(tmp_name);
 112                 return 1;
 113         }
 114
 115         /* open the old tdb */
 116         tdb = tdb_open(old_name, 0, 0, O_RDWR, 0);
 117         if (!tdb) {
 118                 printf("Failed to open %s\n", old_name);
 119                 free(tmp_name);
 120                 return 1;
 121         }
 122
 123         /* create the new tdb */
 124         unlink(tmp_name);
 125         tdb_new = tdb_open(tmp_name,
 126                            hash_size ? hash_size : tdb_hash_size(tdb),
 127                            TDB_DEFAULT, O_RDWR|O_CREAT|O_EXCL,
 128                            st.st_mode & 0777);
 129         if (!tdb_new) {
 130                 perror(tmp_name);
 131                 free(tmp_name);
 132                 return 1;
 133         }
 134
 135         /* lock the old tdb */
 136         if (tdb_lockall(tdb) != 0) {
 137                 fprintf(stderr,"Failed to lock %s\n", old_name);
 138                 tdb_close(tdb);
 139                 tdb_close(tdb_new);
 140                 unlink(tmp_name);
 141                 free(tmp_name);
 142                 return 1;
 143         }
 144
 145         failed = 0;
 146
 147         /* traverse and copy */
 148         count1 = tdb_traverse(tdb, copy_fn, (void *)tdb_new);
 149         if (count1 < 0 || failed) {
 150                 fprintf(stderr,"failed to copy %s\n", old_name);
 151                 tdb_close(tdb);
 152                 tdb_close(tdb_new);
 153                 unlink(tmp_name);
 154                 free(tmp_name);
 155                 return 1;
 156         }
 157
 158         /* close the old tdb */
 159         tdb_close(tdb);
 160
 161         /* close the new tdb and re-open read-only */
 162         tdb_close(tdb_new);
 163         tdb_new = tdb_open(tmp_name, 0, TDB_DEFAULT, O_RDONLY, 0);
 164         if (!tdb_new) {
 165                 fprintf(stderr,"failed to reopen %s\n", tmp_name);
 166                 unlink(tmp_name);
 167                 perror(tmp_name);
 168                 free(tmp_name);
 169                 return 1;
 170         }
 171
 172         /* traverse the new tdb to confirm */
 173         count2 = tdb_traverse(tdb_new, test_fn, 0);
 174         if (count2 != count1) {
 175                 fprintf(stderr,"failed to copy %s\n", old_name);
 176                 tdb_close(tdb_new);
 177                 unlink(tmp_name);
 178                 free(tmp_name);
 179                 return 1;
 180         }
 181
 182         /* make sure the new tdb has reached stable storage */
 183         fsync(tdb_fd(tdb_new));
 184
 185         /* close the new tdb and rename it to .bak */
 186         tdb_close(tdb_new);
 187         unlink(new_name);
 188         if (rename(tmp_name, new_name) != 0) {
 189                 perror(new_name);
 190                 free(tmp_name);
 191                 return 1;
 192         }
 193
 194         free(tmp_name);
 195
 196         return 0;
 197 }
 198
 199
 200
 201 /*
 202   verify a tdb and if it is corrupt then restore from *.bak
 203 */
 204 int verify_tdb(const char *fname, const char *bak_name)
 205 {
 206         TDB_CONTEXT *tdb;
 207         int count = -1;
 208
 209         /* open the tdb */
 210         tdb = tdb_open(fname, 0, 0, O_RDONLY, 0);
 211
 212         /* traverse the tdb, then close it */
 213         if (tdb) {
 214                 count = tdb_traverse(tdb, test_fn, NULL);
 215                 tdb_close(tdb);
 216         }
 217
 218         /* count is < 0 means an error */
 219         if (count < 0) {
 220                 printf("restoring %s\n", fname);
 221                 return backup_tdb(bak_name, fname, 0);
 222         }
 223
 224         printf("%s : %d records\n", fname, count);
 225
 226         return 0;
 227 }