/* ---------------------------------------------------------------------- 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; }