smartcard_main.c

 
#include <freerdp/config.h>
 
#include <winpr/crt.h>
#include <winpr/smartcard.h>
#include <winpr/environment.h>
 
#include <freerdp/freerdp.h>
#include <freerdp/channels/rdpdr.h>
#include <freerdp/channels/scard.h>
#include <freerdp/utils/smartcard_call.h>
#include <freerdp/utils/smartcard_operations.h>
#include <freerdp/utils/rdpdr_utils.h>
 
#include "smartcard_main.h"
 
#define CAST_FROM_DEVICE(device) cast_device_from(device, __func__, __FILE__, __LINE__)
 
typedef struct
{
  SMARTCARD_OPERATION operation;
  IRP* irp;
} scard_irp_queue_element;
 
static void smartcard_context_free(void* pCtx);
 
static UINT smartcard_complete_irp(SMARTCARD_DEVICE* smartcard, IRP* irp, BOOL* handled);
 
static SMARTCARD_DEVICE* cast_device_from(DEVICE* device, const char* fkt, const char* file,
                                          size_t line)
{
  if (!device)
  {
    WLog_ERR(TAG, "%s [%s:%" PRIuz "] Called smartcard channel with nullptr device", fkt, file,
             line);
    return nullptr;
  }
 
  if (device->type != RDPDR_DTYP_SMARTCARD)
  {
    WLog_ERR(TAG,
             "%s [%s:%" PRIuz "] Called smartcard channel with invalid device of type %" PRIx32,
             fkt, file, line, device->type);
    return nullptr;
  }
 
  return (SMARTCARD_DEVICE*)device;
}
 
static DWORD smartcard_context_queue_loop(SMARTCARD_CONTEXT* pContext, wMessageQueue* queue)
{
  DWORD nCount = 0;
  DWORD waitStatus = 0;
  HANDLE hEvents[2] = WINPR_C_ARRAY_INIT;
  wMessage message = WINPR_C_ARRAY_INIT;
  SMARTCARD_DEVICE* smartcard = nullptr;
  UINT error = CHANNEL_RC_OK;
  smartcard = pContext->smartcard;
 
  hEvents[nCount++] = MessageQueue_Event(queue);
 
  while (1)
  {
    waitStatus = WaitForMultipleObjects(nCount, hEvents, FALSE, INFINITE);
 
    if (waitStatus == WAIT_FAILED)
    {
      error = GetLastError();
      WLog_ERR(TAG, "WaitForMultipleObjects failed with error %" PRIu32 "!", error);
      break;
    }
 
    waitStatus = WaitForSingleObject(MessageQueue_Event(queue), 0);
 
    if (waitStatus == WAIT_FAILED)
    {
      error = GetLastError();
      WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "!", error);
      break;
    }
 
    if (waitStatus == WAIT_OBJECT_0)
    {
      scard_irp_queue_element* element = nullptr;
 
      if (!MessageQueue_Peek(queue, &message, TRUE))
      {
        WLog_ERR(TAG, "MessageQueue_Peek failed!");
        error = ERROR_INTERNAL_ERROR;
        break;
      }
 
      if (message.id == WMQ_QUIT)
        break;
 
      element = (scard_irp_queue_element*)message.wParam;
 
      if (element)
      {
        BOOL handled = FALSE;
        WINPR_ASSERT(smartcard);
 
        const LONG status =
            smartcard_irp_device_control_call(smartcard->callctx, element->irp->output,
                                              &element->irp->IoStatus, &element->operation);
        if (status)
        {
          element->irp->Discard(element->irp);
          smartcard_operation_free(&element->operation, TRUE);
          WLog_ERR(TAG,
                   "smartcard_irp_device_control_call failed with error %s [%" PRId32 "]",
                   NtStatus2Tag(status), status);
          error = (UINT)status;
          break;
        }
 
        error = smartcard_complete_irp(smartcard, element->irp, &handled);
        if (!handled)
          element->irp->Discard(element->irp);
        smartcard_operation_free(&element->operation, TRUE);
 
        if (error)
        {
          WLog_ERR(TAG, "smartcard_complete_irp failed with %s [%" PRIu32 "]",
                   WTSErrorToString(error), error);
          break;
        }
      }
    }
  }
 
  if (error && smartcard->rdpcontext)
    setChannelError(smartcard->rdpcontext, error, "smartcard_context_thread reported an error");
 
  return error;
}
 
