windows-server-2003/admin/cys/servmgmt/snapins/manager/queryreq.cpp

// queryreq.cpp - Query request handler

#include "stdafx.h"
#include <process.h>
#include "queryreq.h"
#include "namemap.h"
#include "resource.h"
#include "util.h"
#include "lmaccess.h"

#include <algorithm>


// singleton query thread object
CQueryThread g_QueryThread;



////////////////////////////////////////////////////////////////////////////////////////////
// class CQueryRequest
//

#define MSG_QUERY_START     (WM_USER + 1)
#define MSG_QUERY_REPLY     (WM_USER + 2)

// static members
HWND CQueryRequest::m_hWndCB = NULL;

// Forward ref
LRESULT CALLBACK QueryRequestWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
HANDLE CQueryRequest::m_hMutex = NULL;

// query window class object
CMsgWindowClass QueryWndClass(L"BOMQueryHandler", QueryRequestWndProc);  


CQueryRequest::CQueryRequest()
{
    m_cRef        = 0;
    m_eState      = QRST_INACTIVE;
    m_cPrefs      = 0;
    m_paSrchPrefs = NULL;
    m_hrStatus    = S_OK;
    m_pvstrAttr   = NULL;
    m_pQueryCallback = NULL;
}

CQueryRequest::~CQueryRequest()
{
    if (m_paSrchPrefs != NULL)
        delete m_paSrchPrefs;
}


HRESULT CQueryRequest::SetQueryParameters(LPCWSTR pszScope, LPCWSTR pszFilter, string_vector* pvstrClasses, string_vector* pvstrAttr)
{
    if( !pszScope || !pszScope[0] || !pszFilter || !pvstrClasses || pvstrClasses->empty() ) return E_INVALIDARG;
    if( m_eState != QRST_INACTIVE ) return E_FAIL;

    m_strScope  = pszScope;
    m_strFilter = pszFilter;
    m_vstrClasses = *pvstrClasses;
    m_pvstrAttr = pvstrAttr;

    return S_OK;
}


HRESULT CQueryRequest::SetSearchPreferences(ADS_SEARCHPREF_INFO* paSrchPrefs, int cPrefs)
{
    m_cPrefs = cPrefs;

    if( cPrefs == 0 ) return S_OK;  // Special case

    if( !paSrchPrefs ) return E_POINTER;
    if( m_eState != QRST_INACTIVE ) return E_FAIL;

    m_paSrchPrefs = new ADS_SEARCHPREF_INFO[cPrefs];
    if (m_paSrchPrefs == NULL) return E_OUTOFMEMORY;
    
    memcpy(m_paSrchPrefs, paSrchPrefs, cPrefs * sizeof(ADS_SEARCHPREF_INFO)); 

    return S_OK;
}


HRESULT CQueryRequest::SetCallback(CQueryCallback* pCallback, LPARAM lUserParam)
{
    if( m_eState != QRST_INACTIVE ) return E_FAIL;

    m_pQueryCallback = pCallback;
    m_lUserParam = lUserParam;

    return S_OK;
}


HRESULT CQueryRequest::Start()
{
    if( m_strScope.empty() || !m_pQueryCallback ) return E_FAIL;
    if( m_eState != QRST_INACTIVE ) return E_FAIL;

    // Create callback window the first time (m_hwndCB is static)
    if (m_hWndCB == NULL) 
        m_hWndCB = QueryWndClass.Window();

    if (m_hWndCB == NULL) return E_FAIL;

    // Create mutex the first time (m_hMutex is static)
    if (m_hMutex == NULL) 
        m_hMutex = CreateMutex(NULL, FALSE, NULL);

    if (m_hMutex == NULL) return E_FAIL;

    // Post request to query thread
    Lock();

    BOOL bStat = g_QueryThread.PostRequest(this);
    if (bStat)
    {
        m_eState = QRST_QUEUED;
        m_cRef++;
    }

    Unlock();

    return bStat ? S_OK : E_FAIL;
}


