gpg: Move sqlite helper functions into their own file.
[gnupg.git] / g10 / sqlite.c
1 /* sqlite.c - SQLite helper functions.
2  * Copyright (C) 2015 g10 Code GmbH
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG 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  * GnuPG 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 #include <config.h>
21 #include <stdarg.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <assert.h>
25
26 #include "gpg.h"
27 #include "util.h"
28 #include "logging.h"
29
30 #include "sqlite.h"
31
32 /* This is a convenience function that combines sqlite3_mprintf and
33    sqlite3_exec.  */
34 int
35 sqlite3_exec_printf (sqlite3 *db,
36                      int (*callback)(void*,int,char**,char**), void *cookie,
37                      char **errmsg,
38                      const char *sql, ...)
39 {
40   va_list ap;
41   int rc;
42   char *sql2;
43
44   va_start (ap, sql);
45   sql2 = sqlite3_vmprintf (sql, ap);
46   va_end (ap);
47
48 #if 0
49   log_debug ("tofo db: executing: '%s'\n", sql2);
50 #endif
51
52   rc = sqlite3_exec (db, sql2, callback, cookie, errmsg);
53
54   sqlite3_free (sql2);
55
56   return rc;
57 }
58
59 int
60 sqlite3_stepx (sqlite3 *db,
61                sqlite3_stmt **stmtp,
62                int (*callback) (void*,int,char**,char**),
63                void *cookie,
64                char **errmsg,
65                const char *sql, ...)
66 {
67   int rc;
68   int err = 0;
69   sqlite3_stmt *stmt = NULL;
70
71   va_list va;
72   int args;
73   enum sqlite_arg_type t;
74   int i;
75
76   int cols;
77   /* Names of the columns.  We initialize this lazily to avoid the
78      overhead in case the query doesn't return any results.  */
79   const char **azColName = 0;
80   int callback_initialized = 0;
81
82   const char **azVals = 0;
83
84   callback_initialized = 0;
85
86   if (stmtp && *stmtp)
87     {
88       stmt = *stmtp;
89
90       /* Make sure this statement is associated with the supplied db.  */
91       assert (db == sqlite3_db_handle (stmt));
92
93 #if DEBUG_TOFU_CACHE
94       prepares_saved ++;
95 #endif
96     }
97   else
98     {
99       const char *tail = NULL;
100
101       rc = sqlite3_prepare_v2 (db, sql, -1, &stmt, &tail);
102       if (rc)
103         log_fatal ("failed to prepare SQL: %s", sql);
104
105       /* We can only process a single statement.  */
106       if (tail)
107         {
108           while (*tail == ' ' || *tail == ';')
109             tail ++;
110
111           if (*tail)
112             log_fatal
113               ("sqlite3_stepx can only process a single SQL statement."
114                "  Second statement starts with: '%s'\n",
115                tail);
116         }
117
118       if (stmtp)
119         *stmtp = stmt;
120     }
121
122 #if DEBUG_TOFU_CACHE
123   queries ++;
124 #endif
125
126   args = sqlite3_bind_parameter_count (stmt);
127   va_start (va, sql);
128   if (args)
129     {
130       for (i = 1; i <= args; i ++)
131         {
132           t = va_arg (va, enum sqlite_arg_type);
133           switch (t)
134             {
135             case SQLITE_ARG_INT:
136               {
137                 int value = va_arg (va, int);
138                 err = sqlite3_bind_int (stmt, i, value);
139                 break;
140               }
141             case SQLITE_ARG_LONG_LONG:
142               {
143                 long long value = va_arg (va, long long);
144                 err = sqlite3_bind_int64 (stmt, i, value);
145                 break;
146               }
147             case SQLITE_ARG_STRING:
148               {
149                 char *text = va_arg (va, char *);
150                 err = sqlite3_bind_text (stmt, i, text, -1, SQLITE_STATIC);
151                 break;
152               }
153             default:
154               /* Internal error.  Likely corruption.  */
155               log_fatal ("Bad value for parameter type %d.\n", t);
156             }
157
158           if (err)
159             {
160               log_fatal ("Error binding parameter %d\n", i);
161               goto out;
162             }
163         }
164
165     }
166   t = va_arg (va, enum sqlite_arg_type);
167   assert (t == SQLITE_ARG_END);
168   va_end (va);
169
170   for (;;)
171     {
172       rc = sqlite3_step (stmt);
173
174       if (rc != SQLITE_ROW)
175         /* No more data (SQLITE_DONE) or an error occured.  */
176         break;
177
178       if (! callback)
179         continue;
180
181       if (! callback_initialized)
182         {
183           cols = sqlite3_column_count (stmt);
184           azColName = xmalloc (2 * cols * sizeof (const char *) + 1);
185
186           for (i = 0; i < cols; i ++)
187             azColName[i] = sqlite3_column_name (stmt, i);
188
189           callback_initialized = 1;
190         }
191
192       azVals = &azColName[cols];
193       for (i = 0; i < cols; i ++)
194         {
195           azVals[i] = sqlite3_column_text (stmt, i);
196           if (! azVals[i] && sqlite3_column_type (stmt, i) != SQLITE_NULL)
197             /* Out of memory.  */
198             {
199               err = SQLITE_NOMEM;
200               break;
201             }
202         }
203
204       if (callback (cookie, cols, (char **) azVals, (char **) azColName))
205         /* A non-zero result means to abort.  */
206         {
207           err = SQLITE_ABORT;
208           break;
209         }
210     }
211
212  out:
213   xfree (azColName);
214
215   if (stmtp)
216     rc = sqlite3_reset (stmt);
217   else
218     rc = sqlite3_finalize (stmt);
219   if (rc == SQLITE_OK && err)
220     /* Local error.  */
221     {
222       rc = err;
223       if (errmsg)
224         {
225           const char *e = sqlite3_errstr (err);
226           size_t l = strlen (e) + 1;
227           *errmsg = sqlite3_malloc (l);
228           if (! *errmsg)
229             log_fatal ("Out of memory.\n");
230           memcpy (*errmsg, e, l);
231         }
232     }
233   else if (rc != SQLITE_OK && errmsg)
234     /* Error reported by sqlite.  */
235     {
236       const char * e = sqlite3_errmsg (db);
237       size_t l = strlen (e) + 1;
238       *errmsg = sqlite3_malloc (l);
239       if (! *errmsg)
240         log_fatal ("Out of memory.\n");
241       memcpy (*errmsg, e, l);
242     }
243
244   return rc;
245 }