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