Remove emem APIs from UAT functionality.

Change-Id: I009c09f25d170e5c9aaaef713eaacb3252817856
Reviewed-on: https://code.wireshark.org/review/6460
Petri-Dish: Michael Mann <mmann78@netscape.net>
Reviewed-by: Evan Huus <eapache@gmail.com>
Petri-Dish: Anders Broman <a.broman58@gmail.com>
Tested-by: Petri Dish Buildbot <buildbot-no-reply@wireshark.org>
Reviewed-by: Michael Mann <mmann78@netscape.net>

14 files changed, 170 insertions, 109 deletions

diff --git a/epan/dfilter/dfilter-macro.c b/epan/dfilter/dfilter-macro.c
index 772d9e3e79..6ed12a5bbe 100644
--- a/epan/dfilter/dfilter-macro.c
+++ b/epan/dfilter/dfilter-macro.c
@@ -580,13 +580,13 @@ static gboolean macro_name_chk(void* r _U_, const char* in_name, guint name_len,
 	guint i;
 
 	if (name_len == 0) {
-		*error = "invalid name";
+		*error = g_strdup("invalid name");
 		return FALSE;
 	}
 
 	for (i=0; i < name_len; i++) {
 		if (!(in_name[i] == '_' || g_ascii_isalnum(in_name[i]) ) ) {
-			*error = "invalid char in name";
+			*error = g_strdup("invalid char in name");
 			return FALSE;
 		}
 	}
diff --git a/epan/dissectors/packet-dtls.c b/epan/dissectors/packet-dtls.c
index ad5ca4640b..c1ec134976 100644
--- a/epan/dissectors/packet-dtls.c
+++ b/epan/dissectors/packet-dtls.c
@@ -255,6 +255,7 @@ dtls_parse_old_keys(void)
         if (!uat_load_str(dtlsdecrypt_uat, uat_entry, &err)) {
           ssl_debug_printf("dtls_parse: Can't load UAT string %s: %s\n",
                            uat_entry, err);
+          g_free(err);
         }
         wmem_free(NULL, uat_entry);
       }
