/usr/src/lib/libcurses/tinfo/write_entry.c

Bug Summary

File:	src/lib/libcurses/tinfo/write_entry.c
Warning:	line 227, column 1 Potential memory leak

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name write_entry.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/lib/libcurses/obj -resource-dir /usr/local/lib/clang/13.0.0 -I . -I /usr/src/lib/libcurses -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/lib/libcurses/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/lib/libcurses/tinfo/write_entry.c

1/* $OpenBSD: write_entry.c,v 1.13 2010/01/12 23:22:06 nicm Exp $ */

3/****************************************************************************
* Copyright (c) 1998-2007,2008 Free Software Foundation, Inc.              *
*                                                                          *
* Permission is hereby granted, free of charge, to any person obtaining a  *
* copy of this software and associated documentation files (the            *
* "Software"), to deal in the Software without restriction, including      *
* without limitation the rights to use, copy, modify, merge, publish,      *
* distribute, distribute with modifications, sublicense, and/or sell       *
* copies of the Software, and to permit persons to whom the Software is    *
* furnished to do so, subject to the following conditions:                 *
*                                                                          *
* The above copyright notice and this permission notice shall be included  *
* in all copies or substantial portions of the Software.                   *
*                                                                          *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
* IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
* THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
*                                                                          *
* Except as contained in this notice, the name(s) of the above copyright   *
* holders shall not be used in advertising or otherwise to promote the     *
* sale, use or other dealings in this Software without prior written       *
* authorization.                                                           *
****************************************************************************/

31/****************************************************************************
*  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
*     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
*     and: Thomas E. Dickey                        1996-on                 *
****************************************************************************/

37/*
*	write_entry.c -- write a terminfo structure onto the file system
*/

41#include <curses.priv.h>
42#include <hashed_db.h>

44#include <sys/stat.h>

46#include <tic.h>
47#include <term_entry.h>

49#ifndef S_ISDIR
50#define S_ISDIR(mode)((mode & 0170000) == 0040000) ((mode & S_IFMT0170000) == S_IFDIR0040000)
51#endif

53#if 1
54#define TRACE_OUT(p) DEBUG(2, p)
55#else
56#define TRACE_OUT(p)		/*nothing */
57#endif

59MODULE_ID("$Id: write_entry.c,v 1.13 2010/01/12 23:22:06 nicm Exp $")

61static int total_written;

63static int make_db_root(const char *);
64static int write_object(TERMTYPE *, char *, unsigned *, unsigned);

66#if !USE_HASHED_DB0
67static void
68write_file(char *filename, TERMTYPE *tp)
69{
  char buffer[MAX_ENTRY_SIZE4096];
  unsigned limit = sizeof(buffer);
  unsigned offset = 0;

  FILE *fp = (_nc_access(filename, W_OK0x02) == 0) ? fopen(filename, "wb") : 0;
  if (fp == 0) {
perror(filename);
_nc_syserr_abort("can't open %s/%s", _nc_tic_dir(0), filename);
  }
  DEBUG(1, ("Created %s", filename));

  if (write_object(tp, buffer, &offset, limit) == ERR(-1)
|| fwrite(buffer, sizeof(char), offset, fp) != offset) {
_nc_syserr_abort("error writing %s/%s", _nc_tic_dir(0), filename);
  }

  fclose(fp);
87}