HRESULT CQueryRequest::Stop(BOOL bNotify)
{
    HRESULT hr = S_OK;

    Lock();

    if (m_eState == QRST_QUEUED || m_eState == QRST_ACTIVE)
    {
        // Change state to stopped and notify the user if requested.
        // Don't release the query request here because the query thread needs
        // to see the new state. When the thread sees the stopped state it will
        // send a message to this thread's window proc, which will release the request.
        m_eState = QRST_STOPPED;
        if (bNotify)
        {
            ASSERT(m_pQueryCallback != NULL);
            m_pQueryCallback->QueryCallback(QRYN_STOPPED, this, m_lUserParam);
        }
    }
    else
    {
       hr = S_FALSE;
    }

    Unlock();

    return hr; 
}


void CQueryRequest::Release()
{
    ASSERT(m_cRef > 0);

    if (--m_cRef == 0)
        delete this;
}


void CQueryRequest::Execute()
{
    // Move query to active state (if still in queued state)
    Lock();
    ASSERT(m_eState == QRST_QUEUED || m_eState == QRST_STOPPED);
    if (m_eState == QRST_STOPPED)
    {
        PostMessage(m_hWndCB, MSG_QUERY_REPLY, (WPARAM)this, (LPARAM)QRYN_STOPPED);

        Unlock();
        return;
    }

    m_eState = QRST_ACTIVE;
    Unlock();

    // Intiate the query
    CComPtr<IDirectorySearch> spDirSrch;
    ADS_SEARCH_HANDLE hSearch;
    LPCWSTR* paszAttr = NULL;
    LPCWSTR* paszNameAttr = NULL;

    do
    {
        // Create a directory search object     
        m_hrStatus = ADsOpenObject(m_strScope.c_str(), NULL, NULL, ADS_SECURE_AUTHENTICATION, IID_IDirectorySearch, (LPVOID*)&spDirSrch);
        BREAK_ON_FAILURE(m_hrStatus)
    
        if (m_cPrefs != 0) 
        {
            m_hrStatus = spDirSrch->SetSearchPreference(m_paSrchPrefs, m_cPrefs);
            BREAK_ON_FAILURE(m_hrStatus)
        }
    

        // Get naming attribute for each query class
        // This will be the attribute placed in column [0] of each RowItem 
        paszNameAttr = new LPCWSTR[m_vstrClasses.size()];
        if (paszNameAttr == NULL) 
        {
            m_hrStatus = E_OUTOFMEMORY;
            break;
        }

        for (int i = 0; i < m_vstrClasses.size(); i++) 
        {
            // get display name map for this class
            DisplayNameMap* pNameMap = DisplayNames::GetMap(m_vstrClasses[i].c_str());
            ASSERT(pNameMap != NULL);

            // Save pointer to naming attribute
            paszNameAttr[i] = pNameMap->GetNameAttribute();
        }


        // Create array of attribute name ptrs for ExecuteSearch
        // Include space for user selected attribs, naming attribs, class and object path (distinguised name)
        paszAttr = new LPCWSTR[m_pvstrAttr->size() + m_vstrClasses.size() + 3];
        if (paszAttr == NULL) 
        {
            m_hrStatus = E_OUTOFMEMORY;
            break;
        }

        int cAttr = 0;

        // add user selected attributes
        // These must be first because the column loop in the query code below indexes through them
        for (i=0; i < m_pvstrAttr->size(); i++)
            paszAttr[cAttr++] = const_cast<LPWSTR>((*m_pvstrAttr)[i].c_str());

        // add class naming attributes
        for (i = 0; i < m_vstrClasses.size(); i++)
        {
            // Multiple classes can use the same name so check for dup before adding
            int j = 0;
            while (j < i && wcscmp(paszNameAttr[i], paszNameAttr[j]) != 0) j++;

            if (j == i)
                paszAttr[cAttr++] = paszNameAttr[i];
        }

        // add path attribute
        paszAttr[cAttr++] = L"distinguishedName";

        // add class attribute
        paszAttr[cAttr++] = L"objectClass";

		// add user state attribute
		paszAttr[cAttr++] = L"userAccountControl";


        // Add (& ... ) around the query because DSQuery leaves it off
        // and GetNextRow causes heap error or endless query without it
        Lock();
        m_strFilter.insert(0, L"(&"),
        m_strFilter.append(L")");

        // Initiate search
        m_hrStatus = spDirSrch->ExecuteSearch((LPWSTR)m_strFilter.c_str(), (LPWSTR*)paszAttr, cAttr, &hSearch);
        Unlock();

        BREAK_ON_FAILURE(m_hrStatus)

    } while (FALSE);
     

    // If search failed, change query state and send failure message
    if (FAILED(m_hrStatus)) 
    {
        // Don't do anything if query has already been stopped
        Lock();
        if (m_eState == QRST_ACTIVE) 
        {
            m_eState = QRST_FAILED;
            PostMessage(m_hWndCB, MSG_QUERY_REPLY, (WPARAM)this, (LPARAM)QRYN_FAILED);
        }
        Unlock();

        delete [] paszAttr;
        paszAttr = NULL;

        delete [] paszNameAttr;
        paszNameAttr = NULL;

        return;
    }
    
    // Get class map for translating class names
    DisplayNameMap* pNameMap = DisplayNames::GetClassMap();
    if( !pNameMap ) return;

    // Get Results
    int nItems = 0;
 
    while (nItems < MAX_RESULT_ITEMS && spDirSrch->GetNextRow(hSearch) == S_OK)
    {
        ADS_SEARCH_COLUMN col;

       // Allocate row item for user attributes plus fixed attributes (name & class)
       CRowItem* pRowItem = new CRowItem(m_pvstrAttr->size() + ROWITEM_USER_INDEX);
       if (pRowItem == NULL)
       {
           m_hrStatus = E_OUTOFMEMORY;
           break;
       }

       // Get path attribute
       if (spDirSrch->GetColumn(hSearch, L"distinguishedName", &col) == S_OK)
       {
           pRowItem->SetObjPath(col.pADsValues->CaseIgnoreString);
           spDirSrch->FreeColumn(&col);
       }

       // Get class attribute
       if (spDirSrch->GetColumn(hSearch, L"objectClass", &col) == S_OK)
       {
            // Class name is last element of multivalued objectClass attribute
            ASSERT(col.dwADsType == ADSTYPE_CASE_IGNORE_STRING);
            LPWSTR pszClass = col.pADsValues[col.dwNumValues-1].CaseIgnoreString;

            // Put class display name in row item
            pRowItem->SetAttribute(ROWITEM_CLASS_INDEX, pNameMap->GetAttributeDisplayName(pszClass));

            // Find class name in query classes vector
            string_vector::iterator itClass = std::find(m_vstrClasses.begin(), m_vstrClasses.end(), pszClass);

            // if found, look up name attribute for this class and put it in the rowitem 
            if (itClass != m_vstrClasses.end()) 
            {
                ADS_SEARCH_COLUMN colName;
                if (spDirSrch->GetColumn(hSearch, (LPWSTR)paszNameAttr[itClass - m_vstrClasses.begin()], &colName) == S_OK)
                {
                    pRowItem->SetAttribute(ROWITEM_NAME_INDEX, colName.pADsValues->CaseIgnoreString);
                    spDirSrch->FreeColumn(&colName);
                }
            }
			else
			{
				// Use CN from path for the name
				LPCWSTR pszPath = pRowItem->GetObjPath();
                if( pszPath == NULL )
                {
                    m_hrStatus = E_OUTOFMEMORY;
                    break;
                }

				LPCWSTR pszSep;
				if (_tcsnicmp(pszPath, L"CN=", 3) == 0 && (pszSep = _tcschr(pszPath + 3, L',')) != NULL)
				{
					// Limit name to MAX_PATH chars
					int cch = pszSep - (pszPath + 3);
					if (cch >= MAX_PATH)
						cch = MAX_PATH - 1;

					// Create null-terminated CN string
					WCHAR szTemp[MAX_PATH];
					memcpy(szTemp, pszPath + 3, cch * sizeof(WCHAR));
					szTemp[cch] = 0;

					pRowItem->SetAttribute(ROWITEM_NAME_INDEX , szTemp);  				
				}
				else
				{
					ASSERT(0);
				}
			}

            spDirSrch->FreeColumn(&col);
       }


	   // Set disabled status based on the value returned by AD
		if (SUCCEEDED(spDirSrch->GetColumn(hSearch, L"userAccountControl", &col)))
		{
			pRowItem->SetDisabled((col.pADsValues->Integer & UF_ACCOUNTDISABLE) != 0);
			spDirSrch->FreeColumn(&col);
		}

       // loop through all user attributes
       for (int iAttr = 0; iAttr < m_pvstrAttr->size(); ++iAttr)
       {
           HRESULT hr = spDirSrch->GetColumn(hSearch, (LPWSTR)paszAttr[iAttr], &col);
           if (SUCCEEDED(hr) && col.dwNumValues > 0)
           {
               WCHAR szBuf[MAX_PATH] = {0};
              LPWSTR psz = NULL;

              switch (col.dwADsType)
              {
                case ADSTYPE_DN_STRING:
                case ADSTYPE_CASE_EXACT_STRING:    
                case ADSTYPE_PRINTABLE_STRING:    
                case ADSTYPE_NUMERIC_STRING:      
                case ADSTYPE_TYPEDNAME:        
                case ADSTYPE_FAXNUMBER:        
                case ADSTYPE_PATH:          
                case ADSTYPE_OBJECT_CLASS:
                case ADSTYPE_CASE_IGNORE_STRING:
                    psz = col.pADsValues->CaseIgnoreString;
                    break;

                case ADSTYPE_BOOLEAN:
                    if (col.pADsValues->Boolean)
                    {
                        static WCHAR szYes[16] = L"";
                        if (szYes[0] == 0)
                        {
                           int nLen = ::LoadString(_Module.GetResourceInstance(), IDS_YES, szYes, lengthof(szYes));
                           ASSERT(nLen != 0);
                        }
                        psz = szYes;
                    }
                    else
                    {
                        static WCHAR szNo[16] = L"";
                        if (szNo[0] == 0)
                        {
                           int nLen = ::LoadString(_Module.GetResourceInstance(), IDS_NO, szNo, lengthof(szNo));
                           ASSERT(nLen != 0);
                        }
                        psz = szNo;
                    }
                    break;

                case ADSTYPE_INTEGER:
                    _snwprintf( szBuf, MAX_PATH-1, L"%d",col.pADsValues->Integer );
                    psz = szBuf;
                    break;

                case ADSTYPE_OCTET_STRING:
                  if ( (_wcsicmp(col.pszAttrName, L"objectGUID") == 0) )
                  {
                     //Cast to LPGUID
                     GUID* pObjectGUID = (LPGUID)(col.pADsValues->OctetString.lpValue);
                     //Convert GUID to string.
                     ::StringFromGUID2(*pObjectGUID, szBuf, 39);
                     psz = szBuf;
                  }
                  break;

                case ADSTYPE_UTC_TIME:
                    {
                      SYSTEMTIME systemtime = col.pADsValues->UTCTime;
                      DATE date;
                      VARIANT varDate;
                      if (SystemTimeToVariantTime(&systemtime, &date) != 0) 
                      {
                        //Pack in variant.vt.
                        varDate.vt = VT_DATE;
                        varDate.date = date;
                        if( SUCCEEDED(VariantChangeType(&varDate,&varDate, VARIANT_NOVALUEPROP, VT_BSTR)) )
                        {
                            wcsncpy(szBuf, varDate.bstrVal, MAX_PATH-1);                            
                        }
                        
                        VariantClear(&varDate);
                      }
                    }
                  break;

                case ADSTYPE_LARGE_INTEGER:
                    {
                        LARGE_INTEGER liValue;
                        FILETIME filetime;
                        DATE date;
                        SYSTEMTIME systemtime;
                        VARIANT varDate;

                        liValue = col.pADsValues->LargeInteger;
                        filetime.dwLowDateTime = liValue.LowPart;
                        filetime.dwHighDateTime = liValue.HighPart;

                        if((filetime.dwHighDateTime!=0) || (filetime.dwLowDateTime!=0))
                        {
                            //Check for properties of type LargeInteger that represent time.
                            //If TRUE, then convert to variant time.
                            if ((0==wcscmp(L"accountExpires", col.pszAttrName)) ||
                                (0==wcscmp(L"badPasswordTime", col.pszAttrName))||
                                (0==wcscmp(L"lastLogon", col.pszAttrName))      ||
                                (0==wcscmp(L"lastLogoff", col.pszAttrName))     ||
                                (0==wcscmp(L"lockoutTime", col.pszAttrName))    ||
                                (0==wcscmp(L"pwdLastSet", col.pszAttrName))
                               )
                            {
                                //Handle special case for Never Expires where low part is -1
                                if (filetime.dwLowDateTime==-1)
                                {
                                    psz = L"Never Expires";
                                }
                                else
                                {

                                    if ( (FileTimeToLocalFileTime(&filetime, &filetime) != 0) && 
                                         (FileTimeToSystemTime(&filetime, &systemtime) != 0)  &&
                                         (SystemTimeToVariantTime(&systemtime, &date) != 0) )
                                    {
                                        //Pack in variant.vt.
                                        varDate.vt = VT_DATE;
                                        varDate.date = date;
                                        if( SUCCEEDED(VariantChangeType(&varDate, &varDate, VARIANT_NOVALUEPROP,VT_BSTR)) )
                                        {
                                            wcsncpy( szBuf, varDate.bstrVal, lengthof(szBuf) );
                                            psz = szBuf;
                                        }

                                        VariantClear(&varDate);
                                    }
                                }
                            }
                            else
                            {
                              //Print the LargeInteger.
                              _snwprintf(szBuf, MAX_PATH-1, L"%d,%d",filetime.dwHighDateTime, filetime.dwLowDateTime);
                            }
                        }
                    }
                    break;

                 case ADSTYPE_NT_SECURITY_DESCRIPTOR:
                     break;
                }


                if (psz != NULL)
                    hr = pRowItem->SetAttribute(iAttr + ROWITEM_USER_INDEX, psz);


                spDirSrch->FreeColumn(&col);
            }
        } // for user attributes

        // Add row to new rows vector and notify client
        Lock();

        // if query is still active
        if (m_eState == QRST_ACTIVE) 
        {
            m_vRowsNew.push_back(*pRowItem);
            delete pRowItem;

            // notify if first new row
            if (m_vRowsNew.size() == 1)
                PostMessage(m_hWndCB, MSG_QUERY_REPLY, (WPARAM)this, (LPARAM)QRYN_NEWROWITEMS);            

            Unlock();
        }
        else
        {
           delete pRowItem;

           Unlock();
           break;
        }
    }

    Lock();

    // If query wasn't stopped, then change state to completed and notify main thread
    if (m_eState == QRST_ACTIVE)
    {
        m_eState = QRST_COMPLETE;
        PostMessage(m_hWndCB, MSG_QUERY_REPLY, (WPARAM)this, (LPARAM)QRYN_COMPLETED);
    }
    else if (m_eState == QRST_STOPPED)
    {
        // if query was stopped, then acknowledge with notify so main thread can release the query req
        PostMessage(m_hWndCB, MSG_QUERY_REPLY, (WPARAM)this, (LPARAM)QRYN_STOPPED);
    }

    Unlock();

    spDirSrch->CloseSearchHandle(hSearch);

    delete [] paszAttr;
    delete [] paszNameAttr;
}


