1077 lines
23 KiB
C++
1077 lines
23 KiB
C++
/* ----------------------------------------------------------------------
|
|
|
|
Module: ULS.DLL (Service Provider)
|
|
File: spils.cpp
|
|
Content: This file contains the ILS specifics.
|
|
History:
|
|
12/10/96 Chu, Lon-Chan [lonchanc]
|
|
Created.
|
|
|
|
Copyright (c) Microsoft Corporation 1996-1997
|
|
|
|
---------------------------------------------------------------------- */
|
|
|
|
#include "ulsp.h"
|
|
#include "spinc.h"
|
|
|
|
#include "winsock.h"
|
|
#include "ping.h"
|
|
|
|
// Constant string for ISBU's special modify-operation attribute
|
|
//
|
|
const TCHAR c_szModOp[] = { TEXT ('s'), TEXT ('m'), TEXT ('o'), TEXT ('d'),
|
|
TEXT ('o'), TEXT ('p'), TEXT ('\0'),
|
|
TEXT ('0'), TEXT ('\0')}; //TEXT ("smodop\0000");
|
|
|
|
ULONG g_cbUserPrefix = sizeof (c_szModOp);
|
|
TCHAR *g_pszUserPrefix = NULL;
|
|
ULONG g_cbMtgPrefix = sizeof (c_szModOp);
|
|
TCHAR *g_pszMtgPrefix = NULL;
|
|
|
|
|
|
CPing *g_pPing = NULL;
|
|
|
|
|
|
HRESULT
|
|
IlsInitialize ( VOID )
|
|
{
|
|
// Allocate the ping object
|
|
//
|
|
g_pPing = new CPing;
|
|
if (g_pPing == NULL)
|
|
return ILS_E_MEMORY;
|
|
|
|
// Allocate user prefix
|
|
//
|
|
g_pszUserPrefix = (TCHAR *) MemAlloc (g_cbUserPrefix);
|
|
if (g_pszUserPrefix == NULL)
|
|
return ILS_E_MEMORY;
|
|
|
|
// Fill in user prefix string
|
|
//
|
|
TCHAR *psz = g_pszUserPrefix;
|
|
lstrcpy (psz, &c_szModOp[0]);
|
|
psz += lstrlen (psz) + 1;
|
|
lstrcpy (psz, TEXT ("0"));
|
|
|
|
// Allocate mtg prefix
|
|
//
|
|
g_pszMtgPrefix = (TCHAR *) MemAlloc (g_cbMtgPrefix);
|
|
if (g_pszMtgPrefix == NULL)
|
|
{
|
|
MemFree (g_pszUserPrefix);
|
|
g_pszUserPrefix = NULL;
|
|
return ILS_E_MEMORY;
|
|
}
|
|
|
|
// Fill in mtg prefix string
|
|
//
|
|
psz = g_pszMtgPrefix;
|
|
lstrcpy (psz, &c_szModOp[0]);
|
|
psz += lstrlen (psz) + 1;
|
|
lstrcpy (psz, TEXT ("0"));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
IlsCleanup ( VOID )
|
|
{
|
|
// Free the ping object
|
|
//
|
|
if (g_pPing != NULL)
|
|
{
|
|
delete g_pPing;
|
|
g_pPing = NULL;
|
|
}
|
|
|
|
// Free user prefix string
|
|
//
|
|
MemFree (g_pszUserPrefix);
|
|
g_pszUserPrefix = NULL;
|
|
|
|
// Free mtg prefix string
|
|
//
|
|
MemFree (g_pszMtgPrefix);
|
|
g_pszMtgPrefix = NULL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
ULONG
|
|
IlsCalcModifyListSize ( ULONG cAttrs )
|
|
{
|
|
ULONG cbSize;
|
|
|
|
// array itself
|
|
cbSize = (cAttrs + 1) * sizeof (LDAPMod *);
|
|
|
|
// array elements
|
|
cbSize += cAttrs * sizeof (LDAPMod);
|
|
|
|
// single valued attribute requires two pointers
|
|
cbSize += cAttrs * 2 * sizeof (TCHAR *);
|
|
|
|
return cbSize;
|
|
}
|
|
|
|
|
|
LDAPMod *
|
|
IlsGetModifyListMod ( LDAPMod ***pppMod, ULONG cAttrs, LONG AttrIdx )
|
|
{
|
|
return (LDAPMod *) (((BYTE *) *pppMod) +
|
|
(cAttrs + 1) * sizeof (LDAPMod *) +
|
|
AttrIdx * (sizeof (LDAPMod) + 2 * sizeof (TCHAR *)));
|
|
}
|
|
|
|
|
|
VOID
|
|
IlsFillModifyListItem (
|
|
LDAPMod *pMod,
|
|
TCHAR *pszAttrName,
|
|
TCHAR *pszAttrValue )
|
|
{
|
|
MyAssert (pMod != NULL);
|
|
MyAssert (pszAttrName != NULL);
|
|
|
|
// Set attribute name
|
|
//
|
|
pMod->mod_type = pszAttrName;
|
|
|
|
// Set single valued attribute value
|
|
//
|
|
TCHAR **ppsz = (TCHAR **) (pMod + 1);
|
|
pMod->mod_values = ppsz;
|
|
*ppsz++ = (pszAttrValue != NULL) ? pszAttrValue : STR_EMPTY;
|
|
|
|
// Set null string to terminate this array of values
|
|
//
|
|
*ppsz = NULL;
|
|
}
|
|
|
|
|
|
VOID
|
|
IlsFillModifyListForAnyAttrs (
|
|
LDAPMod *apMod[],
|
|
ULONG *puIndex,
|
|
ANY_ATTRS *pAnyAttrs )
|
|
{
|
|
LDAPMod *pMod;
|
|
TCHAR *pszName, *pszValue;
|
|
ULONG i = *puIndex, j;
|
|
|
|
// Put in extended attributes to add
|
|
//
|
|
pszName = pAnyAttrs->pszAttrsToAdd;
|
|
for (j = 0; j < pAnyAttrs->cAttrsToAdd; j++)
|
|
{
|
|
pMod = apMod[i++];
|
|
pMod->mod_op = LDAP_MOD_ADD;
|
|
pszValue = pszName + lstrlen (pszName) + 1;
|
|
IlsFillModifyListItem (pMod, pszName, pszValue);
|
|
pszName = pszValue + lstrlen (pszValue) + 1;
|
|
}
|
|
|
|
// Put in extended attributes to modify
|
|
//
|
|
pszName = pAnyAttrs->pszAttrsToModify;
|
|
for (j = 0; j < pAnyAttrs->cAttrsToModify; j++)
|
|
{
|
|
pMod = apMod[i++];
|
|
pMod->mod_op = LDAP_MOD_REPLACE;
|
|
pszValue = pszName + lstrlen (pszName) + 1;
|
|
IlsFillModifyListItem (pMod, pszName, pszValue);
|
|
pszName = pszValue + lstrlen (pszValue) + 1;
|
|
}
|
|
|
|
// Put in extended attributes to remove
|
|
//
|
|
pszName = pAnyAttrs->pszAttrsToRemove;
|
|
for (j = 0; j < pAnyAttrs->cAttrsToRemove; j++)
|
|
{
|
|
pMod = apMod[i++];
|
|
pMod->mod_op = LDAP_MOD_DELETE;
|
|
IlsFillModifyListItem (pMod, pszName, NULL);
|
|
pszName = pszName + lstrlen (pszName) + 1;
|
|
}
|
|
|
|
// Return the running index
|
|
//
|
|
*puIndex = i;
|
|
}
|
|
|
|
|
|
TCHAR c_szModOp_AddApp[] = TEXT ("0");
|
|
TCHAR c_szModOp_DeleteApp[] = TEXT ("1");
|
|
TCHAR c_szModOp_ModifyUser[] = TEXT ("2");
|
|
TCHAR c_szModOp_ModifyApp[] = TEXT ("3");
|
|
|
|
|
|
VOID
|
|
IlsFixUpModOp ( LDAPMod *pMod, LONG LdapModOp, LONG IsbuModOp )
|
|
{
|
|
MyAssert (pMod != NULL);
|
|
|
|
pMod->mod_op = LdapModOp;
|
|
// pMod->mod_op = LDAP_MOD_ADD; // lonchanc: MUST MUST MUST
|
|
pMod->mod_type = (TCHAR *) &c_szModOp[0];
|
|
pMod->mod_values = (TCHAR **) (pMod + 1);
|
|
|
|
switch (IsbuModOp)
|
|
{
|
|
case ISBU_MODOP_ADD_APP:
|
|
*(pMod->mod_values) = &c_szModOp_AddApp[0];
|
|
break;
|
|
case ISBU_MODOP_DELETE_APP:
|
|
*(pMod->mod_values) = &c_szModOp_DeleteApp[0];
|
|
break;
|
|
case ISBU_MODOP_MODIFY_USER:
|
|
*(pMod->mod_values) = &c_szModOp_ModifyUser[0];
|
|
break;
|
|
case ISBU_MODOP_MODIFY_APP:
|
|
*(pMod->mod_values) = &c_szModOp_ModifyApp[0];
|
|
break;
|
|
default:
|
|
MyAssert (FALSE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
IlsParseRefreshPeriod (
|
|
LDAP *ld,
|
|
LDAPMessage *pLdapMsg,
|
|
const TCHAR *pszTtlAttrName,
|
|
ULONG *puTTL )
|
|
{
|
|
MyAssert (ld != NULL);
|
|
MyAssert (pLdapMsg != NULL);
|
|
MyAssert (pszTtlAttrName != NULL);
|
|
MyAssert (puTTL != NULL);
|
|
|
|
HRESULT hr;
|
|
ULONG uRefreshPeriod;
|
|
ULONG tcRefreshPeriod;
|
|
|
|
// Get the first entry
|
|
//
|
|
LDAPMessage *pEntry = ldap_first_entry (ld, pLdapMsg);
|
|
if (pEntry == NULL)
|
|
{
|
|
MyAssert (FALSE);
|
|
hr = ILS_E_MEMORY;
|
|
goto MyExit;
|
|
}
|
|
|
|
// Get the sTTL attribute
|
|
//
|
|
TCHAR **ppszAttrVal;
|
|
ppszAttrVal = my_ldap_get_values (ld, pEntry, (TCHAR *) pszTtlAttrName);
|
|
if (ppszAttrVal == NULL || *ppszAttrVal == NULL)
|
|
{
|
|
MyAssert (FALSE);
|
|
hr = ILS_E_MEMORY;
|
|
goto MyExit;
|
|
}
|
|
|
|
// Convert string to long
|
|
//
|
|
uRefreshPeriod = ::GetStringLong (*ppszAttrVal);
|
|
|
|
// Reserve two-minute overhead
|
|
//
|
|
if (uRefreshPeriod > ILS_DEF_REFRESH_MARGIN_MINUTE)
|
|
uRefreshPeriod -= ILS_DEF_REFRESH_MARGIN_MINUTE;
|
|
|
|
// Make sure we have a safe, reasonable refresh period at least
|
|
//
|
|
if (uRefreshPeriod < ILS_DEF_REFRESH_MARGIN_MINUTE)
|
|
uRefreshPeriod = ILS_DEF_REFRESH_MARGIN_MINUTE;
|
|
|
|
// Convert min to ms
|
|
//
|
|
tcRefreshPeriod = Minute2TickCount (uRefreshPeriod);
|
|
|
|
// Free the attribute value
|
|
//
|
|
ldap_value_free (ppszAttrVal);
|
|
|
|
// Update ttl
|
|
//
|
|
*puTTL = uRefreshPeriod; // in unit of minute
|
|
|
|
hr = S_OK;
|
|
|
|
MyExit:
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
MyAssert (FALSE);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
IlsUpdateOneAttr (
|
|
SERVER_INFO *pServerInfo,
|
|
TCHAR *pszDN,
|
|
TCHAR *pszAttrName,
|
|
TCHAR *pszAttrValue,
|
|
LONG nModifyMagic,
|
|
ULONG cPrefix,
|
|
TCHAR *pszPrefix,
|
|
SP_CSession **ppSession, // output
|
|
ULONG *puMsgID ) // output
|
|
{
|
|
MyAssert (pServerInfo != NULL);
|
|
MyAssert (pszDN != NULL);
|
|
MyAssert (pszAttrName != NULL);
|
|
MyAssert (pszAttrValue != NULL);
|
|
MyAssert ( nModifyMagic == ISBU_MODOP_MODIFY_USER ||
|
|
nModifyMagic == ISBU_MODOP_MODIFY_APP);
|
|
MyAssert (ppSession != NULL);
|
|
MyAssert (puMsgID != NULL);
|
|
|
|
// Build modify array for ldap_modify()
|
|
//
|
|
LDAP *ld;
|
|
LDAPMod **ppMod = NULL;
|
|
ULONG cTotal = 0;
|
|
HRESULT hr = IlsFillDefStdAttrsModArr (&ppMod,
|
|
1, // one attribute (i.e. IP addr)
|
|
1, // max? there is only one attr, come on
|
|
&cTotal,
|
|
nModifyMagic,
|
|
cPrefix,
|
|
pszPrefix);
|
|
if (hr != S_OK)
|
|
goto MyExit;
|
|
|
|
// Fill in modify list
|
|
//
|
|
MyAssert (ppMod != NULL);
|
|
LDAPMod *pMod;
|
|
pMod = ppMod[cPrefix];
|
|
MyAssert (pMod != NULL);
|
|
pMod->mod_type = pszAttrName;
|
|
|
|
// Put in ip address
|
|
//
|
|
pMod->mod_values = (TCHAR **) (pMod + 1);
|
|
*(pMod->mod_values) = pszAttrValue;
|
|
|
|
// Get the session object
|
|
//
|
|
hr = g_pSessionContainer->GetSession (ppSession, pServerInfo, FALSE);
|
|
if (hr != S_OK)
|
|
goto MyExit;
|
|
MyAssert (*ppSession != NULL);
|
|
|
|
// Get the ldap session
|
|
//
|
|
ld = (*ppSession)->GetLd ();
|
|
MyAssert (ld != NULL);
|
|
|
|
// Send the data over the wire
|
|
//
|
|
*puMsgID = ldap_modify (ld, pszDN, ppMod);
|
|
if (*puMsgID == -1)
|
|
{
|
|
hr = ::LdapError2Hresult (ld->ld_errno);
|
|
(*ppSession)->Disconnect ();
|
|
goto MyExit;
|
|
}
|
|
|
|
// Success
|
|
//
|
|
hr = S_OK;
|
|
|
|
MyExit:
|
|
|
|
MemFree (ppMod);
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
IlsUpdateIPAddress (
|
|
SERVER_INFO *pServerInfo,
|
|
TCHAR *pszDN,
|
|
TCHAR *pszIPAddrName,
|
|
TCHAR *pszIPAddrValue,
|
|
LONG nModifyMagic,
|
|
ULONG cPrefix,
|
|
TCHAR *pszPrefix )
|
|
{
|
|
SP_CSession *pSession = NULL;
|
|
LDAP *ld;
|
|
ULONG uMsgID;
|
|
|
|
// Update the ip address attribute on the server
|
|
//
|
|
HRESULT hr = IlsUpdateOneAttr ( pServerInfo,
|
|
pszDN,
|
|
pszIPAddrName,
|
|
pszIPAddrValue,
|
|
nModifyMagic,
|
|
cPrefix,
|
|
pszPrefix,
|
|
&pSession,
|
|
&uMsgID);
|
|
if (hr != S_OK)
|
|
return hr;
|
|
|
|
// Get the ldap session
|
|
//
|
|
MyAssert (pSession != NULL);
|
|
ld = pSession->GetLd ();
|
|
MyAssert (ld != NULL);
|
|
|
|
// Let's wait for the result
|
|
//
|
|
LDAP_TIMEVAL TimeVal;
|
|
TimeVal.tv_usec = 0;
|
|
TimeVal.tv_sec = pSession->GetServerTimeoutInSecond ();
|
|
|
|
// We don't care the result.
|
|
// Should it fails, nothing we can do.
|
|
// We can try it again in next keep alive time.
|
|
//
|
|
LDAPMessage *pLdapMsg;
|
|
pLdapMsg = NULL;
|
|
ldap_result (ld, uMsgID, LDAP_MSG_ALL, &TimeVal, &pLdapMsg);
|
|
|
|
// Free message
|
|
//
|
|
if (pLdapMsg != NULL)
|
|
ldap_msgfree (pLdapMsg);
|
|
|
|
|
|
// Free up the session
|
|
//
|
|
if (pSession != NULL)
|
|
pSession->Disconnect ();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
IlsSendRefreshMsg (
|
|
SERVER_INFO *pServerInfo,
|
|
TCHAR *pszBaseDN,
|
|
TCHAR *pszTTL,
|
|
TCHAR *pszRefreshFilter,
|
|
ULONG *puTTL )
|
|
{
|
|
MyAssert (pServerInfo != NULL);
|
|
MyAssert (MyIsGoodString (pszBaseDN));
|
|
MyAssert (MyIsGoodString (pszTTL));
|
|
MyAssert (MyIsGoodString (pszRefreshFilter));
|
|
MyAssert (puTTL != NULL);
|
|
|
|
// Let's check to see if we need to use Ping...
|
|
//
|
|
if (g_pPing != NULL && g_pPing->IsAutodialEnabled ())
|
|
{
|
|
LPTSTR pszServerName = My_strdup(pServerInfo->pszServerName);
|
|
if (NULL == pszServerName)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
LPTSTR pszSeparator = My_strchr(pszServerName, _T(':'));
|
|
if (NULL != pszSeparator)
|
|
{
|
|
*pszSeparator = _T('\0');
|
|
}
|
|
|
|
DWORD dwIPAddr = inet_addr (pszServerName);
|
|
MemFree(pszServerName);
|
|
if (dwIPAddr != INADDR_NONE)
|
|
{
|
|
if (g_pPing->Ping (dwIPAddr, 10 * 1000, 9) == S_FALSE)
|
|
{
|
|
MyDebugMsg ((ZONE_KA, "KA: ping failed, network down\r\n"));
|
|
|
|
// The "ping" operation failed, but other operations failed
|
|
//
|
|
return ILS_E_NETWORK_DOWN;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get the connection object
|
|
//
|
|
SP_CSession *pSession = NULL;
|
|
HRESULT hr = g_pSessionContainer->GetSession (&pSession, pServerInfo, FALSE);
|
|
if (hr != S_OK)
|
|
{
|
|
MyDebugMsg ((ZONE_KA, "KA: network down, hr=0x%lX\r\n", hr));
|
|
|
|
// Report error
|
|
//
|
|
return ILS_E_NETWORK_DOWN;
|
|
}
|
|
MyAssert (pSession != NULL);
|
|
|
|
// Get the ldap session
|
|
//
|
|
LDAP *ld = pSession->GetLd ();
|
|
MyAssert (ld != NULL);
|
|
|
|
// Set attributes to return
|
|
//
|
|
TCHAR *apszAttrNames[2];
|
|
apszAttrNames[0] = pszTTL;
|
|
apszAttrNames[1] = NULL;
|
|
|
|
// Update options in ld
|
|
//
|
|
ld->ld_sizelimit = 0; // no limit in the num of entries to return
|
|
ld->ld_timelimit = 0; // no limit on the time to spend on the search
|
|
ld->ld_deref = LDAP_DEREF_ALWAYS;
|
|
|
|
// Send search query
|
|
//
|
|
MyDebugMsg ((ZONE_KA, "KA: calling ldap_search()...\r\n"));
|
|
ULONG uMsgID = ::ldap_search ( ld,
|
|
pszBaseDN, // base DN
|
|
LDAP_SCOPE_BASE, // scope
|
|
pszRefreshFilter, // filter
|
|
&apszAttrNames[0], // attrs[]
|
|
0); // both type and value
|
|
if (uMsgID == -1)
|
|
{
|
|
MyDebugMsg ((ZONE_KA, "KA: ldap_search() failed\r\n"));
|
|
hr = ::LdapError2Hresult (ld->ld_errno);
|
|
pSession->Disconnect ();
|
|
return hr;
|
|
}
|
|
|
|
// Let's wait for the result
|
|
//
|
|
LDAP_TIMEVAL TimeVal;
|
|
TimeVal.tv_usec = 0;
|
|
TimeVal.tv_sec = pSession->GetServerTimeoutInSecond ();
|
|
|
|
// Wait and get the result back
|
|
//
|
|
LDAPMessage *pLdapMsg = NULL;
|
|
INT ResultType = ::ldap_result (ld, uMsgID, LDAP_MSG_ALL, &TimeVal, &pLdapMsg);
|
|
if (ResultType == LDAP_RES_SEARCH_ENTRY ||
|
|
ResultType == LDAP_RES_SEARCH_RESULT)
|
|
{
|
|
if (pLdapMsg != NULL)
|
|
{
|
|
switch (pLdapMsg->lm_returncode)
|
|
{
|
|
case LDAP_NO_SUCH_OBJECT:
|
|
MyDebugMsg ((ZONE_KA, "KA: no such object!\r\n"));
|
|
|
|
// Report error
|
|
//
|
|
hr = ILS_E_NEED_RELOGON;
|
|
break;
|
|
|
|
case LDAP_SUCCESS:
|
|
// Get the new refresh period
|
|
//
|
|
hr = ::IlsParseRefreshPeriod (ld, pLdapMsg, pszTTL, puTTL);
|
|
break;
|
|
|
|
default:
|
|
MyDebugMsg ((ZONE_KA, "KA: unknown lm_returncode=%ld\r\n", pLdapMsg->lm_returncode));
|
|
MyAssert (FALSE);
|
|
hr = ::LdapError2Hresult (ld->ld_errno);
|
|
break;
|
|
}
|
|
|
|
// Free this message
|
|
//
|
|
ldap_msgfree (pLdapMsg);
|
|
} // if (pLdapMsg != NULL)
|
|
else
|
|
{
|
|
hr = ILS_E_FAIL;
|
|
}
|
|
} // not timeout
|
|
else
|
|
{
|
|
// Timeout
|
|
//
|
|
hr = ILS_E_TIMEOUT;
|
|
}
|
|
|
|
// Free up the session
|
|
//
|
|
pSession->Disconnect ();
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
IlsFillDefStdAttrsModArr (
|
|
LDAPMod ***pppMod,
|
|
DWORD dwFlags,
|
|
ULONG cMaxAttrs,
|
|
ULONG *pcTotal, // in/out parameter!!!
|
|
LONG IsbuModOp,
|
|
ULONG cPrefix,
|
|
TCHAR *pszPrefix )
|
|
{
|
|
|
|
MyAssert (pppMod != NULL);
|
|
MyAssert (pcTotal != NULL);
|
|
MyAssert ( (cPrefix == 0 && pszPrefix == NULL) ||
|
|
(cPrefix != 0 && pszPrefix != NULL));
|
|
|
|
// Figure out the num of attributes
|
|
//
|
|
ULONG cAttrs = 0;
|
|
for (ULONG i = 0; i < cMaxAttrs; i++)
|
|
{
|
|
if (dwFlags & 0x01)
|
|
cAttrs++;
|
|
dwFlags >>= 1;
|
|
}
|
|
|
|
// Allocate modify list
|
|
//
|
|
ULONG cTotal = *pcTotal + cPrefix + cAttrs;
|
|
ULONG cbMod = IlsCalcModifyListSize (cTotal);
|
|
*pppMod = (LDAPMod **) MemAlloc (cbMod);
|
|
if (*pppMod == NULL)
|
|
return ILS_E_MEMORY;
|
|
|
|
// Fill in the modify list
|
|
//
|
|
LDAPMod *pMod;
|
|
for (i = 0; i < cTotal; i++)
|
|
{
|
|
pMod = IlsGetModifyListMod (pppMod, cTotal, i);
|
|
(*pppMod)[i] = pMod;
|
|
pMod->mod_values = (TCHAR **) (pMod + 1);
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
// Fix up the first and the last ones
|
|
//
|
|
IlsFixUpModOp ((*pppMod)[0], LDAP_MOD_REPLACE, IsbuModOp);
|
|
(*pppMod)[cTotal] = NULL;
|
|
|
|
// Return the total number of entries
|
|
//
|
|
*pcTotal = cTotal;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
const TCHAR c_szAnyAttrPrefix[] = TEXT ("ILSA");
|
|
#define SIZE_ANY_ATTR_PREFIX (sizeof (c_szAnyAttrPrefix) / sizeof (TCHAR))
|
|
|
|
|
|
const TCHAR *
|
|
UlsLdap_GetExtAttrNamePrefix ( VOID )
|
|
{
|
|
return &c_szAnyAttrPrefix[0];
|
|
}
|
|
|
|
|
|
const TCHAR *
|
|
IlsSkipAnyAttrNamePrefix ( const TCHAR *pszAttrName )
|
|
{
|
|
MyAssert (pszAttrName != NULL);
|
|
|
|
const TCHAR *psz = IlsIsAnyAttrName (pszAttrName);
|
|
if (psz == NULL)
|
|
{
|
|
MyAssert (FALSE);
|
|
psz = pszAttrName;
|
|
}
|
|
|
|
return psz;
|
|
}
|
|
|
|
|
|
const TCHAR *
|
|
IlsIsAnyAttrName ( const TCHAR *pszAttrName )
|
|
{
|
|
BOOL fRet = FALSE;
|
|
TCHAR *psz = (TCHAR *) pszAttrName;
|
|
|
|
if (pszAttrName != NULL)
|
|
{
|
|
if (lstrlen (pszAttrName) > SIZE_ANY_ATTR_PREFIX)
|
|
{
|
|
TCHAR c = pszAttrName[SIZE_ANY_ATTR_PREFIX-1];
|
|
psz[SIZE_ANY_ATTR_PREFIX-1] = TEXT ('\0');
|
|
fRet = (My_lstrcmpi (pszAttrName, &c_szAnyAttrPrefix[0]) == 0);
|
|
psz[SIZE_ANY_ATTR_PREFIX-1] = c;
|
|
}
|
|
}
|
|
|
|
return (fRet ? &pszAttrName[SIZE_ANY_ATTR_PREFIX-1] : NULL);
|
|
}
|
|
|
|
|
|
TCHAR *
|
|
IlsPrefixNameValueArray (
|
|
BOOL fPair,
|
|
ULONG cAttrs,
|
|
const TCHAR *pszAttrs )
|
|
{
|
|
if (cAttrs == 0 || pszAttrs == NULL)
|
|
{
|
|
MyAssert (FALSE);
|
|
return NULL;
|
|
}
|
|
|
|
// compute the total size required
|
|
ULONG cbTotalSize = 0;
|
|
ULONG cbThisSize;
|
|
TCHAR *pszSrc = (TCHAR *) pszAttrs;
|
|
for (ULONG i = 0; i < cAttrs; i++)
|
|
{
|
|
// get name size
|
|
cbThisSize = lstrlen (pszSrc) + 1;
|
|
pszSrc += lstrlen (pszSrc) + 1;
|
|
|
|
// get value size as needed
|
|
if (fPair)
|
|
{
|
|
cbThisSize += lstrlen (pszSrc) + 1;
|
|
pszSrc += lstrlen (pszSrc) + 1;
|
|
}
|
|
|
|
// adjust the size
|
|
cbThisSize += SIZE_ANY_ATTR_PREFIX;
|
|
cbThisSize *= sizeof (TCHAR);
|
|
|
|
// accumulate it
|
|
cbTotalSize += cbThisSize;
|
|
}
|
|
|
|
// allocate the new buffer
|
|
TCHAR *pszPrefixAttrs = (TCHAR *) MemAlloc (cbTotalSize);
|
|
if (pszPrefixAttrs == NULL)
|
|
return NULL;
|
|
|
|
// copy the strings over to the new buffer
|
|
pszSrc = (TCHAR *) pszAttrs;
|
|
TCHAR *pszDst = pszPrefixAttrs;
|
|
for (i = 0; i < cAttrs; i++)
|
|
{
|
|
// copy prefix
|
|
lstrcpy (pszDst, &c_szAnyAttrPrefix[0]);
|
|
pszDst += lstrlen (pszDst); // no plus 1
|
|
|
|
// copy name
|
|
lstrcpy (pszDst, pszSrc);
|
|
pszDst += lstrlen (pszDst) + 1;
|
|
pszSrc += lstrlen (pszSrc) + 1;
|
|
|
|
// copy value as needed
|
|
if (fPair)
|
|
{
|
|
lstrcpy (pszDst, pszSrc);
|
|
pszDst += lstrlen (pszDst) + 1;
|
|
pszSrc += lstrlen (pszSrc) + 1;
|
|
}
|
|
}
|
|
|
|
return pszPrefixAttrs;
|
|
}
|
|
|
|
|
|
TCHAR *
|
|
IlsBuildDN (
|
|
TCHAR *pszBaseDN,
|
|
TCHAR *pszC,
|
|
TCHAR *pszO,
|
|
TCHAR *pszCN,
|
|
TCHAR *pszObjectClass )
|
|
{
|
|
MyAssert (MyIsGoodString (pszCN));
|
|
MyAssert (MyIsGoodString (pszObjectClass));
|
|
|
|
static TCHAR s_szC[] = TEXT ("c=");
|
|
static TCHAR s_szO[] = TEXT ("o=");
|
|
static TCHAR s_szCN[] = TEXT ("cn=");
|
|
static TCHAR s_szObjectClass[] = TEXT ("objectClass=");
|
|
static TCHAR s_szDelimiter[] = TEXT (", ");
|
|
enum { C_LENGTH = 2 };
|
|
enum { O_LENGTH = 2 };
|
|
enum { CN_LENGTH = 3 };
|
|
enum { OBJECTCLASS_LENGTH = 12 };
|
|
enum { DELIMITER_LENGTH = 2 };
|
|
|
|
ULONG cchDN = 1;
|
|
BOOL fInBaseDN;
|
|
|
|
ASSERT(MyIsGoodString(pszC));
|
|
|
|
cchDN += lstrlen (pszC) + DELIMITER_LENGTH + C_LENGTH;
|
|
|
|
if (MyIsGoodString (pszBaseDN))
|
|
{
|
|
fInBaseDN = TRUE;
|
|
|
|
cchDN += lstrlen (pszBaseDN) + DELIMITER_LENGTH;
|
|
}
|
|
else
|
|
{
|
|
fInBaseDN = FALSE;
|
|
|
|
if (MyIsGoodString (pszO))
|
|
cchDN += lstrlen (pszO) + DELIMITER_LENGTH + O_LENGTH;
|
|
}
|
|
|
|
if (MyIsGoodString (pszCN))
|
|
cchDN += lstrlen (pszCN) + CN_LENGTH;
|
|
|
|
if (MyIsGoodString (pszObjectClass))
|
|
cchDN += lstrlen (pszObjectClass) + DELIMITER_LENGTH + OBJECTCLASS_LENGTH;
|
|
|
|
TCHAR *pszDN = (TCHAR *) MemAlloc (cchDN * sizeof (TCHAR));
|
|
if (pszDN != NULL)
|
|
{
|
|
TCHAR *psz = pszDN;
|
|
psz[0] = TEXT ('\0');
|
|
|
|
if (MyIsGoodString (pszC))
|
|
{
|
|
lstrcpy (psz, &s_szC[0]);
|
|
psz += lstrlen (psz);
|
|
lstrcpy (psz, pszC);
|
|
psz += lstrlen (psz);
|
|
}
|
|
|
|
if (fInBaseDN)
|
|
{
|
|
if (psz != pszDN)
|
|
{
|
|
lstrcpy (psz, &s_szDelimiter[0]);
|
|
psz += lstrlen (psz);
|
|
}
|
|
|
|
lstrcpy (psz, pszBaseDN);
|
|
psz += lstrlen (psz);
|
|
}
|
|
else
|
|
{
|
|
if (MyIsGoodString (pszO))
|
|
{
|
|
if (psz != pszDN)
|
|
{
|
|
lstrcpy (psz, &s_szDelimiter[0]);
|
|
psz += lstrlen (psz);
|
|
}
|
|
|
|
lstrcpy (psz, &s_szO[0]);
|
|
psz += lstrlen (psz);
|
|
lstrcpy (psz, pszO);
|
|
psz += lstrlen (psz);
|
|
}
|
|
}
|
|
|
|
if (MyIsGoodString (pszCN))
|
|
{
|
|
if (psz != pszDN)
|
|
{
|
|
lstrcpy (psz, &s_szDelimiter[0]);
|
|
psz += lstrlen (psz);
|
|
}
|
|
|
|
lstrcpy (psz, &s_szCN[0]);
|
|
psz += lstrlen (psz);
|
|
lstrcpy (psz, pszCN);
|
|
psz += lstrlen (psz);
|
|
}
|
|
|
|
if (MyIsGoodString (pszObjectClass))
|
|
{
|
|
if (psz != pszDN)
|
|
{
|
|
lstrcpy (psz, &s_szDelimiter[0]);
|
|
psz += lstrlen (psz);
|
|
}
|
|
|
|
lstrcpy (psz, &s_szObjectClass[0]);
|
|
psz += lstrlen (psz);
|
|
lstrcpy (psz, pszObjectClass);
|
|
psz += lstrlen (psz);
|
|
}
|
|
|
|
MyAssert (psz == pszDN + cchDN - 1);
|
|
}
|
|
|
|
return pszDN;
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
IlsCreateAnyAttrsPrefix ( ANY_ATTRS *pAnyAttrs )
|
|
{
|
|
if (pAnyAttrs->cAttrsToAdd != 0)
|
|
{
|
|
MyAssert (pAnyAttrs->pszAttrsToAdd != NULL);
|
|
pAnyAttrs->pszAttrsToAdd = IlsPrefixNameValueArray (
|
|
TRUE,
|
|
pAnyAttrs->cAttrsToAdd,
|
|
(const TCHAR *) pAnyAttrs->pszAttrsToAdd);
|
|
if (pAnyAttrs->pszAttrsToAdd == NULL)
|
|
return ILS_E_MEMORY;
|
|
}
|
|
|
|
if (pAnyAttrs->cAttrsToModify != 0)
|
|
{
|
|
MyAssert (pAnyAttrs->pszAttrsToModify != NULL);
|
|
pAnyAttrs->pszAttrsToModify = IlsPrefixNameValueArray (
|
|
TRUE,
|
|
pAnyAttrs->cAttrsToModify,
|
|
(const TCHAR *) pAnyAttrs->pszAttrsToModify);
|
|
if (pAnyAttrs->pszAttrsToModify == NULL)
|
|
{
|
|
MemFree (pAnyAttrs->pszAttrsToAdd);
|
|
pAnyAttrs->pszAttrsToAdd = NULL;
|
|
return ILS_E_MEMORY;
|
|
}
|
|
}
|
|
|
|
if (pAnyAttrs->cAttrsToRemove != 0)
|
|
{
|
|
MyAssert (pAnyAttrs->pszAttrsToRemove != NULL);
|
|
pAnyAttrs->pszAttrsToRemove = IlsPrefixNameValueArray (
|
|
FALSE,
|
|
pAnyAttrs->cAttrsToRemove,
|
|
(const TCHAR *) pAnyAttrs->pszAttrsToRemove);
|
|
if (pAnyAttrs->pszAttrsToRemove == NULL)
|
|
{
|
|
MemFree (pAnyAttrs->pszAttrsToAdd);
|
|
MemFree (pAnyAttrs->pszAttrsToModify);
|
|
pAnyAttrs->pszAttrsToAdd = NULL;
|
|
pAnyAttrs->pszAttrsToModify = NULL;
|
|
return ILS_E_MEMORY;
|
|
}
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
VOID
|
|
IlsReleaseAnyAttrsPrefix ( ANY_ATTRS *pAnyAttrs )
|
|
{
|
|
MemFree (pAnyAttrs->pszAttrsToAdd);
|
|
MemFree (pAnyAttrs->pszAttrsToModify);
|
|
MemFree (pAnyAttrs->pszAttrsToRemove);
|
|
ZeroMemory (pAnyAttrs, sizeof (*pAnyAttrs));
|
|
}
|
|
|
|
|
|
|
|
|
|
TCHAR **my_ldap_get_values ( LDAP *ld, LDAPMessage *pEntry, TCHAR *pszRetAttrName )
|
|
{
|
|
MyAssert (ld != NULL);
|
|
MyAssert (pEntry != NULL);
|
|
MyAssert (pszRetAttrName != NULL);
|
|
|
|
// Examine the first attribute
|
|
//
|
|
struct berelement *pContext = NULL;
|
|
TCHAR *pszAttrName = ldap_first_attribute (ld, pEntry, &pContext);
|
|
if (My_lstrcmpi (pszAttrName, pszRetAttrName) != 0)
|
|
{
|
|
// Examine the other attributes
|
|
//
|
|
while ((pszAttrName = ldap_next_attribute (ld, pEntry, pContext))
|
|
!= NULL)
|
|
{
|
|
if (My_lstrcmpi (pszAttrName, pszRetAttrName) == 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Get the attribute value if needed
|
|
//
|
|
TCHAR **ppszAttrValue = NULL;
|
|
if (pszAttrName != NULL)
|
|
ppszAttrValue = ldap_get_values (ld, pEntry, pszAttrName);
|
|
|
|
return ppszAttrValue;
|
|
}
|
|
|
|
|
|
ULONG my_ldap_count_1st_entry_attributes ( LDAP *ld, LDAPMessage *pLdapMsg )
|
|
{
|
|
MyAssert (ld != NULL);
|
|
MyAssert (pLdapMsg != NULL);
|
|
|
|
ULONG cAttrs = 0;
|
|
|
|
// there should be only an entry
|
|
ULONG cEntries = ldap_count_entries (ld, pLdapMsg);
|
|
if (cEntries > 0)
|
|
{
|
|
// there should be only one entry
|
|
MyAssert (cEntries == 1);
|
|
|
|
TCHAR *pszAttrName;
|
|
|
|
// get this entry
|
|
LDAPMessage *pEntry = ldap_first_entry (ld, pLdapMsg);
|
|
if (pEntry == NULL)
|
|
{
|
|
MyAssert (FALSE);
|
|
return cAttrs;
|
|
}
|
|
|
|
// examine the first attribute
|
|
struct berelement *pContext = NULL;
|
|
pszAttrName = ldap_first_attribute (ld, pEntry, &pContext);
|
|
if (pszAttrName == NULL)
|
|
{
|
|
MyAssert (FALSE);
|
|
return 0;
|
|
}
|
|
cAttrs = 1;
|
|
|
|
TCHAR **ppszAttrVal;
|
|
ppszAttrVal = ldap_get_values (ld, pEntry, pszAttrName);
|
|
if (ppszAttrVal != NULL)
|
|
ldap_value_free (ppszAttrVal);
|
|
|
|
// step through the others
|
|
while ((pszAttrName = ldap_next_attribute (ld, pEntry, pContext)) != NULL)
|
|
{
|
|
cAttrs++;
|
|
|
|
ppszAttrVal = ldap_get_values (ld, pEntry, pszAttrName);
|
|
if (ppszAttrVal != NULL)
|
|
ldap_value_free (ppszAttrVal);
|
|
}
|
|
} // if cEntries > 0
|
|
|
|
return cAttrs;
|
|
}
|
|
|
|
|