89/*
* Check for access rights to destination directories
* Create any directories which don't exist.
*
* Note:  there's no reason to return the result of make_db_root(), since
* this function is called only in instances where that has to succeed.
*/
96static void
97check_writeable(int code)
98{
  static const char dirnames[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
  static bool_Bool verified[sizeof(dirnames)];

  char dir[sizeof(LEAF_FMT"%c")];
  char *s = 0;

  if (code == 0 || (s = strchr(dirnames, code)) == 0)
_nc_err_abort("Illegal terminfo subdirectory \"" LEAF_FMT"%c" "\"", code);

  if (verified[s - dirnames])
return;

  snprintf(dir, sizeof(dir), LEAF_FMT"%c", code);
  if (make_db_root(dir) < 0) {
_nc_err_abort("%s/%s: permission denied", _nc_tic_dir(0), dir);
  }

  verified[s - dirnames] = TRUE1;
117}
118#endif /* !USE_HASHED_DB */

120static int
121make_db_path(char *dst, const char *src, unsigned limit)
122{
  int rc = -1;
  const char *top = _nc_tic_dir(0);

  if (src == top || _nc_is_abs_path(src)) {
if (strlen(src) + 1 <= limit) {
(void) strlcpy(dst, src, limit);
   rc = 0;
}
  } else {
if (strlen(top) + strlen(src) + 2 <= limit) {
(void) snprintf(dst, limit, "%s/%s", top, src);
   rc = 0;
}
  }
137#if USE_HASHED_DB0
  if (rc == 0) {
if (_nc_is_dir_path(dst)) {
   rc = -1;
} else {
   unsigned have = strlen(dst);
   if (have > 3 && strcmp(dst + have - 3, DBM_SUFFIX)) {
if (have + 3 <= limit)
    strlcat(dst, DBM_SUFFIX, limit);
else
    rc = -1;
   }
}
  }
151#endif
  return rc;
153}

155/*
* Make a database-root if it doesn't exist.
*/
158static int
159make_db_root(const char *path)
160{
  int rc;
  char fullpath[PATH_MAX1024];

  if ((rc = make_db_path(fullpath, path, sizeof(fullpath))) == 0) {
165#if USE_HASHED_DB0
DB *capdbp;

if ((capdbp = _nc_db_open(fullpath, TRUE1)) == NULL((void*)0))
   rc = -1;
else if (_nc_db_close(capdbp) < 0)
   rc = -1;
172#else
struct stat statbuf;

if ((rc = stat(path, &statbuf)) < 0) {
   rc = mkdir(path, 0777);
} else if (_nc_access(path, R_OK0x04 | W_OK0x02 | X_OK0x01) < 0) {
   rc = -1;		/* permission denied */
} else if (!(S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000))) {
   rc = -1;		/* not a directory */
}
182#endif
  }
  return rc;
185}

187/*
* Set the write directory for compiled entries.
*/
190NCURSES_EXPORT(void)void
191_nc_set_writedir(char *dir)
192{
  const char *destination;
  char actual[PATH_MAX1024];

  if (dir == 0
1
Assuming 'dir' is equal to null→
3
←
Taking false branch→
&& use_terminfo_vars()(!issetugid()))
2
←
Assuming the condition is false→
dir = getenv("TERMINFO");

  if (dir3.1
'dir' is equal to null
 != 0)
4
←
Taking false branch→
(void) _nc_tic_dir(dir);

  destination = _nc_tic_dir(0);
  if (make_db_root(destination) < 0) {
5
←
Taking true branch→
char *home = _nc_home_terminfo();

if (home != 0) {
6
←
Assuming 'home' is equal to null→
7
←
Taking false branch→
   destination = home;
   if (make_db_root(destination) < 0)
_nc_err_abort("%s: permission denied (errno %d)",
	      destination, errno(*__errno()));
}
  }

  /*
   * Note: because of this code, this logic should be exercised
   * *once only* per run.
   */
219#if USE_HASHED_DB0
  make_db_path(actual, destination, sizeof(actual));
221#else
  if (chdir(_nc_tic_dir(destination)) < 0
8
←
Assuming the condition is false→
10
←
Taking false branch→
|| getcwd(actual, sizeof(actual)) == 0)
9
←
Assuming the condition is false→
_nc_err_abort("%s: not a directory", destination);
225#endif
  _nc_keep_tic_dir(strdup(actual));
11
←
Memory is allocated→
227}
12
←
Potential memory leak

229/*
*	Save the compiled version of a description in the filesystem.
*
*	make a copy of the name-list
*	break it up into first-name and all-but-last-name
*	creat(first-name)
*	write object information to first-name
*	close(first-name)
*      for each name in all-but-last-name
*	    link to first-name
*
*	Using 'time()' to obtain a reference for file timestamps is unreliable,
*	e.g., with NFS, because the filesystem may have a different time
*	reference.  We check for pre-existence of links by latching the first
*	timestamp from a file that we create.
*
*	The _nc_warning() calls will report a correct line number only if
*	_nc_curr_line is properly set before the write_entry() call.
*/

