fix doxygen generation
[obnox/wireshark/wip.git] / pcap-util.c
1 /* pcap-util.c
2  * Utility routines for packet capture
3  *
4  * $Id$
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@ethereal.com>
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 <pcap.h>
32
33 #include <glib.h>
34
35 #include <stdlib.h>
36 #include <limits.h>
37 #include <string.h>
38
39 #ifdef HAVE_SYS_TYPES_H
40 # include <sys/types.h>
41 #endif
42
43 #ifdef HAVE_SYS_SOCKET_H
44 #include <sys/socket.h>
45 #endif
46
47 #include <wtap.h>
48 #include <wtap-capture.h>
49
50 #include "pcap-util.h"
51 #include "pcap-util-int.h"
52
53 #ifndef _WIN32
54 #include <netinet/in.h>
55 #endif
56
57
58 /*
59  * Get the data-link type for a libpcap device.
60  * This works around AIX 5.x's non-standard and incompatible-with-the-
61  * rest-of-the-universe libpcap.
62  */
63 int
64 get_pcap_linktype(pcap_t *pch, char *devname
65 #ifndef _AIX
66         _U_
67 #endif
68 )
69 {
70         int linktype;
71 #ifdef _AIX
72         char *ifacename;
73 #endif
74
75         linktype = pcap_datalink(pch);
76 #ifdef _AIX
77
78         /*
79          * The libpcap that comes with AIX 5.x uses RFC 1573 ifType values
80          * rather than DLT_ values for link-layer types; the ifType values
81          * for LAN devices are:
82          *
83          *      Ethernet        6
84          *      802.3           7
85          *      Token Ring      9
86          *      FDDI            15
87          *
88          * and the ifType value for a loopback device is 24.
89          *
90          * The AIX names for LAN devices begin with:
91          *
92          *      Ethernet                en
93          *      802.3                   et
94          *      Token Ring              tr
95          *      FDDI                    fi
96          *
97          * and the AIX names for loopback devices begin with "lo".
98          *
99          * (The difference between "Ethernet" and "802.3" is presumably
100          * whether packets have an Ethernet header, with a packet type,
101          * or an 802.3 header, with a packet length, followed by an 802.2
102          * header and possibly a SNAP header.)
103          *
104          * If the device name matches "linktype" interpreted as an ifType
105          * value, rather than as a DLT_ value, we will assume this is AIX's
106          * non-standard, incompatible libpcap, rather than a standard libpcap,
107          * and will map the link-layer type to the standard DLT_ value for
108          * that link-layer type, as that's what the rest of Ethereal expects.
109          *
110          * (This means the capture files won't be readable by a tcpdump
111          * linked with AIX's non-standard libpcap, but so it goes.  They
112          * *will* be readable by standard versions of tcpdump, Ethereal,
113          * and so on.)
114          *
115          * XXX - if we conclude we're using AIX libpcap, should we also
116          * set a flag to cause us to assume the time stamps are in
117          * seconds-and-nanoseconds form, and to convert them to
118          * seconds-and-microseconds form before processing them and
119          * writing them out?
120          */
121
122         /*
123          * Find the last component of the device name, which is the
124          * interface name.
125          */
126         ifacename = strchr(devname, '/');
127         if (ifacename == NULL)
128                 ifacename = devname;
129
130         /* See if it matches any of the LAN device names. */
131         if (strncmp(ifacename, "en", 2) == 0) {
132                 if (linktype == 6) {
133                         /*
134                          * That's the RFC 1573 value for Ethernet; map it
135                          * to DLT_EN10MB.
136                          */
137                         linktype = 1;
138                 }
139         } else if (strncmp(ifacename, "et", 2) == 0) {
140                 if (linktype == 7) {
141                         /*
142                          * That's the RFC 1573 value for 802.3; map it to
143                          * DLT_EN10MB.
144                          * (libpcap, tcpdump, Ethereal, etc. don't care if
145                          * it's Ethernet or 802.3.)
146                          */
147                         linktype = 1;
148                 }
149         } else if (strncmp(ifacename, "tr", 2) == 0) {
150                 if (linktype == 9) {
151                         /*
152                          * That's the RFC 1573 value for 802.5 (Token Ring);
153                          * map it to DLT_IEEE802, which is what's used for
154                          * Token Ring.
155                          */
156                         linktype = 6;
157                 }
158         } else if (strncmp(ifacename, "fi", 2) == 0) {
159                 if (linktype == 15) {
160                         /*
161                          * That's the RFC 1573 value for FDDI; map it to
162                          * DLT_FDDI.
163                          */
164                         linktype = 10;
165                 }
166         } else if (strncmp(ifacename, "lo", 2) == 0) {
167                 if (linktype == 24) {
168                         /*
169                          * That's the RFC 1573 value for "software loopback"
170                          * devices; map it to DLT_NULL, which is what's used
171                          * for loopback devices on BSD.
172                          */
173                         linktype = 0;
174                 }
175         }
176 #endif
177
178         return linktype;
179 }
180
181 if_info_t *
182 if_info_new(char *name, char *description)
183 {
184         if_info_t *if_info;
185
186         if_info = g_malloc(sizeof (if_info_t));
187         if_info->name = g_strdup(name);
188         if (description == NULL)
189                 if_info->description = NULL;
190         else
191                 if_info->description = g_strdup(description);
192         if_info->ip_addr = NULL;
193         if_info->loopback = FALSE;
194         return if_info;
195 }
196
197 void
198 if_info_add_address(if_info_t *if_info, struct sockaddr *addr)
199 {
200         if_addr_t *ip_addr;
201         struct sockaddr_in *ai;
202 #ifdef INET6
203         struct sockaddr_in6 *ai6;
204 #endif
205
206         switch (addr->sa_family) {
207
208         case AF_INET:
209                 ai = (struct sockaddr_in *)addr;
210                 ip_addr = g_malloc(sizeof(*ip_addr));
211                 ip_addr->type = AT_IPv4;
212                 ip_addr->ip_addr.ip4_addr =
213                     *((guint32 *)&(ai->sin_addr.s_addr));
214                 if_info->ip_addr = g_slist_append(if_info->ip_addr, ip_addr);
215                 break;
216
217 #ifdef INET6
218         case AF_INET6:
219                 ai6 = (struct sockaddr_in6 *)addr;
220                 ip_addr = g_malloc(sizeof(*ip_addr));
221                 ip_addr->type = AT_IPv6;
222                 memcpy((void *)&ip_addr->ip_addr.ip6_addr,
223                     (void *)&ai6->sin6_addr.s6_addr,
224                     sizeof ip_addr->ip_addr.ip6_addr);
225                 if_info->ip_addr = g_slist_append(if_info->ip_addr, ip_addr);
226                 break;
227 #endif
228         }
229 }
230
231 #ifdef HAVE_PCAP_FINDALLDEVS
232 /*
233  * Get all IP address information, and the loopback flag, for the given
234  * interface.
235  */
236 static void
237 if_info_ip(if_info_t *if_info, pcap_if_t *d)
238 {
239         pcap_addr_t *a;
240
241         /* Loopback flag */
242         if_info->loopback = (d->flags & PCAP_IF_LOOPBACK) ? TRUE : FALSE;
243
244         /* All addresses */
245         for (a = d->addresses; a != NULL; a = a->next) {
246                 if (a->addr != NULL)
247                         if_info_add_address(if_info, a->addr);
248         }
249 }
250
251 GList *
252 get_interface_list_findalldevs(int *err, char *err_str)
253 {
254         GList  *il = NULL;
255         pcap_if_t *alldevs, *dev;
256         if_info_t *if_info;
257
258         if (pcap_findalldevs(&alldevs, err_str) == -1) {
259                 *err = CANT_GET_INTERFACE_LIST;
260                 return NULL;
261         }
262
263         if (alldevs == NULL) {
264                 /*
265                  * No interfaces found.
266                  */
267                 *err = NO_INTERFACES_FOUND;
268                 return NULL;
269         }
270
271         for (dev = alldevs; dev != NULL; dev = dev->next) {
272                 if_info = if_info_new(dev->name, dev->description);
273                 il = g_list_append(il, if_info);
274                 if_info_ip(if_info, dev);
275         }
276         pcap_freealldevs(alldevs);
277
278         return il;
279 }
280 #endif /* HAVE_PCAP_FINDALLDEVS */
281
282 static void
283 free_if_info_addr_cb(gpointer addr, gpointer user_data _U_)
284 {
285         g_free(addr);
286 }
287
288 static void
289 free_if_cb(gpointer data, gpointer user_data _U_)
290 {
291         if_info_t *if_info = data;
292
293         g_free(if_info->name);
294         if (if_info->description != NULL)
295                 g_free(if_info->description);
296
297         g_slist_foreach(if_info->ip_addr, free_if_info_addr_cb, NULL);
298         g_slist_free(if_info->ip_addr);
299 }
300
301 void
302 free_interface_list(GList *if_list)
303 {
304         g_list_foreach(if_list, free_if_cb, NULL);
305         g_list_free(if_list);
306 }
307
308 /*
309  * Get the data-link types available for a libpcap device.
310  */
311 static data_link_info_t *
312 create_data_link_info(int dlt)
313 {
314         data_link_info_t *data_link_info;
315 #ifdef HAVE_PCAP_DATALINK_VAL_TO_NAME
316         const char *typename;
317 #endif
318         int wtap_encap;
319
320         data_link_info = g_malloc(sizeof (data_link_info_t));
321         data_link_info->dlt = dlt;
322 #ifdef HAVE_PCAP_DATALINK_VAL_TO_NAME
323         typename = pcap_datalink_val_to_name(dlt);
324         if (typename != NULL)
325                 data_link_info->name = g_strdup(typename);
326         else
327 #endif
328                 data_link_info->name = g_strdup_printf("DLT %d", dlt);
329         wtap_encap = wtap_pcap_encap_to_wtap_encap(dlt);
330         if (wtap_encap == WTAP_ENCAP_UNKNOWN) {
331                 /*
332                  * We don't support this in Wiretap.
333                  * However, we should, so you can capture on it.
334                  * Put in an entry for it, with no description.
335                  */
336                 data_link_info->description = NULL;
337         } else {
338                 /*
339                  * If this is null, that's a bug in
340                  * "wtap_pcap_encap_to_wtap_encap()" - it should always
341                  * return a valid encapsulation type - so we assume it's
342                  * not null.
343                  */
344                 data_link_info->description =
345                     g_strdup(wtap_encap_string(wtap_encap));
346         }
347         return data_link_info;
348 }
349
350 GList *
351 get_pcap_linktype_list(char *devname, char *err_buf)
352 {
353         GList *linktype_list = NULL;
354         pcap_t *pch;
355         int deflt;
356 #ifdef HAVE_PCAP_SET_DATALINK
357         int *linktypes;
358         int i, nlt;
359 #endif
360         data_link_info_t *data_link_info;
361
362         pch = pcap_open_live(devname, MIN_PACKET_SIZE, 0, 0, err_buf);
363         if (pch == NULL)
364                 return NULL;
365         err_buf[0] = '\0';      /* an empty list doesn't mean an error */
366         deflt = get_pcap_linktype(pch, devname);
367 #ifdef HAVE_PCAP_LIST_DATALINKS
368         nlt = pcap_list_datalinks(pch, &linktypes);
369         if (nlt == 0 || linktypes == NULL)
370                 return NULL;
371         for (i = 0; i < nlt; i++) {
372                 data_link_info = create_data_link_info(linktypes[i]);
373
374                 /*
375                  * XXX - for 802.11, make the most detailed 802.11
376                  * version the default, rather than the one the
377                  * device has as the default?
378                  */
379                 if (linktypes[i] == deflt)
380                         linktype_list = g_list_prepend(linktype_list,
381                             data_link_info);
382                 else
383                         linktype_list = g_list_append(linktype_list,
384                             data_link_info);
385         }
386         free(linktypes);
387 #else
388         data_link_info = create_data_link_info(deflt);
389         linktype_list = g_list_append(linktype_list, data_link_info);
390 #endif
391
392         pcap_close(pch);
393         return linktype_list;
394 }
395
396 static void
397 free_linktype_cb(gpointer data, gpointer user_data _U_)
398 {
399         data_link_info_t *linktype_info = data;
400
401         g_free(linktype_info->name);
402         if (linktype_info->description != NULL)
403                 g_free(linktype_info->description);
404 }
405
406 void
407 free_pcap_linktype_list(GList *linktype_list)
408 {
409         g_list_foreach(linktype_list, free_linktype_cb, NULL);
410         g_list_free(linktype_list);
411 }
412
413 /* Set the data link type on a pcap. */
414 const char *
415 set_pcap_linktype(pcap_t *pch, char *devname
416 #ifdef HAVE_PCAP_SET_DATALINK
417         _U_
418 #endif
419         , int dlt)
420 {
421 #ifdef HAVE_PCAP_SET_DATALINK
422         if (pcap_set_datalink(pch, dlt) == 0)
423                 return NULL;    /* no error */
424         return pcap_geterr(pch);
425 #else
426         /* Let them set it to the type it is; reject any other request. */
427         if (get_pcap_linktype(pch, devname) == dlt)
428                 return NULL;    /* no error */
429         return "That DLT is not one of the DLTs supported by this device";
430 #endif
431 }
432
433 #endif /* HAVE_LIBPCAP */