Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <dirent.h>
4 : : #include <errno.h>
5 : : #include <fcntl.h>
6 : : #include <ftw.h>
7 : : #include <langinfo.h>
8 : : #include <libintl.h>
9 : : #include <locale.h>
10 : : #include <stddef.h>
11 : : #include <stdint.h>
12 : : #include <stdlib.h>
13 : : #include <string.h>
14 : : #include <sys/mman.h>
15 : : #include <sys/stat.h>
16 : :
17 : : #include "def.h"
18 : : #include "dirent-util.h"
19 : : #include "env-util.h"
20 : : #include "fd-util.h"
21 : : #include "hashmap.h"
22 : : #include "locale-util.h"
23 : : #include "path-util.h"
24 : : #include "set.h"
25 : : #include "string-table.h"
26 : : #include "string-util.h"
27 : : #include "strv.h"
28 : : #include "utf8.h"
29 : :
30 : 3404 : static char *normalize_locale(const char *name) {
31 : : const char *e;
32 : :
33 : : /* Locale names are weird: glibc has some magic rules when looking for the charset name on disk: it
34 : : * lowercases everything, and removes most special chars. This means the official .UTF-8 suffix
35 : : * becomes .utf8 when looking things up on disk. When enumerating locales, let's do the reverse
36 : : * operation, and go back to ".UTF-8" which appears to be the more commonly accepted name. We only do
37 : : * that for UTF-8 however, since it's kinda the only charset that matters. */
38 : :
39 : 3404 : e = endswith(name, ".utf8");
40 [ + + ]: 3404 : if (e) {
41 : 1176 : _cleanup_free_ char *prefix = NULL;
42 : :
43 : 1176 : prefix = strndup(name, e - name);
44 [ - + ]: 1176 : if (!prefix)
45 : 0 : return NULL;
46 : :
47 : 1176 : return strjoin(prefix, ".UTF-8");
48 : : }
49 : :
50 : 2228 : e = strstr(name, ".utf8@");
51 [ + + ]: 2228 : if (e) {
52 : 40 : _cleanup_free_ char *prefix = NULL;
53 : :
54 : 40 : prefix = strndup(name, e - name);
55 [ - + ]: 40 : if (!prefix)
56 : 0 : return NULL;
57 : :
58 : 40 : return strjoin(prefix, ".UTF-8@", e + 6);
59 : : }
60 : :
61 : 2188 : return strdup(name);
62 : : }
63 : :
64 : 4 : static int add_locales_from_archive(Set *locales) {
65 : : /* Stolen from glibc... */
66 : :
67 : : struct locarhead {
68 : : uint32_t magic;
69 : : /* Serial number. */
70 : : uint32_t serial;
71 : : /* Name hash table. */
72 : : uint32_t namehash_offset;
73 : : uint32_t namehash_used;
74 : : uint32_t namehash_size;
75 : : /* String table. */
76 : : uint32_t string_offset;
77 : : uint32_t string_used;
78 : : uint32_t string_size;
79 : : /* Table with locale records. */
80 : : uint32_t locrectab_offset;
81 : : uint32_t locrectab_used;
82 : : uint32_t locrectab_size;
83 : : /* MD5 sum hash table. */
84 : : uint32_t sumhash_offset;
85 : : uint32_t sumhash_used;
86 : : uint32_t sumhash_size;
87 : : };
88 : :
89 : : struct namehashent {
90 : : /* Hash value of the name. */
91 : : uint32_t hashval;
92 : : /* Offset of the name in the string table. */
93 : : uint32_t name_offset;
94 : : /* Offset of the locale record. */
95 : : uint32_t locrec_offset;
96 : : };
97 : :
98 : : const struct locarhead *h;
99 : : const struct namehashent *e;
100 : 4 : const void *p = MAP_FAILED;
101 : 4 : _cleanup_close_ int fd = -1;
102 : 4 : size_t sz = 0;
103 : : struct stat st;
104 : : size_t i;
105 : : int r;
106 : :
107 : 4 : fd = open("/usr/lib/locale/locale-archive", O_RDONLY|O_NOCTTY|O_CLOEXEC);
108 [ - + ]: 4 : if (fd < 0)
109 [ # # ]: 0 : return errno == ENOENT ? 0 : -errno;
110 : :
111 [ - + ]: 4 : if (fstat(fd, &st) < 0)
112 : 0 : return -errno;
113 : :
114 [ - + ]: 4 : if (!S_ISREG(st.st_mode))
115 : 0 : return -EBADMSG;
116 : :
117 [ - + ]: 4 : if (st.st_size < (off_t) sizeof(struct locarhead))
118 : 0 : return -EBADMSG;
119 : :
120 : 4 : p = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
121 [ - + ]: 4 : if (p == MAP_FAILED)
122 : 0 : return -errno;
123 : :
124 : 4 : h = (const struct locarhead *) p;
125 [ + - ]: 4 : if (h->magic != 0xde020109 ||
126 [ + - ]: 4 : h->namehash_offset + h->namehash_size > st.st_size ||
127 [ + - ]: 4 : h->string_offset + h->string_size > st.st_size ||
128 [ + - ]: 4 : h->locrectab_offset + h->locrectab_size > st.st_size ||
129 [ - + ]: 4 : h->sumhash_offset + h->sumhash_size > st.st_size) {
130 : 0 : r = -EBADMSG;
131 : 0 : goto finish;
132 : : }
133 : :
134 : 4 : e = (const struct namehashent*) ((const uint8_t*) p + h->namehash_offset);
135 [ + + ]: 5472 : for (i = 0; i < h->namehash_size; i++) {
136 : : char *z;
137 : :
138 [ + + ]: 5468 : if (e[i].locrec_offset == 0)
139 : 2208 : continue;
140 : :
141 [ - + ]: 3260 : if (!utf8_is_valid((char*) p + e[i].name_offset))
142 : 0 : continue;
143 : :
144 : 3260 : z = normalize_locale((char*) p + e[i].name_offset);
145 [ - + ]: 3260 : if (!z) {
146 : 0 : r = -ENOMEM;
147 : 0 : goto finish;
148 : : }
149 : :
150 : 3260 : r = set_consume(locales, z);
151 [ - + ]: 3260 : if (r < 0)
152 : 0 : goto finish;
153 : : }
154 : :
155 : 4 : r = 0;
156 : :
157 : 4 : finish:
158 [ + - ]: 4 : if (p != MAP_FAILED)
159 : 4 : munmap((void*) p, sz);
160 : :
161 : 4 : return r;
162 : : }
163 : :
164 : 4 : static int add_locales_from_libdir (Set *locales) {
165 : 4 : _cleanup_closedir_ DIR *dir = NULL;
166 : : struct dirent *entry;
167 : : int r;
168 : :
169 : 4 : dir = opendir("/usr/lib/locale");
170 [ - + ]: 4 : if (!dir)
171 [ # # ]: 0 : return errno == ENOENT ? 0 : -errno;
172 : :
173 [ + + - + : 160 : FOREACH_DIRENT(entry, dir, return -errno) {
+ + ]
174 : : char *z;
175 : :
176 : 148 : dirent_ensure_type(dir, entry);
177 : :
178 [ + + ]: 148 : if (entry->d_type != DT_DIR)
179 : 4 : continue;
180 : :
181 : 144 : z = normalize_locale(entry->d_name);
182 [ - + ]: 144 : if (!z)
183 : 0 : return -ENOMEM;
184 : :
185 : 144 : r = set_consume(locales, z);
186 [ - + # # ]: 144 : if (r < 0 && r != -EEXIST)
187 : 0 : return r;
188 : : }
189 : :
190 : 4 : return 0;
191 : : }
192 : :
193 : 4 : int get_locales(char ***ret) {
194 : 4 : _cleanup_set_free_ Set *locales = NULL;
195 : 4 : _cleanup_strv_free_ char **l = NULL;
196 : : int r;
197 : :
198 : 4 : locales = set_new(&string_hash_ops);
199 [ - + ]: 4 : if (!locales)
200 : 0 : return -ENOMEM;
201 : :
202 : 4 : r = add_locales_from_archive(locales);
203 [ - + # # ]: 4 : if (r < 0 && r != -ENOENT)
204 : 0 : return r;
205 : :
206 : 4 : r = add_locales_from_libdir(locales);
207 [ - + ]: 4 : if (r < 0)
208 : 0 : return r;
209 : :
210 : 4 : l = set_get_strv(locales);
211 [ - + ]: 4 : if (!l)
212 : 0 : return -ENOMEM;
213 : :
214 : 4 : r = getenv_bool("SYSTEMD_LIST_NON_UTF8_LOCALES");
215 [ - + # # ]: 4 : if (r == -ENXIO || r == 0) {
216 : : char **a, **b;
217 : :
218 : : /* Filter out non-UTF-8 locales, because it's 2019, by default */
219 [ + + ]: 3272 : for (a = b = l; *a; a++) {
220 : :
221 [ + + ]: 3268 : if (endswith(*a, "UTF-8") ||
222 [ + + ]: 2148 : strstr(*a, ".UTF-8@"))
223 : 1160 : *(b++) = *a;
224 : : else
225 : 2108 : free(*a);
226 : : }
227 : :
228 : 4 : *b = NULL;
229 : :
230 [ # # ]: 0 : } else if (r < 0)
231 [ # # ]: 0 : log_debug_errno(r, "Failed to parse $SYSTEMD_LIST_NON_UTF8_LOCALES as boolean");
232 : :
233 : 4 : strv_sort(l);
234 : :
235 : 4 : *ret = TAKE_PTR(l);
236 : :
237 : 4 : return 0;
238 : : }
239 : :
240 : 1196 : bool locale_is_valid(const char *name) {
241 : :
242 [ + + ]: 1196 : if (isempty(name))
243 : 4 : return false;
244 : :
245 [ - + ]: 1192 : if (strlen(name) >= 128)
246 : 0 : return false;
247 : :
248 [ - + ]: 1192 : if (!utf8_is_valid(name))
249 : 0 : return false;
250 : :
251 [ + + ]: 1192 : if (!filename_is_valid(name))
252 : 4 : return false;
253 : :
254 [ + + ]: 1188 : if (!string_is_safe(name))
255 : 4 : return false;
256 : :
257 : 1184 : return true;
258 : : }
259 : :
260 : 0 : void init_gettext(void) {
261 : 0 : setlocale(LC_ALL, "");
262 : 0 : textdomain(GETTEXT_PACKAGE);
263 : 0 : }
264 : :
265 : 2360 : bool is_locale_utf8(void) {
266 : : const char *set;
267 : : static int cached_answer = -1;
268 : :
269 : : /* Note that we default to 'true' here, since today UTF8 is
270 : : * pretty much supported everywhere. */
271 : :
272 [ + + ]: 2360 : if (cached_answer >= 0)
273 : 2332 : goto out;
274 : :
275 [ - + ]: 28 : if (!setlocale(LC_ALL, "")) {
276 : 0 : cached_answer = true;
277 : 0 : goto out;
278 : : }
279 : :
280 : 28 : set = nl_langinfo(CODESET);
281 [ - + ]: 28 : if (!set) {
282 : 0 : cached_answer = true;
283 : 0 : goto out;
284 : : }
285 : :
286 [ + - ]: 28 : if (streq(set, "UTF-8")) {
287 : 28 : cached_answer = true;
288 : 28 : goto out;
289 : : }
290 : :
291 : : /* For LC_CTYPE=="C" return true, because CTYPE is effectively
292 : : * unset and everything can do to UTF-8 nowadays. */
293 : 0 : set = setlocale(LC_CTYPE, NULL);
294 [ # # ]: 0 : if (!set) {
295 : 0 : cached_answer = true;
296 : 0 : goto out;
297 : : }
298 : :
299 : : /* Check result, but ignore the result if C was set
300 : : * explicitly. */
301 : 0 : cached_answer =
302 [ # # ]: 0 : STR_IN_SET(set, "C", "POSIX") &&
303 [ # # ]: 0 : !getenv("LC_ALL") &&
304 [ # # # # ]: 0 : !getenv("LC_CTYPE") &&
305 : 0 : !getenv("LANG");
306 : :
307 : 2360 : out:
308 : 2360 : return (bool) cached_answer;
309 : : }
310 : :
311 : 28 : static bool emoji_enabled(void) {
312 : : static int cached_emoji_enabled = -1;
313 : :
314 [ + + ]: 28 : if (cached_emoji_enabled < 0) {
315 : : int val;
316 : :
317 : 4 : val = getenv_bool("SYSTEMD_EMOJI");
318 [ + - ]: 4 : if (val < 0)
319 : 4 : cached_emoji_enabled =
320 [ + - ]: 8 : is_locale_utf8() &&
321 [ + - - + : 4 : !STRPTR_IN_SET(getenv("TERM"), "dumb", "linux");
+ - ]
322 : : else
323 : 0 : cached_emoji_enabled = val;
324 : : }
325 : :
326 : 28 : return cached_emoji_enabled;
327 : : }
328 : :
329 : 132 : const char *special_glyph(SpecialGlyph code) {
330 : :
331 : : /* A list of a number of interesting unicode glyphs we can use to decorate our output. It's probably wise to be
332 : : * conservative here, and primarily stick to the glyphs defined in the eurlatgr font, so that display still
333 : : * works reasonably well on the Linux console. For details see:
334 : : *
335 : : * http://git.altlinux.org/people/legion/packages/kbd.git?p=kbd.git;a=blob;f=data/consolefonts/README.eurlatgr
336 : : */
337 : :
338 : : static const char* const draw_table[2][_SPECIAL_GLYPH_MAX] = {
339 : : /* ASCII fallback */
340 : : [false] = {
341 : : [SPECIAL_GLYPH_TREE_VERTICAL] = "| ",
342 : : [SPECIAL_GLYPH_TREE_BRANCH] = "|-",
343 : : [SPECIAL_GLYPH_TREE_RIGHT] = "`-",
344 : : [SPECIAL_GLYPH_TREE_SPACE] = " ",
345 : : [SPECIAL_GLYPH_TRIANGULAR_BULLET] = ">",
346 : : [SPECIAL_GLYPH_BLACK_CIRCLE] = "*",
347 : : [SPECIAL_GLYPH_BULLET] = "*",
348 : : [SPECIAL_GLYPH_ARROW] = "->",
349 : : [SPECIAL_GLYPH_MDASH] = "-",
350 : : [SPECIAL_GLYPH_ELLIPSIS] = "...",
351 : : [SPECIAL_GLYPH_MU] = "u",
352 : : [SPECIAL_GLYPH_CHECK_MARK] = "+",
353 : : [SPECIAL_GLYPH_CROSS_MARK] = "-",
354 : : [SPECIAL_GLYPH_ECSTATIC_SMILEY] = ":-]",
355 : : [SPECIAL_GLYPH_HAPPY_SMILEY] = ":-}",
356 : : [SPECIAL_GLYPH_SLIGHTLY_HAPPY_SMILEY] = ":-)",
357 : : [SPECIAL_GLYPH_NEUTRAL_SMILEY] = ":-|",
358 : : [SPECIAL_GLYPH_SLIGHTLY_UNHAPPY_SMILEY] = ":-(",
359 : : [SPECIAL_GLYPH_UNHAPPY_SMILEY] = ":-{️",
360 : : [SPECIAL_GLYPH_DEPRESSED_SMILEY] = ":-[",
361 : : },
362 : :
363 : : /* UTF-8 */
364 : : [true] = {
365 : : [SPECIAL_GLYPH_TREE_VERTICAL] = "\342\224\202 ", /* │ */
366 : : [SPECIAL_GLYPH_TREE_BRANCH] = "\342\224\234\342\224\200", /* ├─ */
367 : : [SPECIAL_GLYPH_TREE_RIGHT] = "\342\224\224\342\224\200", /* └─ */
368 : : [SPECIAL_GLYPH_TREE_SPACE] = " ", /* */
369 : : [SPECIAL_GLYPH_TRIANGULAR_BULLET] = "\342\200\243", /* ‣ */
370 : : [SPECIAL_GLYPH_BLACK_CIRCLE] = "\342\227\217", /* ● */
371 : : [SPECIAL_GLYPH_BULLET] = "\342\200\242", /* • */
372 : : [SPECIAL_GLYPH_ARROW] = "\342\206\222", /* → */
373 : : [SPECIAL_GLYPH_MDASH] = "\342\200\223", /* – */
374 : : [SPECIAL_GLYPH_ELLIPSIS] = "\342\200\246", /* … */
375 : : [SPECIAL_GLYPH_MU] = "\316\274", /* μ */
376 : : [SPECIAL_GLYPH_CHECK_MARK] = "\342\234\223", /* ✓ */
377 : : [SPECIAL_GLYPH_CROSS_MARK] = "\342\234\227", /* ✗ */
378 : : [SPECIAL_GLYPH_ECSTATIC_SMILEY] = "\360\237\230\207", /* 😇 */
379 : : [SPECIAL_GLYPH_HAPPY_SMILEY] = "\360\237\230\200", /* 😀 */
380 : : [SPECIAL_GLYPH_SLIGHTLY_HAPPY_SMILEY] = "\360\237\231\202", /* 🙂 */
381 : : [SPECIAL_GLYPH_NEUTRAL_SMILEY] = "\360\237\230\220", /* 😐 */
382 : : [SPECIAL_GLYPH_SLIGHTLY_UNHAPPY_SMILEY] = "\360\237\231\201", /* 🙁 */
383 : : [SPECIAL_GLYPH_UNHAPPY_SMILEY] = "\360\237\230\250", /* 😨️️ */
384 : : [SPECIAL_GLYPH_DEPRESSED_SMILEY] = "\360\237\244\242", /* 🤢 */
385 : : },
386 : : };
387 : :
388 [ - + ]: 132 : assert(code < _SPECIAL_GLYPH_MAX);
389 : :
390 [ + + ]: 132 : return draw_table[code >= _SPECIAL_GLYPH_FIRST_SMILEY ? emoji_enabled() : is_locale_utf8()][code];
391 : : }
392 : :
393 : 0 : void locale_variables_free(char *l[_VARIABLE_LC_MAX]) {
394 : : LocaleVariable i;
395 : :
396 [ # # ]: 0 : if (!l)
397 : 0 : return;
398 : :
399 [ # # ]: 0 : for (i = 0; i < _VARIABLE_LC_MAX; i++)
400 : 0 : l[i] = mfree(l[i]);
401 : : }
402 : :
403 : : static const char * const locale_variable_table[_VARIABLE_LC_MAX] = {
404 : : [VARIABLE_LANG] = "LANG",
405 : : [VARIABLE_LANGUAGE] = "LANGUAGE",
406 : : [VARIABLE_LC_CTYPE] = "LC_CTYPE",
407 : : [VARIABLE_LC_NUMERIC] = "LC_NUMERIC",
408 : : [VARIABLE_LC_TIME] = "LC_TIME",
409 : : [VARIABLE_LC_COLLATE] = "LC_COLLATE",
410 : : [VARIABLE_LC_MONETARY] = "LC_MONETARY",
411 : : [VARIABLE_LC_MESSAGES] = "LC_MESSAGES",
412 : : [VARIABLE_LC_PAPER] = "LC_PAPER",
413 : : [VARIABLE_LC_NAME] = "LC_NAME",
414 : : [VARIABLE_LC_ADDRESS] = "LC_ADDRESS",
415 : : [VARIABLE_LC_TELEPHONE] = "LC_TELEPHONE",
416 : : [VARIABLE_LC_MEASUREMENT] = "LC_MEASUREMENT",
417 : : [VARIABLE_LC_IDENTIFICATION] = "LC_IDENTIFICATION"
418 : : };
419 : :
420 [ + + + + ]: 128 : DEFINE_STRING_TABLE_LOOKUP(locale_variable, LocaleVariable);
|
