开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
ctime.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：34k
源码类别：

MySQL数据库

开发平台：

Visual C++

ctime.c：源码内容
  1. /*
  2.  * Copyright (c) 1987, 1989 Regents of the University of California.
  3.  * Copyright (c) 1994 Chris Provenzano, proven@mit.edu
  4.  * All rights reserved.
  5.  *
  6.  * This code is derived from software contributed to Berkeley by
  7.  * Arthur David Olson of the National Cancer Institute.
  8.  *
  9.  * Redistribution and use in source and binary forms, with or without
  10.  * modification, are permitted provided that the following conditions
  11.  * are met:
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer.
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in the
  16.  *    documentation and/or other materials provided with the distribution.
  17.  * 3. All advertising materials mentioning features or use of this software
  18.  *    must display the following acknowledgement:
  19.  * This product includes software developed by the University of
  20.  * California, Berkeley and its contributors.
  21.  * 4. Neither the name of the University nor the names of its contributors
  22.  *    may be used to endorse or promote products derived from this software
  23.  *    without specific prior written permission.
  24.  *
  25.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35.  * SUCH DAMAGE.
  36.  */
  38. #if defined(LIBC_SCCS) && !defined(lint)
  39. static char sccsid[] = "@(#)ctime.c 5.26 (Berkeley) 2/23/91";
  40. #endif /* LIBC_SCCS and not lint */
  42. /*
  43. ** Leap second handling from Bradley White (bww@k.gp.cs.cmu.edu).
  44. ** POSIX-style TZ environment variable handling from Guy Harris
  45. ** (guy@auspex.com).
  46. */
  48. /*LINTLIBRARY*/
  49. #include "config.h"
  50. #include <pthread.h>
  51. #include <sys/param.h>
  52. #include <fcntl.h>
  53. #include <time.h>
  54. #include <tzfile.h>
  55. #include <string.h>
  56. #include <ctype.h>
  57. #include <stdio.h>
  58. #include <unistd.h>
  59. #include <stdlib.h>
  61. #ifndef WILDABBR
  62. /*
  63. ** Someone might make incorrect use of a time zone abbreviation:
  64. ** 1. They might reference tzname[0] before calling tzset (explicitly
  65. **   or implicitly).
  66. ** 2. They might reference tzname[1] before calling tzset (explicitly
  67. **   or implicitly).
  68. ** 3. They might reference tzname[1] after setting to a time zone
  69. ** in which Daylight Saving Time is never observed.
  70. ** 4. They might reference tzname[0] after setting to a time zone
  71. ** in which Standard Time is never observed.
  72. ** 5. They might reference tm.TM_ZONE after calling offtime.
  73. ** What's best to do in the above cases is open to debate;
  74. ** for now, we just set things up so that in any of the five cases
  75. ** WILDABBR is used.  Another possibility:  initialize tzname[0] to the
  76. ** string "tzname[0] used before set", and similarly for the other cases.
  77. ** And another:  initialize tzname[0] to "ERA", with an explanation in the
  78. ** manual page of what this "time zone abbreviation" means (doing this so
  79. ** that tzname[0] has the "normal" length of three characters).
  80. */
  81. #define WILDABBR "   "
  82. #endif /* !defined WILDABBR */
  84. #ifndef TRUE
  85. #define TRUE 1
  86. #define FALSE 0
  87. #endif /* !defined TRUE */
  89. static const char GMT[] = "GMT";
  91. struct ttinfo { /* time type information */
  92. long tt_gmtoff; /* GMT offset in seconds */
  93. int tt_isdst; /* used to set tm_isdst */
  94. int tt_abbrind; /* abbreviation list index */
  95. int tt_ttisstd; /* TRUE if transition is std time */
  96. };
  98. struct lsinfo { /* leap second information */
  99. time_t ls_trans; /* transition time */
  100. long ls_corr; /* correction to apply */
  101. };
  103. struct state {
  104. int leapcnt;
  105. int timecnt;
  106. int typecnt;
  107. int charcnt;
  108. time_t ats[TZ_MAX_TIMES];
  109. unsigned char types[TZ_MAX_TIMES];
  110. struct ttinfo ttis[TZ_MAX_TYPES];
  111. char chars[(TZ_MAX_CHARS + 1 > sizeof GMT) ?
  112. TZ_MAX_CHARS + 1 : sizeof GMT];
  113. struct lsinfo lsis[TZ_MAX_LEAPS];
  114. };
  116. struct rule {
  117. int r_type; /* type of rule--see below */
  118. int r_day; /* day number of rule */
  119. int r_week; /* week number of rule */
  120. int r_mon; /* month number of rule */
  121. long r_time; /* transition time of rule */
  122. };
  124. #define JULIAN_DAY 0 /* Jn - Julian day */
  125. #define DAY_OF_YEAR 1 /* n - day of year */
  126. #define MONTH_NTH_DAY_OF_WEEK 2 /* Mm.n.d - month, week, day of week */
  128. /*
  129. ** Prototypes for static functions.
  130. */
  132. static int detzcode __P_((const char *));
  133. static const char * getnum __P_((const char *, int *, int, int));
  134. static const char * getsecs __P_((const char *, long *));
  135. static const char * getoffset __P_((const char *, long *));
  136. static const char * getrule __P_((const char *, struct rule *));
  137. static const char * getzname __P_((const char *));
  138. static void gmtload __P_((struct state *));
  139. static void gmtsub __P_((const time_t *, long, struct tm *));
  140. static void localsub __P_((const time_t *, long, struct tm *));
  141. static void normalize __P_((int *, int *, int));
  142. static void settzname __P_((struct state *));
  143. static time_t time1 __P_((struct tm *, long));
  144. static time_t time2 __P_((struct tm *, long, int *));
  145. static void timesub __P_((const time_t *, long, const struct state *,
  146. struct tm *));
  147. static int tmcomp __P_((const struct tm *, const struct tm *));
  148. static time_t transtime __P_((time_t, int, const struct rule *, long));
  149. static int tzload __P_((const char *, struct state *));
  150. static int tzparse __P_((const char *, struct state *, int));
  151. static void tzset_basic __P_((void));
  152. static void tzsetwall_basic __P_((void));
  154. static pthread_mutex_t lcl_mutex  = PTHREAD_MUTEX_INITIALIZER;
  155. static pthread_mutex_t gmt_mutex  = PTHREAD_MUTEX_INITIALIZER;
  156. static int  lcl_is_set  = FALSE;
  157. static int  gmt_is_set  = FALSE;
  158. static struct state lclmem;
  159. static struct state gmtmem;
  161. #define lclptr (&lclmem)
  162. #define gmtptr (&gmtmem)
  164. char * tzname[2] = {
  165. WILDABBR,
  166. WILDABBR
  167. };
  169. #ifdef USG_COMPAT
  170. time_t timezone = 0;
  171. int daylight = 0;
  172. #endif /* defined USG_COMPAT */
  174. #ifdef ALTZONE
  175. time_t altzone = 0;
  176. #endif /* defined ALTZONE */
  178. static int detzcode(const char * codep)
  179. {
  180. long result;
  181. int i;
  183. result = 0;
  184. for (i = 0; i < 4; ++i)
  185. result = (result << 8) | (codep[i] & 0xff);
  186. return result;
  187. }
  189. static void settzname(struct state * sp)
  190. {
  191. register int i;
  193. tzname[0] = WILDABBR;
  194. tzname[1] = WILDABBR;
  195. #ifdef USG_COMPAT
  196. daylight = 0;
  197. timezone = 0;
  198. #endif /* defined USG_COMPAT */
  199. #ifdef ALTZONE
  200. altzone = 0;
  201. #endif /* defined ALTZONE */
  202. for (i = 0; i < sp->typecnt; ++i) {
  203. register const struct ttinfo * const ttisp = &sp->ttis[i];
  205. tzname[ttisp->tt_isdst] =
  206. (char *) &sp->chars[ttisp->tt_abbrind];
  207. #ifdef USG_COMPAT
  208. if (ttisp->tt_isdst)
  209. daylight = 1;
  210. if (i == 0 || !ttisp->tt_isdst)
  211. timezone = -(ttisp->tt_gmtoff);
  212. #endif /* defined USG_COMPAT */
  213. #ifdef ALTZONE
  214. if (i == 0 || ttisp->tt_isdst)
  215. altzone = -(ttisp->tt_gmtoff);
  216. #endif /* defined ALTZONE */
  217. }
  218. /*
  219. ** And to get the latest zone names into tzname. . .
  220. */
  221. for (i = 0; i < sp->timecnt; ++i) {
  222. register const struct ttinfo * const ttisp =
  223. &sp->ttis[sp->types[i]];
  225. tzname[ttisp->tt_isdst] =
  226. (char *) &sp->chars[ttisp->tt_abbrind];
  227. }
  228. }
  230. static int tzload(const char * name, struct state * sp)
  231. {
  232. register const char * p;
  233. register int i;
  234. register int fid;
  236. if (name == NULL && (name = TZDEFAULT) == NULL)
  237. return -1;
  238. {
  239. char fullname[FILENAME_MAX + 1];
  241. if (name[0] == ':')
  242. ++name;
  243. if (name[0] != '/') {
  244. if ((p = TZDIR) == NULL)
  245. return -1;
  246. if ((strlen(p) + strlen(name) + 1) >= sizeof fullname)
  247. return -1;
  248. (void) strcpy(fullname, p);
  249. (void) strcat(fullname, "/");
  250. (void) strcat(fullname, name);
  251. name = fullname;
  252. }
  253. if ((fid = open(name, O_RDONLY)) == -1)
  254. return -1;
  255. }
  256. {
  257. register const struct tzhead * tzhp;
  258. char buf[sizeof *sp + sizeof *tzhp];
  259. int ttisstdcnt;
  261. i = read(fid, buf, sizeof buf);
  262. if (close(fid) != 0 || i < sizeof *tzhp)
  263. return -1;
  264. tzhp = (struct tzhead *) buf;
  265. ttisstdcnt = (int) detzcode(tzhp->tzh_ttisstdcnt);
  266. sp->leapcnt = (int) detzcode(tzhp->tzh_leapcnt);
  267. sp->timecnt = (int) detzcode(tzhp->tzh_timecnt);
  268. sp->typecnt = (int) detzcode(tzhp->tzh_typecnt);
  269. sp->charcnt = (int) detzcode(tzhp->tzh_charcnt);
  270. if (sp->leapcnt < 0 || sp->leapcnt > TZ_MAX_LEAPS ||
  271. sp->typecnt <= 0 || sp->typecnt > TZ_MAX_TYPES ||
  272. sp->timecnt < 0 || sp->timecnt > TZ_MAX_TIMES ||
  273. sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS ||
  274. (ttisstdcnt != sp->typecnt && ttisstdcnt != 0))
  275. return -1;
  276. if (i < sizeof *tzhp +
  277. sp->timecnt * (4 + sizeof (char)) +
  278. sp->typecnt * (4 + 2 * sizeof (char)) +
  279. sp->charcnt * sizeof (char) +
  280. sp->leapcnt * 2 * 4 +
  281. ttisstdcnt * sizeof (char))
  282. return -1;
  283. p = buf + sizeof *tzhp;
  284. for (i = 0; i < sp->timecnt; ++i) {
  285. sp->ats[i] = detzcode(p);
  286. p += 4;
  287. }
  288. for (i = 0; i < sp->timecnt; ++i) {
  289. sp->types[i] = (unsigned char) *p++;
  290. if (sp->types[i] >= sp->typecnt)
  291. return -1;
  292. }
  293. for (i = 0; i < sp->typecnt; ++i) {
  294. register struct ttinfo * ttisp;
  296. ttisp = &sp->ttis[i];
  297. ttisp->tt_gmtoff = detzcode(p);
  298. p += 4;
  299. ttisp->tt_isdst = (unsigned char) *p++;
  300. if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1)
  301. return -1;
  302. ttisp->tt_abbrind = (unsigned char) *p++;
  303. if (ttisp->tt_abbrind < 0 ||
  304. ttisp->tt_abbrind > sp->charcnt)
  305. return -1;
  306. }
  307. for (i = 0; i < sp->charcnt; ++i)
  308. sp->chars[i] = *p++;
  309. sp->chars[i] = ''; /* ensure '' at end */
  310. for (i = 0; i < sp->leapcnt; ++i) {
  311. register struct lsinfo * lsisp;
  313. lsisp = &sp->lsis[i];
  314. lsisp->ls_trans = detzcode(p);
  315. p += 4;
  316. lsisp->ls_corr = detzcode(p);
  317. p += 4;
  318. }
  319. for (i = 0; i < sp->typecnt; ++i) {
  320. register struct ttinfo * ttisp;
  322. ttisp = &sp->ttis[i];
  323. if (ttisstdcnt == 0)
  324. ttisp->tt_ttisstd = FALSE;
  325. else {
  326. ttisp->tt_ttisstd = *p++;
  327. if (ttisp->tt_ttisstd != TRUE &&
  328. ttisp->tt_ttisstd != FALSE)
  329. return -1;
  330. }
  331. }
  332. }
  333. return 0;
  334. }
  336. static const int mon_lengths[2][MONSPERYEAR] = {
  337. 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
  338. 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  339. };
  341. static const int year_lengths[2] = {
  342. DAYSPERNYEAR, DAYSPERLYEAR
  343. };
  345. /*
  346. ** Given a pointer into a time zone string, scan until a character that is not
  347. ** a valid character in a zone name is found.  Return a pointer to that
  348. ** character.
  349. */
  350. static const char * getzname(const char * strp)
  351. {
  352. register char c;
  354. while ((c = *strp) != '' && !isdigit(c) && c != ',' && c != '-' &&
  355. c != '+')
  356. ++strp;
  357. return strp;
  358. }
  360. /*
  361. ** Given a pointer into a time zone string, extract a number from that string.
  362. ** Check that the number is within a specified range; if it is not, return
  363. ** NULL.
  364. ** Otherwise, return a pointer to the first character not part of the number.
  365. */
  367. static const char *getnum(const char * strp, int * nump, int min, int max)
  368. {
  369. char c;
  370. int num;
  372. if (strp == NULL || !isdigit(*strp))
  373. return NULL;
  374. num = 0;
  375. while ((c = *strp) != '' && isdigit(c)) {
  376. num = num * 10 + (c - '0');
  377. if (num > max)
  378. return NULL; /* illegal value */
  379. ++strp;
  380. }
  381. if (num < min)
  382. return NULL; /* illegal value */
  383. *nump = num;
  384. return strp;
  385. }
  387. /*
  388. ** Given a pointer into a time zone string, extract a number of seconds,
  389. ** in hh[:mm[:ss]] form, from the string.
  390. ** If any error occurs, return NULL.
  391. ** Otherwise, return a pointer to the first character not part of the number
  392. ** of seconds.
  393. */
  394. static const char * getsecs(const char * strp, long * secsp)
  395. {
  396. int num;
  398. strp = getnum(strp, &num, 0, HOURSPERDAY);
  399. if (strp == NULL)
  400. return NULL;
  401. *secsp = num * SECSPERHOUR;
  402. if (*strp == ':') {
  403. ++strp;
  404. strp = getnum(strp, &num, 0, MINSPERHOUR - 1);
  405. if (strp == NULL)
  406. return NULL;
  407. *secsp += num * SECSPERMIN;
  408. if (*strp == ':') {
  409. ++strp;
  410. strp = getnum(strp, &num, 0, SECSPERMIN - 1);
  411. if (strp == NULL)
  412. return NULL;
  413. *secsp += num;
  414. }
  415. }
  416. return strp;
  417. }
  419. /*
  420. ** Given a pointer into a time zone string, extract an offset, in
  421. ** [+-]hh[:mm[:ss]] form, from the string.
  422. ** If any error occurs, return NULL.
  423. ** Otherwise, return a pointer to the first character not part of the time.
  424. */
  425. static const char * getoffset(const char * strp, long * offsetp)
  426. {
  427. int neg;
  429. if (*strp == '-') {
  430. neg = 1;
  431. ++strp;
  432. } else if (isdigit(*strp) || *strp++ == '+')
  433. neg = 0;
  434. else return NULL; /* illegal offset */
  435. strp = getsecs(strp, offsetp);
  436. if (strp == NULL)
  437. return NULL; /* illegal time */
  438. if (neg)
  439. *offsetp = -*offsetp;
  440. return strp;
  441. }
  443. /*
  444. ** Given a pointer into a time zone string, extract a rule in the form
  445. ** date[/time].  See POSIX section 8 for the format of "date" and "time".
  446. ** If a valid rule is not found, return NULL.
  447. ** Otherwise, return a pointer to the first character not part of the rule.
  448. */
  449. static const char * getrule(const char * strp, struct rule * rulep)
  450. {
  451. if (*strp == 'J') {
  452. /*
  453. ** Julian day.
  454. */
  455. rulep->r_type = JULIAN_DAY;
  456. ++strp;
  457. strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);
  458. } else if (*strp == 'M') {
  459. /*
  460. ** Month, week, day.
  461. */
  462. rulep->r_type = MONTH_NTH_DAY_OF_WEEK;
  463. ++strp;
  464. strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR);
  465. if (strp == NULL)
  466. return NULL;
  467. if (*strp++ != '.')
  468. return NULL;
  469. strp = getnum(strp, &rulep->r_week, 1, 5);
  470. if (strp == NULL)
  471. return NULL;
  472. if (*strp++ != '.')
  473. return NULL;
  474. strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);
  475. } else if (isdigit(*strp)) {
  476. /*
  477. ** Day of year.
  478. */
  479. rulep->r_type = DAY_OF_YEAR;
  480. strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
  481. } else return NULL; /* invalid format */
  482. if (strp == NULL)
  483. return NULL;
  484. if (*strp == '/') {
  485. /*
  486. ** Time specified.
  487. */
  488. ++strp;
  489. strp = getsecs(strp, &rulep->r_time);
  490. } else rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */
  491. return strp;
  492. }
  494. /*
  495. ** Given the Epoch-relative time of January 1, 00:00:00 GMT, in a year, the
  496. ** year, a rule, and the offset from GMT at the time that rule takes effect,
  497. ** calculate the Epoch-relative time that rule takes effect.
  498. */
  499. static time_t transtime(time_t janfirst, int year,
  500.   const struct rule * rulep, long offset)
  501. {
  502. register int leapyear;
  503. register time_t value;
  504. register int i;
  505. int d, m1, yy0, yy1, yy2, dow;
  507. leapyear = isleap(year);
  508. switch (rulep->r_type) {
  510. case JULIAN_DAY:
  511. /*
  512. ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap
  513. ** years.
  514. ** In non-leap years, or if the day number is 59 or less, just
  515. ** add SECSPERDAY times the day number-1 to the time of
  516. ** January 1, midnight, to get the day.
  517. */
  518. value = janfirst + (rulep->r_day - 1) * SECSPERDAY;
  519. if (leapyear && rulep->r_day >= 60)
  520. value += SECSPERDAY;
  521. break;
  523. case DAY_OF_YEAR:
  524. /*
  525. ** n - day of year.
  526. ** Just add SECSPERDAY times the day number to the time of
  527. ** January 1, midnight, to get the day.
  528. */
  529. value = janfirst + rulep->r_day * SECSPERDAY;
  530. break;
  532. case MONTH_NTH_DAY_OF_WEEK:
  533. /*
  534. ** Mm.n.d - nth "dth day" of month m.
  535. */
  536. value = janfirst;
  537. for (i = 0; i < rulep->r_mon - 1; ++i)
  538. value += mon_lengths[leapyear][i] * SECSPERDAY;
  540. /*
  541. ** Use Zeller's Congruence to get day-of-week of first day of
  542. ** month.
  543. */
  544. m1 = (rulep->r_mon + 9) % 12 + 1;
  545. yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;
  546. yy1 = yy0 / 100;
  547. yy2 = yy0 % 100;
  548. dow = ((26 * m1 - 2) / 10 +
  549. 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
  550. if (dow < 0)
  551. dow += DAYSPERWEEK;
  553. /*
  554. ** "dow" is the day-of-week of the first day of the month.  Get
  555. ** the day-of-month (zero-origin) of the first "dow" day of the
  556. ** month.
  557. */
  558. d = rulep->r_day - dow;
  559. if (d < 0)
  560. d += DAYSPERWEEK;
  561. for (i = 1; i < rulep->r_week; ++i) {
  562. if (d + DAYSPERWEEK >=
  563. mon_lengths[leapyear][rulep->r_mon - 1])
  564. break;
  565. d += DAYSPERWEEK;
  566. }
  568. /*
  569. ** "d" is the day-of-month (zero-origin) of the day we want.
  570. */
  571. value += d * SECSPERDAY;
  572. break;
  573. }
  575. /*
  576. ** "value" is the Epoch-relative time of 00:00:00 GMT on the day in
  577. ** question.  To get the Epoch-relative time of the specified local
  578. ** time on that day, add the transition time and the current offset
  579. ** from GMT.
  580. */
  581. return value + rulep->r_time + offset;
  582. }
  584. /*
  585. ** Given a POSIX section 8-style TZ string, fill in the rule tables as
  586. ** appropriate.
  587. */
  588. static int tzparse(const char * name, struct state * sp, int lastditch)
  589. {
  590. const char * stdname;
  591. const char * dstname;
  592. int stdlen;
  593. int dstlen;
  594. long stdoffset;
  595. long dstoffset;
  596. register time_t * atp;
  597. register unsigned char * typep;
  598. register char * cp;
  599. register int load_result;
  601. stdname = name;
  602. if (lastditch) {
  603. stdlen = strlen(name); /* length of standard zone name */
  604. name += stdlen;
  605. if (stdlen >= sizeof sp->chars)
  606. stdlen = (sizeof sp->chars) - 1;
  607. } else {
  608. name = getzname(name);
  609. stdlen = name - stdname;
  610. if (stdlen < 3)
  611. return -1;
  612. }
  613. if (*name == '')
  614. return -1;
  615. else {
  616. name = getoffset(name, &stdoffset);
  617. if (name == NULL)
  618. return -1;
  619. }
  620. load_result = tzload(TZDEFRULES, sp);
  621. if (load_result != 0)
  622. sp->leapcnt = 0; /* so, we're off a little */
  623. if (*name != '') {
  624. dstname = name;
  625. name = getzname(name);
  626. dstlen = name - dstname; /* length of DST zone name */
  627. if (dstlen < 3)
  628. return -1;
  629. if (*name != '' && *name != ',' && *name != ';') {
  630. name = getoffset(name, &dstoffset);
  631. if (name == NULL)
  632. return -1;
  633. } else dstoffset = stdoffset - SECSPERHOUR;
  634. if (*name == ',' || *name == ';') {
  635. struct rule start;
  636. struct rule end;
  637. register int year;
  638. register time_t janfirst;
  639. time_t starttime;
  640. time_t endtime;
  642. ++name;
  643. if ((name = getrule(name, &start)) == NULL)
  644. return -1;
  645. if (*name++ != ',')
  646. return -1;
  647. if ((name = getrule(name, &end)) == NULL)
  648. return -1;
  649. if (*name != '')
  650. return -1;
  651. sp->typecnt = 2; /* standard time and DST */
  652. /*
  653. ** Two transitions per year, from EPOCH_YEAR to 2037.
  654. */
  655. sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1);
  656. if (sp->timecnt > TZ_MAX_TIMES)
  657. return -1;
  658. sp->ttis[0].tt_gmtoff = -dstoffset;
  659. sp->ttis[0].tt_isdst = 1;
  660. sp->ttis[0].tt_abbrind = stdlen + 1;
  661. sp->ttis[1].tt_gmtoff = -stdoffset;
  662. sp->ttis[1].tt_isdst = 0;
  663. sp->ttis[1].tt_abbrind = 0;
  664. atp = sp->ats;
  665. typep = sp->types;
  666. janfirst = 0;
  667. for (year = EPOCH_YEAR; year <= 2037; ++year) {
  668. starttime = transtime(janfirst, year, &start,
  669. stdoffset);
  670. endtime = transtime(janfirst, year, &end,
  671. dstoffset);
  672. if (starttime > endtime) {
  673. *atp++ = endtime;
  674. *typep++ = 1; /* DST ends */
  675. *atp++ = starttime;
  676. *typep++ = 0; /* DST begins */
  677. } else {
  678. *atp++ = starttime;
  679. *typep++ = 0; /* DST begins */
  680. *atp++ = endtime;
  681. *typep++ = 1; /* DST ends */
  682. }
  683. janfirst +=
  684. year_lengths[isleap(year)] * SECSPERDAY;
  685. }
  686. } else {
  687. int sawstd;
  688. int sawdst;
  689. long stdfix;
  690. long dstfix;
  691. long oldfix;
  692. int isdst;
  693. register int i;
  695. if (*name != '')
  696. return -1;
  697. if (load_result != 0)
  698. return -1;
  699. /*
  700. ** Compute the difference between the real and
  701. ** prototype standard and summer time offsets
  702. ** from GMT, and put the real standard and summer
  703. ** time offsets into the rules in place of the
  704. ** prototype offsets.
  705. */
  706. sawstd = FALSE;
  707. sawdst = FALSE;
  708. stdfix = 0;
  709. dstfix = 0;
  710. for (i = 0; i < sp->typecnt; ++i) {
  711. if (sp->ttis[i].tt_isdst) {
  712. oldfix = dstfix;
  713. dstfix =
  714.     sp->ttis[i].tt_gmtoff + dstoffset;
  715. if (sawdst && (oldfix != dstfix))
  716. return -1;
  717. sp->ttis[i].tt_gmtoff = -dstoffset;
  718. sp->ttis[i].tt_abbrind = stdlen + 1;
  719. sawdst = TRUE;
  720. } else {
  721. oldfix = stdfix;
  722. stdfix =
  723.     sp->ttis[i].tt_gmtoff + stdoffset;
  724. if (sawstd && (oldfix != stdfix))
  725. return -1;
  726. sp->ttis[i].tt_gmtoff = -stdoffset;
  727. sp->ttis[i].tt_abbrind = 0;
  728. sawstd = TRUE;
  729. }
  730. }
  731. /*
  732. ** Make sure we have both standard and summer time.
  733. */
  734. if (!sawdst || !sawstd)
  735. return -1;
  736. /*
  737. ** Now correct the transition times by shifting
  738. ** them by the difference between the real and
  739. ** prototype offsets.  Note that this difference
  740. ** can be different in standard and summer time;
  741. ** the prototype probably has a 1-hour difference
  742. ** between standard and summer time, but a different
  743. ** difference can be specified in TZ.
  744. */
  745. isdst = FALSE; /* we start in standard time */
  746. for (i = 0; i < sp->timecnt; ++i) {
  747. register const struct ttinfo * ttisp;
  749. /*
  750. ** If summer time is in effect, and the
  751. ** transition time was not specified as
  752. ** standard time, add the summer time
  753. ** offset to the transition time;
  754. ** otherwise, add the standard time offset
  755. ** to the transition time.
  756. */
  757. ttisp = &sp->ttis[sp->types[i]];
  758. sp->ats[i] +=
  759. (isdst && !ttisp->tt_ttisstd) ?
  760. dstfix : stdfix;
  761. isdst = ttisp->tt_isdst;
  762. }
  763. }
  764. } else {
  765. dstlen = 0;
  766. sp->typecnt = 1; /* only standard time */
  767. sp->timecnt = 0;
  768. sp->ttis[0].tt_gmtoff = -stdoffset;
  769. sp->ttis[0].tt_isdst = 0;
  770. sp->ttis[0].tt_abbrind = 0;
  771. }
  772. sp->charcnt = stdlen + 1;
  773. if (dstlen != 0)
  774. sp->charcnt += dstlen + 1;
  775. if (sp->charcnt > sizeof sp->chars)
  776. return -1;
  777. cp = sp->chars;
  778. (void) strncpy(cp, stdname, stdlen);
  779. cp += stdlen;
  780. *cp++ = '';
  781. if (dstlen != 0) {
  782. (void) strncpy(cp, dstname, dstlen);
  783. *(cp + dstlen) = '';
  784. }
  785. return 0;
  786. }
  788. static void gmtload(struct state * sp)
  789. {
  790. if (tzload(GMT, sp) != 0)
  791. (void) tzparse(GMT, sp, TRUE);
  792. }
  794. static void tzset_basic()
  795. {
  796. const char * name;
  797. if ((name = getenv("TZ")) == NULL) {
  798. tzsetwall_basic();
  799. return;
  800. }
  802. if (*name == '') {
  803. /*
  804. ** User wants it fast rather than right.
  805. */
  806. lclptr->leapcnt = 0; /* so, we're off a little */
  807. lclptr->timecnt = 0;
  808. lclptr->ttis[0].tt_gmtoff = 0;
  809. lclptr->ttis[0].tt_abbrind = 0;
  810. (void) strcpy(lclptr->chars, GMT);
  811. } else {
  812. if (tzload(name, lclptr) != 0)
  813. if (name[0] == ':' || tzparse(name, lclptr, FALSE) != 0)
  814. (void) gmtload(lclptr);
  815. }
  816. lcl_is_set = TRUE;
  817. settzname(lclptr);
  818. }
  820. void tzset()
  821. {
  822. pthread_mutex_lock(&lcl_mutex);
  823. tzset_basic();
  824. pthread_mutex_unlock(&lcl_mutex);
  825. }
  827. static void tzsetwall_basic()
  828. {
  829. if (tzload((char *) NULL, lclptr) != 0)
  830. gmtload(lclptr);
  831. settzname(lclptr);
  832. lcl_is_set = TRUE;
  833. }
  835. void tzsetwall()
  836. {
  837. pthread_mutex_lock(&lcl_mutex);
  838. tzsetwall_basic();
  839. pthread_mutex_unlock(&lcl_mutex);
  840. }
  842. /*
  843. ** The easy way to behave "as if no library function calls" localtime
  844. ** is to not call it--so we drop its guts into "localsub", which can be
  845. ** freely called.  (And no, the PANS doesn't require the above behavior--
  846. ** but it *is* desirable.)
  847. **
  848. ** The unused offset argument is for the benefit of mktime variants.
  849. */
  851. static void localsub(const time_t * timep, long offset, struct tm * tmp)
  852. {
  853. const struct ttinfo * ttisp;
  854. const time_t t = *timep;
  855. struct state * sp;
  856. int i;
  858. if (!lcl_is_set)
  859. tzset_basic();
  860. sp = lclptr;
  861. if (sp->timecnt == 0 || t < sp->ats[0]) {
  862. i = 0;
  863. while (sp->ttis[i].tt_isdst)
  864. if (++i >= sp->typecnt) {
  865. i = 0;
  866. break;
  867. }
  868. } else {
  869. for (i = 1; i < sp->timecnt; ++i)
  870. if (t < sp->ats[i])
  871. break;
  872. i = sp->types[i - 1];
  873. }
  874. ttisp = &sp->ttis[i];
  875. /*
  876. ** To get (wrong) behavior that's compatible with System V Release 2.0
  877. ** you'd replace the statement below with
  878. ** t += ttisp->tt_gmtoff;
  879. ** timesub(&t, 0L, sp, tmp);
  880. */
  881. timesub(&t, ttisp->tt_gmtoff, sp, tmp);
  882. tzname[tmp->tm_isdst] = (char *) &sp->chars[ttisp->tt_abbrind];
  883. #ifdef BSD_TM
  884. tmp->tm_zone = &sp->chars[ttisp->tt_abbrind];
  885. #endif
  886. tmp->tm_isdst = ttisp->tt_isdst;
  888. pthread_mutex_unlock(&lcl_mutex);
  889. }
  891. struct tm * localtime_r(const time_t * timep, struct tm * tm)
  892. {
  893. pthread_mutex_lock(&lcl_mutex);
  894. localsub(timep, 0L, tm);
  895. pthread_mutex_unlock(&lcl_mutex);
  896. return(tm);
  897. }
  899. struct tm * localtime(const time_t * timep)
  900. {
  901. static pthread_mutex_t localtime_mutex = PTHREAD_MUTEX_INITIALIZER;
  902. static pthread_key_t localtime_key = -1;
  903. struct tm * tm;
  905. pthread_mutex_lock(&localtime_mutex);
  906. if (localtime_key < 0) {
  907. if (pthread_key_create(&localtime_key, free) < 0) {
  908. pthread_mutex_unlock(&localtime_mutex);
  909. return(NULL);
  910. }
  911. }
  912. pthread_mutex_unlock(&localtime_mutex);
  913. if ((tm = pthread_getspecific(localtime_key)) == NULL) {
  914. if ((tm = (struct tm *)malloc(sizeof(struct tm))) == NULL) {
  915. return(NULL);
  916. }
  917. pthread_setspecific(localtime_key, tm);
  918. }
  920. pthread_mutex_lock(&lcl_mutex);
  921. localsub(timep, 0L, tm);
  922. pthread_mutex_unlock(&lcl_mutex);
  923. return tm;
  924. }
  927. /*
  928.  * gmtsub is to gmtime as localsub is to localtime.
  929.  *
  930.  * Once set there is no need to lock the gmt_mutex to view gmtptr 
  931.  */
  932. static void gmtsub(const time_t * timep, long offset, struct tm * tmp)
  933. {
  934. pthread_mutex_lock(&gmt_mutex);
  935. if (gmt_is_set == FALSE) {
  936. gmt_is_set = TRUE;
  937. gmtload(gmtptr);
  938. }
  939. pthread_mutex_unlock(&gmt_mutex);
  941. timesub(timep, offset, gmtptr, tmp);
  942. /*
  943. ** Could get fancy here and deliver something such as
  944. ** "GMT+xxxx" or "GMT-xxxx" if offset is non-zero,
  945. ** but this is no time for a treasure hunt.
  946. */
  947. #ifdef BSD_TM
  948. if (offset != 0) {
  949. tmp->tm_zone = WILDABBR;
  950. } else {
  951. tmp->tm_zone = gmtptr->chars;
  952. }
  953. #endif
  954. }
  956. struct tm * gmtime_r(const time_t * timep, struct tm * tm)
  957. {
  958. gmtsub(timep, 0L, tm);
  959. return(tm);
  960. }
  962. struct tm * gmtime(const time_t * timep)
  963. {
  964. static pthread_mutex_t gmtime_mutex = PTHREAD_MUTEX_INITIALIZER;
  965. static pthread_key_t gmtime_key = -1;
  966. struct tm * tm;
  968. pthread_mutex_lock(&gmtime_mutex);
  969. if (gmtime_key < 0) {
  970. if (pthread_key_create(&gmtime_key, free) < 0) {
  971. pthread_mutex_unlock(&gmtime_mutex);
  972. return(NULL);
  973. }
  974. }
  975. pthread_mutex_unlock(&gmtime_mutex);
  976. if ((tm = pthread_getspecific(gmtime_key)) == NULL) {
  977. if ((tm = (struct tm *)malloc(sizeof(struct tm))) == NULL) {
  978. return(NULL);
  979. }
  980. pthread_setspecific(gmtime_key, tm);
  981. }
  983. gmtsub(timep, 0L, tm);
  984. return(tm);
  985. }
  987. static void timesub(const time_t * timep, long offset,
  988.   const struct state * sp, struct tm * tmp)
  989. {
  990. register const struct lsinfo * lp;
  991. register long days;
  992. register long rem;
  993. register int y;
  994. register int yleap;
  995. register const int * ip;
  996. register long corr;
  997. register int hit;
  998. register int i;
  1000. corr = 0;
  1001. hit = FALSE;
  1002. i = sp->leapcnt;
  1003. while (--i >= 0) {
  1004. lp = &sp->lsis[i];
  1005. if (*timep >= lp->ls_trans) {
  1006. if (*timep == lp->ls_trans)
  1007. hit = ((i == 0 && lp->ls_corr > 0) ||
  1008. lp->ls_corr > sp->lsis[i - 1].ls_corr);
  1009. corr = lp->ls_corr;
  1010. break;
  1011. }
  1012. }
  1013. days = *timep / SECSPERDAY;
  1014. rem = *timep % SECSPERDAY;
  1015. #ifdef mc68k
  1016. if (*timep == 0x80000000) {
  1017. /*
  1018. ** A 3B1 muffs the division on the most negative number.
  1019. */
  1020. days = -24855;
  1021. rem = -11648;
  1022. }
  1023. #endif /* mc68k */
  1024. rem += (offset - corr);
  1025. while (rem < 0) {
  1026. rem += SECSPERDAY;
  1027. --days;
  1028. }
  1029. while (rem >= SECSPERDAY) {
  1030. rem -= SECSPERDAY;
  1031. ++days;
  1032. }
  1033. tmp->tm_hour = (int) (rem / SECSPERHOUR);
  1034. rem = rem % SECSPERHOUR;
  1035. tmp->tm_min = (int) (rem / SECSPERMIN);
  1036. tmp->tm_sec = (int) (rem % SECSPERMIN);
  1037. if (hit)
  1038. /*
  1039. ** A positive leap second requires a special
  1040. ** representation.  This uses "... ??:59:60".
  1041. */
  1042. ++(tmp->tm_sec);
  1043. tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK);
  1044. if (tmp->tm_wday < 0)
  1045. tmp->tm_wday += DAYSPERWEEK;
  1046. y = EPOCH_YEAR;
  1047. if (days >= 0)
  1048. for ( ; ; ) {
  1049. yleap = isleap(y);
  1050. if (days < (long) year_lengths[yleap])
  1051. break;
  1052. ++y;
  1053. days = days - (long) year_lengths[yleap];
  1054. }
  1055. else do {
  1056. --y;
  1057. yleap = isleap(y);
  1058. days = days + (long) year_lengths[yleap];
  1059. } while (days < 0);
  1060. tmp->tm_year = y - TM_YEAR_BASE;
  1061. tmp->tm_yday = (int) days;
  1062. ip = mon_lengths[yleap];
  1063. for (tmp->tm_mon = 0; days >= (long) ip[tmp->tm_mon]; ++(tmp->tm_mon))
  1064. days = days - (long) ip[tmp->tm_mon];
  1065. tmp->tm_mday = (int) (days + 1);
  1066. tmp->tm_isdst = 0;
  1067. #ifdef BSD_TM
  1068. tmp->tm_gmtoff = offset;
  1069. #endif
  1070. }
  1072. /*
  1073.  * A la X3J11
  1074.  *
  1075.  * Made thread safe by using thread specific data
  1076.  */
  1077. char * asctime_r(const struct tm * timeptr, char * result)
  1078. {
  1079. static const char wday_name[DAYSPERWEEK][3] = {
  1080. "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
  1081. };
  1082. static const char mon_name[MONSPERYEAR][3] = {
  1083. "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  1084. "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  1085. };
  1086. (void) sprintf(result, "%.3s %.3s%3d %02.2d:%02.2d:%02.2d %dn",
  1087. wday_name[timeptr->tm_wday],
  1088. mon_name[timeptr->tm_mon],
  1089. timeptr->tm_mday, timeptr->tm_hour,
  1090. timeptr->tm_min, timeptr->tm_sec,
  1091. TM_YEAR_BASE + timeptr->tm_year);
  1092. return(result);
  1093. }
  1095. char * asctime(const struct tm * timeptr)
  1096. {
  1097. static pthread_mutex_t asctime_mutex = PTHREAD_MUTEX_INITIALIZER;
  1098. static pthread_key_t asctime_key = -1;
  1099. char * result;
  1101. pthread_mutex_lock(&asctime_mutex);
  1102. if (asctime_key < 0) {
  1103. if (pthread_key_create(&asctime_key, free) < 0) {
  1104. pthread_mutex_unlock(&asctime_mutex);
  1105. return(NULL);
  1106. }
  1107. }
  1108. pthread_mutex_unlock(&asctime_mutex);
  1109. if ((result = pthread_getspecific(asctime_key)) == NULL) {
  1110. if ((result = malloc(26)) == NULL) {
  1111. return(NULL);
  1112. }
  1113. pthread_setspecific(asctime_key, result);
  1114. }
  1116. return(asctime_r(timeptr, result));
  1117. }
  1119. char * ctime_r(const time_t * timep, char * buf)
  1120. {
  1121. struct tm tm;
  1122. return asctime_r(localtime_r(timep, &tm), buf);
  1123. }
  1125. char * ctime(const time_t * timep)
  1126. {
  1127. struct tm tm;
  1128. return asctime(localtime_r(timep, &tm));
  1129. }
  1131. /*
  1132. ** Adapted from code provided by Robert Elz, who writes:
  1133. ** The "best" way to do mktime I think is based on an idea of Bob
  1134. ** Kridle's (so its said...) from a long time ago. (mtxinu!kridle now).
  1135. ** It does a binary search of the time_t space.  Since time_t's are
  1136. ** just 32 bits, its a max of 32 iterations (even at 64 bits it
  1137. ** would still be very reasonable).
  1138. */
  1139. static void normalize(int * tensptr,int *  unitsptr, int base)
  1140. {
  1141. if (*unitsptr >= base) {
  1142. *tensptr += *unitsptr / base;
  1143. *unitsptr %= base;
  1144. } else if (*unitsptr < 0) {
  1145. --*tensptr;
  1146. *unitsptr += base;
  1147. if (*unitsptr < 0) {
  1148. *tensptr -= 1 + (-*unitsptr) / base;
  1149. *unitsptr = base - (-*unitsptr) % base;
  1150. }
  1151. }
  1152. }
  1154. static int tmcomp(const struct tm * atmp, const struct tm * btmp)
  1155. {
  1156. register int result;
  1158. if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
  1159. (result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
  1160. (result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
  1161. (result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
  1162. (result = (atmp->tm_min - btmp->tm_min)) == 0)
  1163. result = atmp->tm_sec - btmp->tm_sec;
  1164. return result;
  1165. }
  1167. static time_t time2(struct tm * tmp, long offset, int * okayp)
  1168. {
  1169. register const struct state * sp;
  1170. register int dir;
  1171. register int bits;
  1172. register int i, j ;
  1173. register int saved_seconds;
  1174. time_t newt;
  1175. time_t t;
  1176. struct tm yourtm, mytm;
  1178. *okayp = FALSE;
  1179. yourtm = *tmp;
  1180. if (yourtm.tm_sec >= SECSPERMIN + 2 || yourtm.tm_sec < 0)
  1181. normalize(&yourtm.tm_min, &yourtm.tm_sec, SECSPERMIN);
  1182. normalize(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR);
  1183. normalize(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY);
  1184. normalize(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR);
  1185. while (yourtm.tm_mday <= 0) {
  1186. --yourtm.tm_year;
  1187. yourtm.tm_mday +=
  1188. year_lengths[isleap(yourtm.tm_year + TM_YEAR_BASE)];
  1189. }
  1190. for ( ; ; ) {
  1191. i = mon_lengths[isleap(yourtm.tm_year +
  1192. TM_YEAR_BASE)][yourtm.tm_mon];
  1193. if (yourtm.tm_mday <= i)
  1194. break;
  1195. yourtm.tm_mday -= i;
  1196. if (++yourtm.tm_mon >= MONSPERYEAR) {
  1197. yourtm.tm_mon = 0;
  1198. ++yourtm.tm_year;
  1199. }
  1200. }
  1201. saved_seconds = yourtm.tm_sec;
  1202. yourtm.tm_sec = 0;
  1203. /*
  1204. ** Calculate the number of magnitude bits in a time_t
  1205. ** (this works regardless of whether time_t is
  1206. ** signed or unsigned, though lint complains if unsigned).
  1207. */
  1208. for (bits = 0, t = 1; t > 0; ++bits, t <<= 1)
  1209. ;
  1210. /*
  1211. ** If time_t is signed, then 0 is the median value,
  1212. ** if time_t is unsigned, then 1 << bits is median.
  1213. */
  1214. t = (t < 0) ? 0 : ((time_t) 1 << bits);
  1215. for ( ; ; ) {
  1216. localsub(&t, offset, &mytm);
  1217. dir = tmcomp(&mytm, &yourtm);
  1218. if (dir != 0) {
  1219. if (bits-- < 0)
  1220. return NOTOK;
  1221. if (bits < 0)
  1222. --t;
  1223. else if (dir > 0)
  1224. t -= (time_t) 1 << bits;
  1225. else t += (time_t) 1 << bits;
  1226. continue;
  1227. }
  1228. if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
  1229. break;
  1230. /*
  1231. ** Right time, wrong type.
  1232. ** Hunt for right time, right type.
  1233. ** It's okay to guess wrong since the guess
  1234. ** gets checked.
  1235. */
  1236. sp = lclptr;
  1237. for (i = 0; i < sp->typecnt; ++i) {
  1238. if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
  1239. continue;
  1240. for (j = 0; j < sp->typecnt; ++j) {
  1241. if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
  1242. continue;
  1243. newt = t + sp->ttis[j].tt_gmtoff -
  1244. sp->ttis[i].tt_gmtoff;
  1245. localsub(&newt, offset, &mytm);
  1246. if (tmcomp(&mytm, &yourtm) != 0)
  1247. continue;
  1248. if (mytm.tm_isdst != yourtm.tm_isdst)
  1249. continue;
  1250. /*
  1251. ** We have a match.
  1252. */
  1253. t = newt;
  1254. goto label;
  1255. }
  1256. }
  1257. return NOTOK;
  1258. }
  1259. label:
  1260. t += saved_seconds;
  1261. localsub(&t, offset, tmp);
  1262. *okayp = TRUE;
  1263. return t;
  1264. }
  1266. static time_t time1(struct tm * tmp, long offset)
  1267. {
  1268. const struct state * sp;
  1269. int samei, otheri, okay;
  1270. time_t t;
  1272. if (tmp->tm_isdst > 1)
  1273. tmp->tm_isdst = 1;
  1274. t = time2(tmp, offset, &okay);
  1275. if (okay || tmp->tm_isdst < 0)
  1276. return t;
  1277. /*
  1278. ** We're supposed to assume that somebody took a time of one type
  1279. ** and did some math on it that yielded a "struct tm" that's bad.
  1280. ** We try to divine the type they started from and adjust to the
  1281. ** type they need.
  1282. */
  1283. sp = lclptr;
  1284. for (samei = 0; samei < sp->typecnt; ++samei) {
  1285. if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
  1286. continue;
  1287. for (otheri = 0; otheri < sp->typecnt; ++otheri) {
  1288. if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
  1289. continue;
  1290. tmp->tm_sec += sp->ttis[otheri].tt_gmtoff -
  1291. sp->ttis[samei].tt_gmtoff;
  1292. tmp->tm_isdst = !tmp->tm_isdst;
  1293. t = time2(tmp, offset, &okay);
  1294. if (okay) 
  1295. return t;
  1296. tmp->tm_sec -= sp->ttis[otheri].tt_gmtoff -
  1297. sp->ttis[samei].tt_gmtoff;
  1298. tmp->tm_isdst = !tmp->tm_isdst;
  1299. }
  1300. }
  1301. return NOTOK;
  1302. }
  1304. time_t mktime(struct tm * tmp)
  1305. {
  1306. time_t mktime_return_value;
  1308. pthread_mutex_lock(&lcl_mutex);
  1309. if (lcl_is_set == FALSE) {
  1310. tzset_basic();
  1311. }
  1312. mktime_return_value = time1(tmp, 0L);
  1313. pthread_mutex_unlock(&lcl_mutex);
  1314. return(mktime_return_value);
  1315. }