diff --git a/epan/dissectors/packet-k12.c b/epan/dissectors/packet-k12.c
index 426bf0ff03..40cf879df0 100644
--- a/epan/dissectors/packet-k12.c
+++ b/epan/dissectors/packet-k12.c
@@ -371,7 +371,7 @@ protos_chk_cb(void* r _U_, const char* p, guint len, const void* u1 _U_, const v
 		g_strstrip(protos[num_protos]);
 
 	if (!num_protos) {
-		*err = ep_strdup_printf("No protocols given");
+		*err = g_strdup_printf("No protocols given");
 		wmem_free(NULL, line);
 		wmem_free(NULL, protos);
 		return FALSE;
@@ -379,7 +379,7 @@ protos_chk_cb(void* r _U_, const char* p, guint len, const void* u1 _U_, const v
 
 	for (i = 0; i < num_protos; i++) {
 		if (!find_dissector(protos[i])) {
-			*err = ep_strdup_printf("Could not find dissector for: '%s'",protos[i]);
+			*err = g_strdup_printf("Could not find dissector for: '%s'",protos[i]);
 			wmem_free(NULL, line);
 			wmem_free(NULL, protos);
 			return FALSE;
diff --git a/epan/dissectors/packet-lbm.h b/epan/dissectors/packet-lbm.h
index 11d67d0eaf..9903ff2875 100644
--- a/epan/dissectors/packet-lbm.h
+++ b/epan/dissectors/packet-lbm.h
@@ -130,12 +130,12 @@ typedef guint64 lbm_uint64_t;
     {\
         if (((rec_t*)rec)->field_name ) \
         { \
-            *out_ptr = (((rec_t*)rec)->field_name); \
+            *out_ptr = g_strdup((((rec_t*)rec)->field_name)); \
             *out_len = (unsigned)strlen((((rec_t*)rec)->field_name)); \
         } \
         else \
         { \
-            *out_ptr = ""; \
+            *out_ptr = g_strdup(""); \
             *out_len = 0; \
         } \
     }
@@ -150,12 +150,12 @@ typedef guint64 lbm_uint64_t;
         struct in_addr addr; \
         if (inet_aton(strptr, &addr) == 0) \
         { \
-            *err = "invalid address"; \
+            *err = g_strdup("invalid address"); \
             return (FALSE); \
         } \
         if (!IN_MULTICAST(g_ntohl(addr.s_addr)) && (g_ntohl(addr.s_addr) != 0)) \
         { \
-            *err = "invalid multicast address"; \
+            *err = g_strdup("invalid multicast address"); \
             return (FALSE); \
         } \
         return (TRUE); \
@@ -173,12 +173,12 @@ typedef guint64 lbm_uint64_t;
     {\
         if (((rec_t*)rec)->field_name ) \
         { \
-            *out_ptr = (((rec_t*)rec)->field_name); \
+            *out_ptr = g_strdup((((rec_t*)rec)->field_name)); \
             *out_len = (unsigned)strlen((((rec_t*)rec)->field_name)); \
         } \
         else \
         { \
-            *out_ptr = ""; \
+            *out_ptr = g_strdup(""); \
             *out_len = 0; \
         } \
     }
diff --git a/epan/dissectors/packet-ssl-utils.c b/epan/dissectors/packet-ssl-utils.c
index 1c3a97f457..37e049c6de 100644
--- a/epan/dissectors/packet-ssl-utils.c
+++ b/epan/dissectors/packet-ssl-utils.c
@@ -1445,7 +1445,7 @@ ssl_data_clone(StringInfo *str)
 }
 
 /* from_hex converts |hex_len| bytes of hex data from |in| and sets |*out| to
- * the result. |out->data| will be allocated using se_alloc. Returns TRUE on
+ * the result. |out->data| will be allocated using wmem_file_scope. Returns TRUE on
  * success. */
 static gboolean from_hex(StringInfo* out, const char* in, gsize hex_len) {
     gsize i;
@@ -4068,7 +4068,7 @@ ssl_private_key_hash  (gconstpointer v)
 }
 
 /* private key table entries have a scope 'larger' then packet capture,
- * so we can't relay on se_alloc** function */
+ * so we can't rely on wmem_file_scope function */
 void
 ssl_private_key_free(gpointer id, gpointer key, gpointer dummy _U_)
 {
@@ -4815,7 +4815,7 @@ gboolean
 ssldecrypt_uat_fld_ip_chk_cb(void* r _U_, const char* p, guint len _U_, const void* u1 _U_, const void* u2 _U_, const char** err)
 {
     if (!p || strlen(p) == 0u) {
-        *err = ep_strdup_printf("No IP address given.");
+        *err = g_strdup_printf("No IP address given.");
         return FALSE;
     }
 
@@ -4827,14 +4827,14 @@ gboolean
 ssldecrypt_uat_fld_port_chk_cb(void* r _U_, const char* p, guint len _U_, const void* u1 _U_, const void* u2 _U_, const char** err)
 {
     if (!p || strlen(p) == 0u) {
-        *err = ep_strdup_printf("No Port given.");
+        *err = g_strdup_printf("No Port given.");
         return FALSE;
     }
 
     if (strcmp(p, "start_tls") != 0){
         const gint i = atoi(p);
         if (i < 0 || i > 65535) {
-            *err = ep_strdup_printf("Invalid port given.");
+            *err = g_strdup_printf("Invalid port given.");
             return FALSE;
         }
     }
@@ -4847,13 +4847,13 @@ gboolean
 ssldecrypt_uat_fld_protocol_chk_cb(void* r _U_, const char* p, guint len _U_, const void* u1 _U_, const void* u2 _U_, const char** err)
 {
     if (!p || strlen(p) == 0u) {
-        *err = ep_strdup_printf("No protocol given.");
+        *err = g_strdup_printf("No protocol given.");
         return FALSE;
     }
 
     if (!find_dissector(p)) {
         char* ssl_str = ssl_association_info();
-        *err = ep_strdup_printf("Could not find dissector for: '%s'\nValid dissectors are:\n%s", p, ssl_str);
+        *err = g_strdup_printf("Could not find dissector for: '%s'\nValid dissectors are:\n%s", p, ssl_str);
         g_free(ssl_str);
         return FALSE;
     }
@@ -4868,11 +4868,11 @@ ssldecrypt_uat_fld_fileopen_chk_cb(void* r _U_, const char* p, guint len _U_, co
     ws_statb64 st;
 
     if (!p || strlen(p) == 0u) {
-        *err = ep_strdup_printf("No filename given.");
+        *err = g_strdup_printf("No filename given.");
         return FALSE;
     } else {
         if (ws_stat64(p, &st) != 0) {
-            *err = ep_strdup_printf("File '%s' does not exist or access is denied.", p);
+            *err = g_strdup_printf("File '%s' does not exist or access is denied.", p);
             return FALSE;
         }
     }
@@ -4893,14 +4893,14 @@ ssldecrypt_uat_fld_password_chk_cb(void* r _U_, const char* p, guint len _U_, co
             char *msg = NULL;
             if (!ssl_load_pkcs12(fp, p, &msg)) {
                 fclose(fp);
-                *err = ep_strdup_printf("Could not load PKCS#12 key file: %s", msg);
+                *err = g_strdup_printf("Could not load PKCS#12 key file: %s", msg);
                 g_free(msg);
                 return FALSE;
             }
             g_free(msg);
             fclose(fp);
         } else {
-            *err = ep_strdup_printf("Leave this field blank if the keyfile is not PKCS#12.");
+            *err = g_strdup_printf("Leave this field blank if the keyfile is not PKCS#12.");
             return FALSE;
         }
     }
diff --git a/epan/dissectors/packet-ssl.c b/epan/dissectors/packet-ssl.c
index 522f622620..04e5cced1e 100644
--- a/epan/dissectors/packet-ssl.c
+++ b/epan/dissectors/packet-ssl.c
@@ -369,6 +369,7 @@ ssl_parse_old_keys(void)
                 if (!uat_load_str(ssldecrypt_uat, uat_entry, &err)) {
                     ssl_debug_printf("ssl_parse_old_keys: Can't load UAT string %s: %s\n",
                                      uat_entry, err);
+                    g_free(err);
                 }
                 wmem_free(NULL, uat_entry);
             }
diff --git a/epan/prefs.c b/epan/prefs.c
index 6f7128cf7f..415f3e57cb 100644
--- a/epan/prefs.c
+++ b/epan/prefs.c
@@ -3460,7 +3460,8 @@ static gboolean
 prefs_set_uat_pref(char *uat_entry) {
     gchar *p, *colonp;
     uat_t *uat;
-    gchar *err;
+    gchar *err = NULL;
+    gboolean ret;
 
     colonp = strchr(uat_entry, ':');
     if (colonp == NULL)
@@ -3492,10 +3493,9 @@ prefs_set_uat_pref(char *uat_entry) {
         return FALSE;
     }
 
-    if (uat_load_str(uat, p, &err)) {
-        return TRUE;
-    }
-    return FALSE;
+    ret = uat_load_str(uat, p, &err);
+    g_free(err);
+    return ret;
 }
 
 /*
@@ -4531,6 +4531,7 @@ prefs_pref_to_str(pref_t *pref, pref_source_t source) {
     const char *pref_text = "[Unknown]";
     void *valp; /* pointer to preference value */
     color_t *pref_color;
+    gchar *tmp_value, *ret_value;
 
     if (!pref) {
         return g_strdup(pref_text);
@@ -4603,8 +4604,11 @@ prefs_pref_to_str(pref_t *pref, pref_source_t source) {
         return g_strdup(*(const char **) valp);
 
     case PREF_RANGE:
-        pref_text = range_convert_range(*(range_t **) valp);
-        break;
+        /* Convert wmem to g_alloc memory */
+        tmp_value = range_convert_range(NULL, *(range_t **) valp);
+        ret_value = g_strdup(tmp_value);
+        wmem_free(NULL, tmp_value);
+        return ret_value;
 
     case PREF_COLOR:
         return g_strdup_printf("%02x%02x%02x",
diff --git a/epan/range.c b/epan/range.c
index 6783ec9382..0101a8d86e 100644
--- a/epan/range.c
+++ b/epan/range.c
@@ -322,27 +322,27 @@ range_foreach(range_t *range, void (*callback)(guint32 val))
    }
 }
 
-/* This function converts a range_t to a (ep_alloc()-allocated) string.  */
+/* This function converts a range_t to a (wmem-allocated) string.  */
 char *
-range_convert_range(range_t *range)
+range_convert_range(wmem_allocator_t *scope, range_t *range)
 {
    guint32 i;
    gboolean prepend_comma = FALSE;
-   emem_strbuf_t *strbuf;
+   wmem_strbuf_t *strbuf;
 
-   strbuf=ep_strbuf_new(NULL);
+   strbuf=wmem_strbuf_new(scope, "");
 
    if (range) {
       for (i=0; i < range->nranges; i++) {
          if (range->ranges[i].low == range->ranges[i].high) {
-            ep_strbuf_append_printf(strbuf, "%s%u", prepend_comma?",":"", range->ranges[i].low);
+            wmem_strbuf_append_printf(strbuf, "%s%u", prepend_comma?",":"", range->ranges[i].low);
          } else {
-            ep_strbuf_append_printf(strbuf, "%s%u-%u", prepend_comma?",":"", range->ranges[i].low, range->ranges[i].high);
+            wmem_strbuf_append_printf(strbuf, "%s%u-%u", prepend_comma?",":"", range->ranges[i].low, range->ranges[i].high);
          }
          prepend_comma = TRUE;
       }
    }
-   return strbuf->str;
+   return wmem_strbuf_finalize(strbuf);
 }
 
 /* Create a copy of a range. */
diff --git a/epan/range.h b/epan/range.h
index 1746bf1a9f..a7b8f5c748 100644
--- a/epan/range.h
+++ b/epan/range.h
@@ -28,6 +28,7 @@
 
 #include <glib.h>
 #include "ws_symbol_export.h"
+#include <epan/wmem/wmem.h>
 
 /** @file
  * Range strings a variant of value_strings
@@ -113,9 +114,9 @@ WS_DLL_PUBLIC gboolean ranges_are_equal(range_t *a, range_t *b);
 WS_DLL_PUBLIC void range_foreach(range_t *range, void (*callback)(guint32 val));
 
 /**
- * This function converts a range_t to a (ep_alloc()-allocated) string.
+ * This function converts a range_t to a (wmem_alloc()-allocated) string.
  */
-WS_DLL_PUBLIC char *range_convert_range(range_t *range);
+WS_DLL_PUBLIC char *range_convert_range(wmem_allocator_t *scope, range_t *range);
 
 /**
  * Create a copy of a range.
diff --git a/epan/uat-int.h b/epan/uat-int.h
index e797f3bee7..88c52f4b33 100644
--- a/epan/uat-int.h
+++ b/epan/uat-int.h
@@ -96,7 +96,7 @@ WS_DLL_PUBLIC
 void uat_clear(uat_t*);
 
 WS_DLL_PUBLIC
-gboolean uat_save(uat_t* , const char** );
+gboolean uat_save(uat_t* , char** );
 
 void uat_load_all(void);
 
diff --git a/epan/uat.c b/epan/uat.c
index 824e64d5a2..6868d4219f 100644
--- a/epan/uat.c
+++ b/epan/uat.c
@@ -160,16 +160,18 @@ void* uat_add_record(uat_t* uat, const void* data, gboolean valid_rec) {
 
 void uat_swap(uat_t* uat, guint a, guint b) {
     size_t s = uat->record_size;
-    void* tmp = ep_alloc(s);
+    void* tmp;
     gboolean tmp_bool;
 
     g_assert( a < uat->raw_data->len && b < uat->raw_data->len );
 
     if (a == b) return;
 
+    tmp = g_malloc(s);
     memcpy(tmp, UAT_INDEX_PTR(uat,a), s);
     memcpy(UAT_INDEX_PTR(uat,a), UAT_INDEX_PTR(uat,b), s);
     memcpy(UAT_INDEX_PTR(uat,b), tmp, s);
+    g_free(tmp);
 
     tmp_bool = *(gboolean*)(uat->valid_data->data + (sizeof(gboolean) * (a)));
     *(gboolean*)(uat->valid_data->data + (sizeof(gboolean) * (a))) = *(gboolean*)(uat->valid_data->data + (sizeof(gboolean) * (b)));
@@ -254,7 +256,7 @@ static void putfld(FILE* fp, void* rec, uat_field_t* f) {
             }
 
             putc('"',fp);
-            return;
+            break;
         }
         case PT_TXTMOD_HEXBYTES: {
             guint i;
@@ -263,14 +265,16 @@ static void putfld(FILE* fp, void* rec, uat_field_t* f) {
                 fprintf(fp,"%.2x",((const guint8*)fld_ptr)[i]);
             }
 
-            return;
+            break;
         }
         default:
             g_assert_not_reached();
     }
+
+    g_free((char*)fld_ptr);
 }
 
-gboolean uat_save(uat_t* uat, const char** error) {
+gboolean uat_save(uat_t* uat, char** error) {
     guint i;
     gchar* fname = uat_get_actual_filename(uat,TRUE);
     FILE* fp;
@@ -283,7 +287,7 @@ gboolean uat_save(uat_t* uat, const char** error) {
         /* Parent directory does not exist, try creating first */
         gchar *pf_dir_path = NULL;
         if (create_persconffile_dir(&pf_dir_path) != 0) {
-            *error = ep_strdup_printf("uat_save: error creating '%s'", pf_dir_path);
+            *error = g_strdup_printf("uat_save: error creating '%s'", pf_dir_path);
             g_free (pf_dir_path);
             return FALSE;
         }
@@ -291,7 +295,7 @@ gboolean uat_save(uat_t* uat, const char** error) {
     }
 
     if (!fp) {
-        *error = ep_strdup_printf("uat_save: error opening '%s': %s",fname,g_strerror(errno));
+        *error = g_strdup_printf("uat_save: error opening '%s': %s",fname,g_strerror(errno));
         return FALSE;
     }
 
@@ -426,7 +430,7 @@ void uat_foreach_table(uat_cb_t cb,void* user_data) {
 
 void uat_load_all(void) {
     guint i;
-    const gchar* err;
+    gchar* err;
 
     for (i=0; i < all_uats->len; i++) {
         uat_t* u = (uat_t *)g_ptr_array_index(all_uats,i);
@@ -437,6 +441,7 @@ void uat_load_all(void) {
 
         if (err) {
             report_failure("Error loading table '%s': %s",u->name,err);
+            g_free(err);
         }
     }
 }
@@ -444,7 +449,7 @@ void uat_load_all(void) {
 
 gboolean uat_fld_chk_str(void* u1 _U_, const char* strptr, guint len _U_, const void* u2 _U_, const void* u3 _U_, const char** err) {
     if (strptr == NULL) {
-        *err = "NULL pointer";
+        *err = g_strdup("NULL pointer");
         return FALSE;
     }
 
@@ -457,21 +462,25 @@ gboolean uat_fld_chk_oid(void* u1 _U_, const char* strptr, guint len, const void
     *err = NULL;
 
     if (strptr == NULL) {
-      *err = "NULL pointer";
+      *err = g_strdup("NULL pointer");
       return FALSE;
     }
 
     for(i = 0; i < len; i++)
       if(!(g_ascii_isdigit(strptr[i]) || strptr[i] == '.')) {
-        *err = "Only digits [0-9] and \".\" allowed in an OID";
-        break;
+        *err = g_strdup("Only digits [0-9] and \".\" allowed in an OID");
+        return FALSE;
       }
 
-    if(strptr[len-1] == '.')
-      *err = "OIDs must not be terminated with a \".\"";
+    if(strptr[len-1] == '.') {
+      *err = g_strdup("OIDs must not be terminated with a \".\"");
+      return FALSE;
+    }
 
-    if(!((*strptr == '0' || *strptr == '1' || *strptr =='2') && (len > 1 && strptr[1] == '.')))
-      *err = "OIDs must start with \"0.\" (ITU-T assigned), \"1.\" (ISO assigned) or \"2.\" (joint ISO/ITU-T assigned)";
+    if(!((*strptr == '0' || *strptr == '1' || *strptr =='2') && (len > 1 && strptr[1] == '.'))) {
+      *err = g_strdup("OIDs must start with \"0.\" (ITU-T assigned), \"1.\" (ISO assigned) or \"2.\" (joint ISO/ITU-T assigned)");
+      return FALSE;
+    }
 
     /* should also check that the second arc is in the range 0-39 */
 
@@ -480,15 +489,17 @@ gboolean uat_fld_chk_oid(void* u1 _U_, const char* strptr, guint len, const void
 
 gboolean uat_fld_chk_proto(void* u1 _U_, const char* strptr, guint len, const void* u2 _U_, const void* u3 _U_, const char** err) {
     if (len) {
-        char* name = ep_strndup(strptr,len);
+        char* name = g_strndup(strptr,len);
         ascii_strdown_inplace(name);
         g_strchug(name);
 
         if (find_dissector(name)) {
             *err = NULL;
+            g_free(name);
             return TRUE;
         } else {
-            *err = "dissector not found";
+            *err = g_strdup("dissector not found");
+            g_free(name);
             return FALSE;
         }
     } else {
@@ -499,7 +510,7 @@ gboolean uat_fld_chk_proto(void* u1 _U_, const char* strptr, guint len, const vo
 
 static gboolean uat_fld_chk_num(int base, const char* strptr, guint len, const char** err) {
     if (len > 0) {
-        char* str = ep_strndup(strptr,len);
+        char* str = g_strndup(strptr,len);
         char* strn;
         long i;
 
@@ -508,18 +519,23 @@ static gboolean uat_fld_chk_num(int base, const char* strptr, guint len, const c
 
         if (((i == G_MAXLONG || i == G_MINLONG) && errno == ERANGE)
             || (errno != 0 && i == 0)) {
-            *err = g_strerror(errno);
+            *err = g_strdup(g_strerror(errno));
+            g_free(str);
             return FALSE;
         }
         if ((*strn != '\0') && (*strn != ' ')) {
-            *err = "Invalid value";
+            *err = g_strdup("Invalid value");
+            g_free(str);
             return FALSE;
         }
         /* Allow only 32bit values */
         if ((sizeof(long) > 4) && ((i < G_MININT) || (i > G_MAXINT))) {
-            *err = "Value too large";
+            *err = g_strdup("Value too large");
+            g_free(str);
             return FALSE;
         }
+
+        g_free(str);
     }
 
     *err = NULL;
@@ -535,40 +551,50 @@ gboolean uat_fld_chk_num_hex(void* u1 _U_, const char* strptr, guint len, const
 }
 
 gboolean uat_fld_chk_enum(void* u1 _U_, const char* strptr, guint len, const void* v, const void* u3 _U_, const char** err) {
-    char* str = ep_strndup(strptr,len);
+    char* str = g_strndup(strptr,len);
     guint i;
     const value_string* vs = (const value_string *)v;
 
     for(i=0;vs[i].strptr;i++) {
         if (g_str_equal(vs[i].strptr,str)) {
             *err = NULL;
+            g_free(str);
             return TRUE;
         }
     }
 
-    *err = ep_strdup_printf("invalid value: %s",str);
+    *err = g_strdup_printf("invalid value: %s",str);
+    g_free(str);
     return FALSE;
 }
 
 gboolean uat_fld_chk_range(void* u1 _U_, const char* strptr, guint len, const void* v _U_, const void* u3, const char** err) {
-    char* str = ep_strndup(strptr,len);
+    char* str = g_strndup(strptr,len);
     range_t* r = NULL;
     convert_ret_t ret = range_convert_str(&r, str,GPOINTER_TO_UINT(u3));
+    gboolean ret_value = FALSE;
 
     switch (  ret ) {
         case CVT_NO_ERROR:
             *err = NULL;
-            return TRUE;
+            ret_value = TRUE;
+            break;
         case CVT_SYNTAX_ERROR:
-            *err = ep_strdup_printf("syntax error in range: %s",str);
-            return FALSE;
+            *err = g_strdup_printf("syntax error in range: %s",str);
+            ret_value = FALSE;
+            break;
         case CVT_NUMBER_TOO_BIG:
-            *err = ep_strdup_printf("value too large in range: '%s' (max = %u)",str,GPOINTER_TO_UINT(u3));
-            return FALSE;
+            *err = g_strdup_printf("value too large in range: '%s' (max = %u)",str,GPOINTER_TO_UINT(u3));
+            ret_value = FALSE;
+            break;
         default:
-            *err = "This should not happen, it is a bug in wireshark! please report to wireshark-dev@wireshark.org";
-            return FALSE;
+            *err = g_strdup("This should not happen, it is a bug in wireshark! please report to wireshark-dev@wireshark.org");
+            ret_value = FALSE;
+            break;
     }
+
+    g_free(str);
+    return ret_value;
 }
 
 char* uat_unbinstring(const char* si, guint in_len, guint* len_p) {
@@ -685,7 +711,7 @@ char* uat_undquote(const char* si, guint in_len, guint* len_p) {
 
 char* uat_esc(const char* buf, guint len) {
     const guint8* end = ((const guint8*)buf)+len;
-    char* out = (char *)ep_alloc0((4*len)+1);
+    char* out = (char *)g_malloc0((4*len)+1);
     const guint8* b;
     char* s = out;
 
diff --git a/epan/uat.h b/epan/uat.h
index 3495579f96..60e6eb7556 100644
--- a/epan/uat.h
+++ b/epan/uat.h
@@ -278,7 +278,7 @@ uat_t* uat_new(const char* name,
  * @return TRUE on success, FALSE on failure.
  */
 WS_DLL_PUBLIC
-gboolean uat_load(uat_t* uat_in, const char** err);
+gboolean uat_load(uat_t* uat_in, char** err);
 
 /** Create or update a single uat entry using a string.
  *
@@ -355,7 +355,7 @@ gboolean uat_fld_chk_str_ ## what (void* UNUSED_PARAMETER(u1), const char* strpt
 	guint i; for (i=0;i<len;i++) { \
 		char c = strptr[i]; \
 			if (! g_ascii_ ## what(c)) { \
-				*err = ep_strdup_printf("invalid char pos=%d value=%.2x",i,c); return FALSE;  } } \
+				*err = g_strdup_printf("invalid char pos=%d value=%.2x",i,c); return FALSE;  } } \
 		*err = NULL; return TRUE; }
 
 
@@ -376,10 +376,10 @@ static void basename ## _ ## field_name ## _set_cb(void* rec, const char* buf, g
 	(((rec_t*)rec)->field_name) = new_buf; } \
 static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out_ptr, unsigned* out_len, const void* UNUSED_PARAMETER(u1), const void* UNUSED_PARAMETER(u2)) {\
 		if (((rec_t*)rec)->field_name ) { \
-			*out_ptr = (((rec_t*)rec)->field_name); \
+			*out_ptr = g_strdup((((rec_t*)rec)->field_name)); \
 			*out_len = (unsigned)strlen((((rec_t*)rec)->field_name)); \
 		} else { \
-			*out_ptr = ""; *out_len = 0; } }
+			*out_ptr = g_strdup(""); *out_len = 0; } }
 
 #define UAT_FLD_CSTRING(basename,field_name,title,desc) \
 	{#field_name, title, PT_TXTMOD_STRING,{uat_fld_chk_str,basename ## _ ## field_name ## _set_cb,basename ## _ ## field_name ## _tostr_cb},{0,0,0},0,desc,FLDFILL}
@@ -427,7 +427,10 @@ static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out
 		*out_ptr = uat_esc(((rec_t*)rec)->ptr_element, (((rec_t*)rec)->len_element)); \
 		*out_len = (unsigned)strlen(*out_ptr); \
 	} else { \
-		*out_ptr = ""; *out_len = 0; } }
+		*out_ptr = g_strdup(""); \
+		*out_len = 0; \
+	} \
+}
 
 #define UAT_FLD_LSTRING(basename,field_name,title, desc) \
 {#field_name, title, PT_TXTMOD_STRING,{0,basename ## _ ## field_name ## _set_cb,basename ## _ ## field_name ## _tostr_cb},{0,0,0},0,desc,FLDFILL}
@@ -446,7 +449,7 @@ static void basename ## _ ## field_name ## _set_cb(void* rec, const char* buf, g
 	(((rec_t*)rec)->ptr_element) = new_buf; \
 	(((rec_t*)rec)->len_element) = len; } \
 static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out_ptr, unsigned* out_len, const void* UNUSED_PARAMETER(u1), const void* UNUSED_PARAMETER(u2)) {\
-	*out_ptr = ((rec_t*)rec)->ptr_element ? (const char*)ep_memdup(((rec_t*)rec)->ptr_element,((rec_t*)rec)->len_element) : ""; \
+	*out_ptr = ((rec_t*)rec)->ptr_element ? (const char*)g_memdup(((rec_t*)rec)->ptr_element,((rec_t*)rec)->len_element) : g_strdup(""); \
 	*out_len = ((rec_t*)rec)->len_element; }
 
 #define UAT_FLD_BUFFER(basename,field_name,title,desc) \
@@ -459,9 +462,11 @@ static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out
  */
 #define UAT_DEC_CB_DEF(basename,field_name,rec_t) \
 static void basename ## _ ## field_name ## _set_cb(void* rec, const char* buf, guint len, const void* UNUSED_PARAMETER(u1), const void* UNUSED_PARAMETER(u2)) {\
-	((rec_t*)rec)->field_name = (guint)strtol(ep_strndup(buf,len),NULL,10); } \
+	char* tmp_str = g_strndup(buf,len); \
+	((rec_t*)rec)->field_name = (guint)strtol(tmp_str,NULL,10); \
+	g_free(tmp_str); } \
 static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out_ptr, unsigned* out_len, const void* UNUSED_PARAMETER(u1), const void* UNUSED_PARAMETER(u2)) {\
-	*out_ptr = ep_strdup_printf("%d",((rec_t*)rec)->field_name); \
+	*out_ptr = g_strdup_printf("%d",((rec_t*)rec)->field_name); \
 	*out_len = (unsigned)strlen(*out_ptr); }
 
 #define UAT_FLD_DEC(basename,field_name,title,desc) \
@@ -477,9 +482,11 @@ static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out
  */
 #define UAT_HEX_CB_DEF(basename,field_name,rec_t) \
 static void basename ## _ ## field_name ## _set_cb(void* rec, const char* buf, guint len, const void* UNUSED_PARAMETER(u1), const void* UNUSED_PARAMETER(u2)) {\
-	((rec_t*)rec)->field_name = (guint)strtol(ep_strndup(buf,len),NULL,16); } \
+	char* tmp_str = g_strndup(buf,len); \
+	((rec_t*)rec)->field_name = (guint)strtol(tmp_str,NULL,16); \
+	g_free(tmp_str); } \
 static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out_ptr, unsigned* out_len, const void* UNUSED_PARAMETER(u1), const void* UNUSED_PARAMETER(u2)) {\
-	*out_ptr = ep_strdup_printf("%x",((rec_t*)rec)->field_name); \
+	*out_ptr = g_strdup_printf("%x",((rec_t*)rec)->field_name); \
 	*out_len = (unsigned)strlen(*out_ptr); }
 
 #define UAT_FLD_HEX(basename,field_name,title,desc) \
@@ -496,34 +503,50 @@ static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out
 #define UAT_VS_DEF(basename,field_name,rec_t,default_t,default_val,default_str) \
 static void basename ## _ ## field_name ## _set_cb(void* rec, const char* buf, guint len, const void* vs, const void* UNUSED_PARAMETER(u2)) {\
 	guint i; \
-	char* str = ep_strndup(buf,len); \
-	const char* cstr; ((rec_t*)rec)->field_name = default_val; \
+	char* str = g_strndup(buf,len); \
+	const char* cstr; \
+	((rec_t*)rec)->field_name = default_val; \
 	for(i=0; ( cstr = ((const value_string*)vs)[i].strptr ) ;i++) { \
 		if (g_str_equal(cstr,str)) { \
-			((rec_t*)rec)->field_name = (default_t)((const value_string*)vs)[i].value; return; } } } \
+			((rec_t*)rec)->field_name = (default_t)((const value_string*)vs)[i].value; \
+			g_free(str); \
+			return; \
+		} \
+	} \
+	g_free(str); } \
 static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out_ptr, unsigned* out_len, const void* vs, const void* UNUSED_PARAMETER(u2)) {\
 	guint i; \
-	*out_ptr = ep_strdup(default_str); \
+	*out_ptr = g_strdup(default_str); \
 	*out_len = (unsigned)strlen(default_str);\
 	for(i=0;((const value_string*)vs)[i].strptr;i++) { \
 		if ( ((const value_string*)vs)[i].value == ((rec_t*)rec)->field_name ) { \
-			*out_ptr = ep_strdup(((const value_string*)vs)[i].strptr); \
-			*out_len = (unsigned)strlen(*out_ptr); return; } } }
+			g_free((char*)*out_ptr); \
+			*out_ptr = g_strdup(((const value_string*)vs)[i].strptr); \
+			*out_len = (unsigned)strlen(*out_ptr); \
+			return; \
+		} \
+    } } \
 
 #define UAT_VS_CSTRING_DEF(basename,field_name,rec_t,default_val,default_str) \
 static void basename ## _ ## field_name ## _set_cb(void* rec, const char* buf, guint len, const void* vs, const void* UNUSED_PARAMETER(u2)) {\
 	guint i; \
-	char* str = ep_strndup(buf,len); \
-	const char* cstr; ((rec_t*)rec)->field_name = default_val; \
+	char* str = g_strndup(buf,len); \
+	const char* cstr; \
+	((rec_t*)rec)->field_name = default_val; \
 	for(i=0; ( cstr = ((const value_string*)vs)[i].strptr ) ;i++) { \
 		if (g_str_equal(cstr,str)) { \
-		  ((rec_t*)rec)->field_name = g_strdup(((const value_string*)vs)[i].strptr); return; } } } \
+		  ((rec_t*)rec)->field_name = g_strdup(((const value_string*)vs)[i].strptr); \
+		  g_free(str); \
+		  return; \
+		} \
+	} \
+	g_free(str);} \
 static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out_ptr, unsigned* out_len, const void* UNUSED_PARAMETER(vs), const void* UNUSED_PARAMETER(u2)) {\
 		if (((rec_t*)rec)->field_name ) { \
-			*out_ptr = (((rec_t*)rec)->field_name); \
+			*out_ptr = g_strdup((((rec_t*)rec)->field_name)); \
 			*out_len = (unsigned)strlen((((rec_t*)rec)->field_name)); \
 		} else { \
-			*out_ptr = ""; *out_len = 0; } }
+			*out_ptr = g_strdup(""); *out_len = 0; } }
 
 #define UAT_FLD_VS(basename,field_name,title,enum,desc) \
 	{#field_name, title, PT_TXTMOD_ENUM,{uat_fld_chk_enum,basename ## _ ## field_name ## _set_cb,basename ## _ ## field_name ## _tostr_cb},{&(enum),&(enum),&(enum)},&(enum),desc,FLDFILL}
@@ -547,10 +570,10 @@ static void basename ## _ ## field_name ## _set_cb(void* rec, const char* buf, g
 		} } \
 static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out_ptr, unsigned* out_len, const void* UNUSED_PARAMETER(u1), const void* UNUSED_PARAMETER(u2)) {\
 	if ( ((rec_t*)rec)->name_field ) { \
-		*out_ptr = (((rec_t*)rec)->name_field); \
+		*out_ptr = g_strdup((((rec_t*)rec)->name_field)); \
 		*out_len = (unsigned)strlen(*out_ptr); \
 	} else { \
-		*out_ptr = ""; *out_len = 0; } }
+		*out_ptr = g_strdup(""); *out_len = 0; } }
 
 
 #define UAT_FLD_PROTO(basename,field_name,title,desc) \
