/*++

Copyright (c) 1995  Microsoft Corporation

Module Name:

   certdb.c

Abstract:

   License Logging Service certificate database implementation.  This database
   tracks license certificates to help ensure that no more licenses from a
   single certificate are installe don the license enterprise than are allowed
   by the certificate's license agreement.

   The certificate database at the top level is an unsorted array of
   certificate headers.  There is exactly one header per unique certificate.
   A unique certificate is identified by a combination of product name,
   certificate ID, certificate capacity (max. licenses legally installable),
   and expiration date.

   Each header has an attached array of certificate claims.  There is exactly
   one claim per machine that (a) replicates to this machine, directly or
   indirectly, and (b) has licenses from this certificate installed.  Each
   claim contains the server name to which it corresponds, the number of
   licenses installed on it, and the date this information was replicated.
   If a claim is not updated after LLS_CERT_DB_REPLICATION_DATE_DELTA_MAX
   seconds (3 days as of this writing), the claim is considered forfeit and
   is erased.

Author:

   Jeff Parham (jeffparh) 08-Dec-1995

Revision History:

--*/


#include <stdlib.h>
#include <limits.h>
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <rpc.h>
#include <rpcndr.h>
#include <dsgetdc.h>

#include "debug.h"
#include "llsutil.h"
#include "llssrv.h"
#include "llsapi.h"
#include "llsevent.h"
#include "llsrpc_s.h"
#include "certdb.h"
#include "purchase.h"
#include "registry.h"


RTL_RESOURCE                     CertDbHeaderListLock;
static PLLS_CERT_DB_CERTIFICATE_HEADER  CertDbHeaderList        = NULL;
static DWORD                            CertDbHeaderListSize    = 0;
static HANDLE                           CertDbFile              = NULL;


///////////////////////////////////////////////////////////////////////////////
NTSTATUS CertDbClaimEnter( LPTSTR               pszServerName,
                           PLLS_LICENSE_INFO_1  pLicense,
                           BOOL                 bIsTotal,
                           DWORD                ReplicationDate )

/*++

Routine Description:

   Enter a claim into the database.

Arguments:

   pszServerName (LPTSTR)
      The server for which to enter this claim.  A value of NULL indicates the
      local server.
   pLicense (PLLS_LICENSE_INFO_1)
      License information to enter into the database.
   bIsTotal (BOOL)
      If TRUE, indicates that this license information represents the total
      licenses installed on the machine and should therefore replace the
      current claim (if any).  Otherwise, indicates this license information
      should be added to the current claim (if any).
   ReplicationDate (DWORD)
      Indicates the date which this information was last replicated.  A value
      of 0 will be replaced with the current system time.

Return Value:

   STATUS_SUCCESS
   STATUS_INVALID_PARAMETER
   STATUS_INVALID_COMPUTER_NAME
   STATUS_NO_MEMORY

--*/

{
   NTSTATUS    nt;

   if ( ( NULL == pLicense ) || ( 0 == pLicense->CertificateID ) )
   {
      ASSERT( FALSE );
      nt = STATUS_INVALID_PARAMETER;
   }
   else
   {
      TCHAR    szComputerName[ 1 + MAX_COMPUTERNAME_LENGTH ];

      if ( NULL == pszServerName )
      {
         // use local server name
         DWORD    cchComputerName = sizeof( szComputerName ) / sizeof( *szComputerName );
         BOOL     ok;

         ok = GetComputerName( szComputerName, &cchComputerName );
         ASSERT( ok );

         if ( ok )
         {
            pszServerName = szComputerName;
         }
      }
      else
      {
         // remove leading backslashes (if any) from server name
         while ( TEXT('\\') == *pszServerName )
         {
            pszServerName++;
         }
      }

      if ( ( NULL == pszServerName ) || !*pszServerName || ( lstrlen( pszServerName ) > MAX_COMPUTERNAME_LENGTH ) )
      {
         ASSERT( FALSE );
         nt = STATUS_INVALID_COMPUTER_NAME;
      }
      else
      {
         PLLS_CERT_DB_CERTIFICATE_HEADER  pHeader;

         RtlAcquireResourceExclusive( &CertDbHeaderListLock, TRUE );

         // is the certificate in the db?
         pHeader = CertDbHeaderFind( pLicense );

         if ( NULL == pHeader )
         {
            // certificate not yet in db; add it
            pHeader = CertDbHeaderAdd( pLicense );
         }

         if ( NULL == pHeader )
         {
            // could not find or add header
            ASSERT( FALSE );
            nt = STATUS_NO_MEMORY;
         }
         else
         {
            // now have header; is this claim already filed?
            int iClaim;

            iClaim = CertDbClaimFind( pHeader, pszServerName );

            if ( iClaim < 0 )
            {
               PLLS_CERT_DB_CERTIFICATE_CLAIM pClaimsTmp;

               // claim does not yet exist; add it
               if ( NULL == pHeader->Claims )
               {
                  pClaimsTmp = LocalAlloc( LPTR, ( 1 + pHeader->NumClaims ) * sizeof( LLS_CERT_DB_CERTIFICATE_CLAIM ) );
               }
               else
               {
                   pClaimsTmp = LocalReAlloc( pHeader->Claims, ( 1 + pHeader->NumClaims ) * sizeof( LLS_CERT_DB_CERTIFICATE_CLAIM ), LHND );

               }

               if ( NULL != pClaimsTmp )
               {
                  // memory allocation succeeded

                  // claim list expanded; save server name
                  pHeader->Claims = pClaimsTmp;

                  iClaim = pHeader->NumClaims;
                  lstrcpy( pHeader->Claims[ iClaim ].ServerName, pszServerName );
                  pHeader->Claims[ iClaim ].Quantity = 0;

                  pHeader->NumClaims++;
               }
            }

            if ( iClaim < 0 )
            {
               // could not find or add claim to header
               ASSERT( FALSE );
               nt = STATUS_NO_MEMORY;
            }
            else
            {
               // claim found or added; update info
               ASSERT( !lstrcmpi( pszServerName, pHeader->Claims[ iClaim ].ServerName ) );
               pHeader->Claims[ iClaim ].ReplicationDate = ReplicationDate ? ReplicationDate : DateSystemGet();

               if ( bIsTotal )
               {
                  // the given value is the new total
                  pHeader->Claims[ iClaim ].Quantity        = pLicense->Quantity;
                  nt = STATUS_SUCCESS;
               }
               else if ( pHeader->Claims[ iClaim ].Quantity + pLicense->Quantity >= 0 )
               {
                  // the given value is added to the current sum to make the total
                  pHeader->Claims[ iClaim ].Quantity       += pLicense->Quantity;
                  nt = STATUS_SUCCESS;
               }
               else
               {
                  // overflow
                  nt = STATUS_INVALID_PARAMETER;
               }
            }
         }

         RtlReleaseResource( &CertDbHeaderListLock );

         if ( STATUS_SUCCESS == nt )
         {
            // any product that has licenses with non-0 certificate IDs
            // must be secure; this code is here such that when certificates
            // are replicated, the "product is secure" info is replicated, too
            // this will also help recover from the case where someone deletes
            // the registry key that lists all secure products
            ServiceSecuritySet( pLicense->Product );
         }
      }
   }

   return nt;
}


