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

/*
===============================================================================
Module      -  edk.cpp
System      -  EnterpriseAdministrator
Creator     -  Steven Bailey
Created     -  2 Apr 97
Description -  Exchange MAPI helper routines.
Updates     -  Christy Boles - added more MAPI helper functions, and some DAPI 
               helper functions.
===============================================================================
*/
#ifdef USE_STDAFX
#   include "stdafx.h"
#else
#   include <windows.h>
#endif

#include <mapiguid.h>

#include "edk2.hpp"

#include <edkcode.h>
#include <objbase.h>
#include <mapiutil.h>
#include <emsabtag.h>
#include <_ENTRYID.H>


extern LPMAPIALLOCATEBUFFER         pMAPIAllocateBuffer;
extern LPMAPIFREEBUFFER             pMAPIFreeBuffer;
extern LPMAPIINITIALIZE             pMAPIInitialize;
extern LPMAPIUNINITIALIZE           pMAPIUninitialize;
extern LPMAPILOGONEX                pMAPILogonEx;
extern LPMAPIADMINPROFILES          pMAPIAdminProfiles;
extern LPFREEPADRLIST               pFreePadrlist;
extern LPFREEPROWS                  pFreeProws;      
extern LPSCDUPPROPSET               pScDupPropset;
extern LPHRQUERYALLROWS             pHrQueryAllRows;
extern LPULRELEASE                  pUlRelease;

#define CHAR WCHAR
#define HR_LOG(x) x

// definition of the Exchange address type.
// from edk.h
#define EXCHANGE_ADDRTYPE	L"EX"

#define CbNewFlagList(_cflag) \
	(offsetof(FlagList,ulFlag) + (_cflag)*sizeof(ULONG))

//$--cbStrLen@------------------------------------------------
//  Returns total number of bytes (including NULL) used by 
//  a string.  Useful for string allocations...
// -----------------------------------------------------------
#define cbStrLenA(sz)   ((lstrlenA((sz)) + 1) * sizeof(CHAR))

#if defined(_M_IX86)
#define cbStrLenW(sz)   ((lstrlenW((sz)) + 1) * sizeof(WCHAR))
#else
// lstrlenW can return 0 for UNALIGNED UNICODE strings on non-IX86 platforms
__inline static size_t cbStrLenW(
    IN UNALIGNED const WCHAR *wsz)
{
    size_t cbWsz = 0;

    for(; *wsz; wsz++)
        cbWsz += sizeof( WCHAR);

    return( cbWsz + sizeof( WCHAR));
}
#endif

#ifdef UNICODE
#define cbStrLen    cbStrLenW
#else 
#define cbStrLen    cbStrLenA
#endif


#define ULRELEASE(x) \
{                    \
	(*pUlRelease)((x));  \
	(x) = NULL;      \
}

#define MAPIFREEBUFFER(x) \
{                         \
    (*pMAPIFreeBuffer)((x));  \
	(x) = NULL;           \
}


#define FREEPADRLIST(x) \
{                       \
    (*pFreePadrlist)((x));  \
	(x) = NULL;         \
}

#define FREEPROWS(x)    \
{                       \
    (*pFreeProws)((x));     \
	(x) = NULL;         \
}

// Definitions from ExchInst.c
#define MAX_CSV_LINE_SIZ                2048
#define MAX_WORD                        0xFFFF
#define FILE_PREFIX                     L"EXCH"
#define NEW_LINE                        L"\r\n"

#define EXCHINST_DELIM                  L'\t'
#define EXCHINST_QUOTE                  L'"'
#define EXCHINST_MV_SEP                 L'%'

#define SZ_EXCHINST_DELIM               L"\t"
#define SZ_EXCHINST_QUOTE               L"\""
#define SZ_EXCHINST_MV_SEP              L"%"

#define BEGIN_CSV_LINE(a,b)  lstrcpy(a, b)

#define APPEND_CSV_LINE(a,b)           \
    {                                  \
	lstrcat(a, SZ_EXCHINST_DELIM); \
	lstrcat(a, b);                 \
    }

#define DELETEFILE(_file)                       \
{                                               \
    if((_file) != NULL && (_file)[0] != 0)      \
    {                                           \
	if(! DeleteFile ((_file)))              \
	{                                       \
	    HRESULT _hr = HR_LOG(E_FAIL);       \
	}                                       \
    }                                           \
    (_file)[0] = 0;                             \
}

#define CLOSEHANDLE(h)                                  \
{                                                       \
    if(((h) != NULL) && ((h) != INVALID_HANDLE_VALUE))  \
    {                                                   \
        if(CloseHandle((h)) == FALSE)                   \
        {                                               \
/*            HRESULT _hr = HR_LOG(E_FAIL);             \
*/            HR_LOG(E_FAIL);               \
        }                                               \
        (h) = NULL;                                     \
    }                                                   \
}

//
// Attribute Defines
//

