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
 149     if (sizeof(void *) == 4)
 150     {
 151         struct pcap_pkthdr_win32 hdr32;
 152         hdr32.ts.tv_sec  = params->hdr->ts.tv_sec;
 153         hdr32.ts.tv_usec = params->hdr->ts.tv_usec;
 154         hdr32.caplen     = params->hdr->caplen;
 155         hdr32.len        = params->hdr->len;
 156         pcap_dump( params->user, (const struct pcap_pkthdr *)&hdr32, params->packet );
 157     }
 158     else
 159     {
 160         struct pcap_pkthdr hdr64;
 161         hdr64.ts.tv_sec  = params->hdr->ts.tv_sec;
 162         hdr64.ts.tv_usec = params->hdr->ts.tv_usec;
 163         hdr64.caplen     = params->hdr->caplen;
 164         hdr64.len        = params->hdr->len;
 165         pcap_dump( params->user, &hdr64, params->packet );
 166     }
 167     return STATUS_SUCCESS;
 168 }
 169
 170 static NTSTATUS wrap_dump_close( void *args )
 171 {
 172     const struct dump_close_params *params = args;
 173     pcap_dump_close( (pcap_dumper_t *)(ULONG_PTR)params->handle );
 174     return STATUS_SUCCESS;
 175 }
 176
 177 static NTSTATUS wrap_dump_open( void *args )
 178 {
 179     const struct dump_open_params *params = args;
 180     *params->ret_handle = (ULONG_PTR)pcap_dump_open( (pcap_t *)(ULONG_PTR)params->handle, params->name );
 181     return STATUS_SUCCESS;
 182 }
 183
 184 static NTSTATUS wrap_findalldevs( void *args )
 185 {
 186     const struct findalldevs_params *params = args;
 187     pcap_if_t *devs = NULL, *src;
 188     struct pcap_interface_offsets *dst = (struct pcap_interface_offsets *)params->buf;
 189     int ret, len_total = 0;
 190
 191     if ((ret = pcap_findalldevs( &devs, params->errbuf ))) return ret;
 192
 193     src = devs;
 194     while (src)
 195     {
 196         int len_name = strlen( src->name ) + 1, len_description = src->description ? strlen( src->description ) + 1 : 0;
 197         int len = sizeof(*dst) + len_name + len_description;
 198
 199         if (*params->buflen >= len_total + len)
 200         {
 201             dst->name_offset = sizeof(*dst);
 202             dst->name_len = len_name;
 203             strcpy( (char *)dst + dst->name_offset, src->name );
 204             if (!len_description) dst->description_offset = dst->description_len = 0;
 205             else
 206             {
 207                 dst->description_offset = dst->name_offset + len_name;
 208                 dst->description_len = len_description;
 209                 strcpy( (char *)dst + dst->description_offset, src->description );
 210             }
 211             dst->flags = src->flags;
 212             dst = (struct pcap_interface_offsets *)((char *)dst + len);
 213         }
 214         len_total += len;
 215         src = src->next;
 216     }
 217
 218     if (*params->buflen < len_total) ret = STATUS_BUFFER_TOO_SMALL;
 219     *params->buflen = len_total;
 220     pcap_freealldevs( devs );
 221     return ret;
 222 }
 223
 224 static NTSTATUS wrap_get_tstamp_precision( void *args )
 225 {
 226     const struct get_tstamp_precision_params *params = args;
 227     return pcap_get_tstamp_precision( (pcap_t *)(ULONG_PTR)params->handle );
 228 }
 229
 230 static NTSTATUS wrap_geterr( void *args )
 231 {
 232     const struct geterr_params *params = args;
 233     char *errbuf = pcap_geterr( (pcap_t *)(ULONG_PTR)params->handle );
 234     assert( strlen(errbuf) < PCAP_ERRBUF_SIZE );
 235     strcpy( params->errbuf, errbuf );
 236     return STATUS_SUCCESS;
 237 }
 238
 239 static NTSTATUS wrap_getnonblock( void *args )
 240 {
 241     const struct getnonblock_params *params = args;
 242     return pcap_getnonblock( (pcap_t *)(ULONG_PTR)params->handle, params->errbuf );
 243 }
 244
 245 static NTSTATUS wrap_init( void *args )
 246 {
 247     const struct init_params *params = args;
 248     return pcap_init( params->opt, params->errbuf );
 249 }
 250
 251 static NTSTATUS wrap_lib_version( void *args )
 252 {
 253     const struct lib_version_params *params = args;
 254     const char *str = pcap_lib_version();
 255     unsigned int len = min( strlen(str) + 1, params->size );
 256
 257     memcpy( params->version, str, len );
 258     params->version[len - 1] = 0;
 259     return STATUS_SUCCESS;
 260 }
 261
 262 static NTSTATUS wrap_list_datalinks( void *args )
 263 {
 264     const struct list_datalinks_params *params = args;
 265     NTSTATUS status = STATUS_SUCCESS;
 266     int *links = NULL, count;
 267
 268     if ((count = pcap_list_datalinks( (pcap_t *)(ULONG_PTR)params->handle, &links )) > 0)
 269     {
 270         if (*params->count < count) status = STATUS_BUFFER_TOO_SMALL;
 271         else memcpy( params->links, links, count * sizeof(*links) );
 272     }
 273     pcap_free_datalinks( links );
 274     *params->count = count;
 275     return status;
 276 }
 277
 278 static NTSTATUS wrap_list_tstamp_types( void *args )
 279 {
 280     const struct list_tstamp_types_params *params = args;
 281     NTSTATUS status = STATUS_SUCCESS;
 282     int *types = NULL, count;
 283
 284     if ((count = pcap_list_tstamp_types( (pcap_t *)(ULONG_PTR)params->handle, &types )) > 0)
 285     {
 286         if (*params->count < count) status = STATUS_BUFFER_TOO_SMALL;
 287         else memcpy( params->types, types, count * sizeof(*types) );
 288     }
 289     pcap_free_tstamp_types( types );
 290     *params->count = count;
 291     return status;
 292 }
 293
 294 static NTSTATUS wrap_lookupnet( void *args )
 295 {
 296     const struct lookupnet_params *params = args;
 297     return pcap_lookupnet( params->device, params->net, params->mask, params->errbuf );
 298 }
 299
 300 static NTSTATUS wrap_major_version( void *args )
 301 {
 302     const struct major_version_params *params = args;
 303     return pcap_major_version( (pcap_t *)(ULONG_PTR)params->handle );
 304 }
 305
 306 static NTSTATUS wrap_minor_version( void *args )
 307 {
 308     const struct minor_version_params *params = args;
 309     return pcap_minor_version( (pcap_t *)(ULONG_PTR)params->handle );
 310 }
 311
 312 static NTSTATUS wrap_next_ex( void *args )
 313 {
 314     struct next_ex_params *params = args;
 315     int ret;
 316
 317     if (sizeof(void *) == 4)
 318     {
 319         struct pcap_pkthdr_win32 *hdr32;
 320         if ((ret = pcap_next_ex( (pcap_t *)(ULONG_PTR)params->handle, (struct pcap_pkthdr **)&hdr32, params->data )) == 1)
 321         {
 322             params->hdr->ts.tv_sec  = hdr32->ts.tv_sec;
 323             params->hdr->ts.tv_usec = hdr32->ts.tv_usec;
 324             params->hdr->caplen     = hdr32->caplen;
 325             params->hdr->len        = hdr32->len;
 326         }
 327     }
 328     else
 329     {
 330         struct pcap_pkthdr *hdr64;
 331         if ((ret = pcap_next_ex( (pcap_t *)(ULONG_PTR)params->handle, &hdr64, params->data )) == 1)
 332         {
 333             if (hdr64->ts.tv_sec > INT_MAX || hdr64->ts.tv_usec > INT_MAX) WARN( "truncating timeval values(s)\n" );
 334             params->hdr->ts.tv_sec  = hdr64->ts.tv_sec;
 335             params->hdr->ts.tv_usec = hdr64->ts.tv_usec;
 336             params->hdr->caplen     = hdr64->caplen;
 337             params->hdr->len        = hdr64->len;
 338         }
 339     }
 340     return ret;
 341 }
 342
 343 static NTSTATUS wrap_open_live( void *args )
 344 {
 345     const struct open_live_params *params = args;
 346     if (!(*params->handle = (ULONG_PTR)pcap_open_live( params->source, params->snaplen, params->promisc,
 347                                                        params->timeout, params->errbuf ))) return STATUS_NO_MEMORY;
 348     return STATUS_SUCCESS;
 349 }
 350
 351 static NTSTATUS wrap_sendpacket( void *args )
 352 {
 353     const struct sendpacket_params *params = args;
 354     return pcap_sendpacket( (pcap_t *)(ULONG_PTR)params->handle, params->buf, params->size );
 355 }
 356
 357 static NTSTATUS wrap_set_buffer_size( void *args )
 358 {
 359     const struct set_buffer_size_params *params = args;
 360     return pcap_set_buffer_size( (pcap_t *)(ULONG_PTR)params->handle, params->size );
 361 }
 362
 363 static NTSTATUS wrap_set_datalink( void *args )
 364 {
 365     const struct set_datalink_params *params = args;
 366     return pcap_set_datalink( (pcap_t *)(ULONG_PTR)params->handle, params->link );
 367 }
 368
 369 static NTSTATUS wrap_set_promisc( void *args )
 370 {
 371     const struct set_promisc_params *params = args;
 372     return pcap_set_promisc( (pcap_t *)(ULONG_PTR)params->handle, params->enable );
 373 }
 374
 375 static NTSTATUS wrap_set_rfmon( void *args )
 376 {
 377     const struct set_rfmon_params *params = args;
 378     return pcap_set_rfmon( (pcap_t *)(ULONG_PTR)params->handle, params->enable );
 379 }
 380
 381 static NTSTATUS wrap_set_snaplen( void *args )
 382 {
 383     const struct set_snaplen_params *params = args;
 384     return pcap_set_snaplen( (pcap_t *)(ULONG_PTR)params->handle, params->len );
 385 }
 386
 387 static NTSTATUS wrap_set_timeout( void *args )
 388 {
 389     const struct set_timeout_params *params = args;
 390     return pcap_set_timeout( (pcap_t *)(ULONG_PTR)params->handle, params->timeout );
 391 }
 392
 393 static NTSTATUS wrap_set_tstamp_precision( void *args )
 394 {
 395     const struct set_tstamp_precision_params *params = args;
 396     return pcap_set_tstamp_precision( (pcap_t *)(ULONG_PTR)params->handle, params->precision );
 397 }
 398
 399 static NTSTATUS wrap_set_tstamp_type( void *args )
 400 {
 401     const struct set_tstamp_type_params *params = args;
 402     return pcap_set_tstamp_type( (pcap_t *)(ULONG_PTR)params->handle, params->type );
 403 }
 404
 405 static NTSTATUS wrap_setfilter( void *args )
 406 {
 407     const struct setfilter_params *params = args;
 408     struct bpf_program program = { params->program_len, params->program_insns };
 409     return pcap_setfilter( (pcap_t *)(ULONG_PTR)params->handle, &program );
 410 }
 411
 412 static NTSTATUS wrap_setnonblock( void *args )
 413 {
 414     const struct setnonblock_params *params = args;
 415     return pcap_setnonblock( (pcap_t *)(ULONG_PTR)params->handle, params->nonblock, params->errbuf );
 416 }
 417
 418 static NTSTATUS wrap_snapshot( void *args )
 419 {
 420     const struct snapshot_params *params = args;
 421     return pcap_snapshot( (pcap_t *)(ULONG_PTR)params->handle );
 422 }
 423
 424 static NTSTATUS wrap_stats( void *args )
 425 {
 426     struct stats_params *params = args;
 427     struct pcap_stat stat;
 428     int ret;
 429
 430     if (!(ret = pcap_stats( (pcap_t *)(ULONG_PTR)params->handle, &stat )))
 431     {
 432         params->stat.ps_recv    = stat.ps_recv;
 433         params->stat.ps_drop    = stat.ps_drop;
 434         params->stat.ps_ifdrop  = stat.ps_ifdrop;
 435         params->stat.ps_capt    = 0;
 436         params->stat.ps_sent    = 0;
 437         params->stat.ps_netdrop = 0;
 438     }
 439     return ret;
 440 }
 441
 442 static NTSTATUS wrap_tstamp_type_name_to_val( void *args )
 443 {
 444     const struct tstamp_type_name_to_val_params *params = args;
 445     return pcap_tstamp_type_name_to_val( params->name );
 446 }
 447
 448 static NTSTATUS wrap_tstamp_type_val_to_description( void *args )
 449 {
 450     const struct tstamp_type_val_to_description_params *params = args;
 451     const char *str = pcap_tstamp_type_val_to_description( params->type );
 452     int len;
 453
 454     if (!str || !params->buf) return STATUS_INVALID_PARAMETER;
 455     if ((len = strlen( str )) >= *params->buflen)
 456     {
 457         *params->buflen = len + 1;
 458         return STATUS_BUFFER_TOO_SMALL;
 459     }
 460     strcpy( params->buf, str );
 461     return STATUS_SUCCESS;
 462 }
 463
 464 static NTSTATUS wrap_tstamp_type_val_to_name( void *args )
 465 {
 466     const struct tstamp_type_val_to_name_params *params = args;
 467     const char *str = pcap_tstamp_type_val_to_name( params->type );
 468     int len;
 469
 470     if (!str || !params->buf) return STATUS_INVALID_PARAMETER;
 471     if ((len = strlen( str )) >= *params->buflen)
 472     {
 473         *params->buflen = len + 1;
 474         return STATUS_BUFFER_TOO_SMALL;
 475     }
 476     strcpy( params->buf, str );
 477     return STATUS_SUCCESS;
 478 }
 479
 480 const unixlib_entry_t __wine_unix_call_funcs[] =
 481 {
 482     wrap_activate,
 483     wrap_breakloop,
 484     wrap_bufsize,
 485     wrap_can_set_rfmon,
 486     wrap_close,
 487     wrap_compile,
 488     wrap_create,
 489     wrap_datalink,
 490     wrap_datalink_name_to_val,
 491     wrap_datalink_val_to_description,
 492     wrap_datalink_val_to_name,
 493     wrap_dump,
 494     wrap_dump_close,
 495     wrap_dump_open,
 496     wrap_findalldevs,
 497     wrap_get_tstamp_precision,
 498     wrap_geterr,
 499     wrap_getnonblock,
 500     wrap_init,
 501     wrap_lib_version,
 502     wrap_list_datalinks,
 503     wrap_list_tstamp_types,
 504     wrap_lookupnet,
 505     wrap_major_version,
 506     wrap_minor_version,
 507     wrap_next_ex,
 508     wrap_open_live,
 509     wrap_sendpacket,
 510     wrap_set_buffer_size,
 511     wrap_set_datalink,
 512     wrap_set_promisc,
 513     wrap_set_rfmon,
 514     wrap_set_snaplen,
 515     wrap_set_timeout,
 516     wrap_set_tstamp_precision,
 517     wrap_set_tstamp_type,
 518     wrap_setfilter,
 519     wrap_setnonblock,
 520     wrap_snapshot,
 521     wrap_stats,
 522     wrap_tstamp_type_name_to_val,
 523     wrap_tstamp_type_val_to_description,
 524     wrap_tstamp_type_val_to_name,
 525 };
 526
 527 C_ASSERT( ARRAYSIZE(__wine_unix_call_funcs) == unix_funcs_count );
 528
 529 #ifdef _WIN64
 530
 531 typedef ULONG PTR32;
 532
 533 static NTSTATUS wow64_compile( void *args )
 534 {
 535     struct
 536     {
 537         UINT64 handle;
 538         PTR32 program_len;
 539         PTR32 program_insns;
 540         PTR32 str;
 541         int optimize;
 542         unsigned int mask;
 543     } const *params32 = args;
 544
 545     struct compile_params params =
 546     {
 547         params32->handle,
 548         ULongToPtr(params32->program_len),
 549         ULongToPtr(params32->program_insns),
 550         ULongToPtr(params32->str),
 551         params32->optimize,
 552         params32->mask
 553     };
 554     return wrap_compile( &params );
 555 }
 556
 557 static NTSTATUS wow64_create( void *args )
 558 {
 559     struct
 560     {
 561         PTR32 source;
 562         PTR32 errbuf;
 563         PTR32 handle;
 564     } const *params32 = args;
 565
 566     struct create_params params =
 567     {
 568         ULongToPtr(params32->source),
 569         ULongToPtr(params32->errbuf),
 570         ULongToPtr(params32->handle),
 571     };
 572     return wrap_create( &params );
 573 }
 574
 575 static NTSTATUS wow64_datalink_name_to_val( void *args )
 576 {
 577     struct
 578     {
 579         PTR32 name;
 580     } const *params32 = args;
 581
 582     struct datalink_name_to_val_params params =
 583     {
 584         ULongToPtr(params32->name),
 585     };
 586     return wrap_datalink_name_to_val( &params );
 587 }
 588
 589 static NTSTATUS wow64_datalink_val_to_description( void *args )
 590 {
 591     struct
 592     {
 593         int link;
 594         PTR32 buf;
 595         PTR32 buflen;
 596     } const *params32 = args;
 597
 598     struct datalink_val_to_description_params params =
 599     {
 600         params32->link,
 601         ULongToPtr(params32->buf),
 602         ULongToPtr(params32->buflen)
 603     };
 604     return wrap_datalink_val_to_description( &params );
 605 }
 606
 607 static NTSTATUS wow64_datalink_val_to_name( void *args )
 608 {
 609     struct
 610     {
 611         int link;
 612         PTR32 buf;
 613         PTR32 buflen;
 614     } const *params32 = args;
 615
 616     struct datalink_val_to_name_params params =
 617     {
 618         params32->link,
 619         ULongToPtr(params32->buf),
 620         ULongToPtr(params32->buflen)
 621     };
 622     return wrap_datalink_val_to_name( &params );
 623 }
 624
 625 static NTSTATUS wow64_dump( void *args )
 626 {
 627     struct
 628     {
 629         PTR32 user;
 630         PTR32 hdr;
 631         PTR32 packet;
 632     } const *params32 = args;
 633
 634     struct dump_params params =
 635     {
 636         ULongToPtr(params32->user),
 637         ULongToPtr(params32->hdr),
 638         ULongToPtr(params32->packet)
 639     };
 640     return wrap_dump( &params );
 641 }
 642
 643 static NTSTATUS wow64_dump_open( void *args )
 644 {
 645     struct
 646     {
 647         UINT64 handle;
 648         PTR32 name;
 649         PTR32 ret_handle;
 650     } const *params32 = args;
 651
 652     struct datalink_val_to_name_params params =
 653     {
 654         params32->handle,
 655         ULongToPtr(params32->name),
 656         ULongToPtr(params32->ret_handle)
 657     };
 658     return wrap_dump_open( &params );
 659 }
 660
 661 static NTSTATUS wow64_findalldevs( void *args )
 662 {
 663     struct
 664     {
 665         PTR32 buf;
 666         PTR32 buflen;
 667         PTR32 errbuf;
 668     } const *params32 = args;
 669
 670     struct findalldevs_params params =
 671     {
 672         ULongToPtr(params32->buf),
 673         ULongToPtr(params32->buflen),
 674         ULongToPtr(params32->errbuf)
 675     };
 676     return wrap_findalldevs( &params );
 677 }
 678
 679 static NTSTATUS wow64_geterr( void *args )
 680 {
 681     struct
 682     {
 683         UINT64 handle;
 684         PTR32 errbuf;
 685     } const *params32 = args;
 686
 687     struct geterr_params params =
 688     {
 689         params32->handle,
 690         ULongToPtr(params32->errbuf)
 691     };
 692     return wrap_geterr( &params );
 693 }
 694
 695 static NTSTATUS wow64_getnonblock( void *args )
 696 {
 697     struct
 698     {
 699         UINT64 handle;
 700         PTR32 errbuf;
 701     } const *params32 = args;
 702
 703     struct getnonblock_params params =
 704     {
 705         params32->handle,
 706         ULongToPtr(params32->errbuf)
 707     };
 708     return wrap_getnonblock( &params );
 709 }
 710
 711 static NTSTATUS wow64_init( void *args )
 712 {
 713     struct
 714     {
 715         int opt;
 716         PTR32 errbuf;
 717     } const *params32 = args;
 718
 719     struct init_params params =
 720     {
 721         params32->opt,
 722         ULongToPtr(params32->errbuf)
 723     };
 724     return wrap_init( &params );
 725 }
 726
 727 static NTSTATUS wow64_lib_version( void *args )
 728 {
 729     struct
 730     {
 731         PTR32 version;
 732         unsigned int size;
 733     } const *params32 = args;
 734
 735     struct lib_version_params params =
 736     {
 737         ULongToPtr(params32->version),
 738         params32->size
 739     };
 740     return wrap_lib_version( &params );
 741 }
 742
 743 static NTSTATUS wow64_list_datalinks( void *args )
 744 {
 745     struct
 746     {
 747         UINT64 handle;
 748         PTR32 links;
 749         PTR32 count;
 750     } const *params32 = args;
 751
 752     struct list_datalinks_params params =
 753     {
 754         params32->handle,
 755         ULongToPtr(params32->links),
 756         ULongToPtr(params32->count)
 757     };
 758     return wrap_list_datalinks( &params );
 759 }
 760
 761 static NTSTATUS wow64_list_tstamp_types( void *args )
 762 {
 763     struct
 764     {
 765         UINT64 handle;
 766         PTR32 types;
 767         PTR32 count;
 768     } const *params32 = args;
 769
 770     struct list_tstamp_types_params params =
 771     {
 772         params32->handle,
 773         ULongToPtr(params32->types),
 774         ULongToPtr(params32->count)
 775     };
 776     return wrap_list_tstamp_types( &params );
 777 }
 778
 779 static NTSTATUS wow64_lookupnet( void *args )
 780 {
 781     struct
 782     {
 783         PTR32 device;
 784         PTR32 net;
 785         PTR32 mask;
 786         PTR32 errbuf;
 787     } const *params32 = args;
 788
 789     struct lookupnet_params params =
 790     {
 791         ULongToPtr(params32->device),
 792         ULongToPtr(params32->net),
 793         ULongToPtr(params32->mask),
 794         ULongToPtr(params32->errbuf)
 795     };
 796     return wrap_lookupnet( &params );
 797 }
 798
 799 static NTSTATUS wow64_next_ex( void *args )
 800 {
 801     struct
 802     {
 803         UINT64 handle;
 804         PTR32 hdr;
 805         PTR32 data;
 806     } const *params32 = args;
 807
 808     struct next_ex_params params =
 809     {
 810         params32->handle,
 811         ULongToPtr(params32->hdr),
 812         ULongToPtr(params32->data)
 813     };
 814     return wrap_next_ex( &params );
 815 }
 816
 817 static NTSTATUS wow64_open_live( void *args )
 818 {
 819     struct
 820     {
 821         PTR32 source;
 822         int snaplen;
 823         int promisc;
 824         int timeout;
 825         PTR32 errbuf;
 826         PTR32 handle;
 827     } const *params32 = args;
 828
 829     struct open_live_params params =
 830     {
 831         ULongToPtr(params32->source),
 832         params32->snaplen,
 833         params32->promisc,
 834         params32->timeout,
 835         ULongToPtr(params32->errbuf),
 836         ULongToPtr(params32->handle)
 837     };
 838     return wrap_open_live( &params );
 839 }
 840
 841 static NTSTATUS wow64_sendpacket( void *args )
 842 {
 843     struct
 844     {
 845         UINT64 handle;
 846         PTR32 buf;
 847         int size;
 848     } const *params32 = args;
 849
 850     struct sendpacket_params params =
 851     {
 852         params32->handle,
 853         ULongToPtr(params32->buf),
 854         params32->size
 855     };
 856     return wrap_sendpacket( &params );
 857 }
 858
 859 static NTSTATUS wow64_setfilter( void *args )
 860 {
 861     struct
 862     {
 863         UINT64 handle;
 864         unsigned int program_len;
 865         PTR32 program_insns;
 866     } const *params32 = args;
 867
 868     struct setfilter_params params =
 869     {
 870         params32->handle,
 871         params32->program_len,
 872         ULongToPtr(params32->program_insns)
 873     };
 874     return wrap_setfilter( &params );
 875 }
 876
 877 static NTSTATUS wow64_setnonblock( void *args )
 878 {
 879     struct
 880     {
 881         UINT64 handle;
 882         int nonblock;
 883         PTR32 errbuf;
 884     } const *params32 = args;
 885
 886     struct setnonblock_params params =
 887     {
 888         params32->handle,
 889         params32->nonblock,
 890         ULongToPtr(params32->errbuf)
 891     };
 892     return wrap_setnonblock( &params );
 893 }
 894
 895 static NTSTATUS wow64_tstamp_type_name_to_val( void *args )
 896 {
 897     struct
 898     {
 899         PTR32 name;
 900     } const *params32 = args;
 901
 902     struct tstamp_type_name_to_val_params params =
 903     {
 904         ULongToPtr(params32->name)
 905     };
 906     return wrap_tstamp_type_name_to_val( &params );
 907 }
 908
 909 static NTSTATUS wow64_tstamp_type_val_to_description( void *args )
 910 {
 911     struct
 912     {
 913         int type;
 914         PTR32 buf;
 915         PTR32 buflen;
 916     } const *params32 = args;
 917
 918     struct tstamp_type_val_to_description_params params =
 919     {
 920         params32->type,
 921         ULongToPtr(params32->buf),
 922         ULongToPtr(params32->buflen)
 923     };
 924     return wrap_tstamp_type_val_to_description( &params );
 925 }
 926
 927 static NTSTATUS wow64_tstamp_type_val_to_name( void *args )
 928 {
 929     struct
 930     {
 931         int type;
 932         PTR32 buf;
 933         PTR32 buflen;
 934     } const *params32 = args;
 935
 936     struct tstamp_type_val_to_name_params params =
 937     {
 938         params32->type,
 939         ULongToPtr(params32->buf),
 940         ULongToPtr(params32->buflen)
 941     };
 942     return wrap_tstamp_type_val_to_name( &params );
 943 }
 944
 945 const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
 946 {
 947     wrap_activate,
 948     wrap_breakloop,
 949     wrap_bufsize,
 950     wrap_can_set_rfmon,
 951     wrap_close,
 952     wow64_compile,
 953     wow64_create,
 954     wrap_datalink,
 955     wow64_datalink_name_to_val,
 956     wow64_datalink_val_to_description,
 957     wow64_datalink_val_to_name,
 958     wow64_dump,
 959     wrap_dump_close,
 960     wow64_dump_open,
 961     wow64_findalldevs,
 962     wrap_get_tstamp_precision,
 963     wow64_geterr,
 964     wow64_getnonblock,
 965     wow64_init,
 966     wow64_lib_version,
 967     wow64_list_datalinks,
 968     wow64_list_tstamp_types,
 969     wow64_lookupnet,
 970     wrap_major_version,
 971     wrap_minor_version,
 972     wow64_next_ex,
 973     wow64_open_live,
 974     wow64_sendpacket,
 975     wrap_set_buffer_size,
 976     wrap_set_datalink,
 977     wrap_set_promisc,
 978     wrap_set_rfmon,
 979     wrap_set_snaplen,
 980     wrap_set_timeout,
 981     wrap_set_tstamp_precision,
 982     wrap_set_tstamp_type,
 983     wow64_setfilter,
 984     wow64_setnonblock,
 985     wrap_snapshot,
 986     wrap_stats,
 987     wow64_tstamp_type_name_to_val,
 988     wow64_tstamp_type_val_to_description,
 989     wow64_tstamp_type_val_to_name,
 990 };
 991
 992 C_ASSERT( ARRAYSIZE(__wine_unix_call_wow64_funcs) == unix_funcs_count );
 993
 994 #endif /* _WIN64 */
 995
 996 #endif /* HAVE_PCAP_PCAP_H */