///////////////////////////////////////////////////////////////////////////////
BOOL CertDbClaimApprove( PLLS_LICENSE_INFO_1 pLicense )

/*++

Routine Description:

   Check to see if adding the given licenses is legal.  This call is typically
   made before adding a license into the system to verify that doing so does
   not violate the certificate's license agreement.

Arguments:

   pLicense (PLLS_LICENSE_INFO_1)
      License information for which approval is sought.

Return Value:

   TRUE (approved) or FALSE (rejected).

--*/

{
   BOOL                             bOkToAdd = TRUE;
   PLLS_CERT_DB_CERTIFICATE_HEADER  pHeader;
   TCHAR                            szComputerName[ 1 + MAX_COMPUTERNAME_LENGTH ];
   DWORD                            cchComputerName = sizeof( szComputerName ) / sizeof( *szComputerName );
   BOOL                             ok;

   if ( ( pLicense->Quantity > 0 ) && ( (DWORD)pLicense->Quantity > pLicense->MaxQuantity ) )
   {
      // certificate add request exceeds its capacity all by itself!
      bOkToAdd = FALSE;
   }
   else
   {
      ok = GetComputerName( szComputerName, &cchComputerName );
      ASSERT( ok );

      if ( !ok )
      {
         // deletions will fail...
         *szComputerName = TEXT( '\0' );
      }

      // do we have a record of this certificate?
      RtlAcquireResourceShared( &CertDbHeaderListLock, TRUE );

      pHeader = CertDbHeaderFind( pLicense );

      if ( NULL == pHeader )
      {
         // don't have any record of this certificate; ok to add if Quantity > 0
         bOkToAdd = ( pLicense->Quantity > 0 );
      }
      else
      {
         LONG     lTotalQuantity = 0;
         int      iClaim;

         // we have seen this certificate; are there enough licenses available?
         for ( iClaim=0; (DWORD)iClaim < pHeader->NumClaims; iClaim++ )
         {
            // for license remove requests, tally only local licenses
            // for license add requests, tally all licenses
            if (    (    ( pLicense->Quantity > 0 )
                      || ( !lstrcmpi( pHeader->Claims[ iClaim ].ServerName, szComputerName ) ) )
                 && ( lTotalQuantity + pHeader->Claims[ iClaim ].Quantity >= 0 ) )
            {
               // add to tally
               lTotalQuantity += pHeader->Claims[ iClaim ].Quantity;
            }
         }

         if ( lTotalQuantity + pLicense->Quantity < 0 )
         {
            // overflow or underflow
            bOkToAdd = FALSE;
         }
         else if ( (DWORD)(lTotalQuantity + pLicense->Quantity) > pHeader->MaxQuantity )
         {
            // exceeds certificate capacity
            bOkToAdd = FALSE;
         }
         else
         {
            // okay by me
            bOkToAdd = TRUE;
         }
      }

      RtlReleaseResource( &CertDbHeaderListLock );
   }

   return bOkToAdd;
}


///////////////////////////////////////////////////////////////////////////////
PLLS_CERT_DB_CERTIFICATE_HEADER CertDbHeaderFind( PLLS_LICENSE_INFO_1 pLicense )

/*++

Routine Description:

   Find a certificate header in the database.

Arguments:

   pLicense (PLLS_LICENSE_INFO_1)
      License information for which to find the appropriate header.

Return Value:

   A pointer to the found header, or NULL if not found.

--*/

{
   // assumes db is already locked for shared or exclusive access

   PLLS_CERT_DB_CERTIFICATE_HEADER  pHeader = NULL;
   int                              iHeader;

   for ( iHeader=0; ( NULL == pHeader ) && ( (DWORD)iHeader < CertDbHeaderListSize ); iHeader++ )
   {
      if (    ( CertDbHeaderList[ iHeader ].CertificateID  ==   pLicense->CertificateID  )
           && ( CertDbHeaderList[ iHeader ].MaxQuantity    ==   pLicense->MaxQuantity    )
           && ( CertDbHeaderList[ iHeader ].ExpirationDate ==   pLicense->ExpirationDate )
           && ( !lstrcmpi( CertDbHeaderList[ iHeader ].Product, pLicense->Product      ) ) )
      {
         // header found!
         pHeader = &CertDbHeaderList[ iHeader ];
      }
   }

   return pHeader;
}


///////////////////////////////////////////////////////////////////////////////
PLLS_CERT_DB_CERTIFICATE_HEADER CertDbHeaderAdd( PLLS_LICENSE_INFO_1 pLicense )

/*++

Routine Description:

   Add a certificate header to the database.

Arguments:

   pLicense (PLLS_LICENSE_INFO_1)
      License information for which to add the header.

Return Value:

   A pointer to the added header, or NULL if memory could not be allocated.

--*/

