Rename some functions and types for endpoint tables.

The "conversation table" mechanism supports two types of tables, one for
the "Conversations" menu item under "Statistics" and one for the
"Endpoints" menu item under "Statistics".  The first of them shows
statistics for conversations at various layers of the networking stack;
the second of them shows statistics for endpoints at various layers of
the networking stack.

The latter is *not* a table of hosts; an endpoint might be a host,
identified by an address at some network level (MAC, IP, etc.), or it
might be a port on a host, identified by an address/port pair.

Some data types, function names, etc. use "host" or "hostlist" or other
terms that imply that an endpoint is a host; change them to speak of
endpoints rather than hosts, using names similar to the corresponding
functions for conversations.

Provide wrapper functions and typedefs for backwards source and binary
compatibility; mark them as deprecated in favor of the new names.

Clean up some comment errors found in the process.

21 files changed, 83 insertions, 83 deletions

diff --git a/epan/dissectors/packet-bluetooth.c b/epan/dissectors/packet-bluetooth.c
index 4876d495d8..58e7c5cf32 100644
--- a/epan/dissectors/packet-bluetooth.c
+++ b/epan/dissectors/packet-bluetooth.c
@@ -4412,7 +4412,7 @@ static const char* bluetooth_conv_get_filter_type(conv_item_t* conv, conv_filter
 static ct_dissector_info_t bluetooth_ct_dissector_info = {&bluetooth_conv_get_filter_type};
 
 
-static const char* bluetooth_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* bluetooth_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if (filter == CONV_FT_ANY_ADDRESS) {
         if (host->myaddress.type == AT_ETHER)
@@ -4424,7 +4424,7 @@ static const char* bluetooth_get_filter_type(hostlist_talker_t* host, conv_filte
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t  bluetooth_dissector_info = {&bluetooth_get_filter_type};
+static et_dissector_info_t  bluetooth_dissector_info = {&bluetooth_get_filter_type};
 
 
 static tap_packet_status
@@ -4448,8 +4448,8 @@ bluetooth_hostlist_packet(void *pit, packet_info *pinfo,
     conv_hash_t *hash = (conv_hash_t*) pit;
     hash->flags = flags;
 
-    add_hostlist_table_data(hash, &pinfo->dl_src, 0, TRUE,  1, pinfo->fd->pkt_len, &bluetooth_dissector_info, ENDPOINT_NONE);
-    add_hostlist_table_data(hash, &pinfo->dl_dst, 0, FALSE, 1, pinfo->fd->pkt_len, &bluetooth_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &pinfo->dl_src, 0, TRUE,  1, pinfo->fd->pkt_len, &bluetooth_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &pinfo->dl_dst, 0, FALSE, 1, pinfo->fd->pkt_len, &bluetooth_dissector_info, ENDPOINT_NONE);
 
     return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-dccp.c b/epan/dissectors/packet-dccp.c
index f16079a819..5dba9dcbc2 100644
--- a/epan/dissectors/packet-dccp.c
+++ b/epan/dissectors/packet-dccp.c
@@ -453,7 +453,7 @@ dccpip_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U
     return TAP_PACKET_REDRAW;
 }
 
-static const char* dccp_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* dccp_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
 
     if (filter == CONV_FT_SRC_PORT)
@@ -494,7 +494,7 @@ static const char* dccp_host_get_filter_type(hostlist_talker_t* host, conv_filte
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t dccp_host_dissector_info = {&dccp_host_get_filter_type};
+static et_dissector_info_t dccp_host_dissector_info = {&dccp_host_get_filter_type};
 
 static tap_packet_status
 dccpip_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags )
@@ -506,8 +506,8 @@ dccpip_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, c
     /* Take two "add" passes per packet, adding for each direction, ensures that all
     packets are counted properly (even if address is sending to itself)
     XXX - this could probably be done more efficiently inside hostlist_table */
-    add_hostlist_table_data(hash, &dccphdr->ip_src, dccphdr->sport, TRUE, 1, pinfo->fd->pkt_len, &dccp_host_dissector_info, ENDPOINT_DCCP);
-    add_hostlist_table_data(hash, &dccphdr->ip_dst, dccphdr->dport, FALSE, 1, pinfo->fd->pkt_len, &dccp_host_dissector_info, ENDPOINT_DCCP);
+    add_endpoint_table_data(hash, &dccphdr->ip_src, dccphdr->sport, TRUE, 1, pinfo->fd->pkt_len, &dccp_host_dissector_info, ENDPOINT_DCCP);
+    add_endpoint_table_data(hash, &dccphdr->ip_dst, dccphdr->dport, FALSE, 1, pinfo->fd->pkt_len, &dccp_host_dissector_info, ENDPOINT_DCCP);
 
     return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-eth.c b/epan/dissectors/packet-eth.c
index 000e75ade4..2956e7e86f 100644
--- a/epan/dissectors/packet-eth.c
+++ b/epan/dissectors/packet-eth.c
@@ -167,7 +167,7 @@ eth_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_,
   return TAP_PACKET_REDRAW;
 }
 
-static const char* eth_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* eth_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
   if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == AT_ETHER))
     return "eth.addr";
