Use G_STRINGIFY/G_PASTE
[obnox/wireshark/wip.git] / capture-wpcap.c
1 /* capture-wpcap.c
2  * WinPcap-specific interfaces for capturing.  We load WinPcap at run
3  * time, so that we only need one Wireshark binary and one TShark binary
4  * for Windows, regardless of whether WinPcap is installed or not.
5  *
6  * $Id$
7  *
8  * Wireshark - Network traffic analyzer
9  * By Gerald Combs <gerald@wireshark.org>
10  * Copyright 2001 Gerald Combs
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * as published by the Free Software Foundation; either version 2
15  * of the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
25  */
26
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <stdio.h>
32 #include <glib.h>
33 #include <gmodule.h>
34
35 #ifdef HAVE_LIBPCAP
36 #include <pcap.h>
37 #endif
38
39 #include "capture-pcap-util.h"
40 #include "capture-pcap-util-int.h"
41
42 #define MAX_WIN_IF_NAME_LEN 511
43
44
45 gboolean has_wpcap = FALSE;
46
47 #ifdef HAVE_LIBPCAP
48
49 /*
50  * XXX - should we require at least WinPcap 3.1 both for building an
51  * for using Wireshark?
52  */
53
54 static char*   (*p_pcap_lookupdev) (char *);
55 static void    (*p_pcap_close) (pcap_t *);
56 static int     (*p_pcap_stats) (pcap_t *, struct pcap_stat *);
57 static int     (*p_pcap_dispatch) (pcap_t *, int, pcap_handler, guchar *);
58 static int     (*p_pcap_snapshot) (pcap_t *);
59 static int     (*p_pcap_datalink) (pcap_t *);
60 static int     (*p_pcap_setfilter) (pcap_t *, struct bpf_program *);
61 static char*   (*p_pcap_geterr) (pcap_t *);
62 static int     (*p_pcap_compile) (pcap_t *, struct bpf_program *, const char *, int,
63                         bpf_u_int32);
64 #ifdef WPCAP_CONSTIFIED
65 static int     (*p_pcap_lookupnet) (const char *, bpf_u_int32 *, bpf_u_int32 *,
66                         char *);
67 static pcap_t* (*p_pcap_open_live) (const char *, int, int, int, char *);
68 #else
69 static int     (*p_pcap_lookupnet) (char *, bpf_u_int32 *, bpf_u_int32 *,
70                         char *);
71 static pcap_t* (*p_pcap_open_live) (char *, int, int, int, char *);
72 #endif
73 static int     (*p_pcap_loop) (pcap_t *, int, pcap_handler, guchar *);
74 static void    (*p_pcap_freecode) (struct bpf_program *);
75 #ifdef HAVE_PCAP_FINDALLDEVS
76 static int     (*p_pcap_findalldevs) (pcap_if_t **, char *);
77 static void    (*p_pcap_freealldevs) (pcap_if_t *);
78 #endif
79 #ifdef HAVE_PCAP_DATALINK_NAME_TO_VAL
80 static int (*p_pcap_datalink_name_to_val) (const char *);
81 #endif
82 #ifdef HAVE_PCAP_DATALINK_VAL_TO_NAME
83 static const char *(*p_pcap_datalink_val_to_name) (int);
84 #endif
85 #ifdef HAVE_PCAP_BREAKLOOP
86 static void    (*p_pcap_breakloop) (pcap_t *);
87 #endif
88 static const char *(*p_pcap_lib_version) (void);
89 static int     (*p_pcap_setbuff) (pcap_t *, int dim);
90 static int     (*p_pcap_next_ex) (pcap_t *, struct pcap_pkthdr **pkt_header, const u_char **pkt_data);
91 #ifdef HAVE_PCAP_REMOTE
92 static pcap_t* (*p_pcap_open) (const char *, int, int, int,
93                                struct pcap_rmtauth *, char *);
94 static int     (*p_pcap_findalldevs_ex) (char *, struct pcap_rmtauth *,
95                                          pcap_if_t **, char *);
96 static int     (*p_pcap_createsrcstr) (char *, int, const char *, const char *,
97                                        const char *, char *);
98 #endif
99 #ifdef HAVE_PCAP_SETSAMPLING
100 static struct pcap_samp* (*p_pcap_setsampling)(pcap_t *);
101 #endif
102
103 #ifdef HAVE_PCAP_LIST_DATALINKS
104 static int      (*p_pcap_list_datalinks)(pcap_t *, int **);
105 #endif
106
107 #ifdef HAVE_PCAP_SET_DATALINK
108 static int      (*p_pcap_set_datalink)(pcap_t *, int);
109 #endif
110
111 #ifdef HAVE_FREE_DATALINKS
112 static int      (*p_pcap_free_datalinks)(int *);
113 #endif
114
115 typedef struct {
116         const char      *name;
117         gpointer        *ptr;
118         gboolean        optional;
119 } symbol_table_t;
120
121 #define SYM(x, y)       { G_STRINGIFY(x) , (gpointer) &G_PASTE(p_,x), y }
122
123 void
124 load_wpcap(void)
125 {
126
127         /* These are the symbols I need or want from Wpcap */
128         static const symbol_table_t     symbols[] = {
129                 SYM(pcap_lookupdev, FALSE),
130                 SYM(pcap_close, FALSE),
131                 SYM(pcap_stats, FALSE),
132                 SYM(pcap_dispatch, FALSE),
133                 SYM(pcap_snapshot, FALSE),
134                 SYM(pcap_datalink, FALSE),
135                 SYM(pcap_setfilter, FALSE),
136                 SYM(pcap_geterr, FALSE),
137                 SYM(pcap_compile, FALSE),
138                 SYM(pcap_lookupnet, FALSE),
139 #ifdef HAVE_PCAP_REMOTE
140                 SYM(pcap_open, FALSE),
141                 SYM(pcap_findalldevs_ex, FALSE),
142                 SYM(pcap_createsrcstr, FALSE),
143 #else
144                 SYM(pcap_open_live, FALSE),
145 #endif
146 #ifdef HAVE_PCAP_SETSAMPLING
147                 SYM(pcap_setsampling, TRUE),
148 #endif
149                 SYM(pcap_loop, FALSE),
150                 SYM(pcap_freecode, TRUE),
151 #ifdef HAVE_PCAP_FINDALLDEVS
152                 SYM(pcap_findalldevs, TRUE),
153                 SYM(pcap_freealldevs, TRUE),
154 #endif
155 #ifdef HAVE_PCAP_DATALINK_NAME_TO_VAL
156                 SYM(pcap_datalink_name_to_val, TRUE),
157 #endif
158 #ifdef HAVE_PCAP_DATALINK_VAL_TO_NAME
159                 SYM(pcap_datalink_val_to_name, TRUE),
160 #endif
161 #ifdef HAVE_PCAP_BREAKLOOP
162                 /*
163                  * We don't try to work around the lack of this at
164                  * run time; it's present in WinPcap 3.1, which is
165                  * the version we build with and ship with.
166                  */
167                 SYM(pcap_breakloop, FALSE),
168 #endif
169                 SYM(pcap_lib_version, TRUE),
170                 SYM(pcap_setbuff, TRUE),
171                 SYM(pcap_next_ex, TRUE),
172 #ifdef HAVE_PCAP_LIST_DATALINKS
173                 SYM(pcap_list_datalinks, FALSE),
174 #endif
175 #ifdef HAVE_PCAP_SET_DATALINK
176                 SYM(pcap_set_datalink, FALSE),
177 #endif
178 #ifdef HAVE_PCAP_FREE_DATALINKS
179                 SYM(pcap_free_datalinks, TRUE),
180 #endif
181                 { NULL, NULL, FALSE }
182         };
183
184         GModule         *wh; /* wpcap handle */
185         const symbol_table_t    *sym;
186
187         wh = g_module_open("wpcap", 0);
188
189         if (!wh) {
190                 return;
191         }
192
193         sym = symbols;
194         while (sym->name) {
195                 if (!g_module_symbol(wh, sym->name, sym->ptr)) {
196                         if (sym->optional) {
197                                 /*
198                                  * We don't care if it's missing; we just
199                                  * don't use it.
200                                  */
201                                 *sym->ptr = NULL;
202                         } else {
203                                 /*
204                                  * We require this symbol.
205                                  */
206                                 return;
207                         }
208                 }
209                 sym++;
210         }
211
212
213         has_wpcap = TRUE;
214 }
215
216 char*
217 pcap_lookupdev (char *a)
218 {
219         g_assert(has_wpcap);
220         return p_pcap_lookupdev(a);
221 }
222
223 void
224 pcap_close(pcap_t *a)
225 {
226         g_assert(has_wpcap);
227         p_pcap_close(a);
228 }
229
230 int
231 pcap_stats(pcap_t *a, struct pcap_stat *b)
232 {
233         g_assert(has_wpcap);
234         return p_pcap_stats(a, b);
235 }
236
237 int
238 pcap_dispatch(pcap_t *a, int b, pcap_handler c, guchar *d)
239 {
240         g_assert(has_wpcap);
241         return p_pcap_dispatch(a, b, c, d);
242 }
243
244 int
245 pcap_snapshot(pcap_t *a)
246 {
247         g_assert(has_wpcap);
248         return p_pcap_snapshot(a);
249 }
250
251 int
252 pcap_datalink(pcap_t *a)
253 {
254         g_assert(has_wpcap);
255         return p_pcap_datalink(a);
256 }
257
258 #ifdef HAVE_PCAP_SET_DATALINK
259 int
260 pcap_set_datalink(pcap_t *p, int dlt)
261 {
262         g_assert(has_wpcap);
263         return p_pcap_set_datalink(p, dlt);
264 }
265 #endif
266
267 int
268 pcap_setfilter(pcap_t *a, struct bpf_program *b)
269 {
270         g_assert(has_wpcap);
271         return p_pcap_setfilter(a, b);
272 }
273
274 char*
275 pcap_geterr(pcap_t *a)
276 {
277         g_assert(has_wpcap);
278         return p_pcap_geterr(a);
279 }
280
281 int
282 pcap_compile(pcap_t *a, struct bpf_program *b, const char *c, int d,
283             bpf_u_int32 e)
284 {
285         g_assert(has_wpcap);
286         return p_pcap_compile(a, b, c, d, e);
287 }
288
289 int
290 #ifdef WPCAP_CONSTIFIED
291 pcap_lookupnet(const char *a, bpf_u_int32 *b, bpf_u_int32 *c, char *d)
292 #else
293 pcap_lookupnet(char *a, bpf_u_int32 *b, bpf_u_int32 *c, char *d)
294 #endif
295 {
296         g_assert(has_wpcap);
297         return p_pcap_lookupnet(a, b, c, d);
298 }
299
300 pcap_t*
301 #ifdef WPCAP_CONSTIFIED
302 pcap_open_live(const char *a, int b, int c, int d, char *e)
303 #else
304 pcap_open_live(char *a, int b, int c, int d, char *e)
305 #endif
306 {
307         g_assert(has_wpcap);
308         return p_pcap_open_live(a, b, c, d, e);
309 }
310
311 #ifdef HAVE_PCAP_REMOTE
312 pcap_t*
313 pcap_open(const char *a, int b, int c, int d, struct pcap_rmtauth *e, char *f)
314 {
315     g_assert(has_wpcap);
316     return p_pcap_open(a, b, c, d, e, f);
317 }
318
319 int
320 pcap_findalldevs_ex(char *a, struct pcap_rmtauth *b, pcap_if_t **c, char *d)
321 {
322     g_assert(has_wpcap);
323     return p_pcap_findalldevs_ex(a, b, c, d);
324 }
325
326 int
327 pcap_createsrcstr(char *a, int b, const char *c, const char *d, const char *e,
328                   char *f)
329 {
330     g_assert(has_wpcap);
331     return p_pcap_createsrcstr(a, b, c, d, e, f);
332 }
333 #endif
334
335 #ifdef HAVE_PCAP_SETSAMPLING
336 struct pcap_samp *
337 pcap_setsampling(pcap_t *a)
338 {
339     g_assert(has_wpcap);
340     if (p_pcap_setsampling != NULL) {
341         return p_pcap_setsampling(a);
342     }
343     return NULL;
344 }
345 #endif
346
347 int
348 pcap_loop(pcap_t *a, int b, pcap_handler c, guchar *d)
349 {
350         g_assert(has_wpcap);
351         return p_pcap_loop(a, b, c, d);
352 }
353
354 void
355 pcap_freecode(struct bpf_program *a)
356 {
357         g_assert(has_wpcap);
358     if(p_pcap_freecode) {
359             p_pcap_freecode(a);
360     }
361 }
362
363 #ifdef HAVE_PCAP_FINDALLDEVS
364 int
365 pcap_findalldevs(pcap_if_t **a, char *b)
366 {
367         g_assert(has_wpcap && p_pcap_findalldevs != NULL);
368         return p_pcap_findalldevs(a, b);
369 }
370
371 void
372 pcap_freealldevs(pcap_if_t *a)
373 {
374         g_assert(has_wpcap && p_pcap_freealldevs != NULL);
375         p_pcap_freealldevs(a);
376 }
377 #endif
378
379 #if defined(HAVE_PCAP_DATALINK_NAME_TO_VAL) || defined(HAVE_PCAP_DATALINK_VAL_TO_NAME)
380 /*
381  * Table of DLT_ types, names, and descriptions, for use if the version
382  * of WinPcap we have installed lacks "pcap_datalink_name_to_val()"
383  * or "pcap_datalink_val_to_name()".
384  */
385 struct dlt_choice {
386         const char *name;
387         const char *description;
388         int     dlt;
389 };
390
391 #define DLT_CHOICE(code, description) { #code, description, code }
392 #define DLT_CHOICE_SENTINEL { NULL, NULL, 0 }
393
394 static struct dlt_choice dlt_choices[] = {
395         DLT_CHOICE(DLT_NULL, "BSD loopback"),
396         DLT_CHOICE(DLT_EN10MB, "Ethernet"),
397         DLT_CHOICE(DLT_IEEE802, "Token ring"),
398         DLT_CHOICE(DLT_ARCNET, "ARCNET"),
399         DLT_CHOICE(DLT_SLIP, "SLIP"),
400         DLT_CHOICE(DLT_PPP, "PPP"),
401         DLT_CHOICE(DLT_FDDI, "FDDI"),
402         DLT_CHOICE(DLT_ATM_RFC1483, "RFC 1483 IP-over-ATM"),
403         DLT_CHOICE(DLT_RAW, "Raw IP"),
404 #ifdef DLT_SLIP_BSDOS
405         DLT_CHOICE(DLT_SLIP_BSDOS, "BSD/OS SLIP"),
406 #endif
407 #ifdef DLT_PPP_BSDOS
408         DLT_CHOICE(DLT_PPP_BSDOS, "BSD/OS PPP"),
409 #endif
410 #ifdef DLT_ATM_CLIP
411         DLT_CHOICE(DLT_ATM_CLIP, "Linux Classical IP-over-ATM"),
412 #endif
413 #ifdef DLT_PPP_SERIAL
414         DLT_CHOICE(DLT_PPP_SERIAL, "PPP over serial"),
415 #endif
416 #ifdef DLT_PPP_ETHER
417         DLT_CHOICE(DLT_PPP_ETHER, "PPPoE"),
418 #endif
419 #ifdef DLT_C_HDLC
420         DLT_CHOICE(DLT_C_HDLC, "Cisco HDLC"),
421 #endif
422 #ifdef DLT_IEEE802_11
423         DLT_CHOICE(DLT_IEEE802_11, "802.11"),
424 #endif
425 #ifdef DLT_FRELAY
426         DLT_CHOICE(DLT_FRELAY, "Frame Relay"),
427 #endif
428 #ifdef DLT_LOOP
429         DLT_CHOICE(DLT_LOOP, "OpenBSD loopback"),
430 #endif
431 #ifdef DLT_ENC
432         DLT_CHOICE(DLT_ENC, "OpenBSD encapsulated IP"),
433 #endif
434 #ifdef DLT_LINUX_SLL
435         DLT_CHOICE(DLT_LINUX_SLL, "Linux cooked"),
436 #endif
437 #ifdef DLT_LTALK
438         DLT_CHOICE(DLT_LTALK, "Localtalk"),
439 #endif
440 #ifdef DLT_PFLOG
441         DLT_CHOICE(DLT_PFLOG, "OpenBSD pflog file"),
442 #endif
443 #ifdef DLT_PRISM_HEADER
444         DLT_CHOICE(DLT_PRISM_HEADER, "802.11 plus Prism header"),
445 #endif
446 #ifdef DLT_IP_OVER_FC
447         DLT_CHOICE(DLT_IP_OVER_FC, "RFC 2625 IP-over-Fibre Channel"),
448 #endif
449 #ifdef DLT_SUNATM
450         DLT_CHOICE(DLT_SUNATM, "Sun raw ATM"),
451 #endif
452 #ifdef DLT_IEEE802_11_RADIO
453         DLT_CHOICE(DLT_IEEE802_11_RADIO, "802.11 plus radio information header"),
454 #endif
455 #ifdef DLT_ARCNET_LINUX
456         DLT_CHOICE(DLT_ARCNET_LINUX, "Linux ARCNET"),
457 #endif
458 #ifdef DLT_LINUX_IRDA
459         DLT_CHOICE(DLT_LINUX_IRDA, "Linux IrDA"),
460 #endif
461 #ifdef DLT_LINUX_LAPD
462         DLT_CHOICE(DLT_LINUX_LAPD, "Linux vISDN LAPD"),
463 #endif
464 #ifdef DLT_LANE8023
465         DLT_CHOICE(DLT_LANE8023, "Linux 802.3 LANE"),
466 #endif
467 #ifdef DLT_CIP
468         DLT_CHOICE(DLT_CIP, "Linux Classical IP-over-ATM"),
469 #endif
470 #ifdef DLT_HDLC
471         DLT_CHOICE(DLT_HDLC, "Cisco HDLC"),
472 #endif
473         DLT_CHOICE_SENTINEL
474 };
475 #endif /* defined(HAVE_PCAP_DATALINK_NAME_TO_VAL) || defined(HAVE_PCAP_DATALINK_VAL_TO_NAME) */
476
477 #ifdef HAVE_PCAP_DATALINK_NAME_TO_VAL
478 int
479 pcap_datalink_name_to_val(const char *name)
480 {
481         int i;
482
483         g_assert(has_wpcap);
484
485         if (p_pcap_datalink_name_to_val != NULL)
486                 return p_pcap_datalink_name_to_val(name);
487         else {
488                 /*
489                  * We don't have it in WinPcap; do it ourselves.
490                  */
491                 for (i = 0; dlt_choices[i].name != NULL; i++) {
492                         if (g_ascii_strcasecmp(dlt_choices[i].name + sizeof("DLT_") - 1,
493                             name) == 0)
494                                 return dlt_choices[i].dlt;
495                 }
496                 return -1;
497         }
498 }
499 #endif
500
501 #ifdef HAVE_PCAP_LIST_DATALINKS
502 int
503 pcap_list_datalinks(pcap_t *p, int **ddlt)
504 {
505         g_assert(has_wpcap);
506         return p_pcap_list_datalinks(p, ddlt);
507 }
508 #endif
509
510 #ifdef HAVE_PCAP_FREE_DATALINKS
511 void
512 pcap_free_datalinks(int *ddlt)
513 {
514         g_assert(has_wpcap);
515
516         /*
517          * If we don't have pcap_free_datalinks() in WinPcap,
518          * we don't free the memory - we can't use free(), as
519          * we might not have been built with the same version
520          * of the C runtime library as WinPcap was, and, if we're
521          * not, free() isn't guaranteed to work on something
522          * allocated by WinPcap.
523          */
524         if (p_pcap_free_datalinks != NULL)
525                 p_pcap_free_datalinks(ddlt);
526 }
527 #endif
528
529 #ifdef HAVE_PCAP_DATALINK_VAL_TO_NAME
530 const char *
531 pcap_datalink_val_to_name(int dlt)
532 {
533         int i;
534
535         g_assert(has_wpcap);
536
537         if (p_pcap_datalink_val_to_name != NULL)
538                 return p_pcap_datalink_val_to_name(dlt);
539         else {
540                 /*
541                  * We don't have it in WinPcap; do it ourselves.
542                  */
543                 for (i = 0; dlt_choices[i].name != NULL; i++) {
544                         if (dlt_choices[i].dlt == dlt)
545                                 return dlt_choices[i].name + sizeof("DLT_") - 1;
546                 }
547                 return NULL;
548         }
549 }
550 #endif
551
552 #ifdef HAVE_PCAP_BREAKLOOP
553 void pcap_breakloop(pcap_t *a)
554 {
555         p_pcap_breakloop(a);
556 }
557 #endif
558
559 /* setbuff is win32 specific! */
560 int pcap_setbuff(pcap_t *a, int b)
561 {
562         g_assert(has_wpcap);
563         return p_pcap_setbuff(a, b);
564 }
565
566 /* pcap_next_ex is available since libpcap 0.8 / WinPcap 3.0! */
567 /* (if you get a declaration warning here, try to update to at least WinPcap 3.1b4 develpack) */
568 int pcap_next_ex (pcap_t *a, struct pcap_pkthdr **b, const u_char **c)
569 {
570         g_assert(has_wpcap);
571         return p_pcap_next_ex(a, b, c);
572 }
573
574 #ifdef HAVE_PCAP_REMOTE
575 GList *
576 get_remote_interface_list(const char *hostname, const char *port,
577                           int auth_type, const char *username,
578                           const char *passwd, int *err, char **err_str)
579 {
580     struct pcap_rmtauth auth;
581     char source[PCAP_BUF_SIZE];
582     char errbuf[PCAP_ERRBUF_SIZE];
583     GList *result;
584
585     if (pcap_createsrcstr(source, PCAP_SRC_IFREMOTE, hostname, port,
586                           NULL, errbuf) == -1) {
587         *err = CANT_GET_INTERFACE_LIST;
588         if (err_str != NULL)
589             *err_str = cant_get_if_list_error_message(errbuf);
590         return NULL;
591     }
592
593     auth.type = auth_type;
594     auth.username = g_strdup(username);
595     auth.password = g_strdup(passwd);
596
597     result = get_interface_list_findalldevs_ex(source, &auth, err, err_str);
598     g_free(auth.username);
599     g_free(auth.password);
600
601     return result;
602 }
603 #endif
604
605 /*
606  * This will use "pcap_findalldevs()" if we have it, otherwise it'll
607  * fall back on "pcap_lookupdev()".
608  */
609 GList *
610 get_interface_list(int *err, char **err_str)
611 {
612         GList  *il = NULL;
613         wchar_t *names;
614         char *win95names;
615         char ascii_name[MAX_WIN_IF_NAME_LEN + 1];
616         char ascii_desc[MAX_WIN_IF_NAME_LEN + 1];
617         int i, j;
618         char errbuf[PCAP_ERRBUF_SIZE];
619
620 #ifdef HAVE_PCAP_FINDALLDEVS
621         if (p_pcap_findalldevs != NULL)
622                 return get_interface_list_findalldevs(err, err_str);
623 #endif
624
625         /*
626          * In WinPcap, pcap_lookupdev is implemented by calling
627          * PacketGetAdapterNames.  According to the documentation
628          * I could find:
629          *
630          *      http://www.winpcap.org/docs/man/html/Packet32_8c.html#a43
631          *
632          * this means that:
633          *
634          * On Windows OT (95, 98, Me), pcap_lookupdev returns a sequence
635          * of bytes consisting of:
636          *
637          *      a sequence of null-terminated ASCII strings (i.e., each
638          *      one is terminated by a single 0 byte), giving the names
639          *      of the interfaces;
640          *
641          *      an empty ASCII string (i.e., a single 0 byte);
642          *
643          *      a sequence of null-terminated ASCII strings, giving the
644          *      descriptions of the interfaces;
645          *
646          *      an empty ASCII string.
647          *
648          * On Windows NT (NT 4.0, W2K, WXP, W2K3, etc.), pcap_lookupdev
649          * returns a sequence of bytes consisting of:
650          *
651          *      a sequence of null-terminated double-byte Unicode strings
652          *      (i.e., each one consits of a sequence of double-byte
653          *      characters, terminated by a double-byte 0), giving the
654          *      names of the interfaces;
655          *
656          *      an empty Unicode string (i.e., a double 0 byte);
657          *
658          *      a sequence of null-terminated ASCII strings, giving the
659          *      descriptions of the interfaces;
660          *
661          *      an empty ASCII string.
662          *
663          * The Nth string in the first sequence is the name of the Nth
664          * adapter; the Nth string in the second sequence is the
665          * description of the Nth adapter.
666          */
667
668         names = (wchar_t *)pcap_lookupdev(errbuf);
669         i = 0;
670
671         if (names) {
672                 char* desc = 0;
673                 int desc_pos = 0;
674
675                 if (names[0]<256) {
676                         /*
677                          * If names[0] is less than 256 it means the first
678                          * byte is 0.  This implies that we are using Unicode
679                          * characters.
680                          */
681                         while (*(names+desc_pos) || *(names+desc_pos-1))
682                                 desc_pos++;
683                         desc_pos++;     /* Step over the extra '\0' */
684                         desc = (char*)(names + desc_pos); /* cast *after* addition */
685
686                         while (names[i] != 0) {
687                                 /*
688                                  * Copy the Unicode description to an ASCII
689                                  * string.
690                                  */
691                                 j = 0;
692                                 while (*desc != 0) {
693                                         if (j < MAX_WIN_IF_NAME_LEN)
694                                                 ascii_desc[j++] = *desc;
695                                         desc++;
696                                 }
697                                 ascii_desc[j] = '\0';
698                                 desc++;
699
700                                 /*
701                                  * Copy the Unicode name to an ASCII string.
702                                  */
703                                 j = 0;
704                                 while (names[i] != 0) {
705                                         if (j < MAX_WIN_IF_NAME_LEN)
706                                         ascii_name[j++] = (char) names[i++];
707                                 }
708                                 ascii_name[j] = '\0';
709                                 i++;
710                                 il = g_list_append(il,
711                                     if_info_new(ascii_name, ascii_desc));
712                         }
713                 } else {
714                         /*
715                          * Otherwise we are in Windows 95/98 and using ASCII
716                          * (8-bit) characters.
717                          */
718                         win95names=(char *)names;
719                         while (*(win95names+desc_pos) || *(win95names+desc_pos-1))
720                                 desc_pos++;
721                         desc_pos++;     /* Step over the extra '\0' */
722                         desc = win95names + desc_pos;
723
724                         while (win95names[i] != '\0') {
725                                 /*
726                                  * "&win95names[i]" points to the current
727                                  * interface name, and "desc" points to
728                                  * that interface's description.
729                                  */
730                                 il = g_list_append(il,
731                                     if_info_new(&win95names[i], desc));
732
733                                 /*
734                                  * Skip to the next description.
735                                  */
736                                 while (*desc != 0)
737                                         desc++;
738                                 desc++;
739
740                                 /*
741                                  * Skip to the next name.
742                                  */
743                                 while (win95names[i] != 0)
744                                         i++;
745                                 i++;
746                         }
747                 }
748         }
749
750         if (il == NULL) {
751                 /*
752                  * No interfaces found.
753                  */
754                 *err = NO_INTERFACES_FOUND;
755                 if (err_str != NULL)
756                         *err_str = NULL;
757         }
758
759         return il;
760 }
761
762 /*
763  * Get an error message string for a CANT_GET_INTERFACE_LIST error from
764  * "get_interface_list()".
765  */
766 gchar *
767 cant_get_if_list_error_message(const char *err_str)
768 {
769         /*
770          * If the error message includes "Not enough storage is available
771          * to process this command" or "The operation completed successfully",
772          * suggest that they install a WinPcap version later than 3.0.
773          */
774         if (strstr(err_str, "Not enough storage is available to process this command") != NULL ||
775             strstr(err_str, "The operation completed successfully") != NULL) {
776                 return g_strdup_printf("Can't get list of interfaces: %s\n"
777 "This might be a problem with WinPcap 3.0; you should try updating to\n"
778 "a later version of WinPcap - see the WinPcap site at www.winpcap.org",
779                     err_str);
780         }
781         return g_strdup_printf("Can't get list of interfaces: %s", err_str);
782 }
783
784 /*
785  * Append the version of WinPcap with which we were compiled to a GString.
786  */
787 void
788 get_compiled_pcap_version(GString *str)
789 {
790         g_string_append(str, "with WinPcap (version unknown)");
791 }
792
793 /*
794  * Append the version of WinPcap with which we we're running to a GString.
795  */
796 void
797 get_runtime_pcap_version(GString *str)
798 {
799         /*
800          * On Windows, we might have been compiled with WinPcap but
801          * might not have it loaded; indicate whether we have it or
802          * not and, if we have it and we have "pcap_lib_version()",
803          * what version we have.
804          */
805         GModule *handle;                /* handle returned by dlopen */
806         static gchar *packetVer;
807         gchar *blankp;
808
809         if (has_wpcap) {
810                 g_string_append_printf(str, "with ");
811                 if (p_pcap_lib_version != NULL)
812                         g_string_append_printf(str, p_pcap_lib_version());
813                 else {
814                         /*
815                          * An alternative method of obtaining the version
816                          * number, by using the PacketLibraryVersion
817                          * string from packet.dll.
818                          *
819                          * Unfortunately, in WinPcap 3.0, it returns
820                          * "3.0 alpha3", even in the final version of
821                          * WinPcap 3.0, so if there's a blank in the
822                          * string, we strip it and everything after
823                          * it from the string, so we don't misleadingly
824                          * report that 3.0 alpha3 is being used when
825                          * the final version is being used.
826                          */
827                         if (packetVer == NULL) {
828                                 packetVer = "version unknown";
829                                 handle = g_module_open("Packet.dll", 0);
830                                 if (handle != NULL) {
831                                         if (g_module_symbol(handle,
832                                             "PacketLibraryVersion",
833                                             (gpointer*)&packetVer)) {
834                                                 packetVer = g_strdup(packetVer);
835                                                 blankp = strchr(packetVer, ' ');
836                                                 if (blankp != NULL)
837                                                         *blankp = '\0';
838                                         } else {
839                                                 packetVer = "version unknown";
840                                         }
841                                         g_module_close(handle);
842                                 }
843                         }
844                         g_string_append_printf(str, "WinPcap (%s)", packetVer);
845                 }
846         } else
847                 g_string_append(str, "without WinPcap");
848 }
849
850 #else /* HAVE_LIBPCAP */
851
852 void
853 load_wpcap(void)
854 {
855         return;
856 }
857
858 /*
859  * Append an indication that we were not compiled with WinPcap
860  * to a GString.
861  */
862 void
863 get_compiled_pcap_version(GString *str)
864 {
865         g_string_append(str, "without WinPcap");
866 }
867
868 /*
869  * Don't append anything, as we weren't even compiled to use WinPcap.
870  */
871 void
872 get_runtime_pcap_version(GString *str _U_)
873 {
874 }
875
876 #endif /* HAVE_LIBPCAP */