// Map11Pge.cpp : implementation file // #include "stdafx.h" #include #include "certmap.h" // persistence and mapping includes #include "WrapMaps.h" //#include "wrpprsis.h" //#include "admutil.h" #include "ListRow.h" #include "ChkLstCt.h" #include "wrapmb.h" // mapping page includes #include "brwsdlg.h" #include "EdtOne11.h" #include "Ed11Maps.h" #include "Map11Pge.h" #include "CrackCrt.h" #include //#include "WrpMBWrp.h" #ifdef _DEBUG #define new DEBUG_NEW #undef THIS_FILE static char THIS_FILE[] = __FILE__; #endif #define COL_NUM_ENABLED 0 #define COL_NUM_NAME 1 #define COL_NUM_NTACCOUNT 2 #define MB_EXTEND_KEY _T("Cert11") #define MB_EXTEND_KEY_MAPS _T("Cert11/Mappings") ///////////////////////////////////////////////////////////////////////////// // CMap11Page property page IMPLEMENT_DYNCREATE(CMap11Page, CPropertyPage) CMap11Page::CMap11Page() : CPropertyPage(CMap11Page::IDD), m_MapsInMetabase( 0 ) { //{{AFX_DATA_INIT(CMap11Page) m_csz_i_c = _T(""); m_csz_i_o = _T(""); m_csz_i_ou = _T(""); m_csz_s_c = _T(""); m_csz_s_cn = _T(""); m_csz_s_l = _T(""); m_csz_s_o = _T(""); m_csz_s_ou = _T(""); m_csz_s_s = _T(""); //}}AFX_DATA_INIT } CMap11Page::~CMap11Page() { ResetMappingList(); } void CMap11Page::DoDataExchange(CDataExchange* pDX) { CPropertyPage::DoDataExchange(pDX); //{{AFX_DATA_MAP(CMap11Page) DDX_Control(pDX, IDC_ADD, m_cbutton_add); DDX_Control(pDX, IDC_ISSUER, m_cbutton_grp_issuer); DDX_Control(pDX, IDC_ISSUED_TO, m_cbutton_grp_issuedto); DDX_Control(pDX, IDC_LIST, m_clistctrl_list); DDX_Control(pDX, IDC_EDIT_11MAP, m_cbutton_editmap); DDX_Control(pDX, IDC_DELETE, m_cbutton_delete); DDX_Text(pDX, IDC_I_C, m_csz_i_c); DDX_Text(pDX, IDC_I_O, m_csz_i_o); DDX_Text(pDX, IDC_I_OU, m_csz_i_ou); DDX_Text(pDX, IDC_S_C, m_csz_s_c); DDX_Text(pDX, IDC_S_CN, m_csz_s_cn); DDX_Text(pDX, IDC_S_L, m_csz_s_l); DDX_Text(pDX, IDC_S_O, m_csz_s_o); DDX_Text(pDX, IDC_S_OU, m_csz_s_ou); DDX_Text(pDX, IDC_S_S, m_csz_s_s); //}}AFX_DATA_MAP } BEGIN_MESSAGE_MAP(CMap11Page, CPropertyPage) //{{AFX_MSG_MAP(CMap11Page) ON_BN_CLICKED(IDC_ADD, OnAdd) ON_BN_CLICKED(IDC_DELETE, OnDelete) ON_BN_CLICKED(IDC_EDIT_11MAP, OnEdit11map) ON_NOTIFY(LVN_ITEMCHANGED, IDC_LIST, OnItemchangedList) ON_NOTIFY(NM_DBLCLK, IDC_LIST, OnDblclkList) //}}AFX_MSG_MAP ON_COMMAND(ID_HELP_FINDER, DoHelp) ON_COMMAND(ID_HELP, DoHelp) ON_COMMAND(ID_CONTEXT_HELP, DoHelp) ON_COMMAND(ID_DEFAULT_HELP, DoHelp) END_MESSAGE_MAP() //--------------------------------------------------------------------------- void CMap11Page::DoHelp() { WinHelp( HIDD_CERTMAP_MAIN_BASIC ); } ///////////////////////////////////////////////////////////////////////////// // initialization routines //--------------------------------------------------------------------------- // FInitMapper is called by the routine instantiating this page. After the object // is first created is when it is called. It allows us to fail gracefully. BOOL CMap11Page::FInit(IMSAdminBase* pMB) { m_pMB = pMB; // this has become a simple place return TRUE; } //--------------------------------------------------------------------------- BOOL CMap11Page::OnInitDialog() { //call the parental oninitdialog BOOL f = CPropertyPage::OnInitDialog(); // if the initinalization (sp?) succeeded, init the list and other items if ( f ) { // init the contents of the list FInitMappingList(); // Fill the mapping list with the stored items FillMappingList(); // set the initial button states EnableDependantButtons(); } // set any changes in the info into place UpdateData(FALSE); // return the answer return f; } //--------------------------------------------------------------------------- BOOL CMap11Page::FInitMappingList() { CString sz; int i; // setup the friendly name column sz.Empty(); i = m_clistctrl_list.InsertColumn( COL_NUM_ENABLED, sz, LVCFMT_LEFT, 20 ); // setup the friendly name column sz.LoadString( IDS_LIST11_NAME ); i = m_clistctrl_list.InsertColumn( COL_NUM_NAME, sz, LVCFMT_LEFT, 105 ); // setup the account column sz.LoadString( IDS_LIST11_ACCOUNT ); i = m_clistctrl_list.InsertColumn( COL_NUM_NTACCOUNT, sz, LVCFMT_LEFT, 195 ); return TRUE; } //--------------------------------------------------------------------------- BOOL CMap11Page::FillMappingList() { // reset the mapping list - get rid of anything in there now ResetMappingList(); // read in the mappings - it adds them to the list FReadMappings(); return TRUE; } //--------------------------------------------------------------------------- //BOOL CMap11Page::FAddMappingToList( C11Mapping* pMap, DWORD iList ) BOOL CMap11Page::FAddMappingToList( C11Mapping* pMap ) { CString sz; int i; DWORD iList; // if requested, make sure the mapping is added to the end of the list iList = m_clistctrl_list.GetItemCount(); // get the appropriate "enabled" string BOOL fEnabled; pMap->GetMapEnabled( &fEnabled ); if ( fEnabled ) sz.LoadString( IDS_ENABLED ); else sz.Empty(); // add the friendly name of the mapping // create the new entry in the list box. Do not sort on this entry - yet i = m_clistctrl_list.InsertItem( iList, sz ); // add the friendly name of the mapping pMap->GetMapName( sz ); // create the new entry in the list box. Do not sort on this entry - yet m_clistctrl_list.SetItemText( i, COL_NUM_NAME, sz ); // add the account name of the mapping pMap->GetNTAccount( sz ); m_clistctrl_list.SetItemText( i, COL_NUM_NTACCOUNT, sz ); // attach the pointer to the mapping as the private data in the list. m_clistctrl_list.SetItemData( i, (UINT_PTR)pMap ); // return whether or not the insertion succeeded return TRUE; } //--------------------------------------------------------------------------- void CMap11Page::EnableDependantButtons() { // the whole purpose of this routine is to gray or activate // the edit and delete buttons depending on whether or not anything // is selected. So start by getting the selection count if ( m_clistctrl_list.GetSelectedCount() > 0 ) { // there are items selected m_cbutton_editmap.EnableWindow( TRUE ); m_cbutton_delete.EnableWindow( TRUE ); EnableCrackDisplay( TRUE ); } else { // nope. Nothing selected m_cbutton_editmap.EnableWindow( FALSE ); m_cbutton_delete.EnableWindow( FALSE ); } // always enable the add button m_cbutton_add.EnableWindow( TRUE ); } //--------------------------------------------------------------------------- BOOL CMap11Page::EditOneMapping( C11Mapping* pUpdateMap ) { CEditOne11MapDlg mapdlg; // prepare the mapping dialog pUpdateMap->GetMapName( mapdlg.m_sz_mapname ); pUpdateMap->GetMapEnabled( &mapdlg.m_bool_enable ); pUpdateMap->GetNTAccount( mapdlg.m_sz_accountname ); pUpdateMap->GetNTPassword( mapdlg.m_sz_password ); // run the mapping dialog if ( mapdlg.DoModal() == IDOK ) { // update its friendly name pUpdateMap->SetMapName( mapdlg.m_sz_mapname ); // set the NT account field of the mapping object pUpdateMap->SetNTAccount( mapdlg.m_sz_accountname ); // set the NT account password field of the mapping object pUpdateMap->SetNTPassword( mapdlg.m_sz_password ); // set whether or not the mapping is enabled pUpdateMap->SetMapEnabled( mapdlg.m_bool_enable ); // NOTE: the caller is resposible for calling UpdateMappingInDispList // as the mapping in question may not yet be in the display list // this mapping has changed. Mark it to be saved MarkToSave( pUpdateMap ); // return true because the user said "OK" return TRUE; } // return FALSE because the user did not say "OK" return FALSE; } //--------------------------------------------------------------------------- BOOL CMap11Page::EditMultipleMappings() { CEdit11Mappings mapdlg; C11Mapping* pUpdate11Map; BOOL fSetInitialState = FALSE; BOOL fEnable; // scan the list of seleted items for the proper initial enable button state // loop through the selected items, setting each one's mapping int iList = -1; while( (iList = m_clistctrl_list.GetNextItem( iList, LVNI_SELECTED )) >= 0 ) { // get the mapping item for updating purposes pUpdate11Map = GetMappingInDisplay( iList ); ASSERT( pUpdate11Map ); if ( !pUpdate11Map ) { AfxMessageBox( IDS_ERR_ACCESS_MAPPING ); break; } // get the enable state of the mapping pUpdate11Map->GetMapEnabled( &fEnable ); // if this is the first time, just set the initial state if ( !fSetInitialState ) { mapdlg.m_int_enable = fEnable; fSetInitialState = TRUE; } else { // if it is different, then go indeterminate and break if ( fEnable != mapdlg.m_int_enable ) { mapdlg.m_int_enable = 2; break; } } } // run the mapping dialog if ( mapdlg.DoModal() == IDOK ) { // loop through the selected items, setting each one's mapping int iList = -1; while( (iList = m_clistctrl_list.GetNextItem( iList, LVNI_SELECTED )) >= 0 ) { // get the mapping item for updating purposes pUpdate11Map = GetMappingInDisplay( iList ); if ( !pUpdate11Map ) { AfxMessageBox( IDS_ERR_ACCESS_MAPPING ); break; } // set the enable flag if requested switch ( mapdlg.m_int_enable ) { case 0: // disable pUpdate11Map->SetMapEnabled( FALSE ); break; case 1: // enable pUpdate11Map->SetMapEnabled( TRUE ); break; } // set the NT account field of the mapping object pUpdate11Map->SetNTAccount( mapdlg.m_sz_accountname ); // set the NT account password field of the mapping object pUpdate11Map->SetNTPassword( mapdlg.m_sz_password ); // update it in the list control too UpdateMappingInDispList( iList, pUpdate11Map ); // this mapping has changed. Mark it to be saved MarkToSave( pUpdate11Map ); } // activate the apply button SetModified(); // return true because the user said "OK" return TRUE; } // return FALSE because the user did not say "OK" return FALSE; } //--------------------------------------------------------------------------- void CMap11Page::UpdateMappingInDispList( DWORD iList, C11Mapping* pMap ) { CString sz; // verify the index and the pointer! ASSERT( pMap == GetMappingInDisplay(iList) ); // get the appropriate "enabled" string BOOL fEnabled; pMap->GetMapEnabled( &fEnabled ); if ( fEnabled ) sz.LoadString( IDS_ENABLED ); else sz.Empty(); // update the "Enabled" indicator m_clistctrl_list.SetItemText( iList, COL_NUM_ENABLED, sz ); // update the mapping name pMap->GetMapName( sz ); m_clistctrl_list.SetItemText( iList, COL_NUM_NAME, sz ); // update the account name pMap->GetNTAccount( sz ); m_clistctrl_list.SetItemText( iList, COL_NUM_NTACCOUNT, sz ); } //--------------------------------------------------------------------------- void CMap11Page::ResetMappingList() { // first, delete all the mapping objects in the list DWORD cbList = m_clistctrl_list.GetItemCount(); for ( DWORD iList = 0; iList < cbList; iList++ ) DeleteMapping( GetMappingInDisplay(iList) ); // reset the mapping list - get rid of anything in there now m_clistctrl_list.DeleteAllItems(); } //--------------------------------------------------------------------------- void CMap11Page::MarkToSave( C11Mapping* pSaveMap, BOOL fSave ) { // first, we see if it is already in the list. If it is, we have nothing to do // unless fSave is set to false, then we remove it from the list DWORD cbItemsInList = (DWORD)m_rgbSave.GetSize(); for ( DWORD i = 0; i < cbItemsInList; i++ ) { if ( pSaveMap == (C11Mapping*)m_rgbSave[i] ) { // go away if fSave, otherwise, double check it isn't // anywhere else in the list if ( fSave ) { return; } else { // remove the item from the list m_rgbSave.RemoveAt(i); // don't skip now as the list slid down cbItemsInList--; i--; } } } // since it is not there, we should add it, if fSave is true if ( fSave ) m_rgbSave.Add( (CObject*)pSaveMap ); } ///////////////////////////////////////////////////////////////////////////// // CMap11Page message handlers //--------------------------------------------------------------------------- void CMap11Page::OnOK() { // this has gotten much simpler FWriteMappings(); CPropertyPage::OnOK(); } //--------------------------------------------------------------------------- BOOL CMap11Page::OnApply() { // this has gotten much simpler BOOL f = FWriteMappings(); // rebuild the display FillMappingList(); return f; } //#define MB_EXTEND_KEY "nsepm/Cert11/" //#define MB_EXTEND_KEY_MAPS "nsepm/Cert11/Mappings/" //--------------------------------------------------------------------------- // when the user pushes the add button, ask them to load a certificate, then // add it to the list as a mapping void CMap11Page::OnAdd() { // put this in a try/catch to make errors easier to deal with try { CString szFilter; szFilter.LoadString( IDS_KEY_OR_CERT_FILE_FILTER ); // prepare the file dialog variables CFileDialog cfdlg(TRUE, NULL, NULL, OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY, (LPCTSTR)szFilter); // Disable hook to get Windows 2000 style dialog cfdlg.m_ofn.Flags &= ~(OFN_ENABLEHOOK); // run the dialog if ( cfdlg.DoModal() == IDOK ) { // add the certificate to the mapping list if ( FAddCertificateFile( cfdlg.GetPathName() ) ) { // activate the apply button SetModified(); } } } catch ( CException e ) { } } //--------------------------------------------------------------------------- void CMap11Page::OnDelete() { C11Mapping* pKillMap; // ask the user to confirm this decision if ( AfxMessageBox(IDS_CONFIRM_DELETE, MB_OKCANCEL) != IDOK ) return; // loop through the selected items. Remove each from the list, // then mark it to be deleted. int iList = -1; while( (iList = m_clistctrl_list.GetNextItem( -1, LVNI_SELECTED )) >= 0 ) { // get the mapping pKillMap = GetMappingInDisplay( iList ); // remove it from the list m_clistctrl_list.DeleteItem( iList ); // if it has not yet been applied to the metabase, continue if ( pKillMap->iMD == NEW_OBJECT ) { // since this mapping never existed, we can just remove it from the add/edit lists MarkToSave( pKillMap, FALSE ); // go to the next selected object continue; } // mark the item to be deleted from the metabase m_rgbDelete.Add( (CObject*)pKillMap ); } // activate the apply button SetModified(); } //--------------------------------------------------------------------------- void CMap11Page::OnEdit11map() { int iList; C11Mapping* pUpdateMap; // what happens here depends on if just one mapping is selected, or many switch( m_clistctrl_list.GetSelectedCount() ) { case 0: // do nothing - should not get here because button grays out ASSERT( FALSE ); break; case 1: // get the mapping for update and run single edit dialog // get index of the selected list item iList = m_clistctrl_list.GetNextItem( -1, LVNI_SELECTED ); ASSERT( iList >= 0 ); // get the mapping item for updating purposes pUpdateMap = GetMappingInDisplay( iList ); if ( !pUpdateMap ) { AfxMessageBox( IDS_ERR_ACCESS_MAPPING ); break; } // edit the mapping, update it if successful, delete if not if ( EditOneMapping(pUpdateMap) ) { UpdateMappingInDispList( iList, pUpdateMap ); // activate the apply button SetModified(); } break; default: // run the multi edit dialog EditMultipleMappings(); break; } } //--------------------------------------------------------------------------- void CMap11Page::OnDblclkList(NMHDR* pNMHDR, LRESULT* pResult) { *pResult = 0; // if something in the list was double clicked, edit it if ( m_clistctrl_list.GetSelectedCount() > 0 ) OnEdit11map(); } //--------------------------------------------------------------------------- void CMap11Page::OnItemchangedList(NMHDR* pNMHDR, LRESULT* pResult) { C11Mapping* pSelMap; NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR; *pResult = 0; // enable the correct items EnableDependantButtons(); // fill in the cracked information for the selected mapping - if there is only one if ( m_clistctrl_list.GetSelectedCount() == 1 ) { // get index of the selected list item int i = m_clistctrl_list.GetNextItem( -1, LVNI_SELECTED ); ASSERT( i >= 0 ); // get the mapper index for the item pSelMap = GetMappingInDisplay( i ); if ( pSelMap ) { DisplayCrackedMap( pSelMap ); } } else { // either multiple, or no mappings selected EnableCrackDisplay( FALSE ); } } //================================================================================ // special display //--------------------------------------------------------------------------- BOOL CMap11Page::DisplayCrackedMap( C11Mapping* pMap ) { PUCHAR pCert; DWORD cbCert; CString sz; // obtain a reference to the certificate if ( !pMap->GetCertificate( &pCert, &cbCert ) ) return FALSE; // crack the certificate CCrackedCert cracker; if ( !cracker.CrackCert( pCert, cbCert ) ) return FALSE; // fill in all the fields cracker.GetIssuerCountry( sz ); m_csz_i_c = sz; cracker.GetIssuerOrganization( sz ); m_csz_i_o = sz; cracker.GetIssuerUnit( sz ); m_csz_i_ou = sz; cracker.GetSubjectCountry( sz ); m_csz_s_c = sz; cracker.GetSubjectCommonName( sz ); m_csz_s_cn = sz; cracker.GetSubjectLocality( sz ); m_csz_s_l = sz; cracker.GetSubjectOrganization( sz ); m_csz_s_o = sz; cracker.GetSubjectUnit( sz ); m_csz_s_ou = sz; cracker.GetSubjectState( sz ); m_csz_s_s = sz; UpdateData( FALSE ); // return success return TRUE; } //--------------------------------------------------------------------------- void CMap11Page::ClearCrackDisplay() { m_csz_i_c.Empty(); m_csz_i_o.Empty(); m_csz_i_ou.Empty(); m_csz_s_c.Empty(); m_csz_s_cn.Empty(); m_csz_s_l.Empty(); m_csz_s_o.Empty(); m_csz_s_ou.Empty(); m_csz_s_s.Empty(); UpdateData( FALSE ); } //--------------------------------------------------------------------------- void CMap11Page::EnableCrackDisplay( BOOL fEnable ) { if ( !fEnable ) ClearCrackDisplay(); m_cbutton_grp_issuer.EnableWindow( fEnable ); m_cbutton_grp_issuedto.EnableWindow( fEnable ); } //--------------------------------------------------------------------------- BOOL CMap11Page::FReadMappings() { BOOL f; C11Mapping* pMap; DWORD cbData; PVOID pData; DWORD fEnabled; CString sz; BOOL fRet = TRUE; // before messing with the metabase, prepare the strings we will need CString szBasePath = m_szMBPath + _T('/'); CString szRelativePath = MB_EXTEND_KEY_MAPS; CString szObjectPath = m_szMBPath + _T('/') + szRelativePath; CString szMapPath; // prepare the metabase wrappers CWrapMetaBase mbWrap; f = mbWrap.FInit(m_pMB); // open the base object f = mbWrap.Open( szObjectPath, METADATA_PERMISSION_READ ); ASSERT( f ); if ( !f ) { return FALSE; } // for now, at least, we are reading in all the mappings. reset the m_nNamer counter // so that we end up with a somewhat accurate reading of the last number-name in the list. m_MapsInMetabase = 0; // Loop the items in the metabase, adding each to the napper. DWORD index = 0; CString szEnum; while ( mbWrap.EnumObjects(_T(""), szEnum.GetBuffer(MAX_PATH*sizeof(WCHAR)), MAX_PATH*sizeof(WCHAR), index) ) { szEnum.ReleaseBuffer(); // keep track of the number of mappings we encounter m_MapsInMetabase++; // build the final mapping object path szMapPath.Format( _T("/%s"), szEnum ); // make a new mapping object pMap = PNewMapping(); if (pMap == NULL) { SetLastError(E_OUTOFMEMORY); fRet = FALSE; break; } // install the object name into the mapping pMap->iMD = m_MapsInMetabase; // get the certificate pData = mbWrap.GetData( szMapPath, MD_MAPCERT, IIS_MD_UT_SERVER, BINARY_METADATA, &cbData ); if ( pData ) { // set the data into place pMap->SetCertificate( (PUCHAR)pData, cbData ); // free the buffer mbWrap.FreeWrapData( pData ); } // get the NT Account - a string cbData = METADATA_MAX_NAME_LEN; if ( Get11String( &mbWrap, szMapPath, MD_MAPNTACCT, sz) ) { pMap->SetNTAccount( sz ); } // get the NT Password cbData = METADATA_MAX_NAME_LEN; if ( Get11String( &mbWrap, szMapPath, MD_MAPNTPWD, sz) ) { pMap->SetNTPassword( sz ); } // get the Enabled flag if ( mbWrap.GetDword( szMapPath, MD_MAPENABLED, IIS_MD_UT_SERVER, &fEnabled) ) pMap->SetMapEnabled( (fEnabled > 0) ); // get the mapping name cbData = METADATA_MAX_NAME_LEN; if ( Get11String( &mbWrap, szMapPath, MD_MAPNAME, sz) ) { pMap->SetMapName( sz ); } // add the mapping to the list FAddMappingToList( pMap ); // increment the index index++; } szEnum.ReleaseBuffer(); // close the mapping object mbWrap.Close(); // return success return fRet; } //--------------------------------------------------------------------------- // IMPORTANT: There is a bug in the mapping namespace extension where, even // though we are using the unicode metabase interface, all the strings are // expected to be ansi. This means that we cannont use the wrapmb getstring // and setstring calls with regards to the nsmp extetention. That is why // there are these two string wrapper classes that // also, all the strings used here are IIS_MD_UT_SERVER, so we can elimiate that parameter. BOOL CMap11Page::Get11String(CWrapMetaBase* pmb, LPCTSTR pszPath, DWORD dwPropID, CString& sz) { DWORD dwcb; BOOL fAnswer = FALSE; // get the string using the self-allocating get data process // that that it is cast as ANSI so the sz gets it right. // NOTE: This must be gotten as an ANSI string! PCHAR pchar = (PCHAR)pmb->GetData( pszPath, dwPropID, IIS_MD_UT_SERVER, STRING_METADATA, &dwcb ); if ( pchar ) { // set the answer sz = pchar; fAnswer = TRUE; // clean up pmb->FreeWrapData( pchar ); } // return the answer return fAnswer; } //--------------------------------------------------------------------------- /* INTRINSA suppress=null_pointers, uninitialized */ BOOL CMap11Page::Set11String(CWrapMetaBase* pmb, LPCTSTR pszPath, DWORD dwPropID, CString& sz, DWORD dwFlags ) { USES_CONVERSION; // Easy. Just set it as data // Make sure it is set back as an ANSI string though LPSTR pA = T2A((LPTSTR)(LPCTSTR)sz); return pmb->SetData( pszPath, dwPropID, IIS_MD_UT_SERVER, STRING_METADATA, (PVOID)pA, strlen(pA)+1, dwFlags ); } //--------------------------------------------------------------------------- // we only need to write out the mappings that have been either changed or added. // Thoughts on further optimizations: The bare minimum info about where to find // a mapping in the metabase could be stored in the metabase. Then, the mappings // would only be loaded when they were added to be edited or displayed in the // cracked list. The private data for each item in the list would have to have // some sort of reference to a position in the metabase. BOOL CMap11Page::FWriteMappings() { BOOL f; DWORD i,j; DWORD cMappings; C11Mapping* pMap; C11Mapping* pMapTemp; CString sz; DWORD dwEnabled; PUCHAR pCert; DWORD cbCert; DWORD iList; // before messing with the metabase, prepare the strings we will need CString szTempPath; CString szBasePath = m_szMBPath + _T("/Cert11"); CString szRelativePath = _T("/Mappings"); CString szObjectPath = szRelativePath + _T('/'); // prepare the base metabase wrapper CWrapMetaBase mbBase; f = mbBase.FInit(m_pMB); if ( !f ) { AfxMessageBox( IDS_ERR_ACCESS_MAPPING ); return FALSE; } // first, we have to open the Cert11 object. If it doesn't exist // then we have to add it tothe metabase if ( !mbBase.Open( szBasePath, METADATA_PERMISSION_READ|METADATA_PERMISSION_WRITE ) ) { // Cert11 does not exist - open the namespace base and add it szTempPath = m_szMBPath + _T('/'); if ( !mbBase.Open( szTempPath, METADATA_PERMISSION_READ|METADATA_PERMISSION_WRITE ) ) { AfxMessageBox( IDS_ERR_ACCESS_MAPPING ); return FALSE; // serious problems if we can't open the base } // add the Cert11 object szTempPath = _T("Cert11"); f = mbBase.AddObject( szTempPath ); mbBase.Close(); if ( !f ) { AfxMessageBox( IDS_ERR_CANTADD ); return FALSE; } // try again to open the Cert11. Fail if it doesn't work if ( !mbBase.Open( szBasePath, METADATA_PERMISSION_READ|METADATA_PERMISSION_WRITE ) ) { AfxMessageBox( IDS_ERR_ACCESS_MAPPING ); return FALSE; } } //========== // start by deleting all the mappings in the to-be-deleted list cMappings = (DWORD)m_rgbDelete.GetSize(); // only bother if there are items waiting to be deleted if ( cMappings > 0 ) { // get the count of mappings in the display list DWORD cList = m_clistctrl_list.GetItemCount(); // sort the mappings, in decending order for ( i = 0; i < cMappings-1; i++ ) { pMap = (C11Mapping*)m_rgbDelete[i]; for ( j = i; j < cMappings; j++ ) { pMapTemp = (C11Mapping*)m_rgbDelete[j]; if ( pMap->iMD < pMapTemp->iMD ) { m_rgbDelete.SetAt( i, (CObject*)pMapTemp ); m_rgbDelete.SetAt( j, (CObject*)pMap ); pMap = pMapTemp; } } } // loop the mappings, deleting each from the metabase for ( i = 0; i < cMappings; i++ ) { // get the mapping object pMap = (C11Mapping*)m_rgbDelete[i]; if ( !pMap || (pMap->iMD == NEW_OBJECT) ) continue; // build the relative path to the object in question. szObjectPath.Format( _T("%s/%d"), szRelativePath, pMap->iMD ); // delete that mapping's object from the metabase f = mbBase.DeleteObject( szObjectPath ); // decrement the number of maps in the metabase m_MapsInMetabase--; // loop the items in the list, decrementing the index of those // that are above it. Yes - this is non-optimal, but its what // has to be done for now for ( iList = 0; iList < cList; iList++ ) { pMapTemp = GetMappingInDisplay(iList); if ( (pMapTemp->iMD > pMap->iMD) && (pMapTemp->iMD != NEW_OBJECT) ) pMapTemp->iMD--; } // since we will no longer be needing this mapping, delete it DeleteMapping( pMap ); } // reset the to-be-deleted list m_rgbDelete.RemoveAll(); } //========== // get the number mappings in the to-be-saved list cMappings = (DWORD)m_rgbSave.GetSize(); // loop the mappings, adding each to the metabase for ( i = 0; i < cMappings; i++ ) { // get the mapping object pMap = (C11Mapping*)m_rgbSave[i]; ASSERT( pMap ); // if the object is already in the metabase, just open it. if ( pMap->iMD != NEW_OBJECT ) { // build the relative path to the object szObjectPath.Format( _T("%s/%d"), szRelativePath, pMap->iMD ); } else { // set up the name of the new mapping as one higher // than the number of mappings in the metabase pMap->iMD = m_MapsInMetabase + 1; // build the relative path to the object szObjectPath.Format( _T("%s/%d"), szRelativePath, pMap->iMD ); // add the mapping object to the base f = mbBase.AddObject( szObjectPath ); if ( f ) { // increment the number of maps in the metabase m_MapsInMetabase++; } } // write the object's parameters if ( f ) { // save the certificate if ( pMap->GetCertificate(&pCert, &cbCert) ) { // set the data into place in the object f = mbBase.SetData( szObjectPath, MD_MAPCERT, IIS_MD_UT_SERVER, BINARY_METADATA, pCert, cbCert, METADATA_SECURE | METADATA_INHERIT ); } // save the NTAccount if ( pMap->GetNTAccount(sz) ) { // set the data into place in the object f = Set11String(&mbBase, szObjectPath, MD_MAPNTACCT, sz, METADATA_SECURE); } // save the password - secure if ( pMap->GetNTPassword(sz) ) { // set the data into place in the object f = Set11String(&mbBase, szObjectPath, MD_MAPNTPWD, sz, METADATA_SECURE); } // save the map's name if ( pMap->GetMapName(sz) ) { // set the data into place in the object f = Set11String(&mbBase, szObjectPath, MD_MAPNAME, sz); } // save the Enabled flag // server reads the flag as the value of the dword if ( pMap->GetMapEnabled(&f) ) { dwEnabled = (DWORD)f; f = mbBase.SetDword( szObjectPath, MD_MAPENABLED, IIS_MD_UT_SERVER, dwEnabled ); } } } // close the base object mbBase.Close(); // save the metabase mbBase.Save(); // reset the to-be-saved list m_rgbSave.RemoveAll(); // return success return TRUE; } //--------------------------------------------------------------------------- C11Mapping* CMap11Page::PNewMapping() { // the way it should be return new C11Mapping(); } //--------------------------------------------------------------------------- void CMap11Page::DeleteMapping( C11Mapping* pMap ) { // the way it should be delete pMap; }