/* ----------------------------------------------------------------------

	Module:		ULS.DLL (Service Provider)
	File:		spclient.cpp
	Content:	This file contains the client object.
	History:
	10/15/96	Chu, Lon-Chan [lonchanc]
				Created.

	Copyright (c) Microsoft Corporation 1996-1997

   ---------------------------------------------------------------------- */

#include "ulsp.h"
#include "spinc.h"


// Array of constant strings for user object's attribute names
//
const TCHAR *c_apszClientStdAttrNames[COUNT_ENUM_CLIENTATTR] =
{
	/* -- the following is for user -- */

	TEXT ("cn"),
	TEXT ("givenname"),
	TEXT ("surname"),
	TEXT ("rfc822mailbox"),
	TEXT ("location"),
	TEXT ("comment"),
	TEXT ("sipaddress"),
	TEXT ("sflags"),
	TEXT ("c"),

	/* -- the following is for app -- */

	TEXT ("sappid"),
	TEXT ("smimetype"),
	TEXT ("sappguid"),

	TEXT ("sprotid"),
	TEXT ("sprotmimetype"),
	TEXT ("sport"),

	/* -- the above are resolvable -- */

	TEXT ("ssecurity"),
	TEXT ("sttl"),

	/* -- the above are changeable standard attributes for RTPerson -- */

	TEXT ("objectClass"),
	TEXT ("o"),
};


/* ---------- public methods ----------- */


SP_CClient::
SP_CClient ( DWORD_PTR dwContext )
	:
	m_cRefs (0),						// Reference count
	m_uSignature (CLIENTOBJ_SIGNATURE),	// Client object's signature
	m_pszDN (NULL),						// Clean up DN
	m_pszAppPrefix (NULL),				// Clean up app prefix
	m_pszRefreshFilter (NULL),			// Clean up the refresh search filter
	m_fExternalIPAddress (FALSE),		// Default is I figure out the ip address
	m_dwIPAddress (0),					// Assume we are not connected to the network
	m_uTTL (ILS_DEF_REFRESH_MINUTE)		// Reset refresh time
{
	m_dwContext = dwContext;

	// Clean up attached server info structure
	//
	::ZeroMemory (&m_ServerInfo, sizeof (m_ServerInfo));

	// Clean up the scratch buffer for caching pointers to attribute values
	//
	::ZeroMemory (&m_ClientInfo, sizeof (m_ClientInfo));

	// Indicate this client is not registered yet
	//
	SetRegNone ();
}


SP_CClient::
~SP_CClient ( VOID )
{
	// Invalidate the client object's signature
	//
	m_uSignature = (ULONG) -1;

	// Free server info structure
	//
	::IlsFreeServerInfo (&m_ServerInfo);

	// Free DN and app prefix
	//
	MemFree (m_pszDN);
	MemFree (m_pszAppPrefix);

	// Free the refresh search filter
	//
	MemFree (m_pszRefreshFilter);

	// Release the previous prefix for extended attribute names
	//
	::IlsReleaseAnyAttrsPrefix (&(m_ClientInfo.AnyAttrs));
}


ULONG SP_CClient::
AddRef ( VOID )
{
	::InterlockedIncrement (&m_cRefs);
	return m_cRefs;
}


ULONG SP_CClient::
Release ( VOID )
{
	MyAssert (m_cRefs != 0);
	::InterlockedDecrement (&m_cRefs);

	ULONG cRefs = m_cRefs;
	if (cRefs == 0)
		delete this;

	return cRefs;
}