static DWORD WINAPI smartcard_context_thread(LPVOID arg)
{
  SMARTCARD_CONTEXT* pContext = (SMARTCARD_CONTEXT*)arg;
  const DWORD error = smartcard_context_queue_loop(pContext, pContext->IrpQueue);
  ExitThread(error);
  return error;
}
 
static DWORD WINAPI smartcard_context_tx_thread(LPVOID arg)
{
  SMARTCARD_CONTEXT* pContext = (SMARTCARD_CONTEXT*)arg;
  const DWORD error = smartcard_context_queue_loop(pContext, pContext->TxQueue);
  ExitThread(error);
  return error;
}
 
static void smartcard_operation_queue_free(void* obj)
{
  wMessage* msg = obj;
  if (!msg)
    return;
  if (msg->id != 0)
    return;
 
  scard_irp_queue_element* element = (scard_irp_queue_element*)msg->wParam;
  if (!element)
    return;
  WINPR_ASSERT(element->irp);
  WINPR_ASSERT(element->irp->Discard);
  element->irp->Discard(element->irp);
  smartcard_operation_free(&element->operation, TRUE);
}
 
static void* smartcard_context_new(void* smartcard, SCARDCONTEXT hContext)
{
  SMARTCARD_CONTEXT* pContext = (SMARTCARD_CONTEXT*)calloc(1, sizeof(SMARTCARD_CONTEXT));
 
  WLog_VRB(TAG, "smartcard context create %p", (const void*)pContext);
  if (!pContext)
  {
    WLog_ERR(TAG, "calloc failed!");
    return pContext;
  }
 
  pContext->smartcard = smartcard;
  pContext->hContext = hContext;
  pContext->IrpQueue = MessageQueue_New(nullptr);
 
  if (!pContext->IrpQueue)
  {
    WLog_ERR(TAG, "MessageQueue_New failed!");
    goto fail;
  }
 
  {
    wObject* obj = MessageQueue_Object(pContext->IrpQueue);
    WINPR_ASSERT(obj);
    obj->fnObjectFree = smartcard_operation_queue_free;
  }
 
  pContext->thread = CreateThread(nullptr, 0, smartcard_context_thread, pContext, 0, nullptr);
 
  if (!pContext->thread)
  {
    WLog_ERR(TAG, "CreateThread failed!");
    goto fail;
  }
 
  pContext->TxQueue = MessageQueue_New(nullptr);
 
  if (!pContext->TxQueue)
  {
    WLog_ERR(TAG, "MessageQueue_New failed!");
    goto fail;
  }
 
  {
    wObject* obj = MessageQueue_Object(pContext->TxQueue);
    WINPR_ASSERT(obj);
    obj->fnObjectFree = smartcard_operation_queue_free;
  }
 
  pContext->txThread =
      CreateThread(nullptr, 0, smartcard_context_tx_thread, pContext, 0, nullptr);
 
  if (!pContext->txThread)
  {
    WLog_ERR(TAG, "CreateThread failed!");
    goto fail;
  }
 
  return pContext;
fail:
  smartcard_context_free(pContext);
  return nullptr;
}
 
