windows-xp/Source/XPSP1/NT/admin/admt/workobj/exchange.cpp

#include "stdafx.h"

#include "exchange.hpp"

#include "common.hpp"
#include "err.hpp"
#include "ErrDct.hpp"
#include "UString.hpp"

#include "sidcache.hpp"
#include "sd.hpp"
#include "SecObj.hpp"
#include "MAPIProf.hpp"
#include "exldap.h"

#include "Mcs.h"

extern TErrorDct     err;

#define NOT_PT_ERROR(x) ( PROP_TYPE(x.ulPropTag) != PT_ERROR )

#define LDAP_PortNumber_DN_Part          L"/cn=Protocols/cn=LDAP"
#define ATT_OBJ_CLASS          L"Obj-Class"
#define ATT_DIST_NAME          L"Obj-Dist-Name"
#define ATT_LDAP_PORT          L"Port-Number"
#define LDAP_USE_SITE_VALUES     L"Use-Site-Values"


// Stuff related to dynamic loading of DAPI.DLL

HINSTANCE                    hDapi = NULL;
LPDAPISTART                  pDAPIStart = NULL;
LPDAPIEND                    pDAPIEnd = NULL;
LPDAPIREAD                   pDAPIRead = NULL;
LPDAPIWRITE                  pDAPIWrite = NULL;
LPDAPIFREEMEMORY             pDAPIFreeMemory = NULL;
LPBATCHEXPORT                pBatchExport = NULL;

BOOL LoadDAPI()
{
   BOOL                      success = TRUE;

   if ( ! hDapi )
   {
      success = FALSE;
      hDapi = LoadLibrary(_T("DAPI.DLL"));
      if ( hDapi )
      {
         do { // once 
            pDAPIStart = (LPDAPISTART)GetProcAddress(hDapi,"DAPIStartW@8");
            if ( ! pDAPIStart )
            {
               err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"DAPIStart");
               break;
            }
            pDAPIEnd = (LPDAPIEND)GetProcAddress(hDapi,"DAPIEnd@4");
            if ( ! pDAPIEnd )
            {
               err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"DAPIEnd");
               break;
            }
            
            pDAPIRead = (LPDAPIREAD)GetProcAddress(hDapi,"DAPIReadW@24");
            if ( ! pDAPIRead )
            {
               err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"DAPIRead");
               break;
            }
            
            pDAPIWrite = (LPDAPIWRITE)GetProcAddress(hDapi,"DAPIWriteW@28");
            if ( ! pDAPIWrite )
            {
               err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"DAPIWrite");
               break;
            }

            pDAPIFreeMemory = (LPDAPIFREEMEMORY)GetProcAddress(hDapi,"DAPIFreeMemory@4");
            if ( ! pDAPIFreeMemory )
            {
               err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"DAPIFreeMemory");
               break;
            }

            pBatchExport = (LPBATCHEXPORT)GetProcAddress(hDapi,"BatchExportA@4");
            if ( ! pBatchExport )
            {
               err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"BatchExport");
               break;
            }
            success = TRUE;
         } while (false);
      }
      else
      {
         err.MsgWrite(ErrE,DCT_MSG_DAPI_LOAD_LIBRARY_FAILED);
      }
   }
   if ( ! success )
   {
      ReleaseDAPI();
   }
   return success;
}

void ReleaseDAPI()
{
   if ( hDapi )
   {
      FreeLibrary(hDapi);
      hDapi = NULL;
      pDAPIStart = NULL;
      pDAPIEnd = NULL;
      pDAPIRead = NULL;
      pDAPIWrite = NULL;
      pDAPIFreeMemory = NULL;
      pBatchExport = NULL;
   }
}

TGlobalDirectory::TGlobalDirectory()
{
   m_stat                     = NULL;
   m_bUseDefaultMapiProfile   = FALSE;               // Whether to use MAPI profile listed in Registry.
   m_bPromptForMapiProfile    = TRUE;                // Whether to prompt for MAPI profile.
   m_pszMapiProfile           = NULL;                // MAPI profile to use.

   // MAPI
   m_bMapiInitialized         = FALSE;               // TRUE if initialization was successful.
   m_pMapiSession             = NULL;                // MAPI session handle.

   m_pAdrBook                 = NULL;                // The master AB.

   m_pGlobalList              = NULL;
   m_pGlobalTable             = NULL;
   m_pGlobalPropertyTags      = NULL;
   m_pGlobalRows              = NULL;
   m_pRootRows                = NULL;
   m_pContainer               = NULL;
   m_pContainerTable          = NULL;
}

TGlobalDirectory::~TGlobalDirectory()
{
   delete [] m_pszMapiProfile;

   CloseGlobalList();
   EndMapiSession();
}


LPTSTR   TGlobalDirectory::GetMapiProfile() const
{
   return m_pszMapiProfile;
} 

BOOL  TGlobalDirectory::DoUseDefaultMapiProfile() const
{
   return m_bUseDefaultMapiProfile;
} 

BOOL  TGlobalDirectory::DoPromptForMapiProfile() const
{
   return m_bPromptForMapiProfile;
} 

///////////////////////////////////////////////////////////////////////////////
// Log a MAPI warning or error.
void  
   TGlobalDirectory::LogMapiError(
      int                    iSeverity,     // in - Severity (i.e. ErrW, ErrE, etc)
      LPCTSTR                pszEntryPoint, // in - API that generated the error
      HRESULT                hr             // in - error code
   )
{
   if (hr != 0)
      err.MsgWrite(iSeverity,DCT_MSG_GENERIC_HRESULT_SD, pszEntryPoint, hr);
   else
      err.MsgWrite(iSeverity,DCT_MSG_GENERIC_S, pszEntryPoint);
}

void 
   TGlobalDirectory::LogDapiError(
      int                    iSeverity,      // in - severity of error (i.e. ErrW, ErrE, etc.)
      LPCTSTR                pszUserMessage, // in - message describing the action that failed
      DAPI_EVENT           * pResult         // in - DAPIEvent error structure returned from Exchange
   )
{
   WCHAR                     strMsg[1000];
   DWORD                     dimMsg = DIM(strMsg);
   DWORD                     lenMsg;
   DAPI_EVENT              * pEvt;
   WCHAR                     msg[2000];
   
   if ( !pResult )
      return;
   
   safecopy(msg,pszUserMessage);

   for ( pEvt = pResult ; pEvt ; pEvt = pEvt->pNextEvent )
   {
      strMsg[0] = 0;
      lenMsg = FormatMessageW(
               FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY,
               pEvt->hinstDAPI,
               pEvt->dwDAPIError,
               0,
               strMsg,
               dimMsg,
               (va_list*)pEvt->rgpszSubst
               );
      UStrCpy(msg+UStrLen(msg),strMsg,DIM(msg)-UStrLen(msg));
   }
   err.MsgWrite(iSeverity,DCT_MSG_GENERIC_S,&*msg);
}