249NCURSES_EXPORT(void)void
250_nc_write_entry(TERMTYPE *const tp)
251{
252#if USE_HASHED_DB0

  char buffer[MAX_ENTRY_SIZE4096 + 1];
  unsigned limit = sizeof(buffer);
  unsigned offset = 0;

258#else /* !USE_HASHED_DB */

  struct stat statbuf;
  char filename[PATH_MAX1024];
  char linkname[PATH_MAX1024];
263#if USE_SYMLINKS0
  char symlinkname[PATH_MAX1024];
265#if !HAVE_LINK1
266#undef HAVE_LINK1
267#define HAVE_LINK1 1
268#endif
269#endif /* USE_SYMLINKS */

  static int call_count;
  static time_t start_time;	/* time at start of writes */

274#endif /* USE_HASHED_DB */

  char name_list[MAX_TERMINFO_LENGTH4096];
  char *first_name, *other_names;
  char *ptr;

  assert(strlen(tp->term_names) != 0)((void)0);
  assert(strlen(tp->term_names) < sizeof(name_list))((void)0);

  (void) strlcpy(name_list, tp->term_names, sizeof(name_list));
  DEBUG(7, ("Name list = '%s'", name_list));

  first_name = name_list;

  ptr = &name_list[strlen(name_list) - 1];
  other_names = ptr + 1;

  while (ptr > name_list && *ptr != '|')
ptr--;

  if (ptr != name_list) {
*ptr = '\0';

for (ptr = name_list; *ptr != '\0' && *ptr != '|'; ptr++)
   continue;

if (*ptr == '\0')
   other_names = ptr;
else {
   *ptr = '\0';
   other_names = ptr + 1;
}
  }

  DEBUG(7, ("First name = '%s'", first_name));
  DEBUG(7, ("Other names = '%s'", other_names));

  _nc_set_type(first_name);

313#if USE_HASHED_DB0
  if (write_object(tp, buffer + 1, &offset, limit - 1) != ERR(-1)) {
DB *capdb = _nc_db_open(_nc_tic_dir(0), TRUE1);
DBT key, data;

if (capdb != 0) {
   buffer[0] = 0;

   memset(&key, 0, sizeof(key));
   key.data = tp->term_names;
   key.size = strlen(tp->term_names);

   memset(&data, 0, sizeof(data));
   data.data = buffer;
   data.size = offset + 1;

   _nc_db_put(capdb, &key, &data);

   buffer[0] = 2;

   key.data = name_list;
   key.size = strlen(name_list);

   strlcpy(buffer + 1, tp->term_names, sizeof(buffer) - 1);
   data.size = strlen(tp->term_names) + 1;

   _nc_db_put(capdb, &key, &data);

   while (*other_names != '\0') {
ptr = other_names++;
while (*other_names != '|' && *other_names != '\0')
    other_names++;

if (*other_names != '\0')
    *(other_names++) = '\0';

key.data = ptr;
key.size = strlen(ptr);

_nc_db_put(capdb, &key, &data);
   }
   _nc_db_close(capdb);
}
  }
357#else /* !USE_HASHED_DB */
  if (call_count++ == 0) {
start_time = 0;
  }

  if (strlen(first_name) >= sizeof(filename) - 3)
_nc_warning("terminal name too long.");

  snprintf(filename, sizeof(filename), LEAF_FMT"%c" "/%s", first_name[0], first_name);

  /*
   * Has this primary name been written since the first call to
   * write_entry()?  If so, the newer write will step on the older,
   * so warn the user.
   */
  if (start_time > 0 &&
stat(filename, &statbuf) >= 0
&& statbuf.st_mtimest_mtim.tv_sec >= start_time) {
_nc_warning("name multiply defined.");
  }

  check_writeable(first_name[0]);
  write_file(filename, tp);

  if (start_time == 0) {
if (stat(filename, &statbuf) < 0
   || (start_time = statbuf.st_mtimest_mtim.tv_sec) == 0) {
   _nc_syserr_abort("error obtaining time from %s/%s",
	     _nc_tic_dir(0), filename);
}
  }
  while (*other_names != '\0') {
ptr = other_names++;
assert(ptr < buffer + sizeof(buffer) - 1)((void)0);
while (*other_names != '|' && *other_names != '\0')
   other_names++;

if (*other_names != '\0')
   *(other_names++) = '\0';

if (strlen(ptr) > sizeof(linkname) - 3) {
   _nc_warning("terminal alias %s too long.", ptr);
   continue;
}
if (strchr(ptr, '/') != 0) {
   _nc_warning("cannot link alias %s.", ptr);
   continue;
}

check_writeable(ptr[0]);
snprintf(linkname, sizeof(linkname), LEAF_FMT"%c" "/%s", ptr[0], ptr);

if (strcmp(filename, linkname) == 0) {
   _nc_warning("self-synonym ignored");
} else if (stat(linkname, &statbuf) >= 0 &&
   statbuf.st_mtimest_mtim.tv_sec < start_time) {
   _nc_warning("alias %s multiply defined.", ptr);
} else if (_nc_access(linkname, W_OK0x02) == 0)
415#if HAVE_LINK1
{
   int code;
418#if USE_SYMLINKS0
          strlcpy(symlinkname, "../", sizeof(symlinkname));
          strlcat(symlinkname, filename, sizeof(symlinkname));
421#endif /* USE_SYMLINKS */
422#if HAVE_REMOVE1
   code = remove(linkname);
424#else
   code = unlink(linkname);
426#endif
   if (code != 0 && errno(*__errno()) == ENOENT2)
code = 0;
429#if USE_SYMLINKS0
   if (symlink(symlinkname, linkname) < 0)
431#else
   if (link(filename, linkname) < 0)
433#endif /* USE_SYMLINKS */
   {
/*
 * If there wasn't anything there, and we cannot
 * link to the target because it is the same as the
 * target, then the source must be on a filesystem
 * that uses caseless filenames, such as Win32, etc.
 */
if (code == 0 && errno(*__errno()) == EEXIST17)
    _nc_warning("can't link %s to %s", filename, linkname);
else if (code == 0 && (errno(*__errno()) == EPERM1 || errno(*__errno()) == ENOENT2))
    write_file(linkname, tp);
else {
446#if MIXEDCASE_FILENAMES1
    _nc_syserr_abort("can't link %s to %s", filename, linkname);
448#else
    _nc_warning("can't link %s to %s (errno=%d)", filename,
		linkname, errno(*__errno()));
451#endif
}
   } else {
DEBUG(1, ("Linked %s", linkname));
   }
}
457#else /* just make copies */
   write_file(linkname, tp);
459#endif /* HAVE_LINK */
  }
461#endif /* USE_HASHED_DB */
462}

