1 /**************************************************************************** 2 * Copyright (c) 2006-2011,2013 Free Software Foundation, Inc. * 3 * * 4 * Permission is hereby granted, free of charge, to any person obtaining a * 5 * copy of this software and associated documentation files (the * 6 * "Software"), to deal in the Software without restriction, including * 7 * without limitation the rights to use, copy, modify, merge, publish, * 8 * distribute, distribute with modifications, sublicense, and/or sell * 9 * copies of the Software, and to permit persons to whom the Software is * 10 * furnished to do so, subject to the following conditions: * 11 * * 12 * The above copyright notice and this permission notice shall be included * 13 * in all copies or substantial portions of the Software. * 14 * * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * 16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * 18 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * 19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * 20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * 21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * 22 * * 23 * Except as contained in this notice, the name(s) of the above copyright * 24 * holders shall not be used in advertising or otherwise to promote the * 25 * sale, use or other dealings in this Software without prior written * 26 * authorization. * 27 ****************************************************************************/ 28 29 /**************************************************************************** 30 * Author: Thomas E. Dickey 2006-on * 31 ****************************************************************************/ 32 33 #include <curses.priv.h> 34 #include <tic.h> 35 #include <hashed_db.h> 36 37 #if USE_HASHED_DB 38 39 MODULE_ID("$Id: hashed_db.c,v 1.17 2013/12/15 00:33:01 tom Exp $") 40 41 #if HASHED_DB_API >= 2 42 static DBC *cursor; 43 #endif 44 45 typedef struct _myconn { 46 struct _myconn *next; 47 DB *db; 48 char *path; 49 bool modify; 50 } MYCONN; 51 52 static MYCONN *connections; 53 54 static void 55 cleanup(void) 56 { 57 while (connections != 0) { 58 _nc_db_close(connections->db); 59 } 60 } 61 62 static DB * 63 find_connection(const char *path, bool modify) 64 { 65 DB *result = 0; 66 MYCONN *p; 67 68 for (p = connections; p != 0; p = p->next) { 69 if (!strcmp(p->path, path) && p->modify == modify) { 70 result = p->db; 71 break; 72 } 73 } 74 75 return result; 76 } 77 78 static void 79 drop_connection(DB * db) 80 { 81 MYCONN *p, *q; 82 83 for (p = connections, q = 0; p != 0; q = p, p = p->next) { 84 if (p->db == db) { 85 if (q != 0) 86 q->next = p->next; 87 else 88 connections = p->next; 89 free(p->path); 90 free(p); 91 break; 92 } 93 } 94 } 95 96 static void 97 make_connection(DB * db, const char *path, bool modify) 98 { 99 MYCONN *p = typeCalloc(MYCONN, 1); 100 101 if (p != 0) { 102 p->db = db; 103 p->path = strdup(path); 104 p->modify = modify; 105 if (p->path != 0) { 106 p->next = connections; 107 connections = p; 108 } else { 109 free(p); 110 } 111 } 112 } 113 114 /* 115 * Open the database. 116 */ 117 NCURSES_EXPORT(DB *) 118 _nc_db_open(const char *path, bool modify) 119 { 120 DB *result = 0; 121 int code; 122 123 if (connections == 0) 124 atexit(cleanup); 125 126 if ((result = find_connection(path, modify)) == 0) { 127 128 #if HASHED_DB_API >= 4 129 db_create(&result, NULL, 0); 130 if ((code = result->open(result, 131 NULL, 132 path, 133 NULL, 134 DB_HASH, 135 modify ? DB_CREATE : DB_RDONLY, 136 0644)) != 0) { 137 result = 0; 138 } 139 #elif HASHED_DB_API >= 3 140 db_create(&result, NULL, 0); 141 if ((code = result->open(result, 142 path, 143 NULL, 144 DB_HASH, 145 modify ? DB_CREATE : DB_RDONLY, 146 0644)) != 0) { 147 result = 0; 148 } 149 #elif HASHED_DB_API >= 2 150 if ((code = db_open(path, 151 DB_HASH, 152 modify ? DB_CREATE : DB_RDONLY, 153 0644, 154 (DB_ENV *) 0, 155 (DB_INFO *) 0, 156 &result)) != 0) { 157 result = 0; 158 } 159 #else 160 if ((result = dbopen(path, 161 modify ? (O_CREAT | O_RDWR) : O_RDONLY, 162 0644, 163 DB_HASH, 164 NULL)) == 0) { 165 code = errno; 166 } 167 #endif 168 if (result != 0) { 169 make_connection(result, path, modify); 170 T(("opened %s", path)); 171 } else { 172 T(("cannot open %s: %s", path, strerror(code))); 173 } 174 } 175 return result; 176 } 177 178 /* 179 * Close the database. Do not attempt to use the 'db' handle after this call. 180 */ 181 NCURSES_EXPORT(int) 182 _nc_db_close(DB * db) 183 { 184 int result; 185 186 drop_connection(db); 187 #if HASHED_DB_API >= 2 188 result = db->close(db, 0); 189 #else 190 result = db->close(db); 191 #endif 192 return result; 193 } 194 195 /* 196 * Write a record to the database. 197 * 198 * Returns 0 on success. 199 * 200 * FIXME: the FreeBSD cap_mkdb program assumes the database could have 201 * duplicates. There appears to be no good reason for that (review/fix). 202 */ 203 NCURSES_EXPORT(int) 204 _nc_db_put(DB * db, DBT * key, DBT * data) 205 { 206 int result; 207 #if HASHED_DB_API >= 2 208 /* remove any pre-existing value, since we do not want duplicates */ 209 (void) db->del(db, NULL, key, 0); 210 result = db->put(db, NULL, key, data, DB_NOOVERWRITE); 211 #else 212 result = db->put(db, key, data, R_NOOVERWRITE); 213 #endif 214 return result; 215 } 216 217 /* 218 * Read a record from the database. 219 * 220 * Returns 0 on success. 221 */ 222 NCURSES_EXPORT(int) 223 _nc_db_get(DB * db, DBT * key, DBT * data) 224 { 225 int result; 226 227 memset(data, 0, sizeof(*data)); 228 #if HASHED_DB_API >= 2 229 result = db->get(db, NULL, key, data, 0); 230 #else 231 result = db->get(db, key, data, 0); 232 #endif 233 return result; 234 } 235 236 /* 237 * Read the first record from the database, ignoring order. 238 * 239 * Returns 0 on success. 240 */ 241 NCURSES_EXPORT(int) 242 _nc_db_first(DB * db, DBT * key, DBT * data) 243 { 244 int result; 245 246 memset(key, 0, sizeof(*key)); 247 memset(data, 0, sizeof(*data)); 248 #if HASHED_DB_API >= 2 249 if ((result = db->cursor(db, NULL, &cursor, 0)) == 0) { 250 result = cursor->c_get(cursor, key, data, DB_FIRST); 251 } 252 #else 253 result = db->seq(db, key, data, 0); 254 #endif 255 return result; 256 } 257 258 /* 259 * Read the next record from the database, ignoring order. 260 * 261 * Returns 0 on success. 262 */ 263 NCURSES_EXPORT(int) 264 _nc_db_next(DB * db, DBT * key, DBT * data) 265 { 266 int result; 267 268 #if HASHED_DB_API >= 2 269 (void) db; 270 if (cursor != 0) { 271 result = cursor->c_get(cursor, key, data, DB_NEXT); 272 } else { 273 result = -1; 274 } 275 #else 276 result = db->seq(db, key, data, 0); 277 #endif 278 return result; 279 } 280 281 /* 282 * Check if a record is a terminfo index record. Index records are those that 283 * contain only an alias pointing to a list of aliases. 284 */ 285 NCURSES_EXPORT(bool) 286 _nc_db_have_index(DBT * key, DBT * data, char **buffer, int *size) 287 { 288 bool result = FALSE; 289 int used = (int) data->size - 1; 290 char *have = (char *) data->data; 291 292 (void) key; 293 if (*have++ == 2) { 294 result = TRUE; 295 } 296 /* 297 * Update params in any case for consistency with _nc_db_have_data(). 298 */ 299 *buffer = have; 300 *size = used; 301 return result; 302 } 303 304 /* 305 * Check if a record is the terminfo data record. Ignore index records, e.g., 306 * those that contain only an alias pointing to a list of aliases. 307 */ 308 NCURSES_EXPORT(bool) 309 _nc_db_have_data(DBT * key, DBT * data, char **buffer, int *size) 310 { 311 bool result = FALSE; 312 int used = (int) data->size - 1; 313 char *have = (char *) data->data; 314 315 if (*have++ == 0) { 316 if (data->size > key->size 317 && IS_TIC_MAGIC(have)) { 318 result = TRUE; 319 } 320 } 321 /* 322 * Update params in any case to make it simple to follow a index record 323 * to the data record. 324 */ 325 *buffer = have; 326 *size = used; 327 return result; 328 } 329 330 #else 331 332 extern 333 NCURSES_EXPORT(void) 334 _nc_hashed_db(void); 335 336 NCURSES_EXPORT(void) 337 _nc_hashed_db(void) 338 { 339 } 340 341 #endif /* USE_HASHED_DB */ 342