///////////////////////////////////////////////////////////////////////////////
// Start a MAPI session.
// Tries to use the profile specified on the command line.
BOOL  TGlobalDirectory::StartMapiSession()
{
   //ASSERT(m_bMapiInitialized == FALSE);
   MCSASSERT(m_pMapiSession == NULL);
   
   HRESULT  hr;
   if ( !m_bMapiInitialized )
   {
      hr = (*pMAPIInitialize)(NULL);

      if (FAILED(hr)) 
      {
         LogMapiError(ErrE, TEXT("MAPIInitialize"), hr);
         return FALSE;
      }

      m_bMapiInitialized = TRUE;
   }
   FLAGS    fLogonOptions = MAPI_NEW_SESSION | MAPI_NO_MAIL;
   LPTSTR   pszMapiProfile;

   if (DoUseDefaultMapiProfile()) {
      fLogonOptions |= MAPI_USE_DEFAULT;
      pszMapiProfile = NULL;
   }
   else if (DoPromptForMapiProfile()) {
      fLogonOptions |= MAPI_LOGON_UI | MAPI_EXPLICIT_PROFILE;
      pszMapiProfile = NULL;
   }
   else {
      fLogonOptions |= MAPI_EXPLICIT_PROFILE ;
      pszMapiProfile = GetMapiProfile();
   }

   hr = (*pMAPILogonEx)(0, pszMapiProfile, NULL, fLogonOptions | MAPI_UNICODE, &m_pMapiSession);
   if (FAILED(hr)) {
      switch (hr) {
      case MAPI_E_USER_CANCEL:
         break;
      default:
         err.SysMsgWrite(ErrE,hr,DCT_MSG_NO_MAPI_SESSION_D,hr);
         break;
      }
      return FALSE;
   }

   m_bLoggedFailedClose = FALSE;
   return TRUE;
} /* TGlobalDirectory::StartMapiSession() */

///////////////////////////////////////////////////////////////////////////////
// Terminate a MAPI session.
// No-op if there's not one open.
void  TGlobalDirectory::EndMapiSession()
{
   if (m_pMapiSession) {
      HRESULT  hr = m_pMapiSession->Logoff(0, 0, 0);

      if (SUCCEEDED(hr))
         m_pMapiSession = NULL;
      else if (!m_bLoggedFailedClose) {
         err.SysMsgWrite(ErrW,hr,DCT_MSG_MAPI_LOGOFF_FAILED_D,hr);
      }

      // NOTE: If this fails once, it may fail twice.
      // The second failure will come on the dtor.
      // This is on purpose. It's a retry. But we report it only once.
   }

   if (m_bMapiInitialized) 
   {
      (*pMAPIUninitialize)();
      m_bMapiInitialized = FALSE;
   }
} /* TGlobalDirectory::EndMapiSession() */

///////////////////////////////////////////////////////////////////////////////
// Open the Address Book and get an interface to the Global List.
// The Global List contains the Distribution Lists.
BOOL  TGlobalDirectory::OpenGlobalList()
{
   // Open the Address Book.
   if ( ! m_pMapiSession )
      return FALSE;

   HRESULT  hr = m_pMapiSession->OpenAddressBook(0, NULL, AB_NO_DIALOG , &m_pAdrBook);

   if (FAILED(hr)) 
   {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_NO_ADDRBOOK_D,hr);
      return FALSE;
   }

   // Get the GAL entry ID.
   ULONG       cbEntryId;
   LPENTRYID   pEntryId;

   hr = HrFindExchangeGlobalAddressList(m_pAdrBook, &cbEntryId, &pEntryId);

   if (FAILED(hr)) 
   {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_FAILED_TO_OPEN_GAL_D,hr);
      return FALSE;
   }

   // Load the GAL from the AB.
   ULONG    ulObjType;
   hr = m_pAdrBook->OpenEntry(cbEntryId, pEntryId, NULL, 0, &ulObjType, (LPUNKNOWN*)&m_pGlobalList);

   (*pMAPIFreeBuffer)(pEntryId);

   if (FAILED(hr)) 
   {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_RETRIEVE_GAL_FAILED_D,hr);
      return FALSE;
   }

   // Get a list of the contents of the Global List.
   hr = m_pGlobalList->GetContentsTable(0, &m_pGlobalTable);
   
   if (FAILED(hr)) 
   {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_RETRIEVE_GAL_FAILED_D,hr);
      return FALSE;
   }

   return TRUE;
} /* TEaSyncCommand::OpenGlobalList() */

///////////////////////////////////////////////////////////////////////////////
// Release the interfaces to the Global List and the Address Book.
void  TGlobalDirectory::CloseGlobalList()
{
   if (m_pGlobalTable != NULL) 
   {
      m_pGlobalTable->Release();
      m_pGlobalTable = NULL;
   }

   if (m_pGlobalList != NULL) 
   {
      m_pGlobalList->Release();
      m_pGlobalList = NULL;
   }

   if (m_pAdrBook != NULL) 
   {
      m_pAdrBook->Release();
      m_pAdrBook = NULL;
   }
} /* TGlobalDirectory::CloseGlobalList() */