#define OBJ_CLASS                       L"Obj-Class"
#define MODE                            L"Mode"
#define ADDR_SYNTAX                     L"Address-Syntax"
#define ADDR_ENTRY_DT                   L"Address-Entry-Display-Table"
#define ADDR_TYPE                       L"Address-Type"
#define ADMIN_DISPLAY_NAME              L"Admin-Display-Name"
#define DISPLAY_NAME                    L"Display-Name"
#define COMMON_NAME                     L"Common-Name"
#define DELIVERY_MECHANISM              L"Delivery-Mechanism"
#define DELIV_EXT_CONT_TYPES            L"Deliv-Ext-Cont-Types"
#define EXTENSION_DATA                  L"Extension-Data"
#define EXTENSION_NAME                  L"Extension-Name"
#define HELP_FILE_NAME                  L"Help-File-Name"
#define COMPUTER_NAME                   L"Computer-Name"
#define GATEWAY_PROXY                   L"Gateway-Proxy"
#define HOME_SERVER                     L"Home-Server"
#define FILE_VERSION                    L"File-Version"
#define PER_MSG_DDT                     L"Per-Msg-Dialog-Display-Table"
#define PER_RECIP_DDT                   L"Per-Recip-Dialog-Display-Table"
#define PROXY_GENERATOR_DLL             L"Proxy-Generator-DLL"
#define ROUTING_LIST                    L"Routing-List"
#define OBJ_DIST_NAME                   L"Obj-Dist-Name"
#define ORGANIZATION                    L"Organization"
#define ORGANIZATIONAL_UNIT             L"Organizational-Unit"
#define CONTAINER                       L"Container"
#define HELP_DATA16                     L"Help-Data16"
#define HELP_DATA32                     L"Help-Data32"
#define OBJ_ADMIN                       L"Obj-Admins"
#define SITE_ADDRESSING                 L"Site-Addressing"
#define ADMIN_EXTENSION_DLL             L"Admin-Extension-Dll"
#define CAN_PRESERVE_DNS                L"Can-Preserve-DNs"
#define HEURISTICS                      L"Heuristics"
#define CONTAINER_INFO                  L"Container-Info"

//
// Attribute Value Defines
//

#define OBJ_CLASS_GW                    L"Mail-Gateway"
#define OBJ_CLASS_MB                    L"Mailbox-Agent"
#define OBJ_CLASS_SITE                  L"Site-Addressing"
#define OBJ_CLASS_ADDR_TYPE             L"Addr-Type"
#define OBJ_CLASS_ADDR_TEMPLATE         L"Address-Template"
#define OBJ_CLASS_ADMIN_EXTENSION       L"Admin-Extension"
#define OBJ_CLASS_COMPUTER              L"Computer"
#define OBJ_CLASS_CONTAINER             L"Container"

//
// Container Information Defines
//

#define ADDRESS_TEMPLATE_CONTAINER_INFO L"256"

//
// Import Mode Defines
//

#define MODE_CREATE                                             L"Create"
#define MODE_MODIFY                                             L"Modify"
#define MODE_DELETE                                             L"Delete"

#define DELIVERY_MECHANISM_GW                   L"2"
#define DELIVERY_MECHANISM_MB                   L"0"

#define CONTAINER_CONFIGURATION         L"/cn=Configuration"
#define CONTAINER_GW                    L"/cn=Configuration/cn=Connections"
#define CONTAINER_ADDR_TYPE             L"/cn=Configuration/cn=Addressing/cn=Address-Types"
#define CONTAINER_ADDR_TEMPLATE         L"/cn=Configuration/cn=Addressing/cn=Address-Templates"
#define CONTAINER_SERVERS               L"/cn=Configuration/cn=Servers"
#define CONTAINER_SITE_ADDR             L"/cn=Configuration/cn=Site-Addressing"
#define CONTAINER_ADD_INS               L"/cn=Configuration/cn=Add-Ins"

#define ACCOUNT_NAME                    L"Obj-Users"

//
//  Common macros.
//

#define CREATEKEY(hkParent, pszName, hkOut, dwDisposition) \
    RegCreateKeyEx(hkParent, pszName, 0, "", REG_OPTION_NON_VOLATILE, \
	KEY_ALL_ACCESS, NULL, &hkOut, &dwDisposition)

#define SETSZVALUE(hk, pszName, pszValue) \
    RegSetValueEx(hk, pszName, 0, REG_SZ, pszValue, lstrlen(pszValue)+1)

#define SETMULTISZVALUE(hk, pszName, pszValue) \
    RegSetValueEx(hk, pszName, 0, REG_MULTI_SZ, pszValue, \
	CbMultiSz(pszValue)+sizeof(CHAR))

#define FREEHKEY(hk) \
    if(hk != INVALID_HANDLE_VALUE) \
	RegCloseKey(hk);

static CHAR szExport[]          = L"Export";

static CHAR szNull[]            = L"(null)";

static CHAR szNullDisplayName[] = L"No Display Name!";

#define GLOBALFREE(x) { if((x) != NULL) {GlobalFree((void *)(x)); (x) = NULL;} }

//--HrMAPICreateSizedAddressList------------------------------------------------
//  Create a sized address list.
// -----------------------------------------------------------------------------
HRESULT 
   HrMAPICreateSizedAddressList(        
      ULONG                  cEntries,                // in - count of entries in address list
      LPADRLIST            * lppAdrList)              // out- pointer to address list pointer
{
    HRESULT         hr              = NOERROR;
    SCODE           sc              = 0;
    ULONG           cBytes          = 0;

    *lppAdrList = NULL;

    cBytes = CbNewADRLIST(cEntries);

    sc = (*pMAPIAllocateBuffer)(cBytes, (void **)lppAdrList);

    if(FAILED(sc))                           
    {                                                   
        hr = HR_LOG(E_OUTOFMEMORY);                                 
        goto cleanup;
    }                                                   

    // Initialize ADRLIST structure
    ZeroMemory(*lppAdrList, cBytes);

    (*lppAdrList)->cEntries = cEntries;

cleanup:

    return hr;
}

