Initial publish

1 files changed, 662 insertions, 0 deletions

diff --git a/network/wlan/ihvsample/utils.cpp b/network/wlan/ihvsample/utils.cpp
new file mode 100644
index 00000000..f7dae91e
--- /dev/null
+++ b/network/wlan/ihvsample/utils.cpp
@@ -0,0 +1,662 @@
+/*++
+
+Copyright (c) 2005 Microsoft Corporation
+
+Abstract:
+
+   Sample IHV Extensibility DLL to extend
+   802.11 LWF driver for third party protocols.
+
+
+--*/
+
+#include "precomp.h"
+
+//
+// Service specific global Variables
+//
+PDOT11EXT_APIS             g_pDot11ExtApi          =  NULL;
+
+CRITICAL_SECTION           g_csSynch               =  {0};
+DWORD                      g_dwThreadCount         =  0;
+DWORD                      g_dwSessionID           =  0;
+BOOL                       g_bAllowInit            =  TRUE;
+
+
+
+
+//
+// Structure to store data
+// required to start a new
+// thread. The thread count
+// needs to be protected.
+//
+typedef
+struct _THREAD_PROTECTOR
+{
+   LPTHREAD_START_ROUTINE   pStartRoutine;
+   LPVOID                   pvParams;
+   HANDLE                   hIhvExtAdapter;
+}
+THREAD_PROTECTOR, *PTHREAD_PROTECTOR;
+
+
+
+//
+// Logical copy function macro.
+//
+#define COPY_FUNCTION( _p, _FuncName, _Preface )   \
+   (_p)->Dot11ExtIhv##_FuncName =                  \
+   _Preface##_FuncName;                            \
+
+
+
+//
+// Trace utility function
+//
+VOID
+SampleTraceFn
+(
+    LPCSTR      pszFormat,
+    LPCSTR      pszVal1,
+    DWORD       dwVal1
+)
+{
+    CHAR    szMsgString[ 512 ]  =   {0};
+    HRESULT hr                  =   S_OK;
+
+    hr =
+    StringCchPrintfA
+    (
+        szMsgString,
+        sizeof( szMsgString ) - 1,
+        pszFormat,
+        pszVal1,
+        dwVal1
+    );
+
+    if ( S_OK == hr )
+    {
+        OutputDebugStringA( szMsgString );
+    }
+    else
+    {
+        OutputDebugStringA( "ERROR: Trace message generation failed.\n" );
+    }
+
+    return;
+}
+
+// Private Memory alloc function
+LPVOID
+PrivateMemoryAlloc
+(
+    size_t  MemSize
+)
+{
+    LPVOID  pvBuffer    =   NULL;
+
+    if (!MemSize)
+    {
+        BAIL( );
+    }
+
+    pvBuffer = malloc( MemSize );
+    if ( pvBuffer )
+    {
+        ZeroMemory( pvBuffer, MemSize );
+    }
+
+error:
+    return pvBuffer;
+}
+
+// Private Memory free function
+VOID
+PrivateMemoryFree
+(
+    LPVOID  pvBuffer
+)
+{
+    if ( pvBuffer )
+    {
+        free( pvBuffer );
+    }
+}
+
+
+
+//
+// Initialize the handler functions
+//
+VOID
+HandlerInit
+(
+   OUT   PDOT11EXT_IHV_HANDLERS     pDot11IHVHandlers
+)
+{
+
+   COPY_FUNCTION( pDot11IHVHandlers,  DeinitService           , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  InitAdapter             , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  DeinitAdapter           , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  ProcessSessionChange    , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  IsUIRequestPending      , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  ReceiveIndication       , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  PerformCapabilityMatch  , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  ValidateProfile         , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  PerformPreAssociate     , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  PerformPostAssociate    , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  AdapterReset            , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  StopPostAssociate       , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  ReceivePacket           , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  CreateDiscoveryProfiles , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  ProcessUIResponse       , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  SendPacketCompletion    , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  QueryUIRequest          , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  OnexIndicateResult      , Ihv  );
+   COPY_FUNCTION( pDot11IHVHandlers,  Control                 , Ihv  );
+
+}
+
+#define ASSERT_MSG_LEN  768
+
+//
+// Calling DebugBreak indirectly
+// to facilitate frame stepping
+// in a debugger.
+//
+VOID
+AssertFunc
+(
+    _In_    LPCSTR  pszFile,
+            int     nLine
+)
+{
+    HRESULT     hr                          =   S_OK;
+    CHAR        Message[ ASSERT_MSG_LEN ]   =   {0};
+
+    hr =
+    StringCchPrintfA
+    (
+        Message,
+        ASSERT_MSG_LEN-1,
+        "\n\nAssertion failed in File %s, Line %d\n\n",
+        pszFile,
+        nLine
+    );
+    if ( S_OK == hr )
+    {
+        OutputDebugStringA( Message );
+    }
+    else
+    {
+        OutputDebugStringA( "Assertion Failed\n" );
+    }
+
+    DebugBreak( );
+}
+
+//
+// Initialize global synchronization structure.
+//
+DWORD
+InitCritSect
+(
+   CRITICAL_SECTION* pCritSect
+)
+{
+   DWORD    dwResult =  ERROR_SUCCESS;
+
+   __try
+   {
+      InitializeCriticalSection( pCritSect );
+   }
+   __except (EXCEPTION_EXECUTE_HANDLER)
+   {
+      dwResult = GetExceptionCode( );
+      BAIL_ON_WIN32_ERROR( dwResult );
+   }
+
+error:
+    return dwResult;
+}
+
+
+
+
+
+//
+// Dll Main function.
+//
+BOOL
+WINAPI
+DllMain
+(
+   IN HINSTANCE   Dll,
+   IN DWORD       Reason,
+   IN PVOID       Reserved
+)
+{
+    DWORD   dwResult =  ERROR_SUCCESS;
+
+    UNREFERENCED_PARAMETER( Dll );
+    UNREFERENCED_PARAMETER( Reserved );
+
+    switch (Reason)
+    {
+        case DLL_PROCESS_ATTACH:
+
+            dwResult = InitCritSect( &g_csSynch );
+            BAIL_ON_WIN32_ERROR( dwResult );
+
+            g_dwThreadCount =  0;
+            g_dwSessionID   =  0;
+            g_bAllowInit    =  TRUE;
+
+            break;
+
+        case DLL_PROCESS_DETACH:
+            DeleteCriticalSection( &g_csSynch );
+            break;
+
+        default:
+            break;
+    }
+
+error:
+    return ( ERROR_SUCCESS == dwResult );
+}
+
+
+
+
+//
+// Disable starting new threads or adding new adapters..
+//
+VOID
+StartShutdown
+(
+   VOID
+)
+{
+   g_bAllowInit = FALSE;
+}
+
+
+
+//
+// Wait for spawned threadcount
+// to come down to zero.
+//
+VOID
+WaitOnZeroThreads
+(
+   VOID
+)
+{
+   BOOL  bZeroThreads   =  FALSE;
+
+   for ( ;; )
+   {
+      EnterCriticalSection( &g_csSynch );
+      bZeroThreads = ( 0 == g_dwThreadCount );
+      LeaveCriticalSection( &g_csSynch );
+
+      if ( bZeroThreads )
+      {
+          break;
+      }
+
+      Sleep( 100 );
+   }
+}
+
+
+
+
+
+
+//
+// Function uses pThreadProtector structure
+// to start a new thread. Decrements the
+// global thread count after this thread has
+// returned.
+//
+DWORD
+WINAPI
+ProtectedThreadEntry
+(
+   LPVOID pvThreadProtector
+)
+{
+    DWORD                       dwResult            =   ERROR_SUCCESS;
+    PTHREAD_PROTECTOR           pThreadProtector    =   NULL;
+    LPTHREAD_START_ROUTINE      pStartRoutine       =   NULL;
+    LPVOID                      pvParams            =   NULL;
+    HANDLE                      hIhvExtAdapter      =   NULL;
+
+    pThreadProtector  = (PTHREAD_PROTECTOR) pvThreadProtector;
+    ASSERT ( pThreadProtector )
+
+    pStartRoutine  =  pThreadProtector->pStartRoutine;
+    pvParams       =  pThreadProtector->pvParams;
+    hIhvExtAdapter =  pThreadProtector->hIhvExtAdapter;
+
+    PrivateMemoryFree( pThreadProtector );
+    pThreadProtector = NULL;
+
+
+    if ( pStartRoutine )
+    {
+        dwResult = pStartRoutine( pvParams );
+        BAIL_ON_WIN32_ERROR( dwResult );
+    }
+
+error:
+    EnterCriticalSection( &g_csSynch );
+
+    // decrement thread count.
+    g_dwThreadCount--;
+
+    // decrement adapter reference.
+    DerefenceAdapterDetails( hIhvExtAdapter );
+
+    LeaveCriticalSection( &g_csSynch );
+
+    return dwResult;
+}
+
+
+//
+// Start a new thread.
+//
+DWORD
+StartNewProtectedThread
+(
+    HANDLE                  hIhvExtAdapter,
+    LPTHREAD_START_ROUTINE  pStartRoutine,
+    LPVOID                  pvParams
+)
+{
+    DWORD               dwResult            =   ERROR_SUCCESS;
+    HANDLE              hThread             =   NULL;
+    PTHREAD_PROTECTOR   pThreadProtector    =   NULL;
+    BOOL                bLocked             =   FALSE;
+    PADAPTER_DETAILS    pAdapterDetails     =   NULL;
+    BOOL                bCloseHandle        =   FALSE;
+    BOOL                bOk                 =   TRUE;
+
+
+    EnterCriticalSection( &g_csSynch );
+    bLocked = TRUE;
+
+    if (( !g_bAllowInit ) || (g_dwThreadCount >= MAX_THREAD_COUNT) )
+    {
+        dwResult = ERROR_INVALID_STATE;
+        BAIL_ON_WIN32_ERROR( dwResult );
+    }
+
+    dwResult =
+    ReferenceAdapterDetails
+    (
+        hIhvExtAdapter,
+        &pAdapterDetails
+    );
+    BAIL_ON_WIN32_ERROR( dwResult );
+    ASSERT( pAdapterDetails );
+
+
+    // This memory is initialized, used and freed entirely by the Extensibility
+    // DLL. Hence this memory can be allocated and freed using any method.
+    pThreadProtector = (PTHREAD_PROTECTOR) PrivateMemoryAlloc( sizeof( THREAD_PROTECTOR ) );
+    if ( !pThreadProtector )
+    {
+        dwResult = ERROR_OUTOFMEMORY;
+        BAIL_ON_WIN32_ERROR( dwResult );
+    }
+
+    pThreadProtector->pStartRoutine  =  pStartRoutine;
+    pThreadProtector->pvParams       =  pvParams;
+    pThreadProtector->hIhvExtAdapter =  hIhvExtAdapter;
+
+    hThread =
+    CreateThread
+    (
+        NULL,                   // security attributes
+        0,                      // default stack size
+        ProtectedThreadEntry,   // pointer to function to run
+        pThreadProtector,       // parameter
+        0,                      // run thread immediately
+        NULL                    // Thread ID receiver
+    );
+    if ( !hThread )
+    {
+        dwResult = GetLastError( );
+        BAIL_ON_WIN32_ERROR( dwResult );
+    }
+    bCloseHandle = TRUE;
+
+    // Thread successfully started, memory
+    // would be freed by ProtectedThreadEntry
+    pThreadProtector = NULL;
+
+    // Transfering dereference duty to ProtectedThreadEntry function.
+    pAdapterDetails = NULL;
+
+    g_dwThreadCount++;
+
+error:
+    if ( bCloseHandle )
+    {
+        bOk = CloseHandle( hThread );
+        ASSERT( bOk );
+    }
+
+    PrivateMemoryFree( pThreadProtector );
+
+    if ( pAdapterDetails )
+    {
+        DerefenceAdapterDetails( hIhvExtAdapter );
+    }
+
+    if ( bLocked )
+    {
+        LeaveCriticalSection( &g_csSynch );
+    }
+    return dwResult;
+}
+
+
+//
+// Function to match beacon and profile.
+//
+BOOL
+WINAPI
+MatchBssDescription
+(
+    PDOT11EXT_IHV_PROFILE_PARAMS    pIhvProfileParams,
+    PIHV_CONNECTIVITY_PROFILE       pConnectivityProfile,
+    PIHV_SECURITY_PROFILE           pSecurityProfile,
+    PULDOT11_BSS_ENTRY              pBssEntry
+)
+{
+    UNREFERENCED_PARAMETER( pIhvProfileParams );
+    UNREFERENCED_PARAMETER( pConnectivityProfile );
+    UNREFERENCED_PARAMETER( pSecurityProfile );
+    UNREFERENCED_PARAMETER( pBssEntry );
+
+    // Try to match the current profile with the beacon.
+    return TRUE;
+}
+
+
+
+DWORD
+CopyConnectivityProfile
+(
+    IN      PDOT11EXT_IHV_CONNECTIVITY_PROFILE  pSrc,
+    OUT     PDOT11EXT_IHV_CONNECTIVITY_PROFILE  pDst
+)
+{
+    DWORD   dwResult    =   ERROR_SUCCESS;
+    DWORD   dwLen       =   0;
+
+    ASSERT( pSrc );
+    ASSERT( pDst );
+
+    ZeroMemory( pDst, sizeof( DOT11EXT_IHV_CONNECTIVITY_PROFILE ) );
+
+    if ( pSrc->pszXmlFragmentIhvConnectivity )
+    {
+        dwLen =  (DWORD) wcslen( pSrc->pszXmlFragmentIhvConnectivity );
+
+        dwResult =  
+        (g_pDot11ExtApi->Dot11ExtAllocateBuffer)
+        ( 
+            (dwLen+1) * sizeof( WCHAR ),
+            (LPVOID*) &(pDst->pszXmlFragmentIhvConnectivity)
+        );
+        BAIL_ON_WIN32_ERROR( dwResult );
+        ASSERT( pDst->pszXmlFragmentIhvConnectivity );
+
+        CopyMemory
+        (
+            (LPVOID) pDst->pszXmlFragmentIhvConnectivity,
+            (LPVOID) pSrc->pszXmlFragmentIhvConnectivity,
+            (dwLen+1) * sizeof( WCHAR )
+        );
+    }
+
+error:
+    return dwResult;
+}
+
+
+VOID
+FreeConnectivityProfile
+(
+    IN  PDOT11EXT_IHV_CONNECTIVITY_PROFILE  pSrc
+)
+{
+    if ( pSrc && pSrc->pszXmlFragmentIhvConnectivity )
+    {
+        (g_pDot11ExtApi->Dot11ExtFreeBuffer)( (LPVOID) pSrc->pszXmlFragmentIhvConnectivity );
+        pSrc->pszXmlFragmentIhvConnectivity = NULL;
+    }
+}
+
+
+
+DWORD
+CopySecurityProfile
+(
+    IN  PDOT11EXT_IHV_SECURITY_PROFILE  pSrc,
+    OUT PDOT11EXT_IHV_SECURITY_PROFILE  pDst
+)
+{
+    DWORD   dwResult    =   ERROR_SUCCESS;
+    DWORD   dwLen       =   0;
+
+    ASSERT( pSrc );
+    ASSERT( pDst );
+
+    ZeroMemory( pDst, sizeof( DOT11EXT_IHV_SECURITY_PROFILE ) );
+
+    pDst->bUseMSOnex = pSrc->bUseMSOnex;
+
+    if ( pSrc->pszXmlFragmentIhvSecurity )
+    {
+        dwLen =  (DWORD) wcslen( pSrc->pszXmlFragmentIhvSecurity );
+
+        dwResult =  
+        (g_pDot11ExtApi->Dot11ExtAllocateBuffer)
+        ( 
+            (dwLen+1) * sizeof( WCHAR ),
+            (LPVOID*) &(pDst->pszXmlFragmentIhvSecurity)
+        );
+        BAIL_ON_WIN32_ERROR( dwResult );
+        ASSERT( pDst->pszXmlFragmentIhvSecurity );
+
+        CopyMemory
+        (
+            (LPVOID) pDst->pszXmlFragmentIhvSecurity,
+            (LPVOID) pSrc->pszXmlFragmentIhvSecurity,
+            (dwLen+1) * sizeof( WCHAR )
+        );
+    }
+
+
+error:
+    return dwResult;
+}
+
+
+VOID
+FreeSecurityProfile
+(
+    IN  PDOT11EXT_IHV_SECURITY_PROFILE  pSrc
+)
+{
+    if ( pSrc && pSrc->pszXmlFragmentIhvSecurity )
+    {
+        (g_pDot11ExtApi->Dot11ExtFreeBuffer)( (LPVOID) pSrc->pszXmlFragmentIhvSecurity );
+        pSrc->pszXmlFragmentIhvSecurity = NULL;
+    }
+}
+
+
+
+
+DWORD
+CopyDiscoveryProfile
+(
+    IN  PDOT11EXT_IHV_DISCOVERY_PROFILE     pSrc,
+    OUT PDOT11EXT_IHV_DISCOVERY_PROFILE     pDst
+)
+{
+    DWORD   dwResult    =   ERROR_SUCCESS;
+
+    ASSERT( pSrc );
+    ASSERT( pDst );
+
+    dwResult =
+    CopyConnectivityProfile
+    (
+        &(pSrc->IhvConnectivityProfile),
+        &(pDst->IhvConnectivityProfile)
+    );
+    BAIL_ON_WIN32_ERROR( dwResult );
+
+
+    dwResult =
+    CopySecurityProfile
+    (
+        &(pSrc->IhvSecurityProfile),
+        &(pDst->IhvSecurityProfile)
+    );
+    BAIL_ON_WIN32_ERROR( dwResult );
+
+error:
+    if ( ERROR_SUCCESS != dwResult )
+    {
+        FreeDiscoveryProfile( pDst );
+    }
+    return dwResult;
+}
+
+
+VOID
+FreeDiscoveryProfile
+(
+    IN  PDOT11EXT_IHV_DISCOVERY_PROFILE     pSrc
+)
+{
+    if ( pSrc )
+    {
+        FreeConnectivityProfile( &(pSrc->IhvConnectivityProfile) );
+        FreeSecurityProfile( &(pSrc->IhvSecurityProfile) );
+    }
+}
+
+
+