@@ -175,7 +175,7 @@ static const char* eth_host_get_filter_type(hostlist_talker_t* host, conv_filter
   return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t eth_host_dissector_info = {&eth_host_get_filter_type};
+static et_dissector_info_t eth_host_dissector_info = {&eth_host_get_filter_type};
 
 static tap_packet_status
 eth_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -187,8 +187,8 @@ eth_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, cons
   /* Take two "add" passes per packet, adding for each direction, ensures that all
      packets are counted properly (even if address is sending to itself)
      XXX - this could probably be done more efficiently inside hostlist_table */
-  add_hostlist_table_data(hash, &ehdr->src, 0, TRUE, 1, pinfo->fd->pkt_len, &eth_host_dissector_info, ENDPOINT_NONE);
-  add_hostlist_table_data(hash, &ehdr->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &eth_host_dissector_info, ENDPOINT_NONE);
+  add_endpoint_table_data(hash, &ehdr->src, 0, TRUE, 1, pinfo->fd->pkt_len, &eth_host_dissector_info, ENDPOINT_NONE);
+  add_endpoint_table_data(hash, &ehdr->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &eth_host_dissector_info, ENDPOINT_NONE);
 
   return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-fc.c b/epan/dissectors/packet-fc.c
index 59a967d587..446138b707 100644
--- a/epan/dissectors/packet-fc.c
+++ b/epan/dissectors/packet-fc.c
@@ -206,7 +206,7 @@ fc_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_, c
     return TAP_PACKET_REDRAW;
 }
 
-static const char* fc_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* fc_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == AT_FC))
         return "fc.id";
@@ -214,7 +214,7 @@ static const char* fc_host_get_filter_type(hostlist_talker_t* host, conv_filter_
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t fc_host_dissector_info = {&fc_host_get_filter_type};
+static et_dissector_info_t fc_host_dissector_info = {&fc_host_get_filter_type};
 
 static tap_packet_status
 fc_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -226,8 +226,8 @@ fc_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const
     /* Take two "add" passes per packet, adding for each direction, ensures that all
     packets are counted properly (even if address is sending to itself)
     XXX - this could probably be done more efficiently inside hostlist_table */
-    add_hostlist_table_data(hash, &fchdr->s_id, 0, TRUE, 1, pinfo->fd->pkt_len, &fc_host_dissector_info, ENDPOINT_NONE);
-    add_hostlist_table_data(hash, &fchdr->d_id, 0, FALSE, 1, pinfo->fd->pkt_len, &fc_host_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &fchdr->s_id, 0, TRUE, 1, pinfo->fd->pkt_len, &fc_host_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &fchdr->d_id, 0, FALSE, 1, pinfo->fd->pkt_len, &fc_host_dissector_info, ENDPOINT_NONE);
 
     return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-fddi.c b/epan/dissectors/packet-fddi.c
index 27ee237154..2c1a5442a4 100644
--- a/epan/dissectors/packet-fddi.c
+++ b/epan/dissectors/packet-fddi.c
@@ -166,7 +166,7 @@ fddi_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_,
   return TAP_PACKET_REDRAW;
 }
 
-static const char* fddi_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* fddi_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
   if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == AT_ETHER))
     return "fddi.addr";
@@ -174,7 +174,7 @@ static const char* fddi_host_get_filter_type(hostlist_talker_t* host, conv_filte
   return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t fddi_host_dissector_info = {&fddi_host_get_filter_type};
+static et_dissector_info_t fddi_host_dissector_info = {&fddi_host_get_filter_type};
 
 static tap_packet_status
 fddi_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -186,8 +186,8 @@ fddi_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, con
   /* Take two "add" passes per packet, adding for each direction, ensures that all
   packets are counted properly (even if address is sending to itself)
   XXX - this could probably be done more efficiently inside hostlist_table */
-  add_hostlist_table_data(hash, &ehdr->src, 0, TRUE, 1, pinfo->fd->pkt_len, &fddi_host_dissector_info, ENDPOINT_NONE);
-  add_hostlist_table_data(hash, &ehdr->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &fddi_host_dissector_info, ENDPOINT_NONE);
+  add_endpoint_table_data(hash, &ehdr->src, 0, TRUE, 1, pinfo->fd->pkt_len, &fddi_host_dissector_info, ENDPOINT_NONE);
+  add_endpoint_table_data(hash, &ehdr->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &fddi_host_dissector_info, ENDPOINT_NONE);
 
   return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-ieee80211.c b/epan/dissectors/packet-ieee80211.c
index 803c6a5052..a6595696d7 100644
--- a/epan/dissectors/packet-ieee80211.c
+++ b/epan/dissectors/packet-ieee80211.c
@@ -8006,7 +8006,7 @@ wlan_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_,
 }
 
 static const char*