//--HrMAPISetAddressList--------------------------------------------------------
//  Set an address list.
// -----------------------------------------------------------------------------
HRESULT HrMAPISetAddressList(                
    ULONG iEntry,                        // in - index of address list entry
    ULONG cProps,                        // in - count of values in address list
                                         //      entry
    LPSPropValue lpPropValues,           // in - pointer to address list entry
    LPADRLIST lpAdrList)                 // i/o - pointer to address list pointer
{
    HRESULT         hr              = NOERROR;
    SCODE           sc              = 0;
    LPSPropValue    lpNewPropValues = NULL;
//    ULONG           cBytes          = 0;

    if(iEntry >= lpAdrList->cEntries)
    {
        hr = HR_LOG(E_FAIL);
        goto cleanup;
    }

    sc = (*pScDupPropset)(
        cProps,
        lpPropValues,
		(*pMAPIAllocateBuffer),
		&lpNewPropValues);

    if(FAILED(sc))
    {
        hr = HR_LOG(E_FAIL);
        goto cleanup;
    }

    if(lpAdrList->aEntries[iEntry].rgPropVals != NULL)
    {
        MAPIFREEBUFFER(lpAdrList->aEntries[iEntry].rgPropVals);
    }

    lpAdrList->aEntries[iEntry].cValues = cProps;
    lpAdrList->aEntries[iEntry].rgPropVals = lpNewPropValues;

cleanup:

    return hr;
}

HRESULT HrGWResolveAddressW(
    LPABCONT                 lpGalABCont,        // in - pointer to GAL container
    LPCWSTR                  lpszAddress,        // in - pointer to proxy address
    BOOL                   * lpfMapiRecip,       // out- MAPI recipient
    ULONG                  * lpcbEntryID,        // out- count of bytes in entry ID
    LPENTRYID              * lppEntryID)        // out- pointer to entry ID
{
    HRESULT     hr          = NOERROR;
    HRESULT     hrT         = 0;
    SCODE       sc          = 0;
    LPADRLIST   lpAdrList   = NULL;
    LPFlagList  lpFlagList  = NULL;
    SPropValue  prop[2]     = {0};
    ULONG       cbEntryID   = 0;
    LPENTRYID   lpEntryID   = NULL;

    static const SizedSPropTagArray(2, rgPropTags) =
    { 2, 
        {
            PR_ENTRYID,
            PR_SEND_RICH_INFO
        }
    };

    *lpfMapiRecip = FALSE;
    *lpcbEntryID  = 0;
    *lppEntryID   = NULL;

    sc = (*pMAPIAllocateBuffer)( CbNewFlagList(1), (LPVOID*)&lpFlagList);

    if(FAILED(sc))
    {
        hr = HR_LOG(E_OUTOFMEMORY);
        goto cleanup;
    }

    lpFlagList->cFlags    = 1;
    lpFlagList->ulFlag[0] = MAPI_UNRESOLVED;

    hr = HrMAPICreateSizedAddressList(1, &lpAdrList);

    if(FAILED(hr))
    {
        hr = HR_LOG(E_FAIL);
        goto cleanup;
    }

    prop[0].ulPropTag = PR_DISPLAY_NAME_W;
    prop[0].Value.lpszW = (LPWSTR)lpszAddress;
    prop[1].ulPropTag = PR_RECIPIENT_TYPE;
    prop[1].Value.ul = MAPI_TO;

    hr = HrMAPISetAddressList(
        0,
        2,
        prop,
        lpAdrList);

    if(FAILED(hr))
    {
        hr = HR_LOG(E_FAIL);
        goto cleanup;
    }

    hrT = lpGalABCont->ResolveNames(
        (LPSPropTagArray)&rgPropTags,
        EMS_AB_ADDRESS_LOOKUP,
        lpAdrList,
        lpFlagList);

    if(lpFlagList->ulFlag[0] != MAPI_RESOLVED)
    {
        if(lpFlagList->ulFlag[0] == MAPI_AMBIGUOUS)
        {
            hrT = MAPI_E_AMBIGUOUS_RECIP;
        }
        else
        {
            hrT = MAPI_E_NOT_FOUND;
        }
    }

    if(FAILED(hrT))
    {
        if(hrT == MAPI_E_NOT_FOUND)
        {
            hr = HR_LOG(EDK_E_NOT_FOUND);
        }
        else
        {
            hr = HR_LOG(E_FAIL);
        };

        goto cleanup;
    }

    cbEntryID = lpAdrList->aEntries[0].rgPropVals[0].Value.bin.cb;
    lpEntryID = (LPENTRYID)lpAdrList->aEntries[0].rgPropVals[0].Value.bin.lpb;

    sc = (*pMAPIAllocateBuffer)( cbEntryID, (LPVOID*)lppEntryID);

    if(FAILED(sc))
    {
        hr = HR_LOG(E_OUTOFMEMORY);
        goto cleanup;
    }

    CopyMemory(*lppEntryID, lpEntryID, cbEntryID);
    *lpcbEntryID  = cbEntryID;
    *lpfMapiRecip = lpAdrList->aEntries[0].rgPropVals[1].Value.b;

cleanup:

    MAPIFREEBUFFER(lpFlagList);

    FREEPADRLIST(lpAdrList);

   return hr;
}


