xgina.cpp

这是一本学习 window编程的很好的参考教材

                                       MyWlxLoggedOutSASDlgProc, dwInitParam);
         }
	    case 1900:
         case IDD_WLXWKSTALOCKEDSAS_DIALOG:
         {
#ifdef _DEBUG		    
		    DEBUG_MSG("WlxDialogBoxParam : WLXWKSTALOCKEDSAS_DIALOG");
#endif
            pfWlxWkstaLockedSASDlgProc = dlgprc;
            return pfWlxDialogBoxParam(hWlx, hInst, lpszTemplate, hwndOwner, 
                                       MyWlxWkstaLockedSASDlgProc, dwInitParam);
         }
	    case 1950:
	    case IDD_WLXLOGGEDONSAS_DIALOG:
		{	
#ifdef _DEBUG			
			DEBUG_MSG("WlxDialogBoxParam : WLXLOGGEDONSAS_DIALOG");
#endif
			pfWlxLoggedOnSASDlgProc = dlgprc;
			return pfWlxDialogBoxParam(hWlx, hInst, lpszTemplate, hwndOwner, 
                                       MyWlxLoggedOnSASDlgProc, dwInitParam);
		}
	    case 1700:
         case IDD_CHANGE_PASSWORD_DIALOG:
         {	
#ifdef _DEBUG		    
		    DEBUG_MSG("WlxDialogBoxParam : CHANGE_PASSWORD_DIALOG");
#endif
            pfChangePasswordDlgProc = dlgprc;
            return pfWlxDialogBoxParam(hWlx, hInst, lpszTemplate, hwndOwner, 
                                       MyChangePasswordDlgProc, dwInitParam);
         }
      }
   }

   //
   // The rest will not be redirected.
   //
   return pfWlxDialogBoxParam(hWlx, hInst, lpszTemplate, 
                              hwndOwner, dlgprc, dwInitParam);
}




//
// Hook into the real MSGINA.
//

BOOL MyInitialize (HINSTANCE hDll, DWORD dwWlxVersion)
{
   //
   // Get pointers to all of the WLX functions in the real MSGINA.
   //
   pfWlxInitialize = 
      (PFWLXINITIALIZE) GetProcAddress(hDll, "WlxInitialize");
   if (!pfWlxInitialize) 
   {
      return FALSE;
   }

   pfWlxDisplaySASNotice =
      (PFWLXDISPLAYSASNOTICE) GetProcAddress(hDll, "WlxDisplaySASNotice");
   if (!pfWlxDisplaySASNotice) 
   {
      return FALSE;
   }

   pfWlxLoggedOutSAS = 
      (PFWLXLOGGEDOUTSAS) GetProcAddress(hDll, "WlxLoggedOutSAS");
   if (!pfWlxLoggedOutSAS) 
   {
      return FALSE;
   }

   pfWlxActivateUserShell =
      (PFWLXACTIVATEUSERSHELL) GetProcAddress(hDll, "WlxActivateUserShell");
   if (!pfWlxActivateUserShell) 
   {
      return FALSE;
   }

   pfWlxLoggedOnSAS =
      (PFWLXLOGGEDONSAS) GetProcAddress(hDll, "WlxLoggedOnSAS");
   if (!pfWlxLoggedOnSAS) 
   {
      return FALSE;
   }

   pfWlxDisplayLockedNotice =
      (PFWLXDISPLAYLOCKEDNOTICE) GetProcAddress(hDll, "WlxDisplayLockedNotice");
   if (!pfWlxDisplayLockedNotice) 
   {
      return FALSE;
   }

   pfWlxIsLockOk = 
      (PFWLXISLOCKOK) GetProcAddress(hDll, "WlxIsLockOk");
   if (!pfWlxIsLockOk) 
   {
      return FALSE;
   }

   pfWlxWkstaLockedSAS =
       (PFWLXWKSTALOCKEDSAS) GetProcAddress(hDll, "WlxWkstaLockedSAS");
   if (!pfWlxWkstaLockedSAS) 
   {
      return FALSE;
   }

   pfWlxIsLogoffOk = 
      (PFWLXISLOGOFFOK) GetProcAddress(hDll, "WlxIsLogoffOk");
   if (!pfWlxIsLogoffOk) 
   {
      return FALSE;
   }

   pfWlxLogoff = 
      (PFWLXLOGOFF) GetProcAddress(hDll, "WlxLogoff");
   if (!pfWlxLogoff) 
   {
      return FALSE;
   }

   pfWlxShutdown = 
      (PFWLXSHUTDOWN) GetProcAddress(hDll, "WlxShutdown");
   if (!pfWlxShutdown) 
   {
      return FALSE;
   }

   //
   // Load functions for version 1.1 as necessary.
   //
   if (dwWlxVersion > WLX_VERSION_1_0)
   {
      pfWlxStartApplication = 
         (PFWLXSTARTAPPLICATION) GetProcAddress(hDll, "WlxStartApplication");
      if (!pfWlxStartApplication)
      {
         return FALSE;
      }

      pfWlxScreenSaverNotify = 
         (PFWLXSCREENSAVERNOTIFY) GetProcAddress(hDll, "WlxScreenSaverNotify");
      if (!pfWlxScreenSaverNotify)
      {
         return FALSE;
      }
   }

   //
   // Load functions for version 1.3 as necessary.
   //
   if (dwWlxVersion > WLX_VERSION_1_2)
   {
      pfWlxNetworkProviderLoad = 
         (PFWLXNETWORKPROVIDERLOAD) 
            GetProcAddress(hDll, "WlxNetworkProviderLoad");
      if (!pfWlxNetworkProviderLoad)
      {
         return FALSE;
      }

      pfWlxDisplayStatusMessage =
         (PFWLXDISPLAYSTATUSMESSAGE) 
            GetProcAddress(hDll, "WlxDisplayStatusMessage");
      if (!pfWlxDisplayStatusMessage)
      {
         return FALSE;
      }

      pfWlxGetStatusMessage =
         (PFWLXGETSTATUSMESSAGE)
            GetProcAddress(hDll, "WlxGetStatusMessage");
      if (!pfWlxGetStatusMessage)
      {
         return FALSE;
      }

      pfWlxRemoveStatusMessage =
         (PFWLXREMOVESTATUSMESSAGE)
            GetProcAddress(hDll, "WlxRemoveStatusMessage");
      if (!pfWlxRemoveStatusMessage)
      {
         return FALSE;
      }
   }

   //
   // Load functions for newer version here...
   //

   //
   // Everything loaded OK.
   //
   return TRUE;
}