void smartcard_context_free(void* pCtx)
{
  SMARTCARD_CONTEXT* pContext = pCtx;
 
  WLog_VRB(TAG, "smartcard context destroy %p", pCtx);
  if (!pContext)
    return;
 
  /* cancel blocking calls like SCardGetStatusChange */
  WINPR_ASSERT(pContext->smartcard);
  smartcard_call_cancel_context(pContext->smartcard->callctx, pContext->hContext);
 
  if (pContext->IrpQueue)
  {
    if (MessageQueue_PostQuit(pContext->IrpQueue, 0))
    {
      if (WaitForSingleObject(pContext->thread, INFINITE) == WAIT_FAILED)
        WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "!", GetLastError());
 
      (void)CloseHandle(pContext->thread);
    }
    MessageQueue_Free(pContext->IrpQueue);
  }
  if (pContext->TxQueue)
  {
    if (pContext->txThread && MessageQueue_PostQuit(pContext->TxQueue, 0))
    {
      if (WaitForSingleObject(pContext->txThread, INFINITE) == WAIT_FAILED)
        WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "!", GetLastError());
 
      (void)CloseHandle(pContext->txThread);
    }
    MessageQueue_Free(pContext->TxQueue);
  }
  smartcard_call_release_context(pContext->smartcard->callctx, pContext->hContext);
  free(pContext);
}
 
static UINT smartcard_free_(SMARTCARD_DEVICE* smartcard)
{
  if (!smartcard)
    return CHANNEL_RC_OK;
 
  if (smartcard->IrpQueue)
  {
    MessageQueue_Free(smartcard->IrpQueue);
    (void)CloseHandle(smartcard->thread);
  }
 
  Stream_Free(smartcard->device.data, TRUE);
  ListDictionary_Free(smartcard->rgOutstandingMessages);
 
  smartcard_call_context_free(smartcard->callctx);
 
  free(smartcard);
  return CHANNEL_RC_OK;
}
static UINT smartcard_free(DEVICE* device)
{
  SMARTCARD_DEVICE* smartcard = CAST_FROM_DEVICE(device);
 
  WLog_VRB(TAG, "smartcard device destroy: %p", (const void*)smartcard);
  if (!smartcard)
    return ERROR_INVALID_PARAMETER;
 
  smartcard_call_cancel_all_context(smartcard->callctx);
 
  /* Stopping all threads and cancelling all IRPs */
 
  if (smartcard->IrpQueue)
  {
    if (MessageQueue_PostQuit(smartcard->IrpQueue, 0) &&
        (WaitForSingleObject(smartcard->thread, INFINITE) == WAIT_FAILED))
    {
      DWORD error = GetLastError();
      WLog_ERR(TAG, "WaitForSingleObject failed with error %" PRIu32 "!", error);
      return error;
    }
  }
 
  return smartcard_free_(smartcard);
}
 
static UINT smartcard_init(DEVICE* device)
{
  SMARTCARD_DEVICE* smartcard = CAST_FROM_DEVICE(device);
 
  WLog_VRB(TAG, "smartcard device init %p", (const void*)smartcard);
  if (!smartcard)
    return ERROR_INVALID_PARAMETER;
 
  smartcard_call_cancel_all_context(smartcard->callctx);
  return CHANNEL_RC_OK;
}
 
UINT smartcard_complete_irp(SMARTCARD_DEVICE* smartcard, IRP* irp, BOOL* handled)
{
  WINPR_ASSERT(smartcard);
  WINPR_ASSERT(irp);
  WINPR_ASSERT(handled);
 
  uintptr_t key = (uintptr_t)irp->CompletionId + 1;
  ListDictionary_Remove(smartcard->rgOutstandingMessages, (void*)key);
 
  WINPR_ASSERT(irp->Complete);
  *handled = TRUE;
  return irp->Complete(irp);
}
 