//--HrFindExchangeGlobalAddressList-------------------------------------------------
// Returns the entry ID of the global address list container in the address
// book.
// -----------------------------------------------------------------------------
// CAVEAT: If this function is successful, you must free the buffer returned in lppeid.

HRESULT 
   HrFindExchangeGlobalAddressList( 
    LPADRBOOK                lpAdrBook,        // in - address book pointer
    ULONG                  * lpcbeid,          // out- pointer to count of bytes in entry ID
    LPENTRYID              * lppeid)           // out- pointer to entry ID pointer
{
    HRESULT         hr                  = NOERROR;
    ULONG           ulObjType           = 0;
//    ULONG           i                   = 0;
    LPMAPIPROP      lpRootContainer     = NULL;
    LPMAPIPROP      lpContainer         = NULL;
    LPMAPITABLE     lpContainerTable    = NULL;
    LPSRowSet       lpRows              = NULL;
    ULONG           cbContainerEntryId  = 0;
    LPENTRYID       lpContainerEntryId  = NULL;
    LPSPropValue    lpCurrProp          = NULL;
    SRestriction    SRestrictAnd[2]     = {0};
    SRestriction    SRestrictGAL        = {0};
    SPropValue      SPropID             = {0};
    SPropValue      SPropProvider       = {0};
    BYTE            muid[]              = MUIDEMSAB;

    SizedSPropTagArray(1, rgPropTags) =
    {
        1, 
        {
            PR_ENTRYID,
        }
    };

    *lpcbeid = 0;
    *lppeid  = NULL;

    // Open the root container of the address book
    hr = lpAdrBook->OpenEntry(
        0,
        NULL,
        NULL,
        MAPI_DEFERRED_ERRORS, 
        &ulObjType,
        (LPUNKNOWN FAR *)&lpRootContainer);

    if(FAILED(hr))
    {
        goto cleanup;
    }

    if(ulObjType != MAPI_ABCONT)
    {
        hr = E_FAIL;
        goto cleanup;
    }

    // Get the hierarchy table of the root container
    hr = ((LPABCONT)lpRootContainer)->GetHierarchyTable(
        MAPI_DEFERRED_ERRORS|CONVENIENT_DEPTH,
        &lpContainerTable);

    if(FAILED(hr))
    {
        goto cleanup;
    }

    // Restrict the table to the global address list (GAL)
    // ---------------------------------------------------

    // Initialize provider restriction to only Exchange providers

    SRestrictAnd[0].rt                          = RES_PROPERTY;
    SRestrictAnd[0].res.resProperty.relop       = RELOP_EQ;
    SRestrictAnd[0].res.resProperty.ulPropTag   = PR_AB_PROVIDER_ID;
    SPropProvider.ulPropTag                     = PR_AB_PROVIDER_ID;

    SPropProvider.Value.bin.cb                  = 16;
    SPropProvider.Value.bin.lpb                 = (LPBYTE)muid;
    SRestrictAnd[0].res.resProperty.lpProp      = &SPropProvider;

    // Initialize container ID restriction to only GAL container

    SRestrictAnd[1].rt                          = RES_PROPERTY;
    SRestrictAnd[1].res.resProperty.relop       = RELOP_EQ;
    SRestrictAnd[1].res.resProperty.ulPropTag   = PR_EMS_AB_CONTAINERID;
    SPropID.ulPropTag                           = PR_EMS_AB_CONTAINERID;
    SPropID.Value.l                             = 0;
    SRestrictAnd[1].res.resProperty.lpProp      = &SPropID;

    // Initialize AND restriction 
    
    SRestrictGAL.rt                             = RES_AND;
    SRestrictGAL.res.resAnd.cRes                = 2;
    SRestrictGAL.res.resAnd.lpRes               = &SRestrictAnd[0];

    // Restrict the table to the GAL - only a single row should remain

    // Get the row corresponding to the GAL

	//
	//  Query all the rows
	//

	hr = (*pHrQueryAllRows)(
	    lpContainerTable,
		(LPSPropTagArray)&rgPropTags,
		&SRestrictGAL,
		NULL,
		0,
		&lpRows);

    if(FAILED(hr) || (lpRows == NULL) || (lpRows->cRows != 1))
    {
        hr = E_FAIL;
        goto cleanup;
    }

    // Get the entry ID for the GAL

    lpCurrProp = &(lpRows->aRow[0].lpProps[0]);

    if(lpCurrProp->ulPropTag == PR_ENTRYID)
    {
        cbContainerEntryId = lpCurrProp->Value.bin.cb;
        lpContainerEntryId = (LPENTRYID)lpCurrProp->Value.bin.lpb;
    }
    else
    {
        hr = EDK_E_NOT_FOUND;
        goto cleanup;
    }

    hr = (*pMAPIAllocateBuffer)(cbContainerEntryId, (LPVOID *)lppeid);

    if(FAILED(hr))
    {
        *lpcbeid = 0;
        *lppeid = NULL;
    }
    else
    {
        CopyMemory(
            *lppeid,
            lpContainerEntryId,
            cbContainerEntryId);

        *lpcbeid = cbContainerEntryId;
    }

cleanup:

    if (lpRootContainer)
       lpRootContainer->Release();
    if (lpContainerTable)
       lpContainerTable->Release();
    if (lpContainer)
       lpContainer->Release();

    (*pFreeProws)(lpRows);
    
    if(FAILED(hr))
    {
        (*pMAPIFreeBuffer)(*lppeid);

        *lpcbeid = 0;
        *lppeid = NULL;
    }
    
    return hr;
}


