static void
prefs_register_p7(void)
{
static guint tcp_port = 0;
/* de-register the old port */
/* port 102 is registered by TPKT - don't undo this! */
if((tcp_port > 0) && (tcp_port != 102) && tpkt_handle)
dissector_delete_uint("tcp.port", tcp_port, tpkt_handle);
/* Set our port number for future use */
tcp_port = global_p7_tcp_port;
if((tcp_port > 0) && (tcp_port != 102) && tpkt_handle)
dissector_add_uint("tcp.port", global_p7_tcp_port, tpkt_handle);
}
void
proto_reg_handoff_mactelnet(void)
{
static gboolean initialized = FALSE;
static guint current_port;
static dissector_handle_t mactelnet_handle;
if (!initialized) {
mactelnet_handle = new_create_dissector_handle(dissect_mactelnet, proto_mactelnet);
data_handle = find_dissector("data");
initialized = TRUE;
} else {
dissector_delete_uint("udp.port", current_port, mactelnet_handle);
}
current_port = global_mactelnet_port;
dissector_add_uint("udp.port", current_port, mactelnet_handle);
}
void
proto_reg_handoff_uhd(void)
{
static gboolean uhd_prefs_initialized = FALSE;
static dissector_handle_t uhd_handle;
static gint dissector_port;
if (!uhd_prefs_initialized) {
uhd_handle = create_dissector_handle(dissect_uhd, proto_uhd);
uhd_prefs_initialized = TRUE;
} else {
dissector_delete_uint("udp.port", dissector_port, uhd_handle);
}
dissector_port = dissector_port_pref;
dissector_add_uint("udp.port", dissector_port, uhd_handle);
}
void
proto_reg_handoff_pcli(void) {
static gboolean pcli_initialized = FALSE;
static dissector_handle_t pcli_handle;
static guint udp_port_pcli;
if(!pcli_initialized) {
pcli_handle = create_dissector_handle(dissect_pcli,proto_pcli);
ip_handle = find_dissector("ip");
pcli_initialized = TRUE;
} else {
dissector_delete_uint("udp.port",udp_port_pcli,pcli_handle);
}
udp_port_pcli = global_udp_port_pcli;
dissector_add_uint("udp.port",global_udp_port_pcli,pcli_handle);
}
void
proto_reg_handoff_itdm(void)
{
static gboolean Initialized=FALSE;
static dissector_handle_t itdm_handle;
static guint ItdmMPLSLabel;
if (!Initialized) {
itdm_handle = find_dissector("itdm");
data_handle = find_dissector("data");
Initialized=TRUE;
} else {
dissector_delete_uint("mpls.label", ItdmMPLSLabel, itdm_handle);
}
ItdmMPLSLabel = gbl_ItdmMPLSLabel;
dissector_add_uint("mpls.label", gbl_ItdmMPLSLabel, itdm_handle);
}
/* Register handoff routine for DIS dissector. This will be invoked initially
* and when the preferences are changed, to handle changing the UDP port for
* which this dissector is registered.
*/
void proto_reg_handoff_dis(void)
{
static gboolean dis_prefs_initialized = FALSE;
static dissector_handle_t dis_dissector_handle;
static guint saved_dis_udp_port;
if (!dis_prefs_initialized)
{
dis_dissector_handle = new_create_dissector_handle(dissect_dis, proto_dis);
dis_prefs_initialized = TRUE;
}
else
{
dissector_delete_uint("udp.port", saved_dis_udp_port, dis_dissector_handle);
}
dissector_add_uint("udp.port", dis_udp_port, dis_dissector_handle);
saved_dis_udp_port = dis_udp_port;
}
/* The registration hand-off routine */
void
proto_reg_handoff_lwres(void)
{
static gboolean lwres_prefs_initialized = FALSE;
static dissector_handle_t lwres_handle;
static guint lwres_port;
if(!lwres_prefs_initialized) {
lwres_handle = create_dissector_handle(dissect_lwres, proto_lwres);
lwres_prefs_initialized = TRUE;
}
else {
dissector_delete_uint("udp.port", lwres_port, lwres_handle);
}
dissector_add_uint("udp.port", global_lwres_port, lwres_handle);
lwres_port = global_lwres_port;
}
void
proto_reg_handoff_atmtcp(void)
{
static gboolean initialized = FALSE;
static dissector_handle_t atmtcp_handle;
static int current_port;
if (!initialized) {
atmtcp_handle = new_create_dissector_handle(dissect_atmtcp, proto_atmtcp);
data_handle = find_dissector("data");
initialized = TRUE;
} else {
dissector_delete_uint("tcp.port", current_port, atmtcp_handle);
}
current_port = global_atmtcp_tcp_port;
dissector_add_uint("tcp.port", current_port, atmtcp_handle);
}
void
proto_reg_handoff_tcpencap(void)
{
static dissector_handle_t tcpencap_handle;
static gboolean initialized = FALSE;
static guint tcpencap_tcp_port;
if (!initialized) {
tcpencap_handle = new_create_dissector_handle(dissect_tcpencap, proto_tcpencap);
esp_handle = find_dissector("esp");
udp_handle = find_dissector("udp");
initialized = TRUE;
} else {
dissector_delete_uint("tcp.port", tcpencap_tcp_port, tcpencap_handle);
}
tcpencap_tcp_port = global_tcpencap_tcp_port;
dissector_add_uint("tcp.port", global_tcpencap_tcp_port, tcpencap_handle);
}
void
proto_reg_handoff_osi(void)
{
static gboolean osi_prefs_initialized = FALSE;
static dissector_handle_t osi_tpkt_handle, osi_juniper_handle;
static guint tcp_port_osi_over_tpkt;
if (!osi_prefs_initialized) {
osi_handle = create_dissector_handle(dissect_osi, proto_osi);
dissector_add_uint("llc.dsap", SAP_OSINL1, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL2, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL3, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL4, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL5, osi_handle);
dissector_add_uint("ppp.protocol", PPP_OSI, osi_handle);
dissector_add_uint("chdlc.protocol", CHDLCTYPE_OSI, osi_handle);
dissector_add_uint("null.type", BSD_AF_ISO, osi_handle);
dissector_add_uint("gre.proto", SAP_OSINL5, osi_handle);
dissector_add_uint("ip.proto", IP_PROTO_ISOIP, osi_handle); /* ISO network layer PDUs [RFC 1070] */
osi_juniper_handle = create_dissector_handle(dissect_osi_juniper, proto_osi);
dissector_add_uint("juniper.proto", JUNIPER_PROTO_ISO, osi_juniper_handle);
dissector_add_uint("juniper.proto", JUNIPER_PROTO_CLNP, osi_juniper_handle);
dissector_add_uint("juniper.proto", JUNIPER_PROTO_MPLS_CLNP, osi_juniper_handle);
data_handle = find_dissector("data");
ppp_handle = find_dissector("ppp");
osi_tpkt_handle = create_dissector_handle(dissect_osi_tpkt, proto_osi);
dissector_add_for_decode_as("tcp.port", osi_tpkt_handle);
osi_prefs_initialized = TRUE;
} else {
if (tcp_port_osi_over_tpkt != 0) {
dissector_delete_uint("tcp.port", tcp_port_osi_over_tpkt, osi_tpkt_handle);
}
}
if (global_tcp_port_osi_over_tpkt != 0) {
dissector_add_uint("tcp.port", global_tcp_port_osi_over_tpkt, osi_tpkt_handle);
}
tcp_port_osi_over_tpkt = global_tcp_port_osi_over_tpkt;
}
void
proto_reg_handoff_quakeworld(void)
{
static gboolean Initialized=FALSE;
static dissector_handle_t quakeworld_handle;
static guint ServerPort;
if (!Initialized) {
quakeworld_handle = create_dissector_handle(dissect_quakeworld,
proto_quakeworld);
data_handle = find_dissector("data");
Initialized=TRUE;
} else {
dissector_delete_uint("udp.port", ServerPort, quakeworld_handle);
}
/* set port for future deletes */
ServerPort=gbl_quakeworldServerPort;
dissector_add_uint("udp.port", gbl_quakeworldServerPort, quakeworld_handle);
}
void
proto_reg_handoff_hp_erm(void)
{
static dissector_handle_t hp_erm_handle;
static guint hp_erm_udp_port;
static gboolean initialized = FALSE;
if (!initialized) {
eth_withoutfcs_handle = find_dissector("eth_withoutfcs");
hp_erm_handle = create_dissector_handle(dissect_hp_erm, proto_hp_erm);
initialized = TRUE;
} else {
if (hp_erm_udp_port != 0)
dissector_delete_uint("udp.port", hp_erm_udp_port, hp_erm_handle);
}
hp_erm_udp_port = global_hp_erm_udp_port;
if (hp_erm_udp_port != 0)
dissector_add_uint("udp.port", hp_erm_udp_port, hp_erm_handle);
}
/*--- proto_reg_handoff_rua ---------------------------------------*/
void
proto_reg_handoff_rua(void)
{
static gboolean initialized = FALSE;
static dissector_handle_t rua_handle;
static guint sctp_port;
if (!initialized) {
rua_handle = find_dissector("rua");
ranap_handle = find_dissector("ranap");
dissector_add_uint("sctp.ppi", RUA_PAYLOAD_PROTOCOL_ID, rua_handle);
initialized = TRUE;
#include "packet-rua-dis-tab.c"
} else {
dissector_delete_uint("sctp.port", sctp_port, rua_handle);
}
/* Set our port number for future use */
sctp_port = global_sctp_port;
dissector_add_uint("sctp.port", sctp_port, rua_handle);
}
void
proto_reg_handoff_evrc(void)
{
static gboolean evrc_prefs_initialized = FALSE;
static dissector_handle_t evrc_legacy_handle;
if (!evrc_prefs_initialized)
{
dissector_handle_t evrc_handle;
dissector_handle_t evrcb_handle;
dissector_handle_t evrcwb_handle;
dissector_handle_t evrcnw_handle;
dissector_handle_t evrcnw2k_handle;
evrc_handle = create_dissector_handle(dissect_evrc, proto_evrc);
evrcb_handle = create_dissector_handle(dissect_evrcb, proto_evrc);
evrcwb_handle = create_dissector_handle(dissect_evrcwb, proto_evrc);
evrcnw_handle = create_dissector_handle(dissect_evrcnw, proto_evrc);
evrcnw2k_handle = create_dissector_handle(dissect_evrcnw2k, proto_evrc);
evrc_legacy_handle = create_dissector_handle(dissect_evrc_legacy, proto_evrc);
/* header-full mime types */
dissector_add_string("rtp_dyn_payload_type", "EVRC", evrc_handle);
dissector_add_string("rtp_dyn_payload_type", "EVRCB", evrcb_handle);
dissector_add_string("rtp_dyn_payload_type", "EVRCWB", evrcwb_handle);
dissector_add_string("rtp_dyn_payload_type", "EVRCNW", evrcnw_handle);
dissector_add_string("rtp_dyn_payload_type", "EVRCNW2K", evrcnw2k_handle);
evrc_prefs_initialized = TRUE;
}
else
{
dissector_delete_uint("rtp.pt", 60, evrc_legacy_handle);
}
if (legacy_pt_60)
{
dissector_add_uint("rtp.pt", 60, evrc_legacy_handle);
}
}
/*--- proto_reg_handoff_brp -------------------------------------------*/
void proto_reg_handoff_brp(void)
{
static gboolean initialized = FALSE;
static dissector_handle_t brp_handle;
static guint saved_brp_port;
if (!initialized) {
brp_handle = new_create_dissector_handle(dissect_brp, proto_brp);
dissector_add_handle("udp.port", brp_handle);
initialized = TRUE;
} else {
if (saved_brp_port != 0) {
dissector_delete_uint("udp.port", saved_brp_port, brp_handle);
}
}
/* Set the port number */
if (global_brp_port != 0) {
dissector_add_uint("udp.port", global_brp_port, brp_handle);
}
saved_brp_port = global_brp_port;
}
void proto_reg_handoff_netdump(void)
{
static gboolean initalized = FALSE;
static dissector_handle_t netdump_handle;
static int CurrentPort;
if (!initalized) {
netdump_handle = create_dissector_handle(dissect_netdump,
proto_netdump);
dissector_add_handle("udp.port", netdump_handle); /* For Decode As */
initalized = TRUE;
} else {
if (CurrentPort != 0)
dissector_delete_uint("udp.port", CurrentPort, netdump_handle);
}
CurrentPort = gPORT_PREF;
if (CurrentPort != 0)
dissector_add_uint("udp.port", CurrentPort, netdump_handle);
}
void
proto_reg_handoff_moldudp(void)
{
static gboolean initialized = FALSE;
static dissector_handle_t moldudp_handle;
static int currentPort;
if (!initialized) {
moldudp_handle = new_create_dissector_handle(dissect_moldudp,
proto_moldudp);
initialized = TRUE;
} else {
dissector_delete_uint("udp.port", currentPort, moldudp_handle);
}
currentPort = pf_moldudp_port;
dissector_add_uint("udp.port", currentPort, moldudp_handle);
}
void
proto_reg_handoff_cwids(void)
{
static dissector_handle_t cwids_handle;
static guint saved_udp_port;
static gboolean initialized = FALSE;
if (!initialized) {
cwids_handle = create_dissector_handle(dissect_cwids, proto_cwids);
dissector_add_handle("udp.port", cwids_handle);
ieee80211_handle = find_dissector("wlan");
initialized = TRUE;
} else {
if (saved_udp_port != 0) {
dissector_delete_uint("udp.port", saved_udp_port, cwids_handle);
}
}
if (global_udp_port != 0) {
dissector_add_uint("udp.port", global_udp_port, cwids_handle);
}
saved_udp_port = global_udp_port;
}
void
proto_reg_handoff_newmail(void)
{
static gboolean inited = FALSE;
static dissector_handle_t newmail_handle;
static guint preference_default_port_last;
if(!inited) {
newmail_handle = find_dissector("newmail");
dissector_add_handle("udp.port", newmail_handle); /* for 'decode-as' */
inited = TRUE;
} else {
if (preference_default_port_last != 0) {
dissector_delete_uint("udp.port", preference_default_port_last, newmail_handle);
}
}
if(preference_default_port != 0) {
dissector_add_uint("udp.port", preference_default_port, newmail_handle);
}
preference_default_port_last = preference_default_port;
}
void
proto_reg_handoff_h263P(void)
{
static dissector_handle_t h263P_handle;
static guint dynamic_payload_type;
static gboolean h263P_prefs_initialized = FALSE;
if (!h263P_prefs_initialized) {
h263P_handle = find_dissector("h263P");
dissector_add_string("rtp_dyn_payload_type","H263-1998", h263P_handle);
dissector_add_string("rtp_dyn_payload_type","H263-2000", h263P_handle);
h263P_prefs_initialized = TRUE;
}
else {
if ( dynamic_payload_type > 95 )
dissector_delete_uint("rtp.pt", dynamic_payload_type, h263P_handle);
}
dynamic_payload_type = temp_dynamic_payload_type;
if ( dynamic_payload_type > 95 ){
dissector_add_uint("rtp.pt", dynamic_payload_type, h263P_handle);
}
}
/*--- proto_reg_handoff_x2ap ---------------------------------------*/
void
proto_reg_handoff_x2ap(void)
{
static gboolean Initialized=FALSE;
static guint SctpPort;
if (!Initialized) {
dissector_add_for_decode_as("sctp.port", x2ap_handle);
dissector_add_uint("sctp.ppi", X2AP_PAYLOAD_PROTOCOL_ID, x2ap_handle);
Initialized=TRUE;
#include "packet-x2ap-dis-tab.c"
} else {
if (SctpPort != 0) {
dissector_delete_uint("sctp.port", SctpPort, x2ap_handle);
}
}
SctpPort=gbl_x2apSctpPort;
if (SctpPort != 0) {
dissector_add_uint("sctp.port", SctpPort, x2ap_handle);
}
}
/* The registration hand-off routine */
void proto_reg_handoff_actrace(void)
{
static gboolean actrace_prefs_initialized = FALSE;
static dissector_handle_t actrace_handle;
static guint actrace_udp_port;
if (!actrace_prefs_initialized)
{
actrace_handle = new_create_dissector_handle(dissect_actrace, proto_actrace);
/* Get a handle for the lapd dissector. */
lapd_handle = find_dissector("lapd");
actrace_prefs_initialized = TRUE;
}
else
{
dissector_delete_uint("udp.port", actrace_udp_port, actrace_handle);
}
/* Set our port number for future use */
actrace_udp_port = global_actrace_udp_port;
dissector_add_uint("udp.port", global_actrace_udp_port, actrace_handle);
}
void
proto_reg_handoff_dtpt(void)
{
static dissector_handle_t dtpt_handle;
static gboolean Initialized=FALSE;
static int ServerPort;
if (!Initialized) {
dtpt_handle = new_create_dissector_handle(dissect_dtpt, proto_dtpt);
dtpt_conversation_handle = new_create_dissector_handle(dissect_dtpt_conversation, proto_dtpt);
/** dtpt_data_handle = new_create_dissector_handle(dissect_dtpt_data, proto_dtpt); **/
data_handle = find_dissector("data");
Initialized=TRUE;
} else {
dissector_delete_uint("tcp.port", ServerPort, dtpt_handle);
}
/* set port for future deletes */
ServerPort=gbl_dtptServerPort;
dissector_add_uint("tcp.port", gbl_dtptServerPort, dtpt_handle);
}
/*--- proto_reg_handoff_sbc_ap ---------------------------------------*/
void
proto_reg_handoff_sbc_ap(void)
{
static gboolean inited = FALSE;
static guint SctpPort;
if( !inited ) {
sbc_ap_handle = create_dissector_handle(dissect_sbc_ap, proto_sbc_ap);
dissector_add_uint("sctp.ppi", SBC_AP_PAYLOAD_PROTOCOL_ID, sbc_ap_handle);
inited = TRUE;
#include "packet-sbc-ap-dis-tab.c"
} else {
if (SctpPort != 0) {
dissector_delete_uint("sctp.port", SctpPort, sbc_ap_handle);
}
}
SctpPort = global_sbc_ap_port;
if (SctpPort != 0) {
dissector_add_uint("sctp.port", SctpPort, sbc_ap_handle);
}
}
void
proto_reg_handoff_osi(void)
{
static gboolean osi_prefs_initialized = FALSE;
static dissector_handle_t osi_tpkt_handle;
static guint tcp_port_osi_over_tpkt;
if (!osi_prefs_initialized) {
osi_handle = create_dissector_handle(dissect_osi, proto_osi);
dissector_add_uint("llc.dsap", SAP_OSINL1, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL2, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL3, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL4, osi_handle);
dissector_add_uint("llc.dsap", SAP_OSINL5, osi_handle);
dissector_add_uint("ppp.protocol", PPP_OSI, osi_handle);
dissector_add_uint("chdlc.protocol", CHDLCTYPE_OSI, osi_handle);
dissector_add_uint("null.type", BSD_AF_ISO, osi_handle);
dissector_add_uint("gre.proto", SAP_OSINL5, osi_handle);
dissector_add_uint("ip.proto", IP_PROTO_ISOIP, osi_handle); /* ISO-TP4 ISO Transport Protocol Class 4 [RFC905,RC77] */
data_handle = find_dissector("data");
ppp_handle = find_dissector("ppp");
osi_tpkt_handle = create_dissector_handle(dissect_osi_tpkt, proto_osi);
dissector_add_handle("tcp.port", osi_tpkt_handle); /* for 'decode-as' */
osi_prefs_initialized = TRUE;
} else {
if (tcp_port_osi_over_tpkt != 0) {
dissector_delete_uint("tcp.port", tcp_port_osi_over_tpkt, osi_tpkt_handle);
}
}
if (global_tcp_port_osi_over_tpkt != 0) {
dissector_add_uint("tcp.port", global_tcp_port_osi_over_tpkt, osi_tpkt_handle);
}
tcp_port_osi_over_tpkt = global_tcp_port_osi_over_tpkt;
}
/*FUNCTION:------------------------------------------------------
* NAME
* proto_reg_handoff_zep
* DESCRIPTION
* Registers the zigbee dissector with Wireshark.
* Will be called every time 'apply' is pressed in the preferences menu.
* PARAMETERS
* none
* RETURNS
* void
*---------------------------------------------------------------
*/
void proto_reg_handoff_zep(void)
{
static dissector_handle_t zep_handle;
static int lastPort;
static gboolean inited = FALSE;
if ( !inited) {
dissector_handle_t h;
/* Get dissector handles. */
if ( !(h = find_dissector("wpan")) ) { /* Try use built-in 802.15.4 disector */
h = find_dissector("ieee802154"); /* otherwise use older 802.15.4 plugin disector */
}
ieee802154_handle = h;
if ( !(h = find_dissector("wpan_cc24xx")) ) { /* Try use built-in 802.15.4 (Chipcon) disector */
h = find_dissector("ieee802154_ccfcs"); /* otherwise use older 802.15.4 (Chipcon) plugin disector */
}
ieee802154_ccfcs_handle = h;
if ( !(h = find_dissector("wpane")) ) { /* Try use built-in 802.15.4 disector */
h = find_dissector("ieee802154e"); /* otherwise use older 802.15.4 plugin disector */
}
ieee802154e_handle = h;
zep_handle = find_dissector("zep");
data_handle = find_dissector("data");
inited = TRUE;
} else {
/* If we were already registered, de-register our dissector
* to free the port. */
dissector_delete_uint("udp.port", lastPort, zep_handle);
}
/* Register our dissector. */
dissector_add_uint("udp.port", gPREF_zep_udp_port, zep_handle);
lastPort = gPREF_zep_udp_port;
} /* proto_reg_handoff_zep */
/*--- proto_reg_handoff_m3ap ---------------------------------------*/
void
proto_reg_handoff_m3ap(void)
{
static gboolean inited = FALSE;
static guint SctpPort;
if( !inited ) {
m3ap_handle = create_dissector_handle(dissect_m3ap, proto_m3ap);
dissector_add_uint("sctp.ppi", PROTO_3GPP_M3AP_PROTOCOL_ID, m3ap_handle);
inited = TRUE;
#include "packet-m3ap-dis-tab.c"
dissector_add_uint("m3ap.extension", 17, new_create_dissector_handle(dissect_AllocationAndRetentionPriority_PDU, proto_m3ap));
}
else {
if (SctpPort != 0) {
dissector_delete_uint("sctp.port", SctpPort, m3ap_handle);
}
}
SctpPort = global_m3ap_port;
if (SctpPort != 0) {
dissector_add_uint("sctp.port", SctpPort, m3ap_handle);
}
}
/* Register the protocol with Wireshark */
static void range_delete_nasdaq_soup_tcp_callback(guint32 port) {
dissector_delete_uint("tcp.port", port, nasdaq_soup_handle);
}
static void ipa_udp_delete_callback(guint32 port)
{
if (port)
dissector_delete_uint("udp.port", port, ipa_handle);
}
void
proto_reg_handoff_forces(void)
{
static gboolean inited = FALSE;
static guint alternate_tcp_port = 0; /* 3000 */
static guint alternate_udp_port = 0;
static guint alternate_sctp_high_prio_channel_port = 0; /* 6700 */
static guint alternate_sctp_med_prio_channel_port = 0;
static guint alternate_sctp_low_prio_channel_port = 0;
static dissector_handle_t forces_handle_tcp, forces_handle;
if (!inited) {
forces_handle_tcp = create_dissector_handle(dissect_forces_tcp, proto_forces);
forces_handle = create_dissector_handle(dissect_forces_not_tcp, proto_forces);
ip_handle = find_dissector("ip");
inited = TRUE;
}
/* Register TCP port for dissection */
if ((alternate_tcp_port != 0) && (alternate_tcp_port != forces_alternate_tcp_port))
dissector_delete_uint("tcp.port", alternate_tcp_port, forces_handle_tcp);
if ((forces_alternate_tcp_port != 0) && (alternate_tcp_port != forces_alternate_tcp_port))
dissector_add_uint("tcp.port", forces_alternate_tcp_port, forces_handle_tcp);
alternate_tcp_port = forces_alternate_tcp_port;
/* Register UDP port for dissection */
if ((alternate_udp_port != 0) && (alternate_udp_port != forces_alternate_udp_port))
dissector_delete_uint("udp.port", alternate_udp_port, forces_handle);
if ((forces_alternate_udp_port != 0) && (alternate_udp_port != forces_alternate_udp_port))
dissector_add_uint("udp.port", forces_alternate_udp_port, forces_handle);
alternate_udp_port = forces_alternate_udp_port;
/* Register SCTP port for high priority dissection */
if ((alternate_sctp_high_prio_channel_port != 0) &&
(alternate_sctp_high_prio_channel_port != forces_alternate_sctp_high_prio_channel_port))
dissector_delete_uint("sctp.port", alternate_sctp_high_prio_channel_port, forces_handle);
if ((forces_alternate_sctp_high_prio_channel_port != 0) &&
(alternate_sctp_high_prio_channel_port != forces_alternate_sctp_high_prio_channel_port))
dissector_add_uint("sctp.port", forces_alternate_sctp_high_prio_channel_port, forces_handle);
alternate_sctp_high_prio_channel_port = forces_alternate_sctp_high_prio_channel_port;
/* Register SCTP port for medium priority dissection */
if ((alternate_sctp_med_prio_channel_port != 0) &&
(alternate_sctp_med_prio_channel_port != forces_alternate_sctp_med_prio_channel_port))
dissector_delete_uint("udp.port", alternate_sctp_med_prio_channel_port, forces_handle);
if ((forces_alternate_sctp_med_prio_channel_port != 0) &&
(alternate_sctp_med_prio_channel_port != forces_alternate_sctp_med_prio_channel_port))
dissector_add_uint("udp.port", forces_alternate_sctp_med_prio_channel_port, forces_handle);
alternate_sctp_med_prio_channel_port = forces_alternate_sctp_med_prio_channel_port;
/* Register SCTP port for low priority dissection */
if ((alternate_sctp_low_prio_channel_port != 0) &&
(alternate_sctp_low_prio_channel_port != forces_alternate_sctp_low_prio_channel_port))
dissector_delete_uint("udp.port", alternate_sctp_low_prio_channel_port, forces_handle);
if ((forces_alternate_sctp_low_prio_channel_port != 0) &&
(alternate_sctp_low_prio_channel_port != forces_alternate_sctp_low_prio_channel_port))
dissector_add_uint("udp.port", forces_alternate_sctp_low_prio_channel_port, forces_handle);
alternate_sctp_low_prio_channel_port = forces_alternate_sctp_low_prio_channel_port;
}
