//+------------------------------------------------------------------------- // // Microsoft Windows // // Copyright (C) Microsoft Corporation, 1998 - 1999 // // File: pgsrvs.cpp // //-------------------------------------------------------------------------- // PgSrvs.cpp : implementation file // #include "stdafx.h" #include #include #include "acsadmin.h" #include #include "PgSrvs.h" #include "ntsecapi.h" #ifndef STATUS_SUCCESS #define STATUS_SUCCESS 0L #endif #ifdef _DEBUG #define new DEBUG_NEW #undef THIS_FILE static char THIS_FILE[] = __FILE__; #endif typedef BOOL (*ACSINSTALL_Func)( LPWSTR HostName, LPWSTR DomainName, LPWSTR UserName, LPWSTR PassWord, LPDWORD dwError); typedef BOOL (*ACSUNINSTALL_Func)( LPWSTR HostName, LPDWORD dwError); #define ACSINSTALL "AcsInstall" #define ACSUNINSTALL "AcsUninstall" #define ACSINSTALLDLL _T("acsetupc.dll") #define ACSAccount _T("AcsService") ///////////////////////////////////////////////////////////////////////////// // CPgServers property page IMPLEMENT_DYNCREATE(CPgServers, CACSPage) #if 0 // LSA functions can only change policy on a machine, it's not the APIs we want // need to remove the code later void InitLsaString( PLSA_UNICODE_STRING LsaString, LPWSTR String ) { DWORD StringLength; if (String == NULL) { LsaString->Buffer = NULL; LsaString->Length = 0; LsaString->MaximumLength = 0; return; } StringLength = wcslen(String); LsaString->Buffer = String; LsaString->Length = (USHORT) StringLength * sizeof(WCHAR); LsaString->MaximumLength=(USHORT)(StringLength+1) * sizeof(WCHAR); } NTSTATUS OpenPolicy( LPWSTR ServerName, DWORD DesiredAccess, PLSA_HANDLE PolicyHandle ) { LSA_OBJECT_ATTRIBUTES ObjectAttributes; LSA_UNICODE_STRING ServerString; PLSA_UNICODE_STRING Server = NULL; // // Always initialize the object attributes to all zeroes. // ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes)); if (ServerName != NULL) { // // Make a LSA_UNICODE_STRING out of the LPWSTR passed in // InitLsaString(&ServerString, ServerName); Server = &ServerString; } // // Attempt to open the policy. // return LsaOpenPolicy( Server, &ObjectAttributes, DesiredAccess, PolicyHandle ); } /*++ This function attempts to obtain a SID representing the supplied account on the supplied system. If the function succeeds, the return value is TRUE. A buffer is allocated which contains the SID representing the supplied account. This buffer should be freed when it is no longer needed by calling HeapFree(GetProcessHeap(), 0, buffer) If the function fails, the return value is FALSE. Call GetLastError() to obtain extended error information. Scott Field (sfield) 12-Jul-95 --*/ BOOL GetAccountSid( LPTSTR SystemName, LPTSTR AccountName, PSID *Sid ) { LPTSTR ReferencedDomain=NULL; DWORD cbSid=128; // initial allocation attempt DWORD cbReferencedDomain=16; // initial allocation size SID_NAME_USE peUse; BOOL bSuccess=FALSE; // assume this function will fail __try { // // initial memory allocations // if((*Sid=HeapAlloc( GetProcessHeap(), 0, cbSid )) == NULL) __leave; if((ReferencedDomain=(LPTSTR)HeapAlloc( GetProcessHeap(), 0, cbReferencedDomain )) == NULL) __leave; // // Obtain the SID of the specified account on the specified system. // while(!LookupAccountName( SystemName, // machine to lookup account on AccountName, // account to lookup *Sid, // SID of interest &cbSid, // size of SID ReferencedDomain, // domain account was found on &cbReferencedDomain, &peUse )) { if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) { // // reallocate memory // if((*Sid=HeapReAlloc( GetProcessHeap(), 0, *Sid, cbSid )) == NULL) __leave; if((ReferencedDomain=(LPTSTR)HeapReAlloc( GetProcessHeap(), 0, ReferencedDomain, cbReferencedDomain )) == NULL) __leave; } else __leave; } // // Indicate success. // bSuccess=TRUE; } // finally __finally { // // Cleanup and indicate failure, if appropriate. // HeapFree(GetProcessHeap(), 0, ReferencedDomain); if(!bSuccess) { if(*Sid != NULL) { HeapFree(GetProcessHeap(), 0, *Sid); *Sid = NULL; } } } // finally return bSuccess; } NTSTATUS SetPrivilegeOnAccount( LSA_HANDLE PolicyHandle, // open policy handle PSID AccountSid, // SID to grant privilege to LPWSTR PrivilegeName, // privilege to grant (Unicode) BOOL bEnable // enable or disable ) { LSA_UNICODE_STRING PrivilegeString; // // Create a LSA_UNICODE_STRING for the privilege name. // InitLsaString(&PrivilegeString, PrivilegeName); // // grant or revoke the privilege, accordingly // if(bEnable) { return LsaAddAccountRights( PolicyHandle, // open policy handle AccountSid, // target SID &PrivilegeString, // privileges 1 // privilege count ); } else { return LsaRemoveAccountRights( PolicyHandle, // open policy handle AccountSid, // target SID FALSE, // do not disable all rights &PrivilegeString, // privileges 1 // privilege count ); } } #endif // LSA is not the right API for this HRESULT RemoveInteractiveLoginPrivilege(LPCTSTR strDomain, LPCTSTR strAccount) { return S_OK; #if 0 // LSA is not the right API for this LSA_HANDLE PolicyHandle = NULL; PSID pSid = NULL; NTSTATUS Status; HRESULT hr = S_OK; // // Open the policy on the target machine. // if((Status=OpenPolicy( (LPTSTR)strDomain, // target machine POLICY_CREATE_ACCOUNT | POLICY_LOOKUP_NAMES, &PolicyHandle // resultant policy handle )) != 0) { return HRESULT_FROM_WIN32(Status); } // // Obtain the SID of the user/group. // Note that we could target a specific machine, but we don't. // Specifying NULL for target machine searches for the SID in the // following order: well-known, Built-in and local, primary domain, // trusted domains. // if(GetAccountSid( NULL, // default lookup logic (LPTSTR)strAccount,// account to obtain SID &pSid // buffer to allocate to contain resultant SID )) { // // We only grant the privilege if we succeeded in obtaining the // SID. We can actually add SIDs which cannot be looked up, but // looking up the SID is a good sanity check which is suitable for // most cases. // // Grant the SeServiceLogonRight to users represented by pSid. // // #define SE_INTERACTIVE_LOGON_NAME TEXT("SeInteractiveLogonRight") // #define SE_DENY_INTERACTIVE_LOGON_NAME TEXT("SeDenyInteractiveLogonRight") if((Status=SetPrivilegeOnAccount( PolicyHandle, // policy handle pSid, // SID to grant privilege SE_INTERACTIVE_LOGON_NAME, // Unicode privilege FALSE // enable the privilege )) != STATUS_SUCCESS) { hr = HRESULT_FROM_WIN32(Status); goto L_Err; } if((Status=SetPrivilegeOnAccount( PolicyHandle, // policy handle pSid, // SID to grant privilege SE_DENY_INTERACTIVE_LOGON_NAME, // Unicode privilege TRUE // enable the privilege )) != STATUS_SUCCESS) { hr = HRESULT_FROM_WIN32(Status); goto L_Err; } } L_Err: // // Close the policy handle. // if(PolicyHandle != NULL) LsaClose(PolicyHandle); // // Free memory allocated for SID. // if(pSid != NULL) HeapFree(GetProcessHeap(), 0, pSid); return hr; #endif // LSA is not the right API } HRESULT VerifyAccount(LPCTSTR strDomain, LPCTSTR strAccount, LPCTSTR passwd, HWND hParent) { CString UserDN = _T("WinNT://"); CComPtr spADs; CComPtr spADsUser; CComPtr spCont; CComPtr spDisp; CWaitCursor wc; UserDN+=strDomain; UserDN+=_T("/"); UserDN+=strAccount; // this doesn't compile // UserDN.Replace(_T("\\"), _T("/")); // try to create the user account in DS, HRESULT hr = ADsOpenObject((LPTSTR)(LPCTSTR)UserDN, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_USE_SIGNING | ADS_USE_SEALING, IID_IADs, (void**)&spADs); // if no such object if ( hr != S_OK) { CString strDomainDN = _T("WinNT://"); strDomainDN += strDomain; CHECK_HR(hr = ADsOpenObject((LPTSTR)(LPCTSTR)strDomainDN, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_USE_SIGNING | ADS_USE_SEALING, IID_IADsContainer, (void**)&spCont)); // create the user CHECK_HR(hr = spCont->Create(L"user", (LPTSTR)(LPCTSTR)strAccount, &spDisp )); hr = spDisp->QueryInterface( IID_IADsUser, (void**) &spADsUser ); CHECK_HR(hr = spADsUser->SetInfo()); // Commit // set the password for the user try{ BSTR bstrPasswd = SysAllocString((LPTSTR)passwd); spADsUser->SetPassword(bstrPasswd); SysFreeString(bstrPasswd); // turn the interactive login off CString str = strDomain; str += _T("\\"); str += strAccount; hr = RemoveInteractiveLoginPrivilege(NULL, str); } catch(...) { hr = E_OUTOFMEMORY; } } L_ERR: if (FAILED(hr)) { if (IDYES == ReportErrorEx(hr,IDS_ERR_USERACCOUNT, hParent, MB_YESNO)) hr = S_OK; } return hr; } HRESULT InstallACSServer(LPCWSTR pMachineName, LPCWSTR strDomain, LPCWSTR strUser, LPCWSTR strPasswd, HWND hParent) { HRESULT hr = S_OK; ACSINSTALL_Func acsInstallFunc; HINSTANCE hAcsInstallDLL = NULL; CWaitCursor wc; hAcsInstallDLL = LoadLibrary(ACSINSTALLDLL); if ( NULL != hAcsInstallDLL ) { // load the API pointer acsInstallFunc = (ACSINSTALL_Func) GetProcAddress(hAcsInstallDLL, ACSINSTALL); if(acsInstallFunc == NULL) hr = HRESULT_FROM_WIN32(GetLastError()); else { DWORD dwErr; if(!acsInstallFunc((LPWSTR)pMachineName, (LPWSTR) strDomain, (LPWSTR)strUser, (LPWSTR)strPasswd, &dwErr)) hr = HRESULT_FROM_WIN32(dwErr); } FreeLibrary(hAcsInstallDLL); } else hr = HRESULT_FROM_WIN32(GetLastError()); return hr; } HRESULT UninstallACSServer(LPWSTR pMachineName, HWND hParent) { ACSUNINSTALL_Func acsUninstallFunc; HRESULT hr = S_OK; HINSTANCE hAcsInstallDLL = NULL; CWaitCursor wc; hAcsInstallDLL = LoadLibrary(ACSINSTALLDLL); if ( NULL != hAcsInstallDLL ) { // load the API pointer acsUninstallFunc = (ACSUNINSTALL_Func) GetProcAddress(hAcsInstallDLL, ACSUNINSTALL); if(acsUninstallFunc == NULL) hr = HRESULT_FROM_WIN32(GetLastError()); else { DWORD dwErr; if(!acsUninstallFunc(pMachineName, &dwErr)) hr = HRESULT_FROM_WIN32(dwErr); } FreeLibrary(hAcsInstallDLL); } else hr = HRESULT_FROM_WIN32(GetLastError()); return hr; } CPgServers::CPgServers(CACSSubnetConfig* pConfig) : CACSPage(CPgServers::IDD) { ASSERT(pConfig); m_spConfig = pConfig; DataInit(); } CPgServers::CPgServers() : CACSPage(CPgServers::IDD) { DataInit(); } void CPgServers::DataInit() { m_pServers = NULL; //{{AFX_DATA_INIT(CPgServers) // NOTE: the ClassWizard will add member initialization here //}}AFX_DATA_INIT } CPgServers::~CPgServers() { if(m_pServers) delete m_pServers; } void CPgServers::DoDataExchange(CDataExchange* pDX) { CACSPage::DoDataExchange(pDX); //{{AFX_DATA_MAP(CPgServers) // NOTE: the ClassWizard will add DDX and DDV calls here //}}AFX_DATA_MAP } BEGIN_MESSAGE_MAP(CPgServers, CACSPage) //{{AFX_MSG_MAP(CPgServers) ON_BN_CLICKED(IDC_SERVERS_ADD, OnServersAdd) ON_BN_CLICKED(IDC_SERVERS_INSTALL, OnServersInstall) ON_BN_CLICKED(IDC_SERVERS_REMOVE, OnServersRemove) //}}AFX_MSG_MAP END_MESSAGE_MAP() //+-------------------------------------------------------------------------- // // Function: InitObjectPickerForComputers // // Synopsis: Call IDsObjectPicker::Initialize with arguments that will // set it to allow the user to pick a single computer object. // // Arguments: [pDsObjectPicker] - object picker interface instance // // Returns: Result of calling IDsObjectPicker::Initialize. // // History: 10-14-1998 DavidMun Created // //--------------------------------------------------------------------------- HRESULT InitObjectPickerForComputers( IDsObjectPicker *pDsObjectPicker) { // // Prepare to initialize the object picker. // Set up the array of scope initializer structures. // static const int SCOPE_INIT_COUNT = 1; DSOP_SCOPE_INIT_INFO aScopeInit[SCOPE_INIT_COUNT]; ZeroMemory(aScopeInit, sizeof(DSOP_SCOPE_INIT_INFO) * SCOPE_INIT_COUNT); // // Since we just want computer objects from every scope, combine them // all in a single scope initializer. // aScopeInit[0].cbSize = sizeof(DSOP_SCOPE_INIT_INFO); aScopeInit[0].flType = DSOP_SCOPE_TYPE_UPLEVEL_JOINED_DOMAIN | DSOP_SCOPE_TYPE_DOWNLEVEL_JOINED_DOMAIN | DSOP_SCOPE_TYPE_ENTERPRISE_DOMAIN | DSOP_SCOPE_TYPE_GLOBAL_CATALOG | DSOP_SCOPE_TYPE_EXTERNAL_UPLEVEL_DOMAIN | DSOP_SCOPE_TYPE_EXTERNAL_DOWNLEVEL_DOMAIN | DSOP_SCOPE_TYPE_WORKGROUP | DSOP_SCOPE_TYPE_USER_ENTERED_UPLEVEL_SCOPE | DSOP_SCOPE_TYPE_USER_ENTERED_DOWNLEVEL_SCOPE; aScopeInit[0].FilterFlags.Uplevel.flBothModes = DSOP_FILTER_COMPUTERS; aScopeInit[0].FilterFlags.flDownlevel = DSOP_DOWNLEVEL_FILTER_COMPUTERS; // // Put the scope init array into the object picker init array // DSOP_INIT_INFO InitInfo; ZeroMemory(&InitInfo, sizeof(InitInfo)); InitInfo.cbSize = sizeof(InitInfo); InitInfo.pwzTargetComputer = NULL; // NULL == local machine InitInfo.cDsScopeInfos = SCOPE_INIT_COUNT; InitInfo.aDsScopeInfos = aScopeInit; InitInfo.flOptions = DSOP_FLAG_MULTISELECT; LPCTSTR attrs[] = {_T("dNSHostName"), _T("userAccountControl")}; InitInfo.cAttributesToFetch = 2; InitInfo.apwzAttributeNames = attrs; // // Note object picker makes its own copy of InitInfo. Also note // that Initialize may be called multiple times, last call wins. // return pDsObjectPicker->Initialize(&InitInfo); } #define BREAK_ON_FAIL_HRESULT(hr) \ if (FAILED(hr)) { printf("line %u err 0x%x\n", __LINE__, hr); break; } UINT g_cfDsObjectPicker = RegisterClipboardFormat(CFSTR_DSOP_DS_SELECTION_LIST); ///////////////////////////////////////////////////////////////////////////// // CPgServers message handlers void CPgServers::OnServersAdd() { bool bAddedNew = false; HRESULT hr = S_OK; IDsObjectPicker *pDsObjectPicker = NULL; IDataObject *pdo = NULL; hr = CoInitialize(NULL); if (FAILED(hr)) return; do { // // Create an instance of the object picker. The implementation in // objsel.dll is apartment model. // hr = CoCreateInstance(CLSID_DsObjectPicker, NULL, CLSCTX_INPROC_SERVER, IID_IDsObjectPicker, (void **) &pDsObjectPicker); BREAK_ON_FAIL_HRESULT(hr); // // Reinitialize the object picker to choose computers // hr = InitObjectPickerForComputers(pDsObjectPicker); if(FAILED(hr)) { TCHAR msg[1024]; FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, hr, 0, msg, 1024, NULL); } BREAK_ON_FAIL_HRESULT(hr); // // Now pick a computer // hr = pDsObjectPicker->InvokeDialog(this->GetSafeHwnd(), &pdo); BREAK_ON_FAIL_HRESULT(hr); if(hr == S_OK) // when user selected cancel, hr == S_FALSE, // ProcessSelectedObjects(pdo); { ASSERT(pdo); STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL, NULL }; FORMATETC formatetc = { (unsigned short)g_cfDsObjectPicker, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL }; bool fGotStgMedium = false; do { hr = pdo->GetData(&formatetc, &stgmedium); BREAK_ON_FAIL_HRESULT(hr); // user and password dialog CDlgPasswd dlg; fGotStgMedium = true; PDS_SELECTION_LIST pDsSelList = (PDS_SELECTION_LIST) GlobalLock(stgmedium.hGlobal); if (!pDsSelList) { printf("GlobalLock error %u\n", GetLastError()); break; } if(pDsSelList->cItems > 0) // some are selected { // user and password dialog if(dlg.DoModal() != IDOK) break; // the selected servers are not added // validate user's existence -- return other than OK, will not do anything if (S_OK != VerifyAccount(dlg.m_strDomain, ACSAccount, dlg.m_strPasswd, GetSafeHwnd())) break; } ULONG i; for (i = 0; i < pDsSelList->cItems; i++) { CString* pStr = NULL; BSTR bstrTemp; try{ if(pDsSelList->aDsSelection[i].pvarFetchedAttributes[0].vt == VT_EMPTY) { CString str; str.Format(IDS_ERR_DNSNAME, pDsSelList->aDsSelection[i].pwzName); AfxMessageBox(str, MB_OK); continue; } ASSERT(pDsSelList->aDsSelection[i].pvarFetchedAttributes[0].vt == VT_BSTR); bstrTemp = V_BSTR(&(pDsSelList->aDsSelection[i].pvarFetchedAttributes[0])); DSROLE_PRIMARY_DOMAIN_INFO_BASIC* pDsRole; DWORD dwErr = DsRoleGetPrimaryDomainInformation(bstrTemp, DsRolePrimaryDomainInfoBasic, (PBYTE *)&pDsRole); if(dwErr == NO_ERROR && (pDsRole->MachineRole == DsRole_RoleStandaloneWorkstation || pDsRole->MachineRole == DsRole_RoleMemberWorkstation)) { CString tempMsg; tempMsg.LoadString(IDS_ERR_NOT_SERVER); CString errMsg; errMsg.Format(tempMsg, bstrTemp); AfxMessageBox(errMsg); DsRoleFreeMemory((PVOID)pDsRole); pDsRole = NULL; continue; } else { if(pDsRole) { DsRoleFreeMemory((PVOID)pDsRole); pDsRole = NULL; } } // add to the list pStr = NULL; if(m_aServers.Find(bstrTemp) == -1 ) { HRESULT hr = S_OK; pStr = new CString(); *pStr = bstrTemp; bAddedNew = true; hr = InstallACSServer(V_BSTR(&(pDsSelList->aDsSelection[i].pvarFetchedAttributes[0])), dlg.m_strDomain, ACSAccount, dlg.m_strPasswd, GetSafeHwnd()); if( hr != S_OK) { CString Str; Str.LoadString(IDS_FAILED_INSTALL_ACSSERVER); CString strTemp1; strTemp1.LoadString(IDS_ADD_TO_LIST); CString strAskAdd1; strAskAdd1.Format(strTemp1, V_BSTR(&(pDsSelList->aDsSelection[i].pvarFetchedAttributes[0]))); CString strTemp2; strTemp2.LoadString(IDS_ASK_ADD_SERVER); CString strAskAdd2; strAskAdd2.Format(strTemp2, V_BSTR(&(pDsSelList->aDsSelection[i].pvarFetchedAttributes[0]))); Str += strAskAdd1; Str += strAskAdd2; UINT nAdd = IDNO; if(hr == REGDB_E_CLASSNOTREG) { CString strQosNotInstalled; strQosNotInstalled.LoadString(IDS_ERROR_QOS_NOTINSTALLED); CString strToDisplay; strToDisplay.Format(Str, strQosNotInstalled); nAdd = AfxMessageBox(strToDisplay, MB_YESNO); } else nAdd = ReportErrorEx(hr, Str, GetSafeHwnd(), MB_YESNO); if(IDYES != nAdd) continue; } m_pServers->AddString(pStr); // this will add the string to m_aServers array as well underneath } } catch(...) { delete pStr; pStr = NULL; } } GlobalUnlock(stgmedium.hGlobal); } while (0); if (fGotStgMedium) { ReleaseStgMedium(&stgmedium); } pdo->Release(); pdo = NULL; } } while (0); if (pDsObjectPicker) { pDsObjectPicker->Release(); } CoUninitialize(); if(bAddedNew) SetModified(); } void CPgServers::OnServersInstall() { int i = m_pServers->GetSelected(); // nothing selected if(i == LB_ERR) return; HRESULT hr = S_OK; CString* pStr = m_aServers.GetAt(i); ASSERT(pStr); // user and password dialog CDlgPasswd dlg; if(dlg.DoModal() != IDOK) return; // validate user's existence -- return other than OK, will not do anything if (S_OK != VerifyAccount(dlg.m_strDomain, ACSAccount, dlg.m_strPasswd, GetSafeHwnd())) return; USES_CONVERSION; InstallACSServer(T2W((LPTSTR)(LPCTSTR)*pStr), dlg.m_strDomain, ACSAccount, dlg.m_strPasswd, GetSafeHwnd()); } void CPgServers::OnServersRemove() { // TODO: Add your control notification handler code here int i = m_pServers->GetSelected(); if(i== LB_ERR) return; HRESULT hr = S_OK; CString* pStr = m_aServers.GetAt(i); ASSERT(pStr); USES_CONVERSION; int cId = AfxMessageBox(IDS_QUESTION_UNINSTALL_ACS, MB_YESNOCANCEL); if (cId == IDCANCEL) return; if (cId == IDYES) hr = UninstallACSServer(T2W((LPTSTR)(LPCTSTR)*pStr), GetSafeHwnd()); if( hr != S_OK) { CString ErrStr; ErrStr.LoadString(IDS_FAILED_UNINSTALL_ACSSERVER); CString Str; Str.Format(ErrStr, (LPCTSTR)*pStr); CString strBecause; Str += strBecause; ReportError(hr, Str, GetSafeHwnd()); } m_pServers->DeleteSelected(); SetModified(); } BOOL CPgServers::OnApply() { // logging level DWORD dwAttrFlags = ATTR_FLAGS_NONE; m_spConfig->SetFlags(ATTR_FLAG_SAVE, ACS_SCAF_SERVERLIST, true); m_spConfig->m_strArrayServerList = m_aServers; m_spConfig->SetFlags(ATTR_FLAG_SAVE, ACS_SCAF_SERVERLIST, m_aServers.GetSize() != 0); dwAttrFlags |= ACS_SCAF_SERVERLIST; AddFlags(dwAttrFlags); // prepare flags for saving return CACSPage::OnApply(); } BOOL CPgServers::OnInitDialog() { if(m_spConfig->GetFlags(ATTR_FLAG_LOAD, ACS_SCAF_SERVERLIST)) { m_aServers = m_spConfig->m_strArrayServerList; } m_pServers = new CStrBox(this, IDC_SERVERS_LIST, m_aServers); m_pServers->Fill(); CACSPage::OnInitDialog(); // TODO: Add extra initialization here return TRUE; // return TRUE unless you set the focus to a control // EXCEPTION: OCX Property Pages should return FALSE } ///////////////////////////////////////////////////////////////////////////// // CDlgPasswd dialog IMPLEMENT_DYNCREATE(CDlgPasswd, CACSDialog) CDlgPasswd::CDlgPasswd(CWnd* pParent /*=NULL*/) : CACSDialog(CDlgPasswd::IDD, pParent) { AFX_MANAGE_STATE(AfxGetStaticModuleState()); //{{AFX_DATA_INIT(CDlgPasswd) m_strPasswd = _T(""); m_strMachine = _T(""); m_strPasswd2 = _T(""); m_strDomain = _T(""); //}}AFX_DATA_INIT } void CDlgPasswd::DoDataExchange(CDataExchange* pDX) { CACSDialog::DoDataExchange(pDX); //{{AFX_DATA_MAP(CDlgPasswd) DDX_Text(pDX, IDC_USERPASSWD_PASSWD, m_strPasswd); DDX_Text(pDX, IDC_USERPASSWD_PASSWD2, m_strPasswd2); DDX_Text(pDX, IDC_USERPASSWD_DOMAIN, m_strDomain); //}}AFX_DATA_MAP } BEGIN_MESSAGE_MAP(CDlgPasswd, CACSDialog) //{{AFX_MSG_MAP(CDlgPasswd) //}}AFX_MSG_MAP END_MESSAGE_MAP() ///////////////////////////////////////////////////////////////////////////// // CDlgPasswd message handlers void CDlgPasswd::OnOK() { // TODO: Add extra validation here // user name should be in domain\user format // password and confirmed password must be exactly the same UpdateData(); // domain name field can not be empty m_strDomain.TrimLeft(); m_strDomain.TrimRight(); if (m_strDomain.IsEmpty()) { AfxMessageBox(IDS_EMPTY_DOMAIN); GotoDlgCtrl(GetDlgItem(IDC_USERPASSWD_DOMAIN)); return; } if (m_strPasswd.Compare(m_strPasswd2) != 0) // not the same { AfxMessageBox(IDS_PASSWORDMUSTBESAME); GotoDlgCtrl(GetDlgItem(IDC_USERPASSWD_PASSWD)); return; } CACSDialog::OnOK(); }