@@ -562,15 +585,16 @@ static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out
 
 #define UAT_RANGE_CB_DEF(basename,field_name,rec_t) \
 static void basename ## _ ## field_name ## _set_cb(void* rec, const char* buf, guint len, const void* UNUSED_PARAMETER(u1), const void* u2) {\
-	char* rng = ep_strndup(buf,len);\
+	char* rng = g_strndup(buf,len);\
 		range_convert_str(&(((rec_t*)rec)->field_name), rng,GPOINTER_TO_UINT(u2)); \
+		g_free(rng); \
 	} \
 static void basename ## _ ## field_name ## _tostr_cb(void* rec, const char** out_ptr, unsigned* out_len, const void* UNUSED_PARAMETER(u1), const void* UNUSED_PARAMETER(u2)) {\
 	if ( ((rec_t*)rec)->field_name ) { \
-		*out_ptr = range_convert_range(((rec_t*)rec)->field_name); \
+		*out_ptr = range_convert_range(NULL, ((rec_t*)rec)->field_name); \
 		*out_len = (unsigned)strlen(*out_ptr); \
 	} else { \
-		*out_ptr = ""; *out_len = 0; } }
+		*out_ptr = g_strdup(""); *out_len = 0; } }
 
 
 #define UAT_FLD_RANGE(basename,field_name,title,max,desc) \
