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