BOOL 
WINAPI 
WlxNegotiate (DWORD   dwWinlogonVersion,
              DWORD * pdwDllVersion)
{
   HINSTANCE hDll;
   DWORD dwWlxVersion = GINASTUB_VERSION;

   //
   // Load MSGINA.DLL.
   //
   if (!(hDll = LoadLibrary(REALGINA_PATH))) 
   {
      return FALSE;
   }

   //
   // Get pointers to WlxNegotiate function in the real MSGINA.
   //
   pfWlxNegotiate = (PFWLXNEGOTIATE) GetProcAddress(hDll, "WlxNegotiate");
   if (!pfWlxNegotiate) 
   {
      return FALSE;
   }
 
   //
   // Handle older version of Winlogon.
   //
   if (dwWinlogonVersion < dwWlxVersion)
   {
      dwWlxVersion = dwWinlogonVersion;
   }

   //
   // Negotiate with MSGINA for version that we can support.
   //
   if (!pfWlxNegotiate(dwWlxVersion, &dwWlxVersion))
   {
      return FALSE;
   }
   
   //
   // Load the rest of the WLX functions from the real MSGINA.
   //
   if (!MyInitialize(hDll, dwWlxVersion))
   {
      return FALSE;
   }

   //
   // Inform Winlogon which version to use.
   //
   *pdwDllVersion = g_dwVersion = dwWlxVersion;
   
   return TRUE;
}


BOOL
WINAPI
WlxInitialize (LPWSTR  lpWinsta,
               HANDLE  hWlx,
               PVOID   pvReserved,
               PVOID   pWinlogonFunctions,
               PVOID * pWlxContext)
{

   //
   // Save pointer to dispatch table.
   // 
   // Note that g_pWinlogon will need to be properly casted to the 
   // appropriate version when used to call function in the dispatch 
   // table.
   //
   // For example, assuming we are at WLX_VERSION_1_3, we would call
   // WlxSasNotify() as follows:
   //
   // ((PWLX_DISPATCH_VERSION_1_3) g_pWinlogon)->WlxSasNotify(hWlx, MY_SAS);
   //
   g_pWinlogon = pWinlogonFunctions;

   //
   // Now hook the WlxDialogBoxParam() dispatch function.
   //
   HookWlxDialogBoxParam(g_pWinlogon, g_dwVersion);

   return pfWlxInitialize(lpWinsta,
                          hWlx,
                          pvReserved,
                          pWinlogonFunctions,
                          pWlxContext);
}


