|
|
/**********************************************************************//** Microsoft Windows/NT **//** Copyright(c) Microsoft Corporation, 1997 - 1999 **//**********************************************************************/
/*
winsdb.cpp Wins database enumerator
FILE HISTORY: Oct 13 1997 EricDav Modified
*/
#include "stdafx.h"
#include "wins.h"
#include "search.h"
#include "winsdb.h"
#include "tfschar.h"
IMPLEMENT_ADDREF_RELEASE(CWinsDatabase);
IMPLEMENT_SIMPLE_QUERYINTERFACE(CWinsDatabase, IWinsDatabase)
DEBUG_DECLARE_INSTANCE_COUNTER(CWinsDatabase)
CWinsDatabase::CWinsDatabase() : m_cRef(1), m_fFiltered(FALSE), m_fInitialized(FALSE), m_bShutdown(FALSE), m_hrLastError(hrOK){ DEBUG_INCREMENT_INSTANCE_COUNTER(CWinsDatabase);
SetCurrentState(WINSDB_NORMAL);
m_hBinding = NULL; m_hThread = NULL; m_hStart = NULL; m_hAbort = NULL; m_dwOwner = (DWORD)-1; m_strPrefix = NULL; m_dwRecsCount = 0; m_bEnableCache = FALSE;}
CWinsDatabase::~CWinsDatabase(){ DEBUG_DECREMENT_INSTANCE_COUNTER(CWinsDatabase); m_bShutdown = TRUE;
if (m_strPrefix != NULL) delete m_strPrefix; SetEvent(m_hAbort); SetEvent(m_hStart); if (WaitForSingleObject(m_hThread, 30000) != WAIT_OBJECT_0) { Trace0("WinsDatabase destructor thread never died!\n");
// TerminateThread
}
CloseHandle(m_hAbort); CloseHandle(m_hStart); CloseHandle(m_hThread);}
/*!--------------------------------------------------------------------------
CWinsDatabase::Init Implementation of IWinsDatabase::Init Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::Init(){ HRESULT hr = hrOK; WINSDB_STATE uCurrentState;
m_dwRecsCount = 0;
COM_PROTECT_TRY { CORg (GetCurrentState(&uCurrentState)); if (uCurrentState != WINSDB_NORMAL) { Trace1("WinsDatabase::Init - called when database busy - state %d\n", uCurrentState); return E_FAIL; }
CORg (m_cMemMan.Initialize()); CORg (m_IndexMgr.Initialize());
m_hrLastError = hrOK;
CORg (SetCurrentState(WINSDB_LOADING));
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::Start Implementation of IWinsDatabase::Start Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::Start(){ // signal the thread to start loading
SetEvent(m_hStart);
return hrOK;}
/*!--------------------------------------------------------------------------
CWinsDatabase::Initialize Implementation of IWinsDatabase::Initialize Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::Initialize(LPCOLESTR pszName, LPCOLESTR pszIP){ HRESULT hr = hrOK; DWORD dwError; DWORD dwThreadId;
COM_PROTECT_TRY { m_strName = pszName; m_strIp = pszIP;
CORg (m_cMemMan.Initialize()); CORg (m_IndexMgr.Initialize());
m_hStart = ::CreateEvent(NULL, FALSE, FALSE, NULL); if (m_hStart == NULL) { dwError = ::GetLastError(); Trace1("WinsDatabase::Initialize - CreateEvent Failed m_hStart %d\n", dwError); return HRESULT_FROM_WIN32(dwError); }
m_hAbort = ::CreateEvent(NULL, FALSE, FALSE, NULL); if (m_hAbort == NULL) { dwError = ::GetLastError(); Trace1("WinsDatabase::Initialize - CreateEvent Failed m_hAbort %d\n", dwError); return HRESULT_FROM_WIN32(dwError); }
m_hThread = ::CreateThread(NULL, 0, ThreadProc, this, 0, &dwThreadId); if (m_hThread == NULL) { dwError = ::GetLastError(); Trace1("WinsDatabase::Init - CreateThread Failed %d\n", dwError); return HRESULT_FROM_WIN32(dwError); }
m_fInitialized = TRUE; COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH return hr;} /*!--------------------------------------------------------------------------
CWinsDatabase::GetName Implementation of IWinsDatabase::GetName Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::GetName(LPOLESTR pszName, UINT cchMax){ HRESULT hr = hrOK; LPCTSTR pBuf;
COM_PROTECT_TRY { if (cchMax < (UINT) (m_strName.GetLength() / sizeof(TCHAR))) return E_FAIL;
StrnCpy(pszName, (LPCTSTR) m_strName, cchMax); } COM_PROTECT_CATCH
return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::GetIP Implementation of IWinsDatabase::GetIP Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::GetIP(LPOLESTR pszIP, UINT cchMax){ HRESULT hr = hrOK; LPCTSTR pBuf;
COM_PROTECT_TRY { if (cchMax < (UINT) (m_strIp.GetLength() / sizeof(TCHAR))) return E_FAIL;
StrnCpy(pszIP, (LPCTSTR) m_strIp, cchMax);
} COM_PROTECT_CATCH
return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::Stop Implementation of IWinsDatabase::Stop Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::Stop(){ HRESULT hr = hrOK; WINSDB_STATE uState;
COM_PROTECT_TRY { CORg (GetCurrentState(&uState));
if (uState != WINSDB_LOADING) return hr;
SetEvent(m_hAbort);
CORg (SetCurrentState(WINSDB_NORMAL));
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH
return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::Clear Clears the wins DB of all records Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::Clear(){ HRESULT hr = hrOK; WINSDB_STATE uState;
COM_PROTECT_TRY { CORg (GetCurrentState(&uState));
if (uState == WINSDB_SORTING || uState == WINSDB_FILTERING) return E_FAIL;
if (uState == WINSDB_LOADING) { SetEvent(m_hAbort); CORg (SetCurrentState(WINSDB_NORMAL)); }
CORg (m_cMemMan.Initialize()); CORg (m_IndexMgr.Initialize()); m_dwOwner = (DWORD)-1; if (m_strPrefix != NULL) delete m_strPrefix; m_strPrefix = NULL;
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH
return hr;} /*!--------------------------------------------------------------------------
CWinsDatabase::GetLastError Returns the last error for async calls Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::GetLastError(HRESULT * pLastError){ HRESULT hr = hrOK; WINSDB_STATE uState;
COM_PROTECT_TRY { if (pLastError) *pLastError = m_hrLastError;
} COM_PROTECT_CATCH
return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::Sort Implementation of IWinsDatabase::Sort Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::Sort(WINSDB_SORT_TYPE SortType, DWORD dwSortOptions){ HRESULT hr = hrOK; WINSDB_STATE uState;
COM_PROTECT_TRY { CORg (GetCurrentState(&uState));
if (uState != WINSDB_NORMAL) return E_FAIL;
CORg (SetCurrentState(WINSDB_SORTING));
m_IndexMgr.Sort(SortType, dwSortOptions);
CORg (SetCurrentState(WINSDB_NORMAL));
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::GetHRow Implementation of IWinsDatabase::GetHRow returns the HRow in the current sorted index Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::GetHRow(UINT uIndex, LPHROW hRow){ Assert(uIndex >= 0);
HRESULT hr = hrOK; WINSDB_STATE uState; int nCurrentCount;
COM_PROTECT_TRY { CORg (GetCurrentCount(&nCurrentCount));
if (uIndex > (UINT) nCurrentCount) return E_FAIL;
CORg (GetCurrentState(&uState)); if (uState == WINSDB_SORTING || uState == WINSDB_FILTERING) return E_FAIL;
m_IndexMgr.GetHRow(uIndex, hRow);
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH
return hr;} /*!--------------------------------------------------------------------------
CWinsDatabase::GetRows Implementation of IWinsDatabase::GetRows Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::GetRows( ULONG uNumberOfRows, ULONG uStartPos, HROW* pHRow, int* nNumberOfRowsReturned){ int nCurrentCount; WINSDB_STATE uState; HRESULT hr = hrOK; int nReturnedRows = 0; int i; HROW hrowCur;
Assert (uStartPos >= 0);
COM_PROTECT_TRY { CORg (GetCurrentState(&uState)); if (uState == WINSDB_SORTING || uState == WINSDB_FILTERING) return E_FAIL;
CORg (GetCurrentCount(&nCurrentCount)); Assert ((int) uStartPos <= nCurrentCount); if (uStartPos > (UINT) nCurrentCount) return E_FAIL;
for (i = (int) uStartPos; i < (int) (uStartPos + uNumberOfRows); i++) { if( i > nCurrentCount ) { break; }
CORg (m_IndexMgr.GetHRow(i, &hrowCur));
// if the row is marked deleted, don't add it to the array
// REVIEW: directly accessing memory here.. we may want to change this
// to go through the memory manager
if ( ((LPWINSDBRECORD) hrowCur)->szRecordName[17] & WINSDB_INTERNAL_DELETED ) { continue; }
// fill in the data
pHRow[i-uStartPos] = hrowCur; nReturnedRows++; }
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH
if (nNumberOfRowsReturned) *nNumberOfRowsReturned = nReturnedRows;
return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::GetData Implementation of IWinsDatabase::GetData returns the HRow in the current sorted index Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::GetData(HROW hRow, LPWINSRECORD pRecordData){ HRESULT hr = E_FAIL;
COM_PROTECT_TRY { CORg (m_cMemMan.GetData(hRow, pRecordData));
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH
return hr;} /*!--------------------------------------------------------------------------
CWinsDatabase::FindRow Implementation of IWinsDatabase::FindRow Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::FindRow(LPCOLESTR pszName, HROW hrowStart, HROW * phRow) { HRESULT hr = E_FAIL; WinsRecord ws; int nIndex, nPos, nCurrentCount; HROW hrowCur; HROW hrowFound = NULL; char szName[MAX_PATH];
CString strTemp(pszName);
// this should be OEM
WideToMBCS(strTemp, szName, WINS_NAME_CODE_PAGE);
COM_PROTECT_TRY { CORg (m_IndexMgr.GetIndex(hrowStart, &nIndex)); /////
CORg(GetHRow(nIndex, &hrowCur)); CORg (m_IndexMgr.GetIndex(hrowCur, &nIndex));
CORg (GetCurrentCount(&nCurrentCount));
if(nIndex != -1) {
CORg(GetHRow(nIndex, &hrowCur));
for (nPos = nIndex + 1; nPos < nCurrentCount; nPos++) { CORg(GetHRow(nPos, &hrowCur)); CORg(GetData(hrowCur, &ws)); if(!_strnicmp(ws.szRecordName, szName, strlen(szName) )) { hrowFound = hrowCur; hr = hrOK; break; } } }
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH
if (phRow) *phRow = hrowFound;
return hr;} /*!--------------------------------------------------------------------------
CWinsDatabase::GetTotalCount Implementation of IWinsDatabase::GetTotalCount Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::GetTotalCount(int * nTotalCount){ HRESULT hr = hrOK; COM_PROTECT_TRY { *nTotalCount = m_IndexMgr.GetTotalCount(); } COM_PROTECT_CATCH return hr;} /*!--------------------------------------------------------------------------
CWinsDatabase::GetCurrentCount Implementation of IWinsDatabase::GetCurrentCount returns the HRow in the current sorted index Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::GetCurrentCount(int * nCurrentCount){ HRESULT hr = hrOK;
COM_PROTECT_TRY { if (m_DBState == WINSDB_SORTING) *nCurrentCount = 0; else *nCurrentCount = m_IndexMgr.GetCurrentCount(); } COM_PROTECT_CATCH
return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::GetCurrentScanned(int * nCurrentScanned) Implementation of IWinsDatabase::GetCurrentScanned returns the total number of records that were read from the server Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::GetCurrentScanned(int * nCurrentCount){ HRESULT hr = hrOK;
COM_PROTECT_TRY { *nCurrentCount = m_dwRecsCount; } COM_PROTECT_CATCH
return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::AddRecord Implementation of IWinsDatabase::AddRecord Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULTCWinsDatabase::AddRecord(const LPWINSRECORD pRecordData){ HRESULT hr = hrOK;
COM_PROTECT_TRY { // critical sections taken care by the memory manager
HROW hrow = NULL; CORg (m_cMemMan.AddData(*pRecordData, &hrow)); CORg (m_IndexMgr.AddHRow(hrow));
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH
return hrOK;} /*!--------------------------------------------------------------------------
CWinsDatabase::DeleteRecord Implementation of IWinsDatabase::DeleteRecord Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::DeleteRecord(HROW hrowRecord){ HRESULT hr = hrOK; WINSDB_STATE uState; COM_PROTECT_TRY { CORg (GetCurrentState(&uState));
if (uState != WINSDB_NORMAL) return E_FAIL;
// make sure the hrow is a valid one
if (!m_cMemMan.IsValidHRow(hrowRecord)) return E_FAIL;
// Tell the memmgr to delete this record
CORg (m_cMemMan.Delete(hrowRecord));
// now tell the index manager to remove this hrow
CORg (m_IndexMgr.RemoveHRow(hrowRecord));
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH
return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::GetCurrentState Implementation of IWinsDatabase::GetCurrentState Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::GetCurrentState(WINSDB_STATE * pState){ CSingleLock cl(&m_csState); cl.Lock();
*pState = m_DBState; return hrOK;}
/*!--------------------------------------------------------------------------
CWinsDatabase::SetCurrentState Helper function to set the current state, protected Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::SetCurrentState(WINSDB_STATE winsdbState){ CSingleLock cl(&m_csState); cl.Lock();
m_DBState = winsdbState; return hrOK;}
/*!--------------------------------------------------------------------------
CWinsDatabase::FilterRecords Implementation of IWinsDatabase::FilterRecords Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::FilterRecords( WINSDB_FILTER_TYPE FilterType, DWORD dwParam1, DWORD dwParam2){ HRESULT hr = E_NOTIMPL; WINSDB_STATE uState ;
COM_PROTECT_TRY { // fail if the state is other then WINSDB_NORMAL
CORg (GetCurrentState(&uState));
if (uState == WINSDB_SORTING || uState == WINSDB_FILTERING) return E_FAIL;
// if in the loading state the readrecords function takes care
if(uState != WINSDB_LOADING) CORg (SetCurrentState(WINSDB_FILTERING));
// do the filtering here, rebuild the filtered name Index
m_IndexMgr.Filter(FilterType, dwParam1, dwParam2);
if(uState != WINSDB_LOADING) CORg (SetCurrentState(WINSDB_NORMAL));
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::AddFilter Adds the filters specified to the list Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::AddFilter(WINSDB_FILTER_TYPE FilterType, DWORD dwParam1, DWORD dwParam2, LPCOLESTR strParam3){ HRESULT hr = hrOK; COM_PROTECT_TRY { // for filter by type, dwParam1 is the type, dwParam2 is show/not show
m_IndexMgr.AddFilter(FilterType, dwParam1, dwParam2, strParam3); } COM_PROTECT_CATCH
return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::ClearFilter CLears all the filters Author: EricDav, v-shubk ---------------------------------------------------------------------------*/
HRESULT CWinsDatabase::ClearFilter(WINSDB_FILTER_TYPE FilterType){ HRESULT hr = hrOK;
COM_PROTECT_TRY { //CFilteredIndexName *pFilterName = (CFilteredIndexName *)m_IndexMgr.GetFilteredNameIndex();
//pFilterName->ClearFilter();
m_IndexMgr.ClearFilter(FilterType); } COM_PROTECT_CATCH
return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::SetActiveView Implementation of IWinsDatabase::SetActiveView Author: EricDav, v-shubk ---------------------------------------------------------------------------*/
HRESULT CWinsDatabase::SetActiveView(WINSDB_VIEW_TYPE ViewType){ HRESULT hr = hrOK;
COM_PROTECT_TRY { m_IndexMgr.SetActiveView(ViewType); } COM_PROTECT_CATCH
return hr;
}
/*!--------------------------------------------------------------------------
CWinsDatabase::Execute() The background thread calls into this to execute Author: EricDav, v-shubk ---------------------------------------------------------------------------*/DWORDCWinsDatabase::Execute(){ DWORD dwStatus = 0;
// wait for the other thread to signal us to start doing something
while (::WaitForSingleObject(m_hStart, INFINITE) == WAIT_OBJECT_0) { if (m_bShutdown) break;
Trace0("WinsDatabase::Execute - start event signaled\n");
WINSINTF_BIND_DATA_T wbdBindData; handle_t hBinding = NULL;
do { // enumerate leases here
SetCurrentState(WINSDB_LOADING);
// now that the server name and ip are valid, call
// WINSBind function directly.
WINSINTF_ADD_T waWinsAddress;
DWORD dwStatus; CString strNetBIOSName;
// call WinsBind function with the IP address
wbdBindData.fTcpIp = 1; wbdBindData.pPipeName = NULL; // convert wbdBindData.pServerAdd to wide char again as one of the internal
// functions expects a wide char string, this is done in WinsABind which is bypassed for
// unicode compatible apps
wbdBindData.pServerAdd = (LPSTR) (LPCTSTR) m_strIp;
if ((hBinding = ::WinsBind(&wbdBindData)) == NULL) { dwStatus = ::GetLastError(); Trace1("WinsDatabase::Execute - WinsBind failed %lx\n", dwStatus); break; }
#ifdef WINS_CLIENT_APIS
dwStatus = ::WinsGetNameAndAdd( hBinding, &waWinsAddress, (BYTE *)strNetBIOSName.GetBuffer(128));
#else
dwStatus = ::WinsGetNameAndAdd( &waWinsAddress, (BYTE *)strNetBIOSName.GetBuffer(128));
#endif WINS_CLIENT_APIS
strNetBIOSName.ReleaseBuffer();
if (dwStatus == ERROR_SUCCESS) { if(m_dwOwner == (DWORD)-1) dwStatus = ReadRecords(hBinding); else dwStatus = ReadRecordsByOwner(hBinding);
break; } else { Trace1("WinsDatabase::Execute - WinsGetNameAndAdd failed %lx\n", dwStatus); break; } } while (FALSE);
SetCurrentState(WINSDB_NORMAL);
if(hBinding) { // call winsunbind here, the handle is invalid after this and that's fine
WinsUnbind(&wbdBindData, hBinding); hBinding = NULL; } Trace0("WinsDatabase::Execute - all done, going to sleep now...\n");
} // while !Start
Trace0("WinsDatabase::Execute - exiting\n"); return dwStatus;}
/*!--------------------------------------------------------------------------
CWinsDatabase::ReadRecords Reads records from the WINS server Author: EricDav, v-shubk ---------------------------------------------------------------------------*/DWORD CWinsDatabase::ReadRecords(handle_t hBinding){ DWORD dwStatus = ERROR_SUCCESS; DWORD err = ERROR_SUCCESS; CWinsResults winsResults; err = winsResults.Update(hBinding);
WINSINTF_RECS_T Recs; Recs.pRow = NULL; DWORD NoOfRecsDesired = 500; DWORD TypeOfRecs = 4; BOOL fReadAllRecords ;
PWINSINTF_RECORD_ACTION_T pRow; enum {ST_SCAN_1B_NAME, ST_SCAN_NORM_NAME} State; LPBYTE pLastName; UINT nLastNameLen, nLastBuffLen;
pLastName = NULL; nLastNameLen = 0; nLastBuffLen = 0;
#ifdef DEBUG
CTime timeStart, timeFinish; timeStart = CTime::GetCurrentTime();#endif
m_dwRecsCount = 0;
// initialize the state machine. If we have a name prefix filter we
// start in ST_INIT_1B since we look first for the 1B names. These are
// particular in a sense their type byte - i.e. 0x1B - has been swapped
// with the first byte from the name. Consequently we need to do the same
// to allow WINS to look first for these names. Once we get over the 1B zone
// of our names, we restore the first byte and initiate another cycle for
// the rest of the name.
if (m_strPrefix != NULL) { nLastNameLen = nLastBuffLen = strlen(m_strPrefix) + 1; pLastName = (LPBYTE) new CHAR[nLastBuffLen]; strcpy((LPSTR)pLastName, m_strPrefix); pLastName[0] = 0x1B; State = ST_SCAN_1B_NAME; } else { State = ST_SCAN_NORM_NAME; }
do {
#ifdef WINS_CLIENT_APIS
err = ::WinsGetDbRecsByName( hBinding, NULL, WINSINTF_BEGINNING, pLastName, nLastNameLen, NoOfRecsDesired, TypeOfRecs, &Recs);
#else
err = ::WinsGetDbRecsByName( NULL, WINSINTF_BEGINNING, pFromName, LastNameLen, NoOfRecsDesired, TypeOfRecs, &Recs);
#endif WINS_CLIENT_APIS
// check to see if we need to abort
if (WaitForSingleObject(m_hAbort, 0) == WAIT_OBJECT_0) { Trace0("CWinsDatabase::ReadRecords - abort detected\n"); dwStatus = ERROR_OPERATION_ABORTED; break; }
if (err == ERROR_REC_NON_EXISTENT) { //
// Not a problem, there simply
// are no records in the database
//
Trace0("WinsDatabase::ReadRecords - no records in the Datbase\n"); fReadAllRecords = TRUE; err = ERROR_SUCCESS; break; }
if (err == ERROR_SUCCESS) { fReadAllRecords = Recs.NoOfRecs < NoOfRecsDesired; if (fReadAllRecords) Trace0("WinsDatabase::ReadRecords - Recs.NoOfRecs < NoOfRecsDesired, will exit\n");
TRY { DWORD i; pRow = Recs.pRow;
for (i = 0; i < Recs.NoOfRecs; ++i, ++pRow) { PWINSINTF_RECORD_ACTION_T pRow1 = Recs.pRow; WinsRecord wRecord; HROW hrow = NULL;
WinsIntfToWinsRecord(pRow, wRecord); if (pRow->OwnerId < (UINT) winsResults.AddVersMaps.GetSize()) { wRecord.dwOwner = winsResults.AddVersMaps[pRow->OwnerId].Add.IPAdd; } else { // having a record owned by a server which is not in the version map
// we got just earlier from WINS is not something that usually happens.
// It might happen only if the new owner was added right in between.
// Unlikely since this is a very small window - but if this happens
// just skip the record. From our point of view this owner doesn't exist
// hence the record doesn't belong to the view. It will show up with the
// first refresh.
continue; }
m_dwRecsCount++;
if (!m_bEnableCache && !m_IndexMgr.AcceptWinsRecord(&wRecord)) continue;
// add the data to our memory store and
// to the sorted index
m_cMemMan.AddData(wRecord, &hrow); // if m_bEnableCache is 0 the the filter was checked
m_IndexMgr.AddHRow(hrow, TRUE, !m_bEnableCache);
//Trace1("%d records added to DB\n", m_dwRecsCount);
}
// if we reached the end of the DB there is no need to do
// anything from below. Is just pLastName that needs to be
// freed up - this is done outside the loop, before exiting
// the call.
if (!fReadAllRecords) { BOOL fRangeOver = FALSE;
// get to the last record that was retrieved.
--pRow;
// check if the last name retrieved from the server is still
// mathing the pattern prefix (if any) or the range has been
// passed over (fRangeOver)
if (m_strPrefix != NULL) { for (UINT i = 0; i < pRow->NameLen && m_strPrefix[i] != 0; i++) { if (m_strPrefix[i] != pRow->pName[i]) { fRangeOver = TRUE; break; } } }
// here fRangeOver is either TRUE if the name doesn't match the pattern
// prefix or FALSE if the range is not passed yet. This latter thing means
// either the name is included in the prefix or the prefix isn't included in the name
// !!! We might want to invalidate the "name included in the prefix" case.
if (fRangeOver) { switch(State) { case ST_SCAN_1B_NAME: // in this state pLastName is definitely not NULL and even more,
// it once copied m_strPrefix. Since pLastName can only grow, it is
// certain it is large enough to cotain m_strPrefix one more time.
strcpy((LPSTR)pLastName, m_strPrefix); nLastNameLen = strlen((LPCSTR)pLastName); State = ST_SCAN_NORM_NAME; break; case ST_SCAN_NORM_NAME: // we were scanning normal names and we passed
// over the range of names we are looking for
// so just get out of the loop.
fReadAllRecords = TRUE; break; } } else { // enlarge the pLastName if needed
if (nLastBuffLen < pRow->NameLen+2) { if (pLastName != NULL) delete pLastName; nLastBuffLen = pRow->NameLen+2; pLastName = (LPBYTE)new CHAR[nLastBuffLen]; } // copy in pLastName the name of the last record
strcpy((LPSTR)pLastName, (LPCSTR)(pRow->pName));
if (pRow->NameLen >= 16 && pLastName[15] == 0x1B) { CHAR ch = pLastName[15]; pLastName[15] = pLastName[0]; pLastName[0] = ch; }
strcat((LPSTR)pLastName, "\x01"); nLastNameLen = strlen((LPCSTR)pLastName); } } } CATCH_ALL(e) { err = ::GetLastError(); Trace1("WinsDatabase::ReadRecords - Exception! %d \n", err); m_hrLastError = HRESULT_FROM_WIN32(err); } END_CATCH_ALL } else { Trace1("WinsDatabase::ReadRecords - GetRecsByName failed! %d \n", err); m_hrLastError = HRESULT_FROM_WIN32(err); break; } if (Recs.pRow != NULL) { ::WinsFreeMem(Recs.pRow); }
} while(!fReadAllRecords );
if (pLastName != NULL) delete pLastName;
#ifdef DEBUG
timeFinish = CTime::GetCurrentTime(); CTimeSpan timeDelta = timeFinish - timeStart; CString strTempTime = timeDelta.Format(_T("%H:%M:%S")); Trace2("WINS DB - ReadRecords: %d records read, total time %s\n", m_dwRecsCount, strTempTime);#endif
return dwStatus;}
/*!--------------------------------------------------------------------------
ThreadProc - Author: EricDav, v-shubk ---------------------------------------------------------------------------*/DWORD WINAPI ThreadProc(LPVOID pParam){ DWORD dwReturn; HRESULT hr = hrOK;
COM_PROTECT_TRY { CWinsDatabase *pWinsDB = (CWinsDatabase *) pParam; Trace0("WinsDatabase Background Thread started.\n");
dwReturn = pWinsDB->Execute(); } COM_PROTECT_CATCH
return dwReturn;}
/*!--------------------------------------------------------------------------
WinsIntfToWinsRecord Converts a wins record from the server into the WinsRecord struct Author: EricDav, v-shubk ---------------------------------------------------------------------------*/voidWinsIntfToWinsRecord(PWINSINTF_RECORD_ACTION_T pRecord, WinsRecord & wRecord){ ZeroMemory(&wRecord, sizeof(WinsRecord));
//::strcpy(wRecord.szRecordName, (LPCSTR)pRecord->pName);
::memcpy(wRecord.szRecordName, (LPCSTR)pRecord->pName, pRecord->NameLen);
wRecord.dwExpiration = (ULONG) pRecord->TimeStamp; wRecord.liVersion = pRecord->VersNo; wRecord.dwOwner = pRecord->OwnerId; wRecord.dwNameLen = WINSINTF_NAME_LEN_M(pRecord->NameLen); wRecord.dwType |= (BYTE) wRecord.szRecordName[15];
// translate the state and types to our own definitions
switch (pRecord->State_e) { case WINSINTF_E_TOMBSTONE: wRecord.dwState |= WINSDB_REC_TOMBSTONE; break;
case WINSINTF_E_DELETED: //Trace0("WinsIntfToWinsRecord - deleted record.\n");
wRecord.dwState |= WINSDB_REC_DELETED; break;
case WINSINTF_E_RELEASED: //Trace0("WinsIntfToWinsRecord - released record.\n");
wRecord.dwState |= WINSDB_REC_RELEASED; break;
default: // WINSINTF_E_ACTIVE:
wRecord.dwState |= WINSDB_REC_ACTIVE; break; }
switch (pRecord->TypOfRec_e) { case WINSINTF_E_NORM_GROUP: wRecord.dwState |= WINSDB_REC_NORM_GROUP; break;
case WINSINTF_E_SPEC_GROUP: wRecord.dwState |= WINSDB_REC_SPEC_GROUP; break;
case WINSINTF_E_MULTIHOMED: wRecord.dwState |= WINSDB_REC_MULTIHOMED; break;
default: // WINSINTF_E_UNIQUE:
wRecord.dwState |= WINSDB_REC_UNIQUE; break; }
// now do the type -- move the value into the high word
DWORD dwTemp = (pRecord->TypOfRec_e << 16); wRecord.dwType |= dwTemp;
// now set the static flag
if (pRecord->fStatic) wRecord.dwState |= WINSDB_REC_STATIC;
// store all of the IP addrs
wRecord.dwNoOfAddrs = pRecord->NoOfAdds; if (pRecord->NoOfAdds > 1) { Assert(pRecord->NoOfAdds <= WINSDB_MAX_NO_IPADDRS); //if (wRecord.dwNoOfAddrs > 4)
// Trace1("WinsIntfToWinsRecord - record with multiple (>4) IP addrs: %d\n", wRecord.dwNoOfAddrs);
wRecord.dwState |= WINSDB_REC_MULT_ADDRS;
for (UINT i = 0; i < pRecord->NoOfAdds; i++) wRecord.dwIpAdd[i] = pRecord->pAdd[i].IPAdd; } else { if (pRecord->NoOfAdds == 0) { //Trace2("WinsIntfToWinsRecord - record with NoOfAdds == 0; IP: %lx State: %lx \n", pRecord->Add.IPAdd, wRecord.dwState);
}
if (pRecord->Add.IPAdd == 0) { Trace1("WinsIntfToWinsRecord - record with 0 IP Address! State: %lx \n", wRecord.dwState); }
wRecord.dwIpAdd[0] = pRecord->Add.IPAdd; }}
/*!--------------------------------------------------------------------------
CreateWinsDatabase - Author: EricDav, v-shubk ---------------------------------------------------------------------------*/HRESULTCreateWinsDatabase(CString& strName, CString& strIP, IWinsDatabase **ppWinsDB){ AFX_MANAGE_STATE(AfxGetModuleState()); CWinsDatabase * pWinsDB = NULL; HRESULT hr = hrOK;
SPIWinsDatabase spWinsDB;
COM_PROTECT_TRY { pWinsDB = new CWinsDatabase(); Assert(pWinsDB); spWinsDB = pWinsDB; CORg(pWinsDB->Initialize(strName, strIP)); *ppWinsDB = spWinsDB.Transfer();
COM_PROTECT_ERROR_LABEL; } COM_PROTECT_CATCH return hr;}
/*!--------------------------------------------------------------------------
CWinsDatabase::SetApiInfo Implementation of SetApiInfo of IWinsDatabase Author: FlorinT ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::SetApiInfo(DWORD dwOwner, LPCOLESTR strPrefix, BOOL bCache){ // first cleanup the old prefix
if (m_strPrefix != NULL) { delete m_strPrefix; m_strPrefix = NULL; }
if (strPrefix != NULL) { UINT nPxLen = 0; LPSTR pPrefix;
nPxLen = (_tcslen(strPrefix)+1)*sizeof(TCHAR); m_strPrefix = new char[nPxLen]; if (m_strPrefix != NULL) {#ifdef _UNICODE
if (WideCharToMultiByte(CP_OEMCP, 0, strPrefix, -1, m_strPrefix, nPxLen, NULL, NULL) == 0) { delete m_strPrefix; m_strPrefix = NULL; }#else
CharToOem(strPrefix, m_strPrefix);#endif
m_strPrefix = _strupr(m_strPrefix);
for (pPrefix = m_strPrefix; *pPrefix != '\0' && *pPrefix != '*' && *pPrefix != '?'; pPrefix++); *pPrefix = '\0'; } }
m_dwOwner = dwOwner;
m_bEnableCache = bCache;
return hrOK;}
/*!--------------------------------------------------------------------------
CWinsDatabase::GetCachingFlag Implementation of GetCachingFlag of IWinsDatabase Author: FlorinT ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::GetCachingFlag(LPBOOL pbCache){ *pbCache = m_bEnableCache; return hrOK;}
/*!--------------------------------------------------------------------------
CWinsDatabase::ReloadSuggested Implementation of ReloadSuggested of IWinsDatabase Author: FlorinT ---------------------------------------------------------------------------*/HRESULT CWinsDatabase::ReloadSuggested(DWORD dwOwner, LPCOLESTR strPrefix, LPBOOL pbReload){ // check whether we filtered on a particular owner.
if (m_dwOwner != 0xFFFFFFFF) { // we did filter on owner previously, suggest RELOAD if we now
// don't want to filter on any owner (dwOwner == 0xffffffff)
// or the owner we want to filter is different from the original one
*pbReload = (m_dwOwner != dwOwner); } else { // we didn't filter on any owner previously so we either loaded
// all the records (if no name prefix was specified) or loaded
// all the records matching the given prefix
if (m_strPrefix != NULL) { // we did have a previous prefix to match so we need to see
// if the new prefix is not by any chance more specific than
// the original one. In which case there is no need to reload
LPSTR pPrefix; UINT nPxLen; UINT i;
if (strPrefix == NULL) { // if now we're not filtering by name, since we did previously
// we definitely need to reload the database
*pbReload = TRUE; return hrOK; }
nPxLen = (_tcslen(strPrefix)+1)*sizeof(TCHAR); pPrefix = new char[nPxLen]; if (pPrefix != NULL) {#ifdef _UNICODE
if (WideCharToMultiByte(CP_OEMCP, 0, strPrefix, -1, pPrefix, nPxLen, NULL, NULL) == 0) { delete pPrefix; *pbReload = TRUE; return hrOK; }#else
CharToOem(strPrefix, pPrefix);#endif
pPrefix = _strupr(pPrefix);
for (i = 0; pPrefix[i] != '\0' && pPrefix[i] != '*' && pPrefix[i] != '?'; i++); pPrefix[i] = '\0';
// we don't suggest database reloading only if the current prefix
// is a prefix for the new one to be applied. This way, whatever
// was retrieved previously already contains the names having the
// new prefix.
*pbReload = (strncmp(m_strPrefix, pPrefix, strlen(m_strPrefix)) != 0);
delete pPrefix; } else { // couldn't allocate memory -> serious enough to ask a full reload
*pbReload = TRUE; } } else { // well, there was no prefix specified last time the db was loaded so
// we should have the whole database in hand. No need to reload.
*pbReload = FALSE; } }
return hrOK;}
/*!--------------------------------------------------------------------------
CWinsDatabase::ReadRecordsByOwner Reads records from the WINS server for a particular owner Author: EricDav, v-shubk ---------------------------------------------------------------------------*/#define MAX_DESIRED_RECORDS 400
#define LARGE_GAP_DETECT_COUNT 32
DWORD CWinsDatabase::ReadRecordsByOwner(handle_t hBinding){ DWORD err; CWinsResults winsResults; WINSINTF_RECS_T Recs; DWORD dwIP; LARGE_INTEGER MinVersNo, MaxVersNo; LARGE_INTEGER LowestVersNo; DWORD dwDesired; DWORD dwLargeGapCount; WINSINTF_ADD_T OwnerAdd; DWORD i;
err = winsResults.Update(hBinding); if (err != ERROR_SUCCESS) { m_hrLastError = HRESULT_FROM_WIN32(err); return err; }
MinVersNo.QuadPart= 0; for (i = 0; i < (int)winsResults.NoOfOwners; i++) { if (m_dwOwner == winsResults.AddVersMaps[i].Add.IPAdd) { MaxVersNo = winsResults.AddVersMaps[i].VersNo; break; } }
// if we couldn't find the owner (highly unlikely) get out
// with error INVALID_PARAMETER.
if (i == winsResults.NoOfOwners) { err = ERROR_INVALID_PARAMETER; m_hrLastError = HRESULT_FROM_WIN32(err); return err; }
m_dwRecsCount = 0;
OwnerAdd.Type = 0; OwnerAdd.Len = 4; OwnerAdd.IPAdd = m_dwOwner;
// This is what the server does to retrieve the records:
// 1. sets an ascending index on owner & version number.
// 2. goes to the first record owned by the given owner,
// having a version number larger or equal to MinVersNo.
// 3. stop if the record's vers num is higher than the range specified
// 4. stop if more than 1000 recs have been already received
// 5. add the new record to the set to return and go to 3.
//
dwDesired = MAX_DESIRED_RECORDS; dwLargeGapCount = LARGE_GAP_DETECT_COUNT; LowestVersNo.QuadPart = 0; if (MaxVersNo.QuadPart > dwDesired) MinVersNo.QuadPart = MaxVersNo.QuadPart-dwDesired; else MinVersNo.QuadPart = 0; Recs.pRow = NULL; while(MaxVersNo.QuadPart >= MinVersNo.QuadPart) { // clear up the previous array - if any
if (Recs.pRow != NULL) { ::WinsFreeMem(Recs.pRow); Recs.pRow = NULL; }
// go to WINS to get the data for the given Owner
#ifdef WINS_CLIENT_APIS
err = ::WinsGetDbRecs(hBinding, &OwnerAdd, MinVersNo, MaxVersNo, &Recs);#else
err = ::WinsGetDbRecs(&OwnerAdd, MinVersNo, MaxVersNo, &Recs);#endif WINS_CLIENT_APIS
// if abort was requested, break out with "ABORTED"
if (WaitForSingleObject(m_hAbort, 0) == WAIT_OBJECT_0) { err = ERROR_OPERATION_ABORTED; break; }
// if there is any kind of error break out
if (err != ERROR_SUCCESS) { if (err == ERROR_REC_NON_EXISTENT) { // I'm not sure this happens after all. The server side (WINS) has
// not code path returning such an error code.
err = ERROR_SUCCESS; } else { // if this happens, just get out with the error, and save the
// meaning of the error
m_hrLastError = HRESULT_FROM_WIN32(err); } break; }
// if got less than 1/4 of the size of the range, expand the range
// to double of what it was + 1. (+1 is important to avoid the effect
// of dramatic drop down because of DWORD roll-over
if (Recs.NoOfRecs <= (dwDesired >> 2)) { dwDesired <<= 1; dwDesired |= 1; } // else if got more than 3/4 of the size of the range, split the range in 2
// but not less than MAX_DESIRED_RECORDS
else if (Recs.NoOfRecs >= (dwDesired - (dwDesired >> 2))) { dwDesired = max (MAX_DESIRED_RECORDS, dwDesired >> 1); }
TRY { DWORD j; PWINSINTF_RECORD_ACTION_T pRow;
for (j = 0, pRow = Recs.pRow; j < Recs.NoOfRecs; j++, ++pRow) { WinsRecord wRecord; HROW hrow = NULL;
pRow->OwnerId = m_dwOwner; WinsIntfToWinsRecord(pRow, wRecord);
m_dwRecsCount++; if (!m_bEnableCache && !m_IndexMgr.AcceptWinsRecord(&wRecord)) continue;
// add the data to our memory store and
// to the sorted index
m_cMemMan.AddData(wRecord, &hrow); m_IndexMgr.AddHRow(hrow, FALSE, !m_bEnableCache); }
// now setup the new range to search..
//
// if this is not the gap boundary detection cycle, the next MaxVersNo
// needs to go right below the current MinVersNo. Otherwise, MaxVersNo
// needs to remain untouched!
if (dwLargeGapCount != 0) MaxVersNo.QuadPart = MinVersNo.QuadPart - 1;
// if no records were found..
if (Recs.NoOfRecs == 0) { // ..and we were already in the gap boundary detection cycle..
if (dwLargeGapCount == 0) // ..just break the loop - there are simply no more records
// for this owner in the database
break;
// ..otherwise just decrease the gap boundary detection counter.
// If it reaches 0, then next cycle we will attempt to see if
// there is any record closer to the lowest edge of the range by
// expanding for one time only the whole space.
dwLargeGapCount--; } else { // if we just exited the gap boundary detection cycle by finding some
// records, set the LowestVersNo to one more than the largest VersNo
// we found during this cycle.
if (dwLargeGapCount == 0) { pRow--; LowestVersNo.QuadPart = pRow->VersNo.QuadPart+1; }
// if there were any records found, just reset the gap boundary detection counter.
dwLargeGapCount = LARGE_GAP_DETECT_COUNT; }
// if the dwLargeGapCount counter is zero, it means the next cycle is a gap boundary detection one
// which means the range should be set for the whole unexplored space.
if (dwLargeGapCount != 0 && MaxVersNo.QuadPart > LowestVersNo.QuadPart + dwDesired) MinVersNo.QuadPart = MaxVersNo.QuadPart - dwDesired; else MinVersNo.QuadPart = LowestVersNo.QuadPart; } CATCH_ALL(e) { err = ::GetLastError(); m_hrLastError = HRESULT_FROM_WIN32(err); } END_CATCH_ALL }
if (Recs.pRow != NULL) ::WinsFreeMem(Recs.pRow);
return err;}
|
