lib/ntdb/tools/ntdbrestore.c

   1 /*
   2    ntdbrestore -- construct a ntdb from (n)tdbdump output.
   3    Copyright (C) Rusty Russell                  2012
   4    Copyright (C) Volker Lendecke                2010
   5    Copyright (C) Simon McVittie                 2005
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "config.h"
  22 #include "ntdb.h"
  23 #include <assert.h>
  24 #ifdef HAVE_LIBREPLACE
  25 #include <replace.h>
  26 #include <system/filesys.h>
  27 #else
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <fcntl.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #endif
  34
  35 static int read_linehead(FILE *f)
  36 {
  37         int i, c;
  38         int num_bytes;
  39         char prefix[128];
  40
  41         while (1) {
  42                 c = getc(f);
  43                 if (c == EOF) {
  44                         return -1;
  45                 }
  46                 if (c == '(') {
  47                         break;
  48                 }
  49         }
  50         for (i=0; i<sizeof(prefix); i++) {
  51                 c = getc(f);
  52                 if (c == EOF) {
  53                         return -1;
  54                 }
  55                 prefix[i] = c;
  56                 if (c == '"') {
  57                         break;
  58                 }
  59         }
  60         if (i == sizeof(prefix)) {
  61                 return -1;
  62         }
  63         prefix[i] = '\0';
  64
  65         if (sscanf(prefix, "%d) = ", &num_bytes) != 1) {
  66                 return -1;
  67         }
  68         return num_bytes;
  69 }
  70
  71 static int read_hex(void) {
  72         int c;
  73         c = getchar();
  74         if (c == EOF) {
  75                 fprintf(stderr, "Unexpected EOF in data\n");
  76                 return -1;
  77         } else if (c == '"') {
  78                 fprintf(stderr, "Unexpected \\\" sequence\n");
  79                 return -1;
  80         } else if ('0' <= c && c <= '9')  {
  81                 return c - '0';
  82         } else if ('A' <= c && c <= 'F')  {
  83                 return c - 'A' + 10;
  84         } else if ('a' <= c && c <= 'f')  {
  85                 return c - 'a' + 10;
  86         } else {
  87                 fprintf(stderr, "Invalid hex: %c\n", c);
  88                 return -1;
  89         }
  90 }
  91
  92 static int read_data(FILE *f, NTDB_DATA *d, size_t size) {
  93         int c, low, high;
  94         int i;
  95
  96         d->dptr = (unsigned char *)malloc(size);
  97         if (d->dptr == NULL) {
  98                 return -1;
  99         }
 100         d->dsize = size;
 101
 102         for (i=0; i<size; i++) {
 103                 c = getc(f);
 104                 if (c == EOF) {
 105                         fprintf(stderr, "Unexpected EOF in data\n");
 106                         return 1;
 107                 } else if (c == '"') {
 108                         return 0;
 109                 } else if (c == '\\') {
 110                         high = read_hex();
 111                         if (high < 0) {
 112                                 return -1;
 113                         }
 114                         high = high << 4;
 115                         assert(high == (high & 0xf0));
 116                         low = read_hex();
 117                         if (low < 0) {
 118                                 return -1;
 119                         }
 120                         assert(low == (low & 0x0f));
 121                         d->dptr[i] = (low|high);
 122                 } else {
 123                         d->dptr[i] = c;
 124                 }
 125         }
 126         return 0;
 127 }
 128
 129 static int swallow(FILE *f, const char *s, int *eof)
 130 {
 131         char line[128];
 132
 133         if (fgets(line, sizeof(line), f) == NULL) {
 134                 if (eof != NULL) {
 135                         *eof = 1;
 136                 }
 137                 return -1;
 138         }
 139         if (strcmp(line, s) != 0) {
 140                 return -1;
 141         }
 142         return 0;
 143 }
 144
 145 static bool read_rec(FILE *f, struct ntdb_context *ntdb, int *eof)
 146 {
 147         int length;
 148         NTDB_DATA key, data;
 149         bool ret = false;
 150         enum NTDB_ERROR e;
 151
 152         key.dptr = NULL;
 153         data.dptr = NULL;
 154
 155         if (swallow(f, "{\n", eof) == -1) {
 156                 goto fail;
 157         }
 158         length = read_linehead(f);
 159         if (length == -1) {
 160                 goto fail;
 161         }
 162         if (read_data(f, &key, length) == -1) {
 163                 goto fail;
 164         }
 165         if (swallow(f, "\"\n", NULL) == -1) {
 166                 goto fail;
 167         }
 168         length = read_linehead(f);
 169         if (length == -1) {
 170                 goto fail;
 171         }
 172         if (read_data(f, &data, length) == -1) {
 173                 goto fail;
 174         }
 175         if ((swallow(f, "\"\n", NULL) == -1)
 176             || (swallow(f, "}\n", NULL) == -1)) {
 177                 goto fail;
 178         }
 179         e = ntdb_store(ntdb, key, data, NTDB_INSERT);
 180         if (e != NTDB_SUCCESS) {
 181                 fprintf(stderr, "NTDB error: %s\n", ntdb_errorstr(e));
 182                 goto fail;
 183         }
 184
 185         ret = true;
 186 fail:
 187         free(key.dptr);
 188         free(data.dptr);
 189         return ret;
 190 }
 191
 192 static int restore_ntdb(const char *fname, unsigned int hsize)
 193 {
 194         struct ntdb_context *ntdb;
 195         union ntdb_attribute hashsize;
 196
 197         hashsize.base.attr = NTDB_ATTRIBUTE_HASHSIZE;
 198         hashsize.base.next = NULL;
 199         hashsize.hashsize.size = hsize;
 200
 201         ntdb = ntdb_open(fname, 0, O_RDWR|O_CREAT|O_EXCL, 0666,
 202                          hsize ? &hashsize : NULL);
 203         if (!ntdb) {
 204                 perror("ntdb_open");
 205                 fprintf(stderr, "Failed to open %s\n", fname);
 206                 return 1;
 207         }
 208
 209         while (1) {
 210                 int eof = 0;
 211                 if (!read_rec(stdin, ntdb, &eof)) {
 212                         if (eof) {
 213                                 break;
 214                         }
 215                         return 1;
 216                 }
 217         }
 218         if (ntdb_close(ntdb)) {
 219                 fprintf(stderr, "Error closing ntdb\n");
 220                 return 1;
 221         }
 222         fprintf(stderr, "EOF\n");
 223         return 0;
 224 }
 225
 226 int main(int argc, char *argv[])
 227 {
 228         unsigned int hsize = 0;
 229         const char *execname = argv[0];
 230
 231         if (argv[1] && strcmp(argv[1], "-h") == 0) {
 232                 if (argv[2]) {
 233                         hsize = atoi(argv[2]);
 234                 }
 235                 if (hsize == 0) {
 236                         fprintf(stderr, "-h requires a integer value"
 237                                 " (eg. 128 or 131072)\n");
 238                         exit(1);
 239                 }
 240                 argv += 2;
 241                 argc -= 2;
 242         }
 243         if (argc != 2) {
 244                 printf("Usage: %s [-h <hashsize>] dbname < tdbdump_output\n",
 245                        execname);
 246                 exit(1);
 247         }
 248
 249
 250         return restore_ntdb(argv[1], hsize);
 251 }