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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /*
28 * Copyright (c) 2018, Joyent, Inc.
29 */
30
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <unistd.h>
35 #include <sys/param.h>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <tzfile.h>
39 #include <fcntl.h>
40 #include <regex.h>
41 #include <errno.h>
42 #include <libintl.h>
43 #include <libzoneinfo.h>
44
45 #define DEFINIT "/etc/default/init"
46 #define ZONEINFOTABDIR "/usr/share/lib/zoneinfo/tab/"
47 #define CONTINENT_TAB ZONEINFOTABDIR "continent.tab"
48 #define COUNTRY_TAB ZONEINFOTABDIR "country.tab"
49 #define ZONE_SUN_TAB ZONEINFOTABDIR "zone_sun.tab"
50
51 #define NEWLINE "\n"
52 #define SLASH "/"
53 #define WHITESPACE "\t "
54 #define WHITESPACE_NL "\t \n"
55 #define DIGITS "0123456789"
56 #define BUFFLEN 1024
57
58 #define CCLEN 2 /* country code length */
59
60 #define GMT_MAX (12*60*60) /* The maximum GMT offset */
61 #define GMT_MIN (-13*60*60) /* The minimum GMT offset */
62 #define GMT_FMT_Q "<GMT%c%d>%c%d"
63 #define GMT_FMT_Q_LEN (11) /* "<GMT+dd>+dd" - maximum 11 chars */
64 #define GMT0_FMT "GMT0" /* backwards compatibility name */
65 #define GMT_FMT_ZONE ":Etc/GMT%c%d" /* ":Etc/GMT+dd" */
66 #define GMT_FMT_ZONE_LEN (11) /* ":Etc/GMT+dd" - maximum 11 chars */
67
68 #define TZ_FMT "TZ=%s\n" /* format TZ entry init file */
69 #define TZ_FMT_Q "TZ=\"%s\"\n" /* format quoted TZ entry init file */
70
71 #define COORD_FMTLEN1 (sizeof ("+DDMM+DDDMM") - 1)
72 #define COORD_FMTLEN2 (sizeof ("+DDMMSS+DDDMMSS") - 1)
73 #define COORD_FMT1 (1) /* flag for format 1 */
74 #define COORD_FMT2 (2) /* flag for format 2 */
75 #define COORD_DLEN_LAT (2) /* length of DD for latitude */
76 #define COORD_DLEN_LONG (3) /* length of DDD for longtitude */
77 #define COORD_MLEN (2) /* length of MM */
78 #define COORD_SLEN (2) /* length of SS */
79
80 #define TRAILER "/XXXXXX"
81 #define TR_LEN (sizeof (TRAILER) -1)
82
83 /* Internal Declarations */
84 static char *skipwhite(char *);
85 static int skipline(char *);
86 static int trav_link(char **);
87 static void remove_component(char *);
88 static void strip_quotes(char *, char *);
89 static int compar(struct tz_country *, struct tz_country *);
90 static int get_coord(struct tz_timezone *, char *, size_t);
91 static int _tz_match(const char *, const char *);
92 static char *_conv_gmt_zoneinfo(int);
93 static char *_conv_gmt_posix(int);
94
95 /*
96 * get_tz_continents() reads the continent.tab file, and
97 * returns a list of continents.
98 */
99 int
100 get_tz_continents(struct tz_continent **cont)
101 {
102 FILE *fp;
103 char buff[BUFFLEN];
104 char *lp; /* line pointer */
105 char *lptr, *ptr; /* temp pointer */
106 struct tz_continent *head = NULL, *lcp, *prev = NULL;
107 int sav_errno = 0, ncount, status;
108 size_t len;
109
110 /* open continents file */
111 if ((fp = fopen(CONTINENT_TAB, "r")) == NULL) {
112 /* fopen() sets errno */
113 return (-1);
114 }
115 /* read and count continents */
116 ncount = 0;
117 /*CONSTANTCONDITION*/
118 while (1) {
119 if (fgets(buff, sizeof (buff), fp) == NULL) {
120 if (feof(fp) == 0) {
121 /* fgets() sets errno */
122 sav_errno = errno;
123 ncount = -1;
124 }
125 break;
126 }
127 /* Skip comments or blank/whitespace lines */
128 if ((status = skipline(buff)) != 0) {
129 if (status == 1)
130 continue;
131 else {
132 sav_errno = EINVAL;
133 ncount = -1;
134 break;
135 }
136 }
137 /* Get continent name */
138 lp = skipwhite(&buff[0]);
139 if ((len = strcspn(lp, WHITESPACE)) > _TZBUFLEN -1) {
140 sav_errno = ENAMETOOLONG;
141 ncount = -1;
142 break;
143 }
144 /* create continent struct */
145 if ((lcp = (struct tz_continent *)
146 calloc(1, sizeof (struct tz_continent))) == NULL) {
147 sav_errno = ENOMEM;
148 ncount = -1;
149 break;
150 }
151 (void) strncpy(lcp->ctnt_name, lp, len);
152 lcp->ctnt_name[len] = '\0';
153
154 /* Get continent description */
155 lp = skipwhite(lp + len);
156 len = strcspn(lp, NEWLINE);
157 if ((ptr = malloc(len + 1)) == NULL) {
158 (void) free_tz_continents(lcp);
159 sav_errno = ENOMEM;
160 ncount = -1;
161 break;
162 }
163 (void) strncpy(ptr, lp, len);
164 *(ptr + len) = '\0';
165 lcp->ctnt_id_desc = ptr;
166
167 /* Get localized continent description */
168 lptr = dgettext(TEXT_DOMAIN, lcp->ctnt_id_desc);
169 if ((ptr = strdup(lptr)) == NULL) {
170 (void) free_tz_continents(lcp);
171 sav_errno = ENOMEM;
172 ncount = -1;
173 break;
174 }
175 lcp->ctnt_display_desc = ptr;
176
177 if (head == NULL) {
178 head = lcp;
179 } else {
180 prev->ctnt_next = lcp;
181 }
182 prev = lcp;
183 ncount++;
184 }
185 (void) fclose(fp);
186 if (ncount == -1) {
187 if (head != NULL) {
188 (void) free_tz_continents(head);
189 }
190 if (sav_errno)
191 errno = sav_errno;
192 } else {
193 *cont = head;
194 }
195 return (ncount);
196 }
197
198 /*
199 * get_tz_countries() finds the list of countries from the zone_sun.tab
200 * file, for the input continent, and retrieves the country
201 * names from the country.tab file. It also retrieves the localized
202 * country names. The returned list of countries is sorted by the
203 * countries' localized name fields.
204 */
205 int
206 get_tz_countries(struct tz_country **country, struct tz_continent *cont)
207 {
208 FILE *fp_zone, *fp_cc;
209 char buff[BUFFLEN], ccbuf[_CCBUFLEN], *ptr;
210 char *lp, *lptr, *lp_coord, *lp_cc, *lp_tz; /* line pointer */
211 struct tz_country *head = NULL, *prev = NULL, *next, *cp, *cp2;
212 int sav_errno = 0, ncount, i;
213 int cmp, status;
214 size_t len, len_coord, len_ctnt;
215
216 len_ctnt = strlen(cont->ctnt_name);
217 ccbuf[0] = '\0';
218
219 /* open zone_sun.tab and country.tab files */
220 if ((fp_zone = fopen(ZONE_SUN_TAB, "r")) == NULL) {
221 /* fopen() sets errno */
222 return (-1);
223 }
224 if ((fp_cc = fopen(COUNTRY_TAB, "r")) == NULL) {
225 /* fopen() sets errno */
226 (void) fclose(fp_zone);
227 return (-1);
228 }
229
230 /* read timezones to match continents, and get countries */
231 ncount = 0;
232 /*CONSTANTCONDITION*/
233 while (1) {
234 if (fgets(buff, sizeof (buff), fp_zone) == NULL) {
235 if (feof(fp_zone) == 0) {
236 /* fgets() error - errno set */
237 sav_errno = errno;
238 ncount = -1;
239 }
240 break;
241 }
242 /* Skip comments or blank/whitespace lines */
243 if ((status = skipline(buff)) != 0) {
244 if (status == 1)
245 continue;
246 else {
247 sav_errno = EINVAL;
248 ncount = -1;
249 break;
250 }
251 }
252 /*
253 * If country matches previously *matched* country, skip
254 * entry, since zone.tab is alphabetized by country code
255 * (It should be a *matched* country, because the same country
256 * can be in different continents.)
257 */
258 /* Get country code */
259 lp_cc = skipwhite(&buff[0]);
260 if (strcspn(lp_cc, WHITESPACE) != CCLEN) {
261 ncount = -1;
262 sav_errno = EINVAL;
263 break;
264 }
265 /* Check country code cache; skip if already found */
266 if (strncmp(ccbuf, lp_cc, CCLEN) == 0) {
267 continue;
268 }
269 /* Get coordinates */
270 lp_coord = skipwhite(lp_cc + CCLEN);
271 if (((len_coord = strcspn(lp_coord, WHITESPACE)) !=
272 COORD_FMTLEN1) &&
273 (len_coord != COORD_FMTLEN2)) {
274 ncount = -1;
275 sav_errno = EINVAL;
276 break;
277 }
278
279 /* Get timezone name (Skip timezone description) */
280 lp_tz = skipwhite(lp_coord + len_coord);
281 if ((len = strcspn(lp_tz, SLASH)) == 0) {
282 ncount = -1;
283 sav_errno = EINVAL;
284 break;
285 }
286 /* If continents match, allocate a country struct */
287 if ((len == len_ctnt) &&
288 (strncmp(cont->ctnt_name, lp_tz, len) == 0)) {
289 if ((cp = (struct tz_country *)
290 calloc(1, sizeof (struct tz_country))) == NULL) {
291 sav_errno = ENOMEM;
292 ncount = -1;
293 break;
294 }
295 /* Copy and save country code (len already checked) */
296 (void) strncpy(cp->ctry_code, lp_cc, CCLEN);
297 cp->ctry_code[CCLEN] = '\0';
298 (void) strncpy(ccbuf, lp_cc, CCLEN);
299 ccbuf[CCLEN] = '\0';
300
301 /* Create linked list */
302 if (head == NULL) {
303 head = cp;
304 } else {
305 prev->ctry_next = cp;
306 };
307 prev = cp;
308 ncount++;
309 }
310 } /* while */
311
312 if (ncount == -1)
313 goto error;
314
315 /* Get country name from country.tab; get localized country name */
316 /* Read country list, match country codes to process entry */
317 cp = head;
318 /*CONSTANTCONDITION*/
319 while (1) {
320 if (fgets(buff, sizeof (buff), fp_cc) == NULL) {
321 if (feof(fp_cc) == 0) {
322 /* fgets() sets errno */
323 ncount = -1;
324 sav_errno = errno;
325 }
326 break;
327 }
328 /* Skip comments or blank/whitespace lines */
329 if ((status = skipline(buff)) != 0) {
330 if (status == 1)
331 continue;
332 else {
333 sav_errno = EINVAL;
334 ncount = -1;
335 break;
336 }
337 }
338 /* Match country codes */
339 if ((len = strcspn(buff, WHITESPACE)) != CCLEN) {
340 sav_errno = EINVAL;
341 ncount = -1;
342 break;
343 }
344 if ((cmp = strncmp(cp->ctry_code, buff, CCLEN)) == 0) {
345 /* Get country description, and localized desc. */
346 /* Skip to country description */
347 lp = &buff[CCLEN];
348 if ((len = strspn(lp, WHITESPACE)) == 0) {
349 sav_errno = EINVAL;
350 ncount = -1;
351 break;
352 }
353 lp += len; /* lp points to country desc. */
354 len = strcspn(lp, NEWLINE);
355 if ((ptr = calloc(len + 1, 1)) == NULL) {
356 ncount = -1;
357 errno = ENOMEM;
358 break;
359 }
360 (void) strncpy(ptr, lp, len);
361 *(ptr + len) = '\0';
362 cp->ctry_id_desc = ptr;
363
364 /* Get localized country description */
365 lptr = dgettext(TEXT_DOMAIN, ptr);
366 if ((ptr = strdup(lptr)) == NULL) {
367 ncount = -1;
368 errno = ENOMEM;
369 break;
370 }
371 cp->ctry_display_desc = ptr;
372 } else if (cmp > 0) {
373 /* Keep searching country.tab */
374 continue;
375 } else {
376 /* Not found - should not happen */
377 ncount = -1;
378 errno = EILSEQ;
379 break;
380 }
381 if (cp->ctry_next == NULL) {
382 /* done with countries list */
383 break;
384 } else {
385 cp = cp->ctry_next;
386 }
387 } /* while */
388
389 /* Now sort the list by ctry_display_desc field */
390 if ((ncount != -1) &&
391 ((cp2 = calloc(ncount, sizeof (struct tz_country))) != NULL)) {
392 /*
393 * First copy list to a static array for qsort() to use.
394 * Use the cnt_next field to point back to original structure.
395 */
396 cp = head;
397 for (i = 0; i < ncount; i++) {
398 next = cp->ctry_next;
399 cp->ctry_next = cp;
400 (void) memcpy(&cp2[i], cp, sizeof (struct tz_country));
401 cp = next;
402 }
403
404 /* Next, call qsort() using strcoll() to order */
405 qsort(cp2, ncount, sizeof (struct tz_country),
406 (int (*)(const void *, const void *))compar);
407
408 /* Rearrange the country list according to qsort order */
409 head = cp2->ctry_next; /* ctry_next is pointer to orig struct */
410 cp = head;
411 for (i = 0; i < ncount; i++) {
412 prev = cp;
413 cp = cp2[i].ctry_next;
414 prev->ctry_next = cp;
415 }
416 cp->ctry_next = NULL;
417
418 /* Last, free the static buffer */
419 free(cp2);
420
421 } else {
422 if (ncount != -1)
423 ncount = -1;
424 }
425
426 error:
427 (void) fclose(fp_zone);
428 (void) fclose(fp_cc);
429 if (ncount == -1) {
430 /* free the linked list */
431 if (head != NULL)
432 (void) free_tz_countries(head);
433 if (sav_errno)
434 errno = sav_errno;
435 } else {
436 *country = head;
437 }
438 return (ncount);
439 }
440
441 /*
442 * get_timezones_by_country() finds the list of timezones from the
443 * zone_sun.tab file, for the input country.
444 */
445 int
446 get_timezones_by_country(struct tz_timezone **tmzone,
447 struct tz_country *country)
448 {
449 FILE *fp_zone; /* zone.tab */
450 int match = 0, ncount = 0, sav_errno = 0, status;
451 char buff[1024];
452 char *lp_cc, *lp_tz, *lp_otz, *lp_coord, *lp_tzdesc, *ptr, *lptr;
453 size_t len_tz, len_otz, len_coord, len_tzdesc;
454 struct tz_timezone *head = NULL, *prev = NULL, *tp;
455
456 /* open zone.tab file */
457 if ((fp_zone = fopen(ZONE_SUN_TAB, "r")) == NULL)
458 return (-1);
459
460 /* Read through zone.tab until countries match */
461 /*CONSTANTCONDITION*/
462 while (1) {
463 if (fgets(buff, sizeof (buff), fp_zone) == NULL) {
464 if (feof(fp_zone)) {
465 break;
466 } else {
467 /* fgets() sets errno */
468 ncount = -1;
469 sav_errno = errno;
470 break;
471 }
472 }
473 /* Skip comments or blank/whitespace lines */
474 if ((status = skipline(buff)) != 0) {
475 if (status == 1)
476 continue;
477 else {
478 sav_errno = EINVAL;
479 ncount = -1;
480 break;
481 }
482 }
483 /*
484 * Find country entries, or detect if no country matches.
485 */
486 lp_cc = skipwhite(&buff[0]);
487 if (strcspn(lp_cc, WHITESPACE) != CCLEN) {
488 sav_errno = EINVAL;
489 ncount = -1;
490 break;
491 }
492 if (strncmp(country->ctry_code, lp_cc, CCLEN) == 0) {
493 match = 1;
494
495 /* Get coordinates */
496 lp_coord = skipwhite(lp_cc + CCLEN);
497 if (((len_coord = strcspn(lp_coord, WHITESPACE)) !=
498 COORD_FMTLEN1) &&
499 (len_coord != COORD_FMTLEN2)) {
500 ncount = -1;
501 sav_errno = EINVAL;
502 break;
503 }
504 /* Get Olson timezone name */
505 lp_otz = skipwhite(lp_coord + len_coord);
506 len_otz = strcspn(lp_otz, WHITESPACE);
507
508 /* Get Solaris compatible timezone name */
509 lp_tz = skipwhite(lp_otz + len_otz);
510 len_tz = strcspn(lp_tz, WHITESPACE_NL);
511 if (*(lp_tz + len_tz - 1) == '\n') {
512 /* No timezone description */
513 len_tz--;
514 lp_tzdesc = NULL;
515 len_tzdesc = 0;
516 } else {
517 /* Get timezone description */
518 lp_tzdesc = skipwhite(lp_tz +
519 len_tz);
520 len_tzdesc = strcspn(lp_tzdesc,
521 NEWLINE);
522 }
523 /*
524 * Check tz name lengths. This check assumes the
525 * tz_oname and tz_name fields are the same size.
526 * (since tz_name may be written with lp_otz, if
527 * lp_tz is "-".)
528 */
529 if ((len_otz > _TZBUFLEN - 1) ||
530 (len_tz > _TZBUFLEN - 1)) {
531 sav_errno = ENAMETOOLONG;
532 ncount = -1;
533 break;
534 }
535 /* Create timezone struct */
536 if ((tp = (struct tz_timezone *)
537 calloc(1, sizeof (struct tz_timezone))) ==
538 NULL) {
539 sav_errno = ENOMEM;
540 ncount = -1;
541 break;
542 }
543 /*
544 * Copy the timezone names - use the Solaris
545 * compatible timezone name if one exists,
546 * otherwise use the current Olson timezone
547 * name.
548 */
549 (void) strncpy(tp->tz_oname, lp_otz, len_otz);
550 tp->tz_oname[len_otz] = '\0';
551 if (strncmp("-", lp_tz, len_tz) == 0) {
552 lp_tz = lp_otz;
553 len_tz = len_otz;
554 }
555 /* If name has numeric digits, prefix ':' */
556 if (strcspn(lp_tz, DIGITS) < len_tz) {
557 if (len_tz > _TZBUFLEN - 2) {
558 free(tp);
559 sav_errno = ENAMETOOLONG;
560 ncount = -1;
561 break;
562 }
563 tp->tz_name[0] = ':';
564 (void) strncpy(tp->tz_name + 1, lp_tz, len_tz);
565 tp->tz_name[len_tz + 1] = '\0';
566 } else {
567 (void) strncpy(tp->tz_name, lp_tz, len_tz);
568 tp->tz_name[len_tz] = '\0';
569 }
570 /* Process timezone description, if one exists */
571 if ((lp_tzdesc != NULL) && (*lp_tzdesc != '\n')) {
572 if ((ptr = calloc(1, len_tzdesc + 1))
573 == NULL) {
574 sav_errno = ENOMEM;
575 ncount = -1;
576 (void) free_timezones(tp);
577 break;
578 }
579 (void) strncpy(ptr, lp_tzdesc, len_tzdesc);
580 *(ptr + len_tzdesc) = '\0';
581 tp->tz_id_desc = ptr;
582
583 /* Get localized country description */
584 lptr = dgettext(TEXT_DOMAIN, ptr);
585 if ((ptr = strdup(lptr)) == NULL) {
586 sav_errno = ENOMEM;
587 ncount = -1;
588 (void) free_timezones(tp);
589 break;
590 }
591 tp->tz_display_desc = ptr;
592
593 } else {
594 tp->tz_id_desc = NULL;
595 tp->tz_display_desc = NULL;
596 }
597 /* Get coordinate information */
598 if (get_coord(tp, lp_coord, len_coord) == -1) {
599 sav_errno = EILSEQ;
600 ncount = -1;
601 (void) free_timezones(tp);
602 break;
603 }
604 /* Store timezone struct in a linked list */
605 if (head == NULL) {
606 head = tp;
607 } else {
608 prev->tz_next = tp;
609 }
610 prev = tp;
611 ncount++;
612 } else {
613 if (match == 1) {
614 /*
615 * At this point, since zone_sun.tab is ordered,
616 * if we've already found timezone entries for
617 * the input country, then we've found all of
618 * the desired timezone entries (since we will
619 * be past that country's section in
620 * zone_sun.tab), and we are done.
621 */
622 break;
623 }
624 }
625 }
626
627 /* Finish up */
628 (void) fclose(fp_zone);
629 if (ncount == -1) {
630 if (head != NULL)
631 (void) free_timezones(head);
632 if (sav_errno)
633 errno = sav_errno;
634 } else {
635 *tmzone = head;
636 }
637 return (ncount);
638 }
639
640 int
641 free_tz_continents(struct tz_continent *cont)
642 {
643 struct tz_continent *cptr, *cprev;
644
645 cptr = cont;
646 while (cptr != NULL) {
647 if (cptr->ctnt_id_desc != NULL)
648 free(cptr->ctnt_id_desc);
649 if (cptr->ctnt_display_desc != NULL)
650 free(cptr->ctnt_display_desc);
651 cprev = cptr;
652 cptr = cptr->ctnt_next;
653 free(cprev);
654 }
655 return (0);
656 }
657
658 int
659 free_tz_countries(struct tz_country *country)
660 {
661 struct tz_country *cptr, *cprev;
662
663 cptr = country;
664 while (cptr != NULL) {
665 if (cptr->ctry_id_desc != NULL)
666 free(cptr->ctry_id_desc);
667 if (cptr->ctry_display_desc != NULL)
668 free(cptr->ctry_display_desc);
669 cprev = cptr;
670 cptr = cptr->ctry_next;
671 free(cprev);
672 }
673 return (0);
674 }
675
676 int
677 free_timezones(struct tz_timezone *timezone)
678 {
679 struct tz_timezone *tzptr, *tzprev;
680
681 tzptr = timezone;
682 while (tzptr != NULL) {
683 if (tzptr->tz_id_desc != NULL)
684 free(tzptr->tz_id_desc);
685 if (tzptr->tz_display_desc != NULL)
686 free(tzptr->tz_display_desc);
687 tzprev = tzptr;
688 tzptr = tzptr->tz_next;
689 free(tzprev);
690 }
691 return (0);
692 }
693
694 /*
695 * conv_gmt() returns a GMT-offset style timezone
696 * If flag = 0, return Quoted POSIX timezone like: <GMT+8>+8
697 * If flag = 1, return zoneinfo timezone like: :Etc/GMT+8
698 */
699 char *
700 conv_gmt(int seconds, int flag)
701 {
702 int hour;
703 char *cp;
704
705 if ((seconds < _GMT_MIN) || (seconds > _GMT_MAX)) {
706 errno = EINVAL;
707 return (NULL);
708 }
709 hour = (seconds / 60) / 60;
710
711 if (flag == 0) {
712 cp = _conv_gmt_posix(hour);
713 } else if (flag == 1) {
714 cp = _conv_gmt_zoneinfo(hour);
715 } else {
716 errno = EINVAL;
717 return (NULL);
718 }
719 return (cp);
720 }
721
722 static char *
723 _conv_gmt_posix(int hour)
724 {
725 char *cp;
726 char xsign;
727
728 if (hour == 0) {
729 if ((cp = strdup(GMT0_FMT)) == NULL) {
730 errno = ENOMEM;
731 return (NULL);
732 }
733 } else {
734 if (hour < 0) {
735 xsign = '-';
736 /* make hour positive for snprintf() */
737 hour = -hour;
738 } else {
739 xsign = '+';
740 }
741 if ((cp = malloc(GMT_FMT_Q_LEN + 1)) == NULL) {
742 errno = ENOMEM;
743 return (NULL);
744 }
745 (void) snprintf(cp, GMT_FMT_Q_LEN + 1, GMT_FMT_Q,
746 xsign, hour, xsign, hour);
747 }
748 return (cp);
749 }
750
751 static char *
752 _conv_gmt_zoneinfo(int hour)
753 {
754 char *cp;
755 char xsign;
756
757 if (hour < 0) {
758 xsign = '-';
759 /* make hour positive for snprintf() */
760 hour = -hour;
761 } else {
762 xsign = '+';
763 }
764 if ((cp = malloc(GMT_FMT_ZONE_LEN + 1)) == NULL) {
765 errno = ENOMEM;
766 return (NULL);
767 }
768 (void) snprintf(cp, GMT_FMT_ZONE_LEN + 1, GMT_FMT_ZONE,
769 xsign, hour);
770 return (cp);
771 }
772
773 /* Regular expression for POSIX GMT-offset timezone */
774 #define _GMT_EXPR "(" _GMT_EXPR_U "|" _GMT_EXPR_Q ")"
775 #define _GMT_EXPR_U "^[gG][mM][tT][-+]?[0-2]?[0-9]$"
776 #define _GMT_EXPR_Q "^<[gG][mM][tT][-+]?[0-2]?[0-9]>[-+]?[0-2]?[0-9]$"
777
778 /*
779 * Regular expression for quoted POSIX timezone.
780 */
781 /* Avoid alphabetic ranges (eg, a-z) due to effect of LC_COLLATE */
782 #define _ALPHA "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
783 #define _NUM "0123456789" /* for safe */
784 #define _STD_Q_ELM "[-+" _ALPHA _NUM "]"
785 #define _STD_Q "<" _STD_Q_ELM _STD_Q_ELM _STD_Q_ELM "+>"
786
787 /* Regular expression for unquoted POSIX timezone */
788 #define _STD_U_ELM_1 "[^-+,<" _NUM "]"
789 #define _STD_U_ELM "[^-+," _NUM "]"
790 #define _STD_U _STD_U_ELM_1 _STD_U_ELM _STD_U_ELM "+"
791
792 /* Regular expression for POSIX timezone */
793 #define _STD "(" _STD_U "|" _STD_Q ")"
794 #define _DST _STD
795 #define _OFFSET "[-+]?" _TIME
796 #define _START "(" _DATEJ "|" _DATEn "|" _DATEM ")"
797 #define _DATEJ "J(([0-2]?[0-9]?[0-9])|3[0-5][0-9]|36[0-5])"
798 #define _DATEn "(([0-2]?[0-9]?[0-9])|3[0-5][0-9]|36[0-5])"
799 #define _DATEM "M([0-9]|10|11|12)\\.[1-5]\\.[0-6]"
800 #define _END _START
801 #define _TIME _HH "(:" _MM "(:" _SS ")?" ")?"
802 #define _HH "(([0-1]?[0-9])|20|21|22|23|24)"
803 #define _MM "[0-5]?[0-9]"
804 #define _SS _MM
805 #define _POSIX_EXPR "^" _STD _OFFSET "(" _DST "(" _OFFSET ")?" \
806 "(," _START "(/" _TIME ")?" \
807 "," _END "(/" _TIME ")?" ")?" ")?" "$"
808
809 #define LEN_TZDIR (sizeof (TZDIR) - 1)
810
811 /*
812 * isvalid_tz() checks if timezone is a valid POSIX or zoneinfo
813 * timezone, depending on the value of flag. For flag = _VTZ_INSTALL,
814 * isvalid_tz() behaves according to the behavior of Solaris Install
815 * in Solaris 9 and earlier, where timezones under /usr/share/lib/zoneinfo
816 * were validated. isvalid_tz() has a special check for GMT+-* timezones
817 * because Solaris Install validated /usr/share/lib/zoneinfo/GMT+-*.
818 * However, when /usr/share/lib/zoneinfo/GMT+-* are EOF'd, that check
819 * no longer works.
820 *
821 * isvalid_tz() returns 1 if a valid timezone is detected.
822 */
823 int
824 isvalid_tz(char *timezone, char *root, int flag)
825 {
826 char path[MAXPATHLEN];
827 char buf[sizeof (struct tzhead)];
828 int fid, ret;
829
830 if ((timezone == NULL) || (*timezone == '\0')) {
831 return (0);
832 }
833
834 /* First check if timezone is a valid POSIX timezone */
835 switch (flag) {
836 case _VTZ_INSTALL:
837 /*
838 * Special check for POSIX GMT timezone.
839 * If no match, check for zoneinfo timezone below
840 */
841 if (_tz_match(_GMT_EXPR, timezone) == 0) {
842 /* Valid GMT timezone */
843 return (1);
844 }
845 break;
846 case _VTZ_POSIX:
847 /* Check for generic POSIX timezone */
848 if (_tz_match(_POSIX_EXPR, timezone) == 0) {
849 /* Valid POSIX timezone */
850 return (1);
851 }
852 /* Invalid POSIX timezone */
853 return (0);
854 case _VTZ_ALL:
855 /* Check for generic POSIX timezone */
856 if (_tz_match(_POSIX_EXPR, timezone) == 0) {
857 /* Valid POSIX timezone */
858 return (1);
859 }
860 break;
861 case _VTZ_ZONEINFO:
862 break;
863 default:
864 return (0);
865 }
866
867 /*
868 * Check for valid zoneinfo timezone -
869 * open zoneinfo file and check for magic number
870 */
871
872 /* skip prepended ':' if one exists */
873 if (*timezone == ':') {
874 timezone++;
875 }
876 /* Construct full zoneinfo pathname */
877 if ((root != NULL) && (*root != '\0')) {
878 ret = snprintf(path, sizeof (path),
879 "%s%s/%s", root, TZDIR, timezone);
880 if (ret >= sizeof (path)) {
881 /* too long */
882 return (0);
883 }
884 } else {
885 ret = snprintf(path, sizeof (path),
886 "%s/%s", TZDIR, timezone);
887 if (ret >= sizeof (path)) {
888 /* too long */
889 return (0);
890 }
891 }
892 if ((fid = open(path, O_RDONLY)) == -1) {
893 return (0);
894 }
895 if (read(fid, buf, sizeof (struct tzhead)) !=
896 sizeof (struct tzhead)) {
897 (void) close(fid);
898 return (0);
899 }
900 if (strncmp(buf, TZ_MAGIC, sizeof (TZ_MAGIC) - 1) != 0) {
901 (void) close(fid);
902 return (0);
903 }
904 if (close(fid) == -1) {
905 return (0);
906 }
907 /* Valid zoneinfo timezone */
908 return (1);
909 }
910
911 #define N_MATCH 1
912
913 int
914 _tz_match(const char *expr, const char *string)
915 {
916 regex_t reg;
917 regmatch_t pmatch[N_MATCH];
918 int ret;
919
920 ret = regcomp(®, expr, REG_EXTENDED);
921 if (ret != 0) {
922 return (-1);
923 }
924
925 ret = regexec((const regex_t *)®, string, N_MATCH, pmatch, 0);
926 if (ret == 0) {
927 #ifdef DEBUG
928 printf("OK matched - %s\n", string);
929 #endif
930 regfree(®);
931 return (0);
932 }
933 #ifdef DEBUG
934 printf("NOT matched - %s\n", string);
935 #endif
936 regfree(®);
937 return (-1);
938 }
939
940 char *
941 get_system_tz(char *root)
942 {
943 FILE *ifp;
944 char buff[512];
945 int serrno, ret;
946 char *sp, *ptr, *p;
947 char fname[MAXPATHLEN];
948
949 if ((ret = snprintf(fname, sizeof (fname), "%s/%s", root, DEFINIT)) >=
950 sizeof (fname)) {
951 errno = ENAMETOOLONG;
952 return (NULL);
953 } else if (ret < 0) {
954 return (NULL);
955 }
956 if ((ifp = fopen(fname, "r")) == NULL)
957 return (NULL);
958 while (fgets(buff, sizeof (buff), ifp) != NULL) {
959 if (strncmp(buff, "TZ=", 3) == 0) {
960 (void) fclose(ifp);
961 p = &buff[3];
962 if ((sp = strchr(p, ';')) != NULL) {
963 *sp = '\0';
964 } else if ((sp = strchr(p, '\n')) != NULL) {
965 *sp = '\0';
966 }
967 if (strpbrk(p, "\"'") != NULL) {
968 strip_quotes(p, p);
969 }
970 ptr = strdup(p);
971 if (ptr == NULL) {
972 errno = ENOMEM;
973 return (NULL);
974 }
975 return (ptr);
976 }
977 }
978
979 /* Either reached EOF with no TZ= entry, or got fgets() error */
980 serrno = errno;
981 if (feof(ifp) != 0) {
982 /* No "TZ=" entry found */
983 serrno = EINVAL;
984 }
985 (void) fclose(ifp);
986 errno = serrno;
987 return (NULL);
988 }
989
990 int
991 set_system_tz(char *tz, char *root)
992 {
993 FILE *ifp, *ofp; /* Input & output files */
994 char *tmpdir, *tmp; /* Temp file name and location */
995 char buff[1024];
996 int replaced = 0, ret, serrno;
997 char *tdb;
998 struct stat sb;
999 char fname[MAXPATHLEN];
1000 const char *tzfmt;
1001 int len, fd;
1002
1003 if (tz == NULL || root == NULL)
1004 return (-1);
1005
1006 if (strchr(tz, '<')) {
1007 tzfmt = TZ_FMT_Q;
1008 } else {
1009 tzfmt = TZ_FMT;
1010 }
1011
1012 if ((ret = snprintf(fname, sizeof (fname), "%s/%s", root, DEFINIT)) >=
1013 sizeof (fname)) {
1014 errno = ENAMETOOLONG;
1015 return (-1);
1016 } else if (ret < 0) {
1017 return (-1);
1018 }
1019
1020 /*
1021 * Generate temporary file name to use. We make sure it's in the same
1022 * directory as the db we're processing so that we can use rename to
1023 * do the replace later. Otherwise we run the risk of being on the
1024 * wrong filesystem and having rename() fail for that reason.
1025 */
1026 tdb = fname;
1027 if (trav_link(&tdb) == -1)
1028 return (-1);
1029 if ((tmpdir = strdup(tdb)) == NULL) {
1030 errno = ENOMEM;
1031 return (-1);
1032 }
1033 remove_component(tmpdir);
1034 if ((len = strlen(tmpdir)) == 0) {
1035 (void) strcpy(tmpdir, ".");
1036 len = 1;
1037 }
1038
1039 if ((tmp = malloc(len + TR_LEN + 1)) == NULL) {
1040 free(tmpdir);
1041 errno = ENOMEM;
1042 return (-1);
1043 }
1044 (void) strcpy(tmp, tmpdir);
1045 (void) strcpy(tmp + len, TRAILER);
1046 free(tmpdir);
1047 if ((fd = mkstemp(tmp)) == -1) {
1048 free(tmp);
1049 return (-1);
1050 }
1051 if ((ofp = fdopen(fd, "w")) == NULL) {
1052 serrno = errno;
1053 (void) close(fd);
1054 free(tmp);
1055 errno = serrno;
1056 return (-1);
1057 }
1058
1059 /* Preserve permissions of current file if it exists */
1060 if (stat(tdb, &sb) == 0) {
1061 if (fchmod(fileno(ofp), sb.st_mode) == -1) {
1062 serrno = errno;
1063 (void) fclose(ofp);
1064 (void) unlink(tmp);
1065 free(tmp);
1066 errno = serrno;
1067 return (-1);
1068 }
1069 if (fchown(fileno(ofp), sb.st_uid, sb.st_gid) == -1) {
1070 serrno = errno;
1071 (void) fclose(ofp);
1072 (void) unlink(tmp);
1073 free(tmp);
1074 errno = serrno;
1075 return (-1);
1076 }
1077 } else if (errno != ENOENT) {
1078 serrno = errno;
1079 (void) fclose(ofp);
1080 (void) unlink(tmp);
1081 free(tmp);
1082 errno = serrno;
1083 return (-1);
1084 }
1085
1086 if ((ifp = fopen(fname, "r+")) != NULL) {
1087 while (fgets(buff, sizeof (buff), ifp) != NULL) {
1088 if (!replaced && (strncmp(buff, "TZ=", 3) == 0)) {
1089 ret = snprintf(buff, sizeof (buff), tzfmt,
1090 tz);
1091 if ((ret >= sizeof (buff)) || (ret < 0)) {
1092 if (ret >= sizeof (buff))
1093 serrno = EINVAL;
1094 (void) fclose(ofp);
1095 (void) fclose(ifp);
1096 (void) unlink(tmp);
1097 free(tmp);
1098 errno = serrno;
1099 return (-1);
1100 }
1101 replaced = 1;
1102 }
1103 if (fputs(buff, ofp) == EOF) {
1104 serrno = errno;
1105 (void) fclose(ofp);
1106 (void) fclose(ifp);
1107 (void) unlink(tmp);
1108 free(tmp);
1109 errno = serrno;
1110 return (-1);
1111 }
1112 }
1113 (void) fclose(ifp);
1114
1115 } else if (errno != ENOENT) {
1116 serrno = errno;
1117 (void) fclose(ofp);
1118 (void) unlink(tmp);
1119 free(tmp);
1120 errno = serrno;
1121 return (-1);
1122 }
1123
1124 /*
1125 * no $(ROOT)/etc/default/init found, or
1126 * no "TZ=" entry found in the init file.
1127 */
1128 if (!replaced &&
1129 (fprintf(ofp, tzfmt, tz) == EOF)) {
1130 serrno = errno;
1131 (void) fclose(ofp);
1132 (void) unlink(tmp);
1133 free(tmp);
1134 errno = serrno;
1135 return (-1);
1136 }
1137
1138 if (fsync(fileno(ofp))) {
1139 serrno = errno;
1140 (void) unlink(tmp);
1141 free(tmp);
1142 errno = serrno;
1143 return (-1);
1144 }
1145
1146 (void) fclose(ofp);
1147 if (rename(tmp, tdb) != 0) {
1148 serrno = errno;
1149 (void) unlink(tmp);
1150 free(tmp);
1151 errno = serrno;
1152 return (-1);
1153 } else {
1154 free(tmp);
1155 return (0);
1156 }
1157 }
1158
1159 /*
1160 * Function to traverse a symlink path to find the real file at the end of
1161 * the rainbow.
1162 */
1163 int
1164 trav_link(char **path)
1165 {
1166 static char newpath[MAXPATHLEN];
1167 char lastpath[MAXPATHLEN];
1168 int len, ret;
1169 char *tp;
1170
1171 (void) strcpy(lastpath, *path);
1172 while ((len = readlink(*path, newpath, sizeof (newpath))) != -1) {
1173 newpath[len] = '\0';
1174 if (newpath[0] != '/') {
1175 if ((tp = strdup(newpath)) == NULL) {
1176 errno = ENOMEM;
1177 return (-1);
1178 }
1179 remove_component(lastpath);
1180 ret = snprintf(newpath, sizeof (newpath),
1181 "%s/%s", lastpath, tp);
1182 free(tp);
1183 if ((ret >= sizeof (newpath)) || (ret < 0))
1184 return (-1);
1185 }
1186 (void) strcpy(lastpath, newpath);
1187 *path = newpath;
1188 }
1189
1190 /*
1191 * ENOENT or EINVAL is the normal exit case of the above loop.
1192 */
1193 if ((errno == ENOENT) || (errno == EINVAL))
1194 return (0);
1195 else
1196 return (-1);
1197 }
1198
1199 void
1200 remove_component(char *path)
1201 {
1202 char *p;
1203
1204 p = strrchr(path, '/'); /* find last '/' */
1205 if (p == NULL) {
1206 *path = '\0'; /* set path to null str */
1207 } else {
1208 *p = '\0'; /* zap it */
1209 }
1210 }
1211
1212 /*
1213 * get_coord() fills in the tz_coord structure of the tz_timezone
1214 * struct. It returns 0 on success, or -1 on error.
1215 * The format of p_coord is:
1216 *
1217 * Latitude and longitude of the zone's principal location
1218 * in ISO 6709 sign-degrees-minutes-seconds format,
1219 * either +-DDMM+-DDDMM or +-DDMMSS+-DDDMMSS,
1220 * first latitude (+ is north), then longitude (+ is east).
1221 */
1222 static int
1223 get_coord(struct tz_timezone *tp, char *p_coord, size_t len_coord)
1224 {
1225 int i, fmt_flag, nchar;
1226 int *signp, *degp, *minp, *secp;
1227 struct tz_coord *tcp;
1228 char buff[512], *endp;
1229
1230 tcp = &(tp->tz_coord);
1231
1232 /* Figure out which format to use */
1233 if (len_coord == COORD_FMTLEN1) {
1234 /* "+-DDMM+-DDDMM" */
1235 fmt_flag = COORD_FMT1;
1236 } else if (len_coord == COORD_FMTLEN2) {
1237 /* "+-DDMMSS+-DDDMMSS" */
1238 fmt_flag = COORD_FMT2;
1239 } else {
1240 /* error */
1241 return (-1);
1242 }
1243 /*
1244 * First time through, get values for latitude;
1245 * second time through, get values for longitude.
1246 */
1247 for (i = 0; i < 2; i++) {
1248 /* Set up pointers */
1249 if (i == 0) {
1250 /* Do latitude */
1251 nchar = COORD_DLEN_LAT;
1252 signp = (int *)&(tcp->lat_sign);
1253 degp = (int *)&(tcp->lat_degree);
1254 minp = (int *)&(tcp->lat_minute);
1255 secp = (int *)&(tcp->lat_second);
1256 } else {
1257 /* Do longitude */
1258 nchar = COORD_DLEN_LONG;
1259 signp = (int *)&(tcp->long_sign);
1260 degp = (int *)&tcp->long_degree;
1261 minp = (int *)&tcp->long_minute;
1262 secp = (int *)&tcp->long_second;
1263 }
1264 /* Get latitude/logitude sign */
1265 if (*p_coord == '+') {
1266 *signp = 1;
1267 } else if (*p_coord == '-') {
1268 *signp = -1;
1269 } else {
1270 return (-1);
1271 }
1272 p_coord++;
1273
1274 /* Get DD latitude, or DDD longitude */
1275 (void) strncpy(buff, p_coord, nchar);
1276 buff[nchar] = '\0';
1277 errno = 0;
1278 *degp = (int)strtol(buff, &endp, 10);
1279 if ((endp != &buff[nchar]) || ((*degp == 0) && (errno != 0)))
1280 return (-1);
1281 p_coord += nchar;
1282
1283 /* Get MM latitude/longitude */
1284 (void) strncpy(buff, p_coord, COORD_MLEN);
1285 buff[COORD_MLEN] = '\0';
1286 errno = 0;
1287 *minp = (int)strtol(buff, &endp, 10);
1288 if ((endp != &buff[COORD_MLEN]) ||
1289 ((*degp == 0) && (errno != 0)))
1290 return (-1);
1291 p_coord += COORD_MLEN;
1292
1293 /* If FMT2, then get SS latitude/longitude */
1294 if (fmt_flag == COORD_FMT2) {
1295 (void) strncpy(buff, p_coord, COORD_SLEN);
1296 buff[COORD_SLEN] = '\0';
1297 errno = 0;
1298 *secp = (int)strtol(buff, &endp, 10);
1299 if ((endp != &buff[COORD_SLEN]) ||
1300 ((*degp == 0) && (errno != 0)))
1301 return (-1);
1302 p_coord += COORD_SLEN;
1303 } else {
1304 *secp = 0;
1305 }
1306 }
1307 return (0);
1308 }
1309
1310 static char *
1311 skipwhite(char *cp)
1312 {
1313 while (*cp && ((*cp == ' ') || (*cp == '\t'))) {
1314 cp++;
1315 }
1316
1317 return (cp);
1318 }
1319
1320 /*
1321 * skipline() checks if the line begins with a comment
1322 * comment character anywhere in the line, or if the
1323 * line is only whitespace.
1324 * skipline() also checks if the line read is too long to
1325 * fit in the buffer.
1326 * skipline() returns 1 if the line can be skipped, -1 if
1327 * the line read is too long, and 0 if the line should not be skipped.
1328 */
1329 static int
1330 skipline(char *line)
1331 {
1332 size_t len;
1333
1334 len = strlen(line);
1335 if (line[len - 1] != '\n')
1336 return (-1);
1337 if (line[0] == '#' || line[0] == '\0' ||
1338 (len = strspn(line, " \t\n")) == strlen(line) ||
1339 strchr(line, '#') == line + len)
1340
1341 return (1);
1342 else
1343 return (0);
1344 }
1345
1346 /*
1347 * strip_quotes -- strip double (") or single (') quotes
1348 */
1349 static void
1350 strip_quotes(char *from, char *to)
1351 {
1352 char *strip_ptr = NULL;
1353
1354 while (*from != '\0') {
1355 if ((*from == '"') || (*from == '\'')) {
1356 if (strip_ptr == NULL)
1357 strip_ptr = to;
1358 } else {
1359 if (strip_ptr != NULL) {
1360 *strip_ptr = *from;
1361 strip_ptr++;
1362 } else {
1363 *to = *from;
1364 to++;
1365 }
1366 }
1367 from++;
1368 }
1369 if (strip_ptr != NULL) {
1370 *strip_ptr = '\0';
1371 } else {
1372 *to = '\0';
1373 }
1374 }
1375
1376 /*
1377 * Compare function used by get_tz_countries() - uses strcoll()
1378 * for locale-sensitive comparison for the localized country names.
1379 */
1380 static int
1381 compar(struct tz_country *p1, struct tz_country *p2)
1382 {
1383 int ret;
1384
1385 ret = strcoll(p1->ctry_display_desc, p2->ctry_display_desc);
1386 return (ret);
1387 }