usr.bin/gencat/gencat.c

   1 /*      $NetBSD: gencat.c,v 1.36 2013/11/27 17:38:11 apb Exp $  */
   2
   3 /*
   4  * Copyright (c) 1996 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by J.T. Conklin.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #if defined(__RCSID) && !defined(lint)
  34 __RCSID("$NetBSD: gencat.c,v 1.36 2013/11/27 17:38:11 apb Exp $");
  35 #endif
  36
  37 /***********************************************************
  38 Copyright 1990, by Alfalfa Software Incorporated, Cambridge, Massachusetts.
  39
  40                         All Rights Reserved
  41
  42 Permission to use, copy, modify, and distribute this software and its
  43 documentation for any purpose and without fee is hereby granted,
  44 provided that the above copyright notice appear in all copies and that
  45 both that copyright notice and this permission notice appear in
  46 supporting documentation, and that Alfalfa's name not be used in
  47 advertising or publicity pertaining to distribution of the software
  48 without specific, written prior permission.
  49
  50 ALPHALPHA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  51 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  52 ALPHALPHA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  53 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  54 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  55 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  56 SOFTWARE.
  57
  58 If you make any modifications, bugfixes or other changes to this software
  59 we'd appreciate it if you could send a copy to us so we can keep things
  60 up-to-date.  Many thanks.
  61                                 Kee Hinckley
  62                                 Alfalfa Software, Inc.
  63                                 267 Allston St., #3
  64                                 Cambridge, MA 02139  USA
  65                                 nazgul@alfalfa.com
  66
  67 ******************************************************************/
  68
  69 #if HAVE_NBTOOL_CONFIG_H
  70 #include "nbtool_config.h"
  71 #endif
  72
  73 #define _NLS_PRIVATE
  74
  75 #include <sys/types.h>
  76 #include <sys/queue.h>
  77
  78 #include <netinet/in.h> /* Needed by arpa/inet.h on NetBSD */
  79 #include <arpa/inet.h>  /* Needed for htonl() on POSIX systems */
  80
  81 #include <ctype.h>
  82 #include <err.h>
  83 #include <errno.h>
  84 #include <fcntl.h>
  85 #include <limits.h>
  86 #include <nl_types.h>
  87 #include <stdio.h>
  88 #include <stdlib.h>
  89 #include <string.h>
  90 #include <unistd.h>
  91
  92 #ifndef NL_SETMAX
  93 #define NL_SETMAX 255
  94 #endif
  95 #ifndef NL_MSGMAX
  96 #define NL_MSGMAX 2048
  97 #endif
  98
  99 struct _msgT {
 100         long    msgId;
 101         char   *str;
 102         LIST_ENTRY(_msgT) entries;
 103 };
 104
 105 struct _setT {
 106         long    setId;
 107         LIST_HEAD(msghead, _msgT) msghead;
 108         LIST_ENTRY(_setT) entries;
 109 };
 110
 111 static LIST_HEAD(sethead, _setT) sethead = LIST_HEAD_INITIALIZER(sethead);
 112 static struct _setT *curSet;
 113
 114 static const char *curfile;
 115 static char *curline = NULL;
 116 static long lineno = 0;
 117
 118 static  char   *cskip(char *);
 119 __dead static   void    error(const char *);
 120 static  char   *get_line(int);
 121 static  char   *getmsg(int, char *, char);
 122 static  void    warning(const char *, const char *);
 123 static  char   *wskip(char *);
 124 static  char   *xstrdup(const char *);
 125 static  void   *xmalloc(size_t);
 126 static  void   *xrealloc(void *, size_t);
 127
 128 static void     MCParse(int fd);
 129 static void     MCReadCat(int fd);
 130 static void     MCWriteCat(int fd);
 131 static void     MCDelMsg(int msgId);
 132 static void     MCAddMsg(int msgId, const char *msg);
 133 static void     MCAddSet(int setId);
 134 static void     MCDelSet(int setId);
 135 __dead static void      usage(void);
 136
 137 #define CORRUPT                 "corrupt message catalog"
 138 #define NOMEMORY                "out of memory"
 139
 140 static void
 141 usage(void)
 142 {
 143         fprintf(stderr, "usage: %s catfile [msgfile|- ...]\n", getprogname());
 144         exit(1);
 145 }
 146
 147 int
 148 main(int argc, char *argv[])
 149 {
 150         int     ofd, ifd;
 151         char   *catfile = NULL;
 152         int     c;
 153         int     updatecat = 0;
 154
 155         while ((c = getopt(argc, argv, "")) != -1) {
 156                 switch (c) {
 157                 case '?':
 158                 default:
 159                         usage();
 160                         /* NOTREACHED */
 161                 }
 162         }
 163         argc -= optind;
 164         argv += optind;
 165
 166         if (argc < 1) {
 167                 usage();
 168                 /* NOTREACHED */
 169         }
 170         catfile = *argv++;
 171
 172         if ((catfile[0] == '-') && (catfile[1] == '\0')) {
 173                 ofd = STDOUT_FILENO;
 174         } else {
 175                 ofd = open(catfile, O_WRONLY | O_CREAT | O_EXCL, 0666);
 176                 if (ofd < 0) {
 177                         if (errno == EEXIST) {
 178                                 if ((ofd = open(catfile, O_RDWR)) < 0) {
 179                                         err(1, "Unable to open %s", catfile);
 180                                         /* NOTREACHED */
 181                                 }
 182                         } else {
 183                                 err(1, "Unable to create new %s", catfile);
 184                                 /* NOTREACHED */
 185                         }
 186                         curfile = catfile;
 187                         updatecat = 1;
 188                         MCReadCat(ofd);
 189                         if (lseek(ofd, (off_t)0, SEEK_SET) == (off_t)-1) {
 190                                 err(1, "Unable to seek on %s", catfile);
 191                                 /* NOTREACHED */
 192                         }
 193                 }
 194         }
 195
 196         if (argc < 2 || (((*argv)[0] == '-') && ((*argv)[1] == '\0'))) {
 197                 if (argc > 2)
 198                         usage();
 199                         /* NOTREACHED */
 200                 MCParse(STDIN_FILENO);
 201         } else {
 202                 for (; *argv; argv++) {
 203                         if ((ifd = open(*argv, O_RDONLY)) < 0)
 204                                 err(1, "Unable to read %s", *argv);
 205                         curfile = *argv;
 206                         lineno = 0;
 207                         MCParse(ifd);
 208                         close(ifd);
 209                 }
 210         }
 211
 212         if (updatecat) {
 213                 if (ftruncate(ofd, 0) != 0) {
 214                         err(1, "Unable to truncate %s", catfile);
 215                         /* NOTREACHED */
 216                 }
 217         }
 218
 219         MCWriteCat(ofd);
 220         exit(0);
 221 }
 222
 223 static void
 224 warning(const char *cptr, const char *msg)
 225 {
 226         if (lineno) {
 227                 fprintf(stderr, "%s: %s on line %ld, %s\n",
 228                         getprogname(), msg, lineno, curfile);
 229                 fprintf(stderr, "%s\n", curline);
 230                 if (cptr) {
 231                         char   *tptr;
 232                         for (tptr = curline; tptr < cptr; ++tptr)
 233                                 putc(' ', stderr);
 234                         fprintf(stderr, "^\n");
 235                 }
 236         } else {
 237                 fprintf(stderr, "%s: %s, %s\n", getprogname(), msg, curfile);
 238         }
 239 }
 240
 241 static void
 242 error(const char *msg)
 243 {
 244         warning(NULL, msg);
 245         exit(1);
 246 }
 247
 248 static void *
 249 xmalloc(size_t len)
 250 {
 251         void   *p;
 252
 253         if ((p = malloc(len)) == NULL)
 254                 errx(1, NOMEMORY);
 255         return (p);
 256 }
 257
 258 static void *
 259 xrealloc(void *ptr, size_t size)
 260 {
 261         if ((ptr = realloc(ptr, size)) == NULL)
 262                 errx(1, NOMEMORY);
 263         return (ptr);
 264 }
 265
 266 static char *
 267 xstrdup(const char *str)
 268 {
 269         char *nstr;
 270
 271         if ((nstr = strdup(str)) == NULL)
 272                 errx(1, NOMEMORY);
 273         return (nstr);
 274 }
 275
 276 static char *
 277 get_line(int fd)
 278 {
 279         static long curlen = BUFSIZ;
 280         static char buf[BUFSIZ], *bptr = buf, *bend = buf;
 281         char   *cptr, *cend;
 282         long    buflen;
 283
 284         if (!curline) {
 285                 curline = xmalloc(curlen);
 286         }
 287         ++lineno;
 288
 289         cptr = curline;
 290         cend = curline + curlen;
 291         for (;;) {
 292                 for (; bptr < bend && cptr < cend; ++cptr, ++bptr) {
 293                         if (*bptr == '\n') {
 294                                 *cptr = '\0';
 295                                 ++bptr;
 296                                 return (curline);
 297                         } else
 298                                 *cptr = *bptr;
 299                 }
 300                 if (cptr == cend) {
 301                         cptr = curline = xrealloc(curline, curlen *= 2);
 302                         cend = curline + curlen;
 303                 }
 304                 if (bptr == bend) {
 305                         buflen = read(fd, buf, BUFSIZ);
 306                         if (buflen <= 0) {
 307                                 if (cptr > curline) {
 308                                         *cptr = '\0';
 309                                         return (curline);
 310                                 }
 311                                 return (NULL);
 312                         }
 313                         bend = buf + buflen;
 314                         bptr = buf;
 315                 }
 316         }
 317 }
 318
 319 static char *
 320 wskip(char *cptr)
 321 {
 322         if (!*cptr || !isspace((unsigned char) *cptr)) {
 323                 warning(cptr, "expected a space");
 324                 return (cptr);
 325         }
 326         while (*cptr && isspace((unsigned char) *cptr))
 327                 ++cptr;
 328         return (cptr);
 329 }
 330
 331 static char *
 332 cskip(char *cptr)
 333 {
 334         if (!*cptr || isspace((unsigned char) *cptr)) {
 335                 warning(cptr, "wasn't expecting a space");
 336                 return (cptr);
 337         }
 338         while (*cptr && !isspace((unsigned char) *cptr))
 339                 ++cptr;
 340         return (cptr);
 341 }
 342
 343 static char *
 344 getmsg(int fd, char *cptr, char quote)
 345 {
 346         static char *msg = NULL;
 347         static size_t msglen = 0;
 348         size_t  clen, i;
 349         int     in_quote = 0;
 350         char   *tptr;
 351
 352         if (quote && *cptr == quote) {
 353                 ++cptr;
 354                 in_quote = 1;
 355         }
 356
 357         clen = strlen(cptr) + 1;
 358         if (clen > msglen) {
 359                 if (msglen)
 360                         msg = xrealloc(msg, clen);
 361                 else
 362                         msg = xmalloc(clen);
 363                 msglen = clen;
 364         }
 365         tptr = msg;
 366
 367         while (*cptr) {
 368                 if (quote && *cptr == quote) {
 369                         char   *tmp;
 370                         tmp = cptr + 1;
 371                         if (!in_quote) {
 372                                 /* XXX hard error? */
 373                                 warning(cptr, "unexpected quote character, ignoring");
 374                                 *tptr++ = *cptr++;
 375                         } else {
 376                                 cptr++;
 377                                 /* don't use wskip() */
 378                                 while (*cptr && isspace((unsigned char) *cptr))
 379 #ifndef _BACKWARDS_COMPAT
 380                                         cptr++;
 381 #else
 382                                         *tptr++ = *cptr++;
 383 #endif
 384                                 /* XXX hard error? */
 385                                 if (*cptr)
 386                                         warning(tmp, "unexpected extra characters, ignoring");
 387                                 in_quote = 0;
 388 #ifndef _BACKWARDS_COMPAT
 389                                 break;
 390 #endif
 391                         }
 392                 } else {
 393                         if (*cptr == '\\') {
 394                                 ++cptr;
 395                                 switch (*cptr) {
 396                                 case '\0':
 397                                         cptr = get_line(fd);
 398                                         if (!cptr)
 399                                                 error("premature end of file");
 400                                         msglen += strlen(cptr);
 401                                         i = tptr - msg;
 402                                         msg = xrealloc(msg, msglen);
 403                                         tptr = msg + i;
 404                                         break;
 405                                 case 'n':
 406                                         *tptr++ = '\n';
 407                                         ++cptr;
 408                                         break;
 409                                 case 't':
 410                                         *tptr++ = '\t';
 411                                         ++cptr;
 412                                         break;
 413                                 case 'v':
 414                                         *tptr++ = '\v';
 415                                         ++cptr;
 416                                         break;
 417                                 case 'b':
 418                                         *tptr++ = '\b';
 419                                         ++cptr;
 420                                         break;
 421                                 case 'r':
 422                                         *tptr++ = '\r';
 423                                         ++cptr;
 424                                         break;
 425                                 case 'f':
 426                                         *tptr++ = '\f';
 427                                         ++cptr;
 428                                         break;
 429                                 case '\\':
 430                                         *tptr++ = '\\';
 431                                         ++cptr;
 432                                         break;
 433                                 default:
 434                                         if (quote && *cptr == quote) {
 435                                                 *tptr++ = *cptr++;
 436                                         } else if (isdigit((unsigned char) *cptr)) {
 437                                                 *tptr = 0;
 438                                                 for (i = 0; i < 3; ++i) {
 439                                                         if (!isdigit((unsigned char) *cptr))
 440                                                                 break;
 441                                                         if (*cptr > '7')
 442                                                                 warning(cptr, "octal number greater than 7?!");
 443                                                         *tptr *= 8;
 444                                                         *tptr += (*cptr - '0');
 445                                                         ++cptr;
 446                                                 }
 447                                         } else {
 448                                                 warning(cptr, "unrecognized escape sequence");
 449                                         }
 450                                         break;
 451                                 }
 452                         } else {
 453                                 *tptr++ = *cptr++;
 454                         }
 455                 }
 456         }
 457
 458         if (in_quote)
 459                 warning(cptr, "unterminated quoted message, ignoring");
 460
 461         *tptr = '\0';
 462         return (msg);
 463 }
 464
 465 static void
 466 MCParse(int fd)
 467 {
 468         char   *cptr, *str;
 469         int     msgid = 0;
 470         int     setid = 0;
 471         char    quote = 0;
 472
 473         while ((cptr = get_line(fd))) {
 474                 if (*cptr == '$') {
 475                         ++cptr;
 476                         if (strncmp(cptr, "set", 3) == 0) {
 477                                 cptr += 3;
 478                                 cptr = wskip(cptr);
 479                                 setid = atoi(cptr);
 480                                 MCAddSet(setid);
 481                                 msgid = 0;
 482                         } else if (strncmp(cptr, "delset", 6) == 0) {
 483                                 cptr += 6;
 484                                 cptr = wskip(cptr);
 485                                 setid = atoi(cptr);
 486                                 MCDelSet(setid);
 487                         } else if (strncmp(cptr, "quote", 5) == 0) {
 488                                 cptr += 5;
 489                                 if (!*cptr)
 490                                         quote = 0;
 491                                 else {
 492                                         cptr = wskip(cptr);
 493                                         if (!*cptr)
 494                                                 quote = 0;
 495                                         else
 496                                                 quote = *cptr;
 497                                 }
 498                         } else if (isspace((unsigned char) *cptr)) {
 499                                 ;
 500                         } else {
 501                                 if (*cptr) {
 502                                         cptr = wskip(cptr);
 503                                         if (*cptr)
 504                                                 warning(cptr, "unrecognized line");
 505                                 }
 506                         }
 507                 } else {
 508                         /*
 509                          * First check for (and eat) empty lines....
 510                          */
 511                         if (!*cptr)
 512                                 continue;
 513                         /*
 514                          * We have a digit? Start of a message. Else,
 515                          * syntax error.
 516                          */
 517                         if (isdigit((unsigned char) *cptr)) {
 518                                 msgid = atoi(cptr);
 519                                 cptr = cskip(cptr);
 520                                 if (*cptr) {
 521                                         cptr = wskip(cptr);
 522                                         if (!*cptr) {
 523                                                 MCAddMsg(msgid, "");
 524                                                 continue;
 525                                         }
 526                                 }
 527                         } else {
 528                                 warning(cptr, "neither blank line nor start of a message id");
 529                                 continue;
 530                         }
 531                         /*
 532                          * If no set directive specified, all messages
 533                          * shall be in default message set NL_SETD.
 534                          */
 535                         if (setid == 0) {
 536                                 setid = NL_SETD;
 537                                 MCAddSet(setid);
 538                         }
 539                         /*
 540                          * If we have a message ID, but no message,
 541                          * then this means "delete this message id
 542                          * from the catalog".
 543                          */
 544                         if (!*cptr) {
 545                                 MCDelMsg(msgid);
 546                         } else {
 547                                 str = getmsg(fd, cptr, quote);
 548                                 MCAddMsg(msgid, str);
 549                         }
 550                 }
 551         }
 552 }
 553
 554 static void
 555 MCReadCat(int fd)
 556 {
 557         void   *msgcat;         /* message catalog data */
 558         struct _nls_cat_hdr cat_hdr;
 559         struct _nls_set_hdr *set_hdr;
 560         struct _nls_msg_hdr *msg_hdr;
 561         char   *strings;
 562         ssize_t n;
 563         int     m, s;
 564         int     msgno, setno;
 565
 566         n = read(fd, &cat_hdr, sizeof(cat_hdr));
 567         if (n < (ssize_t)sizeof(cat_hdr)) {
 568                 if (n == 0)
 569                         return;         /* empty file */
 570                 else if (n == -1)
 571                         err(1, "header read");
 572                 else
 573                         errx(1, CORRUPT);
 574         }
 575         if (ntohl((uint32_t)cat_hdr.__magic) != _NLS_MAGIC)
 576                 errx(1, "%s: bad magic number (%#x)", CORRUPT, cat_hdr.__magic);
 577
 578         cat_hdr.__mem = ntohl(cat_hdr.__mem);
 579
 580         cat_hdr.__nsets = ntohl(cat_hdr.__nsets);
 581         cat_hdr.__msg_hdr_offset = ntohl(cat_hdr.__msg_hdr_offset);
 582         cat_hdr.__msg_txt_offset = ntohl(cat_hdr.__msg_txt_offset);
 583         if ((cat_hdr.__mem < 0) ||
 584             (cat_hdr.__msg_hdr_offset < 0) ||
 585             (cat_hdr.__msg_txt_offset < 0) ||
 586             (cat_hdr.__mem < (int32_t)(cat_hdr.__nsets * sizeof(struct _nls_set_hdr))) ||
 587             (cat_hdr.__mem < cat_hdr.__msg_hdr_offset) ||
 588             (cat_hdr.__mem < cat_hdr.__msg_txt_offset))
 589                 errx(1, "%s: catalog header", CORRUPT);
 590
 591         msgcat = xmalloc(cat_hdr.__mem);
 592
 593         n = read(fd, msgcat, cat_hdr.__mem);
 594         if (n < cat_hdr.__mem) {
 595                 if (n == -1)
 596                         err(1, "data read");
 597                 else
 598                         errx(1, CORRUPT);
 599         }
 600
 601         set_hdr = (struct _nls_set_hdr *)msgcat;
 602         msg_hdr = (struct _nls_msg_hdr *)((char *)msgcat +
 603             cat_hdr.__msg_hdr_offset);
 604         strings = (char *)msgcat + cat_hdr.__msg_txt_offset;
 605
 606         setno = 0;
 607         for (s = 0; s < cat_hdr.__nsets; s++, set_hdr++) {
 608                 set_hdr->__setno = ntohl(set_hdr->__setno);
 609                 if (set_hdr->__setno < setno)
 610                         errx(1, "%s: bad set number (%d)",
 611                              CORRUPT, set_hdr->__setno);
 612                 setno = set_hdr->__setno;
 613
 614                 MCAddSet(setno);
 615
 616                 set_hdr->__nmsgs = ntohl(set_hdr->__nmsgs);
 617                 set_hdr->__index = ntohl(set_hdr->__index);
 618                 if (set_hdr->__nmsgs < 0 || set_hdr->__index < 0)
 619                         errx(1, "%s: set header", CORRUPT);
 620
 621                 /* Get the data */
 622                 msgno = 0;
 623                 for (m = 0; m < set_hdr->__nmsgs; m++, msg_hdr++) {
 624                         msg_hdr->__msgno = ntohl(msg_hdr->__msgno);
 625                         msg_hdr->__offset = ntohl(msg_hdr->__offset);
 626                         if (msg_hdr->__msgno < msgno)
 627                                 errx(1, "%s: bad message number (%d)",
 628                                      CORRUPT, msg_hdr->__msgno);
 629                         if ((msg_hdr->__offset < 0) ||
 630                             ((strings + msg_hdr->__offset) >
 631                              ((char *)msgcat + cat_hdr.__mem)))
 632                                 errx(1, "%s: message header", CORRUPT);
 633
 634                         msgno = msg_hdr->__msgno;
 635                         MCAddMsg(msgno, strings + msg_hdr->__offset);
 636                 }
 637         }
 638         free(msgcat);
 639 }
 640
 641 /*
 642  * Write message catalog.
 643  *
 644  * The message catalog is first converted from its internal to its
 645  * external representation in a chunk of memory allocated for this
 646  * purpose.  Then the completed catalog is written.  This approach
 647  * avoids additional housekeeping variables and/or a lot of seeks
 648  * that would otherwise be required.
 649  */
 650 static void
 651 MCWriteCat(int fd)
 652 {
 653         int     nsets;          /* number of sets */
 654         int     nmsgs;          /* number of msgs */
 655         int     string_size;    /* total size of string pool */
 656         int     msgcat_size;    /* total size of message catalog */
 657         void   *msgcat;         /* message catalog data */
 658         struct _nls_cat_hdr *cat_hdr;
 659         struct _nls_set_hdr *set_hdr;
 660         struct _nls_msg_hdr *msg_hdr;
 661         char   *strings;
 662         struct _setT *set;
 663         struct _msgT *msg;
 664         int     msg_index;
 665         int     msg_offset;
 666
 667         /* determine number of sets, number of messages, and size of the
 668          * string pool */
 669         nsets = 0;
 670         nmsgs = 0;
 671         string_size = 0;
 672
 673         LIST_FOREACH(set, &sethead, entries) {
 674                 nsets++;
 675
 676                 LIST_FOREACH(msg, &set->msghead, entries) {
 677                         nmsgs++;
 678                         string_size += strlen(msg->str) + 1;
 679                 }
 680         }
 681
 682 #ifdef DEBUG
 683         printf("number of sets: %d\n", nsets);
 684         printf("number of msgs: %d\n", nmsgs);
 685         printf("string pool size: %d\n", string_size);
 686 #endif
 687
 688         /* determine size and then allocate buffer for constructing external
 689          * message catalog representation */
 690         msgcat_size = sizeof(struct _nls_cat_hdr)
 691             + (nsets * sizeof(struct _nls_set_hdr))
 692             + (nmsgs * sizeof(struct _nls_msg_hdr))
 693             + string_size;
 694
 695         msgcat = xmalloc(msgcat_size);
 696         memset(msgcat, '\0', msgcat_size);
 697
 698         /* fill in msg catalog header */
 699         cat_hdr = (struct _nls_cat_hdr *) msgcat;
 700         cat_hdr->__magic = htonl(_NLS_MAGIC);
 701         cat_hdr->__nsets = htonl(nsets);
 702         cat_hdr->__mem = htonl(msgcat_size - sizeof(struct _nls_cat_hdr));
 703         cat_hdr->__msg_hdr_offset =
 704             htonl(nsets * sizeof(struct _nls_set_hdr));
 705         cat_hdr->__msg_txt_offset =
 706             htonl(nsets * sizeof(struct _nls_set_hdr) +
 707             nmsgs * sizeof(struct _nls_msg_hdr));
 708
 709         /* compute offsets for set & msg header tables and string pool */
 710         set_hdr = (struct _nls_set_hdr *) ((char *) msgcat +
 711             sizeof(struct _nls_cat_hdr));
 712         msg_hdr = (struct _nls_msg_hdr *) ((char *) msgcat +
 713             sizeof(struct _nls_cat_hdr) +
 714             nsets * sizeof(struct _nls_set_hdr));
 715         strings = (char *) msgcat +
 716             sizeof(struct _nls_cat_hdr) +
 717             nsets * sizeof(struct _nls_set_hdr) +
 718             nmsgs * sizeof(struct _nls_msg_hdr);
 719
 720         msg_index = 0;
 721         msg_offset = 0;
 722         LIST_FOREACH(set, &sethead, entries) {
 723
 724                 nmsgs = 0;
 725                 LIST_FOREACH(msg, &set->msghead, entries) {
 726                         int32_t     msg_len = strlen(msg->str) + 1;
 727
 728                         msg_hdr->__msgno = htonl(msg->msgId);
 729                         msg_hdr->__msglen = htonl(msg_len);
 730                         msg_hdr->__offset = htonl(msg_offset);
 731
 732                         memcpy(strings, msg->str, msg_len);
 733                         strings += msg_len;
 734                         msg_offset += msg_len;
 735
 736                         nmsgs++;
 737                         msg_hdr++;
 738                 }
 739
 740                 set_hdr->__setno = htonl(set->setId);
 741                 set_hdr->__nmsgs = htonl(nmsgs);
 742                 set_hdr->__index = htonl(msg_index);
 743                 msg_index += nmsgs;
 744                 set_hdr++;
 745         }
 746
 747         /* write out catalog.  XXX: should this be done in small chunks? */
 748         write(fd, msgcat, msgcat_size);
 749 }
 750
 751 static void
 752 MCAddSet(int setId)
 753 {
 754         struct _setT *p, *q;
 755
 756         if (setId <= 0) {
 757                 error("setId's must be greater than zero");
 758                 /* NOTREACHED */
 759         }
 760         if (setId > NL_SETMAX) {
 761                 error("setId exceeds limit");
 762                 /* NOTREACHED */
 763         }
 764
 765         p = LIST_FIRST(&sethead);
 766         q = NULL;
 767         for (; p != NULL && p->setId < setId; q = p, p = LIST_NEXT(p, entries))
 768                 continue;
 769
 770         if (p && p->setId == setId) {
 771                 ;
 772         } else {
 773                 p = xmalloc(sizeof(struct _setT));
 774                 memset(p, '\0', sizeof(struct _setT));
 775                 LIST_INIT(&p->msghead);
 776
 777                 p->setId = setId;
 778
 779                 if (q == NULL) {
 780                         LIST_INSERT_HEAD(&sethead, p, entries);
 781                 } else {
 782                         LIST_INSERT_AFTER(q, p, entries);
 783                 }
 784         }
 785
 786         curSet = p;
 787 }
 788
 789 static void
 790 MCAddMsg(int msgId, const char *str)
 791 {
 792         struct _msgT *p, *q;
 793
 794         if (!curSet)
 795                 error("can't specify a message when no set exists");
 796
 797         if (msgId <= 0) {
 798                 error("msgId's must be greater than zero");
 799                 /* NOTREACHED */
 800         }
 801         if (msgId > NL_MSGMAX) {
 802                 error("msgID exceeds limit");
 803                 /* NOTREACHED */
 804         }
 805
 806         p = LIST_FIRST(&curSet->msghead);
 807         q = NULL;
 808         for (; p != NULL && p->msgId < msgId; q = p, p = LIST_NEXT(p, entries))
 809                 continue;
 810
 811         if (p && p->msgId == msgId) {
 812                 free(p->str);
 813         } else {
 814                 p = xmalloc(sizeof(struct _msgT));
 815                 memset(p, '\0', sizeof(struct _msgT));
 816
 817                 if (q == NULL) {
 818                         LIST_INSERT_HEAD(&curSet->msghead, p, entries);
 819                 } else {
 820                         LIST_INSERT_AFTER(q, p, entries);
 821                 }
 822         }
 823
 824         p->msgId = msgId;
 825         p->str = xstrdup(str);
 826 }
 827
 828 static void
 829 MCDelSet(int setId)
 830 {
 831         struct _setT *set;
 832         struct _msgT *msg;
 833
 834         if (setId <= 0) {
 835                 error("setId's must be greater than zero");
 836                 /* NOTREACHED */
 837         }
 838         if (setId > NL_SETMAX) {
 839                 error("setId exceeds limit");
 840                 /* NOTREACHED */
 841         }
 842
 843         set = LIST_FIRST(&sethead);
 844         for (; set != NULL && set->setId < setId; set = LIST_NEXT(set, entries))
 845                 continue;
 846
 847         if (set && set->setId == setId) {
 848                 LIST_REMOVE(set, entries);
 849                 while ((msg = LIST_FIRST(&set->msghead)) != NULL) {
 850                         LIST_REMOVE(msg, entries);
 851                         free(msg->str);
 852                         free(msg);
 853                 }
 854                 free(set);
 855                 return;
 856         }
 857         warning(NULL, "specified set doesn't exist");
 858 }
 859
 860 static void
 861 MCDelMsg(int msgId)
 862 {
 863         struct _msgT *msg;
 864
 865         if (!curSet)
 866                 error("you can't delete a message before defining the set");
 867
 868         msg = LIST_FIRST(&curSet->msghead);
 869         for (; msg != NULL && msg->msgId < msgId; msg = LIST_NEXT(msg, entries))
 870                 continue;
 871
 872         if (msg && msg->msgId == msgId) {
 873                 LIST_REMOVE(msg, entries);
 874                 free(msg->str);
 875                 free(msg);
 876                 return;
 877         }
 878         warning(NULL, "specified msg doesn't exist");
 879 }