{
   // assumes caller has made sure the header does not already exist
   // assumes db is locked for exclusive access

   PLLS_CERT_DB_CERTIFICATE_HEADER  pHeader;

   if ( CertDbHeaderListSize )
   {
      pHeader = LocalReAlloc( CertDbHeaderList, ( 1 + CertDbHeaderListSize ) * sizeof( LLS_CERT_DB_CERTIFICATE_HEADER ), LHND );
   }
   else
   {
      pHeader = LocalAlloc( LPTR, ( 1 + CertDbHeaderListSize ) * sizeof( LLS_CERT_DB_CERTIFICATE_HEADER ) );
   }

   if ( NULL != pHeader )
   {
       CertDbHeaderList = pHeader;

      // allocate space for product name
      CertDbHeaderList[ CertDbHeaderListSize ].Product = LocalAlloc( LPTR, sizeof( TCHAR ) * ( 1 + lstrlen( pLicense->Product ) ) );

      if ( NULL == CertDbHeaderList[ CertDbHeaderListSize ].Product )
      {
         // memory allocation failed
         ASSERT( FALSE );
         pHeader = NULL;
      }
      else
      {
         // success!
         pHeader = &CertDbHeaderList[ CertDbHeaderListSize ];
         CertDbHeaderListSize++;

         lstrcpy( pHeader->Product, pLicense->Product );
         pHeader->CertificateID   = pLicense->CertificateID;
         pHeader->MaxQuantity     = pLicense->MaxQuantity;
         pHeader->ExpirationDate  = pLicense->ExpirationDate;
      }
   }

   return pHeader;
}


///////////////////////////////////////////////////////////////////////////////
int CertDbClaimFind( PLLS_CERT_DB_CERTIFICATE_HEADER pHeader, LPTSTR pszServerName )

/*++

Routine Description:

   Find a certificate claim for a specific server in the claim list.

Arguments:

   pHeader (PLLS_CERT_DB_CERTIFICATE_HEADER)
      Header containing the claim list to search.
   pszServerName (LPTSTR)
      Name of the server for which the claim is sought.

Return Value:

   The index of the found claim, or -1 if not found.

--*/

{
   // assumes db is already locked for shared or exclusive access

   int iClaim;

   for ( iClaim=0; (DWORD)iClaim < pHeader->NumClaims; iClaim++ )
   {
      if ( !lstrcmpi( pHeader->Claims[ iClaim ].ServerName, pszServerName ) )
      {
         break;
      }
   }

   if ( (DWORD)iClaim >= pHeader->NumClaims )
   {
      iClaim = -1;
   }

   return iClaim;
}


///////////////////////////////////////////////////////////////////////////////
void CertDbPrune()

/*++

Routine Description:

   Remove entries in the database which have expired.  Entries expire if they
   have not been re-replicated in LLS_CERT_DB_REPLICATION_DATE_DELTA_MAX
   seconds (3 days as of this writing).

Arguments:

   None.

Return Value:

   None.

--*/

{
   int      iHeader;
   int      iClaim;
   DWORD    CurrentDate;
   DWORD    MinimumDate;
   TCHAR    szComputerName[ 1 + MAX_COMPUTERNAME_LENGTH ] = TEXT("");
   DWORD    cchComputerName = sizeof( szComputerName ) / sizeof( *szComputerName );
   BOOL     ok;

   ok = GetComputerName( szComputerName, &cchComputerName );
   ASSERT( ok );

   if ( ok )
   {
      RtlAcquireResourceExclusive( &CertDbHeaderListLock, TRUE );

      CurrentDate = DateSystemGet();
      MinimumDate = CurrentDate - LLS_CERT_DB_REPLICATION_DATE_DELTA_MAX;

      for ( iHeader=0; (DWORD)iHeader < CertDbHeaderListSize; iHeader++ )
      {
         for ( iClaim=0; (DWORD)iClaim < CertDbHeaderList[ iHeader ].NumClaims; )
         {
            // Note that we prune entries made in the future, too, to avoid having an incorrect date
            // forcing us to keep an entry forever.
            //
            // For this application, it's better to keep fewer entries rather than more, as the
            // fewer entries we have, the less restrictive the system is.
            //
            // Don't prune local entries.

            if (    (    ( CertDbHeaderList[ iHeader ].Claims[ iClaim ].ReplicationDate < MinimumDate )
                      || ( CertDbHeaderList[ iHeader ].Claims[ iClaim ].ReplicationDate > CurrentDate ) )
                 && lstrcmpi( szComputerName, CertDbHeaderList[ iHeader ].Claims[ iClaim ].ServerName   ) )
            {
               // remove claim
               MoveMemory( &CertDbHeaderList[ iHeader ].Claims[ iClaim ],
                           &CertDbHeaderList[ iHeader ].Claims[ iClaim+1 ],
                           CertDbHeaderList[ iHeader ].NumClaims - ( iClaim + 1 ) );

               CertDbHeaderList[ iHeader ].NumClaims--;
            }
            else
            {
               // keep this claim
               iClaim++;
            }
         }
      }

      RtlReleaseResource( &CertDbHeaderListLock );
   }
}


///////////////////////////////////////////////////////////////////////////////
void CertDbRemoveLocalClaims()

/*++

Routine Description:

   Remove entries in the database corresponding to the local server.

Arguments:

   None.

Return Value:

   None.

--*/

{
   int      iHeader;
   int      iClaim;
   TCHAR    szComputerName[ 1 + MAX_COMPUTERNAME_LENGTH ] = TEXT("");
   DWORD    cchComputerName = sizeof( szComputerName ) / sizeof( *szComputerName );
   BOOL     ok;

   ok = GetComputerName( szComputerName, &cchComputerName );
   ASSERT( ok );

   if ( ok )
   {
      RtlAcquireResourceExclusive( &CertDbHeaderListLock, TRUE );

      for ( iHeader=0; (DWORD)iHeader < CertDbHeaderListSize; iHeader++ )
      {
         for ( iClaim=0; (DWORD)iClaim < CertDbHeaderList[ iHeader ].NumClaims; )
         {
            if ( !lstrcmpi( szComputerName, CertDbHeaderList[ iHeader ].Claims[ iClaim ].ServerName ) )
            {
               // remove claim
               MoveMemory( &CertDbHeaderList[ iHeader ].Claims[ iClaim ],
                           &CertDbHeaderList[ iHeader ].Claims[ iClaim+1 ],
                           CertDbHeaderList[ iHeader ].NumClaims - ( iClaim + 1 ) );

               CertDbHeaderList[ iHeader ].NumClaims--;
            }
            else
            {
               // keep this claim
               iClaim++;
            }
         }
      }

      RtlReleaseResource( &CertDbHeaderListLock );
   }
}