HRESULT SP_CClient::
Register (
	ULONG			uRespID,
	SERVER_INFO		*pServerInfo,
	LDAP_CLIENTINFO	*pInfo )
{
	MyAssert (pInfo != NULL);
	MyAssert (MyIsGoodString (pServerInfo->pszServerName));

	// Cache the server info
	//
	HRESULT hr = ::IlsCopyServerInfo (&m_ServerInfo, pServerInfo);
	if (hr != S_OK)
		return hr;

	// Cache client info
	//
	hr = CacheClientInfo (pInfo);
	if (hr != S_OK)
		return hr;

	// If the application sets an IP address,
	//		then we will use what the app provides,
	//		otherwise, we will get the IP address via winsock.
	//
	// CacheClientInfo() will set up the flag if ip address is passed in
	//
	if (IsExternalIPAddressPassedIn ())
	{
		// Use whatever passed in
		//
		m_fExternalIPAddress = TRUE;

		// Figure out the passed in ip address is done in CacheClientInfo()
		// The IP address string will be setup in CacheClientInfo() too.
		//
	}
	else
	{
		// I will figure out the ip address
		//
		m_fExternalIPAddress = FALSE;

		// Get IP address
		//
		hr = ::GetLocalIPAddress (&m_dwIPAddress);
		if (hr != S_OK)
			return hr;

		// Create IP address string
		//
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_IP_ADDRESS] = &m_ClientInfo.szIPAddress[0];
		::GetLongString (m_dwIPAddress, &m_ClientInfo.szIPAddress[0]);
	}

	// Create client signature string
	//
	m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_CLIENT_SIG] = &m_ClientInfo.szClientSig[0];
	::GetLongString (g_dwClientSig, &m_ClientInfo.szClientSig[0]);

	// Create TTL string
	//
	m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_TTL] = &m_ClientInfo.szTTL[0];
	::GetLongString (m_uTTL + ILS_DEF_REFRESH_MARGIN_MINUTE, &m_ClientInfo.szTTL[0]);

	// Set object class RTPerson
	//
	m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_OBJECT_CLASS] = (TCHAR *) &c_szRTPerson[0];

	// Ideally, o= should be read in from registiry
	// but for now, we simply hard code it
	//
	m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_O] = (TCHAR *) &c_szDefO[0];

	// Build DN
	//
	m_pszDN = ::IlsBuildDN (m_ServerInfo.pszBaseDN,
							m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_C],
							m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_O],
							m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_CN],
							m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_OBJECT_CLASS]);
	if (m_pszDN == NULL)
		return ILS_E_MEMORY;

	// Build refreh filter
	//
	m_pszRefreshFilter = ::ClntCreateRefreshFilter (m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_CN]);
	if (m_pszRefreshFilter == NULL)
		return ILS_E_MEMORY;

	// Cache generic protocol info (per KevinMa's suggestion)
	//
	// m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_PROT_NAME] = TEXT ("h323");
	// m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_PROT_MIME] = TEXT ("text/h323");
	// m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_PROT_PORT] = TEXT ("1720");
	m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_PROT_NAME] = STR_EMPTY;
	m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_PROT_MIME] = STR_EMPTY;
	m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_PROT_PORT] = STR_EMPTY;

	// Allocate app prefix here
	//
	ULONG cbPrefix = g_cbUserPrefix + sizeof (TCHAR) * (2 +
				::lstrlen (STR_CLIENT_APP_NAME) +
				::lstrlen (m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_APP_NAME]));
	m_pszAppPrefix = (TCHAR *) MemAlloc (cbPrefix);
	if (m_pszAppPrefix == NULL)
		return ILS_E_MEMORY;

	// Fill user prefix
	//
	::CopyMemory (m_pszAppPrefix, g_pszUserPrefix, g_cbUserPrefix);

	// Fill app prefix
	//
	TCHAR *psz = (TCHAR *) ((BYTE *) m_pszAppPrefix + g_cbUserPrefix);
	::lstrcpy (psz, STR_CLIENT_APP_NAME);
	psz += lstrlen (psz) + 1;
	::lstrcpy (psz, m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_APP_NAME]);

	// Build modify array for ldap_add()
	//
	LDAPMod **ppModUser = NULL;
	hr = CreateRegUserModArr (&ppModUser);
	if (hr != S_OK)
	{
		return hr;
	}
	MyAssert (ppModUser != NULL);

	// Build modify array for ldap_modify()
	//
	LDAPMod **ppModApp = NULL;
	hr = CreateRegAppModArr (&ppModApp);
	if (hr != S_OK)
	{
		MemFree (ppModUser);
		return hr;
	}
	MyAssert (ppModApp != NULL);

	// so far, we are done with local preparation
	//

	// Get the session object
	//
	SP_CSession *pSession = NULL;
	LDAP *ld;
	ULONG uMsgIDUser = (ULONG) -1, uMsgIDApp = (ULONG) -1;
	hr = g_pSessionContainer->GetSession (&pSession, &m_ServerInfo);
	if (hr == S_OK)
	{
		MyAssert (pSession != NULL);

		// Get the ldap session
		//
		ld = pSession->GetLd ();
		MyAssert (ld != NULL);

		// Send the data over the wire
		//
		uMsgIDUser = ::ldap_add (ld, m_pszDN, ppModUser);
		if (uMsgIDUser != -1)
		{
			uMsgIDApp = ::ldap_modify (ld, m_pszDN, ppModApp);
			if (uMsgIDApp == -1)
			{
				hr = ::LdapError2Hresult (ld->ld_errno);
			}
		}
		else
		{
			hr = ::LdapError2Hresult (ld->ld_errno);
		}
	}

	// Free modify arrays
	//
	MemFree (ppModUser);
	MemFree (ppModApp);

	// Report failure if so
	//
	if (hr != S_OK)
		goto MyExit;

	// Construct a pending info
	//
	RESP_INFO ri;
	::FillDefRespInfo (&ri, uRespID, ld, uMsgIDUser, uMsgIDApp);
	ri.uNotifyMsg = WM_ILS_REGISTER_CLIENT;
	ri.hObject = (HANDLE) this;

	// Queue the pending result
	//
	hr = g_pRespQueue->EnterRequest (pSession, &ri);
	if (hr != S_OK)
	{
		MyAssert (FALSE);
		goto MyExit;
	}

MyExit:

	if (hr != S_OK)
	{
		if (uMsgIDUser != (ULONG) -1)
			::ldap_abandon (ld, uMsgIDUser);

		if (uMsgIDApp != (ULONG) -1)
			::ldap_abandon (ld, uMsgIDApp);

		if (pSession != NULL)
			pSession->Disconnect ();
	}

	return hr;
}