464static unsigned
465fake_write(char *dst,
  unsigned *offset,
  unsigned limit,
  char *src,
  unsigned want,
  unsigned size)
471{
  int have = (limit - *offset);

  want *= size;
  if (have > 0) {
if ((int) want > have)
   want = have;
memcpy(dst + *offset, src, want);
*offset += want;
  } else {
want = 0;
  }
  return (int) (want / size);
484}

486#define Write(buf, size, count)fake_write(buffer, offset, limit, (char *) buf, count, size) fake_write(buffer, offset, limit, (char *) buf, count, size)

488#undef LITTLE_ENDIAN		/* BSD/OS defines this as a feature macro */
489#define HI(x)((x) / 256)			((x) / 256)
490#define LO(x)((x) % 256)			((x) % 256)
491#define LITTLE_ENDIAN(p, x)(p)[0] = ((x) % 256), (p)[1] = ((x) / 256)	(p)[0] = LO(x)((x) % 256), (p)[1] = HI(x)((x) / 256)

493#define WRITE_STRING(str)(fake_write(buffer, offset, limit, (char *) str, strlen(str) +
 1, sizeof(char)) == strlen(str) + 1) (Write(str, sizeof(char), strlen(str) + 1)fake_write(buffer, offset, limit, (char *) str, strlen(str) +
 1, sizeof(char)) == strlen(str) + 1)

495static int
496compute_offsets(char **Strings, unsigned strmax, short *offsets)
497{
  size_t nextfree = 0;
  unsigned i;

  for (i = 0; i < strmax; i++) {
if (Strings[i] == ABSENT_STRING(char *)0) {
   offsets[i] = -1;
} else if (Strings[i] == CANCELLED_STRING(char *)(-1)) {
   offsets[i] = -2;
} else {
   offsets[i] = nextfree;
   nextfree += strlen(Strings[i]) + 1;
   TRACE_OUT(("put Strings[%d]=%s(%d)", (int) i,
       _nc_visbuf(Strings[i]), (int) nextfree));
}
  }
  return nextfree;
514}

