osmocom
/
wireshark
11
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
wireshark/epan/to_str.c

598 lines
17 KiB
C
Raw Blame History

/* to_str.c
* Routines for utilities to convert various other types to strings.
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "config.h"
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <glib.h>
#include <epan/wmem_scopes.h>
#include "proto.h"
#include "to_str.h"
#include "strutil.h"
#include <wsutil/pint.h>
#include <wsutil/utf8_entities.h>
/*
* If a user _does_ pass in a too-small buffer, this is probably
* going to be too long to fit. However, even a partial string
* starting with "[Buf" should provide enough of a clue to be
* useful.
*/
#define BUF_TOO_SMALL_ERR "[Buffer too small]"
static const char mon_names[12][4] = {
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec"
};
static const gchar *
get_zonename(struct tm *tmp)
{
#if defined(_WIN32)
/*
* The strings in _tzname[] are encoded using the code page
* for the current C-language locale.
*
* On Windows, all Wireshark programs set that code page
* to the UTF-8 code page by calling
*
* setlocale(LC_ALL, ".UTF-8");
*
* so the strings in _tzname[] are UTF-8 strings, and we can
* just return them.
*
* (Note: the above does *not* mean we've set any code pages
* *other* than the one used by the Visual Studio C runtime
* to UTF-8, so don't assume, for example, that the "ANSI"
* versions of Windows APIs will take UTF-8 strings, or that
* non-UTF-16 output to the console will be treated as UTF-8.
* Setting those other code pages can cause problems, especially
* on pre-Windows 10 or older Windows 10 releases.)
*/
return _tzname[tmp->tm_isdst];
#else
/*
* UN*X.
*
* If we have tm_zone in struct tm, use that.
* Otherwise, if we have tzname[], use it, otherwise just
* say "we don't know.
*/
# if defined(HAVE_STRUCT_TM_TM_ZONE)
return tmp->tm_zone;
# else /* HAVE_STRUCT_TM_TM_ZONE */
if ((tmp->tm_isdst != 0) && (tmp->tm_isdst != 1)) {
return "???";
}
# if defined(HAVE_TZNAME)
return tzname[tmp->tm_isdst];
# else
return tmp->tm_isdst ? "?DT" : "?ST";
# endif /* HAVE_TZNAME */
# endif /* HAVE_STRUCT_TM_TM_ZONE */
#endif /* _WIN32 */
}
static struct tm *
get_fmt_broken_down_time(field_display_e fmt, const time_t *secs)
{
switch (fmt) {
case ABSOLUTE_TIME_UTC:
case ABSOLUTE_TIME_DOY_UTC:
case ABSOLUTE_TIME_NTP_UTC:
return gmtime(secs);
case ABSOLUTE_TIME_LOCAL:
return localtime(secs);
default:
break;
}
ws_assert_not_reached();
}
static char *
snprint_abs_time_secs(wmem_allocator_t *scope,
field_display_e fmt, struct tm *tmp,
const char *nsecs_str, const char *tzone_sep,
const char *tzone_str, gboolean add_quotes)
{
char *buf;
switch (fmt) {
case ABSOLUTE_TIME_DOY_UTC:
buf = wmem_strdup_printf(scope,
"%s%04d/%03d:%02d:%02d:%02d%s%s%s%s",
add_quotes ? "\"" : "",
tmp->tm_year + 1900,
tmp->tm_yday + 1,
tmp->tm_hour,
tmp->tm_min,
tmp->tm_sec,
nsecs_str,
tzone_sep,
tzone_str,
add_quotes ? "\"" : "");
break;
case ABSOLUTE_TIME_NTP_UTC: /* FALLTHROUGH */
case ABSOLUTE_TIME_UTC: /* FALLTHROUGH */
case ABSOLUTE_TIME_LOCAL:
buf = wmem_strdup_printf(scope,
"%s%s %2d, %d %02d:%02d:%02d%s%s%s%s",
add_quotes ? "\"" : "",
mon_names[tmp->tm_mon],
tmp->tm_mday,
tmp->tm_year + 1900,
tmp->tm_hour,
tmp->tm_min,
tmp->tm_sec,
nsecs_str,
tzone_sep,
tzone_str,
add_quotes ? "\"" : "");
break;
default:
ws_assert_not_reached();
}
return buf;
}
char *
abs_time_to_str_ex(wmem_allocator_t *scope, const nstime_t *abs_time, field_display_e fmt,
int flags)
{
struct tm *tmp;
char buf_nsecs[32];
const char *tzone_sep, *tzone_str;
if (fmt == BASE_NONE)
fmt = ABSOLUTE_TIME_LOCAL;
ws_assert(FIELD_DISPLAY_IS_ABSOLUTE_TIME(fmt));
if (fmt == ABSOLUTE_TIME_UNIX) {
return abs_time_to_unix_str(scope, abs_time);
}
if (fmt == ABSOLUTE_TIME_NTP_UTC && abs_time->secs == 0 &&
(abs_time->nsecs == 0 || abs_time->nsecs == G_MAXINT)) {
return wmem_strdup(scope, "NULL");
}
tmp = get_fmt_broken_down_time(fmt, &abs_time->secs);
if (tmp == NULL) {
return wmem_strdup(scope, "Not representable");
}
*buf_nsecs = '\0';
if (abs_time->nsecs != G_MAXINT) {
snprintf(buf_nsecs, sizeof(buf_nsecs), ".%09d", abs_time->nsecs);
}
tzone_sep = "";
tzone_str = "";
if (flags & ABS_TIME_TO_STR_SHOW_ZONE || flags & ABS_TIME_TO_STR_SHOW_UTC_ONLY) {
switch (fmt) {
case ABSOLUTE_TIME_UTC:
case ABSOLUTE_TIME_DOY_UTC:
case ABSOLUTE_TIME_NTP_UTC:
tzone_sep = " ";
tzone_str = "UTC";
break;
case ABSOLUTE_TIME_LOCAL:
if (flags & ABS_TIME_TO_STR_SHOW_ZONE) {
tzone_sep = " ";
tzone_str = get_zonename(tmp);
}
break;
default:
ws_assert_not_reached();
}
}
return snprint_abs_time_secs(scope, fmt, tmp, buf_nsecs, tzone_sep, tzone_str, flags & ABS_TIME_TO_STR_ADD_DQUOTES);
}
char *
abs_time_secs_to_str_ex(wmem_allocator_t *scope, const time_t abs_time_secs, field_display_e fmt,
int flags)
{
nstime_t abs_time;
nstime_set_unset(&abs_time);
abs_time.secs = abs_time_secs;
return abs_time_to_str_ex(scope, &abs_time, fmt, flags);
}
#define PLURALIZE(n) (((n) > 1) ? "s" : "")
#define COMMA(do_it) ((do_it) ? ", " : "")
/*
* Maximum length of a string showing days/hours/minutes/seconds.
* (Does not include the terminating '\0'.)
* Includes space for a '-' sign for any negative components.
* -12345 days, 12 hours, 12 minutes, 12.123 seconds
*/
#define TIME_SECS_LEN (10+1+4+2+2+5+2+2+7+2+2+7+4)
/*
* Convert an unsigned value in seconds and fractions of a second to a string,
* giving time in days, hours, minutes, and seconds, and put the result
* into a buffer.
* "is_nsecs" says that "frac" is nanoseconds if true and milliseconds
* if false.
*/
static void
unsigned_time_secs_to_str_buf(guint32 time_val, const guint32 frac,
const gboolean is_nsecs, wmem_strbuf_t *buf)
{
int hours, mins, secs;
gboolean do_comma = FALSE;
secs = time_val % 60;
time_val /= 60;
mins = time_val % 60;
time_val /= 60;
hours = time_val % 24;
time_val /= 24;
if (time_val != 0) {
wmem_strbuf_append_printf(buf, "%u day%s", time_val, PLURALIZE(time_val));
do_comma = TRUE;
}
if (hours != 0) {
wmem_strbuf_append_printf(buf, "%s%u hour%s", COMMA(do_comma), hours, PLURALIZE(hours));
do_comma = TRUE;
}
if (mins != 0) {
wmem_strbuf_append_printf(buf, "%s%u minute%s", COMMA(do_comma), mins, PLURALIZE(mins));
do_comma = TRUE;
}
if (secs != 0 || frac != 0) {
if (frac != 0) {
if (is_nsecs)
wmem_strbuf_append_printf(buf, "%s%u.%09u seconds", COMMA(do_comma), secs, frac);
else
wmem_strbuf_append_printf(buf, "%s%u.%03u seconds", COMMA(do_comma), secs, frac);
} else
wmem_strbuf_append_printf(buf, "%s%u second%s", COMMA(do_comma), secs, PLURALIZE(secs));
}
}
gchar *
unsigned_time_secs_to_str(wmem_allocator_t *scope, const guint32 time_val)
{
wmem_strbuf_t *buf;
if (time_val == 0) {
return wmem_strdup(scope, "0 seconds");
}
buf = wmem_strbuf_new_sized(scope, TIME_SECS_LEN+1);
unsigned_time_secs_to_str_buf(time_val, 0, FALSE, buf);
return wmem_strbuf_finalize(buf);
}
/*
* Convert a signed value in seconds and fractions of a second to a string,
* giving time in days, hours, minutes, and seconds, and put the result
* into a buffer.
* "is_nsecs" says that "frac" is nanoseconds if true and milliseconds
* if false.
*/
static void
signed_time_secs_to_str_buf(gint32 time_val, const guint32 frac,
const gboolean is_nsecs, wmem_strbuf_t *buf)
{
if(time_val < 0){
wmem_strbuf_append_printf(buf, "-");
if(time_val == G_MININT32) {
/*
* You can't fit time_val's absolute value into
* a 32-bit signed integer. Just directly
* pass G_MAXUINT32, which is its absolute
* value, directly to unsigned_time_secs_to_str_buf().
*
* (XXX - does ISO C guarantee that -(-2^n),
* when calculated and cast to an n-bit unsigned
* integer type, will have the value 2^n?)
*/
unsigned_time_secs_to_str_buf(G_MAXUINT32, frac,
is_nsecs, buf);
} else {
/*
* We now know -secs will fit into a guint32;
* negate it and pass that to
* unsigned_time_secs_to_str_buf().
*/
unsigned_time_secs_to_str_buf(-time_val, frac, is_nsecs, buf);
}
} else
unsigned_time_secs_to_str_buf(time_val, frac, is_nsecs, buf);
}
gchar *
signed_time_secs_to_str(wmem_allocator_t *scope, const gint32 time_val)
{
wmem_strbuf_t *buf;
if (time_val == 0) {
return wmem_strdup(scope, "0 seconds");
}
buf = wmem_strbuf_new_sized(scope, TIME_SECS_LEN+1);
signed_time_secs_to_str_buf(time_val, 0, FALSE, buf);
return wmem_strbuf_finalize(buf);
}
/*
* Convert a signed value in milliseconds to a string, giving time in days,
* hours, minutes, and seconds, and put the result into a buffer.
*/
gchar *
signed_time_msecs_to_str(wmem_allocator_t *scope, gint32 time_val)
{
wmem_strbuf_t *buf;
int msecs;
if (time_val == 0) {
return wmem_strdup(scope, "0 seconds");
}
buf = wmem_strbuf_new_sized(scope, TIME_SECS_LEN+1+3+1);
if (time_val<0) {
/* oops we got passed a negative time */
time_val= -time_val;
msecs = time_val % 1000;
time_val /= 1000;
time_val= -time_val;
} else {
msecs = time_val % 1000;
time_val /= 1000;
}
signed_time_secs_to_str_buf(time_val, msecs, FALSE, buf);
return wmem_strbuf_finalize(buf);
}
/*
* Display a relative time as days/hours/minutes/seconds.
*/
gchar *
rel_time_to_str(wmem_allocator_t *scope, const nstime_t *rel_time)
{
wmem_strbuf_t *buf;
gint32 time_val;
gint32 nsec;
/* If the nanoseconds part of the time stamp is negative,
print its absolute value and, if the seconds part isn't
(the seconds part should be zero in that case), stick
a "-" in front of the entire time stamp. */
time_val = (gint) rel_time->secs;
nsec = rel_time->nsecs;
if (time_val == 0 && nsec == 0) {
return wmem_strdup(scope, "0.000000000 seconds");
}
buf = wmem_strbuf_new_sized(scope, 1+TIME_SECS_LEN+1+6+1);
if (nsec < 0) {
nsec = -nsec;
wmem_strbuf_append_c(buf, '-');
/*
* We assume here that "rel_time->secs" is negative
* or zero; if it's not, the time stamp is bogus,
* with a positive seconds and negative microseconds.
*/
time_val = (gint) -rel_time->secs;
}
signed_time_secs_to_str_buf(time_val, nsec, TRUE, buf);
return wmem_strbuf_finalize(buf);
}
/*
* Number of characters required by a 64-bit signed number.
*/
#define CHARS_64_BIT_SIGNED 20 /* sign plus 19 digits */
/*
* Number of characters required by a fractional part, in nanoseconds */
#define CHARS_NANOSECONDS 10 /* .000000001 */
/* Includes terminating '\0' */
#define NSTIME_SECS_LEN (CHARS_64_BIT_SIGNED+CHARS_NANOSECONDS+1)
/*
* Display a relative time as seconds.
*/
gchar *
rel_time_to_secs_str(wmem_allocator_t *scope, const nstime_t *rel_time)
{
gchar *buf;
buf = (gchar *)wmem_alloc(scope, NSTIME_SECS_LEN);
display_signed_time(buf, NSTIME_SECS_LEN, rel_time, WS_TSPREC_NSEC);
return buf;
}
gchar *
abs_time_to_unix_str(wmem_allocator_t *scope, const nstime_t *rel_time)
{
gchar *buf;
buf = (gchar *)wmem_alloc(scope, NSTIME_SECS_LEN);
display_epoch_time(buf, NSTIME_SECS_LEN, rel_time, WS_TSPREC_NSEC);
return buf;
}
/*
* Generates a string representing the bits in a bitfield at "bit_offset" from an 8 bit boundary
* with the length in bits of no_of_bits based on value.
* Ex: ..xx x...
*/
char *
decode_bits_in_field(wmem_allocator_t *scope, const guint bit_offset, const gint no_of_bits, const guint64 value, const guint encoding)
{
guint64 mask;
char *str;
int bit, str_p = 0;
int i;
int max_bits = MIN(64, no_of_bits);
int no_leading_dots;
mask = G_GUINT64_CONSTANT(1) << (max_bits-1);
if (encoding & ENC_LITTLE_ENDIAN) {
/* Bits within octet are numbered from LSB (0) to MSB (7).
* The value in string is from most significant bit to lowest.
* Calculate how many dots have to be printed at the beginning of string.
*/
no_leading_dots = (8 - ((bit_offset + no_of_bits) % 8)) % 8;
} else {
no_leading_dots = bit_offset % 8;
}
/* Prepare the string, 256 pos for the bits and zero termination, + 64 for the spaces */
str = (char *)wmem_alloc0(scope, 256+64);
for (bit = 0; bit < no_leading_dots; bit++) {
if (bit && !(bit % 4)) {
str[str_p] = ' ';
str_p++;
}
str[str_p] = '.';
str_p++;
}
/* read the bits for the int */
for (i = 0; i < max_bits; i++) {
if (bit && !(bit % 4)) {
str[str_p] = ' ';
str_p++;
}
if (bit && !(bit % 8)) {
str[str_p] = ' ';
str_p++;
}
bit++;
if ((value & mask) != 0) {
str[str_p] = '1';
str_p++;
} else {
str[str_p] = '0';
str_p++;
}
mask = mask>>1;
}
for (; bit % 8; bit++) {
if (bit && !(bit % 4)) {
str[str_p] = ' ';
str_p++;
}
str[str_p] = '.';
str_p++;
}
return str;
}
gchar *
guid_to_str(wmem_allocator_t *scope, const e_guid_t *guid)
{
gchar *buf;
buf = (gchar *)wmem_alloc(scope, GUID_STR_LEN);
return guid_to_str_buf(guid, buf, GUID_STR_LEN);
}
gchar *
guid_to_str_buf(const e_guid_t *guid, gchar *buf, int buf_len)
{
char *tempptr = buf;
if (buf_len < GUID_STR_LEN) {
(void) g_strlcpy(buf, BUF_TOO_SMALL_ERR, buf_len); /* Let the unexpected value alert user */
return buf;
}
/* 37 bytes */
tempptr = dword_to_hex(tempptr, guid->data1); /* 8 bytes */
*tempptr++ = '-'; /* 1 byte */
tempptr = word_to_hex(tempptr, guid->data2); /* 4 bytes */
*tempptr++ = '-'; /* 1 byte */
tempptr = word_to_hex(tempptr, guid->data3); /* 4 bytes */
*tempptr++ = '-'; /* 1 byte */
tempptr = bytes_to_hexstr(tempptr, &guid->data4[0], 2); /* 4 bytes */
*tempptr++ = '-'; /* 1 byte */
tempptr = bytes_to_hexstr(tempptr, &guid->data4[2], 6); /* 12 bytes */
*tempptr = '\0';
return buf;
}
const gchar *
port_type_to_str (port_type type)
{
switch (type) {
case PT_NONE: return "NONE";
case PT_SCTP: return "SCTP";
case PT_TCP: return "TCP";
case PT_UDP: return "UDP";
case PT_DCCP: return "DCCP";
case PT_IPX: return "IPX";
case PT_DDP: return "DDP";
case PT_IDP: return "IDP";
case PT_USB: return "USB";
case PT_I2C: return "I2C";
case PT_IBQP: return "IBQP";
case PT_BLUETOOTH: return "BLUETOOTH";
case PT_IWARP_MPA: return "IWARP_MPA";
default: return "[Unknown]";
}
}
/*
* Editor modelines - https://www.wireshark.org/tools/modelines.html
*
* Local variables:
* c-basic-offset: 4
* tab-width: 8
* indent-tabs-mode: nil
* End:
*
* vi: set shiftwidth=4 tabstop=8 expandtab:
* :indentSize=4:tabSize=8:noTabs=true:
*/
Reference in New Issue View Git Blame Copy Permalink