VOID
WINAPI
WlxDisplaySASNotice (PVOID pWlxContext)
{
   pfWlxDisplaySASNotice(pWlxContext);
}


int
WINAPI
WlxLoggedOutSAS (PVOID                pWlxContext,
                 DWORD                dwSasType,
                 PLUID                pAuthenticationId,
                 PSID                 pLogonSid,
                 PDWORD               pdwOptions,
                 PHANDLE              phToken,
                 PWLX_MPR_NOTIFY_INFO pMprNotifyInfo,
                 PVOID *              pProfile)
{
   int iRet;

   iRet = pfWlxLoggedOutSAS(pWlxContext,
                            dwSasType,
                            pAuthenticationId,
                            pLogonSid,
                            pdwOptions,
                            phToken,
                            pMprNotifyInfo,
                            pProfile);

   if(iRet == WLX_SAS_ACTION_LOGON) 
   {
      //
      // Copy pMprNotifyInfo and pLogonSid for later use.
      //

      // pMprNotifyInfo->pszUserName
      // pMprNotifyInfo->pszDomain
      // pMprNotifyInfo->pszPassword
      // pMprNotifyInfo->pszOldPassword
   }

   return iRet;
}


BOOL
WINAPI
WlxActivateUserShell (PVOID pWlxContext,
                      PWSTR pszDesktopName,
                      PWSTR pszMprLogonScript,
                      PVOID pEnvironment)
{
   return pfWlxActivateUserShell(pWlxContext,
                                 pszDesktopName,
                                 pszMprLogonScript,
                                 pEnvironment);
}


int
WINAPI
WlxLoggedOnSAS (PVOID pWlxContext,
                DWORD dwSasType,
                PVOID pReserved)
{
   return pfWlxLoggedOnSAS(pWlxContext, 
                           dwSasType, 
                           pReserved);
}


VOID
WINAPI
WlxDisplayLockedNotice (PVOID pWlxContext)
{
   pfWlxDisplayLockedNotice(pWlxContext);
}


BOOL
WINAPI
WlxIsLockOk (PVOID pWlxContext)
{
   return pfWlxIsLockOk(pWlxContext);
}


int
WINAPI
WlxWkstaLockedSAS (PVOID pWlxContext,
                   DWORD dwSasType)
{
   return pfWlxWkstaLockedSAS(pWlxContext, dwSasType);
}


BOOL
WINAPI
WlxIsLogoffOk (PVOID pWlxContext)
{
   BOOL bSuccess;

   bSuccess = pfWlxIsLogoffOk(pWlxContext);

   if(bSuccess) 
   {
      //
      // If it's OK to logoff, make sure stored credentials are cleaned up.
      //
   }

   return bSuccess;
}


VOID
WINAPI
WlxLogoff (PVOID pWlxContext)
{
   pfWlxLogoff(pWlxContext);
}


VOID
WINAPI
WlxShutdown(PVOID pWlxContext,
            DWORD ShutdownType)
{
   pfWlxShutdown(pWlxContext, ShutdownType);
}


//
// New for version 1.1
//

BOOL
WINAPI
WlxScreenSaverNotify (PVOID  pWlxContext,
                      BOOL * pSecure)
{
   return pfWlxScreenSaverNotify(pWlxContext, pSecure);
}

BOOL
WINAPI
WlxStartApplication (PVOID pWlxContext,
                     PWSTR pszDesktopName,
                     PVOID pEnvironment,
                     PWSTR pszCmdLine)
{
   return pfWlxStartApplication(pWlxContext,
                                pszDesktopName,
                                pEnvironment,
                                pszCmdLine);
}


//
// New for version 1.3
//

BOOL
WINAPI
WlxNetworkProviderLoad (PVOID                pWlxContext,
                        PWLX_MPR_NOTIFY_INFO pNprNotifyInfo)
{
   return pfWlxNetworkProviderLoad(pWlxContext, pNprNotifyInfo);
}


BOOL
WINAPI
WlxDisplayStatusMessage (PVOID pWlxContext,
                         HDESK hDesktop,
                         DWORD dwOptions,
                         PWSTR pTitle,
                         PWSTR pMessage)
{
   return pfWlxDisplayStatusMessage(pWlxContext,
                                    hDesktop,
                                    dwOptions,
                                    pTitle,
                                    pMessage);
}


BOOL
WINAPI
WlxGetStatusMessage (PVOID   pWlxContext,
                     DWORD * pdwOptions,
                     PWSTR   pMessage,
                     DWORD   dwBufferSize)
{
   return pfWlxGetStatusMessage(pWlxContext,
                                pdwOptions,
                                pMessage,
                                dwBufferSize);
}