-wlan_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+wlan_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
   if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == wlan_address_type))
     return "wlan.addr";
@@ -8014,7 +8014,7 @@ wlan_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
   return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t wlan_host_dissector_info = {&wlan_host_get_filter_type};
+static et_dissector_info_t wlan_host_dissector_info = {&wlan_host_get_filter_type};
 
 static tap_packet_status
 wlan_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -8026,8 +8026,8 @@ wlan_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, con
   /* Take two "add" passes per packet, adding for each direction, ensures that all
   packets are counted properly (even if address is sending to itself)
   XXX - this could probably be done more efficiently inside hostlist_table */
-  add_hostlist_table_data(hash, &whdr->src, 0, TRUE, 1, pinfo->fd->pkt_len, &wlan_host_dissector_info, ENDPOINT_NONE);
-  add_hostlist_table_data(hash, &whdr->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &wlan_host_dissector_info, ENDPOINT_NONE);
+  add_endpoint_table_data(hash, &whdr->src, 0, TRUE, 1, pinfo->fd->pkt_len, &wlan_host_dissector_info, ENDPOINT_NONE);
+  add_endpoint_table_data(hash, &whdr->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &wlan_host_dissector_info, ENDPOINT_NONE);
 
   return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-ieee802154.c b/epan/dissectors/packet-ieee802154.c
index 7af53fc04f..e9b87d0fc9 100644
--- a/epan/dissectors/packet-ieee802154.c
+++ b/epan/dissectors/packet-ieee802154.c
@@ -5603,7 +5603,7 @@ static tap_packet_status ieee802154_conversation_packet(void *pct, packet_info *
     return TAP_PACKET_REDRAW;
 }
 
-static const char* ieee802154_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* ieee802154_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if (filter == CONV_FT_ANY_ADDRESS) {
         if (host->myaddress.type == ieee802_15_4_short_address_type)
@@ -5615,7 +5615,7 @@ static const char* ieee802154_host_get_filter_type(hostlist_talker_t* host, conv
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t ieee802154_host_dissector_info = {&ieee802154_host_get_filter_type };
+static et_dissector_info_t ieee802154_host_dissector_info = {&ieee802154_host_get_filter_type };
 
 static tap_packet_status ieee802154_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip _U_, tap_flags_t flags)
 {
@@ -5625,9 +5625,9 @@ static tap_packet_status ieee802154_hostlist_packet(void *pit, packet_info *pinf
     /* Take two "add" passes per packet, adding for each direction, ensures that all
      packets are counted properly (even if address is sending to itself)
      XXX - this could probably be done more efficiently inside hostlist_table */
-    add_hostlist_table_data(hash, &pinfo->dl_src, 0, TRUE, 1,
+    add_endpoint_table_data(hash, &pinfo->dl_src, 0, TRUE, 1,
             pinfo->fd->pkt_len, &ieee802154_host_dissector_info, ENDPOINT_NONE);
-    add_hostlist_table_data(hash, &pinfo->dl_dst, 0, FALSE, 1,
+    add_endpoint_table_data(hash, &pinfo->dl_dst, 0, FALSE, 1,
             pinfo->fd->pkt_len, &ieee802154_host_dissector_info, ENDPOINT_NONE);
 
     return TAP_PACKET_REDRAW;
diff --git a/epan/dissectors/packet-ip.c b/epan/dissectors/packet-ip.c
index b62224ba38..8e947021cc 100644
--- a/epan/dissectors/packet-ip.c
+++ b/epan/dissectors/packet-ip.c
@@ -516,7 +516,7 @@ ip_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_, c
     return TAP_PACKET_REDRAW;
 }
 
-static const char* ip_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* ip_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == AT_IPv4))
         return "ip.addr";
@@ -524,7 +524,7 @@ static const char* ip_host_get_filter_type(hostlist_talker_t* host, conv_filter_
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t ip_host_dissector_info = {&ip_host_get_filter_type};
+static et_dissector_info_t ip_host_dissector_info = {&ip_host_get_filter_type};
 
 static tap_packet_status
 ip_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -536,8 +536,8 @@ ip_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const
     /* Take two "add" passes per packet, adding for each direction, ensures that all
     packets are counted properly (even if address is sending to itself)
     XXX - this could probably be done more efficiently inside hostlist_table */
-    add_hostlist_table_data(hash, &iph->ip_src, 0, TRUE, 1, pinfo->fd->pkt_len, &ip_host_dissector_info, ENDPOINT_NONE);
-    add_hostlist_table_data(hash, &iph->ip_dst, 0, FALSE, 1, pinfo->fd->pkt_len, &ip_host_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &iph->ip_src, 0, TRUE, 1, pinfo->fd->pkt_len, &ip_host_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &iph->ip_dst, 0, FALSE, 1, pinfo->fd->pkt_len, &ip_host_dissector_info, ENDPOINT_NONE);
     return TAP_PACKET_REDRAW;
 }
 
diff --git a/epan/dissectors/packet-ipv6.c b/epan/dissectors/packet-ipv6.c
index 038f09ff4a..815bcc7162 100644
--- a/epan/dissectors/packet-ipv6.c
+++ b/epan/dissectors/packet-ipv6.c
@@ -541,7 +541,7 @@ ipv6_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_,
     return TAP_PACKET_REDRAW;
 }
 
-static const char* ipv6_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* ipv6_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == AT_IPv6))
         return "ipv6.addr";
