g10: Fix segfault on unsupported curve.
[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                sqlite3_stepx_callback callback,
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 == ';' || *tail == '\n')
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             case SQLITE_ARG_BLOB:
154               {
155                 char *blob = va_arg (va, void *);
156                 long long length = va_arg (va, long long);
157                 err = sqlite3_bind_blob (stmt, i, blob, length, SQLITE_STATIC);
158                 break;
159               }
160             default:
161               /* Internal error.  Likely corruption.  */
162               log_fatal ("Bad value for parameter type %d.\n", t);
163             }
164
165           if (err)
166             {
167               log_fatal ("Error binding parameter %d\n", i);
168               goto out;
169             }
170         }
171
172     }
173   t = va_arg (va, enum sqlite_arg_type);
174   assert (t == SQLITE_ARG_END);
175   va_end (va);
176
177   for (;;)
178     {
179       rc = sqlite3_step (stmt);
180
181       if (rc != SQLITE_ROW)
182         /* No more data (SQLITE_DONE) or an error occurred.  */
183         break;
184
185       if (! callback)
186         continue;
187
188       if (! callback_initialized)
189         {
190           cols = sqlite3_column_count (stmt);
191           azColName = xmalloc (2 * cols * sizeof (const char *) + 1);
192
193           for (i = 0; i < cols; i ++)
194             azColName[i] = sqlite3_column_name (stmt, i);
195
196           callback_initialized = 1;
197         }
198
199       azVals = &azColName[cols];
200       for (i = 0; i < cols; i ++)
201         {
202           azVals[i] = sqlite3_column_text (stmt, i);
203           if (! azVals[i] && sqlite3_column_type (stmt, i) != SQLITE_NULL)
204             /* Out of memory.  */
205             {
206               err = SQLITE_NOMEM;
207               break;
208             }
209         }
210
211       if (callback (cookie, cols, (char **) azVals, (char **) azColName, stmt))
212         /* A non-zero result means to abort.  */
213         {
214           err = SQLITE_ABORT;
215           break;
216         }
217     }
218
219  out:
220   xfree (azColName);
221
222   if (stmtp)
223     rc = sqlite3_reset (stmt);
224   else
225     rc = sqlite3_finalize (stmt);
226   if (rc == SQLITE_OK && err)
227     /* Local error.  */
228     {
229       rc = err;
230       if (errmsg)
231         {
232           const char *e = sqlite3_errstr (err);
233           size_t l = strlen (e) + 1;
234           *errmsg = sqlite3_malloc (l);
235           if (! *errmsg)
236             log_fatal ("Out of memory.\n");
237           memcpy (*errmsg, e, l);
238         }
239     }
240   else if (rc != SQLITE_OK && errmsg)
241     /* Error reported by sqlite.  */
242     {
243       const char * e = sqlite3_errmsg (db);
244       size_t l = strlen (e) + 1;
245       *errmsg = sqlite3_malloc (l);
246       if (! *errmsg)
247         log_fatal ("Out of memory.\n");
248       memcpy (*errmsg, e, l);
249     }
250
251   return rc;
252 }