///////////////////////////////////////////////////////////////////////////////
void CertDbLogViolations()

/*++

Routine Description:

   Log violations of certificate license agreements to the event log of the
   local server.

Arguments:

   None.

Return Value:

   None.

--*/

{
   int         iHeader;
   int         iClaim;
   HANDLE      hEventLog;
   DWORD       dwTotalQuantity;
   HINSTANCE   hDll;
   DWORD       cch;
   LPTSTR      pszViolationServerEntryFormat;
   LPTSTR      pszViolationFormat;
   LPTSTR      pszViolationServerEntryList;
   LPTSTR      pszNextViolationServerEntry;
   TCHAR       szNumLicenses[ 20 ];
   TCHAR       szMaxLicenses[ 20 ];
   TCHAR       szCertificateID[ 20 ];
   LPTSTR      apszSubstStrings[ 5 ];
   DWORD       cbViolationServerList;
   LPTSTR      pszViolationServerList;

   // get rid of out-dated entries
   CertDbPrune();

   hDll = LoadLibrary( TEXT( "LLSRPC.DLL" ) );
   ASSERT( NULL != hDll );

   if ( NULL != hDll )
   {
      // format for part of logged message that lists server and #licenses
      cch = FormatMessage(   FORMAT_MESSAGE_ALLOCATE_BUFFER
                           | FORMAT_MESSAGE_IGNORE_INSERTS
                           | FORMAT_MESSAGE_FROM_HMODULE,
                           hDll,
                           LLS_EVENT_CERT_VIOLATION_SERVER_ENTRY,
                           GetSystemDefaultLangID(),
                           (LPVOID) &pszViolationServerEntryFormat,
                           0,
                           NULL );

      if ( 0 != cch )
      {
         hEventLog = RegisterEventSource( NULL, TEXT("LicenseService") );

         if ( NULL != hEventLog )
         {
            RtlAcquireResourceShared( &CertDbHeaderListLock, TRUE );

            for ( iHeader=0; (DWORD)iHeader < CertDbHeaderListSize; iHeader++ )
            {
               dwTotalQuantity = 0;

               // tally the number of licenses claimed against this certificate
               for ( iClaim=0; (DWORD)iClaim < CertDbHeaderList[ iHeader ].NumClaims; iClaim++ )
               {
                  if ( dwTotalQuantity + (DWORD)CertDbHeaderList[ iHeader ].Claims[ iClaim ].Quantity < dwTotalQuantity )
                  {
                     // overflow!
                     dwTotalQuantity = ULONG_MAX;
                     break;
                  }
                  else
                  {
                     // add to tally
                     dwTotalQuantity += CertDbHeaderList[ iHeader ].Claims[ iClaim ].Quantity;
                  }
               }

               if ( dwTotalQuantity > CertDbHeaderList[ iHeader ].MaxQuantity )
               {
                  // this certificate is in violation

                  // create message we're going to log
                  cbViolationServerList =   CertDbHeaderList[ iHeader ].NumClaims
                                          * sizeof( TCHAR )
                                          * (   lstrlen( pszViolationServerEntryFormat )
                                              + 20
                                              + MAX_COMPUTERNAME_LENGTH );
                  pszViolationServerList = LocalAlloc( LPTR, cbViolationServerList );
                  ASSERT( NULL != pszViolationServerList );

                  if ( NULL != pszViolationServerList )
                  {
                     // create an entry for each server in violation, stringing them
                     // together in pszViolationServerList
                     pszNextViolationServerEntry  = pszViolationServerList;

                     for ( iClaim=0; (DWORD)iClaim < CertDbHeaderList[ iHeader ].NumClaims; iClaim++ )
                     {
                        _ltow( CertDbHeaderList[ iHeader ].Claims[ iClaim ].Quantity, szNumLicenses, 10 );

                        apszSubstStrings[ 0 ] = CertDbHeaderList[ iHeader ].Claims[ iClaim ].ServerName;
                        apszSubstStrings[ 1 ] = szNumLicenses;

                        cch = FormatMessage(   FORMAT_MESSAGE_FROM_STRING
                                             | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                                             pszViolationServerEntryFormat,
                                             (DWORD)0,
                                             (DWORD)0,
                                             pszNextViolationServerEntry,
                                             cbViolationServerList - (DWORD)( pszNextViolationServerEntry - pszViolationServerList ),
                                             (va_list *) apszSubstStrings );
                        ASSERT( 0 != cch );

                        pszNextViolationServerEntry += lstrlen( pszNextViolationServerEntry );
                     }

                     _ultow( CertDbHeaderList[ iHeader ].CertificateID, szCertificateID, 10 );
                     _ultow( dwTotalQuantity,                           szNumLicenses,   10 );
                     _ultow( CertDbHeaderList[ iHeader ].MaxQuantity,   szMaxLicenses,   10 );

                     apszSubstStrings[ 0 ] = CertDbHeaderList[ iHeader ].Product;
                     apszSubstStrings[ 1 ] = szCertificateID;
                     apszSubstStrings[ 2 ] = szNumLicenses;
                     apszSubstStrings[ 3 ] = szMaxLicenses;
                     apszSubstStrings[ 4 ] = pszViolationServerList;

                     // log the violation
                     if ( NULL != hEventLog )
                     {
                        ReportEvent( hEventLog,
                                     EVENTLOG_ERROR_TYPE,
                                     0,
                                     LLS_EVENT_CERT_VIOLATION,
                                     NULL,
                                     5,
                                     0,
                                     apszSubstStrings,
                                     NULL );
                     }

                     LocalFree( pszViolationServerList );
                  }
               }
            }

            RtlReleaseResource( &CertDbHeaderListLock );
            LocalFree( pszViolationServerEntryFormat );

            DeregisterEventSource( hEventLog );
         }
      }

      FreeLibrary( hDll );
   }
}


