grim/purple-plugin-pack
/************************************************************************* * copied from the Olson Timezone code, licence unchanged. * by Martijn van Oosterhout <kleptog@svana.org> April 2006 * Original Licence below (public domain). * This code has been copied from the Olson Timezone code, but heavily * adapted to meet my needs. In particular, you can load multiple timezones * and specify which timezone to convert with. *************************************************************************/ ** This file is in the public domain, so clarified as of ** 1996-06-05 by Arthur David Olson. #define TM_GMTOFF tm_gmtoff ** Leap second handling from Bradley White. ** POSIX-style TZ environment variable handling from Guy Harris. #include "float.h" /* for FLT_MAX and DBL_MAX */ #define TZ_ABBR_MAX_LEN 16 #endif /* !defined TZ_ABBR_MAX_LEN */ #define TZ_ABBR_CHAR_SET \ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._" #endif /* !defined TZ_ABBR_CHAR_SET */ #define TZ_ABBR_ERR_CHAR '_' #endif /* !defined TZ_ABBR_ERR_CHAR */ ** SunOS 4.1.1 headers lack O_BINARY. #define OPEN_MODE (O_RDONLY | O_BINARY) #endif /* defined O_BINARY */ #define OPEN_MODE O_RDONLY #endif /* !defined O_BINARY */ ** Someone might make incorrect use of a time zone abbreviation: ** 1. They might reference tzname[0] before calling tzset (explicitly ** 2. They might reference tzname[1] before calling tzset (explicitly ** 3. They might reference tzname[1] after setting to a time zone ** in which Daylight Saving Time is never observed. ** 4. They might reference tzname[0] after setting to a time zone ** in which Standard Time is never observed. ** 5. They might reference tm.TM_ZONE after calling offtime. ** What's best to do in the above cases is open to debate; ** for now, we just set things up so that in any of the five cases ** WILDABBR is used. Another possibility: initialize tzname[0] to the ** string "tzname[0] used before set", and similarly for the other cases. ** And another: initialize tzname[0] to "ERA", with an explanation in the ** manual page of what this "time zone abbreviation" means (doing this so ** that tzname[0] has the "normal" length of three characters). #endif /* !defined WILDABBR */ static char wildabbr[] = WILDABBR; static const char gmt[] = "GMT"; ** The DST rules to use if TZ has no rules and we can't load TZDEFRULES. ** We default to US rules as of 1999-08-17. ** POSIX 1003.1 section 8.1.1 says that the default DST rules are ** implementation dependent; for historical reasons, US rules are a #define TZDEFRULESTRING ",M4.1.0,M10.5.0" #endif /* !defined TZDEFDST */ struct ttinfo { /* time type information */ long tt_gmtoff; /* UTC offset in seconds */ int tt_isdst; /* used to set tm_isdst */ int tt_abbrind; /* abbreviation list index */ int tt_ttisstd; /* TRUE if transition is std time */ int tt_ttisgmt; /* TRUE if transition is UTC */ struct lsinfo { /* leap second information */ time_t ls_trans; /* transition time */ long ls_corr; /* correction to apply */ #define BIGGEST(a, b) (((a) > (b)) ? (a) : (b)) #define MY_TZNAME_MAX TZNAME_MAX #endif /* defined TZNAME_MAX */ #define MY_TZNAME_MAX 255 #endif /* !defined TZNAME_MAX */ time_t ats[TZ_MAX_TIMES]; unsigned char types[TZ_MAX_TIMES]; struct ttinfo ttis[TZ_MAX_TYPES]; char chars[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt), (2 * (MY_TZNAME_MAX + 1)))]; struct lsinfo lsis[TZ_MAX_LEAPS]; int r_type; /* type of rule--see below */ int r_day; /* day number of rule */ int r_week; /* week number of rule */ int r_mon; /* month number of rule */ long r_time; /* transition time of rule */ #define JULIAN_DAY 0 /* Jn - Julian day */ #define DAY_OF_YEAR 1 /* n - day of year */ #define MONTH_NTH_DAY_OF_WEEK 2 /* Mm.n.d - month, week, day of week */ ** Prototypes for static functions. static long detzcode P((const char * codep)); static const char * getzname P((const char * strp)); static const char * getqzname P((const char * strp, const char delim)); static const char * getnum P((const char * strp, int * nump, int min, static const char * getsecs P((const char * strp, long * secsp)); static const char * getoffset P((const char * strp, long * offsetp)); static const char * getrule P((const char * strp, struct rule * rulep)); static void gmtload P((struct state * sp)); struct tm * gmtsub P((const time_t * timep, long offset, struct tm * localsub P((const time_t * timep, long offset, struct tm * tmp, struct state *sp)); static int increment_overflow P((int * number, int delta)); static int leaps_thru_end_of P((int y)); static struct tm * timesub P((const time_t * timep, long offset, const struct state * sp, struct tm * tmp)); static time_t transtime P((time_t janfirst, int year, const struct rule * rulep, long offset)); static int tzload P((const char * name, struct state * sp)); static int tzparse P((const char * name, struct state * sp, struct state *timezone_load P((const char * name)); static struct state * gmtptr; #endif /* defined ALL_STATE */ static struct state gmtmem; #define TZ_STRLEN_MAX 255 #endif /* !defined TZ_STRLEN_MAX */ //static char lcl_TZname[TZ_STRLEN_MAX + 1]; ** Section 4.12.3 of X3.159-1989 requires that ** Except for the strftime function, these functions [asctime, ** ctime, gmtime, localtime] return values in one of two static ** objects: a broken-down time structure and an array of char. ** Thanks to Paul Eggert for noting this. #endif /* defined USG_COMPAT */ #endif /* defined ALTZONE */ const char * const codep; result = (codep[0] & 0x80) ? ~0L : 0L; result = (result << 8) | (codep[i] & 0xff); register const char * name; register struct state * const sp; if (name == NULL && (name = TZDEFAULT) == NULL) ** Section 4.9.1 of the C standard says that ** "FILENAME_MAX expands to an integral constant expression ** that is the size needed for an array of char large enough ** to hold the longest file name string that the implementation ** guarantees can be opened." char fullname[FILENAME_MAX + 1]; doaccess = name[0] == '/'; if ((strlen(p) + strlen(name) + 1) >= sizeof fullname) (void) strcpy(fullname, p); (void) strcat(fullname, "/"); (void) strcat(fullname, name); ** Set doaccess if '.' (as in "../") shows up in name. if (strchr(name, '.') != NULL) if (doaccess && access(name, R_OK) != 0) if ((fid = open(name, OPEN_MODE)) == -1) char buf[sizeof *sp + sizeof *tzhp]; i = read(fid, u.buf, sizeof u.buf); ttisstdcnt = (int) detzcode(u.tzhead.tzh_ttisstdcnt); ttisgmtcnt = (int) detzcode(u.tzhead.tzh_ttisgmtcnt); sp->leapcnt = (int) detzcode(u.tzhead.tzh_leapcnt); sp->timecnt = (int) detzcode(u.tzhead.tzh_timecnt); sp->typecnt = (int) detzcode(u.tzhead.tzh_typecnt); sp->charcnt = (int) detzcode(u.tzhead.tzh_charcnt); p = u.tzhead.tzh_charcnt + sizeof u.tzhead.tzh_charcnt; if (sp->leapcnt < 0 || sp->leapcnt > TZ_MAX_LEAPS || sp->typecnt <= 0 || sp->typecnt > TZ_MAX_TYPES || sp->timecnt < 0 || sp->timecnt > TZ_MAX_TIMES || sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS || (ttisstdcnt != sp->typecnt && ttisstdcnt != 0) || (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0)) if (i - (p - u.buf) < sp->timecnt * 4 + /* ats */ sp->timecnt + /* types */ sp->typecnt * (4 + 2) + /* ttinfos */ sp->charcnt + /* chars */ sp->leapcnt * (4 + 4) + /* lsinfos */ ttisstdcnt + /* ttisstds */ ttisgmtcnt) /* ttisgmts */ for (i = 0; i < sp->timecnt; ++i) { sp->ats[i] = detzcode(p); for (i = 0; i < sp->timecnt; ++i) { sp->types[i] = (unsigned char) *p++; if (sp->types[i] >= sp->typecnt) for (i = 0; i < sp->typecnt; ++i) { register struct ttinfo * ttisp; ttisp->tt_gmtoff = detzcode(p); ttisp->tt_isdst = (unsigned char) *p++; if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1) ttisp->tt_abbrind = (unsigned char) *p++; if (ttisp->tt_abbrind < 0 || ttisp->tt_abbrind > sp->charcnt) for (i = 0; i < sp->charcnt; ++i) sp->chars[i] = '\0'; /* ensure '\0' at end */ for (i = 0; i < sp->leapcnt; ++i) { register struct lsinfo * lsisp; lsisp->ls_trans = detzcode(p); lsisp->ls_corr = detzcode(p); for (i = 0; i < sp->typecnt; ++i) { register struct ttinfo * ttisp; ttisp->tt_ttisstd = FALSE; ttisp->tt_ttisstd = *p++; if (ttisp->tt_ttisstd != TRUE && ttisp->tt_ttisstd != FALSE) for (i = 0; i < sp->typecnt; ++i) { register struct ttinfo * ttisp; ttisp->tt_ttisgmt = FALSE; ttisp->tt_ttisgmt = *p++; if (ttisp->tt_ttisgmt != TRUE && ttisp->tt_ttisgmt != FALSE) ** Out-of-sort ats should mean we're running on a ** signed time_t system but using a data file with ** unsigned values (or vice versa). for (i = 0; i < sp->timecnt - 2; ++i) if (sp->ats[i] > sp->ats[i + 1]) { if (TYPE_SIGNED(time_t)) { ** Ignore the end (easy). ** Ignore the beginning (harder). for (j = 0; j + i < sp->timecnt; ++j) { sp->ats[j] = sp->ats[j + i]; sp->types[j] = sp->types[j + i]; struct state *timezone_load(name) struct state *sp = malloc( sizeof(struct state) ); res = tzload( name, sp ); static const int mon_lengths[2][MONSPERYEAR] = { { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } static const int year_lengths[2] = { DAYSPERNYEAR, DAYSPERLYEAR ** Given a pointer into a time zone string, scan until a character that is not ** a valid character in a zone name is found. Return a pointer to that register const char * strp; while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' && ** Given a pointer into an extended time zone string, scan until the ending ** delimiter of the zone name is located. Return a pointer to the delimiter. ** As with getzname above, the legal character set is actually quite ** restricted, with other characters producing undefined results. ** We choose not to care - allowing almost anything to be in the zone abbrev. getqzname(register const char *strp, const char delim) register const char * strp; while ((c = *strp) != '\0' && c != delim) ** Given a pointer into a time zone string, extract a number from that string. ** Check that the number is within a specified range; if it is not, return ** Otherwise, return a pointer to the first character not part of the number. getnum(strp, nump, min, max) register const char * strp; if (strp == NULL || !is_digit(c = *strp)) num = num * 10 + (c - '0'); return NULL; /* illegal value */ return NULL; /* illegal value */ ** Given a pointer into a time zone string, extract a number of seconds, ** in hh[:mm[:ss]] form, from the string. ** If any error occurs, return NULL. ** Otherwise, return a pointer to the first character not part of the number register const char * strp; ** `HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like ** "M10.4.6/26", which does not conform to Posix, ** but which specifies the equivalent of ** ``02:00 on the first Sunday on or after 23 Oct''. strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1); *secsp = num * (long) SECSPERHOUR; strp = getnum(strp, &num, 0, MINSPERHOUR - 1); *secsp += num * SECSPERMIN; /* `SECSPERMIN' allows for leap seconds. */ strp = getnum(strp, &num, 0, SECSPERMIN); ** Given a pointer into a time zone string, extract an offset, in ** [+-]hh[:mm[:ss]] form, from the string. ** If any error occurs, return NULL. ** Otherwise, return a pointer to the first character not part of the time. register const char * strp; strp = getsecs(strp, offsetp); return NULL; /* illegal time */ ** Given a pointer into a time zone string, extract a rule in the form ** date[/time]. See POSIX section 8 for the format of "date" and "time". ** If a valid rule is not found, return NULL. ** Otherwise, return a pointer to the first character not part of the rule. register struct rule * const rulep; rulep->r_type = JULIAN_DAY; strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR); } else if (*strp == 'M') { rulep->r_type = MONTH_NTH_DAY_OF_WEEK; strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR); strp = getnum(strp, &rulep->r_week, 1, 5); strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1); } else if (is_digit(*strp)) { rulep->r_type = DAY_OF_YEAR; strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1); } else return NULL; /* invalid format */ strp = getsecs(strp, &rulep->r_time); } else rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */ ** Given the Epoch-relative time of January 1, 00:00:00 UTC, in a year, the ** year, a rule, and the offset from UTC at the time that rule takes effect, ** calculate the Epoch-relative time that rule takes effect. transtime(janfirst, year, rulep, offset) register const struct rule * const rulep; int d, m1, yy0, yy1, yy2, dow; ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap ** In non-leap years, or if the day number is 59 or less, just ** add SECSPERDAY times the day number-1 to the time of ** January 1, midnight, to get the day. value = janfirst + (rulep->r_day - 1) * SECSPERDAY; if (leapyear && rulep->r_day >= 60) ** Just add SECSPERDAY times the day number to the time of ** January 1, midnight, to get the day. value = janfirst + rulep->r_day * SECSPERDAY; case MONTH_NTH_DAY_OF_WEEK: ** Mm.n.d - nth "dth day" of month m. for (i = 0; i < rulep->r_mon - 1; ++i) value += mon_lengths[leapyear][i] * SECSPERDAY; ** Use Zeller's Congruence to get day-of-week of first day of m1 = (rulep->r_mon + 9) % 12 + 1; yy0 = (rulep->r_mon <= 2) ? (year - 1) : year; dow = ((26 * m1 - 2) / 10 + 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7; ** "dow" is the day-of-week of the first day of the month. Get ** the day-of-month (zero-origin) of the first "dow" day of the for (i = 1; i < rulep->r_week; ++i) { mon_lengths[leapyear][rulep->r_mon - 1]) ** "d" is the day-of-month (zero-origin) of the day we want. ** "value" is the Epoch-relative time of 00:00:00 UTC on the day in ** question. To get the Epoch-relative time of the specified local ** time on that day, add the transition time and the current offset return value + rulep->r_time + offset; ** Given a POSIX section 8-style TZ string, fill in the rule tables as tzparse(name, sp, lastditch) register struct state * const sp; register unsigned char * typep; register int load_result; stdlen = strlen(name); /* length of standard zone name */ if (stdlen >= sizeof sp->chars) stdlen = (sizeof sp->chars) - 1; name = getqzname(name, '>'); name = getoffset(name, &stdoffset); load_result = tzload(TZDEFRULES, sp); sp->leapcnt = 0; /* so, we're off a little */ name = getqzname(name, '>'); dstlen = name - dstname; /* length of DST zone name */ if (*name != '\0' && *name != ',' && *name != ';') { name = getoffset(name, &dstoffset); } else dstoffset = stdoffset - SECSPERHOUR; if (*name == '\0' && load_result != 0) if (*name == ',' || *name == ';') { register time_t janfirst; if ((name = getrule(name, &start)) == NULL) if ((name = getrule(name, &end)) == NULL) sp->typecnt = 2; /* standard time and DST */ ** Two transitions per year, from EPOCH_YEAR to 2037. sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1); if (sp->timecnt > TZ_MAX_TIMES) sp->ttis[0].tt_gmtoff = -dstoffset; sp->ttis[0].tt_isdst = 1; sp->ttis[0].tt_abbrind = stdlen + 1; sp->ttis[1].tt_gmtoff = -stdoffset; sp->ttis[1].tt_isdst = 0; sp->ttis[1].tt_abbrind = 0; for (year = EPOCH_YEAR; year <= 2037; ++year) { starttime = transtime(janfirst, year, &start, endtime = transtime(janfirst, year, &end, if (starttime > endtime) { *typep++ = 1; /* DST ends */ *typep++ = 0; /* DST begins */ *typep++ = 0; /* DST begins */ *typep++ = 1; /* DST ends */ janfirst += year_lengths[isleap(year)] * register long theirstdoffset; register long theirdstoffset; register long theiroffset; ** Initial values of theirstdoffset and theirdstoffset. for (i = 0; i < sp->timecnt; ++i) { if (!sp->ttis[j].tt_isdst) { for (i = 0; i < sp->timecnt; ++i) { if (sp->ttis[j].tt_isdst) { ** Initially we're assumed to be in standard time. theiroffset = theirstdoffset; ** Now juggle transition times and types ** tracking offsets as you do. for (i = 0; i < sp->timecnt; ++i) { sp->types[i] = sp->ttis[j].tt_isdst; if (sp->ttis[j].tt_ttisgmt) { /* No adjustment to transition time */ ** If summer time is in effect, and the ** transition time was not specified as ** standard time, add the summer time ** offset to the transition time; ** otherwise, add the standard time ** offset to the transition time. ** Transitions from DST to DDST ** will effectively disappear since ** POSIX provides for only one DST if (isdst && !sp->ttis[j].tt_ttisstd) { sp->ats[i] += dstoffset - sp->ats[i] += stdoffset - theiroffset = -sp->ttis[j].tt_gmtoff; if (sp->ttis[j].tt_isdst) theirdstoffset = theiroffset; else theirstdoffset = theiroffset; ** Finally, fill in ttis. ** ttisstd and ttisgmt need not be handled. sp->ttis[0].tt_gmtoff = -stdoffset; sp->ttis[0].tt_isdst = FALSE; sp->ttis[0].tt_abbrind = 0; sp->ttis[1].tt_gmtoff = -dstoffset; sp->ttis[1].tt_isdst = TRUE; sp->ttis[1].tt_abbrind = stdlen + 1; sp->typecnt = 1; /* only standard time */ sp->ttis[0].tt_gmtoff = -stdoffset; sp->ttis[0].tt_isdst = 0; sp->ttis[0].tt_abbrind = 0; sp->charcnt = stdlen + 1; sp->charcnt += dstlen + 1; if ((size_t) sp->charcnt > sizeof sp->chars) (void) strncpy(cp, stdname, stdlen); (void) strncpy(cp, dstname, dstlen); if (tzload(gmt, sp) != 0) (void) tzparse(gmt, sp, TRUE); ** The easy way to behave "as if no library function calls" localtime ** is to not call it--so we drop its guts into "localsub", which can be ** freely called. (And no, the PANS doesn't require the above behavior-- ** but it *is* desirable.) ** The unused offset argument is for the benefit of mktime variants. localsub(timep, offset, tmp, sp) const time_t * const timep; register const struct ttinfo * ttisp; register struct tm * result; return gmtsub(timep, offset, tmp); #endif /* defined ALL_STATE */ if (sp->timecnt == 0 || t < sp->ats[0]) { while (sp->ttis[i].tt_isdst) if (++i >= sp->typecnt) { for (i = 1; i < sp->timecnt; ++i) i = (int) sp->types[i - 1]; ** To get (wrong) behavior that's compatible with System V Release 2.0 ** you'd replace the statement below with ** t += ttisp->tt_gmtoff; ** timesub(&t, 0L, sp, tmp); result = timesub(&t, ttisp->tt_gmtoff, sp, tmp); tmp->tm_isdst = ttisp->tt_isdst; tzname[tmp->tm_isdst] = &sp->chars[ttisp->tt_abbrind]; tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind]; #endif /* defined TM_ZONE */ ** gmtsub is to gmtime as localsub is to localtime. gmtsub(timep, offset, tmp) const time_t * const timep; register struct tm * result; gmtptr = (struct state *) malloc(sizeof *gmtptr); #endif /* defined ALL_STATE */ result = timesub(timep, offset, gmtptr, tmp); ** Could get fancy here and deliver something such as ** "UTC+xxxx" or "UTC-xxxx" if offset is non-zero, ** but this is no time for a treasure hunt. else tmp->TM_ZONE = gmtptr->chars; #endif /* defined ALL_STATE */ tmp->TM_ZONE = gmtptr->chars; #endif /* defined TM_ZONE */ ** Return the number of leap years through the end of the given year ** where, to make the math easy, the answer for year zero is defined as zero. return (y >= 0) ? (y / 4 - y / 100 + y / 400) : -(leaps_thru_end_of(-(y + 1)) + 1); timesub(timep, offset, sp, tmp) const time_t * const timep; register const struct state * const sp; register struct tm * const tmp; register const struct lsinfo * lp; register int idays; /* unsigned would be so 2003 */ i = (sp == NULL) ? 0 : sp->leapcnt; #endif /* defined ALL_STATE */ if (*timep >= lp->ls_trans) { if (*timep == lp->ls_trans) { hit = ((i == 0 && lp->ls_corr > 0) || lp->ls_corr > sp->lsis[i - 1].ls_corr); sp->lsis[i - 1].ls_trans + 1 && sp->lsis[i - 1].ls_corr + 1) { tdays = *timep / SECSPERDAY; rem = *timep - tdays * SECSPERDAY; while (tdays < 0 || tdays >= year_lengths[isleap(y)]) { tdelta = tdays / DAYSPERLYEAR; if (tdelta - idelta >= 1 || idelta - tdelta >= 1) idelta = (tdays < 0) ? -1 : 1; if (increment_overflow(&newy, idelta)) leapdays = leaps_thru_end_of(newy - 1) - leaps_thru_end_of(y - 1); tdays -= ((time_t) newy - y) * DAYSPERNYEAR; seconds = tdays * SECSPERDAY + 0.5; tdays = seconds / SECSPERDAY; rem += seconds - tdays * SECSPERDAY; ** Given the range, we can now fearlessly cast... while (rem >= SECSPERDAY) { if (increment_overflow(&y, -1)) idays += year_lengths[isleap(y)]; while (idays >= year_lengths[isleap(y)]) { idays -= year_lengths[isleap(y)]; if (increment_overflow(&y, 1)) if (increment_overflow(&tmp->tm_year, -TM_YEAR_BASE)) ** The "extra" mods below avoid overflow problems. tmp->tm_wday = EPOCH_WDAY + ((y - EPOCH_YEAR) % DAYSPERWEEK) * (DAYSPERNYEAR % DAYSPERWEEK) + leaps_thru_end_of(y - 1) - leaps_thru_end_of(EPOCH_YEAR - 1) + tmp->tm_wday %= DAYSPERWEEK; tmp->tm_wday += DAYSPERWEEK; tmp->tm_hour = (int) (rem / SECSPERHOUR); tmp->tm_min = (int) (rem / SECSPERMIN); ** A positive leap second requires a special ** representation. This uses "... ??:59:60" et seq. tmp->tm_sec = (int) (rem % SECSPERMIN) + hit; ip = mon_lengths[isleap(y)]; for (tmp->tm_mon = 0; idays >= ip[tmp->tm_mon]; ++(tmp->tm_mon)) idays -= ip[tmp->tm_mon]; tmp->tm_mday = (int) (idays + 1); #endif /* defined TM_GMTOFF */ ** Adapted from code provided by Robert Elz, who writes: ** The "best" way to do mktime I think is based on an idea of Bob ** Kridle's (so its said...) from a long time ago. ** It does a binary search of the time_t space. Since time_t's are ** just 32 bits, its a max of 32 iterations (even at 64 bits it ** would still be very reasonable). #endif /* !defined WRONG */ ** Simplified normalize logic courtesy Paul Eggert. increment_overflow(number, delta) return (*number < number0) != (delta < 0); int tz_init( const char *zoneinfo_dir ) if( zoneinfo_dir == NULL ) ptr = malloc( strlen(zoneinfo_dir) + 10 ); sprintf( ptr, "%s/zone.tab", zoneinfo_dir ); fd = open( ptr, O_RDONLY ); tzdir = strdup(zoneinfo_dir);