dlls/winscard/unixlib.c

   1 /*
   2  * Copyright 2022 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #if 0
  20 #pragma makedep unix
  21 #endif
  22
  23 #include <stdarg.h>
  24 #include <stdlib.h>
  25 #include "ntstatus.h"
  26 #define WIN32_NO_STATUS
  27 #include "windef.h"
  28 #include "winternl.h"
  29 #include "winbase.h"
  30
  31 #include "wine/unixlib.h"
  32 #include "unixlib.h"
  33
  34 #ifdef __APPLE__
  35 LONG SCardEstablishContext( UINT32, const void *, const void *, UINT32 * );
  36 LONG SCardReleaseContext( UINT32 );
  37 LONG SCardIsValidContext( UINT32 );
  38 LONG SCardGetStatusChange( UINT32, UINT32, void *, UINT32 );
  39 LONG SCardCancel( UINT32 );
  40 LONG SCardListReaders( UINT32, const char *, char *, UINT32 * );
  41 LONG SCardListReaderGroups( UINT32, char *, UINT32 * );
  42 LONG SCardConnect( UINT32, const char *, UINT32, UINT32, UINT32 *, UINT32 * );
  43 LONG SCardStatus( UINT32, char *, UINT32 *, UINT32 *, UINT32 *, BYTE *, UINT32 * );
  44 LONG SCardDisconnect( UINT32, UINT32 );
  45 LONG SCardReconnect( UINT32, UINT32, UINT32, UINT32, UINT32 * );
  46 LONG SCardBeginTransaction( UINT32 );
  47 LONG SCardEndTransaction( UINT32, UINT32 );
  48 LONG SCardTransmit( UINT32, const void *, const BYTE *, UINT32, void *, BYTE *, UINT32 * );
  49 LONG SCardControl132( UINT32, UINT32, const void *, UINT32, void *, UINT32, UINT32 * );
  50 LONG SCardGetAttrib( UINT32, UINT32, BYTE *, UINT32 * );
  51 LONG SCardSetAttrib( UINT32, UINT32, const BYTE *, UINT32 );
  52 #else
  53 LONG SCardEstablishContext( UINT64, const void *, const void *, UINT64 * );
  54 LONG SCardReleaseContext( UINT64 );
  55 LONG SCardIsValidContext( UINT64 );
  56 LONG SCardGetStatusChange( UINT64, UINT64, void *, UINT64 );
  57 LONG SCardCancel( UINT64 );
  58 LONG SCardListReaders( UINT64, const char *, char *, UINT64 * );
  59 LONG SCardListReaderGroups( UINT64, char *, UINT64 * );
  60 LONG SCardConnect( UINT64, const char *, UINT64, UINT64, UINT64 *, UINT64 * );
  61 LONG SCardStatus( UINT64, char *, UINT64 *, UINT64 *, UINT64 *, BYTE *, UINT64 * );
  62 LONG SCardDisconnect( UINT64, UINT64 );
  63 LONG SCardReconnect( UINT64, UINT64, UINT64, UINT64, UINT64 * );
  64 LONG SCardBeginTransaction( UINT64 );
  65 LONG SCardEndTransaction( UINT64, UINT64 );
  66 LONG SCardTransmit( UINT64, const void *, const BYTE *, UINT64, void *, BYTE *, UINT64 * );
  67 LONG SCardControl( UINT64, UINT64, const void *, UINT64, void *, UINT64, UINT64 * );
  68 LONG SCardGetAttrib( UINT64, UINT64, BYTE *, UINT64 * );
  69 LONG SCardSetAttrib( UINT64, UINT64, const BYTE *, UINT64 );
  70 #endif
  71
  72 static NTSTATUS scard_establish_context( void *args )
  73 {
  74     struct scard_establish_context_params *params = args;
  75 #ifdef __APPLE__
  76     NTSTATUS status;
  77     UINT32 handle;
  78     if (!(status = SCardEstablishContext( params->scope, NULL, NULL, &handle ))) *params->handle = handle;
  79     return status;
  80 #else
  81     return SCardEstablishContext( params->scope, NULL, NULL, params->handle );
  82 #endif
  83 }
  84
  85 static NTSTATUS scard_release_context( void *args )
  86 {
  87     struct scard_release_context_params *params = args;
  88     return SCardReleaseContext( params->handle );
  89 }
  90
  91 static NTSTATUS scard_is_valid_context( void *args )
  92 {
  93     struct scard_is_valid_context_params *params = args;
  94     return SCardIsValidContext( params->handle );
  95 }
  96
  97 #ifdef __APPLE__
  98 struct reader_state_macos
  99 {
 100     UINT64 reader;
 101     UINT64 userdata;
 102     UINT32 current_state;
 103     UINT32 event_state;
 104     UINT32 atr_size;
 105     unsigned char atr[MAX_ATR_SIZE];
 106 };
 107
 108 static struct reader_state_macos *map_states_in( const struct reader_state *state, unsigned int count )
 109 {
 110     struct reader_state_macos *ret;
 111     unsigned int i;
 112
 113     if (!(ret = malloc( sizeof(*ret) * count ))) return NULL;
 114     for (i = 0; i < count; i++)
 115     {
 116         ret[i].reader = state[i].reader;
 117         ret[i].userdata = state[i].userdata;
 118         ret[i].current_state = state[i].current_state;
 119         ret[i].event_state = state[i].event_state;
 120         memcpy( ret[i].atr, state[i].atr, state[i].atr_size );
 121         ret[i].atr_size = state[i].atr_size;
 122     }
 123     return ret;
 124 }
 125
 126 static void map_states_out( const struct reader_state_macos *state_macos, struct reader_state *state, unsigned int count )
 127 {
 128     unsigned int i;
 129     for (i = 0; i < count; i++)
 130     {
 131         state[i].current_state = state_macos[i].current_state;
 132         state[i].event_state = state_macos[i].event_state;
 133         memcpy( state[i].atr, state_macos[i].atr, state_macos[i].atr_size );
 134         state[i].atr_size = state_macos[i].atr_size;
 135     }
 136 }
 137 #endif
 138
 139 static NTSTATUS scard_get_status_change( void *args )
 140 {
 141     struct scard_get_status_change_params *params = args;
 142 #ifdef __APPLE__
 143     NTSTATUS status;
 144     struct reader_state_macos *states = map_states_in( params->states, params->count );
 145
 146     if (!states) return STATUS_NO_MEMORY;
 147     if (!(status = SCardGetStatusChange( params->handle, params->timeout, states, params->count )))
 148         map_states_out( states, params->states, params->count );
 149     free( states );
 150     return status;
 151 #else
 152     return SCardGetStatusChange( params->handle, params->timeout, params->states, params->count );
 153 #endif
 154 }
 155
 156 static NTSTATUS scard_cancel( void *args )
 157 {
 158     struct scard_cancel_params *params = args;
 159     return SCardCancel( params->handle );
 160 }
 161
 162 static NTSTATUS scard_list_readers( void *args )
 163 {
 164     struct scard_list_readers_params *params = args;
 165 #ifdef __APPLE__
 166     NTSTATUS status;
 167     UINT32 len = *params->readers_len;
 168     if (!(status = SCardListReaders( params->handle, params->groups, params->readers, &len ))) *params->readers_len = len;
 169     return status;
 170 #else
 171     return SCardListReaders( params->handle, params->groups, params->readers, params->readers_len );
 172 #endif
 173 }
 174
 175 static NTSTATUS scard_list_reader_groups( void *args )
 176 {
 177     struct scard_list_reader_groups_params *params = args;
 178 #ifdef __APPLE__
 179     NTSTATUS status;
 180     UINT32 len = *params->groups_len;
 181     if (!(status = SCardListReaderGroups( params->handle, params->groups, &len ))) *params->groups_len = len;
 182     return status;
 183 #else
 184     return SCardListReaderGroups( params->handle, params->groups, params->groups_len );
 185 #endif
 186 }
 187
 188 static NTSTATUS scard_connect( void *args )
 189 {
 190     struct scard_connect_params *params = args;
 191 #ifdef __APPLE__
 192     NTSTATUS status;
 193     UINT32 handle, protocol;
 194     if (!(status = SCardConnect( params->context_handle, params->reader, params->share_mode,
 195                                  params->preferred_protocols, &handle, &protocol )))
 196     {
 197         *params->connect_handle = handle;
 198         *params->protocol = protocol;
 199     }
 200     return status;
 201 #else
 202     return SCardConnect( params->context_handle, params->reader, params->share_mode, params->preferred_protocols,
 203                          params->connect_handle, params->protocol );
 204 #endif
 205 }
 206
 207 static NTSTATUS scard_status( void *args )
 208 {
 209     struct scard_status_params *params = args;
 210 #ifdef __APPLE__
 211     NTSTATUS status;
 212     UINT32 names_len = params->names_len ? *params->names_len : 0;
 213     UINT32 atr_len = params->atr_len ? *params->atr_len : 0;
 214     UINT32 state, protocol;
 215
 216     if (!(status = SCardStatus( params->handle, params->names, params->names_len ? &names_len : NULL,
 217                                 params->state ? &state : NULL, params->protocol ? &protocol : NULL, params->atr,
 218                                 params->atr_len ? &atr_len : NULL )))
 219     {
 220         if (params->names_len) *params->names_len = names_len;
 221         if (params->state) *params->state = state;
 222         if (params->protocol) *params->protocol = protocol;
 223         if (params->atr_len) *params->atr_len = atr_len;
 224     }
 225     return status;
 226 #else
 227     return SCardStatus( params->handle, params->names, params->names_len, params->state, params->protocol,
 228                         params->atr, params->atr_len );
 229 #endif
 230 }
 231
 232 static NTSTATUS scard_reconnect( void *args )
 233 {
 234     struct scard_reconnect_params *params = args;
 235 #ifdef __APPLE__
 236     NTSTATUS status;
 237     UINT32 protocol;
 238     if (!(status = SCardReconnect( params->handle, params->share_mode, params->preferred_protocols,
 239                                    params->initialization, &protocol ))) *params->protocol = protocol;
 240     return status;
 241 #else
 242     return SCardReconnect( params->handle, params->share_mode, params->preferred_protocols, params->initialization,
 243                            params->protocol );
 244 #endif
 245 }
 246
 247 static NTSTATUS scard_disconnect( void *args )
 248 {
 249     struct scard_disconnect_params *params = args;
 250     return SCardDisconnect( params->handle, params->disposition );
 251 }
 252
 253 static NTSTATUS scard_begin_transaction( void *args )
 254 {
 255     struct scard_begin_transaction_params *params = args;
 256     return SCardBeginTransaction( params->handle );
 257 }
 258
 259 static NTSTATUS scard_end_transaction( void *args )
 260 {
 261     struct scard_end_transaction_params *params = args;
 262     return SCardEndTransaction( params->handle, params->disposition );
 263 }
 264
 265 static NTSTATUS scard_transmit( void *args )
 266 {
 267     struct scard_transmit_params *params = args;
 268 #ifdef __APPLE__
 269     NTSTATUS status;
 270     UINT32 len = *params->recv_buflen;
 271     struct
 272     {
 273         UINT32 protocol;
 274         UINT32 pci_len;
 275     } send, recv;
 276
 277     send.protocol = params->send->protocol;
 278     send.pci_len = params->send->pci_len;
 279     if (params->recv)
 280     {
 281         recv.protocol = params->recv->protocol;
 282         recv.pci_len = params->recv->pci_len;
 283     }
 284     if (!(status = SCardTransmit( params->handle, &send, params->send_buf, params->send_buflen, &recv,
 285                                   params->recv_buf, &len )))
 286     {
 287         if (params->recv)
 288         {
 289             params->recv->protocol = recv.protocol;
 290             params->recv->pci_len = recv.pci_len;
 291         }
 292         *params->recv_buflen = len;
 293     }
 294     return status;
 295 #else
 296     return SCardTransmit( params->handle, params->send, params->send_buf, params->send_buflen, params->recv,
 297                           params->recv_buf, params->recv_buflen );
 298 #endif
 299 }
 300
 301 static NTSTATUS scard_control( void *args )
 302 {
 303     struct scard_control_params *params = args;
 304 #ifdef __APPLE__
 305     NTSTATUS status;
 306     UINT32 len;
 307     if (!(status = SCardControl132( params->handle, params->code, params->in_buf, params->in_buflen, params->out_buf,
 308                                     params->out_buflen, &len )))
 309         *params->ret_len = len;
 310     return status;
 311 #else
 312     return SCardControl( params->handle, params->code, params->in_buf, params->in_buflen, params->out_buf,
 313                          params->out_buflen, params->ret_len );
 314 #endif
 315 }
 316
 317 static NTSTATUS scard_get_attrib( void *args )
 318 {
 319     struct scard_get_attrib_params *params = args;
 320 #ifdef __APPLE__
 321     NTSTATUS status;
 322     UINT32 len = *params->attr_len;
 323     if (!(status = SCardGetAttrib( params->handle, params->id, params->attr, &len ))) *params->attr_len = len;
 324     return status;
 325 #else
 326     return SCardGetAttrib( params->handle, params->id, params->attr, params->attr_len );
 327 #endif
 328 }
 329
 330 static NTSTATUS scard_set_attrib( void *args )
 331 {
 332     struct scard_set_attrib_params *params = args;
 333     return SCardSetAttrib( params->handle, params->id, params->attr, params->attr_len );
 334 }
 335
 336 const unixlib_entry_t __wine_unix_call_funcs[] =
 337 {
 338     scard_establish_context,
 339     scard_release_context,
 340     scard_is_valid_context,
 341     scard_get_status_change,
 342     scard_cancel,
 343     scard_list_readers,
 344     scard_list_reader_groups,
 345     scard_connect,
 346     scard_status,
 347     scard_reconnect,
 348     scard_disconnect,
 349     scard_begin_transaction,
 350     scard_end_transaction,
 351     scard_transmit,
 352     scard_control,
 353     scard_get_attrib,
 354     scard_set_attrib,
 355 };
 356
 357 C_ASSERT( ARRAYSIZE(__wine_unix_call_funcs) == unix_funcs_count );
 358
 359 #ifdef _WIN64
 360
 361 typedef ULONG PTR32;
 362
 363 static NTSTATUS wow64_scard_establish_context( void *args )
 364 {
 365     struct
 366     {
 367         UINT64 scope;
 368         PTR32 handle;
 369     } const *params32 = args;
 370
 371     struct scard_establish_context_params params =
 372     {
 373         params32->scope,
 374         ULongToPtr(params32->handle)
 375     };
 376     return scard_establish_context( &params );
 377 }
 378
 379 static NTSTATUS wow64_scard_release_context( void *args )
 380 {
 381     struct
 382     {
 383         UINT64 handle;
 384     } const *params32 = args;
 385
 386     struct scard_release_context_params params =
 387     {
 388         params32->handle
 389     };
 390     return scard_release_context( &params );
 391 }
 392
 393 static NTSTATUS wow64_scard_is_valid_context( void *args )
 394 {
 395     struct
 396     {
 397         UINT64 handle;
 398     } const *params32 = args;
 399
 400     struct scard_is_valid_context_params params =
 401     {
 402         params32->handle
 403     };
 404     return scard_is_valid_context( &params );
 405 }
 406
 407 static NTSTATUS wow64_scard_get_status_change( void *args )
 408 {
 409     struct
 410     {
 411         UINT64 handle;
 412         UINT64 timeout;
 413         PTR32 states;
 414         UINT64 count;
 415     } const *params32 = args;
 416
 417     struct scard_get_status_change_params params =
 418     {
 419         params32->handle,
 420         params32->timeout,
 421         ULongToPtr(params32->states),
 422         params32->count,
 423     };
 424     return scard_get_status_change( &params );
 425 }
 426
 427 static NTSTATUS wow64_scard_cancel( void *args )
 428 {
 429     struct
 430     {
 431         UINT64 handle;
 432     } const *params32 = args;
 433
 434     struct scard_cancel_params params =
 435     {
 436         params32->handle
 437     };
 438     return scard_cancel( &params );
 439 }
 440
 441 static NTSTATUS wow64_scard_list_readers( void *args )
 442 {
 443     struct
 444     {
 445         UINT64 handle;
 446         PTR32 groups;
 447         PTR32 readers;
 448         PTR32 readers_len;
 449     } *params32 = args;
 450
 451     struct scard_list_readers_params params =
 452     {
 453         params32->handle,
 454         ULongToPtr(params32->groups),
 455         ULongToPtr(params32->readers),
 456         ULongToPtr(params32->readers_len)
 457     };
 458     return scard_list_readers( &params );
 459 };
 460
 461 static NTSTATUS wow64_scard_list_reader_groups( void *args )
 462 {
 463     struct
 464     {
 465         UINT64 handle;
 466         PTR32 groups;
 467         PTR32 groups_len;
 468     } *params32 = args;
 469
 470     struct scard_list_reader_groups_params params =
 471     {
 472         params32->handle,
 473         ULongToPtr(params32->groups),
 474         ULongToPtr(params32->groups_len)
 475     };
 476     return scard_list_reader_groups( &params );
 477 }
 478
 479 static NTSTATUS wow64_scard_connect( void *args )
 480 {
 481     struct
 482     {
 483         UINT64 context_handle;
 484         PTR32 reader;
 485         UINT64 share_mode;
 486         UINT64 preferred_protocols;
 487         PTR32 connect_handle;
 488         PTR32 protocol;
 489     } *params32 = args;
 490
 491     struct scard_connect_params params =
 492     {
 493         params32->context_handle,
 494         ULongToPtr(params32->reader),
 495         params32->share_mode,
 496         params32->preferred_protocols,
 497         ULongToPtr(params32->connect_handle),
 498         ULongToPtr(params32->protocol)
 499     };
 500     return scard_connect( &params );
 501 }
 502
 503 static NTSTATUS wow64_scard_status( void *args )
 504 {
 505     struct
 506     {
 507         UINT64 handle;
 508         PTR32 names;
 509         PTR32 names_len;
 510         PTR32 state;
 511         PTR32 protocol;
 512         PTR32 atr;
 513         PTR32 atr_len;
 514     } *params32 = args;
 515
 516     struct scard_status_params params =
 517     {
 518         params32->handle,
 519         ULongToPtr(params32->names),
 520         ULongToPtr(params32->names_len),
 521         ULongToPtr(params32->state),
 522         ULongToPtr(params32->protocol),
 523         ULongToPtr(params32->atr),
 524         ULongToPtr(params32->atr_len)
 525     };
 526     return scard_status( &params );
 527 };
 528
 529 static NTSTATUS wow64_scard_reconnect( void *args )
 530 {
 531     struct
 532     {
 533         UINT64 handle;
 534         UINT64 share_mode;
 535         UINT64 preferred_protocols;
 536         UINT64 initialization;
 537         PTR32 protocol;
 538     } *params32 = args;
 539
 540     struct scard_reconnect_params params =
 541     {
 542         params32->handle,
 543         params32->share_mode,
 544         params32->preferred_protocols,
 545         params32->initialization,
 546         ULongToPtr(params32->protocol)
 547     };
 548     return scard_reconnect( &params );
 549 }
 550
 551 static NTSTATUS wow64_scard_disconnect( void *args )
 552 {
 553     struct
 554     {
 555         UINT64 handle;
 556         UINT64 disposition;
 557     } *params32 = args;
 558
 559     struct scard_disconnect_params params =
 560     {
 561         params32->handle,
 562         params32->disposition
 563     };
 564     return scard_disconnect( &params );
 565 }
 566
 567 static NTSTATUS wow64_scard_begin_transaction( void *args )
 568 {
 569     struct
 570     {
 571         UINT64 handle;
 572     } *params32 = args;
 573
 574     struct scard_begin_transaction_params params =
 575     {
 576         params32->handle
 577     };
 578     return scard_begin_transaction( &params );
 579 }
 580
 581 static NTSTATUS wow64_scard_end_transaction( void *args )
 582 {
 583     struct
 584     {
 585         UINT64 handle;
 586         UINT64 disposition;
 587     } *params32 = args;
 588
 589     struct scard_end_transaction_params params =
 590     {
 591         params32->handle,
 592         params32->disposition
 593     };
 594     return scard_end_transaction( &params );
 595 }
 596
 597 static NTSTATUS wow64_scard_transmit( void *args )
 598 {
 599     struct
 600     {
 601         UINT64 handle;
 602         PTR32 send;
 603         PTR32 send_buf;
 604         UINT64 send_buflen;
 605         PTR32 recv;
 606         PTR32 recv_buf;
 607         PTR32 recv_buflen;
 608     } *params32 = args;
 609
 610     struct scard_transmit_params params =
 611     {
 612         params32->handle,
 613         ULongToPtr(params32->send),
 614         ULongToPtr(params32->send_buf),
 615         params32->send_buflen,
 616         ULongToPtr(params32->recv),
 617         ULongToPtr(params32->recv_buf),
 618         ULongToPtr(params32->recv_buflen)
 619     };
 620     return scard_transmit( &params );
 621 };
 622
 623 static NTSTATUS wow64_scard_control( void *args )
 624 {
 625     struct
 626     {
 627         UINT64 handle;
 628         UINT64 code;
 629         PTR32 in_buf;
 630         UINT64 in_buflen;
 631         PTR32 out_buf;
 632         UINT64 out_buflen;
 633         PTR32 ret_len;
 634     } *params32 = args;
 635
 636     struct scard_control_params params =
 637     {
 638         params32->handle,
 639         params32->code,
 640         ULongToPtr(params32->in_buf),
 641         params32->in_buflen,
 642         ULongToPtr(params32->out_buf),
 643         params32->out_buflen,
 644         ULongToPtr(params32->ret_len)
 645     };
 646     return scard_control( &params );
 647 };
 648
 649 static NTSTATUS wow64_scard_get_attrib( void *args )
 650 {
 651     struct
 652     {
 653         UINT64 handle;
 654         UINT64 id;
 655         PTR32 attr;
 656         PTR32 attr_len;
 657     } *params32 = args;
 658
 659     struct scard_get_attrib_params params =
 660     {
 661         params32->handle,
 662         params32->id,
 663         ULongToPtr(params32->attr),
 664         ULongToPtr(params32->attr_len)
 665     };
 666     return scard_get_attrib( &params );
 667 }
 668
 669 static NTSTATUS wow64_scard_set_attrib( void *args )
 670 {
 671     struct
 672     {
 673         UINT64 handle;
 674         UINT64 id;
 675         PTR32 attr;
 676         UINT64 attr_len;
 677     } *params32 = args;
 678
 679     struct scard_set_attrib_params params =
 680     {
 681         params32->handle,
 682         params32->id,
 683         ULongToPtr(params32->attr),
 684         params32->attr_len
 685     };
 686     return scard_set_attrib( &params );
 687 }
 688
 689 const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
 690 {
 691     wow64_scard_establish_context,
 692     wow64_scard_release_context,
 693     wow64_scard_is_valid_context,
 694     wow64_scard_get_status_change,
 695     wow64_scard_cancel,
 696     wow64_scard_list_readers,
 697     wow64_scard_list_reader_groups,
 698     wow64_scard_connect,
 699     wow64_scard_status,
 700     wow64_scard_reconnect,
 701     wow64_scard_disconnect,
 702     wow64_scard_begin_transaction,
 703     wow64_scard_end_transaction,
 704     wow64_scard_transmit,
 705     wow64_scard_control,
 706     wow64_scard_get_attrib,
 707     wow64_scard_set_attrib,
 708 };
 709
 710 C_ASSERT( ARRAYSIZE(__wine_unix_call_wow64_funcs) == unix_funcs_count );
 711
 712 #endif  /* _WIN64 */