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