@@ -549,7 +549,7 @@ static const char* ipv6_host_get_filter_type(hostlist_talker_t* host, conv_filte
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t ipv6_host_dissector_info = {&ipv6_host_get_filter_type};
+static et_dissector_info_t ipv6_host_dissector_info = {&ipv6_host_get_filter_type};
 
 static tap_packet_status
 ipv6_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -559,9 +559,9 @@ ipv6_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, con
 
     const ipv6_tap_info_t *ip6 = (const ipv6_tap_info_t *)vip;
 
-    add_hostlist_table_data(hash, &ip6->ip6_src, 0, TRUE, 1,
+    add_endpoint_table_data(hash, &ip6->ip6_src, 0, TRUE, 1,
                 pinfo->fd->pkt_len, &ipv6_host_dissector_info, ENDPOINT_NONE);
-    add_hostlist_table_data(hash, &ip6->ip6_dst, 0, FALSE, 1,
+    add_endpoint_table_data(hash, &ip6->ip6_dst, 0, FALSE, 1,
                 pinfo->fd->pkt_len, &ipv6_host_dissector_info, ENDPOINT_NONE);
 
     return TAP_PACKET_REDRAW;
diff --git a/epan/dissectors/packet-ipx.c b/epan/dissectors/packet-ipx.c
index c7e032639d..d69c2ff05c 100644
--- a/epan/dissectors/packet-ipx.c
+++ b/epan/dissectors/packet-ipx.c
@@ -161,7 +161,7 @@ ipx_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_,
 	return TAP_PACKET_REDRAW;
 }
 
-static const char* ipx_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* ipx_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
 	if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == AT_IPX))
 		return "ipx.addr";
@@ -169,7 +169,7 @@ static const char* ipx_host_get_filter_type(hostlist_talker_t* host, conv_filter
 	return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t ipx_host_dissector_info = {&ipx_host_get_filter_type};
+static et_dissector_info_t ipx_host_dissector_info = {&ipx_host_get_filter_type};
 
 static tap_packet_status
 ipx_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -182,8 +182,8 @@ ipx_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, cons
 	/* Take two "add" passes per packet, adding for each direction, ensures that all
 	packets are counted properly (even if address is sending to itself)
 	XXX - this could probably be done more efficiently inside hostlist_table */
-	add_hostlist_table_data(hash, &ipxh->ipx_src, 0, TRUE, 1, pinfo->fd->pkt_len, &ipx_host_dissector_info, ENDPOINT_NONE);
-	add_hostlist_table_data(hash, &ipxh->ipx_dst, 0, FALSE, 1, pinfo->fd->pkt_len, &ipx_host_dissector_info, ENDPOINT_NONE);
+	add_endpoint_table_data(hash, &ipxh->ipx_src, 0, TRUE, 1, pinfo->fd->pkt_len, &ipx_host_dissector_info, ENDPOINT_NONE);
+	add_endpoint_table_data(hash, &ipxh->ipx_dst, 0, FALSE, 1, pinfo->fd->pkt_len, &ipx_host_dissector_info, ENDPOINT_NONE);
 
 	return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-jxta.c b/epan/dissectors/packet-jxta.c
index 56af6ebc85..dfd9a88bfe 100644
--- a/epan/dissectors/packet-jxta.c
+++ b/epan/dissectors/packet-jxta.c
@@ -197,7 +197,7 @@ jxta_conversation_packet(void *pct, packet_info *pinfo _U_, epan_dissect_t *edt
     return TAP_PACKET_REDRAW;
 }
 
-static const char* jxta_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* jxta_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == uri_address_type))
         return "jxta.message.address";
