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; }