ctime.c

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

// fix djdir

/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
/* This file has been modified by DJ Delorie.  These modifications are
** Copyright (C) 1995 DJ Delorie, 24 Kirsten Ave, Rochester NH,
** 03867-2954, USA.
*/

/*
 * Copyright (c) 1987, 1989 Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Arthur David Olson of the National Cancer Institute.
 *
 * Redistribution and use in source and binary forms are permitted provided
 * that: (1) source distributions retain this entire copyright notice and
 * comment, and (2) distributions including binaries display the following
 * acknowledgement:  ``This product includes software developed by the
 * University of California, Berkeley and its contributors'' in the
 * documentation or other materials provided with the distribution and in
 * all advertising materials mentioning features or use of this software.
 * Neither the name of the University nor the names of its contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

/*
** Leap second handling from Bradley White ([e-mail]).
** POSIX-style TZ environment variable handling from Guy Harris
** ([e-mail]).
*/

#include <precomp.h>

#include "tzfile.h"
#include "posixrul.h"

#ifdef __cplusplus
#define CPP_CONST const
#else
#define CPP_CONST
#endif

#define P(s)        s
#define alloc_size_t    size_t
#define qsort_size_t    size_t
#define fread_size_t    size_t
#define fwrite_size_t   size_t

#define ACCESS_MODE O_RDONLY|O_BINARY
#define OPEN_MODE   O_RDONLY|O_BINARY

/*
** Someone might make incorrect use of a time zone abbreviation:
**  1.  They might reference tzname[0] before calling tzset (explicitly
**      or implicitly).
**  2.  They might reference tzname[1] before calling tzset (explicitly
**      or implicitly).
**  3.  They might reference tzname[1] after setting to a time zone
**      in which Daylight Saving Time is never observed.
**  4.  They might reference tzname[0] after setting to a time zone
**      in which Standard Time is never observed.
**  5.  They might reference tm.TM_ZONE after calling offtime.
** What's best to do in the above cases is open to debate;
** for now, we just set things up so that in any of the five cases
** WILDABBR is used.  Another possibility:  initialize tzname[0] to the
** string "tzname[0] used before set", and similarly for the other cases.
** And another:  initialize tzname[0] to "ERA", with an explanation in the
** manual page of what this "time zone abbreviation" means (doing this so
** that tzname[0] has the "normal" length of three characters).
*/

void _set_daylight_export(int);
void _set_timezone_export(int);


/* buffers must hold 64 characters! */
static char TZ_NAME[64] = "PST";
static char TZ_DST_NAME[64] = "PDT";

#ifndef TRUE
#define TRUE        1
#define FALSE       0
#endif /* !defined TRUE */

static const char GMT[] = "GMT";

struct ttinfo {     /* time type information */
  long tt_gmtoff;   /* GMT offset in seconds */
  int tt_isdst;     /* used to set tm_isdst */
  int tt_abbrind;   /* abbreviation list index */
  int tt_ttisstd;   /* TRUE if transition is std time */
};

struct lsinfo {     /* leap second information */
  time_t ls_trans;  /* transition time */
  long ls_corr;     /* correction to apply */
};

struct state {
  int leapcnt;
  int timecnt;
  int typecnt;
  int charcnt;
  time_t ats[TZ_MAX_TIMES];
  unsigned char types[TZ_MAX_TIMES];
  struct ttinfo ttis[TZ_MAX_TYPES];
  char chars[(TZ_MAX_CHARS + 1 > sizeof GMT) ? TZ_MAX_CHARS + 1 : sizeof GMT];
  struct lsinfo lsis[TZ_MAX_LEAPS];
};

struct rule {
  int r_type;       /* type of rule--see below */
  int r_day;        /* day number of rule */
  int r_week;       /* week number of rule */
  int r_mon;        /* month number of rule */
  long r_time;      /* transition time of rule */
};

#define JULIAN_DAY      0   /* Jn - Julian day */
#define DAY_OF_YEAR     1   /* n - day of year */
#define MONTH_NTH_DAY_OF_WEEK   2   /* Mm.n.d - month, week, day of week */

/*
** Prototypes for static functions.
*/
#if 0
static long     detzcode P((const char * codep));
static const char * getzname P((const char * strp));
static const char * getnum P((const char * strp, int * nump, int min, int max));
static const char * getsecs P((const char * strp, long * secsp));
static const char * getoffset P((const char * strp, long * offsetp));
static const char * getrule P((const char * strp, struct rule * rulep));
static void     gmtload P((struct state * sp));
static void     gmtsub P((const time_t * timep, long offset, struct tm * tmp));
static void     localsub P((const time_t * timep, long offset, struct tm * tmp));
static void     normalize P((int * tensptr, int * unitsptr, int base));
static void     settzname P((void));
static time_t   time1 P((struct tm * tmp, void (* funcp)(const time_t * CPP_CONST, const long, struct tm * CPP_CONST), long offset));
static time_t   time2 P((struct tm *tmp, void (* funcp)(const time_t * CPP_CONST, const long, struct tm * CPP_CONST), long offset, int * okayp));
static void     timesub P((const time_t * timep, long offset, const struct state * sp, struct tm * tmp));
static int      tmcomp P((const struct tm * atmp, const struct tm * btmp));
static time_t   transtime P((time_t janfirst, int year, const struct rule * rulep, long offset));
static int      tzload P((const char * name, struct state * sp));
static int      tzparse P((const char * name, struct state * sp, int lastditch));
static void     tzsetwall(void);