BOOL 
   TGlobalDirectory::UpdateEntry( 
      LPMAPIPROP               pUserEntry,  // in - interface to mail recipient object
      ULONG                    ulType,      // in - type of object
      SecurityTranslatorArgs * args         // in - translation settings
   )
{
   // Prepare to get the columns that interest us.
   // For DCT, we probably only care about ASSOC_NT_ACCOUNT, and possibly PR_EMS_AB_NT_SECURITY_DESCRIPTOR
   HRESULT           hr;
   BOOL              anychange = FALSE;
   BOOL              verbose = args->LogVerbose();

   MCSASSERT(pUserEntry);
   if ( args->Cache()->IsCancelled() )
   {
      err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
      return FALSE;
   }
   SizedSPropTagArray(5, oPropertiesToGet) =
   {
      5,
      {
         PR_DISPLAY_NAME,
         PR_EMS_AB_ASSOC_NT_ACCOUNT,         // SID
         PR_ENTRYID,
         PR_EMS_AB_NT_SECURITY_DESCRIPTOR,   // SD
         PR_DISPLAY_TYPE
      }
   };
   ULONG    ulPropsReturned = 0;
   LPSPropValue   pUserProperties = NULL;

   hr = pUserEntry->GetProps((SPropTagArray *)&oPropertiesToGet,
                             0, &ulPropsReturned, &pUserProperties);
   
   if (FAILED(hr)) 
   {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_SECURITY_FOR_RECIP_FAILED_D,hr);
      pUserEntry->Release();
      pUserEntry = NULL;
      return FALSE;
   }

   if (ulPropsReturned != oPropertiesToGet.cValues) 
   {
      err.MsgWrite(ErrE,DCT_MSG_GET_SECURITY_FOR_RECIP_FAILED_D,hr);
      pUserEntry->Release();
      pUserEntry = NULL;
      return FALSE;
   }

   // 1. Translate the    PR_EMS_AB_ASSOC_NT_ACCOUNT property

   WCHAR name[MAX_PATH];
   safecopy(name,pUserProperties[0].Value.lpszW);
   if ( m_stat )
   {
      m_stat->DisplayPath(name);
      m_stat->IncrementExamined(mailbox);
   }
   PISID pSid = (PISID)pUserProperties[1].Value.bin.lpb;
   if (pSid != NULL) 
   {
    
      LPSPropValue         pNewPropValues = NULL;
      LPSPropProblemArray  pProblems      = NULL;

      // check if the sid is one we need to change            
      //TRACE (_T("DisplayName = %s "),pUserProperties[0].Value.lpszW);
      PSID newSid = 0;
      TAcctNode * node;

      if ( IsValidSid(pSid) )
      {
      
         node = args->Cache()->Lookup(pSid); 
         if ( m_stat )
         {
            m_stat->IncrementOwnerExamined();
            if ( verbose )
               err.MsgWrite(0,DCT_MSG_EXAMINED_S,pUserProperties[0].Value.lpszW);
         }
         if ( node == (TAcctNode*)-1  && m_stat )
            m_stat->IncrementOwnerNoTarget();

         if ( node && (node != (TAcctNode *)-1) && node->IsValidOnTgt() )
            newSid = args->Cache()->GetTgtSid(node);
         else
            newSid = NULL;
      }
      else
      {
         newSid = NULL;
      }
      if ( newSid )
      {
         //TRACE (_T("needs to be translated\n"));
         // update the entry, or maybe put it into a list of entries to be updated
         // Allocate a buffer to set the property.
         MCSASSERT ( IsValidSid(newSid) );
         PSID        pMapiSid;
         DWORD       dwSidLength = GetLengthSid(newSid);
   
         hr = ResultFromScode((*pMAPIAllocateBuffer)((sizeof SPropValue) * 1, (void **)&pNewPropValues));
         if (FAILED(hr)) 
         {
            err.SysMsgWrite(ErrE,hr,DCT_MSG_FAILED_TO_ALLOCATE_BUFFER_D,hr);
            goto exit_update_sid;
         }
         // Allocate a buffer for the SID
         hr = ResultFromScode((*pMAPIAllocateBuffer)(dwSidLength, (void **)&pMapiSid));
         if (FAILED(hr)) 
         {
            err.SysMsgWrite(ErrE,hr,DCT_MSG_FAILED_TO_ALLOCATE_BUFFER_D,hr);
            goto exit_update_sid;
         }
         // Copy the SID.
         CopySid(dwSidLength,pMapiSid,newSid);
         // Write the SID
         pNewPropValues[0].ulPropTag = PR_EMS_AB_ASSOC_NT_ACCOUNT;
         pNewPropValues[0].Value.bin.lpb = (UCHAR *)pMapiSid;
         pNewPropValues[0].Value.bin.cb = dwSidLength;
         MCSASSERT (IsValidSid (pMapiSid) );

         if ( m_stat )
         {
            m_stat->IncrementOwnerChange(node,mailbox,NULL);
         }
         anychange = TRUE;
         if ( ! args->NoChange() )
         {
            hr = pUserEntry->SetProps(1, pNewPropValues, &pProblems);

            if (FAILED(hr)) 
            {
               err.SysMsgWrite(ErrE,hr,DCT_MSG_UPDATE_ACCOUNT_FAILED_D, hr);
               pProblems = NULL; // Don't try to free this if SetProps fails.
               goto exit_update_sid;
            }

            // Save changes.
            hr = pUserEntry->SaveChanges(KEEP_OPEN_READWRITE);

            if (FAILED(hr)) 
            {
               err.SysMsgWrite(ErrE,hr,DCT_MSG_SAVE_CHANGES_FAILED_D, hr);
               goto exit_update_sid;
            }
         }
     
         exit_update_sid:
         if (pMapiSid != NULL)
            (*pMAPIFreeBuffer)(pMapiSid);

         if (pProblems != NULL)
            (*pMAPIFreeBuffer)(pProblems);

         if (pNewPropValues != NULL)
            (*pMAPIFreeBuffer)(pNewPropValues);

      }
   }
   // 2.  Translate the PR_EMS_AB_NT_SECURITY_DESCRIPTOR property
   PSECURITY_DESCRIPTOR pSD = (PSECURITY_DESCRIPTOR)pUserProperties[3].Value.bin.lpb;
   if ( pSD && PR_EMS_AB_NT_SECURITY_DESCRIPTOR == pUserProperties[3].ulPropTag  )
   {
      TMapiSD   tMailbox((SECURITY_DESCRIPTOR *)pSD);
      
      tMailbox.SetName(pUserProperties[0].Value.lpszW);
     
      if ( tMailbox.HasSecurity() )
      {
         TSD               * pSD = tMailbox.GetSecurity();

         bool  changes = tMailbox.ResolveSDInternal(args->Cache(),m_stat,verbose,args->TranslationMode(),mailbox, FALSE);
         
         if ( changes )
         {
            anychange = TRUE;
            // need to write the changes
            LPSPropValue         pNewPropValues = NULL;
            LPSPropProblemArray  pProblems      = NULL;

            // update the entry
            // Allocate a buffer to set the property.
            SECURITY_DESCRIPTOR *        pMapiSD;
            SECURITY_DESCRIPTOR *        pRelSD = (SECURITY_DESCRIPTOR *)pSD->MakeRelSD();
            DWORD                        dwSDLength = GetSecurityDescriptorLength(pRelSD);
         
            if ( ! pRelSD )
            {
               goto exit_update_sd;
            }
            hr = ResultFromScode((*pMAPIAllocateBuffer)((sizeof SPropValue) * 1, (void **)&pNewPropValues));
            if (FAILED(hr)) 
            {
               err.SysMsgWrite(ErrE,hr,DCT_MSG_FAILED_TO_ALLOCATE_BUFFER_D,hr);
               goto exit_update_sd;
            }
            // Allocate a buffer for the SD
            hr = ResultFromScode((*pMAPIAllocateBuffer)(dwSDLength, (void **)&pMapiSD));
            if (FAILED(hr)) 
            {
               err.SysMsgWrite(ErrE,hr,DCT_MSG_FAILED_TO_ALLOCATE_BUFFER_D,hr);
               goto exit_update_sd;
            }

            // Copy the SD.
            memcpy(pMapiSD,pRelSD,dwSDLength );
            // Write the SD
            free(pRelSD);
            pNewPropValues[0].ulPropTag = PR_EMS_AB_NT_SECURITY_DESCRIPTOR;
            pNewPropValues[0].Value.bin.lpb = (UCHAR *)pMapiSD;
            pNewPropValues[0].Value.bin.cb = dwSDLength;
            if ( ! args->NoChange() )
            {
               hr = pUserEntry->SetProps(1, pNewPropValues, &pProblems);

               if (FAILED(hr)) 
               {
                  err.SysMsgWrite(ErrE,hr,DCT_MSG_RECIP_SD_WRITE_FAILED_SD,pUserProperties[0].Value.lpszW,hr);
                  pProblems = NULL; // Don't try to free this if SetProps fails.
                  goto exit_update_sd;
               }

               // Save changes.
               hr = pUserEntry->SaveChanges(KEEP_OPEN_READONLY);

               if (FAILED(hr)) 
               {  
                  err.SysMsgWrite(ErrE,hr,DCT_MSG_RECIP_SD_SAVE_FAILED_SD,pUserProperties[0].Value.lpszW,hr);
                  goto exit_update_sd;
               }
            }
     
            exit_update_sd:
            if (pMapiSD != NULL)
               (*pMAPIFreeBuffer)(pMapiSD);

            if (pProblems != NULL)
               (*pMAPIFreeBuffer)(pProblems);

            if (pNewPropValues != NULL)
               (*pMAPIFreeBuffer)(pNewPropValues);
         }
   
      }
   }
   if ( anychange && m_stat )
   {
      m_stat->IncrementChanged(mailbox);
      if ( args->LogFileDetails() )
         err.MsgWrite(0,DCT_MSG_CHANGED_S,pUserProperties[0].Value.lpszW);
   }
   (*pMAPIFreeBuffer)(pUserProperties);
   pUserProperties = NULL;
  
   return TRUE;
}

