← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to gnulib/mktime.c

Replace MAX_(DATE|TIME).*_WIDTH defines in definitions.h with real (and correct) static const members to Temporal types.

This fixes the buffer overflow in https://bugs.launchpad.net/drizzle/+bug/373468

It also removes a handwritten snprintf in field/datetime.cc
However... this caused us to have to change Temporal to have a way to not
"convert" the int64_t value (so 20090101 becomes 20090101000000 etc) as it
has already been converted and we just want the Temporal type to do the
to_string conversion.

This still causes a failure in 'metadata' test due to size of timestamp type. I need feedback from Jay on when the usecond code comes into play to know the correct fix for this.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnulib/mktime.c
17
17
   with this program; if not, write to the Free Software Foundation,
18
18
   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
19
19
 
 
20
/* Define this to have a standalone program to test this implementation of
 
21
   mktime.  */
 
22
/* #define DEBUG 1 */
 
23
 
20
24
#ifndef _LIBC
21
25
# include <config.h>
22
26
#endif
34
38
 
35
39
#include <string.h>             /* For the real memcpy prototype.  */
36
40
 
 
41
#if DEBUG
 
42
# include <stdio.h>
 
43
# include <stdlib.h>
 
44
/* Make it work even if the system's libc has its own mktime routine.  */
 
45
# define mktime my_mktime
 
46
#endif /* DEBUG */
37
47
 
38
48
/* Shift A right by B bits portably, by dividing A by 2**B and
39
49
   truncating towards minus infinity.  A and B should be free of side
252
262
}
253
263
 
254
264
 
255
 
extern time_t
256
 
__mktime_internal (struct tm *tp,
257
 
                   struct tm *(*convert) (const time_t *, struct tm *),
258
 
                   time_t *offset);
259
265
/* Convert *TP to a time_t value, inverting
260
266
   the monotonic and mostly-unit-linear conversion function CONVERT.
261
267
   Use *OFFSET to keep track of a guess at the offset of the result,
517
523
libc_hidden_def (mktime)
518
524
libc_hidden_weak (timelocal)
519
525
#endif
 
526
 
 
527
#if DEBUG
 
528
 
 
529
static int
 
530
not_equal_tm (const struct tm *a, const struct tm *b)
 
531
{
 
532
  return ((a->tm_sec ^ b->tm_sec)
 
533
          | (a->tm_min ^ b->tm_min)
 
534
          | (a->tm_hour ^ b->tm_hour)
 
535
          | (a->tm_mday ^ b->tm_mday)
 
536
          | (a->tm_mon ^ b->tm_mon)
 
537
          | (a->tm_year ^ b->tm_year)
 
538
          | (a->tm_yday ^ b->tm_yday)
 
539
          | (a->tm_isdst ^ b->tm_isdst));
 
540
}
 
541
 
 
542
static void
 
543
print_tm (const struct tm *tp)
 
544
{
 
545
  if (tp)
 
546
    printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
 
547
            tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
 
548
            tp->tm_hour, tp->tm_min, tp->tm_sec,
 
549
            tp->tm_yday, tp->tm_wday, tp->tm_isdst);
 
550
  else
 
551
    printf ("0");
 
552
}
 
553
 
 
554
static int
 
555
check_result (time_t tk, struct tm tmk, time_t tl, const struct tm *lt)
 
556
{
 
557
  if (tk != tl || !lt || not_equal_tm (&tmk, lt))
 
558
    {
 
559
      printf ("mktime (");
 
560
      print_tm (lt);
 
561
      printf (")\nyields (");
 
562
      print_tm (&tmk);
 
563
      printf (") == %ld, should be %ld\n", (long int) tk, (long int) tl);
 
564
      return 1;
 
565
    }
 
566
 
 
567
  return 0;
 
568
}
 
569
 
 
570
int
 
571
main (int argc, char **argv)
 
572
{
 
573
  int status = 0;
 
574
  struct tm tm, tmk, tml;
 
575
  struct tm *lt;
 
576
  time_t tk, tl, tl1;
 
577
  char trailer;
 
578
 
 
579
  if ((argc == 3 || argc == 4)
 
580
      && (sscanf (argv[1], "%d-%d-%d%c",
 
581
                  &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
 
582
          == 3)
 
583
      && (sscanf (argv[2], "%d:%d:%d%c",
 
584
                  &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
 
585
          == 3))
 
586
    {
 
587
      tm.tm_year -= TM_YEAR_BASE;
 
588
      tm.tm_mon--;
 
589
      tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
 
590
      tmk = tm;
 
591
      tl = mktime (&tmk);
 
592
      lt = localtime (&tl);
 
593
      if (lt)
 
594
        {
 
595
          tml = *lt;
 
596
          lt = &tml;
 
597
        }
 
598
      printf ("mktime returns %ld == ", (long int) tl);
 
599
      print_tm (&tmk);
 
600
      printf ("\n");
 
601
      status = check_result (tl, tmk, tl, lt);
 
602
    }
 
603
  else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
 
604
    {
 
605
      time_t from = atol (argv[1]);
 
606
      time_t by = atol (argv[2]);
 
607
      time_t to = atol (argv[3]);
 
608
 
 
609
      if (argc == 4)
 
610
        for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
 
611
          {
 
612
            lt = localtime (&tl);
 
613
            if (lt)
 
614
              {
 
615
                tmk = tml = *lt;
 
616
                tk = mktime (&tmk);
 
617
                status |= check_result (tk, tmk, tl, &tml);
 
618
              }
 
619
            else
 
620
              {
 
621
                printf ("localtime (%ld) yields 0\n", (long int) tl);
 
622
                status = 1;
 
623
              }
 
624
            tl1 = tl + by;
 
625
            if ((tl1 < tl) != (by < 0))
 
626
              break;
 
627
          }
 
628
      else
 
629
        for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
 
630
          {
 
631
            /* Null benchmark.  */
 
632
            lt = localtime (&tl);
 
633
            if (lt)
 
634
              {
 
635
                tmk = tml = *lt;
 
636
                tk = tl;
 
637
                status |= check_result (tk, tmk, tl, &tml);
 
638
              }
 
639
            else
 
640
              {
 
641
                printf ("localtime (%ld) yields 0\n", (long int) tl);
 
642
                status = 1;
 
643
              }
 
644
            tl1 = tl + by;
 
645
            if ((tl1 < tl) != (by < 0))
 
646
              break;
 
647
          }
 
648
    }
 
649
  else
 
650
    printf ("Usage:\
 
651
\t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
 
652
\t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
 
653
\t%s FROM BY TO - # Do not test those values (for benchmark).\n",
 
654
            argv[0], argv[0], argv[0]);
 
655
 
 
656
  return status;
 
657
}
 
658
 
 
659
#endif /* DEBUG */
 
660
 
 
661
/*
 
662
Local Variables:
 
663
compile-command: "gcc -DDEBUG -Wall -W -O -g mktime.c -o mktime"
 
664
End:
 
665
*/