HRESULT SP_CClient::
UnRegister ( ULONG uRespID )
{
	MyAssert (MyIsGoodString (m_pszDN));

	// Make sure that there is not refresh scheduled for this object
	//
	if (g_pRefreshScheduler != NULL)
	{
		g_pRefreshScheduler->RemoveClientObject (this);
	}
	else
	{
		MyAssert (FALSE);
	}

	// If it is not registered on the server,
	// the simply report success
	//
	if (! IsRegRemotely ())
	{
		SetRegNone ();
		::PostMessage (g_hWndNotify, WM_ILS_UNREGISTER_CLIENT, uRespID, S_OK);
		return S_OK;
	}

	// Indicate that we are not registered at all
	//
	SetRegNone ();

	// Get the session object
	//
	SP_CSession *pSession = NULL;
	LDAP *ld;
	ULONG uMsgID = (ULONG) -1;
	HRESULT hr = g_pSessionContainer->GetSession (&pSession, &m_ServerInfo);
	if (hr == S_OK)
	{
		// Get the ldap session
		//
		MyAssert (pSession != NULL);
		ld = pSession->GetLd ();
		MyAssert (ld != NULL);

		// Send the data over the wire
		//
		MyAssert (MyIsGoodString (m_pszDN));
		uMsgID = ::ldap_delete (ld, m_pszDN);
		if (uMsgID == -1)
		{
			hr = ::LdapError2Hresult (ld->ld_errno);
		}
	}

	// Report failure if so
	//
	if (hr != S_OK)
		goto MyExit;

	// Construct a pending info
	//
	RESP_INFO ri;
	::FillDefRespInfo (&ri, uRespID, ld, uMsgID, INVALID_MSG_ID);
	ri.uNotifyMsg = WM_ILS_UNREGISTER_CLIENT;

	// Queue this pending result
	//
	hr = g_pRespQueue->EnterRequest (pSession, &ri);
	if (hr != S_OK)
	{
		MyAssert (FALSE);
		goto MyExit;
	}

MyExit:

	if (hr != S_OK)
	{
		if (uMsgID != (ULONG) -1)
			::ldap_abandon (ld, uMsgID);

		if (pSession != NULL)
			pSession->Disconnect ();
	}

	return hr;
}


HRESULT SP_CClient::
SetAttributes (
	ULONG			uRespID,
	LDAP_CLIENTINFO	*pInfo )
{
	MyAssert (pInfo != NULL);

	MyAssert (MyIsGoodString (m_pszDN));

	// cache info
	//
	HRESULT hr = CacheClientInfo (pInfo);
	if (hr != S_OK)
		return hr;

	// Build modify array for user object's ldap_modify()
	//
	LDAPMod **ppModUser = NULL;
	hr = CreateSetUserAttrsModArr (&ppModUser);
	if (hr != S_OK)
		return hr;
	MyAssert (ppModUser != NULL);

	// Build modify array for app object's ldap_modify()
	//
	LDAPMod **ppModApp = NULL;
	hr = CreateSetAppAttrsModArr (&ppModApp);
	if (hr != S_OK)
	{
		MemFree (ppModUser);
		return hr;
	}
	MyAssert (ppModApp != NULL);

	// So far, we are done with local preparation
	//

	// Get the session object
	//
	SP_CSession *pSession = NULL;
	LDAP *ld;
	ULONG uMsgIDUser = (ULONG) -1, uMsgIDApp = (ULONG) -1;
	hr = g_pSessionContainer->GetSession (&pSession, &m_ServerInfo);
	if (hr == S_OK)
	{
		MyAssert (pSession != NULL);

		// Get the ldap session
		//
		ld = pSession->GetLd ();
		MyAssert (ld != NULL);

		// Send the data over the wire
		//
		uMsgIDUser = ::ldap_modify (ld, m_pszDN, ppModUser);
		if (uMsgIDUser != -1)
		{
			uMsgIDApp = ::ldap_modify (ld, m_pszDN, ppModApp);
			if (uMsgIDApp == -1)
			{
				hr = ::LdapError2Hresult (ld->ld_errno);
			}
		}
		else
		{
			hr = ::LdapError2Hresult (ld->ld_errno);
		}
	}

	// Free modify arrays
	//
	MemFree (ppModUser);
	MemFree (ppModApp);

	// Report failure if so
	//
	if (hr != S_OK)
		goto MyExit;

	// Initialize pending info
	//
	RESP_INFO ri;
	::FillDefRespInfo (&ri, uRespID, ld, uMsgIDUser, uMsgIDApp);
	ri.uNotifyMsg = WM_ILS_SET_CLIENT_INFO;

	// Queue the pending result
	//
	hr = g_pRespQueue->EnterRequest (pSession, &ri);
	if (hr != S_OK)
	{
		MyAssert (FALSE);
		goto MyExit;
	}

MyExit:

	if (hr != S_OK)
	{
		if (uMsgIDUser != (ULONG) -1)
			::ldap_abandon (ld, uMsgIDUser);

		if (uMsgIDApp != (ULONG) -1)
			::ldap_abandon (ld, uMsgIDApp);

		if (pSession != NULL)
			pSession->Disconnect ();
	}
	else
	{
		// If the user customizes the ip address
		// we need to remember this
		//
		m_fExternalIPAddress |= IsExternalIPAddressPassedIn ();
	}

	return hr;
}