516static void
517convert_shorts(unsigned char *buf, short *Numbers, unsigned count)
518{
  unsigned i;
  for (i = 0; i < count; i++) {
if (Numbers[i] == ABSENT_NUMERIC(-1)) {	/* HI/LO won't work */
   buf[2 * i] = buf[2 * i + 1] = 0377;
} else if (Numbers[i] == CANCELLED_NUMERIC(-2)) {	/* HI/LO won't work */
   buf[2 * i] = 0376;
   buf[2 * i + 1] = 0377;
} else {
   LITTLE_ENDIAN(buf + 2 * i, Numbers[i])(buf + 2 * i)[0] = ((Numbers[i]) % 256), (buf + 2 * i)[1] = (
(Numbers[i]) / 256);
   TRACE_OUT(("put Numbers[%d]=%d", i, Numbers[i]));
}
  }
531}

533#define even_boundary(value)((value) % 2 != 0 && fake_write(buffer, offset, limit
, (char *) &zero, 1, sizeof(char)) != 1) \
   ((value) % 2 != 0 && Write(&zero, sizeof(char), 1)fake_write(buffer, offset, limit, (char *) &zero, 1, sizeof
(char)) != 1)

536#if NCURSES_XNAMES1
537static unsigned
538extended_Booleans(TERMTYPE *tp)
539{
  unsigned short result = 0;
  unsigned short i;

  for (i = 0; i < tp->ext_Booleans; ++i) {
if (tp->Booleans[BOOLCOUNT44 + i] == TRUE1)
   result = (i + 1);
  }
  return result;
548}

550static unsigned
551extended_Numbers(TERMTYPE *tp)
552{
  unsigned short result = 0;
  unsigned short i;

  for (i = 0; i < tp->ext_Numbers; ++i) {
if (tp->Numbers[NUMCOUNT39 + i] != ABSENT_NUMERIC(-1))
   result = (i + 1);
  }
  return result;
561}

563static unsigned
564extended_Strings(TERMTYPE *tp)
565{
  unsigned short result = 0;
  unsigned short i;

  for (i = 0; i < tp->ext_Strings; ++i) {
if (tp->Strings[STRCOUNT414 + i] != ABSENT_STRING(char *)0)
   result = (i + 1);
  }
  return result;
574}

576/*
* _nc_align_termtype() will extend entries that are referenced in a use=
* clause - discard the unneeded data.
*/
580static bool_Bool
581extended_object(TERMTYPE *tp)
582{
  bool_Bool result = FALSE0;

  if (_nc_user_definable) {
result = ((extended_Booleans(tp)
   + extended_Numbers(tp)
   + extended_Strings(tp)) != 0);
  }
  return result;
591}
592#endif