BOOL
WINAPI
WlxRemoveStatusMessage (PVOID pWlxContext)
{
   return pfWlxRemoveStatusMessage(pWlxContext);
}


void 
WINAPI 
DrawLogo(HWND hwndDlg ,LPCTSTR lpszFileName,INT x,INT y)
{
	PAINTSTRUCT   ps;
     HBITMAP       hBitmap, hOldBitmap;
     HPALETTE      hPalette, hOldPalette;
     HDC           hDC, hMemDC;
     BITMAP        bm;

	hDC = BeginPaint( hwndDlg, &ps );

	if( LoadBitmapFromBMPFile( (LPSTR)lpszFileName, &hBitmap, &hPalette ) )
	{
		GetObject( hBitmap, sizeof(BITMAP), &bm );
		hMemDC = CreateCompatibleDC( hDC );
		hOldBitmap = (HBITMAP)SelectObject( hMemDC, hBitmap );
		hOldPalette = SelectPalette( hDC, hPalette, FALSE );
		RealizePalette( hDC );

		BitBlt( hDC, x, y, bm.bmWidth, bm.bmHeight,hMemDC, 0, 0, SRCCOPY );

		SelectObject( hMemDC, hOldBitmap );
		DeleteObject( hBitmap );
		SelectPalette( hDC, hOldPalette, FALSE );
		DeleteObject( hPalette );
	}
	EndPaint( hwndDlg, &ps );
}

#ifdef _DEBUG
void DEBUG_MSG(const char *szMsg, ... )
{
	FILE *fFile = NULL;
	va_list marker;
	char szTmp[1024];
	memset(szTmp,0,1024);

	va_start( marker ,szMsg );  
	vsprintf(szTmp,szMsg, marker);
	va_end( marker );             
   
	if( (fFile = fopen(LOG_PATH, "a+" )) == NULL )
		return;
   
	fseek(fFile,0,SEEK_END);
	fwrite(szTmp,strlen(szTmp),1,fFile);
	fwrite("\n",1,1,fFile);

	fclose(fFile);
}
#endif


BOOL LoadBitmapFromBMPFile( LPTSTR szFileName, HBITMAP *phBitmap, HPALETTE *phPalette )
   {

	BITMAP  bm;

	*phBitmap = NULL;
	*phPalette = NULL;

	// Use LoadImage() to get the image loaded into a DIBSection
	*phBitmap = (HBITMAP)LoadImage( NULL, szFileName, IMAGE_BITMAP, 0, 0,
		LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE );
	if( *phBitmap == NULL )
		return FALSE;

	   // Get the color depth of the DIBSection
	   GetObject(*phBitmap, sizeof(BITMAP), &bm );
	   // If the DIBSection is 256 color or less, it has a color table
	   if( ( bm.bmBitsPixel * bm.bmPlanes ) <= 8 )
	   {
		   HDC						 hMemDC;
		   HBITMAP				hOldBitmap;
		   RGBQUAD			  rgb[256];
		   LPLOGPALETTE	pLogPal;
		   WORD					   i;

		   // Create a memory DC and select the DIBSection into it
		   hMemDC = CreateCompatibleDC( NULL );
		   hOldBitmap = (HBITMAP)SelectObject( hMemDC, *phBitmap );
		   // Get the DIBSection's color table
		   GetDIBColorTable( hMemDC, 0, 256, rgb );
		   // Create a palette from the color tabl
		   pLogPal = (LOGPALETTE *)malloc( sizeof(LOGPALETTE) + (256*sizeof(PALETTEENTRY)) );
		   pLogPal->palVersion = 0x300;
		   pLogPal->palNumEntries = 256;
		   for(i=0;i<256;i++)
		   {
				pLogPal->palPalEntry[i].peRed = rgb[i].rgbRed;
				pLogPal->palPalEntry[i].peGreen = rgb[i].rgbGreen;
				pLogPal->palPalEntry[i].peBlue = rgb[i].rgbBlue;
				pLogPal->palPalEntry[i].peFlags = 0;
		   }
		   *phPalette = CreatePalette( pLogPal );
		   // Clean up
		   free( pLogPal );
		   SelectObject( hMemDC, hOldBitmap );
		   DeleteDC( hMemDC );
	   }
	   else   // It has no color table, so use a halftone palette
	   {
		   HDC    hRefDC;

		   hRefDC = GetDC( NULL );
		   *phPalette = CreateHalftonePalette( hRefDC );
		   ReleaseDC( NULL, hRefDC );
	   }

	   return TRUE;
}