CLeanup PBX patch and add localtime stuff for saytime (bug #168)
authorMark Spencer <markster@digium.com>
Sat, 13 Sep 2003 20:51:48 +0000 (20:51 +0000)
committerMark Spencer <markster@digium.com>
Sat, 13 Sep 2003 20:51:48 +0000 (20:51 +0000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@1506 65c4cc65-6c06-0410-ace0-fbb531ad65f3

12 files changed:
Makefile
apps/app_voicemail2.c
include/asterisk/localtime.h [new file with mode: 0755]
include/asterisk/pbx.h
include/asterisk/say.h
pbx.c
say.c
stdtime/Makefile [new file with mode: 0755]
stdtime/localtime.c [new file with mode: 0755]
stdtime/private.h [new file with mode: 0755]
stdtime/test.c [new file with mode: 0755]
stdtime/tzfile.h [new file with mode: 0755]

index 844b9ab..13763a0 100755 (executable)
--- a/Makefile
+++ b/Makefile
@@ -153,12 +153,7 @@ _all: all
 all: depend asterisk subdirs
 
 editline/config.h:
-       @if [ -d editline ]; then \
-               cd editline && unset CFLAGS LIBS && ./configure ; \
-       else \
-               echo "You need to do a cvs update -d not just cvs update"; \
-               exit 1; \
-       fi
+       cd editline && unset CFLAGS LIBS && ./configure ; \
 
 editline/libedit.a: editline/config.h
        $(MAKE) -C editline libedit.a
@@ -199,8 +194,16 @@ build.h:
        ./make_build_h
 endif
 
-asterisk: editline/libedit.a db1-ast/libdb1.a $(OBJS)
-       $(CC) $(DEBUG) -o asterisk -rdynamic $(OBJS) $(LIBS) $(LIBEDIT) db1-ast/libdb1.a
+stdtime/localtime.o:
+       @if [ -d stdtime ]; then \
+               $(MAKE) -C stdtime; \
+       else \
+               echo "You need to do a cvs update -d not just cvs update"; \
+               exit 1; \
+       fi
+
+asterisk: editline/libedit.a db1-ast/libdb1.a stdtime/localtime.o $(OBJS)
+       $(CC) $(DEBUG) -o asterisk -rdynamic $(OBJS) $(LIBS) $(LIBEDIT) db1-ast/libdb1.a stdtime/localtime.o
 
 subdirs: 
        for x in $(SUBDIRS); do $(MAKE) -C $$x || exit 1 ; done
@@ -212,6 +215,7 @@ clean:
        rm -f ast_expr.c
        @if [ -e editline/Makefile ]; then $(MAKE) -C editline clean ; fi
        $(MAKE) -C db1-ast clean
+       $(MAKE) -C stdtime clean
 
 datafiles: all
        mkdir -p $(ASTVARLIBDIR)/sounds/digits
index e5f1db7..0ee22fb 100755 (executable)
@@ -106,26 +106,26 @@ static char *synopsis_vm =
 "Leave a voicemail message";
 
 static char *descrip_vm =
-"  VoiceMail([s|u|b]extension[@context]): Leaves voicemail for a given  extension (must\n"
-"be configured in voicemail.conf). If the extension is preceeded by an 's'"
-"then instructions for leaving the message will be skipped.  If the extension\n"
-"is preceeded by 'u' then the \"unavailable\" message will be played (that is, \n"
-"/var/lib/asterisk/sounds/vm/<exten>/unavail) if it exists.  If the extension\n"
-"is preceeded by a 'b' then the the busy message will be played (that is,\n"
-"busy instead of unavail). \n"
-"Returns  -1 on  error or mailbox not found, or if the user hangs up. \n"
-"Otherwise, it returns 0. \n";
+"  VoiceMail([s|u|b]extension[@context]):  Leaves voicemail for a given\n"
+"extension (must be configured in voicemail.conf).  If the extension is\n"
+"preceded by an 's' then instructions for leaving the message will be\n"
+"skipped.  If the extension is preceeded by 'u' then the \"unavailable\"\n"
+"message will be played (/var/lib/asterisk/sounds/vm/<exten>/unavail) if it\n"
+"exists.  If the extension is preceeded by a 'b' then the the busy message\n"
+"will be played (that is, busy instead of unavail).\n"
+"Returns -1 on error or mailbox not found, or if the user hangs up.\n"
+"Otherwise, it returns 0.\n";
 
 static char *synopsis_vmain =
 "Enter voicemail system";
 
 static char *descrip_vmain =
-"  VoiceMailMain([[s]mailbox][@context]): Enters the main voicemail system for the checking of\n"
-"voicemail.  The mailbox can be passed as the option, which will stop the\n"
-"voicemail system from prompting the user for the mailbox.  If the mailbox\n"
-"is preceded by 's' then the password check will be skipped.  If a context is\n"
-"specified, logins are considered in that context only. Returns -1 if\n"
-"the user hangs up or 0 otherwise.\n";
+"  VoiceMailMain([[s]mailbox][@context]): Enters the main voicemail system\n"
+"for the checking of voicemail.  The mailbox can be passed as the option,\n"
+"which will stop the voicemail system from prompting the user for the mailbox.\n"
+"If the mailbox is preceded by 's' then the password check will be skipped.  If\n"
+"a context is specified, logins are considered in that context only.\n"
+"Returns -1 if the user hangs up or 0 otherwise.\n";
 
 /* Leave a message */
 static char *app = "VoiceMail2";
@@ -1897,298 +1897,13 @@ static int wait_file(struct ast_channel *chan, struct vm_state *vms, char *file)
        return res;
 }
 
-static int play_datetime_format(struct ast_channel *chan, time_t time, struct vm_state *vms, struct vm_zone *zone)
-{
-       int d = 0, offset = 0, sndoffset = 0;
-       char sndfile[256], nextmsg[256];
-       struct tm tm;
-       char *tzenv, current_tz[256] = "", *qmark;
-
-       tzenv = getenv("TZ");
-       if (tzenv != NULL)
-               strncpy(current_tz, tzenv, sizeof(current_tz) - 1);
-       if (zone->timezone && strcmp(current_tz,zone->timezone)) {
-               setenv("TZ", zone->timezone, 1);
-               tzset();
-               localtime_r(&time, &tm);
-               if (tzenv != NULL)
-                       setenv("TZ", current_tz, 1);
-               else
-                       unsetenv("TZ");
-       } else {
-               /* No need to change the timezone */
-               localtime_r(&time, &tm);
-       }
-
-       /* Check for a subexpression */
-       if ((qmark = index(zone->msg_format, '?'))) {
-               /* TODO Allow subexpressions - we probably need to implement a parser here. */
-       }
-
-       for (offset=0 ; zone->msg_format[offset] != '\0' ; offset++) {
-               ast_log(LOG_NOTICE, "Parsing %c in %s\n", zone->msg_format[offset], zone->msg_format);
-               switch (zone->msg_format[offset]) {
-                       /* NOTE:  if you add more options here, please try to be consistent with strftime(3) */
-                       case '\'':
-                               /* Literal name of a sound file */
-                               sndoffset=0;
-                               for (sndoffset=0 ; zone->msg_format[++offset] != '\'' ; sndoffset++)
-                                       sndfile[sndoffset] = zone->msg_format[offset];
-                               sndfile[sndoffset] = '\0';
-                               snprintf(nextmsg,sizeof(nextmsg), AST_SOUNDS "/%s", sndfile);
-                               d = wait_file(chan,vms,nextmsg);
-                               break;
-                       case '$':
-                               /* Ooooh, variables and/or expressions */
-                               {
-                                       struct vm_zone z;
-                                       memcpy(&z,zone,sizeof(struct vm_zone));
-                                       pbx_substitute_variables_helper(chan, zone->msg_format + offset, z.msg_format, sizeof(z.msg_format));
-                                       d = play_datetime_format(chan, time, vms, &z);
-                                       /* Subtract one, so that when the for loop increments, we point at the nil */
-                                       offset = strlen(zone->msg_format) - 1;
-                               }
-                               break;
-                       case 'A':
-                       case 'a':
-                               /* Sunday - Saturday */
-                               snprintf(nextmsg,sizeof(nextmsg), DIGITS_DIR "day-%d", tm.tm_wday);
-                               d = wait_file(chan,vms,nextmsg);
-                               break;
-                       case 'B':
-                       case 'b':
-                       case 'h':
-                               /* January - December */
-                               snprintf(nextmsg,sizeof(nextmsg), DIGITS_DIR "mon-%d", tm.tm_mon);
-                               d = wait_file(chan,vms,nextmsg);
-                               break;
-                       case 'd':
-                       case 'e':
-                               /* First - Thirtyfirst */
-                               if ((tm.tm_mday < 21) || (tm.tm_mday == 30)) {
-                                       snprintf(nextmsg,sizeof(nextmsg), DIGITS_DIR "h-%d", tm.tm_mday);
-                                       d = wait_file(chan,vms,nextmsg);
-                               } else if (tm.tm_mday == 31) {
-                                       /* "Thirty" and "first" */
-                                       d = wait_file(chan,vms,DIGITS_DIR "30");
-                                       if (!d) {
-                                               d = wait_file(chan,vms,DIGITS_DIR "h-1");
-                                       }
-                               } else {
-                                       /* Between 21 and 29 - two sounds */
-                                       d = wait_file(chan,vms,DIGITS_DIR "20");
-                                       if (!d) {
-                                               snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "h-%d", tm.tm_mday - 20);
-                                               d = wait_file(chan,vms,nextmsg);
-                                       }
-                               }
-                               break;
-                       case 'Y':
-                               /* Year */
-                               if (tm.tm_year > 99) {
-                                       d = wait_file(chan,vms,DIGITS_DIR "2");
-                                       if (!d) {
-                                               d = wait_file(chan,vms,DIGITS_DIR "thousand");
-                                       }
-                                       if (tm.tm_year > 100) {
-                                               if (!d) {
-                                                       /* This works until the end of 2020 */
-                                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_year - 100);
-                                                       d = wait_file(chan,vms,nextmsg);
-                                               }
-                                       }
-                               } else {
-                                       if (tm.tm_year < 1) {
-                                               /* I'm not going to handle 1900 and prior */
-                                               /* We'll just be silent on the year, instead of bombing out. */
-                                       } else {
-                                               d = wait_file(chan,vms,DIGITS_DIR "19");
-                                               if (!d) {
-                                                       if (tm.tm_year < 20) {
-                                                               /* 1901 - 1920 */
-                                                               snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_year);
-                                                               d = wait_file(chan,vms,nextmsg);
-                                                       } else {
-                                                               /* 1921 - 1999 */
-                                                               int ten, one;
-                                                               ten = tm.tm_year / 10;
-                                                               one = tm.tm_year % 10;
-                                                               snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", ten * 10);
-                                                               d = wait_file(chan,vms,nextmsg);
-                                                               if (!d) {
-                                                                       if (one != 0) {
-                                                                               snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", one);
-                                                                               d = wait_file(chan,vms,nextmsg);
-                                                                       }
-                                                               }
-                                                       }
-                                               }
-                                       }
-                               }
-                               break;
-                       case 'I':
-                       case 'l':
-                               /* 12-Hour */
-                               if (tm.tm_hour == 0)
-                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "12");
-                               else if (tm.tm_hour > 12)
-                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_hour - 12);
-                               else
-                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_hour);
-                               d = wait_file(chan,vms,nextmsg);
-                               break;
-                       case 'H':
-                       case 'k':
-                               /* 24-Hour */
-                               if (zone->msg_format[offset] == 'H') {
-                                       /* e.g. oh-eight */
-                                       if (tm.tm_hour < 10) {
-                                               d = wait_file(chan,vms,DIGITS_DIR "oh");
-                                       }
-                               } else {
-                                       /* e.g. eight */
-                                       if (tm.tm_hour == 0) {
-                                               d = wait_file(chan,vms,DIGITS_DIR "oh");
-                                       }
-                               }
-                               if (!d) {
-                                       if (tm.tm_hour != 0) {
-                                               snprintf(nextmsg,sizeof(nextmsg), AST_SOUNDS "/digits/%d", tm.tm_hour);
-                                               d = wait_file(chan,vms,nextmsg);
-                                       }
-                               }
-                               break;
-                       case 'M':
-                               /* Minute */
-                               if (tm.tm_min == 0) {
-                                       d = wait_file(chan,vms,DIGITS_DIR "oclock");
-                               } else if (tm.tm_min < 10) {
-                                       d = wait_file(chan,vms,DIGITS_DIR "oh");
-                                       if (!d) {
-                                               snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_min);
-                                               d = wait_file(chan,vms,nextmsg);
-                                       }
-                               } else if ((tm.tm_min < 21) || (tm.tm_min % 10 == 0)) {
-                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_min);
-                                       d = wait_file(chan,vms,nextmsg);
-                               } else {
-                                       int ten, one;
-                                       ten = (tm.tm_min / 10) * 10;
-                                       one = (tm.tm_min % 10);
-                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", ten);
-                                       d = wait_file(chan,vms,nextmsg);
-                                       if (!d) {
-                                               /* Fifty, not fifty-zero */
-                                               if (one != 0) {
-                                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", one);
-                                                       d = wait_file(chan,vms,nextmsg);
-                                               }
-                                       }
-                               }
-                               break;
-                       case 'P':
-                       case 'p':
-                               /* AM/PM */
-                               if ((tm.tm_hour == 0) || (tm.tm_hour > 11))
-                                       snprintf(nextmsg,sizeof(nextmsg), DIGITS_DIR "p-m");
-                               else
-                                       snprintf(nextmsg,sizeof(nextmsg), DIGITS_DIR "a-m");
-                               d = wait_file(chan,vms,nextmsg);
-                               break;
-                       case 'Q':
-                               /* Shorthand for "Today", "Yesterday", or ABdY */
-                               {
-                                       struct timeval now;
-                                       struct tm tmnow;
-                                       time_t beg_today, tnow;
-
-                                       gettimeofday(&now,NULL);
-                                       tnow = now.tv_sec;
-                                       localtime_r(&tnow,&tmnow);
-                                       tmnow.tm_hour = 0;
-                                       tmnow.tm_min = 0;
-                                       tmnow.tm_sec = 0;
-                                       beg_today = mktime(&tmnow);
-                                       if (beg_today < time) {
-                                               /* Today */
-                                               d = wait_file(chan,vms,DIGITS_DIR "today");
-                                       } else if (beg_today - 86400 < time) {
-                                               /* Yesterday */
-                                               d = wait_file(chan,vms,DIGITS_DIR "yesterday");
-                                       } else {
-                                               struct vm_zone z;
-                                               memcpy(&z, zone, sizeof(struct vm_zone));
-                                               strcpy(z.msg_format, "ABdY");
-                                               d = play_datetime_format(chan, time, vms, &z);
-                                       }
-                               }
-                               break;
-                       case 'q':
-                               /* Shorthand for "" (today), "Yesterday", A (weekday), or ABdY */
-                               {
-                                       struct timeval now;
-                                       struct tm tmnow;
-                                       time_t beg_today, tnow;
-
-                                       gettimeofday(&now,NULL);
-                                       tnow = now.tv_sec;
-                                       localtime_r(&tnow,&tmnow);
-                                       tmnow.tm_hour = 0;
-                                       tmnow.tm_min = 0;
-                                       tmnow.tm_sec = 0;
-                                       beg_today = mktime(&tmnow);
-                                       if (beg_today < time) {
-                                               /* Today */
-                                       } else if (beg_today - 86400 < time) {
-                                               /* Yesterday */
-                                               d = wait_file(chan,vms,DIGITS_DIR "yesterday");
-                                       } else if (beg_today - 86400 * 6 < time) {
-                                               /* Within the last week */
-                                               struct vm_zone z;
-                                               memcpy(&z, zone, sizeof(struct vm_zone));
-                                               strcpy(z.msg_format, "A");
-                                               d = play_datetime_format(chan, time, vms, &z);
-                                       } else {
-                                               struct vm_zone z;
-                                               memcpy(&z, zone, sizeof(struct vm_zone));
-                                               strcpy(z.msg_format, "ABdY");
-                                               d = play_datetime_format(chan, time, vms, &z);
-                                       }
-                               }
-                               break;
-                       case 'R':
-                               {
-                                       struct vm_zone z;
-                                       memcpy(&z, zone, sizeof(struct vm_zone));
-                                       strcpy(z.msg_format, "HM");
-                                       d = play_datetime_format(chan, time, vms, &z);
-                               }
-                               break;
-                       case ' ':
-                       case '  ':
-                               /* Just ignore spaces and tabs */
-                               break;
-                       default:
-                               /* Unknown character */
-                               ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c\n", zone->msg_format, zone->msg_format[offset]);
-               }
-               /* Jump out on DTMF */
-               if (d) {
-                       break;
-               }
-       }
-       return d;
-}
-
 static int play_message_datetime(struct ast_channel *chan, struct ast_vm_user *vmu, struct vm_state *vms)
 {
        int res = 0;
-       char filename[256], *origtime, temp[256];
+       char filename[256], *origtime;
        struct vm_zone *the_zone = NULL;
        struct ast_config *msg_cfg;
-       time_t t, tnow;
-       struct timeval tv_now;
-       struct tm time_now, time_then;
+       time_t t;
        long tin;
 
        make_file(vms->fn2, sizeof(vms->fn2), vms->curdir, vms->curmsg); 
@@ -2229,6 +1944,8 @@ static int play_message_datetime(struct ast_channel *chan, struct ast_vm_user *v
                strncpy(the_zone->msg_format, "'vm-received' q 'digits/at' IMp", sizeof(the_zone->msg_format) - 1);
        }
 
+/* No internal variable parsing for now, so we'll comment it out for the time being */
+#if 0
        /* Set the DIFF_* variables */
        localtime_r(&t, &time_now);
        gettimeofday(&tv_now,NULL);
@@ -2243,9 +1960,11 @@ static int play_message_datetime(struct ast_channel *chan, struct ast_vm_user *v
        pbx_builtin_setvar_helper(chan, "DIFF_DAY", temp);
 
        /* Can't think of how other diffs might be helpful, but I'm sure somebody will think of something. */
-
-       res = play_datetime_format(chan, t, vms, the_zone);
+#endif
+       res = ast_say_date_with_format(chan, t, AST_DIGIT_ANY, chan->language, the_zone->msg_format, the_zone->timezone);
+#if 0
        pbx_builtin_setvar_helper(chan, "DIFF_DAY", NULL);
+#endif
        return res;
 }
 
diff --git a/include/asterisk/localtime.h b/include/asterisk/localtime.h
new file mode 100755 (executable)
index 0000000..320c293
--- /dev/null
@@ -0,0 +1,22 @@
+/*
+ * Asterisk -- A telephony toolkit for Linux.
+ *
+ * Custom localtime functions for multiple timezones
+ * 
+ * Copyright (C) 2003, Mark Spencer
+ *
+ * Tilghman Lesher <tlesher@vcch.com>
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License
+ */
+
+#ifndef _ASTERISK_LOCALTIME_H
+#define _ASTERISK_LOCALTIME_H
+
+extern int ast_tzsetwall(void);
+extern void ast_tzset(const char *name);
+extern struct tm *ast_localtime(const time_t *timep, struct tm *p_tm, const char *zone);
+extern time_t ast_mktime(struct tm * const tmp, const char *zone);
+
+#endif
index c2c4878..32dfcc1 100755 (executable)
@@ -523,6 +523,8 @@ extern void pbx_builtin_setvar_helper(struct ast_channel *chan, char *name, char
 extern void pbx_builtin_clear_globals(void);
 extern void pbx_substitute_variables_helper(struct ast_channel *c,const char *cp1,char *cp2,int count);
 
+int ast_extension_patmatch(const char *pattern, const char *data);
+
 #if defined(__cplusplus) || defined(c_plusplus)
 }
 #endif
index 7c0d911..c1bfdea 100755 (executable)
@@ -69,6 +69,8 @@ int ast_say_date(struct ast_channel *chan, time_t t, char *ints, char *lang);
 
 int ast_say_datetime_from_now(struct ast_channel *chan, time_t t, char *ints, char *lang);
 
+int ast_say_date_with_format(struct ast_channel *chan, time_t t, char *ints, char *lang, char *format, char *timezone);
+
 #if defined(__cplusplus) || defined(c_plusplus)
 }
 #endif
