1 /*********************************************************** 2 Copyright 1990, by Alfalfa Software Incorporated, Cambridge, Massachusetts. 3 Copyright 2010, Gabor Kovesdan <gabor@FreeBSD.org> 4 5 All Rights Reserved 6 7 Permission to use, copy, modify, and distribute this software and its 8 documentation for any purpose and without fee is hereby granted, 9 provided that the above copyright notice appear in all copies and that 10 both that copyright notice and this permission notice appear in 11 supporting documentation, and that Alfalfa's name not be used in 12 advertising or publicity pertaining to distribution of the software 13 without specific, written prior permission. 14 15 ALPHALPHA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING 16 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL 17 ALPHALPHA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR 18 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 19 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, 20 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS 21 SOFTWARE. 22 23 If you make any modifications, bugfixes or other changes to this software 24 we'd appreciate it if you could send a copy to us so we can keep things 25 up-to-date. Many thanks. 26 Kee Hinckley 27 Alfalfa Software, Inc. 28 267 Allston St., #3 29 Cambridge, MA 02139 USA 30 nazgul@alfalfa.com 31 32 ******************************************************************/ 33 34 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD$"); 36 37 #define _NLS_PRIVATE 38 39 #include "namespace.h" 40 #include <sys/types.h> 41 #include <sys/stat.h> 42 #include <sys/mman.h> 43 #include <sys/queue.h> 44 45 #include <arpa/inet.h> /* for ntohl() */ 46 47 #include <errno.h> 48 #include <fcntl.h> 49 #include <limits.h> 50 #include <nl_types.h> 51 #include <pthread.h> 52 #include <stdio.h> 53 #include <stdlib.h> 54 #include <string.h> 55 #include <unistd.h> 56 #include "un-namespace.h" 57 58 #include "../locale/xlocale_private.h" 59 60 #define _DEFAULT_NLS_PATH "/usr/share/nls/%L/%N.cat:/usr/share/nls/%N/%L:/usr/local/share/nls/%L/%N.cat:/usr/local/share/nls/%N/%L" 61 62 #define RLOCK(fail) { int ret; \ 63 if (__isthreaded && \ 64 ((ret = _pthread_rwlock_rdlock(&rwlock)) != 0)) { \ 65 errno = ret; \ 66 return (fail); \ 67 }} 68 #define WLOCK(fail) { int ret; \ 69 if (__isthreaded && \ 70 ((ret = _pthread_rwlock_wrlock(&rwlock)) != 0)) { \ 71 errno = ret; \ 72 return (fail); \ 73 }} 74 #define UNLOCK { if (__isthreaded) \ 75 _pthread_rwlock_unlock(&rwlock); } 76 77 #define NLERR ((nl_catd) -1) 78 #define NLRETERR(errc) { errno = errc; return (NLERR); } 79 #define SAVEFAIL(n, l, e) { WLOCK(NLERR); \ 80 np = malloc(sizeof(struct catentry)); \ 81 if (np != NULL) { \ 82 np->name = strdup(n); \ 83 np->path = NULL; \ 84 np->catd = NLERR; \ 85 np->refcount = 0; \ 86 np->lang = (l == NULL) ? NULL : \ 87 strdup(l); \ 88 np->caterrno = e; \ 89 SLIST_INSERT_HEAD(&cache, np, list); \ 90 } \ 91 UNLOCK; \ 92 errno = e; \ 93 } 94 95 static nl_catd load_msgcat(const char *, const char *, const char *); 96 97 static pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER; 98 99 struct catentry { 100 SLIST_ENTRY(catentry) list; 101 char *name; 102 char *path; 103 int caterrno; 104 nl_catd catd; 105 char *lang; 106 int refcount; 107 }; 108 109 SLIST_HEAD(listhead, catentry) cache = 110 SLIST_HEAD_INITIALIZER(cache); 111 112 nl_catd 113 catopen(const char *name, int type) 114 { 115 struct stat sbuf; 116 struct catentry *np; 117 char *base, *cptr, *cptr1, *nlspath, *pathP, *pcode; 118 char *plang, *pter; 119 int saverr, spcleft; 120 const char *lang, *tmpptr; 121 char path[PATH_MAX]; 122 123 /* sanity checking */ 124 if (name == NULL || *name == '\0') 125 NLRETERR(EINVAL); 126 127 if (strchr(name, '/') != NULL) 128 /* have a pathname */ 129 lang = NULL; 130 else { 131 if (type == NL_CAT_LOCALE) 132 lang = querylocale(LC_MESSAGES_MASK, __get_locale()); 133 else 134 lang = getenv("LANG"); 135 136 if (lang == NULL || *lang == '\0' || strlen(lang) > ENCODING_LEN || 137 (lang[0] == '.' && 138 (lang[1] == '\0' || (lang[1] == '.' && lang[2] == '\0'))) || 139 strchr(lang, '/') != NULL) 140 lang = "C"; 141 } 142 143 /* Try to get it from the cache first */ 144 RLOCK(NLERR); 145 SLIST_FOREACH(np, &cache, list) { 146 if ((strcmp(np->name, name) == 0) && 147 ((lang != NULL && np->lang != NULL && 148 strcmp(np->lang, lang) == 0) || (np->lang == lang))) { 149 if (np->caterrno != 0) { 150 /* Found cached failing entry */ 151 UNLOCK; 152 NLRETERR(np->caterrno); 153 } else { 154 /* Found cached successful entry */ 155 np->refcount++; 156 UNLOCK; 157 return (np->catd); 158 } 159 } 160 } 161 UNLOCK; 162 163 /* is it absolute path ? if yes, load immediately */ 164 if (strchr(name, '/') != NULL) 165 return (load_msgcat(name, name, lang)); 166 167 /* sanity checking */ 168 if ((plang = cptr1 = strdup(lang)) == NULL) 169 return (NLERR); 170 if ((cptr = strchr(cptr1, '@')) != NULL) 171 *cptr = '\0'; 172 pter = pcode = ""; 173 if ((cptr = strchr(cptr1, '_')) != NULL) { 174 *cptr++ = '\0'; 175 pter = cptr1 = cptr; 176 } 177 if ((cptr = strchr(cptr1, '.')) != NULL) { 178 *cptr++ = '\0'; 179 pcode = cptr; 180 } 181 182 if ((nlspath = getenv("NLSPATH")) == NULL || issetugid()) 183 nlspath = _DEFAULT_NLS_PATH; 184 185 if ((base = cptr = strdup(nlspath)) == NULL) { 186 saverr = errno; 187 free(plang); 188 errno = saverr; 189 return (NLERR); 190 } 191 192 while ((nlspath = strsep(&cptr, ":")) != NULL) { 193 pathP = path; 194 if (*nlspath) { 195 for (; *nlspath; ++nlspath) { 196 if (*nlspath == '%') { 197 switch (*(nlspath + 1)) { 198 case 'l': 199 tmpptr = plang; 200 break; 201 case 't': 202 tmpptr = pter; 203 break; 204 case 'c': 205 tmpptr = pcode; 206 break; 207 case 'L': 208 tmpptr = lang; 209 break; 210 case 'N': 211 tmpptr = (char *)name; 212 break; 213 case '%': 214 ++nlspath; 215 /* FALLTHROUGH */ 216 default: 217 if (pathP - path >= 218 sizeof(path) - 1) 219 goto too_long; 220 *(pathP++) = *nlspath; 221 continue; 222 } 223 ++nlspath; 224 put_tmpptr: 225 spcleft = sizeof(path) - 226 (pathP - path) - 1; 227 if (strlcpy(pathP, tmpptr, spcleft) >= 228 spcleft) { 229 too_long: 230 free(plang); 231 free(base); 232 SAVEFAIL(name, lang, ENAMETOOLONG); 233 NLRETERR(ENAMETOOLONG); 234 } 235 pathP += strlen(tmpptr); 236 } else { 237 if (pathP - path >= sizeof(path) - 1) 238 goto too_long; 239 *(pathP++) = *nlspath; 240 } 241 } 242 *pathP = '\0'; 243 if (stat(path, &sbuf) == 0) { 244 free(plang); 245 free(base); 246 return (load_msgcat(path, name, lang)); 247 } 248 } else { 249 tmpptr = (char *)name; 250 --nlspath; 251 goto put_tmpptr; 252 } 253 } 254 free(plang); 255 free(base); 256 SAVEFAIL(name, lang, ENOENT); 257 NLRETERR(ENOENT); 258 } 259 260 char * 261 catgets(nl_catd catd, int set_id, int msg_id, const char *s) 262 { 263 struct _nls_cat_hdr *cat_hdr; 264 struct _nls_msg_hdr *msg_hdr; 265 struct _nls_set_hdr *set_hdr; 266 int i, l, r, u; 267 268 if (catd == NULL || catd == NLERR) { 269 errno = EBADF; 270 /* LINTED interface problem */ 271 return ((char *)s); 272 } 273 274 cat_hdr = (struct _nls_cat_hdr *)catd->__data; 275 set_hdr = (struct _nls_set_hdr *)(void *)((char *)catd->__data + 276 sizeof(struct _nls_cat_hdr)); 277 278 /* binary search, see knuth algorithm b */ 279 l = 0; 280 u = ntohl((u_int32_t)cat_hdr->__nsets) - 1; 281 while (l <= u) { 282 i = (l + u) / 2; 283 r = set_id - ntohl((u_int32_t)set_hdr[i].__setno); 284 285 if (r == 0) { 286 msg_hdr = (struct _nls_msg_hdr *) 287 (void *)((char *)catd->__data + 288 sizeof(struct _nls_cat_hdr) + 289 ntohl((u_int32_t)cat_hdr->__msg_hdr_offset)); 290 291 l = ntohl((u_int32_t)set_hdr[i].__index); 292 u = l + ntohl((u_int32_t)set_hdr[i].__nmsgs) - 1; 293 while (l <= u) { 294 i = (l + u) / 2; 295 r = msg_id - 296 ntohl((u_int32_t)msg_hdr[i].__msgno); 297 if (r == 0) { 298 return ((char *) catd->__data + 299 sizeof(struct _nls_cat_hdr) + 300 ntohl((u_int32_t) 301 cat_hdr->__msg_txt_offset) + 302 ntohl((u_int32_t) 303 msg_hdr[i].__offset)); 304 } else if (r < 0) { 305 u = i - 1; 306 } else { 307 l = i + 1; 308 } 309 } 310 311 /* not found */ 312 goto notfound; 313 314 } else if (r < 0) { 315 u = i - 1; 316 } else { 317 l = i + 1; 318 } 319 } 320 321 notfound: 322 /* not found */ 323 errno = ENOMSG; 324 /* LINTED interface problem */ 325 return ((char *)s); 326 } 327 328 static void 329 catfree(struct catentry *np) 330 { 331 332 if (np->catd != NULL && np->catd != NLERR) { 333 munmap(np->catd->__data, (size_t)np->catd->__size); 334 free(np->catd); 335 } 336 SLIST_REMOVE(&cache, np, catentry, list); 337 free(np->name); 338 free(np->path); 339 free(np->lang); 340 free(np); 341 } 342 343 int 344 catclose(nl_catd catd) 345 { 346 struct catentry *np; 347 348 /* sanity checking */ 349 if (catd == NULL || catd == NLERR) { 350 errno = EBADF; 351 return (-1); 352 } 353 354 /* Remove from cache if not referenced any more */ 355 WLOCK(-1); 356 SLIST_FOREACH(np, &cache, list) { 357 if (catd == np->catd) { 358 np->refcount--; 359 if (np->refcount == 0) 360 catfree(np); 361 break; 362 } 363 } 364 UNLOCK; 365 return (0); 366 } 367 368 /* 369 * Internal support functions 370 */ 371 372 static nl_catd 373 load_msgcat(const char *path, const char *name, const char *lang) 374 { 375 struct stat st; 376 nl_catd catd; 377 struct catentry *np; 378 void *data; 379 int fd; 380 381 /* path/name will never be NULL here */ 382 383 /* 384 * One more try in cache; if it was not found by name, 385 * it might still be found by absolute path. 386 */ 387 RLOCK(NLERR); 388 SLIST_FOREACH(np, &cache, list) { 389 if ((np->path != NULL) && (strcmp(np->path, path) == 0)) { 390 np->refcount++; 391 UNLOCK; 392 return (np->catd); 393 } 394 } 395 UNLOCK; 396 397 if ((fd = _open(path, O_RDONLY | O_CLOEXEC)) == -1) { 398 SAVEFAIL(name, lang, errno); 399 NLRETERR(errno); 400 } 401 402 if (_fstat(fd, &st) != 0) { 403 _close(fd); 404 SAVEFAIL(name, lang, EFTYPE); 405 NLRETERR(EFTYPE); 406 } 407 408 /* 409 * If the file size cannot be held in size_t we cannot mmap() 410 * it to the memory. Probably, this will not be a problem given 411 * that catalog files are usually small. 412 */ 413 if (st.st_size > SIZE_T_MAX) { 414 _close(fd); 415 SAVEFAIL(name, lang, EFBIG); 416 NLRETERR(EFBIG); 417 } 418 419 if ((data = mmap(0, (size_t)st.st_size, PROT_READ, 420 MAP_FILE|MAP_SHARED, fd, (off_t)0)) == MAP_FAILED) { 421 int saved_errno = errno; 422 _close(fd); 423 SAVEFAIL(name, lang, saved_errno); 424 NLRETERR(saved_errno); 425 } 426 _close(fd); 427 428 if (ntohl((u_int32_t)((struct _nls_cat_hdr *)data)->__magic) != 429 _NLS_MAGIC) { 430 munmap(data, (size_t)st.st_size); 431 SAVEFAIL(name, lang, EFTYPE); 432 NLRETERR(EFTYPE); 433 } 434 435 if ((catd = malloc(sizeof (*catd))) == NULL) { 436 munmap(data, (size_t)st.st_size); 437 SAVEFAIL(name, lang, ENOMEM); 438 NLRETERR(ENOMEM); 439 } 440 441 catd->__data = data; 442 catd->__size = (int)st.st_size; 443 444 /* Caching opened catalog */ 445 WLOCK(NLERR); 446 if ((np = malloc(sizeof(struct catentry))) != NULL) { 447 np->name = strdup(name); 448 np->path = strdup(path); 449 np->catd = catd; 450 np->lang = (lang == NULL) ? NULL : strdup(lang); 451 np->refcount = 1; 452 np->caterrno = 0; 453 SLIST_INSERT_HEAD(&cache, np, list); 454 } 455 UNLOCK; 456 return (catd); 457 } 458