HRESULT SP_CClient::
AddProtocol ( ULONG uNotifyMsg, ULONG uRespID, SP_CProtocol *pProt )
{
	HRESULT hr = m_Protocols.Append ((VOID *) pProt);
	if (hr == S_OK)
	{
		hr = UpdateProtocols (uNotifyMsg, uRespID, pProt);
	}

	return hr;
}


HRESULT SP_CClient::
RemoveProtocol ( ULONG uNotifyMsg, ULONG uRespID, SP_CProtocol *pProt )
{
	HRESULT hr = m_Protocols.Remove ((VOID *) pProt);
	if (hr == S_OK)
	{
		hr = UpdateProtocols (uNotifyMsg, uRespID, pProt);
	}
	else
	{
		hr = ILS_E_NOT_REGISTERED;
	}

	return hr;
}


HRESULT SP_CClient::
UpdateProtocols ( ULONG uNotifyMsg, ULONG uRespID, SP_CProtocol *pProt )
{
	MyAssert (	uNotifyMsg == WM_ILS_REGISTER_PROTOCOL ||
				uNotifyMsg == WM_ILS_UNREGISTER_PROTOCOL ||
				uNotifyMsg == WM_ILS_SET_PROTOCOL_INFO);
	
	MyAssert (MyIsGoodString (m_pszDN));

	HRESULT hr = S_OK;

	// Build modify array for protocol object's ldap_modify()
	//
	LDAPMod **ppModProt = NULL;
	hr = CreateSetProtModArr (&ppModProt);
	if (hr != S_OK)
		return hr;
	MyAssert (ppModProt != NULL);

	// So far, we are done with local preparation
	//

	// Get the session object
	//
	SP_CSession *pSession = NULL;
	LDAP *ld;
	ULONG uMsgIDProt = (ULONG) -1;
	hr = g_pSessionContainer->GetSession (&pSession, &m_ServerInfo);
	if (hr == S_OK)
	{
		MyAssert (pSession != NULL);

		// Get the ldap session
		//
		ld = pSession->GetLd ();
		MyAssert (ld != NULL);

		// Send the data over the wire
		//
		uMsgIDProt = ::ldap_modify (ld, m_pszDN, ppModProt);
		if (uMsgIDProt == -1)
		{
			hr = ::LdapError2Hresult (ld->ld_errno);
		}
	}

	// Free modify arrays
	//
	MemFree (ppModProt);

	// Report failure if so
	//
	if (hr != S_OK)
		goto MyExit;

	// Initialize pending info
	//
	RESP_INFO ri;
	::FillDefRespInfo (&ri, uRespID, ld, uMsgIDProt, INVALID_MSG_ID);
	ri.uNotifyMsg = uNotifyMsg;
	ri.hObject = (HANDLE) pProt;

	// Queue the pending result
	//
	hr = g_pRespQueue->EnterRequest (pSession, &ri);
	if (hr != S_OK)
	{
		MyAssert (FALSE);
		goto MyExit;
	}

MyExit:

	if (hr != S_OK)
	{
		if (uMsgIDProt != (ULONG) -1)
			::ldap_abandon (ld, uMsgIDProt);

		if (pSession != NULL)
			pSession->Disconnect ();
	}

	return hr;
}


HRESULT SP_CClient::
UpdateIPAddress ( VOID )
{
	MyAssert (MyIsGoodString (m_pszDN));

	// Update cached ip address
	//
	HRESULT hr = ::GetLocalIPAddress (&m_dwIPAddress);
	if (hr != S_OK)
		return hr;

	// Update the ip address string
	//
	::GetLongString (m_dwIPAddress, &m_ClientInfo.szIPAddress[0]);

	// Update IP address on the server
	//
	return ::IlsUpdateIPAddress (	&m_ServerInfo,
									m_pszDN,
									STR_CLIENT_IP_ADDR,
									&m_ClientInfo.szIPAddress[0],
									ISBU_MODOP_MODIFY_USER,
									1,
									g_pszUserPrefix);
}


/* ---------- protected methods ----------- */


HRESULT SP_CClient::
SendRefreshMsg ( VOID )
{
	MyAssert (m_pszRefreshFilter != NULL);

	HRESULT hr;

	// Send a refresh message to the server and parse the new TTL value
	//
	hr = ::IlsSendRefreshMsg (	&m_ServerInfo,
								STR_DEF_CLIENT_BASE_DN,
								STR_CLIENT_TTL,
								m_pszRefreshFilter,
								&m_uTTL);
	if (hr == ILS_E_NEED_RELOGON)
	{
		SetRegLocally ();
		::PostMessage (g_hWndNotify, WM_ILS_CLIENT_NEED_RELOGON,
							(WPARAM) this, (LPARAM) m_dwContext);
	}
	else
	if (hr == ILS_E_NETWORK_DOWN)
	{
		SetRegLocally ();
		::PostMessage (g_hWndNotify, WM_ILS_CLIENT_NETWORK_DOWN,
							(WPARAM) this, (LPARAM) m_dwContext);
	}

	// If the ip address is not provided by the app, then
	// we need to make sure that the current ip address is equal to
	// the one we used to register the user.
	//
	if (! m_fExternalIPAddress && hr == S_OK)
	{
		// Get local ip address
		//
		DWORD dwIPAddress = 0;
		if (::GetLocalIPAddress (&dwIPAddress) == S_OK)
		{
			// Now, the network appears to be up and running.
			// Update the ip address if they are different.
			//
			if (dwIPAddress != 0 && dwIPAddress != m_dwIPAddress)
				UpdateIPAddress ();
		}
	}

	return hr;
}


