static inline char
low_nibble_of_octet_to_hex(guint8 oct)
{
- /* At least one version of Apple's C compiler/linker is buggy, causing
- a complaint from the linker about the "literal C string section"
- not ending with '\0' if we initialize a 16-element "char" array with
- a 16-character string, the fact that initializing such an array with
- such a string is perfectly legitimate ANSI C nonwithstanding, the 17th
- '\0' byte in the string nonwithstanding. */
- static const gchar hex_digits[16] =
- { '0', '1', '2', '3', '4', '5', '6', '7',
- '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
-
- return hex_digits[oct & 0xF];
+ /* At least one version of Apple's C compiler/linker is buggy, causing
+ a complaint from the linker about the "literal C string section"
+ not ending with '\0' if we initialize a 16-element "char" array with
+ a 16-character string, the fact that initializing such an array with
+ such a string is perfectly legitimate ANSI C nonwithstanding, the 17th
+ '\0' byte in the string nonwithstanding. */
+ static const gchar hex_digits[16] =
+ { '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+
+ return hex_digits[oct & 0xF];
}
static inline char *
byte_to_hex(char *out, guint32 dword) {
- *out++ = low_nibble_of_octet_to_hex(dword >> 4);
- *out++ = low_nibble_of_octet_to_hex(dword);
- return out;
+ *out++ = low_nibble_of_octet_to_hex(dword >> 4);
+ *out++ = low_nibble_of_octet_to_hex(dword);
+ return out;
}
char *
word_to_hex(char *out, guint16 word) {
- out = byte_to_hex(out, word >> 8);
- out = byte_to_hex(out, word);
- return out;
+ out = byte_to_hex(out, word >> 8);
+ out = byte_to_hex(out, word);
+ return out;
}
char *
char *
dword_to_hex(char *out, guint32 dword) {
- out = byte_to_hex(out, dword >> 24);
- out = byte_to_hex(out, dword >> 16);
- out = byte_to_hex(out, dword >> 8);
- out = byte_to_hex(out, dword);
- return out;
+ out = byte_to_hex(out, dword >> 24);
+ out = byte_to_hex(out, dword >> 16);
+ out = byte_to_hex(out, dword >> 8);
+ out = byte_to_hex(out, dword);
+ return out;
}
char *
dword_to_hex_punct(char *out, guint32 dword, char punct) {
- out = byte_to_hex(out, dword >> 24);
- *out++ = punct;
- out = byte_to_hex(out, dword >> 16);
- *out++ = punct;
- out = byte_to_hex(out, dword >> 8);
- *out++ = punct;
- out = byte_to_hex(out, dword);
- return out;
+ out = byte_to_hex(out, dword >> 24);
+ *out++ = punct;
+ out = byte_to_hex(out, dword >> 16);
+ *out++ = punct;
+ out = byte_to_hex(out, dword >> 8);
+ *out++ = punct;
+ out = byte_to_hex(out, dword);
+ return out;
}
/*
*/
char *
bytes_to_hexstr(char *out, const guint8 *ad, guint32 len) {
- guint32 i;
+ guint32 i;
- if (!ad)
- REPORT_DISSECTOR_BUG("Null pointer passed to bytes_to_hexstr()");
+ if (!ad)
+ REPORT_DISSECTOR_BUG("Null pointer passed to bytes_to_hexstr()");
- for (i = 0; i < len; i++)
- out = byte_to_hex(out, ad[i]);
- return out;
+ for (i = 0; i < len; i++)
+ out = byte_to_hex(out, ad[i]);
+ return out;
}
/*
*/
char *
bytes_to_hexstr_punct(char *out, const guint8 *ad, guint32 len, char punct) {
- guint32 i;
+ guint32 i;
- if (!ad)
- REPORT_DISSECTOR_BUG("Null pointer passed to bytes_to_hexstr_punct()");
+ if (!ad)
+ REPORT_DISSECTOR_BUG("Null pointer passed to bytes_to_hexstr_punct()");
- out = byte_to_hex(out, ad[0]);
- for (i = 1; i < len; i++) {
- *out++ = punct;
- out = byte_to_hex(out, ad[i]);
- }
- return out;
+ out = byte_to_hex(out, ad[0]);
+ for (i = 1; i < len; i++) {
+ *out++ = punct;
+ out = byte_to_hex(out, ad[i]);
+ }
+ return out;
}
/* Routine to convert a sequence of bytes to a hex string, one byte/two hex
*/
const gchar *
bytestring_to_str(const guint8 *ad, const guint32 len, const char punct) {
- gchar *buf;
- size_t buflen;
+ gchar *buf;
+ size_t buflen;
- if (!ad)
- REPORT_DISSECTOR_BUG("Null pointer passed to bytestring_to_str()");
+ if (!ad)
+ REPORT_DISSECTOR_BUG("Null pointer passed to bytestring_to_str()");
- /* XXX, Old code was using int as iterator... Why len is guint32 anyway?! (darkjames) */
- if ( ((int) len) < 0)
- return "";
+ /* XXX, Old code was using int as iterator... Why len is guint32 anyway?! (darkjames) */
+ if ( ((int) len) < 0)
+ return "";
- if (!len)
- return "";
+ if (!len)
+ return "";
- if (punct)
- buflen=len*3;
- else
- buflen=len*2 + 1;
+ if (punct)
+ buflen=len*3;
+ else
+ buflen=len*2 + 1;
- buf=(gchar *)ep_alloc(buflen);
+ buf=(gchar *)ep_alloc(buflen);
- if (punct)
- bytes_to_hexstr_punct(buf, ad, len, punct);
- else
- bytes_to_hexstr(buf, ad, len);
+ if (punct)
+ bytes_to_hexstr_punct(buf, ad, len, punct);
+ else
+ bytes_to_hexstr(buf, ad, len);
- buf[buflen-1] = '\0';
- return buf;
+ buf[buflen-1] = '\0';
+ return buf;
}
/* Max string length for displaying byte string. */
gchar *
bytes_to_str(const guint8 *bd, int bd_len) {
- gchar *cur;
- gchar *cur_ptr;
- int truncated = 0;
+ gchar *cur;
+ gchar *cur_ptr;
+ int truncated = 0;
- if (!bd)
- REPORT_DISSECTOR_BUG("Null pointer passed to bytes_to_str()");
+ if (!bd)
+ REPORT_DISSECTOR_BUG("Null pointer passed to bytes_to_str()");
- cur=(gchar *)ep_alloc(MAX_BYTE_STR_LEN+3+1);
- if (bd_len <= 0) { cur[0] = '\0'; return cur; }
+ cur=(gchar *)ep_alloc(MAX_BYTE_STR_LEN+3+1);
+ if (bd_len <= 0) { cur[0] = '\0'; return cur; }
- if (bd_len > MAX_BYTE_STR_LEN/2) { /* bd_len > 24 */
- truncated = 1;
- bd_len = MAX_BYTE_STR_LEN/2;
- }
+ if (bd_len > MAX_BYTE_STR_LEN/2) { /* bd_len > 24 */
+ truncated = 1;
+ bd_len = MAX_BYTE_STR_LEN/2;
+ }
- cur_ptr = bytes_to_hexstr(cur, bd, bd_len); /* max MAX_BYTE_STR_LEN bytes */
+ cur_ptr = bytes_to_hexstr(cur, bd, bd_len); /* max MAX_BYTE_STR_LEN bytes */
- if (truncated)
- cur_ptr = g_stpcpy(cur_ptr, "..."); /* 3 bytes */
+ if (truncated)
+ cur_ptr = g_stpcpy(cur_ptr, "..."); /* 3 bytes */
- *cur_ptr = '\0'; /* 1 byte */
- return cur;
+ *cur_ptr = '\0'; /* 1 byte */
+ return cur;
}
/* Turn an array of bytes into a string showing the bytes in hex with
*/
gchar *
bytes_to_str_punct(const guint8 *bd, int bd_len, gchar punct) {
- gchar *cur;
- gchar *cur_ptr;
- int truncated = 0;
+ gchar *cur;
+ gchar *cur_ptr;
+ int truncated = 0;
- if (!punct)
- return bytes_to_str(bd, bd_len);
+ if (!punct)
+ return bytes_to_str(bd, bd_len);
- cur=(gchar *)ep_alloc(MAX_BYTE_STR_LEN+3+1);
- if (bd_len <= 0) { cur[0] = '\0'; return cur; }
+ cur=(gchar *)ep_alloc(MAX_BYTE_STR_LEN+3+1);
+ if (bd_len <= 0) { cur[0] = '\0'; return cur; }
- if (bd_len > MAX_BYTE_STR_LEN/3) { /* bd_len > 16 */
- truncated = 1;
- bd_len = MAX_BYTE_STR_LEN/3;
- }
+ if (bd_len > MAX_BYTE_STR_LEN/3) { /* bd_len > 16 */
+ truncated = 1;
+ bd_len = MAX_BYTE_STR_LEN/3;
+ }
- cur_ptr = bytes_to_hexstr_punct(cur, bd, bd_len, punct); /* max MAX_BYTE_STR_LEN-1 bytes */
+ cur_ptr = bytes_to_hexstr_punct(cur, bd, bd_len, punct); /* max MAX_BYTE_STR_LEN-1 bytes */
- if (truncated) {
- *cur_ptr++ = punct; /* 1 byte */
- cur_ptr = g_stpcpy(cur_ptr, "..."); /* 3 bytes */
- }
+ if (truncated) {
+ *cur_ptr++ = punct; /* 1 byte */
+ cur_ptr = g_stpcpy(cur_ptr, "..."); /* 3 bytes */
+ }
- *cur_ptr = '\0';
- return cur;
+ *cur_ptr = '\0';
+ return cur;
}
static int
guint32_to_str_buf_len(const guint32 u) {
- if (u >= 1000000000)return 10;
- if (u >= 100000000) return 9;
- if (u >= 10000000) return 8;
- if (u >= 1000000) return 7;
- if (u >= 100000) return 6;
- if (u >= 10000) return 5;
- if (u >= 1000) return 4;
- if (u >= 100) return 3;
- if (u >= 10) return 2;
-
- return 1;
+ if (u >= 1000000000)return 10;
+ if (u >= 100000000) return 9;
+ if (u >= 10000000) return 8;
+ if (u >= 1000000) return 7;
+ if (u >= 100000) return 6;
+ if (u >= 10000) return 5;
+ if (u >= 1000) return 4;
+ if (u >= 100) return 3;
+ if (u >= 10) return 2;
+
+ return 1;
}
static const char fast_strings[][4] = {
-"0", "1", "2", "3", "4", "5", "6", "7",
-"8", "9", "10", "11", "12", "13", "14", "15",
-"16", "17", "18", "19", "20", "21", "22", "23",
-"24", "25", "26", "27", "28", "29", "30", "31",
-"32", "33", "34", "35", "36", "37", "38", "39",
-"40", "41", "42", "43", "44", "45", "46", "47",
-"48", "49", "50", "51", "52", "53", "54", "55",
-"56", "57", "58", "59", "60", "61", "62", "63",
-"64", "65", "66", "67", "68", "69", "70", "71",
-"72", "73", "74", "75", "76", "77", "78", "79",
-"80", "81", "82", "83", "84", "85", "86", "87",
-"88", "89", "90", "91", "92", "93", "94", "95",
-"96", "97", "98", "99", "100", "101", "102", "103",
-"104", "105", "106", "107", "108", "109", "110", "111",
-"112", "113", "114", "115", "116", "117", "118", "119",
-"120", "121", "122", "123", "124", "125", "126", "127",
-"128", "129", "130", "131", "132", "133", "134", "135",
-"136", "137", "138", "139", "140", "141", "142", "143",
-"144", "145", "146", "147", "148", "149", "150", "151",
-"152", "153", "154", "155", "156", "157", "158", "159",
-"160", "161", "162", "163", "164", "165", "166", "167",
-"168", "169", "170", "171", "172", "173", "174", "175",
-"176", "177", "178", "179", "180", "181", "182", "183",
-"184", "185", "186", "187", "188", "189", "190", "191",
-"192", "193", "194", "195", "196", "197", "198", "199",
-"200", "201", "202", "203", "204", "205", "206", "207",
-"208", "209", "210", "211", "212", "213", "214", "215",
-"216", "217", "218", "219", "220", "221", "222", "223",
-"224", "225", "226", "227", "228", "229", "230", "231",
-"232", "233", "234", "235", "236", "237", "238", "239",
-"240", "241", "242", "243", "244", "245", "246", "247",
-"248", "249", "250", "251", "252", "253", "254", "255"
+ "0", "1", "2", "3", "4", "5", "6", "7",
+ "8", "9", "10", "11", "12", "13", "14", "15",
+ "16", "17", "18", "19", "20", "21", "22", "23",
+ "24", "25", "26", "27", "28", "29", "30", "31",
+ "32", "33", "34", "35", "36", "37", "38", "39",
+ "40", "41", "42", "43", "44", "45", "46", "47",
+ "48", "49", "50", "51", "52", "53", "54", "55",
+ "56", "57", "58", "59", "60", "61", "62", "63",
+ "64", "65", "66", "67", "68", "69", "70", "71",
+ "72", "73", "74", "75", "76", "77", "78", "79",
+ "80", "81", "82", "83", "84", "85", "86", "87",
+ "88", "89", "90", "91", "92", "93", "94", "95",
+ "96", "97", "98", "99", "100", "101", "102", "103",
+ "104", "105", "106", "107", "108", "109", "110", "111",
+ "112", "113", "114", "115", "116", "117", "118", "119",
+ "120", "121", "122", "123", "124", "125", "126", "127",
+ "128", "129", "130", "131", "132", "133", "134", "135",
+ "136", "137", "138", "139", "140", "141", "142", "143",
+ "144", "145", "146", "147", "148", "149", "150", "151",
+ "152", "153", "154", "155", "156", "157", "158", "159",
+ "160", "161", "162", "163", "164", "165", "166", "167",
+ "168", "169", "170", "171", "172", "173", "174", "175",
+ "176", "177", "178", "179", "180", "181", "182", "183",
+ "184", "185", "186", "187", "188", "189", "190", "191",
+ "192", "193", "194", "195", "196", "197", "198", "199",
+ "200", "201", "202", "203", "204", "205", "206", "207",
+ "208", "209", "210", "211", "212", "213", "214", "215",
+ "216", "217", "218", "219", "220", "221", "222", "223",
+ "224", "225", "226", "227", "228", "229", "230", "231",
+ "232", "233", "234", "235", "236", "237", "238", "239",
+ "240", "241", "242", "243", "244", "245", "246", "247",
+ "248", "249", "250", "251", "252", "253", "254", "255"
};
void
guint32_to_str_buf(guint32 u, gchar *buf, int buf_len) {
- int str_len = guint32_to_str_buf_len(u)+1;
+ int str_len = guint32_to_str_buf_len(u)+1;
- gchar *bp = &buf[str_len];
+ gchar *bp = &buf[str_len];
- if (buf_len < str_len) {
- g_strlcpy(buf, BUF_TOO_SMALL_ERR, buf_len); /* Let the unexpected value alert user */
- return;
- }
+ if (buf_len < str_len) {
+ g_strlcpy(buf, BUF_TOO_SMALL_ERR, buf_len); /* Let the unexpected value alert user */
+ return;
+ }
- *--bp = '\0';
+ *--bp = '\0';
- uint_to_str_back(bp, u);
+ uint_to_str_back(bp, u);
}
gchar *
guint32_to_str(const guint32 u) {
- int str_len = 16; /* guint32_to_str_buf_len(u)+1; */
+ int str_len = 16; /* guint32_to_str_buf_len(u)+1; */
- gchar *bp = (gchar *)ep_alloc(str_len);
- guint32_to_str_buf(u, bp, str_len);
+ gchar *bp = (gchar *)ep_alloc(str_len);
+ guint32_to_str_buf(u, bp, str_len);
- return bp;
+ return bp;
}
#define PLURALIZE(n) (((n) > 1) ? "s" : "")
*/
static void
time_secs_to_str_buf(gint32 time_val, const guint32 frac, const gboolean is_nsecs,
- emem_strbuf_t *buf)
+ emem_strbuf_t *buf)
{
- int hours, mins, secs;
- const gchar *msign = "";
- gboolean do_comma = FALSE;
-
- if(time_val == G_MININT32) { /* That Which Shall Not Be Negated */
- ep_strbuf_append_printf(buf, "Unable to cope with time value %d", time_val);
- return;
- }
-
- if(time_val < 0){
- time_val = -time_val;
- msign = "-";
- }
-
- 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) {
- ep_strbuf_append_printf(buf, "%s%u day%s", msign, time_val, PLURALIZE(time_val));
- do_comma = TRUE;
- msign="";
- }
- if (hours != 0) {
- ep_strbuf_append_printf(buf, "%s%s%u hour%s", COMMA(do_comma), msign, hours, PLURALIZE(hours));
- do_comma = TRUE;
- msign="";
- }
- if (mins != 0) {
- ep_strbuf_append_printf(buf, "%s%s%u minute%s", COMMA(do_comma), msign, mins, PLURALIZE(mins));
- do_comma = TRUE;
- msign="";
- }
- if (secs != 0 || frac != 0) {
- if (frac != 0) {
- if (is_nsecs)
- ep_strbuf_append_printf(buf, "%s%s%u.%09u seconds", COMMA(do_comma), msign, secs, frac);
- else
- ep_strbuf_append_printf(buf, "%s%s%u.%03u seconds", COMMA(do_comma), msign, secs, frac);
- } else
- ep_strbuf_append_printf(buf, "%s%s%u second%s", COMMA(do_comma), msign, secs, PLURALIZE(secs));
- }
+ int hours, mins, secs;
+ const gchar *msign = "";
+ gboolean do_comma = FALSE;
+
+ if(time_val == G_MININT32) { /* That Which Shall Not Be Negated */
+ ep_strbuf_append_printf(buf, "Unable to cope with time value %d", time_val);
+ return;
+ }
+
+ if(time_val < 0){
+ time_val = -time_val;
+ msign = "-";
+ }
+
+ 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) {
+ ep_strbuf_append_printf(buf, "%s%u day%s", msign, time_val, PLURALIZE(time_val));
+ do_comma = TRUE;
+ msign="";
+ }
+ if (hours != 0) {
+ ep_strbuf_append_printf(buf, "%s%s%u hour%s", COMMA(do_comma), msign, hours, PLURALIZE(hours));
+ do_comma = TRUE;
+ msign="";
+ }
+ if (mins != 0) {
+ ep_strbuf_append_printf(buf, "%s%s%u minute%s", COMMA(do_comma), msign, mins, PLURALIZE(mins));
+ do_comma = TRUE;
+ msign="";
+ }
+ if (secs != 0 || frac != 0) {
+ if (frac != 0) {
+ if (is_nsecs)
+ ep_strbuf_append_printf(buf, "%s%s%u.%09u seconds", COMMA(do_comma), msign, secs, frac);
+ else
+ ep_strbuf_append_printf(buf, "%s%s%u.%03u seconds", COMMA(do_comma), msign, secs, frac);
+ } else
+ ep_strbuf_append_printf(buf, "%s%s%u second%s", COMMA(do_comma), msign, secs, PLURALIZE(secs));
+ }
}
gchar *
time_secs_to_str(const gint32 time_val)
{
- emem_strbuf_t *buf;
+ emem_strbuf_t *buf;
- buf=ep_strbuf_sized_new(TIME_SECS_LEN+1, TIME_SECS_LEN+1);
+ buf=ep_strbuf_sized_new(TIME_SECS_LEN+1, TIME_SECS_LEN+1);
- if (time_val == 0) {
- ep_strbuf_append(buf, "0 seconds");
- return buf->str;
- }
+ if (time_val == 0) {
+ ep_strbuf_append(buf, "0 seconds");
+ return buf->str;
+ }
- time_secs_to_str_buf(time_val, 0, FALSE, buf);
- return buf->str;
+ time_secs_to_str_buf(time_val, 0, FALSE, buf);
+ return buf->str;
}
static void
time_secs_to_str_buf_unsigned(guint32 time_val, const guint32 frac, const gboolean is_nsecs,
- emem_strbuf_t *buf)
+ emem_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) {
- ep_strbuf_append_printf(buf, "%u day%s", time_val, PLURALIZE(time_val));
- do_comma = TRUE;
- }
- if (hours != 0) {
- ep_strbuf_append_printf(buf, "%s%u hour%s", COMMA(do_comma), hours, PLURALIZE(hours));
- do_comma = TRUE;
- }
- if (mins != 0) {
- ep_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)
- ep_strbuf_append_printf(buf, "%s%u.%09u seconds", COMMA(do_comma), secs, frac);
- else
- ep_strbuf_append_printf(buf, "%s%u.%03u seconds", COMMA(do_comma), secs, frac);
- } else
- ep_strbuf_append_printf(buf, "%s%u second%s", COMMA(do_comma), secs, PLURALIZE(secs));
- }
+ 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) {
+ ep_strbuf_append_printf(buf, "%u day%s", time_val, PLURALIZE(time_val));
+ do_comma = TRUE;
+ }
+ if (hours != 0) {
+ ep_strbuf_append_printf(buf, "%s%u hour%s", COMMA(do_comma), hours, PLURALIZE(hours));
+ do_comma = TRUE;
+ }
+ if (mins != 0) {
+ ep_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)
+ ep_strbuf_append_printf(buf, "%s%u.%09u seconds", COMMA(do_comma), secs, frac);
+ else
+ ep_strbuf_append_printf(buf, "%s%u.%03u seconds", COMMA(do_comma), secs, frac);
+ } else
+ ep_strbuf_append_printf(buf, "%s%u second%s", COMMA(do_comma), secs, PLURALIZE(secs));
+ }
}
gchar *
time_secs_to_str_unsigned(const guint32 time_val)
{
- emem_strbuf_t *buf;
+ emem_strbuf_t *buf;
- buf=ep_strbuf_sized_new(TIME_SECS_LEN+1, TIME_SECS_LEN+1);
+ buf=ep_strbuf_sized_new(TIME_SECS_LEN+1, TIME_SECS_LEN+1);
- if (time_val == 0) {
- ep_strbuf_append(buf, "0 seconds");
- return buf->str;
- }
+ if (time_val == 0) {
+ ep_strbuf_append(buf, "0 seconds");
+ return buf->str;
+ }
- time_secs_to_str_buf_unsigned(time_val, 0, FALSE, buf);
- return buf->str;
+ time_secs_to_str_buf_unsigned(time_val, 0, FALSE, buf);
+ return buf->str;
}
gchar *
time_msecs_to_str(gint32 time_val)
{
- emem_strbuf_t *buf;
- int msecs;
-
- buf=ep_strbuf_sized_new(TIME_SECS_LEN+1+3+1, TIME_SECS_LEN+1+3+1);
-
- if (time_val == 0) {
- ep_strbuf_append(buf, "0 seconds");
- return buf->str;
- }
-
- 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;
- }
-
- time_secs_to_str_buf(time_val, msecs, FALSE, buf);
- return buf->str;
+ emem_strbuf_t *buf;
+ int msecs;
+
+ buf=ep_strbuf_sized_new(TIME_SECS_LEN+1+3+1, TIME_SECS_LEN+1+3+1);
+
+ if (time_val == 0) {
+ ep_strbuf_append(buf, "0 seconds");
+ return buf->str;
+ }
+
+ 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;
+ }
+
+ time_secs_to_str_buf(time_val, msecs, FALSE, buf);
+ return buf->str;
}
static const char mon_names[12][4] = {
/* ("which is not necessarily the same as the C library locale"). */
/* So: _tzname must be converted to UTF8 before use. */
/* Alternative: use Windows GetTimeZoneInformation() to get the */
- /* timezone name in UTF16 and convert same to UTF8. */
+ /* timezone name in UTF16 and convert same to UTF8. */
/* XXX: the result is that the timezone name will be based upon the */
/* system code page (iow: the charset of the system). */
/* Since Wireshark is not internationalized, it would seem more */
/* correct to show the timezone name in English, no matter what */
- /* the system code page, but I don't how to do that (or if it's */
- /* really even possible). */
- /* In any case converting to UTF8 presumably at least keeps GTK */
- /* happy. (A bug was reported wherein Wireshark crashed in GDK */
- /* on a "Japanese version of Windows XP" when trying to copy */
- /* the date/time string (containing a copy of _tz_name) to the */
- /* clipboard). */
+ /* the system code page, but I don't how to do that (or if it's */
+ /* really even possible). */
+ /* In any case converting to UTF8 presumably at least keeps GTK */
+ /* happy. (A bug was reported wherein Wireshark crashed in GDK */
+ /* on a "Japanese version of Windows XP" when trying to copy */
+ /* the date/time string (containing a copy of _tz_name) to the */
+ /* clipboard). */
{
static char *ws_tzname[2] = {NULL, NULL};
gchar *
abs_time_to_str(const nstime_t *abs_time, const absolute_time_display_e fmt,
- gboolean show_zone)
+ gboolean show_zone)
{
- struct tm *tmp = NULL;
- const char *zonename = "???";
- gchar *buf = NULL;
+ struct tm *tmp = NULL;
+ const char *zonename = "???";
+ gchar *buf = NULL;
#if (defined _WIN32) && (_MSC_VER < 1500)
- /* calling localtime() on MSVC 2005 with huge values causes it to crash */
- /* XXX - find the exact value that still does work */
- /* XXX - using _USE_32BIT_TIME_T might be another way to circumvent this problem */
- if(abs_time->secs > 2000000000) {
- tmp = NULL;
- } else
+ /* calling localtime() on MSVC 2005 with huge values causes it to crash */
+ /* XXX - find the exact value that still does work */
+ /* XXX - using _USE_32BIT_TIME_T might be another way to circumvent this problem */
+ if(abs_time->secs > 2000000000) {
+ tmp = NULL;
+ } else
#endif
- switch (fmt) {
-
- case ABSOLUTE_TIME_UTC:
- case ABSOLUTE_TIME_DOY_UTC:
- tmp = gmtime(&abs_time->secs);
- zonename = "UTC";
- break;
-
- case ABSOLUTE_TIME_LOCAL:
- tmp = localtime(&abs_time->secs);
- if (tmp) {
- zonename = get_zonename(tmp);
- }
- break;
- }
- if (tmp) {
- switch (fmt) {
-
- case ABSOLUTE_TIME_DOY_UTC:
- if (show_zone) {
- buf = ep_strdup_printf("%04d/%03d:%02d:%02d:%02d.%09ld %s",
- tmp->tm_year + 1900,
- tmp->tm_yday + 1,
- tmp->tm_hour,
- tmp->tm_min,
- tmp->tm_sec,
- (long)abs_time->nsecs,
- zonename);
- } else {
- buf = ep_strdup_printf("%04d/%03d:%02d:%02d:%02d.%09ld",
- tmp->tm_year + 1900,
- tmp->tm_yday + 1,
- tmp->tm_hour,
- tmp->tm_min,
- tmp->tm_sec,
- (long)abs_time->nsecs);
- }
- break;
-
- case ABSOLUTE_TIME_UTC:
- case ABSOLUTE_TIME_LOCAL:
- if (show_zone) {
- buf = ep_strdup_printf("%s %2d, %d %02d:%02d:%02d.%09ld %s",
- mon_names[tmp->tm_mon],
- tmp->tm_mday,
- tmp->tm_year + 1900,
- tmp->tm_hour,
- tmp->tm_min,
- tmp->tm_sec,
- (long)abs_time->nsecs,
- zonename);
- } else {
- buf = ep_strdup_printf("%s %2d, %d %02d:%02d:%02d.%09ld",
- mon_names[tmp->tm_mon],
- tmp->tm_mday,
- tmp->tm_year + 1900,
- tmp->tm_hour,
- tmp->tm_min,
- tmp->tm_sec,
- (long)abs_time->nsecs);
- }
- break;
- }
- } else
- buf = ep_strdup("Not representable");
- return buf;
+ switch (fmt) {
+
+ case ABSOLUTE_TIME_UTC:
+ case ABSOLUTE_TIME_DOY_UTC:
+ tmp = gmtime(&abs_time->secs);
+ zonename = "UTC";
+ break;
+
+ case ABSOLUTE_TIME_LOCAL:
+ tmp = localtime(&abs_time->secs);
+ if (tmp) {
+ zonename = get_zonename(tmp);
+ }
+ break;
+ }
+ if (tmp) {
+ switch (fmt) {
+
+ case ABSOLUTE_TIME_DOY_UTC:
+ if (show_zone) {
+ buf = ep_strdup_printf("%04d/%03d:%02d:%02d:%02d.%09ld %s",
+ tmp->tm_year + 1900,
+ tmp->tm_yday + 1,
+ tmp->tm_hour,
+ tmp->tm_min,
+ tmp->tm_sec,
+ (long)abs_time->nsecs,
+ zonename);
+ } else {
+ buf = ep_strdup_printf("%04d/%03d:%02d:%02d:%02d.%09ld",
+ tmp->tm_year + 1900,
+ tmp->tm_yday + 1,
+ tmp->tm_hour,
+ tmp->tm_min,
+ tmp->tm_sec,
+ (long)abs_time->nsecs);
+ }
+ break;
+
+ case ABSOLUTE_TIME_UTC:
+ case ABSOLUTE_TIME_LOCAL:
+ if (show_zone) {
+ buf = ep_strdup_printf("%s %2d, %d %02d:%02d:%02d.%09ld %s",
+ mon_names[tmp->tm_mon],
+ tmp->tm_mday,
+ tmp->tm_year + 1900,
+ tmp->tm_hour,
+ tmp->tm_min,
+ tmp->tm_sec,
+ (long)abs_time->nsecs,
+ zonename);
+ } else {
+ buf = ep_strdup_printf("%s %2d, %d %02d:%02d:%02d.%09ld",
+ mon_names[tmp->tm_mon],
+ tmp->tm_mday,
+ tmp->tm_year + 1900,
+ tmp->tm_hour,
+ tmp->tm_min,
+ tmp->tm_sec,
+ (long)abs_time->nsecs);
+ }
+ break;
+ }
+ } else
+ buf = ep_strdup("Not representable");
+ return buf;
}
gchar *
abs_time_secs_to_str(const time_t abs_time, const absolute_time_display_e fmt,
- gboolean show_zone)
+ gboolean show_zone)
{
- struct tm *tmp = NULL;
- const char *zonename = "???";
- gchar *buf = NULL;
+ struct tm *tmp = NULL;
+ const char *zonename = "???";
+ gchar *buf = NULL;
#if (defined _WIN32) && (_MSC_VER < 1500)
- /* calling localtime() on MSVC 2005 with huge values causes it to crash */
- /* XXX - find the exact value that still does work */
- /* XXX - using _USE_32BIT_TIME_T might be another way to circumvent this problem */
- if(abs_time > 2000000000) {
- tmp = NULL;
- } else
+ /* calling localtime() on MSVC 2005 with huge values causes it to crash */
+ /* XXX - find the exact value that still does work */
+ /* XXX - using _USE_32BIT_TIME_T might be another way to circumvent this problem */
+ if(abs_time > 2000000000) {
+ tmp = NULL;
+ } else
#endif
- switch (fmt) {
-
- case ABSOLUTE_TIME_UTC:
- case ABSOLUTE_TIME_DOY_UTC:
- tmp = gmtime(&abs_time);
- zonename = "UTC";
- break;
-
- case ABSOLUTE_TIME_LOCAL:
- tmp = localtime(&abs_time);
- if (tmp) {
- zonename = get_zonename(tmp);
- }
- break;
- }
- if (tmp) {
- switch (fmt) {
-
- case ABSOLUTE_TIME_DOY_UTC:
- if (show_zone) {
- buf = ep_strdup_printf("%04d/%03d:%02d:%02d:%02d %s",
- tmp->tm_year + 1900,
- tmp->tm_yday + 1,
- tmp->tm_hour,
- tmp->tm_min,
- tmp->tm_sec,
- zonename);
- } else {
- buf = ep_strdup_printf("%04d/%03d:%02d:%02d:%02d",
- tmp->tm_year + 1900,
- tmp->tm_yday + 1,
- tmp->tm_hour,
- tmp->tm_min,
- tmp->tm_sec);
- }
- break;
-
- case ABSOLUTE_TIME_UTC:
- case ABSOLUTE_TIME_LOCAL:
- if (show_zone) {
- buf = ep_strdup_printf("%s %2d, %d %02d:%02d:%02d %s",
- mon_names[tmp->tm_mon],
- tmp->tm_mday,
- tmp->tm_year + 1900,
- tmp->tm_hour,
- tmp->tm_min,
- tmp->tm_sec,
- zonename);
- } else {
- buf = ep_strdup_printf("%s %2d, %d %02d:%02d:%02d",
- mon_names[tmp->tm_mon],
- tmp->tm_mday,
- tmp->tm_year + 1900,
- tmp->tm_hour,
- tmp->tm_min,
- tmp->tm_sec);
- }
- break;
- }
- } else
- buf = ep_strdup("Not representable");
- return buf;
+ switch (fmt) {
+
+ case ABSOLUTE_TIME_UTC:
+ case ABSOLUTE_TIME_DOY_UTC:
+ tmp = gmtime(&abs_time);
+ zonename = "UTC";
+ break;
+
+ case ABSOLUTE_TIME_LOCAL:
+ tmp = localtime(&abs_time);
+ if (tmp) {
+ zonename = get_zonename(tmp);
+ }
+ break;
+ }
+ if (tmp) {
+ switch (fmt) {
+
+ case ABSOLUTE_TIME_DOY_UTC:
+ if (show_zone) {
+ buf = ep_strdup_printf("%04d/%03d:%02d:%02d:%02d %s",
+ tmp->tm_year + 1900,
+ tmp->tm_yday + 1,
+ tmp->tm_hour,
+ tmp->tm_min,
+ tmp->tm_sec,
+ zonename);
+ } else {
+ buf = ep_strdup_printf("%04d/%03d:%02d:%02d:%02d",
+ tmp->tm_year + 1900,
+ tmp->tm_yday + 1,
+ tmp->tm_hour,
+ tmp->tm_min,
+ tmp->tm_sec);
+ }
+ break;
+
+ case ABSOLUTE_TIME_UTC:
+ case ABSOLUTE_TIME_LOCAL:
+ if (show_zone) {
+ buf = ep_strdup_printf("%s %2d, %d %02d:%02d:%02d %s",
+ mon_names[tmp->tm_mon],
+ tmp->tm_mday,
+ tmp->tm_year + 1900,
+ tmp->tm_hour,
+ tmp->tm_min,
+ tmp->tm_sec,
+ zonename);
+ } else {
+ buf = ep_strdup_printf("%s %2d, %d %02d:%02d:%02d",
+ mon_names[tmp->tm_mon],
+ tmp->tm_mday,
+ tmp->tm_year + 1900,
+ tmp->tm_hour,
+ tmp->tm_min,
+ tmp->tm_sec);
+ }
+ break;
+ }
+ } else
+ buf = ep_strdup("Not representable");
+ return buf;
}
void
display_signed_time(gchar *buf, int buflen, const gint32 sec, gint32 frac,
- const to_str_time_res_t units)
+ const to_str_time_res_t units)
{
/* If the fractional part of the time stamp is negative,
print its absolute value and, if the seconds part isn't
frac = -frac;
if (sec >= 0) {
if (buflen < 1) {
- return;
+ return;
}
buf[0] = '-';
buf++;
}
switch (units) {
- case TO_STR_TIME_RES_T_SECS:
- g_snprintf(buf, buflen, "%d", sec);
- break;
+ case TO_STR_TIME_RES_T_SECS:
+ g_snprintf(buf, buflen, "%d", sec);
+ break;
- case TO_STR_TIME_RES_T_DSECS:
- g_snprintf(buf, buflen, "%d.%01d", sec, frac);
- break;
+ case TO_STR_TIME_RES_T_DSECS:
+ g_snprintf(buf, buflen, "%d.%01d", sec, frac);
+ break;
- case TO_STR_TIME_RES_T_CSECS:
- g_snprintf(buf, buflen, "%d.%02d", sec, frac);
- break;
+ case TO_STR_TIME_RES_T_CSECS:
+ g_snprintf(buf, buflen, "%d.%02d", sec, frac);
+ break;
- case TO_STR_TIME_RES_T_MSECS:
- g_snprintf(buf, buflen, "%d.%03d", sec, frac);
- break;
+ case TO_STR_TIME_RES_T_MSECS:
+ g_snprintf(buf, buflen, "%d.%03d", sec, frac);
+ break;
- case TO_STR_TIME_RES_T_USECS:
- g_snprintf(buf, buflen, "%d.%06d", sec, frac);
- break;
+ case TO_STR_TIME_RES_T_USECS:
+ g_snprintf(buf, buflen, "%d.%06d", sec, frac);
+ break;
- case TO_STR_TIME_RES_T_NSECS:
- g_snprintf(buf, buflen, "%d.%09d", sec, frac);
- break;
+ case TO_STR_TIME_RES_T_NSECS:
+ g_snprintf(buf, buflen, "%d.%09d", sec, frac);
+ break;
}
}
void
display_epoch_time(gchar *buf, int buflen, const time_t sec, gint32 frac,
- const to_str_time_res_t units)
+ const to_str_time_res_t units)
{
double elapsed_secs;
frac = -frac;
if (elapsed_secs >= 0) {
if (buflen < 1) {
- return;
+ return;
}
buf[0] = '-';
buf++;
}
switch (units) {
- case TO_STR_TIME_RES_T_SECS:
- g_snprintf(buf, buflen, "%0.0f", elapsed_secs);
- break;
+ case TO_STR_TIME_RES_T_SECS:
+ g_snprintf(buf, buflen, "%0.0f", elapsed_secs);
+ break;
- case TO_STR_TIME_RES_T_DSECS:
- g_snprintf(buf, buflen, "%0.0f.%01d", elapsed_secs, frac);
- break;
+ case TO_STR_TIME_RES_T_DSECS:
+ g_snprintf(buf, buflen, "%0.0f.%01d", elapsed_secs, frac);
+ break;
- case TO_STR_TIME_RES_T_CSECS:
- g_snprintf(buf, buflen, "%0.0f.%02d", elapsed_secs, frac);
- break;
+ case TO_STR_TIME_RES_T_CSECS:
+ g_snprintf(buf, buflen, "%0.0f.%02d", elapsed_secs, frac);
+ break;
- case TO_STR_TIME_RES_T_MSECS:
- g_snprintf(buf, buflen, "%0.0f.%03d", elapsed_secs, frac);
- break;
+ case TO_STR_TIME_RES_T_MSECS:
+ g_snprintf(buf, buflen, "%0.0f.%03d", elapsed_secs, frac);
+ break;
- case TO_STR_TIME_RES_T_USECS:
- g_snprintf(buf, buflen, "%0.0f.%06d", elapsed_secs, frac);
- break;
+ case TO_STR_TIME_RES_T_USECS:
+ g_snprintf(buf, buflen, "%0.0f.%06d", elapsed_secs, frac);
+ break;
- case TO_STR_TIME_RES_T_NSECS:
- g_snprintf(buf, buflen, "%0.0f.%09d", elapsed_secs, frac);
- break;
+ case TO_STR_TIME_RES_T_NSECS:
+ g_snprintf(buf, buflen, "%0.0f.%09d", elapsed_secs, frac);
+ break;
}
}
gchar *
rel_time_to_secs_str(const nstime_t *rel_time)
{
- gchar *buf;
+ gchar *buf;
buf=(gchar *)ep_alloc(REL_TIME_SECS_LEN);
- display_signed_time(buf, REL_TIME_SECS_LEN, (gint32) rel_time->secs,
- rel_time->nsecs, TO_STR_TIME_RES_T_NSECS);
- return buf;
+ display_signed_time(buf, REL_TIME_SECS_LEN, (gint32) rel_time->secs,
+ rel_time->nsecs, TO_STR_TIME_RES_T_NSECS);
+ return buf;
}
/*
char *
other_decode_bitfield_value(char *buf, const guint32 val, const guint32 mask, const int width)
{
- int i;
- guint32 bit;
- char *p;
-
- i = 0;
- p = buf;
- bit = 1 << (width - 1);
- for (;;) {
- if (mask & bit) {
- /* This bit is part of the field. Show its value. */
- if (val & bit)
- *p++ = '1';
- else
- *p++ = '0';
- } else {
- /* This bit is not part of the field. */
- *p++ = '.';
- }
- bit >>= 1;
- i++;
- if (i >= width)
- break;
- if (i % 4 == 0)
- *p++ = ' ';
- }
- *p = '\0';
- return p;
+ int i;
+ guint32 bit;
+ char *p;
+
+ i = 0;
+ p = buf;
+ bit = 1 << (width - 1);
+ for (;;) {
+ if (mask & bit) {
+ /* This bit is part of the field. Show its value. */
+ if (val & bit)
+ *p++ = '1';
+ else
+ *p++ = '0';
+ } else {
+ /* This bit is not part of the field. */
+ *p++ = '.';
+ }
+ bit >>= 1;
+ i++;
+ if (i >= width)
+ break;
+ if (i % 4 == 0)
+ *p++ = ' ';
+ }
+ *p = '\0';
+ return p;
}
char *
decode_bitfield_value(char *buf, const guint32 val, const guint32 mask, const int width)
{
- char *p;
+ char *p;
- p = other_decode_bitfield_value(buf, val, mask, width);
- p = g_stpcpy(p, " = ");
+ p = other_decode_bitfield_value(buf, val, mask, width);
+ p = g_stpcpy(p, " = ");
- return p;
+ return p;
}
/* Generate a string describing a Boolean bitfield (a one-bit field that
says something is either true or false). */
const char *
decode_boolean_bitfield(const guint32 val, const guint32 mask, const int width,
- const char *truedesc, const char *falsedesc)
+ const char *truedesc, const char *falsedesc)
{
- char *buf;
- char *p;
-
- buf=(char *)ep_alloc(1025); /* is this a bit overkill? */
- p = decode_bitfield_value(buf, val, mask, width);
- if (val & mask)
- strcpy(p, truedesc);
- else
- strcpy(p, falsedesc);
- return buf;
+ char *buf;
+ char *p;
+
+ buf=(char *)ep_alloc(1025); /* is this a bit overkill? */
+ p = decode_bitfield_value(buf, val, mask, width);
+ if (val & mask)
+ strcpy(p, truedesc);
+ else
+ strcpy(p, falsedesc);
+ return buf;
}
/* Generate a string describing a numeric bitfield (an N-bit field whose
value is just a number). */
const char *
decode_numeric_bitfield(const guint32 val, const guint32 mask, const int width,
- const char *fmt)
+ const char *fmt)
{
- char *buf;
- char *p;
- int shift = 0;
-
- buf=(char *)ep_alloc(1025); /* isnt this a bit overkill? */
- /* Compute the number of bits we have to shift the bitfield right
- to extract its value. */
- while ((mask & (1<<shift)) == 0)
- shift++;
-
- p = decode_bitfield_value(buf, val, mask, width);
- g_snprintf(p, (gulong) (1025-(p-buf)), fmt, (val & mask) >> shift);
- return buf;
+ char *buf;
+ char *p;
+ int shift = 0;
+
+ buf=(char *)ep_alloc(1025); /* isnt this a bit overkill? */
+ /* Compute the number of bits we have to shift the bitfield right
+ to extract its value. */
+ while ((mask & (1<<shift)) == 0)
+ shift++;
+
+ p = decode_bitfield_value(buf, val, mask, width);
+ g_snprintf(p, (gulong) (1025-(p-buf)), fmt, (val & mask) >> shift);
+ return buf;
}
/*
- This function is very fast and this function is called a lot.
- XXX update the ep_address_to_str stuff to use this function.
-*/
+ This function is very fast and this function is called a lot.
+ XXX update the ep_address_to_str stuff to use this function.
+ */
void
ip_to_str_buf(const guint8 *ad, gchar *buf, const int buf_len)
{
}
gchar* guid_to_str(const e_guid_t *guid) {
- gchar *buf;
+ gchar *buf;
- buf=(gchar *)ep_alloc(GUID_STR_LEN);
- return guid_to_str_buf(guid, buf, GUID_STR_LEN);
+ buf=(gchar *)ep_alloc(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) {
- 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;
+ char *tempptr = buf;
+
+ if (buf_len < GUID_STR_LEN) {
+ 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) {
return ptr;
}
+/*
+ * Editor modelines - http://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 8
+ * tab-width: 8
+ * indent-tabs-mode: t
+ * End:
+ *
+ * vi: set shiftwidth=8 tabstop=8 noexpandtab:
+ * :indentSize=8:tabSize=8:noTabs=false:
+ */
git.samba.org / metze / wireshark / wip.git / commitdiff