LRESULT CALLBACK QueryRequestWndProc(HWND hWnd, UINT nMsg, WPARAM  wParam, LPARAM  lParam)
{
    if (nMsg == MSG_QUERY_REPLY)
    {
        CQueryRequest* pQueryReq = reinterpret_cast<CQueryRequest*>(wParam);
        if( !pQueryReq ) return 0;

        QUERY_NOTIFY qryn = static_cast<QUERY_NOTIFY>(lParam);

        // Don't do any callbacks for a stopped query. Also, don't forward a stop notification. 
        // The client receives a QRYN_STOPPED directly from the CQueryRequest::Stop() method.
        if (pQueryReq->m_eState != QRST_STOPPED && qryn != QRYN_STOPPED)
            pQueryReq->m_pQueryCallback->QueryCallback(qryn, pQueryReq, pQueryReq->m_lUserParam);

        // any notify but new row items indicates query is completed, so it can be released
        if (qryn != QRYN_NEWROWITEMS)
            pQueryReq->Release();

        return 0;
    }

    return DefWindowProc(hWnd, nMsg, wParam, lParam);
}


////////////////////////////////////////////////////////////////////////////////////////////
// class QueryThread
//
LRESULT CALLBACK QueryHandlerWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

//-----------------------------------------------------------------------------
// CQueryThread::StartThread
//
// Start the thread
//-----------------------------------------------------------------------------