//--HrSearchGAL----------------------------------------------------------------
//  Look for the entry ID by searching for the DN in the global address list.
//
//  RETURNS:	hr == NOERROR           Found
//				hr == EDK_E_NOT_FOUND   DN Not Found
//				hr == (anything else)   Other Error
// -----------------------------------------------------------------------------
static HRESULT HrSearchGAL(				
	LPADRBOOK	             lpAdrBook,			   // in - address book (directory) to look in
	LPWSTR		             lpszDN,	            // in - object distinguished name
	ULONG                  * lpcbEntryID,		   // out- count of bytes in entry ID
	LPENTRYID              * lppEntryID)		   // out- pointer to entry ID
{
    HRESULT         hr                  = NOERROR;
    LPWSTR           lpszAddress         = NULL;
    ULONG           cbGALEntryID        = 0;
    LPENTRYID       lpGALEntryID        = NULL;
    ULONG           ulGALObjectType     = 0;
    LPABCONT        lpGAL               = NULL;
    BOOL            fMapiRecip          = FALSE;


    // Initially zero out the return variables.

    *lpcbEntryID = 0;
    *lppEntryID = NULL;

    // Create an address string consisting of "EX:" followed by the DN.

    hr = (*pMAPIAllocateBuffer)(
        wcslen(EXCHANGE_ADDRTYPE L":") + wcslen(lpszDN) + 1, 
        (void **)&lpszAddress);
    if (FAILED(hr))
        goto cleanup;

    wcscpy(lpszAddress, EXCHANGE_ADDRTYPE L":");
    wcscat(lpszAddress, lpszDN);

    // Open the global address list.

    hr = HrFindExchangeGlobalAddressList(
        lpAdrBook, 
        &cbGALEntryID, 
        &lpGALEntryID);
    if (FAILED(hr))
        goto cleanup;
    
    hr = lpAdrBook->OpenEntry(
        cbGALEntryID, 
        lpGALEntryID, 
        NULL, 
        MAPI_BEST_ACCESS | MAPI_DEFERRED_ERRORS, 
        &ulGALObjectType, 
        (LPUNKNOWN *) &lpGAL);
    if (FAILED(hr))
        goto cleanup;

    // Make sure it's the right object type.

    if (ulGALObjectType != MAPI_ABCONT)
    {
        //hr = HR_LOG(E_FAIL);
        goto cleanup;
    }

    // Resolve the address (returns EDK_E_NOT_FOUND if not found).

    hr = HrGWResolveAddressW(
        lpGAL, 
        lpszAddress, 
        &fMapiRecip, 
        lpcbEntryID, 
        lppEntryID);
    if (FAILED(hr))
        goto cleanup;

cleanup:
    ULRELEASE(lpGAL);
    MAPIFREEBUFFER(lpGALEntryID);
    MAPIFREEBUFFER(lpszAddress);
    return hr;
}



//$--HrCreateDirEntryIdEx-------------------------------------------------------
//  Create a directory entry ID given the address of the object
//  in the directory.
// -----------------------------------------------------------------------------
HRESULT HrCreateDirEntryIdEx(			// RETURNS: HRESULT
	IN	LPADRBOOK	lpAdrBook,			// address book (directory) to look in
	IN	LPWSTR		lpszAddress,		// object distinguished name
	OUT	ULONG *		lpcbEntryID,		// count of bytes in entry ID
	OUT	LPENTRYID * lppEntryID)		    // pointer to entry ID
{
	HRESULT			hr					= NOERROR;
//    ULONG           cbHierarchyEntryID  = 0;
//    LPENTRYID       lpHierarchyEntryID  = NULL;
    ULONG           ulEntryIDType       = 0;

    // Initially zero out the return variables.

    *lpcbEntryID = 0;
    *lppEntryID = NULL;

	// Look for the DN in the global address list.

	hr = HrSearchGAL(
		lpAdrBook, 
		lpszAddress, 
        lpcbEntryID, 
        lppEntryID);
	if (FAILED(hr))
		goto cleanup;

    // If the type was DT_AGENT or DT_ORGANIZATION, then we have to 
    // do a further lookup in the hierarchy table to determine the 
    // DN's real type.

    ulEntryIDType = ((LPDIR_ENTRYID) *lppEntryID)->ulType;

   

cleanup:
   return hr;
}



//$--CbMultiSz------------------------------------------------------------------
//  Count of bytes in a REG_MULTI_SZ string (not including terminating NULL).
// -----------------------------------------------------------------------------
static DWORD CbMultiSz(                 // RETURNS: count of bytes
    IN LPWSTR lpszRegMultiSz)           // REG_MULTI_SZ string
{
//    HRESULT hr   = NOERROR;
    DWORD   cch  = 0;
    DWORD   cb   = 0;
    LPWSTR  lpsz = NULL;

    if(lpszRegMultiSz == NULL)
    {
	goto cleanup;
    }

    lpsz = lpszRegMultiSz;

    while(*lpsz)
    {
	cch = lstrlenW(lpsz);

	cch++;

	cb  += cch * sizeof(WCHAR);

	lpsz += cch;
    }

cleanup:

    return(cb);
}

