Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
Windows2003-3790/enduser/netmeeting/ulsldap/spnotify.cpp

2831 lines
63 KiB
C++
Raw Permalink Normal View History

First commit
2001-01-01 00:00:00 +01:00
/* ----------------------------------------------------------------------
Module: ULS.DLL (Service Provider)
File: spnotify.cpp
Content: This file contains the notification handlers.
History:
10/15/96 Chu, Lon-Chan [lonchanc]
Created.
Copyright (c) Microsoft Corporation 1996-1997
---------------------------------------------------------------------- */
#include "ulsp.h"
#include "spinc.h"
typedef struct
{
TCHAR *pszName;
TCHAR *pszValue;
}
ATTR_PAIR;
typedef struct
{
ULONG cMaxAttrs;
ULONG cCurrAttrs;
ATTR_PAIR aPairs[1];
}
ATTR_PAIRS;
typedef struct
{
CLIENT_INFO ClientInfo;
ATTR_PAIRS Attrs;
}
CLIENT_INFO_ATTRS;
#ifdef ENABLE_MEETING_PLACE
typedef struct
{
MTG_INFO MtgInfo;
ATTR_PAIRS Attrs;
}
MTG_INFO_ATTRS;
#endif
ULONG
GetUniqueNotifyID ( VOID )
{
// Always positive number
//
if (g_uRespID & 0x80000000UL)
g_uRespID = 1;
return g_uRespID++;
}
BOOL
NotifyGeneric (
HRESULT hrServer,
SP_CResponse *pItem )
{
MyAssert (pItem != NULL);
// Get the pending info
//
RESP_INFO *pInfo = pItem->GetRespInfo ();
MyAssert (pInfo != NULL);
// Do not use the result (pLdapMsg)
//
// Check dependency such as modify/modrdn
//
if (pInfo->uMsgID[0] != INVALID_MSG_ID)
{
// Do we wait for the second result?
// If so, remember the hr from the first result.
//
if (pInfo->uMsgID[1] != INVALID_MSG_ID)
{
// We need two results; the first one just comes in.
// We still need to wait for the second one
//
pInfo->uMsgID[0] = INVALID_MSG_ID;
pInfo->hrDependency = hrServer;
// Don't destroy this item
//
return FALSE;
}
}
else
{
// This is the second result
//
MyAssert (pInfo->uMsgID[1] != INVALID_MSG_ID);
// Propagate the hr from the first result if needed
//
if (pInfo->hrDependency != S_OK)
hrServer = pInfo->hrDependency;
}
// Post the result to the com layer
//
PostMessage (g_hWndNotify, pInfo->uNotifyMsg, pInfo->uRespID, hrServer);
// Destroy this pending item
//
return TRUE;
}
BOOL
NotifyRegister (
HRESULT hrServer,
SP_CResponse *pItem )
{
MyAssert (pItem != NULL);
// Get pending info
//
RESP_INFO *pInfo = pItem->GetRespInfo ();
MyAssert (pInfo != NULL);
// Get the object of user/app/prot/mtg
//
HANDLE hObject = pInfo->hObject;
MyAssert (hObject != NULL);
// Do not use the result (pLdapMsg)
//
// Check dependency such as modify/modrdn
//
if (pInfo->uMsgID[0] != INVALID_MSG_ID)
{
// Do we wait for the second result?
// If so, remember the hr from the first result.
//
if (pInfo->uMsgID[1] != INVALID_MSG_ID)
{
// We need two results; the first one just comes in.
// We still need to wait for the second one
//
pInfo->uMsgID[0] = INVALID_MSG_ID;
pInfo->hrDependency = hrServer;
// Don't destroy this item
//
return FALSE;
}
}
else
{
// This is the second result
//
MyAssert (pInfo->uMsgID[1] != INVALID_MSG_ID);
// Propagate the hr from the first result if needed
//
if (pInfo->hrDependency != S_OK)
hrServer = pInfo->hrDependency;
}
// Notify the object of success/failure
//
SP_CClient *pClient;
SP_CProtocol *pProt;
#ifdef ENABLE_MEETING_PLACE
SP_CMeeting *pMtg;
#endif
if (hrServer != S_OK)
{
// Release the object when failure
//
switch (pInfo->uNotifyMsg)
{
case WM_ILS_REGISTER_CLIENT:
pClient = (SP_CClient *) hObject;
if (pClient->IsValidObject ())
{
pClient->Release ();
}
break;
case WM_ILS_REGISTER_PROTOCOL:
pProt = (SP_CProtocol *) hObject;
if (pProt->IsValidObject ())
{
pProt->Release ();
}
break;
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_REGISTER_MEETING:
pMtg = (SP_CMeeting *) hObject;
if (pMtg->IsValidObject ())
{
pMtg->Release ();
}
break;
#endif
default:
MyAssert (FALSE);
break;
}
}
else
{
// Set as successful registration when success
//
switch (pInfo->uNotifyMsg)
{
case WM_ILS_REGISTER_CLIENT:
pClient = (SP_CClient *) hObject;
if (pClient->IsValidObject ())
{
pClient->SetRegRemotely ();
if (g_pRefreshScheduler != NULL)
{
g_pRefreshScheduler->EnterClientObject (pClient);
}
else
{
MyAssert (FALSE);
}
}
break;
case WM_ILS_REGISTER_PROTOCOL:
pProt = (SP_CProtocol *) hObject;
if (pProt->IsValidObject ())
{
pProt->SetRegRemotely ();
}
break;
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_REGISTER_MEETING:
pMtg = (SP_CMeeting *) hObject;
if (pMtg->IsValidObject ())
{
pMtg->SetRegRemotely ();
if (g_pRefreshScheduler != NULL)
{
g_pRefreshScheduler->EnterMtgObject (pMtg);
}
else
{
MyAssert (FALSE);
}
}
break;
#endif
default:
MyAssert (FALSE);
break;
}
}
// Post the result to the com layer
//
PostMessage (g_hWndNotify, pInfo->uNotifyMsg, pInfo->uRespID, (LPARAM) hrServer);
// Destroy this pending item
//
return TRUE;
}
/* =========== ENUMERATION ============ */
typedef struct
{
ULONG uEnumUsers; // WM_ILS_ENUM_USERS, WM_ILS_ENUM_USERINFOS, or 0
ULONG cItems;
ULONG cbEntrySize;
BYTE bData[8]; // data starting from here
}
ENUM_LIST;
extern HRESULT CacheEnumInfos ( ULONG uNotifyMsg, LDAP *ld, LDAPMessage *pEntry, VOID *p );
extern VOID BuildEnumObjectNames ( LDAP_ENUM *pEnum, ENUM_LIST *pEnumList );
extern VOID BuildEnumClientInfos ( LDAP_ENUM *pEnum, ENUM_LIST *pEnumList );
extern VOID SizeEnumClientInfos ( ULONG *pcbTotalSize, CLIENT_INFO_ATTRS *pcia );
extern VOID TotalSizeEnumObjectNames ( ULONG *pcbTotalSize, ULONG cEntries, TCHAR **appszObjectNames[] );
extern VOID FreeStdAttrCache ( TCHAR *apszStdAttrValues[], ULONG cStdAttrs );
extern VOID FreeAttrPairArrayCache ( ATTR_PAIR aAttrPair[], ULONG cPairs );
extern VOID CacheAnyAttrNamesInAttrPairs ( ULONG cNames, TCHAR *pszSrcNameList, ATTR_PAIR aAttrPairs[] );
#ifdef ENABLE_MEETING_PLACE
extern VOID BuildEnumMtgInfos ( LDAP_ENUM *pEnum, ENUM_LIST *pEnumList );
extern VOID SizeEnumMtgInfos ( ULONG *pcbTotalSize, MTG_INFO_ATTRS *pmia );
#endif
BOOL NotifyEnumX (
ULONG uEnumType,
HRESULT hrServer,
SP_CResponse *pItem,
TCHAR *pszRetAttrName ) // returned attribute's name
{
MyAssert (pItem != NULL);
#if defined (DEBUG) || defined (_DEBUG)
// Consistency checks
//
switch (uEnumType)
{
case WM_ILS_ENUM_CLIENTS:
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_ENUM_MEETINGS:
#endif
MyAssert (pszRetAttrName != NULL && *pszRetAttrName != TEXT ('\0'));
break;
case WM_ILS_ENUM_CLIENTINFOS:
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_ENUM_MEETINGINFOS:
#endif
MyAssert (pszRetAttrName == NULL);
break;
default:
MyAssert (FALSE);
break;
}
#endif
// Get pending info
//
RESP_INFO *pInfo = pItem->GetRespInfo ();
MyAssert (pInfo != NULL);
// Initialize minimal info
//
LDAP_ENUM *pEnum = NULL;
ENUM_LIST *pEnumList = NULL;
// If error, simply report the error
//
if (hrServer != S_OK)
goto MyExit;
// Get the ldap result
//
LDAPMessage *pLdapMsg;
pLdapMsg = pItem->GetResult ();
if (pLdapMsg == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_POINTER;
goto MyExit;
}
// Get ld
//
LDAP *ld;
ld = pItem->GetLd ();
if (ld == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_HANDLE;
goto MyExit;
}
// Initialize the total size of LDAP_ENUM
//
ULONG cbTotalSize;
cbTotalSize = sizeof (LDAP_ENUM) + // the minimal info
sizeof (TCHAR); // the last null terminator
// Let's get the count of entries in this result set
//
ULONG cEntries, i;
cEntries = ldap_count_entries (ld, pLdapMsg);
// Return now if there is nothing to handle
//
if (cEntries <= 0)
{
// I want to make sure this case happens or not
//
MyAssert (cEntries == 0);
// Simply return without deleting this pending item
//
return FALSE;
}
// In the following, we only deal with the case (cEntries > 0)
//
// Calculate enum list size
//
ULONG cbEntrySize , cbSizeEnumList;
switch (uEnumType)
{
case WM_ILS_ENUM_CLIENTINFOS:
cbEntrySize = sizeof (CLIENT_INFO_ATTRS) +
pInfo->cAnyAttrs * sizeof (ATTR_PAIR);
break;
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_ENUM_MEETINGINFOS:
cbEntrySize = sizeof (MTG_INFO_ATTRS) +
pInfo->cAnyAttrs * sizeof (ATTR_PAIR);
break;
#endif
default:
cbEntrySize = sizeof (TCHAR **);
break;
}
cbSizeEnumList = sizeof (ENUM_LIST) + cEntries * cbEntrySize;
// Allocate the enum list that is a temporary cache
// for all attributes from wldap32.dll
//
pEnumList = (ENUM_LIST *) MemAlloc (cbSizeEnumList);
if (pEnumList == NULL)
{
// Fails probably due to insane cbSizeEnumList
//
MyAssert (FALSE);
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Fill in enum list
//
pEnumList->uEnumUsers = uEnumType;
pEnumList->cItems = cEntries;
pEnumList->cbEntrySize = cbEntrySize;
// Fill in names of extended attributes if needed
//
if (pInfo->cAnyAttrs > 0)
{
switch (uEnumType)
{
case WM_ILS_ENUM_CLIENTINFOS:
for (i = 0; i < cEntries; i++)
{
CLIENT_INFO_ATTRS *p = (CLIENT_INFO_ATTRS *) (&(pEnumList->bData[0]) + i * cbEntrySize);
p->Attrs.cMaxAttrs = pInfo->cAnyAttrs;
CacheAnyAttrNamesInAttrPairs ( pInfo->cAnyAttrs,
pInfo->pszAnyAttrNameList,
&(p->Attrs.aPairs[0]));
}
break;
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_ENUM_MEETINGINFOS:
for (i = 0; i < cEntries; i++)
{
MTG_INFO_ATTRS *p = (MTG_INFO_ATTRS *) (&(pEnumList->bData[0]) + i * cbEntrySize);
p->Attrs.cMaxAttrs = pInfo->cAnyAttrs;
CacheAnyAttrNamesInAttrPairs ( pInfo->cAnyAttrs,
pInfo->pszAnyAttrNameList,
&(p->Attrs.aPairs[0]));
}
break;
#endif
default:
break;
}
}
// Get the first entry
//
LDAPMessage *pEntry;
pEntry = ldap_first_entry (ld, pLdapMsg);
if (pEntry == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Cache the attributes in the first entry
//
TCHAR ***appszObjectNames = NULL;
switch (uEnumType)
{
case WM_ILS_ENUM_CLIENTINFOS:
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_ENUM_MEETINGINFOS:
#endif
hrServer = CacheEnumInfos (uEnumType, ld, pEntry, (VOID *) &(pEnumList->bData[0]));
if (hrServer != S_OK)
{
MyAssert (FALSE);
goto MyExit;
}
break;
default:
appszObjectNames = (TCHAR ***) &(pEnumList->bData[0]);
appszObjectNames[0] = my_ldap_get_values (ld, pEntry, pszRetAttrName);
if (appszObjectNames[0] == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_MEMORY;
goto MyExit;
}
break;
} // switch (uEnumType)
// Loop through the other entries
//
for (i = 1; i < cEntries; i++)
{
// Next entry, please
//
pEntry = ldap_next_entry (ld, pEntry);
if (pEntry == NULL)
{
MyAssert (FALSE);
// Failed, adjust the count to return partial result
//
pEnumList->cItems = cEntries = i;
break;
}
// Cache the attributes in the subsequent entries
//
switch (uEnumType)
{
case WM_ILS_ENUM_CLIENTINFOS:
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_ENUM_MEETINGINFOS:
#endif
hrServer = CacheEnumInfos (uEnumType, ld, pEntry, (CLIENT_INFO_ATTRS *)
(&(pEnumList->bData[0]) + i * cbEntrySize));
if (hrServer != S_OK)
{
MyAssert (FALSE);
goto MyExit;
}
break;
default:
appszObjectNames[i] = my_ldap_get_values (ld, pEntry, pszRetAttrName);
if (appszObjectNames[i] == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_MEMORY;
goto MyExit;
}
break;
} // switch (uEnumType)
} // for (i = 1; i < cEntries; i++)
// We just cache all the attribute names and values.
// Now, we need to calculate the total size of the return buffer.
//
// Calculate the total size of the LDAP_ENUM structure...
//
switch (uEnumType)
{
case WM_ILS_ENUM_CLIENTINFOS:
for (i = 0; i < cEntries; i++)
{
SizeEnumClientInfos (&cbTotalSize, (CLIENT_INFO_ATTRS *)
(&(pEnumList->bData[0]) + i * cbEntrySize));
}
break;
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_ENUM_MEETINGINFOS:
for (i = 0; i < cEntries; i++)
{
SizeEnumMtgInfos (&cbTotalSize, (MTG_INFO_ATTRS *)
(&(pEnumList->bData[0]) + i * cbEntrySize));
}
break;
#endif
default:
TotalSizeEnumObjectNames (&cbTotalSize, cEntries, &(appszObjectNames[0]));
break;
} // switch (uEnumType)
// Allocate the returned LDAP_ENUM structure
//
pEnum = (LDAP_ENUM *) MemAlloc (cbTotalSize);
if (pEnum == NULL)
{
// Fails probably due to insane cbTotalSize
//
MyAssert (FALSE);
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Fill in LDAP_ENUM common fields
//
pEnum->uSize = sizeof (*pEnum);
pEnum->hResult = hrServer;
pEnum->cItems = cEntries;
pEnum->uOffsetItems = sizeof (*pEnum);
// Fill in LDAP_ENUM items
//
switch (uEnumType)
{
case WM_ILS_ENUM_CLIENTINFOS:
BuildEnumClientInfos (pEnum, pEnumList);
break;
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_ENUM_MEETINGINFOS:
BuildEnumMtgInfos (pEnum, pEnumList);
break;
#endif
default:
BuildEnumObjectNames (pEnum, pEnumList);
break;
}
MyAssert (hrServer == S_OK);
MyExit:
// Free the temporary cache
//
if (pEnumList != NULL)
{
switch (uEnumType)
{
case WM_ILS_ENUM_CLIENTINFOS:
for (i = 0; i < pEnumList->cItems; i++)
{
CLIENT_INFO_ATTRS *p = (CLIENT_INFO_ATTRS *)
(&(pEnumList->bData[0]) + i * cbEntrySize);
// Free standard attributes
//
FreeStdAttrCache (&(p->ClientInfo.apszStdAttrValues[0]), COUNT_ENUM_DIR_CLIENT_INFO);
// Free extended attributes
//
FreeAttrPairArrayCache (&(p->Attrs.aPairs[0]), pInfo->cAnyAttrs);
}
break;
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_ENUM_MEETINGINFOS:
for (i = 0; i < pEnumList->cItems; i++)
{
MTG_INFO_ATTRS *p = (MTG_INFO_ATTRS *)
(&(pEnumList->bData[0]) + i * cbEntrySize);
// Free standard attributes
//
FreeStdAttrCache (&(p->MtgInfo.apszStdAttrValues[0]), COUNT_ENUM_DIRMTGINFO);
// Free extended attributes
//
FreeAttrPairArrayCache (&(p->Attrs.aPairs[0]), pInfo->cAnyAttrs);
}
break;
#endif
default:
for (i = 0; i < pEnumList->cItems; i++)
{
if (appszObjectNames && appszObjectNames[i] != NULL)
ldap_value_free (appszObjectNames[i]);
}
break;
}
MemFree (pEnumList);
} // if
// Clean up if failure
//
if (hrServer != S_OK)
{
// Special treatment of enum termination for wldap32.dll
//
if (hrServer == ILS_E_PARAMETER)
{
MemFree (pEnum);
pEnum = NULL; // enum termination
}
else
{
// Make sure we have at least LDAP_ENUM buffer to return
//
if (pEnum != NULL)
ZeroMemory (pEnum, sizeof (*pEnum));
else
pEnum = (LDAP_ENUM *) MemAlloc (sizeof (LDAP_ENUM));
// Set up the LDAP_ENUM info
//
if (pEnum != NULL)
{
pEnum->uSize = sizeof (*pEnum);
pEnum->hResult = hrServer;
}
}
// Force to delete this pending item
//
cEntries = 0;
}
// Post a message to the com layer of this enum result
//
PostMessage (g_hWndNotify, pInfo->uNotifyMsg, pInfo->uRespID, (LPARAM) pEnum);
return (cEntries == 0);
}
BOOL
NotifyEnumClients (
HRESULT hrServer,
SP_CResponse *pItem )
{
return NotifyEnumX (WM_ILS_ENUM_CLIENTS,
hrServer,
pItem,
STR_CLIENT_CN);
}
BOOL
NotifyEnumClientInfos (
HRESULT hrServer,
SP_CResponse *pItem )
{
return NotifyEnumX (WM_ILS_ENUM_CLIENTINFOS,
hrServer,
pItem,
NULL);
}
BOOL NotifyEnumProts ( HRESULT hrServer, SP_CResponse *pItem )
{
MyAssert (pItem != NULL);
// Clean up locals
//
LDAP_ENUM *pEnum = NULL;
TCHAR **apszProtNames = NULL;
// Get the pending info
//
RESP_INFO *pInfo = pItem->GetRespInfo ();
MyAssert (pInfo != NULL);
// If error, simply report the error
//
if (hrServer != S_OK)
goto MyExit;
// Get the ldap result
//
LDAPMessage *pLdapMsg;
pLdapMsg = pItem->GetResult ();
MyAssert (pLdapMsg != NULL);
if (pLdapMsg == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_POINTER;
goto MyExit;
}
// Get ld
//
LDAP *ld;
ld = pItem->GetLd ();
if (ld == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_HANDLE;
goto MyExit;
}
// Get the array
//
apszProtNames = my_ldap_get_values (ld, pLdapMsg, STR_PROT_NAME);
if (apszProtNames == NULL)
{
hrServer = ILS_E_NO_SUCH_OBJECT;
goto MyExit;
}
// Initialize minimal info size
//
ULONG cbEnumList;
cbEnumList = sizeof (LDAP_ENUM) + // the minimal info
sizeof (TCHAR); // the last null terminator
// Let's see how many strings in the array
//
ULONG cNames;
for (cNames = 0; apszProtNames[cNames] != NULL; cNames++)
{
cbEnumList += (lstrlen (apszProtNames[cNames]) + 1) * sizeof (TCHAR);
}
// Allocate the enum structure
//
pEnum = (LDAP_ENUM *) MemAlloc (cbEnumList);
if (pEnum == NULL)
{
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Fill in header
//
pEnum->uSize = sizeof (*pEnum);
pEnum->hResult = hrServer;
pEnum->cItems = cNames;
pEnum->uOffsetItems = sizeof (*pEnum);
// Fill in name strings
//
ULONG i;
TCHAR *pszName;
pszName = (TCHAR *) (pEnum + 1);
for (i = 0; i < cNames; i++)
{
My_lstrcpy (pszName, apszProtNames[i]);
pszName += lstrlen (pszName) + 1;
}
MyAssert (hrServer == S_OK);
MyExit:
// Free the array if allocated
//
if (apszProtNames != NULL)
ldap_value_free (apszProtNames);
// Post messages back to the COM layer
//
if (hrServer != S_OK)
{
// Make sure we have at least LDAP_ENUM buffer to return
//
if (pEnum != NULL)
ZeroMemory (pEnum, sizeof (*pEnum));
else
pEnum = (LDAP_ENUM *) MemAlloc (sizeof (LDAP_ENUM));
// Set up the LDAP_ENUM info
//
if (pEnum != NULL)
{
pEnum->uSize = sizeof (*pEnum);
pEnum->hResult = hrServer;
}
}
// Post a message to the com layer of this enum result
//
PostMessage (g_hWndNotify, pInfo->uNotifyMsg, pInfo->uRespID, (LPARAM) pEnum);
// Terminate enumeration if success
//
if (hrServer == S_OK)
{
PostMessage (g_hWndNotify, pInfo->uNotifyMsg, pInfo->uRespID, (LPARAM) NULL);
}
// Destroy this pending item
//
return TRUE;
}
#ifdef ENABLE_MEETING_PLACE
BOOL NotifyEnumMtgs ( HRESULT hrServer, SP_CResponse *pItem )
{
return NotifyEnumX (WM_ILS_ENUM_MEETINGS,
hrServer,
pItem,
STR_MTG_NAME);
}
#endif
#ifdef ENABLE_MEETING_PLACE
BOOL NotifyEnumMtgInfos ( HRESULT hrServer, SP_CResponse *pItem )
{
return NotifyEnumX (WM_ILS_ENUM_MEETINGINFOS,
hrServer,
pItem,
NULL);
}
#endif
#ifdef ENABLE_MEETING_PLACE
BOOL NotifyEnumAttendees ( HRESULT hrServer, SP_CResponse *pItem )
{
MyAssert (pItem != NULL);
// Get pending info
//
RESP_INFO *pInfo = pItem->GetRespInfo ();
MyAssert (pInfo != NULL);
// Initialize minimal info
//
LDAP_ENUM *pEnum = NULL;
// If error, simply report the error
//
if (hrServer != S_OK)
goto MyExit;
// Get the ldap result
//
LDAPMessage *pLdapMsg;
pLdapMsg = pItem->GetResult ();
if (pLdapMsg == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_POINTER;
goto MyExit;
}
// Get ld
//
LDAP *ld;
ld = pItem->GetLd ();
if (ld == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_HANDLE;
goto MyExit;
}
// Initialize the total size of LDAP_ENUM
//
ULONG cbTotalSize;
cbTotalSize = sizeof (LDAP_ENUM) + // the minimal info
sizeof (TCHAR); // the last null terminator
// Get the first entry that we care about
//
LDAPMessage *pEntry;
pEntry = ldap_first_entry (ld, pLdapMsg);
if (pEntry == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Get the Members attribute
//
ULONG cItems;
cItems = 0;
TCHAR **apszMembers;
apszMembers = my_ldap_get_values (ld, pEntry, STR_MTG_MEMBERS);
if (apszMembers != NULL)
{
// Find out how many attendees
//
for (TCHAR **ppsz = apszMembers; *ppsz != NULL; ppsz++)
{
cItems++;
cbTotalSize += (lstrlen (*ppsz) + 1) * sizeof (TCHAR);
}
}
// Allocate the returned LDAP_ENUM structure
//
pEnum = (LDAP_ENUM *) MemAlloc (cbTotalSize);
if (pEnum == NULL)
{
// Fails probably due to insane cbTotalSize
//
MyAssert (FALSE);
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Fill in LDAP_ENUM common fields
//
pEnum->uSize = sizeof (*pEnum);
pEnum->hResult = hrServer;
pEnum->cItems = cItems;
pEnum->uOffsetItems = sizeof (*pEnum);
// Fill in LDAP_ENUM items
//
TCHAR *pszDst;
ULONG i;
pszDst = (TCHAR *) (pEnum + 1);
for (i = 0; i < cItems; i++)
{
lstrcpy (pszDst, apszMembers[i]);
pszDst += lstrlen (pszDst) + 1;
}
MyAssert (hrServer == S_OK);
MyExit:
// Clean up if failure
//
if (hrServer != S_OK)
{
// Make sure we have at least LDAP_ENUM buffer to return
//
if (pEnum != NULL)
ZeroMemory (pEnum, sizeof (*pEnum));
else
pEnum = (LDAP_ENUM *) MemAlloc (sizeof (LDAP_ENUM));
// Fill in the minimal info
//
if (pEnum != NULL)
{
pEnum->uSize = sizeof (*pEnum);
pEnum->hResult = hrServer;
}
}
// Post a message to the com layer of this enum result
//
PostMessage (g_hWndNotify, pInfo->uNotifyMsg, pInfo->uRespID, (LPARAM) pEnum);
// Delete this pending item
//
return TRUE;
}
#endif // ENABLE_MEETING_PLACE
VOID CacheEnumClientInfoAttr (
CLIENT_INFO_ATTRS *puia,
TCHAR *pszAttrName,
TCHAR **ppszAttrValue )
{
ULONG i;
// See if this attribute is arbitrary?
//
if (IlsIsAnyAttrName (pszAttrName) != NULL)
{
// Deal with extended attributes
//
for (i = 0; i < puia->Attrs.cMaxAttrs; i++)
{
if (My_lstrcmpi (pszAttrName, puia->Attrs.aPairs[i].pszName) == 0)
{
puia->Attrs.aPairs[i].pszValue = (TCHAR *) ppszAttrValue;
break;
}
}
}
else
{
// Deal with standard attributes
//
for (i = 0; i < COUNT_ENUM_DIR_CLIENT_INFO; i++)
{
if (My_lstrcmpi (pszAttrName, c_apszClientStdAttrNames[i]) == 0)
{
puia->ClientInfo.apszStdAttrValues[i] = (TCHAR *) ppszAttrValue;
break;
}
}
}
}
#ifdef ENABLE_MEETING_PLACE
VOID CacheEnumMtgInfoAttr (
MTG_INFO_ATTRS *pmia,
TCHAR *pszAttrName,
TCHAR **ppszAttrValue )
{
ULONG i;
// See if this attribute is arbitrary?
//
if (IlsIsAnyAttrName (pszAttrName) != NULL)
{
// Deal with extended attributes
//
for (i = 0; i < pmia->Attrs.cMaxAttrs; i++)
{
if (My_lstrcmpi (pszAttrName, pmia->Attrs.aPairs[i].pszName) == 0)
{
pmia->Attrs.aPairs[i].pszValue = (TCHAR *) ppszAttrValue;
break;
}
}
}
else
{
// Deal with standard attributes
//
for (i = 0; i < COUNT_ENUM_DIRMTGINFO; i++)
{
if (My_lstrcmpi (pszAttrName, c_apszMtgStdAttrNames[i]) == 0)
{
pmia->MtgInfo.apszStdAttrValues[i] = (TCHAR *) ppszAttrValue;
break;
}
}
}
}
#endif // ENABLE_MEETING_PLACE
HRESULT CacheEnumInfos (
ULONG uNotifyMsg,
LDAP *ld,
LDAPMessage *pEntry,
VOID *p )
{
MyAssert (ld != NULL);
MyAssert (pEntry != NULL);
MyAssert (p != NULL);
struct berelement *pContext = NULL;
// Examine the first attribute
//
TCHAR *pszAttrName = ldap_first_attribute (ld, pEntry, &pContext);
TCHAR **ppszAttrValue = ldap_get_values (ld, pEntry, pszAttrName);
if (ppszAttrValue == NULL)
return ILS_E_MEMORY;
// Cache the first attribute
//
switch (uNotifyMsg)
{
case WM_ILS_ENUM_CLIENTINFOS:
CacheEnumClientInfoAttr ( (CLIENT_INFO_ATTRS *) p,
pszAttrName, ppszAttrValue);
break;
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_ENUM_MEETINGINFOS:
CacheEnumMtgInfoAttr ( (MTG_INFO_ATTRS *) p,
pszAttrName, ppszAttrValue);
break;
#endif
default:
MyAssert (FALSE);
break;
}
// Step through the others
//
while ((pszAttrName = ldap_next_attribute (ld, pEntry, pContext))
!= NULL)
{
// Examine the other attributes one by one
//
ppszAttrValue = ldap_get_values (ld, pEntry, pszAttrName);
if (ppszAttrValue == NULL)
return ILS_E_MEMORY;
// Cache the other attributes one by one
//
switch (uNotifyMsg)
{
case WM_ILS_ENUM_CLIENTINFOS:
CacheEnumClientInfoAttr ( (CLIENT_INFO_ATTRS *) p,
pszAttrName, ppszAttrValue);
break;
#ifdef ENABLE_MEETING_PLACE
case WM_ILS_ENUM_MEETINGINFOS:
CacheEnumMtgInfoAttr ( (MTG_INFO_ATTRS *) p,
pszAttrName, ppszAttrValue);
break;
#endif
default:
MyAssert (FALSE);
break;
}
}
return S_OK;
}
VOID
BuildEnumObjectNames (
LDAP_ENUM *pEnum,
ENUM_LIST *pEnumList )
{
MyAssert (pEnum != NULL);
MyAssert (pEnumList != NULL);
ULONG cEntries = pEnum->cItems;
// appszObjectNames are an array of names from server
//
TCHAR *pszName = (TCHAR *) (pEnum + 1);
TCHAR ***appszObjectNames = (TCHAR ***) &(pEnumList->bData[0]);
for (ULONG i = 0; i < cEntries; i++)
{
TCHAR **ppsz = appszObjectNames[i];
if (ppsz != NULL && *ppsz != NULL)
{
My_lstrcpy (pszName, *ppsz);
pszName += lstrlen (pszName) + 1;
}
else
{
*pszName++ = TEXT ('\0'); // empty strings
}
}
}
VOID
BuildEnumClientInfos (
LDAP_ENUM *pEnum,
ENUM_LIST *pEnumList )
{
MyAssert (pEnum != NULL);
MyAssert (pEnumList != NULL);
ULONG i, j;
ULONG cEntries = pEnumList->cItems;
ULONG cbEntrySize = pEnumList->cbEntrySize;
LDAP_CLIENTINFO *plci = (LDAP_CLIENTINFO *) (pEnum + 1);
TCHAR *pszStringBuffer = (TCHAR *) (plci + cEntries);
TCHAR **ppsz;
CLIENT_INFO_ATTRS *p;
ULONG cAttrs;
// Loop through all entries
//
for (i = 0; i < cEntries; i++, plci++)
{
// Get to cached structure
//
p = (CLIENT_INFO_ATTRS *) (&(pEnumList->bData[0]) + i * cbEntrySize);
// Set the size of LDAP_USERINFO
//
plci->uSize = sizeof (*plci);
// Copy the User Name if needed
//
ppsz = (TCHAR **) p->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_CN];
if (ppsz != NULL)
{
plci->uOffsetCN = (ULONG)((ULONG_PTR) pszStringBuffer - (ULONG_PTR) plci);
My_lstrcpy (pszStringBuffer, *ppsz);
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy the First Name if needed
//
ppsz = (TCHAR **) p->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_FIRST_NAME];
if (ppsz != NULL)
{
plci->uOffsetFirstName = (ULONG)((ULONG_PTR) pszStringBuffer - (ULONG_PTR) plci);
My_lstrcpy (pszStringBuffer, *ppsz);
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy the Last Name if needed
//
ppsz = (TCHAR **) p->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_LAST_NAME];
if (ppsz != NULL)
{
plci->uOffsetLastName = (ULONG)((ULONG_PTR) pszStringBuffer - (ULONG_PTR) plci);
My_lstrcpy (pszStringBuffer, *ppsz);
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy the Email Name if needed
//
ppsz = (TCHAR **) p->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_EMAIL_NAME];
if (ppsz != NULL)
{
plci->uOffsetEMailName = (ULONG)((ULONG_PTR) pszStringBuffer - (ULONG_PTR) plci);
My_lstrcpy (pszStringBuffer, *ppsz);
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy the City Name if needed
//
ppsz = (TCHAR **) p->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_CITY_NAME];
if (ppsz != NULL)
{
plci->uOffsetCityName = (ULONG)((ULONG_PTR) pszStringBuffer - (ULONG_PTR) plci);
My_lstrcpy (pszStringBuffer, *ppsz);
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy the Country Name if needed
//
ppsz = (TCHAR **) p->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_C];
if (ppsz != NULL)
{
plci->uOffsetCountryName = (ULONG)((ULONG_PTR) pszStringBuffer - (ULONG_PTR) plci);
My_lstrcpy (pszStringBuffer, *ppsz);
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy the Comment Name if needed
//
ppsz = (TCHAR **) p->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_COMMENT];
if (ppsz != NULL)
{
plci->uOffsetComment = (ULONG)((ULONG_PTR) pszStringBuffer - (ULONG_PTR) plci);
My_lstrcpy (pszStringBuffer, *ppsz);
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy the IP Address if needed
//
ppsz = (TCHAR **) p->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_IP_ADDRESS];
if (ppsz != NULL)
{
plci->uOffsetIPAddress = (ULONG)((ULONG_PTR) pszStringBuffer - (ULONG_PTR) plci);
GetIPAddressString (pszStringBuffer, GetStringLong (*ppsz));
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy the Flags if needed
//
ppsz = (TCHAR **) p->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_FLAGS];
if (ppsz != NULL)
{
plci->dwFlags = (*ppsz != NULL) ? GetStringLong (*ppsz) :
INVALID_USER_FLAGS;
}
// Copy extended attributes if needed
//
plci->cAttrsReturned = cAttrs = p->Attrs.cMaxAttrs;
plci->uOffsetAttrsReturned = (ULONG)((ULONG_PTR) pszStringBuffer - (ULONG_PTR) plci);
for (j = 0; j < cAttrs; j++)
{
// Extended attribute name
//
My_lstrcpy (pszStringBuffer, IlsSkipAnyAttrNamePrefix (
(const TCHAR *) p->Attrs.aPairs[j].pszName));
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
// Extended attribute value
//
ppsz = (TCHAR **) p->Attrs.aPairs[j].pszValue;
if (ppsz != NULL)
{
My_lstrcpy (pszStringBuffer, *ppsz);
}
else
{
ASSERT(FALSE);
}
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
} // for j
} // for i
}
#ifdef ENABLE_MEETING_PLACE
VOID BuildEnumMtgInfos (
LDAP_ENUM *pEnum,
ENUM_LIST *pEnumList )
{
MyAssert (pEnum != NULL);
MyAssert (pEnumList != NULL);
ULONG i, j;
ULONG cEntries = pEnumList->cItems;
ULONG cbEntrySize = pEnumList->cbEntrySize;
LDAP_MEETINFO *plmi = (LDAP_MEETINFO *) (pEnum + 1);
TCHAR *pszStringBuffer = (TCHAR *) (plmi + cEntries);
TCHAR **ppsz;
MTG_INFO_ATTRS *p;
ULONG cAttrs;
// Loop through all entries
//
for (i = 0; i < cEntries; i++, plmi++)
{
// Get to the cache structure
//
p = (MTG_INFO_ATTRS *) (&(pEnumList->bData[0]) + i * cbEntrySize);
// Set the size of LDAP_MEETINFO
//
plmi->uSize = sizeof (*plmi);
// Copy the Meeting Name if needed
//
ppsz = (TCHAR **) p->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_CN];
if (ppsz != NULL)
{
plmi->uOffsetMeetingPlaceID = (ULONG) pszStringBuffer - (ULONG) plmi;
My_lstrcpy (pszStringBuffer, *ppsz);
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy the Meeting Type if needed
//
ppsz = (TCHAR **) p->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_MTG_TYPE];
if (ppsz != NULL)
{
plmi->lMeetingPlaceType = (*ppsz != NULL) ? GetStringLong (*ppsz) :
INVALID_MEETING_TYPE;
}
// Copy the Attendee Type if needed
//
ppsz = (TCHAR **) p->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_MEMBER_TYPE];
if (ppsz != NULL)
{
plmi->lAttendeeType = (*ppsz != NULL) ? GetStringLong (*ppsz) :
INVALID_ATTENDEE_TYPE;
}
// Copy the Description if needed
//
ppsz = (TCHAR **) p->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_DESCRIPTION];
if (ppsz != NULL)
{
plmi->uOffsetDescription = (ULONG) pszStringBuffer - (ULONG) plmi;
My_lstrcpy (pszStringBuffer, *ppsz);
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy the Host Name if needed
//
ppsz = (TCHAR **) p->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_HOST_NAME];
if (ppsz != NULL)
{
plmi->uOffsetHostName = (ULONG) pszStringBuffer - (ULONG) plmi;
My_lstrcpy (pszStringBuffer, *ppsz);
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy the Host IP Address if needed
//
ppsz = (TCHAR **) p->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_IP_ADDRESS];
if (ppsz != NULL)
{
plmi->uOffsetHostIPAddress = (ULONG) pszStringBuffer - (ULONG) plmi;
GetIPAddressString (pszStringBuffer, GetStringLong (*ppsz));
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
}
// Copy extended attributes if needed
//
plmi->cAttrsReturned = cAttrs = p->Attrs.cMaxAttrs;
plmi->uOffsetAttrsReturned = (ULONG) pszStringBuffer - (ULONG) plmi;
for (j = 0; j < cAttrs; j++)
{
// Extended attribute name
//
My_lstrcpy (pszStringBuffer, IlsSkipAnyAttrNamePrefix (
(const TCHAR *) p->Attrs.aPairs[j].pszName));
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
// Extended attribute value
//
ppsz = (TCHAR **) p->Attrs.aPairs[j].pszValue;
My_lstrcpy (pszStringBuffer, *ppsz);
pszStringBuffer += lstrlen (pszStringBuffer) + 1;
} // for j
} // for i
}
#endif // ENABLE_MEETING_PLACE
VOID TotalSizeEnumObjectNames (
ULONG *pcbTotalSize,
ULONG cEntries,
TCHAR **appszObjectNames[] )
{
ULONG i, cbThisSize;
TCHAR **ppsz;
// Loop through all the entries and compute the total size
//
for (i = 0; i < cEntries; i++)
{
ppsz = appszObjectNames[i];
// Calcualte the attribute string length
//
cbThisSize = 1;
if (ppsz != NULL && *ppsz != NULL)
cbThisSize += My_lstrlen (*ppsz);
// Convert string length to string size
//
cbThisSize *= sizeof (TCHAR);
// Add up this entry size
//
// lonchanc: BUGS BUGS the size is wrong. need to figure out the exact size
*pcbTotalSize += sizeof (LDAP_CLIENTINFO) + cbThisSize;
}
}
VOID SizeEnumClientInfos (
ULONG *pcbTotalSize,
CLIENT_INFO_ATTRS *pcia )
{
ULONG i, cbThisSize;
TCHAR **ppsz;
// Add up user info header
//
*pcbTotalSize += sizeof (LDAP_CLIENTINFO);
// Add up the total size for standard attributes
//
for (i = 0; i < COUNT_ENUM_DIR_CLIENT_INFO; i++)
{
// Get the attribute value
//
ppsz = (TCHAR **) pcia->ClientInfo.apszStdAttrValues[i];
// Calcualte the attribute string length
//
cbThisSize = 1;
if (ppsz != NULL && *ppsz != NULL)
cbThisSize += My_lstrlen (*ppsz);
// Compensate the string length if it is ip address
//
if (i == ENUM_CLIENTATTR_IP_ADDRESS)
cbThisSize += 16;
// Convert string length to string size
//
cbThisSize *= sizeof (TCHAR);
// Add up this entry size
//
*pcbTotalSize += cbThisSize;
}
// Add up the total size for extended attributes
//
for (i = 0; i < pcia->Attrs.cMaxAttrs; i++)
{
// Get the extended attribute value
//
ppsz = (TCHAR **) pcia->Attrs.aPairs[i].pszValue;
// Calcualte the attribute string length
//
cbThisSize = 1;
if (ppsz != NULL && *ppsz != NULL)
cbThisSize += My_lstrlen (*ppsz);
// Get the extended attribute name
//
cbThisSize += lstrlen (IlsSkipAnyAttrNamePrefix ((const TCHAR *)
pcia->Attrs.aPairs[i].pszName)) + 1;
// Convert string length to string size
//
cbThisSize *= sizeof (TCHAR);
// Add up this entry size
//
*pcbTotalSize += cbThisSize;
}
}
#ifdef ENABLE_MEETING_PLACE
VOID SizeEnumMtgInfos (
ULONG *pcbTotalSize,
MTG_INFO_ATTRS *pmia )
{
ULONG i, cbThisSize;
TCHAR **ppsz;
// Add up meeting info header
//
*pcbTotalSize += sizeof (LDAP_MEETINFO);
// Add up the total size for standard attributes
//
for (i = 0; i < COUNT_ENUM_DIRMTGINFO; i++)
{
// Get the standard attribute value
//
ppsz = (TCHAR **) pmia->MtgInfo.apszStdAttrValues[i];
// Calcualte the attribute string length
//
cbThisSize = 1;
if (ppsz != NULL && *ppsz != NULL)
cbThisSize += My_lstrlen (*ppsz);
// Compensate the string length if it is ip address
//
if (i == ENUM_MTGATTR_IP_ADDRESS)
cbThisSize += 16;
// Convert string length to string size
//
cbThisSize *= sizeof (TCHAR);
// Add up this entry size
//
*pcbTotalSize += cbThisSize;
}
// Add up the total size for extended attributes
//
for (i = 0; i < pmia->Attrs.cMaxAttrs; i++)
{
// Get the extended attribute value
//
ppsz = (TCHAR **) pmia->Attrs.aPairs[i].pszValue;
// Calcualte the attribute string length
//
cbThisSize = 1;
if (ppsz != NULL && *ppsz != NULL)
cbThisSize += My_lstrlen (*ppsz);
// Get the extended attribute name
//
cbThisSize += lstrlen (IlsSkipAnyAttrNamePrefix ((const TCHAR *)
pmia->Attrs.aPairs[i].pszName)) + 1;
// Convert string length to string size
//
cbThisSize *= sizeof (TCHAR);
// Add up this entry size
//
*pcbTotalSize += cbThisSize;
}
}
#endif // ENABLE_MEETING_PLACE
/* =========== RESOLVE ============ */
typedef HRESULT (INFO_HANDLER) ( VOID *, const TCHAR *, const TCHAR ** );
extern HRESULT CacheResolveClientInfoAttr ( VOID *, const TCHAR *, const TCHAR ** );
extern HRESULT CacheResolveProtInfoAttr ( VOID *, const TCHAR *, const TCHAR ** );
extern HRESULT CacheResolveMtgInfoAttr ( VOID *, const TCHAR *, const TCHAR ** );
HRESULT
NotifyResolveX (
HRESULT hrServer,
SP_CResponse *pItem,
VOID *pInfo,
INFO_HANDLER *pHandler )
{
MyAssert (pItem != NULL);
MyAssert (pInfo != NULL);
MyAssert (pHandler != NULL);
// Get the ldap result
//
LDAPMessage *pLdapMsg = pItem->GetResult ();
MyAssert (pLdapMsg != NULL);
if (pLdapMsg == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_POINTER;
goto MyExit;
}
// Get ld
//
LDAP *ld;
ld = pItem->GetLd ();
if (ld == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_HANDLE;
goto MyExit;
}
// Get the first entry that we care only
//
LDAPMessage *pEntry;
pEntry = ldap_first_entry (ld, pLdapMsg);
if (pEntry == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Initialize wldap32.dll context
//
struct berelement *pContext;
pContext = NULL;
// Examine the first attribute
//
TCHAR *pszAttrName;
pszAttrName = ldap_first_attribute (ld, pEntry, &pContext);
if (pszAttrName == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_MEMORY;
goto MyExit;
}
TCHAR **ppszAttrVal;
ppszAttrVal = ldap_get_values (ld, pEntry, pszAttrName);
if (ppszAttrVal == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Cache this attribute name (if needed) and value
//
HRESULT hr;
hr = (*pHandler) (pInfo, pszAttrName,(const TCHAR **) ppszAttrVal);
ldap_value_free (ppszAttrVal);
if (hr != S_OK)
{
hrServer = hr;
goto MyExit;
}
// Step through the other attributes
//
while ((pszAttrName = ldap_next_attribute (ld, pEntry, pContext))
!= NULL)
{
ppszAttrVal = ldap_get_values (ld, pEntry, pszAttrName);
if (ppszAttrVal == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Cache the other attribute names (if needed) and values
//
hr = (*pHandler) (pInfo, pszAttrName, (const TCHAR **) ppszAttrVal);
ldap_value_free (ppszAttrVal);
if (hr != S_OK)
{
hrServer = hr;
goto MyExit;
}
}
MyAssert (hrServer == S_OK);
MyExit:
return hrServer;
}
BOOL
NotifyResolveClient (
HRESULT hrServer,
SP_CResponse *pItem )
{
MyAssert (pItem != NULL);
ULONG i;
// Get the pending info
//
RESP_INFO *pInfo = pItem->GetRespInfo ();
MyAssert (pInfo != NULL);
// Initialize minimal info
//
LDAP_CLIENTINFO_RES *pClientRes = NULL;
CLIENT_INFO_ATTRS *pcia = NULL;
// If error, simply report the error
//
if (hrServer != S_OK)
goto MyExit;
// Get the ldap result
//
LDAPMessage *pLdapMsg;
pLdapMsg = pItem->GetResult ();
if (pLdapMsg == NULL)
{
MyAssert (FALSE);
goto MyExit;
}
// Get ld
//
LDAP *ld;
ld = pItem->GetLd ();
if (ld == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_HANDLE;
goto MyExit;
}
// Get the count of attributes
//
ULONG cAttrs;
cAttrs = my_ldap_count_1st_entry_attributes (ld, pLdapMsg);
if (cAttrs == 0)
{
hrServer = ILS_E_NO_MORE;
goto MyExit;
}
// Allocate result set holder
//
pcia = (CLIENT_INFO_ATTRS *) MemAlloc (
sizeof (CLIENT_INFO_ATTRS) +
cAttrs * sizeof (ATTR_PAIR));
if (pcia == NULL)
{
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Initialize result set holder
//
pcia->Attrs.cMaxAttrs = cAttrs;
// Cache resolve set
//
hrServer = NotifyResolveX ( hrServer,
pItem,
pcia,
CacheResolveClientInfoAttr);
if (hrServer != S_OK)
{
goto MyExit;
}
// Initialize the total size
//
ULONG cbTotalSize, cbThisSize;
cbTotalSize = sizeof (LDAP_CLIENTINFO_RES);
// Loop through all attributes in order to compute the total size
//
for (i = 0; i < COUNT_ENUM_RES_CLIENT_INFO; i++)
{
if (pcia->ClientInfo.apszStdAttrValues[i] != NULL)
{
// Get the string length
//
cbThisSize = My_lstrlen (pcia->ClientInfo.apszStdAttrValues[i]) + 1;
// Compensate for the ip address
//
if (i == ENUM_CLIENTATTR_IP_ADDRESS)
cbThisSize += 16;
// Convert string length to string size
//
cbThisSize *= sizeof (TCHAR);
// Add up to the total size
//
cbTotalSize += cbThisSize;
}
}
// Loop through extended attributes
//
for (i = 0; i < pcia->Attrs.cCurrAttrs; i++)
{
cbThisSize = My_lstrlen (pcia->Attrs.aPairs[i].pszName) + 1;
cbThisSize += My_lstrlen (pcia->Attrs.aPairs[i].pszValue) + 1;
cbThisSize *= sizeof (TCHAR);
cbTotalSize += cbThisSize;
}
// Allocate LDAP_USERINFO_RES structure
//
pClientRes = (LDAP_CLIENTINFO_RES *) MemAlloc (cbTotalSize);
if (pClientRes == NULL)
{
MyAssert (FALSE); // we are in deep trouble here
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Fill in common fields
//
pClientRes->uSize = sizeof (*pClientRes);
pClientRes->hResult = hrServer;
pClientRes->lci.uSize = sizeof (pClientRes->lci);
// Prepare to copy strings
//
TCHAR *pszDst, *pszSrc;
pszDst = (TCHAR *) (pClientRes + 1);
// Copy user object's standard attributes
//
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_CN];
if (pszSrc != NULL)
{
pClientRes->lci.uOffsetCN = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pClientRes->lci));
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_FIRST_NAME];
if (pszSrc != NULL)
{
pClientRes->lci.uOffsetFirstName = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pClientRes->lci));
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_LAST_NAME];
if (pszSrc != NULL)
{
pClientRes->lci.uOffsetLastName = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pClientRes->lci));
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_EMAIL_NAME];
if (pszSrc != NULL)
{
pClientRes->lci.uOffsetEMailName = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pClientRes->lci));
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_CITY_NAME];
if (pszSrc != NULL)
{
pClientRes->lci.uOffsetCityName = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pClientRes->lci));
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_C];
if (pszSrc != NULL)
{
pClientRes->lci.uOffsetCountryName = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pClientRes->lci));
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_COMMENT];
if (pszSrc != NULL)
{
pClientRes->lci.uOffsetComment = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pClientRes->lci));
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_IP_ADDRESS];
if (pszSrc != NULL)
{
pClientRes->lci.uOffsetIPAddress = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pClientRes->lci));
GetIPAddressString (pszDst, GetStringLong (pszSrc));
pszDst += lstrlen (pszDst) + 1;
}
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_FLAGS];
if (pszSrc != NULL)
{
pClientRes->lci.dwFlags = (pszSrc != NULL)? GetStringLong (pszSrc) :
INVALID_USER_FLAGS;
}
// Copy app object's standard attributes
//
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_APP_NAME];
if (pszSrc != NULL)
{
pClientRes->lci.uOffsetAppName = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pClientRes->lci));
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_APP_MIME_TYPE];
if (pszSrc != NULL)
{
pClientRes->lci.uOffsetAppMimeType = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pClientRes->lci));
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
pszSrc = pcia->ClientInfo.apszStdAttrValues[ENUM_CLIENTATTR_APP_GUID];
if (MyIsGoodString (pszSrc))
{
GetStringGuid (pszSrc, &(pClientRes->lci.AppGuid));
}
else
{
ZeroMemory (&(pClientRes->lci.AppGuid), sizeof (pClientRes->lci.AppGuid));
}
// Copy app object's extended attributes
//
pClientRes->lci.cAttrsReturned = pcia->Attrs.cCurrAttrs;
if (pClientRes->lci.cAttrsReturned > 0)
{
pClientRes->lci.uOffsetAttrsReturned = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pClientRes->lci));
for (i = 0; i < pcia->Attrs.cCurrAttrs; i++)
{
My_lstrcpy (pszDst, pcia->Attrs.aPairs[i].pszName);
pszDst += lstrlen (pszDst) + 1;
My_lstrcpy (pszDst, pcia->Attrs.aPairs[i].pszValue);
pszDst += lstrlen (pszDst) + 1;
}
}
MyAssert (hrServer == S_OK);
MyExit:
// Free temporary result set holder
//
if (pcia != NULL)
{
// Free standard attributes
//
for (INT k = 0;k < COUNT_ENUM_CLIENT_INFO; k++)
{
MemFree (pcia->ClientInfo.apszStdAttrValues[k]);
}
// Free arbitrary attributes
//
for (ULONG j = 0; j < pcia->Attrs.cCurrAttrs; j++)
{
MemFree (pcia->Attrs.aPairs[j].pszName);
MemFree (pcia->Attrs.aPairs[j].pszValue);
}
// Free the holder itself
//
MemFree (pcia);
}
// Clean up the return structure if failure
//
if (hrServer != S_OK)
{
// Make sure we have a return structure
//
if (pClientRes != NULL)
ZeroMemory (pClientRes, sizeof (*pClientRes));
else
pClientRes = (LDAP_CLIENTINFO_RES *) MemAlloc (sizeof (LDAP_CLIENTINFO_RES));
// Fill in the minimal info
//
if (pClientRes != NULL)
{
pClientRes->uSize = sizeof (*pClientRes);
pClientRes->hResult = hrServer;
}
}
// Post a message to the com layer
//
PostMessage (g_hWndNotify, pInfo->uNotifyMsg, pInfo->uRespID, (LPARAM) pClientRes);
// Delete this pending item
//
return TRUE;
}
HRESULT CacheResolveClientInfoAttr (
VOID *pInfo,
const TCHAR *pszAttrName,
const TCHAR **ppszAttrVal )
{
MyAssert (pInfo != NULL);
MyAssert (pszAttrName != NULL);
// Shorthand meeting info pointer
//
CLIENT_INFO_ATTRS *pcia = (CLIENT_INFO_ATTRS *) pInfo;
// See if this attribute is arbitrary?
//
const TCHAR *pszRealAnyName = IlsIsAnyAttrName (pszAttrName);
if (pszRealAnyName != NULL)
{
MyAssert (pcia->Attrs.cCurrAttrs < pcia->Attrs.cMaxAttrs);
// Duplicate the name
//
pcia->Attrs.aPairs[pcia->Attrs.cCurrAttrs].pszName =
My_strdup (pszRealAnyName);
// Duplicate the value
// BUGS: we should avoid duplicate the string here (cf. enum-user-infos)
//
if (ppszAttrVal != NULL)
{
pcia->Attrs.aPairs[pcia->Attrs.cCurrAttrs++].pszValue =
My_strdup (*ppszAttrVal);
}
else
{
// ILS server bug or wldap32.dll bug
//
MyAssert (FALSE);
}
}
else
{
// Loop through all standard attributes
//
for (INT i = 0; i < COUNT_ENUM_RES_CLIENT_INFO; i++)
{
// Figure out what attribute it is
//
if (My_lstrcmpi (c_apszClientStdAttrNames[i], pszAttrName) == 0)
{
// Free the previously allocated value if any
//
MemFree (pcia->ClientInfo.apszStdAttrValues[i]);
// Duplicate the value
// BUGS: we should avoid duplicate the string here (cf. enum-user-infos)
//
if (ppszAttrVal != NULL)
{
pcia->ClientInfo.apszStdAttrValues[i] = DuplicateGoodString (*ppszAttrVal);
}
else
{
// ILS server bug or wldap32.dll bug
//
MyAssert (FALSE);
}
break;
}
}
}
return S_OK;
}
typedef struct
{
PROT_INFO ProtInfo;
TCHAR *pszProtNameToResolve;
BOOL fFindIndex;
LONG nIndex;
}
PROT_INFO_EX;
enum { INVALID_INDEX = -1 };
BOOL NotifyResolveProt ( HRESULT hrServer, SP_CResponse *pItem )
{
MyAssert (pItem != NULL);
// Get the pending info
//
RESP_INFO *pInfo = pItem->GetRespInfo ();
MyAssert (pInfo != NULL);
// Initialize minimal info
//
LDAP_PROTINFO_RES *pProtRes = NULL;
PROT_INFO_EX *ppi = NULL;
// If error, simply report the error
//
if (hrServer != S_OK)
goto MyExit;
// Allocate result holder
//
ppi = (PROT_INFO_EX *) MemAlloc (sizeof (PROT_INFO_EX));
if (ppi == NULL)
{
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Cache the protocol name to resolve
//
MyAssert (pInfo->pszProtNameToResolve != NULL);
ppi->pszProtNameToResolve = pInfo->pszProtNameToResolve;
ppi->nIndex = INVALID_INDEX;
// Call the common routine to find the index
//
ppi->fFindIndex = TRUE;
hrServer = NotifyResolveX (hrServer, pItem, ppi, CacheResolveProtInfoAttr);
if (hrServer != S_OK)
goto MyExit;
// Check to see if we found the index
//
if (ppi->nIndex == INVALID_INDEX)
{
hrServer = ILS_E_NO_SUCH_OBJECT;
goto MyExit;
}
// Call the common routine AGAIN to save attribute values
//
ppi->fFindIndex = FALSE;
hrServer = NotifyResolveX (hrServer, pItem, ppi, CacheResolveProtInfoAttr);
if (hrServer != S_OK)
goto MyExit;
// Initialize the size
//
ULONG cbTotalSize, cbThisSize;
cbTotalSize = sizeof (LDAP_PROTINFO_RES);
// Loop through standard attrs
//
ULONG i;
for (i = 0; i < COUNT_ENUM_PROTATTR; i++)
{
if (ppi->ProtInfo.apszStdAttrValues[i] != NULL)
{
cbThisSize = My_lstrlen (ppi->ProtInfo.apszStdAttrValues[i]) + 1;
cbThisSize *= sizeof (TCHAR);
cbTotalSize += cbThisSize;
}
}
// Allocate LDAP_PROTINFO_RES structure
//
pProtRes = (LDAP_PROTINFO_RES *) MemAlloc (cbTotalSize);
if (pProtRes == NULL)
{
MyAssert (FALSE); // we are in deep trouble here
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Fill in fields
//
pProtRes->uSize = sizeof (*pProtRes);
pProtRes->hResult = hrServer;
pProtRes->lpi.uSize = sizeof (pProtRes->lpi);
TCHAR *pszSrc, *pszDst;
pszDst = (TCHAR *) (pProtRes + 1);
// Copy protocol name
//
pszSrc = ppi->ProtInfo.apszStdAttrValues[ENUM_PROTATTR_NAME];
if (pszSrc != NULL)
{
pProtRes->lpi.uOffsetName = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pProtRes->lpi));
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
// Copy protocol mime type
//
pszSrc = ppi->ProtInfo.apszStdAttrValues[ENUM_PROTATTR_MIME_TYPE];
if (pszSrc != NULL)
{
pProtRes->lpi.uOffsetMimeType = (ULONG)((ULONG_PTR) pszDst - (ULONG_PTR) &(pProtRes->lpi));
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
// Copy protocol prot number
//
pszSrc = ppi->ProtInfo.apszStdAttrValues[ENUM_PROTATTR_PORT_NUMBER];
if (pszSrc != NULL)
{
pProtRes->lpi.uPortNumber = GetStringLong (pszSrc);
}
MyAssert (hrServer == S_OK);
MyExit:
// Free temporary app result holder
//
if (ppi != NULL)
{
for (INT k = 0; k < COUNT_ENUM_PROTATTR; k++)
{
MemFree (ppi->ProtInfo.apszStdAttrValues[k]);
}
MemFree (ppi);
}
// Clean up the return structure if failure
//
if (hrServer != S_OK)
{
// Make sure we have a valid returned structure
//
if (pProtRes != NULL)
ZeroMemory (pProtRes, sizeof (*pProtRes));
else
pProtRes = (LDAP_PROTINFO_RES *) MemAlloc (sizeof (LDAP_PROTINFO_RES));
// Fill in the minimal info
//
if (pProtRes != NULL)
{
pProtRes->uSize = sizeof (*pProtRes);
pProtRes->hResult = hrServer;
}
}
// Post the result to the com layer
//
PostMessage (g_hWndNotify, pInfo->uNotifyMsg, pInfo->uRespID, (LPARAM) pProtRes);
// Destroy this pending item
//
return TRUE;
}
HRESULT CacheResolveProtInfoAttr (
VOID *pInfo,
const TCHAR *pszAttrName,
const TCHAR **ppszAttrVal )
{
MyAssert (pInfo != NULL);
MyAssert (pszAttrName != NULL);
// Shorthand prot info pointer
//
PROT_INFO_EX *ppi = (PROT_INFO_EX *) pInfo;
// Are we trying to find the index of the protocol to resolve?
//
if (ppi->fFindIndex)
{
// If we already located the index, then simply return
//
if (ppi->nIndex == INVALID_INDEX)
{
// Looking for "sprotid"
//
if (My_lstrcmpi (STR_PROT_NAME, pszAttrName) == 0)
{
// Get to the protocol name attribute
//
if (ppszAttrVal != NULL)
{
TCHAR *pszVal;
for (LONG nIndex = 0;
(pszVal = (TCHAR *) ppszAttrVal[nIndex]) != NULL;
nIndex++)
{
if (My_lstrcmpi (ppi->pszProtNameToResolve, pszVal) == 0)
{
// Locate the same protocol name, remember the index
//
ppi->nIndex = nIndex;
break;
// return S_OK; // we should be able to return from here
}
}
}
else
{
// ILS server bug or wldap32.dll bug
//
MyAssert (FALSE);
}
}
}
}
else
{
// Loop through all standard attributes
//
for (INT i = 0; i < COUNT_ENUM_PROTATTR; i++)
{
// Figure out what attribute it is
//
if (My_lstrcmpi (c_apszProtStdAttrNames[i], pszAttrName) == 0)
{
// Free the previously allocated value if any
//
MemFree (ppi->ProtInfo.apszStdAttrValues[i]);
// Duplicate the value
// BUGS: we should avoid duplicate the string here (cf. enum-user-infos)
//
if (ppszAttrVal != NULL)
{
// Make sure that we do not fault when the ILS server or wldap32.dll has a bug
//
for (LONG nIndex = 0; nIndex <= ppi->nIndex; nIndex++)
{
if (ppszAttrVal[nIndex] == NULL)
{
// ILS server bug
//
MyAssert (FALSE);
return S_OK;
}
}
// Duplicate the attribute value
//
ppi->ProtInfo.apszStdAttrValues[i] = My_strdup (ppszAttrVal[ppi->nIndex]);
}
else
{
// ILS server bug or wldap32.dll bug
//
MyAssert (FALSE);
}
break;
}
}
}
return S_OK;
}
#ifdef ENABLE_MEETING_PLACE
BOOL NotifyResolveMtg ( HRESULT hrServer, SP_CResponse *pItem )
{
MyAssert (pItem != NULL);
// Get pending info
//
RESP_INFO *pInfo = pItem->GetRespInfo ();
MyAssert (pInfo != NULL);
// Initialize minimal return info
//
LDAP_MEETINFO_RES *pMtgRes = NULL;
MTG_INFO_ATTRS *pmia = NULL;
// If error, simply report the error
//
if (hrServer != S_OK)
goto MyExit;
// Get the ldap result
//
LDAPMessage *pLdapMsg;
pLdapMsg = pItem->GetResult ();
if (pLdapMsg == NULL)
{
MyAssert (FALSE);
goto MyExit;
}
// Get ld
//
LDAP *ld;
ld = pItem->GetLd ();
if (ld == NULL)
{
MyAssert (FALSE);
hrServer = ILS_E_HANDLE;
goto MyExit;
}
// Get the count of attributes
//
ULONG cAttrs;
cAttrs = my_ldap_count_1st_entry_attributes (ld, pLdapMsg);
if (cAttrs == 0)
{
hrServer = ILS_E_NO_MORE;
goto MyExit;
}
// Allocate result set holder
//
pmia = (MTG_INFO_ATTRS *) MemAlloc (
sizeof (MTG_INFO_ATTRS) +
cAttrs * sizeof (ATTR_PAIR));
if (pmia == NULL)
{
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Initialize result set holder
//
pmia->Attrs.cMaxAttrs = cAttrs;
// Cache resolve set
//
hrServer = NotifyResolveX ( hrServer,
pItem,
pmia,
CacheResolveMtgInfoAttr);
if (hrServer != S_OK)
goto MyExit;
// Initialize the size
//
ULONG cbTotalSize, cbThisSize;
cbTotalSize = sizeof (LDAP_MEETINFO_RES);
// Loop through standard attrs to calculate the total size
//
ULONG i;
for (i = 0; i < COUNT_ENUM_MTGATTR; i++)
{
if (pmia->MtgInfo.apszStdAttrValues[i] != NULL)
{
// Compute the string length
//
cbThisSize = My_lstrlen (pmia->MtgInfo.apszStdAttrValues[i]) + 1;
// Compensate the string length if it is ip address
//
if (i == ENUM_MTGATTR_IP_ADDRESS)
cbThisSize += 16;
// Convert the string length to string size
//
cbThisSize *= sizeof (TCHAR);
// Add up to the total size
//
cbTotalSize += cbThisSize;
}
}
// Loop through arbitrary attrs to calculate the total size
//
for (i = 0; i < pmia->Attrs.cCurrAttrs; i++)
{
cbThisSize = My_lstrlen (pmia->Attrs.aPairs[i].pszName) + 1;
cbThisSize += My_lstrlen (pmia->Attrs.aPairs[i].pszValue) + 1;
cbThisSize *= sizeof (TCHAR);
cbTotalSize += cbThisSize;
}
// Allocate LDAP_MTGINFO_RES structure
//
pMtgRes = (LDAP_MEETINFO_RES *) MemAlloc (cbTotalSize);
if (pMtgRes == NULL)
{
MyAssert (FALSE); // we are in deep trouble here
hrServer = ILS_E_MEMORY;
goto MyExit;
}
// Fill in common fields
//
pMtgRes->uSize = sizeof (*pMtgRes);
pMtgRes->hResult = hrServer;
pMtgRes->lmi.uSize = sizeof (pMtgRes->lmi);
TCHAR *pszSrc, *pszDst;
pszDst = (TCHAR *) (pMtgRes + 1);
// Copy Meeting Name if needed
//
pszSrc = pmia->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_CN];
if (pszSrc != NULL)
{
pMtgRes->lmi.uOffsetMeetingPlaceID = (ULONG) pszDst - (ULONG) &(pMtgRes->lmi);
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
// Copy Meeting Type if needed
//
pszSrc = pmia->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_MTG_TYPE];
if (pszSrc != NULL)
{
pMtgRes->lmi.lMeetingPlaceType = (pszSrc != NULL) ? GetStringLong (pszSrc) :
INVALID_MEETING_TYPE;
}
// Copy Attendee Type if needed
//
pszSrc = pmia->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_MEMBER_TYPE];
if (pszSrc != NULL)
{
pMtgRes->lmi.lAttendeeType = (pszSrc != NULL) ? GetStringLong (pszSrc) :
INVALID_ATTENDEE_TYPE;
}
// Copy Description if needed
//
pszSrc = pmia->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_DESCRIPTION];
if (pszSrc != NULL)
{
pMtgRes->lmi.uOffsetDescription = (ULONG) pszDst - (ULONG) &(pMtgRes->lmi);
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
// Copy Host Name if needed
//
pszSrc = pmia->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_HOST_NAME];
if (pszSrc != NULL)
{
pMtgRes->lmi.uOffsetHostName = (ULONG) pszDst - (ULONG) &(pMtgRes->lmi);
My_lstrcpy (pszDst, pszSrc);
pszDst += lstrlen (pszDst) + 1;
}
// Copy Host IP Address if needed
//
pszSrc = pmia->MtgInfo.apszStdAttrValues[ENUM_MTGATTR_IP_ADDRESS];
if (pszSrc != NULL)
{
pMtgRes->lmi.uOffsetHostIPAddress = (ULONG) pszDst - (ULONG) &(pMtgRes->lmi);
GetIPAddressString (pszDst, GetStringLong (pszSrc));
pszDst += lstrlen (pszDst) + 1;
}
// Copy extended attributes
//
pMtgRes->lmi.cAttrsReturned = pmia->Attrs.cCurrAttrs;
if (pMtgRes->lmi.cAttrsReturned > 0)
{
pMtgRes->lmi.uOffsetAttrsReturned = (ULONG) pszDst - (ULONG) &(pMtgRes->lmi);
for (i = 0; i < pmia->Attrs.cCurrAttrs; i++)
{
My_lstrcpy (pszDst, pmia->Attrs.aPairs[i].pszName);
pszDst += lstrlen (pszDst) + 1;
My_lstrcpy (pszDst, pmia->Attrs.aPairs[i].pszValue);
pszDst += lstrlen (pszDst) + 1;
}
}
MyAssert (hrServer == S_OK);
MyExit:
// Free temporary result set holder
//
if (pmia != NULL)
{
// Free standard attributes
//
for (INT i = 0; i < COUNT_ENUM_MTGATTR; i++)
{
MemFree (pmia->MtgInfo.apszStdAttrValues[i]);
}
// Free arbitrary attributes
//
for (ULONG j = 0; j < pmia->Attrs.cCurrAttrs; j++)
{
MemFree (pmia->Attrs.aPairs[j].pszName);
MemFree (pmia->Attrs.aPairs[j].pszValue);
}
// Free the holder itself
//
MemFree (pmia);
}
// Clean up the return structure if failure
//
if (hrServer != S_OK)
{
// Make sure we have a return structure
//
if (pMtgRes != NULL)
ZeroMemory (pMtgRes, sizeof (*pMtgRes));
else
pMtgRes = (LDAP_MEETINFO_RES *) MemAlloc (sizeof (LDAP_MEETINFO_RES));
// Fill in the minimal info
//
if (pMtgRes != NULL)
{
pMtgRes->uSize = sizeof (*pMtgRes);
pMtgRes->hResult = hrServer;
}
}
// Post a message to the com layer
//
PostMessage (g_hWndNotify, pInfo->uNotifyMsg, pInfo->uRespID, (LPARAM) pMtgRes);
// Delete this pending item
//
return TRUE;
}
#endif // ENABLE_MEETING_PLACE
#ifdef ENABLE_MEETING_PLACE
HRESULT CacheResolveMtgInfoAttr (
VOID *pInfo,
const TCHAR *pszAttrName,
const TCHAR **ppszAttrVal )
{
MyAssert (pInfo != NULL);
MyAssert (pszAttrName != NULL);
// Shorthand meeting info pointer
//
MTG_INFO_ATTRS *pmia = (MTG_INFO_ATTRS *) pInfo;
// See if this attribute is arbitrary?
//
const TCHAR *pszRealAnyName = IlsIsAnyAttrName (pszAttrName);
if (pszRealAnyName != NULL)
{
MyAssert (pmia->Attrs.cCurrAttrs < pmia->Attrs.cMaxAttrs);
// Duplicate the name
//
pmia->Attrs.aPairs[pmia->Attrs.cCurrAttrs].pszName =
My_strdup (pszRealAnyName);
// Duplicate the value
// BUGS: we should avoid duplicate the string here (cf. enum-user-infos)
//
if (ppszAttrVal != NULL)
{
pmia->Attrs.aPairs[pmia->Attrs.cCurrAttrs++].pszValue =
My_strdup (*ppszAttrVal);
}
else
{
// ILS server bug or wldap32.dll bug
//
MyAssert (FALSE);
}
}
else
{
// Loop through all standard attributes
//
for (INT i = 0; i < COUNT_ENUM_RESMTGINFO; i++)
{
// Figure out what attribute it is
//
if (My_lstrcmpi (c_apszMtgStdAttrNames[i], pszAttrName) == 0)
{
// Free the previously allocated value if any
//
MemFree (pmia->MtgInfo.apszStdAttrValues[i]);
// Duplicate the value
// BUGS: we should avoid duplicate the string here (cf. enum-user-infos)
//
if (ppszAttrVal != NULL)
{
pmia->MtgInfo.apszStdAttrValues[i] = My_strdup (*ppszAttrVal);
}
else
{
// ILS server bug or wldap32.dll bug
//
MyAssert (FALSE);
}
break;
}
}
}
return S_OK;
}
#endif // ENABLE_MEETING_PLACE
VOID FreeStdAttrCache ( TCHAR *apszStdAttrValues[], ULONG cStdAttrs )
{
for (ULONG i = 0; i < cStdAttrs; i++)
{
if (apszStdAttrValues[i] != NULL)
{
ldap_value_free ((TCHAR **) apszStdAttrValues[i]);
}
}
}
VOID FreeAttrPairArrayCache ( ATTR_PAIR aAttrPair[], ULONG cPairs )
{
if (aAttrPair != NULL)
{
for (ULONG j = 0; j < cPairs; j++)
{
if (aAttrPair[j].pszValue != NULL)
{
ldap_value_free ((TCHAR **) aAttrPair[j].pszValue);
}
}
}
}
VOID CacheAnyAttrNamesInAttrPairs (
ULONG cNames,
TCHAR *pszSrcNameList,
ATTR_PAIR aPairs[] )
{
MyAssert (cNames != 0);
MyAssert (pszSrcNameList != NULL);
MyAssert (aPairs != NULL);
// Note that all these extended attribute names are already PREFIXED
//
for (ULONG i = 0; i < cNames; i++)
{
aPairs[i].pszName = pszSrcNameList;
pszSrcNameList += lstrlen (pszSrcNameList) + 1;
}
}

Reference in New Issue Copy Permalink