datetime.c

Go to the documentation of this file.

 
/*****************************************************************************/
#include "libtpcmisc.h"
/*****************************************************************************/
#include <locale.h>
#include <unistd.h>
#include <time.h>
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_GMTIME_R
struct tm* gmtime_r(
  const time_t *t, 
  struct tm *tm
) {
  struct tm *ltm=gmtime(t);
  if(ltm==NULL || tm==NULL) return(NULL);
  *tm=*ltm; tm->tm_isdst=-1;
  return tm;
}
#endif // HAVE_GMTIME_R
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_LOCALTIME_R
struct tm* localtime_r(
  const time_t *t, 
  struct tm *tm
) {
  struct tm *ltm=localtime(t);
  if(ltm==NULL || tm==NULL) return(NULL);
  *tm=*ltm; tm->tm_isdst=-1;
  return tm;
}
#endif // HAVE_LOCALTIME_R
/*****************************************************************************/
 
/*****************************************************************************/
#ifndef HAVE_TIMEGM
time_t timegm(
  struct tm *tm
) {
#ifdef HAVE_GMTIME_R
  {
  time_t temp_lt;
  struct tm temp_gm;
  if(!tm) temp_lt=0; else temp_lt=mktime(tm);
  if(gmtime_r(&temp_lt, &temp_gm)==NULL) return((time_t)-1);
  return(time_t)(temp_lt + (temp_lt - mktime(&temp_gm)));
  }
#endif
 
#ifdef HAVE_GMTIME_S
  {
  time_t temp_lt;
  struct tm temp_gm;
  if(!tm) temp_lt=0; else temp_lt=mktime(tm);
  if(gmtime_s(&temp_gm, &temp_lt)!=0) return(time_t)-1);
  return(time_t)(temp_lt + (temp_lt - mktime(&temp_gm)));
  }
#endif
 
  time_t temp_lt;
  struct tm *temp_gm;
  if(!tm) temp_lt=0; else {tm->tm_isdst=-1; temp_lt=mktime(tm);}
  temp_gm=gmtime(&temp_lt); if(temp_gm) temp_gm->tm_isdst=-1;
  return(time_t)(temp_lt + (temp_lt - mktime(temp_gm)));
}
#endif // HAVE_TIMEGM
/*****************************************************************************/
 
/*****************************************************************************/
char* ctime_r_int(
  const time_t *t,
  char *buf
) {
  if(buf==NULL) return(NULL);
  buf[0]=(char)0;
  struct tm tm;
  if(!gmtime_r(t, &tm)) return(NULL);
  if(!strftime(buf, 20, "%Y-%m-%d %H:%M:%S", &tm)) return(NULL);
  return(buf);
}
/*****************************************************************************/
 
