static void
xmpp_si_file(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, xmpp_element_t* element)
{
proto_item *file_item;
proto_tree *file_tree;
xmpp_attr_info attrs_info[] ={
{"xmlns", hf_xmpp_xmlns, TRUE, FALSE, NULL, NULL},
{"name", -1, TRUE, TRUE, NULL, NULL},
{"size", -1, TRUE, TRUE, NULL, NULL},
{"date", -1, FALSE, FALSE, NULL, NULL},
{"hash", -1, FALSE, FALSE, NULL, NULL},
{"desc", -1, FALSE, FALSE, NULL, NULL}
};
xmpp_element_t *desc, *range;
file_item = proto_tree_add_item(tree, hf_xmpp_si_file, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
file_tree = proto_item_add_subtree(file_item, ett_xmpp_si_file);
if((desc = xmpp_steal_element_by_name(element, "desc"))!=NULL)
{
xmpp_attr_t *fake_desc = xmpp_ep_init_attr_t(desc->data?desc->data->value:"", desc->offset, desc->length);
g_hash_table_insert(element->attrs, (gpointer)"desc", fake_desc);
}
if((range = xmpp_steal_element_by_name(element, "range"))!=NULL)
{
xmpp_si_file_range(file_tree, tvb, pinfo, range);
}
xmpp_display_attrs(file_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_unknown(file_tree, tvb, pinfo, element);
}
void
xmpp_presence(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, xmpp_element_t *packet)
{
proto_item *presence_item;
proto_tree *presence_tree;
static const gchar *type_enums[] = {"error", "probe", "subscribe", "subscribed",
"unavailable", "unsubscribe", "unsubscribed"};
xmpp_array_t *type_array = xmpp_ep_init_array_t(type_enums, array_length(type_enums));
static const gchar *show_enums[] = {"away", "chat", "dnd", "xa"};
xmpp_array_t *show_array = xmpp_ep_init_array_t(show_enums, array_length(show_enums));
xmpp_attr_info attrs_info[] = {
{"from", hf_xmpp_from, FALSE, FALSE, NULL, NULL},
{"id", hf_xmpp_id, FALSE, TRUE, NULL, NULL},
{"to", hf_xmpp_to, FALSE, FALSE, NULL, NULL},
{"type", hf_xmpp_type, FALSE, TRUE, xmpp_val_enum_list, type_array},
{"xml:lang",-1, FALSE, FALSE, NULL,NULL},
{"show", hf_xmpp_presence_show, FALSE, TRUE, xmpp_val_enum_list, show_array},
{"priority", -1, FALSE, FALSE, NULL, NULL}
};
xmpp_elem_info elems_info[] = {
{NAME, "status", xmpp_presence_status, MANY},
{NAME_AND_ATTR, xmpp_name_attr_struct("c","xmlns","http://jabber.org/protocol/caps"), xmpp_presence_caps, ONE},
{NAME, "delay", xmpp_delay, ONE},
{NAME_AND_ATTR, xmpp_name_attr_struct("x","xmlns", "jabber:x:delay"), xmpp_delay, ONE},
{NAME_AND_ATTR, xmpp_name_attr_struct("x","xmlns", "vcard-temp:x:update"), xmpp_vcard_x_update, ONE},
{NAME_AND_ATTR, xmpp_name_attr_struct("x","xmlns","http://jabber.org/protocol/muc"), xmpp_muc_x, ONE},
{NAME_AND_ATTR, xmpp_name_attr_struct("x","xmlns","http://jabber.org/protocol/muc#user"), xmpp_muc_user_x, ONE},
{NAME, "error", xmpp_error, ONE},
{NAME_AND_ATTR, xmpp_name_attr_struct("query", "xmlns","jabber:iq:last"), xmpp_last_query, ONE}
};
xmpp_element_t *show, *priority;
col_clear(pinfo->cinfo, COL_INFO);
col_append_fstr(pinfo->cinfo, COL_INFO, "PRESENCE ");
presence_item = proto_tree_add_item(tree, hf_xmpp_presence, tvb, packet->offset, packet->length, ENC_BIG_ENDIAN);
presence_tree = proto_item_add_subtree(presence_item, ett_xmpp_presence);
if((show = xmpp_steal_element_by_name(packet, "show"))!=NULL)
{
xmpp_attr_t *fake_show = xmpp_ep_init_attr_t(show->data?show->data->value:"",show->offset, show->length);
g_hash_table_insert(packet->attrs, (gpointer)"show", fake_show);
}
if((priority = xmpp_steal_element_by_name(packet, "priority"))!=NULL)
{
xmpp_attr_t *fake_priority = xmpp_ep_init_attr_t(priority->data?priority->data->value:"",priority->offset, priority->length);
g_hash_table_insert(packet->attrs, (gpointer)"priority", fake_priority);
}
xmpp_display_attrs(presence_tree, packet, pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_display_elems(presence_tree, packet, pinfo, tvb, elems_info, array_length(elems_info));
}
void
xmpp_gtalk_status_query(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, xmpp_element_t* element)
{
proto_item *query_item;
proto_tree *query_tree;
xmpp_attr_info attrs_info[] = {
{"xmlns", hf_xmpp_xmlns, TRUE, TRUE, NULL, NULL},
{"version", -1, FALSE, TRUE, NULL, NULL},
{"status-max", -1, FALSE, FALSE, NULL, NULL},
{"status-list-max", -1, FALSE, FALSE, NULL, NULL},
{"status-list-contents-max", -1, FALSE, FALSE, NULL, NULL},
{"status-min-ver", -1, FALSE, TRUE, NULL, NULL},
{"show", -1, FALSE, TRUE, NULL, NULL},
{"status", -1, FALSE, TRUE, NULL, NULL},
{"invisible", -1, FALSE, TRUE, NULL, NULL},
};
xmpp_elem_info elems_info [] = {
{NAME, "status-list", xmpp_gtalk_status_status_list, MANY}
};
xmpp_element_t *status, *show, *invisible;
col_append_fstr(pinfo->cinfo, COL_INFO, "QUERY(google:shared-status) ");
query_item = proto_tree_add_item(tree, hf_xmpp_query, tvb, element->offset, element->length,
ENC_BIG_ENDIAN);
query_tree = proto_item_add_subtree(query_item, ett_xmpp_query);
if((status = xmpp_steal_element_by_name(element,"status"))!=NULL)
{
xmpp_attr_t *fake_status = xmpp_ep_init_attr_t(status->data?status->data->value:"",status->offset, status->length);
g_hash_table_insert(element->attrs, (gpointer)"status", fake_status);
}
if((show = xmpp_steal_element_by_name(element,"show"))!=NULL)
{
xmpp_attr_t *fake_show = xmpp_ep_init_attr_t(show->data?show->data->value:"",show->offset, show->length);
g_hash_table_insert(element->attrs, (gpointer)"show", fake_show);
}
if((invisible = xmpp_steal_element_by_name(element,"invisible"))!=NULL)
{
xmpp_attr_t *value = xmpp_get_attr(invisible, "value");
xmpp_attr_t *fake_invisible = xmpp_ep_init_attr_t(value?value->value:"",invisible->offset, invisible->length);
g_hash_table_insert(element->attrs, (gpointer)"invisible", fake_invisible);
}
xmpp_display_attrs(query_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_display_elems(query_tree, element, pinfo, tvb, elems_info, array_length(elems_info));
}
void
xmpp_bytestreams_query(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, xmpp_element_t *element)
{
proto_item *query_item;
proto_tree *query_tree;
static const gchar *mode_enums[] = {"tcp", "udp"};
xmpp_array_t *mode_array = xmpp_ep_init_array_t(mode_enums, array_length(mode_enums));
xmpp_attr_info attrs_info[] = {
{"xmlns", hf_xmpp_xmlns, TRUE, TRUE, NULL, NULL},
{"sid", -1, FALSE, TRUE, NULL, NULL},
{"mode", -1, FALSE, TRUE, xmpp_val_enum_list, mode_array},
{"dstaddr", -1, FALSE, TRUE, NULL, NULL}
};
xmpp_element_t *streamhost, *streamhost_used, *activate, *udpsuccess;
col_append_fstr(pinfo->cinfo, COL_INFO, "QUERY(bytestreams) ");
query_item = proto_tree_add_item(tree, hf_xmpp_query, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
query_tree = proto_item_add_subtree(query_item, ett_xmpp_query);
xmpp_display_attrs(query_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
while((streamhost = xmpp_steal_element_by_name(element, "streamhost")) != NULL)
{
xmpp_bytestreams_streamhost(query_tree, tvb, pinfo, streamhost);
}
if((streamhost_used = xmpp_steal_element_by_name(element, "streamhost-used")) != NULL)
{
xmpp_bytestreams_streamhost_used(query_tree, tvb, pinfo, streamhost_used);
}
if((activate = xmpp_steal_element_by_name(element, "activate")) != NULL)
{
xmpp_bytestreams_activate(query_tree, tvb, pinfo, activate);
}
if((udpsuccess = xmpp_steal_element_by_name(element, "udpsuccess")) != NULL)
{
xmpp_bytestreams_udpsuccess(query_tree, tvb, pinfo, udpsuccess);
}
xmpp_unknown(query_tree, tvb, pinfo, element);
}
static void
xmpp_gtalk_jingleinfo_relay(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, xmpp_element_t* element)
{
proto_item *relay_item;
proto_tree *relay_tree;
xmpp_attr_info attrs_info[] = {
{"token", -1, FALSE, FALSE, NULL, NULL}
};
xmpp_elem_info elems_info [] = {
{NAME, "server", xmpp_gtalk_jingleinfo_relay_serv, ONE}
};
xmpp_element_t *token;
relay_item = proto_tree_add_text(tree, tvb, element->offset, element->length, "RELAY");
relay_tree = proto_item_add_subtree(relay_item, ett_xmpp_gtalk_jingleinfo_relay);
if((token = xmpp_steal_element_by_name(element, "token"))!=NULL)
{
xmpp_attr_t *fake_token = xmpp_ep_init_attr_t(token->data?token->data->value:"", token->offset, token->length);
g_hash_table_insert(element->attrs, (gpointer)"token", fake_token);
}
xmpp_display_attrs(relay_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_display_elems(relay_tree, element, pinfo, tvb, elems_info, array_length(elems_info));
}
/*urn:xmpp:jingle:apps:rtp:rtp-hdrext:0*/
static void
xmpp_jingle_cont_desc_rtp_hdrext(proto_tree* tree, tvbuff_t* tvb, packet_info *pinfo, xmpp_element_t* element)
{
proto_item *rtp_hdr_item;
proto_tree *rtp_hdr_tree;
const gchar *senders[] = {"both", "initiator", "responder"};
xmpp_array_t *senders_enums = xmpp_ep_init_array_t(senders, 3);
xmpp_attr_info attrs_info[] = {
{"xmlns", hf_xmpp_xmlns, FALSE, FALSE, NULL, NULL},
{"id", -1, TRUE, FALSE, NULL, NULL},
{"uri", -1, TRUE, TRUE, NULL, NULL},
{"senders", -1, FALSE, TRUE, xmpp_val_enum_list, senders_enums},
{"parameter", -1, FALSE, TRUE, NULL, NULL}
};
xmpp_element_t *parameter;
rtp_hdr_item = proto_tree_add_item(tree, hf_xmpp_jingle_cont_desc_rtp_hdr, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
rtp_hdr_tree = proto_item_add_subtree(rtp_hdr_item, ett_xmpp_jingle_cont_desc_rtp_hdr);
if((parameter = xmpp_steal_element_by_name(element, "parameter"))!=NULL)
{
xmpp_attr_t *name = xmpp_get_attr(element, "name");
xmpp_attr_t *fake_attr = xmpp_ep_init_attr_t(name?name->value:"", parameter->offset, parameter->length);
g_hash_table_insert(element->attrs, "parameter", fake_attr);
}
xmpp_display_attrs(rtp_hdr_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_unknown(rtp_hdr_tree, tvb, pinfo, element);
}
static void
xmpp_x_data_field_option(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, xmpp_element_t* element)
{
proto_item *option_item;
proto_tree *option_tree;
xmpp_attr_info attrs_info[] = {
{"label", -1, FALSE, TRUE, NULL, NULL},
{"value", -1, FALSE, TRUE, NULL, NULL}
};
xmpp_element_t *value;
option_item = proto_tree_add_item(tree, hf_xmpp_x_data_field_value, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
option_tree = proto_item_add_subtree(option_item, ett_xmpp_x_data_field_value);
if((value = xmpp_steal_element_by_name(element, "value"))!=NULL)
{
xmpp_attr_t *fake_value = xmpp_ep_init_attr_t(value->data?value->data->value:"",value->offset, value->length);
g_hash_table_insert(element->attrs, (gpointer)"value", fake_value);
}
xmpp_display_attrs(option_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_unknown(option_tree, tvb, pinfo, element);
}
static void
xmpp_roster_item(proto_tree *tree, tvbuff_t *tvb, packet_info* pinfo, xmpp_element_t *element)
{
proto_item *item_item;
proto_tree *item_tree;
static const gchar *ask_enums[] = {"subscribe"};
static const gchar *subscription_enums[] = {"both", "from", "none", "remove", "to"};
xmpp_array_t *ask_enums_array = xmpp_ep_init_array_t(ask_enums,array_length(ask_enums));
xmpp_array_t *subscription_array = xmpp_ep_init_array_t(subscription_enums,array_length(subscription_enums));
xmpp_attr_info attrs_info[] = {
{"jid", hf_xmpp_query_item_jid, TRUE, TRUE, NULL, NULL},
{"name", hf_xmpp_query_item_name, FALSE, TRUE, NULL, NULL},
{"ask", hf_xmpp_query_item_ask, FALSE, TRUE, xmpp_val_enum_list, ask_enums_array},
{"approved", hf_xmpp_query_item_approved, FALSE, TRUE, NULL, NULL},
{"subscription", hf_xmpp_query_item_subscription, FALSE, TRUE, xmpp_val_enum_list, subscription_array},
};
xmpp_element_t *group;
item_item = proto_tree_add_item(tree, hf_xmpp_query_item, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
item_tree = proto_item_add_subtree(item_item, ett_xmpp_query_item);
xmpp_display_attrs(item_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
while((group = xmpp_steal_element_by_name(element,"group"))!=NULL)
{
proto_tree_add_string(item_tree, hf_xmpp_query_item_group, tvb, group->offset, group->length, xmpp_elem_cdata(group));
}
xmpp_unknown(item_tree, tvb, pinfo, element);
}
void
xmpp_disco_items_query(proto_tree *tree, tvbuff_t *tvb, packet_info* pinfo, xmpp_element_t *element)
{
proto_item *query_item;
proto_tree *query_tree;
xmpp_attr_info attrs_info[] = {
{"xmlns", hf_xmpp_xmlns, TRUE, TRUE, NULL, NULL},
{"node", hf_xmpp_query_node, FALSE, TRUE, NULL, NULL}
};
xmpp_element_t *item;
col_append_fstr(pinfo->cinfo, COL_INFO, "QUERY(disco#items) ");
query_item = proto_tree_add_item(tree, hf_xmpp_query, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
query_tree = proto_item_add_subtree(query_item, ett_xmpp_query);
xmpp_display_attrs(query_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
while((item = xmpp_steal_element_by_name(element, "item")) != NULL)
{
xmpp_disco_items_item(query_tree, tvb, pinfo, item);
}
xmpp_unknown(query_tree, tvb, pinfo, element);
}
void
xmpp_vcard_x_update(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, xmpp_element_t* element)
{
proto_item *x_item;
proto_tree *x_tree;
xmpp_attr_info attrs_info[] = {
{"xmlns", hf_xmpp_xmlns, TRUE, FALSE, NULL, NULL},
{"photo", -1, FALSE, FALSE, NULL, NULL}
};
xmpp_element_t *photo;
x_item = proto_tree_add_item(tree, hf_xmpp_vcard_x_update, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
x_tree = proto_item_add_subtree(x_item, ett_xmpp_vcard_x_update);
if((photo = xmpp_steal_element_by_name(element, "photo"))!=NULL)
{
xmpp_attr_t *fake_photo = xmpp_ep_init_attr_t(photo->data?photo->data->value:"", photo->offset, photo->length);
g_hash_table_insert(element->attrs, (gpointer)"photo", fake_photo);
}
xmpp_display_attrs(x_tree, element,pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_unknown(x_tree, tvb, pinfo, element);
}
static void
xmpp_gtalk_mail_mail_info(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, xmpp_element_t* element)
{
proto_item *mail_info_item;
proto_tree *mail_info_tree;
xmpp_attr_info attrs_info [] = {
{"tid", -1, FALSE, FALSE, NULL, NULL},
{"participation", -1, FALSE, FALSE, NULL, NULL},
{"messages", -1, FALSE, TRUE, NULL, NULL},
{"date", -1, FALSE, TRUE, NULL, NULL},
{"url", -1, FALSE, FALSE, NULL, NULL},
{"labels", -1, FALSE, FALSE, NULL, NULL},
{"subject", -1, FALSE, TRUE, NULL, NULL}
};
xmpp_elem_info elems_info [] = {
{NAME, "senders", xmpp_gtalk_mail_senders, ONE},
{NAME, "snippet", xmpp_gtalk_mail_snippet, ONE}/*or MANY?*/
};
xmpp_element_t *labels, *subject;
mail_info_item = proto_tree_add_text(tree, tvb, element->offset, element->length, "MAIL-THREAD-INFO");
mail_info_tree = proto_item_add_subtree(mail_info_item,ett_xmpp_gtalk_mail_mail_info);
if((labels = xmpp_steal_element_by_name(element,"labels"))!=NULL)
{
xmpp_attr_t *fake_labels = xmpp_ep_init_attr_t(labels->data?labels->data->value:"",labels->offset, labels->length);
g_hash_table_insert(element->attrs, (gpointer)"labels", fake_labels);
}
if((subject = xmpp_steal_element_by_name(element,"subject"))!=NULL)
{
xmpp_attr_t *fake_subject = xmpp_ep_init_attr_t(subject->data?subject->data->value:"",subject->offset, subject->length);
g_hash_table_insert(element->attrs, (gpointer)"subject", fake_subject);
}
xmpp_display_attrs(mail_info_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_display_elems(mail_info_tree, element, pinfo, tvb, elems_info, array_length(elems_info));
}
static void
xmpp_x_data_field(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, xmpp_element_t* element)
{
proto_item *field_item;
proto_tree *field_tree;
static const gchar *type_enums[] = {"boolean", "fixed", "hidden", "jid-multi",
"jid-single", "list-multi", "list-single", "text-multi", "text-single",
"text-private"
};
xmpp_array_t *type_array = xmpp_ep_init_array_t(type_enums, array_length(type_enums));
xmpp_attr_info attrs_info[] =
{
{"label", -1, FALSE, TRUE, NULL, NULL},
{"type", -1, FALSE, TRUE, xmpp_val_enum_list, type_array},
{"var", -1, FALSE, TRUE, NULL, NULL}
};
xmpp_element_t /**desc, *required,*/ *value, *option;
field_item = proto_tree_add_item(tree, hf_xmpp_x_data_field, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
field_tree = proto_item_add_subtree(field_item, ett_xmpp_x_data_field);
xmpp_display_attrs(field_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
while((option = xmpp_steal_element_by_name(element, "option"))!=NULL)
{
xmpp_x_data_field_option(field_tree, tvb, pinfo, option);
}
while((value = xmpp_steal_element_by_name(element, "value"))!=NULL)
{
xmpp_x_data_field_value(field_tree, tvb, pinfo, value);
}
xmpp_unknown(field_item, tvb, pinfo, element);
}
void
xmpp_disco_info_query(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, xmpp_element_t *element)
{
proto_item *query_item;
proto_tree *query_tree;
xmpp_attr_info attrs_info[] = {
{"xmlns", hf_xmpp_xmlns, TRUE, TRUE, NULL, NULL},
{"node", hf_xmpp_query_node, FALSE, TRUE, NULL, NULL}
};
xmpp_element_t *identity, *feature, *x_data;
col_append_fstr(pinfo->cinfo, COL_INFO, "QUERY(disco#info) ");
query_item = proto_tree_add_item(tree, hf_xmpp_query, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
query_tree = proto_item_add_subtree(query_item, ett_xmpp_query);
xmpp_display_attrs(query_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
while((identity = xmpp_steal_element_by_name(element, "identity")) != NULL)
{
xmpp_disco_info_identity(query_tree, tvb, pinfo, identity);
}
while((feature = xmpp_steal_element_by_name(element, "feature")) != NULL)
{
xmpp_disco_info_feature(query_tree, tvb, feature);
}
if((x_data = xmpp_steal_element_by_name_and_attr(element, "x", "xmlns", "jabber:x:data")) != NULL)
{
xmpp_x_data(query_tree, tvb, pinfo, x_data);
}
xmpp_unknown(query_tree, tvb, pinfo, element);
}
/*SI File Transfer*/
void
xmpp_si(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, xmpp_element_t* element)
{
proto_item *si_item;
proto_tree *si_tree;
xmpp_attr_info attrs_info[] = {
{"xmlns", hf_xmpp_xmlns, TRUE, TRUE, NULL, NULL},
{"id", -1, FALSE, FALSE, NULL, NULL},
{"mime-type", -1, FALSE, TRUE, NULL, NULL},
{"profile", -1, FALSE, TRUE, NULL, NULL}
};
xmpp_element_t *file, *feature_neg;
col_append_fstr(pinfo->cinfo, COL_INFO, "SI ");
si_item = proto_tree_add_item(tree, hf_xmpp_si, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
si_tree = proto_item_add_subtree(si_item, ett_xmpp_si);
xmpp_display_attrs(si_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
while((file = xmpp_steal_element_by_name(element, "file"))!=NULL)
{
xmpp_si_file(si_tree, tvb, pinfo, file);
}
while((feature_neg = xmpp_steal_element_by_name(element, "feature"))!=NULL)
{
xmpp_feature_neg(si_tree, tvb, pinfo, feature_neg);
}
xmpp_unknown(si_tree, tvb, pinfo, element);
}
static void
xmpp_error(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, xmpp_element_t *element)
{
proto_item *error_item;
proto_tree *error_tree;
xmpp_element_t *text_element, *cond_element;
xmpp_attr_info attrs_info[] = {
{"type", &hf_xmpp_error_type, TRUE, TRUE, NULL, NULL},
{"code", &hf_xmpp_error_code, FALSE, TRUE, NULL, NULL},
{"condition", &hf_xmpp_error_condition, TRUE, TRUE, NULL, NULL} /*TODO: validate list to the condition element*/
};
gchar *error_info;
xmpp_attr_t *fake_condition = NULL;
error_info = wmem_strdup(wmem_packet_scope(), "Stanza error");
error_item = proto_tree_add_item(tree, hf_xmpp_error, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
error_tree = proto_item_add_subtree(error_item, ett_xmpp_query_item);
cond_element = xmpp_steal_element_by_attr(element, "xmlns", "urn:ietf:params:xml:ns:xmpp-stanzas");
if(cond_element)
{
fake_condition = xmpp_ep_init_attr_t(cond_element->name, cond_element->offset, cond_element->length);
g_hash_table_insert(element->attrs, (gpointer)"condition", fake_condition);
error_info = wmem_strdup_printf(wmem_packet_scope(), "%s: %s;", error_info, cond_element->name);
}
xmpp_display_attrs(error_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
while((text_element = xmpp_steal_element_by_name(element, "text")) != NULL)
{
xmpp_error_text(error_tree, tvb, text_element);
error_info = wmem_strdup_printf(wmem_packet_scope(), "%s Text: %s", error_info, text_element->data?text_element->data->value:"");
}
expert_add_info_format(pinfo, error_item, &ei_xmpp_response, "%s", error_info);
xmpp_unknown(error_tree, tvb, pinfo, element);
}
static void
xmpp_gtalk_status_status_list(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, xmpp_element_t* element)
{
proto_tree *list_tree;
xmpp_attr_info attrs_info [] = {
{"show", NULL, TRUE, TRUE, NULL, NULL}
};
xmpp_element_t *status;
list_tree = proto_tree_add_subtree(tree, tvb, element->offset, element->length, ett_xmpp_gtalk_status_status_list, NULL, "STATUS LIST");
while((status = xmpp_steal_element_by_name(element, "status"))!=NULL)
{
proto_tree_add_text(list_tree, tvb, status->offset, status->length, "STATUS: %s",status->data?status->data->value:"");
}
xmpp_display_attrs(list_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_display_elems(list_tree, element, pinfo, tvb, NULL, 0);
}
void
xmpp_failure(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, xmpp_element_t *packet)
{
proto_item *fail_item;
proto_tree *fail_tree;
xmpp_attr_info attrs_info[] = {
{"xmlns", &hf_xmpp_xmlns, TRUE, TRUE, NULL, NULL},
{"condition", NULL, FALSE, TRUE, NULL, NULL}
};
static const gchar *fail_names[] = {"aborted","account-disabled", "credentials-expired",
"encryption-required", "incorrect-encoding", "invalid-authzid", "invalid-mechanism",
"malformed-request", "mechanism-too-weak", "not-authorized", "temporary-auth-failure",
"transition-needed"
};
xmpp_element_t *fail_condition, *text;
col_add_fstr(pinfo->cinfo, COL_INFO, "FAILURE ");
fail_item = proto_tree_add_item(tree, hf_xmpp_failure, tvb, packet->offset, packet->length, ENC_BIG_ENDIAN);
fail_tree = proto_item_add_subtree(fail_item, ett_xmpp_failure);
if((fail_condition = xmpp_steal_element_by_names(packet, fail_names, array_length(fail_names)))!=NULL)
{
xmpp_attr_t *fake_cond = xmpp_ep_init_attr_t(fail_condition->name, fail_condition->offset, fail_condition->length);
g_hash_table_insert(packet->attrs, (gpointer)"condition", fake_cond);
}
if((text = xmpp_steal_element_by_name(packet, "text"))!=NULL)
{
xmpp_failure_text(fail_tree, tvb, text);
}
xmpp_display_attrs(fail_tree, packet, pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_unknown(fail_tree, tvb, pinfo, packet);
}
static void
xmpp_gtalk_session_reason(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, xmpp_element_t* element)
{
proto_item *reason_item;
proto_tree *reason_tree;
xmpp_attr_info attrs_info[] = {
{"condition", -1, TRUE, TRUE, NULL, NULL},
{"text", -1, FALSE, FALSE, NULL, NULL}
};
xmpp_element_t *condition;
xmpp_element_t *text;
const gchar *reason_names[] = { "success", "busy", "cancel"};
reason_item = proto_tree_add_text(tree, tvb, element->offset, element->length, "REASON");
reason_tree = proto_item_add_subtree(reason_item, ett_xmpp_gtalk_session_reason);
/*Looks for reason description.*/
if((condition = xmpp_steal_element_by_names(element, reason_names, array_length(reason_names)))!=NULL)
{
xmpp_attr_t *fake_cond = xmpp_ep_init_attr_t(condition->name, condition->offset, condition->length);
g_hash_table_insert(element->attrs, (gpointer)"condition", fake_cond);
}
if((text = xmpp_steal_element_by_name(element, "text"))!=NULL)
{
xmpp_attr_t *fake_text = xmpp_ep_init_attr_t(text->data?text->data->value:"", text->offset, text->length);
g_hash_table_insert(element->attrs, (gpointer)"text", fake_text);
}
xmpp_display_attrs(reason_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_unknown(reason_tree, tvb, pinfo, element);
}
static void
xmpp_jingle_reason(proto_tree* tree, tvbuff_t* tvb, packet_info* pinfo, xmpp_element_t* element)
{
proto_item *reason_item;
proto_tree *reason_tree;
xmpp_attr_info attrs_info[] = {
{"condition", hf_xmpp_jingle_reason_condition, TRUE, TRUE, NULL, NULL},
{"sid", -1, FALSE, TRUE, NULL, NULL},
{"rtp-error", -1, FALSE, TRUE, NULL, NULL},
{"text", hf_xmpp_jingle_reason_text, FALSE, FALSE, NULL, NULL}
};
xmpp_element_t *condition; /*1?*/
xmpp_element_t *text; /*0-1*/
xmpp_element_t *rtp_error;
const gchar *reason_names[] = { "success", "busy", "failed-application", "cancel", "connectivity-error",
"decline", "expired", "failed-transport", "general-error", "gone", "incompatible-parameters",
"media-error", "security-error", "timeout", "unsupported-applications", "unsupported-transports"};
const gchar *rtp_error_names[] = {"crypto-required", "invalid-crypto"};
reason_item = proto_tree_add_item(tree, hf_xmpp_jingle_reason, tvb, element->offset, element->length, ENC_BIG_ENDIAN);
reason_tree = proto_item_add_subtree(reason_item, ett_xmpp_jingle_reason);
/*Looks for reason description. "alternative-session" may contain "sid" element
Elements are changed into attribute*/
if((condition = xmpp_steal_element_by_names(element, reason_names, array_length(reason_names)))!=NULL)
{
xmpp_attr_t *fake_cond = xmpp_ep_init_attr_t(condition->name, condition->offset, condition->length);
g_hash_table_insert(element->attrs, "condition", fake_cond);
} else if((condition = xmpp_steal_element_by_name(element, "alternative-session"))!=NULL)
{
xmpp_attr_t *fake_cond,*fake_alter_sid;
xmpp_element_t *sid;
fake_cond = xmpp_ep_init_attr_t(condition->name, condition->offset, condition->length);
g_hash_table_insert(element->attrs, "condition", fake_cond);
if((sid = xmpp_steal_element_by_name(condition, "sid"))!=NULL)
{
fake_alter_sid = xmpp_ep_init_attr_t(sid->name, sid->offset, sid->length);
g_hash_table_insert(element->attrs, "sid", fake_alter_sid);
}
}
if((rtp_error = xmpp_steal_element_by_names(element, rtp_error_names, array_length(rtp_error_names)))!=NULL)
{
xmpp_attr_t *fake_rtp_error = xmpp_ep_init_attr_t(rtp_error->name, rtp_error->offset, rtp_error->length);
g_hash_table_insert(element->attrs, "rtp-error", fake_rtp_error);
}
if((text = xmpp_steal_element_by_name(element, "text"))!=NULL)
{
xmpp_attr_t *fake_text = xmpp_ep_init_attr_t(text->data?text->data->value:"", text->offset, text->length);
g_hash_table_insert(element->attrs, "text", fake_text);
}
xmpp_display_attrs(reason_tree, element, pinfo, tvb, attrs_info, array_length(attrs_info));
xmpp_unknown(reason_tree, tvb, pinfo, element);
}