BOOL 
   TGlobalDirectory::Scan(
      SecurityTranslatorArgs * args,       // in - translation settings
      WCHAR            const * container   // in - distinguished name or display name of container to process
   )
{
   
   LPABCONT                  pRootEntry        = NULL;  // root of AB
   ULONG                     ulObjectType      = 0;
   HRESULT                   hr;
//   TAccountCache           * cache = args->Cache();

   if ( args->Cache()->IsCancelled() )
   {
      err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
      return FALSE;
   }
   if ( ! m_pAdrBook )
   {
      OpenGlobalList();
   }
   if ( ! m_pAdrBook )
   {
      return FALSE;
   }
  
/*   SizedSPropTagArray(3, rgPropTags) =
   {
      3,
      {
         PR_ENTRYID,
         PR_DISPLAY_NAME,
         PR_DEPTH,
      }
   };
*/
   // Open the root entry.
   hr = m_pAdrBook->OpenEntry(0, NULL, NULL, 0, &ulObjectType, (LPUNKNOWN*)&pRootEntry);
  
   if (FAILED(hr)) 
   {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_AB_ROOT_FAILED_D,hr);
      return FALSE;
   }
   ScanHierarchy(pRootEntry,args,container);
   return TRUE;
}

BOOL  
   TGlobalDirectory::ScanHierarchy(
      LPABCONT                 pContainer,   // in - interface pointer to address book
      SecurityTranslatorArgs * args,         // in - translation settings
      WCHAR            const * container     // in - distinguished name or display name of container
   )
{
   HRESULT                   hr;
   LPMAPITABLE               pContainerTable = NULL;
   LPSRowSet                 pContainerRows = NULL;
   LPABCONT                  pEntry = NULL;
   ULONG                     ulObjectType = 0;
   BOOL                      foundContainer = FALSE;
   
   MCSASSERT(pContainer);
   
   if ( args->Cache()->IsCancelled() )
   {
      err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
      return FALSE;
   }
   // Get its hierarchical table.
   SizedSPropTagArray(4, rgPropTags) =
   {
      4,
      {
         PR_ENTRYID,
         PR_DISPLAY_NAME_A,    // I tried to get the display name in unicode format, but it did not work.
         PR_OBJECT_TYPE,
         PR_EMS_AB_OBJ_DIST_NAME_A
      }
   };


   hr = pContainer->GetHierarchyTable(CONVENIENT_DEPTH, &pContainerTable);

   if (FAILED(hr)) 
   {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_HIER_TABLE_FAILED_D,hr);
      return FALSE;
   }

   // Get a list of all rows.
   hr = (*pHrQueryAllRows)(pContainerTable, (LPSPropTagArray)&rgPropTags, NULL, NULL, 0, &pContainerRows);

   if (FAILED(hr)) 
   {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_TABLE_CONTENTS_FAILED_D,hr);
      pContainerTable->Release();
      return FALSE;
   }

   for (ULONG ulRow = (ULONG)0; ulRow < pContainerRows->cRows; ++ulRow) 
   {
      if ( args->Cache()->IsCancelled() )
      {
         err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
         return FALSE;
      }
      hr = m_pAdrBook->OpenEntry(pContainerRows->aRow[ulRow].lpProps[0].Value.bin.cb,
                              (LPENTRYID)pContainerRows->aRow[ulRow].lpProps[0].Value.bin.lpb,
                              NULL,
                              MAPI_MODIFY,      // or 0 if nochange mode
                              &ulObjectType,
                              (LPUNKNOWN *)&pEntry);

      if (!SUCCEEDED(hr)) 
      {
         err.SysMsgWrite(ErrE,hr,DCT_MSG_OPEN_CONTAINER_FAILED_SD,pContainerRows->aRow[ulRow].lpProps[1].Value.lpszW,hr);
         return FALSE;
      }
      else
      {

//         LPMAPITABLE pContainerTable = NULL;  // container table
         UCHAR          containerA[LEN_DistName];
         safecopy(containerA,container);
         // look for the specified container
         if ( NOT_PT_ERROR(pContainerRows->aRow[ulRow].lpProps[1] ) 
            && !UStrICmp(containerA,pContainerRows->aRow[ulRow].lpProps[1].Value.lpszA) )
         {  
            foundContainer = TRUE;
            break;
         }
         if ( container && container[0]== '/' )
         {
            // Check the distinguished name 
            LPSPropValue            props;
            ULONG                   ulCount;
            HRESULT                 hr2;

            hr2 = pEntry->GetProps((LPSPropTagArray)&rgPropTags,0,&ulCount,&props);
            if ( SUCCEEDED(hr) )
            {
               if ( ulCount >= 4 && NOT_PT_ERROR(props[3]) )               
               {
                  if ( !UStrICmp(props[3].Value.lpszA,containerA) )
                  {
                     foundContainer = TRUE;
                  }
               }
               (*pMAPIFreeBuffer)(props);
               props = NULL;
            }
            else
            {
               err.SysMsgWrite(ErrE,hr2,DCT_MSG_GET_CONTAINER_INFO_FAILED_D,hr2);
            }
            if ( foundContainer ) 
               break;
         }
         
      }
   }
   // if we found the container, process it's contents
   if ( foundContainer )
   {

      if ( args->LogFileDetails() )
         err.MsgWrite(0,DCT_MSG_EXAMINING_CONTENTS_S,pContainerRows->aRow[ulRow].lpProps[1].Value.lpszW);
      // Get its contents table.                 
      hr = pEntry->GetContentsTable(0, &pContainerTable);

      if (FAILED(hr)) 
      {
         err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_CONTAINER_INFO_FAILED_D,hr);
         pEntry->Release();
         pEntry = NULL;
         return FALSE;
      }
      // need to scan contents and hierarchy for this item
      m_pContainer = pEntry;
      m_name = pContainerRows->aRow[ulRow].lpProps[1].Value.lpszW;
      ScanContents(pContainerTable,args);
 
   }
   else
   {
      err.MsgWrite(ErrW,DCT_MSG_CONTAINER_NOT_FOUND_S,container);
   }

   (*pFreeProws)(pContainerRows);
   pContainerRows = NULL;
   pContainerTable->Release();
   return TRUE;
}
///////////////////////////////////////////////////////////////////////////////
// Scan the contents of the Container for sids that need to be converted.
BOOL  
   TGlobalDirectory::ScanContents( 
      LPMAPITABLE              pContainerTable, // in - contents table for container
      SecurityTranslatorArgs * args             // in - translation settings
  )
{
   ULONG                     ulDLEntries;
//   WCHAR                     em[500] = L"";

   MCSASSERT  (pContainerTable);
   
   if ( args->Cache()->IsCancelled() )
   {
      err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
      return FALSE;
   }
   HRESULT  hr = pContainerTable->GetRowCount(0, &ulDLEntries);

   if (FAILED(hr)) 
   {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_COUNT_CONTAINER_FAILED_SD,m_name,hr);
      return FALSE;
   }

   // Determine which column of the table has the Entry ID.
   LPSPropTagArray   pDLPropTags = NULL;

   hr = pContainerTable->QueryColumns(0, &pDLPropTags);

   if (FAILED(hr)) 
   {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_CONTAINER_CORRUPTED_SD,m_name,hr);
      return FALSE;
   }

   ULONG ulEntryIdColumn;
   BOOL  bFoundEntryId = FALSE;
   for (UINT ulCol = 0; ulCol < pDLPropTags->cValues; ++ulCol) 
   {
      if (pDLPropTags->aulPropTag[ulCol] == PR_ENTRYID) 
      {
         ulEntryIdColumn = ulCol;
         bFoundEntryId = TRUE;
         break;
      }
   }
   (*pMAPIFreeBuffer)(pDLPropTags);
   pDLPropTags = NULL;
   if (!bFoundEntryId)
   {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_CONTAINER_CORRUPTED_SD,m_name,hr);
      return FALSE;
   }

 
   // Peruse the rows for the SIDs and names.
   LPSRowSet   pDLRows = NULL;
   LPMAPIPROP  pUserEntry      = NULL;
   for (ULONG ulRow = 0; ulRow < ulDLEntries; ++ulRow) 
   {
      if ( args->Cache()->IsCancelled() )
      {
         break;
      }
   
      hr = pContainerTable->SeekRow(BOOKMARK_BEGINNING, ulRow, NULL);

      if (FAILED(hr)) 
      {
         err.SysMsgWrite(ErrE,hr,DCT_MSG_CANT_FIND_ENTRY_SD,m_name,hr);
         return FALSE;
      }

      hr = pContainerTable->QueryRows(1, TBL_NOADVANCE, &pDLRows);

      if (FAILED(hr)) 
      {
         err.SysMsgWrite(ErrE,hr,DCT_MSG_CANT_LOAD_ENTRY_SD,m_name,hr);
         return FALSE;
      }

      // Get the current entry.
      ULONG ulEntryType = 0;

      if ( pDLRows  && pDLRows->cRows )
      {
         hr = m_pContainer->OpenEntry(pDLRows->aRow[0].lpProps[ulEntryIdColumn].Value.bin.cb,
                                 (ENTRYID *)pDLRows->aRow[0].lpProps[ulEntryIdColumn].Value.bin.lpb,
                                 NULL,
                                 MAPI_MODIFY,
                                 &ulEntryType,
                                 (LPUNKNOWN*)&pUserEntry);
      }
      (*pFreeProws)(pDLRows);
      pDLRows = NULL;

      if (FAILED(hr)) 
      {
         err.SysMsgWrite(ErrE,hr,DCT_MSG_RECIP_LOAD_FAILED_SD,m_name,hr);
         return FALSE;
      }
      if ( pUserEntry )
      {
         UpdateEntry(pUserEntry,ulEntryType, args);
         pUserEntry->Release();
         pUserEntry = NULL;
      }
   }
   
   if ( args->Cache()->IsCancelled() )
   {
      err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
      return FALSE;
   }
   
   return TRUE;
} 