#else

static const char * getnum(const char * strp, int * CPP_CONST nump, const int min, const int max);
static void     timesub(const time_t * CPP_CONST timep, const long offset, const struct state * CPP_CONST sp, struct tm * CPP_CONST tmp);
static time_t   transtime(const time_t janfirst, const int year, const struct rule * CPP_CONST rulep, const long offset);
static void     tzsetwall(void);

#endif

#ifdef ALL_STATE
static struct state *lclptr;
static struct state *gmtptr;
#endif /* defined ALL_STATE */

#ifndef ALL_STATE
static struct state lclmem;
static struct state gmtmem;
#define lclptr (&lclmem)
#define gmtptr (&gmtmem)
#endif /* State Farm */

static int lcl_is_set;
static int gmt_is_set;

char * _tzname[2] = {
  TZ_NAME,
  TZ_DST_NAME,
};

static long
detzcode(const char * CPP_CONST codep)
{
  long result;
  int i;

  result = 0;
  for (i = 0; i < 4; ++i)
    result = (result << 8) | (codep[i] & 0xff);
  return result;
}

static void
settzname(void)
{
  const struct state * CPP_CONST sp = lclptr;
  int i;

  _tzname[0] = TZ_NAME;
  _tzname[1] = TZ_DST_NAME;
#ifdef ALL_STATE
  if (sp == NULL)
  {
    _tzname[0] = _tzname[1] = GMT;
    return;
  }
#endif /* defined ALL_STATE */
  for (i = 0; i < sp->typecnt; ++i)
  {
    register const struct ttinfo * CPP_CONST ttisp = &sp->ttis[i];

    _tzname[ttisp->tt_isdst] =
      (char *)&sp->chars[ttisp->tt_abbrind];
#if 0
    if (ttisp->tt_isdst) {
      //_daylight = 1;
      _set_daylight_export(1);
    }
    if (i == 0 || !ttisp->tt_isdst) {
      //_timezone_dll = -(ttisp->tt_gmtoff);
      _set_timezone_export(-(ttisp->tt_gmtoff));
    }
    if (i == 0 || ttisp->tt_isdst) {
      _altzone = -(ttisp->tt_gmtoff);
    }
#endif
  }
  /*
   ** And to get the latest zone names into tzname. . .
   */
  for (i = 0; i < sp->timecnt; ++i)
  {
    const struct ttinfo * CPP_CONST ttisp = &sp->ttis[sp->types[i]];

    _tzname[ttisp->tt_isdst] = (char *)&sp->chars[ttisp->tt_abbrind];
  }
}

static char* tzdir(void)
{
  static char dir[80]={0}, *cp;
  if (dir[0] == 0)
  {
    if ((cp = getenv("TZDIR")))
    {
      strcpy(dir, cp);
    }
    else if ((cp = getenv("DJDIR")))
    {
      strcpy(dir, cp);
      strcat(dir, "/zoneinfo");
    }
    else
      strcpy(dir, "./");
  }
  return dir;
}

