Include <time.h> to declare "gmtime()".
[obnox/wireshark/wip.git] / plugins.c
1 /* plugins.c
2  * plugin routines
3  *
4  * $Id: plugins.c,v 1.2 1999/12/09 20:55:36 oabad Exp $
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@zing.org>
8  * Copyright 1999 Gerald Combs
9  *
10  * 
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  * 
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  * 
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  */
25
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #ifdef HAVE_DLFCN_H
31
32 #include <time.h>
33
34 #include "globals.h"
35
36 #include "plugins.h"
37
38 /* linked list of all plugins */
39 plugin *plugin_list;
40
41 /*
42  * add a new plugin to the list
43  * returns :
44  * - 0 : OK
45  * - ENOMEM : memory allocation problem
46  * - EEXIST : the same plugin (i.e. name/version) was already registered.
47  */
48 int
49 add_plugin(void *handle, gchar *name, gchar *version, gchar *protocol,
50            gchar *filter_string, dfilter *filter,
51            void (*dissector) (const u_char *,
52                               int,
53                               frame_data *,
54                               proto_tree *))
55 {
56     plugin *new_plug, *pt_plug;
57
58     pt_plug = plugin_list;
59     if (!pt_plug) /* the list is empty */
60     {
61         new_plug = (plugin *)g_malloc(sizeof(plugin));
62         if (new_plug == NULL) return ENOMEM;
63         plugin_list = new_plug;
64     }
65     else
66     {
67         while (1)
68         {
69             /* check if the same name/version is already registered */
70             if (!strcmp(pt_plug->name, name) &&
71                 !strcmp(pt_plug->version, version))
72             {
73                 return EEXIST;
74             }
75
76             /* we found the last plugin in the list */
77             if (pt_plug->next == NULL) break;
78
79             pt_plug = pt_plug->next;
80         }
81         new_plug = (plugin *)g_malloc(sizeof(plugin));
82         if (new_plug == NULL) return ENOMEM;
83         pt_plug->next = new_plug;
84     }
85
86     new_plug->handle = handle;
87     new_plug->name = name;
88     new_plug->version = version;
89     new_plug->enabled = FALSE;
90     new_plug->protocol = protocol;
91     new_plug->filter_string = g_strdup(filter_string);
92     new_plug->filter = filter;
93     new_plug->dissector = dissector;
94     new_plug->next = NULL;
95     return 0;
96 }
97
98 /*
99  * enable a plugin
100  * returns a pointer to the enabled plugin, or NULL if the plugin wasn't found
101  * in the list
102  */
103 void *
104 enable_plugin(const gchar *name, const gchar *version)
105 {
106     plugin *pt_plug;
107
108     pt_plug = plugin_list;
109     while (pt_plug)
110     {
111         if (!strcmp(pt_plug->name, name) && !strcmp(pt_plug->version, version))
112         {
113             pt_plug->enabled = TRUE;
114             return pt_plug;
115         }
116         pt_plug = pt_plug->next;
117     }
118     return NULL;
119 }
120
121 /*
122  * disable a plugin
123  * returns a pointer to the disabled plugin, or NULL if the plugin wasn't found
124  * in the list
125  */
126 void *
127 disable_plugin(const gchar *name, const gchar *version)
128 {
129     plugin *pt_plug;
130
131     pt_plug = plugin_list;
132     while (pt_plug)
133     {
134         if (!strcmp(pt_plug->name, name) && !strcmp(pt_plug->version, version))
135         {
136             pt_plug->enabled = FALSE;
137             return pt_plug;
138         }
139         pt_plug = pt_plug->next;
140     }
141     return NULL;
142 }
143
144 /*
145  * find a plugin using its name/version
146  */
147 void *
148 find_plugin(const gchar *name, const gchar *version)
149 {
150     plugin *pt_plug;
151
152     pt_plug = plugin_list;
153     while (pt_plug)
154     {
155         if (!strcmp(pt_plug->name, name) && !strcmp(pt_plug->version, version))
156         {
157             return pt_plug;
158         }
159         pt_plug = pt_plug->next;
160     }
161     return NULL;
162 }
163
164 /*
165  * check if a plugin is enabled
166  */
167 gboolean
168 is_enabled(const gchar *name, const gchar *version)
169 {
170     plugin *pt_plug;
171
172     pt_plug = plugin_list;
173     while (pt_plug)
174     {
175         if (!strcmp(pt_plug->name, name) && !strcmp(pt_plug->version, version))
176             return pt_plug->enabled;
177         pt_plug = pt_plug->next;
178     }
179     return FALSE;
180 }
181
182 /*
183  * replace the filter used by a plugin (filter string and dfilter)
184  */
185 void
186 plugin_replace_filter(const gchar *name, const gchar *version,
187         const gchar *filter_string, dfilter *filter)
188 {
189     plugin *pt_plug;
190
191     pt_plug = plugin_list;
192     while (pt_plug)
193     {
194         if (!strcmp(pt_plug->name, name) && !strcmp(pt_plug->version, version))
195         {
196             g_free(pt_plug->filter_string);
197             pt_plug->filter_string = g_strdup(filter_string);
198             dfilter_destroy(pt_plug->filter);
199             pt_plug->filter = filter;
200             return;
201         }
202         pt_plug = pt_plug->next;
203     }
204 }
205
206 #endif