BOOL TGlobalDirectory::OpenContainerByRow(long row)
{
   HRESULT hr;
   ULONG       ulObjectType      = 0;
   MCSASSERT( m_pRootRows );
   // TODO:  check that row is in valid range.
   // Load the container that should contain the DL.
   hr = m_pAdrBook->OpenEntry(           m_pRootRows->aRow[row].lpProps[0].Value.bin.cb,
                              (LPENTRYID)m_pRootRows->aRow[row].lpProps[0].Value.bin.lpb,
                              NULL,
                              MAPI_MODIFY,      // or 0 if nochange mode
                              &ulObjectType,
                              (LPUNKNOWN *)&m_pContainer);

   (*pFreeProws)(m_pRootRows);
   m_pRootRows = NULL;

   if (FAILED(hr)) {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_OPEN_CONTAINER_FAILED_SD,L"",hr);
      return FALSE;
   }

   // Look for the DL in its container.
//   LPMAPITABLE pContainerTable = NULL;  // container table

   // Get its contents table.
   hr = m_pContainer->GetContentsTable(0, &m_pContainerTable);

   if (FAILED(hr)) {
      err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_TABLE_CONTENTS_FAILED_D,hr);
      m_pContainer->Release();
      m_pContainer = NULL;
      return FALSE;
   }
   

   return TRUE;
}

#define NDX_SID         3
#define NDX_SD          4