@@ -205,7 +205,7 @@ static const char* jxta_host_get_filter_type(hostlist_talker_t* host, conv_filte
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t jxta_host_dissector_info = {&jxta_host_get_filter_type};
+static et_dissector_info_t jxta_host_dissector_info = {&jxta_host_get_filter_type};
 
 static tap_packet_status
 jxta_hostlist_packet(void *pit, packet_info *pinfo _U_, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -218,8 +218,8 @@ jxta_hostlist_packet(void *pit, packet_info *pinfo _U_, epan_dissect_t *edt _U_,
     /* Take two "add" passes per packet, adding for each direction, ensures that all
     packets are counted properly (even if address is sending to itself)
     XXX - this could probably be done more efficiently inside hostlist_table */
-    add_hostlist_table_data(hash, &jxtahdr->src_address, 0, TRUE, 1, jxtahdr->size, &jxta_host_dissector_info, ENDPOINT_NONE);
-    add_hostlist_table_data(hash, &jxtahdr->dest_address, 0, FALSE, 1, jxtahdr->size, &jxta_host_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &jxtahdr->src_address, 0, TRUE, 1, jxtahdr->size, &jxta_host_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &jxtahdr->dest_address, 0, FALSE, 1, jxtahdr->size, &jxta_host_dissector_info, ENDPOINT_NONE);
     return TAP_PACKET_REDRAW;
 }
 
diff --git a/epan/dissectors/packet-ncp.c b/epan/dissectors/packet-ncp.c
index fce248d91e..0f13959660 100644
--- a/epan/dissectors/packet-ncp.c
+++ b/epan/dissectors/packet-ncp.c
@@ -772,12 +772,12 @@ ncp_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_,
     return TAP_PACKET_REDRAW;
 }
 
-static const char* ncp_host_get_filter_type(hostlist_talker_t* host _U_, conv_filter_type_e filter)
+static const char* ncp_host_get_filter_type(endpoint_item_t* host _U_, conv_filter_type_e filter)
 {
     return ncp_conv_get_filter_type(NULL, filter);
 }
 
-static hostlist_dissector_info_t ncp_host_dissector_info = {&ncp_host_get_filter_type};
+static et_dissector_info_t ncp_host_dissector_info = {&ncp_host_get_filter_type};
 
 static tap_packet_status
 ncp_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip _U_, tap_flags_t flags)
@@ -790,8 +790,8 @@ ncp_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, cons
     /* Take two "add" passes per packet, adding for each direction, ensures that all
     packets are counted properly (even if address is sending to itself)
     XXX - this could probably be done more efficiently inside hostlist_table */
-    add_hostlist_table_data(hash, &pinfo->src, 0, TRUE, 1, pinfo->fd->pkt_len, &ncp_host_dissector_info, ENDPOINT_NCP);
-    add_hostlist_table_data(hash, &pinfo->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &ncp_host_dissector_info, ENDPOINT_NCP);
+    add_endpoint_table_data(hash, &pinfo->src, 0, TRUE, 1, pinfo->fd->pkt_len, &ncp_host_dissector_info, ENDPOINT_NCP);
+    add_endpoint_table_data(hash, &pinfo->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &ncp_host_dissector_info, ENDPOINT_NCP);
 
     return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-opensafety.c b/epan/dissectors/packet-opensafety.c
index 3c8f337a2e..9fef548d3f 100644
--- a/epan/dissectors/packet-opensafety.c
+++ b/epan/dissectors/packet-opensafety.c
@@ -1970,7 +1970,7 @@ static const char* opensafety_conv_get_filter_type(conv_item_t* conv, conv_filte
 
 static ct_dissector_info_t opensafety_ct_dissector_info = {&opensafety_conv_get_filter_type};
 
-static const char* opensafety_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* opensafety_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if (host->myaddress.type == AT_NUMERIC) {
         if (filter == CONV_FT_ANY_ADDRESS)
@@ -1984,7 +1984,7 @@ static const char* opensafety_get_filter_type(hostlist_talker_t* host, conv_filt
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t  opensafety_dissector_info = {&opensafety_get_filter_type};
+static et_dissector_info_t  opensafety_dissector_info = {&opensafety_get_filter_type};
 
 static tap_packet_status
 opensafety_conversation_packet(void *pct, packet_info *pinfo,
@@ -2028,8 +2028,8 @@ opensafety_hostlist_packet(void *pit, packet_info *pinfo,
     alloc_address_wmem(pinfo->pool, src, AT_NUMERIC, (int) sizeof(guint16), &sender);
     alloc_address_wmem(pinfo->pool, dst, AT_NUMERIC, (int) sizeof(guint16), &receiver);
 
-    add_hostlist_table_data(hash, src, 0, TRUE,  1, osinfo->msg_len, &opensafety_dissector_info, ENDPOINT_NONE);
-    add_hostlist_table_data(hash, dst, 0, FALSE, 1, osinfo->msg_len, &opensafety_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, src, 0, TRUE,  1, osinfo->msg_len, &opensafety_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, dst, 0, FALSE, 1, osinfo->msg_len, &opensafety_dissector_info, ENDPOINT_NONE);
 
     return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-rsvp.c b/epan/dissectors/packet-rsvp.c
index 78b4b1fdad..7a7f849061 100644
--- a/epan/dissectors/packet-rsvp.c
+++ b/epan/dissectors/packet-rsvp.c
@@ -2125,7 +2125,7 @@ rsvp_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_,
     return TAP_PACKET_REDRAW;
 }
 
-static const char* rsvp_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* rsvp_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == AT_IPv4))
         return "ip.addr";
@@ -2133,7 +2133,7 @@ static const char* rsvp_host_get_filter_type(hostlist_talker_t* host, conv_filte
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t rsvp_host_dissector_info = {&rsvp_host_get_filter_type};
+static et_dissector_info_t rsvp_host_dissector_info = {&rsvp_host_get_filter_type};
 
 static tap_packet_status
 rsvp_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -2148,8 +2148,8 @@ rsvp_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, con
      * itself). XXX - this could probably be done more efficiently inside
      * hostlist_table
      */
-    add_hostlist_table_data(hash, &rsvph->source, 0, TRUE, 1, pinfo->fd->pkt_len, &rsvp_host_dissector_info, ENDPOINT_NONE);
-    add_hostlist_table_data(hash, &rsvph->destination, 0, FALSE, 1, pinfo->fd->pkt_len, &rsvp_host_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &rsvph->source, 0, TRUE, 1, pinfo->fd->pkt_len, &rsvp_host_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &rsvph->destination, 0, FALSE, 1, pinfo->fd->pkt_len, &rsvp_host_dissector_info, ENDPOINT_NONE);
     return TAP_PACKET_REDRAW;
 }
 
diff --git a/epan/dissectors/packet-sctp.c b/epan/dissectors/packet-sctp.c
index 36924e713a..d0200bc65a 100644
--- a/epan/dissectors/packet-sctp.c
+++ b/epan/dissectors/packet-sctp.c
@@ -794,7 +794,7 @@ sctp_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_,
   return TAP_PACKET_REDRAW;
 }
 