diff --git a/pbx.c b/pbx.c
index 9ea3e9d..abb2e32 100755 (executable)
--- a/pbx.c
+++ b/pbx.c
@@ -144,8 +144,6 @@ struct ast_hint {
     struct ast_hint *next;
 };
 
-int ast_extension_patmatch(const char *pattern, const char *data);
-
 static int pbx_builtin_prefix(struct ast_channel *, void *);
 static int pbx_builtin_suffix(struct ast_channel *, void *);
 static int pbx_builtin_stripmsd(struct ast_channel *, void *);
@@ -172,6 +170,7 @@ static int pbx_builtin_saynumber(struct ast_channel *, void *);
 static int pbx_builtin_saydigits(struct ast_channel *, void *);
 void pbx_builtin_setvar_helper(struct ast_channel *chan, char *name, char *value);
 char *pbx_builtin_getvar_helper(struct ast_channel *chan, char *name);
+static int ast_extension_patmatch_repeated(const char *pattern, const char *data, const int num);
 
 static struct varshead globals = AST_LIST_HEAD_INITIALIZER(varshead);
 
@@ -522,14 +521,13 @@ char patmatch_group[80] = "";
    variables, starting with $1, $2 and so on.
  * alternation as in (01|0|99) ("01 or 0 or 99")
  */
