Fix compile errors caused by r4500 / r4501.
[asterisk/asterisk.git] / utils / astdb2sqlite3.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Berkeley DB to SQLite3 converter
22  *
23  * \author Terry Wilson <twilson@digium.com>
24  */
25
26 /*** MODULEINFO
27         <support_level>core</support_level>
28  ***/
29
30 #include "asterisk.h"
31
32 //ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
33
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <fcntl.h>
37 #include <unistd.h>
38 #include <sqlite3.h>
39 #include <libgen.h> /* OS X doesn't have the basename function in strings.h */
40
41 #include "db1-ast/include/db.h"
42
43 #define MAX_DB_FIELD 256
44 #define MIN(a,b) \
45 ({ typeof (a) _a = (a); \
46         typeof (b) _b = (b); \
47         a < _b ? _a : _b; })
48
49 static sqlite3 *astdb;
50
51 #define DEFINE_SQL_STATEMENT(stmt,sql) static sqlite3_stmt *stmt; \
52         const char stmt##_sql[] = sql;
53
54 DEFINE_SQL_STATEMENT(put_stmt, "INSERT OR REPLACE INTO astdb (key, value) VALUES (?, ?)")
55 DEFINE_SQL_STATEMENT(create_astdb_stmt, "CREATE TABLE IF NOT EXISTS astdb(key VARCHAR(256), value VARCHAR(256), PRIMARY KEY(key))")
56
57 static int db_execute_transaction_sql(const char *sql)
58 {
59         char *errmsg = NULL;
60         int res =0;
61
62         sqlite3_exec(astdb, sql, NULL, NULL, &errmsg);
63         if (errmsg) {
64                 fprintf(stderr, "Error executing SQL: %s\n", errmsg);
65                 sqlite3_free(errmsg);
66                 res = -1;
67         }
68
69         return res;
70 }
71
72 static int ast_db_begin_transaction(void)
73 {
74         return db_execute_transaction_sql("BEGIN TRANSACTION");
75 }
76
77 static int ast_db_commit_transaction(void)
78 {
79         return db_execute_transaction_sql("COMMIT");
80 }
81
82 static int ast_db_rollback_transaction(void)
83 {
84         return db_execute_transaction_sql("ROLLBACK");
85 }
86
87 static int db_put_raw(const char *key, size_t keylen, const char *value, size_t valuelen)
88 {
89         int res = 0;
90
91         if (sqlite3_bind_text(put_stmt, 1, key, keylen, SQLITE_STATIC) != SQLITE_OK) {
92                 fprintf(stderr, "Couldn't bind key to stmt: %s\n", sqlite3_errmsg(astdb));
93                 res = -1;
94         } else if (sqlite3_bind_text(put_stmt, 2, value, valuelen, SQLITE_STATIC) != SQLITE_OK) {
95                 fprintf(stderr, "Couldn't bind value to stmt: %s\n", sqlite3_errmsg(astdb));
96                 res = -1;
97         } else if (sqlite3_step(put_stmt) != SQLITE_DONE) {
98                 fprintf(stderr, "Couldn't execute statment: %s\n", sqlite3_errmsg(astdb));
99                 res = -1;
100         }
101         sqlite3_reset(put_stmt);
102
103         return res;
104 }
105
106 static int convert_bdb_to_sqlite3(const char *bdb_dbname)
107 {
108         DB *bdb;
109         DBT key = { 0, }, value = { 0, }, last_key = { 0, };
110         int res, last = 0;
111         char last_key_s[MAX_DB_FIELD];
112
113         if (!(bdb = dbopen(bdb_dbname, O_RDONLY, AST_FILE_MODE, DB_BTREE, NULL))) {
114                 fprintf(stderr, "Unable to open Asterisk database '%s'\n", bdb_dbname);
115                 return -1;
116         }
117
118         if (bdb->seq(bdb, &last_key, &value, R_LAST)) {
119                 /* Empty database */
120                 return 0;
121         }
122
123         memcpy(last_key_s, last_key.data, MIN(last_key.size - 1, sizeof(last_key_s)));
124         last_key_s[last_key.size - 1] = '\0';
125         for (res = bdb->seq(bdb, &key, &value, R_FIRST);
126                         !res; res = bdb->seq(bdb, &key, &value, R_NEXT)) {
127                 last = !strcmp(key.data, last_key_s);
128                 db_put_raw((const char *) key.data, key.size - 1, (const char *) value.data, value.size - 1);
129                 if (last) {
130                         break;
131                 }
132         }
133
134         bdb->close(bdb);
135
136         return 0;
137 }
138
139 static int init_stmt(sqlite3_stmt **stmt, const char *sql, size_t len)
140 {
141         if (sqlite3_prepare(astdb, sql, len, stmt, NULL) != SQLITE_OK) {
142                 fprintf(stderr, "Couldn't prepare statement '%s': %s\n", sql, sqlite3_errmsg(astdb));
143                 return -1;
144         }
145
146         return 0;
147 }
148
149 static int db_create_astdb(void)
150 {
151         if (init_stmt(&create_astdb_stmt, create_astdb_stmt_sql, sizeof(create_astdb_stmt_sql))) {
152                 return -1;
153         }
154
155         ast_db_begin_transaction();
156         if (sqlite3_step(create_astdb_stmt) != SQLITE_DONE) {
157                 fprintf(stderr, "Couldn't create astdb table: %s\n", sqlite3_errmsg(astdb));
158                 ast_db_rollback_transaction();
159                 sqlite3_reset(create_astdb_stmt);
160                 return -1;
161         }
162
163         ast_db_commit_transaction();
164         sqlite3_reset(create_astdb_stmt);
165
166         return 0;
167 }
168
169 static int init_statements(void)
170 {
171         /* Don't initialize create_astdb_statment here as the astdb table needs to exist
172          * brefore these statments can be initialized */
173         return init_stmt(&put_stmt, put_stmt_sql, sizeof(put_stmt_sql));
174 }
175
176 static int db_open(const char *dbname)
177 {
178         if (sqlite3_open(dbname, &astdb) != SQLITE_OK) {
179                 fprintf(stderr, "Unable to open Asterisk database '%s': %s\n", dbname, sqlite3_errmsg(astdb));
180                 sqlite3_close(astdb);
181                 return -1;
182         }
183
184         return 0;
185 }
186
187 static int sql_db_init(const char *dbname)
188 {
189         if (db_open(dbname) || db_create_astdb() || init_statements()) {
190                 return -1;
191         }
192
193         return 0;
194 }
195
196 int main(int argc, char *argv[])
197 {
198         char *dbname;
199         struct stat dont_care;
200
201         if (argc != 2) {
202                 fprintf(stderr, "%s takes the path of astdb as its only argument\n", basename(argv[0]));
203                 exit(-1);
204         }
205
206         if (stat(argv[1], &dont_care)) {
207                 fprintf(stderr, "Unable to open %s: %s\n", argv[1], strerror(errno));
208                 exit(-1);
209         }
210
211         if (!(dbname = alloca(strlen(argv[1]) + sizeof(".sqlite3")))) {
212                 exit(-1);
213         }
214
215         strcpy(dbname, argv[1]);
216         strcat(dbname, ".sqlite3");
217
218         if (!stat(dbname, &dont_care)) {
219                 fprintf(stderr, "%s already exists!\n", dbname);
220                 exit(-1);
221         }
222
223         if (sql_db_init(dbname)) {
224                 exit(-1);
225         }
226
227         if (convert_bdb_to_sqlite3(argv[1])) {
228                 fprintf(stderr, "Database conversion failed!\n");
229                 exit(-1);
230                 sqlite3_close(astdb);
231         }
232
233         sqlite3_close(astdb);
234         return 0;
235 }