/**********************************************************************/ /** Microsoft Windows/NT **/ /** Copyright(c) Microsoft Corporation, 1997 - 1999 **/ /**********************************************************************/ /* hArray.cpp Index manager for wins db FILE HISTORY: Oct 13 1997 EricDav Created */ #include "stdafx.h" #include "wins.h" #include "memmngr.h" #include "harray.h" #include "mbstring.h" #include "vrfysrv.h" // the lstrcmpA fucntion converts the dbcs string to Unicode using the ACP // and then does a string compare. So, we need to do the OEMCP conversion // and then call the string compare ourselves. int lstrcmpOEM( LPCSTR lpString1, LPCSTR lpString2 ) { CString str1, str2; MBCSToWide((LPSTR) lpString1, str1, WINS_NAME_CODE_PAGE); MBCSToWide((LPSTR) lpString2, str2, WINS_NAME_CODE_PAGE); return lstrcmp(str1, str2); } /*!-------------------------------------------------------------------------- Class CHRowIndex ---------------------------------------------------------------------------*/ CHRowIndex::CHRowIndex(INDEX_TYPE IndexType) : m_dbType(IndexType), m_bAscending(TRUE) { } CHRowIndex::~CHRowIndex() { } /*!-------------------------------------------------------------------------- CHRowIndex::GetType - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CHRowIndex::GetType(INDEX_TYPE * pIndexType) { if (pIndexType) *pIndexType = m_dbType; return hrOK; } /*!-------------------------------------------------------------------------- CHRowIndex::SetArray - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CHRowIndex::SetArray(HRowArray & hrowArray) { m_hrowArray.Copy(hrowArray); return hrOK; } /*!-------------------------------------------------------------------------- CHRowIndex::GetHRow - Author: EricDav ---------------------------------------------------------------------------*/ HROW CHRowIndex::GetHRow(int nIndex) { Assert(nIndex >= 0); Assert(nIndex <= m_hrowArray.GetSize()); if (nIndex < 0 || nIndex >= m_hrowArray.GetSize()) { return NULL; } return m_hrowArray.GetAt(nIndex); } /*!-------------------------------------------------------------------------- CHRowIndex::GetIndex - Author: EricDav ---------------------------------------------------------------------------*/ int CHRowIndex::GetIndex(HROW hrow) { Assert(hrow != 0); LPHROW phrow = (LPHROW) BSearch((const void *)&hrow, (const void *)m_hrowArray.GetData(), (size_t) m_hrowArray.GetSize(), (size_t) sizeof(HROW)); int nIndex = (int) (phrow - (LPHROW) m_hrowArray.GetData()); Assert(nIndex >= 0); Assert(nIndex <= m_hrowArray.GetSize()); int nComp, nIndexTemp; nComp = BCompare(&hrow, phrow); if (nComp == 0) { // found the right one, check the previous one to return the first // record in a list of duplicates nIndexTemp = nIndex; while (nIndexTemp && nComp == 0) { *phrow = (HROW) m_hrowArray.GetAt(--nIndexTemp); nComp = BCompare(&hrow, phrow); } if (nIndexTemp == nIndex) return nIndex; // nIndex should be zero here as well else if (nComp == 0) return nIndexTemp; // nIndexTemp should be 0 in this case else return nIndexTemp++; } return -1; } /*!-------------------------------------------------------------------------- CHRowIndex::Add - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CHRowIndex::Add(HROW hrow, BOOL bEnd) { // if we are loading the array then just stick this on the end if (bEnd) { m_hrowArray.Add(hrow); } else { if (m_hrowArray.GetSize() == 0) { m_hrowArray.Add(hrow); } else { LPHROW phrow = (LPHROW) BSearch((const void *)&hrow, (const void *)m_hrowArray.GetData(), (size_t) m_hrowArray.GetSize(), (size_t) sizeof(HROW)); int nIndex = (int) (phrow - (LPHROW) m_hrowArray.GetData()); Assert(nIndex >= 0); Assert(nIndex <= m_hrowArray.GetSize()); int nComp; if (m_bAscending) nComp = BCompare(&hrow, phrow); else nComp = BCompareD(&hrow, phrow); if (nComp < 0) { // Insert before phrow m_hrowArray.InsertAt(nIndex, hrow); } else { // insert after phrow m_hrowArray.InsertAt(nIndex + 1, hrow); } } } return hrOK; } /*!-------------------------------------------------------------------------- CHRowIndex::Remove - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CHRowIndex::Remove(HROW hrow) { // do a bsearch for the record and then remove LPHROW phrow = (LPHROW) BSearch((const void*)&hrow, (const void*)m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), (size_t)sizeof(HROW)); // make sure the record is in the database, may not be if we aren't // filtering if (phrow) { int nComp = BCompare(&hrow, phrow); Assert(nComp == 0); if (nComp != 0) return E_FAIL; // calculate the index int nIndex = (int) (phrow - (LPHROW) m_hrowArray.GetData()); Assert(nIndex >= 0); Assert(nIndex <= m_hrowArray.GetSize()); m_hrowArray.RemoveAt((int) nIndex); } return hrOK; } /*!-------------------------------------------------------------------------- CHRowIndex::BSearch Modified bsearch which returns the closest or equal element in an array Author: EricDav ---------------------------------------------------------------------------*/ void * CHRowIndex::BSearch (const void *key, const void *base, size_t num, size_t width) { char *lo = (char *)base; char *hi = (char *)base + (num - 1) * width; char *mid = NULL; unsigned int half = 0; int result = 0; while (lo <= hi) if (half = num / 2) { mid = lo + (num & 1 ? half : (half - 1)) * width; if (m_bAscending) { if (!(result = BCompare(key,mid))) return(mid); else if (result < 0) { hi = mid - width; num = num & 1 ? half : half-1; } else { lo = mid + width; num = half; } } else { if (!(result = BCompareD(key,mid))) return(mid); else if (result < 0) { hi = mid - width; num = num & 1 ? half : half-1; } else { lo = mid + width; num = half; } } } else if (num) return(lo); else break; return(mid); } /*!-------------------------------------------------------------------------- Class CIndexMgr ---------------------------------------------------------------------------*/ CIndexMgr::CIndexMgr() { m_posCurrentIndex = NULL; m_posFilteredIndex = NULL; m_posLastIndex = NULL; m_posUpdatedIndex = NULL; m_bFiltered = FALSE; } CIndexMgr::~CIndexMgr() { Reset(); } /*!-------------------------------------------------------------------------- CIndexMgr::Initialize - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexMgr::Initialize() { HRESULT hr = hrOK; CSingleLock cl(&m_cs); cl.Lock(); COM_PROTECT_TRY { // cleanup Reset(); // Create one index, the named index CIndexName * pName = new CIndexName(); m_posCurrentIndex = m_listIndicies.AddTail((CHRowIndex *) pName); m_posUpdatedIndex = m_posCurrentIndex; // this will be the current index, we need the Named Index also // for the total count CFilteredIndexName *pFilteredName = new CFilteredIndexName() ; m_posFilteredIndex = m_listFilteredIndices.AddTail((CHRowIndex *) pFilteredName); } COM_PROTECT_CATCH return hr; } /*!-------------------------------------------------------------------------- CIndexMgr::Reset - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexMgr::Reset() { CSingleLock cl(&m_cs); cl.Lock(); while (m_listIndicies.GetCount() > 0) { delete m_listIndicies.RemoveHead(); } while(m_listFilteredIndices.GetCount() > 0 ) { delete m_listFilteredIndices.RemoveHead(); } return hrOK; } /*!-------------------------------------------------------------------------- CIndexMgr::GetTotalCount The index sorted by name contains the total database and should always be available. Use this for the total count. Author: EricDav ---------------------------------------------------------------------------*/ UINT CIndexMgr::GetTotalCount() { CSingleLock cl(&m_cs); cl.Lock(); CHRowIndex * pIndex = GetNameIndex(); if (pIndex == NULL) return 0; return (UINT)pIndex->GetArray().GetSize(); } /*!-------------------------------------------------------------------------- CIndexMgr::GetCurrentCount The current count may differ depending upon if the current Index is a filtered index. Author: EricDav ---------------------------------------------------------------------------*/ UINT CIndexMgr::GetCurrentCount() { CSingleLock cl(&m_cs); cl.Lock(); CHRowIndex * pIndex ; if (!m_bFiltered) pIndex = m_listIndicies.GetAt(m_posUpdatedIndex); else pIndex = m_listFilteredIndices.GetAt(m_posUpdatedIndex); if (pIndex == NULL) return 0; return (UINT)pIndex->GetArray().GetSize(); } /*!-------------------------------------------------------------------------- CIndexMgr::AddHRow - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexMgr::AddHRow(HROW hrow, BOOL bEnd, BOOL bFilterChecked) { CSingleLock cl(&m_cs); cl.Lock(); INDEX_TYPE indexType; HRESULT hr = hrOK; POSITION pos = m_listIndicies.GetHeadPosition(); COM_PROTECT_TRY { while (pos) { CHRowIndex * pIndex = m_listIndicies.GetNext(pos); // check the INDEX type of the HRowIndex, // if filtered, need to add, depending on // whether the filter holds good pIndex->GetType(&indexType); if (indexType != INDEX_TYPE_FILTER) pIndex->Add(hrow, bEnd); } pos = m_listFilteredIndices.GetHeadPosition(); while(pos) { CHRowIndex * pIndex = m_listFilteredIndices.GetNext(pos); pIndex->GetType(&indexType); if (indexType != INDEX_TYPE_FILTER) break; BOOL bCheck = bFilterChecked ? TRUE : ((CFilteredIndexName*)pIndex)->CheckForFilter(&hrow); if (bCheck) pIndex->Add(hrow, bEnd); } } COM_PROTECT_CATCH return hr; } /*!-------------------------------------------------------------------------- CIndexMgr::AcceptHRow - Author: FlorinT ---------------------------------------------------------------------------*/ BOOL CIndexMgr::AcceptWinsRecord(WinsRecord *pWinsRecord) { CSingleLock cl(&m_cs); cl.Lock(); POSITION pos = m_listFilteredIndices.GetHeadPosition(); while(pos) { CHRowIndex *pIndex = m_listFilteredIndices.GetNext(pos); INDEX_TYPE indexType; pIndex->GetType(&indexType); if (indexType != INDEX_TYPE_FILTER) break; if (((CFilteredIndexName*)pIndex)->CheckWinsRecordForFilter(pWinsRecord)) return TRUE; } return FALSE; } /*!-------------------------------------------------------------------------- CIndexMgr::RemoveHRow - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexMgr::RemoveHRow(HROW hrow) { CSingleLock cl(&m_cs); cl.Lock(); HRESULT hr = hrOK; POSITION pos = m_listIndicies.GetHeadPosition(); COM_PROTECT_TRY { // remove from the normal list while (pos) { CHRowIndex * pIndex = m_listIndicies.GetNext(pos); pIndex->Remove(hrow); } // now remove from the filtered list pos = m_listFilteredIndices.GetHeadPosition(); while (pos) { CHRowIndex * pIndex = m_listFilteredIndices.GetNext(pos); pIndex->Remove(hrow); } } COM_PROTECT_CATCH return hr; } /*!-------------------------------------------------------------------------- CIndexMgr::Sort - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexMgr::Sort(WINSDB_SORT_TYPE SortType, DWORD dwSortOptions) { CSingleLock cl(&m_cs); cl.Lock(); HRESULT hr = hrOK; CHRowIndex * pNameIndex; CHRowIndex * pNewIndex; POSITION pos; INDEX_TYPE indexType; BOOL bAscending = (dwSortOptions & WINSDB_SORT_ASCENDING) ? TRUE : FALSE; if (!m_bFiltered) { // check to see if we have an index for this. pos = m_listIndicies.GetHeadPosition(); while (pos) { POSITION posTemp = pos; CHRowIndex * pIndex = m_listIndicies.GetNext(pos); pIndex->GetType(&indexType); if (indexType == SortType) { if (pIndex->IsAscending() != bAscending) { pIndex->SetAscending(bAscending); pIndex->Sort(); } m_posCurrentIndex = posTemp; m_posUpdatedIndex = m_posCurrentIndex; // m_posLastIndex = m_posCurrentIndex; return hrOK; } } } // to save memory, remove all old indicies, except the name index CleanupIndicies(); // if not, create one switch (SortType) { case INDEX_TYPE_NAME: pNewIndex = new CIndexName(); break; case INDEX_TYPE_IP: pNewIndex = new CIndexIpAddr(); break; case INDEX_TYPE_VERSION: pNewIndex = new CIndexVersion(); break; case INDEX_TYPE_TYPE: pNewIndex = new CIndexType(); break; case INDEX_TYPE_EXPIRATION: pNewIndex = new CIndexExpiration(); break; case INDEX_TYPE_STATE: pNewIndex = new CIndexState(); break; case INDEX_TYPE_STATIC: pNewIndex = new CIndexStatic(); break; case INDEX_TYPE_OWNER: pNewIndex = new CIndexOwner(); break; case INDEX_TYPE_FILTER: //pNewIndex = new CIndexFilter(); break; default: Panic1("Invalid sort type passed to IndexMgr::Sort %d\n", SortType); break; } Assert(pNewIndex); if (!m_bFiltered) pNameIndex = GetNameIndex(); else pNameIndex = GetFilteredNameIndex(); Assert(pNameIndex); // copy the array from the named index pNewIndex->SetArray(pNameIndex->GetArray()); pNewIndex->SetAscending(bAscending); pNewIndex->Sort(); if (!m_bFiltered) { m_posCurrentIndex = m_listIndicies.AddTail(pNewIndex); m_posUpdatedIndex = m_posCurrentIndex; } else { POSITION posTemp = m_posFilteredIndex = m_listFilteredIndices.AddTail(pNewIndex); m_posUpdatedIndex = posTemp;// m_posFilteredIndex; } Assert(m_posCurrentIndex); return hr; } /*!-------------------------------------------------------------------------- CIndexMgr::GetNameIndex - Author: EricDav ---------------------------------------------------------------------------*/ CHRowIndex * CIndexMgr::GetNameIndex() { CSingleLock cl(&m_cs); cl.Lock(); INDEX_TYPE indexType; POSITION pos = m_listIndicies.GetHeadPosition(); while (pos) { CHRowIndex * pIndex = m_listIndicies.GetNext(pos); pIndex->GetType(&indexType); if (indexType == INDEX_TYPE_NAME) return pIndex; } return NULL; } /*!-------------------------------------------------------------------------- CIndexMgr::GetFilteredNameIndex - Author: EricDav ---------------------------------------------------------------------------*/ CHRowIndex * CIndexMgr::GetFilteredNameIndex() { CSingleLock cl(&m_cs); cl.Lock(); INDEX_TYPE indexType; POSITION pos = m_listFilteredIndices.GetHeadPosition(); while (pos) { CHRowIndex * pIndex = m_listFilteredIndices.GetNext(pos); pIndex->GetType(&indexType); if (indexType == INDEX_TYPE_FILTER) return pIndex; } return NULL; } /*!-------------------------------------------------------------------------- CIndexMgr::CleanupIndicies Removes all indicies except the name index, and a filtered view Author: EricDav ---------------------------------------------------------------------------*/ void CIndexMgr::CleanupIndicies() { CSingleLock cl(&m_cs); cl.Lock(); INDEX_TYPE indexType; // clean up the non-filtered indicies POSITION pos = m_listIndicies.GetHeadPosition(); while (pos) { POSITION posLast = pos; CHRowIndex * pIndex = m_listIndicies.GetNext(pos); pIndex->GetType(&indexType); if (indexType == INDEX_TYPE_NAME || indexType == INDEX_TYPE_FILTER) continue; m_listIndicies.RemoveAt(posLast); delete pIndex; } // now clean up the filtered indicies pos = m_listFilteredIndices.GetHeadPosition(); // delete all except the first one which is the filetered // name index //CHRowIndex * pIndex = m_listFilteredIndices.GetNext(pos); while (pos) { POSITION posLast = pos; CHRowIndex * pIndex = m_listFilteredIndices.GetNext(pos); pIndex->GetType(&indexType); if (indexType == INDEX_TYPE_NAME || indexType == INDEX_TYPE_FILTER) continue; m_listFilteredIndices.RemoveAt(posLast); delete pIndex; } } /*!-------------------------------------------------------------------------- CIndexMgr::GetHRow Returns an hrow based on an index into the current sorted list Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexMgr::GetHRow(int nIndex, LPHROW phrow) { CSingleLock cl(&m_cs); cl.Lock(); Assert(m_posCurrentIndex != NULL); //CHRowIndex * pIndex = m_listIndicies.GetAt(m_posCurrentIndex); CHRowIndex * pIndex; if (!m_bFiltered) pIndex = m_listIndicies.GetAt(m_posUpdatedIndex); else pIndex = m_listFilteredIndices.GetAt(m_posFilteredIndex); Assert(pIndex); if (phrow) *phrow = pIndex->GetHRow(nIndex); return hrOK; } /*!-------------------------------------------------------------------------- CIndexMgr::GetIndex Returns the index of an hrow from the current sorted list Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexMgr::GetIndex(HROW hrow, int * pIndex) { CSingleLock cl(&m_cs); cl.Lock(); Assert(m_posCurrentIndex != NULL); //CHRowIndex * pCurrentIndex = m_listIndicies.GetAt(m_posCurrentIndex); CHRowIndex * pCurrentIndex; if (!m_bFiltered) pCurrentIndex = m_listIndicies.GetAt(m_posUpdatedIndex); else pCurrentIndex = m_listFilteredIndices.GetAt(m_posFilteredIndex); Assert(pCurrentIndex); if (pIndex) *pIndex = pCurrentIndex->GetIndex(hrow); return hrOK; } HRESULT CIndexMgr::Filter(WINSDB_FILTER_TYPE FilterType, DWORD dwParam1, DWORD dwParam2) { CSingleLock cl(&m_cs); cl.Lock(); HRESULT hr = hrOK; CHRowIndex* pNameIndex; CHRowIndex* pNewIndex; POSITION pos; INDEX_TYPE indexType; UINT uCount; UINT i; BOOL bCheck = FALSE; HROW hrow; HRowArray hrowArray; pNewIndex = GetFilteredNameIndex(); Assert(pNewIndex); // clear the filtered name index first. pNewIndex->SetArray(hrowArray); pNameIndex = GetNameIndex(); Assert(pNameIndex); // do the filtering here. uCount = GetTotalCount(); for(i = 0; i< uCount; i++) { hrow = pNameIndex->GetHRow(i); if (hrow) bCheck = ((CFilteredIndexName *)pNewIndex)->CheckForFilter(&hrow); if (bCheck) pNewIndex->Add(hrow, TRUE); } // check to see if the filtered view has been sorted on something else besides // the name. If so, switch back the index to the named index because // otherwise we will need to resort which can be time consuming... if (m_listFilteredIndices.GetAt(m_posFilteredIndex) != pNewIndex) { m_posFilteredIndex = m_listFilteredIndices.Find(pNewIndex); } // get the current position of the filtered index in the list of indices m_posUpdatedIndex = m_posFilteredIndex; Assert(m_posUpdatedIndex); m_bFiltered = TRUE; return hr; } HRESULT CIndexMgr::AddFilter(WINSDB_FILTER_TYPE FilterType, DWORD dwParam1, DWORD dwParam2, LPCOLESTR strParam3) { CSingleLock cl(&m_cs); cl.Lock(); HRESULT hr = hrOK; CFilteredIndexName *pFilterName = (CFilteredIndexName *)GetFilteredNameIndex(); pFilterName->AddFilter(FilterType, dwParam1, dwParam2, strParam3); m_bFiltered = TRUE; return hr; } HRESULT CIndexMgr::ClearFilter(WINSDB_FILTER_TYPE FilterType) { CSingleLock cl(&m_cs); cl.Lock(); HRESULT hr = hrOK; CFilteredIndexName *pFilterName = (CFilteredIndexName *)GetFilteredNameIndex(); pFilterName->ClearFilter(FilterType); m_bFiltered = FALSE; // m_posCurrentIndex = m_posLastIndex; return hr; } HRESULT CIndexMgr::SetActiveView(WINSDB_VIEW_TYPE ViewType) { CSingleLock cl(&m_cs); cl.Lock(); HRESULT hr = hrOK; switch(ViewType) { case WINSDB_VIEW_FILTERED_DATABASE: m_bFiltered = TRUE; //m_posCurrentIndex = m_posFilteredIndex; m_posUpdatedIndex = m_posFilteredIndex; break; case WINSDB_VIEW_ENTIRE_DATABASE: m_bFiltered = FALSE; //m_posCurrentIndex = m_posLastIndex; m_posUpdatedIndex = m_posCurrentIndex; break; default: break; } return hr; } /*!-------------------------------------------------------------------------- Class CIndexName ---------------------------------------------------------------------------*/ /*!-------------------------------------------------------------------------- CIndexName::BCompare - Author: EricDav ---------------------------------------------------------------------------*/ int CIndexName::BCompare(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; return lstrcmpOEM(puChar1, puChar2); } int CIndexName::BCompareD(const void *elem1, const void *elem2) { return -BCompare(elem1, elem2); } /*!-------------------------------------------------------------------------- CIndexName::Sort - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexName::Sort() { if (m_bAscending) qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareA); else qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareD); return hrOK; } /*!-------------------------------------------------------------------------- CIndexName::QCompare - Author: EricDav ---------------------------------------------------------------------------*/ int __cdecl CIndexName::QCompareA(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; return lstrcmpOEM(puChar1, puChar2); } int __cdecl CIndexName::QCompareD(const void * elem1, const void * elem2) { return -QCompareA(elem1, elem2); } /*!-------------------------------------------------------------------------- Class CIndexType ---------------------------------------------------------------------------*/ /*!-------------------------------------------------------------------------- CIndexType::BCompare - Author: EricDav ---------------------------------------------------------------------------*/ int CIndexType::BCompare(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; if ((unsigned char) puChar1[15] > (unsigned char) puChar2[15]) return 1; else if ((unsigned char) puChar1[15] < (unsigned char) puChar2[15]) return -1; else return lstrcmpOEM(puChar1, puChar2); } int CIndexType::BCompareD(const void *elem1, const void *elem2) { return -BCompare(elem1, elem2); } /*!-------------------------------------------------------------------------- CIndexType::Sort - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexType::Sort() { if (m_bAscending) qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareA); else qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareD); return hrOK; } /*!-------------------------------------------------------------------------- CIndexType::QCompare - Author: EricDav ---------------------------------------------------------------------------*/ int __cdecl CIndexType::QCompareA(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; DWORD dwAddr1, dwAddr2; if (pRec1->szRecordName[18] & WINSDB_REC_MULT_ADDRS) { // if this record has multiple addresses, we want the 2nd // address, because the 1st address is always the WINS server // first dword is the count. LPDWORD pdwIpAddrs = (LPDWORD) pRec1->dwIpAdd; dwAddr1 = pdwIpAddrs[2]; } else { dwAddr1 = (DWORD) pRec1->dwIpAdd; } if (pRec2->szRecordName[18] & WINSDB_REC_MULT_ADDRS) { // if this record has multiple addresses, we want the 2nd // address, because the 1st address is always the WINS server // first dword is the count. LPDWORD pdwIpAddrs = (LPDWORD) pRec2->dwIpAdd; dwAddr2 = pdwIpAddrs[2]; } else { dwAddr2 = (DWORD) pRec2->dwIpAdd; } // check the types first. If they are the same, sort by IP address. // if for some reason the IP addresses are the same then sort by name. if ((unsigned char) puChar1[15] > (unsigned char) puChar2[15]) return 1; else if ((unsigned char) puChar1[15] < (unsigned char) puChar2[15]) return -1; else if (dwAddr1 > dwAddr2) return 1; else if (dwAddr1 < dwAddr2) return -1; else return lstrcmpOEM(puChar1, puChar2); } int __cdecl CIndexType::QCompareD(const void * elem1, const void * elem2) { return -QCompareA(elem1, elem2); } /*!-------------------------------------------------------------------------- Class CIndexIpAddr ---------------------------------------------------------------------------*/ /*!-------------------------------------------------------------------------- CIndexIpAddr::BCompare - Author: EricDav ---------------------------------------------------------------------------*/ int CIndexIpAddr::BCompare(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; DWORD dwAddr1, dwAddr2; if (pRec1->szRecordName[18] & WINSDB_REC_MULT_ADDRS) { // if this record has multiple addresses, we want the 2nd // address, because the 1st address is always the WINS server // first dword is the count. LPDWORD pdwIpAddrs = (LPDWORD) pRec1->dwIpAdd; dwAddr1 = pdwIpAddrs[2]; } else { dwAddr1 = (DWORD) pRec1->dwIpAdd; } if (pRec2->szRecordName[18] & WINSDB_REC_MULT_ADDRS) { // if this record has multiple addresses, we want the 2nd // address, because the 1st address is always the WINS server // first dword is the count. LPDWORD pdwIpAddrs = (LPDWORD) pRec2->dwIpAdd; dwAddr2 = pdwIpAddrs[2]; } else { dwAddr2 = (DWORD) pRec2->dwIpAdd; } if (dwAddr1 > dwAddr2) return 1; else if (dwAddr1 < dwAddr2) return -1; else { // if the addresses are the same, compare types, then names LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; if ((unsigned char) puChar1[15] > (unsigned char) puChar2[15]) return 1; else if ((unsigned char) puChar1[15] < (unsigned char) puChar2[15]) return -1; else return lstrcmpOEM(puChar1, puChar2); } } int CIndexIpAddr::BCompareD(const void *elem1, const void *elem2) { return -BCompare(elem1, elem2); } /*!-------------------------------------------------------------------------- CIndexIpAddr::Sort - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexIpAddr::Sort() { if (m_bAscending) qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareA); else qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareD); return hrOK; } /*!-------------------------------------------------------------------------- CIndexIpAddr::QCompare - Author: EricDav ---------------------------------------------------------------------------*/ int __cdecl CIndexIpAddr::QCompareA(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; DWORD dwAddr1, dwAddr2; if (pRec1->szRecordName[18] & WINSDB_REC_MULT_ADDRS) { // if this record has multiple addresses, we want the 2nd // address, because the 1st address is always the WINS server // first dword is the count. LPDWORD pdwIpAddrs = (LPDWORD) pRec1->dwIpAdd; dwAddr1 = pdwIpAddrs[2]; } else { dwAddr1 = (DWORD) pRec1->dwIpAdd; } if (pRec2->szRecordName[18] & WINSDB_REC_MULT_ADDRS) { // if this record has multiple addresses, we want the 2nd // address, because the 1st address is always the WINS server // first dword is the count. LPDWORD pdwIpAddrs = (LPDWORD) pRec2->dwIpAdd; dwAddr2 = pdwIpAddrs[2]; } else { dwAddr2 = (DWORD) pRec2->dwIpAdd; } if (dwAddr1 > dwAddr2) return 1; else if (dwAddr1 < dwAddr2) return -1; else { // if the addresses are the same, compare types, then names LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; if ((unsigned char) puChar1[15] > (unsigned char) puChar2[15]) return 1; else if ((unsigned char) puChar1[15] < (unsigned char) puChar2[15]) return -1; else return lstrcmpOEM(puChar1, puChar2); } } int __cdecl CIndexIpAddr::QCompareD(const void * elem1, const void * elem2) { return -QCompareA(elem1, elem2); } /*!-------------------------------------------------------------------------- Class CIndexVersion ---------------------------------------------------------------------------*/ /*!-------------------------------------------------------------------------- CIndexVersion::BCompare - Author: EricDav ---------------------------------------------------------------------------*/ int CIndexVersion::BCompare(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; if (pRec1->liVersion.QuadPart > pRec2->liVersion.QuadPart) return 1; else if (pRec1->liVersion.QuadPart < pRec2->liVersion.QuadPart) return -1; else return 0; } int CIndexVersion::BCompareD(const void *elem1, const void *elem2) { return -BCompare(elem1, elem2); } /*!-------------------------------------------------------------------------- CIndexVersion::Sort - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexVersion::Sort() { if (m_bAscending) qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareA); else qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareD); return hrOK; } /*!-------------------------------------------------------------------------- CIndexVersion::QCompare - Author: EricDav ---------------------------------------------------------------------------*/ int __cdecl CIndexVersion::QCompareA(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; if (pRec1->liVersion.QuadPart > pRec2->liVersion.QuadPart) return 1; else if (pRec1->liVersion.QuadPart < pRec2->liVersion.QuadPart) return -1; else return 0; } int __cdecl CIndexVersion::QCompareD(const void * elem1, const void * elem2) { return -QCompareA(elem1, elem2); } /*!-------------------------------------------------------------------------- Class CIndexExpiration ---------------------------------------------------------------------------*/ /*!-------------------------------------------------------------------------- CIndexExpiration::BCompare - Author: EricDav ---------------------------------------------------------------------------*/ int CIndexExpiration::BCompare(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; if (pRec1->dwExpiration > pRec2->dwExpiration) return 1; else if (pRec1->dwExpiration < pRec2->dwExpiration) return -1; else return 0; } int CIndexExpiration::BCompareD(const void *elem1, const void *elem2) { return -BCompare(elem1, elem2); } /*!-------------------------------------------------------------------------- CIndexExpiration::Sort - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexExpiration::Sort() { if (m_bAscending) qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareA); else qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareD); return hrOK; } /*!-------------------------------------------------------------------------- CIndexExpiration::QCompare - Author: EricDav ---------------------------------------------------------------------------*/ int __cdecl CIndexExpiration::QCompareA(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; if (pRec1->dwExpiration > pRec2->dwExpiration) return 1; else if (pRec1->dwExpiration < pRec2->dwExpiration) return -1; else return 0; } int __cdecl CIndexExpiration::QCompareD(const void * elem1, const void * elem2) { return -QCompareA(elem1, elem2); } /*!-------------------------------------------------------------------------- Class CIndexState ---------------------------------------------------------------------------*/ /*!-------------------------------------------------------------------------- CIndexState::BCompare - Author: EricDav ---------------------------------------------------------------------------*/ int CIndexState::BCompare(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; int nPri1 = 0, nPri2 = 0; // calculate relative priorities if (pRec1->szRecordName[18] & WINSDB_REC_ACTIVE) nPri1 = 0; else if (pRec1->szRecordName[18] & WINSDB_REC_RELEASED) nPri1 = 1; else if (pRec1->szRecordName[18] & WINSDB_REC_TOMBSTONE) nPri1 = 2; else if (pRec1->szRecordName[18] & WINSDB_REC_DELETED) nPri1 = 3; // now for record 2 if (pRec2->szRecordName[18] & WINSDB_REC_ACTIVE) nPri2 = 0; else if (pRec2->szRecordName[18] & WINSDB_REC_RELEASED) nPri2 = 1; else if (pRec2->szRecordName[18] & WINSDB_REC_TOMBSTONE) nPri2 = 2; else if (pRec2->szRecordName[18] & WINSDB_REC_DELETED) nPri2 = 3; if (nPri1 > nPri2) return 1; else if (nPri1 < nPri2) return -1; else { LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; return lstrcmpOEM(puChar1, puChar2); } } int CIndexState::BCompareD(const void *elem1, const void *elem2) { return -BCompare(elem1, elem2); } /*!-------------------------------------------------------------------------- CIndexState::Sort - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexState::Sort() { if (m_bAscending) qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareA); else qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareD); return hrOK; } /*!-------------------------------------------------------------------------- CIndexState::QCompare - Author: EricDav ---------------------------------------------------------------------------*/ int __cdecl CIndexState::QCompareA(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; int nPri1 = 0, nPri2 = 0; // calculate relative priorities if (pRec1->szRecordName[18] & WINSDB_REC_ACTIVE) nPri1 = 0; else if (pRec1->szRecordName[18] & WINSDB_REC_RELEASED) nPri1 = 1; else if (pRec1->szRecordName[18] & WINSDB_REC_TOMBSTONE) nPri1 = 2; else if (pRec1->szRecordName[18] & WINSDB_REC_DELETED) nPri1 = 3; // now for record 2 if (pRec2->szRecordName[18] & WINSDB_REC_ACTIVE) nPri2 = 0; else if (pRec2->szRecordName[18] & WINSDB_REC_RELEASED) nPri2 = 1; else if (pRec2->szRecordName[18] & WINSDB_REC_TOMBSTONE) nPri2 = 2; else if (pRec2->szRecordName[18] & WINSDB_REC_DELETED) nPri2 = 3; if (nPri1 > nPri2) return 1; else if (nPri1 < nPri2) return -1; else { LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; return lstrcmpOEM(puChar1, puChar2); } } int __cdecl CIndexState::QCompareD(const void * elem1, const void * elem2) { return -QCompareA(elem1, elem2); } /*!-------------------------------------------------------------------------- Class CIndexStatic ---------------------------------------------------------------------------*/ /*!-------------------------------------------------------------------------- CIndexStatic::BCompare - Author: EricDav ---------------------------------------------------------------------------*/ int CIndexStatic::BCompare(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; BOOL bStatic1 = pRec1->szRecordName[18] & LOBYTE(LOWORD(WINSDB_REC_STATIC)); BOOL bStatic2 = pRec2->szRecordName[18] & LOBYTE(LOWORD(WINSDB_REC_STATIC)); if (bStatic1 && !bStatic2) return 1; else if (!bStatic1 && bStatic2) return -1; else { LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; return lstrcmpOEM(puChar1, puChar2); } } int CIndexStatic::BCompareD(const void *elem1, const void *elem2) { return -BCompare(elem1, elem2); } /*!-------------------------------------------------------------------------- CIndexStatic::Sort - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexStatic::Sort() { if (m_bAscending) qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareA); else qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareD); return hrOK; } /*!-------------------------------------------------------------------------- CIndexStatic::QCompare - Author: EricDav ---------------------------------------------------------------------------*/ int __cdecl CIndexStatic::QCompareA(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; BOOL bStatic1 = pRec1->szRecordName[18] & LOBYTE(LOWORD(WINSDB_REC_STATIC)); BOOL bStatic2 = pRec2->szRecordName[18] & LOBYTE(LOWORD(WINSDB_REC_STATIC)); if (bStatic1 && !bStatic2) return 1; else if (!bStatic1 && bStatic2) return -1; else { LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; return lstrcmpOEM(puChar1, puChar2); } } int __cdecl CIndexStatic::QCompareD(const void * elem1, const void * elem2) { return -QCompareA(elem1, elem2); } /*!-------------------------------------------------------------------------- Class CIndexOwner ---------------------------------------------------------------------------*/ /*!-------------------------------------------------------------------------- CIndexOwner::BCompare - Author: EricDav ---------------------------------------------------------------------------*/ int CIndexOwner::BCompare(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; if (pRec1->dwOwner > pRec2->dwOwner) { return 1; } else if (pRec1->dwOwner < pRec2->dwOwner) { return -1; } else { // if the addresses are the same, compare names LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; return lstrcmpOEM(puChar1, puChar2); } } int CIndexOwner::BCompareD(const void *elem1, const void *elem2) { return -BCompare(elem1, elem2); } /*!-------------------------------------------------------------------------- CIndexStatic::Sort - Author: EricDav ---------------------------------------------------------------------------*/ HRESULT CIndexOwner::Sort() { if (m_bAscending) qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareA); else qsort(m_hrowArray.GetData(), (size_t)m_hrowArray.GetSize(), sizeof(HROW), QCompareD); return hrOK; } /*!-------------------------------------------------------------------------- CIndexStatic::QCompare - Author: EricDav ---------------------------------------------------------------------------*/ int __cdecl CIndexOwner::QCompareA(const void * elem1, const void * elem2) { LPHROW phrow1 = (LPHROW) elem1; LPHROW phrow2 = (LPHROW) elem2; LPWINSDBRECORD pRec1 = (LPWINSDBRECORD) *phrow1; LPWINSDBRECORD pRec2 = (LPWINSDBRECORD) *phrow2; if (pRec1->dwOwner > pRec2->dwOwner) { return 1; } else if (pRec1->dwOwner < pRec2->dwOwner) { return -1; } else { // if the addresses are the same, compare names LPCSTR puChar1 = (IS_DBREC_LONGNAME(pRec1)) ? (LPCSTR) *((char **) pRec1->szRecordName) : (LPCSTR) &pRec1->szRecordName[0]; LPCSTR puChar2 = (IS_DBREC_LONGNAME(pRec2)) ? (LPCSTR) *((char **) pRec2->szRecordName) : (LPCSTR) &pRec2->szRecordName[0]; return lstrcmpOEM(puChar1, puChar2); } } int __cdecl CIndexOwner::QCompareD(const void * elem1, const void * elem2) { return -QCompareA(elem1, elem2); } HRESULT CFilteredIndexName::AddFilter(WINSDB_FILTER_TYPE FilterType, DWORD dwData1, DWORD dwData2, LPCOLESTR strData3) { HRESULT hr = hrOK; tIpReference ipRef; switch (FilterType) { case WINSDB_FILTER_BY_TYPE: m_mapFilterTypes.SetAt(dwData1, (BOOL&) dwData2); break; case WINSDB_FILTER_BY_OWNER: m_dwaFilteredOwners.Add(dwData1); break; case WINSDB_FILTER_BY_IPADDR: ipRef.Address = dwData1; ipRef.Mask = dwData2; m_taFilteredIp.Add(ipRef); break; case WINSDB_FILTER_BY_NAME: UINT nData3Len; nData3Len = (_tcslen(strData3)+1)*sizeof(TCHAR); m_pchFilteredName = new char[nData3Len]; if (m_pchFilteredName != NULL) { #ifdef _UNICODE if (WideCharToMultiByte(CP_OEMCP, 0, strData3, -1, m_pchFilteredName, nData3Len, NULL, NULL) == 0) { delete m_pchFilteredName; m_pchFilteredName = NULL; } #else CharToOem(strData3, m_pchFilteredName); #endif //m_pchFilteredName = _strupr(m_pchFilteredName); m_bMatchCase = dwData1; } break; default: Panic0("Invalid filter type passed to CFilteredIndexName::AddFilter"); break; } return hr; } BOOL CFilteredIndexName::CheckForFilter(LPHROW hrowCheck) { UINT nCountOwner = (UINT)m_dwaFilteredOwners.GetSize(); UINT nCountType = m_mapFilterTypes.GetHashTableSize(); UINT nCountIPAddrs = (UINT)m_taFilteredIp.GetSize(); BOOL bOwnerFilter = (nCountOwner == 0); BOOL bTypeFilter = (nCountType == 0); BOOL bIPAddrsFilter = (nCountIPAddrs == 0); BOOL bNameFilter = (m_pchFilteredName == NULL); LPWINSDBRECORD pRec = (LPWINSDBRECORD) *hrowCheck; UINT i, j; LPCSTR puChar; for (i = 0; !bOwnerFilter && i < nCountOwner; i++) { if (pRec->dwOwner == m_dwaFilteredOwners.GetAt(i)) bOwnerFilter = TRUE; } if (!bOwnerFilter) return FALSE; puChar = (IS_DBREC_LONGNAME(pRec)) ? (LPCSTR) *((char **) pRec->szRecordName) : (LPCSTR) &pRec->szRecordName[0]; if (!bTypeFilter) { DWORD dwType = puChar[0xF]; if (!m_mapFilterTypes.Lookup(dwType, bTypeFilter)) { // no entry for this name type. Check the FFFF name type (other) to see if we should // show it. dwType = 0xFFFF; m_mapFilterTypes.Lookup(dwType, bTypeFilter); } } if (!bTypeFilter) return FALSE; for (i = 0; !bIPAddrsFilter && i < nCountIPAddrs; i++) { if (pRec->szRecordName[18] & WINSDB_REC_MULT_ADDRS) { LPDWORD pdwIpAddrs = (LPDWORD) pRec->dwIpAdd; for (j=0; !bIPAddrsFilter && j < pdwIpAddrs[0]; j+=2) { bIPAddrsFilter = SubnetMatching(m_taFilteredIp[i], pdwIpAddrs[j+2]); } } else { bIPAddrsFilter = SubnetMatching(m_taFilteredIp[i], (DWORD)pRec->dwIpAdd); } } if(!bIPAddrsFilter) return FALSE; if (!bNameFilter) { bNameFilter = (PatternMatching(puChar, m_pchFilteredName, 16) == NULL); } return bNameFilter; } BOOL CFilteredIndexName::CheckWinsRecordForFilter(WinsRecord *pWinsRecord) { UINT nCountOwner = (UINT)m_dwaFilteredOwners.GetSize(); UINT nCountType = m_mapFilterTypes.GetHashTableSize(); UINT nCountIPAddrs = (UINT)m_taFilteredIp.GetSize(); BOOL bOwnerFilter = (nCountOwner == 0); BOOL bTypeFilter = (nCountType == 0); BOOL bIPAddrsFilter = (nCountIPAddrs == 0); BOOL bNameFilter = (m_pchFilteredName == NULL); UINT i, j; //------------------------------------- // check the owner filter first, if any for (i = 0; !bOwnerFilter && i < nCountOwner; i++) { if (pWinsRecord->dwOwner == m_dwaFilteredOwners.GetAt(i)) bOwnerFilter = TRUE; } if (!bOwnerFilter) return FALSE; //------------------------------------- // check the type filter if any if (!bTypeFilter) { if (!m_mapFilterTypes.Lookup(pWinsRecord->dwType, bTypeFilter)) { // no entry for this name type. Check the FFFF name type (other) to see if we should // show it. DWORD dwType = 0xFFFF; m_mapFilterTypes.Lookup(dwType, bTypeFilter); } } if (!bTypeFilter) return FALSE; //------------------------------------- // check the IP address filter if any for (i = 0; !bIPAddrsFilter && i < nCountIPAddrs; i++) { if (pWinsRecord->dwState & WINSDB_REC_MULT_ADDRS) { for (j=0; !bIPAddrsFilter && j < pWinsRecord->dwNoOfAddrs; j++) { bIPAddrsFilter = SubnetMatching(m_taFilteredIp[i], pWinsRecord->dwIpAdd[j]); } } else { bIPAddrsFilter = SubnetMatching(m_taFilteredIp[i], pWinsRecord->dwIpAdd[0]); } } if(!bIPAddrsFilter) return FALSE; //------------------------------------- // check the name filter if any if (!bNameFilter) { bNameFilter = (PatternMatching(pWinsRecord->szRecordName, m_pchFilteredName, 16) == NULL); } return bNameFilter; } LPCSTR CFilteredIndexName::PatternMatching(LPCSTR pName, LPCSTR pPattern, INT nNameLen) { LPCSTR pNameBak = pName; // it is guaranteed here we have a valid (not NULL) pattern while (*pPattern != '\0' && pName-pNameBak < nNameLen) { BOOL bChMatch = (*pPattern == *pName); if (!m_bMatchCase && !bChMatch) { bChMatch = (islower(*pPattern) && _toupper(*pPattern) == *pName) || (islower(*pName) && *pPattern == _toupper(*pName)); } if (*pPattern == '?' || bChMatch) { pPattern++; } else if (*pPattern == '*') { LPCSTR pTrail = pName; INT nTrailLen = nNameLen-(UINT)(pTrail-pNameBak); pPattern++; while ((pName = PatternMatching(pTrail, pPattern, nTrailLen)) != NULL) { pTrail++; nTrailLen--; if (*pTrail == '\0' || nTrailLen <= 0) break; } return pName; } else if (!bChMatch) { // in the test above, note that even in the unikely case *pName == '\0' // *pName will not match *pPattern so the loop is still broken - which is // the desired behavior. In this case the pattern was not consummed // and the name was, so the return will indicate the matching failed break; } pName++; } return *pPattern == '\0' ? NULL : pName; } BOOL CFilteredIndexName::SubnetMatching(tIpReference &IpRefPattern, DWORD dwIPAddress) { DWORD dwMask; return (IpRefPattern.Address & IpRefPattern.Mask) == (dwIPAddress & IpRefPattern.Mask); } HRESULT CFilteredIndexName::ClearFilter(WINSDB_FILTER_TYPE FilterType) { HRESULT hr = hrOK; switch(FilterType) { case WINSDB_FILTER_BY_TYPE: m_mapFilterTypes.RemoveAll(); break; case WINSDB_FILTER_BY_OWNER: m_dwaFilteredOwners.RemoveAll(); break; case WINSDB_FILTER_BY_IPADDR: m_taFilteredIp.RemoveAll(); break; case WINSDB_FILTER_BY_NAME: if (m_pchFilteredName != NULL) { delete m_pchFilteredName; m_pchFilteredName = NULL; } break; default: Panic0("Invalid filter type passed to CFilteredIndexName::ClearFilter"); break; } return hr; }