dlls/wpcap/unixlib.c

   1 /*
   2  * Copyright 2011, 2014 André Hentschel
   3  * Copyright 2021 Hans Leidekker for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #if 0
  21 #pragma makedep unix
  22 #endif
  23
  24 #include "config.h"
  25
  26 #ifdef HAVE_PCAP_PCAP_H
  27 #include <pcap/pcap.h>
  28
  29 #include <assert.h>
  30 #include <stdarg.h>
  31 #include <stdlib.h>
  32 #include <limits.h>
  33 #include "ntstatus.h"
  34 #define WIN32_NO_STATUS
  35 #include "windef.h"
  36 #include "winbase.h"
  37 #include "winternl.h"
  38
  39 #include "wine/unixlib.h"
  40 #include "wine/debug.h"
  41 #include "unixlib.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(wpcap);
  44
  45 static NTSTATUS wrap_activate( void *args )
  46 {
  47     const struct activate_params *params = args;
  48     return pcap_activate( (pcap_t *)(ULONG_PTR)params->handle );
  49 }
  50
  51 static NTSTATUS wrap_breakloop( void *args )
  52 {
  53     const struct breakloop_params *params = args;
  54     pcap_breakloop( (pcap_t *)(ULONG_PTR)params->handle );
  55     return STATUS_SUCCESS;
  56 }
  57
  58 static NTSTATUS wrap_bufsize( void *args )
  59 {
  60     const struct bufsize_params *params = args;
  61     return pcap_bufsize( (pcap_t *)(ULONG_PTR)params->handle );
  62 }
  63
  64 static NTSTATUS wrap_can_set_rfmon( void *args )
  65 {
  66     const struct can_set_rfmon_params *params = args;
  67     return pcap_can_set_rfmon( (pcap_t *)(ULONG_PTR)params->handle );
  68 }
  69
  70 static NTSTATUS wrap_close( void *args )
  71 {
  72     const struct close_params *params = args;
  73     pcap_close( (pcap_t *)(ULONG_PTR)params->handle );
  74     return STATUS_SUCCESS;
  75 }
  76
  77 static NTSTATUS wrap_compile( void *args )
  78 {
  79     struct compile_params *params = args;
  80     struct bpf_program program;
  81     int ret;
  82
  83     if (!(ret = pcap_compile( (pcap_t *)(ULONG_PTR)params->handle, &program, params->str, params->optimize,
  84                               params->mask )))
  85     {
  86         if (*params->program_len < program.bf_len) ret = STATUS_BUFFER_TOO_SMALL;
  87         else memcpy( params->program_insns, program.bf_insns, program.bf_len * sizeof(*program.bf_insns) );
  88         *params->program_len = program.bf_len;
  89         pcap_freecode( &program );
  90     }
  91     return ret;
  92 }
  93
  94 static NTSTATUS wrap_create( void *args )
  95 {
  96     struct create_params *params = args;
  97     if (!(*params->handle = (ULONG_PTR)pcap_create( params->source, params->errbuf ))) return STATUS_NO_MEMORY;
  98     return STATUS_SUCCESS;
  99 }
 100
 101 static NTSTATUS wrap_datalink( void *args )
 102 {
 103     struct datalink_params *params = args;
 104     return pcap_datalink( (pcap_t *)(ULONG_PTR)params->handle );
 105 }
 106
 107 static NTSTATUS wrap_datalink_name_to_val( void *args )
 108 {
 109     struct datalink_name_to_val_params *params = args;
 110     return pcap_datalink_name_to_val( params->name );
 111 }
 112
 113 static NTSTATUS wrap_datalink_val_to_description( void *args )
 114 {
 115     const struct datalink_val_to_description_params *params = args;
 116     const char *str = pcap_datalink_val_to_description( params->link );
 117     int len;
 118
 119     if (!str || !params->buf) return STATUS_INVALID_PARAMETER;
 120     if ((len = strlen( str )) >= *params->buflen)
 121     {
 122         *params->buflen = len + 1;
 123         return STATUS_BUFFER_TOO_SMALL;
 124     }
 125     strcpy( params->buf, str );
 126     return STATUS_SUCCESS;
 127 }
 128
 129 static NTSTATUS wrap_datalink_val_to_name( void *args )
 130 {
 131     const struct datalink_val_to_name_params *params = args;
 132     const char *str = pcap_datalink_val_to_name( params->link );
 133     int len;
 134
 135     if (!str || !params->buf) return STATUS_INVALID_PARAMETER;
 136     if ((len = strlen( str )) >= *params->buflen)
 137     {
 138         *params->buflen = len + 1;
 139         return STATUS_BUFFER_TOO_SMALL;
 140     }
 141     strcpy( params->buf, str );
 142     return STATUS_SUCCESS;
 143 }
 144
 145 static NTSTATUS wrap_dump( void *args )
 146 {
 147     const struct dump_params *params = args;
 148     struct pcap_pkthdr hdr_unix;
 149
 150     hdr_unix.ts.tv_sec  = params->hdr->ts.tv_sec;
 151     hdr_unix.ts.tv_usec = params->hdr->ts.tv_usec;
 152     hdr_unix.caplen     = params->hdr->caplen;
 153     hdr_unix.len        = params->hdr->len;
 154     pcap_dump( params->user, &hdr_unix, params->packet );
 155     return STATUS_SUCCESS;
 156 }
 157
 158 static NTSTATUS wrap_dump_close( void *args )
 159 {
 160     const struct dump_close_params *params = args;
 161     pcap_dump_close( (pcap_dumper_t *)(ULONG_PTR)params->handle );
 162     return STATUS_SUCCESS;
 163 }
 164
 165 static NTSTATUS wrap_dump_open( void *args )
 166 {
 167     const struct dump_open_params *params = args;
 168     *params->ret_handle = (ULONG_PTR)pcap_dump_open( (pcap_t *)(ULONG_PTR)params->handle, params->name );
 169     return STATUS_SUCCESS;
 170 }
 171
 172 static NTSTATUS wrap_findalldevs( void *args )
 173 {
 174     const struct findalldevs_params *params = args;
 175     pcap_if_t *devs = NULL, *src;
 176     struct pcap_interface_offsets *dst = (struct pcap_interface_offsets *)params->buf;
 177     int ret, len_total = 0;
 178
 179     if ((ret = pcap_findalldevs( &devs, params->errbuf ))) return ret;
 180
 181     src = devs;
 182     while (src)
 183     {
 184         int len_name = strlen( src->name ) + 1, len_description = src->description ? strlen( src->description ) + 1 : 0;
 185         int len = sizeof(*dst) + len_name + len_description;
 186
 187         if (*params->buflen >= len_total + len)
 188         {
 189             dst->name_offset = sizeof(*dst);
 190             dst->name_len = len_name;
 191             strcpy( (char *)dst + dst->name_offset, src->name );
 192             if (!len_description) dst->description_offset = dst->description_len = 0;
 193             else
 194             {
 195                 dst->description_offset = dst->name_offset + len_name;
 196                 dst->description_len = len_description;
 197                 strcpy( (char *)dst + dst->description_offset, src->description );
 198             }
 199             dst->flags = src->flags;
 200             dst = (struct pcap_interface_offsets *)((char *)dst + len);
 201         }
 202         len_total += len;
 203         src = src->next;
 204     }
 205
 206     if (*params->buflen < len_total) ret = STATUS_BUFFER_TOO_SMALL;
 207     *params->buflen = len_total;
 208     pcap_freealldevs( devs );
 209     return ret;
 210 }
 211
 212 static NTSTATUS wrap_get_tstamp_precision( void *args )
 213 {
 214     const struct get_tstamp_precision_params *params = args;
 215     return pcap_get_tstamp_precision( (pcap_t *)(ULONG_PTR)params->handle );
 216 }
 217
 218 static NTSTATUS wrap_geterr( void *args )
 219 {
 220     const struct geterr_params *params = args;
 221     char *errbuf = pcap_geterr( (pcap_t *)(ULONG_PTR)params->handle );
 222     assert( strlen(errbuf) < PCAP_ERRBUF_SIZE );
 223     strcpy( params->errbuf, errbuf );
 224     return STATUS_SUCCESS;
 225 }
 226
 227 static NTSTATUS wrap_getnonblock( void *args )
 228 {
 229     const struct getnonblock_params *params = args;
 230     return pcap_getnonblock( (pcap_t *)(ULONG_PTR)params->handle, params->errbuf );
 231 }
 232
 233 static NTSTATUS wrap_init( void *args )
 234 {
 235     const struct init_params *params = args;
 236     return pcap_init( params->opt, params->errbuf );
 237 }
 238
 239 static NTSTATUS wrap_lib_version( void *args )
 240 {
 241     const struct lib_version_params *params = args;
 242     const char *str = pcap_lib_version();
 243     unsigned int len = min( strlen(str) + 1, params->size );
 244
 245     memcpy( params->version, str, len );
 246     params->version[len - 1] = 0;
 247     return STATUS_SUCCESS;
 248 }
 249
 250 static NTSTATUS wrap_list_datalinks( void *args )
 251 {
 252     const struct list_datalinks_params *params = args;
 253     NTSTATUS status = STATUS_SUCCESS;
 254     int *links = NULL, count;
 255
 256     if ((count = pcap_list_datalinks( (pcap_t *)(ULONG_PTR)params->handle, &links )) > 0)
 257     {
 258         if (*params->count < count) status = STATUS_BUFFER_TOO_SMALL;
 259         else memcpy( params->links, links, count * sizeof(*links) );
 260     }
 261     pcap_free_datalinks( links );
 262     *params->count = count;
 263     return status;
 264 }
 265
 266 static NTSTATUS wrap_list_tstamp_types( void *args )
 267 {
 268     const struct list_tstamp_types_params *params = args;
 269     NTSTATUS status = STATUS_SUCCESS;
 270     int *types = NULL, count;
 271
 272     if ((count = pcap_list_tstamp_types( (pcap_t *)(ULONG_PTR)params->handle, &types )) > 0)
 273     {
 274         if (*params->count < count) status = STATUS_BUFFER_TOO_SMALL;
 275         else memcpy( params->types, types, count * sizeof(*types) );
 276     }
 277     pcap_free_tstamp_types( types );
 278     *params->count = count;
 279     return status;
 280 }
 281
 282 static NTSTATUS wrap_lookupnet( void *args )
 283 {
 284     const struct lookupnet_params *params = args;
 285     return pcap_lookupnet( params->device, params->net, params->mask, params->errbuf );
 286 }
 287
 288 static NTSTATUS wrap_major_version( void *args )
 289 {
 290     const struct major_version_params *params = args;
 291     return pcap_major_version( (pcap_t *)(ULONG_PTR)params->handle );
 292 }
 293
 294 static NTSTATUS wrap_minor_version( void *args )
 295 {
 296     const struct minor_version_params *params = args;
 297     return pcap_minor_version( (pcap_t *)(ULONG_PTR)params->handle );
 298 }
 299
 300 static NTSTATUS wrap_next_ex( void *args )
 301 {
 302     struct next_ex_params *params = args;
 303     struct pcap_pkthdr *hdr_unix;
 304     int ret;
 305
 306     if ((ret = pcap_next_ex( (pcap_t *)(ULONG_PTR)params->handle, &hdr_unix, params->data )) == 1)
 307     {
 308         if (hdr_unix->ts.tv_sec > INT_MAX || hdr_unix->ts.tv_usec > INT_MAX) WARN( "truncating timeval values(s)\n" );
 309         params->hdr->ts.tv_sec  = hdr_unix->ts.tv_sec;
 310         params->hdr->ts.tv_usec = hdr_unix->ts.tv_usec;
 311         params->hdr->caplen     = hdr_unix->caplen;
 312         params->hdr->len        = hdr_unix->len;
 313     }
 314     return ret;
 315 }
 316
 317 static NTSTATUS wrap_open_live( void *args )
 318 {
 319     const struct open_live_params *params = args;
 320     if (!(*params->handle = (ULONG_PTR)pcap_open_live( params->source, params->snaplen, params->promisc,
 321                                                        params->timeout, params->errbuf ))) return STATUS_NO_MEMORY;
 322     return STATUS_SUCCESS;
 323 }
 324
 325 static NTSTATUS wrap_sendpacket( void *args )
 326 {
 327     const struct sendpacket_params *params = args;
 328     return pcap_sendpacket( (pcap_t *)(ULONG_PTR)params->handle, params->buf, params->size );
 329 }
 330
 331 static NTSTATUS wrap_set_buffer_size( void *args )
 332 {
 333     const struct set_buffer_size_params *params = args;
 334     return pcap_set_buffer_size( (pcap_t *)(ULONG_PTR)params->handle, params->size );
 335 }
 336
 337 static NTSTATUS wrap_set_datalink( void *args )
 338 {
 339     const struct set_datalink_params *params = args;
 340     return pcap_set_datalink( (pcap_t *)(ULONG_PTR)params->handle, params->link );
 341 }
 342
 343 static NTSTATUS wrap_set_promisc( void *args )
 344 {
 345     const struct set_promisc_params *params = args;
 346     return pcap_set_promisc( (pcap_t *)(ULONG_PTR)params->handle, params->enable );
 347 }
 348
 349 static NTSTATUS wrap_set_rfmon( void *args )
 350 {
 351     const struct set_rfmon_params *params = args;
 352     return pcap_set_rfmon( (pcap_t *)(ULONG_PTR)params->handle, params->enable );
 353 }
 354
 355 static NTSTATUS wrap_set_snaplen( void *args )
 356 {
 357     const struct set_snaplen_params *params = args;
 358     return pcap_set_snaplen( (pcap_t *)(ULONG_PTR)params->handle, params->len );
 359 }
 360
 361 static NTSTATUS wrap_set_timeout( void *args )
 362 {
 363     const struct set_timeout_params *params = args;
 364     return pcap_set_timeout( (pcap_t *)(ULONG_PTR)params->handle, params->timeout );
 365 }
 366
 367 static NTSTATUS wrap_set_tstamp_precision( void *args )
 368 {
 369     const struct set_tstamp_precision_params *params = args;
 370     return pcap_set_tstamp_precision( (pcap_t *)(ULONG_PTR)params->handle, params->precision );
 371 }
 372
 373 static NTSTATUS wrap_set_tstamp_type( void *args )
 374 {
 375     const struct set_tstamp_type_params *params = args;
 376     return pcap_set_tstamp_type( (pcap_t *)(ULONG_PTR)params->handle, params->type );
 377 }
 378
 379 static NTSTATUS wrap_setfilter( void *args )
 380 {
 381     const struct setfilter_params *params = args;
 382     struct bpf_program program = { params->program_len, params->program_insns };
 383     return pcap_setfilter( (pcap_t *)(ULONG_PTR)params->handle, &program );
 384 }
 385
 386 static NTSTATUS wrap_setnonblock( void *args )
 387 {
 388     const struct setnonblock_params *params = args;
 389     return pcap_setnonblock( (pcap_t *)(ULONG_PTR)params->handle, params->nonblock, params->errbuf );
 390 }
 391
 392 static NTSTATUS wrap_snapshot( void *args )
 393 {
 394     const struct snapshot_params *params = args;
 395     return pcap_snapshot( (pcap_t *)(ULONG_PTR)params->handle );
 396 }
 397
 398 static NTSTATUS wrap_stats( void *args )
 399 {
 400     struct stats_params *params = args;
 401     struct pcap_stat stat;
 402     int ret;
 403
 404     if (!(ret = pcap_stats( (pcap_t *)(ULONG_PTR)params->handle, &stat )))
 405     {
 406         params->stat.ps_recv    = stat.ps_recv;
 407         params->stat.ps_drop    = stat.ps_drop;
 408         params->stat.ps_ifdrop  = stat.ps_ifdrop;
 409         params->stat.ps_capt    = 0;
 410         params->stat.ps_sent    = 0;
 411         params->stat.ps_netdrop = 0;
 412     }
 413     return ret;
 414 }
 415
 416 static NTSTATUS wrap_tstamp_type_name_to_val( void *args )
 417 {
 418     const struct tstamp_type_name_to_val_params *params = args;
 419     return pcap_tstamp_type_name_to_val( params->name );
 420 }
 421
 422 static NTSTATUS wrap_tstamp_type_val_to_description( void *args )
 423 {
 424     const struct tstamp_type_val_to_description_params *params = args;
 425     const char *str = pcap_tstamp_type_val_to_description( params->type );
 426     int len;
 427
 428     if (!str || !params->buf) return STATUS_INVALID_PARAMETER;
 429     if ((len = strlen( str )) >= *params->buflen)
 430     {
 431         *params->buflen = len + 1;
 432         return STATUS_BUFFER_TOO_SMALL;
 433     }
 434     strcpy( params->buf, str );
 435     return STATUS_SUCCESS;
 436 }
 437
 438 static NTSTATUS wrap_tstamp_type_val_to_name( void *args )
 439 {
 440     const struct tstamp_type_val_to_name_params *params = args;
 441     const char *str = pcap_tstamp_type_val_to_name( params->type );
 442     int len;
 443
 444     if (!str || !params->buf) return STATUS_INVALID_PARAMETER;
 445     if ((len = strlen( str )) >= *params->buflen)
 446     {
 447         *params->buflen = len + 1;
 448         return STATUS_BUFFER_TOO_SMALL;
 449     }
 450     strcpy( params->buf, str );
 451     return STATUS_SUCCESS;
 452 }
 453
 454 const unixlib_entry_t __wine_unix_call_funcs[] =
 455 {
 456     wrap_activate,
 457     wrap_breakloop,
 458     wrap_bufsize,
 459     wrap_can_set_rfmon,
 460     wrap_close,
 461     wrap_compile,
 462     wrap_create,
 463     wrap_datalink,
 464     wrap_datalink_name_to_val,
 465     wrap_datalink_val_to_description,
 466     wrap_datalink_val_to_name,
 467     wrap_dump,
 468     wrap_dump_close,
 469     wrap_dump_open,
 470     wrap_findalldevs,
 471     wrap_get_tstamp_precision,
 472     wrap_geterr,
 473     wrap_getnonblock,
 474     wrap_init,
 475     wrap_lib_version,
 476     wrap_list_datalinks,
 477     wrap_list_tstamp_types,
 478     wrap_lookupnet,
 479     wrap_major_version,
 480     wrap_minor_version,
 481     wrap_next_ex,
 482     wrap_open_live,
 483     wrap_sendpacket,
 484     wrap_set_buffer_size,
 485     wrap_set_datalink,
 486     wrap_set_promisc,
 487     wrap_set_rfmon,
 488     wrap_set_snaplen,
 489     wrap_set_timeout,
 490     wrap_set_tstamp_precision,
 491     wrap_set_tstamp_type,
 492     wrap_setfilter,
 493     wrap_setnonblock,
 494     wrap_snapshot,
 495     wrap_stats,
 496     wrap_tstamp_type_name_to_val,
 497     wrap_tstamp_type_val_to_description,
 498     wrap_tstamp_type_val_to_name,
 499 };
 500
 501 #ifdef _WIN64
 502
 503 typedef ULONG PTR32;
 504
 505 static NTSTATUS wow64_compile( void *args )
 506 {
 507     struct
 508     {
 509         UINT64 handle;
 510         PTR32 program_len;
 511         PTR32 program_insns;
 512         PTR32 str;
 513         int optimize;
 514         unsigned int mask;
 515     } const *params32 = args;
 516
 517     struct compile_params params =
 518     {
 519         params32->handle,
 520         ULongToPtr(params32->program_len),
 521         ULongToPtr(params32->program_insns),
 522         ULongToPtr(params32->str),
 523         params32->optimize,
 524         params32->mask
 525     };
 526     return wrap_compile( &params );
 527 }
 528
 529 static NTSTATUS wow64_create( void *args )
 530 {
 531     struct
 532     {
 533         PTR32 source;
 534         PTR32 errbuf;
 535         PTR32 handle;
 536     } const *params32 = args;
 537
 538     struct create_params params =
 539     {
 540         ULongToPtr(params32->source),
 541         ULongToPtr(params32->errbuf),
 542         ULongToPtr(params32->handle),
 543     };
 544     return wrap_create( &params );
 545 }
 546
 547 static NTSTATUS wow64_datalink_name_to_val( void *args )
 548 {
 549     struct
 550     {
 551         PTR32 name;
 552     } const *params32 = args;
 553
 554     struct datalink_name_to_val_params params =
 555     {
 556         ULongToPtr(params32->name),
 557     };
 558     return wrap_datalink_name_to_val( &params );
 559 }
 560
 561 static NTSTATUS wow64_datalink_val_to_description( void *args )
 562 {
 563     struct
 564     {
 565         int link;
 566         PTR32 buf;
 567         PTR32 buflen;
 568     } const *params32 = args;
 569
 570     struct datalink_val_to_description_params params =
 571     {
 572         params32->link,
 573         ULongToPtr(params32->buf),
 574         ULongToPtr(params32->buflen)
 575     };
 576     return wrap_datalink_val_to_description( &params );
 577 }
 578
 579 static NTSTATUS wow64_datalink_val_to_name( void *args )
 580 {
 581     struct
 582     {
 583         int link;
 584         PTR32 buf;
 585         PTR32 buflen;
 586     } const *params32 = args;
 587
 588     struct datalink_val_to_name_params params =
 589     {
 590         params32->link,
 591         ULongToPtr(params32->buf),
 592         ULongToPtr(params32->buflen)
 593     };
 594     return wrap_datalink_val_to_name( &params );
 595 }
 596
 597 static NTSTATUS wow64_dump( void *args )
 598 {
 599     struct
 600     {
 601         PTR32 user;
 602         PTR32 hdr;
 603         PTR32 packet;
 604     } const *params32 = args;
 605
 606     struct dump_params params =
 607     {
 608         ULongToPtr(params32->user),
 609         ULongToPtr(params32->hdr),
 610         ULongToPtr(params32->packet)
 611     };
 612     return wrap_dump( &params );
 613 }
 614
 615 static NTSTATUS wow64_dump_open( void *args )
 616 {
 617     struct
 618     {
 619         UINT64 handle;
 620         PTR32 name;
 621         PTR32 ret_handle;
 622     } const *params32 = args;
 623
 624     struct datalink_val_to_name_params params =
 625     {
 626         params32->handle,
 627         ULongToPtr(params32->name),
 628         ULongToPtr(params32->ret_handle)
 629     };
 630     return wrap_dump_open( &params );
 631 }
 632
 633 static NTSTATUS wow64_findalldevs( void *args )
 634 {
 635     struct
 636     {
 637         PTR32 buf;
 638         PTR32 buflen;
 639         PTR32 errbuf;
 640     } const *params32 = args;
 641
 642     struct findalldevs_params params =
 643     {
 644         ULongToPtr(params32->buf),
 645         ULongToPtr(params32->buflen),
 646         ULongToPtr(params32->errbuf)
 647     };
 648     return wrap_findalldevs( &params );
 649 }
 650
 651 static NTSTATUS wow64_geterr( void *args )
 652 {
 653     struct
 654     {
 655         UINT64 handle;
 656         PTR32 errbuf;
 657     } const *params32 = args;
 658
 659     struct geterr_params params =
 660     {
 661         params32->handle,
 662         ULongToPtr(params32->errbuf)
 663     };
 664     return wrap_geterr( &params );
 665 }
 666
 667 static NTSTATUS wow64_getnonblock( void *args )
 668 {
 669     struct
 670     {
 671         UINT64 handle;
 672         PTR32 errbuf;
 673     } const *params32 = args;
 674
 675     struct getnonblock_params params =
 676     {
 677         params32->handle,
 678         ULongToPtr(params32->errbuf)
 679     };
 680     return wrap_getnonblock( &params );
 681 }
 682
 683 static NTSTATUS wow64_init( void *args )
 684 {
 685     struct
 686     {
 687         int opt;
 688         PTR32 errbuf;
 689     } const *params32 = args;
 690
 691     struct init_params params =
 692     {
 693         params32->opt,
 694         ULongToPtr(params32->errbuf)
 695     };
 696     return wrap_init( &params );
 697 }
 698
 699 static NTSTATUS wow64_lib_version( void *args )
 700 {
 701     struct
 702     {
 703         PTR32 version;
 704         unsigned int size;
 705     } const *params32 = args;
 706
 707     struct lib_version_params params =
 708     {
 709         ULongToPtr(params32->version),
 710         params32->size
 711     };
 712     return wrap_lib_version( &params );
 713 }
 714
 715 static NTSTATUS wow64_list_datalinks( void *args )
 716 {
 717     struct
 718     {
 719         UINT64 handle;
 720         PTR32 links;
 721         PTR32 count;
 722     } const *params32 = args;
 723
 724     struct list_datalinks_params params =
 725     {
 726         params32->handle,
 727         ULongToPtr(params32->links),
 728         ULongToPtr(params32->count)
 729     };
 730     return wrap_list_datalinks( &params );
 731 }
 732
 733 static NTSTATUS wow64_list_tstamp_types( void *args )
 734 {
 735     struct
 736     {
 737         UINT64 handle;
 738         PTR32 types;
 739         PTR32 count;
 740     } const *params32 = args;
 741
 742     struct list_tstamp_types_params params =
 743     {
 744         params32->handle,
 745         ULongToPtr(params32->types),
 746         ULongToPtr(params32->count)
 747     };
 748     return wrap_list_tstamp_types( &params );
 749 }
 750
 751 static NTSTATUS wow64_lookupnet( void *args )
 752 {
 753     struct
 754     {
 755         PTR32 device;
 756         PTR32 net;
 757         PTR32 mask;
 758         PTR32 errbuf;
 759     } const *params32 = args;
 760
 761     struct lookupnet_params params =
 762     {
 763         ULongToPtr(params32->device),
 764         ULongToPtr(params32->net),
 765         ULongToPtr(params32->mask),
 766         ULongToPtr(params32->errbuf)
 767     };
 768     return wrap_lookupnet( &params );
 769 }
 770
 771 static NTSTATUS wow64_next_ex( void *args )
 772 {
 773     struct
 774     {
 775         UINT64 handle;
 776         PTR32 hdr;
 777         PTR32 data;
 778     } const *params32 = args;
 779
 780     struct next_ex_params params =
 781     {
 782         params32->handle,
 783         ULongToPtr(params32->hdr),
 784         ULongToPtr(params32->data)
 785     };
 786     return wrap_next_ex( &params );
 787 }
 788
 789 static NTSTATUS wow64_open_live( void *args )
 790 {
 791     struct
 792     {
 793         PTR32 source;
 794         int snaplen;
 795         int promisc;
 796         int timeout;
 797         PTR32 errbuf;
 798         PTR32 handle;
 799     } const *params32 = args;
 800
 801     struct open_live_params params =
 802     {
 803         ULongToPtr(params32->source),
 804         params32->snaplen,
 805         params32->promisc,
 806         params32->timeout,
 807         ULongToPtr(params32->errbuf),
 808         ULongToPtr(params32->handle)
 809     };
 810     return wrap_open_live( &params );
 811 }
 812
 813 static NTSTATUS wow64_sendpacket( void *args )
 814 {
 815     struct
 816     {
 817         UINT64 handle;
 818         PTR32 buf;
 819         int size;
 820     } const *params32 = args;
 821
 822     struct sendpacket_params params =
 823     {
 824         params32->handle,
 825         ULongToPtr(params32->buf),
 826         params32->size
 827     };
 828     return wrap_sendpacket( &params );
 829 }
 830
 831 static NTSTATUS wow64_setfilter( void *args )
 832 {
 833     struct
 834     {
 835         UINT64 handle;
 836         unsigned int program_len;
 837         PTR32 program_insns;
 838     } const *params32 = args;
 839
 840     struct setfilter_params params =
 841     {
 842         params32->handle,
 843         params32->program_len,
 844         ULongToPtr(params32->program_insns)
 845     };
 846     return wrap_setfilter( &params );
 847 }
 848
 849 static NTSTATUS wow64_setnonblock( void *args )
 850 {
 851     struct
 852     {
 853         UINT64 handle;
 854         int nonblock;
 855         PTR32 errbuf;
 856     } const *params32 = args;
 857
 858     struct setnonblock_params params =
 859     {
 860         params32->handle,
 861         params32->nonblock,
 862         ULongToPtr(params32->errbuf)
 863     };
 864     return wrap_setnonblock( &params );
 865 }
 866
 867 static NTSTATUS wow64_tstamp_type_name_to_val( void *args )
 868 {
 869     struct
 870     {
 871         PTR32 name;
 872     } const *params32 = args;
 873
 874     struct tstamp_type_name_to_val_params params =
 875     {
 876         ULongToPtr(params32->name)
 877     };
 878     return wrap_tstamp_type_name_to_val( &params );
 879 }
 880
 881 static NTSTATUS wow64_tstamp_type_val_to_description( void *args )
 882 {
 883     struct
 884     {
 885         int type;
 886         PTR32 buf;
 887         PTR32 buflen;
 888     } const *params32 = args;
 889
 890     struct tstamp_type_val_to_description_params params =
 891     {
 892         params32->type,
 893         ULongToPtr(params32->buf),
 894         ULongToPtr(params32->buflen)
 895     };
 896     return wrap_tstamp_type_val_to_description( &params );
 897 }
 898
 899 static NTSTATUS wow64_tstamp_type_val_to_name( void *args )
 900 {
 901     struct
 902     {
 903         int type;
 904         PTR32 buf;
 905         PTR32 buflen;
 906     } const *params32 = args;
 907
 908     struct tstamp_type_val_to_name_params params =
 909     {
 910         params32->type,
 911         ULongToPtr(params32->buf),
 912         ULongToPtr(params32->buflen)
 913     };
 914     return wrap_tstamp_type_val_to_name( &params );
 915 }
 916
 917 const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
 918 {
 919     wrap_activate,
 920     wrap_breakloop,
 921     wrap_bufsize,
 922     wrap_can_set_rfmon,
 923     wrap_close,
 924     wow64_compile,
 925     wow64_create,
 926     wrap_datalink,
 927     wow64_datalink_name_to_val,
 928     wow64_datalink_val_to_description,
 929     wow64_datalink_val_to_name,
 930     wow64_dump,
 931     wrap_dump_close,
 932     wow64_dump_open,
 933     wow64_findalldevs,
 934     wrap_get_tstamp_precision,
 935     wow64_geterr,
 936     wow64_getnonblock,
 937     wow64_init,
 938     wow64_lib_version,
 939     wow64_list_datalinks,
 940     wow64_list_tstamp_types,
 941     wow64_lookupnet,
 942     wrap_major_version,
 943     wrap_minor_version,
 944     wow64_next_ex,
 945     wow64_open_live,
 946     wow64_sendpacket,
 947     wrap_set_buffer_size,
 948     wrap_set_datalink,
 949     wrap_set_promisc,
 950     wrap_set_rfmon,
 951     wrap_set_snaplen,
 952     wrap_set_timeout,
 953     wrap_set_tstamp_precision,
 954     wrap_set_tstamp_type,
 955     wow64_setfilter,
 956     wow64_setnonblock,
 957     wrap_snapshot,
 958     wrap_stats,
 959     wow64_tstamp_type_name_to_val,
 960     wow64_tstamp_type_val_to_description,
 961     wow64_tstamp_type_val_to_name,
 962 };
 963
 964 #endif /* _WIN64 */
 965
 966 #endif /* HAVE_PCAP_PCAP_H */