DWORD 
	TGlobalDirectory::GetLDAPPort(
      WCHAR				       * server
	)
{
   DWORD                     port = LDAP_PORT;
//   DWORD                     rc = 0;
   DAPI_ENTRY                attList;
   DAPI_ENTRY              * pValues;
   ATT_VALUE                 atts[3];
   WCHAR                     distName[300];
   PDAPI_EVENT               result = NULL; 
   DAPI_ENTRY              * pAttributes = NULL;

   if ( ! LoadDAPI() )
   {
      err.MsgWrite(ErrW,DCT_MSG_LDAP_PORT_DETECT_FAILED_S,server);
      return port;
   }

   if ( DAPIOpen(server) )
   {
      
      // set up the attribute list
      attList.unAttributes = 3;
      attList.ulEvalTag = VALUE_ARRAY;
      attList.rgEntryValues = atts;

      atts[0].DapiType = DAPI_UNICODE;
      atts[0].Value.pszW = ATT_OBJ_CLASS;
      atts[0].size = UStrLen(atts[0].Value.pszW);
      atts[0].pNextValue = NULL;

      atts[1].DapiType = DAPI_UNICODE;
      atts[1].Value.pszW = ATT_LDAP_PORT;
      atts[1].size = UStrLen(atts[1].Value.pszW);
      atts[1].pNextValue = NULL;

      atts[2].DapiType = DAPI_UNICODE;
      atts[2].Value.pszW = LDAP_USE_SITE_VALUES;
      atts[2].size = UStrLen(atts[2].Value.pszW);
      atts[2].pNextValue = NULL;

      // construct the DN for the attribute
      swprintf(distName,L"/cn=Configuration/cn=Servers/cn=%s%s",server,LDAP_PortNumber_DN_Part);

      result = (*pDAPIRead)(m_dSession,DAPI_RAW_MODE,distName,&attList,
                           &pValues, &pAttributes);
   
   
      if ( ! result )
      {
         if ( pValues && pValues->rgEntryValues[2].Value.iValue == 0 )
         {
            // not using site defaults - rgEntryValues[1] contains the correct value for this server
            if ( pValues && pValues->rgEntryValues[1].DapiType == DAPI_INT )
            {
               port = pValues->rgEntryValues[1].Value.iValue;
            }
         }
         else
         {
            // This server is using the default values for the site - need to look at the site level to find the correct value
            (*pDAPIFreeMemory)(pValues);
            swprintf(distName,L"/cn=Configuration%s",LDAP_PortNumber_DN_Part);
            attList.unAttributes = 2; // don't want to get 'Use-Site-Defaults' this time (we're looking at the Site)
            result = (*pDAPIRead)(m_dSession,DAPI_RAW_MODE,distName,&attList,
                           &pValues, &pAttributes);
            if ( ! result )
            {
               if ( pValues && pValues->rgEntryValues[1].DapiType == DAPI_INT )
               {
                  // Here's the default value for the site
                  port = pValues->rgEntryValues[1].Value.iValue;
               }
            }
            else
            {
               (*pDAPIFreeMemory)(result);
            }
         }
         (*pDAPIFreeMemory)(pValues);
      }
      else
      {
         (*pDAPIFreeMemory)(result);
      }
   }
   else
   {
      err.MsgWrite(ErrW,DCT_MSG_LDAP_PORT_DETECT_FAILED_S,server);
   }
   DAPIClose();

   ReleaseDAPI();
   
   return port;
}

void 
   TGlobalDirectory::GetSiteNameForServer(
      WCHAR          const * server,                  // in - name of exchange server to use
      CLdapEnum            * e,                       // in - LDAP connection to use for query
      WCHAR                * siteName                 // out- distinguished name of exchange site for server
      )
{
   WCHAR                   * atts[6] = { L"distinguishedName", L"rdn",NULL };
   WCHAR                     query[200];
   DWORD                     rc;
   WCHAR                  ** values = NULL;
   siteName[0] = 0;
   
   swprintf(query,L"(&(objectClass=computer)(rdn=%ls))",server);
   rc = e->Open(query,L"",2,100,3,atts);
   // there should be only one server with this name
   if (! rc )
      rc = e->Next(&values);
   if (! rc )
   {
      if ( !UStrICmp(values[1],server) )
      {
         WCHAR       serverPrefix[LEN_Path];
         swprintf(serverPrefix,L"cn=%ls,cn=Servers,cn=Configuration,",values[1]);
         if ( ! UStrICmp(values[0],serverPrefix,UStrLen(serverPrefix)) )
         {
            UStrCpy(siteName,values[0] + UStrLen(serverPrefix));
         }
         else
         {
            err.MsgWrite(ErrE,DCT_MSG_GENERIC_S,values[0]);
         }
      }
      else
      {
         err.MsgWrite(ErrE,DCT_MSG_LDAP_CALL_FAILED_SD,server,ERROR_NOT_FOUND);
      }
      e->FreeData(values);
   }
   else
   {
      err.SysMsgWrite(ErrE,e->m_connection.LdapMapErrorToWin32(rc),DCT_MSG_LDAP_CALL_FAILED_SD,server,rc);
   }

}