//$--HrGetRegistryValue---------------------------------------------------------
//  Get a registry value - allocating memory to hold it.
// -----------------------------------------------------------------------------
static HRESULT HrGetRegistryValue(  // RETURNS: return code
    IN  HKEY hk,                    // the key.
    IN  LPWSTR lpszValue,           // value name in key.
    OUT DWORD * lpType,             // where to put type info.
    OUT DWORD * lpcb,               // where to put byte count info.
    OUT LPVOID * lppData)           // where to put the data.
{
    HRESULT hr   = E_FAIL;
    LONG    lRet = 0;

    *lppData = NULL;

    //
    //  Get its size
    //

    lRet = RegQueryValueEx(
	hk,
	lpszValue,
	NULL,
	lpType,
	NULL,
	lpcb);

    if(lRet != ERROR_SUCCESS)
    {
	hr = HR_LOG(HRESULT_FROM_WIN32(lRet));
	goto cleanup;
    }

    //
    //  Allocate memory for it
    //

    *lppData = (LPVOID)GlobalAlloc(GMEM_FIXED, *lpcb);

    if(*lppData == NULL)
    {
	hr = HR_LOG(HRESULT_FROM_WIN32(GetLastError()));
	goto cleanup;
    }

    //
    // Get the current value
    //

    lRet = RegQueryValueEx(hk, lpszValue, NULL, lpType, (UCHAR*)*lppData, lpcb);

    if(lRet != ERROR_SUCCESS)
    {
	hr = HR_LOG(HRESULT_FROM_WIN32(lRet));
	goto cleanup;
    }

    hr = NOERROR;

cleanup:

    if(FAILED(hr))
    {
	if(lppData != NULL)
	{
	    GLOBALFREE(*lppData);
	}
    }

    return hr;
}


//--FCsvGetField---------------------------------------------------------------
// Given a record and a field separator and a field number, this routine 
// will extract the field requested.
//------------------------------------------------------------------------------
static BOOL FCsvGetField(       // RETURNS: TRUE/FALSE
    IN  WORD wLen,              // maximum length of the field to extract
    IN  WORD wFieldNum,         // field number we want from the record
    IN  CHAR cFieldSeparator,  // character to use as a field separator
    IN  CHAR *lpszRecord,      // record to extract the field from
    OUT CHAR *lpszField)       // field we have extracted
{
//    HRESULT hr              = NOERROR;
    BOOL    fRet            = FALSE;
//    CHAR   *lpszBeginField = lpszField;

    while((wFieldNum > 0) && (*lpszRecord != 0))
    {
	// If we found a field separator, increment current field
	if(*lpszRecord == cFieldSeparator)
	{
	    wFieldNum--;
	}
	// If we are at the desired field, copy the current character into it
	else if(wFieldNum == 1 && wLen > 1)
	{
	    *lpszField = *lpszRecord;
	    lpszField++;
	    wLen--;
	}

	lpszRecord++;
    }

    *lpszField = 0;

    // If the requested field # existed, return True,
    // otherwise we ran out of fields - return False

    if(wFieldNum <= 1)
    {
	fRet = TRUE;
    }
    else
    {
	fRet = FALSE;
    }

    return(fRet);
}

//$--FCsvGetRecord--------------------------------------------------------------
// Given a buffer, the buffer's length and a file handle, this
// function fills the buffer with a single line read from the file. 
// The NL & CR are NOT put into the buffer. No unprintable characters are
// placed in the buffer
// -----------------------------------------------------------------------------
BOOL FCsvGetRecord(                 // RETURNS: TRUE/FALSE
    IN  WORD wBufferLen,            // length of the record buffer
    IN  HANDLE hFile,               // file handle to read from
    OUT CHAR *lpszBuffer)          // record we have retrieved
{
//    HRESULT hr          = NOERROR;
    DWORD   dwBytesRead = 0;
    BOOL    fReadData   = FALSE;

    while((ReadFile(hFile, (LPVOID)lpszBuffer, 1, &dwBytesRead, NULL) == TRUE) &&
	  (wBufferLen > 1) && (*lpszBuffer != '\n') && (dwBytesRead > 0))
    {
	fReadData = TRUE;

	// Only store character in buffer if it is printable!

	if((isprint(*lpszBuffer)) || (*lpszBuffer == EXCHINST_DELIM))
	{
	    lpszBuffer++;
	    wBufferLen--;
	}
    }

    // If a given record is too long it is a problem!!!

    if(wBufferLen <= 0)
    {
	fReadData = FALSE;
    }

    *lpszBuffer = 0;

    return(fReadData);
}