///////////////////////////////////////////////////////////////////////////////
NTSTATUS CertDbPack( LPDWORD                               pcchProductStrings,
                     LPTSTR *                              ppchProductStrings,
                     LPDWORD                               pdwNumHeaders,
                     PREPL_CERT_DB_CERTIFICATE_HEADER_0 *  ppHeaders,
                     LPDWORD                               pdwNumClaims,
                     PREPL_CERT_DB_CERTIFICATE_CLAIM_0 *   ppClaims )

/*++

Routine Description:

   Pack the certificate database into manageable chunks that can be saved or
   replicated.

Arguments:

   pcchProductStrings (LPDWORD)
      On return, holds the size (in characters) of the buffer pointed to by
      *ppchProductStrings.
   ppchProductStrings (LPTSTR *)
      On return, points to the buffer containing the product strings component
      of the database.
   pdwNumHeaders (LPDWORD)
      On return, holds the number of certificate headers in the array pointed
      to by *ppHeaders.
   ppHeaders (PREPL_CERT_DB_CERTIFICATE_HEADER_0 *)
      On return, holds a pointer to the certificate header array component of
      the database.
   pdwNumClaims (LPDWORD)
      On return, holds the number of certificate claims in the array pointed
      to by *ppHeaders.
   ppClaims (PREPL_CERT_DB_CERTIFICATE_CLAIM_0 *)
      On return, holds a pointer to the certificate claim array component of
      the database.

Return Value:

   STATUS_SUCCESS or STATUS_NO_MEMORY.

--*/

{
   NTSTATUS                            nt                   = STATUS_SUCCESS;

   DWORD                               cchProductStrings    = 0;
   LPTSTR                              pchProductStrings    = NULL;
   DWORD                               dwNumHeaders         = 0;
   PREPL_CERT_DB_CERTIFICATE_HEADER_0  pHeaders             = NULL;
   DWORD                               dwNumClaims          = 0;
   PREPL_CERT_DB_CERTIFICATE_CLAIM_0   pClaims              = NULL;

   LPTSTR                              pchNextProductString;
   int                                 iHeader;
   int                                 iClaim;

   CertDbPrune();
   CertDbUpdateLocalClaims();

   RtlAcquireResourceExclusive( &CertDbHeaderListLock, TRUE );

   if ( 0 != CertDbHeaderListSize )
   {
      // how big are all of our strings put together?
      // hom many certificate claims are there?
      for ( iHeader=0; (DWORD)iHeader < CertDbHeaderListSize; iHeader++ )
      {
         cchProductStrings += 1 + lstrlen( CertDbHeaderList[ iHeader ].Product );
         dwNumClaims += CertDbHeaderList[ iHeader ].NumClaims;
      }
      dwNumHeaders = CertDbHeaderListSize;

      pchProductStrings = LocalAlloc( LMEM_FIXED, cchProductStrings * sizeof( TCHAR ) );
      pHeaders          = LocalAlloc( LMEM_FIXED, dwNumHeaders * sizeof( REPL_CERT_DB_CERTIFICATE_HEADER_0 ) );
      pClaims           = LocalAlloc( LMEM_FIXED, dwNumClaims * sizeof( REPL_CERT_DB_CERTIFICATE_CLAIM_0 ) );

      if ( ( NULL == pchProductStrings ) || ( NULL == pHeaders ) || ( NULL == pClaims ) )
      {
         ASSERT( FALSE );
         nt = STATUS_NO_MEMORY;
      }
      else
      {
         // pack the product strings
         pchNextProductString = pchProductStrings;

         for ( iHeader=0; (DWORD)iHeader < CertDbHeaderListSize; iHeader++ )
         {
            lstrcpy( pchNextProductString, CertDbHeaderList[ iHeader ].Product );
            pchNextProductString += 1 + lstrlen( pchNextProductString );
         }

         // now pack away the rest of our structures
         iClaim = 0;
         for ( iHeader=0; (DWORD)iHeader < CertDbHeaderListSize; iHeader++ )
         {
            pHeaders[ iHeader ].CertificateID   = CertDbHeaderList[ iHeader ].CertificateID;
            pHeaders[ iHeader ].MaxQuantity     = CertDbHeaderList[ iHeader ].MaxQuantity;
            pHeaders[ iHeader ].ExpirationDate  = CertDbHeaderList[ iHeader ].ExpirationDate;
            pHeaders[ iHeader ].NumClaims       = CertDbHeaderList[ iHeader ].NumClaims;

            if ( CertDbHeaderList[ iHeader ].NumClaims )
            {
               memcpy( &pClaims[ iClaim ],
                       CertDbHeaderList[ iHeader ].Claims,
                       CertDbHeaderList[ iHeader ].NumClaims * sizeof( LLS_CERT_DB_CERTIFICATE_CLAIM ) );

               iClaim += CertDbHeaderList[ iHeader ].NumClaims;
            }
         }

         // all done!
         nt = STATUS_SUCCESS;
      }
   }

   if ( STATUS_SUCCESS == nt )
   {
      *pcchProductStrings  = cchProductStrings;
      *ppchProductStrings  = pchProductStrings;

      *pdwNumHeaders       = dwNumHeaders;
      *ppHeaders           = pHeaders;

      *pdwNumClaims        = dwNumClaims;
      *ppClaims            = pClaims;
   }
   else
   {
      if ( NULL != pchProductStrings   )  LocalFree( pchProductStrings  );
      if ( NULL != pHeaders            )  LocalFree( pHeaders           );
      if ( NULL != pClaims             )  LocalFree( pClaims            );
   }

   RtlReleaseResource( &CertDbHeaderListLock );

   return nt;
}