BOOL 
   TGlobalDirectory::DoLdapTranslation(
      WCHAR                  * server,
      WCHAR                  * creds,
      WCHAR                  * password,
      SecurityTranslatorArgs * args,
      WCHAR                  * basept,
      WCHAR                  * query
   )
{
   CLdapEnum                 e;
   WCHAR                   * atts[6] = { L"distinguishedName", L"rdn", L"cn", L"Assoc-NT-Account",L"NT-Security-Descriptor",NULL };
   WCHAR                  ** values = NULL;
   ULONG                     port = GetLDAPPort(server);
   ULONG                     pageSize = 100;
   WCHAR                     basepoint[LEN_Path] = L"";

   e.m_connection.SetCredentials(creds,password);

   DWORD                     rc  = e.InitConnection(server,port);
   BOOL                      anychange = FALSE;
   BOOL                      verbose = args->LogVerbose();
   BOOL						 bUseMapFile = args->UsingMapFile();


   if (! rc )
   {
      if ( ! basept )
      {
         GetSiteNameForServer(server,&e,basepoint);
      }
      else
      {
         // use the user-specified basepoint
         safecopy(basepoint,basept);
      }
      if ( query )
      {
         rc = e.Open(query,basepoint,2,pageSize,5,atts);  
      }
      else 
      {
         rc = e.Open(L"(objectClass=*)",basepoint,2,pageSize,5,atts);
      }
      if ( ! rc )
      {
         do 
         {
            rc = e.Next(&values);
            anychange = FALSE;
            if (! rc )
            {
               if ( args->Cache()->IsCancelled() )
               {
                  err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
                  return FALSE;
               }
               if ( m_stat )
               {
                  m_stat->DisplayPath(values[0]);
                  m_stat->IncrementExamined(mailbox);
               }

               // update the Assoc-NT-Account, if any
               if ( values[NDX_SID] && *values[NDX_SID] )
               {
                  // convert the SID to a binary value and look it up in the cache
                  BYTE              pSid[500];

                  if ( e.m_connection.StringToBytes(values[NDX_SID],pSid) )
                  {
                     
                     // check if the sid is one we need to change            
                     //TRACE (_T("DisplayName = %s "),pUserProperties[0].Value.lpszW);
                     PSID newSid = 0;
                     TAcctNode * node;

                     if ( IsValidSid(pSid) )
                     {
				        if (!bUseMapFile)
                           node = args->Cache()->Lookup(pSid); 
				        else
                           node = args->Cache()->LookupWODomain(pSid); 
                        if ( m_stat )
                        {
                           m_stat->IncrementOwnerExamined();
                           if ( verbose )
                              err.MsgWrite(0,DCT_MSG_EXAMINED_S,values[0]);
                        }
                        if ( node == (TAcctNode*)-1  && m_stat )
                           m_stat->IncrementOwnerNoTarget();

                        if ( node && (node != (TAcctNode *)-1) && node->IsValidOnTgt() )
						{
	                       if (!bUseMapFile)
                              newSid = args->Cache()->GetTgtSid(node);
	                       else
                              newSid = args->Cache()->GetTgtSidWODomain(node);
						}
                        else
                           newSid = NULL;
                     }
                     else
                     {
                        newSid = NULL;
                     }
                     if ( newSid )
                     {
                        //TRACE (_T("needs to be translated\n"));
                        MCSASSERT ( IsValidSid(newSid) );
                        WCHAR                newSidStr[1000];

                        if ( e.m_connection.BytesToString((BYTE*)newSid,newSidStr,GetLengthSid(newSid)) )
                        {
                           if ( m_stat )
                           {
                              m_stat->IncrementOwnerChange(node,mailbox,NULL);
                           }
                           anychange = TRUE;
                           if ( ! args->NoChange() )
                           {
                              rc = e.m_connection.UpdateSimpleStringValue(values[0],atts[NDX_SID],newSidStr);

                              if ( rc ) 
                              {
                                 err.SysMsgWrite(ErrE,rc,DCT_MSG_UPDATE_ACCOUNT_FAILED_D, rc);
                              }
                           }

                        }
                     }
                  }
                  
               }
               // Update the NT-Security-Descriptor, if any
               if ( values[NDX_SD] && *values[NDX_SD] )
               {
                  // convert the SID to a binary value and look it up in the cache
                  BYTE            * pSD = new BYTE[UStrLen(values[NDX_SD])];
				  if (!pSD)
				     return FALSE;

                  if ( e.m_connection.StringToBytes(values[NDX_SD],pSD) )
                  {
                     TMapiSD   tMailbox((SECURITY_DESCRIPTOR *)pSD);
                     if ( tMailbox.HasSecurity() )
                     {
                        TSD               * pSD2 = tMailbox.GetSecurity();

                        bool  changes = tMailbox.ResolveSDInternal(args->Cache(),m_stat,verbose,args->TranslationMode(),mailbox, bUseMapFile);
         
                        if ( changes )
                        {
                           anychange = TRUE;
                           SECURITY_DESCRIPTOR * pRelSD = (SECURITY_DESCRIPTOR *)pSD2->MakeRelSD();
                           DWORD                 dwSDLength = GetSecurityDescriptorLength(pRelSD);
                           
                           if ( ! args->NoChange() )
                           {     
                              WCHAR * pSDString = new WCHAR[1 + dwSDLength * 2];
							  if (!pSDString)
							  {
                                 delete [] pSD;
							     return FALSE;
							  }
                              if  ( e.m_connection.BytesToString((BYTE*)pRelSD,pSDString,dwSDLength) )
                              {
                                 rc = e.m_connection.UpdateSimpleStringValue(values[0],atts[NDX_SD],pSDString);
                                 if ( rc )
                                 {
                                    err.SysMsgWrite(ErrE,rc,DCT_MSG_RECIP_SD_WRITE_FAILED_SD,values[0],rc);
                                    if ( rc == ERROR_INVALID_PARAMETER )
                                    {
                                       // this error occurs when the security descriptor is too large
                                       // don't abort in this case
                                       rc = 0;
                                    }
                                 }
                  
                              }
                              delete [] pSDString;
                           }
                        }
                     }
                  }
                  delete [] pSD;
               }
               
               if ( anychange && m_stat )
               {
                  m_stat->IncrementChanged(mailbox);
                  if ( args->LogFileDetails() )
                     err.MsgWrite(0,DCT_MSG_CHANGED_S,values[0]);
               }
               e.FreeData(values);
            }

         } while ( ! rc );
      }
      if ( rc && (rc != LDAP_COMPARE_FALSE) && (rc != ERROR_NOT_FOUND) )
      {
         err.SysMsgWrite(ErrE,e.m_connection.LdapMapErrorToWin32(rc),DCT_MSG_LDAP_CALL_FAILED_SD,server,rc);
      }
   }
   else
   {
      err.SysMsgWrite(ErrE,rc,DCT_MSG_CANNOT_CONNECT_TO_EXCHANGE_SERVER_SSD,server,creds,rc);
   }         
   
   return rc;
}
               
BOOL 
   TGlobalDirectory::DoDAPITranslation(
      WCHAR                  * serv,       // in - Exchange server
      SecurityTranslatorArgs * args        // in - translation options
   )
{
   // enumerate organizations, sites, and containers
   if ( DAPIOpen( serv ) )
   {
      HRESULT                   hr;
      LPWSTR                    pOrganizations = NULL;
      LPWSTR                     pSites = NULL;
      LPWSTR                     pContainers = NULL;
      
      WCHAR                    * server;
      WCHAR                     container[1];

      if ( args->Cache()->IsCancelled() )
      {
         err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
         return FALSE;
      }
      server = new WCHAR[wcslen(serv) + 1];
	  if (!server)
	     return FALSE;
      UStrCpy(server,serv);
      container[0] = 0;
      // enumerate organizations
      m_stat->DisplayPath(GET_STRING(IDS_ScanningExchangeDirectory));
      hr = HrEnumOrganizations(container,server,&pOrganizations);
      if ( SUCCEEDED(hr) )
      {
         for ( ; pOrganizations && *pOrganizations ; pOrganizations+=UStrLen(pOrganizations) + 1 )
         {
            if ( args->Cache()->IsCancelled() )
            {
               err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
               break;
            }
            WCHAR          wOrganizations[300];
            safecopy(wOrganizations,pOrganizations);
            DAPITranslate(wOrganizations,args);
            //enumerate sites
            hr = HrEnumSites(server,pOrganizations,&pSites);
            if ( SUCCEEDED(hr) )
            {
               for ( ; pSites && *pSites ; pSites+=UStrLen(pSites) + 1 )
               {
                  if ( args->Cache()->IsCancelled() )
                  {
                     err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
                     break;
                  }
                  WCHAR     wSites[300];
                  safecopy(wSites,pSites);
                  DAPITranslate(wSites,args);
                  //enumerate containers
                  hr = HrEnumContainers(server,pSites,TRUE,&pContainers);
                  if ( SUCCEEDED(hr) )
                  {
                     for ( ; pContainers && *pContainers ; pContainers+=UStrLen(pContainers) + 1 )
                     {
                        if (args->Cache()->IsCancelled() )
                        {
                           err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
                           break;
                        }
                        WCHAR       wContainers[300];
                        safecopy(wContainers,pContainers);
                        DAPITranslate(wContainers,args);
                     }
                  }
                  else
                  {
                     err.SysMsgWrite(ErrE,hr,DCT_MSG_ENUM_CONTAINERS_FAILED_SD,hr);
                  }
               }
            }
            else
            {
                err.SysMsgWrite(ErrE,hr,DCT_MSG_ENUM_SITES_FAILED_SD,hr);
            }      
         }
      }
      else
      {
         err.SysMsgWrite(ErrE,hr,DCT_MSG_ENUM_ORGS_FAILED_SD,hr);
      }
      
      DAPIClose();
   }
   m_stat->DisplayPath(L"");
   return TRUE;
}