static int tzload(const char* name, struct state* CPP_CONST sp)
{
  const char * p;
  int i;
  int fid;
  char fullname[FILENAME_MAX + 1];
  const struct tzhead * tzhp;
  char buf[sizeof *sp + sizeof *tzhp];
  int ttisstdcnt;

  if (name == NULL && (name = TZDEFAULT) == NULL)
    return -1;

  if (name[0] == ':')
    ++name;
  if (name[0] != '/')
  {
    if ((p = tzdir()) == NULL)
      return -1;
    if ((strlen(p) + strlen(name) + 1) >= sizeof fullname)
      return -1;
    strcpy(fullname, p);
    strcat(fullname, "/");
    strcat(fullname, name);
    name = fullname;
  }

  if ((fid = _open(name, OPEN_MODE)) == -1)
  {
    const char *base = strrchr(name, '/');
    if (base)
      base++;
    else
      base = name;
    if (strcmp(base, "posixrules"))
      return -1;

    /* We've got a built-in copy of posixrules just in case */
    memcpy(buf, _posixrules_data, sizeof(_posixrules_data));
    i = sizeof(_posixrules_data);
  }
  else
  {
    i = _read(fid, buf, sizeof buf);
    if (_close(fid) != 0 || i < (int)sizeof *tzhp)
      return -1;
  }

  tzhp = (struct tzhead *) buf;
  ttisstdcnt = (int) detzcode(tzhp->tzh_ttisstdcnt);
  sp->leapcnt = (int) detzcode(tzhp->tzh_leapcnt);
  sp->timecnt = (int) detzcode(tzhp->tzh_timecnt);
  sp->typecnt = (int) detzcode(tzhp->tzh_typecnt);
  sp->charcnt = (int) detzcode(tzhp->tzh_charcnt);
  if (sp->leapcnt < 0 || sp->leapcnt > TZ_MAX_LEAPS ||
      sp->typecnt <= 0 || sp->typecnt > TZ_MAX_TYPES ||
      sp->timecnt < 0 || sp->timecnt > TZ_MAX_TIMES ||
      sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS ||
      (ttisstdcnt != sp->typecnt && ttisstdcnt != 0))
    return -1;
  if (i < (int)sizeof *tzhp +
      sp->timecnt * (4 + (int)sizeof (char)) +
      sp->typecnt * (4 + 2 * (int)sizeof (char)) +
      sp->charcnt * (int)sizeof (char) +
      sp->leapcnt * 2 * 4 +
      ttisstdcnt * (int)sizeof (char))
    return -1;
  p = buf + sizeof *tzhp;
  for (i = 0; i < sp->timecnt; ++i)
  {
    sp->ats[i] = detzcode(p);
    p += 4;
  }
  for (i = 0; i < sp->timecnt; ++i)
  {
    sp->types[i] = (unsigned char) *p++;
    if (sp->types[i] >= sp->typecnt)
      return -1;
  }
  for (i = 0; i < sp->typecnt; ++i)
  {
    struct ttinfo * ttisp;

    ttisp = &sp->ttis[i];
    ttisp->tt_gmtoff = detzcode(p);
    p += 4;
    ttisp->tt_isdst = (unsigned char) *p++;
    if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1)
      return -1;
    ttisp->tt_abbrind = (unsigned char) *p++;
    if (ttisp->tt_abbrind < 0 ||
    ttisp->tt_abbrind > sp->charcnt)
      return -1;
  }
  for (i = 0; i < sp->charcnt; ++i)
    sp->chars[i] = *p++;
  sp->chars[i] = '\0';      /* ensure '\0' at end */
  for (i = 0; i < sp->leapcnt; ++i)
  {
    struct lsinfo * lsisp;

    lsisp = &sp->lsis[i];
    lsisp->ls_trans = detzcode(p);
    p += 4;
    lsisp->ls_corr = detzcode(p);
    p += 4;
  }
  for (i = 0; i < sp->typecnt; ++i)
  {
    struct ttinfo * ttisp;

    ttisp = &sp->ttis[i];
    if (ttisstdcnt == 0)
      ttisp->tt_ttisstd = FALSE;
    else
    {
      ttisp->tt_ttisstd = *p++;
      if (ttisp->tt_ttisstd != TRUE &&
      ttisp->tt_ttisstd != FALSE)
    return -1;
    }
  }
  return 0;
}

static const int mon_lengths[2][MONSPERYEAR] = {
{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
};

static const int year_lengths[2] = {
DAYSPERNYEAR, DAYSPERLYEAR
};

/*
** Given a pointer into a time zone string, scan until a character that is not
** a valid character in a zone name is found.  Return a pointer to that
** character.
*/

static const char*
getzname(const char* strp)
{
  char c;

  while ((c = *strp) != '\0' && !isdigit(c) && c != ',' && c != '-' &&
     c != '+')
    ++strp;
  return strp;
}

/*
** Given a pointer into a time zone string, extract a number from that string.
** Check that the number is within a specified range; if it is not, return
** NULL.
** Otherwise, return a pointer to the first character not part of the number.
*/

static const char*
getnum(const char* strp, int* CPP_CONST nump, const int min, const int max)
{
  char c;
  int num;

  if (strp == NULL || !isdigit(*strp))
    return NULL;
  num = 0;
  while ((c = *strp) != '\0' && isdigit(c))
  {
    num = num * 10 + (c - '0');
    if (num > max)
      return NULL;
    ++strp;
  }
  if (num < min)
    return NULL;
  *nump = num;
  return strp;
}

/*
** Given a pointer into a time zone string, extract a number of seconds,
** in hh[:mm[:ss]] form, from the string.
** If any error occurs, return NULL.
** Otherwise, return a pointer to the first character not part of the number
** of seconds.
*/

static const char *
getsecs(const char *strp, long * CPP_CONST secsp)
{
  int num;

  strp = getnum(strp, &num, 0, HOURSPERDAY);
  if (strp == NULL)
    return NULL;
  *secsp = num * SECSPERHOUR;
  if (*strp == ':')
  {
    ++strp;
    strp = getnum(strp, &num, 0, MINSPERHOUR - 1);
    if (strp == NULL)
      return NULL;
    *secsp += num * SECSPERMIN;
    if (*strp == ':')
    {
      ++strp;
      strp = getnum(strp, &num, 0, SECSPERMIN - 1);
      if (strp == NULL)
    return NULL;
      *secsp += num;
    }
  }
  return strp;
}

/*
** Given a pointer into a time zone string, extract an offset, in
** [+-]hh[:mm[:ss]] form, from the string.
** If any error occurs, return NULL.
** Otherwise, return a pointer to the first character not part of the time.