nstime.h

Go to the documentation of this file.

/* nstime.h
 * Definition of data structure to hold time values with nanosecond resolution
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#ifndef __NSTIME_H__
#define __NSTIME_H__
 
#include <wireshark.h>
#include <time.h>
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
typedef struct {
    time_t  secs;
    int nsecs;
} nstime_t;
 
/*
 * Compute the minimum and maximum time_t values.
 * (Note: this does not guarantee that any particular C standard library
 * function taking a time_t will return a valid result with these values;
 * e.g., asctime has undefined behavior if the year exceeds 4 digits or
 * is less than 1000, the struct tm tm_year member is defined as an int,
 * Windows defines _MAX__TIME64_T and its localtime only allows dates
 * through Jan 3001, etc.)
 *
 * This code is based on the Samba code:
 *
 *  Unix SMB/Netbios implementation.
 *  Version 1.9.
 *  time handling functions
 *  Copyright (C) Andrew Tridgell 1992-1998
 */
 
#ifndef TIME_T_MIN
#define TIME_T_MIN ((time_t) ((time_t)0 < (time_t) -1 ? (time_t) 0 \
                    : (time_t) (~0ULL << (sizeof (time_t) * CHAR_BIT - 1))))
#endif
#ifndef TIME_T_MAX
#define TIME_T_MAX ((time_t) (~ (time_t) 0 - TIME_T_MIN))
#endif
 
/*
 * Macros for conversion between time units.
 *
 * These are #defined so that we can clearly see that we have the right number
 * of zeros, rather than as a guard against the numbers changing. ;)
 */
#define WS_MSECS_PER_SEC    (1000)
#define WS_USECS_PER_SEC    (1000*1000)
#define WS_NSECS_PER_SEC    (1000*1000*1000)
 
#define WS_NSECS_PER_MSEC   (WS_NSECS_PER_SEC/WS_MSECS_PER_SEC)
#define WS_NSECS_PER_USEC   (WS_NSECS_PER_SEC/WS_USECS_PER_SEC)
 
#define WS_NSECS_PER_100NSEC    (100)
#define WS_100NSECS_PER_SEC (WS_NSECS_PER_SEC/WS_NSECS_PER_100NSEC)
 
/* Macros that expand to nstime_t initializers */
 
/* Initialize to zero */
#define NSTIME_INIT_ZERO {0, 0}
 
/* Initialize to unset */
#define NSTIME_INIT_UNSET {0, INT_MAX}
 
/*
 * Initialize to a specified number of seconds and nanoseconds.
 * This does not assume that the number of nanoseconds is < 1 second.
 */
#define NSTIME_INIT_SECS_NSECS(secs, nsecs) {(secs) + ((nsecs) / WS_NSECS_PER_SEC), (nsecs) % WS_NSECS_PER_SEC}
 
/*
 * Initialize to a specified number of seconds and microseconds.
 * This does not assume that the number of microseconds is < 1 second.
 */
#define NSTIME_INIT_SECS_USECS(secs, usecs) {(secs) + ((usecs) / WS_USECS_PER_SEC), ((usecs) % WS_USECS_PER_SEC) * WS_NSECS_PER_USEC}
 
/*
 * Initialize to a specified number of seconds and milliseconds.
 * This does not assume that the number of milliseconds is < 1 second.
 */
#define NSTIME_INIT_SECS_MSECS(secs, msecs) {(secs) + ((msecs) / WS_MSECS_PER_SEC), ((msecs) % WS_MSECS_PER_SEC) * WS_NSECS_PER_MSEC}
 
/* Initialize to a specified number of seconds */
#define NSTIME_INIT_SECS(secs)          {secs, 0}
 
/* Initialize to the maximum possible value */
#define NSTIME_INIT_MAX {TIME_T_MAX, INT_MAX}
 
/* functions */
 
WS_DLL_PUBLIC void nstime_set_zero(nstime_t *nstime);
 
WS_DLL_PUBLIC bool nstime_is_zero(const nstime_t *nstime);
 
WS_DLL_PUBLIC bool nstime_is_negative(const nstime_t *nstime);
 
WS_DLL_PUBLIC void nstime_set_unset(nstime_t *nstime);
 
WS_DLL_PUBLIC bool nstime_is_unset(const nstime_t *nstime);
 
WS_DLL_PUBLIC void nstime_copy(nstime_t *a, const nstime_t *b);
 
WS_DLL_PUBLIC void nstime_delta(nstime_t *delta, const nstime_t *b, const nstime_t *a);
 
WS_DLL_PUBLIC void nstime_sum(nstime_t *sum, const nstime_t *a, const nstime_t *b);
 
#define nstime_add(sum, a) nstime_sum(sum, sum, a)
 
#define nstime_subtract(sum, a) nstime_delta(sum, sum, a)
 
WS_DLL_PUBLIC int nstime_cmp(const nstime_t *a, const nstime_t *b);
 
WS_DLL_PUBLIC unsigned nstime_hash(const nstime_t *nstime);
 
static inline double nstime_to_msec(const nstime_t *nstime)
{
    return ((double)nstime->secs*WS_MSECS_PER_SEC + (double)nstime->nsecs/WS_NSECS_PER_MSEC);
}
 
static inline double nstime_to_sec(const nstime_t *nstime)
{
    return ((double)nstime->secs + (double)nstime->nsecs/WS_NSECS_PER_SEC);
}
 
WS_DLL_PUBLIC bool filetime_to_nstime(nstime_t *nstime, uint64_t filetime);
 
WS_DLL_PUBLIC bool filetime_ns_to_nstime(nstime_t *nstime, uint64_t nsfiletime);
 
WS_DLL_PUBLIC bool filetime_1sec_to_nstime(nstime_t *nstime, uint64_t filetime);
 
typedef enum {
    ISO8601_DATETIME,       
    ISO8601_DATETIME_BASIC, 
    ISO8601_DATETIME_AUTO,  
} iso8601_fmt_e;
 
WS_DLL_PUBLIC const char * iso8601_to_nstime(nstime_t *nstime, const char *ptr, iso8601_fmt_e format);
 
WS_DLL_PUBLIC const char * unix_epoch_to_nstime(nstime_t *nstime, const char *ptr);
 
#define NSTIME_ISO8601_BUFSIZE  sizeof("YYYY-MM-DDTHH:MM:SS.123456789Z")
 
WS_DLL_PUBLIC size_t nstime_to_iso8601(char *buf, size_t buf_size, const nstime_t *nstime);
 
#define NSTIME_UNIX_BUFSIZE  (20+10+1)
 
WS_DLL_PUBLIC void nstime_to_unix(char *buf, size_t buf_size, const nstime_t *nstime);
 
typedef enum {
    WS_TSPREC_SEC      = 0, 
    WS_TSPREC_100_MSEC = 1, 
    WS_TSPREC_10_MSEC  = 2, 
    WS_TSPREC_MSEC     = 3, 
    WS_TSPREC_100_USEC = 4, 
    WS_TSPREC_10_USEC  = 5, 
    WS_TSPREC_USEC     = 6, 
    WS_TSPREC_100_NSEC = 7, 
    WS_TSPREC_10_NSEC  = 8, 
    WS_TSPREC_NSEC     = 9  
} ws_tsprec_e;
 
#define WS_TSPREC_MAX 9
 
#define NUM_WS_TSPREC_VALS (WS_TSPREC_MAX + 1)
 
WS_DLL_PUBLIC void nstime_rounded(nstime_t *a, const nstime_t *b, ws_tsprec_e prec);
 
#define nstime_round(a, prec) nstime_rounded(a, a, prec)
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* __NSTIME_H__  */