BOOL 
   TGlobalDirectory::DAPIOpen(
      WCHAR                * server        // in - name of exchange server
   )
{
   PDAPI_EVENT               result;
   BOOL                      bRc;

   WCHAR                   * serv;

   if ( ! LoadDAPI() )
   {
      return FALSE;
   }
   serv = new WCHAR [wcslen(server) + 1];
   if (!serv)
      return FALSE;
   UStrCpy(serv,&*server);
   
   // initialize parms
   m_dParms.dwDAPISignature = DAPI_SIGNATURE;
   m_dParms.dwFlags = DAPI_RAW_MODE | DAPI_EVENT_SOME;
   m_dParms.pszDSAName = serv;        // computer name of directory service agent
   m_dParms.pszBasePoint = NULL;
   m_dParms.pszContainer = NULL;
   m_dParms.pszNTDomain = NULL;
   m_dParms.pszCreateTemplate = NULL;
   m_dParms.pAttributes = NULL;

   result = (*pDAPIStart)(&m_dSession,&m_dParms);
   if ( result )
   {
      // this is an error - need to show a message or something
      LogDapiError(ErrE,L"DAPIStart: ",result);
      (*pDAPIFreeMemory)(result);
      bRc = FALSE;
   }
   else
      bRc = TRUE;
   return bRc;
}

BOOL TGlobalDirectory::DAPIClose()
{
   (*pDAPIEnd)(&m_dSession);
   return TRUE;
}

void StripQuotes(TCHAR * distName)
{
   int                       nChars = UStrLen(distName);
   int                       i,     // input index
                             o;     // output index
   BOOL                      prevQuote = FALSE;

   for ( i = 0,o = 0  ; i < nChars ; i++ )
   {
      if ( distName[i] != _T('"') || prevQuote )
      {
         prevQuote = FALSE;
         distName[o] = distName[i];
         o++;
      }
      else
      {
         // leave the output pointer where it is, so the character will be overwritten
         prevQuote = TRUE;
      }
   }
   distName[o] = 0;
}
         
BOOL TGlobalDirectory::DAPITranslate(WCHAR * dn, SecurityTranslatorArgs * args)
{
   PDAPI_EVENT    result;
   TCHAR        * distName;  // distinguished name of object to read.
   DAPI_ENTRY   * pValues = NULL;
   DAPI_ENTRY   * pAttributes = NULL;
   ATT_VALUE      attributes[8];             // DapiType, Value, size, pNextValue
   WCHAR        * att_names[8];
   bool           verbose = false;

   if ( args->Cache()->IsCancelled() )
   {
      err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
      return FALSE;
   }
   att_names[0] = L"Obj-Class";
   att_names[1] = L"DSA-Signature";
   att_names[2] = L"Directory Name";
   att_names[3] = L"Obj-View-Containers";
   att_names[4] = L"Obj-Dist-Name";
   int sdIndex = 5;
   att_names[sdIndex] = L"NT-Security-Descriptor";
   att_names[6] = L"Organizational-Unit-Name";
   att_names[7] = L"Organization-Name";
   DAPI_ENTRY     attr;

   attr.unAttributes = 8;
   attr.ulEvalTag = VALUE_ARRAY;
   attr.rgEntryValues = attributes;
   for ( int i = 0 ; i < 8 ; i++ )
   {
      attributes[i].DapiType = DAPI_UNICODE;
      attributes[i].Value.pszW = att_names[i];
      attributes[i].size = UStrLen(att_names[i]);
      attributes[i].pNextValue = NULL;
   }
            // we may need DAPI_RESTRICT_ACCESS and/or DAPI_MODIFY_REPLACE_PROPERTIES

   distName = new TCHAR[wcslen(dn) + 1];
   if (!distName)
      return FALSE;
   UStrCpy(distName,(LPCTSTR)dn);
   StripQuotes(distName);
   result = (*pDAPIRead)(m_dSession,DAPI_RAW_MODE,distName,&attr,
                           &pValues, &pAttributes);
   if ( m_stat )
   {
      WCHAR    wpath[MAX_PATH+1];
      safecopy(wpath,&*distName);
      m_stat->DisplayPath(wpath);
      
      m_stat->IncrementExamined(container);
      
      if ( verbose ) 
         err.MsgWrite(0,DCT_MSG_EXAMINED_S,&*dn);
   }
   if ( result )
   {
      // this is an error - need to show a message or something
      LogDapiError(ErrE,L"DAPIRead: ",result);
      (*pDAPIFreeMemory)(result);
   }
   if ( pValues && pValues->rgEntryValues[sdIndex].DapiType == DAPI_BINARY )
   {
      SECURITY_DESCRIPTOR  * pSD = (SECURITY_DESCRIPTOR *)pValues->rgEntryValues[sdIndex].Value.lpBinary;
      TMapiSD                exContainer(pSD); 

      if ( exContainer.HasSecurity() )
      {
         exContainer.SetName(distName);

         bool                changes = exContainer.ResolveSDInternal(args->Cache(),m_stat,false,args->TranslationMode(),container, FALSE);
//         ULONG               usn = 0; 

         if ( changes )
         {
            if  (m_stat)
            {
               m_stat->IncrementChanged(container);
               if ( args->LogFileDetails() )
                  err.MsgWrite(0,DCT_MSG_CHANGED_S,&*dn);
            }

            // record the changes      
            if ( ! args->NoChange() )
            {
               TSD         * tSD = exContainer.GetSecurity();

               pSD = (SECURITY_DESCRIPTOR *)tSD->MakeRelSD();
               pValues->rgEntryValues[sdIndex].Value.lpBinary = (UCHAR *)pSD;
               // make sure the size is still correct.  For NT 3.51 and 4 it
               // should always be, since all the SIDs are the same length, but 
               // we don't want this to break if it gets a different-length SID
               pValues->rgEntryValues[sdIndex].size = GetSecurityDescriptorLength(pSD); 
               
               // Change the directory name to match the distinguished name, otherwise you get
               // object not found error.
               pValues->rgEntryValues[2].Value.pszW = pValues->rgEntryValues[4].Value.pszW;
               // Same problem for the OU-Name for Sites
               if ( pValues->rgEntryValues[6].DapiType != DAPI_NO_VALUE )
               {
                  pValues->rgEntryValues[6].Value.pszW = pValues->rgEntryValues[4].Value.pszW;
               }
               // Same problem for the O-name for organizations
               if ( pValues->rgEntryValues[7].DapiType != DAPI_NO_VALUE )
               {
                  pValues->rgEntryValues[7].Value.pszW = pValues->rgEntryValues[4].Value.pszW;
               }
               result = (*pDAPIWrite)(m_dSession,DAPI_WRITE_MODIFY,&attr,pValues,NULL,NULL,NULL);
               if ( result )
               {
                  LogDapiError(ErrE,L"DAPIWrite: ",result);
                  (*pDAPIFreeMemory)(result);
               }
               free(pSD);
            }

         }
      }
   }
   // cleanup
   if ( pValues )
      (*pDAPIFreeMemory)(pValues);
   if ( pAttributes )
      (*pDAPIFreeMemory)(pAttributes);
   delete [] distName;
   return TRUE;
}