BOOL CQueryThread::Start()
{
    // If thread exists, just return
    if (m_hThread != NULL)
        return TRUE;

    BOOL bRet = FALSE;
    do // False loop
    {
        // Create start event 
        m_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
        if (m_hEvent == NULL)
            break;

        // Start the thread
        m_hThread = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, this, 0, &m_uThreadID);
        if (m_hThread == NULL)
            break;

        // Wait for start event
        DWORD dwEvStat = WaitForSingleObject(m_hEvent, 10000);
        if (dwEvStat != WAIT_OBJECT_0)
            break;


        bRet = TRUE;
    } 
    while (0);
    
    ASSERT(bRet);

    // Clean up on failure
    if (!bRet)
    {
        if (m_hEvent)
        {
            CloseHandle(m_hEvent);
            m_hEvent = NULL;
        }

        if (m_hThread)
        {
            CloseHandle(m_hThread);
            m_hThread = NULL;
        }
    }

    return bRet;
}


void CQueryThread::Kill()
{
    if (m_hThread != NULL)
    {
        PostThreadMessage(m_uThreadID, WM_QUIT, 0, 0);

        MSG msg;
        while (TRUE)
        {
            // Wait either for the thread to be signaled or any input event.
            DWORD dwStat = MsgWaitForMultipleObjects(1, &m_hThread, FALSE, INFINITE, QS_ALLINPUT);

            if (WAIT_OBJECT_0 == dwStat)
                break;  // The thread is signaled.

            // There is one or more window message available.
            // Dispatch them and wait.
            if (PeekMessage(&msg,NULL,NULL,NULL,PM_REMOVE))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }

        CloseHandle(m_hThread);
        CloseHandle(m_hEvent);

        m_hThread = NULL;
        m_hEvent = NULL;
    }   
}