-int ast_extension_patmatch(const char *pattern, char *data) 
+int ast_extension_patmatch(const char *pattern, const char *data) 
 {
     int i,border=0;
     char *where;
     static char prev = '\0';
     static char groupdata[80] = "";
     static char *group = patmatch_group;
-    int groupcounter = patmatch_groupcounter;
 
     if (option_debug)
        ast_log(LOG_DEBUG, " >>> \"%s\" =~ /%s/\n", data, pattern);
@@ -571,7 +569,7 @@ int ast_extension_patmatch(const char *pattern, char *data)
 
        case '{': /* quantifier {n[,m]} */
          {
-           char *comma;
+           char *comma=NULL;
            int cpos;
            where=strchr(pattern,'}');
            if (where) {
@@ -636,11 +634,10 @@ int ast_extension_patmatch(const char *pattern, char *data)
                }
                prev = *tmp;
                if (i >= from || !from) { /* if found */
+                   int l = strlen(groupdata) - strlen(data);
                    if (option_debug)
                        ast_log(LOG_DEBUG, " >>>> found '%s' in data '%s' after %d runs\n", group, data, i);
-                   char name[16];
                    data = data + (i * (strlen(group)- 1)) - 1;
-                   int l = strlen(groupdata) - strlen(data);
                    /* data = data-i+from-1; */         /* possible failure here! */
                    if (prev == ')') {                  /* grouping => capture */
                        *(group+strlen(group)-1) = '\0';
@@ -708,7 +705,7 @@ int ast_extension_patmatch(const char *pattern, char *data)
                s = scopy = (char *) malloc(strlen(pattern));
                sepcopy   = (char *) malloc(strlen(pattern));
                strcpy(s,group);
-               while (sep = strsep(&s,"|")) {
+               while ((sep = strsep(&s,"|"))) {
                    strcpy(sepcopy,sep);
                    strcat(sepcopy,pattern+border+1);
                    if (option_debug)
@@ -737,7 +734,6 @@ int ast_extension_patmatch(const char *pattern, char *data)
                return 0;
            } else {
                if (pattern[1] != '{') { /* capture without quantifiers */
-                   char name[16];
                    int l = strlen(groupdata) - strlen(data);
                    groupdata[l-1] = '\0';
                    *(group+strlen(group)-1) = '\0';
@@ -810,7 +806,7 @@ int ast_extension_patmatch(const char *pattern, char *data)
 }
 
 /* try exactly num repetitions, from high to from */
-int ast_extension_patmatch_repeated(const char *pattern, char *data, const int num) 
+static int ast_extension_patmatch_repeated(const char *pattern, const char *data, const int num) 
 {
     int i;
     ast_log(LOG_DEBUG, "  >>> try %d repetitions of '%s' in data '%s'\n", num, pattern, data);
@@ -848,7 +844,7 @@ int ast_extension_match(char *pattern, char *data)
 
 static int extension_close(char *pattern, char *data, int needmore)
 {
-       int match;
+       int match=1;
        /* If "data" is longer, it can'be a subset of pattern unless
           pattern is a pattern match */
        if ((strlen(pattern) < strlen(data)) && (pattern[0] != '_'))
diff --git a/say.c b/say.c
index 40b5131..4b8dcf3 100755 (executable)
--- a/say.c
+++ b/say.c
  */
 
 #include <sys/types.h>
+#include <string.h>
+#include <stdlib.h>
+#include <netinet/in.h>
+#include <time.h>
 #include <asterisk/file.h>
 #include <asterisk/channel.h>
 #include <asterisk/logger.h>
 #include <asterisk/say.h>
+#include <asterisk/lock.h>
+#include <asterisk/localtime.h>
+#include "asterisk.h"
 #include <stdio.h>
 
+#define DIGITS_DIR     AST_SOUNDS "/digits/"
+
 int ast_say_digit_str(struct ast_channel *chan, char *fn2, char *ints, char *lang)
 {
        /* XXX Merge with full version? XXX */
@@ -105,14 +114,14 @@ int ast_say_number_full(struct ast_channel *chan, int num, char *ints, char *lan
                                        playh++;
                                        num -= ((num / 100) * 100);
                                } else {
-                                       if (num < 1000000) {
+                                       if (num < 1000000) { /* 1,000,000 */
                                                res = ast_say_number_full(chan, num / 1000, ints, language, audiofd, ctrlfd);
                                                if (res)
                                                        return res;
                                                num = num % 1000;
                                                snprintf(fn, sizeof(fn), "digits/thousand");
                                        } else {
-                                               if (num < 1000000000) {
+                                               if (num < 1000000000) { /* 1,000,000,000 */
                                                        res = ast_say_number_full(chan, num / 1000000, ints, language, audiofd, ctrlfd);
                                                        if (res)
                                                                return res;
@@ -204,11 +213,7 @@ int ast_say_date(struct ast_channel *chan, time_t t, char *ints, char *lang)
        struct tm tm;
        char fn[256];
        int res = 0;
-       localtime_r(&t,&tm);
-       if (!&tm) {
-               ast_log(LOG_WARNING, "Unable to derive local time\n");
-               return -1;
-       }
+       ast_localtime(&t,&tm,NULL);
        if (!res) {
                snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
                res = ast_streamfile(chan, fn, lang);
@@ -231,16 +236,267 @@ int ast_say_date(struct ast_channel *chan, time_t t, char *ints, char *lang)
        return res;
 }
 
+static int wait_file(struct ast_channel *chan, char *ints, char *file, char *lang) 
+{
+       int res;
+       if ((res = ast_streamfile(chan, file, lang)))
+               ast_log(LOG_WARNING, "Unable to play message %s\n", file);
+       if (!res)
+               res = ast_waitstream(chan, ints);
+       return res;
+}
+
+int ast_say_date_with_format(struct ast_channel *chan, time_t time, char *ints, char *lang, char *format, char *timezone)
+{
+       struct tm tm;
+       int res=0, offset, sndoffset;
+       char sndfile[256], nextmsg[256];
+
+       ast_log(LOG_DEBUG, "ast_say_date_with_format() called\n");
+
+       ast_localtime(&time,&tm,timezone);
+
+       ast_log(LOG_DEBUG, "ast_localtime() returned\n");
+
+       for (offset=0 ; format[offset] != '\0' ; offset++) {
+               ast_log(LOG_DEBUG, "Parsing %c (offset %d) in %s\n", format[offset], offset, format);
+               switch (format[offset]) {
+                       /* NOTE:  if you add more options here, please try to be consistent with strftime(3) */
+                       case '\'':
+                               /* Literal name of a sound file */
+                               sndoffset=0;
+                               for (sndoffset=0 ; (format[++offset] != '\'') && (sndoffset < 256) ; sndoffset++)
+                                       sndfile[sndoffset] = format[offset];
+                               sndfile[sndoffset] = '\0';
+                               snprintf(nextmsg,sizeof(nextmsg), AST_SOUNDS "/%s", sndfile);
+                               res = wait_file(chan,ints,nextmsg,lang);
+                               break;
+                       case 'A':
+                       case 'a':
+                               /* Sunday - Saturday */
+                               snprintf(nextmsg,sizeof(nextmsg), DIGITS_DIR "day-%d", tm.tm_wday);
+                               res = wait_file(chan,ints,nextmsg,lang);
+                               break;
+                       case 'B':
+                       case 'b':
+                       case 'h':
+                               /* January - December */
+                               snprintf(nextmsg,sizeof(nextmsg), DIGITS_DIR "mon-%d", tm.tm_mon);
+                               res = wait_file(chan,ints,nextmsg,lang);
+                               break;
+                       case 'd':
+                       case 'e':
+                               /* First - Thirtyfirst */
+                               if ((tm.tm_mday < 21) || (tm.tm_mday == 30)) {
+                                       snprintf(nextmsg,sizeof(nextmsg), DIGITS_DIR "h-%d", tm.tm_mday);
+                                       res = wait_file(chan,ints,nextmsg,lang);
+                               } else if (tm.tm_mday == 31) {
+                                       /* "Thirty" and "first" */
+                                       res = wait_file(chan,ints,DIGITS_DIR "30",lang);
+                                       if (!res) {
+                                               res = wait_file(chan,ints,DIGITS_DIR "h-1",lang);
+                                       }
+                               } else {
+                                       /* Between 21 and 29 - two sounds */
+                                       res = wait_file(chan,ints,DIGITS_DIR "20",lang);
+                                       if (!res) {
+                                               snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "h-%d", tm.tm_mday - 20);
+                                               res = wait_file(chan,ints,nextmsg,lang);
+                                       }
+                               }
+                               break;
+                       case 'Y':
+                               /* Year */
+                               if (tm.tm_year > 99) {
+                                       res = wait_file(chan,ints,DIGITS_DIR "2",lang);
+                                       if (!res) {
+                                               res = wait_file(chan,ints,DIGITS_DIR "thousand",lang);
+                                       }
+                                       if (tm.tm_year > 100) {
+                                               if (!res) {
+                                                       /* This works until the end of 2020 */
+                                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_year - 100);
+                                                       res = wait_file(chan,ints,nextmsg,lang);
+                                               }
+                                       }
+                               } else {
+                                       if (tm.tm_year < 1) {
+                                               /* I'm not going to handle 1900 and prior */
+                                               /* We'll just be silent on the year, instead of bombing out. */
+                                       } else {
+                                               res = wait_file(chan,ints,DIGITS_DIR "19",lang);
+                                               if (!res) {
+                                                       if (tm.tm_year <= 9) {
+                                                               /* 1901 - 1909 */
+                                                               res = wait_file(chan,ints,DIGITS_DIR "oh",lang);
+                                                               if (!res) {
+                                                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_year);
+                                                                       res = wait_file(chan,ints,nextmsg,lang);
+                                                               }
+                                                       } else if (tm.tm_year <= 20) {
+                                                               /* 1910 - 1920 */
+                                                               snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_year);
+                                                               res = wait_file(chan,ints,nextmsg,lang);
+                                                       } else {
+                                                               /* 1921 - 1999 */
+                                                               int ten, one;
+                                                               ten = tm.tm_year / 10;
+                                                               one = tm.tm_year % 10;
+                                                               snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", ten * 10);
+                                                               res = wait_file(chan,ints,nextmsg,lang);
+                                                               if (!res) {
+                                                                       if (one != 0) {
+                                                                               snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", one);
+                                                                               res = wait_file(chan,ints,nextmsg,lang);
+                                                                       }
+                                                               }
+                                                       }
+                                               }
+                                       }
+                               }
+                               break;
+                       case 'I':
+                       case 'l':
+                               /* 12-Hour */
+                               if (tm.tm_hour == 0)
+                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "12");
+                               else if (tm.tm_hour > 12)
+                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_hour - 12);
+                               else
+                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_hour);
+                               res = wait_file(chan,ints,nextmsg,lang);
+                               break;
+                       case 'H':
+                       case 'k':
+                               /* 24-Hour */
+                               if (format[offset] == 'H') {
+                                       /* e.g. oh-eight */
+                                       if (tm.tm_hour < 10) {
+                                               res = wait_file(chan,ints,DIGITS_DIR "oh",lang);
+                                       }
+                               } else {
+                                       /* e.g. eight */
+                                       if (tm.tm_hour == 0) {
+                                               res = wait_file(chan,ints,DIGITS_DIR "oh",lang);
+                                       }
+                               }
+                               if (!res) {
+                                       if (tm.tm_hour != 0) {
+                                               snprintf(nextmsg,sizeof(nextmsg), AST_SOUNDS "/digits/%d", tm.tm_hour);
+                                               res = wait_file(chan,ints,nextmsg,lang);
+                                       }
+                               }
+                               break;
+                       case 'M':
+                               /* Minute */
+                               if (tm.tm_min == 0) {
+                                       res = wait_file(chan,ints,DIGITS_DIR "oclock",lang);
+                               } else if (tm.tm_min < 10) {
+                                       res = wait_file(chan,ints,DIGITS_DIR "oh",lang);
+                                       if (!res) {
+                                               snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_min);
+                                               res = wait_file(chan,ints,nextmsg,lang);
+                                       }
+                               } else if ((tm.tm_min < 21) || (tm.tm_min % 10 == 0)) {
+                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", tm.tm_min);
+                                       res = wait_file(chan,ints,nextmsg,lang);
+                               } else {
+                                       int ten, one;
+                                       ten = (tm.tm_min / 10) * 10;
+                                       one = (tm.tm_min % 10);
+                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", ten);
+                                       res = wait_file(chan,ints,nextmsg,lang);
+                                       if (!res) {
+                                               /* Fifty, not fifty-zero */
+                                               if (one != 0) {
+                                                       snprintf(nextmsg,sizeof(nextmsg),DIGITS_DIR "%d", one);
+                                                       res = wait_file(chan,ints,nextmsg,lang);
+                                               }
+                                       }
+                               }
+                               break;
+                       case 'P':
+                       case 'p':
+                               /* AM/PM */
+                               if ((tm.tm_hour == 0) || (tm.tm_hour > 11))
+                                       snprintf(nextmsg,sizeof(nextmsg), DIGITS_DIR "p-m");
+                               else
+                                       snprintf(nextmsg,sizeof(nextmsg), DIGITS_DIR "a-m");
+                               res = wait_file(chan,ints,nextmsg,lang);
+                               break;
+                       case 'Q':
+                               /* Shorthand for "Today", "Yesterday", or ABdY */
+                               {
+                                       struct timeval now;
+                                       struct tm tmnow;
+                                       time_t beg_today;
+
+                                       gettimeofday(&now,NULL);
+                                       ast_localtime(&now.tv_sec,&tmnow,timezone);
+                                       /* This might be slightly off, if we transcend a leap second, but never more off than 1 second */
+                                       /* In any case, it saves not having to do ast_mktime() */
+                                       beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
+                                       if (beg_today < time) {
+                                               /* Today */
+                                               res = wait_file(chan,ints,DIGITS_DIR "today",lang);
+                                       } else if (beg_today - 86400 < time) {
+                                               /* Yesterday */
+                                               res = wait_file(chan,ints,DIGITS_DIR "yesterday",lang);
+                                       } else {
+                                               res = ast_say_date_with_format(chan, time, ints, lang, "ABdY", timezone);
+                                       }
+                               }
+                               break;
+                       case 'q':
+                               /* Shorthand for "" (today), "Yesterday", A (weekday), or ABdY */
+                               {
+                                       struct timeval now;
+                                       struct tm tmnow;
+                                       time_t beg_today;
+
+                                       gettimeofday(&now,NULL);
+                                       ast_localtime(&now.tv_sec,&tmnow,timezone);
+                                       /* This might be slightly off, if we transcend a leap second, but never more off than 1 second */
+                                       /* In any case, it saves not having to do ast_mktime() */
+                                       beg_today = now.tv_sec - (tmnow.tm_hour * 3600) - (tmnow.tm_min * 60) - (tmnow.tm_sec);
+                                       if (beg_today < time) {
+                                               /* Today */
+                                       } else if ((beg_today - 86400) < time) {
+                                               /* Yesterday */
+                                               res = wait_file(chan,ints,DIGITS_DIR "yesterday",lang);
+                                       } else if (beg_today - 86400 * 6 < time) {
+                                               /* Within the last week */
+                                               res = ast_say_date_with_format(chan, time, ints, lang, "A", timezone);
+                                       } else {
+                                               res = ast_say_date_with_format(chan, time, ints, lang, "ABdY", timezone);
+                                       }
+                               }
+                               break;
+                       case 'R':
+                               res = ast_say_date_with_format(chan, time, ints, lang, "HM", timezone);
+                               break;
+                       case ' ':
+                       case '  ':
+                               /* Just ignore spaces and tabs */
+                               break;
+                       default:
+                               /* Unknown character */
+                               ast_log(LOG_WARNING, "Unknown character in datetime format %s: %c at pos %d\n", format, format[offset], offset);
+               }
+               /* Jump out on DTMF */
+               if (res) {
+                       break;
+               }
+       }
+       return res;
+}
+
 int ast_say_time(struct ast_channel *chan, time_t t, char *ints, char *lang)
 {
        struct tm tm;
        int res = 0;
        int hour, pm=0;
        localtime_r(&t,&tm);
-       if (!&tm) {
-               ast_log(LOG_WARNING, "Unable to derive local time\n");
-               return -1;
-       }
        hour = tm.tm_hour;
        if (!hour)
                hour = 12;
@@ -288,10 +544,6 @@ int ast_say_datetime(struct ast_channel *chan, time_t t, char *ints, char *lang)
        int res = 0;
        int hour, pm=0;
        localtime_r(&t,&tm);
-       if (!&tm) {
-               ast_log(LOG_WARNING, "Unable to derive local time\n");
-               return -1;
-       }
        if (!res) {
                snprintf(fn, sizeof(fn), "digits/day-%d", tm.tm_wday);
                res = ast_streamfile(chan, fn, lang);
@@ -361,10 +613,6 @@ int ast_say_datetime_from_now(struct ast_channel *chan, time_t t, char *ints, ch
        time(&nowt);
 
        localtime_r(&t,&tm);
-       if (!&tm) {
-               ast_log(LOG_WARNING, "Unable to derive local time\n");
-               return -1;
-       }
        localtime_r(&nowt,&now);
        daydiff = now.tm_yday - tm.tm_yday;
        if ((daydiff < 0) || (daydiff > 6)) {
diff --git a/stdtime/Makefile b/stdtime/Makefile
new file mode 100755 (executable)
index 0000000..fede065
--- /dev/null
@@ -0,0 +1,19 @@
+
+CC=gcc
+#CFLAGS=-Wall
+INCLUDE=-I../include
+
+all: localtime.o
+
+clean::
+       rm -f localtime.o test
+
+depend::
+       @echo "Nothing to do for depend"
+
+test: test.c
+       ${CC} ${CFLAGS} -o test test.c
+
+localtime.o: localtime.c
+
+
diff --git a/stdtime/localtime.c b/stdtime/localtime.c
new file mode 100755 (executable)
index 0000000..f64cec8
--- /dev/null
@@ -0,0 +1,1462 @@
+/*
+ * Asterisk -- A telephony toolkit for Linux.
+ *
+ * Multi-timezone Localtime code
+ * 
+ * Copyright (C) 2003, Mark Spencer
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License
+ *
+ * Most of this code is in the public domain, so clarified as of
+ * June 5, 1996 by Arthur David Olson (arthur_david_olson@nih.gov).
+ *
+ * All modifications to this code to abstract timezones away from
+ * the environment are by Tilghman Lesher, <tlesher@vcch.com>, with
+ * the copyright assigned to Digium.
+ */
+
+/*
+ * Asterisk defines
+ *
+ * Don't mess with these unless you're really sure you know what you're doing.
+ */
+#define _THREAD_SAFE
+#define TZ_STRLEN_MAX  255
+/* #define DEBUG */
+#include <asterisk/lock.h>
+
+
+#ifndef lint
+#ifndef NOID
+static char    elsieid[] = "@(#)localtime.c    7.57";
+#endif /* !defined NOID */
+#endif /* !defined lint */
+
+/*
+** Leap second handling from Bradley White (bww@k.gp.cs.cmu.edu).
+** POSIX-style TZ environment variable handling from Guy Harris
+** (guy@auspex.com).
+*/
+
+/*LINTLIBRARY*/
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "private.h"
+#include "tzfile.h"
+#include "fcntl.h"
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+/*
+** SunOS 4.1.1 headers lack O_BINARY.
+*/
+
+#ifdef O_BINARY
+#define OPEN_MODE      (O_RDONLY | O_BINARY)
+#endif /* defined O_BINARY */
+#ifndef O_BINARY
+#define OPEN_MODE      O_RDONLY
+#endif /* !defined O_BINARY */
+
+#ifndef WILDABBR
+/*
+** Someone might make incorrect use of a time zone abbreviation:
+**     1.      They might reference tzname[0] before calling ast_tzset (explicitly
+**             or implicitly).
+**     2.      They might reference tzname[1] before calling ast_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).
+*/
+#define WILDABBR       "   "
+#endif /* !defined WILDABBR */
+
+static char            wildabbr[] = "WILDABBR";
+
+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 */
+       int             tt_ttisgmt;     /* TRUE if transition is GMT */
+};
+
+struct lsinfo {                                /* leap second information */
+       time_t          ls_trans;       /* transition time */
+       long            ls_corr;        /* correction to apply */
+};
+
+#define BIGGEST(a, b)  (((a) > (b)) ? (a) : (b))
+
+#ifdef TZNAME_MAX
+#define MY_TZNAME_MAX  TZNAME_MAX
+#endif /* defined TZNAME_MAX */
+#ifndef TZNAME_MAX
+#define MY_TZNAME_MAX  255
+#endif /* !defined TZNAME_MAX */
+
+struct state {
+       char    name[TZ_STRLEN_MAX + 1];
+       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[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt),
+                               (2 * (MY_TZNAME_MAX + 1)))];
+       struct lsinfo   lsis[TZ_MAX_LEAPS];
+       struct state    *next;
+};
+
+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.
+*/
+
+static long            detzcode P((const char * codep));
+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, const char * zone));
+static void            localsub P((const time_t * timep, long offset,
+                               struct tm * tmp, const char * zone));
+static int             increment_overflow P((int * number, int delta));
+static int             normalize_overflow P((int * tensptr, int * unitsptr,
+                               int base));
+static time_t          time1 P((struct tm * tmp,
+                               void(*funcp) P((const time_t *,
+                               long, struct tm *, const char*)),
+                               long offset, const char * zone));
+static time_t          time2 P((struct tm *tmp,
+                               void(*funcp) P((const time_t *,
+                               long, struct tm*, const char*)),
+                               long offset, int * okayp, const char * zone));
+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 struct state *  lclptr      = NULL;
+static struct state *  last_lclptr = NULL;
+static struct state *  gmtptr      = NULL;
+
+#ifndef TZ_STRLEN_MAX
+#define TZ_STRLEN_MAX 255
+#endif /* !defined TZ_STRLEN_MAX */
+
+static int             gmt_is_set;
+#ifdef _THREAD_SAFE
+static ast_mutex_t             lcl_mutex   = AST_MUTEX_INITIALIZER;
+static ast_mutex_t             tzset_mutex     = AST_MUTEX_INITIALIZER;
+static ast_mutex_t             tzsetwall_mutex = AST_MUTEX_INITIALIZER;
+static ast_mutex_t             gmt_mutex   = AST_MUTEX_INITIALIZER;
+#endif
+
+/*
+** Section 4.12.3 of X3.159-1989 requires that
+**     Except for the strftime function, these functions [asctime,
+**     ctime, gmtime, localtime] return values in one of two static
+**     objects: a broken-down time structure and an array of char.
+** Thanks to Paul Eggert (eggert@twinsun.com) for noting this.
+*/
+
+static long
+detzcode(codep)
+const char * const     codep;
+{
+       register long   result;
+       register int    i;
+
+       result = (codep[0] & 0x80) ? ~0L : 0L;
+       for (i = 0; i < 4; ++i)
+               result = (result << 8) | (codep[i] & 0xff);
+       return result;
+}
+
+static int
+tzload(name, sp)
+register const char *          name;
+register struct state * const  sp;
+{
+       register const char *   p;
+       register int            i;
+       register int            fid;
+
+#ifdef DEBUG
+       fprintf(stderr,"tzload called with name=%s, sp=%d\n", name, sp);
+#endif
+       if (name == NULL && (name = TZDEFAULT) == NULL)
+               return -1;
+       {
+               register int    doaccess;
+               struct stat     stab;
+               /*
+               ** Section 4.9.1 of the C standard says that
+               ** "FILENAME_MAX expands to an integral constant expression
+               ** that is the size needed for an array of char large enough
+               ** to hold the longest file name string that the implementation
+               ** guarantees can be opened."
+               */
+               char            fullname[FILENAME_MAX + 1];
+
+               if (name[0] == ':')
+                       ++name;
+               doaccess = name[0] == '/';
+               if (!doaccess) {
+                       if ((p = TZDIR) == NULL)
+                               return -1;
+                       if ((strlen(p) + 1 + strlen(name) + 1) >= sizeof fullname)
+                               return -1;
+                       (void) strcpy(fullname, p);
+                       (void) strcat(fullname, "/");
+                       (void) strcat(fullname, name);
+                       /*
+                       ** Set doaccess if '.' (as in "../") shows up in name.
+                       */
+                       if (strchr(name, '.') != NULL)
+                               doaccess = TRUE;
+                       name = fullname;
+               }
+               if (doaccess && access(name, R_OK) != 0)
+                       return -1;
+               if ((fid = open(name, OPEN_MODE)) == -1)
+                       return -1;
+               if ((fstat(fid, &stab) < 0) || !S_ISREG(stab.st_mode)) {
+                       close(fid);
+                       return -1;
+               }
+       }
+       {
+               struct tzhead * tzhp;
+               char            buf[sizeof *sp + sizeof *tzhp];
+               int             ttisstdcnt;
+               int             ttisgmtcnt;
+
+               i = read(fid, buf, sizeof buf);
+               if (close(fid) != 0)
+                       return -1;
+               p = buf;
+               p += (sizeof tzhp->tzh_magic) + (sizeof tzhp->tzh_reserved);
+               ttisstdcnt = (int) detzcode(p);
+               p += 4;
+               ttisgmtcnt = (int) detzcode(p);
+               p += 4;
+               sp->leapcnt = (int) detzcode(p);
+               p += 4;
+               sp->timecnt = (int) detzcode(p);
+               p += 4;
+               sp->typecnt = (int) detzcode(p);
+               p += 4;
+               sp->charcnt = (int) detzcode(p);
+               p += 4;
+               if (sp->leapcnt < 0 || sp->leapcnt > TZ_MAX_LEAPS ||
+                       sp->typecnt <= 0 || sp->typecnt > TZ_MAX_TYPES ||
+                       sp->timecnt < 0 || sp->timecnt > TZ_MAX_TIMES ||
+                       sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS ||
+                       (ttisstdcnt != sp->typecnt && ttisstdcnt != 0) ||
+                       (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))
+                               return -1;
+               if (i - (p - buf) < sp->timecnt * 4 +   /* ats */
+                       sp->timecnt +                   /* types */
+                       sp->typecnt * (4 + 2) +         /* ttinfos */
+                       sp->charcnt +                   /* chars */
+                       sp->leapcnt * (4 + 4) +         /* lsinfos */
+                       ttisstdcnt +                    /* ttisstds */
+                       ttisgmtcnt)                     /* ttisgmts */
+                               return -1;
+               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) {
+                       register 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) {
+                       register 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) {
+                       register 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;
+                       }
+               }
+               for (i = 0; i < sp->typecnt; ++i) {
+                       register struct ttinfo *        ttisp;
+
+                       ttisp = &sp->ttis[i];
+                       if (ttisgmtcnt == 0)
+                               ttisp->tt_ttisgmt = FALSE;
+                       else {
+                               ttisp->tt_ttisgmt = *p++;
+                               if (ttisp->tt_ttisgmt != TRUE &&
+                                       ttisp->tt_ttisgmt != 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, 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(strp, nump, min, max)
+register const char *  strp;
+int * const            nump;
+const int              min;
+const int              max;
+{
+       register char   c;
+       register int    num;
+
+       if (strp == NULL || !is_digit(c = *strp))
+               return NULL;
+       num = 0;
+       do {
+               num = num * 10 + (c - '0');
+               if (num > max)
+                       return NULL;    /* illegal value */
+               c = *++strp;
+       } while (is_digit(c));
+       if (num < min)
+               return NULL;            /* illegal value */
+       *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(strp, secsp)
+register const char *  strp;
+long * const           secsp;
+{
+       int     num;
+
+       /*
+       ** `HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like
+       ** "M10.4.6/26", which does not conform to Posix,
+       ** but which specifies the equivalent of
+       ** ``02:00 on the first Sunday on or after 23 Oct''.
+       */
+       strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1);
+       if (strp == NULL)
+               return NULL;
+       *secsp = num * (long) SECSPERHOUR;
+       if (*strp == ':') {
+               ++strp;
+               strp = getnum(strp, &num, 0, MINSPERHOUR - 1);
+               if (strp == NULL)
+                       return NULL;
+               *secsp += num * SECSPERMIN;
+               if (*strp == ':') {
+                       ++strp;
+                       /* `SECSPERMIN' allows for leap seconds.  */
+                       strp = getnum(strp, &num, 0, SECSPERMIN);
+                       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.
+*/
+
+static const char *
+getoffset(strp, offsetp)
+register const char *  strp;
+long * const           offsetp;
+{
+       register int    neg = 0;
+
+       if (*strp == '-') {
+               neg = 1;
+               ++strp;
+       } else if (*strp == '+')
+               ++strp;
+       strp = getsecs(strp, offsetp);
+       if (strp == NULL)
+               return NULL;            /* illegal time */
+       if (neg)
+               *offsetp = -*offsetp;
+       return strp;
+}
+
+/*
+** Given a pointer into a time zone string, extract a rule in the form
+** date[/time].  See POSIX section 8 for the format of "date" and "time".
+** If a valid rule is not found, return NULL.
+** Otherwise, return a pointer to the first character not part of the rule.
+*/
+
+static const char *
+getrule(strp, rulep)
+const char *                   strp;
+register struct rule * const   rulep;
+{
+       if (*strp == 'J') {
+               /*
+               ** Julian day.
+               */
+               rulep->r_type = JULIAN_DAY;
+               ++strp;
+               strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);
+       } else if (*strp == 'M') {
+               /*
+               ** Month, week, day.
+               */
+               rulep->r_type = MONTH_NTH_DAY_OF_WEEK;
+               ++strp;
+               strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR);
+               if (strp == NULL)
+                       return NULL;
+               if (*strp++ != '.')
+                       return NULL;
+               strp = getnum(strp, &rulep->r_week, 1, 5);
+               if (strp == NULL)
+                       return NULL;
+               if (*strp++ != '.')
+                       return NULL;
+               strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);
+       } else if (is_digit(*strp)) {
+               /*
+               ** Day of year.
+               */
+               rulep->r_type = DAY_OF_YEAR;
+               strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
+       } else  return NULL;            /* invalid format */
+       if (strp == NULL)
+               return NULL;
+       if (*strp == '/') {
+               /*
+               ** Time specified.
+               */
+               ++strp;
+               strp = getsecs(strp, &rulep->r_time);
+       } else  rulep->r_time = 2 * SECSPERHOUR;        /* default = 2:00:00 */
+       return strp;
+}
+
+/*
+** Given the Epoch-relative time of January 1, 00:00:00 GMT, in a year, the
+** year, a rule, and the offset from GMT at the time that rule takes effect,
+** calculate the Epoch-relative time that rule takes effect.
+*/
+
+static time_t
+transtime(janfirst, year, rulep, offset)
+const time_t                           janfirst;
+const int                              year;
+register const struct rule * const     rulep;
+const long                             offset;
+{
+       register int    leapyear;
+       register time_t value = 0;
+       register int    i;
+       int             d, m1, yy0, yy1, yy2, dow;
+
+       leapyear = isleap(year);
+       switch (rulep->r_type) {
+
+       case JULIAN_DAY:
+               /*
+               ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap
+               ** years.
+               ** In non-leap years, or if the day number is 59 or less, just
+               ** add SECSPERDAY times the day number-1 to the time of
+               ** January 1, midnight, to get the day.
+               */
+               value = janfirst + (rulep->r_day - 1) * SECSPERDAY;
+               if (leapyear && rulep->r_day >= 60)
+                       value += SECSPERDAY;
+               break;
+
+       case DAY_OF_YEAR:
+               /*
+               ** n - day of year.
+               ** Just add SECSPERDAY times the day number to the time of
+               ** January 1, midnight, to get the day.
+               */
+               value = janfirst + rulep->r_day * SECSPERDAY;
+               break;
+
+       case MONTH_NTH_DAY_OF_WEEK:
+               /*
+               ** Mm.n.d - nth "dth day" of month m.
+               */
+               value = janfirst;
+               for (i = 0; i < rulep->r_mon - 1; ++i)
+                       value += mon_lengths[leapyear][i] * SECSPERDAY;
+
+               /*
+               ** Use Zeller's Congruence to get day-of-week of first day of
+               ** month.
+               */
+               m1 = (rulep->r_mon + 9) % 12 + 1;
+               yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;
+               yy1 = yy0 / 100;
+               yy2 = yy0 % 100;
+               dow = ((26 * m1 - 2) / 10 +
+                       1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
+               if (dow < 0)
+                       dow += DAYSPERWEEK;
+
+               /*
+               ** "dow" is the day-of-week of the first day of the month.  Get
+               ** the day-of-month (zero-origin) of the first "dow" day of the
+               ** month.
+               */
+               d = rulep->r_day - dow;
+               if (d < 0)
+                       d += DAYSPERWEEK;
+               for (i = 1; i < rulep->r_week; ++i) {
+                       if (d + DAYSPERWEEK >=
+                               mon_lengths[leapyear][rulep->r_mon - 1])
+                                       break;
+                       d += DAYSPERWEEK;
+               }
+
+               /*
+               ** "d" is the day-of-month (zero-origin) of the day we want.
+               */
+               value += d * SECSPERDAY;
+               break;
+       }
+
+       /*
+       ** "value" is the Epoch-relative time of 00:00:00 GMT on the day in
+       ** question.  To get the Epoch-relative time of the specified local
+       ** time on that day, add the transition time and the current offset
+       ** from GMT.
+       */
+       return value + rulep->r_time + offset;
+}
+
+/*
+** Given a POSIX section 8-style TZ string, fill in the rule tables as
+** appropriate.
+*/
+
+static int
+tzparse(name, sp, lastditch)
+const char *                   name;
+register struct state * const  sp;
+const int                      lastditch;
+{
+       const char *                    stdname;
+       const char *                    dstname = NULL;
+       size_t                          stdlen = 0;
+       size_t                          dstlen = 0;
+       long                            stdoffset = 0L;
+       long                            dstoffset = 0L;
+       register time_t *               atp;
+       register unsigned char *        typep;
+       register char *                 cp;
+       register int                    load_result;
+
+       stdname = name;
+       load_result = tzload(TZDEFRULES, sp);
+       if (load_result != 0)
+               sp->leapcnt = 0;                /* so, we're off a little */
+       if (*name != '\0') {
+               if (*name != '\0' && *name != ',' && *name != ';') {
+                       name = getoffset(name, &dstoffset);
+                       if (name == NULL)
+                               return -1;
+               } else  dstoffset = stdoffset - SECSPERHOUR;
+               if (*name == ',' || *name == ';') {
+                       struct rule     start;
+                       struct rule     end;
+                       register int    year;
+                       register time_t janfirst;
+                       time_t          starttime;
+                       time_t          endtime;
+
+                       ++name;
+                       if ((name = getrule(name, &start)) == NULL)
+                               return -1;
+                       if (*name++ != ',')
+                               return -1;
+                       if ((name = getrule(name, &end)) == NULL)
+                               return -1;
+                       if (*name != '\0')
+                               return -1;
+                       sp->typecnt = 2;        /* standard time and DST */
+                       /*
+                       ** Two transitions per year, from EPOCH_YEAR to 2037.
+                       */
+                       sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1);
+                       if (sp->timecnt > TZ_MAX_TIMES)
+                               return -1;
+                       sp->ttis[0].tt_gmtoff = -dstoffset;
+                       sp->ttis[0].tt_isdst = 1;
+                       sp->ttis[0].tt_abbrind = stdlen + 1;
+                       sp->ttis[1].tt_gmtoff = -stdoffset;
+                       sp->ttis[1].tt_isdst = 0;
+                       sp->ttis[1].tt_abbrind = 0;
+                       atp = sp->ats;
+                       typep = sp->types;
+                       janfirst = 0;
+                       for (year = EPOCH_YEAR; year <= 2037; ++year) {
+                               starttime = transtime(janfirst, year, &start,
+                                       stdoffset);
+                               endtime = transtime(janfirst, year, &end,
+                                       dstoffset);
+                               if (starttime > endtime) {
+                                       *atp++ = endtime;
+                                       *typep++ = 1;   /* DST ends */
+                                       *atp++ = starttime;
+                                       *typep++ = 0;   /* DST begins */
+                               } else {
+                                       *atp++ = starttime;
+                                       *typep++ = 0;   /* DST begins */
+                                       *atp++ = endtime;
+                                       *typep++ = 1;   /* DST ends */
+                               }
+                               janfirst += year_lengths[isleap(year)] *
+                                       SECSPERDAY;
+                       }
+               } else {
+                       register long   theirstdoffset;
+                       register long   theirdstoffset;
+                       register long   theiroffset;
+                       register int    isdst;
+                       register int    i;
+                       register int    j;
+
+                       if (*name != '\0')
+                               return -1;
+                       if (load_result != 0)
+                               return -1;
+                       /*
+                       ** Initial values of theirstdoffset and theirdstoffset.
+                       */
+                       theirstdoffset = 0;
+                       for (i = 0; i < sp->timecnt; ++i) {
+                               j = sp->types[i];
+                               if (!sp->ttis[j].tt_isdst) {
+                                       theirstdoffset =
+                                               -sp->ttis[j].tt_gmtoff;
+                                       break;
+                               }
+                       }
+                       theirdstoffset = 0;
+                       for (i = 0; i < sp->timecnt; ++i) {
+                               j = sp->types[i];
+                               if (sp->ttis[j].tt_isdst) {
+                                       theirdstoffset =
+                                               -sp->ttis[j].tt_gmtoff;
+                                       break;
+                               }
+                       }
+                       /*
+                       ** Initially we're assumed to be in standard time.
+                       */
+                       isdst = FALSE;
+                       theiroffset = theirstdoffset;
+                       /*
+                       ** Now juggle transition times and types
+                       ** tracking offsets as you do.
+                       */
+                       for (i = 0; i < sp->timecnt; ++i) {
+                               j = sp->types[i];
+                               sp->types[i] = sp->ttis[j].tt_isdst;
+                               if (sp->ttis[j].tt_ttisgmt) {
+                                       /* No adjustment to transition time */
+                               } else {
+                                       /*
+                                       ** If summer time is in effect, and the
+                                       ** transition time was not specified as
+                                       ** standard time, add the summer time
+                                       ** offset to the transition time;
+                                       ** otherwise, add the standard time
+                                       ** offset to the transition time.
+                                       */
+                                       /*
+                                       ** Transitions from DST to DDST
+                                       ** will effectively disappear since
+                                       ** POSIX provides for only one DST
+                                       ** offset.
+                                       */
+                                       if (isdst && !sp->ttis[j].tt_ttisstd) {
+                                               sp->ats[i] += dstoffset -
+                                                       theirdstoffset;
+                                       } else {
+                                               sp->ats[i] += stdoffset -
+                                                       theirstdoffset;
+                                       }
+                               }
+                               theiroffset = -sp->ttis[j].tt_gmtoff;
+                               if (sp->ttis[j].tt_isdst)
+                                       theirdstoffset = theiroffset;
+                               else    theirstdoffset = theiroffset;
+                       }
+                       /*
+                       ** Finally, fill in ttis.
+                       ** ttisstd and ttisgmt need not be handled.
+                       */
+                       sp->ttis[0].tt_gmtoff = -stdoffset;
+                       sp->ttis[0].tt_isdst = FALSE;
+                       sp->ttis[0].tt_abbrind = 0;
+                       sp->ttis[1].tt_gmtoff = -dstoffset;
+                       sp->ttis[1].tt_isdst = TRUE;
+                       sp->ttis[1].tt_abbrind = stdlen + 1;
+               }
+       } else {
+               dstlen = 0;
+               sp->typecnt = 1;                /* only standard time */
+               sp->timecnt = 0;
+               sp->ttis[0].tt_gmtoff = -stdoffset;
+               sp->ttis[0].tt_isdst = 0;
+               sp->ttis[0].tt_abbrind = 0;
+       }
+       sp->charcnt = stdlen + 1;
+       if (dstlen != 0)
+               sp->charcnt += dstlen + 1;
+       if (sp->charcnt > sizeof sp->chars)
+               return -1;
+       cp = sp->chars;
+       (void) strncpy(cp, stdname, stdlen);
+       cp += stdlen;
+       *cp++ = '\0';
+       if (dstlen != 0) {
+               (void) strncpy(cp, dstname, dstlen);
+               *(cp + dstlen) = '\0';
+       }
+       return 0;
+}
+
+static void
+gmtload(sp)
+struct state * const   sp;
+{
+       if (tzload(gmt, sp) != 0)
+               (void) tzparse(gmt, sp, TRUE);
+}
+
+/*
+** A non-static declaration of ast_tzsetwall in a system header file
+** may cause a warning about this upcoming static declaration...
+*/
+static
+#ifdef _THREAD_SAFE
+int
+ast_tzsetwall_basic P((void))
+#else
+int
+ast_tzsetwall P((void))
+#endif
+{
+       struct state *cur_state = lclptr;
+
+       /* Find the appropriate structure, if already parsed */
+       while (cur_state != NULL) {
+               if (cur_state->name[0] == '\0')
+                       break;
+               cur_state = cur_state->next;
+       }
+       if (cur_state != NULL)
+               return 0;
+       cur_state = malloc(sizeof(struct state));
+       if (cur_state == NULL) {
+               return -1;
+       }
+       memset(cur_state,0,sizeof(struct state));
+       if (tzload((char *) NULL, cur_state) != 0)
+               gmtload(cur_state);
+
+       if (last_lclptr)
+               last_lclptr->next = cur_state;
+       else
+               lclptr = cur_state;
+       last_lclptr = cur_state;
+       return 0;
+}
+
+#ifdef _THREAD_SAFE
+int
+ast_tzsetwall P((void))
+{
+       ast_mutex_lock(&tzsetwall_mutex);
+       ast_tzsetwall_basic();
+       ast_mutex_unlock(&tzsetwall_mutex);
+       return 0;
+}
+#endif
+
+#ifdef _THREAD_SAFE
+static int
+ast_tzset_basic P((const char *name))
+#else
+int
+ast_tzset P((const char *name))
+#endif
+{
+       struct state *cur_state = lclptr;
+
+       /* Not set at all */
+       if (name == NULL) {
+               return ast_tzsetwall();
+       }
+
+       /* Find the appropriate structure, if already parsed */
+       while (cur_state != NULL) {
+               if (!strcmp(cur_state->name,name))
+                       break;
+               cur_state = cur_state->next;
+       }
+       if (cur_state != NULL)
+               return 0;
+
+       cur_state = malloc(sizeof(struct state));
+       if (cur_state == NULL) {
+               return -1;
+       }
+       memset(cur_state,0,sizeof(*cur_state));
+
+       /* Name is set, but set to the empty string == no adjustments */
+       if (name[0] == '\0') {
+               /*
+               ** User wants it fast rather than right.
+               */
+               cur_state->leapcnt = 0;         /* so, we're off a little */
+               cur_state->timecnt = 0;
+               cur_state->ttis[0].tt_gmtoff = 0;
+               cur_state->ttis[0].tt_abbrind = 0;
+               (void) strcpy(cur_state->chars, gmt);
+       } else if (tzload(name, cur_state) != 0)
+               if (name[0] == ':' || tzparse(name, cur_state, FALSE) != 0)
+                       (void) gmtload(cur_state);
+       strncpy(cur_state->name,name,sizeof(cur_state->name));
+       if (last_lclptr)
+               last_lclptr->next = cur_state;
+       else
+               lclptr = cur_state;
+       last_lclptr = cur_state;
+       return 0;
+}
+
+#ifdef _THREAD_SAFE
+void
+ast_tzset P((const char *name))
+{
+       ast_mutex_lock(&tzset_mutex);
+       ast_tzset_basic(name);
+       ast_mutex_unlock(&tzset_mutex);
+}
+#endif
+
+/*
+** The easy way to behave "as if no library function calls" localtime
+** is to not call it--so we drop its guts into "localsub", which can be
+** freely called.  (And no, the PANS doesn't require the above behavior--
+** but it *is* desirable.)
+**
+** The unused offset argument is for the benefit of mktime variants.
+*/
+
+/*ARGSUSED*/
+static void
+localsub(timep, offset, tmp, zone)
+const time_t * const   timep;
+const long             offset;
+struct tm * const      tmp;
+const char * const     zone;
+{
+       register struct state *         sp;
+       register const struct ttinfo *  ttisp;
+       register int                    i;
+       const time_t                    t = *timep;
+
+       sp = lclptr;
+       /* Find the right zone record */
+       while (sp != NULL) {
+               if (!strcmp(sp->name,zone))
+                       break;
+               sp = sp->next;
+       }
+
+       if (sp == NULL) {
+               gmtsub(timep, offset, tmp, zone);
+               return;
+       }
+       if (sp->timecnt == 0 || t < sp->ats[0]) {
+               i = 0;
+               while (sp->ttis[i].tt_isdst)
+                       if (++i >= sp->typecnt) {
+                               i = 0;
+                               break;
+                       }
+       } else {
+               for (i = 1; i < sp->timecnt; ++i)
+                       if (t < sp->ats[i])
+                               break;
+               i = sp->types[i - 1];
+       }
+       ttisp = &sp->ttis[i];
+       /*
+       ** To get (wrong) behavior that's compatible with System V Release 2.0
+       ** you'd replace the statement below with
+       **      t += ttisp->tt_gmtoff;
+       **      timesub(&t, 0L, sp, tmp);
+       */
+       timesub(&t, ttisp->tt_gmtoff, sp, tmp);
+       tmp->tm_isdst = ttisp->tt_isdst;
+       tzname[tmp->tm_isdst] = &sp->chars[ttisp->tt_abbrind];
+#ifdef TM_ZONE
+       tmp->TM_ZONE = &sp->chars[ttisp->tt_abbrind];
+#endif /* defined TM_ZONE */
+}
+
+struct tm *
+ast_localtime(timep, p_tm, zone)
+const time_t * const   timep;
+struct tm *p_tm;
+const char * const     zone;
+{
+#ifdef _THREAD_SAFE
+       ast_mutex_lock(&lcl_mutex);
+#endif
+       ast_tzset(zone);
+       localsub(timep, 0L, p_tm, zone);
+#ifdef _THREAD_SAFE
+       ast_mutex_unlock(&lcl_mutex);
+#endif
+       return(p_tm);
+}
+
+/*
+** gmtsub is to gmtime as localsub is to localtime.
+*/
+
+static void
+gmtsub(timep, offset, tmp, zone)
+const time_t * const   timep;
+const long             offset;
+struct tm * const      tmp;
+const char * const     zone;
+{
+#ifdef _THREAD_SAFE
+       ast_mutex_lock(&gmt_mutex);
+#endif
+       if (!gmt_is_set) {
+               gmt_is_set = TRUE;
+               gmtptr = (struct state *) malloc(sizeof *gmtptr);
+               if (gmtptr != NULL)
+                       gmtload(gmtptr);
+       }
+       ast_mutex_unlock(&gmt_mutex);
+       timesub(timep, offset, gmtptr, tmp);
+#ifdef TM_ZONE
+       /*
+       ** Could get fancy here and deliver something such as
+       ** "GMT+xxxx" or "GMT-xxxx" if offset is non-zero,
+       ** but this is no time for a treasure hunt.
+       */
+       if (offset != 0)
+               tmp->TM_ZONE = wildabbr;
+       else {
+               if (gmtptr == NULL)
+                       tmp->TM_ZONE = gmt;
+               else    tmp->TM_ZONE = gmtptr->chars;
+       }
+#endif /* defined TM_ZONE */
+}
+
+static void
+timesub(timep, offset, sp, tmp)
+const time_t * const                   timep;
+const long                             offset;
+register const struct state * const    sp;
+register struct tm * const             tmp;
+{
+       register const struct lsinfo *  lp;
+       register long                   days;
+       register long                   rem;
+       register int                    y;
+       register int                    yleap;
+       register const int *            ip;
+       register long                   corr;
+       register int                    hit;
+       register int                    i;
+
+       corr = 0;
+       hit = 0;
+       i = (sp == NULL) ? 0 : sp->leapcnt;
+       while (--i >= 0) {
+               lp = &sp->lsis[i];
+               if (*timep >= lp->ls_trans) {
+                       if (*timep == lp->ls_trans) {
+                               hit = ((i == 0 && lp->ls_corr > 0) ||
+                                       lp->ls_corr > sp->lsis[i - 1].ls_corr);
+                               if (hit)
+                                       while (i > 0 &&
+                                               sp->lsis[i].ls_trans ==
+                                               sp->lsis[i - 1].ls_trans + 1 &&
+                                               sp->lsis[i].ls_corr ==
+                                               sp->lsis[i - 1].ls_corr + 1) {
+                                                       ++hit;
+                                                       --i;
+                                       }
+                       }
+                       corr = lp->ls_corr;
+                       break;
+               }
+       }
+       days = *timep / SECSPERDAY;
+       rem = *timep % SECSPERDAY;
+#ifdef mc68k
+       if (*timep == 0x80000000) {
+               /*
+               ** A 3B1 muffs the division on the most negative number.
+               */
+               days = -24855;
+               rem = -11648;
+       }
+#endif /* defined mc68k */
+       rem += (offset - corr);
+       while (rem < 0) {
+               rem += SECSPERDAY;
+               --days;
+       }
+       while (rem >= SECSPERDAY) {
+               rem -= SECSPERDAY;
+               ++days;
+       }
+       tmp->tm_hour = (int) (rem / SECSPERHOUR);
+       rem = rem % SECSPERHOUR;
+       tmp->tm_min = (int) (rem / SECSPERMIN);
+       /*
+       ** A positive leap second requires a special
+       ** representation.  This uses "... ??:59:60" et seq.
+       */
+       tmp->tm_sec = (int) (rem % SECSPERMIN) + hit;
+       tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK);
+       if (tmp->tm_wday < 0)
+               tmp->tm_wday += DAYSPERWEEK;
+       y = EPOCH_YEAR;
+#define LEAPS_THRU_END_OF(y)   ((y) / 4 - (y) / 100 + (y) / 400)
+       while (days < 0 || days >= (long) year_lengths[yleap = isleap(y)]) {
+               register int    newy;
+
+               newy = y + days / DAYSPERNYEAR;
+               if (days < 0)
+                       --newy;
+               days -= (newy - y) * DAYSPERNYEAR +
+                       LEAPS_THRU_END_OF(newy - 1) -
+                       LEAPS_THRU_END_OF(y - 1);
+               y = newy;
+       }
+       tmp->tm_year = y - TM_YEAR_BASE;
+       tmp->tm_yday = (int) days;
+       ip = mon_lengths[yleap];
+       for (tmp->tm_mon = 0; days >= (long) ip[tmp->tm_mon]; ++(tmp->tm_mon))
+               days = days - (long) ip[tmp->tm_mon];
+       tmp->tm_mday = (int) (days + 1);
+       tmp->tm_isdst = 0;
+#ifdef TM_GMTOFF
+       tmp->TM_GMTOFF = offset;
+#endif /* defined TM_GMTOFF */
+}
+
+char *
+ctime(timep)
+const time_t * const   timep;
+{
+/*
+** Section 4.12.3.2 of X3.159-1989 requires that
+**     The ctime funciton converts the calendar time pointed to by timer
+**     to local time in the form of a string.  It is equivalent to
+**             asctime(localtime(timer))
+*/
+       return asctime(localtime(timep));
+}
+
+char *
+ctime_r(timep, buf)
+const time_t * const   timep;
+char *buf;
+{
+        struct tm tm;
+       return asctime_r(localtime_r(timep, &tm), buf);
+}
+
+/*
+** Adapted from code provided by Robert Elz, who writes:
+**     The "best" way to do mktime I think is based on an idea of Bob
+**     Kridle's (so its said...) from a long time ago.
+**     [kridle@xinet.com as of 1996-01-16.]
+**     It does a binary search of the time_t space.  Since time_t's are
+**     just 32 bits, its a max of 32 iterations (even at 64 bits it
+**     would still be very reasonable).
+*/
+
+#ifndef WRONG
+#define WRONG  (-1)
+#endif /* !defined WRONG */
+
+/*
+** Simplified normalize logic courtesy Paul Eggert (eggert@twinsun.com).
+*/
+
+static int
+increment_overflow(number, delta)
+int *  number;
+int    delta;
+{
+       int     number0;
+
+       number0 = *number;
+       *number += delta;
+       return (*number < number0) != (delta < 0);
+}
+
+static int
+normalize_overflow(tensptr, unitsptr, base)
+int * const    tensptr;
+int * const    unitsptr;
+const int      base;
+{
+       register int    tensdelta;
+
+       tensdelta = (*unitsptr >= 0) ?
+               (*unitsptr / base) :
+               (-1 - (-1 - *unitsptr) / base);
+       *unitsptr -= tensdelta * base;
+       return increment_overflow(tensptr, tensdelta);
+}
+
+static int
+tmcomp(atmp, btmp)
+register const struct tm * const atmp;
+register const struct tm * const btmp;
+{
+       register int    result;
+
+       if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
+               (result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
+               (result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
+               (result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
+               (result = (atmp->tm_min - btmp->tm_min)) == 0)
+                       result = atmp->tm_sec - btmp->tm_sec;
+       return result;
+}
+
+static time_t
+time2(tmp, funcp, offset, okayp, zone)
+struct tm * const      tmp;
+void (* const          funcp) P((const time_t*, long, struct tm*, const char*));
+const long             offset;
+int * const            okayp;
+const char * const     zone;
+{
+       register const struct state *   sp;
+       register int                    dir;
+       register int                    bits;
+       register int                    i, j ;
+       register int                    saved_seconds;
+       time_t                          newt;
+       time_t                          t;
+       struct tm                       yourtm, mytm;
+
+       *okayp = FALSE;
+       yourtm = *tmp;
+       if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR))
+               return WRONG;
+       if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY))
+               return WRONG;
+       if (normalize_overflow(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR))
+               return WRONG;
+       /*
+       ** Turn yourtm.tm_year into an actual year number for now.
+       ** It is converted back to an offset from TM_YEAR_BASE later.
+       */
+       if (increment_overflow(&yourtm.tm_year, TM_YEAR_BASE))
+               return WRONG;
+       while (yourtm.tm_mday <= 0) {
+               if (increment_overflow(&yourtm.tm_year, -1))
+                       return WRONG;
+               i = yourtm.tm_year + (1 < yourtm.tm_mon);
+               yourtm.tm_mday += year_lengths[isleap(i)];
+       }
+       while (yourtm.tm_mday > DAYSPERLYEAR) {
+               i = yourtm.tm_year + (1 < yourtm.tm_mon);
+               yourtm.tm_mday -= year_lengths[isleap(i)];
+               if (increment_overflow(&yourtm.tm_year, 1))
+                       return WRONG;
+       }
+       for ( ; ; ) {
+               i = mon_lengths[isleap(yourtm.tm_year)][yourtm.tm_mon];
+               if (yourtm.tm_mday <= i)
+                       break;
+               yourtm.tm_mday -= i;
+               if (++yourtm.tm_mon >= MONSPERYEAR) {
+                       yourtm.tm_mon = 0;
+                       if (increment_overflow(&yourtm.tm_year, 1))
+                               return WRONG;
+               }
+       }
+       if (increment_overflow(&yourtm.tm_year, -TM_YEAR_BASE))
+               return WRONG;
+       if (yourtm.tm_year + TM_YEAR_BASE < EPOCH_YEAR) {
+               /*
+               ** We can't set tm_sec to 0, because that might push the
+               ** time below the minimum representable time.
+               ** Set tm_sec to 59 instead.
+               ** This assumes that the minimum representable time is
+               ** not in the same minute that a leap second was deleted from,
+               ** which is a safer assumption than using 58 would be.
+               */
+               if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN))
+                       return WRONG;
+               saved_seconds = yourtm.tm_sec;
+               yourtm.tm_sec = SECSPERMIN - 1;
+       } else {
+               saved_seconds = yourtm.tm_sec;
+               yourtm.tm_sec = 0;
+       }
+       /*
+       ** Divide the search space in half
+       ** (this works whether time_t is signed or unsigned).
+       */
+       bits = TYPE_BIT(time_t) - 1;
+       /*
+       ** If time_t is signed, then 0 is just above the median,
+       ** assuming two's complement arithmetic.
+       ** If time_t is unsigned, then (1 << bits) is just above the median.
+       */
+       t = TYPE_SIGNED(time_t) ? 0 : (((time_t) 1) << bits);
+       for ( ; ; ) {
+               (*funcp)(&t, offset, &mytm, zone);
+               dir = tmcomp(&mytm, &yourtm);
+               if (dir != 0) {
+                       if (bits-- < 0)
+                               return WRONG;
+                       if (bits < 0)
+                               --t; /* may be needed if new t is minimal */
+                       else if (dir > 0)
+                               t -= ((time_t) 1) << bits;
+                       else    t += ((time_t) 1) << bits;
+                       continue;
+               }
+               if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
+                       break;
+               /*
+               ** Right time, wrong type.
+               ** Hunt for right time, right type.
+               ** It's okay to guess wrong since the guess
+               ** gets checked.
+               */
+               /*
+               ** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
+               */
+               sp = (const struct state *)
+                       (((void *) funcp == (void *) localsub) ?
+                       lclptr : gmtptr);
+               if (sp == NULL)
+                       return WRONG;
+               for (i = sp->typecnt - 1; i >= 0; --i) {
+                       if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
+                               continue;
+                       for (j = sp->typecnt - 1; j >= 0; --j) {
+                               if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
+                                       continue;
+                               newt = t + sp->ttis[j].tt_gmtoff -
+                                       sp->ttis[i].tt_gmtoff;
+                               (*funcp)(&newt, offset, &mytm, zone);
+                               if (tmcomp(&mytm, &yourtm) != 0)
+                                       continue;
+                               if (mytm.tm_isdst != yourtm.tm_isdst)
+                                       continue;
+                               /*
+                               ** We have a match.
+                               */
+                               t = newt;
+                               goto label;
+                       }
+               }
+               return WRONG;
+       }
+label:
+       newt = t + saved_seconds;
+       if ((newt < t) != (saved_seconds < 0))
+               return WRONG;
+       t = newt;
+       (*funcp)(&t, offset, tmp, zone);
+       *okayp = TRUE;
+       return t;
+}
+
+static time_t
+time1(tmp, funcp, offset, zone)
+struct tm * const      tmp;
+void (* const          funcp) P((const time_t *, long, struct tm *, const char*));
+const long             offset;
+const char * const     zone;
+{
+       register time_t                 t;
+       register const struct state *   sp;
+       register int                    samei, otheri;
+       int                             okay;
+
+       if (tmp->tm_isdst > 1)
+               tmp->tm_isdst = 1;
+       t = time2(tmp, funcp, offset, &okay, zone);
+#ifdef PCTS
+       /*
+       ** PCTS code courtesy Grant Sullivan (grant@osf.org).
+       */
+       if (okay)
+               return t;
+       if (tmp->tm_isdst < 0)
+               tmp->tm_isdst = 0;      /* reset to std and try again */
+#endif /* defined PCTS */
+#ifndef PCTS
+       if (okay || tmp->tm_isdst < 0)
+               return t;
+#endif /* !defined PCTS */
+       /*
+       ** We're supposed to assume that somebody took a time of one type
+       ** and did some math on it that yielded a "struct tm" that's bad.
+       ** We try to divine the type they started from and adjust to the
+       ** type they need.
+       */
+       /*
+       ** The (void *) casts are the benefit of SunOS 3.3 on Sun 2's.
+       */
+       sp = (const struct state *) (((void *) funcp == (void *) localsub) ?
+               lclptr : gmtptr);
+       if (sp == NULL)
+               return WRONG;
+       for (samei = sp->typecnt - 1; samei >= 0; --samei) {
+               if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
+                       continue;
+               for (otheri = sp->typecnt - 1; otheri >= 0; --otheri) {
+                       if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
+                               continue;
+                       tmp->tm_sec += sp->ttis[otheri].tt_gmtoff -
+                                       sp->ttis[samei].tt_gmtoff;
+                       tmp->tm_isdst = !tmp->tm_isdst;
+                       t = time2(tmp, funcp, offset, &okay, zone);
+                       if (okay)
+                               return t;
+                       tmp->tm_sec -= sp->ttis[otheri].tt_gmtoff -
+                                       sp->ttis[samei].tt_gmtoff;
+                       tmp->tm_isdst = !tmp->tm_isdst;
+               }
+       }
+       return WRONG;
+}
+
+time_t
+ast_mktime(tmp,zone)
+struct tm * const      tmp;
+const char * const     zone;
+{
+       time_t mktime_return_value;
+#ifdef _THREAD_SAFE
+       ast_mutex_lock(&lcl_mutex);
+#endif
+       ast_tzset(zone);
+       mktime_return_value = time1(tmp, localsub, 0L, zone);
+#ifdef _THREAD_SAFE
+       ast_mutex_unlock(&lcl_mutex);
+#endif
+       return(mktime_return_value);
+}
+
diff --git a/stdtime/private.h b/stdtime/private.h
new file mode 100755 (executable)
index 0000000..90329d3
--- /dev/null
@@ -0,0 +1,220 @@
+/* $FreeBSD: src/lib/libc/stdtime/private.h,v 1.6.8.1 2000/08/23 00:19:15 jhb Exp $ */
+
+#ifndef PRIVATE_H
+
+#define PRIVATE_H
+/*
+** This file is in the public domain, so clarified as of
+** June 5, 1996 by Arthur David Olson (arthur_david_olson@nih.gov).
+*/
+
+/* Stuff moved from Makefile.inc to reduce clutter */
+#ifndef TM_GMTOFF
+#define TM_GMTOFF      tm_gmtoff
+#define TM_ZONE                tm_zone
+#define STD_INSPIRED   1
+#define PCTS           1
+#define HAVE_LONG_DOUBLE 1
+#define HAVE_STRERROR  1
+#define        HAVE_UNISTD_H   1
+#define        LOCALE_HOME     _PATH_LOCALE
+#define TZDIR          "/usr/share/zoneinfo"
+#endif /* ndef TM_GMTOFF */
+
+/*
+** This header is for use ONLY with the time conversion code.
+** There is no guarantee that it will remain unchanged,
+** or that it will remain at all.
+** Do NOT copy it to any system include directory.
+** Thank you!
+*/
+
+/*
+** ID
+*/
+
+#ifndef lint
+#ifndef NOID
+/*
+static char    privatehid[] = "@(#)private.h   7.43";
+*/
+#endif /* !defined NOID */
+#endif /* !defined lint */
+
+/*
+** Defaults for preprocessor symbols.
+** You can override these in your C compiler options, e.g. `-DHAVE_ADJTIME=0'.
+*/
+
+#ifndef HAVE_ADJTIME
+#define HAVE_ADJTIME           1
+#endif /* !defined HAVE_ADJTIME */
+
+#ifndef HAVE_GETTEXT
+#define HAVE_GETTEXT           0
+#endif /* !defined HAVE_GETTEXT */
+
+#ifndef HAVE_SETTIMEOFDAY
+#define HAVE_SETTIMEOFDAY      3
+#endif /* !defined HAVE_SETTIMEOFDAY */
+
+#ifndef HAVE_STRERROR
+#define HAVE_STRERROR          0
+#endif /* !defined HAVE_STRERROR */
+
+#ifndef HAVE_UNISTD_H
+#define HAVE_UNISTD_H          1
+#endif /* !defined HAVE_UNISTD_H */
+
+#ifndef HAVE_UTMPX_H
+#define HAVE_UTMPX_H           0
+#endif /* !defined HAVE_UTMPX_H */
+
+#ifndef LOCALE_HOME
+#define LOCALE_HOME            "/usr/lib/locale"
+#endif /* !defined LOCALE_HOME */
+
+/*
+** Nested includes
+*/
+
+#include "sys/types.h" /* for time_t */
+#include "stdio.h"
+#include "errno.h"
+#include "string.h"
+#include "limits.h"    /* for CHAR_BIT */
+#include "time.h"
+#include "stdlib.h"
+
+#if HAVE_GETTEXT - 0
+#include "libintl.h"
+#endif /* HAVE_GETTEXT - 0 */
+
+#if HAVE_UNISTD_H - 0
+#include "unistd.h"    /* for F_OK and R_OK */
+#endif /* HAVE_UNISTD_H - 0 */
+
+#if !(HAVE_UNISTD_H - 0)
+#ifndef F_OK
+#define F_OK   0
+#endif /* !defined F_OK */
+#ifndef R_OK
+#define R_OK   4
+#endif /* !defined R_OK */
+#endif /* !(HAVE_UNISTD_H - 0) */
+
+/* Unlike <ctype.h>'s isdigit, this also works if c < 0 | c > UCHAR_MAX.  */
+#define is_digit(c) ((unsigned)(c) - '0' <= 9)
+
+/*
+** Workarounds for compilers/systems.
+*/
+
+#ifndef P
+#ifdef __STDC__
+#define P(x)   x
+#endif /* defined __STDC__ */
+#ifndef __STDC__
+#define P(x)   ()
+#endif /* !defined __STDC__ */
+#endif /* !defined P */
+
+/*
+** SunOS 4.1.1 headers lack FILENAME_MAX.
+*/
+
+#ifndef FILENAME_MAX
+
+#ifndef MAXPATHLEN
+#ifdef unix
+#include "sys/param.h"
+#endif /* defined unix */
+#endif /* !defined MAXPATHLEN */
+
+#ifdef MAXPATHLEN
+#define FILENAME_MAX   MAXPATHLEN
+#endif /* defined MAXPATHLEN */
+#ifndef MAXPATHLEN
+#define FILENAME_MAX   1024            /* Pure guesswork */
+#endif /* !defined MAXPATHLEN */
+
+#endif /* !defined FILENAME_MAX */
+
+/*
+** Finally, some convenience items.
+*/
+
+#ifndef TRUE
+#define TRUE   1
+#endif /* !defined TRUE */
+
+#ifndef FALSE
+#define FALSE  0
+#endif /* !defined FALSE */
+
+#ifndef TYPE_BIT
+#define TYPE_BIT(type) (sizeof (type) * CHAR_BIT)
+#endif /* !defined TYPE_BIT */
+
+#ifndef TYPE_SIGNED
+#define TYPE_SIGNED(type) (((type) -1) < 0)
+#endif /* !defined TYPE_SIGNED */
+
+#ifndef INT_STRLEN_MAXIMUM
+/*
+** 302 / 1000 is log10(2.0) rounded up.
+** Subtract one for the sign bit if the type is signed;
+** add one for integer division truncation;
+** add one more for a minus sign if the type is signed.
+*/
+#define INT_STRLEN_MAXIMUM(type) \
+    ((TYPE_BIT(type) - TYPE_SIGNED(type)) * 302 / 1000 + 1 + TYPE_SIGNED(type))
+#endif /* !defined INT_STRLEN_MAXIMUM */
+
+/*
+** INITIALIZE(x)
+*/
+
+#ifndef GNUC_or_lint
+#ifdef lint
+#define GNUC_or_lint
+#endif /* defined lint */
+#ifndef lint
+#ifdef __GNUC__
+#define GNUC_or_lint
+#endif /* defined __GNUC__ */
+#endif /* !defined lint */
+#endif /* !defined GNUC_or_lint */
+
+#ifndef INITIALIZE
+#ifdef GNUC_or_lint
+#define INITIALIZE(x)  ((x) = 0)
+#endif /* defined GNUC_or_lint */
+#ifndef GNUC_or_lint
+#define INITIALIZE(x)
+#endif /* !defined GNUC_or_lint */
+#endif /* !defined INITIALIZE */
+
+/*
+** For the benefit of GNU folk...
+** `_(MSGID)' uses the current locale's message library string for MSGID.
+** The default is to use gettext if available, and use MSGID otherwise.
+*/
+
+#ifndef _
+#if HAVE_GETTEXT - 0
+#define _(msgid) gettext(msgid)
+#else /* !(HAVE_GETTEXT - 0) */
+#define _(msgid) msgid
+#endif /* !(HAVE_GETTEXT - 0) */
+#endif /* !defined _ */
+
+#ifndef TZ_DOMAIN
+#define TZ_DOMAIN "tz"
+#endif /* !defined TZ_DOMAIN */
+
+/*
+** UNIX was a registered trademark of UNIX System Laboratories in 1993.
+*/
+
+#endif /* !defined PRIVATE_H */
diff --git a/stdtime/test.c b/stdtime/test.c
new file mode 100755 (executable)
index 0000000..70e2a0c
--- /dev/null
@@ -0,0 +1,20 @@
+/* Testing localtime functionality */
+
+#include "localtime.c"
+#include <sys/time.h>
+#include <stdio.h>
+
+int main(int argc, char **argv) {
+       struct timeval tv;
+       struct tm       tm;
+       char    *zone[4] = { "America/New_York", "America/Chicago", "America/Denver", "America/Los_Angeles" };
+       int     i;
+
+       gettimeofday(&tv,NULL);
+
+       for (i=0;i<4;i++) {
+               ast_localtime(&tv.tv_sec,&tm,zone[i]);
+               printf("Localtime at %s is %04d/%02d/%02d %02d:%02d:%02d\n",zone[i],tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
+       }
+       return 0;
+}
diff --git a/stdtime/tzfile.h b/stdtime/tzfile.h
new file mode 100755 (executable)
index 0000000..c1b27ea
--- /dev/null
@@ -0,0 +1,190 @@
+#ifndef TZFILE_H
+
+#define TZFILE_H
+
+/*
+** This file is in the public domain, so clarified as of
+** 1996-06-05 by Arthur David Olson (arthur_david_olson@nih.gov).
+*/
+
+/*
+** This header is for use ONLY with the time conversion code.
+** There is no guarantee that it will remain unchanged,
+** or that it will remain at all.
+** Do NOT copy it to any system include directory.
+** Thank you!
+*/
+
+/*
+** ID
+*/
+
+#ifndef lint
+#ifndef NOID
+/*
+static char    tzfilehid[] = "@(#)tzfile.h     7.14";
+*/
+#endif /* !defined NOID */
+#endif /* !defined lint */
+
+/*
+** Information about time zone files.
+*/
+
+#ifndef TZDIR
+#define TZDIR  "/usr/share/zoneinfo" /* Time zone object file directory */
+#endif /* !defined TZDIR */
+
+#ifndef TZDEFAULT
+#define TZDEFAULT      "/etc/localtime"
+#endif /* !defined TZDEFAULT */
+
+#ifndef TZDEFRULES
+#define TZDEFRULES     "posixrules"
+#endif /* !defined TZDEFRULES */
+
+/*
+** Each file begins with. . .
+*/
+
+#define        TZ_MAGIC        "TZif"
+
+struct tzhead {
+       char    tzh_magic[4];           /* TZ_MAGIC */
+       char    tzh_reserved[16];       /* reserved for future use */
+       char    tzh_ttisgmtcnt[4];      /* coded number of trans. time flags */
+       char    tzh_ttisstdcnt[4];      /* coded number of trans. time flags */
+       char    tzh_leapcnt[4];         /* coded number of leap seconds */
+       char    tzh_timecnt[4];         /* coded number of transition times */
+       char    tzh_typecnt[4];         /* coded number of local time types */
+       char    tzh_charcnt[4];         /* coded number of abbr. chars */
+};
+
+/*
+** . . .followed by. . .
+**
+**     tzh_timecnt (char [4])s         coded transition times a la time(2)
+**     tzh_timecnt (unsigned char)s    types of local time starting at above
+**     tzh_typecnt repetitions of
+**             one (char [4])          coded UTC offset in seconds
+**             one (unsigned char)     used to set tm_isdst
+**             one (unsigned char)     that's an abbreviation list index
+**     tzh_charcnt (char)s             '\0'-terminated zone abbreviations
+**     tzh_leapcnt repetitions of
+**             one (char [4])          coded leap second transition times
+**             one (char [4])          total correction after above
+**     tzh_ttisstdcnt (char)s          indexed by type; if TRUE, transition
+**                                     time is standard time, if FALSE,
+**                                     transition time is wall clock time
+**                                     if absent, transition times are
+**                                     assumed to be wall clock time
+**     tzh_ttisgmtcnt (char)s          indexed by type; if TRUE, transition
+**                                     time is UTC, if FALSE,
+**                                     transition time is local time
+**                                     if absent, transition times are
+**                                     assumed to be local time
+*/
+
+/*
+** In the current implementation, "tzset()" refuses to deal with files that
+** exceed any of the limits below.
+*/
+
+#ifndef TZ_MAX_TIMES
+/*
+** The TZ_MAX_TIMES value below is enough to handle a bit more than a
+** year's worth of solar time (corrected daily to the nearest second) or
+** 138 years of Pacific Presidential Election time
+** (where there are three time zone transitions every fourth year).
+*/
+#define TZ_MAX_TIMES   370
+#endif /* !defined TZ_MAX_TIMES */
+
+#ifndef TZ_MAX_TYPES
+#ifndef NOSOLAR
+#define TZ_MAX_TYPES   256 /* Limited by what (unsigned char)'s can hold */
+#endif /* !defined NOSOLAR */
+#ifdef NOSOLAR
+/*
+** Must be at least 14 for Europe/Riga as of Jan 12 1995,
+** as noted by Earl Chew <earl@hpato.aus.hp.com>.
+*/
+#define TZ_MAX_TYPES   20      /* Maximum number of local time types */
+#endif /* !defined NOSOLAR */
+#endif /* !defined TZ_MAX_TYPES */
+
+#ifndef TZ_MAX_CHARS
+#define TZ_MAX_CHARS   50      /* Maximum number of abbreviation characters */
+                               /* (limited by what unsigned chars can hold) */
+#endif /* !defined TZ_MAX_CHARS */
+
+#ifndef TZ_MAX_LEAPS
+#define TZ_MAX_LEAPS   50      /* Maximum number of leap second corrections */
+#endif /* !defined TZ_MAX_LEAPS */
+
+#define SECSPERMIN     60
+#define MINSPERHOUR    60
+#define HOURSPERDAY    24
+#define DAYSPERWEEK    7
+#define DAYSPERNYEAR   365
+#define DAYSPERLYEAR   366
+#define SECSPERHOUR    (SECSPERMIN * MINSPERHOUR)
+#define SECSPERDAY     ((long) SECSPERHOUR * HOURSPERDAY)
+#define MONSPERYEAR    12
+
+#define TM_SUNDAY      0
+#define TM_MONDAY      1
+#define TM_TUESDAY     2
+#define TM_WEDNESDAY   3
+#define TM_THURSDAY    4
+#define TM_FRIDAY      5
+#define TM_SATURDAY    6
+
+#define TM_JANUARY     0
+#define TM_FEBRUARY    1
+#define TM_MARCH       2
+#define TM_APRIL       3
+#define TM_MAY         4
+#define TM_JUNE                5
+#define TM_JULY                6
+#define TM_AUGUST      7
+#define TM_SEPTEMBER   8
+#define TM_OCTOBER     9
+#define TM_NOVEMBER    10
+#define TM_DECEMBER    11
+
+#define TM_YEAR_BASE   1900
+
+#define EPOCH_YEAR     1970
+#define EPOCH_WDAY     TM_THURSDAY
+
+/*
+** Accurate only for the past couple of centuries;
+** that will probably do.
+*/
+
+#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
+
+#ifndef USG
+
+/*
+** Use of the underscored variants may cause problems if you move your code to
+** certain System-V-based systems; for maximum portability, use the
+** underscore-free variants.  The underscored variants are provided for
+** backward compatibility only; they may disappear from future versions of
+** this file.
+*/
+
+#define SECS_PER_MIN   SECSPERMIN
+#define MINS_PER_HOUR  MINSPERHOUR
+#define HOURS_PER_DAY  HOURSPERDAY
+#define DAYS_PER_WEEK  DAYSPERWEEK
+#define DAYS_PER_NYEAR DAYSPERNYEAR
+#define DAYS_PER_LYEAR DAYSPERLYEAR
+#define SECS_PER_HOUR  SECSPERHOUR
+#define SECS_PER_DAY   SECSPERDAY
+#define MONS_PER_YEAR  MONSPERYEAR
+
+#endif /* !defined USG */
+
+#endif /* !defined TZFILE_H */