From Jakub Zawadzki:

Optimizations.
https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=4303

svn path=/trunk/; revision=31967

6 files changed, 302 insertions, 234 deletions

diff --git a/epan/addr_resolv.c b/epan/addr_resolv.c
index e843d9b264..ed833010a1 100644
--- a/epan/addr_resolv.c
+++ b/epan/addr_resolv.c
@@ -637,7 +637,7 @@ static gchar *serv_name_lookup(guint port, port_type proto)
   if (!(g_resolv_flags & RESOLV_TRANSPORT) ||
       (servp = getservbyport(g_htons(port), serv_proto)) == NULL) {
     /* unknown port */
-    g_snprintf(tp->name, MAXNAMELEN, "%d", port);
+    guint32_to_str_buf(port, tp->name, MAXNAMELEN);
   } else {
     g_strlcpy(tp->name, servp->s_name, MAXNAMELEN);
   }
@@ -2615,12 +2615,8 @@ static gchar *ep_utoa(guint port)
 {
   gchar *bp = ep_alloc(MAXNAMELEN);
 
-  bp = &bp[MAXNAMELEN -1];
-
-  *bp = 0;
-  do {
-      *--bp = (port % 10) +'0';
-  } while ((port /= 10) != 0);
+  /* XXX, guint32_to_str() ? */
+  guint32_to_str_buf(port, bp, MAXNAMELEN);
   return bp;
 }
 
