2 * packet tap interface 2002 Ronnie Sahlberg
6 * Wireshark - Network traffic analyzer
7 * By Gerald Combs <gerald@wireshark.org>
8 * Copyright 1998 Gerald Combs
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.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
31 #ifdef HAVE_SYS_TYPES_H
32 # include <sys/types.h>
35 #ifdef HAVE_NETINET_IN_H
36 # include <netinet/in.h>
40 #include <epan/packet_info.h>
41 #include <epan/dfilter/dfilter.h>
44 static gboolean tapping_is_active=FALSE;
46 typedef struct _tap_dissector_t {
47 struct _tap_dissector_t *next;
50 static tap_dissector_t *tap_dissector_list=NULL;
53 * This is the list of free and used packets queued for a tap.
54 * It is implemented here explicitly instead of using GLib objects
55 * in order to be as fast as possible as we need to build and tear down the
56 * queued list at least once for each packet we see and thus we must be able
57 * to build and tear it down as fast as possible.
59 typedef struct _tap_packet_t {
62 const void *tap_specific_data;
65 #define TAP_PACKET_QUEUE_LEN 100
66 static tap_packet_t tap_packet_array[TAP_PACKET_QUEUE_LEN];
67 static guint tap_packet_index;
69 typedef struct _tap_listener_t {
70 struct _tap_listener_t *next;
72 gboolean needs_redraw;
80 static volatile tap_listener_t *tap_listener_queue=NULL;
82 /* **********************************************************************
83 * Init routine only called from epan at application startup
84 * ********************************************************************** */
85 /* This function is called once when wireshark starts up and is used
86 to init any data structures we may need later.
96 /* **********************************************************************
97 * Functions called from dissector when made tappable
98 * ********************************************************************** */
99 /* the following two functions are used from dissectors to
100 1. register the ability to tap packets from this subdissector
101 2. push packets encountered by the subdissector to anyone tapping
104 /* This function registers that a dissector has the packet tap ability
105 available. The name parameter is the name of this tap and extensions can
106 use open_tap(char *name,... to specify that it wants to receive packets/
107 events from this tap.
109 This function is only to be called once, when the dissector initializes.
111 The return value from this call is later used as a parameter to the
112 tap_packet(unsigned int *tap_id,...
113 call so that the tap subsystem knows to which tap point this tapped
114 packet is associated.
117 register_tap(const char *name)
119 tap_dissector_t *td, *tdl;
122 if(tap_dissector_list){
123 tap_id=find_tap_id(name);
128 td=g_malloc(sizeof(tap_dissector_t));
130 td->name = g_strdup(name);
132 if(!tap_dissector_list){
133 tap_dissector_list=td;
136 for(i=2,tdl=tap_dissector_list;tdl->next;i++,tdl=tdl->next)
144 /* Everytime the dissector has finished dissecting a packet (and all
145 subdissectors have returned) and if the dissector has been made "tappable"
146 it will push some data to everyone tapping this layer by a call
147 to tap_queue_packet().
148 The first parameter is the tap_id returned by the register_tap()
149 call for this dissector (so the tap system can keep track of who it came
150 from and who is listening to it)
151 The second is the packet_info structure which many tap readers will find
153 The third argument is specific to each tap point or NULL if no additional
154 data is available to this tap. A tap point in say IP will probably want to
155 push the IP header structure here. Same thing for TCP and ONCRPC.
157 The pinfo and the specific pointer are what is supplied to every listener
158 in the read_callback() call made to every one currently listening to this
161 The tap reader is responsible to know how to parse any structure pointed
162 to by the tap specific data pointer.
165 tap_queue_packet(int tap_id, packet_info *pinfo, const void *tap_specific_data)
169 if(!tapping_is_active){
173 * XXX - should we allocate this with an ep_allocator,
174 * rather than having a fixed maximum number of entries?
176 if(tap_packet_index >= TAP_PACKET_QUEUE_LEN){
177 g_warning("Too many taps queued");
181 tpt=&tap_packet_array[tap_packet_index];
184 tpt->tap_specific_data=tap_specific_data;
192 /* **********************************************************************
193 * Functions used by file.c to drive the tap subsystem
194 * ********************************************************************** */
196 void tap_build_interesting (epan_dissect_t *edt)
200 /* nothing to do, just return */
201 if(!tap_listener_queue){
205 /* loop over all tap listeners and build the list of all
206 interesting hf_fields */
207 for(tl=(tap_listener_t *)tap_listener_queue;tl;tl=tl->next){
209 epan_dissect_prime_dfilter(edt, tl->code);
214 /* This function is used to delete/initialize the tap queue and prime an
215 epan_dissect_t with all the filters for tap listeners.
216 To free the tap queue, we just prepend the used queue to the free queue.
219 tap_queue_init(epan_dissect_t *edt)
221 /* nothing to do, just return */
222 if(!tap_listener_queue){
226 tapping_is_active=TRUE;
230 tap_build_interesting (edt);
233 /* this function is called after a packet has been fully dissected to push the tapped
234 data to all extensions that has callbacks registered.
237 tap_push_tapped_queue(epan_dissect_t *edt)
243 /* nothing to do, just return */
244 if(!tapping_is_active){
248 tapping_is_active=FALSE;
250 /* nothing to do, just return */
251 if(!tap_packet_index){
255 /* loop over all tap listeners and call the listener callback
256 for all packets that match the filter. */
257 for(i=0;i<tap_packet_index;i++){
258 for(tl=(tap_listener_t *)tap_listener_queue;tl;tl=tl->next){
259 tp=&tap_packet_array[i];
260 if(tp->tap_id==tl->tap_id){
261 gboolean passed=TRUE;
263 passed=dfilter_apply_edt(tl->code, edt);
265 if(passed && tl->packet){
266 tl->needs_redraw|=tl->packet(tl->tapdata, tp->pinfo, edt, tp->tap_specific_data);
274 /* This function can be used by a dissector to fetch any tapped data before
276 * This can be useful if one wants to extract the data inside dissector BEFORE
277 * it exists as an alternative to the callbacks that are all called AFTER the
278 * dissection has completed.
280 * Example: SMB2 uses this mechanism to extract the data tapped from NTLMSSP
281 * containing the account and domain names before exiting.
282 * Note that the SMB2 tap listener specifies all three callbacks as NULL.
284 * Beware: when using this mechanism to extract the tapped data you can not
285 * use "filters" and should specify the "filter" as NULL when registering
289 fetch_tapped_data(int tap_id, int idx)
294 /* nothing to do, just return */
295 if(!tapping_is_active){
299 /* nothing to do, just return */
300 if(!tap_packet_index){
304 /* loop over all tapped packets and return the one with index idx */
305 for(i=0;i<tap_packet_index;i++){
306 tp=&tap_packet_array[i];
307 if(tp->tap_id==tap_id){
309 return tp->tap_specific_data;
317 /* This function is called when we need to reset all tap listeners, for example
318 when we open/start a new capture or if we need to rescan the packet list.
321 reset_tap_listeners(void)
325 for(tl=(tap_listener_t *)tap_listener_queue;tl;tl=tl->next){
327 tl->reset(tl->tapdata);
329 tl->needs_redraw=TRUE;
335 /* This function is called when we need to redraw all tap listeners, for example
336 when we open/start a new capture or if we need to rescan the packet list.
337 It should be called from a low priority thread say once every 3 seconds
339 If draw_all is true, redraw all aplications regardless if they have
343 draw_tap_listeners(gboolean draw_all)
347 for(tl=(tap_listener_t *)tap_listener_queue;tl;tl=tl->next){
348 if(tl->needs_redraw || draw_all){
350 tl->draw(tl->tapdata);
353 tl->needs_redraw=FALSE;
359 /* **********************************************************************
360 * Functions used by tap to
361 * 1. register that a really simple extension is available for use by
363 * 2. start tapping from a subdissector
364 * 3. close an already open tap
365 * ********************************************************************** */
366 /* this function will return the tap_id for the specific protocol tap
367 or 0 if no such tap was found.
370 find_tap_id(const char *name)
375 for(i=1,td=tap_dissector_list;td;i++,td=td->next) {
376 if(!strcmp(td->name,name)){
383 /* this function attaches the tap_listener to the named tap.
386 * non-NULL: error, return value points to GString containing error
390 register_tap_listener(const char *tapname, void *tapdata, const char *fstring,
391 guint flags, tap_reset_cb reset, tap_packet_cb packet, tap_draw_cb draw)
395 GString *error_string;
397 tap_id=find_tap_id(tapname);
399 error_string = g_string_new("");
400 g_string_printf(error_string, "Tap %s not found", tapname);
404 tl=g_malloc(sizeof(tap_listener_t));
406 tl->needs_redraw=TRUE;
409 if(!dfilter_compile(fstring, &tl->code)){
410 error_string = g_string_new("");
411 g_string_printf(error_string,
412 "Filter \"%s\" is invalid - %s",
413 fstring, dfilter_error_msg);
424 tl->next=(tap_listener_t *)tap_listener_queue;
426 tap_listener_queue=tl;
431 /* this function sets a new dfilter to a tap listener
434 set_tap_dfilter(void *tapdata, const char *fstring)
436 tap_listener_t *tl=NULL,*tl2;
437 GString *error_string;
439 if(!tap_listener_queue){
443 if(tap_listener_queue->tapdata==tapdata){
444 tl=(tap_listener_t *)tap_listener_queue;
446 for(tl2=(tap_listener_t *)tap_listener_queue;tl2->next;tl2=tl2->next){
447 if(tl2->next->tapdata==tapdata){
457 dfilter_free(tl->code);
460 tl->needs_redraw=TRUE;
462 if(!dfilter_compile(fstring, &tl->code)){
463 error_string = g_string_new("");
464 g_string_printf(error_string,
465 "Filter \"%s\" is invalid - %s",
466 fstring, dfilter_error_msg);
475 /* this function removes a tap listener
478 remove_tap_listener(void *tapdata)
480 tap_listener_t *tl=NULL,*tl2;
482 if(!tap_listener_queue){
486 if(tap_listener_queue->tapdata==tapdata){
487 tl=(tap_listener_t *)tap_listener_queue;
488 tap_listener_queue=tap_listener_queue->next;
490 for(tl2=(tap_listener_t *)tap_listener_queue;tl2->next;tl2=tl2->next){
491 if(tl2->next->tapdata==tapdata){
493 tl2->next=tl2->next->next;
502 dfilter_free(tl->code);
511 * Return TRUE if we have tap listeners, FALSE otherwise.
514 have_tap_listeners(void)
516 return tap_listener_queue != NULL;
519 /* Returns TRUE there is an active tap listener for the specified tap id. */
521 have_tap_listener(int tap_id)
523 volatile tap_listener_t *tap_queue = tap_listener_queue;
526 if(tap_queue->tap_id == tap_id)
529 tap_queue = tap_queue->next;
536 * Return TRUE if we have any tap listeners with filters, FALSE otherwise.
539 have_filtering_tap_listeners(void)
543 for(tl=(tap_listener_t *)tap_listener_queue;tl;tl=tl->next){
551 * Get the union of all the flags for all the tap listeners; that gives
552 * an indication of whether the protocol tree, or the columns, are
553 * required by any taps.
556 union_of_tap_listener_flags(void)
561 for(tl=(tap_listener_t *)tap_listener_queue;tl;tl=tl->next){