contrib/sdb/sqlite/zone2sqlite.c

   1 /*
   2  * Copyright (C) 2007  Internet Software Consortium.
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
   9  * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
  10  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
  11  * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
  13  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  14  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  15  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id: zone2sqlite.c,v 1.2 2008/09/24 02:46:21 marka Exp $ */
  19
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include <isc/buffer.h>
  24 #include <isc/mem.h>
  25 #include <isc/print.h>
  26 #include <isc/result.h>
  27
  28 #include <dns/db.h>
  29 #include <dns/dbiterator.h>
  30 #include <dns/fixedname.h>
  31 #include <dns/name.h>
  32 #include <dns/rdata.h>
  33 #include <dns/rdataset.h>
  34 #include <dns/rdatasetiter.h>
  35 #include <dns/rdatatype.h>
  36 #include <dns/result.h>
  37
  38 #include <sqlite3.h>
  39
  40 #ifndef UNUSED
  41 #define UNUSED(x)  (x) = (x)
  42 #endif
  43
  44 /*
  45  * Generate an SQLite table from a zone.
  46  */
  47
  48 typedef struct _dbinfo {
  49     sqlite3 *db;
  50     char *filename;
  51     char *table;
  52 } dbinfo_t;
  53
  54 dbinfo_t dbi = { NULL, NULL, NULL };
  55
  56
  57 static void
  58 closeandexit(int status)
  59 {
  60     if (dbi.db) {
  61         sqlite3_close(dbi.db);
  62         dbi.db = NULL;
  63     }
  64     exit(status);
  65 }
  66
  67 static void
  68 check_result(isc_result_t result, const char *message)
  69 {
  70     if (result != ISC_R_SUCCESS) {
  71         fprintf(stderr, "%s: %s\n", message,
  72                 isc_result_totext(result));
  73         closeandexit(1);
  74     }
  75 }
  76
  77 static isc_result_t
  78 db_connect(dbinfo_t *dbi)
  79 {
  80     if (sqlite3_open(dbi->filename, &dbi->db) == SQLITE_OK) {
  81         return (ISC_R_SUCCESS);
  82     } else {
  83         /* a connection is returned even if the open fails */
  84         sqlite3_close(dbi->db);
  85         dbi->db = NULL;
  86         return (ISC_R_FAILURE);
  87     }
  88 }
  89
  90 static int
  91 add_rdata_cb(void *parm, int cc, char **cv, char **cn)
  92 {
  93     UNUSED(parm);
  94     UNUSED(cc);
  95     UNUSED(cv);
  96     UNUSED(cn);
  97
  98     return 0;
  99 }
 100
 101
 102 static void
 103 addrdata(dns_name_t *name, dns_ttl_t ttl, dns_rdata_t *rdata)
 104 {
 105     unsigned char namearray[DNS_NAME_MAXTEXT + 1];
 106     unsigned char typearray[20];
 107     unsigned char dataarray[2048];
 108     isc_buffer_t b;
 109     isc_result_t result;
 110     char *sql;
 111     char *errmsg = NULL;
 112     int res;
 113
 114     isc_buffer_init(&b, namearray, sizeof(namearray) - 1);
 115     result = dns_name_totext(name, ISC_TRUE, &b);
 116     check_result(result, "dns_name_totext");
 117     namearray[isc_buffer_usedlength(&b)] = 0;
 118
 119     isc_buffer_init(&b, typearray, sizeof(typearray) - 1);
 120     result = dns_rdatatype_totext(rdata->type, &b);
 121     check_result(result, "dns_rdatatype_totext");
 122     typearray[isc_buffer_usedlength(&b)] = 0;
 123
 124     isc_buffer_init(&b, dataarray, sizeof(dataarray) - 1);
 125     result = dns_rdata_totext(rdata, NULL, &b);
 126     check_result(result, "dns_rdata_totext");
 127     dataarray[isc_buffer_usedlength(&b)] = 0;
 128
 129     sql = sqlite3_mprintf(
 130         "INSERT INTO %q (NAME, TTL, RDTYPE, RDATA)"
 131         " VALUES ('%q', %d, '%q', '%q') ",
 132         dbi.table,
 133         namearray, ttl, typearray, dataarray);
 134     printf("%s\n", sql);
 135     res = sqlite3_exec(dbi.db, sql, add_rdata_cb, NULL, &errmsg);
 136     sqlite3_free(sql);
 137
 138     if (result != SQLITE_OK) {
 139         fprintf(stderr, "INSERT failed: %s\n", errmsg);
 140         closeandexit(1);
 141     }
 142 }
 143
 144 int
 145 main(int argc, char *argv[])
 146 {
 147     char *sql;
 148     int res;
 149     char *errmsg = NULL;
 150     char *porigin, *zonefile;
 151     dns_fixedname_t forigin, fname;
 152     dns_name_t *origin, *name;
 153     dns_db_t *db = NULL;
 154     dns_dbiterator_t *dbiter;
 155     dns_dbnode_t *node;
 156     dns_rdatasetiter_t *rdsiter;
 157     dns_rdataset_t rdataset;
 158     dns_rdata_t rdata = DNS_RDATA_INIT;
 159     isc_mem_t *mctx = NULL;
 160     isc_buffer_t b;
 161     isc_result_t result;
 162
 163     if (argc != 5) {
 164         printf("usage: %s <zone> <zonefile> <dbfile> <dbtable>\n", argv[0]);
 165         exit(1);
 166     }
 167
 168     porigin  = argv[1];
 169     zonefile = argv[2];
 170
 171     dbi.filename = argv[3];
 172     dbi.table    = argv[4];
 173
 174     dns_result_register();
 175
 176     mctx = NULL;
 177     result = isc_mem_create(0, 0, &mctx);
 178     check_result(result, "isc_mem_create");
 179
 180     isc_buffer_init(&b, porigin, strlen(porigin));
 181     isc_buffer_add(&b, strlen(porigin));
 182     dns_fixedname_init(&forigin);
 183     origin = dns_fixedname_name(&forigin);
 184     result = dns_name_fromtext(origin, &b, dns_rootname, ISC_FALSE, NULL);
 185     check_result(result, "dns_name_fromtext");
 186
 187     db = NULL;
 188     result = dns_db_create(mctx, "rbt", origin, dns_dbtype_zone,
 189                            dns_rdataclass_in, 0, NULL, &db);
 190     check_result(result, "dns_db_create");
 191
 192     result = dns_db_load(db, zonefile);
 193     if (result == DNS_R_SEENINCLUDE)
 194         result = ISC_R_SUCCESS;
 195     check_result(result, "dns_db_load");
 196
 197     printf("Connecting to '%s'\n", dbi.filename);
 198
 199     if ((result = db_connect(&dbi)) != ISC_R_SUCCESS) {
 200         fprintf(stderr, "Connection to database '%s' failed\n",
 201                 dbi.filename);
 202         closeandexit(1);
 203     }
 204
 205     sql = sqlite3_mprintf("DROP TABLE %q ", dbi.table);
 206     printf("%s\n", sql);
 207     res = sqlite3_exec(dbi.db, sql, NULL, NULL, &errmsg);
 208     sqlite3_free(sql);
 209 #if 0
 210     if (res != SQLITE_OK) {
 211         fprintf(stderr, "DROP TABLE %s failed: %s\n",
 212                 dbi.table, errmsg);
 213     }
 214 #endif
 215
 216 #if 0
 217     sql = sqlite3_mprintf(sql, "BEGIN TRANSACTION");
 218     printf("%s\n", sql);
 219     res = sqlite3_exec(dbi.db, sql, NULL, NULL, &errmsg);
 220     sqlite3_free(sql);
 221     if (res != SQLITE_OK) {
 222         fprintf(stderr, "BEGIN TRANSACTION failed: %s\n", errmsg);
 223         closeandexit(1);
 224     }
 225 #endif
 226
 227     sql = sqlite3_mprintf(
 228         "CREATE TABLE %q "
 229         "(NAME TEXT, TTL INTEGER, RDTYPE TEXT, RDATA TEXT) ",
 230         dbi.table);
 231     printf("%s\n", sql);
 232     res = sqlite3_exec(dbi.db, sql, NULL, NULL, &errmsg);
 233     sqlite3_free(sql);
 234     if (res != SQLITE_OK) {
 235         fprintf(stderr, "CREATE TABLE %s failed: %s\n",
 236                 dbi.table, errmsg);
 237         closeandexit(1);
 238     }
 239
 240     dbiter = NULL;
 241     result = dns_db_createiterator(db, 0, &dbiter);
 242     check_result(result, "dns_db_createiterator()");
 243
 244     result = dns_dbiterator_first(dbiter);
 245     check_result(result, "dns_dbiterator_first");
 246
 247     dns_fixedname_init(&fname);
 248     name = dns_fixedname_name(&fname);
 249     dns_rdataset_init(&rdataset);
 250     dns_rdata_init(&rdata);
 251
 252     while (result == ISC_R_SUCCESS) {
 253         node = NULL;
 254         result = dns_dbiterator_current(dbiter, &node, name);
 255         if (result == ISC_R_NOMORE)
 256             break;
 257         check_result(result, "dns_dbiterator_current");
 258
 259         rdsiter = NULL;
 260         result = dns_db_allrdatasets(db, node, NULL, 0, &rdsiter);
 261         check_result(result, "dns_db_allrdatasets");
 262
 263         result = dns_rdatasetiter_first(rdsiter);
 264
 265         while (result == ISC_R_SUCCESS) {
 266             dns_rdatasetiter_current(rdsiter, &rdataset);
 267             result = dns_rdataset_first(&rdataset);
 268             check_result(result, "dns_rdataset_first");
 269             while (result == ISC_R_SUCCESS) {
 270                 dns_rdataset_current(&rdataset, &rdata);
 271                 addrdata(name, rdataset.ttl, &rdata);
 272                 dns_rdata_reset(&rdata);
 273                 result = dns_rdataset_next(&rdataset);
 274             }
 275             dns_rdataset_disassociate(&rdataset);
 276             result = dns_rdatasetiter_next(rdsiter);
 277         }
 278         dns_rdatasetiter_destroy(&rdsiter);
 279         dns_db_detachnode(db, &node);
 280         result = dns_dbiterator_next(dbiter);
 281     }
 282
 283 #if 0
 284     sql = sqlite3_mprintf(sql, "COMMIT TRANSACTION ");
 285     printf("%s\n", sql);
 286     res = sqlite3_exec(dbi.db, sql, NULL, NULL, &errmsg);
 287     sqlite3_free(sql);
 288     if (res != SQLITE_OK) {
 289         fprintf(stderr, "COMMIT TRANSACTION failed: %s\n", errmsg);
 290         closeandexit(1);
 291     }
 292 #endif
 293
 294     dns_dbiterator_destroy(&dbiter);
 295     dns_db_detach(&db);
 296     isc_mem_destroy(&mctx);
 297
 298     closeandexit(0);
 299
 300     exit(0);
 301 }