tztime.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:77k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2004 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /*
  14.    Most of the following code and structures were derived from
  15.    public domain code from ftp://elsie.nci.nih.gov/pub
  16.    (We will refer to this code as to elsie-code further.)
  17. */
  18. /*
  19.   We should not include mysql_priv.h in mysql_tzinfo_to_sql utility since
  20.   it creates unsolved link dependencies on some platforms.
  21. */
  22. #ifdef USE_PRAGMA_IMPLEMENTATION
  23. #pragma implementation // gcc: Class implementation
  24. #endif
  25. #include <my_global.h>
  26. #if !defined(TZINFO2SQL) && !defined(TESTTIME)
  27. #include "mysql_priv.h"
  28. #else
  29. #include <my_time.h>
  30. #include "tztime.h"
  31. #include <my_sys.h>
  32. #endif
  33. #include "tzfile.h"
  34. #include <m_string.h>
  35. #include <my_dir.h>
  36. /*
  37.   Now we don't use abbreviations in server but we will do this in future.
  38. */
  39. #if defined(TZINFO2SQL) || defined(TESTTIME)
  40. #define ABBR_ARE_USED
  41. #else
  42. #if !defined(DBUG_OFF)
  43. /* Let use abbreviations for debug purposes */
  44. #undef ABBR_ARE_USED
  45. #define ABBR_ARE_USED
  46. #endif /* !defined(DBUG_OFF) */
  47. #endif /* defined(TZINFO2SQL) || defined(TESTTIME) */
  48. /* Structure describing local time type (e.g. Moscow summer time (MSD)) */
  49. typedef struct ttinfo
  50. {
  51.   long tt_gmtoff; // Offset from UTC in seconds
  52.   uint tt_isdst;   // Is daylight saving time or not. Used to set tm_isdst
  53. #ifdef ABBR_ARE_USED
  54.   uint tt_abbrind; // Index of start of abbreviation for this time type.
  55. #endif
  56.   /*
  57.     We don't use tt_ttisstd and tt_ttisgmt members of original elsie-code
  58.     struct since we don't support POSIX-style TZ descriptions in variables.
  59.   */
  60. } TRAN_TYPE_INFO;
  61. /* Structure describing leap-second corrections. */
  62. typedef struct lsinfo
  63. {
  64.   my_time_t ls_trans; // Transition time
  65.   long      ls_corr;  // Correction to apply
  66. } LS_INFO;
  67. /*
  68.   Structure with information describing ranges of my_time_t shifted to local
  69.   time (my_time_t + offset). Used for local TIME -> my_time_t conversion.
  70.   See comments for TIME_to_gmt_sec() for more info.
  71. */
  72. typedef struct revtinfo
  73. {
  74.   long rt_offset; // Offset of local time from UTC in seconds
  75.   uint rt_type;    // Type of period 0 - Normal period. 1 - Spring time-gap
  76. } REVT_INFO;
  77. #ifdef TZNAME_MAX
  78. #define MY_TZNAME_MAX TZNAME_MAX
  79. #endif
  80. #ifndef TZNAME_MAX
  81. #define MY_TZNAME_MAX 255
  82. #endif
  83. /*
  84.   Structure which fully describes time zone which is
  85.   described in our db or in zoneinfo files.
  86. */
  87. typedef struct st_time_zone_info
  88. {
  89.   uint leapcnt;  // Number of leap-second corrections
  90.   uint timecnt;  // Number of transitions between time types
  91.   uint typecnt;  // Number of local time types
  92.   uint charcnt;  // Number of characters used for abbreviations
  93.   uint revcnt;   // Number of transition descr. for TIME->my_time_t conversion
  94.   /* The following are dynamical arrays are allocated in MEM_ROOT */
  95.   my_time_t *ats;       // Times of transitions between time types
  96.   unsigned char *types; // Local time types for transitions
  97.   TRAN_TYPE_INFO *ttis; // Local time types descriptions
  98. #ifdef ABBR_ARE_USED
  99.   /* Storage for local time types abbreviations. They are stored as ASCIIZ */
  100.   char *chars;
  101. #endif
  102.   /*
  103.     Leap seconds corrections descriptions, this array is shared by
  104.     all time zones who use leap seconds.
  105.   */
  106.   LS_INFO *lsis;
  107.   /*
  108.     Starting points and descriptions of shifted my_time_t (my_time_t + offset)
  109.     ranges on which shifted my_time_t -> my_time_t mapping is linear or undefined.
  110.     Used for tm -> my_time_t conversion.
  111.   */
  112.   my_time_t *revts;
  113.   REVT_INFO *revtis;
  114.   /*
  115.     Time type which is used for times smaller than first transition or if
  116.     there are no transitions at all.
  117.   */
  118.   TRAN_TYPE_INFO *fallback_tti;
  119. } TIME_ZONE_INFO;
  120. static my_bool prepare_tz_info(TIME_ZONE_INFO *sp, MEM_ROOT *storage);
  121. #if defined(TZINFO2SQL) || defined(TESTTIME)
  122. /*
  123.   Load time zone description from zoneinfo (TZinfo) file.
  124.   SYNOPSIS
  125.     tz_load()
  126.       name - path to zoneinfo file
  127.       sp   - TIME_ZONE_INFO structure to fill
  128.   RETURN VALUES
  129.     0 - Ok
  130.     1 - Error
  131. */
  132. static my_bool
  133. tz_load(const char *name, TIME_ZONE_INFO *sp, MEM_ROOT *storage)
  134. {
  135.   char *p;
  136.   int read_from_file;
  137.   uint i;
  138.   FILE *file;
  139.   if (!(file= my_fopen(name, O_RDONLY|O_BINARY, MYF(MY_WME))))
  140.     return 1;
  141.   {
  142.     union
  143.     {
  144.       struct tzhead tzhead;
  145.       char buf[sizeof(struct tzhead) + sizeof(my_time_t) * TZ_MAX_TIMES +
  146.                TZ_MAX_TIMES + sizeof(TRAN_TYPE_INFO) * TZ_MAX_TYPES +
  147. #ifdef ABBR_ARE_USED
  148.                max(TZ_MAX_CHARS + 1, (2 * (MY_TZNAME_MAX + 1))) +
  149. #endif
  150.                sizeof(LS_INFO) * TZ_MAX_LEAPS];
  151.     } u;
  152.     uint ttisstdcnt;
  153.     uint ttisgmtcnt;
  154.     char *tzinfo_buf;
  155.     read_from_file= my_fread(file, u.buf, sizeof(u.buf), MYF(MY_WME));
  156.     if (my_fclose(file, MYF(MY_WME)) != 0)
  157.       return 1;
  158.     if (read_from_file < (int)sizeof(struct tzhead))
  159.       return 1;
  160.     ttisstdcnt= int4net(u.tzhead.tzh_ttisgmtcnt);
  161.     ttisgmtcnt= int4net(u.tzhead.tzh_ttisstdcnt);
  162.     sp->leapcnt= int4net(u.tzhead.tzh_leapcnt);
  163.     sp->timecnt= int4net(u.tzhead.tzh_timecnt);
  164.     sp->typecnt= int4net(u.tzhead.tzh_typecnt);
  165.     sp->charcnt= int4net(u.tzhead.tzh_charcnt);
  166.     p= u.tzhead.tzh_charcnt + sizeof u.tzhead.tzh_charcnt;
  167.     if (sp->leapcnt > TZ_MAX_LEAPS ||
  168.         sp->typecnt == 0 || sp->typecnt > TZ_MAX_TYPES ||
  169.         sp->timecnt > TZ_MAX_TIMES ||
  170.         sp->charcnt > TZ_MAX_CHARS ||
  171.         (ttisstdcnt != sp->typecnt && ttisstdcnt != 0) ||
  172.         (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))
  173.       return 1;
  174.     if ((uint)(read_from_file - (p - u.buf)) <
  175.         sp->timecnt * 4 +                       /* ats */
  176.         sp->timecnt +                           /* types */
  177.         sp->typecnt * (4 + 2) +                 /* ttinfos */
  178.         sp->charcnt +                           /* chars */
  179.         sp->leapcnt * (4 + 4) +                 /* lsinfos */
  180.         ttisstdcnt +                            /* ttisstds */
  181.         ttisgmtcnt)                             /* ttisgmts */
  182.       return 1;
  183.     if (!(tzinfo_buf= (char *)alloc_root(storage,
  184.                                          ALIGN_SIZE(sp->timecnt *
  185.                                                     sizeof(my_time_t)) +
  186.                                          ALIGN_SIZE(sp->timecnt) +
  187.                                          ALIGN_SIZE(sp->typecnt *
  188.                                                     sizeof(TRAN_TYPE_INFO)) +
  189. #ifdef ABBR_ARE_USED
  190.                                          ALIGN_SIZE(sp->charcnt) +
  191. #endif
  192.                                          sp->leapcnt * sizeof(LS_INFO))))
  193.       return 1;
  194.     sp->ats= (my_time_t *)tzinfo_buf;
  195.     tzinfo_buf+= ALIGN_SIZE(sp->timecnt * sizeof(my_time_t));
  196.     sp->types= (unsigned char *)tzinfo_buf;
  197.     tzinfo_buf+= ALIGN_SIZE(sp->timecnt);
  198.     sp->ttis= (TRAN_TYPE_INFO *)tzinfo_buf;
  199.     tzinfo_buf+= ALIGN_SIZE(sp->typecnt * sizeof(TRAN_TYPE_INFO));
  200. #ifdef ABBR_ARE_USED
  201.     sp->chars= tzinfo_buf;
  202.     tzinfo_buf+= ALIGN_SIZE(sp->charcnt);
  203. #endif
  204.     sp->lsis= (LS_INFO *)tzinfo_buf;
  205.     for (i= 0; i < sp->timecnt; i++, p+= 4)
  206.       sp->ats[i]= int4net(p);
  207.     for (i= 0; i < sp->timecnt; i++)
  208.     {
  209.       sp->types[i]= (unsigned char) *p++;
  210.       if (sp->types[i] >= sp->typecnt)
  211.         return 1;
  212.     }
  213.     for (i= 0; i < sp->typecnt; i++)
  214.     {
  215.       TRAN_TYPE_INFO * ttisp;
  216.       ttisp= &sp->ttis[i];
  217.       ttisp->tt_gmtoff= int4net(p);
  218.       p+= 4;
  219.       ttisp->tt_isdst= (unsigned char) *p++;
  220.       if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1)
  221.         return 1;
  222.       ttisp->tt_abbrind= (unsigned char) *p++;
  223.       if (ttisp->tt_abbrind > sp->charcnt)
  224.         return 1;
  225.     }
  226.     for (i= 0; i < sp->charcnt; i++)
  227.       sp->chars[i]= *p++;
  228.     sp->chars[i]= ''; /* ensure '' at end */
  229.     for (i= 0; i < sp->leapcnt; i++)
  230.     {
  231.       LS_INFO *lsisp;
  232.       lsisp= &sp->lsis[i];
  233.       lsisp->ls_trans= int4net(p);
  234.       p+= 4;
  235.       lsisp->ls_corr= int4net(p);
  236.       p+= 4;
  237.     }
  238.     /*
  239.       Since we don't support POSIX style TZ definitions in variables we
  240.       don't read further like glibc or elsie code.
  241.     */
  242.   }
  243.   return prepare_tz_info(sp, storage);
  244. }
  245. #endif /* defined(TZINFO2SQL) || defined(TESTTIME) */
  246. /*
  247.   Finish preparation of time zone description for use in TIME_to_gmt_sec()
  248.   and gmt_sec_to_TIME() functions.
  249.   SYNOPSIS
  250.     prepare_tz_info()
  251.       sp - pointer to time zone description
  252.       storage - pointer to MEM_ROOT where arrays for map allocated
  253.   DESCRIPTION
  254.     First task of this function is to find fallback time type which will
  255.     be used if there are no transitions or we have moment in time before
  256.     any transitions.
  257.     Second task is to build "shifted my_time_t" -> my_time_t map used in
  258.     TIME -> my_time_t conversion.
  259.     Note: See description of TIME_to_gmt_sec() function first.
  260.     In order to perform TIME -> my_time_t conversion we need to build table
  261.     which defines "shifted by tz offset and leap seconds my_time_t" ->
  262.     my_time_t function wich is almost the same (except ranges of ambiguity)
  263.     as reverse function to piecewise linear function used for my_time_t ->
  264.     "shifted my_time_t" conversion and which is also specified as table in
  265.     zoneinfo file or in our db (It is specified as start of time type ranges
  266.     and time type offsets). So basic idea is very simple - let us iterate
  267.     through my_time_t space from one point of discontinuity of my_time_t ->
  268.     "shifted my_time_t" function to another and build our approximation of
  269.     reverse function. (Actually we iterate through ranges on which
  270.     my_time_t -> "shifted my_time_t" is linear function).
  271.   RETURN VALUES
  272.     0 Ok
  273.     1 Error
  274. */
  275. static my_bool
  276. prepare_tz_info(TIME_ZONE_INFO *sp, MEM_ROOT *storage)
  277. {
  278.   my_time_t cur_t= MY_TIME_T_MIN;
  279.   my_time_t cur_l, end_t, end_l;
  280.   my_time_t cur_max_seen_l= MY_TIME_T_MIN;
  281.   long cur_offset, cur_corr, cur_off_and_corr;
  282.   uint next_trans_idx, next_leap_idx;
  283.   uint i;
  284.   /*
  285.     Temporary arrays where we will store tables. Needed because
  286.     we don't know table sizes ahead. (Well we can estimate their
  287.     upper bound but this will take extra space.)
  288.   */
  289.   my_time_t revts[TZ_MAX_REV_RANGES];
  290.   REVT_INFO revtis[TZ_MAX_REV_RANGES];
  291.   LINT_INIT(end_l);
  292.   /*
  293.     Let us setup fallback time type which will be used if we have not any
  294.     transitions or if we have moment of time before first transition.
  295.     We will find first non-DST local time type and use it (or use first
  296.     local time type if all of them are DST types).
  297.   */
  298.   for (i= 0; i < sp->typecnt && sp->ttis[i].tt_isdst; i++)
  299.     /* no-op */ ;
  300.   if (i == sp->typecnt)
  301.     i= 0;
  302.   sp->fallback_tti= &(sp->ttis[i]);
  303.   /*
  304.     Let us build shifted my_time_t -> my_time_t map.
  305.   */
  306.   sp->revcnt= 0;
  307.   /* Let us find initial offset */
  308.   if (sp->timecnt == 0 || cur_t < sp->ats[0])
  309.   {
  310.     /*
  311.       If we have not any transitions or t is before first transition we are using
  312.       already found fallback time type which index is already in i.
  313.     */
  314.     next_trans_idx= 0;
  315.   }
  316.   else
  317.   {
  318.     /* cur_t == sp->ats[0] so we found transition */
  319.     i= sp->types[0];
  320.     next_trans_idx= 1;
  321.   }
  322.   cur_offset= sp->ttis[i].tt_gmtoff;
  323.   /* let us find leap correction... unprobable, but... */
  324.   for (next_leap_idx= 0; next_leap_idx < sp->leapcnt &&
  325.          cur_t >= sp->lsis[next_leap_idx].ls_trans;
  326.          ++next_leap_idx)
  327.     continue;
  328.   if (next_leap_idx > 0)
  329.     cur_corr= sp->lsis[next_leap_idx - 1].ls_corr;
  330.   else
  331.     cur_corr= 0;
  332.   /* Iterate trough t space */
  333.   while (sp->revcnt < TZ_MAX_REV_RANGES - 1)
  334.   {
  335.     cur_off_and_corr= cur_offset - cur_corr;
  336.     /*
  337.       We assuming that cur_t could be only overflowed downwards,
  338.       we also assume that end_t won't be overflowed in this case.
  339.     */
  340.     if (cur_off_and_corr < 0 &&
  341.         cur_t < MY_TIME_T_MIN - cur_off_and_corr)
  342.       cur_t= MY_TIME_T_MIN - cur_off_and_corr;
  343.     cur_l= cur_t + cur_off_and_corr;
  344.     /*
  345.       Let us choose end_t as point before next time type change or leap
  346.       second correction.
  347.     */
  348.     end_t= min((next_trans_idx < sp->timecnt) ? sp->ats[next_trans_idx] - 1:
  349.                                                 MY_TIME_T_MAX,
  350.                (next_leap_idx < sp->leapcnt) ?
  351.                  sp->lsis[next_leap_idx].ls_trans - 1: MY_TIME_T_MAX);
  352.     /*
  353.       again assuming that end_t can be overlowed only in positive side
  354.       we also assume that end_t won't be overflowed in this case.
  355.     */
  356.     if (cur_off_and_corr > 0 &&
  357.         end_t > MY_TIME_T_MAX - cur_off_and_corr)
  358.       end_t= MY_TIME_T_MAX - cur_off_and_corr;
  359.     end_l= end_t + cur_off_and_corr;
  360.     if (end_l > cur_max_seen_l)
  361.     {
  362.       /* We want special handling in the case of first range */
  363.       if (cur_max_seen_l == MY_TIME_T_MIN)
  364.       {
  365.         revts[sp->revcnt]= cur_l;
  366.         revtis[sp->revcnt].rt_offset= cur_off_and_corr;
  367.         revtis[sp->revcnt].rt_type= 0;
  368.         sp->revcnt++;
  369.         cur_max_seen_l= end_l;
  370.       }
  371.       else
  372.       {
  373.         if (cur_l > cur_max_seen_l + 1)
  374.         {
  375.           /* We have a spring time-gap and we are not at the first range */
  376.           revts[sp->revcnt]= cur_max_seen_l + 1;
  377.           revtis[sp->revcnt].rt_offset= revtis[sp->revcnt-1].rt_offset;
  378.           revtis[sp->revcnt].rt_type= 1;
  379.           sp->revcnt++;
  380.           if (sp->revcnt == TZ_MAX_TIMES + TZ_MAX_LEAPS + 1)
  381.             break; /* That was too much */
  382.           cur_max_seen_l= cur_l - 1;
  383.         }
  384.         /* Assume here end_l > cur_max_seen_l (because end_l>=cur_l) */
  385.         revts[sp->revcnt]= cur_max_seen_l + 1;
  386.         revtis[sp->revcnt].rt_offset= cur_off_and_corr;
  387.         revtis[sp->revcnt].rt_type= 0;
  388.         sp->revcnt++;
  389.         cur_max_seen_l= end_l;
  390.       }
  391.     }
  392.     if (end_t == MY_TIME_T_MAX ||
  393.         (cur_off_and_corr > 0) &&
  394.         (end_t >= MY_TIME_T_MAX - cur_off_and_corr))
  395.       /* end of t space */
  396.       break;
  397.     cur_t= end_t + 1;
  398.     /*
  399.       Let us find new offset and correction. Because of our choice of end_t
  400.       cur_t can only be point where new time type starts or/and leap
  401.       correction is performed.
  402.     */
  403.     if (sp->timecnt != 0 && cur_t >= sp->ats[0]) /* else reuse old offset */
  404.       if (next_trans_idx < sp->timecnt &&
  405.           cur_t == sp->ats[next_trans_idx])
  406.       {
  407.         /* We are at offset point */
  408.         cur_offset= sp->ttis[sp->types[next_trans_idx]].tt_gmtoff;
  409.         ++next_trans_idx;
  410.       }
  411.     if (next_leap_idx < sp->leapcnt &&
  412.         cur_t == sp->lsis[next_leap_idx].ls_trans)
  413.     {
  414.       /* we are at leap point */
  415.       cur_corr= sp->lsis[next_leap_idx].ls_corr;
  416.       ++next_leap_idx;
  417.     }
  418.   }
  419.   /* check if we have had enough space */
  420.   if (sp->revcnt == TZ_MAX_REV_RANGES - 1)
  421.     return 1;
  422.   /* set maximum end_l as finisher */
  423.   revts[sp->revcnt]= end_l;
  424.   /* Allocate arrays of proper size in sp and copy result there */
  425.   if (!(sp->revts= (my_time_t *)alloc_root(storage,
  426.                                   sizeof(my_time_t) * (sp->revcnt + 1))) ||
  427.       !(sp->revtis= (REVT_INFO *)alloc_root(storage,
  428.                                   sizeof(REVT_INFO) * sp->revcnt)))
  429.     return 1;
  430.   memcpy(sp->revts, revts, sizeof(my_time_t) * (sp->revcnt + 1));
  431.   memcpy(sp->revtis, revtis, sizeof(REVT_INFO) * sp->revcnt);
  432.   return 0;
  433. }
  434. #if !defined(TZINFO2SQL)
  435. static const uint mon_lengths[2][MONS_PER_YEAR]=
  436. {
  437.   { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  438.   { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
  439. };
  440. static const uint mon_starts[2][MONS_PER_YEAR]=
  441. {
  442.   { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
  443.   { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
  444. };
  445. static const uint year_lengths[2]=
  446. {
  447.   DAYS_PER_NYEAR, DAYS_PER_LYEAR
  448. };
  449. #define LEAPS_THRU_END_OF(y)  ((y) / 4 - (y) / 100 + (y) / 400)
  450. /*
  451.   Converts time from my_time_t representation (seconds in UTC since Epoch)
  452.   to broken down representation using given local time zone offset.
  453.   SYNOPSIS
  454.     sec_to_TIME()
  455.       tmp    - pointer to structure for broken down representation
  456.       t      - my_time_t value to be converted
  457.       offset - local time zone offset
  458.   DESCRIPTION
  459.     Convert my_time_t with offset to TIME struct. Differs from timesub
  460.     (from elsie code) because doesn't contain any leap correction and
  461.     TM_GMTOFF and is_dst setting and contains some MySQL specific
  462.     initialization. Funny but with removing of these we almost have
  463.     glibc's offtime function.
  464. */
  465. static void
  466. sec_to_TIME(TIME * tmp, my_time_t t, long offset)
  467. {
  468.   long days;
  469.   long rem;
  470.   int y;
  471.   int yleap;
  472.   const uint *ip;
  473.   days= t / SECS_PER_DAY;
  474.   rem= t % SECS_PER_DAY;
  475.   /*
  476.     We do this as separate step after dividing t, because this
  477.     allows us handle times near my_time_t bounds without overflows.
  478.   */
  479.   rem+= offset;
  480.   while (rem < 0)
  481.   {
  482.     rem+= SECS_PER_DAY;
  483.     days--;
  484.   }
  485.   while (rem >= SECS_PER_DAY)
  486.   {
  487.     rem -= SECS_PER_DAY;
  488.     days++;
  489.   }
  490.   tmp->hour= (uint)(rem / SECS_PER_HOUR);
  491.   rem= rem % SECS_PER_HOUR;
  492.   tmp->minute= (uint)(rem / SECS_PER_MIN);
  493.   /*
  494.     A positive leap second requires a special
  495.     representation.  This uses "... ??:59:60" et seq.
  496.   */
  497.   tmp->second= (uint)(rem % SECS_PER_MIN);
  498.   y= EPOCH_YEAR;
  499.   while (days < 0 || days >= (long)year_lengths[yleap= isleap(y)])
  500.   {
  501.     int newy;
  502.     newy= y + days / DAYS_PER_NYEAR;
  503.     if (days < 0)
  504.       newy--;
  505.     days-= (newy - y) * DAYS_PER_NYEAR +
  506.            LEAPS_THRU_END_OF(newy - 1) -
  507.            LEAPS_THRU_END_OF(y - 1);
  508.     y= newy;
  509.   }
  510.   tmp->year= y;
  511.   ip= mon_lengths[yleap];
  512.   for (tmp->month= 0; days >= (long) ip[tmp->month]; tmp->month++)
  513.     days= days - (long) ip[tmp->month];
  514.   tmp->month++;
  515.   tmp->day= (uint)(days + 1);
  516.   /* filling MySQL specific TIME members */
  517.   tmp->neg= 0; tmp->second_part= 0;
  518.   tmp->time_type= MYSQL_TIMESTAMP_DATETIME;
  519. }
  520. /*
  521.   Find time range wich contains given my_time_t value
  522.   SYNOPSIS
  523.     find_time_range()
  524.       t                - my_time_t value for which we looking for range
  525.       range_boundaries - sorted array of range starts.
  526.       higher_bound     - number of ranges
  527.   DESCRIPTION
  528.     Performs binary search for range which contains given my_time_t value.
  529.     It has sense if number of ranges is greater than zero and my_time_t value
  530.     is greater or equal than beginning of first range. It also assumes that
  531.     t belongs to some range specified or end of last is MY_TIME_T_MAX.
  532.     With this localtime_r on real data may takes less time than with linear
  533.     search (I've seen 30% speed up).
  534.   RETURN VALUE
  535.     Index of range to which t belongs
  536. */
  537. static uint
  538. find_time_range(my_time_t t, const my_time_t *range_boundaries,
  539.                 uint higher_bound)
  540. {
  541.   uint i, lower_bound= 0;
  542.   /*
  543.     Function will work without this assertion but result would be meaningless.
  544.   */
  545.   DBUG_ASSERT(higher_bound > 0 && t >= range_boundaries[0]);
  546.   /*
  547.     Do binary search for minimal interval which contain t. We preserve:
  548.     range_boundaries[lower_bound] <= t < range_boundaries[higher_bound]
  549.     invariant and decrease this higher_bound - lower_bound gap twice
  550.     times on each step.
  551.   */
  552.   while (higher_bound - lower_bound > 1)
  553.   {
  554.     i= (lower_bound + higher_bound) >> 1;
  555.     if (range_boundaries[i] <= t)
  556.       lower_bound= i;
  557.     else
  558.       higher_bound= i;
  559.   }
  560.   return lower_bound;
  561. }
  562. /*
  563.   Find local time transition for given my_time_t.
  564.   SYNOPSIS
  565.     find_transition_type()
  566.       t   - my_time_t value to be converted
  567.       sp  - pointer to struct with time zone description
  568.   RETURN VALUE
  569.     Pointer to structure in time zone description describing
  570.     local time type for given my_time_t.
  571. */
  572. static
  573. const TRAN_TYPE_INFO *
  574. find_transition_type(my_time_t t, const TIME_ZONE_INFO *sp)
  575. {
  576.   if (unlikely(sp->timecnt == 0 || t < sp->ats[0]))
  577.   {
  578.     /*
  579.       If we have not any transitions or t is before first transition let
  580.       us use fallback time type.
  581.     */
  582.     return sp->fallback_tti;
  583.   }
  584.   /*
  585.     Do binary search for minimal interval between transitions which
  586.     contain t. With this localtime_r on real data may takes less
  587.     time than with linear search (I've seen 30% speed up).
  588.   */
  589.   return &(sp->ttis[sp->types[find_time_range(t, sp->ats, sp->timecnt)]]);
  590. }
  591. /*
  592.   Converts time in my_time_t representation (seconds in UTC since Epoch) to
  593.   broken down TIME representation in local time zone.
  594.   SYNOPSIS
  595.     gmt_sec_to_TIME()
  596.       tmp          - pointer to structure for broken down represenatation
  597.       sec_in_utc   - my_time_t value to be converted
  598.       sp           - pointer to struct with time zone description
  599.   TODO
  600.     We can improve this function by creating joined array of transitions and
  601.     leap corrections. This will require adding extra field to TRAN_TYPE_INFO
  602.     for storing number of "extra" seconds to minute occured due to correction
  603.     (60th and 61st second, look how we calculate them as "hit" in this
  604.     function).
  605.     Under realistic assumptions about frequency of transitions the same array
  606.     can be used fot TIME -> my_time_t conversion. For this we need to
  607.     implement tweaked binary search which will take into account that some
  608.     TIME has two matching my_time_t ranges and some of them have none.
  609. */
  610. static void
  611. gmt_sec_to_TIME(TIME *tmp, my_time_t sec_in_utc, const TIME_ZONE_INFO *sp)
  612. {
  613.   const TRAN_TYPE_INFO *ttisp;
  614.   const LS_INFO *lp;
  615.   long  corr= 0;
  616.   int   hit= 0;
  617.   int   i;
  618.   /*
  619.     Find proper transition (and its local time type) for our sec_in_utc value.
  620.     Funny but again by separating this step in function we receive code
  621.     which very close to glibc's code. No wonder since they obviously use
  622.     the same base and all steps are sensible.
  623.   */
  624.   ttisp= find_transition_type(sec_in_utc, sp);
  625.   /*
  626.     Let us find leap correction for our sec_in_utc value and number of extra
  627.     secs to add to this minute.
  628.     This loop is rarely used because most users will use time zones without
  629.     leap seconds, and even in case when we have such time zone there won't
  630.     be many iterations (we have about 22 corrections at this moment (2004)).
  631.   */
  632.   for ( i= sp->leapcnt; i-- > 0; )
  633.   {
  634.     lp= &sp->lsis[i];
  635.     if (sec_in_utc >= lp->ls_trans)
  636.     {
  637.       if (sec_in_utc == lp->ls_trans)
  638.       {
  639.         hit= ((i == 0 && lp->ls_corr > 0) ||
  640.               lp->ls_corr > sp->lsis[i - 1].ls_corr);
  641.         if (hit)
  642.         {
  643.           while (i > 0 &&
  644.                  sp->lsis[i].ls_trans == sp->lsis[i - 1].ls_trans + 1 &&
  645.                  sp->lsis[i].ls_corr == sp->lsis[i - 1].ls_corr + 1)
  646.           {
  647.             hit++;
  648.             i--;
  649.           }
  650.         }
  651.       }
  652.       corr= lp->ls_corr;
  653.       break;
  654.     }
  655.   }
  656.   sec_to_TIME(tmp, sec_in_utc, ttisp->tt_gmtoff - corr);
  657.   tmp->second+= hit;
  658. }
  659. /*
  660.   Converts local time in broken down representation to local
  661.   time zone analog of my_time_t represenation.
  662.   SYNOPSIS
  663.     sec_since_epoch()
  664.       year, mon, mday, hour, min, sec - broken down representation.
  665.   DESCRIPTION
  666.     Converts time in broken down representation to my_time_t representation
  667.     ignoring time zone. Note that we cannot convert back some valid _local_
  668.     times near ends of my_time_t range because of my_time_t  overflow. But we
  669.     ignore this fact now since MySQL will never pass such argument.
  670.   RETURN VALUE
  671.     Seconds since epoch time representation.
  672. */
  673. static my_time_t
  674. sec_since_epoch(int year, int mon, int mday, int hour, int min ,int sec)
  675. {
  676. #ifndef WE_WANT_TO_HANDLE_UNORMALIZED_DATES
  677.   /*
  678.     It turns out that only whenever month is normalized or unnormalized
  679.     plays role.
  680.   */
  681.   DBUG_ASSERT(mon > 0 && mon < 13);
  682.   long days= year * DAYS_PER_NYEAR - EPOCH_YEAR * DAYS_PER_NYEAR +
  683.              LEAPS_THRU_END_OF(year - 1) -
  684.              LEAPS_THRU_END_OF(EPOCH_YEAR - 1);
  685.   days+= mon_starts[isleap(year)][mon - 1];
  686. #else
  687.   long norm_month= (mon - 1) % MONS_PER_YEAR;
  688.   long a_year= year + (mon - 1)/MONS_PER_YEAR - (int)(norm_month < 0);
  689.   long days= a_year * DAYS_PER_NYEAR - EPOCH_YEAR * DAYS_PER_NYEAR +
  690.              LEAPS_THRU_END_OF(a_year - 1) -
  691.              LEAPS_THRU_END_OF(EPOCH_YEAR - 1);
  692.   days+= mon_starts[isleap(a_year)]
  693.                     [norm_month + (norm_month < 0 ? MONS_PER_YEAR : 0)];
  694. #endif
  695.   days+= mday - 1;
  696.   return ((days * HOURS_PER_DAY + hour) * MINS_PER_HOUR + min) *
  697.          SECS_PER_MIN + sec;
  698. }
  699. /*
  700.   Converts local time in broken down TIME representation to my_time_t
  701.   representation.
  702.   SYNOPSIS
  703.     TIME_to_gmt_sec()
  704.       t               - pointer to structure for broken down represenatation
  705.       sp              - pointer to struct with time zone description
  706.       in_dst_time_gap - pointer to bool which is set to true if datetime
  707.                         value passed doesn't really exist (i.e. falls into
  708.                         spring time-gap) and is not touched otherwise.
  709.   DESCRIPTION
  710.     This is mktime analog for MySQL. It is essentially different
  711.     from mktime (or hypotetical my_mktime) because:
  712.     - It has no idea about tm_isdst member so if it
  713.       has two answers it will give the smaller one
  714.     - If we are in spring time gap then it will return
  715.       beginning of the gap
  716.     - It can give wrong results near the ends of my_time_t due to
  717.       overflows, but we are safe since in MySQL we will never
  718.       call this function for such dates (its restriction for year
  719.       between 1970 and 2038 gives us several days of reserve).
  720.     - By default it doesn't support un-normalized input. But if
  721.       sec_since_epoch() function supports un-normalized dates
  722.       then this function should handle un-normalized input right,
  723.       altough it won't normalize structure TIME.
  724.     Traditional approach to problem of conversion from broken down
  725.     representation to time_t is iterative. Both elsie's and glibc
  726.     implementation try to guess what time_t value should correspond to
  727.     this broken-down value. They perform localtime_r function on their
  728.     guessed value and then calculate the difference and try to improve
  729.     their guess. Elsie's code guesses time_t value in bit by bit manner,
  730.     Glibc's code tries to add difference between broken-down value
  731.     corresponding to guess and target broken-down value to current guess.
  732.     It also uses caching of last found correction... So Glibc's approach
  733.     is essentially faster but introduces some undetermenism (in case if
  734.     is_dst member of broken-down representation (tm struct) is not known
  735.     and we have two possible answers).
  736.     We use completely different approach. It is better since it is both
  737.     faster than iterative implementations and fully determenistic. If you
  738.     look at my_time_t to TIME conversion then you'll find that it consist
  739.     of two steps:
  740.     The first is calculating shifted my_time_t value and the second - TIME
  741.     calculation from shifted my_time_t value (well it is a bit simplified
  742.     picture). The part in which we are interested in is my_time_t -> shifted
  743.     my_time_t conversion. It is piecewise linear function which is defined
  744.     by combination of transition times as break points and times offset
  745.     as changing function parameter. The possible inverse function for this
  746.     converison would be ambiguos but with MySQL's restrictions we can use
  747.     some function which is the same as inverse function on unambigiuos
  748.     ranges and coincides with one of branches of inverse function in
  749.     other ranges. Thus we just need to build table which will determine
  750.     this shifted my_time_t -> my_time_t conversion similar to existing
  751.     (my_time_t -> shifted my_time_t table). We do this in
  752.     prepare_tz_info function.
  753.   TODO
  754.     If we can even more improve this function. For doing this we will need to
  755.     build joined map of transitions and leap corrections for gmt_sec_to_TIME()
  756.     function (similar to revts/revtis). Under realistic assumptions about
  757.     frequency of transitions we can use the same array for TIME_to_gmt_sec().
  758.     We need to implement special version of binary search for this. Such step
  759.     will be beneficial to CPU cache since we will decrease data-set used for
  760.     conversion twice.
  761.   RETURN VALUE
  762.     Seconds in UTC since Epoch.
  763.     0 in case of error.
  764. */
  765. static my_time_t
  766. TIME_to_gmt_sec(const TIME *t, const TIME_ZONE_INFO *sp, bool *in_dst_time_gap)
  767. {
  768.   my_time_t local_t;
  769.   uint saved_seconds;
  770.   uint i;
  771.   DBUG_ENTER("TIME_to_gmt_sec");
  772.   /* We need this for correct leap seconds handling */
  773.   if (t->second < SECS_PER_MIN)
  774.     saved_seconds= 0;
  775.   else
  776.     saved_seconds= t->second;
  777.   /*
  778.     NOTE If we want to convert full my_time_t range without MySQL
  779.     restrictions we should catch overflow here somehow.
  780.   */
  781.   local_t= sec_since_epoch(t->year, t->month, t->day,
  782.                            t->hour, t->minute,
  783.                            saved_seconds ? 0 : t->second);
  784.   /* We have at least one range */
  785.   DBUG_ASSERT(sp->revcnt >= 1);
  786.   if (local_t < sp->revts[0] || local_t > sp->revts[sp->revcnt])
  787.   {
  788.     /*
  789.       This means that source time can't be represented as my_time_t due to
  790.       limited my_time_t range.
  791.     */
  792.     DBUG_RETURN(0);
  793.   }
  794.   /* binary search for our range */
  795.   i= find_time_range(local_t, sp->revts, sp->revcnt);
  796.   if (sp->revtis[i].rt_type)
  797.   {
  798.     /*
  799.       Oops! We are in spring time gap.
  800.       May be we should return error here?
  801.       Now we are returning my_time_t value corresponding to the
  802.       beginning of the gap.
  803.     */
  804.     *in_dst_time_gap= 1;
  805.     DBUG_RETURN(sp->revts[i] - sp->revtis[i].rt_offset + saved_seconds);
  806.   }
  807.   else
  808.     DBUG_RETURN(local_t - sp->revtis[i].rt_offset + saved_seconds);
  809. }
  810. /*
  811.   End of elsie derived code.
  812. */
  813. #endif /* !defined(TZINFO2SQL) */
  814. #if !defined(TESTTIME) && !defined(TZINFO2SQL)
  815. /*
  816.   String with names of SYSTEM time zone.
  817. */
  818. static const String tz_SYSTEM_name("SYSTEM", 6, &my_charset_latin1);
  819. /*
  820.   Instance of this class represents local time zone used on this system
  821.   (specified by TZ environment variable or via any other system mechanism).
  822.   It uses system functions (localtime_r, my_system_gmt_sec) for conversion
  823.   and is always available. Because of this it is used by default - if there
  824.   were no explicit time zone specified. On the other hand because of this
  825.   conversion methods provided by this class is significantly slower and
  826.   possibly less multi-threaded-friendly than corresponding Time_zone_db
  827.   methods so the latter should be preffered there it is possible.
  828. */
  829. class Time_zone_system : public Time_zone
  830. {
  831. public:
  832.   virtual my_time_t TIME_to_gmt_sec(const TIME *t,
  833.                                     bool *in_dst_time_gap) const;
  834.   virtual void gmt_sec_to_TIME(TIME *tmp, my_time_t t) const;
  835.   virtual const String * get_name() const;
  836. };
  837. /*
  838.   Converts local time in system time zone in TIME representation
  839.   to its my_time_t representation.
  840.   SYNOPSIS
  841.     TIME_to_gmt_sec()
  842.       t               - pointer to TIME structure with local time in
  843.                         broken-down representation.
  844.       in_dst_time_gap - pointer to bool which is set to true if datetime
  845.                         value passed doesn't really exist (i.e. falls into
  846.                         spring time-gap) and is not touched otherwise.
  847.   DESCRIPTION
  848.     This method uses system function (localtime_r()) for conversion
  849.     local time in system time zone in TIME structure to its my_time_t
  850.     representation. Unlike the same function for Time_zone_db class
  851.     it it won't handle unnormalized input properly. Still it will
  852.     return lowest possible my_time_t in case of ambiguity or if we
  853.     provide time corresponding to the time-gap.
  854.     You should call init_time() function before using this function.
  855.   RETURN VALUE
  856.     Corresponding my_time_t value or 0 in case of error
  857. */
  858. my_time_t
  859. Time_zone_system::TIME_to_gmt_sec(const TIME *t, bool *in_dst_time_gap) const
  860. {
  861.   long not_used;
  862.   return my_system_gmt_sec(t, &not_used, in_dst_time_gap);
  863. }
  864. /*
  865.   Converts time from UTC seconds since Epoch (my_time_t) representation
  866.   to system local time zone broken-down representation.
  867.   SYNOPSIS
  868.     gmt_sec_to_TIME()
  869.       tmp - pointer to TIME structure to fill-in
  870.       t   - my_time_t value to be converted
  871.   NOTE
  872.     We assume that value passed to this function will fit into time_t range
  873.     supported by localtime_r. This conversion is putting restriction on
  874.     TIMESTAMP range in MySQL. If we can get rid of SYSTEM time zone at least
  875.     for interaction with client then we can extend TIMESTAMP range down to
  876.     the 1902 easily.
  877. */
  878. void
  879. Time_zone_system::gmt_sec_to_TIME(TIME *tmp, my_time_t t) const
  880. {
  881.   struct tm tmp_tm;
  882.   time_t tmp_t= (time_t)t;
  883.   localtime_r(&tmp_t, &tmp_tm);
  884.   localtime_to_TIME(tmp, &tmp_tm);
  885.   tmp->time_type= MYSQL_TIMESTAMP_DATETIME;
  886. }
  887. /*
  888.   Get name of time zone
  889.   SYNOPSIS
  890.     get_name()
  891.   RETURN VALUE
  892.     Name of time zone as String
  893. */
  894. const String *
  895. Time_zone_system::get_name() const
  896. {
  897.   return &tz_SYSTEM_name;
  898. }
  899. /*
  900.   Instance of this class represents UTC time zone. It uses system gmtime_r
  901.   function for conversions and is always available. It is used only for
  902.   my_time_t -> TIME conversions in various UTC_...  functions, it is not
  903.   intended for TIME -> my_time_t conversions and shouldn't be exposed to user.
  904. */
  905. class Time_zone_utc : public Time_zone
  906. {
  907. public:
  908.   virtual my_time_t TIME_to_gmt_sec(const TIME *t,
  909.                                     bool *in_dst_time_gap) const;
  910.   virtual void gmt_sec_to_TIME(TIME *tmp, my_time_t t) const;
  911.   virtual const String * get_name() const;
  912. };
  913. /*
  914.   Convert UTC time from TIME representation to its my_time_t representation.
  915.   SYNOPSIS
  916.     TIME_to_gmt_sec()
  917.       t               - pointer to TIME structure with local time
  918.                         in broken-down representation.
  919.       in_dst_time_gap - pointer to bool which is set to true if datetime
  920.                         value passed doesn't really exist (i.e. falls into
  921.                         spring time-gap) and is not touched otherwise.
  922.   DESCRIPTION
  923.     Since Time_zone_utc is used only internally for my_time_t -> TIME
  924.     conversions, this function of Time_zone interface is not implemented for
  925.     this class and should not be called.
  926.   RETURN VALUE
  927.     0
  928. */
  929. my_time_t
  930. Time_zone_utc::TIME_to_gmt_sec(const TIME *t, bool *in_dst_time_gap) const
  931. {
  932.   /* Should be never called */
  933.   DBUG_ASSERT(0);
  934.   return 0;
  935. }
  936. /*
  937.   Converts time from UTC seconds since Epoch (my_time_t) representation
  938.   to broken-down representation (also in UTC).
  939.   SYNOPSIS
  940.     gmt_sec_to_TIME()
  941.       tmp - pointer to TIME structure to fill-in
  942.       t   - my_time_t value to be converted
  943.   NOTE
  944.     See note for apropriate Time_zone_system method.
  945. */
  946. void
  947. Time_zone_utc::gmt_sec_to_TIME(TIME *tmp, my_time_t t) const
  948. {
  949.   struct tm tmp_tm;
  950.   time_t tmp_t= (time_t)t;
  951.   gmtime_r(&tmp_t, &tmp_tm);
  952.   localtime_to_TIME(tmp, &tmp_tm);
  953.   tmp->time_type= MYSQL_TIMESTAMP_DATETIME;
  954. }
  955. /*
  956.   Get name of time zone
  957.   SYNOPSIS
  958.     get_name()
  959.   DESCRIPTION
  960.     Since Time_zone_utc is used only internally by SQL's UTC_* functions it
  961.     is not accessible directly, and hence this function of Time_zone
  962.     interface is not implemented for this class and should not be called.
  963.   RETURN VALUE
  964.     0
  965. */
  966. const String *
  967. Time_zone_utc::get_name() const
  968. {
  969.   /* Should be never called */
  970.   DBUG_ASSERT(0);
  971.   return 0;
  972. }
  973. /*
  974.   Instance of this class represents some time zone which is
  975.   described in mysql.time_zone family of tables.
  976. */
  977. class Time_zone_db : public Time_zone
  978. {
  979. public:
  980.   Time_zone_db(TIME_ZONE_INFO *tz_info_arg, const String * tz_name_arg);
  981.   virtual my_time_t TIME_to_gmt_sec(const TIME *t,
  982.                                     bool *in_dst_time_gap) const;
  983.   virtual void gmt_sec_to_TIME(TIME *tmp, my_time_t t) const;
  984.   virtual const String * get_name() const;
  985. private:
  986.   TIME_ZONE_INFO *tz_info;
  987.   const String *tz_name;
  988. };
  989. /*
  990.   Initializes object representing time zone described by mysql.time_zone
  991.   tables.
  992.   SYNOPSIS
  993.     Time_zone_db()
  994.       tz_info_arg - pointer to TIME_ZONE_INFO structure which is filled
  995.                     according to db or other time zone description
  996.                     (for example by my_tz_init()).
  997.                     Several Time_zone_db instances can share one
  998.                     TIME_ZONE_INFO structure.
  999.       tz_name_arg - name of time zone.
  1000. */
  1001. Time_zone_db::Time_zone_db(TIME_ZONE_INFO *tz_info_arg,
  1002.                            const String *tz_name_arg):
  1003.   tz_info(tz_info_arg), tz_name(tz_name_arg)
  1004. {
  1005. }
  1006. /*
  1007.   Converts local time in time zone described from TIME
  1008.   representation to its my_time_t representation.
  1009.   SYNOPSIS
  1010.     TIME_to_gmt_sec()
  1011.       t               - pointer to TIME structure with local time
  1012.                         in broken-down representation.
  1013.       in_dst_time_gap - pointer to bool which is set to true if datetime
  1014.                         value passed doesn't really exist (i.e. falls into
  1015.                         spring time-gap) and is not touched otherwise.
  1016.   DESCRIPTION
  1017.     Please see ::TIME_to_gmt_sec for function description and
  1018.     parameter restrictions.
  1019.   RETURN VALUE
  1020.     Corresponding my_time_t value or 0 in case of error
  1021. */
  1022. my_time_t
  1023. Time_zone_db::TIME_to_gmt_sec(const TIME *t, bool *in_dst_time_gap) const
  1024. {
  1025.   return ::TIME_to_gmt_sec(t, tz_info, in_dst_time_gap);
  1026. }
  1027. /*
  1028.   Converts time from UTC seconds since Epoch (my_time_t) representation
  1029.   to local time zone described in broken-down representation.
  1030.   SYNOPSIS
  1031.     gmt_sec_to_TIME()
  1032.       tmp - pointer to TIME structure to fill-in
  1033.       t   - my_time_t value to be converted
  1034. */
  1035. void
  1036. Time_zone_db::gmt_sec_to_TIME(TIME *tmp, my_time_t t) const
  1037. {
  1038.   ::gmt_sec_to_TIME(tmp, t, tz_info);
  1039. }
  1040. /*
  1041.   Get name of time zone
  1042.   SYNOPSIS
  1043.     get_name()
  1044.   RETURN VALUE
  1045.     Name of time zone as ASCIIZ-string
  1046. */
  1047. const String *
  1048. Time_zone_db::get_name() const
  1049. {
  1050.   return tz_name;
  1051. }
  1052. /*
  1053.   Instance of this class represents time zone which
  1054.   was specified as offset from UTC.
  1055. */
  1056. class Time_zone_offset : public Time_zone
  1057. {
  1058. public:
  1059.   Time_zone_offset(long tz_offset_arg);
  1060.   virtual my_time_t TIME_to_gmt_sec(const TIME *t,
  1061.                                     bool *in_dst_time_gap) const;
  1062.   virtual void   gmt_sec_to_TIME(TIME *tmp, my_time_t t) const;
  1063.   virtual const String * get_name() const;
  1064.   /*
  1065.     This have to be public because we want to be able to access it from
  1066.     my_offset_tzs_get_key() function
  1067.   */
  1068.   long offset;
  1069. private:
  1070.   /* Extra reserve because of snprintf */
  1071.   char name_buff[7+16];
  1072.   String name;
  1073. };
  1074. /*
  1075.   Initializes object representing time zone described by its offset from UTC.
  1076.   SYNOPSIS
  1077.     Time_zone_offset()
  1078.       tz_offset_arg - offset from UTC in seconds.
  1079.                       Positive for direction to east.
  1080. */
  1081. Time_zone_offset::Time_zone_offset(long tz_offset_arg):
  1082.   offset(tz_offset_arg)
  1083. {
  1084.   uint hours= abs((int)(offset / SECS_PER_HOUR));
  1085.   uint minutes= abs((int)(offset % SECS_PER_HOUR / SECS_PER_MIN));
  1086.   ulong length= my_snprintf(name_buff, sizeof(name_buff), "%s%02d:%02d",
  1087.                             (offset>=0) ? "+" : "-", hours, minutes);
  1088.   name.set(name_buff, length, &my_charset_latin1);
  1089. }
  1090. /*
  1091.   Converts local time in time zone described as offset from UTC
  1092.   from TIME representation to its my_time_t representation.
  1093.   SYNOPSIS
  1094.     TIME_to_gmt_sec()
  1095.       t               - pointer to TIME structure with local time
  1096.                         in broken-down representation.
  1097.       in_dst_time_gap - pointer to bool which should be set to true if
  1098.                         datetime  value passed doesn't really exist
  1099.                         (i.e. falls into spring time-gap) and is not
  1100.                         touched otherwise.
  1101.                         It is not really used in this class.
  1102.   RETURN VALUE
  1103.     Corresponding my_time_t value or 0 in case of error
  1104. */
  1105. my_time_t
  1106. Time_zone_offset::TIME_to_gmt_sec(const TIME *t, bool *in_dst_time_gap) const
  1107. {
  1108.   return sec_since_epoch(t->year, t->month, t->day,
  1109.                          t->hour, t->minute, t->second) -
  1110.          offset;
  1111. }
  1112. /*
  1113.   Converts time from UTC seconds since Epoch (my_time_t) representation
  1114.   to local time zone described as offset from UTC and in broken-down
  1115.   representation.
  1116.   SYNOPSIS
  1117.     gmt_sec_to_TIME()
  1118.       tmp - pointer to TIME structure to fill-in
  1119.       t   - my_time_t value to be converted
  1120. */
  1121. void
  1122. Time_zone_offset::gmt_sec_to_TIME(TIME *tmp, my_time_t t) const
  1123. {
  1124.   sec_to_TIME(tmp, t, offset);
  1125. }
  1126. /*
  1127.   Get name of time zone
  1128.   SYNOPSIS
  1129.     get_name()
  1130.   RETURN VALUE
  1131.     Name of time zone as pointer to String object
  1132. */
  1133. const String *
  1134. Time_zone_offset::get_name() const
  1135. {
  1136.   return &name;
  1137. }
  1138. static Time_zone_utc tz_UTC;
  1139. static Time_zone_system tz_SYSTEM;
  1140. Time_zone *my_tz_UTC= &tz_UTC;
  1141. Time_zone *my_tz_SYSTEM= &tz_SYSTEM;
  1142. static HASH tz_names;
  1143. static HASH offset_tzs;
  1144. static MEM_ROOT tz_storage;
  1145. /*
  1146.   These mutex protects offset_tzs and tz_storage.
  1147.   These protection needed only when we are trying to set
  1148.   time zone which is specified as offset, and searching for existing
  1149.   time zone in offset_tzs or creating if it didn't existed before in
  1150.   tz_storage. So contention is low.
  1151. */
  1152. static pthread_mutex_t tz_LOCK;
  1153. static bool tz_inited= 0;
  1154. /*
  1155.   This two static variables are inteded for holding info about leap seconds
  1156.   shared by all time zones.
  1157. */
  1158. static uint tz_leapcnt= 0;
  1159. static LS_INFO *tz_lsis= 0;
  1160. /*
  1161.   Shows whenever we have found time zone tables during start-up.
  1162.   Used for avoiding of putting those tables to global table list
  1163.   for queries that use time zone info.
  1164. */
  1165. static bool time_zone_tables_exist= 1;
  1166. typedef struct st_tz_names_entry: public Sql_alloc
  1167. {
  1168.   String name;
  1169.   Time_zone *tz;
  1170. } TZ_NAMES_ENTRY;
  1171. /*
  1172.   We are going to call both of these functions from C code so
  1173.   they should obey C calling conventions.
  1174. */
  1175. extern "C" byte* my_tz_names_get_key(TZ_NAMES_ENTRY *entry, uint *length,
  1176.                               my_bool not_used __attribute__((unused)))
  1177. {
  1178.   *length= entry->name.length();
  1179.   return (byte*) entry->name.ptr();
  1180. }
  1181. extern "C" byte* my_offset_tzs_get_key(Time_zone_offset *entry, uint *length,
  1182.                               my_bool not_used __attribute__((unused)))
  1183. {
  1184.   *length= sizeof(long);
  1185.   return (byte*) &entry->offset;
  1186. }
  1187. /*
  1188.   Prepare table list with time zone related tables from preallocated array.
  1189.   SYNOPSIS
  1190.     tz_init_table_list()
  1191.       tz_tabs - pointer to preallocated array of 4 TABLE_LIST objects.
  1192.   DESCRIPTION
  1193.     This function prepares list of TABLE_LIST objects which can be used
  1194.     for opening of time zone tables from preallocated array.
  1195. */
  1196. void
  1197. tz_init_table_list(TABLE_LIST *tz_tabs)
  1198. {
  1199.   bzero(tz_tabs, sizeof(TABLE_LIST) * 4);
  1200.   tz_tabs[0].alias= tz_tabs[0].real_name= (char*)"time_zone_name";
  1201.   tz_tabs[1].alias= tz_tabs[1].real_name= (char*)"time_zone";
  1202.   tz_tabs[2].alias= tz_tabs[2].real_name= (char*)"time_zone_transition_type";
  1203.   tz_tabs[3].alias= tz_tabs[3].real_name= (char*)"time_zone_transition";
  1204.   tz_tabs[0].next= tz_tabs+1;
  1205.   tz_tabs[1].next= tz_tabs+2;
  1206.   tz_tabs[2].next= tz_tabs+3;
  1207.   tz_tabs[0].lock_type= tz_tabs[1].lock_type= tz_tabs[2].lock_type=
  1208.     tz_tabs[3].lock_type= TL_READ;
  1209.   tz_tabs[0].db= tz_tabs[1].db= tz_tabs[2].db= tz_tabs[3].db= (char *)"mysql";
  1210. }
  1211. /*
  1212.   Create table list with time zone related tables.
  1213.   SYNOPSIS
  1214.     my_tz_get_table_list()
  1215.       thd     - current thread object
  1216.   DESCRIPTION
  1217.     This function creates list of TABLE_LIST objects allocated in thd's
  1218.     memroot, which can be used for opening of time zone tables.
  1219.   NOTE
  1220.     my_tz_check_n_skip_implicit_tables() function depends on fact that
  1221.     elements of list created are allocated as TABLE_LIST[4] array.
  1222.   RETURN VALUES
  1223.     Returns pointer to first TABLE_LIST object, (could be 0 if time zone
  1224.     tables don't exist) and &fake_time_zone_tables_list in case of error.
  1225. */
  1226. TABLE_LIST *
  1227. my_tz_get_table_list(THD *thd)
  1228. {
  1229.   TABLE_LIST *tz_tabs;
  1230.   if (!time_zone_tables_exist)
  1231.     return 0;
  1232.   if (!(tz_tabs= (TABLE_LIST *)thd->alloc(sizeof(TABLE_LIST) * 4)))
  1233.     return &fake_time_zone_tables_list;
  1234.   tz_init_table_list(tz_tabs);
  1235.   return tz_tabs;
  1236. }
  1237. /*
  1238.   Initialize time zone support infrastructure.
  1239.   SYNOPSIS
  1240.     my_tz_init()
  1241.       thd            - current thread object
  1242.       default_tzname - default time zone or 0 if none.
  1243.       bootstrap      - indicates whenever we are in bootstrap mode
  1244.   DESCRIPTION
  1245.     This function will init memory structures needed for time zone support,
  1246.     it will register mandatory SYSTEM time zone in them. It will try to open
  1247.     mysql.time_zone* tables and load information about default time zone and
  1248.     information which further will be shared among all time zones loaded.
  1249.     If system tables with time zone descriptions don't exist it won't fail
  1250.     (unless default_tzname is time zone from tables). If bootstrap parameter
  1251.     is true then this routine assumes that we are in bootstrap mode and won't
  1252.     load time zone descriptions unless someone specifies default time zone
  1253.     which is supposedly stored in those tables.
  1254.     It'll also set default time zone if it is specified.
  1255.   RETURN VALUES
  1256.     0 - ok
  1257.     1 - Error
  1258. */
  1259. my_bool
  1260. my_tz_init(THD *org_thd, const char *default_tzname, my_bool bootstrap)
  1261. {
  1262.   THD *thd;
  1263.   TABLE_LIST *tables= 0;
  1264.   TABLE_LIST tables_buff[5];
  1265.   TABLE *table;
  1266.   TZ_NAMES_ENTRY *tmp_tzname;
  1267.   my_bool return_val= 1;
  1268.   int res;
  1269.   uint counter;
  1270.   DBUG_ENTER("my_tz_init");
  1271.   /*
  1272.     To be able to run this from boot, we allocate a temporary THD
  1273.   */
  1274.   if (!(thd= new THD))
  1275.     DBUG_RETURN(1);
  1276.   thd->store_globals();
  1277.   /* Init all memory structures that require explicit destruction */
  1278.   if (hash_init(&tz_names, &my_charset_latin1, 20,
  1279.                 0, 0, (hash_get_key)my_tz_names_get_key, 0, 0))
  1280.   {
  1281.     sql_print_error("Fatal error: OOM while initializing time zones");
  1282.     goto end;
  1283.   }
  1284.   if (hash_init(&offset_tzs, &my_charset_latin1, 26, 0, 0,
  1285.                 (hash_get_key)my_offset_tzs_get_key, 0, 0))
  1286.   {
  1287.     sql_print_error("Fatal error: OOM while initializing time zones");
  1288.     hash_free(&tz_names);
  1289.     goto end;
  1290.   }
  1291.   init_alloc_root(&tz_storage, 32 * 1024, 0);
  1292.   VOID(pthread_mutex_init(&tz_LOCK, MY_MUTEX_INIT_FAST));
  1293.   tz_inited= 1;
  1294.   /* Add 'SYSTEM' time zone to tz_names hash */
  1295.   if (!(tmp_tzname= new (&tz_storage) TZ_NAMES_ENTRY()))
  1296.   {
  1297.     sql_print_error("Fatal error: OOM while initializing time zones");
  1298.     goto end_with_cleanup;
  1299.   }
  1300.   tmp_tzname->name.set("SYSTEM", 6, &my_charset_latin1);
  1301.   tmp_tzname->tz= my_tz_SYSTEM;
  1302.   if (my_hash_insert(&tz_names, (const byte *)tmp_tzname))
  1303.   {
  1304.     sql_print_error("Fatal error: OOM while initializing time zones");
  1305.     goto end_with_cleanup;
  1306.   }
  1307.   if (bootstrap)
  1308.   {
  1309.     /* If we are in bootstrap mode we should not load time zone tables */
  1310.     return_val= time_zone_tables_exist= 0;
  1311.     goto end_with_setting_default_tz;
  1312.   }
  1313.   /*
  1314.     After this point all memory structures are inited and we even can live
  1315.     without time zone description tables. Now try to load information about
  1316.     leap seconds shared by all time zones.
  1317.   */
  1318.   thd->db= my_strdup("mysql",MYF(0));
  1319.   thd->db_length= 5; // Safety
  1320.   bzero((char*) &tables_buff, sizeof(TABLE_LIST));
  1321.   tables_buff[0].alias= tables_buff[0].real_name=
  1322.     (char*)"time_zone_leap_second";
  1323.   tables_buff[0].lock_type= TL_READ;
  1324.   tables_buff[0].db= thd->db;
  1325.   tables_buff[0].next= tables_buff + 1;
  1326.   /* Fill TABLE_LIST for rest of the time zone describing tables */
  1327.   tz_init_table_list(tables_buff + 1);
  1328.   if (open_tables(thd, tables_buff, &counter) ||
  1329.       lock_tables(thd, tables_buff, counter))
  1330.   {
  1331.     sql_print_warning("Can't open and lock time zone table: %s "
  1332.                       "trying to live without them", thd->net.last_error);
  1333.     /* We will try emulate that everything is ok */
  1334.     return_val= time_zone_tables_exist= 0;
  1335.     goto end_with_setting_default_tz;
  1336.   }
  1337.   tables= tables_buff + 1;
  1338.   /*
  1339.     Now we are going to load leap seconds descriptions that are shared
  1340.     between all time zones that use them. We are using index for getting
  1341.     records in proper order. Since we share the same MEM_ROOT between
  1342.     all time zones we just allocate enough memory for it first.
  1343.   */
  1344.   if (!(tz_lsis= (LS_INFO*) alloc_root(&tz_storage,
  1345.                                        sizeof(LS_INFO) * TZ_MAX_LEAPS)))
  1346.   {
  1347.     sql_print_error("Fatal error: Out of memory while loading "
  1348.                     "mysql.time_zone_leap_second table");
  1349.     goto end_with_close;
  1350.   }
  1351.   table= tables_buff[0].table;
  1352.   /*
  1353.     It is OK to ignore ha_index_init()/ha_index_end() return values since
  1354.     mysql.time_zone* tables are MyISAM and these operations always succeed
  1355.     for MyISAM.
  1356.   */
  1357.   (void)table->file->ha_index_init(0);
  1358.   tz_leapcnt= 0;
  1359.   res= table->file->index_first(table->record[0]);
  1360.   while (!res)
  1361.   {
  1362.     if (tz_leapcnt + 1 > TZ_MAX_LEAPS)
  1363.     {
  1364.       sql_print_error("Fatal error: While loading mysql.time_zone_leap_second"
  1365.                       " table: too much leaps");
  1366.       table->file->ha_index_end();
  1367.       goto end_with_close;
  1368.     }
  1369.     tz_lsis[tz_leapcnt].ls_trans= (my_time_t)table->field[0]->val_int();
  1370.     tz_lsis[tz_leapcnt].ls_corr= (long)table->field[1]->val_int();
  1371.     tz_leapcnt++;
  1372.     DBUG_PRINT("info",
  1373.       ("time_zone_leap_second table: tz_leapcnt=%u tt_time=%lld offset=%ld",
  1374.        tz_leapcnt, (longlong)tz_lsis[tz_leapcnt-1].ls_trans,
  1375.        tz_lsis[tz_leapcnt-1].ls_corr));
  1376.     res= table->file->index_next(table->record[0]);
  1377.   }
  1378.   (void)table->file->ha_index_end();
  1379.   if (res != HA_ERR_END_OF_FILE)
  1380.   {
  1381.     sql_print_error("Fatal error: Error while loading "
  1382.                     "mysql.time_zone_leap_second table");
  1383.     goto end_with_close;
  1384.   }
  1385.   /*
  1386.     Loading of info about leap seconds succeeded
  1387.   */
  1388.   return_val= 0;
  1389. end_with_setting_default_tz:
  1390.   /* If we have default time zone try to load it */
  1391.   if (default_tzname)
  1392.   {
  1393.     String tmp_tzname(default_tzname, &my_charset_latin1);
  1394.     if (!(global_system_variables.time_zone= my_tz_find(&tmp_tzname, tables)))
  1395.     {
  1396.       sql_print_error("Fatal error: Illegal or unknown default time zone '%s'",
  1397.                       default_tzname);
  1398.       return_val= 1;
  1399.     }
  1400.   }
  1401. end_with_close:
  1402.   thd->version--; /* Force close to free memory */
  1403.   close_thread_tables(thd);
  1404. end_with_cleanup:
  1405.   /* if there were error free time zone describing structs */
  1406.   if (return_val)
  1407.     my_tz_free();
  1408. end:
  1409.   delete thd;
  1410.   if (org_thd)
  1411.     org_thd->store_globals(); /* purecov: inspected */
  1412.   else
  1413.   {
  1414.     /* Remember that we don't have a THD */
  1415.     my_pthread_setspecific_ptr(THR_THD,  0);
  1416.     my_pthread_setspecific_ptr(THR_MALLOC,  0);
  1417.   }
  1418.   DBUG_RETURN(return_val);
  1419. }
  1420. /*
  1421.   Free resources used by time zone support infrastructure.
  1422.   SYNOPSIS
  1423.     my_tz_free()
  1424. */
  1425. void my_tz_free()
  1426. {
  1427.   if (tz_inited)
  1428.   {
  1429.     tz_inited= 0;
  1430.     VOID(pthread_mutex_destroy(&tz_LOCK));
  1431.     hash_free(&offset_tzs);
  1432.     hash_free(&tz_names);
  1433.     free_root(&tz_storage, MYF(0));
  1434.   }
  1435. }
  1436. /*
  1437.   Load time zone description from system tables.
  1438.   SYNOPSIS
  1439.     tz_load_from_open_tables()
  1440.       tz_name   - name of time zone that should be loaded.
  1441.       tz_tables - list of tables from which time zone description
  1442.                   should be loaded
  1443.   DESCRIPTION
  1444.     This function will try to load information about time zone specified
  1445.     from the list of the already opened and locked tables (first table in
  1446.     tz_tables should be time_zone_name, next time_zone, then
  1447.     time_zone_transition_type and time_zone_transition should be last).
  1448.     It will also update information in hash used for time zones lookup.
  1449.   RETURN VALUES
  1450.     Returns pointer to newly created Time_zone object or 0 in case of error.
  1451. */
  1452. static Time_zone*
  1453. tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
  1454. {
  1455.   TABLE *table= 0;
  1456.   TIME_ZONE_INFO *tz_info;
  1457.   TZ_NAMES_ENTRY *tmp_tzname;
  1458.   Time_zone *return_val= 0;
  1459.   int res;
  1460.   uint tzid, ttid;
  1461.   my_time_t ttime;
  1462.   char buff[MAX_FIELD_WIDTH];
  1463.   String abbr(buff, sizeof(buff), &my_charset_latin1);
  1464.   char *alloc_buff, *tz_name_buff;
  1465.   /*
  1466.     Temporary arrays that are used for loading of data for filling
  1467.     TIME_ZONE_INFO structure
  1468.   */
  1469.   my_time_t ats[TZ_MAX_TIMES];
  1470.   unsigned char types[TZ_MAX_TIMES];
  1471.   TRAN_TYPE_INFO ttis[TZ_MAX_TYPES];
  1472. #ifdef ABBR_ARE_USED
  1473.   char chars[max(TZ_MAX_CHARS + 1, (2 * (MY_TZNAME_MAX + 1)))];
  1474. #endif
  1475.   DBUG_ENTER("tz_load_from_open_tables");
  1476.   /* Prepare tz_info for loading also let us make copy of time zone name */
  1477.   if (!(alloc_buff= alloc_root(&tz_storage, sizeof(TIME_ZONE_INFO) +
  1478.                                tz_name->length() + 1)))
  1479.   {
  1480.     sql_print_error("Out of memory while loading time zone description");
  1481.     return 0;
  1482.   }
  1483.   tz_info= (TIME_ZONE_INFO *)alloc_buff;
  1484.   bzero(tz_info, sizeof(TIME_ZONE_INFO));
  1485.   tz_name_buff= alloc_buff + sizeof(TIME_ZONE_INFO);
  1486.   /*
  1487.     By writing zero to the end we guarantee that we can call ptr()
  1488.     instead of c_ptr() for time zone name.
  1489.   */
  1490.   strmake(tz_name_buff, tz_name->ptr(), tz_name->length());
  1491.   /*
  1492.     Let us find out time zone id by its name (there is only one index
  1493.     and it is specifically for this purpose).
  1494.   */
  1495.   table= tz_tables->table;
  1496.   tz_tables= tz_tables->next;
  1497.   table->field[0]->store(tz_name->ptr(), tz_name->length(), &my_charset_latin1);
  1498.   /*
  1499.     It is OK to ignore ha_index_init()/ha_index_end() return values since
  1500.     mysql.time_zone* tables are MyISAM and these operations always succeed
  1501.     for MyISAM.
  1502.   */
  1503.   (void)table->file->ha_index_init(0);
  1504.   if (table->file->index_read(table->record[0], (byte*)table->field[0]->ptr,
  1505.                               0, HA_READ_KEY_EXACT))
  1506.   {
  1507. #ifdef EXTRA_DEBUG    
  1508.     /*
  1509.       Most probably user has mistyped time zone name, so no need to bark here
  1510.       unless we need it for debugging.
  1511.     */
  1512.     sql_print_error("Can't find description of time zone '%s'", tz_name_buff);
  1513. #endif
  1514.     goto end;
  1515.   }
  1516.   tzid= (uint)table->field[1]->val_int();
  1517.   (void)table->file->ha_index_end();
  1518.   /*
  1519.     Now we need to lookup record in mysql.time_zone table in order to
  1520.     understand whenever this timezone uses leap seconds (again we are
  1521.     using the only index in this table).
  1522.   */
  1523.   table= tz_tables->table;
  1524.   tz_tables= tz_tables->next;
  1525.   table->field[0]->store((longlong)tzid);
  1526.   (void)table->file->ha_index_init(0);
  1527.   if (table->file->index_read(table->record[0], (byte*)table->field[0]->ptr,
  1528.                               0, HA_READ_KEY_EXACT))
  1529.   {
  1530.     sql_print_error("Can't find description of time zone '%u'", tzid);
  1531.     goto end;
  1532.   }
  1533.   /* If Uses_leap_seconds == 'Y' */
  1534.   if (table->field[1]->val_int() == 1)
  1535.   {
  1536.     tz_info->leapcnt= tz_leapcnt;
  1537.     tz_info->lsis= tz_lsis;
  1538.   }
  1539.   (void)table->file->ha_index_end();
  1540.   /*
  1541.     Now we will iterate through records for out time zone in
  1542.     mysql.time_zone_transition_type table. Because we want records
  1543.     only for our time zone guess what are we doing?
  1544.     Right - using special index.
  1545.   */
  1546.   table= tz_tables->table;
  1547.   tz_tables= tz_tables->next;
  1548.   table->field[0]->store((longlong)tzid);
  1549.   (void)table->file->ha_index_init(0);
  1550.   // FIXME Is there any better approach than explicitly specifying 4 ???
  1551.   res= table->file->index_read(table->record[0], (byte*)table->field[0]->ptr,
  1552.                                4, HA_READ_KEY_EXACT);
  1553.   while (!res)
  1554.   {
  1555.     ttid= (uint)table->field[1]->val_int();
  1556.     if (ttid >= TZ_MAX_TYPES)
  1557.     {
  1558.       sql_print_error("Error while loading time zone description from "
  1559.                       "mysql.time_zone_transition_type table: too big "
  1560.                       "transition type id");
  1561.       goto end;
  1562.     }
  1563.     ttis[ttid].tt_gmtoff= (long)table->field[2]->val_int();
  1564.     ttis[ttid].tt_isdst= (table->field[3]->val_int() > 0);
  1565. #ifdef ABBR_ARE_USED
  1566.     // FIXME should we do something with duplicates here ?
  1567.     table->field[4]->val_str(&abbr, &abbr);
  1568.     if (tz_info->charcnt + abbr.length() + 1 > sizeof(chars))
  1569.     {
  1570.       sql_print_error("Error while loading time zone description from "
  1571.                       "mysql.time_zone_transition_type table: not enough "
  1572.                       "room for abbreviations");
  1573.       goto end;
  1574.     }
  1575.     ttis[ttid].tt_abbrind= tz_info->charcnt;
  1576.     memcpy(chars + tz_info->charcnt, abbr.ptr(), abbr.length());
  1577.     tz_info->charcnt+= abbr.length();
  1578.     chars[tz_info->charcnt]= 0;
  1579.     tz_info->charcnt++;
  1580.     DBUG_PRINT("info",
  1581.       ("time_zone_transition_type table: tz_id=%u tt_id=%u tt_gmtoff=%ld "
  1582.        "abbr='%s' tt_isdst=%u", tzid, ttid, ttis[ttid].tt_gmtoff,
  1583.        chars + ttis[ttid].tt_abbrind, ttis[ttid].tt_isdst));
  1584. #else
  1585.     DBUG_PRINT("info",
  1586.       ("time_zone_transition_type table: tz_id=%u tt_id=%u tt_gmtoff=%ld "
  1587.        "tt_isdst=%u", tzid, ttid, ttis[ttid].tt_gmtoff, ttis[ttid].tt_isdst));
  1588. #endif
  1589.     /* ttid is increasing because we are reading using index */
  1590.     DBUG_ASSERT(ttid >= tz_info->typecnt);
  1591.     tz_info->typecnt= ttid + 1;
  1592.     res= table->file->index_next_same(table->record[0],
  1593.                                       (byte*)table->field[0]->ptr, 4);
  1594.   }
  1595.   if (res != HA_ERR_END_OF_FILE)
  1596.   {
  1597.     sql_print_error("Error while loading time zone description from "
  1598.                     "mysql.time_zone_transition_type table");
  1599.     goto end;
  1600.   }
  1601.   (void)table->file->ha_index_end();
  1602.   /*
  1603.     At last we are doing the same thing for records in
  1604.     mysql.time_zone_transition table. Here we additionaly need records
  1605.     in ascending order by index scan also satisfies us.
  1606.   */
  1607.   table= tz_tables->table; 
  1608.   table->field[0]->store((longlong)tzid);
  1609.   (void)table->file->ha_index_init(0);
  1610.   // FIXME Is there any better approach than explicitly specifying 4 ???
  1611.   res= table->file->index_read(table->record[0], (byte*)table->field[0]->ptr,
  1612.                                4, HA_READ_KEY_EXACT);
  1613.   while (!res)
  1614.   {
  1615.     ttime= (my_time_t)table->field[1]->val_int();
  1616.     ttid= (uint)table->field[2]->val_int();
  1617.     if (tz_info->timecnt + 1 > TZ_MAX_TIMES)
  1618.     {
  1619.       sql_print_error("Error while loading time zone description from "
  1620.                       "mysql.time_zone_transition table: "
  1621.                       "too much transitions");
  1622.       goto end;
  1623.     }
  1624.     if (ttid + 1 > tz_info->typecnt)
  1625.     {
  1626.       sql_print_error("Error while loading time zone description from "
  1627.                       "mysql.time_zone_transition table: "
  1628.                       "bad transition type id");
  1629.       goto end;
  1630.     }
  1631.     ats[tz_info->timecnt]= ttime;
  1632.     types[tz_info->timecnt]= ttid;
  1633.     tz_info->timecnt++;
  1634.     DBUG_PRINT("info",
  1635.       ("time_zone_transition table: tz_id=%u tt_time=%lld tt_id=%u",
  1636.        tzid, (longlong)ttime, ttid));
  1637.     res= table->file->index_next_same(table->record[0],
  1638.                                       (byte*)table->field[0]->ptr, 4);
  1639.   }
  1640.   /*
  1641.     We have to allow HA_ERR_KEY_NOT_FOUND because some time zones
  1642.     for example UTC have no transitons.
  1643.   */
  1644.   if (res != HA_ERR_END_OF_FILE && res != HA_ERR_KEY_NOT_FOUND)
  1645.   {
  1646.     sql_print_error("Error while loading time zone description from "
  1647.                     "mysql.time_zone_transition table");
  1648.     goto end;
  1649.   }
  1650.   (void)table->file->ha_index_end();
  1651.   table= 0;
  1652.   /*
  1653.     Now we will allocate memory and init TIME_ZONE_INFO structure.
  1654.   */
  1655.   if (!(alloc_buff= alloc_root(&tz_storage,
  1656.                                ALIGN_SIZE(sizeof(my_time_t) *
  1657.                                           tz_info->timecnt) +
  1658.                                ALIGN_SIZE(tz_info->timecnt) +
  1659. #ifdef ABBR_ARE_USED
  1660.                                ALIGN_SIZE(tz_info->charcnt) +
  1661. #endif
  1662.                                sizeof(TRAN_TYPE_INFO) * tz_info->typecnt)))
  1663.   {
  1664.     sql_print_error("Out of memory while loading time zone description");
  1665.     goto end;
  1666.   }
  1667.   tz_info->ats= (my_time_t *)alloc_buff;
  1668.   memcpy(tz_info->ats, ats, tz_info->timecnt * sizeof(my_time_t));
  1669.   alloc_buff+= ALIGN_SIZE(sizeof(my_time_t) * tz_info->timecnt);
  1670.   tz_info->types= (unsigned char *)alloc_buff;
  1671.   memcpy(tz_info->types, types, tz_info->timecnt);
  1672.   alloc_buff+= ALIGN_SIZE(tz_info->timecnt);
  1673. #ifdef ABBR_ARE_USED
  1674.   tz_info->chars= alloc_buff;
  1675.   memcpy(tz_info->chars, chars, tz_info->charcnt);
  1676.   alloc_buff+= ALIGN_SIZE(tz_info->charcnt);
  1677. #endif
  1678.   tz_info->ttis= (TRAN_TYPE_INFO *)alloc_buff;
  1679.   memcpy(tz_info->ttis, ttis, tz_info->typecnt * sizeof(TRAN_TYPE_INFO));
  1680.   /*
  1681.     Let us check how correct our time zone description and build
  1682.     reversed map. We don't check for tz->timecnt < 1 since it ok for GMT.
  1683.   */
  1684.   if (tz_info->typecnt < 1)
  1685.   {
  1686.     sql_print_error("loading time zone without transition types");
  1687.     goto end;
  1688.   }
  1689.   if (prepare_tz_info(tz_info, &tz_storage))
  1690.   {
  1691.     sql_print_error("Unable to build mktime map for time zone");
  1692.     goto end;
  1693.   }
  1694.   if (!(tmp_tzname= new (&tz_storage) TZ_NAMES_ENTRY()) ||
  1695.       !(tmp_tzname->tz= new (&tz_storage) Time_zone_db(tz_info,
  1696.                                             &(tmp_tzname->name))) ||
  1697.       (tmp_tzname->name.set(tz_name_buff, tz_name->length(),
  1698.                             &my_charset_latin1),
  1699.        my_hash_insert(&tz_names, (const byte *)tmp_tzname)))
  1700.   {
  1701.     sql_print_error("Out of memory while loading time zone");
  1702.     goto end;
  1703.   }
  1704.   /*
  1705.     Loading of time zone succeeded
  1706.   */
  1707.   return_val= tmp_tzname->tz;
  1708. end:
  1709.   if (table)
  1710.     (void)table->file->ha_index_end();
  1711.   DBUG_RETURN(return_val);
  1712. }
  1713. /*
  1714.   Parse string that specifies time zone as offset from UTC.
  1715.   SYNOPSIS
  1716.     str_to_offset()
  1717.       str    - pointer to string which contains offset
  1718.       length - length of string
  1719.       offset - out parameter for storing found offset in seconds.
  1720.   DESCRIPTION
  1721.     This function parses string which contains time zone offset
  1722.     in form similar to '+10:00' and converts found value to
  1723.     seconds from UTC form (east is positive).
  1724.   RETURN VALUE
  1725.     0 - Ok
  1726.     1 - String doesn't contain valid time zone offset
  1727. */
  1728. my_bool
  1729. str_to_offset(const char *str, uint length, long *offset)
  1730. {
  1731.   const char *end= str + length;
  1732.   my_bool negative;
  1733.   ulong number_tmp;
  1734.   long offset_tmp;
  1735.   if (length < 4)
  1736.     return 1;
  1737.   if (*str == '+')
  1738.     negative= 0;
  1739.   else if (*str == '-')
  1740.     negative= 1;
  1741.   else
  1742.     return 1;
  1743.   str++;
  1744.   number_tmp= 0;
  1745.   while (str < end && my_isdigit(&my_charset_latin1, *str))
  1746.   {
  1747.     number_tmp= number_tmp*10 + *str - '0';
  1748.     str++;
  1749.   }
  1750.   if (str + 1 >= end || *str != ':')
  1751.     return 1;
  1752.   str++;
  1753.   offset_tmp = number_tmp * MINS_PER_HOUR; number_tmp= 0;
  1754.   while (str < end && my_isdigit(&my_charset_latin1, *str))
  1755.   {
  1756.     number_tmp= number_tmp * 10 + *str - '0';
  1757.     str++;
  1758.   }
  1759.   if (str != end)
  1760.     return 1;
  1761.   offset_tmp= (offset_tmp + number_tmp) * SECS_PER_MIN;
  1762.   if (negative)
  1763.     offset_tmp= -offset_tmp;
  1764.   /*
  1765.     Check if offset is in range prescribed by standard
  1766.     (from -12:59 to 13:00).
  1767.   */
  1768.   if (number_tmp > 59 || offset_tmp < -13 * SECS_PER_HOUR + 1 ||
  1769.       offset_tmp > 13 * SECS_PER_HOUR)
  1770.     return 1;
  1771.   *offset= offset_tmp;
  1772.   return 0;
  1773. }
  1774. /*
  1775.   Get Time_zone object for specified time zone.
  1776.   SYNOPSIS
  1777.     my_tz_find()
  1778.       name - time zone specification
  1779.       tz_tables - list of opened'n'locked time zone describing tables
  1780.   DESCRIPTION
  1781.     This function checks if name is one of time zones described in db,
  1782.     predefined SYSTEM time zone or valid time zone specification as
  1783.     offset from UTC (In last case it will create proper Time_zone_offset
  1784.     object if there were not any.). If name is ok it returns corresponding
  1785.     Time_zone object.
  1786.     Clients of this function are not responsible for releasing resources
  1787.     occupied by returned Time_zone object so they can just forget pointers
  1788.     to Time_zone object if they are not needed longer.
  1789.     Other important property of this function: if some Time_zone found once
  1790.     it will be for sure found later, so this function can also be used for
  1791.     checking if proper Time_zone object exists (and if there will be error
  1792.     it will be reported during first call).
  1793.     If name pointer is 0 then this function returns 0 (this allows to pass 0
  1794.     values as parameter without additional external check and this property
  1795.     is used by @@time_zone variable handling code).
  1796.     It will perform lookup in system tables (mysql.time_zone*) if needed
  1797.     using tz_tables as list of already opened tables (for info about this
  1798.     list look at tz_load_from_open_tables() description). It won't perform
  1799.     such lookup if no time zone describing tables were found during server
  1800.     start up.
  1801.   RETURN VALUE
  1802.     Pointer to corresponding Time_zone object. 0 - in case of bad time zone
  1803.     specification or other error.
  1804. */
  1805. Time_zone *
  1806. my_tz_find(const String * name, TABLE_LIST *tz_tables)
  1807. {
  1808.   TZ_NAMES_ENTRY *tmp_tzname;
  1809.   Time_zone *result_tz= 0;
  1810.   long offset;
  1811.   DBUG_ENTER("my_tz_find");
  1812.   DBUG_PRINT("enter", ("time zone name='%s'",
  1813.                       name ? ((String *)name)->c_ptr() : "NULL"));
  1814.   DBUG_ASSERT(!time_zone_tables_exist || tz_tables);
  1815.   if (!name)
  1816.     DBUG_RETURN(0);
  1817.   VOID(pthread_mutex_lock(&tz_LOCK));
  1818.   if (!str_to_offset(name->ptr(), name->length(), &offset))
  1819.   {
  1820.     if (!(result_tz= (Time_zone_offset *)hash_search(&offset_tzs,
  1821.                                                      (const byte *)&offset,
  1822.                                                      sizeof(long))))
  1823.     {
  1824.       DBUG_PRINT("info", ("Creating new Time_zone_offset object"));
  1825.       if (!(result_tz= new (&tz_storage) Time_zone_offset(offset)) ||
  1826.           my_hash_insert(&offset_tzs, (const byte *) result_tz))
  1827.       {
  1828.         result_tz= 0;
  1829.         sql_print_error("Fatal error: Out of memory "
  1830.                         "while setting new time zone");
  1831.       }
  1832.     }
  1833.   }
  1834.   else
  1835.   {
  1836.     result_tz= 0;
  1837.     if ((tmp_tzname= (TZ_NAMES_ENTRY *)hash_search(&tz_names,
  1838.                                                    (const byte *)name->ptr(),
  1839.                                                    name->length())))
  1840.       result_tz= tmp_tzname->tz;
  1841.     else if (time_zone_tables_exist)
  1842.       result_tz= tz_load_from_open_tables(name, tz_tables);
  1843.   }
  1844.   VOID(pthread_mutex_unlock(&tz_LOCK));
  1845.   DBUG_RETURN(result_tz);
  1846. }
  1847. #endif /* !defined(TESTTIME) && !defined(TZINFO2SQL) */
  1848. #ifdef TZINFO2SQL
  1849. /*
  1850.   This code belongs to mysql_tzinfo_to_sql converter command line utility.
  1851.   This utility should be used by db admin for populating mysql.time_zone
  1852.   tables.
  1853. */
  1854. /*
  1855.   Print info about time zone described by TIME_ZONE_INFO struct as
  1856.   SQL statements populating mysql.time_zone* tables.
  1857.   SYNOPSIS
  1858.     print_tz_as_sql()
  1859.       tz_name - name of time zone
  1860.       sp      - structure describing time zone
  1861. */
  1862. void
  1863. print_tz_as_sql(const char* tz_name, const TIME_ZONE_INFO *sp)
  1864. {
  1865.   uint i;
  1866.   /* Here we assume that all time zones have same leap correction tables */
  1867.   printf("INSERT INTO time_zone (Use_leap_seconds) VALUES ('%s');n",
  1868.          sp->leapcnt ? "Y" : "N");
  1869.   printf("SET @time_zone_id= LAST_INSERT_ID();n");
  1870.   printf("INSERT INTO time_zone_name (Name, Time_zone_id) VALUES 
  1871. ('%s', @time_zone_id);n", tz_name);
  1872.   if (sp->timecnt)
  1873.   {
  1874.     printf("INSERT INTO time_zone_transition 
  1875. (Time_zone_id, Transition_time, Transition_type_id) VALUESn");
  1876.     for (i= 0; i < sp->timecnt; i++)
  1877.       printf("%s(@time_zone_id, %ld, %u)n", (i == 0 ? " " : ","), sp->ats[i],
  1878.              (uint)sp->types[i]);
  1879.     printf(";n");
  1880.   }
  1881.   printf("INSERT INTO time_zone_transition_type 
  1882. (Time_zone_id, Transition_type_id, Offset, Is_DST, Abbreviation) VALUESn");
  1883.   for (i= 0; i < sp->typecnt; i++)
  1884.     printf("%s(@time_zone_id, %u, %ld, %d, '%s')n", (i == 0 ? " " : ","), i,
  1885.            sp->ttis[i].tt_gmtoff, sp->ttis[i].tt_isdst,
  1886.            sp->chars + sp->ttis[i].tt_abbrind);
  1887.   printf(";n");
  1888. }
  1889. /*
  1890.   Print info about leap seconds in time zone as SQL statements
  1891.   populating mysql.time_zone_leap_second table.
  1892.   SYNOPSIS
  1893.     print_tz_leaps_as_sql()
  1894.       sp      - structure describing time zone
  1895. */
  1896. void
  1897. print_tz_leaps_as_sql(const TIME_ZONE_INFO *sp)
  1898. {
  1899.   uint i;
  1900.   /*
  1901.     We are assuming that there are only one list of leap seconds
  1902.     For all timezones.
  1903.   */
  1904.   printf("TRUNCATE TABLE time_zone_leap_second;n");
  1905.   if (sp->leapcnt)
  1906.   {
  1907.     printf("INSERT INTO time_zone_leap_second 
  1908. (Transition_time, Correction) VALUESn");
  1909.     for (i= 0; i < sp->leapcnt; i++)
  1910.       printf("%s(%ld, %ld)n", (i == 0 ? " " : ","),
  1911.              sp->lsis[i].ls_trans, sp->lsis[i].ls_corr);
  1912.     printf(";n");
  1913.   }
  1914.   printf("ALTER TABLE time_zone_leap_second ORDER BY Transition_time;n");
  1915. }
  1916. /*
  1917.   Some variables used as temporary or as parameters
  1918.   in recursive scan_tz_dir() code.
  1919. */
  1920. TIME_ZONE_INFO tz_info;
  1921. MEM_ROOT tz_storage;
  1922. char fullname[FN_REFLEN + 1];
  1923. char *root_name_end;
  1924. /*
  1925.   Recursively scan zoneinfo directory and print all found time zone
  1926.   descriptions as SQL.
  1927.   SYNOPSIS
  1928.     scan_tz_dir()
  1929.       name_end - pointer to end of path to directory to be searched.
  1930.   DESCRIPTION
  1931.     This auxiliary recursive function also uses several global
  1932.     variables as in parameters and for storing temporary values.
  1933.     fullname      - path to directory that should be scanned.
  1934.     root_name_end - pointer to place in fullname where part with
  1935.                     path to initial directory ends.
  1936.     current_tz_id - last used time zone id
  1937.   RETURN VALUE
  1938.     0 - Ok, 1 - Fatal error
  1939. */
  1940. my_bool
  1941. scan_tz_dir(char * name_end)
  1942. {
  1943.   MY_DIR *cur_dir;
  1944.   char *name_end_tmp;
  1945.   uint i;
  1946.   if (!(cur_dir= my_dir(fullname, MYF(MY_WANT_STAT))))
  1947.     return 1;
  1948.   name_end= strmake(name_end, "/", FN_REFLEN - (name_end - fullname));
  1949.   for (i= 0; i < cur_dir->number_off_files; i++)
  1950.   {
  1951.     if (cur_dir->dir_entry[i].name[0] != '.')
  1952.     {
  1953.       name_end_tmp= strmake(name_end, cur_dir->dir_entry[i].name,
  1954.                             FN_REFLEN - (name_end - fullname));
  1955.       if (MY_S_ISDIR(cur_dir->dir_entry[i].mystat->st_mode))
  1956.       {
  1957.         if (scan_tz_dir(name_end_tmp))
  1958.         {
  1959.           my_dirend(cur_dir);
  1960.           return 1;
  1961.         }
  1962.       }
  1963.       else if (MY_S_ISREG(cur_dir->dir_entry[i].mystat->st_mode))
  1964.       {
  1965.         init_alloc_root(&tz_storage, 32768, 0);
  1966.         if (!tz_load(fullname, &tz_info, &tz_storage))
  1967.           print_tz_as_sql(root_name_end + 1, &tz_info);
  1968.         else
  1969.           fprintf(stderr,
  1970.                   "Warning: Unable to load '%s' as time zone. Skipping it.n",
  1971.                   fullname);
  1972.         free_root(&tz_storage, MYF(0));
  1973.       }
  1974.       else
  1975.         fprintf(stderr, "Warning: '%s' is not regular file or directoryn",
  1976.                 fullname);
  1977.     }
  1978.   }
  1979.   my_dirend(cur_dir);
  1980.   return 0;
  1981. }
  1982. int
  1983. main(int argc, char **argv)
  1984. {
  1985.   MY_INIT(argv[0]);
  1986.   if (argc != 2 && argc != 3)
  1987.   {
  1988.     fprintf(stderr, "Usage:n");
  1989.     fprintf(stderr, " %s timezonedirn", argv[0]);
  1990.     fprintf(stderr, " %s timezonefile timezonenamen", argv[0]);
  1991.     fprintf(stderr, " %s --leap timezonefilen", argv[0]);
  1992.     return 1;
  1993.   }
  1994.   if (argc == 2)
  1995.   {
  1996.     root_name_end= strmake(fullname, argv[1], FN_REFLEN);
  1997.     printf("TRUNCATE TABLE time_zone;n");
  1998.     printf("TRUNCATE TABLE time_zone_name;n");
  1999.     printf("TRUNCATE TABLE time_zone_transition;n");
  2000.     printf("TRUNCATE TABLE time_zone_transition_type;n");
  2001.     if (scan_tz_dir(root_name_end))
  2002.     {
  2003.       fprintf(stderr, "There were fatal errors during processing "
  2004.                       "of zoneinfo directoryn");
  2005.       return 1;
  2006.     }
  2007.     printf("ALTER TABLE time_zone_transition "
  2008.            "ORDER BY Time_zone_id, Transition_time;n");
  2009.     printf("ALTER TABLE time_zone_transition_type "
  2010.            "ORDER BY Time_zone_id, Transition_type_id;n");
  2011.   }
  2012.   else
  2013.   {
  2014.     init_alloc_root(&tz_storage, 32768, 0);
  2015.     if (strcmp(argv[1], "--leap") == 0)
  2016.     {
  2017.       if (tz_load(argv[2], &tz_info, &tz_storage))
  2018.       {
  2019.         fprintf(stderr, "Problems with zoneinfo file '%s'n", argv[2]);
  2020.         return 1;
  2021.       }
  2022.       print_tz_leaps_as_sql(&tz_info);
  2023.     }
  2024.     else
  2025.     {
  2026.       if (tz_load(argv[1], &tz_info, &tz_storage))
  2027.       {
  2028.         fprintf(stderr, "Problems with zoneinfo file '%s'n", argv[2]);
  2029.         return 1;
  2030.       }
  2031.       print_tz_as_sql(argv[2], &tz_info);
  2032.     }
  2033.     free_root(&tz_storage, MYF(0));
  2034.   }
  2035.   return 0;
  2036. }
  2037. #endif /* defined(TZINFO2SQL) */
  2038. #ifdef TESTTIME
  2039. /*
  2040.    Some simple brute-force test wich allowed to catch a pair of bugs.
  2041.    Also can provide interesting facts about system's time zone support
  2042.    implementation.
  2043. */
  2044. #ifndef CHAR_BIT
  2045. #define CHAR_BIT 8
  2046. #endif
  2047. #ifndef TYPE_BIT
  2048. #define TYPE_BIT(type) (sizeof (type) * CHAR_BIT)
  2049. #endif
  2050. #ifndef TYPE_SIGNED
  2051. #define TYPE_SIGNED(type) (((type) -1) < 0)
  2052. #endif
  2053. my_bool
  2054. is_equal_TIME_tm(const TIME* time_arg, const struct tm * tm_arg)
  2055. {
  2056.   return (time_arg->year == (uint)tm_arg->tm_year+TM_YEAR_BASE) &&
  2057.          (time_arg->month == (uint)tm_arg->tm_mon+1) &&
  2058.          (time_arg->day == (uint)tm_arg->tm_mday) &&
  2059.          (time_arg->hour == (uint)tm_arg->tm_hour) &&
  2060.          (time_arg->minute == (uint)tm_arg->tm_min) &&
  2061.          (time_arg->second == (uint)tm_arg->tm_sec) &&
  2062.          time_arg->second_part == 0;
  2063. }
  2064. int
  2065. main(int argc, char **argv)
  2066. {
  2067.   my_bool localtime_negative;
  2068.   TIME_ZONE_INFO tz_info;
  2069.   struct tm tmp;
  2070.   TIME time_tmp;
  2071.   time_t t, t1, t2;
  2072.   char fullname[FN_REFLEN+1];
  2073.   char *str_end;
  2074.   long not_used;
  2075.   bool not_used_2;
  2076.   MEM_ROOT tz_storage;
  2077.   MY_INIT(argv[0]);
  2078.   init_alloc_root(&tz_storage, 32768, 0);
  2079.   /* let us set some well known timezone */
  2080.   setenv("TZ", "MET", 1);
  2081.   tzset();
  2082.   /* Some initial time zone related system info */
  2083.   printf("time_t: %s %u bitn", TYPE_SIGNED(time_t) ? "signed" : "unsigned",
  2084.                                 (uint)TYPE_BIT(time_t));
  2085.   if (TYPE_SIGNED(time_t))
  2086.   {
  2087.     t= -100;
  2088.     localtime_negative= test(localtime_r(&t, &tmp) != 0);
  2089.     printf("localtime_r %s negative params 
  2090.            (time_t=%d is %d-%d-%d %d:%d:%d)n",
  2091.            (localtime_negative ? "supports" : "doesn't support"), (int)t,
  2092.            TM_YEAR_BASE + tmp.tm_year, tmp.tm_mon + 1, tmp.tm_mday,
  2093.            tmp.tm_hour, tmp.tm_min, tmp.tm_sec);
  2094.     printf("mktime %s negative results (%d)n",
  2095.            (t == mktime(&tmp) ? "doesn't support" : "supports"),
  2096.            (int)mktime(&tmp));
  2097.   }
  2098.   tmp.tm_year= 103; tmp.tm_mon= 2; tmp.tm_mday= 30;
  2099.   tmp.tm_hour= 2; tmp.tm_min= 30; tmp.tm_sec= 0; tmp.tm_isdst= -1;
  2100.   t= mktime(&tmp);
  2101.   printf("mktime returns %s for spring time gap (%d)n",
  2102.          (t != (time_t)-1 ? "something" : "error"), (int)t);
  2103.   tmp.tm_year= 103; tmp.tm_mon= 8; tmp.tm_mday= 1;
  2104.   tmp.tm_hour= 0; tmp.tm_min= 0; tmp.tm_sec= 0; tmp.tm_isdst= 0;
  2105.   t= mktime(&tmp);
  2106.   printf("mktime returns %s for non existing date (%d)n",
  2107.          (t != (time_t)-1 ? "something" : "error"), (int)t);
  2108.   tmp.tm_year= 103; tmp.tm_mon= 8; tmp.tm_mday= 1;
  2109.   tmp.tm_hour= 25; tmp.tm_min=0; tmp.tm_sec=0; tmp.tm_isdst=1;
  2110.   t= mktime(&tmp);
  2111.   printf("mktime %s unnormalized input (%d)n",
  2112.          (t != (time_t)-1 ? "handles" : "doesn't handle"), (int)t);
  2113.   tmp.tm_year= 103; tmp.tm_mon= 9; tmp.tm_mday= 26;
  2114.   tmp.tm_hour= 0; tmp.tm_min= 30; tmp.tm_sec= 0; tmp.tm_isdst= 1;
  2115.   mktime(&tmp);
  2116.   tmp.tm_hour= 2; tmp.tm_isdst= -1;
  2117.   t= mktime(&tmp);
  2118.   tmp.tm_hour= 4; tmp.tm_isdst= 0;
  2119.   mktime(&tmp);
  2120.   tmp.tm_hour= 2; tmp.tm_isdst= -1;
  2121.   t1= mktime(&tmp);
  2122.   printf("mktime is %s (%d %d)n",
  2123.          (t == t1 ? "determenistic" : "is non-determenistic"),
  2124.          (int)t, (int)t1);
  2125.   /* Let us load time zone description */
  2126.   str_end= strmake(fullname, TZDIR, FN_REFLEN);
  2127.   strmake(str_end, "/MET", FN_REFLEN - (str_end - fullname));
  2128.   if (tz_load(fullname, &tz_info, &tz_storage))
  2129.   {
  2130.     printf("Unable to load time zone info from '%s'n", fullname);
  2131.     free_root(&tz_storage, MYF(0));
  2132.     return 1;
  2133.   }
  2134.   printf("Testing our implementationn");
  2135.   if (TYPE_SIGNED(time_t) && localtime_negative)
  2136.   {
  2137.     for (t= -40000; t < 20000; t++)
  2138.     {
  2139.       localtime_r(&t, &tmp);
  2140.       gmt_sec_to_TIME(&time_tmp, (my_time_t)t, &tz_info);
  2141.       if (!is_equal_TIME_tm(&time_tmp, &tmp))
  2142.       {
  2143.         printf("Problem with negative time_t = %dn", (int)t);
  2144.         free_root(&tz_storage, MYF(0));
  2145.         return 1;
  2146.       }
  2147.     }
  2148.     printf("gmt_sec_to_TIME = localtime for time_t in [-40000,20000) rangen");
  2149.   }
  2150.   for (t= 1000000000; t < 1100000000; t+= 13)
  2151.   {
  2152.     localtime_r(&t,&tmp);
  2153.     gmt_sec_to_TIME(&time_tmp, (my_time_t)t, &tz_info);
  2154.     if (!is_equal_TIME_tm(&time_tmp, &tmp))
  2155.     {
  2156.       printf("Problem with time_t = %dn", (int)t);
  2157.       free_root(&tz_storage, MYF(0));
  2158.       return 1;
  2159.     }
  2160.   }
  2161.   printf("gmt_sec_to_TIME = localtime for time_t in [1000000000,1100000000) rangen");
  2162.   init_time();
  2163.   /*
  2164.     Be careful here! my_system_gmt_sec doesn't fully handle unnormalized
  2165.     dates.
  2166.   */
  2167.   for (time_tmp.year= 1980; time_tmp.year < 2010; time_tmp.year++)
  2168.     for (time_tmp.month= 1; time_tmp.month < 13; time_tmp.month++)
  2169.       for (time_tmp.day= 1;
  2170.            time_tmp.day < mon_lengths[isleap(time_tmp.year)][time_tmp.month-1];
  2171.            time_tmp.day++)
  2172.         for (time_tmp.hour= 0; time_tmp.hour < 24; time_tmp.hour++)
  2173.           for (time_tmp.minute= 0; time_tmp.minute < 60; time_tmp.minute+= 5)
  2174.             for (time_tmp.second=0; time_tmp.second<60; time_tmp.second+=25)
  2175.             {
  2176.               t= (time_t)my_system_gmt_sec(&time_tmp, &not_used, &not_used_2);
  2177.               t1= (time_t)TIME_to_gmt_sec(&time_tmp, &tz_info, &not_used_2);
  2178.               if (t != t1)
  2179.               {
  2180.                 /*
  2181.                   We need special handling during autumn since my_system_gmt_sec
  2182.                   prefers greater time_t values (in MET) for ambiguity.
  2183.                   And BTW that is a bug which should be fixed !!!
  2184.                 */
  2185.                 tmp.tm_year= time_tmp.year - TM_YEAR_BASE;
  2186.                 tmp.tm_mon= time_tmp.month - 1;
  2187.                 tmp.tm_mday= time_tmp.day;
  2188.                 tmp.tm_hour= time_tmp.hour;
  2189.                 tmp.tm_min= time_tmp.minute;
  2190.                 tmp.tm_sec= time_tmp.second;
  2191.                 tmp.tm_isdst= 1;
  2192.                 t2= mktime(&tmp);
  2193.                 if (t1 == t2)
  2194.                   continue;
  2195.                 printf("Problem: %u/%u/%u %u:%u:%u with times t=%d, t1=%dn",
  2196.                        time_tmp.year, time_tmp.month, time_tmp.day,
  2197.                        time_tmp.hour, time_tmp.minute, time_tmp.second,
  2198.                        (int)t,(int)t1);
  2199.                 free_root(&tz_storage, MYF(0));
  2200.                 return 1;
  2201.               }
  2202.             }
  2203.   printf("TIME_to_gmt_sec = my_system_gmt_sec for test rangen");
  2204.   free_root(&tz_storage, MYF(0));
  2205.   return 0;
  2206. }
  2207. #endif /* defined(TESTTIME) */