The Styleguide section has been moved to the Wireshark Developer's Guide.
[obnox/wireshark/wip.git] / capture_ui_utils.c
1 /* capture_ui_utils.c
2  * Utilities for capture user interfaces
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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  */
24
25 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #ifdef HAVE_LIBPCAP
30
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <ctype.h>
35 #include <glib.h>
36
37 #include "epan/prefs.h"
38 #include "epan/ex-opt.h"
39 #include "capture_ifinfo.h"
40 #include "capture_ui_utils.h"
41
42 /*
43  * Find user-specified capture device description that matches interface
44  * name, if any.
45  */
46 char *
47 capture_dev_user_descr_find(const gchar *if_name)
48 {
49         char    *p;
50         char    *p2 = NULL;
51         char    *descr = NULL;
52         int     lp = 0;
53         int     ct = 0;
54
55         if (prefs.capture_devices_descr == NULL) {
56                 /* There are no descriptions. */
57                 return NULL;
58         }
59
60         if ((p = strstr(prefs.capture_devices_descr, if_name)) == NULL) {
61                 /* There are, but there isn't one for this interface. */
62                 return NULL;
63         }
64
65         while (*p != '\0') {
66                 /* error: ran into next interface description */
67                 if (*p == ',')
68                         return NULL;
69                 /* found left parenthesis, start of description */
70                 else if (*p == '(') {
71                         ct = 0;
72                         lp++;
73                         /* skip over left parenthesis */
74                         p++;
75                         /* save pointer to beginning of description */
76                         p2 = p;
77                         continue;
78                 }
79                 else if (*p == ')') {
80                         /* end of description */
81                         break;
82                 }
83                 else {
84                         p++;
85                         ct++;
86                 }
87         }
88
89         if ((lp == 1) && (ct > 0) && (p2 != NULL)) {
90                 /* Allocate enough space to return the string,
91                    which runs from p2 to p, plus a terminating
92                    '\0'. */
93                 descr = g_malloc(p - p2 + 1);
94                 memcpy(descr, p2, p - p2);
95                 descr[p - p2] = '\0';
96                 return descr;
97         }
98         else
99                 return NULL;
100 }
101
102 gint
103 capture_dev_user_linktype_find(const gchar *if_name)
104 {
105         gchar *p, *next;
106         long linktype;
107
108         if (prefs.capture_devices_linktypes == NULL) {
109                 /* There are no link-layer header types */
110                 return -1;
111         }
112
113         if ((p = strstr(prefs.capture_devices_linktypes, if_name)) == NULL) {
114                 /* There are, but there isn't one for this interface. */
115                 return -1;
116         }
117
118         p += strlen(if_name) + 1;
119         linktype = strtol(p, &next, 10);
120         if (next == p || *next != ')' || linktype < 0) {
121                 /* Syntax error */
122                 return -1;
123         }
124         if (linktype > G_MAXINT) {
125                 /* Value doesn't fit in a gint */
126                 return -1;
127         }
128
129         return (gint)linktype;
130 }
131
132 /*
133  * Return as descriptive a name for an interface as we can get.
134  * If the user has specified a comment, use that.  Otherwise,
135  * if capture_interface_list() supplies a description, use that,
136  * otherwise use the interface name.
137  *
138  * The result must be g_free()'d when you're done with it.
139  *
140  * Note: given that this calls capture_interface_list(), which attempts to
141  * open all adapters it finds in order to check whether they can be
142  * captured on, this is an expensive routine to call, so don't call it
143  * frequently.
144  */
145 char *
146 get_interface_descriptive_name(const char *if_name)
147 {
148   char *descr;
149   GList *if_list;
150   GList *if_entry;
151   if_info_t *if_info;
152   int err;
153
154   /* Do we have a user-supplied description? */
155   descr = capture_dev_user_descr_find(if_name);
156   if (descr != NULL) {
157     /* Yes - make a copy of that. */
158     descr = g_strdup(descr);
159   } else if (strcmp(if_name, "-") == 0) {
160     /*
161      * Strictly speaking, -X (extension) options are for modules, e.g. Lua
162      * and using one here stretches that definition. However, this doesn't
163      * waste a single-letter option on something that might be rarely used
164      * and is backward-compatible to 1.0.
165      */
166     descr = g_strdup(ex_opt_get_nth("stdin_descr", 0));
167     if (!descr) {
168       descr = g_strdup("Standard input");
169     }
170   } else {
171     /* No, we don't have a user-supplied description; did we get
172        one from the OS or libpcap? */
173     descr = NULL;
174     if_list = capture_interface_list(&err, NULL);
175     if (if_list != NULL && if_name != NULL) {
176       if_entry = if_list;
177       do {
178         if_info = if_entry->data;
179         if (strcmp(if_info->name, if_name) == 0) {
180           if (if_info->description != NULL) {
181             /* Return a copy of that - when we free the interface
182                list, that'll also free up the strings to which
183                it refers. */
184             descr = g_strdup(if_info->description);
185           }
186           break;
187         }
188       } while ((if_entry = g_list_next(if_entry)) != NULL);
189     }
190     free_interface_list(if_list);
191
192     if (descr == NULL) {
193       /* The interface name is all we have, so just return a copy of that. */
194       descr = g_strdup(if_name);
195     }
196   }
197
198   return descr;
199 }
200
201
202 /* search interface info by interface name */
203 static if_info_t *
204 search_info(GList *if_list, gchar *if_name)
205 {
206     GList *if_entry;
207     if_info_t *if_info;
208
209
210     for (if_entry = if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) {
211         if_info = if_entry->data;
212
213         if(strcmp(if_name, if_info->name) == 0) {
214             return if_info;
215         }
216     }
217
218     return NULL;
219 }
220
221
222 /* build the string to display in the combo box for the given interface */
223 char *
224 build_capture_combo_name(GList *if_list, gchar *if_name)
225 {
226     gchar *descr;
227     char *if_string;
228     if_info_t *if_info;
229
230
231         /* Do we have a user-supplied description? */
232         descr = capture_dev_user_descr_find(if_name);
233         if (descr != NULL) {
234           /* Yes, we have a user-supplied description; use it. */
235           if_string = g_strdup_printf("%s: %s", descr, if_name);
236           g_free(descr);
237         } else {
238           /* No, we don't have a user-supplied description; did we get
239              one from the OS or libpcap? */
240       if_info = search_info(if_list, if_name);
241           if (if_info && if_info->description != NULL) {
242             /* Yes - use it. */
243             if_string = g_strdup_printf("%s: %s", if_info->description,
244                                         if_info->name);
245           } else {
246             /* No. */
247             if_string = g_strdup(if_name);
248           }
249         }
250
251     return if_string;
252 }
253
254
255 GList *
256 build_capture_combo_list(GList *if_list, gboolean do_hide)
257 {
258   GList *combo_list;
259   GList *if_entry;
260   if_info_t *if_info;
261   char *if_string;
262   gchar *descr;
263
264   combo_list = NULL;
265   if (if_list != NULL) {
266     /* Scan through the list and build a list of strings to display. */
267     for (if_entry = if_list; if_entry != NULL;
268          if_entry = g_list_next(if_entry)) {
269       if_info = if_entry->data;
270
271       /* Is this interface hidden and, if so, should we include it
272          anyway? */
273       if (!prefs_is_capture_device_hidden(if_info->name) || !do_hide) {
274         /* It's not hidden, or it is but we should include it in the list. */
275
276         /* Do we have a user-supplied description? */
277         descr = capture_dev_user_descr_find(if_info->name);
278         if (descr != NULL) {
279               /* Yes, we have a user-supplied description; use it. */
280               if_string = g_strdup_printf("%s: %s", descr, if_info->name);
281           g_free(descr);
282         } else {
283           /* No, we don't have a user-supplied description; did we get
284                  one from the OS or libpcap? */
285           if (if_info->description != NULL) {
286             /* Yes - use it. */
287                 if_string = g_strdup_printf("%s: %s", if_info->description,
288                                         if_info->name);
289           } else {
290             /* No. */
291             if_string = g_strdup(if_info->name);
292           }
293         }
294         combo_list = g_list_append(combo_list, if_string);
295       }
296     }/*for*/
297   }
298   return combo_list;
299 }
300
301 static void
302 free_if_string(gpointer data, gpointer user_data _U_)
303 {
304   g_free(data);
305 }
306
307 void
308 free_capture_combo_list(GList *combo_list)
309 {
310   if (combo_list != NULL) {
311     g_list_foreach(combo_list, free_if_string, NULL);
312     g_list_free(combo_list);
313   }
314 }
315
316 /*
317  * Given text that contains an interface name possibly prefixed by an
318  * interface description, extract the interface name.
319  */
320 const char *
321 get_if_name(const char *if_text)
322 {
323   const char *if_name;
324
325 #ifdef _WIN32
326   /*
327    * We cannot assume that the interface name doesn't contain a space;
328    * some names on Windows OT do.
329    *
330    * We also can't assume it begins with "\Device\", either, as, on
331    * Windows OT, WinPcap doesn't put "\Device\" in front of the name.
332    *
333    * As I remember, we can't assume that the interface description
334    * doesn't contain a colon, either; I think some do.
335    *
336    * We can probably assume that the interface *name* doesn't contain
337    * a colon, however; if any interface name does contain a colon on
338    * Windows, it'll be time to just get rid of the damn interface
339    * descriptions in the drop-down list, have just the names in the
340    * drop-down list, and have a "Browse..." button to browse for interfaces,
341    * with names, descriptions, IP addresses, blah blah blah available when
342    * possible.
343    *
344    * So we search backwards for a colon.  If we don't find it, just
345    * return the entire string; otherwise, skip the colon and any blanks
346    * after it, and return that string.
347    */
348    if_name = if_text + strlen(if_text);
349    for (;;) {
350      if (if_name == if_text) {
351        /* We're at the beginning of the string; return it. */
352        break;
353      }
354      if_name--;
355      if (*if_name == ':') {
356        /*
357         * We've found a colon.
358         * Unfortunately, a colon is used in the string "rpcap://",
359         * which is used in case of a remote capture.
360         * So we'll check to make sure the colon isn't followed by "//";
361         * it'll be followed by a blank if it separates the description
362         * and the interface name.  (We don't wire in "rpcap", in case we
363         * support other protocols in the same syntax.)
364         * Unfortunately, another colon can be used in "rpcap://host:port/"
365         * before port. Check if colon is followed by digit.
366         */
367        if ((strncmp(if_name, "://", 3) != 0) && !isdigit(if_name[1])) {
368          /*
369           * OK, we've found a colon followed neither by "//" nor by digit.  
370           * Skip blanks following it.
371           */
372          if_name++;
373          while (*if_name == ' ')
374            if_name++;
375          break;
376        }
377      }
378      /* Keep looking for a colon not followed by "//". */
379    }
380 #else
381   /*
382    * There's a space between the interface description and name, and
383    * the interface name shouldn't have a space in it (it doesn't, on
384    * UNIX systems); look backwards in the string for a space.
385    *
386    * (An interface name might, however, contain a colon in it, which
387    * is why we don't use the colon search on UNIX.)
388    */
389   if_name = strrchr(if_text, ' ');
390   if (if_name == NULL) {
391     if_name = if_text;
392   } else {
393     if_name++;
394   }
395 #endif
396   return if_name;
397 }
398
399 /*  Return capture_opts->iface_descr (after setting it if it is not set)
400  *  This is necessary because capture_opts.c can't set iface_descr (at least
401  *  not without adding significant dependencies there).
402  */
403 const char *
404 get_iface_description(capture_options *capture_opts)
405 {
406         if (!capture_opts->iface_descr && capture_opts->iface)
407                 capture_opts->iface_descr = get_interface_descriptive_name(capture_opts->iface);
408
409         return(capture_opts->iface_descr);
410
411 }
412 #endif /* HAVE_LIBPCAP */