static UINT smartcard_process_irp(SMARTCARD_DEVICE* smartcard, IRP* irp, BOOL* handled)
{
  LONG status = 0;
  BOOL asyncIrp = FALSE;
  SMARTCARD_CONTEXT* pContext = nullptr;
 
  WINPR_ASSERT(smartcard);
  WINPR_ASSERT(handled);
  WINPR_ASSERT(irp);
  WINPR_ASSERT(irp->Complete);
 
  uintptr_t key = (uintptr_t)irp->CompletionId + 1;
 
  if (!ListDictionary_Add(smartcard->rgOutstandingMessages, (void*)key, irp))
  {
    WLog_ERR(TAG, "ListDictionary_Add failed!");
    return ERROR_INTERNAL_ERROR;
  }
 
  if (irp->MajorFunction == IRP_MJ_DEVICE_CONTROL)
  {
    scard_irp_queue_element* element = calloc(1, sizeof(scard_irp_queue_element));
    if (!element)
      return ERROR_OUTOFMEMORY;
 
    element->irp = irp;
    element->operation.completionID = irp->CompletionId;
 
    status = smartcard_irp_device_control_decode_request(irp->input, irp->CompletionId,
                                                         irp->FileId, &element->operation);
 
    if (status != SCARD_S_SUCCESS)
    {
      UINT error = 0;
 
      smartcard_operation_free(&element->operation, TRUE);
      irp->IoStatus = STATUS_UNSUCCESSFUL;
 
      if ((error = smartcard_complete_irp(smartcard, irp, handled)))
      {
        WLog_ERR(TAG, "Queue_Enqueue failed!");
        return error;
      }
 
      return CHANNEL_RC_OK;
    }
 
    asyncIrp = TRUE;
 
    switch (element->operation.ioControlCode)
    {
      case SCARD_IOCTL_ESTABLISHCONTEXT:
      case SCARD_IOCTL_RELEASECONTEXT:
      case SCARD_IOCTL_ISVALIDCONTEXT:
      case SCARD_IOCTL_CANCEL:
      case SCARD_IOCTL_ACCESSSTARTEDEVENT:
      case SCARD_IOCTL_RELEASETARTEDEVENT:
        asyncIrp = FALSE;
        break;
 
      case SCARD_IOCTL_LISTREADERGROUPSA:
      case SCARD_IOCTL_LISTREADERGROUPSW:
      case SCARD_IOCTL_LISTREADERSA:
      case SCARD_IOCTL_LISTREADERSW:
      case SCARD_IOCTL_INTRODUCEREADERGROUPA:
      case SCARD_IOCTL_INTRODUCEREADERGROUPW:
      case SCARD_IOCTL_FORGETREADERGROUPA:
      case SCARD_IOCTL_FORGETREADERGROUPW:
      case SCARD_IOCTL_INTRODUCEREADERA:
      case SCARD_IOCTL_INTRODUCEREADERW:
      case SCARD_IOCTL_FORGETREADERA:
      case SCARD_IOCTL_FORGETREADERW:
      case SCARD_IOCTL_ADDREADERTOGROUPA:
      case SCARD_IOCTL_ADDREADERTOGROUPW:
      case SCARD_IOCTL_REMOVEREADERFROMGROUPA:
      case SCARD_IOCTL_REMOVEREADERFROMGROUPW:
      case SCARD_IOCTL_LOCATECARDSA:
      case SCARD_IOCTL_LOCATECARDSW:
      case SCARD_IOCTL_LOCATECARDSBYATRA:
      case SCARD_IOCTL_LOCATECARDSBYATRW:
      case SCARD_IOCTL_READCACHEA:
      case SCARD_IOCTL_READCACHEW:
      case SCARD_IOCTL_WRITECACHEA:
      case SCARD_IOCTL_WRITECACHEW:
      case SCARD_IOCTL_GETREADERICON:
      case SCARD_IOCTL_GETDEVICETYPEID:
      case SCARD_IOCTL_GETSTATUSCHANGEA:
      case SCARD_IOCTL_GETSTATUSCHANGEW:
      case SCARD_IOCTL_CONNECTA:
      case SCARD_IOCTL_CONNECTW:
      case SCARD_IOCTL_RECONNECT:
      case SCARD_IOCTL_DISCONNECT:
      case SCARD_IOCTL_BEGINTRANSACTION:
      case SCARD_IOCTL_ENDTRANSACTION:
      case SCARD_IOCTL_STATE:
      case SCARD_IOCTL_STATUSA:
      case SCARD_IOCTL_STATUSW:
      case SCARD_IOCTL_TRANSMIT:
      case SCARD_IOCTL_CONTROL:
      case SCARD_IOCTL_GETATTRIB:
      case SCARD_IOCTL_SETATTRIB:
      case SCARD_IOCTL_GETTRANSMITCOUNT:
        asyncIrp = TRUE;
        break;
      default:
        break;
    }
 
    pContext = smartcard_call_get_context(smartcard->callctx, element->operation.hContext);
 
    if (!pContext)
      asyncIrp = FALSE;
 
    if (!asyncIrp)
    {
      UINT error = 0;
 
      status =
          smartcard_irp_device_control_call(smartcard->callctx, element->irp->output,
                                            &element->irp->IoStatus, &element->operation);
      smartcard_operation_free(&element->operation, TRUE);
 
      if (status)
      {
        WLog_ERR(TAG, "smartcard_irp_device_control_call failed with error %" PRId32 "!",
                 status);
        return (UINT32)status;
      }
 
      if ((error = smartcard_complete_irp(smartcard, irp, handled)))
      {
        WLog_ERR(TAG, "Queue_Enqueue failed!");
        return error;
      }
    }
    else
    {
      if (pContext)
      {
        wMessageQueue* queue = pContext->IrpQueue;
 
        switch (element->operation.ioControlCode)
        {
          /* may wait for the transaction of another handle */
          case SCARD_IOCTL_BEGINTRANSACTION:
          case SCARD_IOCTL_CONNECTA:
          case SCARD_IOCTL_CONNECTW:
          case SCARD_IOCTL_RECONNECT:
            queue = pContext->TxQueue;
            break;
          default:
            break;
        }
 
        if (!MessageQueue_Post(queue, nullptr, 0, (void*)element, nullptr))
        {
          smartcard_operation_free(&element->operation, TRUE);
          WLog_ERR(TAG, "MessageQueue_Post failed!");
          return ERROR_INTERNAL_ERROR;
        }
        *handled = TRUE;
      }
    }
  }
  else
  {
    UINT ustatus = 0;
    WLog_ERR(TAG, "Unexpected SmartCard IRP: MajorFunction %s, MinorFunction: 0x%08" PRIX32 "",
             rdpdr_irp_string(irp->MajorFunction), irp->MinorFunction);
    irp->IoStatus = STATUS_NOT_SUPPORTED;
 
    if ((ustatus = smartcard_complete_irp(smartcard, irp, handled)))
    {
      WLog_ERR(TAG, "Queue_Enqueue failed!");
      return ustatus;
    }
  }
 
  return CHANNEL_RC_OK;
}
 