/* ---------- private methods ----------- */


HRESULT SP_CClient::
CreateRegUserModArr ( LDAPMod ***pppMod )
{
	MyAssert (pppMod != NULL);

	// Calculate the modify array size
	//
#ifdef ANY_IN_USER
	ULONG cStdAttrs = COUNT_ENUM_REG_USER;
	ULONG cAnyAttrs = m_ClientInfo.AnyAttrs.cAttrsToAdd;
	ULONG cTotal = cStdAttrs + cAnyAttrs;
	ULONG cbMod = ::IlsCalcModifyListSize (cTotal);
#else
	ULONG cStdAttrs = COUNT_ENUM_REG_USER;
	ULONG cTotal = cStdAttrs;
	ULONG cbMod = ::IlsCalcModifyListSize (cTotal);
#endif

	// Allocate the modify array
	//
	*pppMod = (LDAPMod **) MemAlloc (cbMod);
	if (*pppMod == NULL)
		return ILS_E_MEMORY;

	// Lay out the modify array
	//
	LDAPMod **apMod = *pppMod;
	LDAPMod *pMod;
	ULONG i, nIndex;
#ifdef ANY_IN_USER
	TCHAR *pszName2, *pszValue;
	pszName2 = m_ClientInfo.AnyAttrs.pszAttrsToAdd;
#endif
	for (i = 0; i < cTotal; i++)
	{
		// Locate modify element
		//
		pMod = ::IlsGetModifyListMod (pppMod, cTotal, i);
		pMod->mod_op = LDAP_MOD_ADD;
		apMod[i] = pMod;

#ifdef ANY_IN_USER
		if (i < cStdAttrs)
		{
			// Get attribute name and value
			//
			if (IsOverAppAttrLine (i))
			{
				nIndex = i + COUNT_ENUM_SKIP_APP_ATTRS;
			}
			else
			{
				nIndex = i;
			}

			// Put standard attributes
			//
			FillModArrAttr (pMod, nIndex);
		}
		else
		{
			// Put extended attributes
			//
			pszValue = pszName2 + lstrlen (pszName2) + 1;
			::IlsFillModifyListItem (pMod, pszName2, pszValue);
			pszName2 = pszValue + lstrlen (pszValue) + 1;
		}
#else
		// Get attribute name and value
		//
		if (IsOverAppAttrLine (i))
		{
			nIndex = i + COUNT_ENUM_SKIP_APP_ATTRS;
		}
		else
		{
			nIndex = i;
		}

		// Fill in modify element
		//
		FillModArrAttr (pMod, nIndex);
#endif
	}

	apMod[cTotal] = NULL;
	return S_OK;
}


HRESULT SP_CClient::
CreateRegAppModArr ( LDAPMod ***pppMod )
{
	MyAssert (pppMod != NULL);

	// Calculate the modify array size
	//
	ULONG cPrefix = 1; // Skip its own app id
	ULONG cStdAttrs = COUNT_ENUM_REG_APP;
#ifdef ANY_IN_USER
	ULONG cTotal = cPrefix + cStdAttrs;
	ULONG cbMod = ::IlsCalcModifyListSize (cTotal);
#else
	ULONG cAnyAttrs = m_ClientInfo.AnyAttrs.cAttrsToAdd;
	ULONG cTotal = cPrefix + cStdAttrs + cAnyAttrs;
	ULONG cbMod = ::IlsCalcModifyListSize (cTotal);
#endif

	// Allocate the modify array
	//
	*pppMod = (LDAPMod **) MemAlloc (cbMod);
	if (*pppMod == NULL)
		return ILS_E_MEMORY;

	// Lay out the modify array
	//
	LDAPMod **apMod = *pppMod;
	LDAPMod *pMod;
#ifdef ANY_IN_USER
	TCHAR *pszName1, *pszValue;
	pszName1 = m_pszAppPrefix;;
#else
	TCHAR *pszName1, *pszName2, *pszValue;
	pszName1 = m_pszAppPrefix;;
	pszName2 = m_ClientInfo.AnyAttrs.pszAttrsToAdd;
#endif
	for (ULONG i = 0; i < cTotal; i++)
	{
		// Locate modify element
		//
		pMod = ::IlsGetModifyListMod (pppMod, cTotal, i);
		pMod->mod_op = LDAP_MOD_ADD;
		apMod[i] = pMod;

		if (i < cPrefix)
		{
			// Put the prefix
			//
			pMod->mod_op = LDAP_MOD_REPLACE;
			pszValue = pszName1 + lstrlen (pszName1) + 1;
			::IlsFillModifyListItem (pMod, pszName1, pszValue);
			pszName1 = pszValue + lstrlen (pszValue) + 1;
		}
		else
#ifdef ANY_IN_USER
		{
			// Put standard attributes
			//
			FillModArrAttr (pMod, i - cPrefix + ENUM_CLIENTATTR_APP_NAME);
		}
#else
		if (i < cPrefix + cStdAttrs)
		{
			// Put standard attributes
			//
			FillModArrAttr (pMod, i - cPrefix + ENUM_CLIENTATTR_APP_NAME);
		}
		else
		{
			// Put extended attributes
			//
			pszValue = pszName2 + lstrlen (pszName2) + 1;
			::IlsFillModifyListItem (pMod, pszName2, pszValue);
			pszName2 = pszValue + lstrlen (pszValue) + 1;
		}
#endif
	}

	::IlsFixUpModOp (apMod[0], LDAP_MOD_ADD, ISBU_MODOP_ADD_APP);
	apMod[cTotal] = NULL;
	return S_OK;
}