-static const char* sctp_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* sctp_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if (filter == CONV_FT_SRC_PORT)
         return "sctp.srcport";
@@ -833,7 +833,7 @@ static const char* sctp_host_get_filter_type(hostlist_talker_t* host, conv_filte
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t sctp_host_dissector_info = {&sctp_host_get_filter_type};
+static et_dissector_info_t sctp_host_dissector_info = {&sctp_host_get_filter_type};
 
 static tap_packet_status
 sctp_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -846,8 +846,8 @@ sctp_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, con
   /* Take two "add" passes per packet, adding for each direction, ensures that all
   packets are counted properly (even if address is sending to itself)
   XXX - this could probably be done more efficiently inside hostlist_table */
-  add_hostlist_table_data(hash, &sctphdr->ip_src, sctphdr->sport, TRUE, 1, pinfo->fd->pkt_len, &sctp_host_dissector_info, ENDPOINT_SCTP);
-  add_hostlist_table_data(hash, &sctphdr->ip_dst, sctphdr->dport, FALSE, 1, pinfo->fd->pkt_len, &sctp_host_dissector_info, ENDPOINT_SCTP);
+  add_endpoint_table_data(hash, &sctphdr->ip_src, sctphdr->sport, TRUE, 1, pinfo->fd->pkt_len, &sctp_host_dissector_info, ENDPOINT_SCTP);
+  add_endpoint_table_data(hash, &sctphdr->ip_dst, sctphdr->dport, FALSE, 1, pinfo->fd->pkt_len, &sctp_host_dissector_info, ENDPOINT_SCTP);
 
   return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-sll.c b/epan/dissectors/packet-sll.c
index 602c8eb7f5..61e799f3ee 100644
--- a/epan/dissectors/packet-sll.c
+++ b/epan/dissectors/packet-sll.c
@@ -149,7 +149,7 @@ sll_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_,
 	return TAP_PACKET_REDRAW;
 }
 
-static const char* sll_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* sll_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
 	if ((filter == CONV_FT_SRC_ADDRESS) && (host->myaddress.type == AT_ETHER))
 		return "sll.src.eth";
@@ -166,7 +166,7 @@ static const char* sll_host_get_filter_type(hostlist_talker_t* host, conv_filter
 	return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t sll_host_dissector_info = {&sll_host_get_filter_type};
+static et_dissector_info_t sll_host_dissector_info = {&sll_host_get_filter_type};
 
 static tap_packet_status
 sll_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -176,7 +176,7 @@ sll_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, cons
 
 	const sll_tap_data *tap_data = (const sll_tap_data*)vip;
 
-	add_hostlist_table_data(hash, &tap_data->src_address, 0, TRUE, 1, pinfo->fd->pkt_len, &sll_host_dissector_info, ENDPOINT_NONE);
+	add_endpoint_table_data(hash, &tap_data->src_address, 0, TRUE, 1, pinfo->fd->pkt_len, &sll_host_dissector_info, ENDPOINT_NONE);
 
 	return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-tcp.c b/epan/dissectors/packet-tcp.c
index c24be4d904..07500648f7 100644
--- a/epan/dissectors/packet-tcp.c
+++ b/epan/dissectors/packet-tcp.c
@@ -956,7 +956,7 @@ mptcpip_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _
     return TAP_PACKET_REDRAW;
 }
 