//$--HrEDKExportObject----------------------------------------------------------
// This function will export an object from an Exchange server.
// -----------------------------------------------------------------------------
static HRESULT HrEDKExportObject(       // RETURNS: return code
    IN  LPWSTR lpszServer,              // server name
    IN  LPWSTR lpszBasePoint,           // base point
    IN  DWORD dwControlFlags,           // control flags
    IN  LPWSTR *rgpszClasses,           // classes
    IN  LPWSTR lpszObjectAttributes,    // list of attributes to export
    OUT LPWSTR lpszTempName)            // temporary file name
{
    HRESULT       hr                     = E_FAIL;
    ULONG         cErrors                = 0;
    HANDLE        hTempFile              = INVALID_HANDLE_VALUE;
    CHAR          szTempPath[MAX_PATH+1] = {0};
    DWORD         dwNumberOfBytesWritten = 0;
    BEXPORT_PARMS BExportParms           = {0};
    BOOL           fRet                   = FALSE;

    // Get temporary directory path

    if(!GetTempPath(MAX_PATH, szTempPath))
    {
	hr = HR_LOG(HRESULT_FROM_WIN32(GetLastError()));
	goto cleanup;
    }

    // Get temporary file name

    if(!GetTempFileName(szTempPath, FILE_PREFIX, 0, lpszTempName))
    {
	hr = HR_LOG(HRESULT_FROM_WIN32(GetLastError()));
	goto cleanup;
    }

    // Create the temporary file
    hTempFile = CreateFile(lpszTempName,
	GENERIC_WRITE,
	0,
	(LPSECURITY_ATTRIBUTES)NULL,
	CREATE_ALWAYS,
	FILE_ATTRIBUTE_NORMAL,
	(HANDLE)NULL);

    // Check to see if temporary file was created...

    if(hTempFile == INVALID_HANDLE_VALUE)
    {
	hr = HR_LOG(HRESULT_FROM_WIN32(GetLastError()));
	goto cleanup;
    }

    // Write data to the temporary file & close it

    fRet = WriteFile(
	hTempFile,
	lpszObjectAttributes,
	lstrlen(lpszObjectAttributes)*sizeof(CHAR),
	&dwNumberOfBytesWritten,
	NULL);

    if(fRet == FALSE)
    {
	hr = HR_LOG(HRESULT_FROM_WIN32(GetLastError()));
	goto cleanup;
    }


    fRet = WriteFile(
	hTempFile,
	NEW_LINE,
	lstrlen(NEW_LINE)*sizeof(CHAR),
	&dwNumberOfBytesWritten,
	NULL);

    if(fRet == FALSE)
    {
	hr = HR_LOG(HRESULT_FROM_WIN32(GetLastError()));
	goto cleanup;
    }

    CLOSEHANDLE(hTempFile);

    //
    // Batch Export
    //

    BExportParms.dwDAPISignature = DAPI_SIGNATURE;
    BExportParms.dwFlags         = dwControlFlags | 
				   DAPI_MODIFY_REPLACE_PROPERTIES | 
				   DAPI_SUPPRESS_PROGRESS | 
				   DAPI_SUPPRESS_COMPLETION | 
                   DAPI_SUPPRESS_ARCHIVES | 
                   DAPI_IMPORT_NO_ERR_FILE;
    BExportParms.pszExportFile   = lpszTempName;
    BExportParms.pszBasePoint    = lpszBasePoint;
    BExportParms.pszDSAName      = lpszServer;
    BExportParms.rgpszClasses    = rgpszClasses;
    BExportParms.chColSep        = EXCHINST_DELIM;
    BExportParms.chQuote         = EXCHINST_QUOTE;
    BExportParms.chMVSep         = EXCHINST_MV_SEP;

    cErrors = (*pBatchExport)(&BExportParms);

    if(cErrors == 0)
    {
	hr = NOERROR;
    }
    else
    {
	hr = HR_LOG(E_FAIL);
    }
    
cleanup:

    CLOSEHANDLE(hTempFile);

    return hr;
}


