epan/dissectors/packet-xmpp-utils.c

   1 /* xmpp-utils.c
   2  * Wireshark's XMPP dissector.
   3  *
   4  * Copyright 2011, Mariusz Okroj <okrojmariusz[]gmail.com>
   5  *
   6  * $Id$
   7  *
   8  * Wireshark - Network traffic analyzer
   9  * By Gerald Combs <gerald@wireshark.org>
  10  * Copyright 1998 Gerald Combs
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <glib.h>
  30
  31 #include <epan/packet.h>
  32 #include <epan/expert.h>
  33 #include <epan/tvbparse.h>
  34 #include <epan/strutil.h>
  35
  36 #include <epan/dissectors/packet-xml.h>
  37
  38 #include <packet-xmpp.h>
  39 #include <packet-xmpp-core.h>
  40 #include <packet-xmpp-utils.h>
  41
  42
  43 void
  44 xmpp_iq_reqresp_track(packet_info *pinfo, xmpp_element_t *packet, xmpp_conv_info_t *xmpp_info)
  45 {
  46     xmpp_transaction_t *xmpp_trans = NULL;
  47
  48     xmpp_attr_t *attr_id;
  49     char *id;
  50
  51     attr_id = xmpp_get_attr(packet, "id");
  52
  53     if (!attr_id) {
  54         return;
  55     }
  56
  57     id = wmem_strdup(wmem_packet_scope(), attr_id->value);
  58
  59     if (!pinfo->fd->flags.visited) {
  60         xmpp_trans = (xmpp_transaction_t *)wmem_tree_lookup_string(xmpp_info->req_resp, id, EMEM_TREE_STRING_NOCASE);
  61         if (xmpp_trans) {
  62             xmpp_trans->resp_frame = pinfo->fd->num;
  63
  64         } else {
  65             char *se_id = wmem_strdup(wmem_file_scope(), id);
  66
  67             xmpp_trans = wmem_new(wmem_file_scope(), xmpp_transaction_t);
  68             xmpp_trans->req_frame = pinfo->fd->num;
  69             xmpp_trans->resp_frame = 0;
  70
  71             wmem_tree_insert_string(xmpp_info->req_resp, se_id, (void *) xmpp_trans, EMEM_TREE_STRING_NOCASE);
  72
  73         }
  74
  75     } else {
  76         wmem_tree_lookup_string(xmpp_info->req_resp, id, EMEM_TREE_STRING_NOCASE);
  77     }
  78 }
  79
  80 void
  81 xmpp_jingle_session_track(packet_info *pinfo, xmpp_element_t *packet, xmpp_conv_info_t *xmpp_info)
  82 {
  83     xmpp_element_t *jingle_packet;
  84     GList *jingle_packet_l;
  85
  86     jingle_packet_l = xmpp_find_element_by_name(packet,"jingle");
  87     jingle_packet = (xmpp_element_t *)(jingle_packet_l?jingle_packet_l->data:NULL);
  88
  89     if (jingle_packet && !pinfo->fd->flags.visited) {
  90         xmpp_attr_t *attr_id;
  91         xmpp_attr_t *attr_sid;
  92
  93         char *se_id;
  94         char *se_sid;
  95
  96
  97         attr_id = xmpp_get_attr(packet, "id");
  98         if (!attr_id) {
  99             return;
 100         }
 101
 102         attr_sid = xmpp_get_attr(jingle_packet, "sid");
 103         if (!attr_sid) {
 104             return;
 105         }
 106
 107         se_id = wmem_strdup(wmem_file_scope(), attr_id->value);
 108         se_sid = wmem_strdup(wmem_file_scope(), attr_sid->value);
 109
 110         wmem_tree_insert_string(xmpp_info->jingle_sessions, se_id, (void*) se_sid, EMEM_TREE_STRING_NOCASE);
 111     }
 112 }
 113
 114 void
 115 xmpp_gtalk_session_track(packet_info *pinfo, xmpp_element_t *packet, xmpp_conv_info_t *xmpp_info)
 116 {
 117     xmpp_element_t *gtalk_packet;
 118     GList *gtalk_packet_l;
 119
 120     gtalk_packet_l = xmpp_find_element_by_name(packet,"session");
 121     gtalk_packet = (xmpp_element_t *)(gtalk_packet_l?gtalk_packet_l->data:NULL);
 122
 123
 124     if (gtalk_packet && !pinfo->fd->flags.visited) {
 125         xmpp_attr_t *attr_id;
 126         xmpp_attr_t *attr_sid;
 127
 128         char *se_id;
 129         char *se_sid;
 130
 131         xmpp_attr_t *xmlns = xmpp_get_attr(gtalk_packet, "xmlns");
 132         if(xmlns && strcmp(xmlns->value,"http://www.google.com/session") != 0)
 133             return;
 134
 135         attr_id = xmpp_get_attr(packet, "id");
 136         if (!attr_id) {
 137             return;
 138         }
 139
 140         attr_sid = xmpp_get_attr(gtalk_packet, "id");
 141         if (!attr_sid) {
 142             return;
 143         }
 144
 145         se_id = wmem_strdup(wmem_file_scope(), attr_id->value);
 146         se_sid = wmem_strdup(wmem_file_scope(), attr_sid->value);
 147
 148         wmem_tree_insert_string(xmpp_info->gtalk_sessions, se_id, (void*) se_sid, EMEM_TREE_STRING_NOCASE);
 149     }
 150 }
 151
 152 void
 153 xmpp_ibb_session_track(packet_info *pinfo, xmpp_element_t *packet, xmpp_conv_info_t *xmpp_info)
 154 {
 155     xmpp_element_t *ibb_packet = NULL;
 156     GList *ibb_packet_l;
 157
 158     if(strcmp(packet->name, "message") == 0)
 159     {
 160         ibb_packet_l = xmpp_find_element_by_name(packet,"data");
 161         ibb_packet = (xmpp_element_t *)(ibb_packet_l?ibb_packet_l->data:NULL);
 162
 163     } else if(strcmp(packet->name, "iq") == 0)
 164     {
 165         ibb_packet_l = xmpp_find_element_by_name(packet,"open");
 166
 167         if(!ibb_packet_l)
 168             ibb_packet_l = xmpp_find_element_by_name(packet,"close");
 169          if(!ibb_packet_l)
 170             ibb_packet_l = xmpp_find_element_by_name(packet,"data");
 171
 172         ibb_packet = (xmpp_element_t *)(ibb_packet_l?ibb_packet_l->data:NULL);
 173     }
 174
 175     if (ibb_packet && !pinfo->fd->flags.visited) {
 176         xmpp_attr_t *attr_id;
 177         xmpp_attr_t *attr_sid;
 178
 179         char *se_id;
 180         char *se_sid;
 181
 182
 183         attr_id = xmpp_get_attr(packet, "id");
 184         attr_sid = xmpp_get_attr(ibb_packet, "sid");
 185         if(attr_id && attr_sid)
 186         {
 187             se_id = wmem_strdup(wmem_file_scope(), attr_id->value);
 188             se_sid = wmem_strdup(wmem_file_scope(), attr_sid->value);
 189             wmem_tree_insert_string(xmpp_info->ibb_sessions, se_id, (void*) se_sid, EMEM_TREE_STRING_NOCASE);
 190         }
 191     }
 192 }
 193
 194 static void
 195 xmpp_unknown_items(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, xmpp_element_t *element, guint level)
 196 {
 197     GList *childs = element->elements;
 198
 199     DISSECTOR_ASSERT( level < ETT_UNKNOWN_LEN );
 200
 201     xmpp_unknown_attrs(tree, tvb, pinfo, element, TRUE);
 202
 203     if(element->data)
 204     {
 205         proto_tree_add_text(tree, tvb, element->data->offset, element->data->length, "CDATA: %s",element->data->value);
 206     }
 207
 208     while(childs)
 209     {
 210         xmpp_element_t *child = (xmpp_element_t *)childs->data;
 211         proto_item *child_item = proto_tree_add_text(tree, tvb, child->offset, child->length, "%s", xmpp_ep_string_upcase(child->name));
 212         proto_tree *child_tree = proto_item_add_subtree(child_item, ett_unknown[level]);
 213
 214         if(child->default_ns_abbrev)
 215             proto_item_append_text(child_item, "(%s)", child->default_ns_abbrev);
 216
 217         xmpp_unknown_items(child_tree, tvb, pinfo, child, level +1);
 218
 219         childs = childs->next;
 220     }
 221 }
 222
 223 void
 224 xmpp_unknown(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo, xmpp_element_t *element)
 225 {
 226     GList *childs = element->elements;
 227
 228     /*element has unrecognized elements*/
 229     while(childs)
 230     {
 231         xmpp_element_t *child = (xmpp_element_t *)childs->data;
 232         if(!child->was_read)
 233         {
 234             proto_item *unknown_item;
 235             proto_tree *unknown_tree;
 236
 237             unknown_item = proto_tree_add_string_format(tree,
 238                     hf_xmpp_unknown, tvb, child->offset, child->length, child->name,
 239                     "%s", xmpp_ep_string_upcase(child->name));
 240
 241             unknown_tree = proto_item_add_subtree(unknown_item, ett_unknown[0]);
 242
 243             /*Add COL_INFO only if root element is IQ*/
 244             if(strcmp(element->name,"iq")==0)
 245                 col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", xmpp_ep_string_upcase(child->name));
 246
 247             if(child->default_ns_abbrev)
 248                 proto_item_append_text(unknown_item,"(%s)",child->default_ns_abbrev);
 249
 250             xmpp_unknown_items(unknown_tree, tvb, pinfo, child, 1);
 251             proto_item_append_text(unknown_item, " [UNKNOWN]");
 252             expert_add_info_format(pinfo, unknown_item, &ei_xmpp_unknown_element, "Unknown element: %s", child->name);
 253         }
 254         childs = childs->next;
 255     }
 256 }
 257
 258 void
 259 xmpp_unknown_attrs(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo _U_, xmpp_element_t *element, gboolean displ_short_list)
 260 {
 261     proto_item *item = proto_tree_get_parent(tree);
 262
 263     GList *keys = g_hash_table_get_keys(element->attrs);
 264     GList *values = g_hash_table_get_values(element->attrs);
 265
 266     GList *keys_head = keys, *values_head = values;
 267
 268     gboolean short_list_started = FALSE;
 269
 270     while(keys && values)
 271     {
 272         xmpp_attr_t *attr = (xmpp_attr_t*) values->data;
 273         if (!attr->was_read) {
 274             if (displ_short_list) {
 275                 if (!short_list_started)
 276                     proto_item_append_text(item, " [");
 277                 else
 278                     proto_item_append_text(item, " ");
 279                 proto_item_append_text(item, "%s=\"%s\"", (gchar*) keys->data, attr->value);
 280
 281                 short_list_started = TRUE;
 282             }
 283
 284             /*If unknown element has xmlns attrib then header field hf_xmpp_xmlns is added to the tree.
 285              In other case only text.*/
 286             if (strcmp((const char *)keys->data, "xmlns") == 0)
 287                 proto_tree_add_string(tree, hf_xmpp_xmlns, tvb, attr->offset, attr->length, attr->value);
 288             else {
 289                 /*xmlns may looks like xmlns:abbrev="sth"*/
 290                 gchar* xmlns_needle = epan_strcasestr((const char *)keys->data, "xmlns:");
 291                 if (xmlns_needle && xmlns_needle == keys->data) {
 292                     proto_tree_add_string_format(tree, hf_xmpp_xmlns, tvb, attr->offset, attr->length, attr->value,"%s: %s", (gchar*)keys->data, attr->value);
 293                 } else {
 294                     proto_item* unknown_attr_item;
 295                     unknown_attr_item = proto_tree_add_string_format(tree,
 296                             hf_xmpp_unknown_attr, tvb, attr->offset, attr->length,
 297                             attr->name, "%s: %s", attr->name, attr->value);
 298                     proto_item_append_text(unknown_attr_item, " [UNKNOWN ATTR]");
 299                     expert_add_info_format(pinfo, unknown_attr_item, &ei_xmpp_unknown_attribute, "Unknown attribute %s", attr->name);
 300                 }
 301             }
 302         }
 303         keys = keys->next;
 304         values = values->next;
 305     }
 306
 307     if(short_list_started && displ_short_list)
 308         proto_item_append_text(item, "]");
 309
 310     g_list_free(keys_head);
 311     g_list_free(values_head);
 312 }
 313
 314 void
 315 xmpp_cdata(proto_tree *tree, tvbuff_t *tvb, xmpp_element_t *element, gint hf)
 316 {
 317     if(element->data)
 318 {
 319         if (hf == -1) {
 320             proto_tree_add_text(tree, tvb, element->data->offset, element->data->length, "CDATA: %s", element->data->value);
 321         } else {
 322             proto_tree_add_string(tree, hf, tvb, element->data->offset, element->data->length, element->data->value);
 323         }
 324     } else
 325     {
 326         if (hf == -1) {
 327             proto_tree_add_text(tree, tvb, 0, 0, "CDATA: (empty)");
 328         } else {
 329             proto_tree_add_string(tree, hf, tvb, 0, 0, "");
 330         }
 331     }
 332 }
 333
 334 /* displays element that looks like <element_name>element_value</element_name>
 335  * ELEMENT_NAME: element_value as TEXT(proto_tree_add_text) int PROTO_TREE
 336  */
 337 void
 338 xmpp_simple_cdata_elem(proto_tree *tree, tvbuff_t *tvb, packet_info *pinfo _U_, xmpp_element_t *element)
 339 {
 340     proto_tree_add_text(tree, tvb, element->offset, element->length, "%s: %s", xmpp_ep_string_upcase(element->name), xmpp_elem_cdata(element));
 341 }
 342
 343 xmpp_array_t*
 344 xmpp_ep_init_array_t(const gchar** array, gint len)
 345 {
 346     xmpp_array_t *result;
 347
 348     result = wmem_new(wmem_packet_scope(), xmpp_array_t);
 349     result->data = (gpointer) array;
 350     result->length = len;
 351
 352     return result;
 353 }
 354
 355 xmpp_attr_t*
 356 xmpp_ep_init_attr_t(const gchar *value, gint offset, gint length)
 357 {
 358     xmpp_attr_t *result;
 359     result = wmem_new(wmem_packet_scope(), xmpp_attr_t);
 360     result->value = value;
 361     result->offset = offset;
 362     result->length = length;
 363     result->name = NULL;
 364
 365     return result;
 366 }
 367
 368 gchar*
 369 xmpp_ep_string_upcase(const gchar* string)
 370 {
 371     gint len = (int)strlen(string);
 372     gint i;
 373     gchar* result = (gchar *)wmem_alloc0(wmem_packet_scope(), len+1);
 374     for(i=0; i<len; i++)
 375     {
 376         result[i] = string[i];
 377
 378         if(string[i]>='a' && string[i]<='z')
 379             result[i]-='a'-'A';
 380
 381     }
 382     return result;
 383 }
 384
 385 gint
 386 xmpp_element_t_cmp(gconstpointer a, gconstpointer b)
 387 {
 388     gint result = strcmp(((xmpp_element_t*)a)->name,((xmpp_element_t*)b)->name);
 389
 390     if(result == 0 && ((xmpp_element_t*)a)->was_read)
 391         result = -1;
 392
 393     return result;
 394 }
 395
 396 GList*
 397 xmpp_find_element_by_name(xmpp_element_t *packet,const gchar *name)
 398 {
 399     GList *found_elements;
 400     xmpp_element_t *search_element;
 401
 402     /*create fake element only with name*/
 403     search_element = wmem_new(wmem_packet_scope(), xmpp_element_t);
 404     search_element->name = wmem_strdup(wmem_packet_scope(), name);
 405
 406     found_elements = g_list_find_custom(packet->elements, search_element, xmpp_element_t_cmp);
 407
 408     if(found_elements)
 409         return found_elements;
 410     else
 411         return NULL;
 412 }
 413
 414
 415 /* steal_*
 416  * function searches element in packet and sets it as read.
 417  * if element doesn't exist, NULL is returned.
 418  * If element is set as read, it is invisible for these functions.*/
 419 xmpp_element_t*
 420 xmpp_steal_element_by_name(xmpp_element_t *packet,const gchar *name)
 421 {
 422     GList *element_l;
 423     xmpp_element_t *element = NULL;
 424
 425     element_l = xmpp_find_element_by_name(packet, name);
 426
 427     if(element_l)
 428     {
 429         element = (xmpp_element_t *)element_l->data;
 430         element->was_read = TRUE;
 431     }
 432
 433     return element;
 434
 435 }
 436
 437 xmpp_element_t*
 438 xmpp_steal_element_by_names(xmpp_element_t *packet, const gchar **names, gint names_len)
 439 {
 440     gint i;
 441     xmpp_element_t *el = NULL;
 442
 443     for(i = 0; i<names_len; i++)
 444     {
 445         if((el = xmpp_steal_element_by_name(packet, names[i])))
 446             break;
 447     }
 448
 449     return el;
 450 }
 451
 452 xmpp_element_t*
 453 xmpp_steal_element_by_attr(xmpp_element_t *packet, const gchar *attr_name, const gchar *attr_value)
 454 {
 455     GList *childs = packet->elements;
 456     xmpp_element_t *result = NULL;
 457
 458     while (childs) {
 459         xmpp_element_t *child_elem = (xmpp_element_t *)childs->data;
 460         xmpp_attr_t *attr = xmpp_get_attr(child_elem, attr_name);
 461
 462         if(attr)
 463             attr->was_read = FALSE;
 464
 465         if (!child_elem->was_read && attr && strcmp(attr->value, attr_value) == 0) {
 466
 467             result = (xmpp_element_t *)childs->data;
 468
 469             result->was_read = TRUE;
 470
 471             break;
 472         } else
 473             childs = childs->next;
 474     }
 475
 476     return result;
 477 }
 478
 479 xmpp_element_t*
 480 xmpp_steal_element_by_name_and_attr(xmpp_element_t *packet, const gchar *name, const gchar *attr_name, const gchar *attr_value)
 481 {
 482     GList *childs = packet->elements;
 483     xmpp_element_t *result = NULL;
 484
 485     while (childs) {
 486         xmpp_element_t *child_elem = (xmpp_element_t *)childs->data;
 487         xmpp_attr_t *attr = xmpp_get_attr(child_elem, attr_name);
 488
 489         if(attr)
 490             attr->was_read = FALSE;
 491
 492         if (!child_elem->was_read && attr && strcmp(child_elem->name, name) == 0 && strcmp(attr->value, attr_value) == 0) {
 493
 494             result = (xmpp_element_t *)childs->data;
 495
 496             result->was_read = TRUE;
 497
 498             break;
 499         } else
 500             childs = childs->next;
 501     }
 502     return result;
 503 }
 504
 505 xmpp_element_t*
 506 xmpp_get_first_element(xmpp_element_t *packet)
 507 {
 508     if(packet->elements && packet->elements->data)
 509         return (xmpp_element_t *)packet->elements->data;
 510     else
 511         return NULL;
 512 }
 513
 514 /*
 515 Function converts xml_frame_t structure to xmpp_element_t (simpler representation)
 516 */
 517 xmpp_element_t*
 518 xmpp_xml_frame_to_element_t(xml_frame_t *xml_frame, xmpp_element_t *parent, tvbuff_t *tvb)
 519 {
 520     xml_frame_t *child;
 521     xmpp_element_t *node = wmem_new0(wmem_packet_scope(), xmpp_element_t);
 522
 523     tvbparse_t* tt;
 524     tvbparse_elem_t* elem;
 525
 526     node->attrs = g_hash_table_new(g_str_hash, g_str_equal);
 527     node->elements = NULL;
 528     node->data = NULL;
 529     node->was_read = FALSE;
 530     node->default_ns_abbrev = NULL;
 531
 532     node->name = wmem_strdup(wmem_packet_scope(), xml_frame->name_orig_case);
 533     node->offset = 0;
 534     node->length = 0;
 535
 536     node->namespaces = g_hash_table_new(g_str_hash, g_str_equal);
 537     if(parent)
 538     {
 539         xmpp_copy_hash_table(parent->namespaces, node->namespaces);
 540     } else
 541     {
 542         g_hash_table_insert(node->namespaces, (gpointer)"", (gpointer)"jabber:client");
 543     }
 544
 545     if(xml_frame->item != NULL)
 546     {
 547         node->length = xml_frame->item->finfo->length;
 548     }
 549
 550     node->offset = xml_frame->start_offset;
 551
 552     tt = tvbparse_init(tvb,node->offset,-1,NULL,want_ignore);
 553
 554     if((elem = tvbparse_get(tt,want_stream_end_with_ns))!=NULL)
 555     {
 556         node->default_ns_abbrev = tvb_get_string(wmem_packet_scope(), elem->sub->tvb, elem->sub->offset, elem->sub->len);
 557     }
 558
 559     child = xml_frame->first_child;
 560
 561     while(child)
 562     {
 563         if(child->type != XML_FRAME_TAG)
 564         {
 565             if(child->type == XML_FRAME_ATTRIB)
 566             {
 567                 gint l;
 568                 gchar *value = NULL;
 569                 gchar *xmlns_needle = NULL;
 570
 571                 xmpp_attr_t *attr = wmem_new(wmem_packet_scope(), xmpp_attr_t);
 572                 attr->length = 0;
 573                 attr->offset = 0;
 574                 attr->was_read = FALSE;
 575
 576                 if (child->value != NULL) {
 577                     l = tvb_reported_length(child->value);
 578                     value = (gchar *)wmem_alloc0(wmem_packet_scope(), l + 1);
 579                     tvb_memcpy(child->value, value, 0, l);
 580                 }
 581
 582                 if(child->item)
 583                 {
 584                     attr->length = child->item->finfo->length;
 585                 }
 586
 587                 attr->offset = child->start_offset;
 588                 attr->value = value;
 589                 attr->name = wmem_strdup(wmem_packet_scope(), child->name_orig_case);
 590
 591                 g_hash_table_insert(node->attrs,(gpointer)attr->name,(gpointer)attr);
 592
 593                 /*checking that attr->name looks like xmlns:ns*/
 594                 xmlns_needle = epan_strcasestr(attr->name, "xmlns");
 595
 596                 if(xmlns_needle == attr->name)
 597                 {
 598                     if(attr->name[5] == ':' && strlen(attr->name) > 6)
 599                     {
 600                         g_hash_table_insert(node->namespaces, (gpointer)wmem_strdup(wmem_packet_scope(), &attr->name[6]), (gpointer)wmem_strdup(wmem_packet_scope(), attr->value));
 601                     } else if(attr->name[5] == '\0')
 602                     {
 603                         g_hash_table_insert(node->namespaces, (gpointer)"", (gpointer)wmem_strdup(wmem_packet_scope(), attr->value));
 604                     }
 605                 }
 606
 607
 608             }
 609             else if( child->type == XML_FRAME_CDATA)
 610             {
 611                 xmpp_data_t *data = NULL;
 612                 gint l;
 613                 gchar* value = NULL;
 614
 615                 data =  wmem_new(wmem_packet_scope(), xmpp_data_t);
 616                 data->length = 0;
 617                 data->offset = 0;
 618
 619                 if (child->value != NULL) {
 620                     l = tvb_reported_length(child->value);
 621                     value = (gchar *)wmem_alloc0(wmem_packet_scope(), l + 1);
 622                     tvb_memcpy(child->value, value, 0, l);
 623                 }
 624
 625                 data->value = value;
 626
 627                 if(child->item)
 628                 {
 629                     data->length = child->item->finfo->length;
 630                 }
 631                 data->offset = child->start_offset;
 632                 node->data = data;
 633             }
 634         } else
 635         {
 636             node->elements = g_list_append(node->elements,(gpointer)xmpp_xml_frame_to_element_t(child, node,tvb));
 637         }
 638
 639         child = child->next_sibling;
 640     }
 641     return node;
 642 }
 643
 644 void
 645 xmpp_element_t_tree_free(xmpp_element_t *root)
 646 {
 647     GList *childs = root->elements;
 648
 649     g_hash_table_destroy(root->attrs);
 650     g_hash_table_destroy(root->namespaces);
 651
 652     while(childs)
 653     {
 654         xmpp_element_t *child = (xmpp_element_t *)childs->data;
 655
 656         xmpp_element_t_tree_free(child);
 657         childs = childs->next;
 658     }
 659     g_list_free(root->elements);
 660 }
 661
 662 /*Function recognize attribute names if they looks like xmlns:ns*/
 663 static gboolean
 664 attr_find_pred(gpointer key, gpointer value _U_, gpointer user_data)
 665 {
 666     gchar *attr_name = (gchar*) user_data;
 667
 668     if( strcmp(attr_name, "xmlns") == 0 )
 669     {
 670         gchar *first_occur = epan_strcasestr((const char *)key, "xmlns:");
 671         if(first_occur && first_occur == key)
 672             return TRUE;
 673         else
 674             return FALSE;
 675     }
 676     return FALSE;
 677 }
 678
 679 /*Functions returns element's attibute by name and set as read*/
 680 xmpp_attr_t*
 681 xmpp_get_attr(xmpp_element_t *element, const gchar* attr_name)
 682 {
 683     xmpp_attr_t *result = (xmpp_attr_t *)g_hash_table_lookup(element->attrs, attr_name);
 684
 685     if(!result)
 686     {
 687         result = (xmpp_attr_t *)g_hash_table_find(element->attrs, attr_find_pred, (gpointer)attr_name);
 688     }
 689
 690     if(result)
 691         result->was_read = TRUE;
 692
 693     return result;
 694 }
 695
 696 /*Functions returns element's attibute by name and namespace abbrev*/
 697 static xmpp_attr_t*
 698 xmpp_get_attr_ext(xmpp_element_t *element, const gchar* attr_name, const gchar* ns_abbrev)
 699 {
 700     gchar* search_phrase;
 701     xmpp_attr_t *result;
 702
 703     if(strcmp(ns_abbrev,"")==0)
 704         search_phrase = wmem_strdup(wmem_packet_scope(), attr_name);
 705     else if(strcmp(attr_name, "xmlns") == 0)
 706         search_phrase = wmem_strdup_printf(wmem_packet_scope(), "%s:%s",attr_name, ns_abbrev);
 707     else
 708         search_phrase = wmem_strdup_printf(wmem_packet_scope(), "%s:%s", ns_abbrev, attr_name);
 709
 710     result = (xmpp_attr_t *)g_hash_table_lookup(element->attrs, search_phrase);
 711
 712     if(!result)
 713     {
 714         result = (xmpp_attr_t *)g_hash_table_find(element->attrs, attr_find_pred, (gpointer)attr_name);
 715     }
 716
 717     if(result)
 718         result->was_read = TRUE;
 719
 720     return result;
 721 }
 722
 723
 724
 725 gchar*
 726 xmpp_element_to_string(tvbuff_t *tvb, xmpp_element_t *element)
 727 {
 728     gchar *buff = NULL;
 729
 730     if(tvb_offset_exists(tvb, element->offset+element->length-1))
 731     {
 732         buff = tvb_get_string(wmem_packet_scope(), tvb, element->offset, element->length);
 733     }
 734     return buff;
 735 }
 736
 737 gchar*
 738 xmpp_attr_to_string(tvbuff_t *tvb, xmpp_attr_t *attr)
 739 {
 740     gchar *buff = NULL;
 741
 742     if(tvb_offset_exists(tvb, attr->offset + attr->length-1))
 743     {
 744         buff = tvb_get_string(wmem_packet_scope(), tvb, attr->offset, attr->length);
 745     }
 746     return buff;
 747 }
 748
 749 static void
 750 children_foreach_hide_func(proto_node *node, gpointer data)
 751 {
 752     int *i = (int *)data;
 753     if((*i) == 0)
 754         PROTO_ITEM_SET_HIDDEN(node);
 755     (*i)++;
 756 }
 757
 758 static void
 759 children_foreach_show_func(proto_node *node, gpointer data)
 760 {
 761     int *i = (int *)data;
 762     if((*i) == 0)
 763         PROTO_ITEM_SET_VISIBLE(node);
 764     (*i)++;
 765 }
 766
 767 void
 768 xmpp_proto_tree_hide_first_child(proto_tree *tree)
 769 {
 770     int i = 0;
 771     proto_tree_children_foreach(tree, children_foreach_hide_func, &i);
 772 }
 773
 774 void
 775 xmpp_proto_tree_show_first_child(proto_tree *tree)
 776 {
 777     int i = 0;
 778     proto_tree_children_foreach(tree, children_foreach_show_func, &i);
 779 }
 780
 781 gchar*
 782 proto_item_get_text(proto_item *item)
 783 {
 784     field_info *fi = NULL;
 785     gchar *result;
 786
 787     if(item == NULL)
 788         return NULL;
 789
 790     fi = PITEM_FINFO(item);
 791
 792     if(fi==NULL)
 793         return NULL;
 794
 795     if (fi->rep == NULL)
 796         return NULL;
 797
 798
 799     result = wmem_strdup(wmem_packet_scope(), fi->rep->representation);
 800     return result;
 801 }
 802
 803
 804 void
 805 xmpp_display_attrs(proto_tree *tree, xmpp_element_t *element, packet_info *pinfo, tvbuff_t *tvb, xmpp_attr_info *attrs, guint n)
 806 {
 807     proto_item *item = proto_tree_get_parent(tree);
 808     xmpp_attr_t *attr;
 809     guint i;
 810     gboolean short_list_started = FALSE;
 811
 812     if(element->default_ns_abbrev)
 813         proto_item_append_text(item, "(%s)",element->default_ns_abbrev);
 814
 815     proto_item_append_text(item," [");
 816     for(i = 0; i < n && attrs!=NULL; i++)
 817     {
 818         attr = xmpp_get_attr(element, attrs[i].name);
 819         if(attr)
 820         {
 821             if(attrs[i].hf != -1)
 822             {
 823                 if(attr->name)
 824                     proto_tree_add_string_format(tree, attrs[i].hf, tvb, attr->offset, attr->length, attr->value,"%s: %s", attr->name, attr->value);
 825                 else
 826                     proto_tree_add_string(tree, attrs[i].hf, tvb, attr->offset, attr->length, attr->value);
 827             }
 828             else
 829             {
 830                 proto_tree_add_text(tree, tvb, attr->offset, attr->length, "%s: %s", attr->name?attr->name:attrs[i].name, attr->value);
 831             }
 832
 833             if(attrs[i].in_short_list)
 834             {
 835                 if(short_list_started)
 836                 {
 837                     proto_item_append_text(item," ");
 838                 }
 839                 proto_item_append_text(item,"%s=\"%s\"",attr->name?attr->name:attrs[i].name, attr->value);
 840                 short_list_started = TRUE;
 841             }
 842
 843         } else if(attrs[i].is_required)
 844         {
 845             expert_add_info_format(pinfo, item, &ei_xmpp_required_attribute, "Required attribute \"%s\" doesn't appear in \"%s\".", attrs[i].name, element->name);
 846         }
 847
 848         if(attrs[i].val_func)
 849         {
 850             if(attr)
 851                 attrs[i].val_func(pinfo, item, attrs[i].name, attr->value, attrs[i].data);
 852             else
 853                 attrs[i].val_func(pinfo, item, attrs[i].name, NULL, attrs[i].data);
 854         }
 855     }
 856     proto_item_append_text(item,"]");
 857
 858     /*displays attributes that weren't recognized*/
 859     xmpp_unknown_attrs(tree, tvb, pinfo, element, FALSE);
 860 }
 861
 862 void
 863 xmpp_display_attrs_ext(proto_tree *tree, xmpp_element_t *element, packet_info *pinfo, tvbuff_t *tvb, xmpp_attr_info_ext *attrs, guint n)
 864 {
 865     proto_item *item = proto_tree_get_parent(tree);
 866     xmpp_attr_t *attr;
 867     guint i;
 868     gboolean short_list_started = FALSE;
 869
 870     GList *ns_abbrevs_head, *ns_abbrevs = g_hash_table_get_keys(element->namespaces);
 871     GList *ns_fullnames_head, *ns_fullnames = g_hash_table_get_values(element->namespaces);
 872     ns_abbrevs_head = ns_abbrevs;
 873     ns_fullnames_head = ns_fullnames;
 874
 875     if(element->default_ns_abbrev)
 876         proto_item_append_text(item, "(%s)",element->default_ns_abbrev);
 877
 878     proto_item_append_text(item," [");
 879     while(ns_abbrevs && ns_fullnames)
 880     {
 881         for (i = 0; i < n && attrs != NULL; i++) {
 882             if(strcmp((const char *)(ns_fullnames->data), attrs[i].ns) == 0)
 883             {
 884                 attr = xmpp_get_attr_ext(element, attrs[i].info.name, (const gchar *)(ns_abbrevs->data));
 885                 if(!attr && element->default_ns_abbrev && strcmp((const char *)ns_abbrevs->data, element->default_ns_abbrev)==0)
 886                     attr = xmpp_get_attr_ext(element, attrs[i].info.name, "");
 887
 888                 if (attr) {
 889                     if (attrs[i].info.hf != -1) {
 890                         if (attr->name)
 891                             proto_tree_add_string_format(tree, attrs[i].info.hf, tvb, attr->offset, attr->length, attr->value, "%s: %s", attr->name, attr->value);
 892                         else
 893                             proto_tree_add_string(tree, attrs[i].info.hf, tvb, attr->offset, attr->length, attr->value);
 894                     } else {
 895                         proto_tree_add_text(tree, tvb, attr->offset, attr->length, "%s: %s", attr->name ? attr->name : attrs[i].info.name, attr->value);
 896                     }
 897
 898                     if (attrs[i].info.in_short_list) {
 899                         if (short_list_started) {
 900                             proto_item_append_text(item, " ");
 901                         }
 902                         proto_item_append_text(item, "%s=\"%s\"", attr->name ? attr->name : attrs[i].info.name, attr->value);
 903                         short_list_started = TRUE;
 904                     }
 905
 906                 } else if (attrs[i].info.is_required) {
 907                     expert_add_info_format(pinfo, item, &ei_xmpp_required_attribute, "Required attribute \"%s\" doesn't appear in \"%s\".", attrs[i].info.name, element->name);
 908                 }
 909
 910                 if (attrs[i].info.val_func) {
 911                     if (attr)
 912                         attrs[i].info.val_func(pinfo, item, attrs[i].info.name, attr->value, attrs[i].info.data);
 913                     else
 914                         attrs[i].info.val_func(pinfo, item, attrs[i].info.name, NULL, attrs[i].info.data);
 915                 }
 916             }
 917         }
 918         ns_abbrevs = ns_abbrevs->next;
 919         ns_fullnames = ns_fullnames->next;
 920     }
 921     proto_item_append_text(item,"]");
 922
 923     /*displays attributes that weren't recognized*/
 924     xmpp_unknown_attrs(tree, tvb, pinfo, element, FALSE);
 925
 926     g_list_free(ns_abbrevs_head);
 927     g_list_free(ns_fullnames_head);
 928 }
 929
 930 typedef struct _name_attr_t
 931 {
 932     const gchar *name;
 933     const gchar *attr_name;
 934     const gchar *attr_value;
 935 } name_attr_t;
 936
 937 /*
 938 returns pointer to the struct that contains 3 strings(element name, attribute name, attribute value)
 939 */
 940 gpointer
 941 xmpp_name_attr_struct(const gchar *name, const gchar *attr_name, const gchar *attr_value)
 942 {
 943     name_attr_t *result;
 944
 945     result =  wmem_new(wmem_packet_scope(), name_attr_t);
 946     result->name = name;
 947     result->attr_name = attr_name;
 948     result->attr_value = attr_value;
 949     return result;
 950 }
 951
 952 void
 953 xmpp_display_elems(proto_tree *tree, xmpp_element_t *parent, packet_info *pinfo, tvbuff_t *tvb, xmpp_elem_info *elems, guint n)
 954 {
 955     guint i;
 956
 957     for(i = 0; i < n && elems!=NULL; i++)
 958     {
 959         xmpp_element_t *elem = NULL;
 960
 961         if(elems[i].type == NAME_AND_ATTR)
 962         {
 963             gboolean loop = TRUE;
 964
 965             name_attr_t *a = (name_attr_t *)(elems[i].data);
 966
 967             while(loop && (elem = xmpp_steal_element_by_name_and_attr(parent, a->name, a->attr_name, a->attr_value))!=NULL)
 968             {
 969                 elems[i].elem_func(tree, tvb, pinfo, elem);
 970                 if(elems[i].occurrence == ONE)
 971                     loop = FALSE;
 972             }
 973         } else if(elems[i].type == NAME)
 974         {
 975             gboolean loop = TRUE;
 976             const gchar *name = (const gchar *)(elems[i].data);
 977
 978             while(loop && (elem = xmpp_steal_element_by_name(parent, name))!=NULL)
 979             {
 980                 elems[i].elem_func(tree, tvb, pinfo, elem);
 981                 if(elems[i].occurrence == ONE)
 982                     loop = FALSE;
 983             }
 984         }
 985         else if(elems[i].type == ATTR)
 986         {
 987             gboolean loop = TRUE;
 988             name_attr_t *attr = (name_attr_t *)(elems[i].data);
 989
 990             while(loop && (elem = xmpp_steal_element_by_attr(parent, attr->attr_name, attr->attr_value))!=NULL)
 991             {
 992                 elems[i].elem_func(tree, tvb, pinfo, elem);
 993                 if(elems[i].occurrence == ONE)
 994                     loop = FALSE;
 995             }
 996
 997         } else if(elems[i].type == NAMES)
 998         {
 999             gboolean loop = TRUE;
1000             const xmpp_array_t *names = (const xmpp_array_t *)(elems[i].data);
1001
1002             while(loop && (elem =  xmpp_steal_element_by_names(parent, (const gchar**)names->data, names->length))!=NULL)
1003             {
1004                 elems[i].elem_func(tree, tvb, pinfo, elem);
1005                 if(elems[i].occurrence == ONE)
1006                     loop = FALSE;
1007             }
1008         }
1009     }
1010
1011     xmpp_unknown(tree, tvb, pinfo, parent);
1012 }
1013
1014 /*
1015 function checks that variable value is in array ((xmpp_array_t)data)->data
1016 */
1017 void
1018 xmpp_val_enum_list(packet_info *pinfo, proto_item *item, const gchar *name, const gchar *value, gconstpointer data)
1019 {
1020     const xmpp_array_t *enums_array = (const xmpp_array_t *)data;
1021
1022     gint i;
1023     gboolean value_in_enums = FALSE;
1024
1025     gchar **enums =  (char**)enums_array->data;
1026
1027     if (value != NULL) {
1028         for (i = 0; i < enums_array->length; i++) {
1029             if (strcmp(value, enums[i]) == 0) {
1030                 value_in_enums = TRUE;
1031                 break;
1032             }
1033         }
1034         if (!value_in_enums) {
1035             expert_add_info_format(pinfo, item, &ei_xmpp_field_unexpected_value, "Field \"%s\" has unexpected value \"%s\"", name, value);
1036         }
1037     }
1038 }
1039
1040
1041 void
1042 xmpp_change_elem_to_attrib(const gchar *elem_name, const gchar *attr_name, xmpp_element_t *parent, xmpp_attr_t* (*transform_func)(xmpp_element_t *element))
1043 {
1044     xmpp_element_t *element = NULL;
1045     xmpp_attr_t *fake_attr = NULL;
1046
1047     element = xmpp_steal_element_by_name(parent, elem_name);
1048     if(element)
1049         fake_attr = transform_func(element);
1050
1051     if(fake_attr)
1052         g_hash_table_insert(parent->attrs, (gpointer)attr_name, fake_attr);
1053 }
1054
1055 xmpp_attr_t*
1056 xmpp_transform_func_cdata(xmpp_element_t *elem)
1057 {
1058     xmpp_attr_t *result = xmpp_ep_init_attr_t(elem->data?elem->data->value:"", elem->offset, elem->length);
1059     return result;
1060 }
1061
1062 static void
1063 xmpp_copy_hash_table_func(gpointer key, gpointer value, gpointer user_data)
1064 {
1065     GHashTable *dst = (GHashTable *)user_data;
1066     g_hash_table_insert(dst, key, value);
1067 }
1068
1069 void xmpp_copy_hash_table(GHashTable *src, GHashTable *dst)
1070 {
1071     g_hash_table_foreach(src, xmpp_copy_hash_table_func, dst);
1072 }
1073
1074 #if 0
1075 static void
1076 printf_hash_table_func(gpointer key, gpointer value, gpointer user_data _U_)
1077 {
1078     printf("'%s' '%s'\n", (gchar*)key, (gchar*)value);
1079 }
1080
1081 void
1082 printf_elements(xmpp_element_t *root)
1083 {
1084     GList *elems = root->elements;
1085
1086     printf("%s\n", root->name);
1087     g_hash_table_foreach(root->namespaces, printf_hash_table_func, NULL);
1088     while(elems)
1089     {
1090         printf_elements(elems->data);
1091         elems = elems->next;
1092     }
1093 }
1094 #endif
1095
1096 /*
1097 * Editor modelines - http://www.wireshark.org/tools/modelines.html
1098 *
1099 * Local variables:
1100 * c-basic-offset: 4
1101 * tab-width: 8
1102 * indent-tabs-mode: nil
1103 * End:
1104 *
1105 * ex: set shiftwidth=4 tabstop=8 expandtab:
1106 * :indentSize=4:tabSize=8:noTabs=true:
1107 */