1 /****************************************************************************
2 * Copyright (c) 1998-2013,2014 Free Software Foundation, Inc. *
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: *
12 * The above copyright notice and this permission notice shall be included *
13 * in all copies or substantial portions of the Software. *
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. *
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 *
27 ****************************************************************************/
29 /****************************************************************************
30 * Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 *
31 * and: Eric S. Raymond <esr@snark.thyrsus.com> *
32 * and: Thomas E. Dickey 1996-on *
33 ****************************************************************************/
36 * write_entry.c -- write a terminfo structure onto the file system
39 #include <curses.priv.h>
40 #include <hashed_db.h>
45 #define TRACE_OUT(p) DEBUG(2, p)
47 #define TRACE_OUT(p) /*nothing */
50 MODULE_ID("$Id: write_entry.c,v 1.92 2014/11/01 14:47:00 tom Exp $")
52 static int total_written
;
54 static int make_db_root(const char *);
55 static int write_object(TERMTYPE
*, char *, unsigned *, unsigned);
59 write_file(char *filename
, TERMTYPE
*tp
)
61 char buffer
[MAX_ENTRY_SIZE
];
62 unsigned limit
= sizeof(buffer
);
65 FILE *fp
= (_nc_access(filename
, W_OK
) == 0) ? fopen(filename
, "wb") : 0;
68 _nc_syserr_abort("can't open %s/%s", _nc_tic_dir(0), filename
);
70 DEBUG(1, ("Created %s", filename
));
72 if (write_object(tp
, buffer
, &offset
, limit
) == ERR
73 || fwrite(buffer
, sizeof(char), (size_t) offset
, fp
) != offset
) {
74 _nc_syserr_abort("error writing %s/%s", _nc_tic_dir(0), filename
);
81 * Check for access rights to destination directories
82 * Create any directories which don't exist.
84 * Note: there's no reason to return the result of make_db_root(), since
85 * this function is called only in instances where that has to succeed.
88 check_writeable(int code
)
90 static const char dirnames
[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
91 static bool verified
[sizeof(dirnames
)];
93 char dir
[sizeof(LEAF_FMT
)];
96 if (code
== 0 || (s
= (strchr
) (dirnames
, code
)) == 0)
97 _nc_err_abort("Illegal terminfo subdirectory \"" LEAF_FMT
"\"", code
);
99 if (verified
[s
- dirnames
])
102 _nc_SPRINTF(dir
, _nc_SLIMIT(sizeof(dir
)) LEAF_FMT
, code
);
103 if (make_db_root(dir
) < 0) {
104 _nc_err_abort("%s/%s: permission denied", _nc_tic_dir(0), dir
);
107 verified
[s
- dirnames
] = TRUE
;
109 #endif /* !USE_HASHED_DB */
112 make_db_path(char *dst
, const char *src
, size_t limit
)
115 const char *top
= _nc_tic_dir(0);
117 if (src
== top
|| _nc_is_abs_path(src
)) {
118 if (strlen(src
) + 1 <= limit
) {
119 _nc_STRCPY(dst
, src
, limit
);
123 if (strlen(top
) + strlen(src
) + 2 <= limit
) {
124 _nc_SPRINTF(dst
, _nc_SLIMIT(limit
) "%s/%s", top
, src
);
130 static const char suffix
[] = DBM_SUFFIX
;
131 size_t have
= strlen(dst
);
132 size_t need
= strlen(suffix
);
133 if (have
> need
&& strcmp(dst
+ (int) (have
- need
), suffix
)) {
134 if (have
+ need
<= limit
) {
135 _nc_STRCAT(dst
, suffix
, limit
);
139 } else if (_nc_is_dir_path(dst
)) {
148 * Make a database-root if it doesn't exist.
151 make_db_root(const char *path
)
154 char fullpath
[PATH_MAX
];
156 if ((rc
= make_db_path(fullpath
, path
, sizeof(fullpath
))) == 0) {
160 if ((capdbp
= _nc_db_open(fullpath
, TRUE
)) == NULL
) {
162 } else if (_nc_db_close(capdbp
) < 0) {
168 if ((rc
= stat(path
, &statbuf
)) < 0) {
170 #if !defined(__MINGW32__)
174 } else if (_nc_access(path
, R_OK
| W_OK
| X_OK
) < 0) {
175 rc
= -1; /* permission denied */
176 } else if (!(S_ISDIR(statbuf
.st_mode
))) {
177 rc
= -1; /* not a directory */
185 * Set the write directory for compiled entries.
188 _nc_set_writedir(const char *dir
)
190 const char *destination
;
191 char actual
[PATH_MAX
];
194 #ifndef USE_ROOT_ENVIRON
195 && use_terminfo_vars()
198 dir
= getenv("TERMINFO");
201 (void) _nc_tic_dir(dir
);
203 destination
= _nc_tic_dir(0);
204 if (make_db_root(destination
) < 0) {
205 char *home
= _nc_home_terminfo();
209 if (make_db_root(destination
) < 0)
210 _nc_err_abort("%s: permission denied (errno %d)",
216 * Note: because of this code, this logic should be exercised
217 * *once only* per run.
220 make_db_path(actual
, destination
, sizeof(actual
));
222 if (chdir(_nc_tic_dir(destination
)) < 0
223 || getcwd(actual
, sizeof(actual
)) == 0)
224 _nc_err_abort("%s: not a directory", destination
);
226 _nc_keep_tic_dir(strdup(actual
));
230 * Save the compiled version of a description in the filesystem.
232 * make a copy of the name-list
233 * break it up into first-name and all-but-last-name
235 * write object information to first-name
237 * for each name in all-but-last-name
240 * Using 'time()' to obtain a reference for file timestamps is unreliable,
241 * e.g., with NFS, because the filesystem may have a different time
242 * reference. We check for pre-existence of links by latching the first
243 * timestamp from a file that we create.
245 * The _nc_warning() calls will report a correct line number only if
246 * _nc_curr_line is properly set before the write_entry() call.
250 _nc_write_entry(TERMTYPE
*const tp
)
254 char buffer
[MAX_ENTRY_SIZE
+ 1];
255 unsigned limit
= sizeof(buffer
);
258 #else /* !USE_HASHED_DB */
261 char filename
[PATH_MAX
];
262 char linkname
[PATH_MAX
];
264 char symlinkname
[PATH_MAX
];
269 #endif /* USE_SYMLINKS */
271 static int call_count
;
272 static time_t start_time
; /* time at start of writes */
274 #endif /* USE_HASHED_DB */
276 char name_list
[MAX_TERMINFO_LENGTH
];
277 char *first_name
, *other_names
;
279 char *term_names
= tp
->term_names
;
280 size_t name_size
= strlen(term_names
);
282 if (name_size
== 0) {
283 _nc_syserr_abort("no terminal name found.");
284 } else if (name_size
>= sizeof(name_list
) - 1) {
285 _nc_syserr_abort("terminal name too long: %s", term_names
);
288 _nc_STRCPY(name_list
, term_names
, sizeof(name_list
));
289 DEBUG(7, ("Name list = '%s'", name_list
));
291 first_name
= name_list
;
293 ptr
= &name_list
[name_size
- 1];
294 other_names
= ptr
+ 1;
296 while (ptr
> name_list
&& *ptr
!= '|')
299 if (ptr
!= name_list
) {
302 for (ptr
= name_list
; *ptr
!= '\0' && *ptr
!= '|'; ptr
++)
309 other_names
= ptr
+ 1;
313 DEBUG(7, ("First name = '%s'", first_name
));
314 DEBUG(7, ("Other names = '%s'", other_names
));
316 _nc_set_type(first_name
);
319 if (write_object(tp
, buffer
+ 1, &offset
, limit
- 1) != ERR
) {
320 DB
*capdb
= _nc_db_open(_nc_tic_dir(0), TRUE
);
326 memset(&key
, 0, sizeof(key
));
327 key
.data
= term_names
;
328 key
.size
= name_size
;
330 memset(&data
, 0, sizeof(data
));
332 data
.size
= offset
+ 1;
334 _nc_db_put(capdb
, &key
, &data
);
338 key
.data
= name_list
;
339 key
.size
= strlen(name_list
);
341 _nc_STRCPY(buffer
+ 1,
344 data
.size
= name_size
+ 1;
346 _nc_db_put(capdb
, &key
, &data
);
348 while (*other_names
!= '\0') {
350 assert(ptr
< buffer
+ sizeof(buffer
) - 1);
351 while (*other_names
!= '|' && *other_names
!= '\0')
354 if (*other_names
!= '\0')
355 *(other_names
++) = '\0';
358 key
.size
= strlen(ptr
);
360 _nc_db_put(capdb
, &key
, &data
);
364 #else /* !USE_HASHED_DB */
365 if (call_count
++ == 0) {
369 if (strlen(first_name
) >= sizeof(filename
) - (2 + LEAF_LEN
))
370 _nc_warning("terminal name too long.");
372 _nc_SPRINTF(filename
, _nc_SLIMIT(sizeof(filename
))
373 LEAF_FMT
"/%s", first_name
[0], first_name
);
376 * Has this primary name been written since the first call to
377 * write_entry()? If so, the newer write will step on the older,
380 if (start_time
> 0 &&
381 stat(filename
, &statbuf
) >= 0
382 && statbuf
.st_mtime
>= start_time
) {
383 #if HAVE_LINK && !USE_SYMLINKS
385 * If the file has more than one link, the reason for the previous
386 * write could be that the current primary name used to be an alias for
387 * the previous entry. In that case, unlink the file so that we will
388 * not modify the previous entry as we write this one.
390 if (statbuf
.st_nlink
> 1) {
391 _nc_warning("name redefined.");
394 _nc_warning("name multiply defined.");
397 _nc_warning("name multiply defined.");
401 check_writeable(first_name
[0]);
402 write_file(filename
, tp
);
404 if (start_time
== 0) {
405 if (stat(filename
, &statbuf
) < 0
406 || (start_time
= statbuf
.st_mtime
) == 0) {
407 _nc_syserr_abort("error obtaining time from %s/%s",
408 _nc_tic_dir(0), filename
);
411 while (*other_names
!= '\0') {
413 while (*other_names
!= '|' && *other_names
!= '\0')
416 if (*other_names
!= '\0')
417 *(other_names
++) = '\0';
419 if (strlen(ptr
) > sizeof(linkname
) - (2 + LEAF_LEN
)) {
420 _nc_warning("terminal alias %s too long.", ptr
);
423 if (strchr(ptr
, '/') != 0) {
424 _nc_warning("cannot link alias %s.", ptr
);
428 check_writeable(ptr
[0]);
429 _nc_SPRINTF(linkname
, _nc_SLIMIT(sizeof(linkname
))
430 LEAF_FMT
"/%s", ptr
[0], ptr
);
432 if (strcmp(filename
, linkname
) == 0) {
433 _nc_warning("self-synonym ignored");
434 } else if (stat(linkname
, &statbuf
) >= 0 &&
435 statbuf
.st_mtime
< start_time
) {
436 _nc_warning("alias %s multiply defined.", ptr
);
437 } else if (_nc_access(linkname
, W_OK
) == 0)
442 if (first_name
[0] == linkname
[0])
443 strncpy(symlinkname
, first_name
, sizeof(symlinkname
) - 1);
445 _nc_STRCPY(symlinkname
, "../", sizeof(suymlinkname
));
446 strncat(symlinkname
, filename
, sizeof(symlinkname
) - 4);
448 symlinkname
[sizeof(symlinkname
) - 1] = '\0';
449 #endif /* USE_SYMLINKS */
451 code
= remove(linkname
);
453 code
= unlink(linkname
);
455 if (code
!= 0 && errno
== ENOENT
)
458 if (symlink(symlinkname
, linkname
) < 0)
460 if (link(filename
, linkname
) < 0)
461 #endif /* USE_SYMLINKS */
464 * If there wasn't anything there, and we cannot
465 * link to the target because it is the same as the
466 * target, then the source must be on a filesystem
467 * that uses caseless filenames, such as Win32, etc.
469 if (code
== 0 && errno
== EEXIST
)
470 _nc_warning("can't link %s to %s", filename
, linkname
);
471 else if (code
== 0 && (errno
== EPERM
|| errno
== ENOENT
))
472 write_file(linkname
, tp
);
474 #if MIXEDCASE_FILENAMES
475 _nc_syserr_abort("can't link %s to %s", filename
, linkname
);
477 _nc_warning("can't link %s to %s (errno=%d)", filename
,
482 DEBUG(1, ("Linked %s", linkname
));
485 #else /* just make copies */
486 write_file(linkname
, tp
);
487 #endif /* HAVE_LINK */
489 #endif /* USE_HASHED_DB */
493 fake_write(char *dst
,
500 size_t have
= (limit
- *offset
);
506 memcpy(dst
+ *offset
, src
, want
);
507 *offset
+= (unsigned) want
;
511 return (want
/ size
);
514 #define Write(buf, size, count) fake_write(buffer, offset, (size_t) limit, (char *) buf, (size_t) count, (size_t) size)
516 #undef LITTLE_ENDIAN /* BSD/OS defines this as a feature macro */
517 #define HI(x) ((x) / 256)
518 #define LO(x) ((x) % 256)
519 #define LITTLE_ENDIAN(p, x) (p)[0] = (unsigned char)LO(x), \
520 (p)[1] = (unsigned char)HI(x)
522 #define WRITE_STRING(str) (Write(str, sizeof(char), strlen(str) + 1) == strlen(str) + 1)
525 compute_offsets(char **Strings
, size_t strmax
, short *offsets
)
530 for (i
= 0; i
< strmax
; i
++) {
531 if (Strings
[i
] == ABSENT_STRING
) {
533 } else if (Strings
[i
] == CANCELLED_STRING
) {
536 offsets
[i
] = (short) nextfree
;
537 nextfree
+= (int) strlen(Strings
[i
]) + 1;
538 TRACE_OUT(("put Strings[%d]=%s(%d)", (int) i
,
539 _nc_visbuf(Strings
[i
]), (int) nextfree
));
546 convert_shorts(unsigned char *buf
, short *Numbers
, size_t count
)
549 for (i
= 0; i
< count
; i
++) {
550 if (Numbers
[i
] == ABSENT_NUMERIC
) { /* HI/LO won't work */
551 buf
[2 * i
] = buf
[2 * i
+ 1] = 0377;
552 } else if (Numbers
[i
] == CANCELLED_NUMERIC
) { /* HI/LO won't work */
554 buf
[2 * i
+ 1] = 0377;
556 LITTLE_ENDIAN(buf
+ 2 * i
, Numbers
[i
]);
557 TRACE_OUT(("put Numbers[%u]=%d", (unsigned) i
, Numbers
[i
]));
562 #define even_boundary(value) \
563 ((value) % 2 != 0 && Write(&zero, sizeof(char), 1) != 1)
567 extended_Booleans(TERMTYPE
*tp
)
572 for (i
= 0; i
< tp
->ext_Booleans
; ++i
) {
573 if (tp
->Booleans
[BOOLCOUNT
+ i
] == TRUE
)
580 extended_Numbers(TERMTYPE
*tp
)
585 for (i
= 0; i
< tp
->ext_Numbers
; ++i
) {
586 if (tp
->Numbers
[NUMCOUNT
+ i
] != ABSENT_NUMERIC
)
593 extended_Strings(TERMTYPE
*tp
)
595 unsigned short result
= 0;
598 for (i
= 0; i
< tp
->ext_Strings
; ++i
) {
599 if (tp
->Strings
[STRCOUNT
+ i
] != ABSENT_STRING
)
600 result
= (unsigned short) (i
+ 1);
606 * _nc_align_termtype() will extend entries that are referenced in a use=
607 * clause - discard the unneeded data.
610 extended_object(TERMTYPE
*tp
)
614 if (_nc_user_definable
) {
615 result
= ((extended_Booleans(tp
)
616 + extended_Numbers(tp
)
617 + extended_Strings(tp
)) != 0);
624 write_object(TERMTYPE
*tp
, char *buffer
, unsigned *offset
, unsigned limit
)
627 size_t namelen
, boolmax
, nummax
, strmax
;
631 short offsets
[MAX_ENTRY_SIZE
/ 2];
632 unsigned char buf
[MAX_ENTRY_SIZE
];
633 unsigned last_bool
= BOOLWRITE
;
634 unsigned last_num
= NUMWRITE
;
635 unsigned last_str
= STRWRITE
;
639 * Normally we limit the list of values to exclude the "obsolete"
640 * capabilities. However, if we are accepting extended names, add
641 * these as well, since they are used for supporting translation
644 if (_nc_user_definable
) {
645 last_bool
= BOOLCOUNT
;
651 namelist
= tp
->term_names
;
652 namelen
= strlen(namelist
) + 1;
655 for (i
= 0; i
< last_bool
; i
++) {
656 if (tp
->Booleans
[i
] == TRUE
)
661 for (i
= 0; i
< last_num
; i
++) {
662 if (tp
->Numbers
[i
] != ABSENT_NUMERIC
)
667 for (i
= 0; i
< last_str
; i
++) {
668 if (tp
->Strings
[i
] != ABSENT_STRING
)
672 nextfree
= compute_offsets(tp
->Strings
, strmax
, offsets
);
674 /* fill in the header */
675 LITTLE_ENDIAN(buf
, MAGIC
);
676 LITTLE_ENDIAN(buf
+ 2, min(namelen
, MAX_NAME_SIZE
+ 1));
677 LITTLE_ENDIAN(buf
+ 4, boolmax
);
678 LITTLE_ENDIAN(buf
+ 6, nummax
);
679 LITTLE_ENDIAN(buf
+ 8, strmax
);
680 LITTLE_ENDIAN(buf
+ 10, nextfree
);
682 /* write out the header */
683 TRACE_OUT(("Header of %s @%d", namelist
, *offset
));
684 if (Write(buf
, 12, 1) != 1
685 || Write(namelist
, sizeof(char), namelen
) != namelen
)
688 for (i
= 0; i
< boolmax
; i
++)
689 if (tp
->Booleans
[i
] == TRUE
)
693 if (Write(buf
, sizeof(char), boolmax
) != boolmax
)
696 if (even_boundary(namelen
+ boolmax
))
699 TRACE_OUT(("Numerics begin at %04x", *offset
));
702 convert_shorts(buf
, tp
->Numbers
, nummax
);
703 if (Write(buf
, 2, nummax
) != nummax
)
706 TRACE_OUT(("String offsets begin at %04x", *offset
));
708 /* the string offsets */
709 convert_shorts(buf
, offsets
, strmax
);
710 if (Write(buf
, 2, strmax
) != strmax
)
713 TRACE_OUT(("String table begins at %04x", *offset
));
716 for (i
= 0; i
< strmax
; i
++)
717 if (VALID_STRING(tp
->Strings
[i
]))
718 if (!WRITE_STRING(tp
->Strings
[i
]))
722 if (extended_object(tp
)) {
723 unsigned extcnt
= (unsigned) NUM_EXT_NAMES(tp
);
725 if (even_boundary(nextfree
))
728 nextfree
= compute_offsets(tp
->Strings
+ STRCOUNT
,
729 (size_t) tp
->ext_Strings
,
731 TRACE_OUT(("after extended string capabilities, nextfree=%d", nextfree
));
733 if (tp
->ext_Strings
>= SIZEOF(offsets
))
736 nextfree
+= compute_offsets(tp
->ext_Names
,
738 offsets
+ tp
->ext_Strings
);
739 TRACE_OUT(("after extended capnames, nextfree=%d", nextfree
));
740 strmax
= tp
->ext_Strings
+ extcnt
;
743 * Write the extended header
745 LITTLE_ENDIAN(buf
+ 0, tp
->ext_Booleans
);
746 LITTLE_ENDIAN(buf
+ 2, tp
->ext_Numbers
);
747 LITTLE_ENDIAN(buf
+ 4, tp
->ext_Strings
);
748 LITTLE_ENDIAN(buf
+ 6, strmax
);
749 LITTLE_ENDIAN(buf
+ 8, nextfree
);
750 TRACE_OUT(("WRITE extended-header @%d", *offset
));
751 if (Write(buf
, 10, 1) != 1)
754 TRACE_OUT(("WRITE %d booleans @%d", tp
->ext_Booleans
, *offset
));
756 && Write(tp
->Booleans
+ BOOLCOUNT
, sizeof(char),
757 tp
->ext_Booleans
) != tp
->ext_Booleans
)
760 if (even_boundary(tp
->ext_Booleans
))
763 TRACE_OUT(("WRITE %d numbers @%d", tp
->ext_Numbers
, *offset
));
764 if (tp
->ext_Numbers
) {
765 convert_shorts(buf
, tp
->Numbers
+ NUMCOUNT
, (size_t) tp
->ext_Numbers
);
766 if (Write(buf
, 2, tp
->ext_Numbers
) != tp
->ext_Numbers
)
771 * Convert the offsets for the ext_Strings and ext_Names tables,
774 convert_shorts(buf
, offsets
, strmax
);
775 TRACE_OUT(("WRITE offsets @%d", *offset
));
776 if (Write(buf
, 2, strmax
) != strmax
)
780 * Write the string table after the offset tables so we do not
781 * have to do anything about alignment.
783 for (i
= 0; i
< tp
->ext_Strings
; i
++) {
784 if (VALID_STRING(tp
->Strings
[i
+ STRCOUNT
])) {
785 TRACE_OUT(("WRITE ext_Strings[%d]=%s", (int) i
,
786 _nc_visbuf(tp
->Strings
[i
+ STRCOUNT
])));
787 if (!WRITE_STRING(tp
->Strings
[i
+ STRCOUNT
]))
793 * Write the extended names
795 for (i
= 0; i
< extcnt
; i
++) {
796 TRACE_OUT(("WRITE ext_Names[%d]=%s", (int) i
, tp
->ext_Names
[i
]));
797 if (!WRITE_STRING(tp
->ext_Names
[i
]))
802 #endif /* NCURSES_XNAMES */
809 * Returns the total number of entries written by this process
812 _nc_tic_written(void)
814 return total_written
;