callback_cleanup.c

 
#include <winpr/config.h>
 
#include <winpr/crt.h>
#include <winpr/pool.h>
#include <winpr/library.h>
 
#include "pool.h"
 
#ifdef WINPR_THREAD_POOL
 
#ifdef _WIN32
static INIT_ONCE init_once_module = INIT_ONCE_STATIC_INIT;
static VOID(WINAPI* pSetEventWhenCallbackReturns)(PTP_CALLBACK_INSTANCE pci, HANDLE evt);
static VOID(WINAPI* pReleaseSemaphoreWhenCallbackReturns)(PTP_CALLBACK_INSTANCE pci, HANDLE sem,
                                                          DWORD crel);
static VOID(WINAPI* pReleaseMutexWhenCallbackReturns)(PTP_CALLBACK_INSTANCE pci, HANDLE mut);
static VOID(WINAPI* pLeaveCriticalSectionWhenCallbackReturns)(PTP_CALLBACK_INSTANCE pci,
                                                              PCRITICAL_SECTION pcs);
static VOID(WINAPI* pFreeLibraryWhenCallbackReturns)(PTP_CALLBACK_INSTANCE pci, HMODULE mod);
static VOID(WINAPI* pDisassociateCurrentThreadFromCallback)(PTP_CALLBACK_INSTANCE pci);
 
static BOOL CALLBACK init_module(PINIT_ONCE once, PVOID param, PVOID* context)
{
  HMODULE kernel32 = LoadLibraryA("kernel32.dll");
  if (kernel32)
  {
    pSetEventWhenCallbackReturns =
        GetProcAddressAs(kernel32, "SetEventWhenCallbackReturns"), void*);
    pReleaseSemaphoreWhenCallbackReturns =
        GetProcAddressAs(kernel32, "ReleaseSemaphoreWhenCallbackReturns", void*);
    pReleaseMutexWhenCallbackReturns =
        GetProcAddressAs(kernel32, "ReleaseMutexWhenCallbackReturns", void*);
    pLeaveCriticalSectionWhenCallbackReturns =
        GetProcAddressAs(kernel32, "LeaveCriticalSectionWhenCallbackReturns", void*);
    pFreeLibraryWhenCallbackReturns =
        GetProcAddressAs(kernel32, "FreeLibraryWhenCallbackReturns", void*);
    pDisassociateCurrentThreadFromCallback =
        GetProcAddressAs(kernel32, "DisassociateCurrentThreadFromCallback", void*);
  }
  return TRUE;
}
#endif
 
VOID SetEventWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci, HANDLE evt)
{
#ifdef _WIN32
  InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL);
  if (pSetEventWhenCallbackReturns)
  {
    pSetEventWhenCallbackReturns(pci, evt);
    return;
  }
#endif
  /* No default implementation */
}
 
VOID ReleaseSemaphoreWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci, HANDLE sem, DWORD crel)
{
#ifdef _WIN32
  InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL);
  if (pReleaseSemaphoreWhenCallbackReturns)
  {
    pReleaseSemaphoreWhenCallbackReturns(pci, sem, crel);
    return;
  }
#endif
  /* No default implementation */
}
 
VOID ReleaseMutexWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci, HANDLE mut)
{
#ifdef _WIN32
  InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL);
  if (pReleaseMutexWhenCallbackReturns)
  {
    pReleaseMutexWhenCallbackReturns(pci, mut);
    return;
  }
#endif
  /* No default implementation */
}
 
VOID LeaveCriticalSectionWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci, PCRITICAL_SECTION pcs)
{
#ifdef _WIN32
  InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL);
  if (pLeaveCriticalSectionWhenCallbackReturns)
  {
    pLeaveCriticalSectionWhenCallbackReturns(pci, pcs);
  }
#endif
  /* No default implementation */
}
 
VOID FreeLibraryWhenCallbackReturns(PTP_CALLBACK_INSTANCE pci, HMODULE mod)
{
#ifdef _WIN32
  InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL);
  if (pFreeLibraryWhenCallbackReturns)
  {
    pFreeLibraryWhenCallbackReturns(pci, mod);
    return;
  }
#endif
  /* No default implementation */
}
 
VOID DisassociateCurrentThreadFromCallback(PTP_CALLBACK_INSTANCE pci)
{
#ifdef _WIN32
  InitOnceExecuteOnce(&init_once_module, init_module, NULL, NULL);
  if (pDisassociateCurrentThreadFromCallback)
  {
    pDisassociateCurrentThreadFromCallback(pci);
    return;
  }
#endif
  /* No default implementation */
}
 
#endif /* WINPR_THREAD_POOL defined */