epan/ftypes/ftype-time.c

   1 /*
   2  * $Id$
   3  *
   4  * Wireshark - Network traffic analyzer
   5  * By Gerald Combs <gerald@wireshark.org>
   6  * Copyright 2001 Gerald Combs
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <ctype.h>
  28 #include <string.h>
  29
  30 /*
  31  * Just make sure we include the prototype for strptime as well
  32  * (needed for glibc 2.2) but make sure we do this only if not
  33  * yet defined.
  34  */
  35 #ifndef __USE_XOPEN
  36 #  define __USE_XOPEN
  37 #endif
  38
  39 #include <time.h>
  40
  41 #include <ftypes-int.h>
  42 #include <epan/to_str.h>
  43
  44 #ifdef NEED_STRPTIME_H
  45 #include "wsutil/strptime.h"
  46 #endif
  47
  48 static gboolean
  49 cmp_eq(const fvalue_t *a, const fvalue_t *b)
  50 {
  51         return ((a->value.time.secs) ==(b->value.time.secs))
  52              &&((a->value.time.nsecs)==(b->value.time.nsecs));
  53 }
  54 static gboolean
  55 cmp_ne(const fvalue_t *a, const fvalue_t *b)
  56 {
  57         return (a->value.time.secs !=b->value.time.secs)
  58              ||(a->value.time.nsecs!=b->value.time.nsecs);
  59 }
  60 static gboolean
  61 cmp_gt(const fvalue_t *a, const fvalue_t *b)
  62 {
  63         if (a->value.time.secs > b->value.time.secs) {
  64                 return TRUE;
  65         }
  66         if (a->value.time.secs < b->value.time.secs) {
  67                 return FALSE;
  68         }
  69
  70         return a->value.time.nsecs > b->value.time.nsecs;
  71 }
  72 static gboolean
  73 cmp_ge(const fvalue_t *a, const fvalue_t *b)
  74 {
  75         if (a->value.time.secs > b->value.time.secs) {
  76                 return TRUE;
  77         }
  78         if (a->value.time.secs < b->value.time.secs) {
  79                 return FALSE;
  80         }
  81
  82         return a->value.time.nsecs >= b->value.time.nsecs;
  83 }
  84 static gboolean
  85 cmp_lt(const fvalue_t *a, const fvalue_t *b)
  86 {
  87         if (a->value.time.secs < b->value.time.secs) {
  88                 return TRUE;
  89         }
  90         if (a->value.time.secs > b->value.time.secs) {
  91                 return FALSE;
  92         }
  93
  94         return a->value.time.nsecs < b->value.time.nsecs;
  95 }
  96 static gboolean
  97 cmp_le(const fvalue_t *a, const fvalue_t *b)
  98 {
  99         if (a->value.time.secs < b->value.time.secs) {
 100                 return TRUE;
 101         }
 102         if (a->value.time.secs > b->value.time.secs) {
 103                 return FALSE;
 104         }
 105
 106         return a->value.time.nsecs <= b->value.time.nsecs;
 107 }
 108
 109
 110 /*
 111  * Get a nanoseconds value, starting at "p".
 112  *
 113  * Returns true on success, false on failure.
 114  */
 115 static gboolean
 116 get_nsecs(char *startp, int *nsecs)
 117 {
 118         int ndigits;
 119         int scale;
 120         char *p;
 121         int val;
 122         int digit;
 123         int i;
 124
 125         /*
 126          * How many characters are in the string?
 127          */
 128         ndigits = (int)strlen(startp);
 129
 130         /*
 131          * If there are N characters in the string, the last of the
 132          * characters would be the digit corresponding to 10^(9-N)
 133          * nanoseconds.
 134          */
 135         scale = 9 - ndigits;
 136
 137         /*
 138          * Start at the last character, and work backwards.
 139          */
 140         p = startp + ndigits;
 141         val = 0;
 142         while (p != startp) {
 143                 p--;
 144
 145                 if (!isdigit((unsigned char)*p)) {
 146                         /*
 147                          * Not a digit - error.
 148                          */
 149                         return FALSE;
 150                 }
 151                 digit = *p - '0';
 152                 if (digit != 0) {
 153                         /*
 154                          * Non-zero digit corresponding to that number
 155                          * of (10^scale) units.
 156                          *
 157                          * If scale is less than zero, this digit corresponds
 158                          * to a value less than a nanosecond, so this number
 159                          * isn't valid.
 160                          */
 161                         if (scale < 0)
 162                                 return FALSE;
 163                         for (i = 0; i < scale; i++)
 164                                 digit *= 10;
 165                         val += digit;
 166                 }
 167                 scale++;
 168         }
 169         *nsecs = val;
 170         return TRUE;
 171 }
 172
 173 static gboolean
 174 relative_val_from_unparsed(fvalue_t *fv, char *s, gboolean allow_partial_value _U_, LogFunc logfunc)
 175 {
 176         char    *curptr, *endptr;
 177         gboolean negative = FALSE;
 178
 179         curptr = s;
 180
 181         if(*curptr == '-') {
 182             negative = TRUE;
 183             curptr++;
 184         }
 185
 186         /*
 187          * If it doesn't begin with ".", it should contain a seconds
 188          * value.
 189          */
 190         if (*curptr != '.') {
 191                 /*
 192                  * Get the seconds value.
 193                  */
 194                 fv->value.time.secs = strtoul(curptr, &endptr, 10);
 195                 if (endptr == curptr || (*endptr != '\0' && *endptr != '.'))
 196                         goto fail;
 197                 curptr = endptr;
 198                 if (*curptr == '.')
 199                         curptr++;       /* skip the decimal point */
 200         } else {
 201                 /*
 202                  * No seconds value - it's 0.
 203                  */
 204                 fv->value.time.secs = 0;
 205                 curptr++;               /* skip the decimal point */
 206         }
 207
 208         /*
 209          * If there's more stuff left in the string, it should be the
 210          * nanoseconds value.
 211          */
 212         if (*curptr != '\0') {
 213                 /*
 214                  * Get the nanoseconds value.
 215                  */
 216                 if (!get_nsecs(curptr, &fv->value.time.nsecs))
 217                         goto fail;
 218         } else {
 219                 /*
 220                  * No nanoseconds value - it's 0.
 221                  */
 222                 fv->value.time.nsecs = 0;
 223         }
 224
 225         if(negative) {
 226             fv->value.time.secs = -fv->value.time.secs;
 227             fv->value.time.nsecs = -fv->value.time.nsecs;
 228         }
 229         return TRUE;
 230
 231 fail:
 232         if (logfunc != NULL)
 233                 logfunc("\"%s\" is not a valid time.", s);
 234         return FALSE;
 235 }
 236
 237
 238 static gboolean
 239 absolute_val_from_string(fvalue_t *fv, char *s, LogFunc logfunc)
 240 {
 241         struct tm tm;
 242         char    *curptr;
 243
 244         memset(&tm, 0, sizeof(tm));
 245         curptr = strptime(s,"%b %d, %Y %H:%M:%S", &tm);
 246         if (curptr == NULL)
 247                 curptr = strptime(s,"%Y-%m-%dT%H:%M:%S", &tm);
 248         if (curptr == NULL)
 249                 curptr = strptime(s,"%Y-%m-%d %H:%M:%S", &tm);
 250         if (curptr == NULL)
 251                 curptr = strptime(s,"%Y-%m-%d %H:%M", &tm);
 252         if (curptr == NULL)
 253                 curptr = strptime(s,"%Y-%m-%d %H", &tm);
 254         if (curptr == NULL)
 255                 curptr = strptime(s,"%Y-%m-%d", &tm);
 256         if (curptr == NULL)
 257                 goto fail;
 258         tm.tm_isdst = -1;       /* let the computer figure out if it's DST */
 259         fv->value.time.secs = mktime(&tm);
 260         if (*curptr != '\0') {
 261                 /*
 262                  * Something came after the seconds field; it must be
 263                  * a nanoseconds field.
 264                  */
 265                 if (*curptr != '.')
 266                         goto fail;      /* it's not */
 267                 curptr++;       /* skip the "." */
 268                 if (!isdigit((unsigned char)*curptr))
 269                         goto fail;      /* not a digit, so not valid */
 270                 if (!get_nsecs(curptr, &fv->value.time.nsecs))
 271                         goto fail;
 272         } else {
 273                 /*
 274                  * No nanoseconds value - it's 0.
 275                  */
 276                 fv->value.time.nsecs = 0;
 277         }
 278
 279         if (fv->value.time.secs == -1) {
 280                 /*
 281                  * XXX - should we supply an error message that mentions
 282                  * that the time specified might be syntactically valid
 283                  * but might not actually have occurred, e.g. a time in
 284                  * the non-existent time range after the clocks are
 285                  * set forward during daylight savings time (or possibly
 286                  * that it's in the time range after the clocks are set
 287                  * backward, so that there are two different times that
 288                  * it could be)?
 289                  */
 290                 goto fail;
 291         }
 292
 293         return TRUE;
 294
 295 fail:
 296         if (logfunc != NULL)
 297                 logfunc("\"%s\" is not a valid absolute time. Example: \"Nov 12, 1999 08:55:44.123\" or \"2011-07-04 12:34:56\"",
 298                     s);
 299         return FALSE;
 300 }
 301
 302 static gboolean
 303 absolute_val_from_unparsed(fvalue_t *fv, char *s, gboolean allow_partial_value _U_, LogFunc logfunc)
 304 {
 305         return absolute_val_from_string(fv, s, logfunc);
 306 }
 307
 308 static void
 309 time_fvalue_new(fvalue_t *fv)
 310 {
 311         fv->value.time.secs = 0;
 312         fv->value.time.nsecs = 0;
 313 }
 314
 315 static void
 316 time_fvalue_set(fvalue_t *fv, gpointer value, gboolean already_copied)
 317 {
 318         g_assert(!already_copied);
 319         memcpy(&(fv->value.time), value, sizeof(nstime_t));
 320 }
 321
 322 static gpointer
 323 value_get(fvalue_t *fv)
 324 {
 325         return &(fv->value.time);
 326 }
 327
 328 static int
 329 absolute_val_repr_len(fvalue_t *fv, ftrepr_t rtype _U_)
 330 {
 331         gchar *rep;
 332
 333         rep = abs_time_to_str(&fv->value.time, ABSOLUTE_TIME_LOCAL,
 334             rtype == FTREPR_DISPLAY);
 335         return (int)strlen(rep) + 2;    /* 2 for opening and closing quotes */
 336 }
 337
 338 static void
 339 absolute_val_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
 340 {
 341         sprintf(buf, "\"%s\"",
 342             abs_time_to_str(&fv->value.time, ABSOLUTE_TIME_LOCAL,
 343                 rtype == FTREPR_DISPLAY));
 344 }
 345
 346 static int
 347 relative_val_repr_len(fvalue_t *fv, ftrepr_t rtype _U_)
 348 {
 349         gchar *rep;
 350
 351         rep = rel_time_to_secs_str(&fv->value.time);
 352         return (int)strlen(rep);
 353 }
 354
 355 static void
 356 relative_val_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
 357 {
 358         strcpy(buf, rel_time_to_secs_str(&fv->value.time));
 359 }
 360
 361 void
 362 ftype_register_time(void)
 363 {
 364
 365         static ftype_t abstime_type = {
 366                 FT_ABSOLUTE_TIME,               /* ftype */
 367                 "FT_ABSOLUTE_TIME",             /* name */
 368                 "Date and time",                /* pretty_name */
 369                 0,                              /* wire_size */
 370                 time_fvalue_new,                /* new_value */
 371                 NULL,                           /* free_value */
 372                 absolute_val_from_unparsed,     /* val_from_unparsed */
 373                 absolute_val_from_string,       /* val_from_string */
 374                 absolute_val_to_repr,           /* val_to_string_repr */
 375                 absolute_val_repr_len,          /* len_string_repr */
 376
 377                 time_fvalue_set,                /* set_value */
 378                 NULL,                           /* set_value_uinteger */
 379                 NULL,                           /* set_value_sinteger */
 380                 NULL,                           /* set_value_integer64 */
 381                 NULL,                           /* set_value_floating */
 382
 383                 value_get,                      /* get_value */
 384                 NULL,                           /* get_value_uinteger */
 385                 NULL,                           /* get_value_sinteger */
 386                 NULL,                           /* get_value_integer64 */
 387                 NULL,                           /* get_value_floating */
 388
 389                 cmp_eq,
 390                 cmp_ne,
 391                 cmp_gt,
 392                 cmp_ge,
 393                 cmp_lt,
 394                 cmp_le,
 395                 NULL,                           /* cmp_bitwise_and */
 396                 NULL,                           /* cmp_contains */
 397                 NULL,                           /* cmp_matches */
 398
 399                 NULL,
 400                 NULL
 401         };
 402         static ftype_t reltime_type = {
 403                 FT_RELATIVE_TIME,               /* ftype */
 404                 "FT_RELATIVE_TIME",             /* name */
 405                 "Time offset",                  /* pretty_name */
 406                 0,                              /* wire_size */
 407                 time_fvalue_new,                /* new_value */
 408                 NULL,                           /* free_value */
 409                 relative_val_from_unparsed,     /* val_from_unparsed */
 410                 NULL,                           /* val_from_string */
 411                 relative_val_to_repr,           /* val_to_string_repr */
 412                 relative_val_repr_len,          /* len_string_repr */
 413
 414                 time_fvalue_set,                /* set_value */
 415                 NULL,                           /* set_value_uinteger */
 416                 NULL,                           /* set_value_sinteger */
 417                 NULL,                           /* set_value_integer64 */
 418                 NULL,                           /* set_value_floating */
 419
 420                 value_get,                      /* get_value */
 421                 NULL,                           /* get_value_uinteger */
 422                 NULL,                           /* get_value_sinteger */
 423                 NULL,                           /* get_value_integer64 */
 424                 NULL,                           /* get_value_floating */
 425
 426                 cmp_eq,
 427                 cmp_ne,
 428                 cmp_gt,
 429                 cmp_ge,
 430                 cmp_lt,
 431                 cmp_le,
 432                 NULL,                           /* cmp_bitwise_and */
 433                 NULL,                           /* cmp_contains */
 434                 NULL,                           /* cmp_matches */
 435
 436                 NULL,
 437                 NULL
 438         };
 439
 440         ftype_register(FT_ABSOLUTE_TIME, &abstime_type);
 441         ftype_register(FT_RELATIVE_TIME, &reltime_type);
 442 }