///////////////////////////////////////////////////////////////////////////////
NTSTATUS CertDbUnpack( DWORD                               cchProductStrings,
                       LPTSTR                              pchProductStrings,
                       DWORD                               dwNumHeaders,
                       PREPL_CERT_DB_CERTIFICATE_HEADER_0  pHeaders,
                       DWORD                               dwNumClaims,
                       PREPL_CERT_DB_CERTIFICATE_CLAIM_0   pClaims,
                       BOOL                                bReplicated )

/*++

Routine Description:

   Pack the certificate database into manageable chunks that can be saved or
   replicated.

Arguments:

   cchProductStrings (DWORD)
      The size (in characters) of the buffer pointed to by pchProductStrings.
   pchProductStrings (LPTSTR)
      The buffer containing the product strings component of the database.
   dwNumHeaders (DWORD)
      The number of certificate headers in the array pointed to by pHeaders.
   pHeaders (PREPL_CERT_DB_CERTIFICATE_HEADER_0)
      The certificate header array component of the database.
   dwNumClaims (DWORD)
      The number of certificate claims in the array pointed to by pHeaders.
   pClaims (PREPL_CERT_DB_CERTIFICATE_CLAIM_0)
      The certificate claim array component of the database.
   bReplicated (BOOL)
      Indicates whether this information was replicated.  This is used to
      determine the time at which this information will expire.

Return Value:

   STATUS_SUCCESS or NTSTATUS error code.

--*/

{
   NTSTATUS                            nt                      = STATUS_SUCCESS;
   LPTSTR                              pchNextProductString;
   LPBYTE                              pb;
   int                                 iHeader;
   int                                 iClaim;
   int                                 iClaimBase;
   LLS_LICENSE_INFO_1                  lic;
   TCHAR                               szComputerName[ 1 + MAX_COMPUTERNAME_LENGTH ];
   DWORD                               cchComputerName = sizeof( szComputerName ) / sizeof( *szComputerName );
   BOOL                                ok;

   ok = GetComputerName( szComputerName, &cchComputerName );
   ASSERT( ok );

   if ( !ok )
   {
      // in this case, we'll just add in the local entries, too
      // under normal circumstances (i.e., as long as the cert db isn't corrupt),
      // this is harmless and is preferrable to failing to unpack
      *szComputerName = TEXT( '\0' );
   }

   RtlAcquireResourceExclusive( &CertDbHeaderListLock, TRUE );

   pchNextProductString = pchProductStrings;

   // these fields are irrelevant!
   lic.Date         = 0;
   lic.Admin        = NULL;
   lic.Comment      = NULL;
   lic.Vendor       = NULL;
   lic.Source       = NULL;
   lic.AllowedModes = 0;

   iClaimBase = 0;
   for ( iHeader=0; (DWORD)iHeader < dwNumHeaders; iHeader++ )
   {
      if ( 0 != pHeaders[ iHeader ].NumClaims )
      {
         // certificate-specific fields
         lic.Product          = pchNextProductString;
         lic.CertificateID    = pHeaders[ iHeader ].CertificateID;
         lic.MaxQuantity      = pHeaders[ iHeader ].MaxQuantity;
         lic.ExpirationDate   = pHeaders[ iHeader ].ExpirationDate;

         for ( iClaim=0; (DWORD)iClaim < pHeaders[ iHeader ].NumClaims; iClaim++ )
         {
            if ( lstrcmpi( szComputerName, pClaims[ iClaimBase + iClaim ].ServerName ) )
            {
               // not the local server

               // claim-specific field
               lic.Quantity = pClaims[ iClaimBase + iClaim ].Quantity;

               nt = CertDbClaimEnter( pClaims[ iClaimBase + iClaim ].ServerName, &lic, TRUE, bReplicated ? 0 : pClaims[ iClaimBase + iClaim ].ReplicationDate );
               ASSERT( STATUS_SUCCESS == nt );

               // even if we encounter an error, go ahead and unpack the rest of the records
            }
         }

         iClaimBase += pHeaders[ iHeader ].NumClaims;
      }

      pchNextProductString += 1 + lstrlen( pchNextProductString );
   }

   RtlReleaseResource( &CertDbHeaderListLock );

   return nt;
}


///////////////////////////////////////////////////////////////////////////////
NTSTATUS CertDbSave()

/*++

Routine Description:

   Save the certificate database.

Arguments:

   None.

Return Value:

   STATUS_SUCCESS, Windows error, or NTSTATUS error code.

--*/

{
   NTSTATUS                            nt;
   LLS_CERT_DB_FILE_HEADER             FileHeader;
   DWORD                               cchProductStrings    = 0;
   LPTSTR                              pchProductStrings    = NULL;
   DWORD                               dwNumHeaders         = 0;
   PREPL_CERT_DB_CERTIFICATE_HEADER_0  pHeaders             = NULL;
   DWORD                               dwNumClaims          = 0;
   PREPL_CERT_DB_CERTIFICATE_CLAIM_0   pClaims              = NULL;
   DWORD                               dwBytesWritten;
   BOOL                                ok;

   nt = CertDbPack( &cchProductStrings, &pchProductStrings, &dwNumHeaders, &pHeaders, &dwNumClaims, &pClaims );

   if ( STATUS_SUCCESS == nt )
   {
      if ( dwNumHeaders )
      {
         nt = EBlock( pchProductStrings, cchProductStrings * sizeof( TCHAR ) );

         if ( STATUS_SUCCESS == nt )
         {
            nt = EBlock( pHeaders, sizeof( REPL_CERT_DB_CERTIFICATE_HEADER_0 ) * dwNumHeaders );

            if ( STATUS_SUCCESS == nt )
            {
               nt = EBlock( pClaims, sizeof( REPL_CERT_DB_CERTIFICATE_CLAIM_0 ) * dwNumClaims );

               if ( STATUS_SUCCESS == nt )
               {
                  if ( NULL != CertDbFile )
                  {
                     CloseHandle( CertDbFile );
                  }

                  CertDbFile = LlsFileInit( CertDbFileName, LLS_CERT_DB_FILE_VERSION, sizeof( LLS_CERT_DB_FILE_HEADER ) );

                  if ( NULL == CertDbFile )
                  {
                     nt = GetLastError();
                  }
                  else
                  {
                     FileHeader.NumCertificates    = dwNumHeaders;
                     FileHeader.ProductStringSize  = cchProductStrings;
                     FileHeader.NumClaims          = dwNumClaims;

                     ok = WriteFile( CertDbFile, &FileHeader, sizeof( FileHeader ), &dwBytesWritten, NULL );

                     if ( ok )
                     {
                        ok = WriteFile( CertDbFile, pchProductStrings, FileHeader.ProductStringSize * sizeof( TCHAR ), &dwBytesWritten, NULL );

                        if ( ok )
                        {
                           ok = WriteFile( CertDbFile, pHeaders, sizeof( REPL_CERT_DB_CERTIFICATE_HEADER_0 ) * FileHeader.NumCertificates, &dwBytesWritten, NULL );

                           if ( ok )
                           {
                              ok = WriteFile( CertDbFile, pClaims, sizeof( REPL_CERT_DB_CERTIFICATE_CLAIM_0 ) * FileHeader.NumClaims, &dwBytesWritten, NULL );
                           }
                        }
                     }

                     if ( !ok )
                     {
                        nt = GetLastError();
                     }
                  }
               }
            }
         }

         LocalFree( pchProductStrings  );
         LocalFree( pHeaders           );
         LocalFree( pClaims            );
      }
   }

   if ( STATUS_SUCCESS != nt )
   {
      LogEvent( LLS_EVENT_SAVE_CERT_DB, 0, NULL, nt );
   }

   return nt;
}