//$--HrEDKEnumDNs---------------------------------------------------------------
//  Enumerates the distinguished name(s).
// -----------------------------------------------------------------------------
static HRESULT HrEDKEnumDNs(             // RETURNS: return code
    IN  LPWSTR lpszRootDN,               // distinguished name of DIT root
    IN  LPWSTR lpszServer,               // server name
    IN  DWORD  dwControlFlags,           // control flags
    IN  LPWSTR *rgpszClasses,            // classes
    OUT LPWSTR *lppszDNs)                // distinguished names
{
    HRESULT hr                                   = NOERROR;
    HANDLE  hTempFile                            = INVALID_HANDLE_VALUE;
    CHAR   szObjectAttributes[MAX_CSV_LINE_SIZ] = {0};
//    CHAR   szAttributeValues[MAX_CSV_LINE_SIZ]  = {0};
//    CHAR   szCurRecord[MAX_CSV_LINE_SIZ]        = {0};
    CHAR   szCurLine[MAX_CSV_LINE_SIZ]          = {0};
    CHAR   szCurField[MAX_PATH+1]               = {0};
    CHAR   szTempName[MAX_PATH+1]               = {0};
    WORD    wAttribField                         = MAX_WORD;
    WORD    wCurrField                           = 0;
    LPWSTR  lpsz                                 = NULL;
    ULONG   ulCurrOffset                         = 0;

    *lppszDNs = NULL;

    BEGIN_CSV_LINE  (szObjectAttributes, OBJ_CLASS);
    APPEND_CSV_LINE (szObjectAttributes, OBJ_DIST_NAME);

    hr = HrEDKExportObject(
	lpszServer,
	lpszRootDN,
	dwControlFlags,
	rgpszClasses,
	szObjectAttributes,
	szTempName);

    if(SUCCEEDED(hr))
    {
	// Open the temporary file
	hTempFile = CreateFile(
	    szTempName,
	    GENERIC_READ,
	    0,
	    (LPSECURITY_ATTRIBUTES)NULL,
	    OPEN_EXISTING,
	    FILE_FLAG_DELETE_ON_CLOSE,
	    (HANDLE)NULL);

	if(hTempFile == INVALID_HANDLE_VALUE)
	{
	    hr = HR_LOG(E_FAIL);
	    goto cleanup;
	}

	//
	// The first line contains the list of fields - find which field has
	// the attribute we are looking for.
	//

	FCsvGetRecord(MAX_CSV_LINE_SIZ, hTempFile, szCurLine);

	for(
	    wCurrField = 1;

	    FCsvGetField(
		MAX_PATH,
		wCurrField,
		EXCHINST_DELIM,
		szCurLine,
		szCurField);

	    wCurrField++)
	{
	    if(wcscmp(szCurField, OBJ_DIST_NAME) == 0) 
	    {
		wAttribField = wCurrField;
		break;
	    }
	}

	// Was the field exported & found above?

	if(wAttribField == MAX_WORD) 
	{
	    hr = HR_LOG(E_FAIL);
	    goto cleanup;
	}

	ulCurrOffset = 0;

	while(FCsvGetRecord (MAX_CSV_LINE_SIZ, hTempFile, szCurLine))
	{
	    FCsvGetField(
		MAX_PATH,
		wAttribField,
		EXCHINST_DELIM,
		szCurLine,
		szCurField);

	    if( *szCurField)
	    {
		if(lpsz == NULL)
		{
		    lpsz = (LPWSTR)GlobalAlloc(
			GMEM_FIXED,
			cbStrLen(szCurField) + sizeof(CHAR));
		}
		else
		{
		    lpsz = (LPWSTR)GlobalReAlloc(
			lpsz,
			GlobalSize(lpsz) + cbStrLen(szCurField),
			GMEM_MOVEABLE);
		}

		if(lpsz == NULL)
		{
		    hr = HR_LOG(HRESULT_FROM_WIN32(GetLastError()));
		    goto cleanup;
		}

		lstrcpy(&lpsz[ulCurrOffset], szCurField);

		ulCurrOffset += cbStrLen(szCurField);

		lpsz[ulCurrOffset] = 0;
	    }
	}
    }
    
    *lppszDNs = lpsz;

cleanup:

    CLOSEHANDLE(hTempFile);

    if(FAILED(hr))
    {
	GLOBALFREE(*lppszDNs);
    }

   return hr;
}

//$--HrEnumOrganizations-----------------------------------------------------
//  Enumerates the organization name(s).
// -----------------------------------------------------------------------------
HRESULT HrEnumOrganizations(          // RETURNS: return code
    IN  LPWSTR lpszRootDN,               // distinguished name of DIT root
    IN  LPWSTR lpszServer,               // server name
    OUT LPWSTR *lppszOrganizations)      // organizations
{
    HRESULT hr              = NOERROR;
    LPWSTR  rgpszClasses[2] = {0};

    rgpszClasses[0] = ORGANIZATION;
    rgpszClasses[1] = NULL;

    hr = HrEDKEnumDNs(
	lpszRootDN,
	lpszServer,
	DAPI_EXPORT_SUBTREE,
	rgpszClasses,
	lppszOrganizations);

   return hr;
}

//$--HrEnumSites-------------------------------------------------------------
//  Enumerates the site name(s).
// -----------------------------------------------------------------------------
HRESULT HrEnumSites(                  // RETURNS: return code
    IN  LPWSTR lpszServer,               // server name
    IN  LPWSTR lpszOrganizationDN,       // distinguished name of organization
    OUT LPWSTR *lppszSites)              // sites
{
    HRESULT hr              = NOERROR;
    LPWSTR  rgpszClasses[2] = {0};

    rgpszClasses[0] = ORGANIZATIONAL_UNIT;
    rgpszClasses[1] = NULL;

    hr = HrEDKEnumDNs(
	lpszOrganizationDN,
	lpszServer,
	0,
	rgpszClasses,
	lppszSites);

   return hr;
}

//$--HrEnumContainers--------------------------------------------------------
//  Enumerates the container name(s).
// -----------------------------------------------------------------------------
HRESULT HrEnumContainers(             // RETURNS: return code
    IN  LPWSTR lpszServer,               // server name
    IN  LPWSTR lpszSiteDN,               // distinguished name of site
    IN  BOOL   fSubtree,                 // sub-tree?
    OUT LPWSTR *lppszContainers)         // containers
{
    HRESULT hr              = NOERROR;
    LPWSTR  rgpszClasses[2] = {0};
    DWORD   dwControlFlags  = 0;

    rgpszClasses[0] = CONTAINER;
    rgpszClasses[1] = NULL;

    if(fSubtree == TRUE)
    {
	dwControlFlags = DAPI_EXPORT_SUBTREE;
    }

    hr = HrEDKEnumDNs(
	lpszSiteDN,
	lpszServer,
	dwControlFlags,
	rgpszClasses,
	lppszContainers);

   return hr;
}

/**/