BOOL CQueryThread::PostRequest(CQueryRequest* pQueryReq)
{
    // make sure thread is active
    BOOL bStat = Start();
    if (bStat)
        bStat = PostThreadMessage(m_uThreadID, MSG_QUERY_START, (WPARAM)pQueryReq, (LPARAM)0);

    return bStat;
}


unsigned _stdcall CQueryThread::ThreadProc(void* pVoid )
{
    ASSERT(pVoid != NULL);

    // Do a PeekMessage to create the message queue
    MSG msg;
    PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);

    // Then signal that thread is started
    CQueryThread* pThread = reinterpret_cast<CQueryThread*>(pVoid);
    if( !pThread ) return 0;

    ASSERT(pThread->m_hEvent != NULL);
    SetEvent(pThread->m_hEvent);

    HRESULT hr = CoInitialize(NULL);
    RETURN_ON_FAILURE(hr);    

    // Mesage loop
    while (TRUE)
    { 
        long lStat = GetMessage(&msg, NULL, 0, 0);
        
        // zero => WM_QUIT received, so exit thread function
        if (lStat == 0)
            break;

        if (lStat > 0)
        {
            // Only process thread message of the expected type
            if (msg.hwnd == NULL && msg.message == MSG_QUERY_START)
            {
                CQueryRequest* pQueryReq = reinterpret_cast<CQueryRequest*>(msg.wParam);
                if( !pQueryReq ) break;

                pQueryReq->Execute();
            }
            else
            {
                DispatchMessage(&msg);
            }
        }
    } // WHILE (TRUE)

    CoUninitialize();

    return 0;
}