///////////////////////////////////////////////////////////////////////////////
NTSTATUS CertDbLoad()

/*++

Routine Description:

   Load the certificate database.

Arguments:

   None.

Return Value:

   STATUS_SUCCESS, Windows error, or NTSTATUS error code.

--*/

{
   NTSTATUS                            nt                   = STATUS_SUCCESS;
   DWORD                               dwVersion;
   DWORD                               dwDataSize;
   LLS_CERT_DB_FILE_HEADER             FileHeader;
   LPTSTR                              pchProductStrings    = NULL;
   PREPL_CERT_DB_CERTIFICATE_HEADER_0  pHeaders             = NULL;
   PREPL_CERT_DB_CERTIFICATE_CLAIM_0   pClaims              = NULL;
   DWORD                               dwBytesRead;
   BOOL                                ok;

   if ( NULL != CertDbFile )
   {
      CloseHandle( CertDbFile );
      CertDbFile = NULL;
   }

   if ( FileExists( CertDbFileName ) )
   {
      CertDbFile = LlsFileCheck( CertDbFileName, &dwVersion, &dwDataSize );

      if ( NULL == CertDbFile )
      {
         nt = GetLastError();
      }
      else if (    ( LLS_CERT_DB_FILE_VERSION != dwVersion )
                || ( sizeof( FileHeader ) != dwDataSize ) )
      {
         nt = STATUS_FILE_INVALID;
      }
      else
      {
         ok = ReadFile( CertDbFile, &FileHeader, sizeof( FileHeader ), &dwBytesRead, NULL );

         if ( !ok )
         {
            nt = GetLastError();
         }
         else if ( FileHeader.NumCertificates )
         {
            pchProductStrings = LocalAlloc( LMEM_FIXED, sizeof( TCHAR ) * FileHeader.ProductStringSize );
            pHeaders          = LocalAlloc( LMEM_FIXED, sizeof( REPL_CERT_DB_CERTIFICATE_HEADER_0 ) * FileHeader.NumCertificates );
            pClaims           = LocalAlloc( LMEM_FIXED, sizeof( REPL_CERT_DB_CERTIFICATE_CLAIM_0  ) * FileHeader.NumClaims );

            if ( ( NULL == pchProductStrings ) || ( NULL == pHeaders ) || ( NULL == pClaims ) )
            {
               ASSERT( FALSE );
               nt = STATUS_NO_MEMORY;
            }
            else
            {
               ok = ReadFile( CertDbFile, pchProductStrings, FileHeader.ProductStringSize * sizeof( TCHAR ), &dwBytesRead, NULL );

               if ( ok )
               {
                  ok = ReadFile( CertDbFile, pHeaders, sizeof( REPL_CERT_DB_CERTIFICATE_HEADER_0 ) * FileHeader.NumCertificates, &dwBytesRead, NULL );

                  if ( ok )
                  {
                     ok = ReadFile( CertDbFile, pClaims, sizeof( REPL_CERT_DB_CERTIFICATE_CLAIM_0 ) * FileHeader.NumClaims, &dwBytesRead, NULL );
                  }
               }

               if ( !ok )
               {
                  nt = GetLastError();
               }
               else
               {
                  nt = DeBlock( pchProductStrings, sizeof( TCHAR ) * FileHeader.ProductStringSize );

                  if ( STATUS_SUCCESS == nt )
                  {
                     nt = DeBlock( pHeaders, sizeof( REPL_CERT_DB_CERTIFICATE_HEADER_0 ) * FileHeader.NumCertificates );

                     if ( STATUS_SUCCESS == nt )
                     {
                        nt = DeBlock( pClaims, sizeof( REPL_CERT_DB_CERTIFICATE_CLAIM_0 ) * FileHeader.NumClaims );

                        if ( STATUS_SUCCESS == nt )
                        {
                           nt = CertDbUnpack( FileHeader.ProductStringSize,
                                              pchProductStrings,
                                              FileHeader.NumCertificates,
                                              pHeaders,
                                              FileHeader.NumClaims,
                                              pClaims,
                                              FALSE );
                        }
                     }
                  }
               }
            }
         }
      }
   }

   if ( NULL != pchProductStrings   )  LocalFree( pchProductStrings  );
   if ( NULL != pHeaders            )  LocalFree( pHeaders           );
   if ( NULL != pClaims             )  LocalFree( pClaims            );

   if ( STATUS_SUCCESS != nt )
   {
      LogEvent( LLS_EVENT_LOAD_CERT_DB, 0, NULL, nt );
   }
   else
   {
      CertDbPrune();
   }

   return nt;
}


///////////////////////////////////////////////////////////////////////////////
NTSTATUS CertDbInit()

