Fix a couple (value) mistakes in value_strings. Found by Martin's patch on the ...
[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         return NULL;
328     }
329     return p_pcap_open_live(a, b, c, d, e);
330 }
331
332 #ifdef HAVE_PCAP_OPEN_DEAD
333 pcap_t*
334 pcap_open_dead(int a, int b)
335 {
336     if (!has_wpcap) {
337         return NULL;
338     }
339     return p_pcap_open_dead(a, b);
340 }
341 #endif
342
343 #ifdef HAVE_BPF_IMAGE
344 char *
345 bpf_image(const struct bpf_insn *a, int b)
346 {
347     if (!has_wpcap) {
348         return NULL;
349     }
350     return p_bpf_image(a, b);
351 }
352 #endif
353
354 #ifdef HAVE_PCAP_REMOTE
355 pcap_t*
356 pcap_open(const char *a, int b, int c, int d, struct pcap_rmtauth *e, char *f)
357 {
358     if (!has_wpcap) {
359         return NULL;
360     }
361     return p_pcap_open(a, b, c, d, e, f);
362 }
363
364 int
365 pcap_findalldevs_ex(char *a, struct pcap_rmtauth *b, pcap_if_t **c, char *d)
366 {
367     g_assert(has_wpcap);
368     return p_pcap_findalldevs_ex(a, b, c, d);
369 }
370
371 int
372 pcap_createsrcstr(char *a, int b, const char *c, const char *d, const char *e,
373                   char *f)
374 {
375     g_assert(has_wpcap);
376     return p_pcap_createsrcstr(a, b, c, d, e, f);
377 }
378 #endif
379
380 #ifdef HAVE_PCAP_SETSAMPLING
381 struct pcap_samp *
382 pcap_setsampling(pcap_t *a)
383 {
384     g_assert(has_wpcap);
385     if (p_pcap_setsampling != NULL) {
386         return p_pcap_setsampling(a);
387     }
388     return NULL;
389 }
390 #endif
391
392 int
393 pcap_loop(pcap_t *a, int b, pcap_handler c, guchar *d)
394 {
395         g_assert(has_wpcap);
396         return p_pcap_loop(a, b, c, d);
397 }
398
399 void
400 pcap_freecode(struct bpf_program *a)
401 {
402         g_assert(has_wpcap);
403     if(p_pcap_freecode) {
404             p_pcap_freecode(a);
405     }
406 }
407
408 #ifdef HAVE_PCAP_FINDALLDEVS
409 int
410 pcap_findalldevs(pcap_if_t **a, char *b)
411 {
412         g_assert(has_wpcap && p_pcap_findalldevs != NULL);
413         return p_pcap_findalldevs(a, b);
414 }
415
416 void
417 pcap_freealldevs(pcap_if_t *a)
418 {
419         g_assert(has_wpcap && p_pcap_freealldevs != NULL);
420         p_pcap_freealldevs(a);
421 }
422 #endif
423
424 #if defined(HAVE_PCAP_DATALINK_NAME_TO_VAL) || defined(HAVE_PCAP_DATALINK_VAL_TO_NAME) || defined(HAVE_PCAP_DATALINK_VAL_TO_DESCRIPTION)
425 /*
426  * Table of DLT_ types, names, and descriptions, for use if the version
427  * of WinPcap we have installed lacks "pcap_datalink_name_to_val()"
428  * or "pcap_datalink_val_to_name()".
429  */
430 struct dlt_choice {
431         const char *name;
432         const char *description;
433         int     dlt;
434 };
435
436 #define DLT_CHOICE(code, description) { #code, description, code }
437 #define DLT_CHOICE_SENTINEL { NULL, NULL, 0 }
438
439 static struct dlt_choice dlt_choices[] = {
440         DLT_CHOICE(DLT_NULL, "BSD loopback"),
441         DLT_CHOICE(DLT_EN10MB, "Ethernet"),
442         DLT_CHOICE(DLT_IEEE802, "Token ring"),
443         DLT_CHOICE(DLT_ARCNET, "ARCNET"),
444         DLT_CHOICE(DLT_SLIP, "SLIP"),
445         DLT_CHOICE(DLT_PPP, "PPP"),
446         DLT_CHOICE(DLT_FDDI, "FDDI"),
447         DLT_CHOICE(DLT_ATM_RFC1483, "RFC 1483 IP-over-ATM"),
448         DLT_CHOICE(DLT_RAW, "Raw IP"),
449 #ifdef DLT_SLIP_BSDOS
450         DLT_CHOICE(DLT_SLIP_BSDOS, "BSD/OS SLIP"),
451 #endif
452 #ifdef DLT_PPP_BSDOS
453         DLT_CHOICE(DLT_PPP_BSDOS, "BSD/OS PPP"),
454 #endif
455 #ifdef DLT_ATM_CLIP
456         DLT_CHOICE(DLT_ATM_CLIP, "Linux Classical IP-over-ATM"),
457 #endif
458 #ifdef DLT_PPP_SERIAL
459         DLT_CHOICE(DLT_PPP_SERIAL, "PPP over serial"),
460 #endif
461 #ifdef DLT_PPP_ETHER
462         DLT_CHOICE(DLT_PPP_ETHER, "PPPoE"),
463 #endif
464 #ifdef DLT_C_HDLC
465         DLT_CHOICE(DLT_C_HDLC, "Cisco HDLC"),
466 #endif
467 #ifdef DLT_IEEE802_11
468         DLT_CHOICE(DLT_IEEE802_11, "802.11"),
469 #endif
470 #ifdef DLT_FRELAY
471         DLT_CHOICE(DLT_FRELAY, "Frame Relay"),
472 #endif
473 #ifdef DLT_LOOP
474         DLT_CHOICE(DLT_LOOP, "OpenBSD loopback"),
475 #endif
476 #ifdef DLT_ENC
477         DLT_CHOICE(DLT_ENC, "OpenBSD encapsulated IP"),
478 #endif
479 #ifdef DLT_LINUX_SLL
480         DLT_CHOICE(DLT_LINUX_SLL, "Linux cooked"),
481 #endif
482 #ifdef DLT_LTALK
483         DLT_CHOICE(DLT_LTALK, "Localtalk"),
484 #endif
485 #ifdef DLT_PFLOG
486         DLT_CHOICE(DLT_PFLOG, "OpenBSD pflog file"),
487 #endif
488 #ifdef DLT_PRISM_HEADER
489         DLT_CHOICE(DLT_PRISM_HEADER, "802.11 plus Prism header"),
490 #endif
491 #ifdef DLT_IP_OVER_FC
492         DLT_CHOICE(DLT_IP_OVER_FC, "RFC 2625 IP-over-Fibre Channel"),
493 #endif
494 #ifdef DLT_SUNATM
495         DLT_CHOICE(DLT_SUNATM, "Sun raw ATM"),
496 #endif
497 #ifdef DLT_IEEE802_11_RADIO
498         DLT_CHOICE(DLT_IEEE802_11_RADIO, "802.11 plus radio information header"),
499 #endif
500 #ifdef DLT_ARCNET_LINUX
501         DLT_CHOICE(DLT_ARCNET_LINUX, "Linux ARCNET"),
502 #endif
503 #ifdef DLT_LINUX_IRDA
504         DLT_CHOICE(DLT_LINUX_IRDA, "Linux IrDA"),
505 #endif
506 #ifdef DLT_LINUX_LAPD
507         DLT_CHOICE(DLT_LINUX_LAPD, "Linux vISDN LAPD"),
508 #endif
509 #ifdef DLT_LANE8023
510         DLT_CHOICE(DLT_LANE8023, "Linux 802.3 LANE"),
511 #endif
512 #ifdef DLT_CIP
513         DLT_CHOICE(DLT_CIP, "Linux Classical IP-over-ATM"),
514 #endif
515 #ifdef DLT_HDLC
516         DLT_CHOICE(DLT_HDLC, "Cisco HDLC"),
517 #endif
518 #ifdef DLT_PPI
519         DLT_CHOICE(DLT_PPI, "Per-Packet Information"),
520 #endif
521         DLT_CHOICE_SENTINEL
522 };
523 #endif /* defined(HAVE_PCAP_DATALINK_NAME_TO_VAL) || defined(HAVE_PCAP_DATALINK_VAL_TO_NAME) || defined(HAVE_PCAP_DATALINK_VAL_TO_DESCRIPTION */
524
525 #ifdef HAVE_PCAP_DATALINK_NAME_TO_VAL
526 int
527 pcap_datalink_name_to_val(const char *name)
528 {
529         int i;
530
531         g_assert(has_wpcap);
532
533         if (p_pcap_datalink_name_to_val != NULL)
534                 return p_pcap_datalink_name_to_val(name);
535         else {
536                 /*
537                  * We don't have it in WinPcap; do it ourselves.
538                  */
539                 for (i = 0; dlt_choices[i].name != NULL; i++) {
540                         if (g_ascii_strcasecmp(dlt_choices[i].name + sizeof("DLT_") - 1,
541                             name) == 0)
542                                 return dlt_choices[i].dlt;
543                 }
544                 return -1;
545         }
546 }
547 #endif
548
549 #ifdef HAVE_PCAP_LIST_DATALINKS
550 int
551 pcap_list_datalinks(pcap_t *p, int **ddlt)
552 {
553         g_assert(has_wpcap);
554         return p_pcap_list_datalinks(p, ddlt);
555 }
556 #endif
557
558 #ifdef HAVE_PCAP_FREE_DATALINKS
559 void
560 pcap_free_datalinks(int *ddlt)
561 {
562         g_assert(has_wpcap);
563
564         /*
565          * If we don't have pcap_free_datalinks() in WinPcap,
566          * we don't free the memory - we can't use free(), as
567          * we might not have been built with the same version
568          * of the C runtime library as WinPcap was, and, if we're
569          * not, free() isn't guaranteed to work on something
570          * allocated by WinPcap.
571          */
572         if (p_pcap_free_datalinks != NULL)
573                 p_pcap_free_datalinks(ddlt);
574 }
575 #endif
576
577 #ifdef HAVE_PCAP_DATALINK_VAL_TO_NAME
578 const char *
579 pcap_datalink_val_to_name(int dlt)
580 {
581         int i;
582
583         g_assert(has_wpcap);
584
585         if (p_pcap_datalink_val_to_name != NULL)
586                 return p_pcap_datalink_val_to_name(dlt);
587         else {
588                 /*
589                  * We don't have it in WinPcap; do it ourselves.
590                  */
591                 for (i = 0; dlt_choices[i].name != NULL; i++) {
592                         if (dlt_choices[i].dlt == dlt)
593                                 return dlt_choices[i].name + sizeof("DLT_") - 1;
594                 }
595                 return NULL;
596         }
597 }
598 #endif
599
600 #ifdef HAVE_PCAP_DATALINK_VAL_TO_DESCRIPTION
601 const char *
602 pcap_datalink_val_to_description(int dlt)
603 {
604         int i;
605
606         g_assert(has_wpcap);
607
608         if (p_pcap_datalink_val_to_description != NULL)
609                 return p_pcap_datalink_val_to_description(dlt);
610         else {
611                 /*
612                  * We don't have it in WinPcap; do it ourselves.
613                  */
614                 for (i = 0; dlt_choices[i].name != NULL; i++) {
615                         if (dlt_choices[i].dlt == dlt)
616                                 return (dlt_choices[i].description);
617                 }
618                 return NULL;
619         }
620 }
621 #endif
622
623 #ifdef HAVE_PCAP_BREAKLOOP
624 void pcap_breakloop(pcap_t *a)
625 {
626         p_pcap_breakloop(a);
627 }
628 #endif
629
630 /* setbuff is win32 specific! */
631 int pcap_setbuff(pcap_t *a, int b)
632 {
633         g_assert(has_wpcap);
634         return p_pcap_setbuff(a, b);
635 }
636
637 /* pcap_next_ex is available since libpcap 0.8 / WinPcap 3.0! */
638 /* (if you get a declaration warning here, try to update to at least WinPcap 3.1b4 develpack) */
639 int pcap_next_ex (pcap_t *a, struct pcap_pkthdr **b, const u_char **c)
640 {
641         g_assert(has_wpcap);
642         return p_pcap_next_ex(a, b, c);
643 }
644
645 #ifdef HAVE_PCAP_REMOTE
646 GList *
647 get_remote_interface_list(const char *hostname, const char *port,
648                           int auth_type, const char *username,
649                           const char *passwd, int *err, char **err_str)
650 {
651     struct pcap_rmtauth auth;
652     char source[PCAP_BUF_SIZE];
653     char errbuf[PCAP_ERRBUF_SIZE];
654     GList *result;
655
656     if (pcap_createsrcstr(source, PCAP_SRC_IFREMOTE, hostname, port,
657                           NULL, errbuf) == -1) {
658         *err = CANT_GET_INTERFACE_LIST;
659         if (err_str != NULL)
660             *err_str = cant_get_if_list_error_message(errbuf);
661         return NULL;
662     }
663
664     auth.type = auth_type;
665     auth.username = g_strdup(username);
666     auth.password = g_strdup(passwd);
667
668     result = get_interface_list_findalldevs_ex(source, &auth, err, err_str);
669     g_free(auth.username);
670     g_free(auth.password);
671
672     return result;
673 }
674 #endif
675
676 /*
677  * This will use "pcap_findalldevs()" if we have it, otherwise it'll
678  * fall back on "pcap_lookupdev()".
679  */
680 GList *
681 get_interface_list(int *err, char **err_str)
682 {
683         GList  *il = NULL;
684         wchar_t *names;
685         char *win95names;
686         char ascii_name[MAX_WIN_IF_NAME_LEN + 1];
687         char ascii_desc[MAX_WIN_IF_NAME_LEN + 1];
688         int i, j;
689         char errbuf[PCAP_ERRBUF_SIZE];
690
691 #ifdef HAVE_PCAP_FINDALLDEVS
692         if (p_pcap_findalldevs != NULL)
693                 return get_interface_list_findalldevs(err, err_str);
694 #endif
695
696         /*
697          * In WinPcap, pcap_lookupdev is implemented by calling
698          * PacketGetAdapterNames.  According to the documentation
699          * I could find:
700          *
701          *      http://www.winpcap.org/docs/man/html/Packet32_8c.html#a43
702          *
703          * this means that:
704          *
705          * On Windows OT (95, 98, Me), pcap_lookupdev returns a sequence
706          * of bytes consisting of:
707          *
708          *      a sequence of null-terminated ASCII strings (i.e., each
709          *      one is terminated by a single 0 byte), giving the names
710          *      of the interfaces;
711          *
712          *      an empty ASCII string (i.e., a single 0 byte);
713          *
714          *      a sequence of null-terminated ASCII strings, giving the
715          *      descriptions of the interfaces;
716          *
717          *      an empty ASCII string.
718          *
719          * On Windows NT (NT 4.0, W2K, WXP, W2K3, etc.), pcap_lookupdev
720          * returns a sequence of bytes consisting of:
721          *
722          *      a sequence of null-terminated double-byte Unicode strings
723          *      (i.e., each one consits of a sequence of double-byte
724          *      characters, terminated by a double-byte 0), giving the
725          *      names of the interfaces;
726          *
727          *      an empty Unicode string (i.e., a double 0 byte);
728          *
729          *      a sequence of null-terminated ASCII strings, giving the
730          *      descriptions of the interfaces;
731          *
732          *      an empty ASCII string.
733          *
734          * The Nth string in the first sequence is the name of the Nth
735          * adapter; the Nth string in the second sequence is the
736          * description of the Nth adapter.
737          */
738
739         names = (wchar_t *)pcap_lookupdev(errbuf);
740         i = 0;
741
742         if (names) {
743                 char* desc = 0;
744                 int desc_pos = 0;
745
746                 if (names[0]<256) {
747                         /*
748                          * If names[0] is less than 256 it means the first
749                          * byte is 0.  This implies that we are using Unicode
750                          * characters.
751                          */
752                         while (*(names+desc_pos) || *(names+desc_pos-1))
753                                 desc_pos++;
754                         desc_pos++;     /* Step over the extra '\0' */
755                         desc = (char*)(names + desc_pos); /* cast *after* addition */
756
757                         while (names[i] != 0) {
758                                 /*
759                                  * Copy the Unicode description to an ASCII
760                                  * string.
761                                  */
762                                 j = 0;
763                                 while (*desc != 0) {
764                                         if (j < MAX_WIN_IF_NAME_LEN)
765                                                 ascii_desc[j++] = *desc;
766                                         desc++;
767                                 }
768                                 ascii_desc[j] = '\0';
769                                 desc++;
770
771                                 /*
772                                  * Copy the Unicode name to an ASCII string.
773                                  */
774                                 j = 0;
775                                 while (names[i] != 0) {
776                                         if (j < MAX_WIN_IF_NAME_LEN)
777                                         ascii_name[j++] = (char) names[i++];
778                                 }
779                                 ascii_name[j] = '\0';
780                                 i++;
781                                 il = g_list_append(il,
782                                     if_info_new(ascii_name, ascii_desc));
783                         }
784                 } else {
785                         /*
786                          * Otherwise we are in Windows 95/98 and using ASCII
787                          * (8-bit) characters.
788                          */
789                         win95names=(char *)names;
790                         while (*(win95names+desc_pos) || *(win95names+desc_pos-1))
791                                 desc_pos++;
792                         desc_pos++;     /* Step over the extra '\0' */
793                         desc = win95names + desc_pos;
794
795                         while (win95names[i] != '\0') {
796                                 /*
797                                  * "&win95names[i]" points to the current
798                                  * interface name, and "desc" points to
799                                  * that interface's description.
800                                  */
801                                 il = g_list_append(il,
802                                     if_info_new(&win95names[i], desc));
803
804                                 /*
805                                  * Skip to the next description.
806                                  */
807                                 while (*desc != 0)
808                                         desc++;
809                                 desc++;
810
811                                 /*
812                                  * Skip to the next name.
813                                  */
814                                 while (win95names[i] != 0)
815                                         i++;
816                                 i++;
817                         }
818                 }
819         }
820
821         if (il == NULL) {
822                 /*
823                  * No interfaces found.
824                  */
825                 *err = NO_INTERFACES_FOUND;
826                 if (err_str != NULL)
827                         *err_str = NULL;
828         }
829
830         return il;
831 }
832
833 /*
834  * Get an error message string for a CANT_GET_INTERFACE_LIST error from
835  * "get_interface_list()".
836  */
837 gchar *
838 cant_get_if_list_error_message(const char *err_str)
839 {
840         /*
841          * If the error message includes "Not enough storage is available
842          * to process this command" or "The operation completed successfully",
843          * suggest that they install a WinPcap version later than 3.0.
844          */
845         if (strstr(err_str, "Not enough storage is available to process this command") != NULL ||
846             strstr(err_str, "The operation completed successfully") != NULL) {
847                 return g_strdup_printf("Can't get list of interfaces: %s\n"
848 "This might be a problem with WinPcap 3.0; you should try updating to\n"
849 "a later version of WinPcap - see the WinPcap site at www.winpcap.org",
850                     err_str);
851         }
852         return g_strdup_printf("Can't get list of interfaces: %s", err_str);
853 }
854
855 /*
856  * Append the version of WinPcap with which we were compiled to a GString.
857  */
858 void
859 get_compiled_pcap_version(GString *str)
860 {
861         g_string_append(str, "with WinPcap (version unknown)");
862 }
863
864 /*
865  * Append the version of WinPcap with which we we're running to a GString.
866  */
867 void
868 get_runtime_pcap_version(GString *str)
869 {
870         /*
871          * On Windows, we might have been compiled with WinPcap but
872          * might not have it loaded; indicate whether we have it or
873          * not and, if we have it and we have "pcap_lib_version()",
874          * what version we have.
875          */
876         GModule *handle;                /* handle returned by ws_module_open */
877         static gchar *packetVer;
878         gchar *blankp;
879
880         if (has_wpcap) {
881                 g_string_append_printf(str, "with ");
882                 if (p_pcap_lib_version != NULL)
883                         g_string_append_printf(str, p_pcap_lib_version());
884                 else {
885                         /*
886                          * An alternative method of obtaining the version
887                          * number, by using the PacketLibraryVersion
888                          * string from packet.dll.
889                          *
890                          * Unfortunately, in WinPcap 3.0, it returns
891                          * "3.0 alpha3", even in the final version of
892                          * WinPcap 3.0, so if there's a blank in the
893                          * string, we strip it and everything after
894                          * it from the string, so we don't misleadingly
895                          * report that 3.0 alpha3 is being used when
896                          * the final version is being used.
897                          */
898                         if (packetVer == NULL) {
899                                 packetVer = "version unknown";
900                                 handle = ws_module_open("packet.dll", 0);
901                                 if (handle != NULL) {
902                                         if (g_module_symbol(handle,
903                                             "PacketLibraryVersion",
904                                             (gpointer*)&packetVer)) {
905                                                 packetVer = g_strdup(packetVer);
906                                                 blankp = strchr(packetVer, ' ');
907                                                 if (blankp != NULL)
908                                                         *blankp = '\0';
909                                         } else {
910                                                 packetVer = "version unknown";
911                                         }
912                                         g_module_close(handle);
913                                 }
914                         }
915                         g_string_append_printf(str, "WinPcap (%s)", packetVer);
916                 }
917         } else
918                 g_string_append(str, "without WinPcap");
919 }
920
921 #else /* HAVE_LIBPCAP */
922
923 void
924 load_wpcap(void)
925 {
926         return;
927 }
928
929 /*
930  * Append an indication that we were not compiled with WinPcap
931  * to a GString.
932  */
933 void
934 get_compiled_pcap_version(GString *str)
935 {
936         g_string_append(str, "without WinPcap");
937 }
938
939 /*
940  * Don't append anything, as we weren't even compiled to use WinPcap.
941  */
942 void
943 get_runtime_pcap_version(GString *str _U_)
944 {
945 }
946
947 #endif /* HAVE_LIBPCAP */