epan/packet.c

   1 /* packet.c
   2  * Routines for packet disassembly
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #include <glib.h>
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33
  34 #ifdef HAVE_STDARG_H
  35 #include <stdarg.h>
  36 #endif
  37
  38 #include <string.h>
  39 #include <ctype.h>
  40 #include <time.h>
  41
  42 #include "packet.h"
  43 #include "timestamp.h"
  44
  45 #include "atalk-utils.h"
  46 #include "sna-utils.h"
  47 #include "osi-utils.h"
  48 #include "to_str.h"
  49
  50 #include "addr_resolv.h"
  51 #include "tvbuff.h"
  52 #include "plugins.h"
  53 #include "epan_dissect.h"
  54 #include "emem.h"
  55
  56 #include <epan/reassemble.h>
  57 #include <epan/stream.h>
  58 #include <epan/expert.h>
  59
  60 static gint proto_malformed = -1;
  61 static dissector_handle_t frame_handle = NULL;
  62 static dissector_handle_t data_handle = NULL;
  63
  64 void
  65 packet_init(void)
  66 {
  67   frame_handle = find_dissector("frame");
  68   data_handle = find_dissector("data");
  69   proto_malformed = proto_get_id_by_filter_name("malformed");
  70 }
  71
  72 void
  73 packet_cleanup(void)
  74 {
  75         /* nothing */
  76 }
  77
  78 /*
  79  * Given a tvbuff, and a length from a packet header, adjust the length
  80  * of the tvbuff to reflect the specified length.
  81  */
  82 void
  83 set_actual_length(tvbuff_t *tvb, guint specified_len)
  84 {
  85   if (specified_len < tvb_reported_length(tvb)) {
  86     /* Adjust the length of this tvbuff to include only the specified
  87        payload length.
  88
  89        The dissector above the one calling us (the dissector above is
  90        probably us) may use that to determine how much of its packet
  91        was padding. */
  92     tvb_set_reported_length(tvb, specified_len);
  93   }
  94 }
  95
  96 /* Allow protocols to register "init" routines, which are called before
  97    we make a pass through a capture file and dissect all its packets
  98    (e.g., when we read in a new capture file, or run a "filter packets"
  99    or "colorize packets" pass over the current capture file). */
 100 static GSList *init_routines;
 101
 102 void
 103 register_init_routine(void (*func)(void))
 104 {
 105         init_routines = g_slist_append(init_routines, (gpointer)func);
 106 }
 107
 108 typedef void (*void_func_t)(void);
 109
 110 /* Initialize all data structures used for dissection. */
 111 static void
 112 call_init_routine(gpointer routine, gpointer dummy _U_)
 113 {
 114         void_func_t func = (void_func_t)routine;
 115         (*func)();
 116 }
 117
 118 /*
 119  * XXX - for now, these are the same; the "init" routines free whatever
 120  * stuff is left over from any previous dissection, and then initialize
 121  * their tables.
 122  *
 123  * We should probably split that into "init" and "cleanup" routines, for
 124  * cleanliness' sake.
 125  */
 126 void
 127 init_dissection(void)
 128 {
 129         /* Reclaim and reinitialize all memory of seasonal scope */
 130         se_free_all();
 131
 132         /* Initialize the table of conversations. */
 133         epan_conversation_init();
 134
 135         /* Initialize the table of circuits. */
 136         epan_circuit_init();
 137
 138         /* Initialize protocol-specific variables. */
 139         g_slist_foreach(init_routines, &call_init_routine, NULL);
 140
 141         /* Initialize the common data structures for fragment reassembly.
 142            Must be done *after* calling init routines, as those routines
 143            may free up space for fragments, which they find by using the
 144            data structures that "reassemble_init()" frees. */
 145         reassemble_init();
 146
 147         /* Initialize the stream-handling tables */
 148         stream_init();
 149
 150         /* Initialize the expert infos */
 151         expert_init();
 152 }
 153
 154 void
 155 cleanup_dissection(void)
 156 {
 157         init_dissection();
 158 }
 159
 160 /* Allow protocols to register a "cleanup" routine to be
 161  * run after the initial sequential run through the packets.
 162  * Note that the file can still be open after this; this is not
 163  * the final cleanup. */
 164 static GSList *postseq_cleanup_routines;
 165
 166 void
 167 register_postseq_cleanup_routine(void_func_t func)
 168 {
 169         postseq_cleanup_routines = g_slist_append(postseq_cleanup_routines,
 170                         (gpointer)func);
 171 }
 172
 173 /* Call all the registered "postseq_cleanup" routines. */
 174 static void
 175 call_postseq_cleanup_routine(gpointer routine, gpointer dummy _U_)
 176 {
 177         void_func_t func = (void_func_t)routine;
 178         (*func)();
 179 }
 180
 181 void
 182 postseq_cleanup_all_protocols(void)
 183 {
 184         g_slist_foreach(postseq_cleanup_routines,
 185                         &call_postseq_cleanup_routine, NULL);
 186 }
 187
 188 /*
 189  * Add a new data source to the list of data sources for a frame, given
 190  * the tvbuff for the data source and its name.
 191  */
 192 void
 193 add_new_data_source(packet_info *pinfo, tvbuff_t *tvb, const char *name)
 194 {
 195         data_source *src;
 196
 197         src = ep_alloc(sizeof (data_source));
 198         src->tvb = tvb;
 199         /*
 200          * XXX - if we require this argument to be a string constant,
 201          * we don't need to allocate a buffer for a copy and make a
 202          * copy, and wouldn't need to free the buffer, either.
 203          */
 204         src->name = ep_strdup_printf("%s (%u bytes)", name, tvb_length(tvb));
 205         pinfo->data_src = g_slist_append(pinfo->data_src, src);
 206 }
 207
 208 /*
 209  * Free up a frame's list of data sources.
 210  */
 211 void
 212 free_data_sources(packet_info *pinfo)
 213 {
 214         g_slist_free(pinfo->data_src);
 215         pinfo->data_src = NULL;
 216 }
 217
 218 /* Allow dissectors to register a "final_registration" routine
 219  * that is run like the proto_register_XXX() routine, but at the
 220  * end of the epan_init() function; that is, *after* all other
 221  * subsystems, like dfilters, have finished initializing. This is
 222  * useful for dissector registration routines which need to compile
 223  * display filters. dfilters can't initialize itself until all protocols
 224  * have registered themselves. */
 225 static GSList *final_registration_routines;
 226
 227 void
 228 register_final_registration_routine(void (*func)(void))
 229 {
 230         final_registration_routines = g_slist_append(final_registration_routines,
 231                         (gpointer)func);
 232 }
 233
 234 /* Call all the registered "final_registration" routines. */
 235 static void
 236 call_final_registration_routine(gpointer routine, gpointer dummy _U_)
 237 {
 238         void_func_t func = (void_func_t)routine;
 239
 240         (*func)();
 241 }
 242
 243 void
 244 final_registration_all_protocols(void)
 245 {
 246         g_slist_foreach(final_registration_routines,
 247                         &call_final_registration_routine, NULL);
 248 }
 249
 250
 251 /* Creates the top-most tvbuff and calls dissect_frame() */
 252 void
 253 dissect_packet(epan_dissect_t *edt, union wtap_pseudo_header *pseudo_header,
 254                const guchar *pd, frame_data *fd, column_info *cinfo)
 255 {
 256         if (cinfo != NULL)
 257                 col_init(cinfo);
 258         edt->pi.current_proto = "<Missing Protocol Name>";
 259         edt->pi.cinfo = cinfo;
 260         edt->pi.fd = fd;
 261         edt->pi.pseudo_header = pseudo_header;
 262         edt->pi.data_src = NULL;
 263         edt->pi.dl_src.type = AT_NONE;
 264         edt->pi.dl_src.len = 0;
 265         edt->pi.dl_src.data = NULL;
 266         edt->pi.dl_dst.type = AT_NONE;
 267         edt->pi.dl_dst.len = 0;
 268         edt->pi.dl_dst.data = NULL;
 269         edt->pi.net_src.type = AT_NONE;
 270         edt->pi.net_src.len = 0;
 271         edt->pi.net_src.data = NULL;
 272         edt->pi.net_dst.type = AT_NONE;
 273         edt->pi.net_dst.len = 0;
 274         edt->pi.net_dst.data = NULL;
 275         edt->pi.src.type = AT_NONE;
 276         edt->pi.src.len = 0;
 277         edt->pi.src.data = NULL;
 278         edt->pi.dst.type = AT_NONE;
 279         edt->pi.dst.len = 0;
 280         edt->pi.dst.data = NULL;
 281         edt->pi.ethertype = 0;
 282         edt->pi.ipproto  = 0;
 283         edt->pi.ipxptype = 0;
 284         edt->pi.ctype = CT_NONE;
 285         edt->pi.circuit_id = 0;
 286         edt->pi.noreassembly_reason = "";
 287         edt->pi.fragmented = FALSE;
 288         edt->pi.in_error_pkt = FALSE;
 289         edt->pi.ptype = PT_NONE;
 290         edt->pi.srcport  = 0;
 291         edt->pi.destport = 0;
 292         edt->pi.match_port = 0;
 293         edt->pi.match_string = NULL;
 294         edt->pi.can_desegment = 0;
 295         edt->pi.want_pdu_tracking = 0;
 296         edt->pi.p2p_dir = P2P_DIR_UNKNOWN;
 297         edt->pi.private_data = NULL;
 298         edt->pi.oxid = 0;
 299         edt->pi.rxid = 0;
 300         edt->pi.r_ctl = 0;
 301         edt->pi.src_idx = 0;
 302         edt->pi.dst_idx = 0;
 303         edt->pi.vsan = 0;
 304         edt->pi.dcectxid = 0;
 305         edt->pi.dcetransporttype = -1;
 306         edt->pi.decrypt_gssapi_tvb = 0;
 307         edt->pi.gssapi_wrap_tvb = NULL;
 308         edt->pi.gssapi_encrypted_tvb = NULL;
 309         edt->pi.gssapi_decrypted_tvb = NULL;
 310         edt->pi.layer_names = NULL;
 311         edt->pi.link_number = 0;
 312         edt->pi.annex_a_used = MTP2_ANNEX_A_USED_UNKNOWN;
 313         edt->pi.profinet_conv = NULL;
 314         edt->pi.profinet_type = 0;
 315         edt->pi.usb_conv_info = NULL;
 316         edt->pi.tcp_tree = NULL;
 317         edt->pi.dcerpc_procedure_name="";
 318         edt->pi.sccp_info = NULL;
 319
 320         TRY {
 321                 edt->tvb = tvb_new_real_data(pd, fd->cap_len, fd->pkt_len);
 322                 /* Add this tvbuffer into the data_src list */
 323                 add_new_data_source(&edt->pi, edt->tvb, "Frame");
 324
 325                 /* Even though dissect_frame() catches all the exceptions a
 326                  * sub-dissector can throw, dissect_frame() itself may throw
 327                  * a ReportedBoundsError in bizarre cases. Thus, we catch the exception
 328                  * in this function. */
 329                 if(frame_handle != NULL)
 330                   call_dissector(frame_handle, edt->tvb, &edt->pi, edt->tree);
 331
 332         }
 333         CATCH(BoundsError) {
 334                 g_assert_not_reached();
 335         }
 336         CATCH(ReportedBoundsError) {
 337                 if(proto_malformed != -1){
 338                         proto_tree_add_protocol_format(edt->tree, proto_malformed, edt->tvb, 0, 0,
 339                                                        "[Malformed Frame: Packet Length]" );
 340                 } else {
 341                         g_assert_not_reached();
 342                 }
 343         }
 344         CATCH(OutOfMemoryError) {
 345                 RETHROW;
 346         }
 347         ENDTRY;
 348
 349         fd->flags.visited = 1;
 350 }
 351
 352 /*********************** code added for sub-dissector lookup *********************/
 353
 354 /*
 355  * An dissector handle.
 356  */
 357 struct dissector_handle {
 358         const char      *name;          /* dissector name */
 359         gboolean        is_new;         /* TRUE if new-style dissector */
 360         union {
 361                 dissector_t     old;
 362                 new_dissector_t new;
 363         } dissector;
 364         protocol_t      *protocol;
 365 };
 366
 367 /* This function will return
 368  * old style dissector :
 369  *   length of the payload or 1 of the payload is empty
 370  * new dissector :
 371  *   >0  this protocol was successfully dissected and this was this protocol.
 372  *   0   this packet did not match this protocol.
 373  *
 374  * The only time this function will return 0 is if it is a new style dissector
 375  * and if the dissector rejected the packet.
 376  */
 377 static int
 378 call_dissector_through_handle(dissector_handle_t handle, tvbuff_t *tvb,
 379     packet_info *pinfo, proto_tree *tree)
 380 {
 381         const char *saved_proto;
 382         int ret;
 383
 384         saved_proto = pinfo->current_proto;
 385
 386         if (handle->protocol != NULL) {
 387                 pinfo->current_proto =
 388                     proto_get_protocol_short_name(handle->protocol);
 389         }
 390
 391         if (handle->is_new) {
 392                 ret = (*handle->dissector.new)(tvb, pinfo, tree);
 393         } else {
 394                 (*handle->dissector.old)(tvb, pinfo, tree);
 395                 ret = tvb_length(tvb);
 396                 if (ret == 0) {
 397                         /*
 398                          * XXX - a tvbuff can have 0 bytes of data in
 399                          * it, so we have to make sure we don't return
 400                          * 0.
 401                          */
 402                         ret = 1;
 403                 }
 404         }
 405
 406         pinfo->current_proto = saved_proto;
 407
 408         return ret;
 409 }
 410
 411 /*
 412  * Call a dissector through a handle.
 413  * If the protocol for that handle isn't enabled, return 0 without
 414  * calling the dissector.
 415  * Otherwise, if the handle refers to a new-style dissector, call the
 416  * dissector and return its return value, otherwise call it and return
 417  * the length of the tvbuff pointed to by the argument.
 418  */
 419 static int
 420 call_dissector_work(dissector_handle_t handle, tvbuff_t *tvb,
 421     packet_info *pinfo_arg, proto_tree *tree)
 422 {
 423         packet_info *volatile pinfo = pinfo_arg;
 424         const char *saved_proto;
 425         guint16 saved_can_desegment;
 426         volatile int ret = 0;
 427         gboolean save_writable;
 428         volatile address save_dl_src;
 429         volatile address save_dl_dst;
 430         volatile address save_net_src;
 431         volatile address save_net_dst;
 432         volatile address save_src;
 433         volatile address save_dst;
 434         volatile gint saved_layer_names_len = 0;
 435
 436         if (handle->protocol != NULL &&
 437             !proto_is_protocol_enabled(handle->protocol)) {
 438                 /*
 439                  * The protocol isn't enabled.
 440                  */
 441                 return 0;
 442         }
 443
 444         saved_proto = pinfo->current_proto;
 445         saved_can_desegment = pinfo->can_desegment;
 446
 447         if (pinfo->layer_names != NULL)
 448                 saved_layer_names_len = pinfo->layer_names->len;
 449
 450         /*
 451          * can_desegment is set to 2 by anyone which offers the
 452          * desegmentation api/service.
 453          * Then everytime a subdissector is called it is decremented
 454          * by one.
 455          * Thus only the subdissector immediately on top of whoever
 456          * offers this service can use it.
 457          * We save the current value of "can_desegment" for the
 458          * benefit of TCP proxying dissectors such as SOCKS, so they
 459          * can restore it and allow the dissectors they call to use
 460          * the desegmentation service.
 461          */
 462         pinfo->saved_can_desegment = saved_can_desegment;
 463         pinfo->can_desegment = saved_can_desegment-(saved_can_desegment>0);
 464         if (handle->protocol != NULL) {
 465                 pinfo->current_proto =
 466                     proto_get_protocol_short_name(handle->protocol);
 467
 468                 /*
 469                  * Add the protocol name to the layers
 470                  */
 471                 if (pinfo->layer_names) {
 472                         if (pinfo->layer_names->len > 0)
 473                                 g_string_append(pinfo->layer_names, ":");
 474                         g_string_append(pinfo->layer_names,
 475                             proto_get_protocol_filter_name(proto_get_id(handle->protocol)));
 476                 }
 477         }
 478
 479         if (pinfo->in_error_pkt) {
 480                 /*
 481                  * This isn't a packet being transported inside
 482                  * the protocol whose dissector is calling us,
 483                  * it's a copy of a packet that caused an error
 484                  * in some protocol included in a packet that
 485                  * reports the error (e.g., an ICMP Unreachable
 486                  * packet).
 487                  */
 488
 489                 /*
 490                  * Save the current state of the writability of
 491                  * the columns, and restore them after the
 492                  * dissector returns, so that the columns
 493                  * don't reflect the packet that got the error,
 494                  * they reflect the packet that reported the
 495                  * error.
 496                  */
 497                 save_writable = col_get_writable(pinfo->cinfo);
 498                 col_set_writable(pinfo->cinfo, FALSE);
 499                 save_dl_src = pinfo->dl_src;
 500                 save_dl_dst = pinfo->dl_dst;
 501                 save_net_src = pinfo->net_src;
 502                 save_net_dst = pinfo->net_dst;
 503                 save_src = pinfo->src;
 504                 save_dst = pinfo->dst;
 505
 506                 /* Dissect the contained packet. */
 507                 TRY {
 508                         ret = call_dissector_through_handle(handle, tvb,
 509                             pinfo, tree);
 510                 }
 511                 CATCH(BoundsError) {
 512                         /*
 513                          * Restore the column writability and addresses.
 514                          */
 515                         col_set_writable(pinfo->cinfo, save_writable);
 516                         pinfo->dl_src = save_dl_src;
 517                         pinfo->dl_dst = save_dl_dst;
 518                         pinfo->net_src = save_net_src;
 519                         pinfo->net_dst = save_net_dst;
 520                         pinfo->src = save_src;
 521                         pinfo->dst = save_dst;
 522
 523                         /*
 524                          * Restore the current protocol, so any
 525                          * "Short Frame" indication reflects that
 526                          * protocol, not the protocol for the
 527                          * packet that got the error.
 528                          */
 529                         pinfo->current_proto = saved_proto;
 530
 531                         /*
 532                          * Restore the desegmentability state.
 533                          */
 534                         pinfo->can_desegment = saved_can_desegment;
 535
 536                         /*
 537                          * Rethrow the exception, so this will be
 538                          * reported as a short frame.
 539                          */
 540                         RETHROW;
 541                 }
 542                 CATCH(ReportedBoundsError) {
 543                         /*
 544                          * "ret" wasn't set because an exception was thrown
 545                          * before "call_dissector_through_handle()" returned.
 546                          * As it called something, at least one dissector
 547                          * accepted the packet, and, as an exception was
 548                          * thrown, not only was all the tvbuff dissected,
 549                          * a dissector tried dissecting past the end of
 550                          * the data in some tvbuff, so we'll assume that
 551                          * the entire tvbuff was dissected.
 552                          */
 553                         ret = tvb_length(tvb);
 554                 }
 555                 CATCH(OutOfMemoryError) {
 556                         RETHROW;
 557                 }
 558                 ENDTRY;
 559
 560                 col_set_writable(pinfo->cinfo, save_writable);
 561                 pinfo->dl_src = save_dl_src;
 562                 pinfo->dl_dst = save_dl_dst;
 563                 pinfo->net_src = save_net_src;
 564                 pinfo->net_dst = save_net_dst;
 565                 pinfo->src = save_src;
 566                 pinfo->dst = save_dst;
 567                 pinfo->want_pdu_tracking = 0;
 568         } else {
 569                 /*
 570                  * Just call the subdissector.
 571                  */
 572                 ret = call_dissector_through_handle(handle, tvb, pinfo, tree);
 573         }
 574
 575         if (ret == 0) {
 576                 /*
 577                  * That dissector didn't accept the packet, so
 578                  * remove its protocol's name from the list
 579                  * of protocols.
 580                  */
 581                 if (pinfo->layer_names != NULL) {
 582                         g_string_truncate(pinfo->layer_names,
 583                             saved_layer_names_len);
 584                 }
 585         }
 586         pinfo->current_proto = saved_proto;
 587         pinfo->can_desegment = saved_can_desegment;
 588         return ret;
 589 }
 590
 591 /*
 592  * An entry in the hash table portion of a dissector table.
 593  */
 594 struct dtbl_entry {
 595         dissector_handle_t initial;
 596         dissector_handle_t current;
 597 };
 598
 599 /*
 600  * A dissector table.
 601  *
 602  * "hash_table" is a hash table, indexed by port number, supplying
 603  * a "struct dtbl_entry"; it records what dissector is assigned to
 604  * that port number in that table.
 605  *
 606  * "dissector_handles" is a list of all dissectors that *could* be
 607  * used in that table; not all of them are necessarily in the table,
 608  * as they may be for protocols that don't have a fixed port number.
 609  *
 610  * "ui_name" is the name the dissector table has in the user interface.
 611  *
 612  * "type" is a field type giving the width of the port number for that
 613  * dissector table.
 614  *
 615  * "base" is the base in which to display the port number for that
 616  * dissector table.
 617  */
 618 struct dissector_table {
 619         GHashTable      *hash_table;
 620         GSList          *dissector_handles;
 621         const char      *ui_name;
 622         ftenum_t        type;
 623         int             base;
 624 };
 625
 626 static GHashTable *dissector_tables = NULL;
 627
 628 /* Finds a dissector table by table name. */
 629 dissector_table_t
 630 find_dissector_table(const char *name)
 631 {
 632         g_assert(dissector_tables);
 633         return g_hash_table_lookup( dissector_tables, name );
 634 }
 635
 636 /* Find an entry in a uint dissector table. */
 637 static dtbl_entry_t *
 638 find_uint_dtbl_entry(dissector_table_t sub_dissectors, guint32 pattern)
 639 {
 640         switch (sub_dissectors->type) {
 641
 642         case FT_UINT8:
 643         case FT_UINT16:
 644         case FT_UINT24:
 645         case FT_UINT32:
 646                 /*
 647                  * You can do a port lookup in these tables.
 648                  */
 649                 break;
 650
 651         default:
 652                 /*
 653                  * But you can't do a port lookup in any other types
 654                  * of tables.
 655                  */
 656                 g_assert_not_reached();
 657         }
 658
 659         /*
 660          * Find the entry.
 661          */
 662         return g_hash_table_lookup(sub_dissectors->hash_table,
 663             GUINT_TO_POINTER(pattern));
 664 }
 665
 666 /* Add an entry to a uint dissector table. */
 667 void
 668 dissector_add(const char *name, guint32 pattern, dissector_handle_t handle)
 669 {
 670         dissector_table_t sub_dissectors;
 671         dtbl_entry_t *dtbl_entry;
 672
 673         sub_dissectors = find_dissector_table(name);
 674 /* sanity checks */
 675         g_assert(sub_dissectors);
 676         switch (sub_dissectors->type) {
 677
 678         case FT_UINT8:
 679         case FT_UINT16:
 680         case FT_UINT24:
 681         case FT_UINT32:
 682                 /*
 683                  * You can do a port lookup in these tables.
 684                  */
 685                 break;
 686
 687         default:
 688                 /*
 689                  * But you can't do a port lookup in any other types
 690                  * of tables.
 691                  */
 692                 g_assert_not_reached();
 693         }
 694
 695         dtbl_entry = g_malloc(sizeof (dtbl_entry_t));
 696         dtbl_entry->current = handle;
 697         dtbl_entry->initial = dtbl_entry->current;
 698
 699 /* do the table insertion */
 700         g_hash_table_insert( sub_dissectors->hash_table,
 701             GUINT_TO_POINTER( pattern), (gpointer)dtbl_entry);
 702
 703         /*
 704          * Now add it to the list of handles that could be used with this
 705          * table, because it *is* being used with this table.
 706          */
 707         dissector_add_handle(name, handle);
 708 }
 709
 710 /* Delete the entry for a dissector in a uint dissector table
 711    with a particular pattern. */
 712
 713 /* NOTE: this doesn't use the dissector call variable. It is included to */
 714 /*      be consistant with the dissector_add and more importantly to be used */
 715 /*      if the technique of adding a temporary dissector is implemented.  */
 716 /*      If temporary dissectors are deleted, then the original dissector must */
 717 /*      be available. */
 718 void
 719 dissector_delete(const char *name, guint32 pattern,
 720         dissector_handle_t handle _U_)
 721 {
 722         dissector_table_t sub_dissectors = find_dissector_table( name);
 723         dtbl_entry_t *dtbl_entry;
 724
 725 /* sanity check */
 726         g_assert( sub_dissectors);
 727
 728         /*
 729          * Find the entry.
 730          */
 731         dtbl_entry = find_uint_dtbl_entry(sub_dissectors, pattern);
 732
 733         if (dtbl_entry != NULL) {
 734                 /*
 735                  * Found - remove it.
 736                  */
 737                 g_hash_table_remove(sub_dissectors->hash_table,
 738                     GUINT_TO_POINTER(pattern));
 739
 740                 /*
 741                  * Now free up the entry.
 742                  */
 743                 g_free(dtbl_entry);
 744         }
 745 }
 746
 747 /* Change the entry for a dissector in a uint dissector table
 748    with a particular pattern to use a new dissector handle. */
 749 void
 750 dissector_change(const char *name, guint32 pattern, dissector_handle_t handle)
 751 {
 752         dissector_table_t sub_dissectors = find_dissector_table( name);
 753         dtbl_entry_t *dtbl_entry;
 754
 755 /* sanity check */
 756         g_assert( sub_dissectors);
 757
 758         /*
 759          * See if the entry already exists. If so, reuse it.
 760          */
 761         dtbl_entry = find_uint_dtbl_entry(sub_dissectors, pattern);
 762         if (dtbl_entry != NULL) {
 763           dtbl_entry->current = handle;
 764           return;
 765         }
 766
 767         /*
 768          * Don't create an entry if there is no dissector handle - I.E. the
 769          * user said not to decode something that wasn't being decoded
 770          * in the first place.
 771          */
 772         if (handle == NULL)
 773           return;
 774
 775         dtbl_entry = g_malloc(sizeof (dtbl_entry_t));
 776         dtbl_entry->initial = NULL;
 777         dtbl_entry->current = handle;
 778
 779 /* do the table insertion */
 780         g_hash_table_insert( sub_dissectors->hash_table,
 781             GUINT_TO_POINTER( pattern), (gpointer)dtbl_entry);
 782 }
 783
 784 /* Reset an entry in a uint dissector table to its initial value. */
 785 void
 786 dissector_reset(const char *name, guint32 pattern)
 787 {
 788         dissector_table_t sub_dissectors = find_dissector_table( name);
 789         dtbl_entry_t *dtbl_entry;
 790
 791 /* sanity check */
 792         g_assert( sub_dissectors);
 793
 794         /*
 795          * Find the entry.
 796          */
 797         dtbl_entry = find_uint_dtbl_entry(sub_dissectors, pattern);
 798
 799         if (dtbl_entry == NULL)
 800                 return;
 801
 802         /*
 803          * Found - is there an initial value?
 804          */
 805         if (dtbl_entry->initial != NULL) {
 806                 dtbl_entry->current = dtbl_entry->initial;
 807         } else {
 808                 g_hash_table_remove(sub_dissectors->hash_table,
 809                     GUINT_TO_POINTER(pattern));
 810                 g_free(dtbl_entry);
 811         }
 812 }
 813
 814 /* Look for a given value in a given uint dissector table and, if found,
 815    call the dissector with the arguments supplied, and return TRUE,
 816    otherwise return FALSE. */
 817 gboolean
 818 dissector_try_port(dissector_table_t sub_dissectors, guint32 port,
 819     tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 820 {
 821         dtbl_entry_t *dtbl_entry;
 822         struct dissector_handle *handle;
 823         guint32 saved_match_port;
 824         int ret;
 825
 826         dtbl_entry = find_uint_dtbl_entry(sub_dissectors, port);
 827         if (dtbl_entry != NULL) {
 828                 /*
 829                  * Is there currently a dissector handle for this entry?
 830                  */
 831                 handle = dtbl_entry->current;
 832                 if (handle == NULL) {
 833                         /*
 834                          * No - pretend this dissector didn't exist,
 835                          * so that other dissectors might have a chance
 836                          * to dissect this packet.
 837                          */
 838                         return FALSE;
 839                 }
 840
 841                 /*
 842                  * Save the current value of "pinfo->match_port",
 843                  * set it to the port that matched, call the
 844                  * dissector, and restore "pinfo->match_port".
 845                  */
 846                 saved_match_port = pinfo->match_port;
 847                 pinfo->match_port = port;
 848                 ret = call_dissector_work(handle, tvb, pinfo, tree);
 849                 pinfo->match_port = saved_match_port;
 850
 851                 /*
 852                  * If a new-style dissector returned 0, it means that
 853                  * it didn't think this tvbuff represented a packet for
 854                  * its protocol, and didn't dissect anything.
 855                  *
 856                  * Old-style dissectors can't reject the packet.
 857                  *
 858                  * 0 is also returned if the protocol wasn't enabled.
 859                  *
 860                  * If the packet was rejected, we return FALSE, so that
 861                  * other dissectors might have a chance to dissect this
 862                  * packet, otherwise we return TRUE.
 863                  */
 864                 return ret != 0;
 865         }
 866         return FALSE;
 867 }
 868
 869 /* Look for a given value in a given uint dissector table and, if found,
 870    return the dissector handle for that value. */
 871 dissector_handle_t
 872 dissector_get_port_handle(dissector_table_t sub_dissectors, guint32 port)
 873 {
 874         dtbl_entry_t *dtbl_entry;
 875
 876         dtbl_entry = find_uint_dtbl_entry(sub_dissectors, port);
 877         if (dtbl_entry != NULL)
 878                 return dtbl_entry->current;
 879         else
 880                 return NULL;
 881 }
 882
 883 /* Find an entry in a string dissector table. */
 884 static dtbl_entry_t *
 885 find_string_dtbl_entry(dissector_table_t sub_dissectors, const gchar *pattern)
 886 {
 887         switch (sub_dissectors->type) {
 888
 889         case FT_STRING:
 890         case FT_STRINGZ:
 891                 /*
 892                  * You can do a string lookup in these tables.
 893                  */
 894                 break;
 895
 896         default:
 897                 /*
 898                  * But you can't do a string lookup in any other types
 899                  * of tables.
 900                  */
 901                 g_assert_not_reached();
 902         }
 903
 904         /*
 905          * Find the entry.
 906          */
 907         return g_hash_table_lookup(sub_dissectors->hash_table, pattern);
 908 }
 909
 910 /* Add an entry to a string dissector table. */
 911 void
 912 dissector_add_string(const char *name, const gchar *pattern,
 913     dissector_handle_t handle)
 914 {
 915         dissector_table_t sub_dissectors = find_dissector_table( name);
 916         dtbl_entry_t *dtbl_entry;
 917
 918 /* sanity check */
 919         g_assert( sub_dissectors);
 920
 921         switch (sub_dissectors->type) {
 922
 923         case FT_STRING:
 924         case FT_STRINGZ:
 925                 /*
 926                  * You can do a string lookup in these tables.
 927                  */
 928                 break;
 929
 930         default:
 931                 /*
 932                  * But you can't do a string lookup in any other types
 933                  * of tables.
 934                  */
 935                 g_assert_not_reached();
 936         }
 937
 938         dtbl_entry = g_malloc(sizeof (dtbl_entry_t));
 939         dtbl_entry->current = handle;
 940         dtbl_entry->initial = dtbl_entry->current;
 941
 942 /* do the table insertion */
 943         g_hash_table_insert( sub_dissectors->hash_table, (gpointer)pattern,
 944             (gpointer)dtbl_entry);
 945
 946         /*
 947          * Now add it to the list of handles that could be used with this
 948          * table, because it *is* being used with this table.
 949          */
 950         dissector_add_handle(name, handle);
 951 }
 952
 953 /* Delete the entry for a dissector in a string dissector table
 954    with a particular pattern. */
 955
 956 /* NOTE: this doesn't use the dissector call variable. It is included to */
 957 /*      be consistant with the dissector_add_string and more importantly to */
 958 /*      be used if the technique of adding a temporary dissector is */
 959 /*      implemented.  */
 960 /*      If temporary dissectors are deleted, then the original dissector must */
 961 /*      be available. */
 962 void
 963 dissector_delete_string(const char *name, const gchar *pattern,
 964         dissector_handle_t handle _U_)
 965 {
 966         dissector_table_t sub_dissectors = find_dissector_table( name);
 967         dtbl_entry_t *dtbl_entry;
 968
 969 /* sanity check */
 970         g_assert( sub_dissectors);
 971
 972         /*
 973          * Find the entry.
 974          */
 975         dtbl_entry = find_string_dtbl_entry(sub_dissectors, pattern);
 976
 977         if (dtbl_entry != NULL) {
 978                 /*
 979                  * Found - remove it.
 980                  */
 981                 g_hash_table_remove(sub_dissectors->hash_table, pattern);
 982
 983                 /*
 984                  * Now free up the entry.
 985                  */
 986                 g_free(dtbl_entry);
 987         }
 988 }
 989
 990 /* Change the entry for a dissector in a string dissector table
 991    with a particular pattern to use a new dissector handle. */
 992 void
 993 dissector_change_string(const char *name, gchar *pattern,
 994     dissector_handle_t handle)
 995 {
 996         dissector_table_t sub_dissectors = find_dissector_table( name);
 997         dtbl_entry_t *dtbl_entry;
 998
 999 /* sanity check */
1000         g_assert( sub_dissectors);
1001
1002         /*
1003          * See if the entry already exists. If so, reuse it.
1004          */
1005         dtbl_entry = find_string_dtbl_entry(sub_dissectors, pattern);
1006         if (dtbl_entry != NULL) {
1007           dtbl_entry->current = handle;
1008           return;
1009         }
1010
1011         /*
1012          * Don't create an entry if there is no dissector handle - I.E. the
1013          * user said not to decode something that wasn't being decoded
1014          * in the first place.
1015          */
1016         if (handle == NULL)
1017           return;
1018
1019         dtbl_entry = g_malloc(sizeof (dtbl_entry_t));
1020         dtbl_entry->initial = NULL;
1021         dtbl_entry->current = handle;
1022
1023 /* do the table insertion */
1024         g_hash_table_insert( sub_dissectors->hash_table, pattern,
1025             (gpointer)dtbl_entry);
1026 }
1027
1028 /* Reset an entry in a string sub-dissector table to its initial value. */
1029 void
1030 dissector_reset_string(const char *name, const gchar *pattern)
1031 {
1032         dissector_table_t sub_dissectors = find_dissector_table( name);
1033         dtbl_entry_t *dtbl_entry;
1034
1035 /* sanity check */
1036         g_assert( sub_dissectors);
1037
1038         /*
1039          * Find the entry.
1040          */
1041         dtbl_entry = find_string_dtbl_entry(sub_dissectors, pattern);
1042
1043         if (dtbl_entry == NULL)
1044                 return;
1045
1046         /*
1047          * Found - is there an initial value?
1048          */
1049         if (dtbl_entry->initial != NULL) {
1050                 dtbl_entry->current = dtbl_entry->initial;
1051         } else {
1052                 g_hash_table_remove(sub_dissectors->hash_table, pattern);
1053                 g_free(dtbl_entry);
1054         }
1055 }
1056
1057 /* Look for a given string in a given dissector table and, if found, call
1058    the dissector with the arguments supplied, and return TRUE, otherwise
1059    return FALSE. */
1060 gboolean
1061 dissector_try_string(dissector_table_t sub_dissectors, const gchar *string,
1062     tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
1063 {
1064         dtbl_entry_t *dtbl_entry;
1065         struct dissector_handle *handle;
1066         int ret;
1067         const gchar *saved_match_string;
1068
1069         dtbl_entry = find_string_dtbl_entry(sub_dissectors, string);
1070         if (dtbl_entry != NULL) {
1071                 /*
1072                  * Is there currently a dissector handle for this entry?
1073                  */
1074                 handle = dtbl_entry->current;
1075                 if (handle == NULL) {
1076                         /*
1077                          * No - pretend this dissector didn't exist,
1078                          * so that other dissectors might have a chance
1079                          * to dissect this packet.
1080                          */
1081                         return FALSE;
1082                 }
1083
1084                 /*
1085                  * Save the current value of "pinfo->match_string",
1086                  * set it to the string that matched, call the
1087                  * dissector, and restore "pinfo->match_string".
1088                  */
1089                 saved_match_string = pinfo->match_string;
1090                 pinfo->match_string = string;
1091                 ret = call_dissector_work(handle, tvb, pinfo, tree);
1092                 pinfo->match_string = saved_match_string;
1093
1094                 /*
1095                  * If a new-style dissector returned 0, it means that
1096                  * it didn't think this tvbuff represented a packet for
1097                  * its protocol, and didn't dissect anything.
1098                  *
1099                  * Old-style dissectors can't reject the packet.
1100                  *
1101                  * 0 is also returned if the protocol wasn't enabled.
1102                  *
1103                  * If the packet was rejected, we return FALSE, so that
1104                  * other dissectors might have a chance to dissect this
1105                  * packet, otherwise we return TRUE.
1106                  */
1107                 return ret != 0;
1108         }
1109         return FALSE;
1110 }
1111
1112 /* Look for a given value in a given string dissector table and, if found,
1113    return the dissector handle for that value. */
1114 dissector_handle_t
1115 dissector_get_string_handle(dissector_table_t sub_dissectors,
1116     const gchar *string)
1117 {
1118         dtbl_entry_t *dtbl_entry;
1119
1120         dtbl_entry = find_string_dtbl_entry(sub_dissectors, string);
1121         if (dtbl_entry != NULL)
1122                 return dtbl_entry->current;
1123         else
1124                 return NULL;
1125 }
1126
1127 dissector_handle_t
1128 dtbl_entry_get_handle (dtbl_entry_t *dtbl_entry)
1129 {
1130         return dtbl_entry->current;
1131 }
1132
1133 /* Add a handle to the list of handles that *could* be used with this
1134    table.  That list is used by code in the UI. */
1135 void
1136 dissector_add_handle(const char *name, dissector_handle_t handle)
1137 {
1138         dissector_table_t sub_dissectors = find_dissector_table( name);
1139         GSList *entry;
1140
1141         /* sanity check */
1142         g_assert(sub_dissectors != NULL);
1143
1144         /* Is it already in this list? */
1145         entry = g_slist_find(sub_dissectors->dissector_handles, (gpointer)handle);
1146         if (entry != NULL) {
1147                 /*
1148                  * Yes - don't insert it again.
1149                  */
1150                 return;
1151         }
1152
1153         /* Add it to the list. */
1154         sub_dissectors->dissector_handles =
1155             g_slist_append(sub_dissectors->dissector_handles, (gpointer)handle);
1156 }
1157
1158 dissector_handle_t
1159 dtbl_entry_get_initial_handle (dtbl_entry_t *dtbl_entry)
1160 {
1161         return dtbl_entry->initial;
1162 }
1163
1164 /**************************************************/
1165 /*                                                */
1166 /*       Routines to walk dissector tables        */
1167 /*                                                */
1168 /**************************************************/
1169
1170 typedef struct dissector_foreach_info {
1171   gpointer     caller_data;
1172   DATFunc      caller_func;
1173   GHFunc       next_func;
1174   const gchar  *table_name;
1175   ftenum_t     selector_type;
1176 } dissector_foreach_info_t;
1177
1178 /*
1179  * Called for each entry in a dissector table.
1180  */
1181 static void
1182 dissector_table_foreach_func (gpointer key, gpointer value, gpointer user_data)
1183 {
1184         dissector_foreach_info_t *info;
1185         dtbl_entry_t *dtbl_entry;
1186
1187         g_assert(value);
1188         g_assert(user_data);
1189
1190         dtbl_entry = value;
1191         if (dtbl_entry->current == NULL ||
1192             dtbl_entry->current->protocol == NULL) {
1193                 /*
1194                  * Either there is no dissector for this entry, or
1195                  * the dissector doesn't have a protocol associated
1196                  * with it.
1197                  *
1198                  * XXX - should the latter check be done?
1199                  */
1200                 return;
1201         }
1202
1203         info = user_data;
1204         info->caller_func(info->table_name, info->selector_type, key, value,
1205             info->caller_data);
1206 }
1207
1208 /*
1209  * Called for each entry in the table of all dissector tables.
1210  */
1211 static void
1212 dissector_all_tables_foreach_func (gpointer key, gpointer value, gpointer user_data)
1213 {
1214         dissector_table_t sub_dissectors;
1215         dissector_foreach_info_t *info;
1216
1217         g_assert(value);
1218         g_assert(user_data);
1219
1220         sub_dissectors = value;
1221         info = user_data;
1222         info->table_name = (gchar*) key;
1223         info->selector_type = get_dissector_table_selector_type(info->table_name);
1224         g_hash_table_foreach(sub_dissectors->hash_table, info->next_func, info);
1225 }
1226
1227 /*
1228  * Walk all dissector tables calling a user supplied function on each
1229  * entry.
1230  */
1231 static void
1232 dissector_all_tables_foreach (DATFunc func,
1233                               gpointer user_data)
1234 {
1235         dissector_foreach_info_t info;
1236
1237         info.caller_data = user_data;
1238         info.caller_func = func;
1239         info.next_func = dissector_table_foreach_func;
1240         g_hash_table_foreach(dissector_tables, dissector_all_tables_foreach_func, &info);
1241 }
1242
1243 /*
1244  * Walk one dissector table's hash table calling a user supplied function
1245  * on each entry.
1246  */
1247 void
1248 dissector_table_foreach (const char *name,
1249                          DATFunc func,
1250                          gpointer user_data)
1251 {
1252         dissector_foreach_info_t info;
1253         dissector_table_t sub_dissectors = find_dissector_table( name);
1254
1255         info.table_name = name;
1256         info.selector_type = sub_dissectors->type;
1257         info.caller_func = func;
1258         info.caller_data = user_data;
1259         g_hash_table_foreach(sub_dissectors->hash_table, dissector_table_foreach_func, &info);
1260 }
1261
1262 /*
1263  * Walk one dissector table's list of handles calling a user supplied
1264  * function on each entry.
1265  */
1266 void
1267 dissector_table_foreach_handle(const char *name,
1268                                DATFunc_handle func,
1269                                gpointer user_data)
1270 {
1271         dissector_table_t sub_dissectors = find_dissector_table( name);
1272         GSList *tmp;
1273
1274         for (tmp = sub_dissectors->dissector_handles; tmp != NULL;
1275             tmp = g_slist_next(tmp))
1276                 func(name, tmp->data, user_data);
1277 }
1278
1279 /*
1280  * Called for each entry in a dissector table.
1281  */
1282 static void
1283 dissector_table_foreach_changed_func (gpointer key, gpointer value, gpointer user_data)
1284 {
1285         dtbl_entry_t *dtbl_entry;
1286         dissector_foreach_info_t *info;
1287
1288         g_assert(value);
1289         g_assert(user_data);
1290
1291         dtbl_entry = value;
1292         if (dtbl_entry->initial == dtbl_entry->current) {
1293                 /*
1294                  * Entry hasn't changed - don't call the function.
1295                  */
1296                 return;
1297         }
1298
1299         info = user_data;
1300         info->caller_func(info->table_name, info->selector_type, key, value,
1301             info->caller_data);
1302 }
1303
1304 /*
1305  * Walk all dissector tables calling a user supplied function only on
1306  * any entry that has been changed from its original state.
1307  */
1308 void
1309 dissector_all_tables_foreach_changed (DATFunc func,
1310                                       gpointer user_data)
1311 {
1312         dissector_foreach_info_t info;
1313
1314         info.caller_data = user_data;
1315         info.caller_func = func;
1316         info.next_func = dissector_table_foreach_changed_func;
1317         g_hash_table_foreach(dissector_tables, dissector_all_tables_foreach_func, &info);
1318 }
1319
1320 /*
1321  * Walk one dissector table calling a user supplied function only on
1322  * any entry that has been changed from its original state.
1323  */
1324 void
1325 dissector_table_foreach_changed (const char *name,
1326                                  DATFunc func,
1327                                  gpointer user_data)
1328 {
1329         dissector_foreach_info_t info;
1330         dissector_table_t sub_dissectors = find_dissector_table( name);
1331
1332         info.table_name = name;
1333         info.selector_type = sub_dissectors->type;
1334         info.caller_func = func;
1335         info.caller_data = user_data;
1336         g_hash_table_foreach(sub_dissectors->hash_table,
1337             dissector_table_foreach_changed_func, &info);
1338 }
1339
1340 typedef struct dissector_foreach_table_info {
1341   gpointer      caller_data;
1342   DATFunc_table caller_func;
1343 } dissector_foreach_table_info_t;
1344
1345 /*
1346  * Called for each entry in the table of all dissector tables.
1347  */
1348 static void
1349 dissector_all_tables_foreach_table_func (gpointer key, gpointer value, gpointer user_data)
1350 {
1351         dissector_table_t table;
1352         dissector_foreach_table_info_t *info;
1353
1354         table = value;
1355         info = user_data;
1356         (*info->caller_func)((gchar*)key, table->ui_name, info->caller_data);
1357 }
1358
1359 /*
1360  * Walk all dissector tables calling a user supplied function on each
1361  * table.
1362  */
1363 void
1364 dissector_all_tables_foreach_table (DATFunc_table func,
1365                                     gpointer user_data)
1366 {
1367         dissector_foreach_table_info_t info;
1368
1369         info.caller_data = user_data;
1370         info.caller_func = func;
1371         g_hash_table_foreach(dissector_tables, dissector_all_tables_foreach_table_func, &info);
1372 }
1373
1374 dissector_table_t
1375 register_dissector_table(const char *name, const char *ui_name, ftenum_t type,
1376     int base)
1377 {
1378         dissector_table_t       sub_dissectors;
1379
1380         /* Create our hash-of-hashes if it doesn't already exist */
1381         if (!dissector_tables) {
1382                 dissector_tables = g_hash_table_new( g_str_hash, g_str_equal );
1383                 g_assert(dissector_tables);
1384         }
1385
1386         /* Make sure the registration is unique */
1387         g_assert(!g_hash_table_lookup( dissector_tables, name ));
1388
1389         /* Create and register the dissector table for this name; returns */
1390         /* a pointer to the dissector table. */
1391         sub_dissectors = g_malloc(sizeof (struct dissector_table));
1392         switch (type) {
1393
1394         case FT_UINT8:
1395         case FT_UINT16:
1396         case FT_UINT24:
1397         case FT_UINT32:
1398                 /*
1399                  * XXX - there's no "g_uint_hash()" or "g_uint_equal()",
1400                  * so we use "g_direct_hash()" and "g_direct_equal()".
1401                  */
1402                 sub_dissectors->hash_table = g_hash_table_new( g_direct_hash,
1403                     g_direct_equal );
1404                 break;
1405
1406         case FT_STRING:
1407         case FT_STRINGZ:
1408                 sub_dissectors->hash_table = g_hash_table_new( g_str_hash,
1409                     g_str_equal );
1410                 break;
1411
1412         default:
1413                 g_assert_not_reached();
1414         }
1415         sub_dissectors->dissector_handles = NULL;
1416         sub_dissectors->ui_name = ui_name;
1417         sub_dissectors->type = type;
1418         sub_dissectors->base = base;
1419         g_hash_table_insert( dissector_tables, (gpointer)name, (gpointer) sub_dissectors );
1420         return sub_dissectors;
1421 }
1422
1423 const char *
1424 get_dissector_table_ui_name(const char *name)
1425 {
1426         dissector_table_t sub_dissectors = find_dissector_table( name);
1427
1428         return sub_dissectors->ui_name;
1429 }
1430
1431 ftenum_t
1432 get_dissector_table_selector_type(const char *name)
1433 {
1434         dissector_table_t sub_dissectors = find_dissector_table( name);
1435
1436         return sub_dissectors->type;
1437 }
1438
1439 int
1440 get_dissector_table_base(const char *name)
1441 {
1442         dissector_table_t sub_dissectors = find_dissector_table( name);
1443
1444         return sub_dissectors->base;
1445 }
1446
1447 static GHashTable *heur_dissector_lists = NULL;
1448
1449 typedef struct {
1450         heur_dissector_t dissector;
1451         protocol_t *protocol;
1452 } heur_dtbl_entry_t;
1453
1454 /* Finds a heuristic dissector table by field name. */
1455 static heur_dissector_list_t *
1456 find_heur_dissector_list(const char *name)
1457 {
1458         g_assert(heur_dissector_lists != NULL);
1459         return g_hash_table_lookup(heur_dissector_lists, name);
1460 }
1461
1462 void
1463 heur_dissector_add(const char *name, heur_dissector_t dissector, int proto)
1464 {
1465         heur_dissector_list_t *sub_dissectors = find_heur_dissector_list(name);
1466         heur_dtbl_entry_t *dtbl_entry;
1467
1468         /* sanity check */
1469         g_assert(sub_dissectors != NULL);
1470
1471         dtbl_entry = g_malloc(sizeof (heur_dtbl_entry_t));
1472         dtbl_entry->dissector = dissector;
1473         dtbl_entry->protocol = find_protocol_by_id(proto);
1474
1475         /* do the table insertion */
1476         *sub_dissectors = g_slist_append(*sub_dissectors, (gpointer)dtbl_entry);
1477 }
1478
1479
1480
1481 static int find_matching_heur_dissector( gconstpointer a, gconstpointer b) {
1482     const heur_dtbl_entry_t *dtbl_entry_a = (const heur_dtbl_entry_t *) a;
1483     const heur_dtbl_entry_t *dtbl_entry_b = (const heur_dtbl_entry_t *) b;
1484     return (dtbl_entry_a->dissector == dtbl_entry_b->dissector) &&
1485                 (dtbl_entry_a->protocol == dtbl_entry_b->protocol) ? 0 : 1;
1486 }
1487
1488 void heur_dissector_delete(const char *name, heur_dissector_t dissector, int proto) {
1489         heur_dissector_list_t *sub_dissectors = find_heur_dissector_list(name);
1490         heur_dtbl_entry_t dtbl_entry;
1491         GSList* found_entry;
1492
1493         /* sanity check */
1494         g_assert(sub_dissectors != NULL);
1495
1496         dtbl_entry.dissector = dissector;
1497
1498         dtbl_entry.protocol = find_protocol_by_id(proto);
1499
1500         found_entry = g_slist_find_custom(*sub_dissectors, (gpointer) &dtbl_entry, find_matching_heur_dissector);
1501
1502         if (found_entry) {
1503                 *sub_dissectors = g_slist_remove_link(*sub_dissectors, found_entry);
1504                 g_free(g_slist_nth_data(found_entry, 1));
1505                 g_slist_free_1(found_entry);
1506         }
1507 }
1508
1509
1510 gboolean
1511 dissector_try_heuristic(heur_dissector_list_t sub_dissectors,
1512     tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
1513 {
1514         gboolean status;
1515         const char *saved_proto;
1516         GSList *entry;
1517         heur_dtbl_entry_t *dtbl_entry;
1518         guint16 saved_can_desegment;
1519         gint saved_layer_names_len = 0;
1520
1521         /* can_desegment is set to 2 by anyone which offers this api/service.
1522            then everytime a subdissector is called it is decremented by one.
1523            thus only the subdissector immediately ontop of whoever offers this
1524            service can use it.
1525            We save the current value of "can_desegment" for the
1526            benefit of TCP proxying dissectors such as SOCKS, so they
1527            can restore it and allow the dissectors they call to use
1528            the desegmentation service.
1529         */
1530         saved_can_desegment=pinfo->can_desegment;
1531         pinfo->saved_can_desegment = saved_can_desegment;
1532         pinfo->can_desegment = saved_can_desegment-(saved_can_desegment>0);
1533
1534         status = FALSE;
1535         saved_proto = pinfo->current_proto;
1536
1537         if (pinfo->layer_names != NULL)
1538                 saved_layer_names_len = pinfo->layer_names->len;
1539
1540         for (entry = sub_dissectors; entry != NULL; entry = g_slist_next(entry)) {
1541                 /* XXX - why set this now and above? */
1542                 pinfo->can_desegment = saved_can_desegment-(saved_can_desegment>0);
1543                 dtbl_entry = (heur_dtbl_entry_t *)entry->data;
1544
1545                 if (dtbl_entry->protocol != NULL &&
1546                     !proto_is_protocol_enabled(dtbl_entry->protocol)) {
1547                         /*
1548                          * No - don't try this dissector.
1549                          */
1550                         continue;
1551                 }
1552
1553                 if (dtbl_entry->protocol != NULL) {
1554                         pinfo->current_proto =
1555                             proto_get_protocol_short_name(dtbl_entry->protocol);
1556
1557                         /*
1558                          * Add the protocol name to the layers; we'll remove it
1559                          * if the dissector fails.
1560                          */
1561                         if (pinfo->layer_names) {
1562                                 if (pinfo->layer_names->len > 0)
1563                                         g_string_append(pinfo->layer_names, ":");
1564                                 g_string_append(pinfo->layer_names,
1565                                         proto_get_protocol_filter_name(proto_get_id(dtbl_entry->protocol)));
1566                         }
1567                 }
1568
1569                 if ((*dtbl_entry->dissector)(tvb, pinfo, tree)) {
1570                         status = TRUE;
1571                         break;
1572                 } else {
1573                         /*
1574                          * That dissector didn't accept the packet, so
1575                          * remove its protocol's name from the list
1576                          * of protocols.
1577                          */
1578                         if (pinfo->layer_names != NULL) {
1579                                 g_string_truncate(pinfo->layer_names,
1580                                     saved_layer_names_len);
1581                         }
1582                 }
1583         }
1584         pinfo->current_proto = saved_proto;
1585         pinfo->can_desegment=saved_can_desegment;
1586         return status;
1587 }
1588
1589 void
1590 register_heur_dissector_list(const char *name, heur_dissector_list_t *sub_dissectors)
1591 {
1592         /* Create our hash-of-lists if it doesn't already exist */
1593         if (heur_dissector_lists == NULL) {
1594                 heur_dissector_lists = g_hash_table_new(g_str_hash, g_str_equal);
1595                 g_assert(heur_dissector_lists != NULL);
1596         }
1597
1598         /* Make sure the registration is unique */
1599         g_assert(g_hash_table_lookup(heur_dissector_lists, name) == NULL);
1600
1601         *sub_dissectors = NULL; /* initially empty */
1602         g_hash_table_insert(heur_dissector_lists, (gpointer)name,
1603             (gpointer) sub_dissectors);
1604 }
1605
1606 /*
1607  * Register dissectors by name; used if one dissector always calls a
1608  * particular dissector, or if it bases the decision of which dissector
1609  * to call on something other than a numerical value or on "try a bunch
1610  * of dissectors until one likes the packet".
1611  */
1612
1613 /*
1614  * List of registered dissectors.
1615  */
1616 static GHashTable *registered_dissectors = NULL;
1617
1618 /* Get the short name of the protocol for a dissector handle, if it has
1619    a protocol. */
1620 const char *
1621 dissector_handle_get_short_name(dissector_handle_t handle)
1622 {
1623         if (handle->protocol == NULL) {
1624                 /*
1625                  * No protocol (see, for example, the handle for
1626                  * dissecting the set of protocols where the first
1627                  * octet of the payload is an OSI network layer protocol
1628                  * ID).
1629                  */
1630                 return NULL;
1631         }
1632         return proto_get_protocol_short_name(handle->protocol);
1633 }
1634
1635 /* Get the index of the protocol for a dissector handle, if it has
1636    a protocol. */
1637 int
1638 dissector_handle_get_protocol_index(dissector_handle_t handle)
1639 {
1640         if (handle->protocol == NULL) {
1641                 /*
1642                  * No protocol (see, for example, the handle for
1643                  * dissecting the set of protocols where the first
1644                  * octet of the payload is an OSI network layer protocol
1645                  * ID).
1646                  */
1647                 return -1;
1648         }
1649         return proto_get_id(handle->protocol);
1650 }
1651
1652 /* Find a registered dissector by name. */
1653 dissector_handle_t
1654 find_dissector(const char *name)
1655 {
1656         g_assert(registered_dissectors != NULL);
1657         return g_hash_table_lookup(registered_dissectors, name);
1658 }
1659
1660 /* Create an anonymous handle for a dissector. */
1661 dissector_handle_t
1662 create_dissector_handle(dissector_t dissector, int proto)
1663 {
1664         struct dissector_handle *handle;
1665
1666         handle = g_malloc(sizeof (struct dissector_handle));
1667         handle->name = NULL;
1668         handle->is_new = FALSE;
1669         handle->dissector.old = dissector;
1670         handle->protocol = find_protocol_by_id(proto);
1671
1672         return handle;
1673 }
1674
1675 dissector_handle_t
1676 new_create_dissector_handle(new_dissector_t dissector, int proto)
1677 {
1678         struct dissector_handle *handle;
1679
1680         handle = g_malloc(sizeof (struct dissector_handle));
1681         handle->name = NULL;
1682         handle->is_new = TRUE;
1683         handle->dissector.new = dissector;
1684         handle->protocol = find_protocol_by_id(proto);
1685
1686         return handle;
1687 }
1688
1689 /* Register a dissector by name. */
1690 void
1691 register_dissector(const char *name, dissector_t dissector, int proto)
1692 {
1693         struct dissector_handle *handle;
1694
1695         /* Create our hash table if it doesn't already exist */
1696         if (registered_dissectors == NULL) {
1697                 registered_dissectors = g_hash_table_new(g_str_hash, g_str_equal);
1698                 g_assert(registered_dissectors != NULL);
1699         }
1700
1701         /* Make sure the registration is unique */
1702         g_assert(g_hash_table_lookup(registered_dissectors, name) == NULL);
1703
1704         handle = g_malloc(sizeof (struct dissector_handle));
1705         handle->name = name;
1706         handle->is_new = FALSE;
1707         handle->dissector.old = dissector;
1708         handle->protocol = find_protocol_by_id(proto);
1709
1710         g_hash_table_insert(registered_dissectors, (gpointer)name,
1711             (gpointer) handle);
1712 }
1713
1714 void
1715 new_register_dissector(const char *name, new_dissector_t dissector, int proto)
1716 {
1717         struct dissector_handle *handle;
1718
1719         /* Create our hash table if it doesn't already exist */
1720         if (registered_dissectors == NULL) {
1721                 registered_dissectors = g_hash_table_new(g_str_hash, g_str_equal);
1722                 g_assert(registered_dissectors != NULL);
1723         }
1724
1725         /* Make sure the registration is unique */
1726         g_assert(g_hash_table_lookup(registered_dissectors, name) == NULL);
1727
1728         handle = g_malloc(sizeof (struct dissector_handle));
1729         handle->name = name;
1730         handle->is_new = TRUE;
1731         handle->dissector.new = dissector;
1732         handle->protocol = find_protocol_by_id(proto);
1733
1734         g_hash_table_insert(registered_dissectors, (gpointer)name,
1735             (gpointer) handle);
1736 }
1737
1738 /* Call a dissector through a handle and if this fails call the "data"
1739  * dissector.
1740  */
1741 int
1742 call_dissector(dissector_handle_t handle, tvbuff_t *tvb,
1743     packet_info *pinfo, proto_tree *tree)
1744 {
1745         int ret;
1746
1747         g_assert(handle != NULL);
1748         ret = call_dissector_work(handle, tvb, pinfo, tree);
1749         if (ret == 0) {
1750                 /*
1751                  * The protocol was disabled, or the dissector rejected
1752                  * it.  Just dissect this packet as data.
1753                  */
1754                 g_assert(data_handle != NULL);
1755                 g_assert(data_handle->protocol != NULL);
1756                 call_dissector(data_handle, tvb, pinfo, tree);
1757                 return tvb_length(tvb);
1758         }
1759         return ret;
1760 }
1761
1762 /* Call a dissector through a handle but if the dissector rejected it
1763  * return 0 instead of using the default "data" dissector.
1764  */
1765 int
1766 call_dissector_only(dissector_handle_t handle, tvbuff_t *tvb,
1767     packet_info *pinfo, proto_tree *tree)
1768 {
1769         int ret;
1770
1771         ret = call_dissector_work(handle, tvb, pinfo, tree);
1772         return ret;
1773 }
1774
1775 /*
1776  * Dumps the "layer type"/"decode as" associations to stdout, similar
1777  * to the proto_registrar_dump_*() routines.
1778  *
1779  * There is one record per line. The fields are tab-delimited.
1780  *
1781  * Field 1 = layer type, e.g. "tcp.port"
1782  * Field 2 = selector in decimal
1783  * Field 3 = "decode as" name, e.g. "http"
1784  */
1785
1786
1787 static void
1788 dissector_dump_decodes_display(const gchar *table_name,
1789     ftenum_t selector_type _U_, gpointer key, gpointer value,
1790     gpointer user_data _U_)
1791 {
1792         guint32 selector = (guint32)(unsigned long) key;
1793         dissector_table_t sub_dissectors = find_dissector_table(table_name);
1794         dtbl_entry_t *dtbl_entry;
1795         dissector_handle_t handle;
1796         gint proto_id;
1797         const gchar *decode_as;
1798
1799         g_assert(sub_dissectors);
1800         switch (sub_dissectors->type) {
1801
1802                 case FT_UINT8:
1803                 case FT_UINT16:
1804                 case FT_UINT24:
1805                 case FT_UINT32:
1806                         dtbl_entry = value;
1807                         g_assert(dtbl_entry);
1808
1809                         handle = dtbl_entry->current;
1810                         g_assert(handle);
1811
1812                         proto_id = dissector_handle_get_protocol_index(handle);
1813
1814                         if (proto_id != -1) {
1815                                 decode_as = proto_get_protocol_filter_name(proto_id);
1816                                 g_assert(decode_as != NULL);
1817                                 printf("%s\t%u\t%s\n", table_name, selector, decode_as);
1818                         }
1819                         break;
1820
1821         default:
1822                 break;
1823         }
1824 }
1825
1826 void
1827 dissector_dump_decodes() {
1828         dissector_all_tables_foreach(dissector_dump_decodes_display, NULL);
1829 }
1830
1831 static GPtrArray* post_dissectors = NULL;
1832 static guint num_of_postdissectors = 0;
1833
1834 void register_postdissector(dissector_handle_t handle) {
1835     if (!post_dissectors)
1836         post_dissectors = g_ptr_array_new();
1837
1838     g_ptr_array_add(post_dissectors, handle);
1839     num_of_postdissectors++;
1840 }
1841
1842 extern void call_all_postdissectors(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
1843     guint i;
1844     for(i=0;i<num_of_postdissectors;i++) {
1845         call_dissector((dissector_handle_t) g_ptr_array_index(post_dissectors,i),
1846                        tvb,pinfo,tree);
1847     }
1848 }
1849