diff --git a/Makefile b/Makefile index 844b9ab92b..13763a0924 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 e5f1db7550..0ee22fb14b 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//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//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 0000000000..320c293d79 --- /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 + * + * 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 c2c4878b97..32dfcc1274 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 7c0d911d7e..c1bfdeac3c 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 9ea3e9ded2..abb2e32566 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 40b5131ef3..4b8dcf31d1 100755 --- a/say.c +++ b/say.c @@ -12,12 +12,21 @@ */ #include +#include +#include +#include +#include #include #include #include #include +#include +#include +#include "asterisk.h" #include +#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 0000000000..fede0651e5 --- /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 0000000000..f64cec84df --- /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, , 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 + + +#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 +#include +#include "private.h" +#include "tzfile.h" +#include "fcntl.h" +#ifdef DEBUG +#include +#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 0000000000..90329d3fa7 --- /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 '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 0000000000..70e2a0c655 --- /dev/null +++ b/stdtime/test.c @@ -0,0 +1,20 @@ +/* Testing localtime functionality */ + +#include "localtime.c" +#include +#include + +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 0000000000..c1b27ea940 --- /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 . +*/ +#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 */