-static const char* tcp_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* tcp_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if (filter == CONV_FT_SRC_PORT)
         return "tcp.srcport";
@@ -995,7 +995,7 @@ static const char* tcp_host_get_filter_type(hostlist_talker_t* host, conv_filter
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t tcp_host_dissector_info = {&tcp_host_get_filter_type};
+static et_dissector_info_t tcp_host_dissector_info = {&tcp_host_get_filter_type};
 
 static tap_packet_status
 tcpip_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -1008,8 +1008,8 @@ tcpip_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, co
     /* Take two "add" passes per packet, adding for each direction, ensures that all
     packets are counted properly (even if address is sending to itself)
     XXX - this could probably be done more efficiently inside hostlist_table */
-    add_hostlist_table_data(hash, &tcphdr->ip_src, tcphdr->th_sport, TRUE, 1, pinfo->fd->pkt_len, &tcp_host_dissector_info, ENDPOINT_TCP);
-    add_hostlist_table_data(hash, &tcphdr->ip_dst, tcphdr->th_dport, FALSE, 1, pinfo->fd->pkt_len, &tcp_host_dissector_info, ENDPOINT_TCP);
+    add_endpoint_table_data(hash, &tcphdr->ip_src, tcphdr->th_sport, TRUE, 1, pinfo->fd->pkt_len, &tcp_host_dissector_info, ENDPOINT_TCP);
+    add_endpoint_table_data(hash, &tcphdr->ip_dst, tcphdr->th_dport, FALSE, 1, pinfo->fd->pkt_len, &tcp_host_dissector_info, ENDPOINT_TCP);
 
     return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-tr.c b/epan/dissectors/packet-tr.c
index f759ac715e..e4511377c6 100644
--- a/epan/dissectors/packet-tr.c
+++ b/epan/dissectors/packet-tr.c
@@ -149,7 +149,7 @@ tr_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_, c
 	return TAP_PACKET_REDRAW;
 }
 
-static const char* tr_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* tr_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
 	if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == AT_ETHER))
 		return "tr.addr";
@@ -157,7 +157,7 @@ static const char* tr_host_get_filter_type(hostlist_talker_t* host, conv_filter_
 	return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t tr_host_dissector_info = {&tr_host_get_filter_type};
+static et_dissector_info_t tr_host_dissector_info = {&tr_host_get_filter_type};
 
 static tap_packet_status
 tr_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -170,8 +170,8 @@ tr_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const
 	/* Take two "add" passes per packet, adding for each direction, ensures that all
 	packets are counted properly (even if address is sending to itself)
 	XXX - this could probably be done more efficiently inside hostlist_table */
-	add_hostlist_table_data(hash, &trhdr->src, 0, TRUE, 1, pinfo->fd->pkt_len, &tr_host_dissector_info, ENDPOINT_NONE);
-	add_hostlist_table_data(hash, &trhdr->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &tr_host_dissector_info, ENDPOINT_NONE);
+	add_endpoint_table_data(hash, &trhdr->src, 0, TRUE, 1, pinfo->fd->pkt_len, &tr_host_dissector_info, ENDPOINT_NONE);
+	add_endpoint_table_data(hash, &trhdr->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &tr_host_dissector_info, ENDPOINT_NONE);
 
 	return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-udp.c b/epan/dissectors/packet-udp.c
index 127bba09ef..8ec2fb732c 100644
--- a/epan/dissectors/packet-udp.c
+++ b/epan/dissectors/packet-udp.c
@@ -286,7 +286,7 @@ udpip_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_
     return TAP_PACKET_REDRAW;
 }
 
-static const char* udp_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* udp_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
 
     if (filter == CONV_FT_SRC_PORT)