/*++

Routine Description:

   Initialize the certificate database.

Arguments:

   None.

Return Value:

   STATUS_SUCCESS.

--*/

{
   CertDbFile           = NULL;

   try
   {
       RtlInitializeResource( &CertDbHeaderListLock );
   } except(EXCEPTION_EXECUTE_HANDLER ) {
        return GetExceptionCode();
   }

   return STATUS_SUCCESS;
}


///////////////////////////////////////////////////////////////////////////////
void CertDbUpdateLocalClaims()

/*++

Routine Description:

   Synchronize the certificate database with the purchase history.

Arguments:

   None.

Return Value:

   None.

--*/

{
   DWORD                      dwPurchaseNdx;
   LLS_LICENSE_INFO_1         lic;
   PLICENSE_PURCHASE_RECORD   pPurchase;

   RtlAcquireResourceExclusive( &LicenseListLock,      TRUE );
   RtlAcquireResourceExclusive( &CertDbHeaderListLock, TRUE );

   // first dump all current entries for the local server
   CertDbRemoveLocalClaims();

   // these fields are irrelevant!
   lic.Date         = 0;
   lic.Admin        = NULL;
   lic.Comment      = NULL;
   lic.Source       = NULL;
   lic.Vendor       = NULL;
   lic.AllowedModes = 0;

   // add in all secure purchases
   for ( dwPurchaseNdx = 0; dwPurchaseNdx < PurchaseListSize; dwPurchaseNdx++ )
   {
      pPurchase = &PurchaseList[ dwPurchaseNdx ];

      if ( 0 != pPurchase->CertificateID )
      {
         lic.Product          =   ( pPurchase->AllowedModes & LLS_LICENSE_MODE_ALLOW_PER_SEAT )
                                ? pPurchase->Service->ServiceName
                                : pPurchase->PerServerService->ServiceName;

         lic.CertificateID    = pPurchase->CertificateID;
         lic.MaxQuantity      = pPurchase->MaxQuantity;
         lic.ExpirationDate   = pPurchase->ExpirationDate;
         lic.Quantity         = pPurchase->NumberLicenses;

         CertDbClaimEnter( NULL, &lic, FALSE, 0 );
      }
   }

   RtlReleaseResource( &CertDbHeaderListLock );
   RtlReleaseResource( &LicenseListLock      );
}


///////////////////////////////////////////////////////////////////////////////
NTSTATUS CertDbClaimsGet( PLLS_LICENSE_INFO_1               pLicense,
                          LPDWORD                           pdwNumClaims,
                          PLLS_CERTIFICATE_CLAIM_INFO_0 *   ppTargets )

/*++

Routine Description:

   Retrieve a list of all servers with licenses installed from a given
   certificate and the number of licenses installed on each.

Arguments:

   pLicense (PLLS_LICENSE_INFO_1)
      License describing the certificate for which the claims are sought.
   pdwNumClaims (LPDWORD)
      On return, holds the number of claims in the array pointed to by
      *ppTargets.
   ppTargets (PLLS_CERTIFICATE_CLAIM_INFO_0 *)
      On return, holds an array describing all claims made on this
      certificate.

Return Value:

   STATUS_SUCCESS
   STATUS_NOT_FOUND
   STATUS_NO_MEMORY

--*/

{
   NTSTATUS                         nt;
   PLLS_CERT_DB_CERTIFICATE_HEADER  pHeader;
   int                              iClaim;

   // is the certificate in the db?
   pHeader = CertDbHeaderFind( pLicense );

   if ( NULL == pHeader )
   {
      // not here!
      nt = STATUS_NOT_FOUND;
   }
   else
   {
      *ppTargets = MIDL_user_allocate( pHeader->NumClaims * sizeof( LLS_CERTIFICATE_CLAIM_INFO_0 ) );

      if ( NULL == *ppTargets )
      {
         nt = STATUS_NO_MEMORY;
      }
      else
      {
         *pdwNumClaims = pHeader->NumClaims;

         for ( iClaim=0; (DWORD)iClaim < pHeader->NumClaims; iClaim++ )
         {
            lstrcpy( (*ppTargets)[ iClaim ].ServerName, pHeader->Claims[ iClaim ].ServerName );
            (*ppTargets)[ iClaim ].Quantity = pHeader->Claims[ iClaim ].Quantity;
         }

         nt = STATUS_SUCCESS;
      }
   }

   return nt;
}


#if DBG
/////////////////////////////////////////////////////////////////////////
void CertDbDebugDump()

/*++

Routine Description:

   Dump contents of certificate database to debug console.

Arguments:

   None.

Return Value:

   None.

--*/

{
   int            iHeader;
   int            iClaim;

   RtlAcquireResourceShared( &CertDbHeaderListLock, TRUE );

   for ( iHeader=0; (DWORD)iHeader < CertDbHeaderListSize; iHeader++ )
   {
      dprintf( TEXT("\n(%3d)  Product        : %s\n"), iHeader, CertDbHeaderList[ iHeader ].Product );
      dprintf( TEXT("       CertificateID  : %d\n"), CertDbHeaderList[ iHeader ].CertificateID );
      dprintf( TEXT("       MaxQuantity    : %d\n"), CertDbHeaderList[ iHeader ].MaxQuantity );
      dprintf( TEXT("       ExpirationDate : %s\n"), TimeToString( CertDbHeaderList[ iHeader ].ExpirationDate ) );

      for ( iClaim=0; (DWORD)iClaim < CertDbHeaderList[ iHeader ].NumClaims; iClaim++ )
      {
         dprintf( TEXT("\n       (%3d)  ServerName      : %s\n"), iClaim, CertDbHeaderList[ iHeader ].Claims[ iClaim ].ServerName );
         dprintf( TEXT("              ReplicationDate : %s\n"), TimeToString( CertDbHeaderList[ iHeader ].Claims[ iClaim ].ReplicationDate ) );
         dprintf( TEXT("              Quantity        : %d\n"), CertDbHeaderList[ iHeader ].Claims[ iClaim ].Quantity );
      }
   }

   RtlReleaseResource( &CertDbHeaderListLock );

} // CertDbDebugDump

#endif