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     ULONG err, size = 4096;
 395     IP_ADAPTER_ADDRESSES *tmp, *ret;
 396     ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
 397
 398     if (!(ret = malloc( size ))) return NULL;
 399     err = GetAdaptersAddresses( AF_UNSPEC, flags, NULL, ret, &size );
 400     while (err == ERROR_BUFFER_OVERFLOW)
 401     {
 402         if (!(tmp = realloc( ret, size ))) break;
 403         ret = tmp;
 404         err = GetAdaptersAddresses( AF_UNSPEC, flags, NULL, ret, &size );
 405     }
 406     if (err == ERROR_SUCCESS) return ret;
 407     free( ret );
 408     return NULL;
 409 }
 410
 411 static IP_ADAPTER_ADDRESSES *find_adapter( IP_ADAPTER_ADDRESSES *list, const char *name )
 412 {
 413     IP_ADAPTER_ADDRESSES *ret;
 414     WCHAR *nameW;
 415
 416     if (!(nameW = strdup_from_utf8( name ))) return NULL;
 417     for (ret = list; ret; ret = ret->Next)
 418     {
 419         if (!wcscmp( nameW, ret->FriendlyName )) break;
 420     }
 421     free( nameW);
 422     return ret;
 423 }
 424
 425 static char *build_win32_name( const char *source, const char *adapter_name )
 426 {
 427     const char prefix[] = "\\Device\\NPF_";
 428     int len = sizeof(prefix) + strlen(adapter_name);
 429     char *ret;
 430
 431     if (source) len += strlen( source );
 432     if ((ret = malloc( len )))
 433     {
 434         ret[0] = 0;
 435         if (source) strcat( ret, source );
 436         strcat( ret, prefix );
 437         strcat( ret, adapter_name );
 438     }
 439     return ret;
 440 }
 441
 442 static char *build_win32_description( const struct pcap_interface_offsets *unix_dev )
 443 {
 444     const char *name = (const char *)unix_dev + unix_dev->name_offset;
 445     const char *description = (const char *)unix_dev + unix_dev->description_offset;
 446     int len = unix_dev->name_len + unix_dev->description_len + 1;
 447     char *ret;
 448
 449     if ((ret = malloc( len )))
 450     {
 451         if (unix_dev->description_len)
 452         {
 453             strcpy( ret, description );
 454             strcat( ret, " " );
 455             strcat( ret, name );
 456         }
 457         else strcpy( ret, name );
 458     }
 459     return ret;
 460 }
 461
 462 static struct sockaddr *get_address( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 463 {
 464     struct sockaddr *ret;
 465     if (!(ret = malloc( addr->Address.iSockaddrLength ))) return NULL;
 466     memcpy( ret, addr->Address.lpSockaddr, addr->Address.iSockaddrLength );
 467     return ret;
 468 }
 469
 470 static void convert_length_to_ipv6_mask( ULONG length, IN6_ADDR *mask )
 471 {
 472     unsigned int i;
 473     for (i = 0; i < length / 8 - 1; i++) mask->u.Byte[i] = 0xff;
 474     mask->u.Byte[i] = 0xff << (8 - length % 8);
 475 }
 476
 477 static struct sockaddr *get_netmask( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 478 {
 479     struct sockaddr *ret;
 480
 481     switch (addr->Address.lpSockaddr->sa_family)
 482     {
 483     case AF_INET:
 484     {
 485         struct sockaddr_in *netmask_addr_in;
 486
 487         if (!(netmask_addr_in = calloc( 1, sizeof(*netmask_addr_in) ))) return NULL;
 488         netmask_addr_in->sin_family = AF_INET;
 489         ConvertLengthToIpv4Mask( addr->OnLinkPrefixLength, &netmask_addr_in->sin_addr.S_un.S_addr );
 490         ret = (struct sockaddr *)netmask_addr_in;
 491         break;
 492     }
 493     case AF_INET6:
 494     {
 495         struct sockaddr_in6 *netmask_addr_in6;
 496
 497         if (!(netmask_addr_in6 = calloc( 1, sizeof(*netmask_addr_in6) ))) return NULL;
 498         netmask_addr_in6->sin6_family = AF_INET6;
 499         convert_length_to_ipv6_mask( addr->OnLinkPrefixLength, &netmask_addr_in6->sin6_addr );
 500         ret = (struct sockaddr *)netmask_addr_in6;
 501         break;
 502     }
 503     default:
 504         FIXME( "address family %u not supported\n", addr->Address.lpSockaddr->sa_family );
 505         return NULL;
 506     }
 507
 508     return ret;
 509 }
 510
 511 static struct sockaddr *get_broadcast( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 512 {
 513     struct sockaddr *ret;
 514
 515     switch (addr->Address.lpSockaddr->sa_family)
 516     {
 517     case AF_INET:
 518     {
 519         struct sockaddr_in *broadcast_addr_in, *addr_in = (struct sockaddr_in *)addr->Address.lpSockaddr;
 520         ULONG netmask;
 521
 522         if (!(broadcast_addr_in = calloc( 1, sizeof(*broadcast_addr_in) ))) return NULL;
 523         broadcast_addr_in->sin_family = AF_INET;
 524         ConvertLengthToIpv4Mask( addr->OnLinkPrefixLength, &netmask );
 525         broadcast_addr_in->sin_addr.S_un.S_addr = addr_in->sin_addr.S_un.S_addr | ~netmask;
 526         ret = (struct sockaddr *)broadcast_addr_in;
 527         break;
 528     }
 529     case AF_INET6:
 530     {
 531         struct sockaddr_in6 *broadcast_addr_in6, *addr_in6 = (struct sockaddr_in6 *)addr->Address.lpSockaddr;
 532         IN6_ADDR netmask, *address = (IN6_ADDR *)&addr_in6->sin6_addr;
 533         unsigned int i;
 534
 535         if (!(broadcast_addr_in6 = calloc( 1, sizeof(*broadcast_addr_in6) ))) return NULL;
 536         broadcast_addr_in6->sin6_family = AF_INET6;
 537         convert_length_to_ipv6_mask( addr->OnLinkPrefixLength, &netmask );
 538         for (i = 0; i < 8; i++) broadcast_addr_in6->sin6_addr.u.Word[i] = address->u.Word[i] | ~netmask.u.Word[i];
 539         ret = (struct sockaddr *)broadcast_addr_in6;
 540         break;
 541     }
 542     default:
 543         FIXME( "address family %u not supported\n", addr->Address.lpSockaddr->sa_family );
 544         return NULL;
 545     }
 546
 547     return ret;
 548 }
 549
 550 static struct pcap_address *build_win32_address( const IP_ADAPTER_UNICAST_ADDRESS *addr )
 551 {
 552     struct pcap_address *ret;
 553
 554     if (!(ret = calloc( 1, sizeof(*ret) ))) return NULL;
 555     if (!(ret->addr = get_address( addr ))) goto err;
 556     if (!(ret->netmask = get_netmask( addr ))) goto err;
 557     if (!(ret->broadaddr = get_broadcast( addr ))) goto err;
 558     return ret;
 559
 560 err:
 561     free( ret->addr );
 562     free( ret->netmask );
 563     free( ret->broadaddr );
 564     free( ret );
 565     return NULL;
 566 }
 567
 568 static void add_win32_address( struct pcap_address **list, struct pcap_address *addr )
 569 {
 570     struct pcap_address *cur = *list;
 571     if (!cur) *list = addr;
 572     else
 573     {
 574         while (cur->next) { cur = cur->next; }
 575         cur->next = addr;
 576     }
 577 }
 578
 579 static struct pcap_address *build_win32_addresses( const IP_ADAPTER_ADDRESSES *adapter )
 580 {
 581     struct pcap_address *dst, *ret = NULL;
 582     IP_ADAPTER_UNICAST_ADDRESS *src = adapter->FirstUnicastAddress;
 583     while (src)
 584     {
 585         if ((dst = build_win32_address( src ))) add_win32_address( &ret, dst );
 586         src = src->Next;
 587     }
 588     return ret;
 589 }
 590
 591 static struct pcap_interface *build_win32_device( const struct pcap_interface_offsets *unix_dev, const char *source,
 592                                                   const IP_ADAPTER_ADDRESSES *adapter )
 593 {
 594     struct pcap_interface *ret;
 595
 596     if (!(ret = calloc( 1, sizeof(*ret) ))) return NULL;
 597     if (!(ret->name = build_win32_name( source, adapter->AdapterName ))) goto err;
 598     if (!(ret->description = build_win32_description( unix_dev ))) goto err;
 599     ret->addresses = build_win32_addresses( adapter );
 600     ret->flags = unix_dev->flags;
 601     return ret;
 602
 603 err:
 604     free( ret->name );
 605     free( ret->description );
 606     free_addresses( ret->addresses );
 607     free( ret );
 608     return NULL;
 609 }
 610
 611 static void add_win32_device( struct pcap_interface **list, struct pcap_interface *dev )
 612 {
 613     struct pcap_interface *cur = *list;
 614     if (!cur) *list = dev;
 615     else
 616     {
 617         while (cur->next) { cur = cur->next; }
 618         cur->next = dev;
 619     }
 620 }
 621
 622 static int find_all_devices( const char *source, struct pcap_interface **devs, char *errbuf )
 623 {
 624     struct pcap_interface *win32_devs = NULL, *dst;
 625     const struct pcap_interface_offsets *src;
 626     IP_ADAPTER_ADDRESSES *ptr, *adapters;
 627     struct findalldevs_params params;
 628     unsigned int len_total = 0, len = 512;
 629     int ret;
 630
 631     if (!(params.buf = malloc( len ))) return PCAP_ERROR;
 632     params.buflen = &len;
 633     params.errbuf = errbuf;
 634     for (;;)
 635     {
 636         char *tmp;
 637         if ((ret = PCAP_CALL( findalldevs, &params )) != STATUS_BUFFER_TOO_SMALL) break;
 638         if (!(tmp = realloc( params.buf, *params.buflen )))
 639         {
 640             free( params.buf );
 641             return PCAP_ERROR;
 642         }
 643         params.buf = tmp;
 644     }
 645     if (ret)
 646     {
 647         free( params.buf );
 648         return ret;
 649     }
 650
 651     if (!(adapters = get_adapters()))
 652     {
 653         free( params.buf );
 654         return PCAP_ERROR;
 655     }
 656
 657     src = (const struct pcap_interface_offsets *)params.buf;
 658     for (;;)
 659     {
 660         const char *name = (const char *)src + src->name_offset;
 661         unsigned int len_src = sizeof(*src) + src->name_len + src->description_len;
 662
 663         if ((ptr = find_adapter( adapters, name )) && (dst = build_win32_device( src, source, ptr )))
 664         {
 665             add_win32_device( &win32_devs, dst );
 666         }
 667
 668         len_total += len_src;
 669         if (len_total >= *params.buflen) break;
 670         src = (const struct pcap_interface_offsets *)((const char *)src + len_src);
 671     }
 672     *devs = win32_devs;
 673
 674     free( adapters );
 675     free( params.buf );
 676     return ret;
 677 }
 678
 679 int CDECL pcap_findalldevs( struct pcap_interface **devs, char *errbuf )
 680 {
 681     TRACE( "%p, %p\n", devs, errbuf );
 682     return find_all_devices( NULL, devs, errbuf );
 683 }
 684
 685 int CDECL pcap_findalldevs_ex( char *source, void *auth, struct pcap_interface **devs, char *errbuf )
 686 {
 687     FIXME( "%s, %p, %p, %p: partial stub\n", debugstr_a(source), auth, devs, errbuf );
 688     return find_all_devices( source, devs, errbuf );
 689 }
 690
 691 void CDECL pcap_free_datalinks( int *links )
 692 {
 693     TRACE( "%p\n", links );
 694     free( links );
 695 }
 696
 697 void CDECL pcap_free_tstamp_types( int *types )
 698 {
 699     TRACE( "%p\n", types );
 700     free( types );
 701 }
 702
 703 void CDECL pcap_freealldevs( struct pcap_interface *devs )
 704 {
 705     TRACE( "%p\n", devs );
 706     free_devices( devs );
 707 }
 708
 709 void CDECL pcap_freecode( struct bpf_program *program )
 710 {
 711     TRACE( "%p\n", program );
 712
 713     if (!program) return;
 714     free( program->bf_insns );
 715 }
 716
 717 void * CDECL pcap_get_airpcap_handle( struct pcap *pcap )
 718 {
 719     TRACE( "%p\n", pcap );
 720     return NULL;
 721 }
 722
 723 int CDECL pcap_get_tstamp_precision( struct pcap *pcap )
 724 {
 725     struct get_tstamp_precision_params params;
 726
 727     TRACE( "%p\n", pcap );
 728
 729     if (!pcap) return PCAP_ERROR;
 730     params.handle = pcap->handle;
 731     return PCAP_CALL( get_tstamp_precision, &params );
 732 }
 733
 734 char * CDECL pcap_geterr( struct pcap *pcap )
 735 {
 736     struct geterr_params params;
 737
 738     TRACE( "%p\n", pcap );
 739
 740     if (!pcap) return NULL;
 741     params.handle = pcap->handle;
 742     params.errbuf = pcap->errbuf;
 743     PCAP_CALL( geterr, &params );
 744     return pcap->errbuf; /* FIXME: keep up-to-date */
 745 }
 746
 747 int CDECL pcap_getnonblock( struct pcap *pcap, char *errbuf )
 748 {
 749     struct getnonblock_params params;
 750
 751     TRACE( "%p, %p\n", pcap, errbuf );
 752
 753     if (!pcap) return PCAP_ERROR;
 754     params.handle = pcap->handle;
 755     params.errbuf = errbuf;
 756     return PCAP_CALL( getnonblock, &params );
 757 }
 758
 759 static char lib_version[256];
 760 static BOOL WINAPI init_lib_version( INIT_ONCE *once, void *param, void **ctx )
 761 {
 762     struct lib_version_params params = { lib_version, sizeof(lib_version) };
 763     PCAP_CALL( lib_version, &params );
 764     return TRUE;
 765 }
 766
 767 const char * CDECL pcap_lib_version( void )
 768 {
 769     static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
 770     if (!lib_version[0]) InitOnceExecuteOnce( &once, init_lib_version, NULL, NULL );
 771     TRACE( "%s\n", debugstr_a(lib_version) );
 772     return lib_version;
 773 }
 774
 775 int CDECL pcap_list_datalinks( struct pcap *pcap, int **links )
 776 {
 777     struct list_datalinks_params params;
 778     int count = 8, *tmp;
 779     NTSTATUS status;
 780
 781     TRACE( "%p, %p\n", pcap, links );
 782
 783     if (!pcap || !links) return PCAP_ERROR;
 784
 785     if (!(params.links = malloc( count * sizeof(*params.links) ))) return PCAP_ERROR;
 786     params.handle = pcap->handle;
 787     params.count  = &count;
 788     if ((status = PCAP_CALL( list_datalinks, &params )) == STATUS_SUCCESS)
 789     {
 790         if (count > 0) *links = params.links;
 791         else
 792         {
 793             free( params.links );
 794             *links = NULL;
 795         }
 796         return count;
 797     }
 798     if (status != STATUS_BUFFER_TOO_SMALL || !(tmp = realloc( params.links, count * sizeof(*tmp) )))
 799     {
 800         free( params.links );
 801         return PCAP_ERROR;
 802     }
 803     params.links = tmp;
 804     if (PCAP_CALL( list_datalinks, &params ))
 805     {
 806         free( params.links );
 807         return PCAP_ERROR;
 808     }
 809     *links = params.links;
 810     return count;
 811 }
 812
 813 int CDECL pcap_list_tstamp_types( struct pcap *pcap, int **types )
 814 {
 815     struct list_tstamp_types_params params;
 816     int count = 8, *tmp;
 817     NTSTATUS status;
 818
 819     TRACE( "%p, %p\n", pcap, types );
 820
 821     TRACE( "%p, %p\n", pcap, types );
 822
 823     if (!pcap || !types) return PCAP_ERROR;
 824
 825     if (!(params.types = malloc( count * sizeof(*params.types) ))) return PCAP_ERROR;
 826     params.handle = pcap->handle;
 827     params.count  = &count;
 828     if ((status = PCAP_CALL( list_tstamp_types, &params )) == STATUS_SUCCESS)
 829     {
 830         if (count > 0) *types = params.types;
 831         else
 832         {
 833             free( params.types );
 834             *types = NULL;
 835         }
 836         return count;
 837     }
 838     if (status != STATUS_BUFFER_TOO_SMALL || !(tmp = realloc( params.types, count * sizeof(*tmp) )))
 839     {
 840         free( params.types );
 841         return PCAP_ERROR;
 842     }
 843     params.types = tmp;
 844     if (PCAP_CALL( list_tstamp_types, &params ))
 845     {
 846         free( params.types );
 847         return PCAP_ERROR;
 848     }
 849     *types = params.types;
 850     return count;
 851 }
 852
 853 char * CDECL pcap_lookupdev( char *errbuf )
 854 {
 855     static char *ret;
 856     struct pcap_interface *devs;
 857
 858     TRACE( "%p\n", errbuf );
 859     if (!ret)
 860     {
 861         if (pcap_findalldevs( &devs, errbuf ) == PCAP_ERROR || !devs) return NULL;
 862         ret = strdup( devs->name );
 863         pcap_freealldevs( devs );
 864     }
 865     return ret;
 866 }
 867
 868 static char *strdup_to_utf8( const WCHAR *src )
 869 {
 870     char *dst;
 871     int len = WideCharToMultiByte( CP_UTF8, 0, src, -1, NULL, 0, NULL, NULL );
 872     if ((dst = malloc( len ))) WideCharToMultiByte( CP_UTF8, 0, src, -1, dst, len, NULL, NULL );
 873     return dst;
 874 }
 875
 876 static char *map_win32_device_name( const char *dev )
 877 {
 878     IP_ADAPTER_ADDRESSES *ptr, *adapters = get_adapters();
 879     const char *name = strchr( dev, '{' );
 880     char *ret = NULL;
 881
 882     if (!adapters || !name) return NULL;
 883     for (ptr = adapters; ptr; ptr = ptr->Next)
 884     {
 885         if (!strcmp( name, ptr->AdapterName ))
 886         {
 887             ret = strdup_to_utf8( ptr->FriendlyName );
 888             break;
 889         }
 890     }
 891     free( adapters );
 892     return ret;
 893 }
 894
 895 int CDECL pcap_lookupnet( const char *device, unsigned int *net, unsigned int *mask, char *errbuf )
 896 {
 897     struct lookupnet_params params;
 898     int ret;
 899
 900     TRACE( "%s, %p, %p, %p\n", debugstr_a(device), net, mask, errbuf );
 901
 902     if (!(params.device = map_win32_device_name( device )))
 903     {
 904         if (errbuf) sprintf( errbuf, "Unable to open the adapter." );
 905         return PCAP_ERROR;
 906     }
 907     params.net    = net;
 908     params.mask   = mask;
 909     params.errbuf = errbuf;
 910     ret = PCAP_CALL( lookupnet, &params );
 911     free( params.device );
 912     return ret;
 913 }
 914
 915 int CDECL pcap_major_version( struct pcap *pcap )
 916 {
 917     struct major_version_params params;
 918
 919     TRACE( "%p\n", pcap );
 920
 921     if (!pcap) return PCAP_ERROR;
 922     params.handle = pcap->handle;
 923     return PCAP_CALL( major_version, &params );
 924 }
 925
 926 int CDECL pcap_minor_version( struct pcap *pcap )
 927 {
 928     struct minor_version_params params;
 929
 930     TRACE( "%p\n", pcap );
 931
 932     if (!pcap) return PCAP_ERROR;
 933     params.handle = pcap->handle;
 934     return PCAP_CALL( minor_version, &params );
 935 }
 936
 937 int CDECL pcap_next_ex( struct pcap *pcap, struct pcap_pkthdr_win32 **hdr, const unsigned char **data )
 938 {
 939     struct next_ex_params params;
 940     int ret;
 941
 942     TRACE( "%p, %p, %p\n", pcap, hdr, data );
 943
 944     if (!pcap) return PCAP_ERROR;
 945     params.handle = pcap->handle;
 946     params.hdr    = &pcap->hdr;
 947     params.data   = data;
 948     if ((ret = PCAP_CALL( next_ex, &params )) == 1) *hdr = &pcap->hdr;
 949     return ret;
 950 }
 951
 952 const unsigned char * CDECL pcap_next( struct pcap *pcap, struct pcap_pkthdr_win32 *hdr )
 953 {
 954     struct pcap_pkthdr_win32 *hdr_ptr;
 955     const unsigned char *data;
 956
 957     if (pcap_next_ex( pcap, &hdr_ptr, &data ) == 1)
 958     {
 959         *hdr = *hdr_ptr;
 960         return data;
 961     }
 962     return NULL;
 963 }
 964
 965 int CDECL pcap_dispatch( struct pcap *pcap, int count,
 966                          void (CALLBACK *callback)(unsigned char *, const struct pcap_pkthdr_win32 *, const unsigned char *),
 967                          unsigned char *user )
 968 {
 969     int processed = 0;
 970
 971     TRACE( "%p, %d, %p, %p\n", pcap, count, callback, user );
 972
 973     while (count <= 0 || processed < count)
 974     {
 975         struct pcap_pkthdr_win32 *hdr = NULL;
 976         const unsigned char *data = NULL;
 977
 978         int ret = pcap_next_ex( pcap, &hdr, &data );
 979
 980         if (ret == 1)
 981             processed++;
 982         else if (ret == 0)
 983             break;
 984         else if (ret == PCAP_ERROR_BREAK)
 985         {
 986             if (processed == 0) return PCAP_ERROR_BREAK;
 987             break;
 988         }
 989         else
 990             return ret;
 991
 992         callback( user, hdr, data );
 993     }
 994
 995     return processed;
 996 }
 997
 998 int CDECL pcap_loop( struct pcap *pcap, int count,
 999                      void (CALLBACK *callback)(unsigned char *, const struct pcap_pkthdr_win32 *, const unsigned char *),
1000                      unsigned char *user)
1001 {
1002     int processed = 0;
1003
1004     TRACE( "%p, %d, %p, %p\n", pcap, count, callback, user );
1005
1006     while (count <= 0 || processed < count)
1007     {
1008         struct pcap_pkthdr_win32 *hdr = NULL;
1009         const unsigned char *data = NULL;
1010
1011         int ret = pcap_next_ex( pcap, &hdr, &data );
1012
1013         if (ret == 1)
1014             processed++;
1015         else if (ret == 0)
1016             continue;
1017         else if (ret == PCAP_ERROR_BREAK)
1018         {
1019             if (processed == 0) return PCAP_ERROR_BREAK;
1020             break;
1021         }
1022         else
1023             return ret;
1024
1025         callback( user, hdr, data );
1026     }
1027
1028     return processed;
1029 }
1030
1031 struct pcap * CDECL pcap_create( const char *source, char *errbuf )
1032 {
1033     struct pcap *ret;
1034     struct create_params params;
1035
1036     TRACE( "%s, %p\n", source, errbuf );
1037
1038     if (!(ret = calloc( 1, sizeof(*ret) ))) return NULL;
1039
1040     if (!(params.source = map_win32_device_name( source )))
1041     {
1042         if (errbuf) sprintf( errbuf, "Unable to open the adapter." );
1043         free( ret );
1044         return NULL;
1045     }
1046     params.errbuf = errbuf;
1047     params.handle = &ret->handle;
1048     if (PCAP_CALL( create, &params ))
1049     {
1050         free( ret );
1051         ret = NULL;
1052     }
1053     free( params.source );
1054     return ret;
1055 }
1056
1057 static struct pcap *open_live( const char *source, int snaplen, int promisc, int timeout, char *errbuf )
1058 {
1059     struct pcap *ret;
1060     struct open_live_params params;
1061
1062     if (!(ret = calloc( 1, sizeof(*ret) ))) return NULL;
1063
1064     if (!(params.source = map_win32_device_name( source )))
1065     {
1066         if (errbuf) sprintf( errbuf, "Unable to open the adapter." );
1067         free( ret );
1068         return NULL;
1069     }
1070     params.snaplen = snaplen;
1071     params.promisc = promisc;
1072     params.timeout = timeout;
1073     params.errbuf  = errbuf;
1074     params.handle  = &ret->handle;
1075     if (PCAP_CALL( open_live, &params ))
1076     {
1077         free( ret );
1078         ret = NULL;
1079     }
1080     free( params.source );
1081     return ret;
1082 }
1083
1084 #define PCAP_OPENFLAG_PROMISCUOUS 1
1085 struct pcap * CDECL pcap_open( const char *source, int snaplen, int flags, int timeout, void *auth, char *errbuf )
1086 {
1087     FIXME( "%s, %d, %d, %d, %p, %p: partial stub\n", debugstr_a(source), snaplen, flags, timeout, auth, errbuf );
1088     return open_live( source, snaplen, flags & PCAP_OPENFLAG_PROMISCUOUS, timeout, errbuf );
1089 }
1090
1091 struct pcap * CDECL pcap_open_live( const char *source, int snaplen, int promisc, int to_ms, char *errbuf )
1092 {
1093     TRACE( "%s, %d, %d, %d, %p\n", debugstr_a(source), snaplen, promisc, to_ms, errbuf );
1094     return open_live( source, snaplen, promisc, to_ms, errbuf );
1095 }
1096
1097 #define PCAP_SRC_FILE    2
1098 #define PCAP_SRC_IFLOCAL 3
1099
1100 int CDECL pcap_parsesrcstr( const char *source, int *ret_type, char *host, char *port, char *name, char *errbuf )
1101 {
1102     int type = PCAP_SRC_IFLOCAL;
1103     const char *ptr = source;
1104
1105     FIXME( "%s, %p, %p, %p, %p, %p: partial stub\n", debugstr_a(source), ret_type, host, port, name, errbuf );
1106
1107     if (host) *host = 0;
1108     if (port) *port = 0;
1109     if (name) *name = 0;
1110
1111     if (!strncmp( ptr, "rpcap://", strlen("rpcap://"))) ptr += strlen( "rpcap://" );
1112     else if (!strncmp( ptr, "file://", strlen("file://") ))
1113     {
1114         ptr += strlen( "file://" );
1115         type = PCAP_SRC_FILE;
1116     }
1117
1118     if (ret_type) *ret_type = type;
1119     if (!*ptr)
1120     {
1121         if (errbuf) sprintf( errbuf, "The name has not been specified in the source string." );
1122         return PCAP_ERROR;
1123     }
1124
1125     if (name) strcpy( name, ptr );
1126     return 0;
1127 }
1128
1129 int CDECL pcap_sendpacket( struct pcap *pcap, const unsigned char *buf, int size )
1130 {
1131     struct sendpacket_params params;
1132
1133     TRACE( "%p, %p, %d\n", pcap, buf, size );
1134
1135     if (!pcap) return PCAP_ERROR;
1136     params.handle = pcap->handle;
1137     params.buf    = buf;
1138     params.size   = size;
1139     return PCAP_CALL( sendpacket, &params );
1140 }
1141
1142 int CDECL pcap_set_buffer_size( struct pcap *pcap, int size )
1143 {
1144     struct set_buffer_size_params params;
1145
1146     TRACE( "%p, %d\n", pcap, size );
1147
1148     if (!pcap) return PCAP_ERROR;
1149     params.handle = pcap->handle;
1150     params.size   = size;
1151     return PCAP_CALL( set_buffer_size, &params );
1152 }
1153
1154 int CDECL pcap_set_datalink( struct pcap *pcap, int link )
1155 {
1156     struct set_datalink_params params;
1157
1158     TRACE( "%p, %d\n", pcap, link );
1159
1160     if (!pcap) return PCAP_ERROR;
1161     params.handle = pcap->handle;
1162     params.link   = link;
1163     return PCAP_CALL( set_datalink, &params );
1164 }
1165
1166 int CDECL pcap_set_promisc( struct pcap *pcap, int enable )
1167 {
1168     struct set_promisc_params params;
1169
1170     TRACE( "%p, %d\n", pcap, enable );
1171
1172     if (!pcap) return PCAP_ERROR;
1173     params.handle = pcap->handle;
1174     params.enable = enable;
1175     return PCAP_CALL( set_promisc, &params );
1176 }
1177
1178 int CDECL pcap_set_rfmon( struct pcap *pcap, int enable )
1179 {
1180     struct set_rfmon_params params;
1181
1182     TRACE( "%p, %d\n", pcap, enable );
1183
1184     if (!pcap) return PCAP_ERROR;
1185     params.handle = pcap->handle;
1186     params.enable = enable;
1187     return PCAP_CALL( set_rfmon, &params );
1188 }
1189
1190 int CDECL pcap_set_snaplen( struct pcap *pcap, int len )
1191 {
1192     struct set_snaplen_params params;
1193
1194     TRACE( "%p, %d\n", pcap, len );
1195
1196     if (!pcap) return PCAP_ERROR;
1197     params.handle = pcap->handle;
1198     params.len    = len;
1199     return PCAP_CALL( set_snaplen, &params );
1200 }
1201
1202 int CDECL pcap_set_timeout( struct pcap *pcap, int timeout )
1203 {
1204     struct set_timeout_params params;
1205
1206     TRACE( "%p, %d\n", pcap, timeout );
1207
1208     if (!pcap) return PCAP_ERROR;
1209     params.handle  = pcap->handle;
1210     params.timeout = timeout;
1211     return PCAP_CALL( set_timeout, &params );
1212 }
1213
1214 int CDECL pcap_set_tstamp_precision( struct pcap *pcap, int precision )
1215 {
1216     struct set_tstamp_precision_params params;
1217
1218     TRACE( "%p, %d\n", pcap, precision );
1219
1220     if (!pcap) return PCAP_ERROR;
1221     params.handle    = pcap->handle;
1222     params.precision = precision;
1223     return PCAP_CALL( set_tstamp_precision, &params );
1224 }
1225
1226 int CDECL pcap_set_tstamp_type( struct pcap *pcap, int type )
1227 {
1228     struct set_tstamp_type_params params;
1229
1230     TRACE( "%p, %d\n", pcap, type );
1231
1232     if (!pcap) return PCAP_ERROR;
1233     params.handle = pcap->handle;
1234     params.type   = type;
1235     return PCAP_CALL( set_tstamp_type, &params );
1236 }
1237
1238 int CDECL pcap_setbuff( struct pcap *pcap, int size )
1239 {
1240     FIXME( "%p, %d\n", pcap, size );
1241     return 0;
1242 }
1243
1244 int CDECL pcap_setfilter( struct pcap *pcap, struct bpf_program *program )
1245 {
1246     struct setfilter_params params;
1247
1248     TRACE( "%p, %p\n", pcap, program );
1249
1250     if (!pcap) return PCAP_ERROR;
1251     params.handle        = pcap->handle;
1252     params.program_len   = program->bf_len;
1253     params.program_insns = program->bf_insns;
1254     return PCAP_CALL( setfilter, &params );
1255 }
1256
1257 int CDECL pcap_setnonblock( struct pcap *pcap, int nonblock, char *errbuf )
1258 {
1259     struct setnonblock_params params;
1260
1261     TRACE( "%p, %d, %p\n", pcap, nonblock, errbuf );
1262
1263     if (!pcap) return PCAP_ERROR;
1264     params.handle   = pcap->handle;
1265     params.nonblock = nonblock;
1266     params.errbuf   = errbuf;
1267     return PCAP_CALL( setnonblock, &params );
1268 }
1269
1270 int CDECL pcap_snapshot( struct pcap *pcap )
1271 {
1272     struct snapshot_params params;
1273
1274     TRACE( "%p\n", pcap );
1275
1276     if (!pcap) return PCAP_ERROR;
1277     params.handle = pcap->handle;
1278     return PCAP_CALL( snapshot, &params );
1279 }
1280
1281 int CDECL pcap_stats( struct pcap *pcap, struct pcap_stat_win32 *stat )
1282 {
1283     struct stats_params params;
1284     int ret;
1285
1286     TRACE( "%p, %p\n", pcap, stat );
1287
1288     if (!pcap) return PCAP_ERROR;
1289     params.handle = pcap->handle;
1290     if (!(ret = PCAP_CALL( stats, &params ))) *stat = params.stat;
1291     return ret;
1292 }
1293
1294 const char * CDECL pcap_statustostr( int status )
1295 {
1296     static char errbuf[32];
1297
1298     TRACE( "%d\n", status );
1299
1300     switch (status)
1301     {
1302     case PCAP_WARNING:
1303         return "Generic warning";
1304     case PCAP_WARNING_TSTAMP_TYPE_NOTSUP:
1305         return "That type of time stamp is not supported by that device";
1306     case PCAP_WARNING_PROMISC_NOTSUP:
1307         return "That device doesn't support promiscuous mode";
1308     case PCAP_ERROR:
1309         return "Generic error";
1310     case PCAP_ERROR_BREAK:
1311         return "Loop terminated by pcap_breakloop";
1312     case PCAP_ERROR_NOT_ACTIVATED:
1313         return "The pcap_t has not been activated";
1314     case PCAP_ERROR_ACTIVATED:
1315         return "The setting can't be changed after the pcap_t is activated";
1316     case PCAP_ERROR_NO_SUCH_DEVICE:
1317         return "No such device exists";
1318     default:
1319         sprintf( errbuf, "Unknown error: %d", status );
1320         return errbuf;
1321     }
1322 }
1323
1324 int CDECL pcap_tstamp_type_name_to_val( const char *name )
1325 {
1326     struct tstamp_type_name_to_val_params params = { name };
1327     TRACE( "%s\n", debugstr_a(name) );
1328     return PCAP_CALL( tstamp_type_name_to_val, &params );
1329 }
1330
1331 static struct
1332 {
1333     char *name;
1334     char *description;
1335 } tstamp_types[16];
1336
1337 static void free_tstamp_types( void )
1338 {
1339     unsigned int i;
1340     for (i = 0; i < ARRAY_SIZE(tstamp_types); i++)
1341     {
1342         free( tstamp_types[i].name );
1343         tstamp_types[i].name = NULL;
1344         free( tstamp_types[i].description );
1345         tstamp_types[i].description = NULL;
1346     }
1347 }
1348
1349 const char * CDECL pcap_tstamp_type_val_to_description( int type )
1350 {
1351     struct tstamp_type_val_to_description_params params;
1352     unsigned int len = 64;
1353     char *tmp;
1354     NTSTATUS status;
1355
1356     TRACE( "%d\n", type );
1357
1358     if (type < 0 || type >= ARRAY_SIZE(tstamp_types))
1359     {
1360         WARN( "unhandled tstamp type %d\n", type );
1361         return NULL;
1362     }
1363     if (tstamp_types[type].description) return tstamp_types[type].description;
1364
1365     if (!(params.buf = malloc( len ))) return NULL;
1366     params.type   = type;
1367     params.buflen = &len;
1368     status = PCAP_CALL( tstamp_type_val_to_description, &params );
1369     if (status == STATUS_SUCCESS) return (tstamp_types[type].description = params.buf);
1370     if (status != STATUS_BUFFER_TOO_SMALL || !(tmp = realloc( params.buf, len )))
1371     {
1372         free( params.buf );
1373         return NULL;
1374     }
1375     params.buf = tmp;
1376     if (PCAP_CALL( tstamp_type_val_to_description, &params ))
1377     {
1378         free( params.buf );
1379         return NULL;
1380     }
1381
1382     return (tstamp_types[type].description = params.buf);
1383 }
1384
1385 const char * CDECL pcap_tstamp_type_val_to_name( int type )
1386 {
1387     struct tstamp_type_val_to_name_params params;
1388     unsigned int len = 32;
1389     char *tmp;
1390     NTSTATUS status;
1391
1392     TRACE( "%d\n", type );
1393
1394     if (type < 0 || type >= ARRAY_SIZE(tstamp_types))
1395     {
1396         WARN( "unhandled tstamp type %d\n", type );
1397         return NULL;
1398     }
1399     if (tstamp_types[type].name) return tstamp_types[type].name;
1400
1401     if (!(params.buf = malloc( len ))) return NULL;
1402     params.type   = type;
1403     params.buflen = &len;
1404     status = PCAP_CALL( tstamp_type_val_to_name, &params );
1405     if (status == STATUS_SUCCESS) return (tstamp_types[type].name = params.buf);
1406     if (status != STATUS_BUFFER_TOO_SMALL || !(tmp = realloc( params.buf, len )))
1407     {
1408         free( params.buf );
1409         return NULL;
1410     }
1411     params.buf = tmp;
1412     if (PCAP_CALL( tstamp_type_val_to_name, &params ))
1413     {
1414         free( params.buf );
1415         return NULL;
1416     }
1417
1418     return (tstamp_types[type].name = params.buf);
1419 }
1420
1421 int CDECL pcap_wsockinit( void )
1422 {
1423     WSADATA wsadata;
1424     TRACE( "\n" );
1425     if (WSAStartup( MAKEWORD(1, 1), &wsadata )) return PCAP_ERROR;
1426     return 0;
1427 }
1428
1429 #define PCAP_CHAR_ENC_LOCAL 0
1430 #define PCAP_CHAR_ENC_UTF_8 1
1431 #define PCAP_MMAP_32BIT     2
1432
1433 int CDECL pcap_init( unsigned int opt, char *errbuf )
1434 {
1435     struct init_params params;
1436
1437     TRACE( "%u, %p\n", opt, errbuf );
1438     if (opt == PCAP_CHAR_ENC_LOCAL) FIXME( "need to convert to/from local encoding\n" );
1439
1440     params.opt    = opt;
1441     params.errbuf = errbuf;
1442     return PCAP_CALL( init, &params );
1443 }
1444
1445 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, void *reserved )
1446 {
1447     switch (reason)
1448     {
1449     case DLL_PROCESS_ATTACH:
1450     {
1451         DisableThreadLibraryCalls( hinst );
1452         if (__wine_init_unix_call()) ERR( "No pcap support, expect problems\n" );
1453         else
1454         {
1455             char errbuf[PCAP_ERRBUF_SIZE];
1456             struct init_params params = { PCAP_CHAR_ENC_UTF_8, errbuf };
1457             BOOL is_wow64;
1458
1459             if (PCAP_CALL( init, &params ) == PCAP_ERROR)
1460                 WARN( "failed to enable UTF-8 encoding %s\n", debugstr_a(errbuf) );
1461             if (IsWow64Process( GetCurrentProcess(), &is_wow64 ) && is_wow64)
1462             {
1463                 params.opt = PCAP_MMAP_32BIT;
1464                 if (PCAP_CALL( init, &params ) == PCAP_ERROR)
1465                     WARN( "failed to enable 32-bit mmap() %s\n", debugstr_a(errbuf) );
1466             }
1467         }
1468         break;
1469     }
1470     case DLL_PROCESS_DETACH:
1471         if (reserved) break;
1472         free_datalinks();
1473         free_tstamp_types();
1474         break;
1475     }
1476     return TRUE;
1477 }