usr/src/lib/libc/port/gen/catopen.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*
  28  * catopen.c
  29  *
  30  */
  31
  32 #pragma weak _catopen = catopen
  33 #pragma weak _catclose = catclose
  34
  35 #include "lint.h"
  36 #include "libc.h"
  37 #include <sys/types.h>
  38 #include <unistd.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <sys/stat.h>
  42 #include <sys/mman.h>
  43 #include <nl_types.h>
  44 #include <locale.h>
  45 #include <limits.h>
  46 #include <errno.h>
  47 #include "../i18n/_loc_path.h"
  48 #include "nlspath_checks.h"
  49
  50 #define SAFE_F          1
  51 #define UNSAFE_F        0
  52
  53 static char *
  54 replace_nls_option(char *, char *, char *, char *, char *, char *, char *);
  55 static nl_catd file_open(const char *, int);
  56 static nl_catd process_nls_path(char *, int);
  57
  58 nl_catd
  59 catopen(const char *name, int oflag)
  60 {
  61         nl_catd p;
  62
  63         if (!name) {                            /* Null pointer */
  64                 errno = EFAULT;
  65                 return ((nl_catd)-1);
  66         } else if (!*name) {            /* Empty string */
  67                 errno = ENOENT;
  68                 return ((nl_catd)-1);
  69         } else if (strchr(name, '/') != NULL) {
  70                 /* If name contains '/', then it is complete file name */
  71                 p = file_open(name, SAFE_F);
  72         } else {                                /* Normal case */
  73                 p = process_nls_path((char *)name, oflag);
  74         }
  75
  76         if (p == NULL) {  /* Opening catalog file failed */
  77                 return ((nl_catd)-1);
  78         } else {
  79                 return (p);
  80         }
  81 }
  82
  83
  84 /*
  85  * This routine will process NLSPATH environment variable.
  86  * It will return catd id whenever it finds valid catalog.
  87  */
  88 static nl_catd
  89 process_nls_path(char *name, int oflag)
  90 {
  91         char    *s, *s1, *s2, *t;
  92         char    *nlspath, *lang, *territory, *codeset, *locale;
  93         char    pathname[PATH_MAX + 1];
  94         nl_catd p;
  95
  96         /*
  97          * locale=language_territory.codeset
  98          * XPG4 uses LC_MESSAGES.
  99          * XPG3 uses LANG.
 100          * From the following two lines, choose one depending on XPG3 or 4.
 101          *
 102          * Chose XPG4. If oflag == NL_CAT_LOCALE, use LC_MESSAGES.
 103          */
 104         if (oflag == NL_CAT_LOCALE) {
 105                 locale_t loc = uselocale(NULL);
 106                 locale = current_locale(loc, LC_MESSAGES);
 107         } else {
 108                 locale = getenv("LANG");
 109         }
 110
 111         nlspath = getenv("NLSPATH");
 112         lang = NULL;
 113         if (nlspath) {
 114                 territory = NULL;
 115                 codeset = NULL;
 116                 /*
 117                  * extract lang, territory and codeset from locale name
 118                  */
 119                 if (locale) {
 120                         lang = s = libc_strdup(locale);
 121                         if (!lang) {
 122                                 /* strdup failed */
 123                                 return (NULL);
 124                         }
 125                         s1 = s2 = NULL;
 126                         while (s && *s) {
 127                                 if (*s == '_') {
 128                                         s1 = s;
 129                                         *s1++ = '\0';
 130                                 } else if (*s == '.') {
 131                                         s2 = s;
 132                                         *s2++ = '\0';
 133                                 }
 134                                 s++;
 135                         }
 136                         territory = s1;
 137                         codeset   = s2;
 138                 } /* if (locale) */
 139
 140                 /*
 141                  * March through NLSPATH until finds valid cat file
 142                  */
 143                 s = nlspath;
 144                 while (*s) {
 145                         if (*s == ':') {
 146                                 /* unqualified pathname is unsafe */
 147                                 p = file_open(name, UNSAFE_F);
 148                                 if (p != NULL) {
 149                                         if (lang)
 150                                                 libc_free(lang);
 151                                         return (p);
 152                                 }
 153                                 ++s;
 154                                 continue;
 155                         }
 156
 157                         /* replace Substitution field */
 158                         s = replace_nls_option(s, name, pathname, locale,
 159                             lang, territory, codeset);
 160
 161                         p = file_open(pathname, UNSAFE_F);
 162                         if (p != NULL) {
 163                                 if (lang)
 164                                         libc_free(lang);
 165                                 return (p);
 166                         }
 167                         if (*s)
 168                                 ++s;
 169                 } /* while */
 170         } /* if (nlspath) */
 171
 172         /* lang is not used any more, free it */
 173         if (lang)
 174                 libc_free(lang);
 175
 176         /*
 177          * Implementation dependent default location of XPG3.
 178          * We use /usr/lib/locale/<locale>/LC_MESSAGES/%N.
 179          * If C locale, do not translate message.
 180          */
 181         if (locale == NULL) {
 182                 return (NULL);
 183         } else if (locale[0] == 'C' && locale[1] == '\0') {
 184                 p = libc_malloc(sizeof (struct _nl_catd_struct));
 185                 if (p == NULL) {
 186                         /* malloc failed */
 187                         return (NULL);
 188                 }
 189                 p->__content = NULL;
 190                 p->__size = 0;
 191                 p->__trust = 1;
 192                 return (p);
 193         }
 194
 195         s = _DFLT_LOC_PATH;
 196         t = pathname;
 197         while (*t++ = *s++)
 198                 continue;
 199         t--;
 200         s = locale;
 201         while (*s && t < pathname + PATH_MAX)
 202                 *t++ = *s++;
 203         s = "/LC_MESSAGES/";
 204         while (*s && t < pathname + PATH_MAX)
 205                 *t++ = *s++;
 206         s = name;
 207         while (*s && t < pathname + PATH_MAX)
 208                 *t++ = *s++;
 209         *t = '\0';
 210         return (file_open(pathname, SAFE_F));
 211 }
 212
 213
 214 /*
 215  * This routine will replace substitution parameters in NLSPATH
 216  * with appropiate values. Returns expanded pathname.
 217  */
 218 static char *
 219 replace_nls_option(char *s, char *name, char *pathname, char *locale,
 220         char *lang, char *territory, char *codeset)
 221 {
 222         char    *t, *u;
 223
 224         t = pathname;
 225         while (*s && *s != ':') {
 226                 if (t < pathname + PATH_MAX) {
 227                         /*
 228                          * %% is considered a single % character (XPG).
 229                          * %L : LC_MESSAGES (XPG4) LANG(XPG3)
 230                          * %l : The language element from the current locale.
 231                          *      (XPG3, XPG4)
 232                          */
 233                         if (*s != '%')
 234                                 *t++ = *s;
 235                         else if (*++s == 'N') {
 236                                 u = name;
 237                                 while (*u && t < pathname + PATH_MAX)
 238                                         *t++ = *u++;
 239                         } else if (*s == 'L') {
 240                                 if (locale) {
 241                                         u = locale;
 242                                         while (*u && t < pathname + PATH_MAX)
 243                                                 *t++ = *u++;
 244                                 }
 245                         } else if (*s == 'l') {
 246                                 if (lang) {
 247                                         u = lang;
 248                                         while (*u && *u != '_' &&
 249                                             t < pathname + PATH_MAX)
 250                                                 *t++ = *u++;
 251                                 }
 252                         } else if (*s == 't') {
 253                                 if (territory) {
 254                                         u = territory;
 255                                         while (*u && *u != '.' &&
 256                                             t < pathname + PATH_MAX)
 257                                                 *t++ = *u++;
 258                                 }
 259                         } else if (*s == 'c') {
 260                                 if (codeset) {
 261                                         u = codeset;
 262                                         while (*u && t < pathname + PATH_MAX)
 263                                                 *t++ = *u++;
 264                                 }
 265                         } else {
 266                                 if (t < pathname + PATH_MAX)
 267                                         *t++ = *s;
 268                         }
 269                 }
 270                 ++s;
 271         }
 272         *t = '\0';
 273         return (s);
 274 }
 275
 276 /*
 277  * This routine will open file, mmap it, and return catd id.
 278  */
 279 static nl_catd
 280 file_open(const char *name, int safe)
 281 {
 282         int             fd;
 283         struct stat64   statbuf;
 284         void            *addr;
 285         struct _cat_hdr *tmp;
 286         nl_catd         tmp_catd;
 287         int             trust;
 288
 289         fd = nls_safe_open(name, &statbuf, &trust, safe);
 290
 291         if (fd == -1) {
 292                 return (NULL);
 293         }
 294
 295         addr = mmap(NULL, (size_t)statbuf.st_size, PROT_READ, MAP_SHARED, fd, 0);
 296         (void) close(fd);
 297
 298         if (addr == MAP_FAILED) {
 299                 return (NULL);
 300         }
 301
 302         /* check MAGIC number of catalogue file */
 303         tmp = (struct _cat_hdr *)addr;
 304         if (tmp->__hdr_magic != _CAT_MAGIC) {
 305                 (void) munmap(addr, (size_t)statbuf.st_size);
 306                 return (NULL);
 307         }
 308
 309         tmp_catd = libc_malloc(sizeof (struct _nl_catd_struct));
 310         if (tmp_catd == NULL) {
 311                 /* malloc failed */
 312                 (void) munmap(addr, statbuf.st_size);
 313                 return (NULL);
 314         }
 315         tmp_catd->__content = addr;
 316         tmp_catd->__size = (int)statbuf.st_size;
 317         tmp_catd->__trust = trust;
 318
 319         return (tmp_catd);
 320 }
 321
 322 int
 323 catclose(nl_catd catd)
 324 {
 325         if (catd &&
 326             catd != (nl_catd)-1) {
 327                 if (catd->__content) {
 328                         (void) munmap(catd->__content, catd->__size);
 329                         catd->__content = NULL;
 330                 }
 331                 catd->__size = 0;
 332                 catd->__trust = 0;
 333                 libc_free(catd);
 334         }
 335         return (0);
 336 }