/*--- proto_reg_handoff_h501 -------------------------------------------*/
void proto_reg_handoff_h501(void) 
{
  static gboolean h501_prefs_initialized = FALSE;
  static dissector_handle_t h501_udp_handle;
  static dissector_handle_t h501_tcp_handle;
  static guint saved_h501_udp_port;
  static guint saved_h501_tcp_port;

  if (!h501_prefs_initialized) {
    h501_pdu_handle = find_dissector(PFNAME);
    h501_udp_handle = new_create_dissector_handle(dissect_h501_udp, proto_h501);
    h501_tcp_handle = new_create_dissector_handle(dissect_h501_tcp, proto_h501);
    h501_prefs_initialized = TRUE;
  } else {
    dissector_delete("udp.port", saved_h501_udp_port, h501_udp_handle);
    dissector_delete("tcp.port", saved_h501_tcp_port, h501_tcp_handle);
  }

  /* Set our port number for future use */
  saved_h501_udp_port = h501_udp_port;
  dissector_add("udp.port", saved_h501_udp_port, h501_udp_handle);
  saved_h501_tcp_port = h501_tcp_port;
  dissector_add("tcp.port", saved_h501_tcp_port, h501_tcp_handle);

}
void
proto_reg_handoff_cpfi(void)
{
  static gboolean cpfi_init_complete = FALSE;
  static dissector_handle_t cpfi_handle;
  static dissector_handle_t ttot_handle;
  static guint cpfi_udp_port;
  static guint cpfi_ttot_udp_port;

  if ( !cpfi_init_complete )
  {
    fc_handle     = find_dissector("fc");
    data_handle   = find_dissector("data");
    cpfi_handle   = new_create_dissector_handle(dissect_cpfi, proto_cpfi);
    ttot_handle   = new_create_dissector_handle(dissect_cpfi, proto_cpfi);
    cpfi_init_complete = TRUE;
  }
  else
  {
    dissector_delete_uint("udp.port", cpfi_udp_port, cpfi_handle);
    dissector_delete_uint("udp.port", cpfi_ttot_udp_port, ttot_handle);
  }

  cpfi_udp_port      = gbl_cpfi_udp_port;
  cpfi_ttot_udp_port = gbl_cpfi_ttot_udp_port;

  dissector_add_uint("udp.port", cpfi_udp_port, cpfi_handle);
  dissector_add_uint("udp.port", cpfi_ttot_udp_port, ttot_handle);
}
/*--- proto_reg_handoff_pkixtsp -------------------------------------------*/
void proto_reg_handoff_pkixtsp(void) {
	dissector_handle_t timestamp_reply_handle;
	dissector_handle_t timestamp_query_handle;

	timestamp_reply_handle = new_create_dissector_handle(dissect_timestamp_reply, proto_pkixtsp);
	dissector_add_string("media_type", "application/timestamp-reply", timestamp_reply_handle);

	timestamp_query_handle = new_create_dissector_handle(dissect_timestamp_query, proto_pkixtsp);
	dissector_add_string("media_type", "application/timestamp-query", timestamp_query_handle);

#include "packet-pkixtsp-dis-tab.c"
}
/*--- proto_reg_handoff_ocsp -------------------------------------------*/
void proto_reg_handoff_ocsp(void) {
    dissector_handle_t ocsp_request_handle;
    dissector_handle_t ocsp_response_handle;

    ocsp_request_handle = new_create_dissector_handle(dissect_ocsp_request, proto_ocsp);
    ocsp_response_handle = new_create_dissector_handle(dissect_ocsp_response, proto_ocsp);

    dissector_add_string("media_type", "application/ocsp-request", ocsp_request_handle);
    dissector_add_string("media_type", "application/ocsp-response", ocsp_response_handle);

#include "packet-ocsp-dis-tab.c"
}
/* Create attachment point for dissector in Wireshark */
void
proto_reg_handoff_jmirror(void)
{
	static int jmirror_inited = FALSE;
	static guint jmirror_udp_port;
	static dissector_handle_t jmirror_handle;

	if ( !jmirror_inited )
	{
		/* register as heuristic dissector for UDP */
		/* heur_dissector_add("udp", dissect_jmirror, proto_jmirror); */

		/* Create a dissector handle for the Jmirror protocol */
		jmirror_handle = new_create_dissector_handle(dissect_jmirror, proto_jmirror);

		/* Create pointer to ipv4, ipv6, ppp and data dissectors */
		ipv4_handle = find_dissector("ip");
		ipv6_handle = find_dissector("ipv6");
		hdlc_handle = find_dissector("pw_hdlc_nocw_hdlc_ppp");

		/* Set the init flag */
		jmirror_inited = TRUE;
	} else {
		/* Unregister from the old UDP port */
		dissector_delete_uint("udp.port", jmirror_udp_port, jmirror_handle);
	}

	jmirror_udp_port = global_jmirror_udp_port;

	/* Register as a normal IP dissector with default UDP port 30030 */
	dissector_add_uint("udp.port", jmirror_udp_port, jmirror_handle);
}
Example #6
0
/*--- proto_reg_handoff_h235 -------------------------------------------*/
void proto_reg_handoff_h235(void) {
  dissector_handle_t mikey_handle;

  mikey_handle = find_dissector("mikey");

  /* H.235.7, Chapter 7.1, MIKEY operation at "session level" */
  dissector_add_string("h245.gef.content", "GenericCapability/" OID_MIKEY         "/nonCollapsing/0", mikey_handle);
  dissector_add_string("h245.gef.content", "GenericCapability/" OID_MIKEY_PS      "/nonCollapsing/0", mikey_handle);
  dissector_add_string("h245.gef.content", "GenericCapability/" OID_MIKEY_DHHMAC  "/nonCollapsing/0", mikey_handle);
  dissector_add_string("h245.gef.content", "GenericCapability/" OID_MIKEY_PK_SIGN "/nonCollapsing/0", mikey_handle);
  dissector_add_string("h245.gef.content", "GenericCapability/" OID_MIKEY_DH_SIGN "/nonCollapsing/0", mikey_handle);
  dissector_add_string("h245.gef.content", "EncryptionSync/0", mikey_handle);
  /* H.235.7, Chapter 7.2, MIKEY operation at "media level" */
  dissector_add_string("h245.gef.content", "EncryptionSync/76", mikey_handle);
  dissector_add_string("h245.gef.content", "EncryptionSync/72", mikey_handle);
  dissector_add_string("h245.gef.content", "EncryptionSync/73", mikey_handle);
  dissector_add_string("h245.gef.content", "EncryptionSync/74", mikey_handle);
  dissector_add_string("h245.gef.content", "EncryptionSync/75", mikey_handle);
  dissector_add_string("h245.gef.content", "GenericCapability/" OID_MIKEY         "/nonCollapsing/76", mikey_handle);
  dissector_add_string("h245.gef.content", "GenericCapability/" OID_MIKEY_PS      "/nonCollapsing/72", mikey_handle);
  dissector_add_string("h245.gef.content", "GenericCapability/" OID_MIKEY_DHHMAC  "/nonCollapsing/73", mikey_handle);
  dissector_add_string("h245.gef.content", "GenericCapability/" OID_MIKEY_PK_SIGN "/nonCollapsing/74", mikey_handle);
  dissector_add_string("h245.gef.content", "GenericCapability/" OID_MIKEY_DH_SIGN "/nonCollapsing/75", mikey_handle);

  /* H.235.8, Chapter 4.1.2, SrtpCryptoCapability transport */
  dissector_add_string("h245.gef.content", "GenericCapability/0.0.8.235.0.4.90/nonCollapsingRaw", 
                       new_create_dissector_handle(dissect_SrtpCryptoCapability_PDU, proto_h235));

}
Example #7
0
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_calcappprotocol(void)
{
  dissector_handle_t calcappprotocol_handle;

  calcappprotocol_handle = new_create_dissector_handle(dissect_calcappprotocol, proto_calcappprotocol);
  dissector_add("sctp.ppi", CALCAPPPROTOCOL_PAYLOAD_PROTOCOL_ID, calcappprotocol_handle);
}
Example #9
0
void
proto_reg_handoff_oicq(void)
{
	dissector_handle_t oicq_handle;

	oicq_handle = new_create_dissector_handle(dissect_oicq, proto_oicq);
	dissector_add("udp.port", UDP_PORT_OICQ, oicq_handle);
}
Example #10
0
void
proto_reg_handoff_nbipx(void)
{
    dissector_handle_t nbipx_handle;

    nbipx_handle = new_create_dissector_handle(dissect_nbipx, proto_nbipx);
    dissector_add_uint("ipx.socket", IPX_SOCKET_NETBIOS, nbipx_handle);
}
void
proto_reg_handoff_componentstatusprotocol(void)
{
  dissector_handle_t componentstatusprotocol_handle;

  componentstatusprotocol_handle = new_create_dissector_handle(dissect_componentstatusprotocol, proto_componentstatusprotocol);
  dissector_add_uint("udp.port", COMPONENTSTATUSPROTOCOL_PORT, componentstatusprotocol_handle);
}
Example #12
0
void
proto_reg_handoff_x29(void)
{
	dissector_handle_t x29_handle;

	x29_handle = new_create_dissector_handle(dissect_x29, proto_x29);
	dissector_add_uint("x.25.spi", NLPID_SPI_X_29, x29_handle);
}
Example #13
0
void
proto_reg_handoff_xtp(void)
{
	dissector_handle_t xtp_handle;

	xtp_handle = new_create_dissector_handle(dissect_xtp, proto_xtp);
	dissector_add_uint("ip.proto", IP_PROTO_XTP, xtp_handle);
}
Example #14
0
/*--- proto_reg_handoff_h323 -------------------------------------------*/
void proto_reg_handoff_h323(void) 
{
  dissector_handle_t q931_handle; 

  q931_handle = find_dissector("q931");

  /* H.323, Annex M1, Tunnelling of signalling protocols (QSIG) in H.323 */
  dissector_add_string("h225.tp", "1.3.12.9", q931_handle);

  /* H.323, Annex M4, Tunnelling of narrow-band signalling syntax (NSS) for H.323 */
  dissector_add_string("h225.gef.content", "GenericData/1000/1", 
                       new_create_dissector_handle(dissect_RasTunnelledSignallingMessage_PDU, proto_h323));

  /* H.323, Annex R, Robustness methods for H.323 entities */
  dissector_add_string("h225.gef.content", "GenericData/1/1", 
                       new_create_dissector_handle(dissect_RobustnessData_PDU, proto_h323));
}
Example #15
0
void
proto_reg_handoff_esio(void)
{
       dissector_handle_t esio_handle;

       esio_handle = new_create_dissector_handle(dissect_esio, proto_esio);
       dissector_add_uint("udp.port", 6060, esio_handle);
}
void
proto_reg_handoff_epl_v1(void)
{
    dissector_handle_t epl_v1_handle;

    epl_v1_handle = new_create_dissector_handle(dissect_epl_v1, proto_epl_v1);
    dissector_add("ethertype", ETHERTYPE_EPL_V1, epl_v1_handle);
}
Example #17
0
void
proto_reg_handoff_llrp(void)
{
    dissector_handle_t llrp_handle;

    llrp_handle = new_create_dissector_handle(dissect_llrp, proto_llrp);
    dissector_add_uint("tcp.port", LLRP_PORT, llrp_handle);
}
Example #18
0
void
proto_reg_handoff_cpha(void)
{
  dissector_handle_t cpha_handle;

  cpha_handle = new_create_dissector_handle(dissect_cpha, proto_cphap);
  dissector_add_uint("udp.port", UDP_PORT_CPHA, cpha_handle);
}
Example #19
0
void
proto_reg_handoff_ddtp(void)
{
    dissector_handle_t ddtp_handle;

    ddtp_handle = new_create_dissector_handle(dissect_ddtp, proto_ddtp);
    dissector_add("udp.port", UDP_PORT_DDTP, ddtp_handle);
}
Example #20
0
void
proto_reg_handoff_ssprotocol(void)
{
  dissector_handle_t ssprotocol_handle;

  ssprotocol_handle = new_create_dissector_handle(dissect_ssprotocol, proto_ssprotocol);
  dissector_add("sctp.ppi", SSPROTOCOL_PAYLOAD_PROTOCOL_ID, ssprotocol_handle);
}
/*--- proto_reg_handoff_x509af -------------------------------------------*/
void proto_reg_handoff_x509af(void) {
	dissector_handle_t pkix_crl_handle;

	pkix_crl_handle = new_create_dissector_handle(dissect_pkix_crl, proto_x509af);
	dissector_add_string("media_type", "application/pkix-crl", pkix_crl_handle);

#include "packet-x509af-dis-tab.c"

	/*XXX these should really go to a better place but since that
	  I have not that ITU standard, ill put it here for the time
	  being.
	  Only implemented those algorithms that take no parameters 
	  for the time being,   ronnie
	*/
	/* from http://www.alvestrand.no/objectid/1.3.14.3.2.html */
	register_ber_oid_dissector("1.3.14.3.2.2", dissect_ber_oid_NULL_callback, proto_x509af, "md4WithRSA");
	register_ber_oid_dissector("1.3.14.3.2.3", dissect_ber_oid_NULL_callback, proto_x509af, "md5WithRSA");
	register_ber_oid_dissector("1.3.14.3.2.4", dissect_ber_oid_NULL_callback, proto_x509af, "md4WithRSAEncryption");
	register_ber_oid_dissector("1.3.14.3.2.6", dissect_ber_oid_NULL_callback, proto_x509af, "desECB");
	register_ber_oid_dissector("1.3.14.3.2.11", dissect_ber_oid_NULL_callback, proto_x509af, "rsaSignature");
	register_ber_oid_dissector("1.3.14.3.2.14", dissect_ber_oid_NULL_callback, proto_x509af, "mdc2WithRSASignature");
	register_ber_oid_dissector("1.3.14.3.2.15", dissect_ber_oid_NULL_callback, proto_x509af, "shaWithRSASignature");
	register_ber_oid_dissector("1.3.14.3.2.16", dissect_ber_oid_NULL_callback, proto_x509af, "dhWithCommonModulus");
	register_ber_oid_dissector("1.3.14.3.2.17", dissect_ber_oid_NULL_callback, proto_x509af, "desEDE");
	register_ber_oid_dissector("1.3.14.3.2.18", dissect_ber_oid_NULL_callback, proto_x509af, "sha");
	register_ber_oid_dissector("1.3.14.3.2.19", dissect_ber_oid_NULL_callback, proto_x509af, "mdc-2");
	register_ber_oid_dissector("1.3.14.3.2.20", dissect_ber_oid_NULL_callback, proto_x509af, "dsaCommon");
	register_ber_oid_dissector("1.3.14.3.2.21", dissect_ber_oid_NULL_callback, proto_x509af, "dsaCommonWithSHA");
	register_ber_oid_dissector("1.3.14.3.2.22", dissect_ber_oid_NULL_callback, proto_x509af, "rsaKeyTransport");
	register_ber_oid_dissector("1.3.14.3.2.23", dissect_ber_oid_NULL_callback, proto_x509af, "keyed-hash-seal");
	register_ber_oid_dissector("1.3.14.3.2.24", dissect_ber_oid_NULL_callback, proto_x509af, "md2WithRSASignature");
	register_ber_oid_dissector("1.3.14.3.2.25", dissect_ber_oid_NULL_callback, proto_x509af, "md5WithRSASignature");
	register_ber_oid_dissector("1.3.14.3.2.26", dissect_ber_oid_NULL_callback, proto_x509af, "SHA-1");
	register_ber_oid_dissector("1.3.14.3.2.27", dissect_ber_oid_NULL_callback, proto_x509af, "dsaWithSHA1");
	register_ber_oid_dissector("1.3.14.3.2.28", dissect_ber_oid_NULL_callback, proto_x509af, "dsaWithCommonSHA1");
	register_ber_oid_dissector("1.3.14.3.2.29", dissect_ber_oid_NULL_callback, proto_x509af, "sha-1WithRSAEncryption");

	/* these will generally be encoded as ";binary" in LDAP */

	register_ldap_name_dissector("cACertificate", dissect_x509af_Certificate_PDU, proto_x509af);
	register_ldap_name_dissector("userCertificate", dissect_x509af_Certificate_PDU, proto_x509af);
	
	register_ldap_name_dissector("certificateRevocationList", dissect_CertificateList_PDU, proto_x509af);
	register_ldap_name_dissector("crl", dissect_CertificateList_PDU, proto_x509af);

	register_ldap_name_dissector("authorityRevocationList", dissect_CertificateList_PDU, proto_x509af);
	register_ldap_name_dissector("arl", dissect_CertificateList_PDU, proto_x509af);

	register_ldap_name_dissector("crossCertificatePair", dissect_CertificatePair_PDU, proto_x509af);

	register_ber_syntax_dissector("Certificate", proto_x509af, dissect_x509af_Certificate_PDU); 
	register_ber_oid_syntax(".cer", NULL, "Certificate");
	register_ber_oid_syntax(".crt", NULL, "Certificate");
	register_ber_syntax_dissector("CertificateList", proto_x509af, dissect_CertificateList_PDU); 
	register_ber_oid_syntax(".crl", NULL, "CertificateList");
	register_ber_syntax_dissector("CrossCertificatePair", proto_x509af, dissect_CertificatePair_PDU); 

}
Example #22
0
void
proto_reg_handoff_wow(void)
{
	dissector_handle_t wow_handle;

	wow_handle = new_create_dissector_handle(dissect_wow, proto_wow);
	dissector_add_uint("tcp.port", WOW_PORT, wow_handle);

}
Example #23
0
void
proto_reg_handoff_aodv(void)
{
    dissector_handle_t aodv_handle;

    aodv_handle = new_create_dissector_handle(dissect_aodv,
					      proto_aodv);
    dissector_add_uint("udp.port", UDP_PORT_AODV, aodv_handle);
}
Example #24
0
void
proto_reg_handoff_tivoconnect(void)
{
    dissector_handle_t tivoconnect_handle;

    tivoconnect_handle = new_create_dissector_handle(dissect_tivoconnect, proto_tivoconnect);
    dissector_add_uint("udp.port", 2190, tivoconnect_handle);
    dissector_add_uint("tcp.port", 2190, tivoconnect_handle);
}
void
proto_reg_handoff_fractalgeneratorprotocol(void)
{
  dissector_handle_t fractalgeneratorprotocol_handle;

  fractalgeneratorprotocol_handle = new_create_dissector_handle(dissect_fractalgeneratorprotocol, proto_fractalgeneratorprotocol);
  dissector_add_uint("sctp.ppi", FRACTALGENERATORPROTOCOL_PAYLOAD_PROTOCOL_ID_LEGACY, fractalgeneratorprotocol_handle);
  dissector_add_uint("sctp.ppi", FGP_PAYLOAD_PROTOCOL_ID, fractalgeneratorprotocol_handle);
}
Example #26
0
/* 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_mbtcp(void)
{
	dissector_handle_t mbtcp_handle;

	mbtcp_handle = new_create_dissector_handle(dissect_mbtcp, proto_mbtcp);
	dissector_add_uint("tcp.port", PORT_MBTCP, mbtcp_handle);
	dissector_add_uint("udp.port", PORT_MBTCP, mbtcp_handle);
}
Example #27
0
void
proto_reg_handoff_mndp(void)
{
	dissector_handle_t mndp_handle;

	mndp_handle = new_create_dissector_handle(dissect_mndp_static, proto_mndp);
	dissector_add_uint("udp.port", PORT_MNDP, mndp_handle);
	/* heur_dissector_add("udp", dissect_mndp_heur, proto_mndp); */
}
void
proto_reg_handoff_babel(void)
{
    dissector_handle_t babel_handle;

    babel_handle = new_create_dissector_handle(dissect_babel, proto_babel);
    dissector_add_uint("udp.port", UDP_PORT_BABEL, babel_handle);
    dissector_add_uint("udp.port", UDP_PORT_BABEL_OLD, babel_handle);
}
Example #29
0
void
proto_reg_handoff_asf(void)
{
	dissector_handle_t asf_handle;

	data_handle = find_dissector("data");

	asf_handle  = new_create_dissector_handle(dissect_asf, proto_asf);
	dissector_add_uint("rmcp.class", RMCP_CLASS_ASF, asf_handle);
}
void
proto_reg_handoff_netmon_802_11(void)
{
  dissector_handle_t netmon_802_11_handle;

  /* handle for 802.11+radio information dissector */
  ieee80211_radio_handle = find_dissector("wlan_radio");
  netmon_802_11_handle = new_create_dissector_handle(dissect_netmon_802_11,
                                                 proto_netmon_802_11);
  dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11_NETMON, netmon_802_11_handle);
}