4347 lines
96 KiB
C++
4347 lines
96 KiB
C++
|
||
/* ----------------------------------------------------------------------
|
||
|
||
Module: ULS.DLL (Service Provider)
|
||
File: ldapsp.cpp
|
||
Content: This file contains the ldap service provider interface.
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
|
||
Copyright (c) Microsoft Corporation 1996-1997
|
||
|
||
---------------------------------------------------------------------- */
|
||
|
||
#include "ulsp.h"
|
||
#include "spinc.h"
|
||
|
||
// Window handle of this layer's hidden window
|
||
//
|
||
HWND g_hWndHidden = NULL;
|
||
|
||
// Window handle of the COM layer's hidden window
|
||
//
|
||
HWND g_hWndNotify = NULL;
|
||
|
||
// Internal request thread
|
||
//
|
||
HANDLE g_hReqThread = NULL;
|
||
DWORD g_dwReqThreadID = 0;
|
||
|
||
// Hidden window class
|
||
//
|
||
extern TCHAR c_szWindowClassName[];
|
||
|
||
// Global generator for response ID
|
||
//
|
||
ULONG g_uRespID = 1;
|
||
|
||
// Global
|
||
//
|
||
DWORD g_dwClientSig = 0;
|
||
|
||
// Global counter for the times of initializations
|
||
//
|
||
LONG g_cInitialized = 0;
|
||
|
||
|
||
// Internal functions prototypes
|
||
//
|
||
VOID BuildStdAttrNameArray ( VOID );
|
||
TCHAR *AddBaseToFilter ( TCHAR *, const TCHAR * );
|
||
HRESULT _EnumClientsEx ( ULONG, TCHAR *, TCHAR *, ULONG, TCHAR *, LDAP_ASYNCINFO * );
|
||
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_Initialize
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Tested on ILS (7438)
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT UlsLdap_Initialize ( HWND hWndCallback )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is not initialized twice
|
||
//
|
||
if (g_cInitialized++ != 0)
|
||
return S_OK;
|
||
|
||
#ifdef DEBUG
|
||
// Validate handler table
|
||
//
|
||
extern VOID DbgValidateHandlerTable ( VOID );
|
||
DbgValidateHandlerTable ();
|
||
#endif
|
||
|
||
// Validate standard attribute name table
|
||
//
|
||
#ifdef DEBUG
|
||
extern VOID DbgValidateStdAttrNameArray ( VOID );
|
||
DbgValidateStdAttrNameArray ();
|
||
#endif
|
||
|
||
// Clean up the events for safe rollback
|
||
//
|
||
ZeroMemory (&g_ahThreadWaitFor[0], NUM_THREAD_WAIT_FOR * sizeof (HANDLE));
|
||
|
||
// Initialize global settings via registry
|
||
//
|
||
if (! GetRegistrySettings ())
|
||
{
|
||
MyAssert (FALSE);
|
||
}
|
||
|
||
// Make sure the uls window handle is valid
|
||
//
|
||
if (! MyIsWindow (hWndCallback))
|
||
{
|
||
MyAssert (FALSE);
|
||
g_cInitialized--;
|
||
MyAssert (g_cInitialized == 0);
|
||
return ILS_E_HANDLE;
|
||
}
|
||
|
||
// Cache the uls window handle
|
||
//
|
||
g_hWndNotify = hWndCallback;
|
||
|
||
// Initialize ILS specifics
|
||
//
|
||
hr = IlsInitialize ();
|
||
if (hr != S_OK)
|
||
return hr;
|
||
|
||
// Create events for inter-thread synchronization
|
||
//
|
||
g_fExitNow = FALSE;
|
||
for (INT i = 0; i < NUM_THREAD_WAIT_FOR; i++)
|
||
{
|
||
g_ahThreadWaitFor[i] = CreateEvent (NULL, // no security
|
||
FALSE, // auto reset
|
||
FALSE, // not signaled initially
|
||
NULL); // no event name
|
||
if (g_ahThreadWaitFor[i] == NULL)
|
||
{
|
||
hr = ILS_E_FAIL;
|
||
goto MyExit;
|
||
}
|
||
}
|
||
|
||
// Create an internal session container
|
||
//
|
||
g_pSessionContainer = new SP_CSessionContainer;
|
||
if (g_pSessionContainer == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Initialize the internal session container
|
||
//
|
||
hr = g_pSessionContainer->Initialize (8, NULL);
|
||
if (hr != S_OK)
|
||
goto MyExit;
|
||
|
||
// Create an internal pending request queue
|
||
//
|
||
g_pReqQueue = new SP_CRequestQueue;
|
||
if (g_pReqQueue == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Create an internal pending response queue
|
||
//
|
||
g_pRespQueue = new SP_CResponseQueue;
|
||
if (g_pRespQueue == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Create an internal refresh scheduler
|
||
//
|
||
g_pRefreshScheduler = new SP_CRefreshScheduler;
|
||
if (g_pRefreshScheduler == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Create the hidden window
|
||
//
|
||
if (! MyCreateWindow ())
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Start WSA for subsequent host query in this service provider
|
||
//
|
||
WSADATA WSAData;
|
||
if (WSAStartup (MAKEWORD (1, 1), &WSAData))
|
||
{
|
||
hr = ILS_E_WINSOCK;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Create an internal hidden request thread that
|
||
// sends request and keep alive messages
|
||
//
|
||
g_hReqThread = CreateThread (NULL, 0,
|
||
ReqThread,
|
||
NULL, 0,
|
||
&g_dwReqThreadID);
|
||
if (g_hReqThread == NULL)
|
||
{
|
||
hr = ILS_E_THREAD;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Everything seems successful
|
||
//
|
||
hr = S_OK;
|
||
|
||
MyExit:
|
||
|
||
if (hr != S_OK)
|
||
{
|
||
// Something wrong, roll back
|
||
//
|
||
g_cInitialized--;
|
||
|
||
for (i = 0; i < NUM_THREAD_WAIT_FOR; i++)
|
||
{
|
||
if (g_ahThreadWaitFor[i] != NULL)
|
||
{
|
||
CloseHandle (g_ahThreadWaitFor[i]);
|
||
g_ahThreadWaitFor[i] = NULL;
|
||
}
|
||
}
|
||
|
||
IlsCleanup ();
|
||
|
||
if (g_pSessionContainer != NULL)
|
||
{
|
||
delete g_pSessionContainer;
|
||
g_pSessionContainer = NULL;
|
||
}
|
||
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
delete g_pReqQueue;
|
||
g_pReqQueue = NULL;
|
||
}
|
||
|
||
if (g_pRespQueue != NULL)
|
||
{
|
||
delete g_pRespQueue;
|
||
g_pRespQueue = NULL;
|
||
}
|
||
|
||
if (g_pRefreshScheduler != NULL)
|
||
{
|
||
delete g_pRefreshScheduler;
|
||
g_pRefreshScheduler = NULL;
|
||
}
|
||
|
||
// Unconditional call to WSACleanup() will not cause any problem
|
||
// because it simply returns WSAEUNINITIALIZED.
|
||
//
|
||
WSACleanup ();
|
||
|
||
MyAssert (g_hReqThread == NULL);
|
||
MyAssert (g_cInitialized == 0);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_Deinitialize
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Tested on ILS (7438)
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT UlsLdap_Deinitialize ( VOID )
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (--g_cInitialized != 0)
|
||
{
|
||
if (g_cInitialized < 0)
|
||
{
|
||
MyAssert (FALSE);
|
||
g_cInitialized = 0;
|
||
return ILS_E_NOT_INITIALIZED;
|
||
}
|
||
return S_OK;
|
||
}
|
||
|
||
// Make sure we have a valid internal hidden window handle
|
||
//
|
||
if (MyIsWindow (g_hWndHidden))
|
||
{
|
||
// Kill poll timer
|
||
//
|
||
KillTimer (g_hWndHidden, ID_TIMER_POLL_RESULT);
|
||
|
||
// Destroy the hidden window
|
||
//
|
||
DestroyWindow (g_hWndHidden);
|
||
|
||
// Unregister the window class
|
||
//
|
||
UnregisterClass (c_szWindowClassName, g_hInstance);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
}
|
||
|
||
// Is the request thread alive?
|
||
//
|
||
if (g_hReqThread != NULL)
|
||
{
|
||
// Signal the request thread to exit
|
||
//
|
||
SetEvent (g_hevExitReqThread);
|
||
g_fExitNow = TRUE;
|
||
|
||
// Wait for the request thread to respond
|
||
//
|
||
DWORD dwResult;
|
||
#define REQ_THREAD_EXIT_TIMEOUT 10000 // 10 seconds timeout
|
||
ULONG tcTimeout = REQ_THREAD_EXIT_TIMEOUT;
|
||
ULONG tcTarget = GetTickCount () + tcTimeout;
|
||
do
|
||
{
|
||
dwResult = (g_hReqThread != NULL) ?
|
||
MsgWaitForMultipleObjects (
|
||
1,
|
||
&g_hReqThread,
|
||
FALSE,
|
||
tcTimeout,
|
||
QS_ALLINPUT) :
|
||
WAIT_OBJECT_0;
|
||
|
||
if (dwResult == (WAIT_OBJECT_0 + 1))
|
||
{
|
||
// Insure that this thread continues to respond
|
||
//
|
||
if (! KeepUiResponsive ())
|
||
{
|
||
dwResult = WAIT_TIMEOUT;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Make sure we only wait for 90 seconds totally
|
||
//
|
||
tcTimeout = tcTarget - GetTickCount ();
|
||
}
|
||
// If the thread does not exit, let's continue to wait.
|
||
//
|
||
while ( dwResult == (WAIT_OBJECT_0 + 1) &&
|
||
tcTimeout <= REQ_THREAD_EXIT_TIMEOUT);
|
||
|
||
// Make sure we propagate back the error that
|
||
// the internal request thread is not responding
|
||
//
|
||
if (dwResult == WAIT_TIMEOUT)
|
||
{
|
||
#ifdef _DEBUG
|
||
DBG_REF("ULS Terminating internal thread");
|
||
#endif
|
||
hr = ILS_E_THREAD;
|
||
TerminateThread (g_hReqThread, (DWORD) -1);
|
||
}
|
||
|
||
// Clean up the internal hidden thread descriptor
|
||
//
|
||
CloseHandle (g_hReqThread);
|
||
g_hReqThread = NULL;
|
||
g_dwReqThreadID = 0;
|
||
} // if (g_hReqThread != NULL)
|
||
|
||
// Clean up inter-thread synchronization
|
||
//
|
||
for (INT i = 0; i < NUM_THREAD_WAIT_FOR; i++)
|
||
{
|
||
if (g_ahThreadWaitFor[i] != NULL)
|
||
{
|
||
CloseHandle (g_ahThreadWaitFor[i]);
|
||
g_ahThreadWaitFor[i] = NULL;
|
||
}
|
||
}
|
||
|
||
IlsCleanup();
|
||
|
||
// Free the internal session container
|
||
//
|
||
if (g_pSessionContainer != NULL)
|
||
{
|
||
delete g_pSessionContainer;
|
||
g_pSessionContainer = NULL;
|
||
}
|
||
|
||
// Free the internal pending request queue
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
delete g_pReqQueue;
|
||
g_pReqQueue = NULL;
|
||
}
|
||
|
||
// Free the internal pending response queue
|
||
//
|
||
if (g_pRespQueue != NULL)
|
||
{
|
||
delete g_pRespQueue;
|
||
g_pRespQueue = NULL;
|
||
}
|
||
|
||
// Free the refresh scheduler object
|
||
//
|
||
if (g_pRefreshScheduler != NULL)
|
||
{
|
||
delete g_pRefreshScheduler;
|
||
g_pRefreshScheduler = NULL;
|
||
}
|
||
|
||
// Unconditional call to WSACleanup() will not cause any problem
|
||
// because it simply returns WSAEUNINITIALIZED.
|
||
//
|
||
WSACleanup ();
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_Cancel
|
||
|
||
History:
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT UlsLdap_Cancel ( ULONG uMsgID )
|
||
{
|
||
HRESULT hr = ILS_E_FAIL;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
if (g_pRespQueue == NULL || g_pReqQueue == NULL)
|
||
{
|
||
MyAssert (FALSE);
|
||
return ILS_E_FAIL;
|
||
}
|
||
|
||
// The locking order is
|
||
// Lock(PendingOpQueue), Lock(RequestQueue), Lock (CurrOp)
|
||
//
|
||
g_pRespQueue->WriteLock ();
|
||
g_pReqQueue->WriteLock ();
|
||
g_pReqQueue->LockCurrOp ();
|
||
|
||
// Redirect the call to the pending op queue object
|
||
//
|
||
hr = g_pRespQueue->Cancel (uMsgID);
|
||
if (hr != S_OK)
|
||
{
|
||
// Redirect the call to the request queue object
|
||
//
|
||
hr = g_pReqQueue->Cancel (uMsgID);
|
||
}
|
||
|
||
// Unlock is always in the reverse order of lock
|
||
//
|
||
g_pReqQueue->UnlockCurrOp ();
|
||
g_pReqQueue->WriteUnlock ();
|
||
g_pRespQueue->WriteUnlock ();
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_Cancel ( MARSHAL_REQ *pReq )
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_CANCEL);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
ULONG uRespID = (ULONG) MarshalReq_GetParam (pReq, 0);
|
||
|
||
// Cancelling in request queue is easy and done in UlsLdap_Cancel()
|
||
// because the request is not sent to the server yet.
|
||
// Cancelling in CurrOp is also easy because the request thread will
|
||
// find out that the current request is cancelled and then can call
|
||
// g_pRespQueue->Cancel() in the request thread (not UI thread).
|
||
// Cancelling in pending op queue is tricky. I have to marshal it to
|
||
// the request thread to do it. This is why AsynReq_Cancel is called!!!
|
||
|
||
// Redirect the call to the pending op queue object
|
||
//
|
||
if (g_pRespQueue != NULL)
|
||
{
|
||
hr = g_pRespQueue->Cancel (uRespID);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
}
|
||
|
||
return (LPARAM) hr;
|
||
}
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_RegisterClient
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Tested on ILS (7438)
|
||
1/14/97 Chu, Lon-Chan [lonchanc]
|
||
Collapsed user/app objects.
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT
|
||
UlsLdap_RegisterClient (
|
||
DWORD_PTR dwContext,
|
||
SERVER_INFO *pServer,
|
||
LDAP_CLIENTINFO *pInfo,
|
||
HANDLE *phClient,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Maks sure the server name is valid
|
||
//
|
||
if (MyIsBadServerInfo (pServer))
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the returned handle
|
||
//
|
||
if (phClient == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the client info structure is valid
|
||
//
|
||
#ifdef STRICT_CHECK
|
||
if (MyIsBadWritePtr (pInfo, sizeof (*pInfo)))
|
||
return ILS_E_POINTER;
|
||
#endif
|
||
|
||
// Make sure the unique id is valid
|
||
//
|
||
TCHAR *pszCN = (TCHAR *) ((BYTE *) pInfo + pInfo->uOffsetCN);
|
||
if (pInfo->uOffsetCN == INVALID_OFFSET || *pszCN == TEXT ('\0'))
|
||
return ILS_E_PARAMETER;
|
||
|
||
// Make sure no modify/remove extended attributes
|
||
// Registration only allows ToAdd
|
||
//
|
||
if (pInfo->cAttrsToModify != 0 || pInfo->cAttrsToRemove != 0)
|
||
return ILS_E_PARAMETER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cbServer = IlsGetLinearServerInfoSize (pServer);
|
||
ULONG cParams = 3;
|
||
ULONG cbSize = cbServer + pInfo->uSize;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_REGISTER_CLIENT, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Create a local client object
|
||
//
|
||
HRESULT hr;
|
||
SP_CClient *pClient = new SP_CClient (dwContext);
|
||
if (pClient == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Make sure this client object will not go away unexpectedly
|
||
//
|
||
pClient->AddRef ();
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParamServer (pReq, 0, pServer, cbServer);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD_PTR) pInfo, pInfo->uSize);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD_PTR) pClient, 0);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
MyExit:
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
*phClient = (HANDLE) pClient;
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_RegisterClient ( MARSHAL_REQ *pReq )
|
||
{
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_REGISTER_CLIENT);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SERVER_INFO *pServer = (SERVER_INFO *) MarshalReq_GetParam (pReq, 0);
|
||
LDAP_CLIENTINFO *pInfo = (LDAP_CLIENTINFO *) MarshalReq_GetParam (pReq, 1);
|
||
SP_CClient *pClient = (SP_CClient *) MarshalReq_GetParam (pReq, 2);
|
||
|
||
// Register the client object on the server
|
||
//
|
||
HRESULT hr = pClient->Register (pReq->uRespID, pServer, pInfo);
|
||
if (hr != S_OK)
|
||
{
|
||
// Release this newly allocated local user object
|
||
//
|
||
pClient->Release ();
|
||
}
|
||
|
||
return (LPARAM) hr;
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_RegisterProtocol
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Blocked by ILS (7438, 7442)
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT
|
||
UlsLdap_RegisterProtocol (
|
||
HANDLE hClient,
|
||
LDAP_PROTINFO *pInfo,
|
||
HANDLE *phProt,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Convert handle to pointer
|
||
//
|
||
SP_CClient *pClient = (SP_CClient *) hClient;
|
||
|
||
// Make sure the parent local app object is valid
|
||
//
|
||
if (MyIsBadWritePtr (pClient, sizeof (*pClient)) ||
|
||
! pClient->IsValidObject () ||
|
||
! pClient->IsRegistered ())
|
||
return ILS_E_HANDLE;
|
||
|
||
// Make sure the returned handle
|
||
//
|
||
if (phProt == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the prot info structure is valid
|
||
//
|
||
#ifdef STRICT_CHECK
|
||
if (MyIsBadWritePtr (pInfo, sizeof (*pInfo)))
|
||
return ILS_E_POINTER;
|
||
#endif
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the protocol name is valid
|
||
//
|
||
TCHAR *pszProtName = (TCHAR *) ((BYTE *) pInfo + pInfo->uOffsetName);
|
||
if (pInfo->uOffsetName == INVALID_OFFSET || *pszProtName == TEXT ('\0'))
|
||
return ILS_E_PARAMETER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cParams = 3;
|
||
ULONG cbSize = pInfo->uSize;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_REGISTER_PROTOCOL, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Create a local prot object
|
||
//
|
||
SP_CProtocol *pProt = new SP_CProtocol (pClient);
|
||
if (pProt == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Make sure the local prot object will not be deleted randomly
|
||
//
|
||
pProt->AddRef ();
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParam (pReq, 0, (DWORD_PTR) pClient, 0);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD_PTR) pInfo, pInfo->uSize);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD_PTR) pProt, 0);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
MyExit:
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
*phProt = (HANDLE) pProt;
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_RegisterProtocol ( MARSHAL_REQ *pReq )
|
||
{
|
||
HRESULT hr;
|
||
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_REGISTER_PROTOCOL);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SP_CClient *pClient = (SP_CClient *) MarshalReq_GetParam (pReq, 0);
|
||
LDAP_PROTINFO *pInfo = (LDAP_PROTINFO *) MarshalReq_GetParam (pReq, 1);
|
||
SP_CProtocol *pProt = (SP_CProtocol *) MarshalReq_GetParam (pReq, 2);
|
||
|
||
// Make sure the parent local app object is valid
|
||
//
|
||
if (MyIsBadWritePtr (pClient, sizeof (*pClient)) ||
|
||
! pClient->IsValidObject () ||
|
||
! pClient->IsRegistered ())
|
||
{
|
||
hr = ILS_E_HANDLE;
|
||
}
|
||
else
|
||
{
|
||
// Make the local prot object do prot registration
|
||
//
|
||
hr = pProt->Register (pReq->uRespID, pInfo);
|
||
if (hr != S_OK)
|
||
{
|
||
// Release the newly allocated local prot object
|
||
//
|
||
pProt->Release ();
|
||
}
|
||
}
|
||
|
||
return (LPARAM) hr;
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_RegisterMeeting
|
||
|
||
Input:
|
||
pszServer: A pointer to the server name.
|
||
pMeetInfo: A pointer to meeting info structure.
|
||
phMtg: A return meeting object handle.
|
||
pAsyncInfo: A pointer to async info structure.
|
||
|
||
History:
|
||
12/02/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
HRESULT
|
||
UlsLdap_RegisterMeeting (
|
||
DWORD dwContext,
|
||
SERVER_INFO *pServer,
|
||
LDAP_MEETINFO *pInfo,
|
||
HANDLE *phMtg,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Maks sure the server name is valid
|
||
//
|
||
if (MyIsBadServerInfo (pServer))
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the returned handle
|
||
//
|
||
if (phMtg == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the user info structure is valid
|
||
//
|
||
#ifdef STRICT_CHECK
|
||
if (MyIsBadWritePtr (pInfo, sizeof (*pInfo)))
|
||
return ILS_E_POINTER;
|
||
#endif
|
||
|
||
// Make sure the unique id is valid
|
||
//
|
||
TCHAR *pszName = (TCHAR *) ((BYTE *) pInfo + pInfo->uOffsetMeetingPlaceID);
|
||
if (pInfo->uOffsetMeetingPlaceID == INVALID_OFFSET || *pszName == TEXT ('\0'))
|
||
return ILS_E_PARAMETER;
|
||
|
||
// Make sure no modify/remove extended attributes
|
||
// Registration only allows ToAdd
|
||
//
|
||
if (pInfo->cAttrsToModify != 0 || pInfo->cAttrsToRemove != 0)
|
||
return ILS_E_PARAMETER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cbServer = IlsGetLinearServerInfoSize (pServer);
|
||
ULONG cParams = 3;
|
||
ULONG cbSize = cbServer + pInfo->uSize;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_REGISTER_MEETING, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Create a local user object
|
||
//
|
||
SP_CMeeting *pMtg = new SP_CMeeting (dwContext);
|
||
if (pMtg == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Make sure this local user object will not go away randomly
|
||
//
|
||
pMtg->AddRef ();
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParamServer (pReq, 0, pServer, cbServer);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD) pInfo, pInfo->uSize);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD) pMtg, 0);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
MyExit:
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
*phMtg = (HANDLE) pMtg;
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_RegisterMeeting ( MARSHAL_REQ *pReq )
|
||
{
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_REGISTER_MEETING);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SERVER_INFO *pServer = (SERVER_INFO *) MarshalReq_GetParam (pReq, 0);
|
||
LDAP_MEETINFO *pInfo = (LDAP_MEETINFO *) MarshalReq_GetParam (pReq, 1);
|
||
SP_CMeeting *pMtg = (SP_CMeeting *) MarshalReq_GetParam (pReq, 2);
|
||
|
||
// Make the local meeting object do meeting registration
|
||
//
|
||
HRESULT hr = pMtg->Register (pReq->uRespID, pServer, pInfo);
|
||
if (hr != S_OK)
|
||
{
|
||
// Release this newly allocated local user object
|
||
//
|
||
pMtg->Release ();
|
||
}
|
||
|
||
return (LPARAM) hr;
|
||
}
|
||
#endif // ENABLE_MEETING_PLACE
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_UnRegisterClient
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Tested on ILS (7438)
|
||
1/14/97 Chu, Lon-Chan [lonchanc]
|
||
Collapsed user/app objects.
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT
|
||
UlsLdap_UnRegisterClient (
|
||
HANDLE hClient,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Convert handle to pointer
|
||
//
|
||
SP_CClient *pClient = (SP_CClient *) hClient;
|
||
|
||
// Make sure the local client object is valid
|
||
//
|
||
if (MyIsBadWritePtr (pClient, sizeof (*pClient)) ||
|
||
! pClient->IsValidObject () ||
|
||
! pClient->IsRegistered ())
|
||
return ILS_E_HANDLE;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cParams = 1;
|
||
ULONG cbSize = 0;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_UNREGISTER_CLIENT, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParam (pReq, 0, (DWORD_PTR) pClient, 0);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_UnRegisterClient ( MARSHAL_REQ *pReq )
|
||
{
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_UNREGISTER_CLIENT);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SP_CClient *pClient = (SP_CClient *) MarshalReq_GetParam (pReq, 0);
|
||
|
||
// Make sure the local client object is valid
|
||
//
|
||
HRESULT hr;
|
||
if (MyIsBadWritePtr (pClient, sizeof (*pClient)) ||
|
||
! pClient->IsValidObject () ||
|
||
! pClient->IsRegistered ())
|
||
{
|
||
// When submitting this request, the client object is fine
|
||
// but now it is not, so it must have been unregistered and released.
|
||
//
|
||
MyAssert (FALSE); // to see if any one tries to break it this way!!!
|
||
hr = S_OK;
|
||
}
|
||
else
|
||
{
|
||
// Make the client object do user unregistration
|
||
//
|
||
hr = pClient->UnRegister (pReq->uRespID);
|
||
|
||
// Free this client object
|
||
//
|
||
pClient->Release ();
|
||
}
|
||
|
||
return (LPARAM) hr;
|
||
}
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_UnRegisterProtocol
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Tested on ILS (7438)
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT UlsLdap_VirtualUnRegisterProtocol ( HANDLE hProt )
|
||
{
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Convert handle to pointer
|
||
//
|
||
SP_CProtocol *pProt = (SP_CProtocol *) hProt;
|
||
|
||
// Make sure the local prot object is valid
|
||
//
|
||
if (MyIsBadWritePtr (pProt, sizeof (*pProt)))
|
||
return ILS_E_HANDLE;
|
||
|
||
// Free this local prot object
|
||
//
|
||
pProt->Release ();
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
HRESULT UlsLdap_UnRegisterProtocol (
|
||
HANDLE hProt,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Convert handle to pointer
|
||
//
|
||
SP_CProtocol *pProt = (SP_CProtocol *) hProt;
|
||
|
||
// Make sure the local prot object is valid
|
||
//
|
||
if (MyIsBadWritePtr (pProt, sizeof (*pProt)) ||
|
||
! pProt->IsValidObject () ||
|
||
! pProt->IsRegistered ())
|
||
return ILS_E_HANDLE;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cParams = 1;
|
||
ULONG cbSize = 0;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_UNREGISTER_PROTOCOL, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParam (pReq, 0, (DWORD_PTR) pProt, 0);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_UnRegisterProt ( MARSHAL_REQ *pReq )
|
||
{
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_UNREGISTER_PROTOCOL);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SP_CProtocol *pProt = (SP_CProtocol *) MarshalReq_GetParam (pReq, 0);
|
||
|
||
// Make sure the local prot object is valid
|
||
//
|
||
HRESULT hr;
|
||
if (MyIsBadWritePtr (pProt, sizeof (*pProt)) ||
|
||
! pProt->IsValidObject () ||
|
||
! pProt->IsRegistered ())
|
||
{
|
||
// When submitting this request, the client object is fine
|
||
// but now it is not, so it must have been unregistered and released.
|
||
//
|
||
MyAssert (FALSE); // to see if any one tries to break it this way!!!
|
||
hr = S_OK;
|
||
}
|
||
else
|
||
{
|
||
// Make the local prot object do prot unregistration
|
||
//
|
||
hr = pProt->UnRegister (pReq->uRespID);
|
||
|
||
// Free this local prot object
|
||
//
|
||
pProt->Release ();
|
||
}
|
||
|
||
return (LPARAM) hr;
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_UnRegisterMeeting
|
||
|
||
Input:
|
||
pszServer: server name.
|
||
hMeeting: a handle to the meeting object.
|
||
pAsyncInfo: a pointer to async info structure.
|
||
|
||
History:
|
||
12/02/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
HRESULT UlsLdap_UnRegisterMeeting (
|
||
HANDLE hMtg,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Convert handle to pointer
|
||
//
|
||
SP_CMeeting *pMtg = (SP_CMeeting *) hMtg;
|
||
|
||
// Make sure the local user object is valid
|
||
//
|
||
if (MyIsBadWritePtr (pMtg, sizeof (*pMtg)) ||
|
||
! pMtg->IsValidObject () ||
|
||
! pMtg->IsRegistered ())
|
||
return ILS_E_HANDLE;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cParams = 1;
|
||
ULONG cbSize = 0;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_UNREGISTER_MEETING, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParam (pReq, 0, (DWORD) pMtg, 0);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_UnRegisterMeeting ( MARSHAL_REQ *pReq )
|
||
{
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_UNREGISTER_MEETING);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SP_CMeeting *pMtg = (SP_CMeeting *) MarshalReq_GetParam (pReq, 0);
|
||
|
||
// Make sure the local user object is valid
|
||
//
|
||
HRESULT hr;
|
||
if (MyIsBadWritePtr (pMtg, sizeof (*pMtg)) ||
|
||
! pMtg->IsValidObject () ||
|
||
! pMtg->IsRegistered ())
|
||
{
|
||
// When submitting this request, the client object is fine
|
||
// but now it is not, so it must have been unregistered and released.
|
||
//
|
||
MyAssert (FALSE); // to see if any one tries to break it this way!!!
|
||
hr = S_OK;
|
||
}
|
||
else
|
||
{
|
||
// Make the local user object do user unregistration
|
||
//
|
||
hr = pMtg->UnRegister (pReq->uRespID);
|
||
|
||
// Free this local user object
|
||
//
|
||
pMtg->Release ();
|
||
}
|
||
|
||
return (LPARAM) hr;
|
||
}
|
||
#endif // ENABLE_MEETING_PLACE
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_SetClientInfo
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Tested on ILS (7438)
|
||
1/14/97 Chu, Lon-Chan [lonchanc]
|
||
Collapsed user/app objects.
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT
|
||
UlsLdap_SetClientInfo (
|
||
HANDLE hClient,
|
||
LDAP_CLIENTINFO *pInfo,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Convert handle to pointer
|
||
//
|
||
SP_CClient *pClient = (SP_CClient *) hClient;
|
||
|
||
// Make sure the client object is valid
|
||
//
|
||
if (MyIsBadWritePtr (pClient, sizeof (*pClient)) ||
|
||
! pClient->IsValidObject () ||
|
||
! pClient->IsRegistered ())
|
||
return ILS_E_HANDLE;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the user info structure is valid
|
||
//
|
||
#ifdef STRICT_CHECK
|
||
if (MyIsBadWritePtr (pInfo, sizeof (*pInfo)))
|
||
return ILS_E_POINTER;
|
||
#endif
|
||
|
||
// We should not change the app name here
|
||
//
|
||
if (pInfo->uOffsetAppName != INVALID_OFFSET || pInfo->uOffsetCN != INVALID_OFFSET)
|
||
return ILS_E_PARAMETER; // ILS_E_READ_ONLY;
|
||
|
||
// lonchanc: BUGS
|
||
// ISBU requires us to block any change of components of dn
|
||
//
|
||
pInfo->uOffsetCountryName = 0;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cParams = 2;
|
||
ULONG cbSize = pInfo->uSize;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_SET_CLIENT_INFO, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParam (pReq, 0, (DWORD_PTR) pClient, 0);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD_PTR) pInfo, pInfo->uSize);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_SetClientInfo ( MARSHAL_REQ *pReq )
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_SET_CLIENT_INFO);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SP_CClient *pClient = (SP_CClient *) MarshalReq_GetParam (pReq, 0);
|
||
LDAP_CLIENTINFO *pInfo = (LDAP_CLIENTINFO *) MarshalReq_GetParam (pReq, 1);
|
||
|
||
// Make sure the local client object is valid
|
||
//
|
||
if (MyIsBadWritePtr (pClient, sizeof (*pClient)) ||
|
||
! pClient->IsValidObject () ||
|
||
! pClient->IsRegistered ())
|
||
{
|
||
// When submitting this request, the client object is fine
|
||
// but now it is not, so it must have been unregistered and released.
|
||
//
|
||
MyAssert (FALSE); // to see if any one tries to break it this way!!!
|
||
hr = ILS_E_HANDLE;
|
||
}
|
||
else
|
||
{
|
||
// Set standard attributes
|
||
//
|
||
hr = pClient->SetAttributes (pReq->uRespID, pInfo);
|
||
}
|
||
|
||
return (LPARAM) hr;
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_SetProtocolInfo
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Blocked by ILS (7438, 7442)
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT UlsLdap_SetProtocolInfo (
|
||
HANDLE hProt,
|
||
LDAP_PROTINFO *pInfo,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Convert handle to pointer
|
||
//
|
||
SP_CProtocol *pProt = (SP_CProtocol *) hProt;
|
||
|
||
// Make sure the local prot object is valid
|
||
//
|
||
if (MyIsBadWritePtr (pProt, sizeof (*pProt)) ||
|
||
! pProt->IsValidObject () ||
|
||
! pProt->IsRegistered ())
|
||
return ILS_E_HANDLE;
|
||
|
||
// Make sure the prot info structure is valid
|
||
//
|
||
#ifdef STRICT_CHECK
|
||
if (MyIsBadWritePtr (pInfo, sizeof (*pInfo)))
|
||
return ILS_E_POINTER;
|
||
#endif
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cParams = 2;
|
||
ULONG cbSize = pInfo->uSize;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_SET_PROTOCOL_INFO, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParam (pReq, 0, (DWORD_PTR) pProt, 0);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD_PTR) pInfo, pInfo->uSize);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_SetProtocolInfo ( MARSHAL_REQ *pReq )
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_SET_PROTOCOL_INFO);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SP_CProtocol *pProt = (SP_CProtocol *) MarshalReq_GetParam (pReq, 0);
|
||
LDAP_PROTINFO *pInfo = (LDAP_PROTINFO *) MarshalReq_GetParam (pReq, 1);
|
||
|
||
// Make sure the local client object is valid
|
||
//
|
||
if (MyIsBadWritePtr (pProt, sizeof (*pProt)) ||
|
||
! pProt->IsValidObject () ||
|
||
! pProt->IsRegistered ())
|
||
{
|
||
// When submitting this request, the client object is fine
|
||
// but now it is not, so it must have been unregistered and released.
|
||
//
|
||
MyAssert (FALSE); // to see if any one tries to break it this way!!!
|
||
hr = ILS_E_HANDLE;
|
||
}
|
||
else
|
||
{
|
||
// Set standard attributes
|
||
//
|
||
hr = pProt->SetAttributes (pReq->uRespID, pInfo);
|
||
}
|
||
|
||
return (LPARAM) hr;
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_SetMeetingInfo
|
||
|
||
Input:
|
||
pszServer: A server name.
|
||
pszMtgName: A meeting id string.
|
||
pMeetInfo: A pointer to meeting info structure.
|
||
pAsyncInfo: A pointer to async info structure.
|
||
|
||
History:
|
||
12/02/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
HRESULT UlsLdap_SetMeetingInfo (
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszMtgName,
|
||
LDAP_MEETINFO *pInfo,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Make sure we have valid pointers
|
||
//
|
||
if (MyIsBadServerInfo (pServer) || MyIsBadString (pszMtgName))
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the app info structure is valid
|
||
//
|
||
#ifdef STRICT_CHECK
|
||
if (MyIsBadWritePtr (pInfo, sizeof (*pInfo)))
|
||
return ILS_E_POINTER;
|
||
#endif
|
||
|
||
// Make sure we do not change meeting name
|
||
//
|
||
if (pInfo->uOffsetMeetingPlaceID != 0)
|
||
return ILS_E_PARAMETER;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cbServer = IlsGetLinearServerInfoSize (pServer);
|
||
ULONG cbSizeMtgName = (lstrlen (pszMtgName) + 1) * sizeof (TCHAR);
|
||
ULONG cParams = 3;
|
||
ULONG cbSize = cbServer + cbSizeMtgName + pInfo->uSize;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_SET_MEETING_INFO, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParamServer (pReq, 0, pServer, cbServer);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD) pszMtgName, cbSizeMtgName);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD) pInfo, pInfo->uSize);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_SetMeetingInfo ( MARSHAL_REQ *pReq )
|
||
{
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_SET_MEETING_INFO);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SERVER_INFO *pServer = (SERVER_INFO *) MarshalReq_GetParam (pReq, 0);
|
||
TCHAR *pszMtgName = (TCHAR *) MarshalReq_GetParam (pReq, 1);
|
||
LDAP_MEETINFO *pInfo = (LDAP_MEETINFO *) MarshalReq_GetParam (pReq, 2);
|
||
|
||
MyAssert (! MyIsBadServerInfo (pServer));
|
||
MyAssert (MyIsGoodString (pszMtgName));
|
||
MyAssert (! MyIsBadWritePtr (pInfo, pInfo->uSize));
|
||
|
||
// Set standard/arbitrary attributes
|
||
//
|
||
return (LPARAM) MtgSetAttrs (pServer, pszMtgName, pInfo, pReq->uRespID);
|
||
}
|
||
#endif // ENABLE_MEETING_PLACE
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
My_EnumClientsEx
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Tested on ILS (7438)
|
||
1/14/97 Chu, Lon-Chan [lonchanc]
|
||
Collapsed user/app objects.
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT
|
||
My_EnumClientsEx (
|
||
ULONG uNotifyMsg,
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszAnyAttrNameList,
|
||
ULONG cAnyAttrNames,
|
||
TCHAR *pszFilter,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure we only deal with the following messages
|
||
//
|
||
MyAssert ( uNotifyMsg == WM_ILS_ENUM_CLIENTINFOS ||
|
||
uNotifyMsg == WM_ILS_ENUM_CLIENTS);
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Maks sure the server name is valid
|
||
//
|
||
if (MyIsBadServerInfo (pServer))
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cbServer = IlsGetLinearServerInfoSize (pServer);
|
||
ULONG cbSizeAnyAttrNames = 0;
|
||
TCHAR *psz = pszAnyAttrNameList;
|
||
ULONG cch;
|
||
for (ULONG i = 0; i < cAnyAttrNames; i++)
|
||
{
|
||
cch = lstrlen (psz) + 1;
|
||
cbSizeAnyAttrNames += cch * sizeof (TCHAR);
|
||
psz += cch;
|
||
}
|
||
ULONG cbSizeFilter = (pszFilter != NULL) ? (lstrlen (pszFilter) + 1) * sizeof (TCHAR) : 0;
|
||
ULONG cParams = 4;
|
||
ULONG cbSize = cbServer + cbSizeAnyAttrNames + cbSizeFilter;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (uNotifyMsg, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParamServer (pReq, 0, pServer, cbServer);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD_PTR) pszAnyAttrNameList, cbSizeAnyAttrNames);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD) cAnyAttrNames, 0);
|
||
MarshalReq_SetParam (pReq, 3, (DWORD_PTR) pszFilter, cbSizeFilter);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_EnumClientsEx ( MARSHAL_REQ *pReq )
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
ULONG uNotifyMsg = pReq->uNotifyMsg;
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SERVER_INFO *pServer = (SERVER_INFO *) MarshalReq_GetParam (pReq, 0);
|
||
TCHAR *pszAnyAttrNameList = (TCHAR *) MarshalReq_GetParam (pReq, 1);
|
||
ULONG cAnyAttrNames = (ULONG) MarshalReq_GetParam (pReq, 2);
|
||
TCHAR *pszFilter = (TCHAR *) MarshalReq_GetParam (pReq, 3);
|
||
|
||
// Clean locals
|
||
//
|
||
SP_CSession *pSession = NULL;
|
||
LDAP *ld;
|
||
ULONG uMsgID = (ULONG) -1;
|
||
|
||
// Create an array of names of attributes to return
|
||
//
|
||
TCHAR *apszAttrNames[COUNT_ENUM_DIR_CLIENT_INFO+1];
|
||
TCHAR **ppszNameList = &apszAttrNames[0];
|
||
ULONG cTotalNames;
|
||
|
||
// See the input filter string
|
||
//
|
||
if (pszFilter != NULL)
|
||
{
|
||
MyDebugMsg ((ZONE_FILTER, "EC: in-filter=[%s]\r\n", pszFilter));
|
||
}
|
||
|
||
// Create a enum client filter
|
||
//
|
||
pszFilter = AddBaseToFilter (pszFilter, STR_DEF_CLIENT_BASE_DN);
|
||
if (pszFilter == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// See the enhanced filter string
|
||
//
|
||
if (pszFilter != NULL)
|
||
{
|
||
MyDebugMsg ((ZONE_FILTER, "EC: out-filter=[%s]\r\n", pszFilter));
|
||
}
|
||
|
||
// Ask directory standard attributes only if enum client info
|
||
//
|
||
if (uNotifyMsg == WM_ILS_ENUM_CLIENTINFOS)
|
||
{
|
||
// Default total number of attributes
|
||
//
|
||
cTotalNames = COUNT_ENUM_DIR_CLIENT_INFO;
|
||
|
||
// Do we want any extended attribute to be returned?
|
||
//
|
||
if (pszAnyAttrNameList != NULL && cAnyAttrNames != 0)
|
||
{
|
||
// Prefix arbitrary attribute names
|
||
//
|
||
pszAnyAttrNameList = IlsPrefixNameValueArray (FALSE, cAnyAttrNames,
|
||
(const TCHAR *) pszAnyAttrNameList);
|
||
if (pszAnyAttrNameList == NULL)
|
||
{
|
||
MemFree (pszFilter);
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Allocate memory for returned attributes' names
|
||
//
|
||
cTotalNames += cAnyAttrNames;
|
||
ppszNameList = (TCHAR **) MemAlloc (sizeof (TCHAR *) * (cTotalNames + 1));
|
||
if (ppszNameList == NULL)
|
||
{
|
||
MemFree (pszFilter);
|
||
MemFree (pszAnyAttrNameList);
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
cTotalNames = 1;
|
||
}
|
||
|
||
// Ask to return cn only if enum names only
|
||
//
|
||
ppszNameList[0] = STR_CLIENT_CN;
|
||
|
||
// Add names of standard/extended attributes to return
|
||
//
|
||
if (uNotifyMsg == WM_ILS_ENUM_CLIENTINFOS)
|
||
{
|
||
// Set up standard attribtues now
|
||
//
|
||
for (ULONG i = 1; i < COUNT_ENUM_DIR_CLIENT_INFO; i++)
|
||
{
|
||
ppszNameList[i] = (TCHAR *) c_apszClientStdAttrNames[i];
|
||
}
|
||
|
||
// Set arbitrary attribute names if needed
|
||
//
|
||
TCHAR *psz = pszAnyAttrNameList;
|
||
for (i = COUNT_ENUM_DIR_CLIENT_INFO; i < cTotalNames; i++)
|
||
{
|
||
ppszNameList[i] = psz;
|
||
psz += lstrlen (psz) + 1;
|
||
}
|
||
}
|
||
|
||
// Terminate the list
|
||
//
|
||
ppszNameList[cTotalNames] = NULL;
|
||
|
||
// Get a session object
|
||
//
|
||
hr = g_pSessionContainer->GetSession (&pSession, pServer);
|
||
if (hr == S_OK)
|
||
{
|
||
// Get an ldap session
|
||
//
|
||
MyAssert (pSession != NULL);
|
||
ld = pSession->GetLd ();
|
||
MyAssert (ld != 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
|
||
//
|
||
uMsgID = ldap_search ( ld,
|
||
STR_DEF_CLIENT_BASE_DN, // base DN
|
||
LDAP_SCOPE_BASE, // scope
|
||
pszFilter, // filter
|
||
ppszNameList, // attrs[]
|
||
0); // both type and value
|
||
if (uMsgID == -1)
|
||
{
|
||
// This ldap_search failed.
|
||
// Convert ldap error code to hr
|
||
//
|
||
hr = ::LdapError2Hresult (ld->ld_errno);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
}
|
||
}
|
||
|
||
// Free the filter string
|
||
//
|
||
MemFree (pszFilter);
|
||
|
||
// Free the buffer holding all returned attribute names if needed
|
||
//
|
||
if (ppszNameList != &apszAttrNames[0])
|
||
MemFree (ppszNameList);
|
||
|
||
// Report failure if so
|
||
//
|
||
if (hr != S_OK)
|
||
{
|
||
// Free extended attribute name list
|
||
//
|
||
if (pszAnyAttrNameList != NULL && cAnyAttrNames != 0)
|
||
MemFree (pszAnyAttrNameList);
|
||
|
||
// Report failure
|
||
//
|
||
goto MyExit;
|
||
}
|
||
|
||
// Construct a pending info structure
|
||
//
|
||
RESP_INFO ri;
|
||
FillDefRespInfo (&ri, pReq->uRespID, ld, uMsgID, INVALID_MSG_ID);
|
||
ri.uNotifyMsg = uNotifyMsg;
|
||
ri.cAnyAttrs = cAnyAttrNames;
|
||
ri.pszAnyAttrNameList = pszAnyAttrNameList;
|
||
|
||
// Queue this pending response
|
||
//
|
||
hr = g_pRespQueue->EnterRequest (pSession, &ri);
|
||
if (hr != S_OK)
|
||
{
|
||
// Abort the ldap_search
|
||
//
|
||
ldap_abandon (ld, uMsgID);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
MyAssert (FALSE);
|
||
}
|
||
|
||
MyExit:
|
||
|
||
LDAP_ENUM *pEnum = NULL;
|
||
if (hr != S_OK)
|
||
{
|
||
pEnum = (LDAP_ENUM *) MemAlloc (sizeof (LDAP_ENUM));
|
||
if (pEnum != NULL)
|
||
{
|
||
pEnum->uSize = sizeof (*pEnum);
|
||
pEnum->hResult = hr;
|
||
}
|
||
}
|
||
|
||
return (LPARAM) pEnum;
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_EnumClients
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Tested on ILS (7438)
|
||
1/14/97 Chu, Lon-Chan [lonchanc]
|
||
Collapsed user/app objects.
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT
|
||
UlsLdap_EnumClients (
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszFilter,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
// Dispatch the call to a common subroutine
|
||
//
|
||
return My_EnumClientsEx (WM_ILS_ENUM_CLIENTS,
|
||
pServer,
|
||
NULL,
|
||
0,
|
||
pszFilter,
|
||
pAsyncInfo);
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_EnumClientInfos
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Tested on ILS (7438)
|
||
1/14/97 Chu, Lon-Chan [lonchanc]
|
||
Collapsed user/app objects.
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT
|
||
UlsLdap_EnumClientInfos (
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszAnyAttrNameList,
|
||
ULONG cAnyAttrNames,
|
||
TCHAR *pszFilter,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
// Dispatch the call to a common subroutine
|
||
//
|
||
return My_EnumClientsEx (WM_ILS_ENUM_CLIENTINFOS,
|
||
pServer,
|
||
pszAnyAttrNameList,
|
||
cAnyAttrNames,
|
||
pszFilter,
|
||
pAsyncInfo);
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_EnumProtocols
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Blocked by ILS (7438, 7442)
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT
|
||
UlsLdap_EnumProtocols (
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszUserName,
|
||
TCHAR *pszAppName,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
if (MyIsBadServerInfo (pServer) || MyIsBadString (pszUserName) ||
|
||
MyIsBadString (pszAppName))
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cbServer = IlsGetLinearServerInfoSize (pServer);
|
||
ULONG cbSizeUserName = (lstrlen (pszUserName) + 1) * sizeof (TCHAR);
|
||
ULONG cbSizeAppName = (lstrlen (pszAppName) + 1) * sizeof (TCHAR);
|
||
ULONG cParams = 3;
|
||
ULONG cbSize = cbServer + cbSizeUserName + cbSizeAppName;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_ENUM_PROTOCOLS, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParamServer (pReq, 0, pServer, cbServer);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD_PTR) pszUserName, cbSizeUserName);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD_PTR) pszAppName, cbSizeAppName);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_EnumProtocols ( MARSHAL_REQ *pReq )
|
||
{
|
||
HRESULT hr = S_OK;
|
||
SP_CSession *pSession = NULL;
|
||
LDAP *ld;
|
||
ULONG uMsgID = (ULONG) -1;
|
||
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_ENUM_PROTOCOLS);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SERVER_INFO *pServer = (SERVER_INFO *) MarshalReq_GetParam (pReq, 0);
|
||
TCHAR *pszUserName = (TCHAR *) MarshalReq_GetParam (pReq, 1);
|
||
TCHAR *pszAppName = (TCHAR *) MarshalReq_GetParam (pReq, 2);
|
||
|
||
// Create enum protocols filter
|
||
//
|
||
TCHAR *pszFilter = ProtCreateEnumFilter (pszUserName, pszAppName);
|
||
if (pszFilter == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Get the session object
|
||
//
|
||
hr = g_pSessionContainer->GetSession (&pSession, pServer);
|
||
if (hr != S_OK)
|
||
{
|
||
MemFree (pszFilter);
|
||
goto MyExit;
|
||
}
|
||
MyAssert (pSession != NULL);
|
||
|
||
// Get an ldap session
|
||
//
|
||
ld = pSession->GetLd ();
|
||
MyAssert (ld != NULL);
|
||
|
||
// Create an array of names of attributes to return
|
||
//
|
||
TCHAR *apszAttrNames[2];
|
||
apszAttrNames[0] = (TCHAR *) c_apszProtStdAttrNames[ENUM_PROTATTR_NAME];
|
||
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 the search query
|
||
//
|
||
uMsgID = ldap_search (ld, (TCHAR *) &c_szDefClientBaseDN[0], // base DN
|
||
LDAP_SCOPE_BASE, // scope
|
||
pszFilter,
|
||
&apszAttrNames[0], // attrs[]
|
||
0); // both type and value
|
||
// Free the search filter
|
||
//
|
||
MemFree (pszFilter);
|
||
|
||
// Check the return of ldap_search
|
||
//
|
||
if (uMsgID == -1)
|
||
{
|
||
// This ldap_search failed.
|
||
// Convert ldap error code to hr
|
||
//
|
||
hr = ::LdapError2Hresult (ld->ld_errno);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
goto MyExit;
|
||
}
|
||
|
||
// Construct a pending info structure
|
||
//
|
||
RESP_INFO ri;
|
||
FillDefRespInfo (&ri, pReq->uRespID, ld, uMsgID, INVALID_MSG_ID);
|
||
ri.uNotifyMsg = WM_ILS_ENUM_PROTOCOLS;
|
||
|
||
// Queue this pending response
|
||
//
|
||
hr = g_pRespQueue->EnterRequest (pSession, &ri);
|
||
if (hr != S_OK)
|
||
{
|
||
// Abort the ldap_search
|
||
//
|
||
ldap_abandon (ld, uMsgID);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
MyAssert (FALSE);
|
||
}
|
||
|
||
MyExit:
|
||
|
||
LDAP_ENUM *pEnum = NULL;
|
||
if (hr != S_OK)
|
||
{
|
||
pEnum = (LDAP_ENUM *) MemAlloc (sizeof (LDAP_ENUM));
|
||
if (pEnum != NULL)
|
||
{
|
||
pEnum->uSize = sizeof (*pEnum);
|
||
pEnum->hResult = hr;
|
||
}
|
||
}
|
||
|
||
return (LPARAM) pEnum;
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
My_EnumMtgsEx
|
||
|
||
Input:
|
||
uNotifyMsg: A notification message.
|
||
pszServer: A pointer to the server name.
|
||
pszFilter: A pointer to a filter string.
|
||
pAsyncInfo: A pointer to async info structure.
|
||
|
||
History:
|
||
12/02/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
HRESULT
|
||
My_EnumMtgsEx (
|
||
ULONG uNotifyMsg,
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszAnyAttrNameList,
|
||
ULONG cAnyAttrNames,
|
||
TCHAR *pszFilter,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure we only deal with the following messages
|
||
//
|
||
MyAssert ( uNotifyMsg == WM_ILS_ENUM_MEETINGINFOS ||
|
||
uNotifyMsg == WM_ILS_ENUM_MEETINGS);
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Maks sure the server name is valid
|
||
//
|
||
if (MyIsBadServerInfo (pServer))
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cbServer = IlsGetLinearServerInfoSize (pServer);
|
||
ULONG cbSizeAnyAttrNames = 0;
|
||
TCHAR *psz = pszAnyAttrNameList;
|
||
ULONG cch;
|
||
for (ULONG i = 0; i < cAnyAttrNames; i++)
|
||
{
|
||
cch = lstrlen (psz) + 1;
|
||
cbSizeAnyAttrNames += cch * sizeof (TCHAR);
|
||
psz += cch;
|
||
}
|
||
ULONG cbSizeFilter = (pszFilter != NULL) ? (lstrlen (pszFilter) + 1) * sizeof (TCHAR) : 0;
|
||
ULONG cParams = 4;
|
||
ULONG cbSize = cbServer + cbSizeAnyAttrNames + cbSizeFilter;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (uNotifyMsg, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParamServer (pReq, 0, pServer, cbServer);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD) pszAnyAttrNameList, cbSizeAnyAttrNames);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD) cAnyAttrNames, 0);
|
||
MarshalReq_SetParam (pReq, 3, (DWORD) pszFilter, cbSizeFilter);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_EnumMtgsEx ( MARSHAL_REQ *pReq )
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
ULONG uNotifyMsg = pReq->uNotifyMsg;
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SERVER_INFO *pServer = (SERVER_INFO *) MarshalReq_GetParam (pReq, 0);
|
||
TCHAR *pszAnyAttrNameList = (TCHAR *) MarshalReq_GetParam (pReq, 1);
|
||
ULONG cAnyAttrNames = (ULONG) MarshalReq_GetParam (pReq, 2);
|
||
TCHAR *pszFilter = (TCHAR *) MarshalReq_GetParam (pReq, 3);
|
||
|
||
// Clean locals
|
||
//
|
||
SP_CSession *pSession = NULL;
|
||
LDAP *ld;
|
||
ULONG uMsgID = (ULONG) -1;
|
||
|
||
// Create an array of names of attributes to return
|
||
//
|
||
TCHAR *apszAttrNames[COUNT_ENUM_DIRMTGINFO+1];
|
||
TCHAR **ppszNameList = &apszAttrNames[0];
|
||
ULONG cTotalNames;
|
||
|
||
// See the input filter string
|
||
//
|
||
if (pszFilter != NULL)
|
||
{
|
||
MyDebugMsg ((ZONE_FILTER, "EU: in-filter=[%s]\r\n", pszFilter));
|
||
}
|
||
|
||
// Create a enum user filter
|
||
//
|
||
pszFilter = AddBaseToFilter (pszFilter, &c_szDefMtgBaseDN[0]);
|
||
if (pszFilter == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// See the enhanced filter string
|
||
//
|
||
if (pszFilter != NULL)
|
||
{
|
||
MyDebugMsg ((ZONE_FILTER, "EU: out-filter=[%s]\r\n", pszFilter));
|
||
}
|
||
|
||
// Ask directory standard attributes only if enum dir user info
|
||
//
|
||
if (uNotifyMsg == WM_ILS_ENUM_MEETINGINFOS)
|
||
{
|
||
// Default total number of attributes
|
||
//
|
||
cTotalNames = COUNT_ENUM_DIRMTGINFO;
|
||
|
||
// Do we want any extended attribute to be returned?
|
||
//
|
||
if (pszAnyAttrNameList != NULL && cAnyAttrNames != 0)
|
||
{
|
||
// Prefix arbitrary attribute names
|
||
//
|
||
pszAnyAttrNameList = IlsPrefixNameValueArray (FALSE, cAnyAttrNames,
|
||
(const TCHAR *) pszAnyAttrNameList);
|
||
if (pszAnyAttrNameList == NULL)
|
||
{
|
||
MemFree (pszFilter);
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Allocate memory for returned attributes' names
|
||
//
|
||
cTotalNames += cAnyAttrNames;
|
||
ppszNameList = (TCHAR **) MemAlloc (sizeof (TCHAR *) * (cTotalNames + 1));
|
||
if (ppszNameList == NULL)
|
||
{
|
||
MemFree (pszFilter);
|
||
MemFree (pszAnyAttrNameList);
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
cTotalNames = 1;
|
||
}
|
||
|
||
// Ask to return cn only if enum names only
|
||
//
|
||
ppszNameList[0] = STR_MTG_NAME;
|
||
|
||
// Add names of standard/extended attributes to return
|
||
//
|
||
if (uNotifyMsg == WM_ILS_ENUM_MEETINGINFOS)
|
||
{
|
||
// Set up standard attribtues now
|
||
//
|
||
for (ULONG i = 1; i < COUNT_ENUM_DIRMTGINFO; i++)
|
||
{
|
||
ppszNameList[i] = (TCHAR *) c_apszMtgStdAttrNames[i];
|
||
}
|
||
|
||
// Set arbitrary attribute names if needed
|
||
//
|
||
TCHAR *psz = pszAnyAttrNameList;
|
||
for (i = COUNT_ENUM_DIRMTGINFO; i < cTotalNames; i++)
|
||
{
|
||
ppszNameList[i] = psz;
|
||
psz += lstrlen (psz) + 1;
|
||
}
|
||
}
|
||
|
||
// Terminate the list
|
||
//
|
||
ppszNameList[cTotalNames] = NULL;
|
||
|
||
// Get a session object
|
||
//
|
||
hr = g_pSessionContainer->GetSession (&pSession, pServer);
|
||
if (hr == S_OK)
|
||
{
|
||
// Get an ldap session
|
||
//
|
||
MyAssert (pSession != NULL);
|
||
ld = pSession->GetLd ();
|
||
MyAssert (ld != 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
|
||
//
|
||
uMsgID = ldap_search (ld, (TCHAR *) &c_szDefMtgBaseDN[0], // base DN
|
||
LDAP_SCOPE_BASE, // scope
|
||
pszFilter, // filter
|
||
ppszNameList, // attrs[]
|
||
0); // both type and value
|
||
if (uMsgID == -1)
|
||
{
|
||
// This ldap_search failed.
|
||
// Convert ldap error code to hr
|
||
//
|
||
hr = ::LdapError2Hresult (ld->ld_errno);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
}
|
||
}
|
||
|
||
// Free the filter string
|
||
//
|
||
MemFree (pszFilter);
|
||
|
||
// Free the buffer holding all returned attribute names if needed
|
||
//
|
||
if (ppszNameList != &apszAttrNames[0])
|
||
MemFree (ppszNameList);
|
||
|
||
// Report failure if so
|
||
//
|
||
if (hr != S_OK)
|
||
{
|
||
// Free extended attribute name list
|
||
//
|
||
if (pszAnyAttrNameList != NULL && cAnyAttrNames != 0)
|
||
MemFree (pszAnyAttrNameList);
|
||
|
||
// Report failure
|
||
//
|
||
goto MyExit;
|
||
}
|
||
|
||
// Construct a pending info structure
|
||
//
|
||
RESP_INFO ri;
|
||
FillDefRespInfo (&ri, pReq->uRespID, ld, uMsgID, INVALID_MSG_ID);
|
||
ri.uNotifyMsg = uNotifyMsg;
|
||
ri.cAnyAttrs = cAnyAttrNames;
|
||
|
||
// Queue this pending response
|
||
//
|
||
hr = g_pRespQueue->EnterRequest (pSession, &ri);
|
||
if (hr != S_OK)
|
||
{
|
||
// Abort the ldap_search
|
||
//
|
||
ldap_abandon (ld, uMsgID);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
MyAssert (FALSE);
|
||
}
|
||
|
||
MyExit:
|
||
|
||
LDAP_ENUM *pEnum = NULL;
|
||
if (hr != S_OK)
|
||
{
|
||
pEnum = (LDAP_ENUM *) MemAlloc (sizeof (LDAP_ENUM));
|
||
if (pEnum != NULL)
|
||
{
|
||
pEnum->uSize = sizeof (*pEnum);
|
||
pEnum->hResult = hr;
|
||
}
|
||
}
|
||
|
||
return (LPARAM) pEnum;
|
||
}
|
||
#endif // ENABLE_MEETING_PLACE
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_EnumMeetingInfos
|
||
|
||
Input:
|
||
pszServer: server name.
|
||
pszFilter: a filter string.
|
||
pAsyncInfo: a pointer to async info structure.
|
||
|
||
History:
|
||
12/02/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
HRESULT
|
||
UlsLdap_EnumMeetingInfos (
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszAnyAttrNameList,
|
||
ULONG cAnyAttrNames,
|
||
TCHAR *pszFilter,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
// Dispatch the call to a common subroutine
|
||
//
|
||
return My_EnumMtgsEx (WM_ILS_ENUM_MEETINGINFOS,
|
||
pServer,
|
||
pszAnyAttrNameList,
|
||
cAnyAttrNames,
|
||
pszFilter,
|
||
pAsyncInfo);
|
||
}
|
||
#endif // ENABLE_MEETING_PLACE
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_EnumMeetings
|
||
|
||
Input:
|
||
pszServer: server name.
|
||
pszFilter: a filter string.
|
||
pAsyncInfo: a pointer to async info structure.
|
||
|
||
History:
|
||
12/02/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
HRESULT
|
||
UlsLdap_EnumMeetings (
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszFilter,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Dispatch the call to a common subroutine
|
||
//
|
||
return My_EnumMtgsEx (WM_ILS_ENUM_MEETINGS,
|
||
pServer,
|
||
NULL,
|
||
0,
|
||
pszFilter,
|
||
pAsyncInfo);
|
||
}
|
||
#endif // ENABLE_MEETING_PLACE
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_EnumAttendee
|
||
|
||
Input:
|
||
pszServer: server name.
|
||
pszMeetingID: a meeting id string.
|
||
pszFilter: a filter string.
|
||
pAsyncInfo: a pointer to async info structure.
|
||
|
||
History:
|
||
12/02/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
HRESULT
|
||
UlsLdap_EnumAttendees(
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszMtgName,
|
||
TCHAR *pszFilter,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
if (MyIsBadServerInfo (pServer) || MyIsBadString (pszMtgName))
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cbServer = IlsGetLinearServerInfoSize (pServer);
|
||
ULONG cbSizeMtgName = (lstrlen (pszMtgName) + 1) * sizeof (TCHAR);
|
||
ULONG cbSizeFilter = (pszFilter != NULL) ? (lstrlen (pszFilter) + 1) * sizeof (TCHAR) : 0;
|
||
ULONG cParams = 3;
|
||
ULONG cbSize = cbServer + cbSizeMtgName + cbSizeFilter;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_ENUM_ATTENDEES, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParamServer (pReq, 0, pServer, cbServer);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD) pszMtgName, cbSizeMtgName);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD) pszFilter, cbSizeFilter);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_EnumAttendees ( MARSHAL_REQ *pReq )
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_ENUM_ATTENDEES);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SERVER_INFO *pServer = (SERVER_INFO *) MarshalReq_GetParam (pReq, 0);
|
||
TCHAR *pszMtgName = (TCHAR *) MarshalReq_GetParam (pReq, 1);
|
||
TCHAR *pszFilter = (TCHAR *) MarshalReq_GetParam (pReq, 2);
|
||
|
||
// Clean up locals
|
||
//
|
||
SP_CSession *pSession = NULL;
|
||
LDAP *ld;
|
||
ULONG uMsgID = (ULONG) -1;
|
||
|
||
// BUGS: ignore the input filter
|
||
//
|
||
pszFilter = MtgCreateEnumMembersFilter (pszMtgName);
|
||
if (pszFilter == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Create an array of names of attributes to return
|
||
//
|
||
TCHAR *apszAttrNames[3];
|
||
apszAttrNames[0] = STR_MTG_NAME;
|
||
apszAttrNames[1] = (TCHAR *) c_apszMtgStdAttrNames[ENUM_MTGATTR_MEMBERS];
|
||
apszAttrNames[2] = NULL;
|
||
|
||
// Get the session object
|
||
//
|
||
hr = g_pSessionContainer->GetSession (&pSession, pServer);
|
||
if (hr != S_OK)
|
||
{
|
||
MemFree (pszFilter);
|
||
goto MyExit;
|
||
}
|
||
MyAssert (pSession != NULL);
|
||
|
||
// Get an ldap session
|
||
//
|
||
ld = pSession->GetLd ();
|
||
MyAssert (ld != 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 the search query
|
||
//
|
||
uMsgID = ldap_search (ld, (TCHAR *) &c_szDefMtgBaseDN[0], // base DN
|
||
LDAP_SCOPE_BASE, // scope
|
||
pszFilter,
|
||
&apszAttrNames[0], // attrs[]
|
||
0); // both type and value
|
||
|
||
// Free the search filter
|
||
//
|
||
MemFree (pszFilter);
|
||
|
||
// Check the return of ldap_search
|
||
//
|
||
if (uMsgID == -1)
|
||
{
|
||
// This ldap_search failed.
|
||
// Convert ldap error code to hr
|
||
//
|
||
hr = ::LdapError2Hresult (ld->ld_errno);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
goto MyExit;
|
||
}
|
||
|
||
// Construct a pending info structure
|
||
//
|
||
RESP_INFO ri;
|
||
FillDefRespInfo (&ri, pReq->uRespID, ld, uMsgID, INVALID_MSG_ID);
|
||
ri.uNotifyMsg = WM_ILS_ENUM_ATTENDEES;
|
||
|
||
// Queue this pending response
|
||
//
|
||
hr = g_pRespQueue->EnterRequest (pSession, &ri);
|
||
if (hr != S_OK)
|
||
{
|
||
// Abort the ldap_search
|
||
//
|
||
ldap_abandon (ld, uMsgID);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
MyAssert (FALSE);
|
||
}
|
||
|
||
MyExit:
|
||
|
||
LDAP_ENUM *pEnum = NULL;
|
||
if (hr != S_OK)
|
||
{
|
||
pEnum = (LDAP_ENUM *) MemAlloc (sizeof (LDAP_ENUM));
|
||
if (pEnum != NULL)
|
||
{
|
||
pEnum->uSize = sizeof (*pEnum);
|
||
pEnum->hResult = hr;
|
||
}
|
||
}
|
||
|
||
return (LPARAM) pEnum;
|
||
}
|
||
#endif // ENABLE_MEETING_PLACE
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_ResolveClient
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Tested on ILS (7438)
|
||
1/14/97 Chu, Lon-Chan [lonchanc]
|
||
Collapsed user/app objects.
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT
|
||
UlsLdap_ResolveClient (
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszCN,
|
||
TCHAR *pszAppName,
|
||
TCHAR *pszProtName,
|
||
TCHAR *pszAnyAttrNameList,
|
||
ULONG cAnyAttrNames,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Maks sure the server name is valid
|
||
//
|
||
if (MyIsBadServerInfo (pServer))
|
||
return ILS_E_POINTER;
|
||
|
||
// Maks sure the user name is valid
|
||
//
|
||
if (MyIsBadString (pszCN))
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cbServer = IlsGetLinearServerInfoSize (pServer);
|
||
ULONG cbSizeCN = (lstrlen (pszCN) + 1) * sizeof (TCHAR);
|
||
ULONG cbSizeAppName = (pszAppName != NULL) ? (lstrlen (pszAppName) + 1) * sizeof (TCHAR) : 0;
|
||
ULONG cbSizeProtName = (pszProtName != NULL) ? (lstrlen (pszProtName) + 1) * sizeof (TCHAR) : 0;
|
||
ULONG cbSizeAnyAttrNames = 0;
|
||
TCHAR *psz = pszAnyAttrNameList;
|
||
ULONG cch;
|
||
for (ULONG i = 0; i < cAnyAttrNames; i++)
|
||
{
|
||
cch = lstrlen (psz) + 1;
|
||
cbSizeAnyAttrNames += cch * sizeof (TCHAR);
|
||
psz += cch;
|
||
}
|
||
ULONG cParams = 6;
|
||
ULONG cbSize = cbServer + cbSizeCN + cbSizeAppName + cbSizeProtName + cbSizeAnyAttrNames;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_RESOLVE_CLIENT, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParamServer (pReq, 0, pServer, cbServer);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD_PTR) pszCN, cbSizeCN);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD_PTR) pszAppName, cbSizeAppName);
|
||
MarshalReq_SetParam (pReq, 3, (DWORD_PTR) pszProtName, cbSizeProtName);
|
||
MarshalReq_SetParam (pReq, 4, (DWORD_PTR) pszAnyAttrNameList, cbSizeAnyAttrNames);
|
||
MarshalReq_SetParam (pReq, 5, (DWORD) cAnyAttrNames, 0);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_ResolveClient ( MARSHAL_REQ *pReq )
|
||
{
|
||
HRESULT hr = S_OK;
|
||
SP_CSession *pSession = NULL;
|
||
LDAP *ld;
|
||
ULONG uMsgID = (ULONG) -1;
|
||
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_RESOLVE_CLIENT);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SERVER_INFO *pServer = (SERVER_INFO *) MarshalReq_GetParam (pReq, 0);
|
||
TCHAR *pszCN = (TCHAR *) MarshalReq_GetParam (pReq, 1);
|
||
TCHAR *pszAppName = (TCHAR *) MarshalReq_GetParam (pReq, 2);
|
||
TCHAR *pszProtName = (TCHAR *) MarshalReq_GetParam (pReq, 3);
|
||
TCHAR *pszAnyAttrNameList = (TCHAR *) MarshalReq_GetParam (pReq, 4);
|
||
ULONG cAnyAttrNames = (ULONG) MarshalReq_GetParam (pReq, 5);
|
||
|
||
// Create a resolve client filter
|
||
//
|
||
TCHAR *pszFilter = ClntCreateResolveFilter (pszCN, pszAppName, pszProtName);
|
||
if (pszFilter == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Create an array of names of attributes to return
|
||
//
|
||
TCHAR *apszAttrNames[COUNT_ENUM_RES_CLIENT_INFO+1];
|
||
TCHAR **ppszNameList;
|
||
ppszNameList = &apszAttrNames[0];
|
||
ULONG cTotalNames;
|
||
cTotalNames = COUNT_ENUM_RES_CLIENT_INFO;
|
||
if (pszAnyAttrNameList != NULL && cAnyAttrNames != 0)
|
||
{
|
||
// Prefix arbitrary attribute names
|
||
//
|
||
pszAnyAttrNameList = IlsPrefixNameValueArray (FALSE, cAnyAttrNames,
|
||
(const TCHAR *) pszAnyAttrNameList);
|
||
if (pszAnyAttrNameList == NULL)
|
||
{
|
||
MemFree (pszFilter);
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// NOTE that pszAnyAttrNameList must be freed if failed in this routine
|
||
// If success, it will be freed in notification.
|
||
|
||
// Allocate memory for keeping returned attributes' names
|
||
//
|
||
cTotalNames += cAnyAttrNames;
|
||
ppszNameList = (TCHAR **) MemAlloc (sizeof (TCHAR *) * (cTotalNames + 1));
|
||
if (ppszNameList == NULL)
|
||
{
|
||
MemFree (pszFilter);
|
||
MemFree (pszAnyAttrNameList);
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
}
|
||
|
||
// Set standard attribute names
|
||
//
|
||
ULONG i;
|
||
for (i = 0; i < COUNT_ENUM_RES_CLIENT_INFO; i++)
|
||
{
|
||
ppszNameList[i] = (TCHAR *) c_apszClientStdAttrNames[i];
|
||
}
|
||
|
||
// Set arbitrary attribute names if needed
|
||
//
|
||
TCHAR *psz;
|
||
psz = pszAnyAttrNameList;
|
||
for (i = COUNT_ENUM_RES_CLIENT_INFO; i < cTotalNames; i++)
|
||
{
|
||
ppszNameList[i] = psz;
|
||
psz += lstrlen (psz) + 1;
|
||
}
|
||
|
||
// Terminate the list
|
||
//
|
||
ppszNameList[cTotalNames] = NULL;
|
||
|
||
// Get the session object
|
||
//
|
||
hr = g_pSessionContainer->GetSession (&pSession, pServer);
|
||
if (hr == S_OK)
|
||
{
|
||
// Get an ldap session
|
||
//
|
||
MyAssert (pSession != NULL);
|
||
ld = pSession->GetLd ();
|
||
MyAssert (ld != 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 the search query
|
||
//
|
||
uMsgID = ldap_search ( ld,
|
||
(TCHAR *) &c_szDefClientBaseDN[0], // base DN
|
||
LDAP_SCOPE_BASE, // scope
|
||
pszFilter, // filter
|
||
ppszNameList, // attrs[]
|
||
0); // both type and value
|
||
if (uMsgID == -1)
|
||
{
|
||
// This ldap_search failed.
|
||
// Convert ldap error code to hr
|
||
//
|
||
hr = ::LdapError2Hresult (ld->ld_errno);
|
||
MyAssert (hr != S_OK);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
}
|
||
}
|
||
|
||
// Free the filter string
|
||
//
|
||
MemFree (pszFilter);
|
||
|
||
// Free the buffer holding all returned attribute names if needed
|
||
//
|
||
if (ppszNameList != &apszAttrNames[0])
|
||
MemFree (ppszNameList);
|
||
|
||
// If failed, exit with cleanup
|
||
//
|
||
if (hr != S_OK)
|
||
{
|
||
// Free extended attribute names list if needed
|
||
//
|
||
if (pszAnyAttrNameList != NULL && cAnyAttrNames != 0)
|
||
MemFree (pszAnyAttrNameList);
|
||
|
||
// Report failure
|
||
//
|
||
goto MyExit;
|
||
}
|
||
|
||
// Construct a pending info structure
|
||
//
|
||
RESP_INFO ri;
|
||
FillDefRespInfo (&ri, pReq->uRespID, ld, uMsgID, INVALID_MSG_ID);
|
||
ri.uNotifyMsg = WM_ILS_RESOLVE_CLIENT;
|
||
ri.cAnyAttrs = cAnyAttrNames;
|
||
ri.pszAnyAttrNameList = pszAnyAttrNameList;
|
||
|
||
// Queue this pending response
|
||
//
|
||
hr = g_pRespQueue->EnterRequest (pSession, &ri);
|
||
if (hr != S_OK)
|
||
{
|
||
// Abort the ldap_search
|
||
//
|
||
ldap_abandon (ld, uMsgID);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
MyAssert (FALSE);
|
||
}
|
||
|
||
MyExit:
|
||
|
||
LDAP_CLIENTINFO_RES *pcir = NULL;
|
||
if (hr != S_OK)
|
||
{
|
||
pcir = (LDAP_CLIENTINFO_RES *) MemAlloc (sizeof (LDAP_CLIENTINFO_RES));
|
||
if (pcir != NULL)
|
||
{
|
||
pcir->uSize = sizeof (*pcir);
|
||
pcir->hResult = hr;
|
||
}
|
||
}
|
||
|
||
return (LPARAM) pcir;
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_ResolveProtocol
|
||
|
||
History:
|
||
10/15/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
10/30/96 Chu, Lon-Chan [lonchanc]
|
||
Blocked by ILS (7438, 7442)
|
||
---------------------------------------------------------------------- */
|
||
|
||
HRESULT UlsLdap_ResolveProtocol (
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszUserName,
|
||
TCHAR *pszAppName,
|
||
TCHAR *pszProtName,
|
||
TCHAR *pszAnyAttrNameList,
|
||
ULONG cAnyAttrNames,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
if (MyIsBadServerInfo (pServer) || MyIsBadString (pszUserName) ||
|
||
MyIsBadString (pszAppName) || MyIsBadString (pszProtName) ||
|
||
pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cbServer = IlsGetLinearServerInfoSize (pServer);
|
||
ULONG cbSizeUserName = (lstrlen (pszUserName) + 1) * sizeof (TCHAR);
|
||
ULONG cbSizeAppName = (lstrlen (pszAppName) + 1) * sizeof (TCHAR);
|
||
ULONG cbSizeProtName = (lstrlen (pszProtName) + 1) * sizeof (TCHAR);
|
||
ULONG cbSizeAnyAttrNames = 0;
|
||
TCHAR *psz = pszAnyAttrNameList;
|
||
ULONG cch;
|
||
for (ULONG i = 0; i < cAnyAttrNames; i++)
|
||
{
|
||
cch = lstrlen (psz) + 1;
|
||
cbSizeAnyAttrNames += cch * sizeof (TCHAR);
|
||
psz += cch;
|
||
}
|
||
ULONG cParams = 6;
|
||
ULONG cbSize = cbServer + cbSizeUserName + cbSizeAppName +
|
||
cbSizeProtName + cbSizeAnyAttrNames;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_RESOLVE_PROTOCOL, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParamServer (pReq, 0, pServer, cbServer);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD_PTR) pszUserName, cbSizeUserName);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD_PTR) pszAppName, cbSizeAppName);
|
||
MarshalReq_SetParam (pReq, 3, (DWORD_PTR) pszProtName, cbSizeProtName);
|
||
MarshalReq_SetParam (pReq, 4, (DWORD_PTR) pszAnyAttrNameList, cbSizeAnyAttrNames);
|
||
MarshalReq_SetParam (pReq, 5, (DWORD) cAnyAttrNames, 0);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_ResolveProtocol ( MARSHAL_REQ *pReq )
|
||
{
|
||
HRESULT hr = S_OK;
|
||
SP_CSession *pSession = NULL;
|
||
LDAP *ld;
|
||
ULONG uMsgID = (ULONG) -1;
|
||
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_RESOLVE_PROTOCOL);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SERVER_INFO *pServer = (SERVER_INFO *) MarshalReq_GetParam (pReq, 0);
|
||
TCHAR *pszUserName = (TCHAR *) MarshalReq_GetParam (pReq, 1);
|
||
TCHAR *pszAppName = (TCHAR *) MarshalReq_GetParam (pReq, 2);
|
||
TCHAR *pszProtName = (TCHAR *) MarshalReq_GetParam (pReq, 3);
|
||
TCHAR *pszAnyAttrNameList = (TCHAR *) MarshalReq_GetParam (pReq, 4);
|
||
ULONG cAnyAttrNames = (ULONG) MarshalReq_GetParam (pReq, 5);
|
||
|
||
TCHAR *pszFilter = NULL;
|
||
|
||
// Duplicate the protocol name to resolve
|
||
//
|
||
TCHAR *pszProtNameToResolve = My_strdup (pszProtName);
|
||
if (pszProtNameToResolve == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Create a resolve client filter
|
||
//
|
||
pszFilter = ProtCreateResolveFilter (pszUserName, pszAppName, pszProtName);
|
||
if (pszFilter == NULL)
|
||
{
|
||
MemFree (pszProtNameToResolve);
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Create an array of names of attributes to return
|
||
//
|
||
TCHAR *apszAttrNames[COUNT_ENUM_PROTATTR+1];
|
||
TCHAR **ppszNameList;
|
||
ppszNameList = &apszAttrNames[0];
|
||
ULONG cTotalNames;
|
||
cTotalNames = COUNT_ENUM_PROTATTR;
|
||
if (pszAnyAttrNameList != NULL && cAnyAttrNames != 0)
|
||
{
|
||
// Prefix arbitrary attribute names
|
||
//
|
||
pszAnyAttrNameList = IlsPrefixNameValueArray (FALSE, cAnyAttrNames,
|
||
(const TCHAR *) pszAnyAttrNameList);
|
||
if (pszAnyAttrNameList == NULL)
|
||
{
|
||
MemFree (pszProtNameToResolve);
|
||
MemFree (pszFilter);
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Allocate memory for returned attributes' names
|
||
//
|
||
cTotalNames += cAnyAttrNames;
|
||
ppszNameList = (TCHAR **) MemAlloc (sizeof (TCHAR *) * (cTotalNames + 1));
|
||
if (ppszNameList == NULL)
|
||
{
|
||
MemFree (pszProtNameToResolve);
|
||
MemFree (pszFilter);
|
||
MemFree (pszAnyAttrNameList);
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
}
|
||
|
||
// Set standard attribute names
|
||
//
|
||
ULONG i;
|
||
for (i = 0; i < COUNT_ENUM_PROTATTR; i++)
|
||
{
|
||
ppszNameList[i] = (TCHAR *) c_apszProtStdAttrNames[i];
|
||
}
|
||
|
||
// Set arbitrary attribute names if needed
|
||
//
|
||
TCHAR *psz;
|
||
psz = pszAnyAttrNameList;
|
||
for (i = COUNT_ENUM_PROTATTR; i < cTotalNames; i++)
|
||
{
|
||
ppszNameList[i] = psz;
|
||
psz += lstrlen (psz) + 1;
|
||
}
|
||
|
||
// Terminate the list
|
||
//
|
||
ppszNameList[cTotalNames] = NULL;
|
||
|
||
// Get the session object
|
||
//
|
||
hr = g_pSessionContainer->GetSession (&pSession, pServer);
|
||
if (hr == S_OK)
|
||
{
|
||
// Get an ldap session
|
||
//
|
||
MyAssert (pSession != NULL);
|
||
ld = pSession->GetLd ();
|
||
MyAssert (ld != 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 the search query
|
||
//
|
||
uMsgID = ldap_search (ld, (TCHAR *) &c_szDefClientBaseDN[0], // base DN
|
||
LDAP_SCOPE_BASE, // scope
|
||
pszFilter,
|
||
ppszNameList, // attrs[]
|
||
0); // both type and value
|
||
if (uMsgID == -1)
|
||
{
|
||
// This ldap_search failed.
|
||
// Convert ldap error code to hr
|
||
//
|
||
hr = ::LdapError2Hresult (ld->ld_errno);
|
||
MyAssert (hr != S_OK);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
}
|
||
}
|
||
|
||
// Free the filter string
|
||
//
|
||
MemFree (pszFilter);
|
||
|
||
// Free the buffer holding all returned attribute names if needed
|
||
//
|
||
if (ppszNameList != &apszAttrNames[0])
|
||
MemFree (ppszNameList);
|
||
|
||
// If failed, exit with cleanup
|
||
//
|
||
if (hr != S_OK)
|
||
{
|
||
// Free duplicated protocol name
|
||
//
|
||
MemFree (pszProtNameToResolve);
|
||
|
||
// Free extended attribute names list if needed
|
||
//
|
||
if (cAnyAttrNames != 0)
|
||
MemFree (pszAnyAttrNameList);
|
||
|
||
// Report failure
|
||
//
|
||
goto MyExit;
|
||
}
|
||
|
||
// Construct a pending info structure
|
||
//
|
||
RESP_INFO ri;
|
||
FillDefRespInfo (&ri, pReq->uRespID, ld, uMsgID, INVALID_MSG_ID);
|
||
ri.uNotifyMsg = WM_ILS_RESOLVE_PROTOCOL;
|
||
ri.cAnyAttrs = cAnyAttrNames;
|
||
ri.pszAnyAttrNameList = pszAnyAttrNameList;
|
||
ri.pszProtNameToResolve = pszProtNameToResolve;
|
||
|
||
// Queue this pending response
|
||
//
|
||
hr = g_pRespQueue->EnterRequest (pSession, &ri);
|
||
if (hr != S_OK)
|
||
{
|
||
// Free duplicated protocol name
|
||
//
|
||
MemFree (pszProtNameToResolve);
|
||
|
||
// Free extended attribute names list if needed
|
||
//
|
||
if (cAnyAttrNames != 0)
|
||
MemFree (pszAnyAttrNameList);
|
||
|
||
// Abort the ldap_search
|
||
//
|
||
ldap_abandon (ld, uMsgID);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
MyAssert (FALSE);
|
||
}
|
||
|
||
MyExit:
|
||
|
||
LDAP_PROTINFO_RES *ppir = NULL;
|
||
if (hr != S_OK)
|
||
{
|
||
ppir = (LDAP_PROTINFO_RES *) MemAlloc (sizeof (LDAP_PROTINFO_RES));
|
||
if (ppir != NULL)
|
||
{
|
||
ppir->uSize = sizeof (*ppir);
|
||
ppir->hResult = hr;
|
||
}
|
||
}
|
||
|
||
return (LPARAM) ppir;
|
||
}
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_ResolveMeeting
|
||
|
||
Input:
|
||
pszServer: A server name.
|
||
pszMeetingID: A meeting id string.
|
||
pszAnyAttrName: A pointer to a series of strings.
|
||
cAnyAttrNames: A count of strings in the series.
|
||
pAsyncInfo: a pointer to async info structure.
|
||
|
||
History:
|
||
12/02/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
HRESULT UlsLdap_ResolveMeeting (
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszMtgName,
|
||
TCHAR *pszAnyAttrNameList,
|
||
ULONG cAnyAttrNames,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
if (MyIsBadServerInfo (pServer) || MyIsBadString (pszMtgName))
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cbServer = IlsGetLinearServerInfoSize (pServer);
|
||
ULONG cbSizeMtgName = (lstrlen (pszMtgName) + 1) * sizeof (TCHAR);
|
||
ULONG cbSizeAnyAttrNames = 0;
|
||
TCHAR *psz = pszAnyAttrNameList;
|
||
ULONG cch;
|
||
for (ULONG i = 0; i < cAnyAttrNames; i++)
|
||
{
|
||
cch = lstrlen (psz) + 1;
|
||
cbSizeAnyAttrNames += cch * sizeof (TCHAR);
|
||
psz += cch;
|
||
}
|
||
ULONG cParams = 4;
|
||
ULONG cbSize = cbServer + cbSizeMtgName + cbSizeAnyAttrNames;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (WM_ILS_RESOLVE_MEETING, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParamServer (pReq, 0, pServer, cbServer);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD) pszMtgName, cbSizeMtgName);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD) pszAnyAttrNameList, cbSizeAnyAttrNames);
|
||
MarshalReq_SetParam (pReq, 3, (DWORD) cAnyAttrNames, 0);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_ResolveMeeting ( MARSHAL_REQ *pReq )
|
||
{
|
||
HRESULT hr = S_OK;
|
||
SP_CSession *pSession = NULL;
|
||
LDAP *ld;
|
||
ULONG uMsgID = (ULONG) -1;
|
||
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert (pReq->uNotifyMsg == WM_ILS_RESOLVE_MEETING);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SERVER_INFO *pServer = (SERVER_INFO *) MarshalReq_GetParam (pReq, 0);
|
||
TCHAR *pszMtgName = (TCHAR *) MarshalReq_GetParam (pReq, 1);
|
||
TCHAR *pszAnyAttrNameList = (TCHAR *) MarshalReq_GetParam (pReq, 2);
|
||
ULONG cAnyAttrNames = (ULONG) MarshalReq_GetParam (pReq, 3);
|
||
|
||
// Create a resolve client filter
|
||
//
|
||
TCHAR *pszFilter = MtgCreateResolveFilter (pszMtgName);
|
||
if (pszFilter == NULL)
|
||
{
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Create an array of names of attributes to return
|
||
//
|
||
TCHAR *apszAttrNames[COUNT_ENUM_MTGATTR+1];
|
||
TCHAR **ppszNameList;
|
||
ppszNameList = &apszAttrNames[0];
|
||
ULONG cTotalNames;
|
||
cTotalNames = COUNT_ENUM_MTGATTR;
|
||
if (pszAnyAttrNameList != NULL && cAnyAttrNames != 0)
|
||
{
|
||
// Prefix arbitrary attribute names
|
||
//
|
||
pszAnyAttrNameList = IlsPrefixNameValueArray (FALSE, cAnyAttrNames,
|
||
(const TCHAR *) pszAnyAttrNameList);
|
||
if (pszAnyAttrNameList == NULL)
|
||
{
|
||
MemFree (pszFilter);
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
|
||
// Allocate memory for returned attributes' names
|
||
//
|
||
cTotalNames += cAnyAttrNames;
|
||
ppszNameList = (TCHAR **) MemAlloc (sizeof (TCHAR *) * (cTotalNames + 1));
|
||
if (ppszNameList == NULL)
|
||
{
|
||
MemFree (pszFilter);
|
||
MemFree (pszAnyAttrNameList);
|
||
hr = ILS_E_MEMORY;
|
||
goto MyExit;
|
||
}
|
||
}
|
||
|
||
// Set standard attribute names
|
||
//
|
||
ULONG i;
|
||
for (i = 0; i < COUNT_ENUM_MTGATTR; i++)
|
||
{
|
||
ppszNameList[i] = (TCHAR *) c_apszMtgStdAttrNames[i];
|
||
}
|
||
|
||
// Set arbitrary attribute names if needed
|
||
//
|
||
TCHAR *psz;
|
||
psz = pszAnyAttrNameList;
|
||
for (i = COUNT_ENUM_MTGATTR; i < cTotalNames; i++)
|
||
{
|
||
ppszNameList[i] = psz;
|
||
psz += lstrlen (psz) + 1;
|
||
}
|
||
|
||
// Terminate the list
|
||
//
|
||
ppszNameList[cTotalNames] = NULL;
|
||
|
||
// Get the session object
|
||
//
|
||
hr = g_pSessionContainer->GetSession (&pSession, pServer);
|
||
if (hr == S_OK)
|
||
{
|
||
// Get an ldap session
|
||
//
|
||
MyAssert (pSession != NULL);
|
||
ld = pSession->GetLd ();
|
||
MyAssert (ld != 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 the search query
|
||
//
|
||
uMsgID = ldap_search (ld, (TCHAR *) &c_szDefMtgBaseDN[0], // base DN
|
||
LDAP_SCOPE_BASE, // scope
|
||
pszFilter,
|
||
ppszNameList, // attrs[]
|
||
0); // both type and value
|
||
if (uMsgID == -1)
|
||
{
|
||
// This ldap_search failed.
|
||
// Convert ldap error code to hr
|
||
//
|
||
hr = ::LdapError2Hresult (ld->ld_errno);
|
||
MyAssert (hr != S_OK);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
}
|
||
}
|
||
|
||
// Free the filter string
|
||
//
|
||
MemFree (pszFilter);
|
||
|
||
// Free the buffer holding all returned attribute names if needed
|
||
//
|
||
if (ppszNameList != &apszAttrNames[0])
|
||
MemFree (ppszNameList);
|
||
|
||
// If failed, exit with cleanup
|
||
//
|
||
if (hr != S_OK)
|
||
{
|
||
// Free extended attribute names list if needed
|
||
//
|
||
if (pszAnyAttrNameList != NULL && cAnyAttrNames != 0)
|
||
MemFree (pszAnyAttrNameList);
|
||
|
||
// Report failure
|
||
//
|
||
goto MyExit;
|
||
}
|
||
|
||
// Construct a pending info structure
|
||
//
|
||
RESP_INFO ri;
|
||
FillDefRespInfo (&ri, pReq->uRespID, ld, uMsgID, INVALID_MSG_ID);
|
||
ri.uNotifyMsg = WM_ILS_RESOLVE_MEETING;
|
||
ri.cAnyAttrs = cAnyAttrNames;
|
||
ri.pszAnyAttrNameList = pszAnyAttrNameList;
|
||
|
||
// Queue this pending response
|
||
//
|
||
hr = g_pRespQueue->EnterRequest (pSession, &ri);
|
||
if (hr != S_OK)
|
||
{
|
||
// Abort the ldap_search
|
||
//
|
||
ldap_abandon (ld, uMsgID);
|
||
|
||
// Free the session object
|
||
//
|
||
pSession->Disconnect ();
|
||
MyAssert (FALSE);
|
||
}
|
||
|
||
MyExit:
|
||
|
||
LDAP_MEETINFO_RES *pmir = NULL;
|
||
if (hr != S_OK)
|
||
{
|
||
pmir = (LDAP_MEETINFO_RES *) MemAlloc (sizeof (LDAP_MEETINFO_RES));
|
||
if (pmir != NULL)
|
||
{
|
||
pmir->uSize = sizeof (*pmir);
|
||
pmir->hResult = hr;
|
||
}
|
||
}
|
||
|
||
return (LPARAM) pmir;
|
||
}
|
||
#endif // ENABLE_MEETING_PLACE
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_AddAttendee
|
||
|
||
Input:
|
||
pszServer: server name.
|
||
pszMeetingID: a meeting id string.
|
||
pszAttendeeID: an attendee id string.
|
||
pAsyncInfo: a pointer to async info structure.
|
||
|
||
History:
|
||
12/02/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
HRESULT My_UpdateAttendees (
|
||
ULONG uNotifyMsg,
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszMtgName,
|
||
ULONG cMembers,
|
||
TCHAR *pszMemberNames,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
HRESULT hr;
|
||
|
||
MyAssert ( uNotifyMsg == WM_ILS_ADD_ATTENDEE ||
|
||
uNotifyMsg == WM_ILS_REMOVE_ATTENDEE);
|
||
|
||
// Make sure this service provider is initialized
|
||
//
|
||
if (g_cInitialized <= 0)
|
||
return ILS_E_NOT_INITIALIZED;
|
||
|
||
// Make sure we there are members to add
|
||
//
|
||
if (cMembers == 0)
|
||
return ILS_E_PARAMETER;
|
||
|
||
// Make sure we have valid pointers
|
||
//
|
||
if (MyIsBadServerInfo (pServer) || MyIsBadString (pszMtgName) ||
|
||
MyIsBadString (pszMemberNames))
|
||
return ILS_E_POINTER;
|
||
|
||
// Make sure the async info structure is valid
|
||
//
|
||
if (pAsyncInfo == NULL)
|
||
return ILS_E_POINTER;
|
||
|
||
// Compute the total size of the data
|
||
//
|
||
ULONG cbServer = IlsGetLinearServerInfoSize (pServer);
|
||
ULONG cbSizeMtgName = (lstrlen (pszMtgName) + 1) * sizeof (TCHAR);
|
||
ULONG cbSizeMemberNames = 0;
|
||
TCHAR *psz = pszMemberNames;
|
||
for (ULONG i = 0; i < cMembers; i++)
|
||
{
|
||
ULONG cchName = lstrlen (psz) + 1;
|
||
cbSizeMemberNames += cchName * sizeof (TCHAR);
|
||
psz += cchName;
|
||
}
|
||
ULONG cParams = 4;
|
||
ULONG cbSize = cbServer + cbSizeMtgName + cbSizeMemberNames;
|
||
|
||
// Allocate marshall request buffer
|
||
//
|
||
MARSHAL_REQ *pReq = MarshalReq_Alloc (uNotifyMsg, cbSize, cParams);
|
||
if (pReq == NULL)
|
||
return ILS_E_MEMORY;
|
||
|
||
// Get the response ID
|
||
//
|
||
ULONG uRespID = pReq->uRespID;
|
||
|
||
// Linearize parameters
|
||
//
|
||
MarshalReq_SetParamServer (pReq, 0, pServer, cbServer);
|
||
MarshalReq_SetParam (pReq, 1, (DWORD) pszMtgName, cbSizeMtgName);
|
||
MarshalReq_SetParam (pReq, 2, (DWORD) cMembers, 0);
|
||
MarshalReq_SetParam (pReq, 3, (DWORD) pszMemberNames, cbSizeMemberNames);
|
||
|
||
// Enter the request
|
||
//
|
||
if (g_pReqQueue != NULL)
|
||
{
|
||
hr = g_pReqQueue->Enter (pReq);
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
hr = ILS_E_FAIL;
|
||
}
|
||
|
||
if (hr == S_OK)
|
||
{
|
||
pAsyncInfo->uMsgID = uRespID;
|
||
}
|
||
else
|
||
{
|
||
MemFree (pReq);
|
||
}
|
||
|
||
return hr;
|
||
}
|
||
|
||
|
||
LPARAM
|
||
AsynReq_UpdateAttendees ( MARSHAL_REQ *pReq )
|
||
{
|
||
MyAssert (GetCurrentThreadId () == g_dwReqThreadID);
|
||
|
||
MyAssert (pReq != NULL);
|
||
MyAssert ( pReq->uNotifyMsg == WM_ILS_ADD_ATTENDEE ||
|
||
pReq->uNotifyMsg == WM_ILS_REMOVE_ATTENDEE);
|
||
|
||
// Delinearize parameters
|
||
//
|
||
SERVER_INFO *pServer = (SERVER_INFO *) MarshalReq_GetParam (pReq, 0);
|
||
TCHAR *pszMtgName = (TCHAR *) MarshalReq_GetParam (pReq, 1);
|
||
ULONG cMembers = (ULONG) MarshalReq_GetParam (pReq, 2);
|
||
TCHAR *pszMemberNames = (TCHAR *) MarshalReq_GetParam (pReq, 3);
|
||
|
||
// Set standard attributes
|
||
//
|
||
return (LPARAM) MtgUpdateMembers (pReq->uNotifyMsg,
|
||
pServer,
|
||
pszMtgName,
|
||
cMembers,
|
||
pszMemberNames,
|
||
pReq->uRespID);
|
||
}
|
||
#endif // ENABLE_MEETING_PLACE
|
||
|
||
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
HRESULT UlsLdap_AddAttendee(
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszMtgName,
|
||
ULONG cMembers,
|
||
TCHAR *pszMemberNames,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
return My_UpdateAttendees ( WM_ILS_ADD_ATTENDEE,
|
||
pServer,
|
||
pszMtgName,
|
||
cMembers,
|
||
pszMemberNames,
|
||
pAsyncInfo);
|
||
}
|
||
#endif // ENABLE_MEETING_PLACE
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_RemoveAttendee
|
||
|
||
Input:
|
||
pszServer: server name.
|
||
pszMeetingID: a meeting id string.
|
||
pszAttendeeID: an attendee id string.
|
||
pAsyncInfo: a pointer to async info structure.
|
||
|
||
History:
|
||
12/02/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
HRESULT UlsLdap_RemoveAttendee(
|
||
SERVER_INFO *pServer,
|
||
TCHAR *pszMtgName,
|
||
ULONG cMembers,
|
||
TCHAR *pszMemberNames,
|
||
LDAP_ASYNCINFO *pAsyncInfo )
|
||
{
|
||
return My_UpdateAttendees ( WM_ILS_REMOVE_ATTENDEE,
|
||
pServer,
|
||
pszMtgName,
|
||
cMembers,
|
||
pszMemberNames,
|
||
pAsyncInfo);
|
||
}
|
||
#endif // ENABLE_MEETING_PLACE
|
||
|
||
|
||
/* ----------------------------------------------------------------------
|
||
UlsLdap_GetStdAttrNameString
|
||
|
||
Input:
|
||
StdName: a standard attribute index.
|
||
|
||
History:
|
||
12/02/96 Chu, Lon-Chan [lonchanc]
|
||
Created.
|
||
---------------------------------------------------------------------- */
|
||
|
||
typedef struct
|
||
{
|
||
#ifdef DEBUG
|
||
LONG nIndex;
|
||
#endif
|
||
const TCHAR **ppszName;
|
||
}
|
||
ATTR_NAME_ENTRY;
|
||
|
||
|
||
const ATTR_NAME_ENTRY c_aAttrNameTbl[ILS_NUM_OF_STDATTRS] =
|
||
{
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_NULL,
|
||
#endif
|
||
NULL
|
||
},
|
||
|
||
// User standard attribute names
|
||
//
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_USER_ID,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_CN]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_IP_ADDRESS,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_IP_ADDRESS]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_EMAIL_NAME,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_EMAIL_NAME]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_FIRST_NAME,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_FIRST_NAME]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_LAST_NAME,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_LAST_NAME]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_CITY_NAME,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_CITY_NAME]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_COUNTRY_NAME,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_C]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_COMMENT,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_COMMENT]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_FLAGS,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_FLAGS]
|
||
},
|
||
|
||
// Application standard attribute names
|
||
//
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_APP_NAME,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_APP_NAME]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_APP_MIME_TYPE,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_APP_MIME_TYPE]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_APP_GUID,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_APP_GUID]
|
||
},
|
||
|
||
// Protocol standard attribute names
|
||
//
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_PROTOCOL_NAME,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_PROT_NAME]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_PROTOCOL_MIME_TYPE,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_PROT_MIME]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_PROTOCOL_PORT,
|
||
#endif
|
||
&c_apszClientStdAttrNames[ENUM_CLIENTATTR_PROT_PORT]
|
||
},
|
||
|
||
#ifdef ENABLE_MEETING_PLACE
|
||
// Meeting place attribute names
|
||
//
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_MEETING_ID,
|
||
#endif
|
||
&c_apszMtgStdAttrNames[ENUM_MTGATTR_CN]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_MEETING_HOST_NAME,
|
||
#endif
|
||
&c_apszMtgStdAttrNames[ENUM_MTGATTR_HOST_NAME]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_MEETING_HOST_IP_ADDRESS,
|
||
#endif
|
||
&c_apszMtgStdAttrNames[ENUM_MTGATTR_IP_ADDRESS]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_MEETING_DESCRIPTION,
|
||
#endif
|
||
&c_apszMtgStdAttrNames[ENUM_MTGATTR_DESCRIPTION]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_MEETING_TYPE,
|
||
#endif
|
||
&c_apszMtgStdAttrNames[ENUM_MTGATTR_MTG_TYPE]
|
||
},
|
||
{
|
||
#ifdef DEBUG
|
||
(LONG) ILS_STDATTR_ATTENDEE_TYPE,
|
||
#endif
|
||
&c_apszMtgStdAttrNames[ENUM_MTGATTR_MEMBER_TYPE]
|
||
},
|
||
#endif // ENABLE_MEETING_PLACE
|
||
};
|
||
|
||
|
||
const TCHAR *UlsLdap_GetStdAttrNameString ( ILS_STD_ATTR_NAME StdName )
|
||
{
|
||
ULONG nIndex = (LONG) StdName;
|
||
|
||
MyAssert (((LONG) ILS_STDATTR_NULL < nIndex) && (nIndex < (LONG) ILS_NUM_OF_STDATTRS));
|
||
|
||
return *(c_aAttrNameTbl[nIndex].ppszName);
|
||
}
|
||
|
||
|
||
#ifdef DEBUG
|
||
VOID DbgValidateStdAttrNameArray ( VOID )
|
||
{
|
||
MyAssert (ARRAY_ELEMENTS (c_aAttrNameTbl) == ILS_NUM_OF_STDATTRS);
|
||
|
||
for (LONG i = 0; i < ILS_NUM_OF_STDATTRS; i++)
|
||
{
|
||
if (i == c_aAttrNameTbl[i].nIndex)
|
||
{
|
||
if (i != ILS_STDATTR_NULL &&
|
||
My_lstrlen (*(c_aAttrNameTbl[i].ppszName)) == 0)
|
||
{
|
||
MyAssert (FALSE);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
MyAssert (FALSE);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
|
||
|
||
/* =============== helper functions =============== */
|
||
|
||
const TCHAR g_szShowEntries[] = TEXT ("(cn=");
|
||
const INT g_nLengthShowEntries = ARRAY_ELEMENTS (g_szShowEntries) - 1;
|
||
const TCHAR g_szShowAllEntries[] = TEXT ("(cn=*)");
|
||
const INT g_nShowAllEntries = ARRAY_ELEMENTS (g_szShowAllEntries) - 1;
|
||
|
||
TCHAR *AddBaseToFilter ( TCHAR *pszFilter, const TCHAR *pszDefBase )
|
||
{
|
||
MyAssert (pszDefBase != NULL);
|
||
|
||
// Calculate the size for "(&(objectclass=RTPerson)())"
|
||
//
|
||
ULONG cbSize = (lstrlen (pszDefBase) + 8 + g_nShowAllEntries) * sizeof (TCHAR);
|
||
|
||
// Look through the filter string to figure out that
|
||
// will this string shows entries???
|
||
//
|
||
TCHAR *pszShowEntries = (TCHAR *) &g_szShowAllEntries[0];
|
||
if (pszFilter != NULL)
|
||
{
|
||
for (TCHAR *psz = pszFilter; *psz != TEXT ('\0'); psz = CharNext (psz))
|
||
{
|
||
if (lstrlen (psz) > g_nLengthShowEntries)
|
||
{
|
||
TCHAR ch = psz[g_nLengthShowEntries]; // remember
|
||
psz[g_nLengthShowEntries] = TEXT ('\0');
|
||
|
||
INT nCmp = lstrcmpi (psz, &g_szShowEntries[0]);
|
||
psz[g_nLengthShowEntries] = ch; // restore
|
||
if (nCmp == 0)
|
||
{
|
||
// Matched
|
||
//
|
||
pszShowEntries = STR_EMPTY;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// It is impossible to match it
|
||
//
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// If the filter is null, then only provide "(objectclass=RTPerson)"
|
||
//
|
||
if (pszFilter != NULL)
|
||
cbSize += lstrlen (pszFilter) * sizeof (TCHAR);
|
||
|
||
// Allocate new memory for filter
|
||
//
|
||
TCHAR *pszNewFilter = (TCHAR *) MemAlloc (cbSize);
|
||
if (pszNewFilter != NULL)
|
||
{
|
||
wsprintf (pszNewFilter, TEXT ("(&(%s)%s"), pszDefBase, pszShowEntries);
|
||
TCHAR *psz = pszNewFilter + lstrlen (pszNewFilter);
|
||
|
||
if (pszFilter != NULL)
|
||
{
|
||
wsprintf (psz, (*pszFilter == TEXT ('(')) ? TEXT ("%s") : TEXT ("(%s)"),
|
||
pszFilter);
|
||
}
|
||
lstrcat (psz, TEXT (")"));
|
||
|
||
// Go through the filter and convert '*' to '%'
|
||
//
|
||
for (psz = pszNewFilter; *psz != TEXT ('\0'); psz = CharNext (psz))
|
||
{
|
||
if (*psz == TEXT ('*'))
|
||
*psz = TEXT ('%');
|
||
}
|
||
}
|
||
|
||
return pszNewFilter;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|