//**************************************************************************** // // Module: ULS.DLL // File: culs.cpp // Content: This file contains the ULS object. // History: // Wed 17-Apr-1996 11:13:54 -by- Viroon Touranachun [viroont] // // Copyright (c) Microsoft Corporation 1996-1997 // //**************************************************************************** #include "ulsp.h" #include "culs.h" #include "localusr.h" #include "attribs.h" #include "localprt.h" #include "callback.h" #include "filter.h" #include "sputils.h" #include "ulsmeet.h" //**************************************************************************** // Constant and static text definition //**************************************************************************** // #define ILS_WND_CLASS TEXT("UserLocationServicesClass") #define ILS_WND_NAME TEXT("ULSWnd") #define ILS_DATABASE_MUTEX TEXT("User Location Service Database") //**************************************************************************** // Global Parameters //**************************************************************************** // CIlsMain *g_pCIls = NULL; CReqMgr *g_pReqMgr = NULL; HWND g_hwndCulsWindow = NULL; //**************************************************************************** // Event Notifiers //**************************************************************************** // //**************************************************************************** // HRESULT // OnNotifyEnumUserNamesResult (IUnknown *pUnk, void *pv) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** HRESULT OnNotifyEnumUserNamesResult (IUnknown *pUnk, void *pv) { CEnumNames *penum = NULL; PENUMRINFO peri = (PENUMRINFO)pv; HRESULT hr = peri->hResult; // Create the enumerator only when there is anything to be enumerated // if (hr == NOERROR) { ASSERT (peri->pv != NULL); // Create a UserName enumerator // penum = new CEnumNames; if (penum != NULL) { hr = penum->Init((LPTSTR)peri->pv, peri->cItems); if (SUCCEEDED(hr)) { penum->AddRef(); } else { delete penum; penum = NULL; }; } else { hr = ILS_E_MEMORY; }; }; // Notify the sink object // ((IIlsNotify*)pUnk)->EnumUserNamesResult(peri->uReqID, penum != NULL ? (IEnumIlsNames *)penum : NULL, hr); if (penum != NULL) { penum->Release(); }; return hr; } //**************************************************************************** // HRESULT // OnNotifyGetUserResult (IUnknown *pUnk, void *pv) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** HRESULT OnNotifyGetUserResult (IUnknown *pUnk, void *pv) { POBJRINFO pobjri = (POBJRINFO)pv; ((IIlsNotify*)pUnk)->GetUserResult(pobjri->uReqID, (IIlsUser *)pobjri->pv, pobjri->hResult); return S_OK; } //**************************************************************************** // HRESULT // OnNotifyGetUserResult (IUnknown *pUnk, void *pv) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** #ifdef ENABLE_MEETING_PLACE HRESULT OnNotifyGetMeetingPlaceResult (IUnknown *pUnk, void *pv) { POBJRINFO pobjri = (POBJRINFO)pv; ((IIlsNotify*)pUnk)->GetMeetingPlaceResult(pobjri->uReqID, (IIlsMeetingPlace *)pobjri->pv, pobjri->hResult); return S_OK; } #endif // ENABLE_MEETING_PLACE //**************************************************************************** // HRESULT // OnNotifyEnumUsersResult (IUnknown *pUnk, void *pv) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** HRESULT OnNotifyEnumUsersResult (IUnknown *pUnk, void *pv) { CEnumUsers *penum = NULL; PENUMRINFO peri = (PENUMRINFO)pv; HRESULT hr = peri->hResult; if (hr == NOERROR) { ASSERT (peri->pv != NULL); // Create a UserName enumerator // penum = new CEnumUsers; if (penum != NULL) { hr = penum->Init((CIlsUser **)peri->pv, peri->cItems); if (SUCCEEDED(hr)) { penum->AddRef(); } else { delete penum; penum = NULL; }; } else { hr = ILS_E_MEMORY; }; }; // Notify the sink object // ((IIlsNotify*)pUnk)->EnumUsersResult(peri->uReqID, penum != NULL ? (IEnumIlsUsers *)penum : NULL, hr); if (penum != NULL) { penum->Release(); }; return hr; } //**************************************************************************** // HRESULT // OnNotifyEnumMeetingPlacesResult (IUnknown *pUnk, void *pv) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** #ifdef ENABLE_MEETING_PLACE HRESULT OnNotifyEnumMeetingPlacesResult (IUnknown *pUnk, void *pv) { CEnumMeetingPlaces *penum = NULL; PENUMRINFO peri = (PENUMRINFO)pv; HRESULT hr = peri->hResult; if (hr == NOERROR) { ASSERT (peri->pv != NULL); // Create a MeetingPlace enumerator // penum = new CEnumMeetingPlaces; if (penum != NULL) { // jam it with the data that we got hr = penum->Init((CIlsMeetingPlace **)peri->pv, peri->cItems); if (SUCCEEDED(hr)) { penum->AddRef(); } else { delete penum; penum = NULL; }; } else { hr = ILS_E_MEMORY; }; }; // Notify the sink object // ((IIlsNotify*)pUnk)->EnumMeetingPlacesResult(peri->uReqID, penum != NULL ? (IEnumIlsMeetingPlaces *)penum : NULL, hr); if (penum != NULL) { penum->Release(); }; return hr; } #endif // ENABLE_MEETING_PLACE //**************************************************************************** // HRESULT // OnNotifyEnumMeetingPlaceNamesResult (IUnknown *pUnk, void *pv) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** #ifdef ENABLE_MEETING_PLACE HRESULT OnNotifyEnumMeetingPlaceNamesResult (IUnknown *pUnk, void *pv) { CEnumNames *penum = NULL; PENUMRINFO peri = (PENUMRINFO)pv; HRESULT hr = peri->hResult; // Create the enumerator only when there is anything to be enumerated // if (hr == NOERROR) { ASSERT (peri->pv != NULL); // Create a MeetingPlaceName enumerator // penum = new CEnumNames; if (penum != NULL) { hr = penum->Init((LPTSTR)peri->pv, peri->cItems); if (SUCCEEDED(hr)) { penum->AddRef(); } else { delete penum; penum = NULL; }; } else { hr = ILS_E_MEMORY; }; }; // Notify the sink object // ((IIlsNotify*)pUnk)->EnumMeetingPlaceNamesResult(peri->uReqID, penum != NULL ? (IEnumIlsNames *)penum : NULL, hr); if (penum != NULL) { penum->Release(); }; return hr; } #endif // ENABLE_MEETING_PLACE //**************************************************************************** // Class Implementation //**************************************************************************** // //**************************************************************************** // CIlsMain::CIls (void) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** CIlsMain:: CIlsMain ( VOID ) :m_cRef (0), fInit (FALSE), hwndCallback (NULL), pConnPt (NULL) { ::EnterCriticalSection (&g_ULSSem); g_pCIls = this; ::LeaveCriticalSection (&g_ULSSem); } //**************************************************************************** // CIlsMain::~CIls (void) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** CIlsMain:: ~CIlsMain ( VOID ) { ASSERT (m_cRef == 0); // Free up resources // Uninitialize(); // Release the connection point // if (pConnPt != NULL) { pConnPt->ContainerReleased(); ((IConnectionPoint*)pConnPt)->Release(); }; // We are gone now // ::EnterCriticalSection (&g_ULSSem); g_pCIls = NULL; ::LeaveCriticalSection (&g_ULSSem); return; } //**************************************************************************** // STDMETHODIMP // CIlsMain::Init (void) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain::Init (void) { HRESULT hr; // Make the connection point // pConnPt = new CConnectionPoint (&IID_IIlsNotify, (IConnectionPointContainer *)this); if (pConnPt != NULL) { ((IConnectionPoint*)pConnPt)->AddRef(); hr = S_OK; } else { hr = ILS_E_MEMORY; }; return hr; } //**************************************************************************** // STDMETHODIMP // CIlsMain::QueryInterface (REFIID riid, void **ppv) // // History: // Wed 17-Apr-1996 11:14:08 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain::QueryInterface (REFIID riid, void **ppv) { *ppv = NULL; if (riid == IID_IIlsMain || riid == IID_IUnknown) { *ppv = (IIlsMain *) this; } else { if (riid == IID_IConnectionPointContainer) { *ppv = (IConnectionPointContainer *) this; }; }; if (*ppv != NULL) { ((LPUNKNOWN)*ppv)->AddRef(); return S_OK; } else { return ILS_E_NO_INTERFACE; }; } //**************************************************************************** // STDMETHODIMP_(ULONG) // CIlsMain::AddRef (void) // // History: // Wed 17-Apr-1996 11:14:17 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP_(ULONG) CIlsMain::AddRef (void) { DllLock(); MyDebugMsg ((DM_REFCOUNT, "CIlsMain::AddRef: ref=%ld\r\n", m_cRef)); ::InterlockedIncrement (&m_cRef); return (ULONG) m_cRef; } //**************************************************************************** // STDMETHODIMP_(ULONG) // CIlsMain::Release (void) // // History: // Wed 17-Apr-1996 11:14:26 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP_(ULONG) CIlsMain::Release (void) { DllRelease(); ASSERT (m_cRef > 0); MyDebugMsg ((DM_REFCOUNT, "CIlsMain::Release: ref=%ld\r\n", m_cRef)); if (::InterlockedDecrement (&m_cRef) == 0) { delete this; return 0; } return (ULONG) m_cRef; } //**************************************************************************** // STDMETHODIMP // CIlsMain::Initialize (BSTR bstrAppName, REFGUID rguid, BSTR bstrMimeType) // // History: // Wed 17-Apr-1996 11:14:08 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain::Initialize () { WNDCLASS wc; HRESULT hr; if (IsInitialized()) { return ILS_E_FAIL; }; // Activate the services // hr = ILS_E_FAIL; fInit = TRUE; // Fill in window class structure with parameters that describe the // working window. // wc.style = CS_NOCLOSE; wc.lpfnWndProc = ULSNotifyProc; wc.cbClsExtra = 0; wc.cbWndExtra = 0; wc.hInstance = g_hInstance; wc.hIcon = ::LoadIcon(NULL, IDI_APPLICATION); wc.hCursor = ::LoadCursor(NULL, IDC_ARROW); wc.hbrBackground = (HBRUSH)COLOR_WINDOW; wc.lpszMenuName = NULL; wc.lpszClassName = ILS_WND_CLASS; if (::RegisterClass(&wc) != 0) { hwndCallback = ::CreateWindowEx(0L, ILS_WND_CLASS, ILS_WND_NAME, WS_OVERLAPPED, 0, 0, 100, 50, NULL, NULL, g_hInstance, NULL); if (hwndCallback != NULL) { // Initialize the request manager // g_pReqMgr = new CReqMgr; if (g_pReqMgr != NULL) { // Initialize the LDAP layer // hr = ::UlsLdap_Initialize(hwndCallback); } else { hr = ILS_E_MEMORY; }; }; }; if (FAILED(hr)) { Uninitialize(); } else { g_hwndCulsWindow = hwndCallback; } return hr; } //**************************************************************************** // STDMETHODIMP // CIlsMain::CreateUser // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain:: CreateUser ( BSTR bstrUserID, BSTR bstrAppName, IIlsUser **ppUser) { CIlsUser *plu; HRESULT hr; // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } // Validate parameter // if (ppUser == NULL) { return ILS_E_POINTER; }; // Assume failure // *ppUser = NULL; // // Allocate a new user object // plu = new CIlsUser; if (plu != NULL) { // Initialize the object // hr = plu->Init(bstrUserID, bstrAppName); if (SUCCEEDED(hr)) { *ppUser = (IIlsUser *)plu; (*ppUser)->AddRef(); } else { delete plu; }; } else { hr = ILS_E_MEMORY; }; return hr; } //**************************************************************************** // STDMETHODIMP // CIlsMain::Uninitialize (void) // // History: // Wed 17-Apr-1996 11:14:08 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain::Uninitialize (void) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } // Uninitialize the LDAP layer // ::UlsLdap_Deinitialize(); // Remove the request manager // if (g_pReqMgr != NULL) { delete g_pReqMgr; g_pReqMgr = NULL; }; // Clear the callback window // if (hwndCallback != NULL) { ::DestroyWindow(hwndCallback); hwndCallback = NULL; }; ::UnregisterClass(ILS_WND_CLASS, g_hInstance); // Flag that is is uninitialized // fInit = FALSE; return S_OK; }; //**************************************************************************** // STDMETHODIMP // CIlsMain::NotifySink (void *pv, CONN_NOTIFYPROC pfn) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain::NotifySink (void *pv, CONN_NOTIFYPROC pfn) { HRESULT hr = S_OK; if (pConnPt != NULL) { hr = pConnPt->Notify(pv, pfn); }; return hr; } //**************************************************************************** // STDMETHODIMP // CIlsMain::CreateAttributes (ILS_ACCESS_CONTROL AccessControl, IIlsAttributes **ppAttributes) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. // 12/05/96 -by- Chu, Lon-Chan [lonchanc] // Added access control. //**************************************************************************** STDMETHODIMP CIlsMain:: CreateAttributes ( ILS_ATTR_TYPE AttrType, IIlsAttributes **ppAttributes ) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } CAttributes *pa; HRESULT hr; // Validate parameter // if (ppAttributes == NULL) { return ILS_E_POINTER; }; // Validate access control // if (AttrType != ILS_ATTRTYPE_NAME_ONLY && AttrType != ILS_ATTRTYPE_NAME_VALUE) return ILS_E_PARAMETER; // Assume failure // *ppAttributes = NULL; // Allocate an attributes object // pa = new CAttributes; if (pa != NULL) { pa->SetAccessType (AttrType); pa->AddRef(); *ppAttributes = pa; hr = NOERROR; } else { hr = ILS_E_MEMORY; }; return hr; } //**************************************************************************** // STDMETHODIMP // CIlsMain::GetUser (BSTR bstrServerName, BSTR bstrUserID, // ULONG *puReqID) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain:: GetUser ( IIlsServer *pIlsServer, BSTR bstrUserID, BSTR bstrAppID, BSTR bstrProtID, IIlsAttributes *pAttrib, IIlsUser **ppUser, ULONG *puReqID ) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } LDAP_ASYNCINFO ldai; HRESULT hr; // We do not implement synchronous operation // if (ppUser != NULL) return ILS_E_NOT_IMPL; // Validate parameters // if (::MyIsBadServer (pIlsServer) || bstrUserID == NULL || puReqID == NULL) return ILS_E_POINTER; // Clone the server object // pIlsServer = ((CIlsServer *) pIlsServer)->Clone (); if (pIlsServer == NULL) return ILS_E_MEMORY; // Get a list of extended attribute names // TCHAR *pszList = NULL; ULONG cList =0, cbList = 0; if (pAttrib != NULL) { hr = ((CAttributes *) pAttrib)->GetAttributeList (&pszList, &cList, &cbList); if (FAILED (hr)) { pIlsServer->Release (); return hr; } } // Initialize locals // TCHAR *pszUserID = NULL, *pszAppID = NULL, *pszProtID = NULL; // Get from the specified server // hr = BSTR_to_LPTSTR(&pszUserID, bstrUserID); if (FAILED (hr)) goto MyExit; // Get the app id if given // if (bstrAppID != NULL) { hr = BSTR_to_LPTSTR (&pszAppID, bstrAppID); if (FAILED (hr)) goto MyExit; } // Get the protocol id if given // if (bstrProtID != NULL) { hr = BSTR_to_LPTSTR (&pszProtID, bstrProtID); if (FAILED (hr)) goto MyExit; } hr = ::UlsLdap_ResolveClient (((CIlsServer *) pIlsServer)->GetServerInfo (), pszUserID, pszAppID, pszProtID, pszList, cList, &ldai); if (SUCCEEDED(hr)) { COM_REQ_INFO ri; ReqInfo_Init (&ri); // If updating server was successfully requested, wait for the response // ri.uReqType = WM_ILS_RESOLVE_CLIENT; ri.uMsgID = ldai.uMsgID; ReqInfo_SetMain (&ri, this); ReqInfo_SetServer (&ri, pIlsServer); pIlsServer->AddRef (); hr = g_pReqMgr->NewRequest(&ri); if (SUCCEEDED(hr)) { // Make sure the objects do not disappear before we get the response // this->AddRef(); // Return the request ID // *puReqID = ri.uReqID; } }; MyExit: // Release the server object // pIlsServer->Release (); // Free the list of extended attribute names // ::MemFree (pszList); // Free the names ::MemFree (pszUserID); ::MemFree (pszAppID); ::MemFree (pszProtID); return hr; } //**************************************************************************** // STDMETHODIMP // CIlsMain::GetUserResult (ULONG uReqID, PLDAP_CLIENTINFO_RES puir, // LPTSTR szServer) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain::GetUserResult (ULONG uReqID, PLDAP_CLIENTINFO_RES puir, CIlsServer *pIlsServer) { CIlsUser *pu; OBJRINFO objri; // Default to the server's result // objri.hResult = (puir != NULL) ? puir->hResult : ILS_E_MEMORY; if (SUCCEEDED(objri.hResult)) { ASSERT (! MyIsBadServer (pIlsServer)); // The server returns CLIENTINFO, create a User object // pu = new CIlsUser; if (pu != NULL) { objri.hResult = pu->Init(pIlsServer, &puir->lci); if (SUCCEEDED(objri.hResult)) { pu->AddRef(); } else { delete pu; pu = NULL; }; } else { objri.hResult = ILS_E_MEMORY; }; } else { pu = NULL; }; // Package the notification info // objri.uReqID = uReqID; objri.pv = (void *)(pu == NULL ? NULL : (IIlsUser *)pu); NotifySink((void *)&objri, OnNotifyGetUserResult); if (pu != NULL) { pu->Release(); }; return NOERROR; } //**************************************************************************** // STDMETHODIMP // CIlsMain::EnumUserNames (BSTR bstrServerName, IIlsFilter *pFilter, // ULONG *puReqID) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** HRESULT CIlsMain:: EnumUsersEx ( BOOL fNameOnly, CIlsServer *pIlsServer, IIlsFilter *pFilter, CAttributes *pAttrib, ULONG *puReqID ) { LDAP_ASYNCINFO ldai; HRESULT hr; // Validate parameter // if (::MyIsBadServer (pIlsServer) || puReqID == NULL) return ILS_E_POINTER; // Clone the server object // pIlsServer = ((CIlsServer *) pIlsServer)->Clone (); if (pIlsServer == NULL) return ILS_E_MEMORY; // Get a list of extended attribute names // TCHAR *pszList = NULL; ULONG cList =0, cbList = 0; if (pAttrib != NULL) { ASSERT (!fNameOnly); hr = pAttrib->GetAttributeList(&pszList, &cList, &cbList); if (FAILED(hr)) { pIlsServer->Release (); return hr; } } // Construct default filter if needed // TCHAR *pszFilter = NULL; BOOL fDefaultRenderer = FALSE; if (pFilter == NULL) { // Build default filter string // TCHAR szLocalFilter[32]; wsprintf (&szLocalFilter[0], TEXT ("($%u=*)"), (UINT) ILS_STDATTR_USER_ID); // Render this filter // hr = StringToFilter (&szLocalFilter[0], (CFilter **) &pFilter); if (! SUCCEEDED (hr)) goto MyExit; // Indicate we have default filter string // fDefaultRenderer = TRUE; } // Create a ldap-like filter // hr = ::FilterToLdapString ((CFilter *) pFilter, &pszFilter); if (hr != S_OK) goto MyExit; // Enumerate users // hr = fNameOnly ? ::UlsLdap_EnumClients (pIlsServer->GetServerInfo (), pszFilter, &ldai) : ::UlsLdap_EnumClientInfos (pIlsServer->GetServerInfo (), pszList, cList, pszFilter, &ldai); if (hr != S_OK) goto MyExit; // If updating server was successfully requested, wait for the response // COM_REQ_INFO ri; ReqInfo_Init (&ri); ri.uReqType = fNameOnly ? WM_ILS_ENUM_CLIENTS : WM_ILS_ENUM_CLIENTINFOS; ri.uMsgID = ldai.uMsgID; ReqInfo_SetMain (&ri, this); if (! fNameOnly) { ReqInfo_SetServer (&ri, pIlsServer); pIlsServer->AddRef (); } // Remember this request // hr = g_pReqMgr->NewRequest (&ri); if (hr == S_OK) { // Make sure the objects do not disappear before we get the response // this->AddRef (); // Return the request ID // *puReqID = ri.uReqID; } MyExit: // Release server object // pIlsServer->Release (); // Free the filter string // ::MemFree (pszFilter); // Release default filter if needed // if (fDefaultRenderer && pFilter != NULL) pFilter->Release (); // Free the list of extended attribute names // ::MemFree (pszList); return hr; } STDMETHODIMP CIlsMain::EnumUserNames ( IIlsServer *pIlsServer, IIlsFilter *pFilter, IEnumIlsNames **ppEnumUserNames, ULONG *puReqID ) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } // We do not implement synchronous operation // if (ppEnumUserNames != NULL) return ILS_E_NOT_IMPL; return EnumUsersEx (TRUE, (CIlsServer *) pIlsServer, pFilter, NULL, puReqID); } //**************************************************************************** // STDMETHODIMP // CIlsMain::EnumUserNamesResult (ULONG uReqID, PLDAP_ENUM ple) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain::EnumUserNamesResult (ULONG uReqID, PLDAP_ENUM ple) { ENUMRINFO eri; // Package the notification info // eri.uReqID = uReqID; // PLDAP_ENUM is NULL when the enumeration is terminated successfully // if (ple != NULL) { eri.hResult = ple->hResult; eri.cItems = ple->cItems; eri.pv = (void *)(((PBYTE)ple)+ple->uOffsetItems); } else { eri.hResult = S_FALSE; eri.cItems = 0; eri.pv = NULL; }; NotifySink((void *)&eri, OnNotifyEnumUserNamesResult); return NOERROR; } //**************************************************************************** // STDMETHODIMP // CIlsMain::EnumUsers (BSTR bstrServerName, IIlsFilter *pFilter, // ULONG *puReqID) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain:: EnumUsers ( IIlsServer *pIlsServer, IIlsFilter *pFilter, IIlsAttributes *pAttrib, IEnumIlsUsers **ppEnumUsers, ULONG *puReqID) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } // We do not implement synchronous operation // if (ppEnumUsers != NULL) return ILS_E_NOT_IMPL; return EnumUsersEx (FALSE, (CIlsServer *) pIlsServer, pFilter, (CAttributes *) pAttrib, puReqID); } //**************************************************************************** // STDMETHODIMP // CIlsMain::EnumUsersResult (ULONG uReqID, PLDAP_ENUM ple, LPTSTR szServer) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain::EnumUsersResult (ULONG uReqID, PLDAP_ENUM ple, CIlsServer *pIlsServer) { CIlsUser **ppu; ULONG cUsers; ENUMRINFO eri; HRESULT hr; if (ple != NULL) { eri.hResult = ple->hResult; cUsers = ple->cItems; } else { eri.hResult = S_FALSE; cUsers = 0; }; eri.uReqID = uReqID; eri.cItems = 0; if ((eri.hResult == NOERROR) && (cUsers != 0)) { ASSERT (! MyIsBadServer (pIlsServer)); // Build an array of User objects here // ppu = (CIlsUser **) ::MemAlloc (cUsers*sizeof(CIlsUser *)); if (ppu != NULL) { CIlsUser *pu; PLDAP_CLIENTINFO pui; ULONG i; // Build one User object at a time // pui = (PLDAP_CLIENTINFO)(((PBYTE)ple)+ple->uOffsetItems); for (i = 0; i < cUsers; i++) { pu = new CIlsUser; if (pu != NULL) { if (SUCCEEDED(pu->Init(pIlsServer, pui))) { pu->AddRef(); ppu[eri.cItems++] = pu; } else { delete pu; }; }; pui++; }; } else { eri.hResult = ILS_E_MEMORY; }; } else { ppu = NULL; }; // Package the notification info // eri.pv = (void *)ppu; NotifySink((void *)&eri, OnNotifyEnumUsersResult); // Free the resources // if (ppu != NULL) { for (; eri.cItems; eri.cItems--) { ppu[eri.cItems-1]->Release(); }; ::MemFree (ppu); }; return NOERROR; } //**************************************************************************** // STDMETHODIMP // CIlsMain::CreateMeetingPlace (BSTR bstrMeetingPlaceID, LONG lConfType, LONG lMemberType, // IIlsMeetingPlace **ppMeetingPlace); // // // History: // // Created. //**************************************************************************** #ifdef ENABLE_MEETING_PLACE STDMETHODIMP CIlsMain::CreateMeetingPlace ( BSTR bstrMeetingPlaceID, LONG lConfType, LONG lMemberType, IIlsMeetingPlace **ppMeetingPlace) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } CIlsMeetingPlace *pCcr = NULL; HRESULT hr; // we are just createing a place holder object which when registered // will be visible by other users if (ppMeetingPlace == NULL || bstrMeetingPlaceID == NULL) { return ILS_E_POINTER; } *ppMeetingPlace = NULL; pCcr = new CIlsMeetingPlace; if (pCcr != NULL ) { // succeeded in createing the object hr = pCcr->Init(bstrMeetingPlaceID, lConfType, lConfType); if (SUCCEEDED(hr)) { *ppMeetingPlace = (IIlsMeetingPlace *) pCcr; (*ppMeetingPlace)->AddRef (); } else { delete pCcr; } } else { hr = ILS_E_MEMORY; } return (hr); } #endif // ENABLE_MEETING_PLACE //**************************************************************************** // STDMETHODIMP // CIlsMain::GetMeetingPlace (BSTR bstrServerName, BSTR bstrMeetingPlaceID, ULONG *puReqID) // // History: // Created. //**************************************************************************** #ifdef ENABLE_MEETING_PLACE STDMETHODIMP CIlsMain:: GetMeetingPlace ( IIlsServer *pIlsServer, BSTR bstrMeetingPlaceID, IIlsAttributes *pAttrib, IIlsMeetingPlace **ppMeetingPlace, ULONG *puReqID) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } LDAP_ASYNCINFO ldai; LPTSTR pszMtgID = NULL; HRESULT hr; // We do not implement synchronous operation // if (ppMeetingPlace != NULL) return ILS_E_NOT_IMPL; // Validate parameters // if (::MyIsBadServer (pIlsServer) || bstrMeetingPlaceID == NULL || puReqID == NULL) return ILS_E_POINTER; // Clone the server object // pIlsServer = ((CIlsServer *) pIlsServer)->Clone (); if (pIlsServer == NULL) return ILS_E_MEMORY; // Get a list of extended attribute names // TCHAR *pszList = NULL; ULONG cList =0, cbList = 0; if (pAttrib != NULL) { hr = ((CAttributes *) pAttrib)->GetAttributeList (&pszList, &cList, &cbList); if (FAILED (hr)) { pIlsServer->Release (); return hr; } } // Get from the specified server // hr = BSTR_to_LPTSTR(&pszMtgID, bstrMeetingPlaceID); if (SUCCEEDED(hr)) { // BUGBUG AppID not given hr = ::UlsLdap_ResolveMeeting (((CIlsServer *) pIlsServer)->GetServerInfo (), pszMtgID, pszList, cList, &ldai); if (SUCCEEDED(hr)) { COM_REQ_INFO ri; ReqInfo_Init (&ri); // If updating server was successfully requested, wait for the response // ri.uReqType = WM_ILS_RESOLVE_MEETING; ri.uMsgID = ldai.uMsgID; ReqInfo_SetMain (&ri, this); ReqInfo_SetServer (&ri, pIlsServer); pIlsServer->AddRef (); hr = g_pReqMgr->NewRequest(&ri); if (SUCCEEDED(hr)) { // Make sure the objects do not disappear before we get the response // this->AddRef(); // Return the request ID // *puReqID = ri.uReqID; } }; ::MemFree (pszMtgID); }; // Release the server object // pIlsServer->Release (); // Free the list of extended attribute names // ::MemFree (pszList); return hr; } #endif // ENABLE_MEETING_PLACE //**************************************************************************** // HRESULT // CIlsMain::GetMeetingPlaceResult (ULONG uReqID, LDAP_MEETINFO_RES pmir, // LPTSTR szServer) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** #ifdef ENABLE_MEETING_PLACE HRESULT CIlsMain:: GetMeetingPlaceResult (ULONG uReqID, PLDAP_MEETINFO_RES pmir, CIlsServer *pIlsServer) { CIlsMeetingPlace *pm; OBJRINFO objri; // Default to the server's result // objri.hResult = (pmir != NULL) ? pmir->hResult : ILS_E_MEMORY; if (SUCCEEDED (objri.hResult)) { ASSERT (! MyIsBadServer (pIlsServer)); // The server returns CLIENTINFO, create a User object // pm = new CIlsMeetingPlace; if (pm != NULL) { objri.hResult = pm->Init (pIlsServer, &(pmir->lmi)); if (SUCCEEDED (objri.hResult)) { pm->AddRef(); } else { delete pm; pm = NULL; }; } else { objri.hResult = ILS_E_MEMORY; }; } else { pm = NULL; }; // Package the notification info // objri.uReqID = uReqID; objri.pv = (void *) (pm == NULL ? NULL : (IIlsMeetingPlace *) pm); NotifySink ((void *) &objri, OnNotifyGetMeetingPlaceResult); if (pm != NULL) pm->Release(); return NOERROR; } #endif // ENABLE_MEETING_PLACE //**************************************************************************** // STDMETHODIMP // CIlsMain::EnumMeetingPlaces (BSTR bstrServerName, IIlsFilter *pFilter, // IIlsAttributes *pAttributes, ULONG *puReqID) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** #ifdef ENABLE_MEETING_PLACE HRESULT CIlsMain:: EnumMeetingPlacesEx ( BOOL fNameOnly, CIlsServer *pIlsServer, IIlsFilter *pFilter, CAttributes *pAttrib, ULONG *puReqID) { LDAP_ASYNCINFO ldai; HRESULT hr; // Validate parameter // if (::MyIsBadServer (pIlsServer) || puReqID == NULL) return ILS_E_POINTER; if (pFilter != NULL) return ILS_E_PARAMETER; // Clone the server object // pIlsServer = ((CIlsServer *) pIlsServer)->Clone (); if (pIlsServer == NULL) return ILS_E_MEMORY; // Get a list of extended attribute names // TCHAR *pszList = NULL; ULONG cList =0, cbList = 0; if (pAttrib != NULL) { hr = ((CAttributes *) pAttrib)->GetAttributeList (&pszList, &cList, &cbList); if (FAILED (hr)) { pIlsServer->Release (); return hr; } } // Construct default filter if needed // TCHAR *pszFilter = NULL; BOOL fDefaultRenderer = FALSE; if (pFilter == NULL) { // Build default filter string // TCHAR szLocalFilter[256]; wsprintf (&szLocalFilter[0], TEXT ("($%u=*)"), (INT) ILS_STDATTR_MEETING_ID ); // Render this filter // hr = StringToFilter (&szLocalFilter[0], (CFilter **) &pFilter); if (! SUCCEEDED (hr)) goto MyExit; // Indicate we have default filter string // fDefaultRenderer = TRUE; } // Create a ldap-like filter // hr = ::FilterToLdapString ((CFilter *) pFilter, &pszFilter); if (hr != S_OK) goto MyExit; // Enum meeting places // hr = fNameOnly ? ::UlsLdap_EnumMeetings (pIlsServer->GetServerInfo (), pszFilter, &ldai) : ::UlsLdap_EnumMeetingInfos (pIlsServer->GetServerInfo (), pszList, cList, pszFilter, &ldai); if (SUCCEEDED(hr)) { COM_REQ_INFO ri; ReqInfo_Init (&ri); // If updating server was successfully requested, wait for the response // ri.uReqType = fNameOnly ? WM_ILS_ENUM_MEETINGS : WM_ILS_ENUM_MEETINGINFOS; ri.uMsgID = ldai.uMsgID; ReqInfo_SetMain (&ri, this); if (! fNameOnly) { ReqInfo_SetServer (&ri, pIlsServer); pIlsServer->AddRef (); } hr = g_pReqMgr->NewRequest(&ri); if (SUCCEEDED(hr)) { // Make sure the objects do not disappear before we get the response // this->AddRef(); // Return the request ID // *puReqID = ri.uReqID; }; }; MyExit: // Free the server object // pIlsServer->Release (); // Free the list of extended attribute names // ::MemFree (pszList); // Free the filter string // ::MemFree (pszFilter); // Release default filter if needed // if (fDefaultRenderer && pFilter != NULL) pFilter->Release (); return hr; } #endif // ENABLE_MEETING_PLACE #ifdef ENABLE_MEETING_PLACE STDMETHODIMP CIlsMain:: EnumMeetingPlaces ( IIlsServer *pServer, IIlsFilter *pFilter, IIlsAttributes *pAttributes, IEnumIlsMeetingPlaces **ppEnum, ULONG *puReqID) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } // We do not implement synchronous operation // if (ppEnum != NULL) return ILS_E_NOT_IMPL; return EnumMeetingPlacesEx (FALSE, (CIlsServer *) pServer, pFilter, (CAttributes *) pAttributes, puReqID); } #endif // ENABLE_MEETING_PLACE //**************************************************************************** // HRESULT // CIlsMain::EnumMeetingPlacesResult (ULONG uReqID, PLDAP_ENUM ple, LPTSTR szServer) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** #ifdef ENABLE_MEETING_PLACE HRESULT CIlsMain::EnumMeetingPlacesResult (ULONG uReqID, PLDAP_ENUM ple, CIlsServer *pIlsServer) { CIlsMeetingPlace **ppm; ULONG cMeetingPlaces; ENUMRINFO eri; HRESULT hr; if (ple != NULL) { eri.hResult = ple->hResult; cMeetingPlaces = ple->cItems; } else { eri.hResult = S_FALSE; cMeetingPlaces = 0; }; eri.uReqID = uReqID; eri.cItems = 0; if ((eri.hResult == NOERROR) && (cMeetingPlaces != 0)) { ASSERT (! MyIsBadServer (pIlsServer)); // Build an array of MeetingPlace objects here // ppm = (CIlsMeetingPlace **) ::MemAlloc (cMeetingPlaces*sizeof(CIlsMeetingPlace *)); if (ppm != NULL) { CIlsMeetingPlace *pm; PLDAP_MEETINFO pmi; ULONG i; // Build one MeetingPlace object at a time // pmi = (PLDAP_MEETINFO)(((PBYTE)ple)+ple->uOffsetItems); for (i = 0; i < cMeetingPlaces; i++) { pm = new CIlsMeetingPlace; if (pm != NULL) { if (SUCCEEDED(pm->Init(pIlsServer, pmi))) { pm->AddRef(); ppm[eri.cItems++] = pm; } else { delete pm; }; }; pmi++; }; } else { eri.hResult = ILS_E_MEMORY; }; } else { ppm = NULL; }; // Package the notification info // eri.pv = (void *)ppm; NotifySink((void *)&eri, OnNotifyEnumMeetingPlacesResult); // Free the resources // if (ppm != NULL) { for (; eri.cItems; eri.cItems--) { ppm[eri.cItems-1]->Release(); }; ::MemFree (ppm); }; return NOERROR; } #endif // ENABLE_MEETING_PLACE //**************************************************************************** // STDMETHODIMP // CIlsMain::EnumMeetingPlaceNames (BSTR bstrServerName, IIlsFilter *pFilter, // ULONG *puReqID) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** #ifdef ENABLE_MEETING_PLACE STDMETHODIMP CIlsMain:: EnumMeetingPlaceNames ( IIlsServer *pServer, IIlsFilter *pFilter, IEnumIlsNames **ppEnum, ULONG *puReqID) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } // We do not implement synchronous operation // if (ppEnum != NULL) return ILS_E_NOT_IMPL; return EnumMeetingPlacesEx (TRUE, (CIlsServer *) pServer, pFilter, NULL, puReqID); } #endif // ENABLE_MEETING_PLACE //**************************************************************************** // HRESULT // CIlsMain::EnumMeetingPlaceNamesResult (ULONG uReqID, PLDAP_ENUM ple) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** #ifdef ENABLE_MEETING_PLACE HRESULT CIlsMain::EnumMeetingPlaceNamesResult (ULONG uReqID, PLDAP_ENUM ple) { ENUMRINFO eri; // Package the notification info // eri.uReqID = uReqID; // PLDAP_ENUM is NULL when the enumeration is terminated successfully // if (ple != NULL) { eri.hResult = ple->hResult; eri.cItems = ple->cItems; eri.pv = (void *)(((PBYTE)ple)+ple->uOffsetItems); } else { eri.hResult = S_FALSE; eri.cItems = 0; eri.pv = NULL; }; NotifySink((void *)&eri, OnNotifyEnumMeetingPlaceNamesResult); return NOERROR; } #endif // ENABLE_MEETING_PLACE //**************************************************************************** // STDMETHODIMP // CIlsMain::Abort (ULONG uReqID) // // History: // Wed 17-Apr-1996 11:14:03 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain::Abort (ULONG uReqID) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } COM_REQ_INFO ri; ReqInfo_Init (&ri); BOOL fServerReq; HRESULT hr; // Look for the matching request information // ri.uReqID = uReqID; ri.uMsgID = 0; hr = g_pReqMgr->GetRequestInfo(&ri); if (FAILED(hr)) { return ILS_E_PARAMETER; }; // Determine the request type // hr = NOERROR; switch(ri.uReqType) { //************************************************************************* // Fail if it is register request. // Cancelling register request must be done through unregister //************************************************************************* // case WM_ILS_LOCAL_REGISTER: case WM_ILS_LOCAL_UNREGISTER: return ILS_E_FAIL; //************************************************************************* // These requests are parts of register, they should not be exposed to // the caller. //************************************************************************* // case WM_ILS_REGISTER_CLIENT: case WM_ILS_UNREGISTER_CLIENT: ASSERT(0); break; //************************************************************************* // Release the objects and resources refernced or allocated for the request // See callback.cpp for the handler in the successful response case //************************************************************************* // case WM_ILS_REGISTER_PROTOCOL: case WM_ILS_UNREGISTER_PROTOCOL: case WM_ILS_LOCAL_REGISTER_PROTOCOL: case WM_ILS_LOCAL_UNREGISTER_PROTOCOL: { CIlsUser *pUser = ReqInfo_GetUser (&ri); if (pUser != NULL) pUser->Release (); CLocalProt *pProtocol = ReqInfo_GetProtocol (&ri); if (pProtocol != NULL) pProtocol->Release (); } break; case WM_ILS_SET_CLIENT_INFO: case WM_ILS_ENUM_PROTOCOLS: case WM_ILS_RESOLVE_PROTOCOL: { CIlsUser *pUser = ReqInfo_GetUser (&ri); if (pUser != NULL) pUser->Release (); } break; case WM_ILS_ENUM_CLIENTS: { CIlsMain *pMain = ReqInfo_GetMain (&ri); if (pMain != NULL) pMain->Release (); } break; case WM_ILS_RESOLVE_CLIENT: case WM_ILS_ENUM_CLIENTINFOS: { CIlsMain *pMain = ReqInfo_GetMain (&ri); if (pMain != NULL) pMain->Release (); CIlsServer *pServer = ReqInfo_GetServer (&ri); if (pServer != NULL) pServer->Release (); } break; //************************************************************************* // Fail if it is register request. // Cancelling register request must be done through unregister //************************************************************************* // #ifdef ENABLE_MEETING_PLACE case WM_ILS_REGISTER_MEETING: case WM_ILS_UNREGISTER_MEETING: return ILS_E_FAIL; case WM_ILS_SET_MEETING_INFO: case WM_ILS_ADD_ATTENDEE: case WM_ILS_REMOVE_ATTENDEE: case WM_ILS_ENUM_ATTENDEES: { CIlsMeetingPlace *pMeeting = ReqInfo_GetMeeting (&ri); if (pMeeting != NULL) pMeeting->Release (); } break; case WM_ILS_RESOLVE_MEETING: case WM_ILS_ENUM_MEETINGINFOS: { CIlsMain *pMain = ReqInfo_GetMain (&ri); if (pMain != NULL) pMain->Release (); CIlsServer *pServer = ReqInfo_GetServer (&ri); if (pServer != NULL) pServer->Release (); } break; case WM_ILS_ENUM_MEETINGS: { CIlsMain *pMain = ReqInfo_GetMain (&ri); if (pMain != NULL) pMain->Release (); } break; #endif // ENABLE_MEETING_PLACE default: // Unknown request // ASSERT(0); break; }; // If it is a server request, cancel the request // if (ri.uMsgID != 0) { hr = UlsLdap_Cancel(ri.uMsgID); }; if (SUCCEEDED(hr)) { // Remove the request from the queue // hr = g_pReqMgr->RequestDone(&ri); }; return hr; } //**************************************************************************** // STDMETHODIMP // CIlsMain::EnumConnectionPoints(IEnumConnectionPoints **ppEnum) // // History: // Wed 17-Apr-1996 11:15:02 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain::EnumConnectionPoints(IEnumConnectionPoints **ppEnum) { CEnumConnectionPoints *pecp; HRESULT hr; // Validate parameters // if (ppEnum == NULL) { return ILS_E_POINTER; }; // Assume failure // *ppEnum = NULL; // Create an enumerator // pecp = new CEnumConnectionPoints; if (pecp == NULL) return ILS_E_MEMORY; // Initialize the enumerator // hr = pecp->Init((IConnectionPoint *)pConnPt); if (FAILED(hr)) { delete pecp; return hr; }; // Give it back to the caller // pecp->AddRef(); *ppEnum = pecp; return S_OK; } //**************************************************************************** // STDMETHODIMP // CIlsMain::FindConnectionPoint(REFIID riid, IConnectionPoint **ppcp) // // History: // Wed 17-Apr-1996 11:15:09 -by- Viroon Touranachun [viroont] // Created. //**************************************************************************** STDMETHODIMP CIlsMain::FindConnectionPoint(REFIID riid, IConnectionPoint **ppcp) { IID siid; HRESULT hr; // Validate parameters // if (ppcp == NULL) { return ILS_E_POINTER; }; // Assume failure // *ppcp = NULL; if (pConnPt != NULL) { hr = pConnPt->GetConnectionInterface(&siid); if (SUCCEEDED(hr)) { if (riid == siid) { *ppcp = (IConnectionPoint *)pConnPt; (*ppcp)->AddRef(); hr = S_OK; } else { hr = ILS_E_NO_INTERFACE; }; }; } else { hr = ILS_E_NO_INTERFACE; }; return hr; } /* ---------------------------------------------------------------------- CIlsMain::CreateFilter Output: ppFilter: a placeholder for the new filter object Input: FilterOp: a filter operation History: 11/12/96 Chu, Lon-Chan [lonchanc] Created. ---------------------------------------------------------------------- */ STDMETHODIMP CIlsMain:: CreateFilter ( ILS_FILTER_TYPE FilterType, ILS_FILTER_OP FilterOp, IIlsFilter **ppFilter ) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } // Make sure we have valid return pointer // if (ppFilter == NULL) return ILS_E_POINTER; // Make sure type/op are compatible // HRESULT hr = S_OK; switch (FilterType) { case ILS_FILTERTYPE_COMPOSITE: // Make sure type/op are compatible // switch (FilterOp) { case ILS_FILTEROP_AND: // Supported // break; case ILS_FILTEROP_OR: case ILS_FILTEROP_NOT: // Not supported // // lonchanc: let it fail at the server side hr = ILS_S_SERVER_MAY_NOT_SUPPORT; break; default: // Invalid // hr = ILS_E_PARAMETER; break; } break; case ILS_FILTERTYPE_SIMPLE: // Make sure type/op are compatible // switch (FilterOp) { case ILS_FILTEROP_EQUAL: case ILS_FILTEROP_EXIST: case ILS_FILTEROP_LESS_THAN: case ILS_FILTEROP_GREATER_THAN: // Supported // break; case ILS_FILTEROP_APPROX: // Not supported // hr = ILS_S_SERVER_MAY_NOT_SUPPORT; break; default: // Invalid // hr = ILS_E_PARAMETER; break; } break; default: hr = ILS_E_FILTER_TYPE; break; } // Create filter only if type/op are compatible // if (SUCCEEDED (hr)) { CFilter *pFilter = new CFilter (FilterType); *ppFilter = pFilter; if (pFilter != NULL) { hr = S_OK; pFilter->AddRef (); pFilter->SetOp (FilterOp); } else hr = ILS_E_MEMORY; } return hr; } /* ---------------------------------------------------------------------- CIlsMain::StringToFilter Output: ppFilter: a placeholder for the new filter object Input: bstrFilterString: an LDAP-like filter string History: 11/12/96 Chu, Lon-Chan [lonchanc] Created. ---------------------------------------------------------------------- */ STDMETHODIMP CIlsMain:: StringToFilter ( BSTR bstrFilterString, IIlsFilter **ppFilter ) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } // Make sure the filter string is valid // if (bstrFilterString == NULL) return ILS_E_POINTER; // Convert a bstr to an ansi string // TCHAR *pszFilter = NULL; HRESULT hr = ::BSTR_to_LPTSTR (&pszFilter, bstrFilterString); if (hr == S_OK) { ASSERT (pszFilter != NULL); // Render this filter // hr = StringToFilter (pszFilter, (CFilter **) ppFilter); // Free the temporary ansi string // ::MemFree(pszFilter); } return hr; } HRESULT CIlsMain:: StringToFilter ( TCHAR *pszFilter, CFilter **ppFilter ) { // Construct a composite filter // CFilterParser FilterParser; return FilterParser.Expr (ppFilter, pszFilter); } STDMETHODIMP CIlsMain:: CreateServer ( BSTR bstrServerName, IIlsServer **ppServer ) { // Make sure ils main is initialized // if (! IsInitialized ()) { return ILS_E_NOT_INITIALIZED; } if (bstrServerName == NULL || ppServer == NULL) return ILS_E_POINTER; HRESULT hr; CIlsServer *pIlsServer = new CIlsServer; if (pIlsServer != NULL) { hr = pIlsServer->SetServerName (bstrServerName); if (hr == S_OK) { pIlsServer->AddRef (); } else { delete pIlsServer; pIlsServer = NULL; } } else { hr = ILS_E_MEMORY; } *ppServer = (IIlsServer *) pIlsServer; return hr; } /* ---------- server authentication object ------------ */ CIlsServer:: CIlsServer ( VOID ) :m_cRefs (0), m_dwSignature (ILS_SERVER_SIGNATURE) { ::ZeroMemory (&m_ServerInfo, sizeof (m_ServerInfo)); m_ServerInfo.AuthMethod = ILS_AUTH_ANONYMOUS; } CIlsServer:: ~CIlsServer ( VOID ) { m_dwSignature = 0; ::IlsFreeServerInfo (&m_ServerInfo); } STDMETHODIMP_(ULONG) CIlsServer:: AddRef ( VOID ) { DllLock(); MyDebugMsg ((DM_REFCOUNT, "CIlsServer::AddRef: ref=%ld\r\n", m_cRefs)); ::InterlockedIncrement (&m_cRefs); return m_cRefs; } STDMETHODIMP_(ULONG) CIlsServer:: Release ( VOID ) { DllRelease(); ASSERT (m_cRefs > 0); MyDebugMsg ((DM_REFCOUNT, "CIlsServer::Release: ref=%ld\r\n", m_cRefs)); if (::InterlockedDecrement (&m_cRefs) == 0) { delete this; return 0; } return m_cRefs; } STDMETHODIMP CIlsServer:: QueryInterface ( REFIID riid, VOID **ppv ) { *ppv = NULL; if (riid == IID_IIlsServer || riid == IID_IUnknown) { *ppv = (IIlsServer *) this; } if (*ppv != NULL) { ((LPUNKNOWN) *ppv)->AddRef(); return S_OK; } return ILS_E_NO_INTERFACE; } STDMETHODIMP CIlsServer:: SetAuthenticationMethod ( ILS_ENUM_AUTH_METHOD enumAuthMethod ) { HRESULT hr; if (ILS_AUTH_ANONYMOUS <= enumAuthMethod && enumAuthMethod < ILS_NUM_OF_AUTH_METHODS) { m_ServerInfo.AuthMethod = enumAuthMethod; hr = S_OK; } else { hr = ILS_E_PARAMETER; } return hr; } STDMETHODIMP CIlsServer:: SetLogonName ( BSTR bstrLogonName ) { // Make sure the filter string is valid // if (bstrLogonName == NULL) return ILS_E_POINTER; // Convert a bstr to an ansi string // TCHAR *psz = NULL; HRESULT hr = ::BSTR_to_LPTSTR (&psz, bstrLogonName); if (hr == S_OK) { // Free the old string // ::MemFree (m_ServerInfo.pszLogonName); // Keep the new string // m_ServerInfo.pszLogonName = psz; } return hr; } STDMETHODIMP CIlsServer:: SetLogonPassword ( BSTR bstrLogonPassword ) { // Make sure the filter string is valid // if (bstrLogonPassword == NULL) return ILS_E_POINTER; // Convert a bstr to an ansi string // TCHAR *psz = NULL; HRESULT hr = ::BSTR_to_LPTSTR (&psz, bstrLogonPassword); if (hr == S_OK) { // Free the old string // ::MemFree (m_ServerInfo.pszLogonPassword); // Keep the new string // m_ServerInfo.pszLogonPassword = psz; } return hr; } STDMETHODIMP CIlsServer:: SetDomain ( BSTR bstrDomain ) { // Make sure the filter string is valid // if (bstrDomain == NULL) return ILS_E_POINTER; // Convert a bstr to an ansi string // TCHAR *psz = NULL; HRESULT hr = ::BSTR_to_LPTSTR (&psz, bstrDomain); if (hr == S_OK) { // Free the old string // ::MemFree (m_ServerInfo.pszDomain); // Keep the new string // m_ServerInfo.pszDomain = psz; } return hr; } STDMETHODIMP CIlsServer:: SetCredential ( BSTR bstrCredential ) { // Make sure the filter string is valid // if (bstrCredential == NULL) return ILS_E_POINTER; // Convert a bstr to an ansi string // TCHAR *psz = NULL; HRESULT hr = ::BSTR_to_LPTSTR (&psz, bstrCredential); if (hr == S_OK) { // Free the old string // ::MemFree (m_ServerInfo.pszCredential); // Keep the new string // m_ServerInfo.pszCredential = psz; } return hr; } STDMETHODIMP CIlsServer:: SetTimeout ( ULONG uTimeoutInSecond ) { m_ServerInfo.uTimeoutInSecond = uTimeoutInSecond; return S_OK; } STDMETHODIMP CIlsServer:: SetBaseDN ( BSTR bstrBaseDN ) { // Make sure the filter string is valid // if (bstrBaseDN == NULL) return ILS_E_POINTER; // Convert a bstr to an ansi string // TCHAR *psz = NULL; HRESULT hr = ::BSTR_to_LPTSTR (&psz, bstrBaseDN); if (hr == S_OK) { // Free the old string // ::MemFree (m_ServerInfo.pszBaseDN); // Keep the new string // m_ServerInfo.pszBaseDN = psz; } return hr; } HRESULT CIlsServer:: SetServerName ( TCHAR *pszServerName ) { // Make sure the filter string is valid // if (pszServerName == NULL) return ILS_E_POINTER; // duplicate the server name // HRESULT hr; TCHAR *psz = ::My_strdup (pszServerName); if (psz != NULL) { if (MyIsGoodString (psz)) { // Free the old string // ::MemFree (m_ServerInfo.pszServerName); // Keep the new string // m_ServerInfo.pszServerName = psz; hr = S_OK; } else { ::MemFree (psz); psz = NULL; hr = ILS_E_PARAMETER; } } else { hr = ILS_E_MEMORY; } return hr; } HRESULT CIlsServer:: SetServerName ( BSTR bstrServerName ) { // Make sure the filter string is valid // if (bstrServerName == NULL) return ILS_E_POINTER; // Convert a bstr to an ansi string // TCHAR *psz = NULL; HRESULT hr = ::BSTR_to_LPTSTR (&psz, bstrServerName); if (hr == S_OK) { if (MyIsGoodString (psz)) { // Free the old string // ::MemFree (m_ServerInfo.pszServerName); // Keep the new string // m_ServerInfo.pszServerName = psz; } else { ::MemFree (psz); psz = NULL; hr = ILS_E_PARAMETER; } } return ((psz != NULL) ? S_OK : ILS_E_MEMORY); } TCHAR *CIlsServer:: DuplicateServerName ( VOID ) { return My_strdup (m_ServerInfo.pszServerName); } BSTR CIlsServer:: DuplicateServerNameBSTR ( VOID ) { BSTR bstr = NULL; TCHAR *psz = DuplicateServerName (); if (psz != NULL) { LPTSTR_to_BSTR (&bstr, psz); } return bstr; } CIlsServer *CIlsServer:: Clone ( VOID ) { CIlsServer *p = new CIlsServer; if (p != NULL) { if (::IlsCopyServerInfo (p->GetServerInfo (), GetServerInfo ()) == S_OK) { p->AddRef (); } else { ::IlsFreeServerInfo (p->GetServerInfo ()); ::MemFree (p); p = NULL; } } return p; }