static DWORD WINAPI smartcard_thread_func(LPVOID arg)
{
  IRP* irp = nullptr;
  DWORD nCount = 0;
  DWORD status = 0;
  HANDLE hEvents[1] = WINPR_C_ARRAY_INIT;
  wMessage message = WINPR_C_ARRAY_INIT;
  UINT error = CHANNEL_RC_OK;
  SMARTCARD_DEVICE* smartcard = CAST_FROM_DEVICE(arg);
 
  if (!smartcard)
    return ERROR_INVALID_PARAMETER;
 
  hEvents[nCount++] = MessageQueue_Event(smartcard->IrpQueue);
 
  while (1)
  {
    status = WaitForMultipleObjects(nCount, hEvents, FALSE, INFINITE);
 
    if (status == WAIT_FAILED)
    {
      error = GetLastError();
      WLog_ERR(TAG, "WaitForMultipleObjects failed with error %" PRIu32 "!", error);
      break;
    }
 
    if (status == WAIT_OBJECT_0)
    {
      if (!MessageQueue_Peek(smartcard->IrpQueue, &message, TRUE))
      {
        WLog_ERR(TAG, "MessageQueue_Peek failed!");
        error = ERROR_INTERNAL_ERROR;
        break;
      }
 
      if (message.id == WMQ_QUIT)
        break;
 
      irp = (IRP*)message.wParam;
 
      if (irp)
      {
        BOOL handled = FALSE;
        if ((error = smartcard_process_irp(smartcard, irp, &handled)))
        {
          WLog_ERR(TAG, "smartcard_process_irp failed with error %" PRIu32 "!", error);
          goto out;
        }
        if (!handled)
        {
          WINPR_ASSERT(irp->Discard);
          irp->Discard(irp);
        }
      }
    }
  }
 
out:
 
  if (error && smartcard->rdpcontext)
    setChannelError(smartcard->rdpcontext, error, "smartcard_thread_func reported an error");
 
  ExitThread(error);
  return error;
}
 