HRESULT SP_CClient::
CreateSetUserAttrsModArr ( LDAPMod ***pppMod )
{
	MyAssert (pppMod != NULL);

	HRESULT hr;
	DWORD dwFlags = m_ClientInfo.dwFlags & CLIENTOBJ_F_USER_MASK;
#ifdef ANY_IN_USER
	ULONG cTotal  = m_ClientInfo.AnyAttrs.cAttrsToAdd +
					m_ClientInfo.AnyAttrs.cAttrsToModify +
					m_ClientInfo.AnyAttrs.cAttrsToRemove;
#else
	ULONG cTotal = 0; // must be initialized to zero
#endif

	// Lay out the modify array for modifying user standard attributes
	//
	hr = ::IlsFillDefStdAttrsModArr (pppMod,
									dwFlags,
									COUNT_ENUM_SET_USER_INFO,
									&cTotal,
									ISBU_MODOP_MODIFY_USER,
									1,
									g_pszUserPrefix);
	if (hr != S_OK)
		return hr;

	// Start to fill standard attributes
	//
	ULONG i = 1;
	LDAPMod **apMod = *pppMod;

	if (dwFlags & CLIENTOBJ_F_EMAIL_NAME)
		FillModArrAttr (apMod[i++], ENUM_CLIENTATTR_EMAIL_NAME);

	if (dwFlags & CLIENTOBJ_F_FIRST_NAME)
		FillModArrAttr (apMod[i++], ENUM_CLIENTATTR_FIRST_NAME);

	if (dwFlags & CLIENTOBJ_F_LAST_NAME)
		FillModArrAttr (apMod[i++], ENUM_CLIENTATTR_LAST_NAME);

	if (dwFlags & CLIENTOBJ_F_CITY_NAME)
		FillModArrAttr (apMod[i++], ENUM_CLIENTATTR_CITY_NAME);

	if (dwFlags & CLIENTOBJ_F_C)
		FillModArrAttr (apMod[i++], ENUM_CLIENTATTR_C);

	if (dwFlags & CLIENTOBJ_F_COMMENT)
		FillModArrAttr (apMod[i++], ENUM_CLIENTATTR_COMMENT);

	if (dwFlags & CLIENTOBJ_F_IP_ADDRESS)
		FillModArrAttr (apMod[i++], ENUM_CLIENTATTR_IP_ADDRESS);

	if (dwFlags & CLIENTOBJ_F_FLAGS)
		FillModArrAttr (apMod[i++], ENUM_CLIENTATTR_FLAGS);

#ifdef ANY_IN_USER
	// Start to fill extended attributes
	//
	::IlsFillModifyListForAnyAttrs (apMod, &i, &m_ClientInfo.AnyAttrs);
#else
#endif

	MyAssert (i == cTotal);
	return S_OK;
}


HRESULT SP_CClient::
CreateSetAppAttrsModArr ( LDAPMod ***pppMod )
{
	MyAssert (pppMod != NULL);

	HRESULT hr;
	DWORD dwFlags = m_ClientInfo.dwFlags & CLIENTOBJ_F_APP_MASK;
#ifdef ANY_IN_USER
	ULONG cTotal = 0; // must be initialized to zero
#else
	ULONG cTotal  = m_ClientInfo.AnyAttrs.cAttrsToAdd +
					m_ClientInfo.AnyAttrs.cAttrsToModify +
					m_ClientInfo.AnyAttrs.cAttrsToRemove;
#endif

	// Lay out the modify array for modifying app standard/extended attributes
	//
	hr = ::IlsFillDefStdAttrsModArr (pppMod,
									dwFlags,
									COUNT_ENUM_SET_APP_INFO,
									&cTotal,
									ISBU_MODOP_MODIFY_APP,
									2,
									m_pszAppPrefix);
	if (hr != S_OK)
		return hr;

	// Start to fill standard attributes
	//
	ULONG i = 2;
	LDAPMod **apMod = *pppMod;

	if (m_ClientInfo.dwFlags & CLIENTOBJ_F_APP_GUID)
		FillModArrAttr (apMod[i++], ENUM_CLIENTATTR_APP_GUID);

	if (m_ClientInfo.dwFlags & CLIENTOBJ_F_APP_NAME)
		FillModArrAttr (apMod[i++], ENUM_CLIENTATTR_APP_NAME);

	if (m_ClientInfo.dwFlags & CLIENTOBJ_F_APP_MIME_TYPE)
		FillModArrAttr (apMod[i++], ENUM_CLIENTATTR_APP_MIME_TYPE);

#ifdef ANY_IN_USER
#else
	// Start to fill extended attributes
	//
	::IlsFillModifyListForAnyAttrs (apMod, &i, &m_ClientInfo.AnyAttrs);
#endif

	MyAssert (i == cTotal);
	return S_OK;
}


