src/src/hintsdb/hints_sqlite.h

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) The Exim Maintainers 2020 - 2024 */
   6 /* Copyright (c) University of Cambridge 1995 - 2018 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8 /* SPDX-License-Identifier: GPL-2.0-or-later */
   9
  10 /* This header file contains macro definitions for one possible hintsdb
  11 backend provider. */
  12
  13 /* ********************* sqlite3 interface ************************ */
  14
  15 # include <sqlite3.h>
  16
  17 /* Basic DB type */
  18 # define EXIM_DB sqlite3
  19
  20 # define EXIM_CURSOR int
  21
  22 # /* The datum type used for queries */
  23 # define EXIM_DATUM blob
  24
  25 /* Some text for messages */
  26 # define EXIM_DBTYPE "sqlite3"
  27
  28 # /* Access functions */
  29
  30 static inline BOOL
  31 exim_lockfile_needed(void)
  32 {
  33 return FALSE;   /* We do transaction; no extra locking needed */
  34 }
  35
  36 /* EXIM_DBOPEN - return pointer to an EXIM_DB, NULL if failed */
  37 static inline EXIM_DB *
  38 exim_dbopen_multi(const uschar * name, const uschar * dirname, int flags,
  39   unsigned mode)
  40 {
  41 EXIM_DB * dbp;
  42 int ret, sflags = flags & O_RDWR ? SQLITE_OPEN_READWRITE : SQLITE_OPEN_READONLY;
  43 if (flags & O_CREAT) sflags |= SQLITE_OPEN_CREATE;
  44 if ((ret = sqlite3_open_v2(CCS name, &dbp, sflags, NULL)) == SQLITE_OK)
  45   {
  46   sqlite3_busy_timeout(dbp, 5000);
  47   if (flags & O_CREAT)
  48     ret = sqlite3_exec(dbp,
  49             "CREATE TABLE IF NOT EXISTS tbl (ky TEXT PRIMARY KEY, dat BLOB);",
  50             NULL, NULL, NULL);
  51   if (ret != SQLITE_OK)
  52     sqlite3_close(dbp);
  53   }
  54 //else
  55 //  fprintf(stderr, "sqlite3_open_v2: %s\n", sqlite3_errmsg(dbp));
  56 return ret == SQLITE_OK ? dbp : NULL;
  57 }
  58
  59 static inline BOOL
  60 exim_dbtransaction_start(EXIM_DB * dbp)
  61 {
  62 return sqlite3_exec(dbp, "BEGIN TRANSACTION;", NULL, NULL, NULL) == SQLITE_OK;
  63 }
  64
  65 static inline EXIM_DB *
  66 exim_dbopen__(const uschar * name, const uschar * dirname, int flags,
  67   unsigned mode)
  68 {
  69 EXIM_DB * dbp = exim_dbopen_multi(name, dirname, flags, mode);
  70 if (!dbp || exim_dbtransaction_start(dbp))
  71   return dbp;
  72 sqlite3_close(dbp);
  73 return NULL;
  74 }
  75
  76 /* EXIM_DBGET - returns TRUE if successful, FALSE otherwise */
  77 /* note we alloc'n'copy - the caller need not do so */
  78 /* result has a NUL appended, but the length is as per the DB */
  79
  80 static inline BOOL
  81 exim_dbget__(EXIM_DB * dbp, const uschar * s, EXIM_DATUM * res)
  82 {
  83 sqlite3_stmt * statement;
  84 int ret;
  85
  86 res->len = (size_t) -1;
  87 /* fprintf(stderr, "exim_dbget__(%s)\n", s); */
  88 if ((ret = sqlite3_prepare_v2(dbp, CCS s, -1, &statement, NULL)) != SQLITE_OK)
  89   {
  90 /* fprintf(stderr, "prepare fail: %s\n", sqlite3_errmsg(dbp)); */
  91   return FALSE;
  92   }
  93 if (sqlite3_step(statement) != SQLITE_ROW)
  94   {
  95 /* fprintf(stderr, "step fail: %s\n", sqlite3_errmsg(dbp)); */
  96   sqlite3_finalize(statement);
  97   return FALSE;
  98   }
  99
 100 res->len = sqlite3_column_bytes(statement, 0);
 101 # ifdef COMPILE_UTILITY
 102 if (!(res->data = malloc(res->len +1)))
 103   { sqlite3_finalize(statement); return FALSE; }
 104 # else
 105 res->data = store_get(res->len +1, GET_TAINTED);
 106 # endif
 107 memcpy(res->data, sqlite3_column_blob(statement, 0), res->len);
 108 res->data[res->len] = '\0';
 109 /* fprintf(stderr, "res %d bytes: '%.*s'\n", (int)res->len, (int)res->len, res->data); */
 110 sqlite3_finalize(statement);
 111 return TRUE;
 112 }
 113
 114 static inline BOOL
 115 exim_dbget(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * res)
 116 {
 117 # define FMT "SELECT dat FROM tbl WHERE ky = '%.*s';"
 118 uschar * qry;
 119 int i;
 120 BOOL ret;
 121
 122 # ifdef COMPILE_UTILITY
 123 /* fprintf(stderr, "exim_dbget(k len %d '%.*s')\n", (int)key->len, (int)key->len, key->data); */
 124 i = snprintf(NULL, 0, FMT, (int) key->len, key->data)+1;
 125 if (!(qry = malloc(i)))
 126   return FALSE;
 127 snprintf(CS qry, i, FMT, (int) key->len, key->data);
 128 ret = exim_dbget__(dbp, qry, res);
 129 free(qry);
 130 # else
 131 /* fprintf(stderr, "exim_dbget(k len %d '%.*s')\n", (int)key->len, (int)key->len, key->data); */
 132 qry = string_sprintf(FMT, (int) key->len, key->data);
 133 ret = exim_dbget__(dbp, qry, res);
 134 # endif
 135
 136 return ret;
 137 # undef FMT
 138 }
 139
 140 /**/
 141 # define EXIM_DBPUTB_OK  0
 142 # define EXIM_DBPUTB_DUP (-1)
 143
 144 static inline int
 145 exim_s_dbp(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data, const uschar * alt)
 146 {
 147 int hlen = data->len * 2, off = 0, res;
 148 # define FMT "INSERT OR %s INTO tbl (ky,dat) VALUES ('%.*s', X'%.*s');"
 149 uschar * qry;
 150 # ifdef COMPILE_UTILITY
 151 uschar * hex = malloc(hlen+1);
 152 if (!hex) return EXIM_DBPUTB_DUP;       /* best we can do */
 153 # else
 154 uschar * hex = store_get(hlen+1, data->data);
 155 # endif
 156
 157 for (const uschar * s = data->data, * t = s + data->len; s < t; s++, off += 2)
 158   sprintf(CS hex + off, "%02X", *s);
 159
 160 # ifdef COMPILE_UTILITY
 161 res = snprintf(CS hex, 0, FMT, alt, (int) key->len, key->data, hlen, hex) +1;
 162 if (!(qry = malloc(res))) return EXIM_DBPUTB_DUP;
 163 snprintf(CS qry, res, FMT, alt, (int) key->len, key->data, hlen, hex);
 164 /* fprintf(stderr, "exim_s_dbp(%s)\n", qry); */
 165 res = sqlite3_exec(dbp, CS qry, NULL, NULL, NULL);
 166 free(qry);
 167 free(hex);
 168 # else
 169 qry = string_sprintf(FMT, alt, (int) key->len, key->data, hlen, hex);
 170 /* fprintf(stderr, "exim_s_dbp(%s)\n", qry); */
 171 res = sqlite3_exec(dbp, CS qry, NULL, NULL, NULL);
 172 /* fprintf(stderr, "exim_s_dbp res %d\n", res); */
 173 # endif
 174
 175 if (res != SQLITE_OK)
 176   fprintf(stderr, "sqlite3_exec: %s\n", sqlite3_errmsg(dbp));
 177
 178 return res == SQLITE_OK ? EXIM_DBPUTB_OK : EXIM_DBPUTB_DUP;
 179 # undef FMT
 180 }
 181
 182 /* EXIM_DBPUT - returns nothing useful, assumes replace mode */
 183
 184 static inline int
 185 exim_dbput(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
 186 {
 187 /* fprintf(stderr, "exim_dbput()\n"); */
 188 (void) exim_s_dbp(dbp, key, data, US"REPLACE");
 189 return 0;
 190 }
 191
 192 /* EXIM_DBPUTB - non-overwriting for use by dbmbuild */
 193
 194 /* Returns from EXIM_DBPUTB */
 195
 196 static inline int
 197 exim_dbputb(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * data)
 198 {
 199 return exim_s_dbp(dbp, key, data, US"ABORT");
 200 }
 201
 202 /* EXIM_DBDEL */
 203 static inline int
 204 exim_dbdel(EXIM_DB * dbp, EXIM_DATUM * key)
 205 {
 206 # define FMT "DELETE FROM tbl WHERE ky = '%.*s';"
 207 uschar * qry;
 208 int res;
 209
 210 # ifdef COMPILE_UTILITY
 211 res = snprintf(NULL, 0, FMT, (int) key->len, key->data) +1; /* res includes nul */
 212 if (!(qry = malloc(res))) return SQLITE_NOMEM;
 213 snprintf(CS qry, res, FMT, (int) key->len, key->data);
 214 res = sqlite3_exec(dbp, CS qry, NULL, NULL, NULL);
 215 free(qry);
 216 # else
 217 qry = string_sprintf(FMT, (int) key->len, key->data);
 218 res = sqlite3_exec(dbp, CS qry, NULL, NULL, NULL);
 219 # endif
 220
 221 return res;
 222 # undef FMT
 223 }
 224
 225
 226 /* EXIM_DBCREATE_CURSOR - initialize for scanning operation */
 227 /* Cursors are inefficiently emulated by repeating searches */
 228
 229 static inline EXIM_CURSOR *
 230 exim_dbcreate_cursor(EXIM_DB * dbp)
 231 {
 232 # ifdef COMPILE_UTILITY
 233 EXIM_CURSOR * c = malloc(sizeof(int));
 234 if (!c) return NULL;
 235 # else
 236 EXIM_CURSOR * c = store_malloc(sizeof(int));
 237 # endif
 238 *c = 0;
 239 return c;
 240 }
 241
 242 /* EXIM_DBSCAN */
 243 /* Note that we return the (next) key, not the record value */
 244 static inline BOOL
 245 exim_dbscan(EXIM_DB * dbp, EXIM_DATUM * key, EXIM_DATUM * res, BOOL first,
 246   EXIM_CURSOR * cursor)
 247 {
 248 # define FMT "SELECT ky FROM tbl ORDER BY ky LIMIT 1 OFFSET %d;"
 249 uschar * qry;
 250 int i;
 251 BOOL ret;
 252
 253 # ifdef COMPILE_UTILITY
 254 i = snprintf(NULL, 0, FMT, *cursor)+1;
 255 if (!(qry = malloc(i))) return FALSE;
 256 snprintf(CS qry, i, FMT, *cursor);
 257 /* fprintf(stderr, "exim_dbscan(%s)\n", qry); */
 258 ret = exim_dbget__(dbp, qry, key);
 259 free(qry);
 260 /* fprintf(stderr, "exim_dbscan ret %c\n", ret ? 'T':'F'); */
 261 # else
 262 qry = string_sprintf(FMT, *cursor);
 263 /* fprintf(stderr, "exim_dbscan(%s)\n", qry); */
 264 ret = exim_dbget__(dbp, qry, key);
 265 /* fprintf(stderr, "exim_dbscan ret %c\n", ret ? 'T':'F'); */
 266 # endif
 267 if (ret) *cursor = *cursor + 1;
 268 return ret;
 269 # undef FMT
 270 }
 271
 272 /* EXIM_DBDELETE_CURSOR - terminate scanning operation. */
 273 static inline void
 274 exim_dbdelete_cursor(EXIM_CURSOR * cursor)
 275 {
 276 # ifdef COMPILE_UTILITY
 277 free(cursor);
 278 # else
 279 store_free(cursor);
 280 # endif
 281 }
 282
 283
 284 /* EXIM_DBCLOSE */
 285 static inline void
 286 exim_dbclose_multi(EXIM_DB * dbp)
 287 {
 288 sqlite3_close(dbp);
 289 }
 290 static inline void
 291 exim_dbtransaction_commit(EXIM_DB * dbp)
 292 {
 293 (void) sqlite3_exec(dbp, "COMMIT TRANSACTION;", NULL, NULL, NULL);
 294 }
 295 static inline void
 296 exim_dbclose__(EXIM_DB * dbp)
 297 {
 298 exim_dbtransaction_commit(dbp);
 299 exim_dbclose_multi(dbp);
 300 }
 301
 302
 303 /* Datum access */
 304
 305 static uschar *
 306 exim_datum_data_get(EXIM_DATUM * dp)
 307 { return US dp->data; }
 308 static void
 309 exim_datum_data_set(EXIM_DATUM * dp, void * s)
 310 { dp->data = s; }
 311
 312 static unsigned
 313 exim_datum_size_get(EXIM_DATUM * dp)
 314 { return dp->len; }
 315 static void
 316 exim_datum_size_set(EXIM_DATUM * dp, unsigned n)
 317 { dp->len = n; }
 318
 319
 320
 321 static inline void
 322 exim_datum_init(EXIM_DATUM * dp)
 323 { dp->data = NULL; }                    /* compiler quietening */
 324
 325 /* No free needed for a datum */
 326
 327 static inline void
 328 exim_datum_free(EXIM_DATUM * dp)
 329 { }
 330
 331 /* size limit */
 332
 333 # define EXIM_DB_RLIMIT 150
 334
 335
 336 /* End of hints_sqlite.h */
 337 /* vi: aw ai sw=2
 338 */