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