@@ -327,7 +327,7 @@ static const char* udp_host_get_filter_type(hostlist_talker_t* host, conv_filter
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t udp_host_dissector_info = {&udp_host_get_filter_type};
+static et_dissector_info_t udp_host_dissector_info = {&udp_host_get_filter_type};
 
 static tap_packet_status
 udpip_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
@@ -340,8 +340,8 @@ udpip_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, co
     /* Take two "add" passes per packet, adding for each direction, ensures that all
     packets are counted properly (even if address is sending to itself)
     XXX - this could probably be done more efficiently inside hostlist_table */
-    add_hostlist_table_data(hash, &udphdr->ip_src, udphdr->uh_sport, TRUE, 1, pinfo->fd->pkt_len, &udp_host_dissector_info, ENDPOINT_UDP);
-    add_hostlist_table_data(hash, &udphdr->ip_dst, udphdr->uh_dport, FALSE, 1, pinfo->fd->pkt_len, &udp_host_dissector_info, ENDPOINT_UDP);
+    add_endpoint_table_data(hash, &udphdr->ip_src, udphdr->uh_sport, TRUE, 1, pinfo->fd->pkt_len, &udp_host_dissector_info, ENDPOINT_UDP);
+    add_endpoint_table_data(hash, &udphdr->ip_dst, udphdr->uh_dport, FALSE, 1, pinfo->fd->pkt_len, &udp_host_dissector_info, ENDPOINT_UDP);
 
     return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-usb.c b/epan/dissectors/packet-usb.c
index d802db0410..000d709ba1 100644
--- a/epan/dissectors/packet-usb.c
+++ b/epan/dissectors/packet-usb.c
@@ -1885,7 +1885,7 @@ usb_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_,
     return TAP_PACKET_REDRAW;
 }
 
-static const char* usb_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* usb_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == usb_address_type))
         return "usb.addr";
@@ -1899,7 +1899,7 @@ usb_col_filter_str(const address* addr _U_, gboolean is_src)
     return is_src ? "usb.src" : "usb.dst";
 }
 
-static hostlist_dissector_info_t usb_host_dissector_info = {&usb_host_get_filter_type};
+static et_dissector_info_t usb_host_dissector_info = {&usb_host_get_filter_type};
 
 static tap_packet_status
 usb_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip _U_, tap_flags_t flags)
@@ -1910,8 +1910,8 @@ usb_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, cons
     /* Take two "add" passes per packet, adding for each direction, ensures that all
        packets are counted properly (even if address is sending to itself)
        XXX - this could probably be done more efficiently inside hostlist_table */
-    add_hostlist_table_data(hash, &pinfo->src, 0, TRUE, 1, pinfo->fd->pkt_len, &usb_host_dissector_info, ENDPOINT_NONE);
-    add_hostlist_table_data(hash, &pinfo->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &usb_host_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &pinfo->src, 0, TRUE, 1, pinfo->fd->pkt_len, &usb_host_dissector_info, ENDPOINT_NONE);
+    add_endpoint_table_data(hash, &pinfo->dst, 0, FALSE, 1, pinfo->fd->pkt_len, &usb_host_dissector_info, ENDPOINT_NONE);
 
     return TAP_PACKET_REDRAW;
 }
diff --git a/epan/dissectors/packet-zbee-nwk.c b/epan/dissectors/packet-zbee-nwk.c
index bf2d0c015b..4853164938 100644
--- a/epan/dissectors/packet-zbee-nwk.c
+++ b/epan/dissectors/packet-zbee-nwk.c
@@ -1825,7 +1825,7 @@ static tap_packet_status zbee_nwk_conversation_packet(void *pct, packet_info *pi
     return TAP_PACKET_REDRAW;
 }
 
-static const char* zbee_nwk_host_get_filter_type(hostlist_talker_t* host, conv_filter_type_e filter)
+static const char* zbee_nwk_host_get_filter_type(endpoint_item_t* host, conv_filter_type_e filter)
 {
     if ((filter == CONV_FT_ANY_ADDRESS) && (host->myaddress.type == zbee_nwk_address_type))
         return "zbee_nwk.addr";
@@ -1833,7 +1833,7 @@ static const char* zbee_nwk_host_get_filter_type(hostlist_talker_t* host, conv_f
     return CONV_FILTER_INVALID;
 }
 
-static hostlist_dissector_info_t zbee_nwk_host_dissector_info = {&zbee_nwk_host_get_filter_type };
+static et_dissector_info_t zbee_nwk_host_dissector_info = {&zbee_nwk_host_get_filter_type };
 
 static tap_packet_status zbee_nwk_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip _U_, tap_flags_t flags)
 {
@@ -1843,9 +1843,9 @@ static tap_packet_status zbee_nwk_hostlist_packet(void *pit, packet_info *pinfo,
     /* Take two "add" passes per packet, adding for each direction, ensures that all
      packets are counted properly (even if address is sending to itself)
      XXX - this could probably be done more efficiently inside hostlist_table */
-    add_hostlist_table_data(hash, &pinfo->net_src, 0, TRUE, 1,
+    add_endpoint_table_data(hash, &pinfo->net_src, 0, TRUE, 1,
             pinfo->fd->pkt_len, &zbee_nwk_host_dissector_info, ENDPOINT_NONE);
-    add_hostlist_table_data(hash, &pinfo->net_dst, 0, FALSE, 1,
+    add_endpoint_table_data(hash, &pinfo->net_dst, 0, FALSE, 1,
             pinfo->fd->pkt_len, &zbee_nwk_host_dissector_info, ENDPOINT_NONE);
 
     return TAP_PACKET_REDRAW;