/* Register Protocol handler */ void proto_reg_handoff_mysensors(void) { mysensors_handle = create_dissector_handle(dissect_mysensors, proto_mysensors); heur_dissector_add("nrf24" /*parent protocol*/, dissect_mysensors_heur, proto_mysensors); heur_dissector_add("rhmesh" /*parent protocol*/, dissect_mysensors_heur, proto_mysensors); data_handle = find_dissector("data"); }
void proto_reg_handoff_h1(void) { heur_dissector_add("cotp", dissect_h1, proto_h1); heur_dissector_add("cotp_is", dissect_h1, proto_h1); heur_dissector_add("tcp", dissect_h1, proto_h1); data_handle = find_dissector("data"); }
void proto_reg_handoff_lanforge(void) { /* Register as a heuristic UDP dissector */ heur_dissector_add("udp", dissect_lanforge, proto_lanforge); heur_dissector_add("tcp", dissect_lanforge, proto_lanforge); /* Find data dissector handle */ data_handle = find_dissector("data"); }
void proto_reg_handoff_ses(void) { /* find data dissector */ data_handle = find_dissector("data"); /* define sub dissector */ pres_handle = find_dissector("pres"); /* add our session dissector to cotp dissector list * and cotp_is dissector list*/ heur_dissector_add("cotp", dissect_ses_heur, proto_ses); heur_dissector_add("cotp_is", dissect_ses_heur, proto_ses); }
void proto_reg_handoff_ndef(void) { dissector_handle_t ndef_handle; ndef_handle = new_create_dissector_handle(dissect_ndef, proto_ndef); heur_dissector_add("snep.ndef", dissect_ndef, proto_ndef); }
void proto_reg_handoff_pn_mrrt (void) { /* register ourself as an heuristic pn-rt payload dissector */ heur_dissector_add("pn_rt", dissect_PNMRRT_Data_heur, "PROFINET MRRT IO", "pn_mrrt_pn_rt", proto_pn_mrrt, HEURISTIC_ENABLE); }
void proto_reg_handoff_tuxedo(void) { tuxedo_handle = create_dissector_handle(dissect_tuxedo, proto_tuxedo); dissector_add_handle("tcp.port", tuxedo_handle); heur_dissector_add("tcp", dissect_tuxedo_heur, proto_tuxedo); }
void proto_reg_handoff_e100(void) { /* Check all UDP traffic, as the specific UDP port is configurable */ heur_dissector_add("udp", dissect_e100, proto_e100); /* e100 traffic encapsulates traffic from the ethernet frame on */ eth_handle = find_dissector("eth"); }
/* If this dissector uses sub-dissector registration add a registration routine. This format is required because a script is used to find these routines and create the code that calls these routines. */ void proto_reg_handoff_msrp(void) { msrp_handle = find_dissector("msrp"); dissector_add_handle("tcp.port", msrp_handle); /* for "decode-as" */ heur_dissector_add("tcp", dissect_msrp_heur, proto_msrp); media_type_dissector_table = find_dissector_table("media_type"); }
void proto_reg_handoff_pktgen(void) { /* Register as a heuristic UDP dissector */ heur_dissector_add("udp", dissect_pktgen, proto_pktgen); /* Find data dissector handle */ data_handle = find_dissector("data"); }
void proto_reg_handoff_tte(void) { heur_dissector_add("eth", dissect_tte, proto_tte); hf_eth_dst = proto_registrar_get_byname ("eth.dst")->id; hf_eth_src = proto_registrar_get_byname ("eth.src")->id; hf_eth_type = proto_registrar_get_byname ("eth.type")->id; }
void proto_reg_handoff_mpa(void) { /* * MPA does not use any specific TCP port so, when not on a specific * port, try this dissector whenever there is TCP traffic. */ heur_dissector_add("tcp", dissect_iwarp_mpa, "IWARP_MPA over TCP", "iwarp_mpa_tcp", proto_iwarp_mpa, HEURISTIC_ENABLE); ddp_rdmap_handle = find_dissector_add_dependency("iwarp_ddp_rdmap", proto_iwarp_mpa); }
/* handoff function */ void proto_reg_handoff_tfp(void) { dissector_handle_t tfp_handle_tcp; tfp_handle_tcp = create_dissector_handle(dissect_tfp_tcp, proto_tfp); dissector_add_uint("tcp.port", tfp_PORT, tfp_handle_tcp); heur_dissector_add("usb.bulk", dissect_tfp_bulk_heur, proto_tfp); }
void proto_reg_handoff_mpa(void) { /* * MPA does not use any specific TCP port so, when not on a specific * port, try this dissector whenever there is TCP traffic. */ heur_dissector_add("tcp", dissect_iwarp_mpa, proto_iwarp_mpa); ddp_rdmap_handle = find_dissector("iwarp_ddp_rdmap"); }
/* Handler registration */ void proto_reg_handoff_chdr(void) { /* register heuristic dissector for use with USB */ heur_dissector_add("usb.bulk", heur_dissect_chdr, proto_chdr); /* register dissector for UDP packets */ static dissector_handle_t chdr_handle; chdr_handle = create_dissector_handle(dissect_chdr, proto_chdr); dissector_add_uint("udp.port", CHDR_PORT, chdr_handle); }
void proto_reg_handoff_yhoo(void) { /* * DO NOT register for port 5050, as that's used by the * old and new Yahoo messenger protocols. * * Just register as a heuristic TCP dissector, and reject stuff * not to or from that port. */ heur_dissector_add("tcp", dissect_yhoo, proto_yhoo); }
void proto_reg_handoff_cattp(void) { static dissector_handle_t cattp_handle; /* Create dissector handle */ cattp_handle = create_dissector_handle(dissect_cattp, proto_cattp); data_handle = find_dissector("data"); dissector_add_uint("udp.port", gcattp_port, cattp_handle); heur_dissector_add("udp",dissect_cattp_heur,proto_cattp); }
void proto_reg_handoff_swift(void) { dissector_handle_t swift_handle; swift_handle = find_dissector("swift"); /* Allow "Decode As" with any UDP packet. */ dissector_add_handle("udp.port", swift_handle); /* Add our heuristic packet finder. */ heur_dissector_add("udp", dissect_swift_heur, proto_swift); }
/* * This format is required because a script is used to find these * routines and create the code that calls these routines. */ void proto_reg_handoff_fcip (void) { dissector_handle_t fcip_handle; heur_dissector_add("tcp", dissect_fcip_heur, proto_fcip); fcip_handle = create_dissector_handle(dissect_fcip_handle, proto_fcip); dissector_add_handle("tcp.port", fcip_handle); data_handle = find_dissector("data"); fc_handle = find_dissector("fc"); }
void proto_reg_handoff_interlink(void) { dissector_handle_t interlink_handle; interlink_handle = find_dissector("interlink"); /* Allow "Decode As" with any UDP packet. */ dissector_add_handle("udp.port", interlink_handle); /* Add our heuristic packet finder. */ heur_dissector_add("udp", dissect_interlink_heur, proto_interlink); data_handle = find_dissector("data"); }
void proto_reg_handoff_njack(void) { dissector_handle_t njack_handle; njack_handle = new_create_dissector_handle(dissect_njack_static, proto_njack); dissector_add_uint("udp.port", PORT_NJACK_PC, njack_handle); /* dissector_add_uint("tcp.port", PORT_NJACK_PC, njack_handle); */ dissector_add_uint("udp.port", PORT_NJACK_SWITCH, njack_handle); /* dissector_add_uint("tcp.port", PORT_NJACK_SWITCH, njack_handle); */ heur_dissector_add("udp", dissect_njack_heur, proto_njack); /* heur_dissector_add("tcp", dissect_njack_heur, proto_njack); */ }
void proto_reg_handoff_pana(void) { dissector_handle_t pana_handle; heur_dissector_add("udp", dissect_pana, proto_pana); pana_handle = new_create_dissector_handle(dissect_pana, proto_pana); dissector_add_handle("udp.port", pana_handle); eap_handle = find_dissector("eap"); /** if(!eap_handle) fprintf(stderr,"PANA warning: EAP dissector not found\n"); **/ }
void proto_reg_handoff_ccn(void) { static gboolean initialized = FALSE; static int current_ccn_port = -1; int global_ccn_port = atoi(CCN_DEFAULT_UNICAST_PORT); if (!initialized) { ccn_handle = new_create_dissector_handle(dissect_ccn, proto_ccn); heur_dissector_add("udp", dissect_ccn_heur, proto_ccn); heur_dissector_add("tcp", dissect_ccn_heur, proto_ccn); if (ccn_register_dtls) heur_dissector_add("dtls", dissect_ccn_heur, proto_ccn); initialized = TRUE; } if (current_ccn_port != -1) { dissector_delete("udp.port", current_ccn_port, ccn_handle); dissector_delete("tcp.port", current_ccn_port, ccn_handle); } dissector_add("udp.port", global_ccn_port, ccn_handle); dissector_add("tcp.port", global_ccn_port, ccn_handle); current_ccn_port = global_ccn_port; }
void proto_reg_handoff_applemidi( void ) { applemidi_handle = create_dissector_handle( dissect_applemidi, proto_applemidi ); /* If we cannot decode the data it will be RTP-MIDI since the Apple session protocol uses * two ports: the control-port and the MIDI-port. On both ports an invitation is being sent. * The second port is then used for the RTP-MIDI-data. So if we can't find valid AppleMidi * packets, it will be most likely RTP-MIDI... */ rtp_handle = find_dissector( "rtp" ); heur_dissector_add( "udp", dissect_applemidi_heur, proto_applemidi ); }
void proto_reg_handoff_dcp_etsi (void) { dissector_handle_t af_handle; dissector_handle_t pft_handle; dissector_handle_t tpl_handle; af_handle = create_dissector_handle(dissect_af, proto_af); pft_handle = create_dissector_handle(dissect_pft, proto_pft); tpl_handle = create_dissector_handle(dissect_tpl, proto_tpl); heur_dissector_add("udp", dissect_dcp_etsi, proto_dcp_etsi); dissector_add_string("dcp-etsi.sync", "AF", af_handle); dissector_add_string("dcp-etsi.sync", "PF", pft_handle); /* if there are ever other payload types ...*/ dissector_add("dcp-af.pt", 'T', tpl_handle); }
void proto_reg_handoff_bt_dht(void) { static gboolean prefs_initialized = FALSE; /* "Decode As" is always available; * Heuristic dissection in disabled by default since the heuristic is quite weak. */ if (!prefs_initialized) { heur_dissector_add("udp", dissect_bt_dht_heur, proto_bt_dht); bt_dht_handle = new_create_dissector_handle(dissect_bt_dht, proto_bt_dht); dissector_add_handle("udp.port", bt_dht_handle); /* for "decode_as" */ prefs_initialized = TRUE; } heur_dissector_set_enabled("udp", dissect_bt_dht_heur, proto_bt_dht, bt_dht_enable_heuristic_dissection); }
/* If this dissector uses sub-dissector registration add a registration routine. This exact format is required because a script is used to find these routines and create the code that calls these routines. */ void proto_reg_handoff_wol(void) { dissector_handle_t wol_handle; /* Use new_create_dissector_handle() to indicate that dissect_wol() * returns the number of bytes it dissected (or 0 if it thinks the packet * does not belong to PROTONAME). */ wol_handle = new_create_dissector_handle(dissect_wol, proto_wol); /* We don't really want to register with EVERY possible dissector, * do we? I know that the AMD white paper specifies that the * MagicPacket could be present in any frame, but are we seriously * going to register WOL with every other dissector!? I think not. * * Unless anyone has a better idea, just register with only those that * are in "common usage" and grow this list as needed. Yeah, I'm sure * we'll miss some, but how else to do this ... add a thousand of * these dissector_add_uint()'s and heur_dissector_add()'s??? */ dissector_add_uint("ethertype", ETHERTYPE_WOL, wol_handle); heur_dissector_add("udp", dissect_wol, proto_wol); }
void proto_reg_handoff_dlm_controld(void) { static gboolean register_dissector = FALSE; static dissector_handle_t dlm_controld_daemon_handle; static dissector_handle_t dlm_controld_ls_handle; if (register_dissector) { dissector_delete_string("openais_cpg.mar_name.value", DLM_CONTROLD_DAEMON_NAME, dlm_controld_daemon_handle); } else { dlm_controld_daemon_handle = new_create_dissector_handle(dissect_dlm_controld_daemon, proto_dlm_controld); register_dissector = TRUE; } dissector_add_string("openais_cpg.mar_name.value", DLM_CONTROLD_DAEMON_NAME, dlm_controld_daemon_handle); heur_dissector_add("openais_cpg", dissect_dlm_controld_ls, proto_dlm_controld); }
void proto_reg_handoff_mpeg_audio(void) { heur_dissector_add("mpeg", dissect_mpeg_audio, proto_mpeg_audio); }
void proto_reg_handoff_mqpcf(void) { heur_dissector_add("mq", dissect_mqpcf_heur, proto_mqpcf); }