git.marmaro.de Git - mmh/blob - sbr/dtime.c

   1 /*
   2 ** dtime.c -- time/date routines
   3 **
   4 ** This code is Copyright (c) 2002, by the authors of nmh.  See the
   5 ** COPYRIGHT file in the root directory of the nmh distribution for
   6 ** complete copyright information.
   7 */
   8
   9 #include <h/mh.h>   /* for snprintf() */
  10 #include <h/nmh.h>
  11 #include <h/tws.h>
  12 #include <time.h>
  13
  14 #if !defined(HAVE_STRUCT_TM_TM_GMTOFF)
  15 extern long timezone;
  16 #endif
  17
  18 /*
  19 ** The number of days in the year, accounting for leap years
  20 */
  21 #define dysize(y) \
  22         (((y) % 4) ? 365 : (((y) % 100) ? 366 : (((y) % 400) ? 365 : 366)))
  23
  24 char *tw_moty[] = {
  25         "Jan", "Feb", "Mar", "Apr",
  26         "May", "Jun", "Jul", "Aug",
  27         "Sep", "Oct", "Nov", "Dec",
  28         NULL
  29 };
  30
  31 char *tw_dotw[] = {
  32         "Sun", "Mon", "Tue",
  33         "Wed", "Thu", "Fri",
  34         "Sat", NULL
  35 };
  36
  37 char *tw_ldotw[] = {
  38         "Sunday", "Monday", "Tuesday",
  39         "Wednesday", "Thursday", "Friday",
  40         "Saturday",  NULL
  41 };
  42
  43 struct zone {
  44         char *std;
  45         char *dst;
  46         int shift;
  47 };
  48
  49 static int dmsize[] = {
  50         31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  51 };
  52
  53
  54 /*
  55 ** Get current time (adjusted for local time
  56 ** zone and daylight savings time) expressed
  57 ** as nmh "broken-down" time structure.
  58 */
  59
  60 struct tws *
  61 dlocaltimenow(void)
  62 {
  63         time_t clock;
  64
  65         time(&clock);
  66         return dlocaltime(&clock);
  67 }
  68
  69
  70 /*
  71 ** Take clock value and return pointer to nmh time structure
  72 ** containing "broken-down" time.  The time is adjusted for
  73 ** local time zone and daylight savings time.
  74 */
  75
  76 struct tws *
  77 dlocaltime(time_t *clock)
  78 {
  79         static struct tws tw;
  80         struct tm *tm;
  81
  82         if (!clock)
  83                 return NULL;
  84
  85         tm = localtime(clock);
  86
  87         tw.tw_sec  = tm->tm_sec;
  88         tw.tw_min  = tm->tm_min;
  89         tw.tw_hour = tm->tm_hour;
  90         tw.tw_mday = tm->tm_mday;
  91         tw.tw_mon  = tm->tm_mon;
  92
  93         /* tm_year is always "year - 1900". So we correct for this. */
  94         tw.tw_year = tm->tm_year + 1900;
  95         tw.tw_wday = tm->tm_wday;
  96         tw.tw_yday = tm->tm_yday;
  97
  98         tw.tw_flags = TW_NULL;
  99         if (tm->tm_isdst)
 100                 tw.tw_flags |= TW_DST;
 101
 102 #ifdef HAVE_STRUCT_TM_TM_GMTOFF
 103         tw.tw_zone = tm->tm_gmtoff / 60;
 104         if (tm->tm_isdst)  /* if DST is in effect */
 105                 tw.tw_zone -= 60;  /* reset to normal offset */
 106 #else
 107         tzset();
 108         tw.tw_zone = -(timezone / 60);
 109 #endif
 110
 111         tw.tw_flags &= ~TW_SDAY;
 112         tw.tw_flags |= TW_SEXP;
 113         tw.tw_flags &= ~TW_SZONE;
 114         tw.tw_flags |= TW_SZEXP;
 115
 116         tw.tw_clock = *clock;
 117
 118         return (&tw);
 119 }
 120
 121
 122 /*
 123 ** Take clock value and return pointer to nmh time
 124 ** structure containing "broken-down" time.  Time is
 125 ** expressed in UTC (Coordinated Universal Time).
 126 */
 127
 128 struct tws *
 129 dgmtime(time_t *clock)
 130 {
 131         static struct tws tw;
 132         struct tm *tm;
 133
 134         if (!clock)
 135                 return NULL;
 136
 137         tm = gmtime(clock);
 138
 139         tw.tw_sec  = tm->tm_sec;
 140         tw.tw_min  = tm->tm_min;
 141         tw.tw_hour = tm->tm_hour;
 142         tw.tw_mday = tm->tm_mday;
 143         tw.tw_mon  = tm->tm_mon;
 144
 145         /* tm_year is always "year - 1900". So we correct for this. */
 146         tw.tw_year = tm->tm_year + 1900;
 147         tw.tw_wday = tm->tm_wday;
 148         tw.tw_yday = tm->tm_yday;
 149
 150         tw.tw_flags = TW_NULL;
 151         if (tm->tm_isdst)
 152                 tw.tw_flags |= TW_DST;
 153
 154         tw.tw_zone = 0;
 155
 156         tw.tw_flags &= ~TW_SDAY;
 157         tw.tw_flags |= TW_SEXP;
 158         tw.tw_flags &= ~TW_SZONE;
 159         tw.tw_flags |= TW_SZEXP;
 160
 161         tw.tw_clock = *clock;
 162
 163         return (&tw);
 164 }
 165
 166
 167 /*
 168 ** Using a nmh "broken-down" time structure,
 169 ** produce a 26-byte date/time string, such as
 170 **
 171 **    Tue Jan 14 17:49:03 1992\n\0
 172 */
 173
 174 char *
 175 dctime(struct tws *tw)
 176 {
 177         static char buffer[26];
 178
 179         if (!tw)
 180                 return NULL;
 181
 182         snprintf(buffer, sizeof(buffer), "%.3s %.3s %02d %02d:%02d:%02d %.4d\n",
 183                 tw_dotw[tw->tw_wday], tw_moty[tw->tw_mon], tw->tw_mday,
 184                 tw->tw_hour, tw->tw_min, tw->tw_sec,
 185                 tw->tw_year < 100 ? tw->tw_year + 1900 : tw->tw_year);
 186
 187         return buffer;
 188 }
 189
 190
 191 /*
 192 ** Produce a date/time string of the form
 193 **
 194 **    Mon, 16 Jun 1992 15:30:48 -0700
 195 **
 196 ** for the current time, as specified by rfc822 and rfc1123.
 197 */
 198 char *
 199 dtimenow(void)
 200 {
 201         time_t clock;
 202
 203         time(&clock);
 204         return dtime(&clock);
 205 }
 206
 207
 208 /*
 209 ** Using a local calendar time value, produce
 210 ** a date/time string of the form
 211 **
 212 **    Mon, 16 Jun 1992 15:30:48 -0700
 213 **
 214 ** as specified by rfc822 and rfc1123.
 215 */
 216 char *
 217 dtime(time_t *clock)
 218 {
 219         return dasctime(dlocaltime(clock));
 220 }
 221
 222
 223 /*
 224 ** Using a nmh "broken-down" time structure, produce
 225 ** a date/time string of the form
 226 **
 227 **    Mon, 16 Jun 1992 15:30:48 -0700
 228 **
 229 ** as specified by rfc822 and rfc1123.
 230 */
 231 char *
 232 dasctime(struct tws *tw)
 233 {
 234         char buffer[80];
 235         static char result[80];
 236
 237         if (!tw)
 238                 return NULL;
 239
 240         /* Display timezone if known */
 241         if ((tw->tw_flags & TW_SZONE) == TW_SZNIL)
 242                 result[0] = '\0';
 243         else
 244                 snprintf(result, sizeof(result), " %s", dtimezone(tw->tw_zone, tw->tw_flags));
 245
 246         snprintf(buffer, sizeof(buffer), "%02d %s %0*d %02d:%02d:%02d%s",
 247                 tw->tw_mday, tw_moty[tw->tw_mon],
 248                 tw->tw_year < 100 ? 2 : 4, tw->tw_year,
 249                 tw->tw_hour, tw->tw_min, tw->tw_sec, result);
 250
 251         if ((tw->tw_flags & TW_SDAY) == TW_SEXP)
 252                 snprintf(result, sizeof(result), "%s, %s", tw_dotw[tw->tw_wday], buffer);
 253         else
 254                 if ((tw->tw_flags & TW_SDAY) == TW_SNIL)
 255                         strncpy(result, buffer, sizeof(result));
 256                 else
 257                         snprintf(result, sizeof(result), "%s (%s)", buffer, tw_dotw[tw->tw_wday]);
 258
 259         return result;
 260 }
 261
 262
 263 /*
 264 ** Get the timezone for given offset as numeric value.
 265 */
 266 char *
 267 dtimezone(int offset, int flags)
 268 {
 269         int hours, mins;
 270         static char buffer[10];
 271
 272         if (offset < 0) {
 273                 mins = -((-offset) % 60);
 274                 hours = -((-offset) / 60);
 275         } else {
 276                 mins = offset % 60;
 277                 hours = offset / 60;
 278         }
 279
 280 #ifdef ADJUST_NUMERIC_ONLY_TZ_OFFSETS_WRT_DST
 281         if (flags & TW_DST)
 282                 hours += 1;
 283 #endif /* ADJUST_NUMERIC_ONLY_TZ_OFFSETS_WRT_DST */
 284         snprintf(buffer, sizeof(buffer), "%s%02d%02d",
 285                 offset < 0 ? "-" : "+", abs(hours), abs(mins));
 286         return buffer;
 287 }
 288
 289
 290 /*
 291 ** Convert nmh time structure for local "broken-down"
 292 ** time to calendar time (clock value).  This routine
 293 ** is based on the gtime() routine written by Steven Shafer
 294 ** at CMU.  It was forwarded to MTR by Jay Lepreau at Utah-CS.
 295 */
 296
 297 time_t
 298 dmktime(struct tws *tw)
 299 {
 300         int i, sec, min, hour, mday, mon, year;
 301         time_t result;
 302
 303         if (tw->tw_clock != 0)
 304                 return tw->tw_clock;
 305
 306         if ((sec = tw->tw_sec) < 0 || sec > 61
 307                 || (min = tw->tw_min) < 0 || min > 59
 308                 || (hour = tw->tw_hour) < 0 || hour > 23
 309                 || (mday = tw->tw_mday) < 1 || mday > 31
 310                 || (mon = tw->tw_mon + 1) < 1 || mon > 12)
 311                 return (tw->tw_clock = (time_t) -1);
 312
 313         year = tw->tw_year;
 314
 315         result = 0;
 316         if (year < 1970)
 317                 year += 1900;
 318
 319         if (year < 1970)
 320                 year += 100;
 321
 322         for (i = 1970; i < year; i++)
 323                 result += dysize(i);
 324         if (dysize(year) == 366 && mon >= 3)
 325                 result++;
 326         while (--mon)
 327                 result += dmsize[mon - 1];
 328         result += mday - 1;
 329         result = 24 * result + hour;
 330         result = 60 * result + min;
 331         result = 60 * result + sec;
 332         result -= 60 * tw->tw_zone;
 333         if (tw->tw_flags & TW_DST)
 334                 result -= 60 * 60;
 335
 336         return (tw->tw_clock = result);
 337 }
 338
 339
 340 /*
 341 ** Simple calculation of day of the week.  Algorithm
 342 ** used is Zeller's congruence.  We assume that
 343 ** if tw->tw_year < 100, then the century = 19.
 344 */
 345
 346 void
 347 set_dotw(struct tws *tw)
 348 {
 349         int month, day, year, century;
 350
 351         month = tw->tw_mon - 1;
 352         day = tw->tw_mday;
 353         year = tw->tw_year % 100;
 354         century = tw->tw_year < 100 ? 19 : tw->tw_year / 100;
 355
 356         if (month <= 0) {
 357                 month += 12;
 358                 if (--year < 0) {
 359                         year += 100;
 360                         century--;
 361                 }
 362         }
 363
 364         tw->tw_wday = ((26 * month - 2) / 10 + day + year + year / 4
 365                         - 3 * century / 4 + 1) % 7;
 366         if (tw->tw_wday < 0)
 367                 tw->tw_wday += 7;
 368
 369         tw->tw_flags &= ~TW_SDAY, tw->tw_flags |= TW_SIMP;
 370 }
 371
 372
 373 /*
 374 ** Copy nmh time structure
 375 */
 376
 377 void
 378 twscopy(struct tws *tb, struct tws *tw)
 379 {
 380         *tb = *tw;  /* struct copy */
 381 }
 382
 383
 384 /*
 385 ** Compare two nmh time structures
 386 */
 387
 388 int
 389 twsort(struct tws *tw1, struct tws *tw2)
 390 {
 391         time_t c1, c2;
 392
 393         if (tw1->tw_clock == 0)
 394                 dmktime(tw1);
 395         if (tw2->tw_clock == 0)
 396                 dmktime(tw2);
 397
 398         return ((c1 = tw1->tw_clock) > (c2 = tw2->tw_clock) ? 1
 399                 : c1 == c2 ? 0 : -1);
 400 }