ad1b20b30513ae0506a35bdc6795a0cdcf2b3ddd
[ncurses.git] / ncurses / tinfo / db_iterator.c
1 /****************************************************************************
2  * Copyright (c) 2006-2010,2011 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                                                *
31  ****************************************************************************/
32
33 /*
34  * Iterators for terminal databases.
35  */
36
37 #include <curses.priv.h>
38
39 #include <time.h>
40 #include <tic.h>
41
42 #if USE_HASHED_DB
43 #include <hashed_db.h>
44 #endif
45
46 MODULE_ID("$Id: db_iterator.c,v 1.22 2011/11/27 01:32:34 tom Exp $")
47
48 #define HaveTicDirectory _nc_globals.have_tic_directory
49 #define KeepTicDirectory _nc_globals.keep_tic_directory
50 #define TicDirectory     _nc_globals.tic_directory
51 #define my_blob          _nc_globals.dbd_blob
52 #define my_list          _nc_globals.dbd_list
53 #define my_size          _nc_globals.dbd_size
54 #define my_time          _nc_globals.dbd_time
55 #define my_vars          _nc_globals.dbd_vars
56
57 static void
58 add_to_blob(const char *text)
59 {
60     if (*text != '\0') {
61         char *last = my_blob + strlen(my_blob);
62         if (last != my_blob)
63             *last++ = ':';
64         strcpy(last, text);
65     }
66 }
67
68 static bool
69 check_existence(const char *name, struct stat *sb)
70 {
71     bool result = FALSE;
72
73     if (stat(name, sb) == 0 && sb->st_size) {
74         result = TRUE;
75     }
76 #if USE_HASHED_DB
77     else if (strlen(name) < PATH_MAX - sizeof(DBM_SUFFIX)) {
78         char temp[PATH_MAX];
79         sprintf(temp, "%s%s", name, DBM_SUFFIX);
80         if (stat(temp, sb) == 0 && sb->st_size) {
81             result = TRUE;
82         }
83     }
84 #endif
85
86     return result;
87 }
88
89 /*
90  * Store the latest value of an environment variable in my_vars[] so we can
91  * detect if one changes, invalidating the cached search-list.
92  */
93 static bool
94 update_getenv(const char *name, DBDIRS which)
95 {
96     bool result = FALSE;
97     char *value = getenv(name);
98
99     if (which < dbdLAST) {
100         if (my_vars[which].name == 0 || strcmp(my_vars[which].name, name)) {
101             FreeIfNeeded(my_vars[which].value);
102             my_vars[which].name = name;
103             my_vars[which].value = value;
104             result = TRUE;
105         } else if ((my_vars[which].value != 0) ^ (value != 0)) {
106             FreeIfNeeded(my_vars[which].value);
107             my_vars[which].value = value;
108             result = TRUE;
109         } else if (value != 0 && strcmp(value, my_vars[which].value)) {
110             FreeIfNeeded(my_vars[which].value);
111             my_vars[which].value = value;
112             result = TRUE;
113         }
114     }
115     return result;
116 }
117
118 static char *
119 cache_getenv(const char *name, DBDIRS which)
120 {
121     char *result = 0;
122
123     (void) update_getenv(name, which);
124     if (which < dbdLAST) {
125         result = my_vars[which].value;
126     }
127     return result;
128 }
129
130 /*
131  * The cache expires if at least a second has passed since the initial lookup,
132  * or if one of the environment variables changed.
133  *
134  * Only a few applications use multiple lookups of terminal entries, seems that
135  * aside from bulk I/O such as tic and toe, that leaves interactive programs
136  * which should not be modifying the terminal databases in a way that would
137  * invalidate the search-list.
138  *
139  * The "1-second" is to allow for user-directed changes outside the program.
140  */
141 static bool
142 cache_expired(void)
143 {
144     bool result = FALSE;
145     time_t now = time((time_t *) 0);
146
147     if (now > my_time) {
148         result = TRUE;
149     } else {
150         DBDIRS n;
151         for (n = 0; n < dbdLAST; ++n) {
152             if (my_vars[n].name != 0
153                 && update_getenv(my_vars[n].name, n)) {
154                 result = TRUE;
155                 break;
156             }
157         }
158     }
159     return result;
160 }
161
162 static void
163 free_cache(void)
164 {
165     FreeAndNull(my_blob);
166     FreeAndNull(my_list);
167 }
168
169 /*
170  * Record the "official" location of the terminfo directory, according to
171  * the place where we're writing to, or the normal default, if not.
172  */
173 NCURSES_EXPORT(const char *)
174 _nc_tic_dir(const char *path)
175 {
176     T(("_nc_tic_dir %s", NonNull(path)));
177     if (!KeepTicDirectory) {
178         if (path != 0) {
179             TicDirectory = path;
180             HaveTicDirectory = TRUE;
181         } else if (!HaveTicDirectory && use_terminfo_vars()) {
182             char *envp;
183             if ((envp = getenv("TERMINFO")) != 0)
184                 return _nc_tic_dir(envp);
185         }
186     }
187     return TicDirectory ? TicDirectory : TERMINFO;
188 }
189
190 /*
191  * Special fix to prevent the terminfo directory from being moved after tic
192  * has chdir'd to it.  If we let it be changed, then if $TERMINFO has a
193  * relative path, we'll lose track of the actual directory.
194  */
195 NCURSES_EXPORT(void)
196 _nc_keep_tic_dir(const char *path)
197 {
198     _nc_tic_dir(path);
199     KeepTicDirectory = TRUE;
200 }
201
202 /*
203  * Cleanup.
204  */
205 NCURSES_EXPORT(void)
206 _nc_last_db(void)
207 {
208     if (my_blob != 0 && cache_expired()) {
209         free_cache();
210     }
211 }
212
213 /*
214  * This is a simple iterator which allows the caller to step through the
215  * possible locations for a terminfo directory.  ncurses uses this to find
216  * terminfo files to read.
217  */
218 NCURSES_EXPORT(const char *)
219 _nc_next_db(DBDIRS * state, int *offset)
220 {
221     const char *result;
222
223     (void) offset;
224     if ((int) *state < my_size
225         && my_list != 0
226         && my_list[*state] != 0) {
227         result = my_list[*state];
228         (*state)++;
229     } else {
230         result = 0;
231     }
232     if (result != 0) {
233         T(("_nc_next_db %d %s", *state, result));
234     }
235     return result;
236 }
237
238 NCURSES_EXPORT(void)
239 _nc_first_db(DBDIRS * state, int *offset)
240 {
241     *state = dbdTIC;
242     *offset = 0;
243
244     T(("_nc_first_db"));
245
246     /* build a blob containing all of the strings we will use for a lookup
247      * table.
248      */
249     if (my_blob == 0) {
250         size_t blobsize = 0;
251         const char *values[dbdLAST];
252         struct stat *my_stat;
253         int j, k;
254
255         for (j = 0; j < dbdLAST; ++j)
256             values[j] = 0;
257
258         /*
259          * This is the first item in the list, and is used only when tic is
260          * writing to the database, as a performance improvement.
261          */
262         values[dbdTIC] = TicDirectory;
263
264 #if USE_DATABASE
265 #ifdef TERMINFO_DIRS
266         values[dbdCfgList] = TERMINFO_DIRS;
267 #endif
268 #ifdef TERMINFO
269         values[dbdCfgOnce] = TERMINFO;
270 #endif
271 #endif
272
273 #if USE_TERMCAP
274         values[dbdCfgList2] = TERMPATH;
275 #endif
276
277         if (use_terminfo_vars()) {
278 #if USE_DATABASE
279             values[dbdEnvOnce] = cache_getenv("TERMINFO", dbdEnvOnce);
280             values[dbdHome] = _nc_home_terminfo();
281             (void) cache_getenv("HOME", dbdHome);
282             values[dbdEnvList] = cache_getenv("TERMINFO_DIRS", dbdEnvList);
283 #endif
284 #if USE_TERMCAP
285             values[dbdEnvOnce2] = cache_getenv("TERMCAP", dbdEnvOnce2);
286             /* only use $TERMCAP if it is an absolute path */
287             if (values[dbdEnvOnce2] != 0
288                 && *values[dbdEnvOnce2] != '/') {
289                 values[dbdEnvOnce2] = 0;
290             }
291             values[dbdEnvList2] = cache_getenv("TERMPATH", dbdEnvList2);
292 #endif /* USE_TERMCAP */
293         }
294
295         for (j = 0; j < dbdLAST; ++j) {
296             if (values[j] == 0)
297                 values[j] = "";
298             blobsize += 2 + strlen(values[j]);
299         }
300
301         my_blob = malloc(blobsize);
302         if (my_blob != 0) {
303             *my_blob = '\0';
304             for (j = 0; j < dbdLAST; ++j) {
305                 add_to_blob(values[j]);
306             }
307
308             /* Now, build an array which will be pointers to the distinct
309              * strings in the blob.
310              */
311             blobsize = 2;
312             for (j = 0; my_blob[j] != '\0'; ++j) {
313                 if (my_blob[j] == ':')
314                     ++blobsize;
315             }
316             my_list = typeCalloc(char *, blobsize);
317             my_stat = typeCalloc(struct stat, blobsize);
318             if (my_list != 0 && my_stat != 0) {
319                 k = 0;
320                 my_list[k++] = my_blob;
321                 for (j = 0; my_blob[j] != '\0'; ++j) {
322                     if (my_blob[j] == ':') {
323                         my_blob[j] = '\0';
324                         my_list[k++] = &my_blob[j + 1];
325                     }
326                 }
327
328                 /*
329                  * Eliminate duplicates from the list.
330                  */
331                 for (j = 0; my_list[j] != 0; ++j) {
332 #ifdef TERMINFO
333                     if (*my_list[j] == '\0')
334                         my_list[j] = TERMINFO;
335 #endif
336                     for (k = 0; k < j; ++k) {
337                         if (!strcmp(my_list[j], my_list[k])) {
338                             k = j - 1;
339                             while ((my_list[j] = my_list[j + 1]) != 0) {
340                                 ++j;
341                             }
342                             j = k;
343                             break;
344                         }
345                     }
346                 }
347
348                 /*
349                  * Eliminate non-existent databases, and those that happen to
350                  * be symlinked to another location.
351                  */
352                 for (j = 0; my_list[j] != 0; ++j) {
353                     bool found = check_existence(my_list[j], &my_stat[j]);
354 #if HAVE_LINK
355                     if (found) {
356                         for (k = 0; k < j; ++k) {
357                             if (my_stat[j].st_dev == my_stat[k].st_dev
358                                 && my_stat[j].st_ino == my_stat[k].st_ino) {
359                                 found = FALSE;
360                                 break;
361                             }
362                         }
363                     }
364 #endif
365                     if (!found) {
366                         k = j;
367                         while ((my_list[k] = my_list[k + 1]) != 0) {
368                             ++k;
369                         }
370                         --j;
371                     }
372                 }
373                 my_size = j;
374                 my_time = time((time_t *) 0);
375             } else {
376                 FreeAndNull(my_blob);
377             }
378             free(my_stat);
379         }
380     }
381 }
382
383 #if NO_LEAKS
384 void
385 _nc_db_iterator_leaks(void)
386 {
387     if (my_blob != 0)
388         FreeAndNull(my_blob);
389     if (my_list != 0)
390         FreeAndNull(my_list);
391 }
392 #endif