1 /*

     2  * Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #include <stdlib.h>

    27 #include <stdio.h>

    28 #include <strings.h>

    29 #include <time.h>

    30 #include <limits.h>

    31 #include <errno.h>

    32 #include <stddef.h>

    33 #include <sys/stat.h>

    34 #include <sys/types.h>

    35 #include <string.h>

    36 #include <dirent.h>

    37 #include <unistd.h>

    38 #if defined(__solaris__)

    39 #include <libscf.h>

    40 #endif

    41 

    42 #include "jvm.h"

    43 #include "TimeZone_md.h"

    44 

    45 #define SKIP_SPACE(p)   while (*p == ' ' || *p == '\t') p++;

    46 

    47 #define RESTARTABLE(_cmd, _result) do { \

    48   do { \

    49     _result = _cmd; \

    50   } while((_result == -1) && (errno == EINTR)); \

    51 } while(0)

    52 

    53 #if defined(_ALLBSD_SOURCE)

    54 #define dirent64 dirent

    55 #define readdir64_r readdir_r

    56 #endif

    57 

    58 #if !defined(__solaris__) || defined(__sparcv9) || defined(amd64)

    59 #define fileopen        fopen

    60 #define filegets        fgets

    61 #define fileclose       fclose

    62 #endif

    63 

    64 #if defined(__linux__) || defined(_ALLBSD_SOURCE)

    65 static const char *ETC_TIMEZONE_FILE = "/etc/timezone";

    66 static const char *ZONEINFO_DIR = "/usr/share/zoneinfo";

    67 static const char *DEFAULT_ZONEINFO_FILE = "/etc/localtime";

    68 #else

    69 static const char *SYS_INIT_FILE = "/etc/default/init";

    70 static const char *ZONEINFO_DIR = "/usr/share/lib/zoneinfo";

    71 static const char *DEFAULT_ZONEINFO_FILE = "/usr/share/lib/zoneinfo/localtime";

    72 #endif /* defined(__linux__) || defined(_ALLBSD_SOURCE) */

    73 

    74 #if defined(_AIX)

    75 static const char *ETC_ENVIRONMENT_FILE = "/etc/environment";

    76 #endif

    77 

    78 #if defined(__linux__) || defined(MACOSX) || defined(__solaris__)

    79 

    80 /*

    81  * Returns a pointer to the zone ID portion of the given zoneinfo file

    82  * name, or NULL if the given string doesn't contain "zoneinfo/".

    83  */

    84 static char *

    85 getZoneName(char *str)

    86 {

    87     static const char *zidir = "zoneinfo/";

    88 

    89     char *pos = strstr((const char *)str, zidir);

    90     if (pos == NULL) {

    91         return NULL;

    92     }

    93     return pos + strlen(zidir);

    94 }

    95 

    96 /*

    97  * Returns a path name created from the given 'dir' and 'name' under

    98  * UNIX. This function allocates memory for the pathname calling

    99  * malloc(). NULL is returned if malloc() fails.

   100  */

   101 static char *

   102 getPathName(const char *dir, const char *name) {

   103     char *path;

   104 

   105     path = (char *) malloc(strlen(dir) + strlen(name) + 2);

   106     if (path == NULL) {

   107         return NULL;

   108     }

   109     return strcat(strcat(strcpy(path, dir), "/"), name);

   110 }

   111 

   112 /*

   113  * Scans the specified directory and its subdirectories to find a

   114  * zoneinfo file which has the same content as /etc/localtime on Linux

   115  * or /usr/share/lib/zoneinfo/localtime on Solaris given in 'buf'.

   116  * If file is symbolic link, then the contents it points to are in buf.

   117  * Returns a zone ID if found, otherwise, NULL is returned.

   118  */

   119 static char *

   120 findZoneinfoFile(char *buf, size_t size, const char *dir)

   121 {

   122     DIR *dirp = NULL;

   123     struct stat statbuf;

   124     struct dirent64 *dp = NULL;

   125     struct dirent64 *entry = NULL;

   126     char *pathname = NULL;

   127     int fd = -1;

   128     char *dbuf = NULL;

   129     char *tz = NULL;

   130     int res;

   131     long name_max = 0;

   132 

   133     dirp = opendir(dir);

   134     if (dirp == NULL) {

   135         return NULL;

   136     }

   137 

   138     name_max = pathconf(dir, _PC_NAME_MAX);

   139     // If pathconf did not work, fall back to a mimimum buffer size.

   140     if (name_max < 1024) {

   141         name_max = 1024;

   142     }

   143 

   144     entry = (struct dirent64 *)malloc(offsetof(struct dirent64, d_name) + name_max + 1);

   145     if (entry == NULL) {

   146         (void) closedir(dirp);

   147         return NULL;

   148     }

   149 

   150     while (readdir64_r(dirp, entry, &dp) == 0 && dp != NULL) {

   151         /*

   152          * Skip '.' and '..' (and possibly other .* files)

   153          */

   154         if (dp->d_name[0] == '.') {

   155             continue;

   156         }

   157 

   158         /*

   159          * Skip "ROC", "posixrules", and "localtime".

   160          */

   161         if ((strcmp(dp->d_name, "ROC") == 0)

   162             || (strcmp(dp->d_name, "posixrules") == 0)

   163 #if defined(__solaris__)

   164             /*

   165              * Skip the "src" and "tab" directories on Solaris.

   166              */

   167             || (strcmp(dp->d_name, "src") == 0)

   168             || (strcmp(dp->d_name, "tab") == 0)

   169 #endif

   170             || (strcmp(dp->d_name, "localtime") == 0)) {

   171             continue;

   172         }

   173 

   174         pathname = getPathName(dir, dp->d_name);

   175         if (pathname == NULL) {

   176             break;

   177         }

   178         RESTARTABLE(stat(pathname, &statbuf), res);

   179         if (res == -1) {

   180             break;

   181         }

   182 

   183         if (S_ISDIR(statbuf.st_mode)) {

   184             tz = findZoneinfoFile(buf, size, pathname);

   185             if (tz != NULL) {

   186                 break;

   187             }

   188         } else if (S_ISREG(statbuf.st_mode) && (size_t)statbuf.st_size == size) {

   189             dbuf = (char *) malloc(size);

   190             if (dbuf == NULL) {

   191                 break;

   192             }

   193             RESTARTABLE(open(pathname, O_RDONLY), fd);

   194             if (fd == -1) {

   195                 break;

   196             }

   197             RESTARTABLE(read(fd, dbuf, size), res);

   198             if (res != (ssize_t) size) {

   199                 break;

   200             }

   201             if (memcmp(buf, dbuf, size) == 0) {

   202                 tz = getZoneName(pathname);

   203                 if (tz != NULL) {

   204                     tz = strdup(tz);

   205                 }

   206                 break;

   207             }

   208             free((void *) dbuf);

   209             dbuf = NULL;

   210             (void) close(fd);

   211             fd = -1;

   212         }

   213         free((void *) pathname);

   214         pathname = NULL;

   215     }

   216 

   217     if (entry != NULL) {

   218         free((void *) entry);

   219     }

   220     if (dirp != NULL) {

   221         (void) closedir(dirp);

   222     }

   223     if (pathname != NULL) {

   224         free((void *) pathname);

   225     }

   226     if (fd != -1) {

   227         (void) close(fd);

   228     }

   229     if (dbuf != NULL) {

   230         free((void *) dbuf);

   231     }

   232     return tz;

   233 }

   234 

   235 #if defined(__linux__) || defined(MACOSX)

   236 

   237 /*

   238  * Performs Linux specific mapping and returns a zone ID

   239  * if found. Otherwise, NULL is returned.

   240  */

   241 static char *

   242 getPlatformTimeZoneID()

   243 {

   244     struct stat statbuf;

   245     char *tz = NULL;

   246     FILE *fp;

   247     int fd;

   248     char *buf;

   249     size_t size;

   250     int res;

   251 

   252 #if defined(__linux__)

   253     /*

   254      * Try reading the /etc/timezone file for Debian distros. There's

   255      * no spec of the file format available. This parsing assumes that

   256      * there's one line of an Olson tzid followed by a '\n', no

   257      * leading or trailing spaces, no comments.

   258      */

   259     if ((fp = fopen(ETC_TIMEZONE_FILE, "r")) != NULL) {

   260         char line[256];

   261 

   262         if (fgets(line, sizeof(line), fp) != NULL) {

   263             char *p = strchr(line, '\n');

   264             if (p != NULL) {

   265                 *p = '\0';

   266             }

   267             if (strlen(line) > 0) {

   268                 tz = strdup(line);

   269             }

   270         }

   271         (void) fclose(fp);

   272         if (tz != NULL) {

   273             return tz;

   274         }

   275     }

   276 #endif /* defined(__linux__) */

   277 

   278     /*

   279      * Next, try /etc/localtime to find the zone ID.

   280      */

   281     RESTARTABLE(lstat(DEFAULT_ZONEINFO_FILE, &statbuf), res);

   282     if (res == -1) {

   283         return NULL;

   284     }

   285 

   286     /*

   287      * If it's a symlink, get the link name and its zone ID part. (The

   288      * older versions of timeconfig created a symlink as described in

   289      * the Red Hat man page. It was changed in 1999 to create a copy

   290      * of a zoneinfo file. It's no longer possible to get the zone ID

   291      * from /etc/localtime.)

   292      */

   293     if (S_ISLNK(statbuf.st_mode)) {

   294         char linkbuf[PATH_MAX+1];

   295         int len;

   296 

   297         if ((len = readlink(DEFAULT_ZONEINFO_FILE, linkbuf, sizeof(linkbuf)-1)) == -1) {

   298             jio_fprintf(stderr, (const char *) "can't get a symlink of %s\n",

   299                         DEFAULT_ZONEINFO_FILE);

   300             return NULL;

   301         }

   302         linkbuf[len] = '\0';

   303         tz = getZoneName(linkbuf);

   304         if (tz != NULL) {

   305             tz = strdup(tz);

   306             return tz;

   307         }

   308     }

   309 

   310     /*

   311      * If it's a regular file, we need to find out the same zoneinfo file

   312      * that has been copied as /etc/localtime.

   313      * If initial symbolic link resolution failed, we should treat target

   314      * file as a regular file.

   315      */

   316     RESTARTABLE(open(DEFAULT_ZONEINFO_FILE, O_RDONLY), fd);

   317     if (fd == -1) {

   318         return NULL;

   319     }

   320 

   321     RESTARTABLE(fstat(fd, &statbuf), res);

   322     if (res == -1) {

   323         (void) close(fd);

   324         return NULL;

   325     }

   326     size = (size_t) statbuf.st_size;

   327     buf = (char *) malloc(size);

   328     if (buf == NULL) {

   329         (void) close(fd);

   330         return NULL;

   331     }

   332 

   333     RESTARTABLE(read(fd, buf, size), res);

   334     if (res != (ssize_t) size) {

   335         (void) close(fd);

   336         free((void *) buf);

   337         return NULL;

   338     }

   339     (void) close(fd);

   340 

   341     tz = findZoneinfoFile(buf, size, ZONEINFO_DIR);

   342     free((void *) buf);

   343     return tz;

   344 }

   345 

   346 #elif defined(__solaris__)

   347 

   348 #if !defined(__sparcv9) && !defined(amd64)

   349 

   350 /*

   351  * Those file* functions mimic the UNIX stream io functions. This is

   352  * because of the limitation of the number of open files on Solaris

   353  * (32-bit mode only) due to the System V ABI.

   354  */

   355 

   356 #define BUFFER_SIZE     4096

   357 

   358 static struct iobuffer {

   359     int     magic;      /* -1 to distinguish from the real FILE */

   360     int     fd;         /* file descriptor */

   361     char    *buffer;    /* pointer to buffer */

   362     char    *ptr;       /* current read pointer */

   363     char    *endptr;    /* end pointer */

   364 };

   365 

   366 static int

   367 fileclose(FILE *stream)

   368 {

   369     struct iobuffer *iop = (struct iobuffer *) stream;

   370 

   371     if (iop->magic != -1) {

   372         return fclose(stream);

   373     }

   374 

   375     if (iop == NULL) {

   376         return 0;

   377     }

   378     close(iop->fd);

   379     free((void *)iop->buffer);

   380     free((void *)iop);

   381     return 0;

   382 }

   383 

   384 static FILE *

   385 fileopen(const char *fname, const char *fmode)

   386 {

   387     FILE *fp;

   388     int fd;

   389     struct iobuffer *iop;

   390 

   391     if ((fp = fopen(fname, fmode)) != NULL) {

   392         return fp;

   393     }

   394 

   395     /*

   396      * It assumes read open.

   397      */

   398     RESTARTABLE(open(fname, O_RDONLY), fd);

   399     if (fd == -1) {

   400         return NULL;

   401     }

   402 

   403     /*

   404      * Allocate struct iobuffer and its buffer

   405      */

   406     iop = malloc(sizeof(struct iobuffer));

   407     if (iop == NULL) {

   408         (void) close(fd);

   409         errno = ENOMEM;

   410         return NULL;

   411     }

   412     iop->magic = -1;

   413     iop->fd = fd;

   414     iop->buffer = malloc(BUFFER_SIZE);

   415     if (iop->buffer == NULL) {

   416         (void) close(fd);

   417         free((void *) iop);

   418         errno = ENOMEM;

   419         return NULL;

   420     }

   421     iop->ptr = iop->buffer;

   422     iop->endptr = iop->buffer;

   423     return (FILE *)iop;

   424 }

   425 

   426 /*

   427  * This implementation assumes that n is large enough and the line

   428  * separator is '\n'.

   429  */

   430 static char *

   431 filegets(char *s, int n, FILE *stream)

   432 {

   433     struct iobuffer *iop = (struct iobuffer *) stream;

   434     char *p;

   435 

   436     if (iop->magic != -1) {

   437         return fgets(s, n, stream);

   438     }

   439 

   440     p = s;

   441     for (;;) {

   442         char c;

   443 

   444         if (iop->ptr == iop->endptr) {

   445             ssize_t len;

   446 

   447             RESTARTABLE(read(iop->fd, (void *)iop->buffer, BUFFER_SIZE), len);

   448             if (len == -1) {

   449                 return NULL;

   450             }

   451             if (len == 0) {

   452                 *p = 0;

   453                 if (s == p) {

   454                     return NULL;

   455                 }

   456                 return s;

   457             }

   458             iop->ptr = iop->buffer;

   459             iop->endptr = iop->buffer + len;

   460         }

   461         c = *iop->ptr++;

   462         *p++ = c;

   463         if ((p - s) == (n - 1)) {

   464             *p = 0;

   465             return s;

   466         }

   467         if (c == '\n') {

   468             *p = 0;

   469             return s;

   470         }

   471     }

   472     /*NOTREACHED*/

   473 }

   474 #endif /* !defined(__sparcv9) && !defined(amd64) */

   475 

   476 /*

   477  * Performs Solaris dependent mapping. Returns a zone ID if

   478  * found. Otherwise, NULL is returned.  Solaris libc looks up

   479  * "/etc/default/init" to get the default TZ value if TZ is not defined

   480  * as an environment variable.

   481  */

   482 static char *

   483 getPlatformTimeZoneID()

   484 {

   485     char *tz = NULL;

   486     FILE *fp;

   487 

   488     /*

   489      * Try the TZ entry in /etc/default/init.

   490      */

   491     if ((fp = fileopen(SYS_INIT_FILE, "r")) != NULL) {

   492         char line[256];

   493         char quote = '\0';

   494 

   495         while (filegets(line, sizeof(line), fp) != NULL) {

   496             char *p = line;

   497             char *s;

   498             char c;

   499 

   500             /* quick check for comment lines */

   501             if (*p == '#') {

   502                 continue;

   503             }

   504             if (strncmp(p, "TZ=", 3) == 0) {

   505                 p += 3;

   506                 SKIP_SPACE(p);

   507                 c = *p;

   508                 if (c == '"' || c == '\'') {

   509                     quote = c;

   510                     p++;

   511                 }

   512 

   513                 /*

   514                  * PSARC/2001/383: quoted string support

   515                  */

   516                 for (s = p; (c = *s) != '\0' && c != '\n'; s++) {

   517                     /* No '\\' is supported here. */

   518                     if (c == quote) {

   519                         quote = '\0';

   520                         break;

   521                     }

   522                     if (c == ' ' && quote == '\0') {

   523                         break;

   524                     }

   525                 }

   526                 if (quote != '\0') {

   527                     jio_fprintf(stderr, "ZoneInfo: unterminated time zone name in /etc/TIMEZONE\n");

   528                 }

   529                 *s = '\0';

   530                 tz = strdup(p);

   531                 break;

   532             }

   533         }

   534         (void) fileclose(fp);

   535     }

   536     return tz;

   537 }

   538 

   539 #define TIMEZONE_FMRI   "svc:/system/timezone:default"

   540 #define TIMEZONE_PG     "timezone"

   541 #define LOCALTIME_PROP  "localtime"

   542 

   543 static void

   544 cleanupScf(scf_handle_t *h,

   545            scf_snapshot_t *snap,

   546            scf_instance_t *inst,

   547            scf_propertygroup_t *pg,

   548            scf_property_t *prop,

   549            scf_value_t *val,

   550            char *buf) {

   551     if (buf != NULL) {

   552         free(buf);

   553     }

   554     if (snap != NULL) {

   555         scf_snapshot_destroy(snap);

   556     }

   557     if (val != NULL) {

   558         scf_value_destroy(val);

   559     }

   560     if (prop != NULL) {

   561         scf_property_destroy(prop);

   562     }

   563     if (pg != NULL) {

   564         scf_pg_destroy(pg);

   565     }

   566     if (inst != NULL) {

   567         scf_instance_destroy(inst);

   568     }

   569     if (h != NULL) {

   570         scf_handle_destroy(h);

   571     }

   572 }

   573 

   574 /*

   575  * Returns a zone ID of Solaris when the TZ value is "localtime".

   576  * First, it tries scf. If scf fails, it looks for the same file as

   577  * /usr/share/lib/zoneinfo/localtime under /usr/share/lib/zoneinfo/.

   578  */

   579 static char *

   580 getSolarisDefaultZoneID() {

   581     char *tz = NULL;

   582     struct stat statbuf;

   583     size_t size;

   584     char *buf;

   585     int fd;

   586     int res;

   587     /* scf specific variables */

   588     scf_handle_t *h = NULL;

   589     scf_snapshot_t *snap = NULL;

   590     scf_instance_t *inst = NULL;

   591     scf_propertygroup_t *pg = NULL;

   592     scf_property_t *prop = NULL;

   593     scf_value_t *val = NULL;

   594 

   595     if ((h = scf_handle_create(SCF_VERSION)) != NULL

   596         && scf_handle_bind(h) == 0

   597         && (inst = scf_instance_create(h)) != NULL

   598         && (snap = scf_snapshot_create(h)) != NULL

   599         && (pg = scf_pg_create(h)) != NULL

   600         && (prop = scf_property_create(h)) != NULL

   601         && (val = scf_value_create(h)) != NULL

   602         && scf_handle_decode_fmri(h, TIMEZONE_FMRI, NULL, NULL, inst,

   603                                   NULL, NULL, SCF_DECODE_FMRI_REQUIRE_INSTANCE) == 0

   604         && scf_instance_get_snapshot(inst, "running", snap) == 0

   605         && scf_instance_get_pg_composed(inst, snap, TIMEZONE_PG, pg) == 0

   606         && scf_pg_get_property(pg, LOCALTIME_PROP, prop) == 0

   607         && scf_property_get_value(prop, val) == 0) {

   608         ssize_t len;

   609 

   610         /* Gets the length of the zone ID string */

   611         len = scf_value_get_astring(val, NULL, 0);

   612         if (len != -1) {

   613             tz = malloc(++len); /* +1 for a null byte */

   614             if (tz != NULL && scf_value_get_astring(val, tz, len) != -1) {

   615                 cleanupScf(h, snap, inst, pg, prop, val, NULL);

   616                 return tz;

   617             }

   618         }

   619     }

   620     cleanupScf(h, snap, inst, pg, prop, val, tz);

   621 

   622     RESTARTABLE(stat(DEFAULT_ZONEINFO_FILE, &statbuf), res);

   623     if (res == -1) {

   624         return NULL;

   625     }

   626     size = (size_t) statbuf.st_size;

   627     buf = malloc(size);

   628     if (buf == NULL) {

   629         return NULL;

   630     }

   631     RESTARTABLE(open(DEFAULT_ZONEINFO_FILE, O_RDONLY), fd);

   632     if (fd == -1) {

   633         free((void *) buf);

   634         return NULL;

   635     }

   636 

   637     RESTARTABLE(read(fd, buf, size), res);

   638     if (res != (ssize_t) size) {

   639         (void) close(fd);

   640         free((void *) buf);

   641         return NULL;

   642     }

   643     (void) close(fd);

   644     tz = findZoneinfoFile(buf, size, ZONEINFO_DIR);

   645     free((void *) buf);

   646     return tz;

   647 }

   648 

   649 #endif /* defined(__solaris__) */

   650 

   651 #elif defined(_AIX)

   652 

   653 static char *

   654 getPlatformTimeZoneID()

   655 {

   656     FILE *fp;

   657     char *tz = NULL;

   658     char *tz_key = "TZ=";

   659     char line[256];

   660     size_t tz_key_len = strlen(tz_key);

   661 

   662     if ((fp = fopen(ETC_ENVIRONMENT_FILE, "r")) != NULL) {

   663         while (fgets(line, sizeof(line), fp) != NULL) {

   664             char *p = strchr(line, '\n');

   665             if (p != NULL) {

   666                 *p = '\0';

   667             }

   668             if (0 == strncmp(line, tz_key, tz_key_len)) {

   669                 tz = strdup(line + tz_key_len);

   670                 break;

   671             }

   672         }

   673         (void) fclose(fp);

   674     }

   675 

   676     return tz;

   677 }

   678 

   679 static char *

   680 mapPlatformToJavaTimezone(const char *java_home_dir, const char *tz) {

   681     FILE *tzmapf;

   682     char mapfilename[PATH_MAX + 1];

   683     char line[256];

   684     int linecount = 0;

   685     char *tz_buf = NULL;

   686     char *temp_tz = NULL;

   687     char *javatz = NULL;

   688     size_t tz_len = 0;

   689 

   690     /* On AIX, the TZ environment variable may end with a comma

   691      * followed by modifier fields. These are ignored here. */

   692     temp_tz = strchr(tz, ',');

   693     tz_len = (temp_tz == NULL) ? strlen(tz) : temp_tz - tz;

   694     tz_buf = (char *)malloc(tz_len + 1);

   695     memcpy(tz_buf, tz, tz_len);

   696     tz_buf[tz_len] = 0;

   697 

   698     /* Open tzmappings file, with buffer overrun check */

   699     if ((strlen(java_home_dir) + 15) > PATH_MAX) {

   700         jio_fprintf(stderr, "Path %s/lib/tzmappings exceeds maximum path length\n", java_home_dir);

   701         goto tzerr;

   702     }

   703     strcpy(mapfilename, java_home_dir);

   704     strcat(mapfilename, "/lib/tzmappings");

   705     if ((tzmapf = fopen(mapfilename, "r")) == NULL) {

   706         jio_fprintf(stderr, "can't open %s\n", mapfilename);

   707         goto tzerr;

   708     }

   709 

   710     while (fgets(line, sizeof(line), tzmapf) != NULL) {

   711         char *p = line;

   712         char *sol = line;

   713         char *java;

   714         int result;

   715 

   716         linecount++;

   717         /*

   718          * Skip comments and blank lines

   719          */

   720         if (*p == '#' || *p == '\n') {

   721             continue;

   722         }

   723 

   724         /*

   725          * Get the first field, platform zone ID

   726          */

   727         while (*p != '\0' && *p != '\t') {

   728             p++;

   729         }

   730         if (*p == '\0') {

   731             /* mapping table is broken! */

   732             jio_fprintf(stderr, "tzmappings: Illegal format at near line %d.\n", linecount);

   733             break;

   734         }

   735 

   736         *p++ = '\0';

   737         if ((result = strncmp(tz_buf, sol, tz_len)) == 0) {

   738             /*

   739              * If this is the current platform zone ID,

   740              * take the Java time zone ID (2nd field).

   741              */

   742             java = p;

   743             while (*p != '\0' && *p != '\n') {

   744                 p++;

   745             }

   746 

   747             if (*p == '\0') {

   748                 /* mapping table is broken! */

   749                 jio_fprintf(stderr, "tzmappings: Illegal format at line %d.\n", linecount);

   750                 break;

   751             }

   752 

   753             *p = '\0';

   754             javatz = strdup(java);

   755             break;

   756         } else if (result < 0) {

   757             break;

   758         }

   759     }

   760     (void) fclose(tzmapf);

   761 

   762 tzerr:

   763     if (tz_buf != NULL ) {

   764         free((void *) tz_buf);

   765     }

   766 

   767     if (javatz == NULL) {

   768         return getGMTOffsetID();

   769     }

   770 

   771     return javatz;

   772 }

   773 

   774 #endif /* defined(_AIX) */

   775 

   776 /*

   777  * findJavaTZ_md() maps platform time zone ID to Java time zone ID

   778  * using <java_home>/lib/tzmappings. If the TZ value is not found, it

   779  * trys some libc implementation dependent mappings. If it still

   780  * can't map to a Java time zone ID, it falls back to the GMT+/-hh:mm

   781  * form.

   782  */

   783 /*ARGSUSED1*/

   784 char *

   785 findJavaTZ_md(const char *java_home_dir)

   786 {

   787     char *tz;

   788     char *javatz = NULL;

   789     char *freetz = NULL;

   790 

   791     tz = getenv("TZ");

   792 

   793     if (tz == NULL || *tz == '\0') {

   794         tz = getPlatformTimeZoneID();

   795         freetz = tz;

   796     }

   797 

   798     if (tz != NULL) {

   799         /* Ignore preceding ':' */

   800         if (*tz == ':') {

   801             tz++;

   802         }

   803 #if defined(__linux__)

   804         /* Ignore "posix/" prefix on Linux. */

   805         if (strncmp(tz, "posix/", 6) == 0) {

   806             tz += 6;

   807         }

   808 #endif

   809 

   810 #if defined(_AIX)

   811         /* On AIX do the platform to Java mapping. */

   812         javatz = mapPlatformToJavaTimezone(java_home_dir, tz);

   813         if (freetz != NULL) {

   814             free((void *) freetz);

   815         }

   816 #else

   817 #if defined(__solaris__)

   818         /* Solaris might use localtime, so handle it here. */

   819         if (strcmp(tz, "localtime") == 0) {

   820             javatz = getSolarisDefaultZoneID();

   821             if (freetz != NULL) {

   822                 free((void *) freetz);

   823             }

   824         } else

   825 #endif

   826         if (freetz == NULL) {

   827             /* strdup if we are still working on getenv result. */

   828             javatz = strdup(tz);

   829         } else if (freetz != tz) {

   830             /* strdup and free the old buffer, if we moved the pointer. */

   831             javatz = strdup(tz);

   832             free((void *) freetz);

   833         } else {

   834             /* we are good if we already work on a freshly allocated buffer. */

   835             javatz = tz;

   836         }

   837 #endif

   838     }

   839 

   840     return javatz;

   841 }

   842 

   843 /**

   844  * Returns a GMT-offset-based zone ID. (e.g., "GMT-08:00")

   845  */

   846 

   847 #if defined(MACOSX)

   848 

   849 char *

   850 getGMTOffsetID()

   851 {

   852     time_t offset;

   853     char sign, buf[32];

   854     struct tm local_tm;

   855     time_t clock;

   856 

   857     clock = time(NULL);

   858     if (localtime_r(&clock, &local_tm) == NULL) {

   859         return strdup("GMT");

   860     }

   861     offset = (time_t)local_tm.tm_gmtoff;

   862     if (offset == 0) {

   863         return strdup("GMT");

   864     }

   865     if (offset > 0) {

   866         sign = '+';

   867     } else {

   868         offset = -offset;

   869         sign = '-';

   870     }

   871     sprintf(buf, (const char *)"GMT%c%02d:%02d",

   872             sign, (int)(offset/3600), (int)((offset%3600)/60));

   873     return strdup(buf);

   874 }

   875 

   876 #else

   877 

   878 char *

   879 getGMTOffsetID()

   880 {

   881     time_t offset;

   882     char sign, buf[32];

   883 #if defined(__solaris__)

   884     struct tm localtm;

   885     time_t currenttime;

   886 

   887     currenttime = time(NULL);

   888     if (localtime_r(&currenttime, &localtm) == NULL) {

   889         return strdup("GMT");

   890     }

   891 

   892     offset = localtm.tm_isdst ? altzone : timezone;

   893 #else

   894     offset = timezone;

   895 #endif

   896 

   897     if (offset == 0) {

   898         return strdup("GMT");

   899     }

   900 

   901     /* Note that the time offset direction is opposite. */

   902     if (offset > 0) {

   903         sign = '-';

   904     } else {

   905         offset = -offset;

   906         sign = '+';

   907     }

   908     sprintf(buf, (const char *)"GMT%c%02d:%02d",

   909             sign, (int)(offset/3600), (int)((offset%3600)/60));

   910     return strdup(buf);

   911 }

   912 #endif /* MACOSX */