HRESULT SP_CClient::
CreateSetProtModArr ( LDAPMod ***pppMod )
// We need to delete the attributes and then add the entire array back.
// This is due to the ILS server limitation. We agreed to live with that.
//
{
	MyAssert (pppMod != NULL);

	ULONG cPrefix = 2;
	TCHAR *pszPrefix = m_pszAppPrefix;

	ULONG cStdAttrs = COUNT_ENUM_PROTATTR;
	ULONG cTotal = cPrefix + cStdAttrs + cStdAttrs;
	ULONG cProts = 0;

	// Find out how many protocols
	//
   	HANDLE hEnum = NULL;
	SP_CProtocol *pProt;
    m_Protocols.Enumerate (&hEnum);
    while (m_Protocols.Next (&hEnum, (VOID **) &pProt) == NOERROR)
    	cProts++;

	// Calculate the modify array's total size
	//
	ULONG cbMod = ::IlsCalcModifyListSize (cTotal);

	// Add up for multi-valued attribute
	//
	if (cProts > 0)
	{
		cbMod += cStdAttrs * (cProts - 1) * sizeof (TCHAR *);
	}

	// Allocate the modify array
	//
	LDAPMod **apMod = *pppMod = (LDAPMod **) MemAlloc (cbMod);
	if (apMod == NULL)
		return ILS_E_MEMORY;

	// Fill in the modify list
	//
	LDAPMod *pMod;
	BYTE *pbData = (BYTE *) apMod + (cTotal + 1) * sizeof (LDAPMod *);
	ULONG uDispPrefix = sizeof (LDAPMod) + 2 * sizeof (TCHAR *);
	ULONG uDispStdAttrs = sizeof (LDAPMod) + (cProts + 1) * sizeof (TCHAR *);
	for (ULONG uOffset = 0, i = 0; i < cTotal; i++)
	{
		// Locate the modify structure
		//
		pMod = (LDAPMod *) (pbData + uOffset);
		apMod[i] = pMod;
		pMod->mod_values = (TCHAR **) (pMod + 1);

		// Fill in the modify structure
		//
		if (i < cPrefix)
		{
			pMod->mod_op = LDAP_MOD_REPLACE;
			pMod->mod_type = pszPrefix;
			pszPrefix += lstrlen (pszPrefix) + 1;
			*(pMod->mod_values) = pszPrefix;
			pszPrefix += lstrlen (pszPrefix) + 1;
		}
		else
		if (i < cPrefix + cStdAttrs)
		{
			// Work around the ISBU server implementation!!!
			// We agreed that we can live with the server implementation.
			//
			pMod->mod_op = LDAP_MOD_DELETE;

			ULONG nIndex = i - cPrefix;

			// Fill in attribute name
			//
			pMod->mod_type = (TCHAR *) c_apszProtStdAttrNames[nIndex];
		}
		else
		{
			pMod->mod_op = LDAP_MOD_ADD;

			ULONG nIndex = i - cPrefix - cStdAttrs;

			// Fill in attribute name
			//
			pMod->mod_type = (TCHAR *) c_apszProtStdAttrNames[nIndex];

		    // Fill in multi-valued modify array
		    //
		    if (cProts > 0)
		    {
				ULONG j = 0; // must initialized to zero
				TCHAR *pszVal;

			    m_Protocols.Enumerate (&hEnum);
			    MyAssert (hEnum != NULL);
			    while (m_Protocols.Next (&hEnum, (VOID **) &pProt) == NOERROR)
			    {
			    	MyAssert (pProt != NULL);
			    	pszVal = (pProt->GetProtInfo ())->apszStdAttrValues[nIndex];
			    	(pMod->mod_values)[j++] = (pszVal != NULL) ? pszVal : STR_EMPTY;
			    }
		    }
		    else
		    {
		    	(pMod->mod_values)[0] = STR_EMPTY;
		    }
		}

		// Calculate the modify structure's offset relative to the array's end
		//
		uOffset += (i < cPrefix + cStdAttrs) ? uDispPrefix : uDispStdAttrs;
	}

	// Fix up the first and the last ones
	//
	IlsFixUpModOp (apMod[0], LDAP_MOD_REPLACE, ISBU_MODOP_MODIFY_APP);
	apMod[cTotal] = NULL;

	return S_OK;
}


VOID SP_CClient::
FillModArrAttr ( LDAPMod *pMod, INT nIndex )
{
	MyAssert (pMod != NULL);
	MyAssert (0 <= nIndex && nIndex <= COUNT_ENUM_CLIENTATTR);

	::IlsFillModifyListItem (	pMod,
								(TCHAR *) c_apszClientStdAttrNames[nIndex],
								m_ClientInfo.apszStdAttrValues[nIndex]);
}