diff --git a/epan/column-utils.c b/epan/column-utils.c
index 9e04f45c35..6bc3f107f1 100644
--- a/epan/column-utils.c
+++ b/epan/column-utils.c
@@ -1157,8 +1157,6 @@ col_set_time(column_info *cinfo, gint el, nstime_t *ts, char *fieldname)
 static void
 col_set_addr(packet_info *pinfo, int col, address *addr, gboolean is_src, gboolean fill_col_exprs)
 {
-  struct e_in6_addr ipv6_addr;
-
   if (addr->type == AT_NONE) {
     pinfo->cinfo->col_data[col] = "";
     /* No address, nothing to do */
@@ -1182,7 +1180,7 @@ col_set_addr(packet_info *pinfo, int col, address *addr, gboolean is_src, gboole
       pinfo->cinfo->col_expr.col_expr[col] = "eth.src";
     else
       pinfo->cinfo->col_expr.col_expr[col] = "eth.dst";
-    g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], ether_to_str(addr->data), COL_MAX_LEN);
+    address_to_str_buf(addr, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
     break;
 
   case AT_IPv4:
@@ -1190,7 +1188,7 @@ col_set_addr(packet_info *pinfo, int col, address *addr, gboolean is_src, gboole
       pinfo->cinfo->col_expr.col_expr[col] = "ip.src";
     else
       pinfo->cinfo->col_expr.col_expr[col] = "ip.dst";
-    g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], ip_to_str(addr->data), COL_MAX_LEN);
+    ip_to_str_buf(addr->data, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
     break;
 
   case AT_IPv6:
@@ -1198,8 +1196,7 @@ col_set_addr(packet_info *pinfo, int col, address *addr, gboolean is_src, gboole
       pinfo->cinfo->col_expr.col_expr[col] = "ipv6.src";
     else
       pinfo->cinfo->col_expr.col_expr[col] = "ipv6.dst";
-    memcpy(&ipv6_addr.bytes, addr->data, sizeof ipv6_addr.bytes);
-    g_strlcpy(pinfo->cinfo->col_expr.col_expr_val[col], ip6_to_str(&ipv6_addr), COL_MAX_LEN);
+    address_to_str_buf(addr, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
     break;
 
   case AT_ATALK:
@@ -1249,11 +1246,11 @@ col_set_port(packet_info *pinfo, int col, gboolean is_res, gboolean is_src, gboo
     if (is_res)
       g_strlcpy(pinfo->cinfo->col_buf[col], get_sctp_port(port), COL_MAX_LEN);
     else
-      g_snprintf(pinfo->cinfo->col_buf[col], COL_MAX_LEN, "%u", port);
+      guint32_to_str_buf(port, pinfo->cinfo->col_buf[col], COL_MAX_LEN);
     break;
 
   case PT_TCP:
-    g_snprintf(pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN, "%u", port);
+    guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
     if (is_res)
       g_strlcpy(pinfo->cinfo->col_buf[col], get_tcp_port(port), COL_MAX_LEN);
     else
@@ -1265,7 +1262,7 @@ col_set_port(packet_info *pinfo, int col, gboolean is_res, gboolean is_src, gboo
     break;
 
   case PT_UDP:
-    g_snprintf(pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN, "%u", port);
+    guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
     if (is_res)
       g_strlcpy(pinfo->cinfo->col_buf[col], get_udp_port(port), COL_MAX_LEN);
     else
@@ -1281,7 +1278,7 @@ col_set_port(packet_info *pinfo, int col, gboolean is_res, gboolean is_src, gboo
       pinfo->cinfo->col_expr.col_expr[col] = "ddp.src_socket";
     else
       pinfo->cinfo->col_expr.col_expr[col] = "ddp.dst_socket";
-    g_snprintf(pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN, "%u", port);
+    guint32_to_str_buf(port, pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
     g_strlcpy(pinfo->cinfo->col_buf[col], pinfo->cinfo->col_expr.col_expr_val[col], COL_MAX_LEN);
     break;
 
@@ -1351,7 +1348,7 @@ col_fill_in_frame_data(frame_data *fd, column_info *cinfo, gint col, gboolean fi
     switch (cinfo->col_fmt[col]) {
 
     case COL_NUMBER:
-      g_snprintf(cinfo->col_buf[col], COL_MAX_LEN, "%u", fd->num);
+      guint32_to_str_buf(fd->num, cinfo->col_buf[col], COL_MAX_LEN);
       cinfo->col_data[col] = cinfo->col_buf[col];
       break;
 
@@ -1366,12 +1363,12 @@ col_fill_in_frame_data(frame_data *fd, column_info *cinfo, gint col, gboolean fi
       break;
 
     case COL_PACKET_LENGTH:
-      g_snprintf(cinfo->col_buf[col], COL_MAX_LEN, "%u", fd->pkt_len);
+      guint32_to_str_buf(fd->pkt_len, cinfo->col_buf[col], COL_MAX_LEN);
       cinfo->col_data[col] = cinfo->col_buf[col];
       break;
 
     case COL_CUMULATIVE_BYTES:
-      g_snprintf(cinfo->col_buf[col], COL_MAX_LEN, "%u", fd->cum_bytes);
+      guint32_to_str_buf(fd->cum_bytes, cinfo->col_buf[col], COL_MAX_LEN);
       cinfo->col_data[col] = cinfo->col_buf[col];
       break;
 
@@ -1508,7 +1505,7 @@ col_fill_in(packet_info *pinfo, gboolean fill_col_exprs, gboolean fill_fd_colums
       break;
 
     case COL_VSAN:
-      g_snprintf(pinfo->cinfo->col_buf[i], COL_MAX_LEN, "%u", pinfo->vsan);
+      guint32_to_str_buf(pinfo->vsan, pinfo->cinfo->col_buf[i], COL_MAX_LEN);
       pinfo->cinfo->col_data[i] = pinfo->cinfo->col_buf[i];
       break;
 
@@ -1715,7 +1712,7 @@ gchar  *ptr;
 
     switch (cinfo->col_fmt[col]) {
     case COL_NUMBER: /* frame number */
-      g_snprintf(buf, COL_MAX_LEN, "%u", fd->num);
+      guint32_to_str_buf(fd->num, buf, COL_MAX_LEN);
       break;
 
     case COL_CLS_TIME:
@@ -1738,11 +1735,11 @@ gchar  *ptr;
       break;
 
     case COL_PACKET_LENGTH: /* fd->pkt_len */
-      g_snprintf(buf, COL_MAX_LEN, "%u", fd->pkt_len);
+      guint32_to_str_buf(fd->pkt_len, buf, COL_MAX_LEN);
       break;
 
     case COL_CUMULATIVE_BYTES: /* fd->cum_bytes */
-      g_snprintf(buf, COL_MAX_LEN, "%u", fd->cum_bytes);
+      guint32_to_str_buf(fd->cum_bytes, buf, COL_MAX_LEN);
       break;
 
     case COL_DEF_SRC:
@@ -1790,7 +1787,7 @@ gchar  *ptr;
     case COL_UNRES_DST_PORT:
       /* hack */
       if (GPOINTER_TO_UINT(fd->col_text[col]) <= 65536)
-          g_snprintf(buf, COL_MAX_LEN, "%u", GPOINTER_TO_UINT(fd->col_text[col]));
+          guint32_to_str_buf(GPOINTER_TO_UINT(fd->col_text[col], buf, COL_MAX_LEN));
       else
           ptr = fd->col_text[col];
       break;
@@ -1803,7 +1800,7 @@ gchar  *ptr;
       break;
 
     case COL_VSAN:
-      g_snprintf(buf, COL_MAX_LEN, "%u", GPOINTER_TO_UINT(fd->col_text[col]));
+      guint32_to_str_buf(GPOINTER_TO_UINT(fd->col_text[col]), buf, COL_MAX_LEN);
       break;
 
     case NUM_COL_FMTS:  /* keep compiler happy - shouldn't get here */
diff --git a/epan/ftypes/ftype-integer.c b/epan/ftypes/ftype-integer.c
index a45169e10f..87d5888c65 100644
--- a/epan/ftypes/ftype-integer.c
+++ b/epan/ftypes/ftype-integer.c
@@ -115,7 +115,15 @@ integer_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
 static void
 integer_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
 {
-	sprintf(buf, "%d", fv->value.sinteger);
+	guint32 val;
+
+	if (fv->value.sinteger < 0) {
+		*buf++ = '-';
+		val = -fv->value.sinteger;
+	} else
+		val = fv->value.sinteger;
+
+	guint32_to_str_buf(val, buf, 11);
 }
 
 static int
@@ -127,7 +135,7 @@ uinteger_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
 static void
 uinteger_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
 {
-	sprintf(buf, "%u", fv->value.uinteger);
+	guint32_to_str_buf(fv->value.uinteger, buf, 11);
 }
 
 static gboolean
@@ -403,7 +411,8 @@ boolean_repr_len(fvalue_t *fv _U_, ftrepr_t rtype _U_)
 static void
 boolean_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, char *buf)
 {
-	sprintf(buf, "%s", fv->value.uinteger ? "1" : "0");
+	*buf++ = (fv->value.uinteger) ? '1' : '0';
+	*buf   = '\0';
 }
 
 /* Checks for equality with zero or non-zero */
diff --git a/epan/strutil.c b/epan/strutil.c
index eebbff38ed..ab0019cf8a 100644
--- a/epan/strutil.c
+++ b/epan/strutil.c
@@ -370,49 +370,6 @@ format_text_wsp(const guchar *string, size_t len)
   return fmtbuf[idx];
 }
 
-/* Max string length for displaying byte string.  */
-#define	MAX_BYTE_STR_LEN	48
-
-/* Turn an array of bytes into a string showing the bytes in hex. */
-#define	N_BYTES_TO_STR_STRINGS	6
-gchar *
-bytes_to_str(const guint8 *bd, int bd_len) {
-  return bytes_to_str_punct(bd,bd_len,'\0');
-}
-
-/* Turn an array of bytes into a string showing the bytes in hex with
- * punct as a bytes separator.
- */
-gchar *
-bytes_to_str_punct(const guint8 *bd, int bd_len, gchar punct) {
-  gchar        *cur;
-  gchar        *p;
-  int           len;
-
-  cur=ep_alloc(MAX_BYTE_STR_LEN+3+1);
-  p = cur;
-  len = MAX_BYTE_STR_LEN;
-  while (bd_len > 0 && len > 0) {
-    *p++ = hex[(*bd) >> 4];
-    *p++ = hex[(*bd) & 0xF];
-    len -= 2;
-    bd++;
-    bd_len--;
-    if(punct && bd_len > 0){
-      *p++ = punct;
-      len--;
-    }
-  }
-  if (bd_len != 0) {
-    /* Note that we're not showing the full string.  */
-    *p++ = '.';
-    *p++ = '.';
-    *p++ = '.';
-  }
-  *p = '\0';
-  return cur;
-}
-
 static gboolean
 is_byte_sep(guint8 c)
 {
diff --git a/epan/to_str.c b/epan/to_str.c
index c320d62776..444bb4a0f3 100644
--- a/epan/to_str.c
+++ b/epan/to_str.c
@@ -73,6 +73,74 @@
  */
 #define BUF_TOO_SMALL_ERR "[Buffer too small]"
 
+static inline char *
+byte_to_hex(char *out, guint32 dword) {
+  /* 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' };
+
+  *out++ = hex_digits[(dword >> 4) & 0xF];
+  *out++ = hex_digits[dword & 0xF];
+  return out;
+}
+
+static inline char *
+word_to_hex(char *out, guint16 word) {
+  out = byte_to_hex(out, word >> 8);
+  out = byte_to_hex(out, word);
+  return out;
+}
+
+static inline 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;
+}
+
+static inline 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;
+}
+
+/* buffer need to be at least len * 2 size */
+static inline char *
+bytes_to_hexstr(char *out, const guint8 *ad, guint32 len) {
+   guint32 i;
+
+   for (i = 0; i < len; i++)
+	out = byte_to_hex(out, ad[i]);
+   return out;
+}
+
+/* buffer need to be at least len * 3 - 1 size */
+static inline char *
+bytes_to_hexstr_punct(char *out, const guint8 *ad, guint32 len, char punct) {
+   guint32 i;
+
+   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
  * digits at at a time, with a specified punctuation character between
  * the bytes.
@@ -83,44 +151,171 @@
 gchar *
 bytestring_to_str(const guint8 *ad, guint32 len, char punct) {
   gchar *buf;
-  gchar        *p;
-  int          i = (int) len - 1;
-  guint32      octet;
   size_t       buflen;
-  /* 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' };
+
+  /* XXX, Old code was using int as iterator... Why len is guint32 anyway?! (darkjames) */
+  if ( ((int) len) < 0)
+     return "";
+
+  if (!len)
+     return "";
 
   if (punct)
     buflen=len*3;
   else
     buflen=len*2 + 1;
 
-  if (buflen < 3 || i < 0) {
-    return "";
-  }
-
   buf=ep_alloc(buflen);
-  p = &buf[buflen - 1];
-  *p = '\0';
-  for (;;) {
-    octet = ad[i];
-    *--p = hex_digits[octet&0xF];
-    octet >>= 4;
-    *--p = hex_digits[octet&0xF];
-    if (i <= 0)
-      break;
+
     if (punct)
-      *--p = punct;
-    i--;
+    bytes_to_hexstr_punct(buf, ad, len, punct);
+  else
+    bytes_to_hexstr(buf, ad, len);
+
+  buf[buflen-1] = '\0';
+  return buf;
   }
-  return p;
+
+/* Max string length for displaying byte string.  */
+#define	MAX_BYTE_STR_LEN	48
+
+gchar *
+bytes_to_str(const guint8 *bd, int bd_len) {
+  gchar *cur;
+  gchar *cur_ptr;
+  int truncated = 0;
+
+  cur=ep_alloc(MAX_BYTE_STR_LEN+3+1);
+
+  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 */
+
+  if (truncated)
+    cur_ptr = g_stpcpy(cur_ptr, "...");		/* 3 bytes */
+
+  *cur_ptr = '\0';				/* 1 byte */
+  return cur;
+}
+
+/* Turn an array of bytes into a string showing the bytes in hex with
+ * punct as a bytes separator.
+ */
+gchar *
+bytes_to_str_punct(const guint8 *bd, int bd_len, gchar punct) {
+  gchar *cur;
+  gchar *cur_ptr;
+  int truncated = 0;
+
+  if (!punct)
+  	return bytes_to_str(bd, bd_len);
+
+  cur=ep_alloc(MAX_BYTE_STR_LEN+3+1);
+
+  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 */
+
+  if (truncated) {
+    *cur_ptr++ = punct;				/* 1 byte */
+    cur_ptr    = g_stpcpy(cur_ptr, "...");	/* 3 bytes */
+  }
+
+  *cur_ptr = '\0';
+  return cur;
+}
+
+static int
+guint32_to_str_buf_len(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;
+}
+
+static const char * const fast_strings[] = {
+"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;
+
+  gchar *bp = &buf[str_len];
+  gchar const *p;
+
+  if (buf_len < str_len) {
+    g_strlcpy(buf, BUF_TOO_SMALL_ERR, buf_len);	/* Let the unexpected value alert user */
+    return;
+  }
+
+  *--bp = '\0';
+
+  while (u >= 10) {
+    p = fast_strings[100 + (u % 100)];
+
+    *--bp = p[2];
+    *--bp = p[1];
+
+    u /= 100;
+  }
+
+  if (bp != buf) /* ugly, fixme! */
+    *--bp = (u % 10) | '0';
+}
+
+gchar *
+guint32_to_str(guint32 u) {
+  int str_len = 16; /* guint32_to_str_buf_len(u)+1; */
+
+  gchar *bp = ep_alloc(str_len);
+  guint32_to_str_buf(u, bp, str_len);
+
+  return bp;
 }
 
 #define	PLURALIZE(n)	(((n) > 1) ? "s" : "")
@@ -727,40 +922,6 @@ ip_to_str(const guint8 *ad) {
  This function is very fast and this function is called a lot.
  XXX update the ep_address_to_str stuff to use this function.
 */
-static const char * const fast_strings[] = {
-"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
 ip_to_str_buf(const guint8 *ad, gchar *buf, int buf_len)
 {
@@ -852,38 +1013,24 @@ ipxnet_to_string(const guint8 *ad)
 gchar *
 ipxnet_to_str_punct(const guint32 ad, char punct)
 {
-  gchar        *buf;
-  gchar        *p;
-  int          i;
-  guint32      octet;
-  /* 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' };
-  static const guint32  octet_mask[4] =
-	  { 0xff000000 , 0x00ff0000, 0x0000ff00, 0x000000ff };
-
-  buf=ep_alloc(12);
-  p = &buf[12];
-  *--p = '\0';
-  i = 3;
-  for (;;) {
-    octet = (ad & octet_mask[i]) >> ((3 - i) * 8);
-    *--p = hex_digits[octet&0xF];
-    octet >>= 4;
-    *--p = hex_digits[octet&0xF];
-    if (i == 0)
-      break;
-    if (punct)
-      *--p = punct;
-    i--;
+  gchar *buf = ep_alloc(12);
+
+  *dword_to_hex_punct(buf, ad, punct) = '\0';
+  return buf;
   }
-  return p;
+
+static void
+vines_addr_to_str_buf(const guint8 *addrp, gchar *buf, int buf_len)
+{
+  if (buf_len < 14) {
+     g_strlcpy(buf, BUF_TOO_SMALL_ERR, buf_len);	/* Let the unexpected value alert user */
+     return;
+  }
+
+  buf    = dword_to_hex(buf, pntohl(&addrp[0]));	/* 8 bytes */
+  *buf++ = '.';						/* 1 byte */
+  buf    = word_to_hex(buf, pntohs(&addrp[4]));		/* 4 bytes */
+  *buf   = '\0';					/* 1 byte */
 }
 
 gchar *
@@ -891,20 +1038,14 @@ vines_addr_to_str(const guint8 *addrp)
 {
   gchar	*buf;
 
-  buf=ep_alloc(214);
+  buf=ep_alloc(214); /* XXX, 14 here? */
 
   vines_addr_to_str_buf(addrp, buf, 214);
   return buf;
 }
 
-void
-vines_addr_to_str_buf(const guint8 *addrp, gchar *buf, int buf_len)
-{
-  g_snprintf(buf, buf_len, "%08x.%04x", pntohl(&addrp[0]), pntohs(&addrp[4]));
-}
-
 
-void
+static void
 usb_addr_to_str_buf(const guint8 *addrp, gchar *buf, int buf_len)
 {
   if(pletohl(&addrp[0])==0xffffffff){
@@ -914,7 +1055,7 @@ usb_addr_to_str_buf(const guint8 *addrp, gchar *buf, int buf_len)
   }
 }
 
-void
+static void
 tipc_addr_to_str_buf( const guint8 *data, gchar *buf, int buf_len){
 	guint8 zone;
 	guint16 subnetwork;
@@ -964,10 +1105,12 @@ fcwwn_to_str (const guint8 *ad)
     int fmt;
     guint8 oui[6];
     gchar *ethstr;
+    gchar *ethptr;
 
     if (ad == NULL) return NULL;
 
     ethstr=ep_alloc(512);
+    ethptr = bytes_to_hexstr_punct(ethstr, ad, 8, ':');	/* 23 bytes */
 
     fmt = (ad[0] & 0xF0) >> 4;
 
@@ -976,9 +1119,8 @@ fcwwn_to_str (const guint8 *ad)
     case FC_NH_NAA_IEEE:
     case FC_NH_NAA_IEEE_E:
         memcpy (oui, &ad[2], 6);
-        g_snprintf (ethstr, 512, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x (%s)", ad[0],
-                 ad[1], ad[2], ad[3], ad[4], ad[5], ad[6], ad[7],
-                 get_manuf_name (oui));
+
+        g_snprintf (ethptr, 512-23, " (%s)", get_manuf_name (oui));
         break;
 
     case FC_NH_NAA_IEEE_R:
@@ -989,14 +1131,11 @@ fcwwn_to_str (const guint8 *ad)
         oui[4] = ((ad[4] & 0x0F) << 4) | ((ad[5] & 0xF0) >> 4);
         oui[5] = ((ad[5] & 0x0F) << 4) | ((ad[6] & 0xF0) >> 4);
 
-        g_snprintf (ethstr, 512, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x (%s)", ad[0],
-                 ad[1], ad[2], ad[3], ad[4], ad[5], ad[6], ad[7],
-                 get_manuf_name (oui));
+        g_snprintf (ethptr, 512-23, " (%s)", get_manuf_name (oui));
         break;
 
     default:
-        g_snprintf (ethstr, 512, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", ad[0],
-                 ad[1], ad[2], ad[3], ad[4], ad[5], ad[6], ad[7]);
+        *ethptr = '\0';
         break;
     }
     return (ethstr);
@@ -1036,52 +1175,6 @@ se_address_to_str(const address *addr)
   return str;
 }
 
-/*
- * XXX - see also bytes_to_str() and bytes_to_str_punct() in strutil.c.
- * They fill in an ep_allocated buffer, rather than a buffer supplied
- * to them, and put in "..." if the string is "too long".
- */
-
-static inline char *
-byte_to_hex(char *out, guint8 octet) {
-  /* 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' };
-
-  *out++ = hex_digits[octet >> 4];
-  *out++ = hex_digits[octet & 0xF];
-  return out;
-}
-
-/* buffer need to be at least len * 2 size */
-static inline char *
-bytes_to_hexstr(char *out, const guint8 *ad, guint32 len) {
-   guint32 i;
-
-   for (i = 0; i < len; i++)
-	out = byte_to_hex(out, ad[i]);
-   return out;
-}
-
-/* buffer need to be at least len * 3 - 1 size */
-static inline char *
-bytes_to_hexstr_punct(char *out, const guint8 *ad, guint32 len, char punct) {
-   guint32 i;
-
-   out = byte_to_hex(out, ad[0]);
-   for (i = 1; i < len; i++) {
-   	*out++ = punct;
-	out = byte_to_hex(out, ad[i]);
-   }
-   return out;
-}
-
 void
 address_to_str_buf(const address *addr, gchar *buf, int buf_len)
 {
@@ -1179,9 +1272,25 @@ gchar* guid_to_str(const e_guid_t *guid) {
 }
 
 gchar* guid_to_str_buf(const e_guid_t *guid, gchar *buf, int buf_len) {
-  g_snprintf(buf, buf_len, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
-          guid->data1, guid->data2, guid->data3,
-          guid->data4[0], guid->data4[1], guid->data4[2], guid->data4[3], guid->data4[4], guid->data4[5], guid->data4[6], guid->data4[7]);
+  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;
 }
 
diff --git a/epan/to_str.h b/epan/to_str.h
index a6c7c86ce0..86e487b036 100644
--- a/epan/to_str.h
+++ b/epan/to_str.h
@@ -70,7 +70,6 @@ extern gchar*	ipx_addr_to_str(guint32, const guint8 *);
 extern gchar*	ipxnet_to_string(const guint8 *ad);
 extern gchar*	ipxnet_to_str_punct(const guint32 ad, char punct);
 extern gchar*	vines_addr_to_str(const guint8 *addrp);
-extern void	vines_addr_to_str_buf(const guint8 *addrp, gchar *buf, int buf_len);
 extern gchar*	time_secs_to_str(gint32);
 extern gchar*	time_secs_to_str_unsigned(guint32);
 extern gchar*	time_msecs_to_str(gint32);
@@ -79,13 +78,14 @@ extern gchar*	abs_time_secs_to_str(time_t, gboolean);
 extern void	display_signed_time(gchar *, int, gint32, gint32, to_str_time_res_t);
 extern void	display_epoch_time(gchar *, int, time_t,  gint32, to_str_time_res_t);
 
+extern gchar*	guint32_to_str(guint32 u);
+extern void	guint32_to_str_buf(guint32 u, gchar *buf, int buf_len);
+
 extern gchar*	rel_time_to_str(nstime_t*);
 extern gchar*	rel_time_to_secs_str(nstime_t*);
 extern gchar*	guid_to_str(const e_guid_t*);
 extern gchar*	guid_to_str_buf(const e_guid_t*, gchar*, int);
 
-void tipc_addr_to_str_buf( const guint8 *data, gchar *buf, int buf_len);
-
 extern char *decode_bits_in_field(gint bit_offset, gint no_of_bits, guint64 value);
 
 extern char	*other_decode_bitfield_value(char *buf, guint32 val, guint32 mask,