static UINT smartcard_irp_request(DEVICE* device, IRP* irp)
{
  SMARTCARD_DEVICE* smartcard = CAST_FROM_DEVICE(device);
 
  if (!smartcard)
  {
    irp->Discard(irp);
    return ERROR_INVALID_PARAMETER;
  }
 
  if (!MessageQueue_Post(smartcard->IrpQueue, nullptr, 0, (void*)irp, nullptr))
  {
    WLog_ERR(TAG, "MessageQueue_Post failed!");
    irp->Discard(irp);
    return ERROR_INTERNAL_ERROR;
  }
 
  return CHANNEL_RC_OK;
}
 
static void smartcard_free_irp(void* obj)
{
  wMessage* msg = obj;
  if (!msg)
    return;
  if (msg->id != 0)
    return;
 
  IRP* irp = (IRP*)msg->wParam;
  if (!irp)
    return;
  WINPR_ASSERT(irp->Discard);
  irp->Discard(irp);
}
 
/* smartcard is always built-in */
#define DeviceServiceEntry smartcard_DeviceServiceEntry
 
FREERDP_ENTRY_POINT(UINT VCAPITYPE DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints))
{
  BOOL registered = FALSE;
  UINT error = CHANNEL_RC_NO_MEMORY;
 
  SMARTCARD_DEVICE* smartcard = (SMARTCARD_DEVICE*)calloc(1, sizeof(SMARTCARD_DEVICE));
  WLog_VRB(TAG, "smartcard device create: %p", (const void*)smartcard);
  if (!smartcard)
  {
    WLog_ERR(TAG, "calloc failed!");
    return CHANNEL_RC_NO_MEMORY;
  }
 
  smartcard->device.type = RDPDR_DTYP_SMARTCARD;
  smartcard->device.name = "SCARD";
  smartcard->device.IRPRequest = smartcard_irp_request;
  smartcard->device.Init = smartcard_init;
  smartcard->device.Free = smartcard_free;
  smartcard->rdpcontext = pEntryPoints->rdpcontext;
  smartcard->IrpQueue = MessageQueue_New(nullptr);
 
  if (!smartcard->IrpQueue)
  {
    WLog_ERR(TAG, "MessageQueue_New failed!");
    goto fail;
  }
 
  wObject* obj = MessageQueue_Object(smartcard->IrpQueue);
  WINPR_ASSERT(obj);
  obj->fnObjectFree = smartcard_free_irp;
 
  smartcard->rgOutstandingMessages = ListDictionary_New(TRUE);
 
  if (!smartcard->rgOutstandingMessages)
  {
    WLog_ERR(TAG, "ListDictionary_New failed!");
    goto fail;
  }
 
  smartcard->callctx = smartcard_call_context_new_with_context(smartcard->rdpcontext);
  if (!smartcard->callctx)
    goto fail;
 
  if (!smarcard_call_set_callbacks(smartcard->callctx, smartcard, smartcard_context_new,
                                   smartcard_context_free))
    goto fail;
 
  error = pEntryPoints->RegisterDevice(pEntryPoints->devman, &smartcard->device);
  if (error)
  {
    WLog_ERR(TAG, "RegisterDevice failed!");
    goto fail;
  }
 
  registered = TRUE;
  smartcard->thread =
      CreateThread(nullptr, 0, smartcard_thread_func, smartcard, CREATE_SUSPENDED, nullptr);
 
  if (!smartcard->thread)
  {
    WLog_ERR(TAG, "CreateThread failed!");
    error = ERROR_INTERNAL_ERROR;
    goto fail;
  }
 
  ResumeThread(smartcard->thread);
 
  if (pEntryPoints->device->Name)
  {
    if (!smartcard_call_context_add(smartcard->callctx, pEntryPoints->device->Name))
      goto fail;
  }
 
  return CHANNEL_RC_OK;
fail:
  if (!registered)
    smartcard_free_(smartcard);
  return error;
}