diff --git a/epan/uat_load.l b/epan/uat_load.l
index 140b917f09..800929710d 100644
--- a/epan/uat_load.l
+++ b/epan/uat_load.l
@@ -79,7 +79,9 @@ static gchar *parse_str;
 static guint parse_str_pos;
 
 #define ERROR(fmtd) do { \
-    error = ep_strdup_printf("%s:%d: %s",uat->filename,linenum,ep_strdup_printf fmtd); \
+    char* fmt_str = g_strdup_printf fmtd; \
+    error = g_strdup_printf("%s:%d: %s",uat->filename,linenum,fmt_str); \
+    g_free(fmt_str); \
     yyterminate(); \
 } while(0)
 
@@ -87,7 +89,7 @@ static guint parse_str_pos;
 	{ const gchar* errx; \
 	if (uat->fields[colnum].cb.chk) { \
 		if ( ! uat->fields[colnum].cb.chk(record, ptrx, len, uat->fields[colnum].cbdata.chk, uat->fields[colnum].fld_data, &errx) ) { \
-			error = ep_strdup_printf("%s:%d: %s",uat->filename,linenum,ep_strdup_printf("%s",errx)); \
+			error = g_strdup_printf("%s:%d: %s",uat->filename,linenum,errx); \
 			valid_record = FALSE; \
 		}\
 	}\
@@ -251,12 +253,8 @@ comment #[^\n]*\n
 		uat->update_cb(rec,&err);
 
 	if (err) {
-		char *tmp = ep_strdup(err);
-		/* XXX bit of a hack to remove emem from dissectors, this can
-		 * be removed as proper use of glib memory is propogated
-		 * through the rest of the UAT code */
-		g_free((char*)err);
-		ERROR(("%s",tmp));
+		error = err;
+		yyterminate();
 	}
 
 	valid_record = TRUE;
@@ -286,7 +284,7 @@ comment #[^\n]*\n
 
 
 gboolean
-uat_load(uat_t *uat_in, const char **errx)
+uat_load(uat_t *uat_in, char **errx)
 {
 	gchar *fname = uat_get_actual_filename(uat_in, FALSE);
 
@@ -304,7 +302,7 @@ uat_load(uat_t *uat_in, const char **errx)
 
 
 	if (!(yyin = ws_fopen(fname,"r"))) {
-		*errx = g_strerror(errno);
+		*errx = g_strdup(g_strerror(errno));
 		g_free(fname);
 		return FALSE;
 	}
@@ -329,7 +327,7 @@ uat_load(uat_t *uat_in, const char **errx)
 	UAT_UPDATE(uat);
 
 	if (error) {
-		*errx = ep_strdup(error);
+		*errx = g_strdup(error);
 		return FALSE;
 	}
 
@@ -368,7 +366,7 @@ uat_load_str(uat_t *uat_in, char *entry, char **err)
 	UAT_UPDATE(uat);
 
 	if (error) {
-		*err = ep_strdup(error);
+		*err = g_strdup(error);
 		return FALSE;
 	}
 
diff --git a/epan/wslua/wslua_proto.c b/epan/wslua/wslua_proto.c
index 7c24d28313..516b2c773c 100644
--- a/epan/wslua/wslua_proto.c
+++ b/epan/wslua/wslua_proto.c
@@ -427,7 +427,13 @@ WSLUA_METAMETHOD Prefs__index(lua_State* L) {
                 case PREF_UINT: lua_pushnumber(L,(lua_Number)prefs_p->value.u); break;
                 case PREF_STRING: lua_pushstring(L,prefs_p->value.s); break;
                 case PREF_ENUM: lua_pushnumber(L,(lua_Number)prefs_p->value.e); break;
-                case PREF_RANGE: lua_pushstring(L,range_convert_range(prefs_p->value.r)); break;
+                case PREF_RANGE:
+                    {
+                    char *push_str = range_convert_range(NULL, prefs_p->value.r);
+                    lua_pushstring(L, push_str);
+                    wmem_free(NULL, push_str);
+                    }
+                    break;
                 default: WSLUA_ERROR(Prefs__index,"Unknow Pref type"); return 0;
             }
             WSLUA_RETURN(1); /* The current value of the preference. */