dlls/wpcap/wpcap.c

   1 /*
   2  * WPcap.dll Proxy.
   3  *
   4  * Copyright 2011, 2014 André Hentschel
   5  * Copyright 2022 Hans Leidekker for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <malloc.h>
  24
  25 #include "ntstatus.h"
  26 #define WIN32_NO_STATUS
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winternl.h"
  30 #include "winnls.h"
  31 #include "winsock2.h"
  32 #include "ws2ipdef.h"
  33 #include "iphlpapi.h"
  34 #include "netioapi.h"
  35
  36 #include "wine/unixlib.h"
  37 #include "wine/debug.h"
  38 #include "unixlib.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(wpcap);
  41 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  42
  43 #define PCAP_CALL( func, params ) WINE_UNIX_CALL( unix_ ## func, params )
  44
  45 #define PCAP_ERROR -1
  46 #define PCAP_ERROR_BREAK -2
  47 #define PCAP_ERROR_NOT_ACTIVATED -3
  48 #define PCAP_ERROR_ACTIVATED -4
  49 #define PCAP_ERROR_NO_SUCH_DEVICE -5
  50 #define PCAP_ERROR_RFMON_NOTSUP -6
  51 #define PCAP_ERROR_NOT_RFMON -7
  52 #define PCAP_ERROR_PERM_DENIED -8
  53 #define PCAP_ERROR_IFACE_NOT_UP -9
  54 #define PCAP_ERROR_CANTSET_TSTAMP_TYPE -10
  55 #define PCAP_ERROR_PROMISC_PERM_DENIED -11
  56 #define PCAP_ERROR_TSTAMP_PRECISION_NOTSUP -12
  57
  58 #define PCAP_WARNING 1
  59 #define PCAP_WARNING_PROMISC_NOTSUP 2
  60 #define PCAP_WARNING_TSTAMP_TYPE_NOTSUP 3
  61
  62 #define PCAP_ERRBUF_SIZE 256
  63 struct pcap
  64 {
  65     UINT64 handle;
  66     struct pcap_pkthdr_win32 hdr;
  67     char errbuf[PCAP_ERRBUF_SIZE];
  68 };
  69
  70 struct bpf_insn
  71 {
  72     unsigned short code;
  73     unsigned char jt;
  74     unsigned char jf;
  75     unsigned int k;
  76 };
  77
  78 struct bpf_program
  79 {
  80     unsigned int bf_len;
  81     struct bpf_insn *bf_insns;
  82 };
  83
  84 int CDECL pcap_activate( struct pcap *pcap )
  85 {
  86     struct activate_params params;
  87     int ret;
  88
  89     TRACE( "%p\n", pcap );
  90
  91     if (!pcap) return PCAP_ERROR;
  92
  93     params.handle = pcap->handle;
  94     ret = PCAP_CALL( activate, &params );
  95     if (ret == PCAP_ERROR_PERM_DENIED)
  96         ERR_(winediag)( "Failed to access raw network (pcap), this requires special permissions.\n" );
  97     return ret;
  98 }
  99
 100 void CDECL pcap_breakloop( struct pcap *pcap )
 101 {
 102     struct breakloop_params params;
 103
 104     TRACE( "%p\n", pcap );
 105
 106     if (!pcap) return;
 107     params.handle = pcap->handle;
 108     PCAP_CALL( breakloop, &params );
 109 }
 110
 111 int CDECL pcap_bufsize( struct pcap *pcap )
 112 {
 113     struct bufsize_params params;
 114
 115     TRACE( "%p\n", pcap );
 116
 117     if (!pcap) return 0;
 118     params.handle = pcap->handle;
 119     return PCAP_CALL( bufsize, &params );
 120 }
 121
 122 int CDECL pcap_can_set_rfmon( struct pcap *pcap )
 123 {
 124     struct can_set_rfmon_params params;
 125
 126     TRACE( "%p\n", pcap );
 127
 128     if (!pcap) return PCAP_ERROR;
 129     params.handle = pcap->handle;
 130     return PCAP_CALL( can_set_rfmon, &params );
 131 }
 132
 133 void CDECL pcap_close( struct pcap *pcap )
 134 {
 135     struct close_params params;
 136
 137     TRACE( "%p\n", pcap );
 138
 139     if (!pcap) return;
 140     params.handle = pcap->handle;
 141     PCAP_CALL( close, &params );
 142     free( pcap );
 143 }
 144
 145 int CDECL pcap_compile( struct pcap *pcap, struct bpf_program *program, const char *str, int optimize, unsigned int mask )
 146 {
 147     struct compile_params params;
 148     unsigned int len = 64;
 149     struct bpf_insn *tmp;
 150     NTSTATUS status;
 151
 152     TRACE( "%p, %p, %s, %d, %#x\n", pcap, program, debugstr_a(str), optimize, mask );
 153
 154     if (!pcap || !program) return PCAP_ERROR;
 155
 156     if (!(params.program_insns = malloc( len * sizeof(*params.program_insns) ))) return PCAP_ERROR;
 157     params.handle        = pcap->handle;
 158     params.program_len   = &len;
 159     params.str           = str;
 160     params.optimize      = optimize;
 161     params.mask          = mask;
 162     if ((status = PCAP_CALL( compile, &params )) == STATUS_SUCCESS)
 163     {
 164         program->bf_len   = *params.program_len;
 165         program->bf_insns = params.program_insns;
 166         return 0;
 167     }
 168     if (status != STATUS_BUFFER_TOO_SMALL || !(tmp = realloc( params.program_insns, len * sizeof(*tmp) )))
 169     {
 170         free( params.program_insns );
 171         return PCAP_ERROR;
 172     }
 173     params.program_insns = tmp;
 174     if (PCAP_CALL( compile, &params ))
 175     {
 176         free( params.program_insns );
 177         return PCAP_ERROR;
 178     }
 179     program->bf_len   = *params.program_len;
 180     program->bf_insns = params.program_insns;
 181     return 0;
 182 }
 183
 184 int CDECL pcap_datalink( struct pcap *pcap )
 185 {
 186     struct datalink_params params;
 187
 188     TRACE( "%p\n", pcap );
 189
 190     if (!pcap) return PCAP_ERROR;
 191     params.handle = pcap->handle;
 192     return PCAP_CALL( datalink, &params );
 193 }
 194
 195 int CDECL pcap_datalink_name_to_val( const char *name )
 196 {
 197     struct datalink_name_to_val_params params = { name };
 198     TRACE( "%s\n", debugstr_a(name) );
 199     return PCAP_CALL( datalink_name_to_val, &params );
 200 }
 201
 202 static struct
 203 {
 204     char *name;
 205     char *description;
 206 } datalinks[192];
 207
 208 static void free_datalinks( void )
 209 {
 210     unsigned int i;
 211     for (i = 0; i < ARRAY_SIZE(datalinks); i++)
 212     {
 213         free( datalinks[i].name );
 214         datalinks[i].name = NULL;
 215         free( datalinks[i].description );
 216         datalinks[i].description = NULL;
 217     }
 218 }
 219
 220 const char * CDECL pcap_datalink_val_to_description( int link )
 221 {
 222     struct datalink_val_to_description_params params;
 223     unsigned int len = 192;
 224     char *tmp;
 225     NTSTATUS status;
 226
 227     TRACE( "%d\n", link );
 228
 229     if (link < 0 || link >= ARRAY_SIZE(datalinks))
 230     {
 231         WARN( "unhandled link type %d\n", link );
 232         return NULL;
 233     }
 234     if (datalinks[link].description) return datalinks[link].description;
 235
 236     if (!(params.buf = malloc( len ))) return NULL;
 237     params.link   = link;
 238     params.buflen = &len;
 239     status = PCAP_CALL( datalink_val_to_description, &params );
 240     if (status == STATUS_SUCCESS) return (datalinks[link].description = params.buf);
 241     if (status != STATUS_BUFFER_TOO_SMALL || !(tmp = realloc( params.buf, len )))
 242     {
 243         free( params.buf );
 244         return NULL;
 245     }
 246     params.buf = tmp;
 247     if (PCAP_CALL( datalink_val_to_description, &params ))
 248     {
 249         free( params.buf );
 250         return NULL;
 251     }
 252
 253     return (datalinks[link].description = params.buf);
 254 }
 255
 256 const char * CDECL pcap_datalink_val_to_name( int link )
 257 {
 258     struct datalink_val_to_name_params params;
 259     unsigned int len = 64;
 260     char *tmp;
 261     NTSTATUS status;
 262
 263     TRACE( "%d\n", link );
 264
 265     if (link < 0 || link >= ARRAY_SIZE(datalinks))
 266     {
 267         WARN( "unhandled link type %d\n", link );
 268         return NULL;
 269     }
 270     if (datalinks[link].name) return datalinks[link].name;
 271
 272     if (!(params.buf = malloc( len ))) return NULL;
 273     params.link   = link;
 274     params.buflen = &len;
 275     status = PCAP_CALL( datalink_val_to_name, &params );
 276     if (status == STATUS_SUCCESS) return (datalinks[link].name = params.buf);
 277     if (status != STATUS_BUFFER_TOO_SMALL || !(tmp = realloc( params.buf, len )))
 278     {
 279         free( params.buf );
 280         return NULL;
 281     }
 282     params.buf = tmp;
 283     if (PCAP_CALL( datalink_val_to_name, &params ))
 284     {
 285         free( params.buf );
 286         return NULL;
 287     }
 288
 289     return (datalinks[link].name = params.buf);
 290 }
 291
 292 void CDECL pcap_dump( unsigned char *user, const struct pcap_pkthdr_win32 *hdr, const unsigned char *packet )
 293 {
 294     struct dump_params params = { user, hdr, packet };
 295     TRACE( "%p, %p, %p\n", user, hdr, packet );
 296     PCAP_CALL( dump, &params );
 297 }
 298
 299 struct dumper
 300 {
 301     UINT64 handle;
 302 };
 303
 304 void CDECL pcap_dump_close( struct dumper *dumper )
 305 {
 306     struct dump_close_params params;
 307
 308     TRACE( "%p\n", dumper );
 309
 310     if (!dumper) return;
 311     params.handle = dumper->handle;
 312     PCAP_CALL( dump, &params );
 313     free( dumper );
 314 }
 315
 316 static inline WCHAR *strdup_from_utf8( const char *str )
 317 {
 318     WCHAR *ret = NULL;
 319     if (str)
 320     {
 321         int len = MultiByteToWideChar( CP_UTF8, 0, str, -1, NULL, 0 );
 322         if ((ret = malloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_UTF8, 0, str, -1, ret, len );
 323     }
 324     return ret;
 325 }
 326
 327 struct dumper * CDECL pcap_dump_open( struct pcap *pcap, const char *filename )
 328 {
 329     struct dumper *dumper;
 330     WCHAR *filenameW;
 331     struct dump_open_params params;
 332
 333     TRACE( "%p, %s\n", pcap, debugstr_a(filename) );
 334
 335     if (!pcap) return NULL;
 336
 337     if (!(filenameW = strdup_from_utf8( filename ))) return NULL;
 338     params.name = wine_get_unix_file_name( filenameW );
 339     free( filenameW );
 340     if (!params.name) return NULL;
 341
 342     if (!(dumper = calloc( 1, sizeof(*dumper) )))
 343     {
 344         HeapFree( GetProcessHeap(), 0, params.name );
 345         return NULL;
 346     }
 347
 348     TRACE( "unix_path %s\n", debugstr_a(params.name) );
 349
 350     params.handle     = pcap->handle;
 351     params.ret_handle = &dumper->handle;
 352     if (PCAP_CALL( dump_open, &params ))
 353     {
 354         free( dumper );
 355         dumper = NULL;
 356     }
 357     HeapFree( GetProcessHeap(), 0, params.name );
 358     return dumper;
 359 }
 360
 361 static void free_addresses( struct pcap_address *addrs )
 362 {
 363     struct pcap_address *next, *cur = addrs;
 364     if (!addrs) return;
 365     do
 366     {
 367         free( cur->addr );
 368         free( cur->netmask );
 369         free( cur->broadaddr );
 370         free( cur->dstaddr );
 371         next = cur->next;
 372         free( cur );
 373         cur = next;
 374     } while (next);
 375 }
 376
 377 static void free_devices( struct pcap_interface *devs )
 378 {
 379     struct pcap_interface *next, *cur = devs;
 380     if (!devs) return;
 381     do
 382     {
 383         free( cur->name );
 384         free( cur->description );
 385         free_addresses( cur->addresses );
 386         next = cur->next;
 387         free( cur );
 388         cur = next;
 389     } while (next);
 390 }
 391
 392 static IP_ADAPTER_ADDRESSES *get_adapters( void )
 393 {
 394     DWORD size = 0;
 395     IP_ADAPTER_ADDRESSES *ret;
 396     ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
 397
 398     if (GetAdaptersAddresses( AF_UNSPEC, flags, NULL, NULL, &size ) != ERROR_BUFFER_OVERFLOW) return NULL;
 399     if (!(ret = malloc( size ))) return NULL;
 400     if (GetAdaptersAddresses( AF_UNSPEC, flags, NULL, ret, &size ))
 401     {
 402         free( ret );
 403         return NULL;
 404     }
 405     return ret;
 406 }
 407
 408 static IP_ADAPTER_ADDRESSES *find_adapter( IP_ADAPTER_ADDRESSES *list, const char *name )
 409 {
 410     IP_ADAPTER_ADDRESSES *ret;
 411     WCHAR *nameW;
 412
 413     if (!(nameW = strdup_from_utf8( name ))) return NULL;
 414     for (ret = list; ret; ret = ret->Next)
 415     {
 416         if (!wcscmp( nameW, ret->FriendlyName )) break;
 417     }
 418     free( nameW);
 419     return ret;
 420 }
 421
 422 static char *build_win32_name( const char *source, const char *adapter_name )
 423 {
 424     const char prefix[] = "\\Device\\NPF_";
 425     int len = sizeof(prefix) + strlen(adapter_name);
 426     char *ret;
 427
 428     if (source) len += strlen( source );
 429     if ((ret = malloc( len )))
 430     {
 431         ret[0] = 0;
 432         if (source) strcat( ret, source );
 433         strcat( ret, prefix );
 434         strcat( ret, adapter_name );
 435     }
 436     return ret;
 437 }
 438
 439 static char *build_win32_description( const struct pcap_interface_offsets *unix_dev )
 440 {
 441     const char *name = (const char *)unix_dev + unix_dev->name_offset;
 442     const char *description = (const char *)unix_dev + unix_dev->description_offset;
 443     int len = unix_dev->name_len + unix_dev->description_len + 1;
 444     char *ret;
 445
 446     if ((ret = malloc( len )))
 447     {
 448         if (unix_dev->description_len)
 449         {
 450             strcpy( ret, description );
 451             strcat( ret, " " );
 452             strcat( ret, name );
 453         }
 454         else strcpy( ret, name );
 455     }
 456     return ret;
 457 }
 458
 459 static struct sockaddr *get_address( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 460 {
 461     struct sockaddr *ret;
 462     if (!(ret = malloc( addr->Address.iSockaddrLength ))) return NULL;
 463     memcpy( ret, addr->Address.lpSockaddr, addr->Address.iSockaddrLength );
 464     return ret;
 465 }
 466
 467 static void convert_length_to_ipv6_mask( ULONG length, IN6_ADDR *mask )
 468 {
 469     unsigned int i;
 470     for (i = 0; i < length / 8 - 1; i++) mask->u.Byte[i] = 0xff;
 471     mask->u.Byte[i] = 0xff << (8 - length % 8);
 472 }
 473
 474 static struct sockaddr *get_netmask( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 475 {
 476     struct sockaddr *ret;
 477
 478     switch (addr->Address.lpSockaddr->sa_family)
 479     {
 480     case AF_INET:
 481     {
 482         struct sockaddr_in *netmask_addr_in;
 483
 484         if (!(netmask_addr_in = calloc( 1, sizeof(*netmask_addr_in) ))) return NULL;
 485         netmask_addr_in->sin_family = AF_INET;
 486         ConvertLengthToIpv4Mask( addr->OnLinkPrefixLength, &netmask_addr_in->sin_addr.S_un.S_addr );
 487         ret = (struct sockaddr *)netmask_addr_in;
 488         break;
 489     }
 490     case AF_INET6:
 491     {
 492         struct sockaddr_in6 *netmask_addr_in6;
 493
 494         if (!(netmask_addr_in6 = calloc( 1, sizeof(*netmask_addr_in6) ))) return NULL;
 495         netmask_addr_in6->sin6_family = AF_INET6;
 496         convert_length_to_ipv6_mask( addr->OnLinkPrefixLength, &netmask_addr_in6->sin6_addr );
 497         ret = (struct sockaddr *)netmask_addr_in6;
 498         break;
 499     }
 500     default:
 501         FIXME( "address family %u not supported\n", addr->Address.lpSockaddr->sa_family );
 502         return NULL;
 503     }
 504
 505     return ret;
 506 }
 507
 508 static struct sockaddr *get_broadcast( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 509 {
 510     struct sockaddr *ret;
 511
 512     switch (addr->Address.lpSockaddr->sa_family)
 513     {
 514     case AF_INET:
 515     {
 516         struct sockaddr_in *broadcast_addr_in, *addr_in = (struct sockaddr_in *)addr->Address.lpSockaddr;
 517         ULONG netmask;
 518
 519         if (!(broadcast_addr_in = calloc( 1, sizeof(*broadcast_addr_in) ))) return FALSE;
 520         broadcast_addr_in->sin_family = AF_INET;
 521         ConvertLengthToIpv4Mask( addr->OnLinkPrefixLength, &netmask );
 522         broadcast_addr_in->sin_addr.S_un.S_addr = addr_in->sin_addr.S_un.S_addr | ~netmask;
 523         ret = (struct sockaddr *)broadcast_addr_in;
 524         break;
 525     }
 526     case AF_INET6:
 527     {
 528         struct sockaddr_in6 *broadcast_addr_in6, *addr_in6 = (struct sockaddr_in6 *)addr->Address.lpSockaddr;
 529         IN6_ADDR netmask, *address = (IN6_ADDR *)&addr_in6->sin6_addr;
 530         unsigned int i;
 531
 532         if (!(broadcast_addr_in6 = calloc( 1, sizeof(*broadcast_addr_in6) ))) return NULL;
 533         broadcast_addr_in6->sin6_family = AF_INET6;
 534         convert_length_to_ipv6_mask( addr->OnLinkPrefixLength, &netmask );
 535         for (i = 0; i < 8; i++) broadcast_addr_in6->sin6_addr.u.Word[i] = address->u.Word[i] | ~netmask.u.Word[i];
 536         ret = (struct sockaddr *)broadcast_addr_in6;
 537         break;
 538     }
 539     default:
 540         FIXME( "address family %u not supported\n", addr->Address.lpSockaddr->sa_family );
 541         return NULL;
 542     }
 543
 544     return ret;
 545 }
 546
 547 static struct pcap_address *build_win32_address( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 548 {
 549     struct pcap_address *ret;
 550
 551     if (!(ret = calloc( 1, sizeof(*ret) ))) return NULL;
 552     if (!(ret->addr = get_address( addr ))) goto err;
 553     if (!(ret->netmask = get_netmask( addr ))) goto err;
 554     if (!(ret->broadaddr = get_broadcast( addr ))) goto err;
 555     return ret;
 556
 557 err:
 558     free( ret->addr );
 559     free( ret->netmask );
 560     free( ret->broadaddr );
 561     free( ret );
 562     return NULL;
 563 }
 564
 565 static void add_win32_address( struct pcap_address **list, struct pcap_address *addr )
 566 {
 567     struct pcap_address *cur = *list;
 568     if (!cur) *list = addr;
 569     else
 570     {
 571         while (cur->next) { cur = cur->next; }
 572         cur->next = addr;
 573     }
 574 }
 575
 576 static struct pcap_address *build_win32_addresses( const IP_ADAPTER_ADDRESSES *adapter )
 577 {
 578     struct pcap_address *dst, *ret = NULL;
 579     IP_ADAPTER_UNICAST_ADDRESS *src = adapter->FirstUnicastAddress;
 580     while (src)
 581     {
 582         if ((dst = build_win32_address( src ))) add_win32_address( &ret, dst );
 583         src = src->Next;
 584     }
 585     return ret;
 586 }
 587
 588 static struct pcap_interface *build_win32_device( const struct pcap_interface_offsets *unix_dev, const char *source,
 589                                                   const IP_ADAPTER_ADDRESSES *adapter )
 590 {
 591     struct pcap_interface *ret;
 592
 593     if (!(ret = calloc( 1, sizeof(*ret) ))) return NULL;
 594     if (!(ret->name = build_win32_name( source, adapter->AdapterName ))) goto err;
 595     if (!(ret->description = build_win32_description( unix_dev ))) goto err;
 596     ret->addresses = build_win32_addresses( adapter );
 597     ret->flags = unix_dev->flags;
 598     return ret;
 599
 600 err:
 601     free( ret->name );
 602     free( ret->description );
 603     free_addresses( ret->addresses );
 604     free( ret );
 605     return NULL;
 606 }
 607
 608 static void add_win32_device( struct pcap_interface **list, struct pcap_interface *dev )
 609 {
 610     struct pcap_interface *cur = *list;
 611     if (!cur) *list = dev;
 612     else
 613     {
 614         while (cur->next) { cur = cur->next; }
 615         cur->next = dev;
 616     }
 617 }
 618
 619 static int find_all_devices( const char *source, struct pcap_interface **devs, char *errbuf )
 620 {
 621     struct pcap_interface *win32_devs = NULL, *dst;
 622     const struct pcap_interface_offsets *src;
 623     IP_ADAPTER_ADDRESSES *ptr, *adapters;
 624     struct findalldevs_params params;
 625     unsigned int len_total = 0, len = 512;
 626     int ret;
 627
 628     if (!(params.buf = malloc( len ))) return PCAP_ERROR;
 629     params.buflen = &len;
 630     params.errbuf = errbuf;
 631     for (;;)
 632     {
 633         char *tmp;
 634         if ((ret = PCAP_CALL( findalldevs, &params )) != STATUS_BUFFER_TOO_SMALL) break;
 635         if (!(tmp = realloc( params.buf, *params.buflen )))
 636         {
 637             free( params.buf );
 638             return PCAP_ERROR;
 639         }
 640         params.buf = tmp;
 641     }
 642     if (ret)
 643     {
 644         free( params.buf );
 645         return ret;
 646     }
 647
 648     if (!(adapters = get_adapters()))
 649     {
 650         free( params.buf );
 651         return PCAP_ERROR;
 652     }
 653
 654     src = (const struct pcap_interface_offsets *)params.buf;
 655     for (;;)
 656     {
 657         const char *name = (const char *)src + src->name_offset;
 658         unsigned int len_src = sizeof(*src) + src->name_len + src->description_len;
 659
 660         if ((ptr = find_adapter( adapters, name )) && (dst = build_win32_device( src, source, ptr )))
 661         {
 662             add_win32_device( &win32_devs, dst );
 663         }
 664
 665         len_total += len_src;
 666         if (len_total >= *params.buflen) break;
 667         src = (const struct pcap_interface_offsets *)((const char *)src + len_src);
 668     }
 669     *devs = win32_devs;
 670
 671     free( adapters );
 672     free( params.buf );
 673     return ret;
 674 }
 675
 676 int CDECL pcap_findalldevs( struct pcap_interface **devs, char *errbuf )
 677 {
 678     TRACE( "%p, %p\n", devs, errbuf );
 679     return find_all_devices( NULL, devs, errbuf );
 680 }
 681
 682 int CDECL pcap_findalldevs_ex( char *source, void *auth, struct pcap_interface **devs, char *errbuf )
 683 {
 684     FIXME( "%s, %p, %p, %p: partial stub\n", debugstr_a(source), auth, devs, errbuf );
 685     return find_all_devices( source, devs, errbuf );
 686 }
 687
 688 void CDECL pcap_free_datalinks( int *links )
 689 {
 690     TRACE( "%p\n", links );
 691     free( links );
 692 }
 693
 694 void CDECL pcap_free_tstamp_types( int *types )
 695 {
 696     TRACE( "%p\n", types );
 697     free( types );
 698 }
 699
 700 void CDECL pcap_freealldevs( struct pcap_interface *devs )
 701 {
 702     TRACE( "%p\n", devs );
 703     free_devices( devs );
 704 }
 705
 706 void CDECL pcap_freecode( struct bpf_program *program )
 707 {
 708     TRACE( "%p\n", program );
 709
 710     if (!program) return;
 711     free( program->bf_insns );
 712 }
 713
 714 void * CDECL pcap_get_airpcap_handle( struct pcap *pcap )
 715 {
 716     TRACE( "%p\n", pcap );
 717     return NULL;
 718 }
 719
 720 int CDECL pcap_get_tstamp_precision( struct pcap *pcap )
 721 {
 722     struct get_tstamp_precision_params params;
 723
 724     TRACE( "%p\n", pcap );
 725
 726     if (!pcap) return PCAP_ERROR;
 727     params.handle = pcap->handle;
 728     return PCAP_CALL( get_tstamp_precision, &params );
 729 }
 730
 731 char * CDECL pcap_geterr( struct pcap *pcap )
 732 {
 733     struct geterr_params params;
 734
 735     TRACE( "%p\n", pcap );
 736
 737     if (!pcap) return NULL;
 738     params.handle = pcap->handle;
 739     params.errbuf = pcap->errbuf;
 740     PCAP_CALL( geterr, &params );
 741     return pcap->errbuf; /* FIXME: keep up-to-date */
 742 }
 743
 744 int CDECL pcap_getnonblock( struct pcap *pcap, char *errbuf )
 745 {
 746     struct getnonblock_params params;
 747
 748     TRACE( "%p, %p\n", pcap, errbuf );
 749
 750     if (!pcap) return PCAP_ERROR;
 751     params.handle = pcap->handle;
 752     params.errbuf = errbuf;
 753     return PCAP_CALL( getnonblock, &params );
 754 }
 755
 756 static char lib_version[256];
 757 static BOOL WINAPI init_lib_version( INIT_ONCE *once, void *param, void **ctx )
 758 {
 759     struct lib_version_params params = { lib_version, sizeof(lib_version) };
 760     PCAP_CALL( lib_version, &params );
 761     return TRUE;
 762 }
 763
 764 const char * CDECL pcap_lib_version( void )
 765 {
 766     static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
 767     if (!lib_version[0]) InitOnceExecuteOnce( &once, init_lib_version, NULL, NULL );
 768     TRACE( "%s\n", debugstr_a(lib_version) );
 769     return lib_version;
 770 }
 771
 772 int CDECL pcap_list_datalinks( struct pcap *pcap, int **links )
 773 {
 774     struct list_datalinks_params params;
 775     int count = 8, *tmp;
 776     NTSTATUS status;
 777
 778     TRACE( "%p, %p\n", pcap, links );
 779
 780     if (!pcap || !links) return PCAP_ERROR;
 781
 782     if (!(params.links = malloc( count * sizeof(*params.links) ))) return PCAP_ERROR;
 783     params.handle = pcap->handle;
 784     params.count  = &count;
 785     if ((status = PCAP_CALL( list_datalinks, &params )) == STATUS_SUCCESS)
 786     {
 787         if (count > 0) *links = params.links;
 788         else
 789         {
 790             free( params.links );
 791             *links = NULL;
 792         }
 793         return count;
 794     }
 795     if (status != STATUS_BUFFER_TOO_SMALL || !(tmp = realloc( params.links, count * sizeof(*tmp) )))
 796     {
 797         free( params.links );
 798         return PCAP_ERROR;
 799     }
 800     params.links = tmp;
 801     if (PCAP_CALL( list_datalinks, &params ))
 802     {
 803         free( params.links );
 804         return PCAP_ERROR;
 805     }
 806     *links = params.links;
 807     return count;
 808 }
 809
 810 int CDECL pcap_list_tstamp_types( struct pcap *pcap, int **types )
 811 {
 812     struct list_tstamp_types_params params;
 813     int count = 8, *tmp;
 814     NTSTATUS status;
 815
 816     TRACE( "%p, %p\n", pcap, types );
 817
 818     TRACE( "%p, %p\n", pcap, types );
 819
 820     if (!pcap || !types) return PCAP_ERROR;
 821
 822     if (!(params.types = malloc( count * sizeof(*params.types) ))) return PCAP_ERROR;
 823     params.handle = pcap->handle;
 824     params.count  = &count;
 825     if ((status = PCAP_CALL( list_tstamp_types, &params )) == STATUS_SUCCESS)
 826     {
 827         if (count > 0) *types = params.types;
 828         else
 829         {
 830             free( params.types );
 831             *types = NULL;
 832         }
 833         return count;
 834     }
 835     if (status != STATUS_BUFFER_TOO_SMALL || !(tmp = realloc( params.types, count * sizeof(*tmp) )))
 836     {
 837         free( params.types );
 838         return PCAP_ERROR;
 839     }
 840     params.types = tmp;
 841     if (PCAP_CALL( list_tstamp_types, &params ))
 842     {
 843         free( params.types );
 844         return PCAP_ERROR;
 845     }
 846     *types = params.types;
 847     return count;
 848 }
 849
 850 char * CDECL pcap_lookupdev( char *errbuf )
 851 {
 852     static char *ret;
 853     struct pcap_interface *devs;
 854
 855     TRACE( "%p\n", errbuf );
 856     if (!ret)
 857     {
 858         if (pcap_findalldevs( &devs, errbuf ) == PCAP_ERROR || !devs) return NULL;
 859         if ((ret = malloc( strlen(devs->name) + 1 ))) strcpy( ret, devs->name );
 860         pcap_freealldevs( devs );
 861     }
 862     return ret;
 863 }
 864
 865 static char *strdup_to_utf8( const WCHAR *src )
 866 {
 867     char *dst;
 868     int len = WideCharToMultiByte( CP_UTF8, 0, src, -1, NULL, 0, NULL, NULL );
 869     if ((dst = malloc( len ))) WideCharToMultiByte( CP_UTF8, 0, src, -1, dst, len, NULL, NULL );
 870     return dst;
 871 }
 872
 873 static char *map_win32_device_name( const char *dev )
 874 {
 875     IP_ADAPTER_ADDRESSES *ptr, *adapters = get_adapters();
 876     const char *name = strchr( dev, '{' );
 877     char *ret = NULL;
 878
 879     if (!adapters || !name) return NULL;
 880     for (ptr = adapters; ptr; ptr = ptr->Next)
 881     {
 882         if (!strcmp( name, ptr->AdapterName ))
 883         {
 884             ret = strdup_to_utf8( ptr->FriendlyName );
 885             break;
 886         }
 887     }
 888     free( adapters );
 889     return ret;
 890 }
 891
 892 int CDECL pcap_lookupnet( const char *device, unsigned int *net, unsigned int *mask, char *errbuf )
 893 {
 894     struct lookupnet_params params;
 895     int ret;
 896
 897     TRACE( "%s, %p, %p, %p\n", debugstr_a(device), net, mask, errbuf );
 898
 899     if (!(params.device = map_win32_device_name( device )))
 900     {
 901         if (errbuf) sprintf( errbuf, "Unable to open the adapter." );
 902         return PCAP_ERROR;
 903     }
 904     params.net    = net;
 905     params.mask   = mask;
 906     params.errbuf = errbuf;
 907     ret = PCAP_CALL( lookupnet, &params );
 908     free( params.device );
 909     return ret;
 910 }
 911
 912 int CDECL pcap_major_version( struct pcap *pcap )
 913 {
 914     struct major_version_params params;
 915
 916     TRACE( "%p\n", pcap );
 917
 918     if (!pcap) return PCAP_ERROR;
 919     params.handle = pcap->handle;
 920     return PCAP_CALL( major_version, &params );
 921 }
 922
 923 int CDECL pcap_minor_version( struct pcap *pcap )
 924 {
 925     struct minor_version_params params;
 926
 927     TRACE( "%p\n", pcap );
 928
 929     if (!pcap) return PCAP_ERROR;
 930     params.handle = pcap->handle;
 931     return PCAP_CALL( minor_version, &params );
 932 }
 933
 934 int CDECL pcap_next_ex( struct pcap *pcap, struct pcap_pkthdr_win32 **hdr, const unsigned char **data )
 935 {
 936     struct next_ex_params params;
 937     int ret;
 938
 939     TRACE( "%p, %p, %p\n", pcap, hdr, data );
 940
 941     if (!pcap) return PCAP_ERROR;
 942     params.handle = pcap->handle;
 943     params.hdr    = &pcap->hdr;
 944     params.data   = data;
 945     if ((ret = PCAP_CALL( next_ex, &params )) == 1) *hdr = &pcap->hdr;
 946     return ret;
 947 }
 948
 949 const unsigned char * CDECL pcap_next( struct pcap *pcap, struct pcap_pkthdr_win32 *hdr )
 950 {
 951     struct pcap_pkthdr_win32 *hdr_ptr;
 952     const unsigned char *data;
 953
 954     if (pcap_next_ex( pcap, &hdr_ptr, &data ) == 1)
 955     {
 956         *hdr = *hdr_ptr;
 957         return data;
 958     }
 959     return NULL;
 960 }
 961
 962 int CDECL pcap_dispatch( struct pcap *pcap, int count,
 963                          void (CALLBACK *callback)(unsigned char *, const struct pcap_pkthdr_win32 *, const unsigned char *),
 964                          unsigned char *user )
 965 {
 966     int processed = 0;
 967
 968     TRACE( "%p, %d, %p, %p\n", pcap, count, callback, user );
 969
 970     while (processed < count)
 971     {
 972         struct pcap_pkthdr_win32 *hdr = NULL;
 973         const unsigned char *data = NULL;
 974
 975         int ret = pcap_next_ex( pcap, &hdr, &data );
 976
 977         if (ret == 1)
 978             processed++;
 979         else if (ret == 0)
 980             break;
 981         else if (ret == PCAP_ERROR_BREAK)
 982         {
 983             if (processed == 0) return PCAP_ERROR_BREAK;
 984             break;
 985         }
 986         else
 987             return ret;
 988
 989         callback( user, hdr, data );
 990     }
 991
 992     return processed;
 993 }
 994
 995 int CDECL pcap_loop( struct pcap *pcap, int count,
 996                      void (CALLBACK *callback)(unsigned char *, const struct pcap_pkthdr_win32 *, const unsigned char *),
 997                      unsigned char *user)
 998 {
 999     int processed = 0;
1000
1001     TRACE( "%p, %d, %p, %p\n", pcap, count, callback, user );
1002
1003     while (processed < count)
1004     {
1005         struct pcap_pkthdr_win32 *hdr = NULL;
1006         const unsigned char *data = NULL;
1007
1008         int ret = pcap_next_ex( pcap, &hdr, &data );
1009
1010         if (ret == 1)
1011             processed++;
1012         else if (ret == 0)
1013             continue;
1014         else if (ret == PCAP_ERROR_BREAK)
1015         {
1016             if (processed == 0) return PCAP_ERROR_BREAK;
1017             break;
1018         }
1019         else
1020             return ret;
1021
1022         callback( user, hdr, data );
1023     }
1024
1025     return processed;
1026 }
1027
1028 struct pcap * CDECL pcap_create( const char *source, char *errbuf )
1029 {
1030     struct pcap *ret;
1031     struct create_params params;
1032
1033     TRACE( "%s, %p\n", source, errbuf );
1034
1035     if (!(ret = calloc( 1, sizeof(*ret) ))) return NULL;
1036
1037     if (!(params.source = map_win32_device_name( source )))
1038     {
1039         if (errbuf) sprintf( errbuf, "Unable to open the adapter." );
1040         free( ret );
1041         return NULL;
1042     }
1043     params.errbuf = errbuf;
1044     params.handle = &ret->handle;
1045     if (PCAP_CALL( create, &params ))
1046     {
1047         free( ret );
1048         ret = NULL;
1049     }
1050     free( params.source );
1051     return ret;
1052 }
1053
1054 static struct pcap *open_live( const char *source, int snaplen, int promisc, int timeout, char *errbuf )
1055 {
1056     struct pcap *ret;
1057     struct open_live_params params;
1058
1059     if (!(ret = calloc( 1, sizeof(*ret) ))) return NULL;
1060
1061     if (!(params.source = map_win32_device_name( source )))
1062     {
1063         if (errbuf) sprintf( errbuf, "Unable to open the adapter." );
1064         free( ret );
1065         return NULL;
1066     }
1067     params.snaplen = snaplen;
1068     params.promisc = promisc;
1069     params.timeout = timeout;
1070     params.errbuf  = errbuf;
1071     params.handle  = &ret->handle;
1072     if (PCAP_CALL( open_live, &params ))
1073     {
1074         free( ret );
1075         ret = NULL;
1076     }
1077     free( params.source );
1078     return ret;
1079 }
1080
1081 #define PCAP_OPENFLAG_PROMISCUOUS 1
1082 struct pcap * CDECL pcap_open( const char *source, int snaplen, int flags, int timeout, void *auth, char *errbuf )
1083 {
1084     FIXME( "%s, %d, %d, %d, %p, %p: partial stub\n", debugstr_a(source), snaplen, flags, timeout, auth, errbuf );
1085     return open_live( source, snaplen, flags & PCAP_OPENFLAG_PROMISCUOUS, timeout, errbuf );
1086 }
1087
1088 struct pcap * CDECL pcap_open_live( const char *source, int snaplen, int promisc, int to_ms, char *errbuf )
1089 {
1090     TRACE( "%s, %d, %d, %d, %p\n", debugstr_a(source), snaplen, promisc, to_ms, errbuf );
1091     return open_live( source, snaplen, promisc, to_ms, errbuf );
1092 }
1093
1094 #define PCAP_SRC_FILE    2
1095 #define PCAP_SRC_IFLOCAL 3
1096
1097 int CDECL pcap_parsesrcstr( const char *source, int *ret_type, char *host, char *port, char *name, char *errbuf )
1098 {
1099     int type = PCAP_SRC_IFLOCAL;
1100     const char *ptr = source;
1101
1102     FIXME( "%s, %p, %p, %p, %p, %p: partial stub\n", debugstr_a(source), ret_type, host, port, name, errbuf );
1103
1104     if (host) *host = 0;
1105     if (port) *port = 0;
1106     if (name) *name = 0;
1107
1108     if (!strncmp( ptr, "rpcap://", strlen("rpcap://"))) ptr += strlen( "rpcap://" );
1109     else if (!strncmp( ptr, "file://", strlen("file://") ))
1110     {
1111         ptr += strlen( "file://" );
1112         type = PCAP_SRC_FILE;
1113     }
1114
1115     if (ret_type) *ret_type = type;
1116     if (!*ptr)
1117     {
1118         if (errbuf) sprintf( errbuf, "The name has not been specified in the source string." );
1119         return PCAP_ERROR;
1120     }
1121
1122     if (name) strcpy( name, ptr );
1123     return 0;
1124 }
1125
1126 int CDECL pcap_sendpacket( struct pcap *pcap, const unsigned char *buf, int size )
1127 {
1128     struct sendpacket_params params;
1129
1130     TRACE( "%p, %p, %d\n", pcap, buf, size );
1131
1132     if (!pcap) return PCAP_ERROR;
1133     params.handle = pcap->handle;
1134     params.buf    = buf;
1135     params.size   = size;
1136     return PCAP_CALL( sendpacket, &params );
1137 }
1138
1139 int CDECL pcap_set_buffer_size( struct pcap *pcap, int size )
1140 {
1141     struct set_buffer_size_params params;
1142
1143     TRACE( "%p, %d\n", pcap, size );
1144
1145     if (!pcap) return PCAP_ERROR;
1146     params.handle = pcap->handle;
1147     params.size   = size;
1148     return PCAP_CALL( set_buffer_size, &params );
1149 }
1150
1151 int CDECL pcap_set_datalink( struct pcap *pcap, int link )
1152 {
1153     struct set_datalink_params params;
1154
1155     TRACE( "%p, %d\n", pcap, link );
1156
1157     if (!pcap) return PCAP_ERROR;
1158     params.handle = pcap->handle;
1159     params.link   = link;
1160     return PCAP_CALL( set_datalink, &params );
1161 }
1162
1163 int CDECL pcap_set_promisc( struct pcap *pcap, int enable )
1164 {
1165     struct set_promisc_params params;
1166
1167     TRACE( "%p, %d\n", pcap, enable );
1168
1169     if (!pcap) return PCAP_ERROR;
1170     params.handle = pcap->handle;
1171     params.enable = enable;
1172     return PCAP_CALL( set_promisc, &params );
1173 }
1174
1175 int CDECL pcap_set_rfmon( struct pcap *pcap, int enable )
1176 {
1177     struct set_rfmon_params params;
1178
1179     TRACE( "%p, %d\n", pcap, enable );
1180
1181     if (!pcap) return PCAP_ERROR;
1182     params.handle = pcap->handle;
1183     params.enable = enable;
1184     return PCAP_CALL( set_rfmon, &params );
1185 }
1186
1187 int CDECL pcap_set_snaplen( struct pcap *pcap, int len )
1188 {
1189     struct set_snaplen_params params;
1190
1191     TRACE( "%p, %d\n", pcap, len );
1192
1193     if (!pcap) return PCAP_ERROR;
1194     params.handle = pcap->handle;
1195     params.len    = len;
1196     return PCAP_CALL( set_snaplen, &params );
1197 }
1198
1199 int CDECL pcap_set_timeout( struct pcap *pcap, int timeout )
1200 {
1201     struct set_timeout_params params;
1202
1203     TRACE( "%p, %d\n", pcap, timeout );
1204
1205     if (!pcap) return PCAP_ERROR;
1206     params.handle  = pcap->handle;
1207     params.timeout = timeout;
1208     return PCAP_CALL( set_timeout, &params );
1209 }
1210
1211 int CDECL pcap_set_tstamp_precision( struct pcap *pcap, int precision )
1212 {
1213     struct set_tstamp_precision_params params;
1214
1215     TRACE( "%p, %d\n", pcap, precision );
1216
1217     if (!pcap) return PCAP_ERROR;
1218     params.handle    = pcap->handle;
1219     params.precision = precision;
1220     return PCAP_CALL( set_tstamp_precision, &params );
1221 }
1222
1223 int CDECL pcap_set_tstamp_type( struct pcap *pcap, int type )
1224 {
1225     struct set_tstamp_type_params params;
1226
1227     TRACE( "%p, %d\n", pcap, type );
1228
1229     if (!pcap) return PCAP_ERROR;
1230     params.handle = pcap->handle;
1231     params.type   = type;
1232     return PCAP_CALL( set_tstamp_type, &params );
1233 }
1234
1235 int CDECL pcap_setbuff( struct pcap *pcap, int size )
1236 {
1237     FIXME( "%p, %d\n", pcap, size );
1238     return 0;
1239 }
1240
1241 int CDECL pcap_setfilter( struct pcap *pcap, struct bpf_program *program )
1242 {
1243     struct setfilter_params params;
1244
1245     TRACE( "%p, %p\n", pcap, program );
1246
1247     if (!pcap) return PCAP_ERROR;
1248     params.handle        = pcap->handle;
1249     params.program_len   = program->bf_len;
1250     params.program_insns = program->bf_insns;
1251     return PCAP_CALL( setfilter, &params );
1252 }
1253
1254 int CDECL pcap_setnonblock( struct pcap *pcap, int nonblock, char *errbuf )
1255 {
1256     struct setnonblock_params params;
1257
1258     TRACE( "%p, %d, %p\n", pcap, nonblock, errbuf );
1259
1260     if (!pcap) return PCAP_ERROR;
1261     params.handle   = pcap->handle;
1262     params.nonblock = nonblock;
1263     params.errbuf   = errbuf;
1264     return PCAP_CALL( setnonblock, &params );
1265 }
1266
1267 int CDECL pcap_snapshot( struct pcap *pcap )
1268 {
1269     struct snapshot_params params;
1270
1271     TRACE( "%p\n", pcap );
1272
1273     if (!pcap) return PCAP_ERROR;
1274     params.handle = pcap->handle;
1275     return PCAP_CALL( snapshot, &params );
1276 }
1277
1278 int CDECL pcap_stats( struct pcap *pcap, struct pcap_stat_win32 *stat )
1279 {
1280     struct stats_params params;
1281     int ret;
1282
1283     TRACE( "%p, %p\n", pcap, stat );
1284
1285     if (!pcap) return PCAP_ERROR;
1286     params.handle = pcap->handle;
1287     if (!(ret = PCAP_CALL( stats, &params ))) *stat = params.stat;
1288     return ret;
1289 }
1290
1291 const char * CDECL pcap_statustostr( int status )
1292 {
1293     static char errbuf[32];
1294
1295     TRACE( "%d\n", status );
1296
1297     switch (status)
1298     {
1299     case PCAP_WARNING:
1300         return "Generic warning";
1301     case PCAP_WARNING_TSTAMP_TYPE_NOTSUP:
1302         return "That type of time stamp is not supported by that device";
1303     case PCAP_WARNING_PROMISC_NOTSUP:
1304         return "That device doesn't support promiscuous mode";
1305     case PCAP_ERROR:
1306         return "Generic error";
1307     case PCAP_ERROR_BREAK:
1308         return "Loop terminated by pcap_breakloop";
1309     case PCAP_ERROR_NOT_ACTIVATED:
1310         return "The pcap_t has not been activated";
1311     case PCAP_ERROR_ACTIVATED:
1312         return "The setting can't be changed after the pcap_t is activated";
1313     case PCAP_ERROR_NO_SUCH_DEVICE:
1314         return "No such device exists";
1315     default:
1316         sprintf( errbuf, "Unknown error: %d", status );
1317         return errbuf;
1318     }
1319 }
1320
1321 int CDECL pcap_tstamp_type_name_to_val( const char *name )
1322 {
1323     struct tstamp_type_name_to_val_params params = { name };
1324     TRACE( "%s\n", debugstr_a(name) );
1325     return PCAP_CALL( tstamp_type_name_to_val, &params );
1326 }
1327
1328 static struct
1329 {
1330     char *name;
1331     char *description;
1332 } tstamp_types[16];
1333
1334 static void free_tstamp_types( void )
1335 {
1336     unsigned int i;
1337     for (i = 0; i < ARRAY_SIZE(tstamp_types); i++)
1338     {
1339         free( tstamp_types[i].name );
1340         tstamp_types[i].name = NULL;
1341         free( tstamp_types[i].description );
1342         tstamp_types[i].description = NULL;
1343     }
1344 }
1345
1346 const char * CDECL pcap_tstamp_type_val_to_description( int type )
1347 {
1348     struct tstamp_type_val_to_description_params params;
1349     unsigned int len = 64;
1350     char *tmp;
1351     NTSTATUS status;
1352
1353     TRACE( "%d\n", type );
1354
1355     if (type < 0 || type >= ARRAY_SIZE(tstamp_types))
1356     {
1357         WARN( "unhandled tstamp type %d\n", type );
1358         return NULL;
1359     }
1360     if (tstamp_types[type].description) return tstamp_types[type].description;
1361
1362     if (!(params.buf = malloc( len ))) return NULL;
1363     params.type   = type;
1364     params.buflen = &len;
1365     status = PCAP_CALL( tstamp_type_val_to_description, &params );
1366     if (status == STATUS_SUCCESS) return (tstamp_types[type].description = params.buf);
1367     if (status != STATUS_BUFFER_TOO_SMALL || !(tmp = realloc( params.buf, len )))
1368     {
1369         free( params.buf );
1370         return NULL;
1371     }
1372     params.buf = tmp;
1373     if (PCAP_CALL( tstamp_type_val_to_description, &params ))
1374     {
1375         free( params.buf );
1376         return NULL;
1377     }
1378
1379     return (tstamp_types[type].description = params.buf);
1380 }
1381
1382 const char * CDECL pcap_tstamp_type_val_to_name( int type )
1383 {
1384     struct tstamp_type_val_to_name_params params;
1385     unsigned int len = 32;
1386     char *tmp;
1387     NTSTATUS status;
1388
1389     TRACE( "%d\n", type );
1390
1391     if (type < 0 || type >= ARRAY_SIZE(tstamp_types))
1392     {
1393         WARN( "unhandled tstamp type %d\n", type );
1394         return NULL;
1395     }
1396     if (tstamp_types[type].name) return tstamp_types[type].name;
1397
1398     if (!(params.buf = malloc( len ))) return NULL;
1399     params.type   = type;
1400     params.buflen = &len;
1401     status = PCAP_CALL( tstamp_type_val_to_name, &params );
1402     if (status == STATUS_SUCCESS) return (tstamp_types[type].name = params.buf);
1403     if (status != STATUS_BUFFER_TOO_SMALL || !(tmp = realloc( params.buf, len )))
1404     {
1405         free( params.buf );
1406         return NULL;
1407     }
1408     params.buf = tmp;
1409     if (PCAP_CALL( tstamp_type_val_to_name, &params ))
1410     {
1411         free( params.buf );
1412         return NULL;
1413     }
1414
1415     return (tstamp_types[type].name = params.buf);
1416 }
1417
1418 int CDECL pcap_wsockinit( void )
1419 {
1420     WSADATA wsadata;
1421     TRACE( "\n" );
1422     if (WSAStartup( MAKEWORD(1, 1), &wsadata )) return PCAP_ERROR;
1423     return 0;
1424 }
1425
1426 #define PCAP_CHAR_ENC_LOCAL 0
1427 #define PCAP_CHAR_ENC_UTF_8 1
1428 #define PCAP_MMAP_32BIT     2
1429
1430 int CDECL pcap_init( unsigned int opt, char *errbuf )
1431 {
1432     struct init_params params;
1433
1434     TRACE( "%u, %p\n", opt, errbuf );
1435     if (opt == PCAP_CHAR_ENC_LOCAL) FIXME( "need to convert to/from local encoding\n" );
1436
1437     params.opt    = opt;
1438     params.errbuf = errbuf;
1439     return PCAP_CALL( init, &params );
1440 }
1441
1442 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, void *reserved )
1443 {
1444     switch (reason)
1445     {
1446     case DLL_PROCESS_ATTACH:
1447     {
1448         DisableThreadLibraryCalls( hinst );
1449         if (__wine_init_unix_call()) ERR( "No pcap support, expect problems\n" );
1450         else
1451         {
1452             char errbuf[PCAP_ERRBUF_SIZE];
1453             struct init_params params = { PCAP_CHAR_ENC_UTF_8, errbuf };
1454             BOOL is_wow64;
1455
1456             if (PCAP_CALL( init, &params ) == PCAP_ERROR)
1457                 WARN( "failed to enable UTF-8 encoding %s\n", debugstr_a(errbuf) );
1458             if (IsWow64Process( GetCurrentProcess(), &is_wow64 ) && is_wow64)
1459             {
1460                 params.opt = PCAP_MMAP_32BIT;
1461                 if (PCAP_CALL( init, &params ) == PCAP_ERROR)
1462                     WARN( "failed to enable 32-bit mmap() %s\n", debugstr_a(errbuf) );
1463             }
1464         }
1465         break;
1466     }
1467     case DLL_PROCESS_DETACH:
1468         if (reserved) break;
1469         free_datalinks();
1470         free_tstamp_types();
1471         break;
1472     }
1473     return TRUE;
1474 }