594static int
595write_object(TERMTYPE *tp, char *buffer, unsigned *offset, unsigned limit)
596{
  char *namelist;
  size_t namelen, boolmax, nummax, strmax;
  char zero = '\0';
  size_t i;
  short nextfree;
  short offsets[MAX_ENTRY_SIZE4096 / 2];
  unsigned char buf[MAX_ENTRY_SIZE4096];
  unsigned last_bool = BOOLWRITE37;
  unsigned last_num = NUMWRITE33;
  unsigned last_str = STRWRITE394;

608#if NCURSES_XNAMES1
  /*
   * Normally we limit the list of values to exclude the "obsolete"
   * capabilities.  However, if we are accepting extended names, add
   * these as well, since they are used for supporting translation
   * to/from termcap.
   */
  if (_nc_user_definable) {
last_bool = BOOLCOUNT44;
last_num = NUMCOUNT39;
last_str = STRCOUNT414;
  }
620#endif

  namelist = tp->term_names;
  namelen = strlen(namelist) + 1;

  boolmax = 0;
  for (i = 0; i < last_bool; i++) {
if (tp->Booleans[i] == TRUE1)
   boolmax = i + 1;
  }

  nummax = 0;
  for (i = 0; i < last_num; i++) {
if (tp->Numbers[i] != ABSENT_NUMERIC(-1))
   nummax = i + 1;
  }

  strmax = 0;
  for (i = 0; i < last_str; i++) {
if (tp->Strings[i] != ABSENT_STRING(char *)0)
   strmax = i + 1;
  }

  nextfree = compute_offsets(tp->Strings, strmax, offsets);

  /* fill in the header */
  LITTLE_ENDIAN(buf, MAGIC)(buf)[0] = ((0432) % 256), (buf)[1] = ((0432) / 256);
  LITTLE_ENDIAN(buf + 2, min(namelen, MAX_NAME_SIZE + 1))(buf + 2)[0] = ((((namelen) > (512 + 1) ? (512 + 1) : (namelen
))) % 256), (buf + 2)[1] = ((((namelen) > (512 + 1) ? (512
 + 1) : (namelen))) / 256);
  LITTLE_ENDIAN(buf + 4, boolmax)(buf + 4)[0] = ((boolmax) % 256), (buf + 4)[1] = ((boolmax) /
 256);
  LITTLE_ENDIAN(buf + 6, nummax)(buf + 6)[0] = ((nummax) % 256), (buf + 6)[1] = ((nummax) / 256
);
  LITTLE_ENDIAN(buf + 8, strmax)(buf + 8)[0] = ((strmax) % 256), (buf + 8)[1] = ((strmax) / 256
);
  LITTLE_ENDIAN(buf + 10, nextfree)(buf + 10)[0] = ((nextfree) % 256), (buf + 10)[1] = ((nextfree
) / 256);

  /* write out the header */
  TRACE_OUT(("Header of %s @%d", namelist, *offset));
  if (Write(buf, 12, 1)fake_write(buffer, offset, limit, (char *) buf, 1, 12) != 1
|| Write(namelist, sizeof(char), namelen)fake_write(buffer, offset, limit, (char *) namelist, namelen,
 sizeof(char)) != namelen)
 return (ERR(-1));

  for (i = 0; i < boolmax; i++)
if (tp->Booleans[i] == TRUE1)
   buf[i] = TRUE1;
else
   buf[i] = FALSE0;
  if (Write(buf, sizeof(char), boolmax)fake_write(buffer, offset, limit, (char *) buf, boolmax, sizeof
(char)) != boolmax)
 return (ERR(-1));

  if (even_boundary(namelen + boolmax)((namelen + boolmax) % 2 != 0 && fake_write(buffer, offset
, limit, (char *) &zero, 1, sizeof(char)) != 1))
return (ERR(-1));

  TRACE_OUT(("Numerics begin at %04x", *offset));

  /* the numerics */
  convert_shorts(buf, tp->Numbers, nummax);
  if (Write(buf, 2, nummax)fake_write(buffer, offset, limit, (char *) buf, nummax, 2) != nummax)
return (ERR(-1));

  TRACE_OUT(("String offsets begin at %04x", *offset));

  /* the string offsets */
  convert_shorts(buf, offsets, strmax);
  if (Write(buf, 2, strmax)fake_write(buffer, offset, limit, (char *) buf, strmax, 2) != strmax)
return (ERR(-1));

  TRACE_OUT(("String table begins at %04x", *offset));

  /* the strings */
  for (i = 0; i < strmax; i++)
if (VALID_STRING(tp->Strings[i])((tp->Strings[i]) != (char *)(-1) && (tp->Strings
[i]) != (char *)0))
   if (!WRITE_STRING(tp->Strings[i])(fake_write(buffer, offset, limit, (char *) tp->Strings[i]
, strlen(tp->Strings[i]) + 1, sizeof(char)) == strlen(tp->
Strings[i]) + 1))
return (ERR(-1));

692#if NCURSES_XNAMES1
  if (extended_object(tp)) {
unsigned extcnt = NUM_EXT_NAMES(tp)((tp)->ext_Booleans + (tp)->ext_Numbers + (tp)->ext_Strings
);

if (even_boundary(nextfree)((nextfree) % 2 != 0 && fake_write(buffer, offset, limit
, (char *) &zero, 1, sizeof(char)) != 1))
   return (ERR(-1));

nextfree = compute_offsets(tp->Strings + STRCOUNT414,
		   tp->ext_Strings,
		   offsets);
TRACE_OUT(("after extended string capabilities, nextfree=%d", nextfree));

if (tp->ext_Strings >= SIZEOF(offsets)(sizeof(offsets)/sizeof(offsets[0])))
   return (ERR(-1));

nextfree += compute_offsets(tp->ext_Names,
		    extcnt,
		    offsets + tp->ext_Strings);
TRACE_OUT(("after extended capnames, nextfree=%d", nextfree));
strmax = tp->ext_Strings + extcnt;

/*
* Write the extended header
*/
LITTLE_ENDIAN(buf + 0, tp->ext_Booleans)(buf + 0)[0] = ((tp->ext_Booleans) % 256), (buf + 0)[1] = (
(tp->ext_Booleans) / 256);
LITTLE_ENDIAN(buf + 2, tp->ext_Numbers)(buf + 2)[0] = ((tp->ext_Numbers) % 256), (buf + 2)[1] = (
(tp->ext_Numbers) / 256);
LITTLE_ENDIAN(buf + 4, tp->ext_Strings)(buf + 4)[0] = ((tp->ext_Strings) % 256), (buf + 4)[1] = (
(tp->ext_Strings) / 256);
LITTLE_ENDIAN(buf + 6, strmax)(buf + 6)[0] = ((strmax) % 256), (buf + 6)[1] = ((strmax) / 256
);
LITTLE_ENDIAN(buf + 8, nextfree)(buf + 8)[0] = ((nextfree) % 256), (buf + 8)[1] = ((nextfree)
 / 256);
TRACE_OUT(("WRITE extended-header @%d", *offset));
if (Write(buf, 10, 1)fake_write(buffer, offset, limit, (char *) buf, 1, 10) != 1)
   return (ERR(-1));

TRACE_OUT(("WRITE %d booleans @%d", tp->ext_Booleans, *offset));
if (tp->ext_Booleans
   && Write(tp->Booleans + BOOLCOUNT, sizeof(char),fake_write(buffer, offset, limit, (char *) tp->Booleans + 44
, tp->ext_Booleans, sizeof(char))
     tp->ext_Booleans)fake_write(buffer, offset, limit, (char *) tp->Booleans + 44
, tp->ext_Booleans, sizeof(char)) != tp->ext_Booleans)
     return (ERR(-1));

if (even_boundary(tp->ext_Booleans)((tp->ext_Booleans) % 2 != 0 && fake_write(buffer,
 offset, limit, (char *) &zero, 1, sizeof(char)) != 1))
   return (ERR(-1));

TRACE_OUT(("WRITE %d numbers @%d", tp->ext_Numbers, *offset));
if (tp->ext_Numbers) {
   convert_shorts(buf, tp->Numbers + NUMCOUNT39, tp->ext_Numbers);
   if (Write(buf, 2, tp->ext_Numbers)fake_write(buffer, offset, limit, (char *) buf, tp->ext_Numbers
, 2) != tp->ext_Numbers)
return (ERR(-1));
}

/*
* Convert the offsets for the ext_Strings and ext_Names tables,
* in that order.
*/
convert_shorts(buf, offsets, strmax);
TRACE_OUT(("WRITE offsets @%d", *offset));
if (Write(buf, 2, strmax)fake_write(buffer, offset, limit, (char *) buf, strmax, 2) != strmax)
   return (ERR(-1));

/*
* Write the string table after the offset tables so we do not
* have to do anything about alignment.
*/
for (i = 0; i < tp->ext_Strings; i++) {
   if (VALID_STRING(tp->Strings[i + STRCOUNT])((tp->Strings[i + 414]) != (char *)(-1) && (tp->
Strings[i + 414]) != (char *)0)) {
TRACE_OUT(("WRITE ext_Strings[%d]=%s", (int) i,
	   _nc_visbuf(tp->Strings[i + STRCOUNT])));
if (!WRITE_STRING(tp->Strings[i + STRCOUNT])(fake_write(buffer, offset, limit, (char *) tp->Strings[i +
 414], strlen(tp->Strings[i + 414]) + 1, sizeof(char)) == strlen
(tp->Strings[i + 414]) + 1))
    return (ERR(-1));
   }
}

/*
* Write the extended names
*/
for (i = 0; i < extcnt; i++) {
   TRACE_OUT(("WRITE ext_Names[%d]=%s", (int) i, tp->ext_Names[i]));
   if (!WRITE_STRING(tp->ext_Names[i])(fake_write(buffer, offset, limit, (char *) tp->ext_Names[
i], strlen(tp->ext_Names[i]) + 1, sizeof(char)) == strlen(
tp->ext_Names[i]) + 1))
return (ERR(-1));
}

  }
773#endif /* NCURSES_XNAMES */

  total_written++;
  return (OK(0));
777}

779/*
* Returns the total number of entries written by this process
*/
782NCURSES_EXPORT(int)int
783_nc_tic_written(void)
784{
  return total_written;
786}