void PasswordSafeSearch::FindMatches(const StringX& searchText, bool fCaseSensitive, SearchPointer& searchPtr, Iter begin, Iter end, Accessor afn) { searchPtr.Clear(); //As per original Windows code, default search is for all text fields CItemData::FieldBits bsFields; bsFields.set(); return FindMatches(searchText, fCaseSensitive, searchPtr, bsFields, false, wxEmptyString, CItemData::END, PWSMatch::MR_INVALID, false, begin, end, afn); }
void print_conflicting_item(const CItemData &item, const CItemData &otherItem, const CItemData::FieldBits &fields, item_diff_func_t diff_fn) { for( auto ft: diff_fields ) { switch(ft) { case CItem::GROUP: case CItem::TITLE: case CItem::USER: break; default: if (fields.test(ft)) { switch (ft) { case CItemData::POLICY: { // Policy comparison compares default policies for the safes if the // item's policy is empty. We just consider them to be same if empty. if ( have_empty_policies(item, otherItem) ) { continue; } break; } default: break; } diff_fn(item, otherItem, fields, ft); } break; } } }
static void CompareField(CItemData::FieldType field, const CItemData::FieldBits &bsTest, const CItemData &first, const CItemData &second, CItemData::FieldBits &bsConflicts, bool bTreatWhiteSpaceasEmpty = false) { if (bsTest.test(field)) { bool flip; if (bTreatWhiteSpaceasEmpty) { StringX a(first.GetFieldValue(field)), b(second.GetFieldValue(field)); EmptyIfOnlyWhiteSpace(a); EmptyIfOnlyWhiteSpace(b); flip = a != b; } else { flip = first.GetFieldValue(field) != second.GetFieldValue(field); } if (flip) bsConflicts.flip(field); } }
void CAdvancedDlg::Set(CItemData::FieldBits bsFields) { LVFINDINFO findinfo; CString cs_text; int iItem; DWORD_PTR dw_data; SecureZeroMemory(&findinfo, sizeof(LVFINDINFO)); findinfo.flags = LVFI_PARAM; // Note: Mandatory fields have a ItemData value + 0x800 rather than 0x1000 // and so will not be found and so not moved anywhere. for (int i = 0; i < CItem::LAST_DATA; i++) { // Don't move or allow non-allowed fields if (!m_bsAllowedFields.test(i)) continue; if (bsFields.test(i)) { // Selected - find entry in list of available fields and move it findinfo.lParam = i | NORMALFIELD; iItem = m_pLC_List->FindItem(&findinfo); if (iItem == -1) continue; cs_text = m_pLC_List->GetItemText(iItem, 0); dw_data = m_pLC_List->GetItemData(iItem); m_pLC_List->DeleteItem(iItem); iItem = m_pLC_Selected->InsertItem(0, cs_text); m_pLC_Selected->SetItemData(iItem, dw_data); } else { // Not selected - find entry in list of selected fields and move it findinfo.lParam = i | NORMALFIELD; iItem = m_pLC_Selected->FindItem(&findinfo); if (iItem == -1) continue; cs_text = m_pLC_Selected->GetItemText(iItem, 0); dw_data = m_pLC_Selected->GetItemData(iItem); m_pLC_Selected->DeleteItem(iItem); iItem = m_pLC_List->InsertItem(0, cs_text); m_pLC_List->SetItemData(iItem, dw_data); } } }
///////////////////////////////////////////////////////////////// // Context diff //////// inline wchar_t context_tag(CItem::FieldType ft, const CItemData::FieldBits &fields, const CItemData &item, const CItemData &otherItem) { // The two items were compared & found to be differing on this field // only show this tag for fields there were compared if (fields.test(ft)) return '!'; const StringX val{item.GetFieldValue(ft)}; // This field was not compared, it could be different. Print it only if // it is the same in both items if (val == otherItem.GetFieldValue(ft)) return L' '; if (val.empty()) return L'+'; // Don't print it return L'-'; }
void PasswordSafeSearch::FindMatches(const StringX& searchText, bool fCaseSensitive, SearchPointer& searchPtr, const CItemData::FieldBits& bsFields, bool fUseSubgroups, const wxString& subgroupText, CItemData::FieldType subgroupObject, PWSMatch::MatchRule subgroupFunction, bool subgroupFunctionCaseSensitive, Iter begin, Iter end, Accessor afn) { if (searchText.empty()) return; searchPtr.Clear(); typedef StringX (CItemData::*ItemDataFuncT)() const; struct { CItemData::FieldType type; ItemDataFuncT func; } ItemDataFields[] = { {CItemData::GROUP, &CItemData::GetGroup}, {CItemData::TITLE, &CItemData::GetTitle}, {CItemData::USER, &CItemData::GetUser}, {CItemData::PASSWORD, &CItemData::GetPassword}, // {CItemData::NOTES, &CItemData::GetNotes}, {CItemData::URL, &CItemData::GetURL}, {CItemData::EMAIL, &CItemData::GetEmail}, {CItemData::RUNCMD, &CItemData::GetRunCommand}, {CItemData::AUTOTYPE, &CItemData::GetAutoType}, {CItemData::XTIME_INT, &CItemData::GetXTimeInt}, }; for ( Iter itr = begin; itr != end; ++itr) { const int fn = (subgroupFunctionCaseSensitive? -subgroupFunction: subgroupFunction); if (fUseSubgroups && !afn(itr).Matches(stringT(subgroupText.c_str()), subgroupObject, fn)) continue; bool found = false; for (size_t idx = 0; idx < NumberOf(ItemDataFields) && !found; ++idx) { if (bsFields.test(ItemDataFields[idx].type)) { const StringX str = (afn(itr).*ItemDataFields[idx].func)(); found = fCaseSensitive? str.find(searchText) != StringX::npos: FindNoCase(searchText, str); } } if (!found && bsFields.test(CItemData::NOTES)) { StringX str = afn(itr).GetNotes(); found = fCaseSensitive? str.find(searchText) != StringX::npos: FindNoCase(searchText, str); } if (!found && bsFields.test(CItemData::PWHIST)) { size_t pwh_max, err_num; PWHistList pwhistlist; CreatePWHistoryList(afn(itr).GetPWHistory(), pwh_max, err_num, pwhistlist, PWSUtil::TMC_XML); for (PWHistList::iterator iter = pwhistlist.begin(); iter != pwhistlist.end(); iter++) { PWHistEntry pwshe = *iter; found = fCaseSensitive? pwshe.password.find(searchText) != StringX::npos: FindNoCase(searchText, pwshe.password ); if (found) break; // break out of for loop } pwhistlist.clear(); } if (found) { uuid_array_t uuid; afn(itr).GetUUID(uuid); searchPtr.Add(pws_os::CUUID(uuid)); } } }
void PWScore::Synchronize(PWScore *pothercore, const CItemData::FieldBits &bsFields, const bool &subgroup_bset, const stringT &subgroup_name, const int &subgroup_object, const int &subgroup_function, int &numUpdated, CReport *pRpt, bool *pbCancel) { /* Purpose: Synchronize entries from otherCore to m_core Algorithm: Foreach entry in otherCore Find in m_core if find a match update requested fields */ std::vector<StringX> vs_updated; numUpdated = 0; MultiCommands *pmulticmds = MultiCommands::Create(this); Command *pcmd1 = UpdateGUICommand::Create(this, UpdateGUICommand::WN_UNDO, UpdateGUICommand::GUI_UNDO_MERGESYNC); pmulticmds->Add(pcmd1); // Make sure we don't add it multiple times std::map<StringX, StringX> mapRenamedPolicies; std::vector<StringX> vs_PoliciesAdded; const StringX sxSync_DateTime = PWSUtil::GetTimeStamp(true).c_str(); ItemListConstIter otherPos; for (otherPos = pothercore->GetEntryIter(); otherPos != pothercore->GetEntryEndIter(); otherPos++) { // See if user has cancelled if (pbCancel != NULL && *pbCancel) { delete pmulticmds; return; } CItemData otherItem = pothercore->GetEntry(otherPos); CItemData::EntryType et = otherItem.GetEntryType(); // Do not process Aliases and Shortcuts if (et == CItemData::ET_ALIAS || et == CItemData::ET_SHORTCUT) continue; if (subgroup_bset && !otherItem.Matches(subgroup_name, subgroup_object, subgroup_function)) continue; const StringX sx_otherGroup = otherItem.GetGroup(); const StringX sx_otherTitle = otherItem.GetTitle(); const StringX sx_otherUser = otherItem.GetUser(); StringX sx_mergedentry; Format(sx_mergedentry, GROUPTITLEUSERINCHEVRONS, sx_otherGroup.c_str(), sx_otherTitle.c_str(), sx_otherUser.c_str()); ItemListConstIter foundPos = Find(sx_otherGroup, sx_otherTitle, sx_otherUser); if (foundPos != GetEntryEndIter()) { // found a match CItemData curItem = GetEntry(foundPos); // Don't update if entry is protected if (curItem.IsProtected()) continue; CItemData updItem(curItem); updItem.SetDisplayInfo(NULL); if (curItem.GetUUID() != otherItem.GetUUID()) { pws_os::Trace(_T("Synchronize: Mis-match UUIDs for [%ls:%ls:%ls]\n"), sx_otherGroup.c_str(), sx_otherTitle.c_str(), sx_otherUser.c_str()); } bool bUpdated(false); // Do not try and change GROUPTITLE = 0x00 (use GROUP & TITLE separately) or UUID = 0x01 for (size_t i = 2; i < bsFields.size(); i++) { if (bsFields.test(i)) { StringX sxValue = otherItem.GetFieldValue(static_cast<CItemData::FieldType>(i)); // Special processing for password policies (default & named) if (static_cast<CItemData::FieldType>(i) == CItemData::POLICYNAME) { Command *pPolicyCmd = ProcessPolicyName(pothercore, updItem, mapRenamedPolicies, vs_PoliciesAdded, sxValue, bUpdated, sxSync_DateTime, IDSC_SYNCPOLICY); if (pPolicyCmd != NULL) pmulticmds->Add(pPolicyCmd); } else { if (sxValue != updItem.GetFieldValue(static_cast<CItemData::FieldType>(i))) { bUpdated = true; updItem.SetFieldValue(static_cast<CItemData::FieldType>(i), sxValue); } } } } if (!bUpdated) continue; GUISetupDisplayInfo(updItem); updItem.SetStatus(CItemData::ES_MODIFIED); StringX sx_updated; Format(sx_updated, GROUPTITLEUSERINCHEVRONS, sx_otherGroup.c_str(), sx_otherTitle.c_str(), sx_otherUser.c_str()); vs_updated.push_back(sx_updated); Command *pcmd = EditEntryCommand::Create(this, curItem, updItem); pcmd->SetNoGUINotify(); pmulticmds->Add(pcmd); // Update the Wizard page UpdateWizard(sx_updated.c_str()); numUpdated++; } // Found match via [g:t:u] } // iteration over other core's entries stringT str_results; if (numUpdated > 0 && pRpt != NULL) { std::sort(vs_updated.begin(), vs_updated.end(), MergeSyncGTUCompare); stringT str_singular_plural_type, str_singular_plural_verb; LoadAString(str_singular_plural_type, numUpdated == 1 ? IDSC_ENTRY : IDSC_ENTRIES); LoadAString(str_singular_plural_verb, numUpdated == 1 ? IDSC_WAS : IDSC_WERE); Format(str_results, IDSC_SYNCHUPDATED, str_singular_plural_type.c_str(), str_singular_plural_verb.c_str()); pRpt->WriteLine(str_results.c_str()); for (size_t i = 0; i < vs_updated.size(); i++) { Format(str_results, L"\t%ls", vs_updated[i].c_str()); pRpt->WriteLine(str_results.c_str()); } } // See if user has cancelled if (pbCancel != NULL && *pbCancel) { delete pmulticmds; return; } Command *pcmd2 = UpdateGUICommand::Create(this, UpdateGUICommand::WN_REDO, UpdateGUICommand::GUI_REDO_MERGESYNC); pmulticmds->Add(pcmd2); Execute(pmulticmds); // See if user has cancelled too late - reset flag so incorrect information not given to user if (pbCancel != NULL && *pbCancel) { *pbCancel = false; return; } // tell the user we're done & provide short Synchronize report stringT str_entries; LoadAString(str_entries, numUpdated == 1 ? IDSC_ENTRY : IDSC_ENTRIES); Format(str_results, IDSC_SYNCHCOMPLETED, numUpdated, str_entries.c_str()); pRpt->WriteLine(str_results.c_str()); }
void PWScore::Compare(PWScore *pothercore, const CItemData::FieldBits &bsFields, const bool &subgroup_bset, const bool &bTreatWhiteSpaceasEmpty, const stringT &subgroup_name, const int &subgroup_object, const int &subgroup_function, CompareData &list_OnlyInCurrent, CompareData &list_OnlyInComp, CompareData &list_Conflicts, CompareData &list_Identical, bool *pbCancel) { /* Purpose: Compare entries from comparison database (compCore) with current database (m_core) Algorithm: Foreach entry in current database { Find in comparison database - subject to subgroup checking if found { Compare if match OK else There are conflicts; note them & increment numConflicts } else { save & increment numOnlyInCurrent } } Foreach entry in comparison database { Find in current database - subject to subgroup checking if not found save & increment numOnlyInComp } */ CItemData::FieldBits bsConflicts(0); st_CompareData st_data; int numOnlyInCurrent(0), numOnlyInComp(0), numConflicts(0), numIdentical(0); ItemListIter currentPos; for (currentPos = GetEntryIter(); currentPos != GetEntryEndIter(); currentPos++) { // See if user has cancelled if (pbCancel != NULL && *pbCancel) { return; } st_data.Empty(); const CItemData ¤tItem = GetEntry(currentPos); if (!subgroup_bset || currentItem.Matches(std::wstring(subgroup_name), subgroup_object, subgroup_function)) { st_data.group = currentItem.GetGroup(); st_data.title = currentItem.GetTitle(); st_data.user = currentItem.GetUser(); StringX sx_original; Format(sx_original, GROUPTITLEUSERINCHEVRONS, st_data.group.c_str(), st_data.title.c_str(), st_data.user.c_str()); // Update the Wizard page UpdateWizard(sx_original.c_str()); ItemListIter foundPos = pothercore->Find(st_data.group, st_data.title, st_data.user); if (foundPos != pothercore->GetEntryEndIter()) { // found a match, see if all other fields also match // Difference flags: /* First byte (values in square brackets taken from ItemData.h) 1... .... NAME [0x00] - n/a - depreciated .1.. .... UUID [0x01] - n/a - unique ..1. .... GROUP [0x02] - not checked - must be identical ...1 .... TITLE [0x03] - not checked - must be identical .... 1... USER [0x04] - not checked - must be identical .... .1.. NOTES [0x05] .... ..1. PASSWORD [0x06] .... ...1 CTIME [0x07] - not checked by default Second byte 1... .... PMTIME [0x08] - not checked by default .1.. .... ATIME [0x09] - not checked by default ..1. .... XTIME [0x0a] - not checked by default ...1 .... RESERVED [0x0b] - not used .... 1... RMTIME [0x0c] - not checked by default .... .1.. URL [0x0d] .... ..1. AUTOTYPE [0x0e] .... ...1 PWHIST [0x0f] Third byte 1... .... POLICY [0x10] - not checked by default .1.. .... XTIME_INT [0x11] - not checked by default ..1. .... RUNCMD [0x12] ...1 .... DCA [0x13] .... 1... EMAIL [0x14] .... .1.. PROTECTED [0x15] .... ..1. SYMBOLS [0x16] .... ...1 SHIFTDCA [0x17] Fourth byte 1... .... POLICYNAME [0x18] - not checked by default .1.. .... KBSHORTCUT [0x19] - not checked by default */ bsConflicts.reset(); StringX sxCurrentPassword, sxComparisonPassword; const CItemData &compItem = pothercore->GetEntry(foundPos); if (currentItem.IsDependent()) { CItemData *pci_base = GetBaseEntry(¤tItem); sxCurrentPassword = pci_base->GetPassword(); } else sxCurrentPassword = currentItem.GetPassword(); if (compItem.IsDependent()) { CItemData *pci_base = pothercore->GetBaseEntry(&compItem); sxComparisonPassword = pci_base->GetPassword(); } else sxComparisonPassword = compItem.GetPassword(); if (bsFields.test(CItemData::PASSWORD) && sxCurrentPassword != sxComparisonPassword) bsConflicts.flip(CItemData::PASSWORD); CompareField(CItemData::NOTES, bsFields, currentItem, compItem, bsConflicts, bTreatWhiteSpaceasEmpty); CompareField(CItemData::CTIME, bsFields, currentItem, compItem, bsConflicts); CompareField(CItemData::PMTIME, bsFields, currentItem, compItem, bsConflicts); CompareField(CItemData::ATIME, bsFields, currentItem, compItem, bsConflicts); CompareField(CItemData::XTIME, bsFields, currentItem, compItem, bsConflicts); CompareField(CItemData::RMTIME, bsFields, currentItem, compItem, bsConflicts); if (bsFields.test(CItemData::XTIME_INT)) { int32 current_xint, comp_xint; currentItem.GetXTimeInt(current_xint); compItem.GetXTimeInt(comp_xint); if (current_xint != comp_xint) bsConflicts.flip(CItemData::XTIME_INT); } CompareField(CItemData::URL, bsFields, currentItem, compItem, bsConflicts, bTreatWhiteSpaceasEmpty); CompareField(CItemData::AUTOTYPE, bsFields, currentItem, compItem, bsConflicts, bTreatWhiteSpaceasEmpty); CompareField(CItemData::PWHIST, bsFields, currentItem, compItem, bsConflicts); CompareField(CItemData::POLICYNAME, bsFields, currentItem, compItem, bsConflicts); // Don't test policy or symbols if either entry is using a named policy // as these are meaningless to compare if (currentItem.GetPolicyName().empty() && compItem.GetPolicyName().empty()) { if (bsFields.test(CItemData::POLICY)) { PWPolicy cur_pwp, cmp_pwp; if (currentItem.GetPWPolicy().empty()) cur_pwp = PWSprefs::GetInstance()->GetDefaultPolicy(); else currentItem.GetPWPolicy(cur_pwp); if (compItem.GetPWPolicy().empty()) cmp_pwp = PWSprefs::GetInstance()->GetDefaultPolicy(true); else compItem.GetPWPolicy(cmp_pwp); if (cur_pwp != cmp_pwp) bsConflicts.flip(CItemData::POLICY); } CompareField(CItemData::SYMBOLS, bsFields, currentItem, compItem, bsConflicts); } CompareField(CItemData::RUNCMD, bsFields, currentItem, compItem, bsConflicts); CompareField(CItemData::DCA, bsFields, currentItem, compItem, bsConflicts); CompareField(CItemData::SHIFTDCA, bsFields, currentItem, compItem, bsConflicts); CompareField(CItemData::EMAIL, bsFields, currentItem, compItem, bsConflicts); CompareField(CItemData::PROTECTED, bsFields, currentItem, compItem, bsConflicts); if (bsFields.test(CItemData::KBSHORTCUT) && currentItem.GetKBShortcut() != compItem.GetKBShortcut()) bsConflicts.flip(CItemData::KBSHORTCUT); st_data.uuid0 = currentPos->first; st_data.uuid1 = foundPos->first; st_data.bsDiffs = bsConflicts; st_data.indatabase = BOTH; st_data.unknflds0 = currentItem.NumberUnknownFields() > 0; st_data.unknflds1 = compItem.NumberUnknownFields() > 0; st_data.bIsProtected0 = currentItem.IsProtected(); if (bsConflicts.any()) { numConflicts++; st_data.id = numConflicts; list_Conflicts.push_back(st_data); } else { numIdentical++; st_data.id = numIdentical; list_Identical.push_back(st_data); } } else { // didn't find any match... numOnlyInCurrent++; st_data.uuid0 = currentPos->first; st_data.uuid1 = CUUID::NullUUID(); st_data.bsDiffs.reset(); st_data.indatabase = CURRENT; st_data.unknflds0 = currentItem.NumberUnknownFields() > 0; st_data.unknflds1 = false; st_data.id = numOnlyInCurrent; list_OnlyInCurrent.push_back(st_data); } } } // iteration over our entries ItemListIter compPos; for (compPos = pothercore->GetEntryIter(); compPos != pothercore->GetEntryEndIter(); compPos++) { // See if user has cancelled if (pbCancel != NULL && *pbCancel) { return; } st_data.Empty(); CItemData compItem = pothercore->GetEntry(compPos); if (!subgroup_bset || compItem.Matches(std::wstring(subgroup_name), subgroup_object, subgroup_function)) { st_data.group = compItem.GetGroup(); st_data.title = compItem.GetTitle(); st_data.user = compItem.GetUser(); StringX sx_compare; Format(sx_compare, GROUPTITLEUSERINCHEVRONS, st_data.group.c_str(), st_data.title.c_str(), st_data.user.c_str()); // Update the Wizard page UpdateWizard(sx_compare.c_str()); if (Find(st_data.group, st_data.title, st_data.user) == GetEntryEndIter()) { // Didn't find any match... numOnlyInComp++; st_data.uuid0 = CUUID::NullUUID(); st_data.uuid1 = compPos->first; st_data.bsDiffs.reset(); st_data.indatabase = COMPARE; st_data.unknflds0 = false; st_data.unknflds1 = compItem.NumberUnknownFields() > 0; st_data.id = numOnlyInComp; list_OnlyInComp.push_back(st_data); } } } // iteration over other core's element // See if user has cancelled too late - reset flag so incorrect information not given to user if (pbCancel != NULL && *pbCancel) { *pbCancel = false; } }
bool CCompareResultsDlg::CompareEntries(st_CompareData *pst_data) { CItemData::FieldBits bsConflicts; bsConflicts.reset(); ItemListIter iter; iter = m_pcore0->Find(pst_data->uuid0); CItemData currentItem = iter->second; iter = m_pcore1->Find(pst_data->uuid1); CItemData compItem = iter->second; StringX sxCurrentPassword, sxComparisonPassword; if (currentItem.GetEntryType() == CItemData::ET_ALIAS || currentItem.GetEntryType() == CItemData::ET_SHORTCUT) { CItemData *pci_base = m_pcore0->GetBaseEntry(¤tItem); sxCurrentPassword == pci_base->GetPassword(); } else sxCurrentPassword == currentItem.GetPassword(); if (compItem.GetEntryType() == CItemData::ET_ALIAS || compItem.GetEntryType() == CItemData::ET_SHORTCUT) { CItemData *pci_base = m_pcore1->GetBaseEntry(&compItem); sxComparisonPassword == pci_base->GetPassword(); } else sxComparisonPassword == compItem.GetPassword(); if (m_bsFields.test(CItemData::PASSWORD) && sxCurrentPassword != sxComparisonPassword) bsConflicts.flip(CItemData::PASSWORD); if (m_bsFields.test(CItemData::NOTES) && FieldsNotEqual(currentItem.GetNotes(), compItem.GetNotes(), m_bTreatWhiteSpaceasEmpty)) bsConflicts.flip(CItemData::NOTES); if (m_bsFields.test(CItemData::CTIME) && currentItem.GetCTime() != compItem.GetCTime()) bsConflicts.flip(CItemData::CTIME); if (m_bsFields.test(CItemData::PMTIME) && currentItem.GetPMTime() != compItem.GetPMTime()) bsConflicts.flip(CItemData::PMTIME); if (m_bsFields.test(CItemData::ATIME) && currentItem.GetATime() != compItem.GetATime()) bsConflicts.flip(CItemData::ATIME); if (m_bsFields.test(CItemData::XTIME) && currentItem.GetXTime() != compItem.GetXTime()) bsConflicts.flip(CItemData::XTIME); if (m_bsFields.test(CItemData::RMTIME) && currentItem.GetRMTime() != compItem.GetRMTime()) bsConflicts.flip(CItemData::RMTIME); if (m_bsFields.test(CItemData::XTIME_INT)) { int current_xint, comp_xint; currentItem.GetXTimeInt(current_xint); compItem.GetXTimeInt(comp_xint); if (current_xint != comp_xint) bsConflicts.flip(CItemData::XTIME_INT); } if (m_bsFields.test(CItemData::URL) && FieldsNotEqual(currentItem.GetURL(), compItem.GetURL(), m_bTreatWhiteSpaceasEmpty)) bsConflicts.flip(CItemData::URL); if (m_bsFields.test(CItemData::AUTOTYPE) && FieldsNotEqual(currentItem.GetAutoType(), compItem.GetAutoType(), m_bTreatWhiteSpaceasEmpty)) bsConflicts.flip(CItemData::AUTOTYPE); if (m_bsFields.test(CItemData::PWHIST) && currentItem.GetPWHistory() != compItem.GetPWHistory()) bsConflicts.flip(CItemData::PWHIST); if (m_bsFields.test(CItemData::POLICY) && currentItem.GetPWPolicy() != compItem.GetPWPolicy()) bsConflicts.flip(CItemData::POLICY); if (m_bsFields.test(CItemData::POLICYNAME) && currentItem.GetPolicyName() != compItem.GetPolicyName()) bsConflicts.flip(CItemData::POLICYNAME); if (m_bsFields.test(CItemData::RUNCMD) && currentItem.GetRunCommand() != compItem.GetRunCommand()) bsConflicts.flip(CItemData::RUNCMD); if (m_bsFields.test(CItemData::DCA) && currentItem.GetDCA() != compItem.GetDCA()) bsConflicts.flip(CItemData::DCA); if (m_bsFields.test(CItemData::SHIFTDCA) && currentItem.GetShiftDCA() != compItem.GetShiftDCA()) bsConflicts.flip(CItemData::SHIFTDCA); if (m_bsFields.test(CItemData::EMAIL) && currentItem.GetEmail() != compItem.GetEmail()) bsConflicts.flip(CItemData::EMAIL); if (m_bsFields.test(CItemData::PROTECTED) && currentItem.GetProtected() != compItem.GetProtected()) bsConflicts.flip(CItemData::PROTECTED); if (m_bsFields.test(CItemData::SYMBOLS) && currentItem.GetSymbols() != compItem.GetSymbols()) bsConflicts.flip(CItemData::SYMBOLS); if (m_bsFields.test(CItemData::KBSHORTCUT) && currentItem.GetKBShortcut() != compItem.GetKBShortcut()) bsConflicts.flip(CItemData::KBSHORTCUT); return bsConflicts.none(); }