epan/tap.c

   1 /* tap.c
   2  * packet tap interface   2002 Ronnie Sahlberg
   3  *
   4  * Wireshark - Network traffic analyzer
   5  * By Gerald Combs <gerald@wireshark.org>
   6  * Copyright 1998 Gerald Combs
   7  *
   8  * SPDX-License-Identifier: GPL-2.0-or-later
   9  */
  10
  11 #include <config.h>
  12 #define WS_LOG_DOMAIN LOG_DOMAIN_EPAN
  13
  14 #include <stdio.h>
  15
  16 #include <sys/types.h>
  17
  18 #ifdef HAVE_NETINET_IN_H
  19 # include <netinet/in.h>
  20 #endif
  21
  22 #include <string.h>
  23
  24 #include <glib.h>
  25
  26 #include <epan/packet_info.h>
  27 #include <epan/dfilter/dfilter.h>
  28 #include <epan/tap.h>
  29 #include <wsutil/wslog.h>
  30
  31 static bool tapping_is_active=false;
  32
  33 typedef struct _tap_dissector_t {
  34         struct _tap_dissector_t *next;
  35         char *name;
  36 } tap_dissector_t;
  37 static tap_dissector_t *tap_dissector_list;
  38
  39 /*
  40  * This is the list of free and used packets queued for a tap.
  41  * It is implemented here explicitly instead of using GLib objects
  42  * in order to be as fast as possible as we need to build and tear down the
  43  * queued list at least once for each packet we see and thus we must be able
  44  * to build and tear it down as fast as possible.
  45  *
  46  * XXX - some fields in packet_info get overwritten in the dissection
  47  * process, such as the addresses and the "this is an error packet" flag.
  48  * A packet may be queued at multiple protocol layers, but the packet_info
  49  * structure will, when the tap listeners are run, contain the values as
  50  * set by the topmost protocol layers.
  51  *
  52  * This means that the tap listener code can't rely on pinfo->flags.in_error_pkt
  53  * to determine whether the packet should be handed to the listener, as, for
  54  * a protocol with error report packets that include a copy of the
  55  * packet in error (ICMP, ICMPv6, CLNP), that flag changes during the
  56  * processing of the packet depending on whether we're currently dissecting
  57  * the packet in error or not.
  58  *
  59  * It also means that a tap listener can't depend on the source and destination
  60  * addresses being the correct ones for the packet being processed if, for
  61  * example, you have some tunneling that causes multiple layers of the same
  62  * protocol.
  63  *
  64  * For now, we handle the error packet flag by setting a bit in the flags
  65  * field of the tap_packet_t structure.  We may ultimately want stacks of
  66  * addresses for this and other reasons.
  67  */
  68 typedef struct _tap_packet_t {
  69         int tap_id;
  70         uint32_t flags;
  71         packet_info *pinfo;
  72         const void *tap_specific_data;
  73 } tap_packet_t;
  74
  75 #define TAP_PACKET_IS_ERROR_PACKET      0x00000001      /* packet being queued is an error packet */
  76
  77 #define TAP_PACKET_QUEUE_LEN 5000
  78 static tap_packet_t tap_packet_array[TAP_PACKET_QUEUE_LEN];
  79 static unsigned tap_packet_index;
  80
  81 typedef struct _tap_listener_t {
  82         struct _tap_listener_t *next;
  83         int tap_id;
  84         bool needs_redraw;
  85         bool failed;
  86         unsigned flags;
  87         char *fstring;
  88         dfilter_t *code;
  89         void *tapdata;
  90         tap_reset_cb reset;
  91         tap_packet_cb packet;
  92         tap_draw_cb draw;
  93         tap_finish_cb finish;
  94 } tap_listener_t;
  95
  96 static tap_listener_t *tap_listener_queue;
  97
  98 static GSList *tap_plugins;
  99
 100 #ifdef HAVE_PLUGINS
 101 void
 102 tap_register_plugin(const tap_plugin *plug)
 103 {
 104         tap_plugins = g_slist_prepend(tap_plugins, (tap_plugin *)plug);
 105 }
 106 #else /* HAVE_PLUGINS */
 107 void
 108 tap_register_plugin(const tap_plugin *plug _U_)
 109 {
 110         ws_warning("built without support for binary plugins");
 111 }
 112 #endif /* HAVE_PLUGINS */
 113
 114 static void
 115 call_plugin_register_tap_listener(void *data, void *user_data _U_)
 116 {
 117         tap_plugin *plug = (tap_plugin *)data;
 118
 119         if (plug->register_tap_listener) {
 120                 plug->register_tap_listener();
 121         }
 122 }
 123
 124 /*
 125  * For all taps, call their register routines.
 126  *
 127  * The table of register routines is part of the main program, not
 128  * part of libwireshark, so it must be passed to us as an argument.
 129  */
 130 void
 131 register_all_tap_listeners(tap_reg_t const *tap_reg_listeners)
 132 {
 133         /* we register the plugin taps before the other taps because
 134          * stats_tree taps plugins will be registered as tap listeners
 135          * by stats_tree_stat.c and need to registered before that */
 136         g_slist_foreach(tap_plugins, call_plugin_register_tap_listener, NULL);
 137
 138         /* Register all builtin listeners. */
 139         for (tap_reg_t const *t = &tap_reg_listeners[0]; t->cb_func != NULL; t++) {
 140                 t->cb_func();
 141         }
 142 }
 143
 144 /* **********************************************************************
 145  * Init routine only called from epan at application startup
 146  * ********************************************************************** */
 147 /* This function is called once when wireshark starts up and is used
 148    to init any data structures we may need later.
 149 */
 150 void
 151 tap_init(void)
 152 {
 153         tap_packet_index=0;
 154 }
 155
 156 /* **********************************************************************
 157  * Functions called from dissector when made tappable
 158  * ********************************************************************** */
 159 /* the following two functions are used from dissectors to
 160    1. register the ability to tap packets from this subdissector
 161    2. push packets encountered by the subdissector to anyone tapping
 162 */
 163
 164 /* This function registers that a dissector has the packet tap ability
 165    available.  The name parameter is the name of this tap and extensions can
 166    use open_tap(char *name,... to specify that it wants to receive packets/
 167    events from this tap.
 168
 169    This function is only to be called once, when the dissector initializes.
 170
 171    The return value from this call is later used as a parameter to the
 172    tap_packet(unsigned int *tap_id,...
 173    call so that the tap subsystem knows to which tap point this tapped
 174    packet is associated.
 175 */
 176 int
 177 register_tap(const char *name)
 178 {
 179         tap_dissector_t *td, *tdl = NULL, *tdl_prev = NULL;
 180         int i=0;
 181
 182         if(tap_dissector_list){
 183                 /* Check if we already have the name registered, if it is return the tap_id of that tap.
 184                  * After the for loop tdl_prev will point to the last element of the list, add the new one there.
 185                  */
 186                 for (i = 1, tdl = tap_dissector_list; tdl; i++, tdl_prev = tdl, tdl = tdl->next) {
 187                         if (!strcmp(tdl->name, name)) {
 188                                 return i;
 189                         }
 190                 }
 191                 tdl = tdl_prev;
 192         }
 193
 194         td=g_new(tap_dissector_t, 1);
 195         td->next=NULL;
 196         td->name = g_strdup(name);
 197
 198         if(!tap_dissector_list){
 199                 tap_dissector_list=td;
 200                 i=1;
 201         } else {
 202                 tdl->next=td;
 203         }
 204         return i;
 205 }
 206
 207
 208 /* Every time the dissector has finished dissecting a packet (and all
 209    subdissectors have returned) and if the dissector has been made "tappable"
 210    it will push some data to everyone tapping this layer by a call
 211    to tap_queue_packet().
 212    The first parameter is the tap_id returned by the register_tap()
 213    call for this dissector (so the tap system can keep track of who it came
 214    from and who is listening to it)
 215    The second is the packet_info structure which many tap readers will find
 216    interesting.
 217    The third argument is specific to each tap point or NULL if no additional
 218    data is available to this tap.  A tap point in say IP will probably want to
 219    push the IP header structure here. Same thing for TCP and ONCRPC.
 220
 221    The pinfo and the specific pointer are what is supplied to every listener
 222    in the read_callback() call made to every one currently listening to this
 223    tap.
 224
 225    The tap reader is responsible to know how to parse any structure pointed
 226    to by the tap specific data pointer.
 227 */
 228 void
 229 tap_queue_packet(int tap_id, packet_info *pinfo, const void *tap_specific_data)
 230 {
 231         tap_packet_t *tpt;
 232
 233         if(!tapping_is_active){
 234                 return;
 235         }
 236         /*
 237          * XXX - should we allocate this with an ep_allocator,
 238          * rather than having a fixed maximum number of entries?
 239          */
 240         if(tap_packet_index >= TAP_PACKET_QUEUE_LEN){
 241                 ws_warning("Too many taps queued");
 242                 return;
 243         }
 244
 245         tpt=&tap_packet_array[tap_packet_index];
 246         tpt->tap_id=tap_id;
 247         tpt->flags = 0;
 248         if (pinfo->flags.in_error_pkt)
 249                 tpt->flags |= TAP_PACKET_IS_ERROR_PACKET;
 250         tpt->pinfo=pinfo;
 251         tpt->tap_specific_data=tap_specific_data;
 252         tap_packet_index++;
 253 }
 254
 255
 256
 257
 258
 259 /* **********************************************************************
 260  * Functions used by file.c to drive the tap subsystem
 261  * ********************************************************************** */
 262
 263 void tap_build_interesting (epan_dissect_t *edt)
 264 {
 265         tap_listener_t *tl;
 266         bool need_protocols = false;
 267
 268         /* nothing to do, just return */
 269         if(!tap_listener_queue){
 270                 return;
 271         }
 272
 273         /* loop over all tap listeners and build the list of all
 274            interesting hf_fields */
 275         for(tl=tap_listener_queue;tl;tl=tl->next){
 276                 if(tl->code){
 277                         epan_dissect_prime_with_dfilter(edt, tl->code);
 278                 }
 279                 if(tl->flags & TL_REQUIRES_PROTOCOLS){
 280                         need_protocols = true;
 281                 }
 282         }
 283         if (need_protocols) {
 284                 epan_dissect_fake_protocols(edt, false);
 285         }
 286 }
 287
 288 /* This function is used to delete/initialize the tap queue and prime an
 289    epan_dissect_t with all the filters for tap listeners.
 290    To free the tap queue, we just prepend the used queue to the free queue.
 291 */
 292 void
 293 tap_queue_init(epan_dissect_t *edt)
 294 {
 295         /* nothing to do, just return */
 296         if(!tap_listener_queue){
 297                 return;
 298         }
 299
 300         tapping_is_active=true;
 301
 302         tap_packet_index=0;
 303
 304         tap_build_interesting (edt);
 305 }
 306
 307 /* this function is called after a packet has been fully dissected to push the tapped
 308    data to all extensions that has callbacks registered.
 309 */
 310 void
 311 tap_push_tapped_queue(epan_dissect_t *edt)
 312 {
 313         tap_packet_t *tp;
 314         tap_listener_t *tl;
 315         unsigned i;
 316
 317         /* nothing to do, just return */
 318         if(!tapping_is_active){
 319                 return;
 320         }
 321
 322         tapping_is_active=false;
 323
 324         /* nothing to do, just return */
 325         if(!tap_packet_index){
 326                 return;
 327         }
 328
 329         /* loop over all tap listeners and call the listener callback
 330            for all packets that match the filter. */
 331         for(i=0;i<tap_packet_index;i++){
 332                 for(tl=tap_listener_queue;tl;tl=tl->next){
 333                         tp=&tap_packet_array[i];
 334                         /* Don't tap the packet if it's an "error packet"
 335                          * unless the listener has requested that we do so.
 336                          */
 337                         if (!(tp->flags & TAP_PACKET_IS_ERROR_PACKET) || (tl->flags & TL_REQUIRES_ERROR_PACKETS))
 338                         {
 339                                 if(tp->tap_id==tl->tap_id){
 340                                         if(!tl->packet){
 341                                                 /* There isn't a per-packet
 342                                                  * routine for this tap.
 343                                                  */
 344                                                 continue;
 345                                         }
 346                                         if(tl->failed){
 347                                                 /* A previous call failed,
 348                                                  * meaning "stop running this
 349                                                  * tap", so don't call the
 350                                                  * packet routine.
 351                                                  */
 352                                                 continue;
 353                                         }
 354
 355                                         /* If we have a filter, see if the
 356                                          * packet passes.
 357                                          */
 358                                         unsigned flags = tl->flags;
 359                                         if(tl->code){
 360                                                 if (!dfilter_apply_edt(tl->code, edt)){
 361                                                         /* The packet didn't
 362                                                          * pass the filter. */
 363                                                         if (tl->flags & TL_IGNORE_DISPLAY_FILTER)
 364                                                                 flags |= TL_DISPLAY_FILTER_IGNORED;
 365                                                         else
 366                                                                 continue;
 367                                                 }
 368                                         }
 369
 370                                         /* So call the per-packet routine. */
 371                                         tap_packet_status status;
 372
 373                                         status = tl->packet(tl->tapdata, tp->pinfo, edt, tp->tap_specific_data, flags);
 374
 375                                         switch (status) {
 376
 377                                         case TAP_PACKET_DONT_REDRAW:
 378                                                 break;
 379
 380                                         case TAP_PACKET_REDRAW:
 381                                                 tl->needs_redraw=true;
 382                                                 break;
 383
 384                                         case TAP_PACKET_FAILED:
 385                                                 tl->failed=true;
 386                                                 break;
 387                                         }
 388                                 }
 389                         }
 390                 }
 391         }
 392 }
 393
 394
 395 /* This function can be used by a dissector to fetch any tapped data before
 396  * returning.
 397  * This can be useful if one wants to extract the data inside dissector  BEFORE
 398  * it exists as an alternative to the callbacks that are all called AFTER the
 399  * dissection has completed.
 400  *
 401  * Example: SMB2 uses this mechanism to extract the data tapped from NTLMSSP
 402  * containing the account and domain names before exiting.
 403  * Note that the SMB2 tap listener specifies all three callbacks as NULL.
 404  *
 405  * Beware: when using this mechanism to extract the tapped data you can not
 406  * use "filters" and should specify the "filter" as NULL when registering
 407  * the tap listener.
 408  */
 409 const void *
 410 fetch_tapped_data(int tap_id, int idx)
 411 {
 412         tap_packet_t *tp;
 413         unsigned i;
 414
 415         /* nothing to do, just return */
 416         if(!tapping_is_active){
 417                 return NULL;
 418         }
 419
 420         /* nothing to do, just return */
 421         if(!tap_packet_index){
 422                 return NULL;
 423         }
 424
 425         /* loop over all tapped packets and return the one with index idx */
 426         for(i=0;i<tap_packet_index;i++){
 427                 tp=&tap_packet_array[i];
 428                 if(tp->tap_id==tap_id){
 429                         if(!idx--){
 430                                 return tp->tap_specific_data;
 431                         }
 432                 }
 433         }
 434
 435         return NULL;
 436 }
 437
 438 /* This function is called when we need to reset all tap listeners, for example
 439    when we open/start a new capture or if we need to rescan the packet list.
 440 */
 441 void
 442 reset_tap_listeners(void)
 443 {
 444         tap_listener_t *tl;
 445
 446         for(tl=tap_listener_queue;tl;tl=tl->next){
 447                 if(tl->reset){
 448                         tl->reset(tl->tapdata);
 449                 }
 450                 tl->needs_redraw=true;
 451                 tl->failed=false;
 452         }
 453
 454 }
 455
 456
 457 /* This function is called when we need to redraw all tap listeners, for example
 458    when we open/start a new capture or if we need to rescan the packet list.
 459    It should be called from a low priority thread say once every 3 seconds
 460
 461    If draw_all is true, redraw all applications regardless if they have
 462    changed or not.
 463 */
 464 void
 465 draw_tap_listeners(bool draw_all)
 466 {
 467         tap_listener_t *tl;
 468
 469         for(tl=tap_listener_queue;tl;tl=tl->next){
 470                 if(tl->needs_redraw || draw_all){
 471                         if(tl->draw){
 472                                 tl->draw(tl->tapdata);
 473                         }
 474                 }
 475                 tl->needs_redraw=false;
 476         }
 477 }
 478
 479 /* Gets a GList of the tap names. The content of the list
 480    is owned by the tap table and should not be modified or freed.
 481    Use g_list_free() when done using the list. */
 482 GList*
 483 get_tap_names(void)
 484 {
 485         GList *list = NULL;
 486         tap_dissector_t *td;
 487
 488         for(td=tap_dissector_list; td; td=td->next) {
 489                 list = g_list_prepend(list, td->name);
 490         }
 491
 492         return g_list_reverse(list);
 493 }
 494
 495 /* **********************************************************************
 496  * Functions used by tap to
 497  * 1. register that a really simple extension is available for use by
 498  *    Wireshark.
 499  * 2. start tapping from a subdissector
 500  * 3. close an already open tap
 501  * ********************************************************************** */
 502 /* this function will return the tap_id for the specific protocol tap
 503    or 0 if no such tap was found.
 504  */
 505 int
 506 find_tap_id(const char *name)
 507 {
 508         tap_dissector_t *td;
 509         int i;
 510
 511         for(i=1,td=tap_dissector_list;td;i++,td=td->next) {
 512                 if(!strcmp(td->name,name)){
 513                         return i;
 514                 }
 515         }
 516         return 0;
 517 }
 518
 519 static void
 520 free_tap_listener(tap_listener_t *tl)
 521 {
 522         /* The free_tap_listener is called in the error path of
 523          * register_tap_listener (when the dfilter fails to be registered)
 524          * and the finish callback is set after that.
 525          * If this is changed make sure the finish callback is not called
 526          * twice to prevent double-free errors.
 527          */
 528         if (tl->finish) {
 529                 tl->finish(tl->tapdata);
 530         }
 531         dfilter_free(tl->code);
 532         g_free(tl->fstring);
 533         g_free(tl);
 534 }
 535
 536 /* this function attaches the tap_listener to the named tap.
 537  * function returns :
 538  *     NULL: ok.
 539  * non-NULL: error, return value points to GString containing error
 540  *           message.
 541  */
 542 GString *
 543 register_tap_listener(const char *tapname, void *tapdata, const char *fstring,
 544                       unsigned flags, tap_reset_cb reset, tap_packet_cb packet,
 545                       tap_draw_cb draw, tap_finish_cb finish)
 546 {
 547         tap_listener_t *tl;
 548         int tap_id;
 549         dfilter_t *code=NULL;
 550         GString *error_string;
 551         df_error_t *df_err;
 552
 553         tap_id=find_tap_id(tapname);
 554         if(!tap_id){
 555                 error_string = g_string_new("");
 556                 g_string_printf(error_string, "Tap %s not found", tapname);
 557                 return error_string;
 558         }
 559
 560         tl=g_new0(tap_listener_t, 1);
 561         tl->needs_redraw=true;
 562         tl->failed=false;
 563         if (flags & TL_REQUIRES_PROTOCOLS) {
 564                 /* Requiring protocols implies needing a protocol tree.
 565                  * XXX - Warn?
 566                  */
 567                 flags |= TL_REQUIRES_PROTO_TREE;
 568         }
 569         tl->flags=flags;
 570         if(fstring && *fstring){
 571                 if(!dfilter_compile(fstring, &code, &df_err)){
 572                         error_string = g_string_new("");
 573                         g_string_printf(error_string,
 574                             "Filter \"%s\" is invalid - %s",
 575                             fstring, df_err->msg);
 576                         df_error_free(&df_err);
 577                         free_tap_listener(tl);
 578                         return error_string;
 579                 }
 580                 tl->fstring=g_strdup(fstring);
 581                 tl->code=code;
 582         }
 583
 584         tl->tap_id=tap_id;
 585         tl->tapdata=tapdata;
 586         tl->reset=reset;
 587         tl->packet=packet;
 588         tl->draw=draw;
 589         tl->finish=finish;
 590         tl->next=tap_listener_queue;
 591
 592         tap_listener_queue=tl;
 593
 594         return NULL;
 595 }
 596
 597 /* this function sets a new dfilter to a tap listener
 598  */
 599 GString *
 600 set_tap_dfilter(void *tapdata, const char *fstring)
 601 {
 602         tap_listener_t *tl=NULL,*tl2;
 603         dfilter_t *code=NULL;
 604         GString *error_string;
 605         df_error_t *df_err;
 606
 607         if(!tap_listener_queue){
 608                 return NULL;
 609         }
 610
 611         if(tap_listener_queue->tapdata==tapdata){
 612                 tl=tap_listener_queue;
 613         } else {
 614                 for(tl2=tap_listener_queue;tl2->next;tl2=tl2->next){
 615                         if(tl2->next->tapdata==tapdata){
 616                                 tl=tl2->next;
 617                                 break;
 618                         }
 619
 620                 }
 621         }
 622
 623         if(tl){
 624                 if(tl->code){
 625                         dfilter_free(tl->code);
 626                         tl->code=NULL;
 627                 }
 628                 tl->needs_redraw=true;
 629                 g_free(tl->fstring);
 630                 if(fstring){
 631                         if(!dfilter_compile(fstring, &code, &df_err)){
 632                                 tl->fstring=NULL;
 633                                 error_string = g_string_new("");
 634                                 g_string_printf(error_string,
 635                                                  "Filter \"%s\" is invalid - %s",
 636                                                  fstring, df_err->msg);
 637                                 df_error_free(&df_err);
 638                                 return error_string;
 639                         }
 640                 }
 641                 tl->fstring=g_strdup(fstring);
 642                 tl->code=code;
 643         }
 644
 645         return NULL;
 646 }
 647
 648 GString *
 649 set_tap_flags(void *tapdata, unsigned flags)
 650 {
 651         tap_listener_t *tl=NULL,*tl2;
 652
 653         if(!tap_listener_queue){
 654                 return NULL;
 655         }
 656
 657         if(tap_listener_queue->tapdata==tapdata){
 658                 tl=tap_listener_queue;
 659         } else {
 660                 for(tl2=tap_listener_queue;tl2->next;tl2=tl2->next){
 661                         if(tl2->next->tapdata==tapdata){
 662                                 tl=tl2->next;
 663                                 break;
 664                         }
 665
 666                 }
 667         }
 668
 669         if(tl){
 670                 tl->needs_redraw=true;
 671                 tl->flags=flags;
 672         }
 673
 674         return NULL;
 675 }
 676
 677 /* this function recompiles dfilter for all registered tap listeners
 678  */
 679 void
 680 tap_listeners_dfilter_recompile(void)
 681 {
 682         tap_listener_t *tl;
 683         dfilter_t *code;
 684
 685         for(tl=tap_listener_queue;tl;tl=tl->next){
 686                 if(tl->code){
 687                         dfilter_free(tl->code);
 688                         tl->code=NULL;
 689                 }
 690                 tl->needs_redraw=true;
 691                 code=NULL;
 692                 if(tl->fstring){
 693                         if(!dfilter_compile(tl->fstring, &code, NULL)){
 694                                 /* Not valid, make a dfilter matching no packets */
 695                                 dfilter_compile("frame.number == 0", &code, NULL);
 696                         }
 697                 }
 698                 tl->code=code;
 699         }
 700 }
 701
 702 /* this function removes a tap listener
 703  */
 704 void
 705 remove_tap_listener(void *tapdata)
 706 {
 707         tap_listener_t *tl=NULL,*tl2;
 708
 709         if(!tap_listener_queue){
 710                 return;
 711         }
 712
 713         if(tap_listener_queue->tapdata==tapdata){
 714                 tl=tap_listener_queue;
 715                 tap_listener_queue=tap_listener_queue->next;
 716         } else {
 717                 for(tl2=tap_listener_queue;tl2->next;tl2=tl2->next){
 718                         if(tl2->next->tapdata==tapdata){
 719                                 tl=tl2->next;
 720                                 tl2->next=tl2->next->next;
 721                                 break;
 722                         }
 723
 724                 }
 725                 if(!tl) {
 726                         ws_warning("no listener found with that tap data");
 727                         return;
 728                 }
 729         }
 730         free_tap_listener(tl);
 731 }
 732
 733 /*
 734  * Return true if we have one or more tap listeners that require dissection,
 735  * false otherwise.
 736  */
 737 bool
 738 tap_listeners_require_dissection(void)
 739 {
 740         tap_listener_t *tap_queue = tap_listener_queue;
 741
 742         while(tap_queue) {
 743                 if(!(tap_queue->flags & TL_IS_DISSECTOR_HELPER))
 744                         return true;
 745
 746                 tap_queue = tap_queue->next;
 747         }
 748
 749         return false;
 750
 751 }
 752
 753 /*
 754  * Return true if we have one or more tap listeners that require the columns,
 755  * false otherwise.
 756  */
 757 bool
 758 tap_listeners_require_columns(void)
 759 {
 760         tap_listener_t *tap_queue = tap_listener_queue;
 761
 762         while(tap_queue) {
 763                 if(tap_queue->flags & TL_REQUIRES_COLUMNS)
 764                         return true;
 765
 766                 if(dfilter_requires_columns(tap_queue->code))
 767                         return true;
 768
 769                 tap_queue = tap_queue->next;
 770         }
 771
 772         return false;
 773
 774 }
 775
 776 /* Returns true there is an active tap listener for the specified tap id. */
 777 bool
 778 have_tap_listener(int tap_id)
 779 {
 780         tap_listener_t *tap_queue = tap_listener_queue;
 781
 782         while(tap_queue) {
 783                 if(tap_queue->tap_id == tap_id)
 784                         return true;
 785
 786                 tap_queue = tap_queue->next;
 787         }
 788
 789         return false;
 790 }
 791
 792 /*
 793  * Return true if we have any tap listeners with filters, false otherwise.
 794  */
 795 bool
 796 have_filtering_tap_listeners(void)
 797 {
 798         tap_listener_t *tl;
 799
 800         for(tl=tap_listener_queue;tl;tl=tl->next){
 801                 if(tl->code)
 802                         return true;
 803         }
 804         return false;
 805 }
 806
 807 void
 808 tap_listeners_load_field_references(epan_dissect_t *edt)
 809 {
 810         tap_listener_t *tl;
 811
 812         for(tl=tap_listener_queue;tl;tl=tl->next){
 813                 if(tl->code)
 814                         dfilter_load_field_references_edt(tl->code, edt);
 815         }
 816 }
 817
 818 /*
 819  * Get the union of all the flags for all the tap listeners; that gives
 820  * an indication of whether the protocol tree, or the columns, are
 821  * required by any taps.
 822  */
 823 unsigned
 824 union_of_tap_listener_flags(void)
 825 {
 826         tap_listener_t *tl;
 827         unsigned flags = 0;
 828
 829         for(tl=tap_listener_queue;tl;tl=tl->next){
 830                 flags|=tl->flags;
 831         }
 832         return flags;
 833 }
 834
 835 void tap_cleanup(void)
 836 {
 837         tap_listener_t *elem_lq;
 838         tap_listener_t *head_lq = tap_listener_queue;
 839         tap_dissector_t *elem_dl;
 840         tap_dissector_t *head_dl = tap_dissector_list;
 841
 842         while(head_lq){
 843                 elem_lq = head_lq;
 844                 head_lq = head_lq->next;
 845                 free_tap_listener(elem_lq);
 846         }
 847         tap_listener_queue = NULL;
 848
 849         while(head_dl){
 850                 elem_dl = head_dl;
 851                 head_dl = head_dl->next;
 852                 g_free(elem_dl->name);
 853                 g_free((void *)elem_dl);
 854         }
 855         tap_dissector_list = NULL;
 856
 857         g_slist_free(tap_plugins);
 858         tap_plugins = NULL;
 859 }
 860
 861 /*
 862  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 863  *
 864  * Local variables:
 865  * c-basic-offset: 8
 866  * tab-width: 8
 867  * indent-tabs-mode: t
 868  * End:
 869  *
 870  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 871  * :indentSize=8:tabSize=8:noTabs=false:
 872  */