12 files changed, 2246 insertions, 342 deletions

diff --git a/Makefile b/Makefile
index 844b9ab92..13763a092 100755
--- 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
diff --git a/apps/app_voicemail2.c b/apps/app_voicemail2.c
index e5f1db755..0ee22fb14 100755
--- a/apps/app_voicemail2.c
+++ b/apps/app_voicemail2.c
@@ -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
index 000000000..320c293d7
--- /dev/null
+++ b/include/asterisk/localtime.h
@@ -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
diff --git a/include/asterisk/pbx.h b/include/asterisk/pbx.h
index c2c4878b9..32dfcc127 100755
--- a/include/asterisk/pbx.h
+++ b/include/asterisk/pbx.h
@@ -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
diff --git a/include/asterisk/say.h b/include/asterisk/say.h
index 7c0d911d7..c1bfdeac3 100755
--- a/include/asterisk/say.h
+++ b/include/asterisk/say.h
@@ -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 9ea3e9ded..abb2e3256 100755
--- 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 40b5131ef..4b8dcf31d 100755
--- a/say.c
+++ b/say.c
@@ -12,12 +12,21 @@
  */
 
 #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
index 000000000..fede0651e
--- /dev/null
+++ b/stdtime/Makefile
@@ -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
index 000000000..f64cec84d
--- /dev/null
+++ b/stdtime/localtime.c
@@ -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
index 000000000..90329d3fa
--- /dev/null
+++ b/stdtime/private.h
@@ -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
index 000000000..70e2a0c65
--- /dev/null
+++ b/stdtime/test.c
@@ -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
index 000000000..c1b27ea94
--- /dev/null
+++ b/stdtime/tzfile.h
@@ -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 */