HRESULT SP_CClient::
CacheClientInfo ( LDAP_CLIENTINFO *pInfo )
{
	MyAssert (pInfo != NULL);

	// Release the previous prefix for extended attribute names
	//
	::IlsReleaseAnyAttrsPrefix (&(m_ClientInfo.AnyAttrs));

	// Clean up the buffer
	//
	ZeroMemory (&m_ClientInfo, sizeof (m_ClientInfo));

	// Start to cache user standard attributes
	//

	if (pInfo->uOffsetCN != INVALID_OFFSET)
	{
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_CN] =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetCN);
		// We do not want to change CN thru ldap_modify()
		// m_ClientInfo.dwFlags |= CLIENTOBJ_F_CN;
	}

	if (pInfo->uOffsetFirstName != INVALID_OFFSET)
	{
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_FIRST_NAME] =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetFirstName);
		m_ClientInfo.dwFlags |= CLIENTOBJ_F_FIRST_NAME;
	}

	if (pInfo->uOffsetLastName != INVALID_OFFSET)
	{
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_LAST_NAME] =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetLastName);
		m_ClientInfo.dwFlags |= CLIENTOBJ_F_LAST_NAME;
	}

	if (pInfo->uOffsetEMailName != INVALID_OFFSET)
	{
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_EMAIL_NAME] =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetEMailName);
		m_ClientInfo.dwFlags |= CLIENTOBJ_F_EMAIL_NAME;
	}

	if (pInfo->uOffsetCityName != INVALID_OFFSET)
	{
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_CITY_NAME] =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetCityName);
		m_ClientInfo.dwFlags |= CLIENTOBJ_F_CITY_NAME;
	}

	if (pInfo->uOffsetCountryName != INVALID_OFFSET)
	{
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_C] =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetCountryName);
		m_ClientInfo.dwFlags |= CLIENTOBJ_F_C;
	}

	if (pInfo->uOffsetComment != INVALID_OFFSET)
	{
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_COMMENT] =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetComment);
		m_ClientInfo.dwFlags |= CLIENTOBJ_F_COMMENT;
	}

	if (pInfo->uOffsetIPAddress != INVALID_OFFSET)
	{
		DWORD dwIPAddr = ::inet_addr ((TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetIPAddress));
		if (dwIPAddr != INADDR_NONE)
		{
			m_dwIPAddress = dwIPAddr;
			m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_IP_ADDRESS] = &m_ClientInfo.szIPAddress[0];
			::GetLongString (m_dwIPAddress, &m_ClientInfo.szIPAddress[0]);
			m_ClientInfo.dwFlags |= CLIENTOBJ_F_IP_ADDRESS;
		}
	}

	if (pInfo->dwFlags != INVALID_USER_FLAGS)
	{
		::GetLongString (pInfo->dwFlags, &m_ClientInfo.szFlags[0]);
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_FLAGS] = &m_ClientInfo.szFlags[0];
		m_ClientInfo.dwFlags |= CLIENTOBJ_F_FLAGS;
	}

	// Start to cache app standard attributes
	//

	if (pInfo->uOffsetAppName != INVALID_OFFSET)
	{
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_APP_NAME] =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetAppName);
		m_ClientInfo.dwFlags |= CLIENTOBJ_F_APP_NAME;
	}

	if (pInfo->uOffsetAppMimeType != INVALID_OFFSET)
	{
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_APP_MIME_TYPE] =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetAppMimeType);
		m_ClientInfo.dwFlags |= CLIENTOBJ_F_APP_MIME_TYPE;
	}

	if (::IsValidGuid (&(pInfo->AppGuid)))
	{
		::GetGuidString (&(pInfo->AppGuid), &m_ClientInfo.szGuid[0]);
		m_ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_APP_GUID] = &m_ClientInfo.szGuid[0];
		m_ClientInfo.dwFlags |= CLIENTOBJ_F_APP_GUID;
	}

	// Start to cache app extended attributes
	//

	if (pInfo->uOffsetAttrsToAdd != INVALID_OFFSET &&
		pInfo->cAttrsToAdd != 0)
	{
		m_ClientInfo.AnyAttrs.cAttrsToAdd = pInfo->cAttrsToAdd;
		m_ClientInfo.AnyAttrs.pszAttrsToAdd =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetAttrsToAdd);
	}

	if (pInfo->uOffsetAttrsToModify != INVALID_OFFSET &&
		pInfo->cAttrsToModify != 0)
	{
		m_ClientInfo.AnyAttrs.cAttrsToModify = pInfo->cAttrsToModify;
		m_ClientInfo.AnyAttrs.pszAttrsToModify =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetAttrsToModify);
	}

	if (pInfo->uOffsetAttrsToRemove != INVALID_OFFSET &&
		pInfo->cAttrsToRemove != 0)
	{
		m_ClientInfo.AnyAttrs.cAttrsToRemove = pInfo->cAttrsToRemove;
		m_ClientInfo.AnyAttrs.pszAttrsToRemove =
						(TCHAR *) (((BYTE *) pInfo) + pInfo->uOffsetAttrsToRemove);
	}

	// Create prefix for extended attribute names
	//
	return ::IlsCreateAnyAttrsPrefix (&(m_ClientInfo.AnyAttrs));
}