/*****************************************************************************/
/* How many days come before each month (0-12). */
static const unsigned short __mon_yday[2][13] = {
    /* Normal years. */
    {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
    /* Leap years. */
    {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}
};
/*****************************************************************************/
 
/*****************************************************************************/
int isdate(
  char *str
) {
  int Y, M, D, n;
  if(strlen(str)<10) return 1;
  if(str[4]!='-' || str[7]!='-') return 2;
  if(strncasecmp(str, "YYYY-MM-DD", 10)==0) return -1;
  n=sscanf(str, "%4d-%2d-%2d", &Y, &M, &D); if(n!=3) return 3;
  if(M>12 || D>31) return -1;
  if(Y<0 || M<1 || D<1) return -1;
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int isdate2(
  char *str,
  char *intdate
) {
  int Y, M, D, n;
  if(strlen(str)<10) return 1;
  if(str[2]!='.' && str[2]!='/') return 2;
  if(str[5]!='.' && str[5]!='/') return 2;
  if(isspace(str[8])) return 2;
  if(strncasecmp(str, "DD.MM.YYYY", 10)==0 ||
     strncasecmp(str, "DD/MM/YYYY", 10)==0) return -1;
  n=sscanf(str, "%2d/%2d/%4d", &D, &M, &Y);
  if(n<3) n=sscanf(str, "%2d.%2d.%4d", &D, &M, &Y);
  if(n!=3) return 3;
  if(M>12 || D>31) return -1;
  if(Y<0 || M<1 || D<1) return -1;
  if(intdate!=NULL) sprintf(intdate, "%04d-%02d-%02d", Y, M, D);
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int isdate3(
  char *str,
  char *intdate
) {
  int Y, M, D, n;
  if(strlen(str)<8) return 1;
  if(str[2]!='.' && str[2]!='/') return 2;
  if(str[5]!='.' && str[5]!='/') return 2;
  if(strncasecmp(str, "DD.MM.YY", 8)==0 ||
     strncasecmp(str, "DD/MM/YY", 8)==0) return -1;
  n=sscanf(str, "%2d/%2d/%2d", &D, &M, &Y);
  if(n<3) n=sscanf(str, "%2d.%2d.%2d", &D, &M, &Y);
  if(n!=3) return 3;
  if(Y>99 || M>12 || D>31) return -1;
  if(Y<0 || M<1 || D<1) return -1;
  if(intdate!=NULL) {
    if(Y>=70) Y+=1900; else Y+=2000;
    sprintf(intdate, "%04d-%02d-%02d", Y, M, D);
  }
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int isdate4(
  int dateint,
  int *year,
  int *month,
  int *day
) {
  int Y, M, D, n;
  if(dateint<1201 || dateint>99991231) return 1;
  n=dateint/100; D=dateint-100*n; Y=n/100; M=n-100*Y;
  if(M>12 || D>31) return -1;
  if(Y<1 || M<1 || D<1) return -1;
  if(year!=NULL) *year=Y;
  if(month!=NULL) *month=M;
  if(day!=NULL) *day=D;
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int istime(
  char *str
) {
  int h, m, s, n;
  if(strlen(str)<8) return 1;
  if(str[2]!=':' || str[5]!=':') return 2;
  if(strncasecmp(str, "hh:mm:ss", 8)==0) return -1;
  n=sscanf(str, "%d:%d:%d", &h, &m, &s); if(n!=3) return 3;
  if(h<0 || h>23 || m<0 || m>59 || s<0 || s>59) return -1;
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int isdatetime(
  char *str,
  char *intdate
) {
  int ret1, ret2, len, type=0;
  char correct_date[20], *time_ptr=NULL;
 
  len=strlen(str); if(len<17) return 1;
  if((ret1=isdate(str))<=0) {
    type=1; strncpy(correct_date, str, 10); correct_date[10]=(char)0; 
  } else if((ret1=isdate2(str, correct_date))<=0) type=2;
  else if((ret1=isdate3(str, correct_date))<=0) type=3;
  else {return 2;}
  if(type==1 || type==2) {
    if(str[10]!=' ' && str[10]!='\t') return 3;
    time_ptr=str+11;
  } else if(type==3) {
    if(str[8]!=' ' && str[8]!='\t') return 3;
    time_ptr=str+9;
  }
  ret2=istime(time_ptr);
  if(ret1>0) {
    if(ret2>=0) return(100*ret1+ret2); else return(100*ret2);
  }
  if(ret2>0) return(10*ret2);
  if(ret1<0) {if(ret2<0) return(-3); else return(-1);}
  if(ret2<0) return(-2);
  if(intdate!=NULL) {
    sprintf(intdate, "%10.10s %8.8s", correct_date, time_ptr);
  }
  return 0;
}
/*****************************************************************************/
 
/*****************************************************************************/
int get_datetime(
  char *str,
  struct tm *date,
  int verbose
) {
  char buf[32];
  int ret, n, YYYY=0, MM=0, DD=0, hh=0, mm=0, ss=0;
 
  if(verbose>0) printf("get_datetime(%s)\n", str);
  if(date==NULL) return(1);
  ret=isdatetime(str, buf); if(ret!=0) return(ret);
  n=sscanf(buf, "%d-%d-%d %d:%d:%d", &YYYY, &MM, &DD, &hh, &mm, &ss);
  if(n!=6) return(40);
  date->tm_year=YYYY-1900; date->tm_mday=DD; date->tm_mon=MM-1;
  date->tm_hour=hh; date->tm_min=mm; date->tm_sec=ss; 
  date->tm_isdst=-1;
#ifdef HAVE_TM_GMTOFF
  date->tm_gmtoff=0L;
#endif
  if(verbose>2) {
    printf("tm_mday=%d\n", date->tm_mday);
    printf("tm_mon=%d\n", date->tm_mon);
    printf("tm_year=%d\n", date->tm_year);
    printf("tm_hour=%d\n", date->tm_hour);
    time_t t=timegm(date);
    printf(" tm_hour=%d\n", date->tm_hour);
    printf("time_t=%ld\n", (long)t);
    printf("time_t_int=%d\n", (int)t);
  }
//  if(mktime(date)==-1 && date->tm_year<70) {
  if(timegm(date)==-1 && date->tm_year<70) {
    if(verbose>2) printf("tm_mday=%d\n", date->tm_mday);
    if(verbose>1) printf("mktime() fails\n");
    /* Date and time format was previously verified, so lets put
       1970-01-01 01:00:00 instead */  
    date->tm_year=70; date->tm_mday=1; date->tm_mon=0;
    date->tm_hour=1; date->tm_min=0; date->tm_sec=0; 
    date->tm_yday=0;
    date->tm_isdst=-1;
    mktime(date);
  }
  if(verbose>1) printf(" tm_hour=%d\n", date->tm_hour);
  return(0);
}
/*****************************************************************************/
 
/*****************************************************************************/
int get_date(
  char *str,
  struct tm *date
) {
  char buf[32];
  int ret, n, YYYY=0, MM=0, DD=0;
 
  if(strlen(str)<8) return 1;
  if((ret=isdate(str))<=0) {
    strncpy(buf, str, 10); buf[10]=(char)0; 
  } else {
    ret=isdate2(str, buf);
    if(ret>0) ret=isdate3(str, buf);
  }
  if(ret>0) return 2;
  n=sscanf(buf, "%d-%d-%d", &YYYY, &MM, &DD);
  if(n!=3) return(3);
  date->tm_year=YYYY-1900; date->tm_mday=DD; date->tm_mon=MM-1;
  date->tm_hour=0; date->tm_min=0; date->tm_sec=0;  date->tm_isdst=-1;
  ret=strftime(buf, 32, "%Y-%m-%d %H:%M:%S", date);
  if(ret==0) return(4);
  return(0);
}
/*****************************************************************************/
 
/*****************************************************************************/
long int math_div(
  long int a, 
  long int b
) {
  return a/b - (a%b < 0);
}
/*****************************************************************************/
 
/*****************************************************************************/
int isleapyear(
  long int year
) {
  return (year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0);
}
/*****************************************************************************/
 
/*****************************************************************************/
long int leaps_between(
  long int year1, 
  long int year2
) {
  long int leaps1, leaps2;
 
  leaps1 = math_div(year1-1, 4) - math_div(year1-1, 100) + math_div(year1-1, 400);
  leaps2 = math_div(year2-1, 4) - math_div(year2-1, 100) + math_div(year2-1, 400);
  return(leaps2-leaps1);
}
/*****************************************************************************/
 
/*****************************************************************************/
void time_to_tm(
  time_t totalsecs,
  int offset,
  struct tm *result
) {
  if(offset==0) {gmtime_r(&totalsecs, result); return;}
 
 
  long int days, rem, y, yg;
  const unsigned short *ip;
 
  days=totalsecs/86400; rem=totalsecs%86400; rem+=offset;
  while(rem<0) {rem+=86400; --days;}
  while(rem>=86400) {rem-=86400; ++days;}
  result->tm_hour=rem/3600;
  rem%=3600; result->tm_min=rem/60;
  result->tm_sec=rem%60;
 
  /* January 1, 1970 was a Thursday. */
  result->tm_wday=(4+days)%7;
  if(result->tm_wday<0) result->tm_wday+=7;
  y=1970;
  while(days<0 || days>=(isleapyear(y)?366:365)) {
    /* Guess a corrected year, assuming 365 days per year. */
    yg=y+math_div(days, 365);
    /* Adjust days and y to match the guessed year. */
    days-=(yg-y)*365 + leaps_between(y, yg);
    y=yg;
  }
  result->tm_year=y-1900; result->tm_yday=days;
  ip=__mon_yday[isleapyear(y)];
  for(y=11; days<ip[y]; y--) continue;
  days-=ip[y];
  result->tm_mon=y;
  result->tm_mday=days+1;
  result->tm_isdst=-1;
#if defined(HAVE_TM_GMTOFF)
  result->tm_gmtoff=0L;
#endif
}
/*****************************************************************************/
 
/*****************************************************************************/
double tmDifference(
  struct tm *tm1,
  struct tm *tm0
) {
  return(difftime(mktime(tm1), mktime(tm0)));
}
/*****************************************************************************/
 
/*****************************************************************************/
void tmAdd(
  int s,
  struct tm *d
) {
  if(d==NULL) return;
  d->tm_sec+=s; 
  //mktime(d); // this automatically normalizes sec to hours etc if necessary
  timegm(d); // this automatically normalizes sec to hours etc if necessary
}
/*****************************************************************************/
 
/*****************************************************************************/