| /* Copyright (C) 1996-2018 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| Contributed by Ulrich Drepper, <drepper@gnu.org>. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include <byteswap.h> |
| #include <endian.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #ifdef _POSIX_MAPPED_FILES |
| # include <sys/mman.h> |
| #endif |
| #include <sys/stat.h> |
| |
| #include "catgetsinfo.h" |
| #include <not-cancel.h> |
| |
| |
| #define SWAPU32(w) bswap_32 (w) |
| |
| |
| int |
| __open_catalog (const char *cat_name, const char *nlspath, const char *env_var, |
| __nl_catd catalog) |
| { |
| int fd = -1; |
| struct stat64 st; |
| int swapping; |
| size_t cnt; |
| size_t max_offset; |
| size_t tab_size; |
| const char *lastp; |
| int result = -1; |
| char *buf = NULL; |
| |
| if (strchr (cat_name, '/') != NULL || nlspath == NULL) |
| fd = __open_nocancel (cat_name, O_RDONLY); |
| else |
| { |
| const char *run_nlspath = nlspath; |
| #define ENOUGH(n) \ |
| if (__glibc_unlikely (bufact + (n) >= bufmax)) \ |
| { \ |
| char *old_buf = buf; \ |
| bufmax += (bufmax < 256 + (n)) ? 256 + (n) : bufmax; \ |
| buf = realloc (buf, bufmax); \ |
| if (__glibc_unlikely (buf == NULL)) \ |
| { \ |
| free (old_buf); \ |
| return -1; \ |
| } \ |
| } |
| |
| /* The RUN_NLSPATH variable contains a colon separated list of |
| descriptions where we expect to find catalogs. We have to |
| recognize certain % substitutions and stop when we found the |
| first existing file. */ |
| size_t bufact; |
| size_t bufmax = 0; |
| size_t len; |
| |
| fd = -1; |
| while (*run_nlspath != '\0') |
| { |
| bufact = 0; |
| |
| if (*run_nlspath == ':') |
| { |
| /* Leading colon or adjacent colons - treat same as %N. */ |
| len = strlen (cat_name); |
| ENOUGH (len); |
| memcpy (&buf[bufact], cat_name, len); |
| bufact += len; |
| } |
| else |
| while (*run_nlspath != ':' && *run_nlspath != '\0') |
| if (*run_nlspath == '%') |
| { |
| const char *tmp; |
| |
| ++run_nlspath; /* We have seen the `%'. */ |
| switch (*run_nlspath++) |
| { |
| case 'N': |
| /* Use the catalog name. */ |
| len = strlen (cat_name); |
| ENOUGH (len); |
| memcpy (&buf[bufact], cat_name, len); |
| bufact += len; |
| break; |
| case 'L': |
| /* Use the current locale category value. */ |
| len = strlen (env_var); |
| ENOUGH (len); |
| memcpy (&buf[bufact], env_var, len); |
| bufact += len; |
| break; |
| case 'l': |
| /* Use language element of locale category value. */ |
| tmp = env_var; |
| do |
| { |
| ENOUGH (1); |
| buf[bufact++] = *tmp++; |
| } |
| while (*tmp != '\0' && *tmp != '_' && *tmp != '.'); |
| break; |
| case 't': |
| /* Use territory element of locale category value. */ |
| tmp = env_var; |
| do |
| ++tmp; |
| while (*tmp != '\0' && *tmp != '_' && *tmp != '.'); |
| if (*tmp == '_') |
| { |
| ++tmp; |
| do |
| { |
| ENOUGH (1); |
| buf[bufact++] = *tmp++; |
| } |
| while (*tmp != '\0' && *tmp != '.'); |
| } |
| break; |
| case 'c': |
| /* Use code set element of locale category value. */ |
| tmp = env_var; |
| do |
| ++tmp; |
| while (*tmp != '\0' && *tmp != '.'); |
| if (*tmp == '.') |
| { |
| ++tmp; |
| do |
| { |
| ENOUGH (1); |
| buf[bufact++] = *tmp++; |
| } |
| while (*tmp != '\0'); |
| } |
| break; |
| case '%': |
| ENOUGH (1); |
| buf[bufact++] = '%'; |
| break; |
| default: |
| /* Unknown variable: ignore this path element. */ |
| bufact = 0; |
| while (*run_nlspath != '\0' && *run_nlspath != ':') |
| ++run_nlspath; |
| break; |
| } |
| } |
| else |
| { |
| ENOUGH (1); |
| buf[bufact++] = *run_nlspath++; |
| } |
| |
| ENOUGH (1); |
| buf[bufact] = '\0'; |
| |
| if (bufact != 0) |
| { |
| fd = __open_nocancel (buf, O_RDONLY); |
| if (fd >= 0) |
| break; |
| } |
| |
| ++run_nlspath; |
| } |
| } |
| |
| /* Avoid dealing with directories and block devices */ |
| if (__builtin_expect (fd, 0) < 0) |
| { |
| free (buf); |
| return -1; |
| } |
| |
| if (__builtin_expect (__fxstat64 (_STAT_VER, fd, &st), 0) < 0) |
| goto close_unlock_return; |
| |
| if (__builtin_expect (!S_ISREG (st.st_mode), 0) |
| || (size_t) st.st_size < sizeof (struct catalog_obj)) |
| { |
| /* `errno' is not set correctly but the file is not usable. |
| Use an reasonable error value. */ |
| __set_errno (EINVAL); |
| goto close_unlock_return; |
| } |
| |
| catalog->file_size = st.st_size; |
| #ifdef _POSIX_MAPPED_FILES |
| # ifndef MAP_COPY |
| /* Linux seems to lack read-only copy-on-write. */ |
| # define MAP_COPY MAP_PRIVATE |
| # endif |
| # ifndef MAP_FILE |
| /* Some systems do not have this flag; it is superfluous. */ |
| # define MAP_FILE 0 |
| # endif |
| catalog->file_ptr = |
| (struct catalog_obj *) __mmap (NULL, st.st_size, PROT_READ, |
| MAP_FILE|MAP_COPY, fd, 0); |
| if (__builtin_expect (catalog->file_ptr != (struct catalog_obj *) MAP_FAILED, |
| 1)) |
| /* Tell the world we managed to mmap the file. */ |
| catalog->status = mmapped; |
| else |
| #endif /* _POSIX_MAPPED_FILES */ |
| { |
| /* mmap failed perhaps because the system call is not |
| implemented. Try to load the file. */ |
| size_t todo; |
| catalog->file_ptr = malloc (st.st_size); |
| if (catalog->file_ptr == NULL) |
| goto close_unlock_return; |
| |
| todo = st.st_size; |
| /* Save read, handle partial reads. */ |
| do |
| { |
| size_t now = __read_nocancel (fd, (((char *) catalog->file_ptr) |
| + (st.st_size - todo)), todo); |
| if (now == 0 || now == (size_t) -1) |
| { |
| #ifdef EINTR |
| if (now == (size_t) -1 && errno == EINTR) |
| continue; |
| #endif |
| free ((void *) catalog->file_ptr); |
| goto close_unlock_return; |
| } |
| todo -= now; |
| } |
| while (todo > 0); |
| catalog->status = malloced; |
| } |
| |
| /* Determine whether the file is a catalog file and if yes whether |
| it is written using the correct byte order. Else we have to swap |
| the values. */ |
| if (__glibc_likely (catalog->file_ptr->magic == CATGETS_MAGIC)) |
| swapping = 0; |
| else if (catalog->file_ptr->magic == SWAPU32 (CATGETS_MAGIC)) |
| swapping = 1; |
| else |
| { |
| invalid_file: |
| /* Invalid file. Free the resources and mark catalog as not |
| usable. */ |
| #ifdef _POSIX_MAPPED_FILES |
| if (catalog->status == mmapped) |
| __munmap ((void *) catalog->file_ptr, catalog->file_size); |
| else |
| #endif /* _POSIX_MAPPED_FILES */ |
| free (catalog->file_ptr); |
| goto close_unlock_return; |
| } |
| |
| #define SWAP(x) (swapping ? SWAPU32 (x) : (x)) |
| |
| /* Get dimensions of the used hashing table. */ |
| catalog->plane_size = SWAP (catalog->file_ptr->plane_size); |
| catalog->plane_depth = SWAP (catalog->file_ptr->plane_depth); |
| |
| /* The file contains two versions of the pointer tables. Pick the |
| right one for the local byte order. */ |
| #if __BYTE_ORDER == __LITTLE_ENDIAN |
| catalog->name_ptr = &catalog->file_ptr->name_ptr[0]; |
| #elif __BYTE_ORDER == __BIG_ENDIAN |
| catalog->name_ptr = &catalog->file_ptr->name_ptr[catalog->plane_size |
| * catalog->plane_depth |
| * 3]; |
| #else |
| # error Cannot handle __BYTE_ORDER byte order |
| #endif |
| |
| /* The rest of the file contains all the strings. They are |
| addressed relative to the position of the first string. */ |
| catalog->strings = |
| (const char *) &catalog->file_ptr->name_ptr[catalog->plane_size |
| * catalog->plane_depth * 3 * 2]; |
| |
| /* Determine the largest string offset mentioned in the table. */ |
| max_offset = 0; |
| tab_size = 3 * catalog->plane_size * catalog->plane_depth; |
| for (cnt = 2; cnt < tab_size; cnt += 3) |
| if (catalog->name_ptr[cnt] > max_offset) |
| max_offset = catalog->name_ptr[cnt]; |
| |
| /* Now we can check whether the file is large enough to contain the |
| tables it says it contains. */ |
| if ((size_t) st.st_size |
| <= (sizeof (struct catalog_obj) + 2 * tab_size + max_offset)) |
| /* The last string is not contained in the file. */ |
| goto invalid_file; |
| |
| lastp = catalog->strings + max_offset; |
| max_offset = (st.st_size |
| - sizeof (struct catalog_obj) + 2 * tab_size + max_offset); |
| while (*lastp != '\0') |
| { |
| if (--max_offset == 0) |
| goto invalid_file; |
| ++lastp; |
| } |
| |
| /* We succeeded. */ |
| result = 0; |
| |
| /* Release the lock again. */ |
| close_unlock_return: |
| __close_nocancel_nostatus (fd); |
| free (buf); |
| |
| return result; |
| } |
| libc_hidden_def (__open_catalog) |