Version set to 1.0-beta6

(closes #20)

EAPMethods/locale/EAPMethods.pot

@@ -2,7 +2,7 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: EAPMethods\n"
-"POT-Creation-Date: 2016-09-19 10:58+0200\n"
+"POT-Creation-Date: 2016-09-20 11:05+0200\n"
 "PO-Revision-Date: 2016-06-02 12:27+0200\n"
 "Last-Translator: Simon Rozman <simon.rozman@amebis.si>\n"
 "Language-Team: Amebis, d. o. o., Kamnik <info@amebis.si>\n"
@@ -286,7 +286,7 @@ msgid "Acceptable Certificate Authorities:"
 msgstr ""
 
 #: lib/TLS_UI/res/wxTLS_UI.cpp:40
-msgid "List of certificate authorities server's certificate must be issued by"
+msgid "Server's certificate must be issued by one of certificate authorities listed here"
 msgstr ""
 
 #: lib/TLS_UI/res/wxTLS_UI.cpp:47
@@ -518,17 +518,21 @@ msgid "EAP Connection Configuration"
 msgstr ""
 
 #: EAPMethods/MSIBuild/en_US.Win32.Release.Feature-2.idtx:4
+#: EAPMethods/MSIBuild/en_US.x64.Release.Feature-2.idtx:4
 msgid "EAP Methods"
 msgstr ""
 
 #: EAPMethods/MSIBuild/en_US.Win32.Release.Feature-2.idtx:4
+#: EAPMethods/MSIBuild/en_US.x64.Release.Feature-2.idtx:4
 msgid "Modules to support individual EAP methods"
 msgstr ""
 
 #: EAPMethods/MSIBuild/en_US.Win32.Release.Feature-2.idtx:5
+#: EAPMethods/MSIBuild/en_US.x64.Release.Feature-2.idtx:5
 msgid "TTLS"
 msgstr ""
 
 #: EAPMethods/MSIBuild/en_US.Win32.Release.Feature-2.idtx:5
+#: EAPMethods/MSIBuild/en_US.x64.Release.Feature-2.idtx:5
 msgid "Tunneled Transport Layer Security"
 msgstr ""

EAPMethods/src/Main.cpp

@@ -755,7 +755,7 @@ DWORD WINAPI EapPeerCredentialsXml2Blob(
     else {
         // <Credentials>
         com_obj<IXMLDOMNode> pXmlElCredentials;
-        if (FAILED(eapxml::select_node(pCredentialsDoc, bstr(L"//EapHostUserCredentials/Credentials"), &pXmlElCredentials))) {
+        if (FAILED(eapxml::select_node(pCredentialsDoc, bstr(L"//EapHostUserCredentials/Credentials"), pXmlElCredentials))) {
             g_peer.log_error(*ppEapError = g_peer.make_error(dwResult = ERROR_NOT_FOUND, _T(__FUNCTION__) _T(" Error selecting <EapHostUserCredentials><Credentials> element.")));
             return dwResult;
         }

EAPMethods/src/Main_UI.cpp

@@ -133,7 +133,7 @@ DWORD WINAPI EapPeerConfigXml2Blob(
         // <Config>
         pConfigDoc->setProperty(bstr(L"SelectionNamespaces"), variant(L"xmlns:eaphostconfig=\"http://www.microsoft.com/provisioning/EapHostConfig\""));
         com_obj<IXMLDOMElement> pXmlElConfig;
-        if (FAILED(eapxml::select_element(pConfigDoc, bstr(L"//eaphostconfig:Config"), &pXmlElConfig))) {
+        if (FAILED(eapxml::select_element(pConfigDoc, bstr(L"//eaphostconfig:Config"), pXmlElConfig))) {
             g_peer.log_error(*ppEapError = g_peer.make_error(dwResult = ERROR_INVALID_PARAMETER, _T(__FUNCTION__) _T(" Error reading <Config> element.")));
             return dwResult;
         }
@@ -215,7 +215,7 @@ DWORD WINAPI EapPeerConfigBlob2Xml(
         // Select <Config> node.
         com_obj<IXMLDOMNode> pXmlElConfig;
         pConfigDoc->setProperty(bstr(L"SelectionNamespaces"), variant(L"xmlns:eaphostconfig=\"http://www.microsoft.com/provisioning/EapHostConfig\""));
-        if (FAILED(eapxml::select_node(pConfigDoc, bstr(L"eaphostconfig:Config"), &pXmlElConfig))) {
+        if (FAILED(eapxml::select_node(pConfigDoc, bstr(L"eaphostconfig:Config"), pXmlElConfig))) {
             g_peer.log_error(*ppEapError = g_peer.make_error(dwResult = ERROR_NOT_FOUND, _T(__FUNCTION__) _T(" Error selecting <Config> element.")));
             return dwResult;
         }

include/Version.h

@@ -29,7 +29,7 @@
 // Product version as a single DWORD
 // Note: Used for version comparison within C/C++ code.
 //
-#define PRODUCT_VERSION          0x00ff1600
+#define PRODUCT_VERSION          0x00ff1800
 
 //
 // Product version by components
@@ -39,26 +39,26 @@
 //
 #define PRODUCT_VERSION_MAJ      0
 #define PRODUCT_VERSION_MIN      255
-#define PRODUCT_VERSION_REV      22
+#define PRODUCT_VERSION_REV      24
 #define PRODUCT_VERSION_BUILD    0
 
 //
 // Human readable product version and build year for UI
 //
-#define PRODUCT_VERSION_STR      "1.0-beta4"
+#define PRODUCT_VERSION_STR      "1.0-beta6"
 #define PRODUCT_BUILD_YEAR_STR   "2016"
 
 //
 // Numerical version presentation for ProductVersion propery in
 // MSI packages (syntax: N.N[.N[.N]])
 //
-#define PRODUCT_VERSION_INST     "0.255.22"
+#define PRODUCT_VERSION_INST     "0.255.24"
 
 //
 // The product code for ProductCode property in MSI packages
 // Replace with new on every version change, regardless how minor it is.
 //
-#define PRODUCT_VERSION_GUID     "{05C95614-D6B8-4C0E-A42E-D1954FD73577}"
+#define PRODUCT_VERSION_GUID     "{68407777-8DFF-49BF-9687-0A8DA406AA34}"
 
 //
 // Product vendor

lib/EAPBase/include/Config.h

@@ -358,8 +358,8 @@ namespace eap
 
     public:
         bool m_allow_save;                                  ///< Are credentials allowed to be saved to Windows Credential Manager?
-        bool m_use_preshared;                               ///< Use pre-shared credentials
-        std::unique_ptr<credentials> m_preshared;           ///< Pre-shared credentials
+        bool m_use_cred;                                    ///< Use configured credentials
+        std::unique_ptr<credentials> m_cred;                ///< Configured credentials
 
         enum status {
             status_success = 0,                             ///< Authentication succeeded

lib/EAPBase/include/Credentials.h

@@ -67,7 +67,7 @@ namespace eap
         enum source_t {
             source_unknown = -1, ///< Unknown source
             source_cache = 0,    ///< Credentials were obtained from EapHost cache
-            source_preshared,    ///< Credentials were set by method configuration
+            source_config,       ///< Credentials were set by method configuration
             source_storage       ///< Credentials were loaded from Windows Credential Manager
         };
 
@@ -247,9 +247,9 @@ namespace eap
         /// \param[in] pszTargetName  The name in Windows Credential Manager to retrieve credentials from (optional, can be \c NULL)
         ///
         /// \returns
-        /// - \c source_cache      Credentials were obtained from EapHost cache
-        /// - \c source_preshared  Credentials were set by method configuration
-        /// - \c source_storage    Credentials were loaded from Windows Credential Manager
+        /// - \c source_cache   Credentials were obtained from EapHost cache
+        /// - \c source_config  Credentials were set by method configuration
+        /// - \c source_storage Credentials were loaded from Windows Credential Manager
         ///
         virtual source_t combine(
             _In_       const credentials             *cred_cached,
@@ -408,9 +408,9 @@ namespace eap
         /// \param[in] pszTargetName  The name in Windows Credential Manager to retrieve credentials from (optional, can be \c NULL)
         ///
         /// \returns
-        /// - \c source_cache      Credentials were obtained from EapHost cache
-        /// - \c source_preshared  Credentials were set by method configuration
-        /// - \c source_storage    Credentials were loaded from Windows Credential Manager
+        /// - \c source_cache   Credentials were obtained from EapHost cache
+        /// - \c source_config  Credentials were set by method configuration
+        /// - \c source_storage Credentials were loaded from Windows Credential Manager
         ///
         virtual source_t combine(
             _In_       const credentials             *cred_cached,

lib/EAPBase/include/EAPXML.h

@@ -18,6 +18,8 @@
     along with GÉANTLink. If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <WinStd/COM.h>
+
 #include <MsXml.h>
 #include <msxml6.h>
 #include <sal.h>
@@ -27,31 +29,31 @@
 
 namespace eapxml
 {
-    inline HRESULT get_document(_In_ IXMLDOMNode *pXmlNode, _Out_ IXMLDOMDocument2 **ppXmlDoc);
-    inline HRESULT select_node(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrNodeName, _Out_ IXMLDOMNode **ppXmlNode);
-    inline HRESULT select_nodes(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrNodeName, _Out_ IXMLDOMNodeList **ppXmlNodes);
-    inline HRESULT select_element(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ IXMLDOMElement **ppXmlElement);
-    inline HRESULT create_element(_In_ IXMLDOMDocument *pDoc, _In_z_ const BSTR bstrElementName, _In_z_ const BSTR bstrNamespace, _Out_ IXMLDOMElement **ppXmlElement);
-    inline HRESULT create_element(_In_ IXMLDOMDocument *pDoc, IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementNameSelect, _In_z_ const BSTR bstrElementNameCreate, _In_z_ const BSTR bstrNamespace, _Out_ IXMLDOMElement **ppXmlElement);
+    inline HRESULT get_document(_In_ IXMLDOMNode *pXmlNode, _Out_ winstd::com_obj<IXMLDOMDocument2> &ppXmlDoc);
+    inline HRESULT select_node(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrNodeName, _Out_ winstd::com_obj<IXMLDOMNode> &ppXmlNode);
+    inline HRESULT select_nodes(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrNodeName, _Out_ winstd::com_obj<IXMLDOMNodeList> &ppXmlNodes);
+    inline HRESULT select_element(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ winstd::com_obj<IXMLDOMElement> &ppXmlElement);
+    inline HRESULT create_element(_In_ IXMLDOMDocument *pDoc, _In_z_ const BSTR bstrElementName, _In_z_ const BSTR bstrNamespace, _Out_ winstd::com_obj<IXMLDOMElement> &ppXmlElement);
+    inline HRESULT create_element(_In_ IXMLDOMDocument *pDoc, IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementNameSelect, _In_z_ const BSTR bstrElementNameCreate, _In_z_ const BSTR bstrNamespace, _Out_ winstd::com_obj<IXMLDOMElement> &ppXmlElement);
     inline bool has_parent(_In_ IXMLDOMNode *pXmlNode);
-    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ BSTR *pbstrValue);
-    template<class _Traits, class _Ax> inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sValue);
-    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ DWORD *pdwValue);
-    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ bool *pbValue);
-    template<class _Ty, class _Ax> inline HRESULT get_element_base64(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::vector<_Ty, _Ax> &aValue);
-    template<class _Ty, class _Ax> inline HRESULT get_element_hex(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::vector<_Ty, _Ax> &aValue);
-    inline HRESULT get_element_localized(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _In_z_ LPCWSTR pszLang, _Out_ BSTR *pbstrValue);
-    template<class _Traits, class _Ax> inline HRESULT get_element_localized(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _In_z_ LPCWSTR pszLang, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sValue);
-    inline HRESULT put_element(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _Out_ IXMLDOMElement **ppXmlElement);
-    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_z_ const BSTR bstrValue);
-    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_ DWORD dwValue);
-    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_ bool bValue);
-    inline HRESULT put_element_base64(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_count_(nValueLen) LPCVOID pValue, _In_ SIZE_T nValueLen);
-    inline HRESULT put_element_hex(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_count_(nValueLen) LPCVOID pValue, _In_ SIZE_T nValueLen);
-    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ BSTR *pbstrValue);
+    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ winstd::bstr &pbstrValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    template<class _Traits, class _Ax> inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ DWORD &pdwValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ bool &pbValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    template<class _Ty, class _Ax> inline HRESULT get_element_base64(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::vector<_Ty, _Ax> &aValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    template<class _Ty, class _Ax> inline HRESULT get_element_hex(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::vector<_Ty, _Ax> &aValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    inline HRESULT get_element_localized(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _In_z_ LPCWSTR pszLang, _Out_ winstd::bstr &pbstrValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    template<class _Traits, class _Ax> inline HRESULT get_element_localized(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _In_z_ LPCWSTR pszLang, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    inline HRESULT put_element(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _Out_ winstd::com_obj<IXMLDOMElement> &ppXmlElement);
+    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_z_ const BSTR bstrValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_ DWORD dwValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_ bool bValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    inline HRESULT put_element_base64(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_count_(nValueLen) LPCVOID pValue, _In_ SIZE_T nValueLen, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    inline HRESULT put_element_hex(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_count_(nValueLen) LPCVOID pValue, _In_ SIZE_T nValueLen, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement = NULL);
+    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ winstd::bstr &pbstrValue);
     template<class _Traits, class _Ax> inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sValue);
-    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ DWORD *pdwValue);
-    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ bool *pbValue);
+    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ DWORD &pdwValue);
+    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ bool &pbValue);
     template<class _Ty, class _Ax> inline HRESULT get_attrib_base64(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ std::vector<_Ty, _Ax> &aValue);
     template<class _Ty, class _Ax> inline HRESULT get_attrib_hex(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ std::vector<_Ty, _Ax> &aValue);
     inline HRESULT put_attrib_value(_In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrAttributeName, _In_opt_z_ _In_z_ const BSTR bstrValue);
@@ -65,7 +67,6 @@ namespace eapxml
 #pragma once
 
 #include <WinStd/Base64.h>
-#include <WinStd/COM.h>
 #include <WinStd/Hex.h>
 
 #include <assert.h>
@@ -73,10 +74,9 @@ namespace eapxml
 
 namespace eapxml
 {
-    inline HRESULT get_document(_In_ IXMLDOMNode *pXmlNode, _Out_ IXMLDOMDocument2 **ppXmlDoc)
+    inline HRESULT get_document(_In_ IXMLDOMNode *pXmlNode, _Out_ winstd::com_obj<IXMLDOMDocument2> &ppXmlDoc)
     {
         assert(pXmlNode);
-        assert(ppXmlDoc);
 
         HRESULT hr;
         winstd::com_obj<IXMLDOMDocument> doc;
@@ -87,50 +87,51 @@ namespace eapxml
     }
 
 
-    inline HRESULT select_node(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrNodeName, _Out_ IXMLDOMNode **ppXmlNode)
+    inline HRESULT select_node(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrNodeName, _Out_ winstd::com_obj<IXMLDOMNode> &ppXmlNode)
     {
         assert(pXmlParent);
-        assert(ppXmlNode);
 
         HRESULT hr;
+        IXMLDOMNode *pXmlNode;
 
-        return
-            SUCCEEDED(hr = pXmlParent->selectSingleNode(bstrNodeName, ppXmlNode)) ?
-            *ppXmlNode ? S_OK : E_NOT_SET : hr;
+        if (SUCCEEDED(hr = pXmlParent->selectSingleNode(bstrNodeName, &pXmlNode))) {
+            ppXmlNode.attach(pXmlNode);
+            return pXmlNode ? S_OK : E_NOT_SET;
+        } else
+            return hr;
     }
 
 
-    inline HRESULT select_nodes(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrNodeName, _Out_ IXMLDOMNodeList **ppXmlNodes)
+    inline HRESULT select_nodes(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrNodeName, _Out_ winstd::com_obj<IXMLDOMNodeList> &ppXmlNodes)
     {
         assert(pXmlParent);
-        assert(ppXmlNodes);
 
         HRESULT hr;
+        IXMLDOMNodeList *pXmlNodes;
 
-        return
-            SUCCEEDED(hr = pXmlParent->selectNodes(bstrNodeName, ppXmlNodes)) ?
-            *ppXmlNodes ? S_OK : E_NOT_SET : hr;
+        if (SUCCEEDED(hr = pXmlParent->selectNodes(bstrNodeName, &pXmlNodes))) {
+            ppXmlNodes.attach(pXmlNodes);
+            return pXmlNodes ? S_OK : E_NOT_SET;
+        } else
+            return hr;
     }
 
 
-    inline HRESULT select_element(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ IXMLDOMElement **ppXmlElement)
+    inline HRESULT select_element(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ winstd::com_obj<IXMLDOMElement> &ppXmlElement)
     {
-        assert(ppXmlElement);
-
         HRESULT hr;
         winstd::com_obj<IXMLDOMNode> pXmlNode;
 
         return
-            SUCCEEDED(hr = select_node(pXmlParent, bstrElementName, &pXmlNode)) ?
+            SUCCEEDED(hr = select_node(pXmlParent, bstrElementName, pXmlNode)) ?
             SUCCEEDED(hr = pXmlNode.query_interface(ppXmlElement)) ?
-            *ppXmlElement ? S_OK : E_NOT_SET : hr : hr;
+            ppXmlElement ? S_OK : E_NOT_SET : hr : hr;
     }
 
 
-    inline HRESULT create_element(_In_ IXMLDOMDocument *pDoc, _In_z_ const BSTR bstrElementName, _In_z_ const BSTR bstrNamespace, _Out_ IXMLDOMElement **ppXmlElement)
+    inline HRESULT create_element(_In_ IXMLDOMDocument *pDoc, _In_z_ const BSTR bstrElementName, _In_z_ const BSTR bstrNamespace, _Out_ winstd::com_obj<IXMLDOMElement> &ppXmlElement)
     {
         assert(pDoc);
-        assert(ppXmlElement);
 
         static const winstd::variant varNodeTypeEl(NODE_ELEMENT);
         HRESULT hr;
@@ -139,22 +140,21 @@ namespace eapxml
         return
             SUCCEEDED(hr = pDoc->createNode(varNodeTypeEl, bstrElementName, bstrNamespace, &pXmlNode)) ?
             SUCCEEDED(hr = pXmlNode.query_interface(ppXmlElement)) ?
-            *ppXmlElement ? S_OK : E_NOT_SET : hr : hr;
+            ppXmlElement ? S_OK : E_NOT_SET : hr : hr;
     }
 
 
-    inline HRESULT create_element(_In_ IXMLDOMDocument *pDoc, IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementNameSelect, _In_z_ const BSTR bstrElementNameCreate, _In_z_ const BSTR bstrNamespace, _Out_ IXMLDOMElement **ppXmlElement)
+    inline HRESULT create_element(_In_ IXMLDOMDocument *pDoc, IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementNameSelect, _In_z_ const BSTR bstrElementNameCreate, _In_z_ const BSTR bstrNamespace, _Out_ winstd::com_obj<IXMLDOMElement> &ppXmlElement)
     {
         assert(pDoc);
         assert(pXmlParent);
-        assert(ppXmlElement);
 
         HRESULT hr;
 
         return
             SUCCEEDED(hr = select_element(pXmlParent, bstrElementNameSelect, ppXmlElement)) ? S_OK :
             SUCCEEDED(hr = create_element(pDoc, bstrElementNameCreate, bstrNamespace, ppXmlElement)) ?
-            SUCCEEDED(hr = pXmlParent->appendChild(*ppXmlElement, NULL)) ? S_OK : hr : hr;
+            SUCCEEDED(hr = pXmlParent->appendChild(ppXmlElement, NULL)) ? S_OK : hr : hr;
     }
 
 
@@ -168,57 +168,57 @@ namespace eapxml
     }
 
 
-    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ BSTR *pbstrValue)
+    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ winstd::bstr &pbstrValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
-        assert(pbstrValue);
-
         HRESULT hr;
         winstd::com_obj<IXMLDOMElement> pXmlElement;
+        BSTR bstrValue;
 
-        return
-            SUCCEEDED(hr = select_element(pXmlParent, bstrElementName, &pXmlElement)) ?
-            SUCCEEDED(hr = pXmlElement->get_text(pbstrValue)) ?
-            *pbstrValue ? S_OK : E_NOT_SET : hr : hr;
+        if (SUCCEEDED(hr = select_element(pXmlParent, bstrElementName, pXmlElement)) &&
+            SUCCEEDED(hr = pXmlElement->get_text(&bstrValue)))
+        {
+            pbstrValue.attach(bstrValue);
+            if (ppXmlElement)
+                *ppXmlElement = std::move(pXmlElement);
+            return bstrValue ? S_OK : E_NOT_SET;
+        } else
+            return hr;
     }
 
 
     template<class _Traits, class _Ax>
-    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sValue)
+    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
         winstd::bstr bstr;
-        HRESULT hr = get_element_value(pXmlParent, bstrElementName, &bstr);
+        HRESULT hr = get_element_value(pXmlParent, bstrElementName, bstr, ppXmlElement);
         if (SUCCEEDED(hr))
             sValue.assign(bstr, bstr.length());
         return hr;
     }
 
 
-    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ DWORD *pdwValue)
+    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ DWORD &pdwValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
-        assert(pdwValue);
-
         winstd::bstr bstr;
-        HRESULT hr = get_element_value(pXmlParent, bstrElementName, &bstr);
+        HRESULT hr = get_element_value(pXmlParent, bstrElementName, bstr, ppXmlElement);
         if (SUCCEEDED(hr))
-            *pdwValue = wcstoul(bstr, NULL, 10);
+            pdwValue = wcstoul(bstr, NULL, 10);
         return hr;
     }
 
 
-    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ bool *pbValue)
+    inline HRESULT get_element_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ bool &pbValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
-        assert(pbValue);
-
         winstd::bstr bstr;
-        HRESULT hr = get_element_value(pXmlParent, bstrElementName, &bstr);
+        HRESULT hr = get_element_value(pXmlParent, bstrElementName, bstr, ppXmlElement);
         if (SUCCEEDED(hr)) {
             if (CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstr, bstr.length(), L"true" , -1, NULL, NULL, 0) == CSTR_EQUAL ||
                 CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstr, bstr.length(), L"1"    , -1, NULL, NULL, 0) == CSTR_EQUAL)
-                *pbValue = true;
+                pbValue = true;
             else if (
                 CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstr, bstr.length(), L"false", -1, NULL, NULL, 0) == CSTR_EQUAL ||
                 CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstr, bstr.length(), L"0"    , -1, NULL, NULL, 0) == CSTR_EQUAL)
-                *pbValue = false;
+                pbValue = false;
             else
                 hr = E_NOT_VALID_STATE;
         }
@@ -228,10 +228,10 @@ namespace eapxml
 
 
     template<class _Ty, class _Ax>
-    inline HRESULT get_element_base64(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::vector<_Ty, _Ax> &aValue)
+    inline HRESULT get_element_base64(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::vector<_Ty, _Ax> &aValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
         winstd::bstr bstr;
-        HRESULT hr = get_element_value(pXmlParent, bstrElementName, &bstr);
+        HRESULT hr = get_element_value(pXmlParent, bstrElementName, bstr, ppXmlElement);
         if (SUCCEEDED(hr)) {
             winstd::base64_dec dec;
             bool is_last;
@@ -243,10 +243,10 @@ namespace eapxml
 
 
     template<class _Ty, class _Ax>
-    inline HRESULT get_element_hex(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::vector<_Ty, _Ax> &aValue)
+    inline HRESULT get_element_hex(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _Out_ std::vector<_Ty, _Ax> &aValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
         winstd::bstr bstr;
-        HRESULT hr = get_element_value(pXmlParent, bstrElementName, &bstr);
+        HRESULT hr = get_element_value(pXmlParent, bstrElementName, bstr, ppXmlElement);
         if (SUCCEEDED(hr)) {
             winstd::hex_dec dec;
             bool is_last;
@@ -257,25 +257,29 @@ namespace eapxml
     }
 
 
-    inline HRESULT get_element_localized(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _In_z_ LPCWSTR pszLang, _Out_ BSTR *pbstrValue)
+    inline HRESULT get_element_localized(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _In_z_ LPCWSTR pszLang, _Out_ winstd::bstr &pbstrValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
-        assert(pbstrValue);
-
         HRESULT hr;
         winstd::com_obj<IXMLDOMElement> pXmlElement;
 
-        if (FAILED(hr = select_element(pXmlParent, bstrElementName, &pXmlElement)))
+        if (FAILED(hr = select_element(pXmlParent, bstrElementName, pXmlElement)))
             return hr;
 
+        if (ppXmlElement)
+            *ppXmlElement = pXmlElement;
+
         winstd::com_obj<IXMLDOMNodeList> pXmlListLocalizedText;
         long lCount = 0;
-        if (FAILED(select_nodes(pXmlElement, winstd::bstr(L"eap-metadata:localized-text"), &pXmlListLocalizedText)) ||
+        if (FAILED(select_nodes(pXmlElement, winstd::bstr(L"eap-metadata:localized-text"), pXmlListLocalizedText)) ||
             FAILED(pXmlListLocalizedText->get_length(&lCount)) ||
             lCount <= 0)
         {
-            return
-                SUCCEEDED(hr = pXmlElement->get_text(pbstrValue)) ?
-                *pbstrValue ? S_OK : E_NOT_SET : hr;
+            BSTR bstr;
+            if (SUCCEEDED(hr = pXmlElement->get_text(&bstr))) {
+                pbstrValue.attach(bstr);
+                return bstr ? S_OK : E_NOT_SET;
+            } else
+                return hr;
         }
 
         winstd::bstr bstrDefault, bstrEn;
@@ -283,11 +287,11 @@ namespace eapxml
             if (i >= lCount) {
                 if (bstrDefault != NULL) {
                     // Return "C" localization.
-                    *pbstrValue = bstrDefault.detach();
+                    pbstrValue = std::move(bstrDefault);
                     return S_OK;
                 } else if (bstrEn != NULL) {
                     // Return "en" localization.
-                    *pbstrValue = bstrEn.detach();
+                    pbstrValue = std::move(bstrEn);
                     return S_OK;
                 } else
                     return ERROR_NOT_FOUND;
@@ -299,21 +303,21 @@ namespace eapxml
             {
                 // Read <lang>.
                 winstd::bstr bstrLang;
-                if (FAILED(get_element_value(pXmlElLocalizedText, winstd::bstr(L"eap-metadata:lang"), &bstrLang)) ||
+                if (FAILED(get_element_value(pXmlElLocalizedText, winstd::bstr(L"eap-metadata:lang"), bstrLang)) ||
                     CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstrLang, bstrLang.length(), L"C" , -1, NULL, NULL, 0) == CSTR_EQUAL)
                 {
                     // <lang> is missing or "C" language found.
                     winstd::bstr bstr;
-                    if (SUCCEEDED(hr = get_element_value(pXmlElLocalizedText, winstd::bstr(L"eap-metadata:text"), &bstr)))
-                        bstrDefault.attach(bstr.detach());
+                    if (SUCCEEDED(hr = get_element_value(pXmlElLocalizedText, winstd::bstr(L"eap-metadata:text"), bstr)))
+                        bstrDefault = std::move(bstr);
                 } else if (CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstrLang, bstrLang.length(), pszLang, -1, NULL, NULL, 0) == CSTR_EQUAL) {
                     // Found an exact match.
                     return get_element_value(pXmlElLocalizedText, winstd::bstr(L"eap-metadata:text"), pbstrValue);
                 } else if (CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstrLang, bstrLang.length(), L"en", -1, NULL, NULL, 0) == CSTR_EQUAL) {
                     // "en" language found.
                     winstd::bstr bstr;
-                    if (SUCCEEDED(hr = get_element_value(pXmlElLocalizedText, winstd::bstr(L"eap-metadata:text"), &bstr)))
-                        bstrEn.attach(bstr.detach());
+                    if (SUCCEEDED(hr = get_element_value(pXmlElLocalizedText, winstd::bstr(L"eap-metadata:text"), bstr)))
+                        bstrEn = std::move(bstr);
                 }
             }
         }
@@ -321,17 +325,17 @@ namespace eapxml
 
 
     template<class _Traits, class _Ax>
-    inline HRESULT get_element_localized(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _In_z_ LPCWSTR pszLang, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sValue)
+    inline HRESULT get_element_localized(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrElementName, _In_z_ LPCWSTR pszLang, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
         winstd::bstr bstr;
-        HRESULT hr = get_element_localized(pXmlParent, bstrElementName, pszLang, &bstr);
+        HRESULT hr = get_element_localized(pXmlParent, bstrElementName, pszLang, bstr, ppXmlElement);
         if (SUCCEEDED(hr))
             sValue.assign(bstr, bstr.length());
         return hr;
     }
 
 
-    inline HRESULT put_element(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _Out_ IXMLDOMElement **ppXmlElement)
+    inline HRESULT put_element(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _Out_ winstd::com_obj<IXMLDOMElement> &ppXmlElement)
     {
         assert(pDoc);
         assert(pCurrentDOMNode);
@@ -348,7 +352,7 @@ namespace eapxml
     }
 
 
-    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_z_ const BSTR bstrValue)
+    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_z_ const BSTR bstrValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
         assert(pDoc);
 
@@ -357,48 +361,51 @@ namespace eapxml
         winstd::com_obj<IXMLDOMNode> pXmlEl;
         winstd::com_obj<IXMLDOMText> pXmlElText;
 
-        return
-            SUCCEEDED(hr = pDoc->createNode(varNodeTypeEl, bstrElementName, bstrNamespace, &pXmlEl)) &&
+        if (SUCCEEDED(hr = pDoc->createNode(varNodeTypeEl, bstrElementName, bstrNamespace, &pXmlEl)) &&
             SUCCEEDED(hr = pDoc->createTextNode(bstrValue, &pXmlElText)) &&
             SUCCEEDED(hr = pXmlEl->appendChild(pXmlElText, NULL)) &&
-            SUCCEEDED(hr = pCurrentDOMNode->appendChild(pXmlEl, NULL)) ? S_OK : hr;
+            SUCCEEDED(hr = pCurrentDOMNode->appendChild(pXmlEl, NULL)))
+        {
+            if (ppXmlElement)
+                pXmlEl.query_interface(*ppXmlElement);
+            return S_OK;
+        } else
+            return hr;
     }
 
 
-    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_ DWORD dwValue)
+    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_ DWORD dwValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
-        return put_element_value(pDoc, pCurrentDOMNode, bstrElementName, bstrNamespace, winstd::bstr(winstd::wstring_printf(L"%d", dwValue)));
+        return put_element_value(pDoc, pCurrentDOMNode, bstrElementName, bstrNamespace, winstd::bstr(winstd::wstring_printf(L"%d", dwValue)), ppXmlElement);
     }
 
 
-    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_ bool bValue)
+    inline HRESULT put_element_value(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_ bool bValue, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
-        return put_element_value(pDoc, pCurrentDOMNode, bstrElementName, bstrNamespace, winstd::bstr(bValue ? L"true": L"false"));
+        return put_element_value(pDoc, pCurrentDOMNode, bstrElementName, bstrNamespace, winstd::bstr(bValue ? L"true": L"false"), ppXmlElement);
     }
 
 
-    inline HRESULT put_element_base64(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_count_(nValueLen) LPCVOID pValue, _In_ SIZE_T nValueLen)
+    inline HRESULT put_element_base64(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_count_(nValueLen) LPCVOID pValue, _In_ SIZE_T nValueLen, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
         std::wstring sBase64;
         winstd::base64_enc enc;
         enc.encode(sBase64, pValue, nValueLen);
-        return put_element_value(pDoc, pCurrentDOMNode, bstrElementName, bstrNamespace, winstd::bstr(sBase64));
+        return put_element_value(pDoc, pCurrentDOMNode, bstrElementName, bstrNamespace, winstd::bstr(sBase64), ppXmlElement);
     }
 
 
-    inline HRESULT put_element_hex(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_count_(nValueLen) LPCVOID pValue, _In_ SIZE_T nValueLen)
+    inline HRESULT put_element_hex(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pCurrentDOMNode, _In_z_ const BSTR bstrElementName, _In_opt_z_ const BSTR bstrNamespace, _In_count_(nValueLen) LPCVOID pValue, _In_ SIZE_T nValueLen, _Out_opt_ winstd::com_obj<IXMLDOMElement> *ppXmlElement)
     {
         std::wstring sHex;
         winstd::hex_enc enc;
         enc.encode(sHex, pValue, nValueLen);
-        return put_element_value(pDoc, pCurrentDOMNode, bstrElementName, bstrNamespace, winstd::bstr(sHex));
+        return put_element_value(pDoc, pCurrentDOMNode, bstrElementName, bstrNamespace, winstd::bstr(sHex), ppXmlElement);
     }
 
 
-    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ BSTR *pbstrValue)
+    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ winstd::bstr &pbstrValue)
     {
-        assert(pbstrValue);
-
         HRESULT hr;
         winstd::com_obj<IXMLDOMNamedNodeMap> pXmlAttributes;
         winstd::com_obj<IXMLDOMNode> pXmlAt;
@@ -406,11 +413,11 @@ namespace eapxml
         V_VT(&varValue) = VT_EMPTY;
 
         return
-            SUCCEEDED(hr = pXmlParent->get_attributes(&pXmlAttributes)) ?
+            SUCCEEDED(hr = pXmlParent->get_attributes(&pXmlAttributes)) &&
             SUCCEEDED(hr = pXmlAttributes->getNamedItem(bstrAttributeName, &pXmlAt)) ?
             pXmlAt ?
             SUCCEEDED(hr = pXmlAt->get_nodeValue(&varValue)) ?
-            V_VT(&varValue) == VT_BSTR ? *pbstrValue = V_BSTR(&varValue), S_OK : E_UNEXPECTED : hr : E_NOT_SET : hr : hr;
+            V_VT(&varValue) == VT_BSTR ? pbstrValue.attach(V_BSTR(&varValue)), V_VT(&varValue) = VT_EMPTY, S_OK : E_UNEXPECTED : hr : E_NOT_SET : hr;
     }
 
 
@@ -418,39 +425,37 @@ namespace eapxml
     inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ std::basic_string<wchar_t, _Traits, _Ax> &sValue)
     {
         winstd::bstr bstr;
-        HRESULT hr = get_attrib_value(pXmlParent, bstrAttributeName, &bstr);
+        HRESULT hr = get_attrib_value(pXmlParent, bstrAttributeName, bstr);
         if (SUCCEEDED(hr))
             sValue.assign(bstr, bstr.length());
         return hr;
     }
 
 
-    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ DWORD *pdwValue)
+    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ DWORD &pdwValue)
     {
-        assert(pdwValue);
-
         winstd::bstr bstr;
-        HRESULT hr = get_attrib_value(pXmlParent, bstrAttributeName, &bstr);
+        HRESULT hr = get_attrib_value(pXmlParent, bstrAttributeName, bstr);
         if (SUCCEEDED(hr))
-            *pdwValue = wcstoul(bstr, NULL, 10);
+            pdwValue = wcstoul(bstr, NULL, 10);
         return hr;
     }
 
 
-    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ bool *pbValue)
+    inline HRESULT get_attrib_value(_In_ IXMLDOMNode *pXmlParent, _In_z_ const BSTR bstrAttributeName, _Out_ bool &pbValue)
     {
         assert(pbValue);
 
         winstd::bstr bstr;
-        HRESULT hr = get_attrib_value(pXmlParent, bstrAttributeName, &bstr);
+        HRESULT hr = get_attrib_value(pXmlParent, bstrAttributeName, bstr);
         if (SUCCEEDED(hr)) {
             if (CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstr, bstr.length(), L"true" , -1, NULL, NULL, 0) == CSTR_EQUAL ||
                 CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstr, bstr.length(), L"1"    , -1, NULL, NULL, 0) == CSTR_EQUAL)
-                *pbValue = true;
+                pbValue = true;
             else if (
                 CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstr, bstr.length(), L"false", -1, NULL, NULL, 0) == CSTR_EQUAL ||
                 CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstr, bstr.length(), L"0"    , -1, NULL, NULL, 0) == CSTR_EQUAL)
-                *pbValue = false;
+                pbValue = false;
             else
                 hr = E_NOT_VALID_STATE;
         }

lib/EAPBase/include/Method.h

@@ -51,6 +51,8 @@ namespace eap
 {
     class method
     {
+        WINSTD_NONCOPYABLE(method)
+
     public:
         ///
         /// Constructs an EAP method
@@ -128,11 +130,6 @@ namespace eap
 
         /// @}
 
-    private:
-        // This class is noncopyable.
-        method(_In_ const method &other);
-        method& operator=(_In_ const method &other);
-
     public:
         module &m_module;                           ///< EAP module
         config_method_with_cred &m_cfg;             ///< Connection configuration
@@ -143,6 +140,8 @@ namespace eap
 
     class method_noneap : public method
     {
+        WINSTD_NONCOPYABLE(method_noneap)
+
     public:
         ///
         /// Constructs an EAP method

lib/EAPBase/include/Module.h

@@ -60,6 +60,8 @@ namespace eap
 {
     class module
     {
+        WINSTD_NONCOPYABLE(module)
+
     public:
         ///
         /// Constructs a module for the given EAP type
@@ -337,7 +339,9 @@ namespace eap
             if (!CryptDecrypt(key_aes, hHash, TRUE, 0, buf))
                 throw win_runtime_error(__FUNCTION__ " CryptDecrypt failed.");
 
-            return std::vector<_Ty, _Ax>(buf);
+            std::vector<_Ty, _Ax> buf_res;
+            buf_res.assign(buf.cbegin(), buf.cend());
+            return buf_res;
         }
 
 
@@ -427,7 +431,7 @@ namespace eap
         template<class _Elem, class _Traits, class _Ax>
         std::basic_string<_Elem, _Traits, _Ax> decrypt_str_md5(_In_ HCRYPTPROV hProv, _In_bytecount_(size) const void *data, _In_ size_t size) const
         {
-            std::vector<_Elem, sanitizing_allocator<_Elem> > buf(std::move(decrypt_md5(hProv, data, size)));
+            std::vector<_Elem, sanitizing_allocator<_Elem> > buf(std::move(decrypt_md5<_Elem, sanitizing_allocator<_Elem> >(hProv, data, size)));
             return std::basic_string<_Elem, _Traits, _Ax>(buf.data(), buf.size());
         }
 
@@ -444,7 +448,7 @@ namespace eap
         template<class _Traits, class _Ax>
         std::basic_string<wchar_t, _Traits, _Ax> decrypt_str_md5(_In_ HCRYPTPROV hProv, _In_bytecount_(size) const void *data, _In_ size_t size) const
         {
-            winstd::sanitizing_string buf(std::move(decrypt_str_md5(hProv, data, size)));
+            winstd::sanitizing_string buf(std::move(decrypt_str_md5<char, std::char_traits<char>, sanitizing_allocator<char> >(hProv, data, size)));
             std::basic_string<wchar_t, _Traits, _Ax> dec;
             MultiByteToWideChar(CP_UTF8, 0, buf.data(), (int)buf.size(), dec);
             return dec;
@@ -556,6 +560,8 @@ namespace eap
 
     class peer : public module
     {
+        WINSTD_NONCOPYABLE(peer)
+
     public:
         ///
         /// Constructs a EAP peer module for the given EAP type

lib/EAPBase/src/Config.cpp

@@ -151,7 +151,7 @@ eap::config_method& eap::config_method::operator=(_Inout_ config_method &&other)
 
 eap::config_method_with_cred::config_method_with_cred(_In_ module &mod, _In_ unsigned int level) :
     m_allow_save(true),
-    m_use_preshared(false),
+    m_use_cred(false),
     m_last_status(status_success),
     config_method(mod, level)
 {
@@ -159,23 +159,23 @@ eap::config_method_with_cred::config_method_with_cred(_In_ module &mod, _In_ uns
 
 
 eap::config_method_with_cred::config_method_with_cred(_In_ const config_method_with_cred &other) :
-    m_allow_save   (other.m_allow_save                                                    ),
-    m_use_preshared(other.m_use_preshared                                                 ),
-    m_preshared    (other.m_preshared ? (credentials*)other.m_preshared->clone() : nullptr),
-    m_last_status  (other.m_last_status                                                   ),
-    m_last_msg     (other.m_last_msg                                                      ),
-    config_method  (other                                                                 )
+    m_allow_save   (other.m_allow_save                                          ),
+    m_use_cred     (other.m_use_cred                                            ),
+    m_cred         (other.m_cred ? (credentials*)other.m_cred->clone() : nullptr),
+    m_last_status  (other.m_last_status                                         ),
+    m_last_msg     (other.m_last_msg                                            ),
+    config_method  (other                                                       )
 {
 }
 
 
 eap::config_method_with_cred::config_method_with_cred(_Inout_ config_method_with_cred &&other) :
-    m_allow_save   (std::move(other.m_allow_save   )),
-    m_use_preshared(std::move(other.m_use_preshared)),
-    m_preshared    (std::move(other.m_preshared    )),
-    m_last_status  (std::move(other.m_last_status  )),
-    m_last_msg     (std::move(other.m_last_msg     )),
-    config_method  (std::move(other                ))
+    m_allow_save (std::move(other.m_allow_save )),
+    m_use_cred   (std::move(other.m_use_cred   )),
+    m_cred       (std::move(other.m_cred       )),
+    m_last_status(std::move(other.m_last_status)),
+    m_last_msg   (std::move(other.m_last_msg   )),
+    config_method(std::move(other              ))
 {
 }
 
@@ -185,8 +185,8 @@ eap::config_method_with_cred& eap::config_method_with_cred::operator=(_In_ const
     if (this != &other) {
         (config_method&)*this = other;
         m_allow_save          = other.m_allow_save;
-        m_use_preshared       = other.m_use_preshared;
-        m_preshared.reset(other.m_preshared ? (credentials*)other.m_preshared->clone() : nullptr);
+        m_use_cred            = other.m_use_cred;
+        m_cred.reset(other.m_cred ? (credentials*)other.m_cred->clone() : nullptr);
         m_last_status         = other.m_last_status;
         m_last_msg            = other.m_last_msg;
     }
@@ -198,12 +198,12 @@ eap::config_method_with_cred& eap::config_method_with_cred::operator=(_In_ const
 eap::config_method_with_cred& eap::config_method_with_cred::operator=(_Inout_ config_method_with_cred &&other)
 {
     if (this != &other) {
-        (config_method&)*this = std::move(other                );
-        m_allow_save          = std::move(other.m_allow_save   );
-        m_use_preshared       = std::move(other.m_use_preshared);
-        m_preshared           = std::move(other.m_preshared    );
-        m_last_status         = std::move(other.m_last_status  );
-        m_last_msg            = std::move(other.m_last_msg     );
+        (config_method&)*this = std::move(other              );
+        m_allow_save          = std::move(other.m_allow_save );
+        m_use_cred            = std::move(other.m_use_cred   );
+        m_cred                = std::move(other.m_cred       );
+        m_last_status         = std::move(other.m_last_status);
+        m_last_msg            = std::move(other.m_last_msg   );
     }
 
     return *this;
@@ -219,15 +219,15 @@ void eap::config_method_with_cred::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOM
 
     // <ClientSideCredential>
     winstd::com_obj<IXMLDOMElement> pXmlElClientSideCredential;
-    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, winstd::bstr(L"eap-metadata:ClientSideCredential"), winstd::bstr(L"ClientSideCredential"), namespace_eapmetadata, &pXmlElClientSideCredential)))
+    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, winstd::bstr(L"eap-metadata:ClientSideCredential"), winstd::bstr(L"ClientSideCredential"), namespace_eapmetadata, pXmlElClientSideCredential)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <ClientSideCredential> element.");
 
     // <ClientSideCredential>/<allow-save>
     if (FAILED(hr = eapxml::put_element_value(pDoc, pXmlElClientSideCredential, winstd::bstr(L"allow-save"), namespace_eapmetadata, m_allow_save)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <allow-save> element.");
 
-    if (m_use_preshared)
-        m_preshared->save(pDoc, pXmlElClientSideCredential);
+    if (m_use_cred)
+        m_cred->save(pDoc, pXmlElClientSideCredential);
 }
 
 
@@ -235,24 +235,24 @@ void eap::config_method_with_cred::load(_In_ IXMLDOMNode *pConfigRoot)
 {
     assert(pConfigRoot);
 
-    m_allow_save    = true;
-    m_use_preshared = false;
-    m_preshared->clear();
+    m_allow_save = true;
+    m_use_cred   = false;
+    m_cred->clear();
 
     // <ClientSideCredential>
     winstd::com_obj<IXMLDOMElement> pXmlElClientSideCredential;
-    if (SUCCEEDED(eapxml::select_element(pConfigRoot, winstd::bstr(L"eap-metadata:ClientSideCredential"), &pXmlElClientSideCredential))) {
+    if (SUCCEEDED(eapxml::select_element(pConfigRoot, winstd::bstr(L"eap-metadata:ClientSideCredential"), pXmlElClientSideCredential))) {
         std::wstring xpath(eapxml::get_xpath(pXmlElClientSideCredential));
 
         // <allow-save>
-        eapxml::get_element_value(pXmlElClientSideCredential, winstd::bstr(L"eap-metadata:allow-save"), &m_allow_save);
+        eapxml::get_element_value(pXmlElClientSideCredential, winstd::bstr(L"eap-metadata:allow-save"), m_allow_save);
         m_module.log_config((xpath + L"/allow-save").c_str(), m_allow_save);
 
         try {
-            m_preshared->load(pXmlElClientSideCredential);
-            m_use_preshared = true;
+            m_cred->load(pXmlElClientSideCredential);
+            m_use_cred = true;
         } catch (...) {
-            // This is not really an error - merely an indication pre-shared credentials are unavailable.
+            // This is not really an error - merely an indication configured credentials are unavailable.
         }
     }
 
@@ -265,8 +265,8 @@ void eap::config_method_with_cred::operator<<(_Inout_ cursor_out &cursor) const
 {
     config_method::operator<<(cursor);
     cursor << m_allow_save;
-    cursor << m_use_preshared;
-    cursor << *m_preshared;
+    cursor << m_use_cred;
+    cursor << *m_cred;
     cursor << m_last_status;
     cursor << m_last_msg;
 }
@@ -276,11 +276,11 @@ size_t eap::config_method_with_cred::get_pk_size() const
 {
     return
         config_method::get_pk_size() +
-        pksizeof(m_allow_save   ) +
-        pksizeof(m_use_preshared) +
-        pksizeof(*m_preshared   ) +
-        pksizeof(m_last_status  ) +
-        pksizeof(m_last_msg     );
+        pksizeof(m_allow_save ) +
+        pksizeof(m_use_cred   ) +
+        pksizeof(*m_cred      ) +
+        pksizeof(m_last_status) +
+        pksizeof(m_last_msg   );
 }
 
 
@@ -288,8 +288,8 @@ void eap::config_method_with_cred::operator>>(_Inout_ cursor_in &cursor)
 {
     config_method::operator>>(cursor);
     cursor >> m_allow_save;
-    cursor >> m_use_preshared;
-    cursor >> *m_preshared;
+    cursor >> m_use_cred;
+    cursor >> *m_cred;
     cursor >> m_last_status;
     cursor >> m_last_msg;
 }
@@ -416,7 +416,7 @@ void eap::config_provider::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pC
 
     // <ProviderInfo>
     com_obj<IXMLDOMElement> pXmlElProviderInfo;
-    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:ProviderInfo"), bstr(L"ProviderInfo"), namespace_eapmetadata, &pXmlElProviderInfo)))
+    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:ProviderInfo"), bstr(L"ProviderInfo"), namespace_eapmetadata, pXmlElProviderInfo)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <ProviderInfo> element.");
 
     // <ProviderInfo>/<DisplayName>
@@ -426,7 +426,7 @@ void eap::config_provider::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pC
 
     // <ProviderInfo>/<Helpdesk>
     com_obj<IXMLDOMElement> pXmlElHelpdesk;
-    if (FAILED(hr = eapxml::create_element(pDoc, pXmlElProviderInfo, bstr(L"eap-metadata:Helpdesk"), bstr(L"Helpdesk"), namespace_eapmetadata, &pXmlElHelpdesk)))
+    if (FAILED(hr = eapxml::create_element(pDoc, pXmlElProviderInfo, bstr(L"eap-metadata:Helpdesk"), bstr(L"Helpdesk"), namespace_eapmetadata, pXmlElHelpdesk)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <Helpdesk> element.");
 
     // <ProviderInfo>/<Helpdesk>/<EmailAddress>
@@ -461,13 +461,13 @@ void eap::config_provider::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pC
 
     // <AuthenticationMethods>
     com_obj<IXMLDOMElement> pXmlElAuthenticationMethods;
-    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:AuthenticationMethods"), bstr(L"AuthenticationMethods"), namespace_eapmetadata, &pXmlElAuthenticationMethods)))
+    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:AuthenticationMethods"), bstr(L"AuthenticationMethods"), namespace_eapmetadata, pXmlElAuthenticationMethods)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <AuthenticationMethods> element.");
 
     for (vector<unique_ptr<config_method> >::const_iterator method = m_methods.cbegin(), method_end = m_methods.cend(); method != method_end; ++method) {
         // <AuthenticationMethod>
         com_obj<IXMLDOMElement> pXmlElAuthenticationMethod;
-        if (FAILED(hr = eapxml::create_element(pDoc, bstr(L"AuthenticationMethod"), namespace_eapmetadata, &pXmlElAuthenticationMethod)))
+        if (FAILED(hr = eapxml::create_element(pDoc, bstr(L"AuthenticationMethod"), namespace_eapmetadata, pXmlElAuthenticationMethod)))
             throw com_runtime_error(hr, __FUNCTION__ " Error creating <AuthenticationMethod> element.");
 
         // <AuthenticationMethod>/...
@@ -498,7 +498,7 @@ void eap::config_provider::load(_In_ IXMLDOMNode *pConfigRoot)
     m_module.log_config((xpath + L" ID").c_str(), m_id.c_str());
 
     // <read-only>
-    if (FAILED(hr = eapxml::get_element_value(pConfigRoot, bstr(L"eap-metadata:read-only"), &m_read_only)))
+    if (FAILED(hr = eapxml::get_element_value(pConfigRoot, bstr(L"eap-metadata:read-only"), m_read_only)))
         m_read_only = true;
     m_module.log_config((xpath + L"/read-only").c_str(), m_read_only);
 
@@ -511,7 +511,7 @@ void eap::config_provider::load(_In_ IXMLDOMNode *pConfigRoot)
     m_lbl_alt_identity.clear();
     m_lbl_alt_password.clear();
     com_obj<IXMLDOMElement> pXmlElProviderInfo;
-    if (SUCCEEDED(eapxml::select_element(pConfigRoot, bstr(L"eap-metadata:ProviderInfo"), &pXmlElProviderInfo))) {
+    if (SUCCEEDED(eapxml::select_element(pConfigRoot, bstr(L"eap-metadata:ProviderInfo"), pXmlElProviderInfo))) {
         wstring lang;
         LoadString(m_module.m_instance, 2, lang);
         wstring xpathProviderInfo(xpath + L"/ProviderInfo");
@@ -521,7 +521,7 @@ void eap::config_provider::load(_In_ IXMLDOMNode *pConfigRoot)
         m_module.log_config((xpathProviderInfo + L"/DisplayName").c_str(), m_name.c_str());
 
         com_obj<IXMLDOMElement> pXmlElHelpdesk;
-        if (SUCCEEDED(eapxml::select_element(pXmlElProviderInfo, bstr(L"eap-metadata:Helpdesk"), &pXmlElHelpdesk))) {
+        if (SUCCEEDED(eapxml::select_element(pXmlElProviderInfo, bstr(L"eap-metadata:Helpdesk"), pXmlElHelpdesk))) {
             wstring xpathHelpdesk(xpathProviderInfo + L"/Helpdesk");
 
             // <Helpdesk>/<EmailAddress>
@@ -553,7 +553,7 @@ void eap::config_provider::load(_In_ IXMLDOMNode *pConfigRoot)
     // Iterate authentication methods (<AuthenticationMethods>).
     m_methods.clear();
     com_obj<IXMLDOMNodeList> pXmlListMethods;
-    if (FAILED(hr = eapxml::select_nodes(pConfigRoot, bstr(L"eap-metadata:AuthenticationMethods/eap-metadata:AuthenticationMethod"), &pXmlListMethods)))
+    if (FAILED(hr = eapxml::select_nodes(pConfigRoot, bstr(L"eap-metadata:AuthenticationMethods/eap-metadata:AuthenticationMethod"), pXmlListMethods)))
         throw com_runtime_error(hr, __FUNCTION__ " Error selecting <AuthenticationMethods>/<AuthenticationMethod> elements.");
     long lCount = 0;
     pXmlListMethods->get_length(&lCount);
@@ -565,7 +565,7 @@ void eap::config_provider::load(_In_ IXMLDOMNode *pConfigRoot)
 
         // Check EAP method type (<EAPMethod>).
         DWORD dwMethodID;
-        if (SUCCEEDED(eapxml::get_element_value(pXmlElMethod, bstr(L"eap-metadata:EAPMethod"), &dwMethodID))) {
+        if (SUCCEEDED(eapxml::get_element_value(pXmlElMethod, bstr(L"eap-metadata:EAPMethod"), dwMethodID))) {
             if ((eap_type_t)dwMethodID != cfg->get_method_id()) {
                 // Wrong type.
                 continue;
@@ -705,13 +705,13 @@ void eap::config_connection::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *
 
     // Create <EAPIdentityProviderList> node.
     com_obj<IXMLDOMElement> pXmlElIdentityProviderList;
-    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:EAPIdentityProviderList"), bstr(L"EAPIdentityProviderList"), namespace_eapmetadata, &pXmlElIdentityProviderList)))
+    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:EAPIdentityProviderList"), bstr(L"EAPIdentityProviderList"), namespace_eapmetadata, pXmlElIdentityProviderList)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <EAPIdentityProviderList> element.");
 
     for (provider_list::const_iterator provider = m_providers.cbegin(), provider_end = m_providers.cend(); provider != provider_end; ++provider) {
         // <EAPIdentityProvider>
         com_obj<IXMLDOMElement> pXmlElIdentityProvider;
-        if (FAILED(hr = eapxml::create_element(pDoc, bstr(L"EAPIdentityProvider"), namespace_eapmetadata, &pXmlElIdentityProvider)))
+        if (FAILED(hr = eapxml::create_element(pDoc, bstr(L"EAPIdentityProvider"), namespace_eapmetadata, pXmlElIdentityProvider)))
             throw com_runtime_error(hr, __FUNCTION__ " Error creating <EAPIdentityProvider> element.");
 
         // <EAPIdentityProvider>/...
@@ -732,7 +732,7 @@ void eap::config_connection::load(_In_ IXMLDOMNode *pConfigRoot)
 
     // Iterate authentication providers (<EAPIdentityProvider>).
     com_obj<IXMLDOMNodeList> pXmlListProviders;
-    if (FAILED(hr = eapxml::select_nodes(pConfigRoot, bstr(L"eap-metadata:EAPIdentityProviderList/eap-metadata:EAPIdentityProvider"), &pXmlListProviders)))
+    if (FAILED(hr = eapxml::select_nodes(pConfigRoot, bstr(L"eap-metadata:EAPIdentityProviderList/eap-metadata:EAPIdentityProvider"), pXmlListProviders)))
         throw com_runtime_error(hr, __FUNCTION__ " Error selecting <EAPIdentityProviderList><EAPIdentityProvider> elements.");
     long lCount = 0;
     pXmlListProviders->get_length(&lCount);

lib/EAPBase/src/Credentials.cpp

@@ -106,7 +106,7 @@ void eap::credentials::load(_In_ IXMLDOMNode *pConfigRoot)
 
     config::load(pConfigRoot);
 
-    std::wstring xpath(eapxml::get_xpath(pConfigRoot));
+    wstring xpath(eapxml::get_xpath(pConfigRoot));
 
     if (FAILED(hr = eapxml::get_element_value(pConfigRoot, bstr(L"eap-metadata:UserName"), m_identity)))
         m_identity.clear();
@@ -225,12 +225,18 @@ void eap::credentials_pass::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *p
 
     HRESULT hr;
 
+    // Prepare cryptographics provider.
+    crypt_prov cp;
+    if (!cp.create(NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT))
+        throw win_runtime_error(__FUNCTION__ " CryptAcquireContext failed.");
+
     // <Password>
-    bstr pass(m_password);
-    hr = eapxml::put_element_value(pDoc, pConfigRoot, bstr(L"Password"), namespace_eapmetadata, pass);
-    SecureZeroMemory((BSTR)pass, sizeof(OLECHAR)*pass.length());
-    if (FAILED(hr))
+    vector<unsigned char> password_enc(std::move(m_module.encrypt_md5(cp, m_password)));
+    com_obj<IXMLDOMElement> pXmlElPassword;
+    if (FAILED(hr = eapxml::put_element_base64(pDoc, pConfigRoot, bstr(L"Password"), namespace_eapmetadata, password_enc.data(), password_enc.size(), std::addressof(pXmlElPassword))))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <Password> element.");
+
+    pXmlElPassword->setAttribute(bstr(L"encryption"), variant(_L(PRODUCT_NAME_STR)));
 }
 
 
@@ -241,13 +247,35 @@ void eap::credentials_pass::load(_In_ IXMLDOMNode *pConfigRoot)
 
     credentials::load(pConfigRoot);
 
-    std::wstring xpath(eapxml::get_xpath(pConfigRoot));
+    wstring xpath(eapxml::get_xpath(pConfigRoot));
 
-    bstr pass;
-    if (FAILED(hr = eapxml::get_element_value(pConfigRoot, bstr(L"eap-metadata:Password"), &pass)))
+    // <Password>
+    bstr password, encryption;
+    com_obj<IXMLDOMElement> pXmlElPassword;
+    if (FAILED(hr = eapxml::get_element_value(pConfigRoot, bstr(L"eap-metadata:Password"), password, std::addressof(pXmlElPassword))))
         throw com_runtime_error(hr, __FUNCTION__ " Error reading <Password> element.");
-    m_password = pass;
-    SecureZeroMemory((BSTR)pass, sizeof(OLECHAR)*pass.length());
+
+    if (SUCCEEDED(eapxml::get_attrib_value(pXmlElPassword, bstr(L"encryption"), encryption)) &&
+        CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, encryption, encryption.length(), _L(PRODUCT_NAME_STR), -1, NULL, NULL, 0) == CSTR_EQUAL)
+    {
+        // Decrypt password.
+
+        // Decode Base64.
+        winstd::base64_dec dec;
+        bool is_last;
+        std::vector<unsigned char> password_enc;
+        dec.decode(password_enc, is_last, (BSTR)password, password.length());
+
+        // Prepare cryptographics provider.
+        crypt_prov cp;
+        if (!cp.create(NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT))
+            throw win_runtime_error(__FUNCTION__ " CryptAcquireContext failed.");
+
+        m_password = m_module.decrypt_str_md5<std::char_traits<wchar_t>, sanitizing_allocator<wchar_t> >(cp, password_enc.data(), password_enc.size());
+    } else {
+        m_password = password;
+        SecureZeroMemory((BSTR)password, sizeof(OLECHAR)*password.length());
+    }
 
     m_module.log_config((xpath + L"/Password").c_str(),
 #ifdef _DEBUG
@@ -375,11 +403,11 @@ eap::credentials::source_t eap::credentials_pass::combine(
         return source_cache;
     }
 
-    if (cfg.m_use_preshared) {
-        // Using preshared credentials.
-        *this = *(credentials_pass*)cfg.m_preshared.get();
-        m_module.log_event(&EAPMETHOD_TRACE_EVT_CRED_PRESHARED1, event_data((unsigned int)cfg.get_method_id()), event_data(credentials_pass::get_name()), event_data::blank);
-        return source_preshared;
+    if (cfg.m_use_cred) {
+        // Using configured credentials.
+        *this = *(credentials_pass*)cfg.m_cred.get();
+        m_module.log_event(&EAPMETHOD_TRACE_EVT_CRED_CONFIG1, event_data((unsigned int)cfg.get_method_id()), event_data(credentials_pass::get_name()), event_data::blank);
+        return source_config;
     }
 
     if (pszTargetName) {
@@ -542,7 +570,7 @@ void eap::credentials_connection::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMN
 
     // Create <EAPIdentityProvider> node.
     com_obj<IXMLDOMElement> pXmlElIdentityProvider;
-    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:EAPIdentityProvider"), bstr(L"EAPIdentityProvider"), namespace_eapmetadata, &pXmlElIdentityProvider)))
+    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:EAPIdentityProvider"), bstr(L"EAPIdentityProvider"), namespace_eapmetadata, pXmlElIdentityProvider)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <EAPIdentityProvider> element.");
 
     // namespace
@@ -567,11 +595,11 @@ void eap::credentials_connection::load(_In_ IXMLDOMNode *pConfigRoot)
     config::load(pConfigRoot);
 
     // <EAPIdentityProvider>
-    winstd::com_obj<IXMLDOMElement> pXmlElClientSideCredential;
-    if (FAILED(hr = eapxml::select_element(pConfigRoot, winstd::bstr(L"eap-metadata:EAPIdentityProvider"), &pXmlElClientSideCredential)))
+    com_obj<IXMLDOMElement> pXmlElClientSideCredential;
+    if (FAILED(hr = eapxml::select_element(pConfigRoot, bstr(L"eap-metadata:EAPIdentityProvider"), pXmlElClientSideCredential)))
         throw com_runtime_error(hr, __FUNCTION__ " Error loading <EAPIdentityProvider> element.");
 
-    std::wstring xpath(eapxml::get_xpath(pXmlElClientSideCredential));
+    wstring xpath(eapxml::get_xpath(pXmlElClientSideCredential));
 
     // namespace
     m_namespace.clear();

lib/EAPBase_UI/include/EAP_UI.h

@@ -199,6 +199,10 @@ public:
         this->SetIcon(wxIcon(wxICON(product.ico)));
 #endif
 
+        // Set banner title.
+        std::unique_ptr<eap::config_method> cfg_dummy(cfg.m_module.make_config_method());
+        m_banner->m_title->SetLabel(wxString::Format("%s %s", wxT(PRODUCT_NAME_STR), cfg_dummy->get_method_str()));
+
         for (eap::config_connection::provider_list::iterator provider = m_cfg.m_providers.begin(), provider_end = m_cfg.m_providers.end(); provider != provider_end; ++provider) {
             bool is_single = provider->m_methods.size() == 1;
             std::vector<std::unique_ptr<eap::config_method> >::size_type count = 0;
@@ -566,14 +570,16 @@ public:
     /// \param[inout] cfg     Configuration data
     /// \param[in]    parent  Parent window
     ///
-    wxEAPCredentialsConfigPanel(const eap::config_provider &prov, eap::config_method_with_cred &cfg, wxWindow *parent) :
+    wxEAPCredentialsConfigPanel(const eap::config_provider &prov, eap::config_method_with_cred &cfg, wxWindow *parent, const wxString &method = wxEmptyString) :
         m_prov(prov),
         m_cfg(cfg),
-        m_has_own(false),
-        m_cred_own(cfg.m_module),
-        m_cred_preshared(cfg.m_module),
+        m_has_storage(false),
+        m_cred_storage(cfg.m_module),
+        m_cred_config(cfg.m_module),
         wxEAPCredentialsConfigPanelBase(parent)
     {
+        m_sb_credentials->GetStaticBox()->SetLabel(method.empty() ? wxString::Format(_("%s User Credentials"), cfg.get_method_str()) : method);
+
         // Load and set icon.
         winstd::library lib_shell32;
         if (lib_shell32.load(_T("shell32.dll"), NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE))
@@ -585,7 +591,7 @@ public:
     ///
     inline void SetFocusFromKbd()
     {
-        m_own->SetFocusFromKbd();
+        m_storage->SetFocusFromKbd();
     }
 
 protected:
@@ -593,18 +599,18 @@ protected:
 
     virtual bool TransferDataToWindow()
     {
-        if (!m_cfg.m_use_preshared)
-            m_own->SetValue(true);
+        if (!m_cfg.m_use_cred)
+            m_storage->SetValue(true);
         else
-            m_preshared->SetValue(true);
+            m_config->SetValue(true);
 
         if (m_cfg.m_allow_save) {
-            RetrieveOwnCredentials();
-            m_timer_own.Start(3000);
+            RetrieveStorageCredentials();
+            m_timer_storage.Start(3000);
         }
 
-        m_cred_preshared = *(_Tcred*)m_cfg.m_preshared.get();
-        UpdatePresharedIdentity();
+        m_cred_config = *(_Tcred*)m_cfg.m_cred.get();
+        UpdateConfigIdentity();
 
         return wxEAPCredentialsConfigPanelBase::TransferDataToWindow();
     }
@@ -616,8 +622,8 @@ protected:
 
         if (!m_prov.m_read_only) {
             // This is not a provider-locked configuration. Save the data.
-            m_cfg.m_use_preshared = !m_own->GetValue();
-            *m_cfg.m_preshared    = m_cred_preshared;
+            m_cfg.m_use_cred = !m_storage->GetValue();
+            *(_Tcred*)m_cfg.m_cred.get() = m_cred_config;
         }
 
         return true;
@@ -627,139 +633,139 @@ protected:
     virtual void OnUpdateUI(wxUpdateUIEvent& /*event*/)
     {
         if (m_cfg.m_allow_save) {
-            if (m_own->GetValue()) {
-                m_own_identity->Enable(true);
-                m_own_set     ->Enable(true);
-                m_own_clear   ->Enable(m_has_own);
+            if (m_storage->GetValue()) {
+                m_storage_identity->Enable(true);
+                m_storage_set     ->Enable(true);
+                m_storage_clear   ->Enable(m_has_storage);
             } else {
-                m_own_identity->Enable(false);
-                m_own_set     ->Enable(false);
-                m_own_clear   ->Enable(false);
+                m_storage_identity->Enable(false);
+                m_storage_set     ->Enable(false);
+                m_storage_clear   ->Enable(false);
             }
         } else {
-            m_own_identity->Enable(false);
-            m_own_set     ->Enable(false);
-            m_own_clear   ->Enable(false);
+            m_storage_identity->Enable(false);
+            m_storage_set     ->Enable(false);
+            m_storage_clear   ->Enable(false);
         }
 
         if (m_prov.m_read_only) {
             // This is provider-locked configuration. Disable controls.
             // To avoid run-away selection of radio buttons, disable the selected one last.
-            if (m_own->GetValue()) {
-                m_preshared->Enable(false);
-                m_own      ->Enable(false);
+            if (m_storage->GetValue()) {
+                m_config ->Enable(false);
+                m_storage->Enable(false);
             } else {
-                m_own      ->Enable(false);
-                m_preshared->Enable(false);
+                m_storage->Enable(false);
+                m_config ->Enable(false);
             }
-            m_preshared_identity->Enable(false);
-            m_preshared_set     ->Enable(false);
+            m_config_identity->Enable(false);
+            m_config_set     ->Enable(false);
         } else {
             // This is not a provider-locked configuration. Selectively enable/disable controls.
-            m_own      ->Enable(true);
-            m_preshared->Enable(true);
-            if (m_own->GetValue()) {
-                m_preshared_identity->Enable(false);
-                m_preshared_set     ->Enable(false);
+            m_storage->Enable(true);
+            m_config->Enable(true);
+            if (m_storage->GetValue()) {
+                m_config_identity->Enable(false);
+                m_config_set     ->Enable(false);
             } else {
-                m_preshared_identity->Enable(true);
-                m_preshared_set     ->Enable(true);
+                m_config_identity->Enable(true);
+                m_config_set     ->Enable(true);
             }
         }
     }
 
 
-    virtual void OnSetOwn(wxCommandEvent& /*event*/)
+    virtual void OnSetStorage(wxCommandEvent& /*event*/)
     {
         // Read credentials from Credential Manager.
-        RetrieveOwnCredentials();
+        RetrieveStorageCredentials();
 
         // Display credential prompt.
         wxEAPCredentialsDialog dlg(m_prov, this);
-        _wxT *panel = new _wxT(m_prov, m_cfg, m_cred_own, &dlg, true);
+        _wxT *panel = new _wxT(m_prov, m_cfg, m_cred_storage, &dlg, true);
         dlg.AddContent(panel);
         if (dlg.ShowModal() == wxID_OK && panel->GetRemember()) {
             // Write credentials to credential manager.
             try {
-                m_cred_own.store(m_prov.get_id().c_str(), m_cfg.m_level);
-                m_has_own = TRUE;
-                UpdateOwnIdentity();
+                m_cred_storage.store(m_prov.get_id().c_str(), m_cfg.m_level);
+                m_has_storage = TRUE;
+                UpdateStorageIdentity();
             } catch (winstd::win_runtime_error &err) {
                 wxLogError(winstd::tstring_printf(_("Error writing credentials to Credential Manager: %hs (error %u)"), err.what(), err.number()).c_str());
-                RetrieveOwnCredentials();
+                RetrieveStorageCredentials();
             } catch (...) {
                 wxLogError(_("Writing credentials failed."));
-                RetrieveOwnCredentials();
+                RetrieveStorageCredentials();
             }
         }
     }
 
 
-    virtual void OnClearOwn(wxCommandEvent& /*event*/)
+    virtual void OnClearStorage(wxCommandEvent& /*event*/)
     {
-        if (CredDelete(m_cred_own.target_name(m_prov.get_id().c_str(), m_cfg.m_level).c_str(), CRED_TYPE_GENERIC, 0)) {
-            m_own_identity->Clear();
-            m_has_own = false;
+        if (CredDelete(m_cred_storage.target_name(m_prov.get_id().c_str(), m_cfg.m_level).c_str(), CRED_TYPE_GENERIC, 0)) {
+            m_storage_identity->Clear();
+            m_has_storage = false;
         } else
             wxLogError(_("Deleting credentials failed (error %u)."), GetLastError());
     }
 
 
-    virtual void OnSetPreshared(wxCommandEvent& /*event*/)
+    virtual void OnSetConfig(wxCommandEvent& /*event*/)
     {
         wxEAPCredentialsDialog dlg(m_prov, this);
 
-        _wxT *panel = new _wxT(m_prov, m_cfg, m_cred_preshared, &dlg, true);
+        _wxT *panel = new _wxT(m_prov, m_cfg, m_cred_config, &dlg, true);
 
         dlg.AddContent(panel);
         if (dlg.ShowModal() == wxID_OK)
-            UpdatePresharedIdentity();
+            UpdateConfigIdentity();
     }
 
 
-    virtual void OnTimerOwn(wxTimerEvent& /*event*/)
+    virtual void OnTimerStorage(wxTimerEvent& /*event*/)
     {
-        if (m_own_identity->IsShownOnScreen())
-            RetrieveOwnCredentials();
+        if (m_storage_identity->IsShownOnScreen())
+            RetrieveStorageCredentials();
     }
 
 
-    void RetrieveOwnCredentials()
+    void RetrieveStorageCredentials()
     {
         try {
-            m_cred_own.retrieve(m_prov.get_id().c_str(), m_cfg.m_level);
-            m_has_own = true;
-            UpdateOwnIdentity();
+            m_cred_storage.retrieve(m_prov.get_id().c_str(), m_cfg.m_level);
+            m_has_storage = true;
+            UpdateStorageIdentity();
         } catch (winstd::win_runtime_error &err) {
             if (err.number() == ERROR_NOT_FOUND) {
-                m_own_identity->Clear();
-                m_has_own = false;
+                m_storage_identity->Clear();
+                m_has_storage = false;
             } else {
-                m_own_identity->SetValue(wxString::Format(_("<error %u>"), err.number()));
-                m_has_own = true;
+                m_storage_identity->SetValue(wxString::Format(_("<error %u>"), err.number()));
+                m_has_storage = true;
             }
         } catch (...) {
-            m_own_identity->SetValue(_("<error>"));
-            m_has_own = true;
+            m_storage_identity->SetValue(_("<error>"));
+            m_has_storage = true;
         }
     }
 
 
-    inline void UpdateOwnIdentity()
+    inline void UpdateStorageIdentity()
     {
-        wxString identity(m_cred_own.get_identity());
-        m_own_identity->SetValue(
+        wxString identity(m_cred_storage.get_identity());
+        m_storage_identity->SetValue(
             !identity.empty()  ? identity :
-            m_cred_own.empty() ? _("<empty>") : _("<blank ID>"));
+            m_cred_storage.empty() ? _("<empty>") : _("<blank ID>"));
     }
 
 
-    inline void UpdatePresharedIdentity()
+    inline void UpdateConfigIdentity()
     {
-        wxString identity(m_cred_preshared.get_identity());
-        m_preshared_identity->SetValue(
-            !identity.empty()        ? identity :
-            m_cred_preshared.empty() ? _("<empty>") : _("<blank ID>"));
+        wxString identity(m_cred_config.get_identity());
+        m_config_identity->SetValue(
+            !identity.empty()  ? identity :
+            m_cred_config.empty() ? _("<empty>") : _("<blank ID>"));
     }
 
     /// \endcond
@@ -769,9 +775,9 @@ protected:
     eap::config_method_with_cred &m_cfg;    ///< EAP method configuration
 
 private:
-    bool m_has_own;                         ///< Does the user has (some sort of) credentials stored in Credential Manager?
-    _Tcred m_cred_own;                      ///< Temporary own credential data
-    _Tcred m_cred_preshared;                ///< Temporary pre-shared credential data
+    bool m_has_storage;                     ///< Does the user has (some sort of) credentials stored in Credential Manager?
+    _Tcred m_cred_storage;                  ///< Temporary stored credential data
+    _Tcred m_cred_config;                   ///< Temporary config credential data
 };
 
 
@@ -791,7 +797,7 @@ public:
     /// \param[in]    cfg         Configuration data
     /// \param[inout] cred        Credentials data
     /// \param[in]    parent      Parent window
-    /// \param[in]    is_config   Is this panel used to pre-enter credentials? When \c true, the "Remember" checkbox is always selected and disabled.
+    /// \param[in]    is_config   Is this panel used to config credentials?
     ///
     wxEAPCredentialsPanel(const eap::config_provider &prov, const eap::config_method_with_cred &cfg, _Tcred &cred, wxWindow* parent, bool is_config = false) :
         m_prov(prov),
@@ -800,48 +806,33 @@ public:
         m_is_config(is_config),
         _Tbase(parent)
     {
+        if (!is_config && !m_cfg.m_use_cred && m_cfg.m_allow_save) {
+            m_remember = new wxCheckBox(m_sb_credentials->GetStaticBox(), wxID_ANY, _("&Remember"));
+            m_remember->SetHelpText(_("Check if you would like to save credentials"));
+            m_sb_credentials_vert->Add(m_remember, 0, wxALL|wxEXPAND, 5);
+        } else
+            m_remember = NULL;
     }
 
     virtual void SetRemember(bool val)
     {
-        return m_remember->SetValue(val);
+        if (m_remember)
+            m_remember->SetValue(val);
     }
 
     virtual bool GetRemember() const
     {
-        return m_remember->GetValue();
+        return m_remember ?
+            m_remember->GetValue() :
+            !m_cfg.m_use_cred && m_cfg.m_allow_save;
     }
 
-protected:
-    /// \cond internal
-
-    virtual bool TransferDataToWindow()
-    {
-        if (m_is_config) {
-            // Configuration mode
-            // Always store credentials (somewhere).
-            m_remember->SetValue(true);
-            m_remember->Enable(false);
-        } else if (m_cfg.m_use_preshared) {
-            // Credential prompt mode & Using pre-shared credentials
-            m_remember->SetValue(false);
-            m_remember->Enable(false);
-        } else if (!m_cfg.m_allow_save) {
-            // Credential prompt mode & using own credentials & saving is not allowed
-            m_remember->SetValue(false);
-            m_remember->Enable(false);
-        }
-
-        return _Tbase::TransferDataToWindow();
-    }
-
-    /// \endcond
-
 protected:
     const eap::config_provider &m_prov;         ///< Provider configuration
     const eap::config_method_with_cred &m_cfg;  ///< Method configuration
     _Tcred &m_cred;                             ///< Credentials
     bool m_is_config;                           ///< Is this a configuration dialog?
+    wxCheckBox *m_remember;                     ///< "Remember" checkbox
 };
 
 
@@ -856,15 +847,16 @@ public:
     /// \param[in]    cfg        Configuration data
     /// \param[inout] cred       Credentials data
     /// \param[in]    parent     Parent window
-    /// \param[in]    is_config  Is this panel used to pre-enter credentials? When \c true, the "Remember" checkbox is always selected and disabled.
+    /// \param[in]    is_config  Is this panel used to config credentials?
     ///
     wxPasswordCredentialsPanel(const eap::config_provider &prov, const eap::config_method_with_cred &cfg, _Tcred &cred, wxWindow* parent, bool is_config = false) :
+        m_password_set(false),
         wxEAPCredentialsPanel<_Tcred, _Tbase>(prov, cfg, cred, parent, is_config)
     {
         // Load and set icon.
         winstd::library lib_shell32;
-        if (lib_shell32.load(_T("shell32.dll"), NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE))
-            m_credentials_icon->SetIcon(wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(269)));
+        if (lib_shell32.load(_T("imageres.dll"), NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE))
+            m_credentials_icon->SetIcon(wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(82)));
 
         bool layout = false;
         if (!m_prov.m_lbl_alt_credential.empty()) {
@@ -894,43 +886,43 @@ protected:
     {
         m_identity->SetValue(m_cred.m_identity);
         m_identity->SetSelection(0, -1);
-        m_password->SetValue(m_cred.m_password.empty() ? wxEmptyString : s_dummy_password);
+        m_password->SetValue(m_cred.m_password.empty() ? wxEmptyString : wxT("dummypass"));
+        m_password_set = false;
 
-        if (!m_is_config && m_cfg.m_use_preshared) {
-            // Credential prompt mode & Using pre-shared credentials
+        if (!m_is_config && m_cfg.m_use_cred) {
+            // Credential prompt mode & Using configured credentials
             m_identity_label->Enable(false);
             m_identity      ->Enable(false);
             m_password_label->Enable(false);
             m_password      ->Enable(false);
         }
 
-        return wxEAPCredentialsPanel<_Tcred, wxEAPCredentialsPassPanelBase>::TransferDataToWindow();
+        return wxEAPCredentialsPanel<_Tcred, wxPasswordCredentialsPanelBase>::TransferDataToWindow();
     }
 
     virtual bool TransferDataFromWindow()
     {
-        if (!wxEAPCredentialsPanel<_Tcred, wxEAPCredentialsPassPanelBase>::TransferDataFromWindow())
+        if (!wxEAPCredentialsPanel<_Tcred, wxPasswordCredentialsPanelBase>::TransferDataFromWindow())
             return false;
 
         m_cred.m_identity = m_identity->GetValue();
-        wxString pass = m_password->GetValue();
-        if (pass.compare(s_dummy_password) != 0) {
-            m_cred.m_password = pass;
-            pass.assign(pass.length(), wxT('*'));
-        }
+        if (m_password_set)
+            m_cred.m_password = m_password->GetValue();
 
         return true;
     }
 
+    virtual void OnPasswordText(wxCommandEvent& /*event*/)
+    {
+        m_password_set = true;
+    }
+
     /// \endcond
 
 private:
-    static const wxStringCharType *s_dummy_password;
+    bool m_password_set;
 };
 
-template <class _Tcred, class _Tbase>
-const wxStringCharType *wxPasswordCredentialsPanel<_Tcred, _Tbase>::s_dummy_password = wxT("dummypass");
-
 
 inline wxIcon wxLoadIconFromResource(HINSTANCE hinst, PCWSTR pszName, int cx, int cy)
 {

lib/EAPBase_UI/res/wxEAP_UI.cpp

@@ -226,146 +226,125 @@ wxEAPNotePanelBase::~wxEAPNotePanelBase()
 
 wxEAPCredentialsConfigPanelBase::wxEAPCredentialsConfigPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : wxPanel( parent, id, pos, size, style )
 {
-	wxStaticBoxSizer* sb_credentials;
-	sb_credentials = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Client Credentials") ), wxVERTICAL );
+	m_sb_credentials = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("%s User Credentials") ), wxVERTICAL );
 	
 	wxBoxSizer* sb_credentials_horiz;
 	sb_credentials_horiz = new wxBoxSizer( wxHORIZONTAL );
 	
-	m_credentials_icon = new wxStaticBitmap( sb_credentials->GetStaticBox(), wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0 );
+	m_credentials_icon = new wxStaticBitmap( m_sb_credentials->GetStaticBox(), wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0 );
 	sb_credentials_horiz->Add( m_credentials_icon, 0, wxALL, 5 );
 	
 	wxBoxSizer* sb_credentials_vert;
 	sb_credentials_vert = new wxBoxSizer( wxVERTICAL );
 	
-	m_credentials_label = new wxStaticText( sb_credentials->GetStaticBox(), wxID_ANY, _("Manage credentials used to connect."), wxDefaultPosition, wxDefaultSize, 0 );
+	m_credentials_label = new wxStaticText( m_sb_credentials->GetStaticBox(), wxID_ANY, _("Select the source where your credentials used to connect are stored."), wxDefaultPosition, wxDefaultSize, 0 );
 	m_credentials_label->Wrap( 440 );
 	sb_credentials_vert->Add( m_credentials_label, 0, wxALL|wxEXPAND, 5 );
 	
-	wxBoxSizer* sb_cred_radio;
-	sb_cred_radio = new wxBoxSizer( wxVERTICAL );
+	m_storage = new wxRadioButton( m_sb_credentials->GetStaticBox(), wxID_ANY, _("Use credentials from Credential &Manager:"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
+	m_storage->SetToolTip( _("Select this option if you would like to use credentials stored in Windows Credential Manager") );
 	
-	wxBoxSizer* sz_own;
-	sz_own = new wxBoxSizer( wxVERTICAL );
+	sb_credentials_vert->Add( m_storage, 0, wxEXPAND|wxTOP|wxRIGHT|wxLEFT, 5 );
 	
-	wxBoxSizer* sz_own_inner;
-	sz_own_inner = new wxBoxSizer( wxHORIZONTAL );
+	wxBoxSizer* sz_storage;
+	sz_storage = new wxBoxSizer( wxVERTICAL );
 	
-	m_own = new wxRadioButton( sb_credentials->GetStaticBox(), wxID_ANY, _("Use &own credentials:"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
-	m_own->SetToolTip( _("Select this option if you have your unique credentials to connect") );
+	m_storage_identity = new wxTextCtrl( m_sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
+	m_storage_identity->SetToolTip( _("Your present credentials stored in Windows Credential Manager") );
 	
-	sz_own_inner->Add( m_own, 2, wxEXPAND, 5 );
+	sz_storage->Add( m_storage_identity, 3, wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );
 	
-	m_own_identity = new wxTextCtrl( sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
-	m_own_identity->SetToolTip( _("Your credentials loaded from Windows Credential Manager") );
+	wxBoxSizer* sb_buttons_storage;
+	sb_buttons_storage = new wxBoxSizer( wxHORIZONTAL );
 	
-	sz_own_inner->Add( m_own_identity, 3, wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );
+	m_storage_clear = new wxButton( m_sb_credentials->GetStaticBox(), wxID_ANY, _("&Clear Credentials"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_storage_clear->SetToolTip( _("Click to clear your credentials from Credential Manager.\nNote: You will be prompted to enter credentials when connecting.") );
+	
+	sb_buttons_storage->Add( m_storage_clear, 0, wxRIGHT, 5 );
+	
+	m_storage_set = new wxButton( m_sb_credentials->GetStaticBox(), wxID_ANY, _("&Set Credentials..."), wxDefaultPosition, wxDefaultSize, 0 );
+	m_storage_set->SetToolTip( _("Click here to set or modify your credentials") );
+	
+	sb_buttons_storage->Add( m_storage_set, 0, wxLEFT, 5 );
 	
 	
-	sz_own->Add( sz_own_inner, 1, wxEXPAND|wxBOTTOM, 5 );
-	
-	wxBoxSizer* sb_buttons_own;
-	sb_buttons_own = new wxBoxSizer( wxHORIZONTAL );
-	
-	m_own_clear = new wxButton( sb_credentials->GetStaticBox(), wxID_ANY, _("&Clear Credentials"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_own_clear->SetToolTip( _("Click to clear your credentials from Credential Manager.\nNote: You will be prompted to enter credentials when connecting.") );
-	
-	sb_buttons_own->Add( m_own_clear, 0, wxRIGHT, 5 );
-	
-	m_own_set = new wxButton( sb_credentials->GetStaticBox(), wxID_ANY, _("&Set Credentials..."), wxDefaultPosition, wxDefaultSize, 0 );
-	m_own_set->SetToolTip( _("Click here to set or modify your credentials") );
-	
-	sb_buttons_own->Add( m_own_set, 0, wxLEFT, 5 );
+	sz_storage->Add( sb_buttons_storage, 0, wxALIGN_RIGHT|wxTOP, 5 );
 	
 	
-	sz_own->Add( sb_buttons_own, 0, wxALIGN_RIGHT, 5 );
+	sb_credentials_vert->Add( sz_storage, 0, wxEXPAND|wxALL, 5 );
+	
+	m_config = new wxRadioButton( m_sb_credentials->GetStaticBox(), wxID_ANY, _("Use credentials from &profile configuration:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_config->SetToolTip( _("Select this option if you would like to store credentials as a part of  profile configuration") );
+	
+	sb_credentials_vert->Add( m_config, 0, wxEXPAND|wxTOP|wxRIGHT|wxLEFT, 5 );
+	
+	wxBoxSizer* sz_config;
+	sz_config = new wxBoxSizer( wxVERTICAL );
+	
+	m_config_identity = new wxTextCtrl( m_sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
+	m_config_identity->SetToolTip( _("Profile configuration credentials") );
+	
+	sz_config->Add( m_config_identity, 3, wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );
+	
+	wxBoxSizer* sb_buttons_config;
+	sb_buttons_config = new wxBoxSizer( wxHORIZONTAL );
+	
+	m_config_set = new wxButton( m_sb_credentials->GetStaticBox(), wxID_ANY, _("&Set Credentials..."), wxDefaultPosition, wxDefaultSize, 0 );
+	m_config_set->SetToolTip( _("Click here to set or modify your credentials") );
+	
+	sb_buttons_config->Add( m_config_set, 0, 0, 5 );
 	
 	
-	sb_cred_radio->Add( sz_own, 0, wxEXPAND|wxBOTTOM, 5 );
-	
-	wxBoxSizer* sz_preshared;
-	sz_preshared = new wxBoxSizer( wxVERTICAL );
-	
-	wxBoxSizer* sz_preshared_inner;
-	sz_preshared_inner = new wxBoxSizer( wxHORIZONTAL );
-	
-	m_preshared = new wxRadioButton( sb_credentials->GetStaticBox(), wxID_ANY, _("Use &pre-shared credentials:"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_preshared->SetToolTip( _("Select this options if all clients connect using the same credentials") );
-	
-	sz_preshared_inner->Add( m_preshared, 2, wxEXPAND, 5 );
-	
-	m_preshared_identity = new wxTextCtrl( sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
-	m_preshared_identity->SetToolTip( _("Common (pre-shared) credentials") );
-	
-	sz_preshared_inner->Add( m_preshared_identity, 3, wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );
+	sz_config->Add( sb_buttons_config, 0, wxALIGN_RIGHT|wxTOP, 5 );
 	
 	
-	sz_preshared->Add( sz_preshared_inner, 1, wxEXPAND|wxBOTTOM, 5 );
-	
-	wxBoxSizer* sb_buttons_preshared;
-	sb_buttons_preshared = new wxBoxSizer( wxHORIZONTAL );
-	
-	m_preshared_set = new wxButton( sb_credentials->GetStaticBox(), wxID_ANY, _("&Set Credentials..."), wxDefaultPosition, wxDefaultSize, 0 );
-	m_preshared_set->SetToolTip( _("Click here to set or modify your credentials") );
-	
-	sb_buttons_preshared->Add( m_preshared_set, 0, 0, 5 );
-	
-	
-	sz_preshared->Add( sb_buttons_preshared, 0, wxALIGN_RIGHT, 5 );
-	
-	
-	sb_cred_radio->Add( sz_preshared, 0, wxEXPAND|wxTOP, 5 );
-	
-	
-	sb_credentials_vert->Add( sb_cred_radio, 0, wxEXPAND|wxALL, 5 );
+	sb_credentials_vert->Add( sz_config, 0, wxEXPAND|wxALL, 5 );
 	
 	
 	sb_credentials_horiz->Add( sb_credentials_vert, 1, wxEXPAND, 5 );
 	
 	
-	sb_credentials->Add( sb_credentials_horiz, 1, wxEXPAND, 5 );
+	m_sb_credentials->Add( sb_credentials_horiz, 1, wxEXPAND, 5 );
 	
 	
-	this->SetSizer( sb_credentials );
+	this->SetSizer( m_sb_credentials );
 	this->Layout();
-	m_timer_own.SetOwner( this, wxID_ANY );
+	m_timer_storage.SetOwner( this, wxID_ANY );
 	
 	// Connect Events
 	this->Connect( wxEVT_UPDATE_UI, wxUpdateUIEventHandler( wxEAPCredentialsConfigPanelBase::OnUpdateUI ) );
-	m_own_clear->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnClearOwn ), NULL, this );
-	m_own_set->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnSetOwn ), NULL, this );
-	m_preshared_set->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnSetPreshared ), NULL, this );
-	this->Connect( wxID_ANY, wxEVT_TIMER, wxTimerEventHandler( wxEAPCredentialsConfigPanelBase::OnTimerOwn ) );
+	m_storage_clear->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnClearStorage ), NULL, this );
+	m_storage_set->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnSetStorage ), NULL, this );
+	m_config_set->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnSetConfig ), NULL, this );
+	this->Connect( wxID_ANY, wxEVT_TIMER, wxTimerEventHandler( wxEAPCredentialsConfigPanelBase::OnTimerStorage ) );
 }
 
 wxEAPCredentialsConfigPanelBase::~wxEAPCredentialsConfigPanelBase()
 {
 	// Disconnect Events
 	this->Disconnect( wxEVT_UPDATE_UI, wxUpdateUIEventHandler( wxEAPCredentialsConfigPanelBase::OnUpdateUI ) );
-	m_own_clear->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnClearOwn ), NULL, this );
-	m_own_set->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnSetOwn ), NULL, this );
-	m_preshared_set->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnSetPreshared ), NULL, this );
-	this->Disconnect( wxID_ANY, wxEVT_TIMER, wxTimerEventHandler( wxEAPCredentialsConfigPanelBase::OnTimerOwn ) );
+	m_storage_clear->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnClearStorage ), NULL, this );
+	m_storage_set->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnSetStorage ), NULL, this );
+	m_config_set->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPCredentialsConfigPanelBase::OnSetConfig ), NULL, this );
+	this->Disconnect( wxID_ANY, wxEVT_TIMER, wxTimerEventHandler( wxEAPCredentialsConfigPanelBase::OnTimerStorage ) );
 	
 }
 
-wxEAPCredentialsPassPanelBase::wxEAPCredentialsPassPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : wxEAPCredentialsPanelBase( parent, id, pos, size, style )
+wxPasswordCredentialsPanelBase::wxPasswordCredentialsPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : wxEAPCredentialsPanelBase( parent, id, pos, size, style )
 {
-	wxStaticBoxSizer* sb_credentials;
-	sb_credentials = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Client Credentials") ), wxVERTICAL );
+	m_sb_credentials = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("User ID and Password") ), wxVERTICAL );
 	
 	wxBoxSizer* sb_credentials_horiz;
 	sb_credentials_horiz = new wxBoxSizer( wxHORIZONTAL );
 	
-	m_credentials_icon = new wxStaticBitmap( sb_credentials->GetStaticBox(), wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0 );
+	m_credentials_icon = new wxStaticBitmap( m_sb_credentials->GetStaticBox(), wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0 );
 	sb_credentials_horiz->Add( m_credentials_icon, 0, wxALL, 5 );
 	
-	wxBoxSizer* sb_credentials_vert;
-	sb_credentials_vert = new wxBoxSizer( wxVERTICAL );
+	m_sb_credentials_vert = new wxBoxSizer( wxVERTICAL );
 	
-	m_credentials_label = new wxStaticText( sb_credentials->GetStaticBox(), wxID_ANY, _("Please provide your user ID and password."), wxDefaultPosition, wxDefaultSize, 0 );
+	m_credentials_label = new wxStaticText( m_sb_credentials->GetStaticBox(), wxID_ANY, _("Please provide your user ID and password."), wxDefaultPosition, wxDefaultSize, 0 );
 	m_credentials_label->Wrap( 440 );
-	sb_credentials_vert->Add( m_credentials_label, 0, wxALL|wxEXPAND, 5 );
+	m_sb_credentials_vert->Add( m_credentials_label, 0, wxALL|wxEXPAND, 5 );
 	
 	wxFlexGridSizer* sb_credentials_tbl;
 	sb_credentials_tbl = new wxFlexGridSizer( 0, 2, 5, 5 );
@@ -373,45 +352,46 @@ wxEAPCredentialsPassPanelBase::wxEAPCredentialsPassPanelBase( wxWindow* parent,
 	sb_credentials_tbl->SetFlexibleDirection( wxBOTH );
 	sb_credentials_tbl->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
 	
-	m_identity_label = new wxStaticText( sb_credentials->GetStaticBox(), wxID_ANY, _("User ID:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_identity_label = new wxStaticText( m_sb_credentials->GetStaticBox(), wxID_ANY, _("User ID:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_identity_label->Wrap( -1 );
 	sb_credentials_tbl->Add( m_identity_label, 0, wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );
 	
-	m_identity = new wxTextCtrl( sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_identity = new wxTextCtrl( m_sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_identity->SetToolTip( _("Enter your user name here (user@domain.org, DOMAIN\\User, etc.)") );
 	
 	sb_credentials_tbl->Add( m_identity, 2, wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );
 	
-	m_password_label = new wxStaticText( sb_credentials->GetStaticBox(), wxID_ANY, _("Password:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_password_label = new wxStaticText( m_sb_credentials->GetStaticBox(), wxID_ANY, _("Password:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_password_label->Wrap( -1 );
 	sb_credentials_tbl->Add( m_password_label, 0, wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );
 	
-	m_password = new wxTextCtrl( sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PASSWORD );
+	m_password = new wxTextCtrl( m_sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PASSWORD );
 	m_password->SetToolTip( _("Enter your password here") );
 	
 	sb_credentials_tbl->Add( m_password, 2, wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );
 	
 	
-	sb_credentials_vert->Add( sb_credentials_tbl, 0, wxEXPAND|wxALL, 5 );
-	
-	m_remember = new wxCheckBox( sb_credentials->GetStaticBox(), wxID_ANY, _("&Remember"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_remember->SetHelpText( _("Check if you would like to save username and password") );
-	
-	sb_credentials_vert->Add( m_remember, 0, wxALL|wxEXPAND, 5 );
+	m_sb_credentials_vert->Add( sb_credentials_tbl, 0, wxEXPAND|wxALL, 5 );
 	
 	
-	sb_credentials_horiz->Add( sb_credentials_vert, 1, wxEXPAND, 5 );
+	sb_credentials_horiz->Add( m_sb_credentials_vert, 1, wxEXPAND, 5 );
 	
 	
-	sb_credentials->Add( sb_credentials_horiz, 0, wxEXPAND, 5 );
+	m_sb_credentials->Add( sb_credentials_horiz, 0, wxEXPAND, 5 );
 	
 	
-	this->SetSizer( sb_credentials );
+	this->SetSizer( m_sb_credentials );
 	this->Layout();
+	
+	// Connect Events
+	m_password->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( wxPasswordCredentialsPanelBase::OnPasswordText ), NULL, this );
 }
 
-wxEAPCredentialsPassPanelBase::~wxEAPCredentialsPassPanelBase()
+wxPasswordCredentialsPanelBase::~wxPasswordCredentialsPanelBase()
 {
+	// Disconnect Events
+	m_password->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( wxPasswordCredentialsPanelBase::OnPasswordText ), NULL, this );
+	
 }
 
 wxEAPProviderContactInfoPanelBase::wxEAPProviderContactInfoPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : wxPanel( parent, id, pos, size, style )

lib/EAPBase_UI/res/wxEAP_UI.h

@@ -34,8 +34,8 @@ class wxEAPBannerPanel;
 #include <wx/textctrl.h>
 #include <wx/statbox.h>
 #include <wx/timer.h>
-#include <wx/checkbox.h>
 #include <wx/choice.h>
+#include <wx/checkbox.h>
 
 ///////////////////////////////////////////////////////////////////////////
 
@@ -165,23 +165,24 @@ class wxEAPCredentialsConfigPanelBase : public wxPanel
 	private:
 	
 	protected:
+		wxStaticBoxSizer* m_sb_credentials;
 		wxStaticBitmap* m_credentials_icon;
 		wxStaticText* m_credentials_label;
-		wxRadioButton* m_own;
-		wxTextCtrl* m_own_identity;
-		wxButton* m_own_clear;
-		wxButton* m_own_set;
-		wxRadioButton* m_preshared;
-		wxTextCtrl* m_preshared_identity;
-		wxButton* m_preshared_set;
-		wxTimer m_timer_own;
+		wxRadioButton* m_storage;
+		wxTextCtrl* m_storage_identity;
+		wxButton* m_storage_clear;
+		wxButton* m_storage_set;
+		wxRadioButton* m_config;
+		wxTextCtrl* m_config_identity;
+		wxButton* m_config_set;
+		wxTimer m_timer_storage;
 		
 		// Virtual event handlers, overide them in your derived class
 		virtual void OnUpdateUI( wxUpdateUIEvent& event ) { event.Skip(); }
-		virtual void OnClearOwn( wxCommandEvent& event ) { event.Skip(); }
-		virtual void OnSetOwn( wxCommandEvent& event ) { event.Skip(); }
-		virtual void OnSetPreshared( wxCommandEvent& event ) { event.Skip(); }
-		virtual void OnTimerOwn( wxTimerEvent& event ) { event.Skip(); }
+		virtual void OnClearStorage( wxCommandEvent& event ) { event.Skip(); }
+		virtual void OnSetStorage( wxCommandEvent& event ) { event.Skip(); }
+		virtual void OnSetConfig( wxCommandEvent& event ) { event.Skip(); }
+		virtual void OnTimerStorage( wxTimerEvent& event ) { event.Skip(); }
 		
 	
 	public:
@@ -192,25 +193,30 @@ class wxEAPCredentialsConfigPanelBase : public wxPanel
 };
 
 ///////////////////////////////////////////////////////////////////////////////
-/// Class wxEAPCredentialsPassPanelBase
+/// Class wxPasswordCredentialsPanelBase
 ///////////////////////////////////////////////////////////////////////////////
-class wxEAPCredentialsPassPanelBase : public wxEAPCredentialsPanelBase
+class wxPasswordCredentialsPanelBase : public wxEAPCredentialsPanelBase
 {
 	private:
 	
 	protected:
+		wxStaticBoxSizer* m_sb_credentials;
 		wxStaticBitmap* m_credentials_icon;
+		wxBoxSizer* m_sb_credentials_vert;
 		wxStaticText* m_credentials_label;
 		wxStaticText* m_identity_label;
 		wxTextCtrl* m_identity;
 		wxStaticText* m_password_label;
 		wxTextCtrl* m_password;
-		wxCheckBox* m_remember;
+		
+		// Virtual event handlers, overide them in your derived class
+		virtual void OnPasswordText( wxCommandEvent& event ) { event.Skip(); }
+		
 	
 	public:
 		
-		wxEAPCredentialsPassPanelBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( 500,-1 ), long style = wxTAB_TRAVERSAL ); 
-		~wxEAPCredentialsPassPanelBase();
+		wxPasswordCredentialsPanelBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( 500,-1 ), long style = wxTAB_TRAVERSAL ); 
+		~wxPasswordCredentialsPanelBase();
 	
 };
 

lib/EAPBase_UI/src/EAP_UI.cpp

@@ -27,7 +27,6 @@
 
 wxEAPBannerPanel::wxEAPBannerPanel(wxWindow* parent) : wxEAPBannerPanelBase(parent)
 {
-    m_title->SetLabelText(wxT(PRODUCT_NAME_STR));
 }
 
 

lib/MSCHAPv2/build/MSCHAPv2.vcxproj

@@ -95,6 +95,11 @@
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
     </ClCompile>
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Events\build\Events.vcxproj">
+      <Project>{d63f24bd-92a0-4d6b-8b69-ed947e4d2b1b}</Project>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

lib/MSCHAPv2/include/Method.h

@@ -40,6 +40,8 @@ namespace eap
 {
     class method_mschapv2 : public method_noneap
     {
+        WINSTD_NONCOPYABLE(method_mschapv2)
+
     public:
         ///
         /// Constructs an EAP method
@@ -132,7 +134,7 @@ namespace eap
         static std::list<std::string> parse_response(_In_count_(count) const char *resp, _In_ size_t count);
 
     protected:
-        credentials_pass &m_cred;           ///< EAP-TLS user credentials
+        credentials_pass &m_cred;               ///< Method user credentials
         winstd::crypt_prov m_cp;                ///< Cryptography provider for general services
 
         challenge_mschapv2 m_challenge_server;  ///< MSCHAP server challenge

lib/MSCHAPv2/src/Config.cpp

@@ -30,7 +30,7 @@ using namespace winstd;
 
 eap::config_method_mschapv2::config_method_mschapv2(_In_ module &mod, _In_ unsigned int level) : config_method_with_cred(mod, level)
 {
-    m_preshared.reset(new credentials_pass(mod));
+    m_cred.reset(new credentials_pass(mod));
 }
 
 

lib/MSCHAPv2_UI/include/MSCHAPv2_UI.h

@@ -24,7 +24,7 @@
 ///
 /// MSCHAPv2 credential configuration panel
 ///
-typedef wxEAPCredentialsConfigPanel<eap::credentials_pass, wxPasswordCredentialsPanel<eap::credentials_pass, wxEAPCredentialsPassPanelBase> > wxMSCHAPv2CredentialsConfigPanel;
+typedef wxEAPCredentialsConfigPanel<eap::credentials_pass, wxPasswordCredentialsPanel<eap::credentials_pass, wxPasswordCredentialsPanelBase> > wxMSCHAPv2CredentialsConfigPanel;
 
 ///
 /// MSCHAPv2 configuration panel
@@ -34,7 +34,7 @@ class wxMSCHAPv2ConfigPanel;
 ///
 /// MSCHAPv2 credential entry panel
 ///
-typedef wxPasswordCredentialsPanel<eap::credentials_pass, wxEAPCredentialsPassPanelBase> wxMSCHAPv2CredentialsPanel;
+typedef wxPasswordCredentialsPanel<eap::credentials_pass, wxPasswordCredentialsPanelBase> wxMSCHAPv2CredentialsPanel;
 
 #pragma once
 

lib/MSCHAPv2_UI/src/MSCHAPv2_UI.cpp

@@ -30,7 +30,7 @@ wxMSCHAPv2ConfigPanel::wxMSCHAPv2ConfigPanel(const eap::config_provider &prov, e
     wxBoxSizer* sb_content;
     sb_content = new wxBoxSizer( wxVERTICAL );
 
-    m_credentials = new wxMSCHAPv2CredentialsConfigPanel(prov, cfg, this);
+    m_credentials = new wxMSCHAPv2CredentialsConfigPanel(prov, cfg, this, _("MSCHAPv2 User ID and Password"));
     sb_content->Add(m_credentials, 0, wxEXPAND, 5);
 
     this->SetSizer(sb_content);

lib/PAP/build/PAP.vcxproj

@@ -93,6 +93,11 @@
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
     </ClCompile>
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Events\build\Events.vcxproj">
+      <Project>{d63f24bd-92a0-4d6b-8b69-ed947e4d2b1b}</Project>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

lib/PAP/include/Method.h

@@ -38,6 +38,8 @@ namespace eap
 {
     class method_pap : public method_noneap
     {
+        WINSTD_NONCOPYABLE(method_pap)
+
     public:
         ///
         /// Constructs an EAP method
@@ -91,7 +93,7 @@ namespace eap
         /// @}
 
     protected:
-        credentials_pass &m_cred;    ///< EAP-TLS user credentials
+        credentials_pass &m_cred;    ///< Method user credentials
 
         enum {
             phase_unknown = -1,     ///< Unknown phase

lib/PAP/src/Config.cpp

@@ -30,7 +30,7 @@ using namespace winstd;
 
 eap::config_method_pap::config_method_pap(_In_ module &mod, _In_ unsigned int level) : config_method_with_cred(mod, level)
 {
-    m_preshared.reset(new credentials_pass(mod));
+    m_cred.reset(new credentials_pass(mod));
 }
 
 

lib/PAP_UI/include/PAP_UI.h

@@ -24,7 +24,7 @@
 ///
 /// PAP credential configuration panel
 ///
-typedef wxEAPCredentialsConfigPanel<eap::credentials_pass, wxPasswordCredentialsPanel<eap::credentials_pass, wxEAPCredentialsPassPanelBase> > wxPAPCredentialsConfigPanel;
+typedef wxEAPCredentialsConfigPanel<eap::credentials_pass, wxPasswordCredentialsPanel<eap::credentials_pass, wxPasswordCredentialsPanelBase> > wxPAPCredentialsConfigPanel;
 
 ///
 /// PAP configuration panel
@@ -34,7 +34,7 @@ class wxPAPConfigPanel;
 ///
 /// PAP credential entry panel
 ///
-typedef wxPasswordCredentialsPanel<eap::credentials_pass, wxEAPCredentialsPassPanelBase> wxPAPCredentialsPanel;
+typedef wxPasswordCredentialsPanel<eap::credentials_pass, wxPasswordCredentialsPanelBase> wxPAPCredentialsPanel;
 
 #pragma once
 

lib/PAP_UI/src/PAP_UI.cpp

@@ -30,7 +30,7 @@ wxPAPConfigPanel::wxPAPConfigPanel(const eap::config_provider &prov, eap::config
     wxBoxSizer* sb_content;
     sb_content = new wxBoxSizer( wxVERTICAL );
 
-    m_credentials = new wxPAPCredentialsConfigPanel(prov, cfg, this);
+    m_credentials = new wxPAPCredentialsConfigPanel(prov, cfg, this, _("PAP User ID and Password"));
     sb_content->Add(m_credentials, 0, wxEXPAND, 5);
 
     this->SetSizer(sb_content);

lib/TLS/build/TLS.vcxproj

@@ -97,6 +97,11 @@
     <ClCompile Include="..\src\Credentials.cpp" />
     <ClCompile Include="..\src\TLS.cpp" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Events\build\Events.vcxproj">
+      <Project>{d63f24bd-92a0-4d6b-8b69-ed947e4d2b1b}</Project>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

lib/TLS/include/Credentials.h

@@ -194,9 +194,9 @@ namespace eap
         /// \param[in] pszTargetName  The name in Windows Credential Manager to retrieve credentials from (optional, can be \c NULL)
         ///
         /// \returns
-        /// - \c source_cache      Credentials were obtained from EapHost cache
-        /// - \c source_preshared  Credentials were set by method configuration
-        /// - \c source_storage    Credentials were loaded from Windows Credential Manager
+        /// - \c source_cache   Credentials were obtained from EapHost cache
+        /// - \c source_config  Credentials were set by method configuration
+        /// - \c source_storage Credentials were loaded from Windows Credential Manager
         ///
         virtual source_t combine(
             _In_       const credentials             *cred_cached,

lib/TLS/include/Method.h

@@ -46,6 +46,8 @@ namespace eap
 {
     class method_tls : public method
     {
+        WINSTD_NONCOPYABLE(method_tls)
+
     public:
 #pragma pack(push)
 #pragma pack(1)

lib/TLS/src/Config.cpp

@@ -68,7 +68,7 @@ tstring eap::get_cert_title(PCCERT_CONTEXT cert)
 
 eap::config_method_tls::config_method_tls(_In_ module &mod, _In_ unsigned int level) : config_method_with_cred(mod, level)
 {
-    m_preshared.reset(new credentials_tls(mod));
+    m_cred.reset(new credentials_tls(mod));
 }
 
 
@@ -145,13 +145,13 @@ void eap::config_method_tls::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *
 
     // <ServerSideCredential>
     com_obj<IXMLDOMElement> pXmlElServerSideCredential;
-    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:ServerSideCredential"), bstr(L"ServerSideCredential"), namespace_eapmetadata, &pXmlElServerSideCredential)))
+    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:ServerSideCredential"), bstr(L"ServerSideCredential"), namespace_eapmetadata, pXmlElServerSideCredential)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <ServerSideCredential> element.");
 
     for (list<cert_context>::const_iterator i = m_trusted_root_ca.begin(), i_end = m_trusted_root_ca.end(); i != i_end; ++i) {
         // <CA>
         com_obj<IXMLDOMElement> pXmlElCA;
-        if (FAILED(hr = eapxml::create_element(pDoc, bstr(L"CA"), namespace_eapmetadata, &pXmlElCA)))
+        if (FAILED(hr = eapxml::create_element(pDoc, bstr(L"CA"), namespace_eapmetadata, pXmlElCA)))
             throw com_runtime_error(hr, __FUNCTION__ " Error creating <CA> element.");
 
         // <CA>/<format>
@@ -188,19 +188,19 @@ void eap::config_method_tls::load(_In_ IXMLDOMNode *pConfigRoot)
 
     // <ServerSideCredential>
     com_obj<IXMLDOMElement> pXmlElServerSideCredential;
-    if (SUCCEEDED(eapxml::select_element(pConfigRoot, bstr(L"eap-metadata:ServerSideCredential"), &pXmlElServerSideCredential))) {
+    if (SUCCEEDED(eapxml::select_element(pConfigRoot, bstr(L"eap-metadata:ServerSideCredential"), pXmlElServerSideCredential))) {
         std::wstring xpathServerSideCredential(xpath + L"/ServerSideCredential");
 
         // <CA>
         com_obj<IXMLDOMNodeList> pXmlListCAs;
         long lCACount = 0;
-        if (SUCCEEDED(eapxml::select_nodes(pXmlElServerSideCredential, bstr(L"eap-metadata:CA"), &pXmlListCAs)) && SUCCEEDED(pXmlListCAs->get_length(&lCACount))) {
+        if (SUCCEEDED(eapxml::select_nodes(pXmlElServerSideCredential, bstr(L"eap-metadata:CA"), pXmlListCAs)) && SUCCEEDED(pXmlListCAs->get_length(&lCACount))) {
             for (long j = 0; j < lCACount; j++) {
                 // Load CA certificate.
                 com_obj<IXMLDOMNode> pXmlElCA;
                 pXmlListCAs->get_item(j, &pXmlElCA);
                 bstr bstrFormat;
-                if (FAILED(eapxml::get_element_value(pXmlElCA, bstr(L"eap-metadata:format"), &bstrFormat))) {
+                if (FAILED(eapxml::get_element_value(pXmlElCA, bstr(L"eap-metadata:format"), bstrFormat))) {
                     // <format> not specified.
                     continue;
                 }
@@ -229,7 +229,7 @@ void eap::config_method_tls::load(_In_ IXMLDOMNode *pConfigRoot)
         // <ServerName>
         com_obj<IXMLDOMNodeList> pXmlListServerIDs;
         long lServerIDCount = 0;
-        if (SUCCEEDED(eapxml::select_nodes(pXmlElServerSideCredential, bstr(L"eap-metadata:ServerName"), &pXmlListServerIDs)) && SUCCEEDED(pXmlListServerIDs->get_length(&lServerIDCount))) {
+        if (SUCCEEDED(eapxml::select_nodes(pXmlElServerSideCredential, bstr(L"eap-metadata:ServerName"), pXmlListServerIDs)) && SUCCEEDED(pXmlListServerIDs->get_length(&lServerIDCount))) {
             for (long j = 0; j < lServerIDCount; j++) {
                 // Load server name (<ServerName>).
                 com_obj<IXMLDOMNode> pXmlElServerID;

lib/TLS/src/Credentials.cpp

@@ -99,7 +99,7 @@ void eap::credentials_tls::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *pC
 
     // <ClientCertificate>
     com_obj<IXMLDOMElement> pXmlElClientCertificate;
-    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:ClientCertificate"), bstr(L"ClientCertificate"), namespace_eapmetadata, &pXmlElClientCertificate)))
+    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:ClientCertificate"), bstr(L"ClientCertificate"), namespace_eapmetadata, pXmlElClientCertificate)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <ClientCertificate> element.");
 
     if (m_cert) {
@@ -127,12 +127,12 @@ void eap::credentials_tls::load(_In_ IXMLDOMNode *pConfigRoot)
 
     // <ClientCertificate>
     com_obj<IXMLDOMElement> pXmlElClientCertificate;
-    if (FAILED(hr = eapxml::select_element(pConfigRoot, bstr(L"eap-metadata:ClientCertificate"), &pXmlElClientCertificate)))
+    if (FAILED(hr = eapxml::select_element(pConfigRoot, bstr(L"eap-metadata:ClientCertificate"), pXmlElClientCertificate)))
         throw com_runtime_error(hr, __FUNCTION__ " Error reading <ClientCertificate> element.");
 
     // <ClientCertificate>/<format>
     bstr bstrFormat;
-    if (SUCCEEDED(eapxml::get_element_value(pXmlElClientCertificate, bstr(L"eap-metadata:format"), &bstrFormat))) {
+    if (SUCCEEDED(eapxml::get_element_value(pXmlElClientCertificate, bstr(L"eap-metadata:format"), bstrFormat))) {
         if (CompareStringEx(LOCALE_NAME_INVARIANT, NORM_IGNORECASE, bstrFormat, bstrFormat.length(), L"PEM", -1, NULL, NULL, 0) == CSTR_EQUAL) {
             // <ClientCertificate>/<cert-data>
             vector<unsigned char> aData;
@@ -303,11 +303,11 @@ eap::credentials::source_t eap::credentials_tls::combine(
         return source_cache;
     }
 
-    if (cfg.m_use_preshared) {
-        // Using preshared credentials.
-        *this = *(credentials_tls*)cfg.m_preshared.get();
-        m_module.log_event(&EAPMETHOD_TRACE_EVT_CRED_PRESHARED2, event_data((unsigned int)eap_type_tls), event_data(credentials_tls::get_name()), event_data(pszTargetName), event_data::blank);
-        return source_preshared;
+    if (cfg.m_use_cred) {
+        // Using configured credentials.
+        *this = *(credentials_tls*)cfg.m_cred.get();
+        m_module.log_event(&EAPMETHOD_TRACE_EVT_CRED_CONFIG2, event_data((unsigned int)eap_type_tls), event_data(credentials_tls::get_name()), event_data(pszTargetName), event_data::blank);
+        return source_config;
     }
 
     if (pszTargetName) {

lib/TLS/src/Method.cpp

@@ -223,7 +223,7 @@ void eap::method_tls::begin_session(
     }
 
     // Prepare client credentials for Schannel.
-    PCCERT_CONTEXT certs[] = { m_cred.m_cert ? m_cred.m_cert : NULL };
+    PCCERT_CONTEXT certs[] = { m_cred.m_cert ? (PCCERT_CONTEXT)m_cred.m_cert : NULL };
     SCHANNEL_CRED cred = {
         SCHANNEL_CRED_VERSION,                                                // dwVersion
         m_cred.m_cert ? 1 : 0,                                                // cCreds

lib/TLS_UI/include/TLS_UI.h

@@ -258,7 +258,7 @@ public:
     /// \param[in]    cfg        Configuration data
     /// \param[inout] cred       Credentials data
     /// \param[in]    parent     Parent window
-    /// \param[in]    is_config  Is this panel used to pre-enter credentials? When \c true, the "Remember" checkbox is always selected and disabled.
+    /// \param[in]    is_config  Is this panel used to config credentials?
     ///
     wxTLSCredentialsPanel(const eap::config_provider &prov, const eap::config_method_with_cred &cfg, eap::credentials_tls &cred, wxWindow* parent, bool is_config = false);
 
@@ -271,7 +271,7 @@ protected:
 };
 
 
-class wxTLSServerTrustPanel : public wxEAPTLSServerTrustConfigPanelBase
+class wxTLSServerTrustPanel : public wxTLSServerTrustPanelBase
 {
 public:
     ///
@@ -330,8 +330,8 @@ protected:
     /// \endcond
 
 protected:
-    const eap::config_provider &m_prov;          ///< EAP provider
-    eap::config_method_tls &m_cfg;               ///< TLS configuration
-    wxTLSServerTrustPanel *m_server_trust;       ///< Server trust configuration panel
-    wxTLSCredentialsConfigPanel *m_credentials;  ///< Credentials configuration panel
+    const eap::config_provider &m_prov;         ///< EAP provider
+    eap::config_method_tls &m_cfg;              ///< TLS configuration
+    wxTLSServerTrustPanel *m_server_trust;      ///< Server trust configuration panel
+    wxTLSCredentialsConfigPanel *m_credentials; ///< Credentials configuration panel
 };

lib/TLS_UI/res/wxTLS_UI.cpp

@@ -11,7 +11,7 @@
 
 ///////////////////////////////////////////////////////////////////////////
 
-wxEAPTLSServerTrustConfigPanelBase::wxEAPTLSServerTrustConfigPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : wxPanel( parent, id, pos, size, style )
+wxTLSServerTrustPanelBase::wxTLSServerTrustPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : wxPanel( parent, id, pos, size, style )
 {
 	wxStaticBoxSizer* sb_server_trust;
 	sb_server_trust = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Server Trust") ), wxVERTICAL );
@@ -37,7 +37,7 @@ wxEAPTLSServerTrustConfigPanelBase::wxEAPTLSServerTrustConfigPanelBase( wxWindow
 	sb_root_ca->Add( m_root_ca_lbl, 0, wxEXPAND|wxBOTTOM, 5 );
 	
 	m_root_ca = new wxListBox( sb_server_trust->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, 0, NULL, wxLB_SORT ); 
-	m_root_ca->SetToolTip( _("List of certificate authorities server's certificate must be issued by") );
+	m_root_ca->SetToolTip( _("Server's certificate must be issued by one of certificate authorities listed here") );
 	
 	sb_root_ca->Add( m_root_ca, 1, wxEXPAND|wxBOTTOM, 5 );
 	
@@ -96,103 +96,70 @@ wxEAPTLSServerTrustConfigPanelBase::wxEAPTLSServerTrustConfigPanelBase( wxWindow
 	this->Layout();
 	
 	// Connect Events
-	this->Connect( wxEVT_UPDATE_UI, wxUpdateUIEventHandler( wxEAPTLSServerTrustConfigPanelBase::OnUpdateUI ) );
-	m_root_ca->Connect( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxCommandEventHandler( wxEAPTLSServerTrustConfigPanelBase::OnRootCADClick ), NULL, this );
-	m_root_ca_add_store->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPTLSServerTrustConfigPanelBase::OnRootCAAddStore ), NULL, this );
-	m_root_ca_add_file->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPTLSServerTrustConfigPanelBase::OnRootCAAddFile ), NULL, this );
-	m_root_ca_remove->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPTLSServerTrustConfigPanelBase::OnRootCARemove ), NULL, this );
+	this->Connect( wxEVT_UPDATE_UI, wxUpdateUIEventHandler( wxTLSServerTrustPanelBase::OnUpdateUI ) );
+	m_root_ca->Connect( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxCommandEventHandler( wxTLSServerTrustPanelBase::OnRootCADClick ), NULL, this );
+	m_root_ca_add_store->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxTLSServerTrustPanelBase::OnRootCAAddStore ), NULL, this );
+	m_root_ca_add_file->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxTLSServerTrustPanelBase::OnRootCAAddFile ), NULL, this );
+	m_root_ca_remove->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxTLSServerTrustPanelBase::OnRootCARemove ), NULL, this );
 }
 
-wxEAPTLSServerTrustConfigPanelBase::~wxEAPTLSServerTrustConfigPanelBase()
+wxTLSServerTrustPanelBase::~wxTLSServerTrustPanelBase()
 {
 	// Disconnect Events
-	this->Disconnect( wxEVT_UPDATE_UI, wxUpdateUIEventHandler( wxEAPTLSServerTrustConfigPanelBase::OnUpdateUI ) );
-	m_root_ca->Disconnect( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxCommandEventHandler( wxEAPTLSServerTrustConfigPanelBase::OnRootCADClick ), NULL, this );
-	m_root_ca_add_store->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPTLSServerTrustConfigPanelBase::OnRootCAAddStore ), NULL, this );
-	m_root_ca_add_file->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPTLSServerTrustConfigPanelBase::OnRootCAAddFile ), NULL, this );
-	m_root_ca_remove->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxEAPTLSServerTrustConfigPanelBase::OnRootCARemove ), NULL, this );
+	this->Disconnect( wxEVT_UPDATE_UI, wxUpdateUIEventHandler( wxTLSServerTrustPanelBase::OnUpdateUI ) );
+	m_root_ca->Disconnect( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, wxCommandEventHandler( wxTLSServerTrustPanelBase::OnRootCADClick ), NULL, this );
+	m_root_ca_add_store->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxTLSServerTrustPanelBase::OnRootCAAddStore ), NULL, this );
+	m_root_ca_add_file->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxTLSServerTrustPanelBase::OnRootCAAddFile ), NULL, this );
+	m_root_ca_remove->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( wxTLSServerTrustPanelBase::OnRootCARemove ), NULL, this );
 	
 }
 
-wxTLSCredentialsPanelBase::wxTLSCredentialsPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : wxPanel( parent, id, pos, size, style )
+wxTLSCredentialsPanelBase::wxTLSCredentialsPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : wxEAPCredentialsPanelBase( parent, id, pos, size, style )
 {
-	wxStaticBoxSizer* sb_credentials;
-	sb_credentials = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("TLS Client Certificate") ), wxVERTICAL );
+	m_sb_credentials = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("User Certificate") ), wxVERTICAL );
 	
 	wxBoxSizer* sb_credentials_horiz;
 	sb_credentials_horiz = new wxBoxSizer( wxHORIZONTAL );
 	
-	m_credentials_icon = new wxStaticBitmap( sb_credentials->GetStaticBox(), wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0 );
+	m_credentials_icon = new wxStaticBitmap( m_sb_credentials->GetStaticBox(), wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0 );
 	sb_credentials_horiz->Add( m_credentials_icon, 0, wxALL, 5 );
 	
-	wxBoxSizer* sb_credentials_vert;
-	sb_credentials_vert = new wxBoxSizer( wxVERTICAL );
+	m_sb_credentials_vert = new wxBoxSizer( wxVERTICAL );
 	
-	m_credentials_label = new wxStaticText( sb_credentials->GetStaticBox(), wxID_ANY, _("Please select your client certificate to use for authentication."), wxDefaultPosition, wxDefaultSize, 0 );
-	m_credentials_label->Wrap( 440 );
-	sb_credentials_vert->Add( m_credentials_label, 0, wxALL|wxEXPAND, 5 );
+	m_certificate_label = new wxStaticText( m_sb_credentials->GetStaticBox(), wxID_ANY, _("Please select your &certificate to use for authentication."), wxDefaultPosition, wxDefaultSize, 0 );
+	m_certificate_label->Wrap( 440 );
+	m_sb_credentials_vert->Add( m_certificate_label, 0, wxEXPAND|wxTOP|wxRIGHT|wxLEFT, 5 );
 	
-	wxBoxSizer* sb_cert_radio;
-	sb_cert_radio = new wxBoxSizer( wxVERTICAL );
+	wxArrayString m_certificateChoices;
+	m_certificate = new wxChoice( m_sb_credentials->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, m_certificateChoices, wxCB_SORT );
+	m_certificate->SetSelection( 0 );
+	m_certificate->SetToolTip( _("Client certificate to use for authentication") );
 	
-	m_cert_none = new wxRadioButton( sb_credentials->GetStaticBox(), wxID_ANY, _("Co&nnect without providing a client certificate"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
-	m_cert_none->SetToolTip( _("Select if your server does not require you to provide a client certificate") );
-	
-	sb_cert_radio->Add( m_cert_none, 1, wxEXPAND, 5 );
-	
-	wxBoxSizer* sb_cert_select;
-	sb_cert_select = new wxBoxSizer( wxHORIZONTAL );
-	
-	m_cert_select = new wxRadioButton( sb_credentials->GetStaticBox(), wxID_ANY, _("Use the following &certificate:"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_cert_select->SetToolTip( _("Select if you need to provide a client certificate when connecting") );
-	
-	sb_cert_select->Add( m_cert_select, 0, wxEXPAND, 5 );
-	
-	wxArrayString m_cert_select_valChoices;
-	m_cert_select_val = new wxChoice( sb_credentials->GetStaticBox(), wxID_ANY, wxDefaultPosition, wxDefaultSize, m_cert_select_valChoices, wxCB_SORT );
-	m_cert_select_val->SetSelection( 0 );
-	m_cert_select_val->SetToolTip( _("Client certificate to use for authentication") );
-	
-	sb_cert_select->Add( m_cert_select_val, 1, wxEXPAND, 5 );
-	
-	
-	sb_cert_radio->Add( sb_cert_select, 1, wxEXPAND, 5 );
-	
-	
-	sb_credentials_vert->Add( sb_cert_radio, 0, wxEXPAND|wxALL, 5 );
+	m_sb_credentials_vert->Add( m_certificate, 0, wxEXPAND|wxALL, 5 );
 	
 	wxBoxSizer* sb_identity;
 	sb_identity = new wxBoxSizer( wxVERTICAL );
 	
-	m_identity_label = new wxStaticText( sb_credentials->GetStaticBox(), wxID_ANY, _("Custom &identity:"), wxDefaultPosition, wxDefaultSize, 0 );
+	m_identity_label = new wxStaticText( m_sb_credentials->GetStaticBox(), wxID_ANY, _("Custom &identity:"), wxDefaultPosition, wxDefaultSize, 0 );
 	m_identity_label->Wrap( -1 );
 	sb_identity->Add( m_identity_label, 0, wxBOTTOM, 5 );
 	
-	m_identity = new wxTextCtrl( sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
+	m_identity = new wxTextCtrl( m_sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
 	m_identity->SetToolTip( _("Your identity (username@domain) to override one from certificate; or blank to use one provided in certificate") );
 	
-	sb_identity->Add( m_identity, 0, wxEXPAND|wxBOTTOM, 5 );
-	
-	m_identity_note = new wxStaticText( sb_credentials->GetStaticBox(), wxID_ANY, _("(Example: user@contoso.com)"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_identity_note->Wrap( -1 );
-	sb_identity->Add( m_identity_note, 0, wxALIGN_RIGHT, 5 );
+	sb_identity->Add( m_identity, 0, wxEXPAND, 5 );
 	
 	
-	sb_credentials_vert->Add( sb_identity, 1, wxEXPAND|wxALL, 5 );
-	
-	m_remember = new wxCheckBox( sb_credentials->GetStaticBox(), wxID_ANY, _("&Remember"), wxDefaultPosition, wxDefaultSize, 0 );
-	m_remember->SetHelpText( _("Check if you would like to save certificate selection") );
-	
-	sb_credentials_vert->Add( m_remember, 0, wxALL|wxEXPAND, 5 );
+	m_sb_credentials_vert->Add( sb_identity, 0, wxEXPAND|wxALL, 5 );
 	
 	
-	sb_credentials_horiz->Add( sb_credentials_vert, 1, wxEXPAND, 5 );
+	sb_credentials_horiz->Add( m_sb_credentials_vert, 1, wxEXPAND, 5 );
 	
 	
-	sb_credentials->Add( sb_credentials_horiz, 0, wxEXPAND, 5 );
+	m_sb_credentials->Add( sb_credentials_horiz, 0, wxEXPAND, 5 );
 	
 	
-	this->SetSizer( sb_credentials );
+	this->SetSizer( m_sb_credentials );
 	this->Layout();
 	
 	// Connect Events

lib/TLS_UI/res/wxTLS_UI.fbp

@@ -40,7 +40,7 @@
             <property name="id">wxID_ANY</property>
             <property name="maximum_size"></property>
             <property name="minimum_size"></property>
-            <property name="name">wxEAPTLSServerTrustConfigPanelBase</property>
+            <property name="name">wxTLSServerTrustPanelBase</property>
             <property name="pos"></property>
             <property name="size">500,-1</property>
             <property name="subclass"></property>
@@ -413,7 +413,7 @@
                                                 <property name="style">wxLB_SORT</property>
                                                 <property name="subclass"></property>
                                                 <property name="toolbar_pane">0</property>
-                                                <property name="tooltip">List of certificate authorities server&apos;s certificate must be issued by</property>
+                                                <property name="tooltip">Server&apos;s certificate must be issued by one of certificate authorities listed here</property>
                                                 <property name="validator_data_type"></property>
                                                 <property name="validator_style">wxFILTER_NONE</property>
                                                 <property name="validator_type">wxDefaultValidator</property>
@@ -1016,7 +1016,7 @@
             <property name="name">wxTLSCredentialsPanelBase</property>
             <property name="pos"></property>
             <property name="size">500,-1</property>
-            <property name="subclass"></property>
+            <property name="subclass">wxEAPCredentialsPanelBase; ../../EAPBase_UI/include/wxEAP_UIBase.h</property>
             <property name="tooltip"></property>
             <property name="window_extra_style"></property>
             <property name="window_name"></property>
@@ -1053,11 +1053,11 @@
             <event name="OnUpdateUI">OnUpdateUI</event>
             <object class="wxStaticBoxSizer" expanded="1">
                 <property name="id">wxID_ANY</property>
-                <property name="label">TLS Client Certificate</property>
+                <property name="label">User Certificate</property>
                 <property name="minimum_size"></property>
-                <property name="name">sb_credentials</property>
+                <property name="name">m_sb_credentials</property>
                 <property name="orient">wxVERTICAL</property>
-                <property name="permission">none</property>
+                <property name="permission">protected</property>
                 <event name="OnUpdateUI"></event>
                 <object class="sizeritem" expanded="1">
                     <property name="border">5</property>
@@ -1155,12 +1155,12 @@
                             <property name="proportion">1</property>
                             <object class="wxBoxSizer" expanded="1">
                                 <property name="minimum_size"></property>
-                                <property name="name">sb_credentials_vert</property>
+                                <property name="name">m_sb_credentials_vert</property>
                                 <property name="orient">wxVERTICAL</property>
-                                <property name="permission">none</property>
+                                <property name="permission">protected</property>
                                 <object class="sizeritem" expanded="0">
                                     <property name="border">5</property>
-                                    <property name="flag">wxALL|wxEXPAND</property>
+                                    <property name="flag">wxEXPAND|wxTOP|wxRIGHT|wxLEFT</property>
                                     <property name="proportion">0</property>
                                     <object class="wxStaticText" expanded="0">
                                         <property name="BottomDockable">1</property>
@@ -1190,7 +1190,7 @@
                                         <property name="gripper">0</property>
                                         <property name="hidden">0</property>
                                         <property name="id">wxID_ANY</property>
-                                        <property name="label">Please select your client certificate to use for authentication.</property>
+                                        <property name="label">Please select your &amp;certificate to use for authentication.</property>
                                         <property name="max_size"></property>
                                         <property name="maximize_button">0</property>
                                         <property name="maximum_size"></property>
@@ -1198,7 +1198,7 @@
                                         <property name="minimize_button">0</property>
                                         <property name="minimum_size"></property>
                                         <property name="moveable">1</property>
-                                        <property name="name">m_credentials_label</property>
+                                        <property name="name">m_certificate_label</property>
                                         <property name="pane_border">1</property>
                                         <property name="pane_position"></property>
                                         <property name="pane_size"></property>
@@ -1245,292 +1245,94 @@
                                     <property name="border">5</property>
                                     <property name="flag">wxEXPAND|wxALL</property>
                                     <property name="proportion">0</property>
-                                    <object class="wxBoxSizer" expanded="1">
+                                    <object class="wxChoice" expanded="1">
+                                        <property name="BottomDockable">1</property>
+                                        <property name="LeftDockable">1</property>
+                                        <property name="RightDockable">1</property>
+                                        <property name="TopDockable">1</property>
+                                        <property name="aui_layer"></property>
+                                        <property name="aui_name"></property>
+                                        <property name="aui_position"></property>
+                                        <property name="aui_row"></property>
+                                        <property name="best_size"></property>
+                                        <property name="bg"></property>
+                                        <property name="caption"></property>
+                                        <property name="caption_visible">1</property>
+                                        <property name="center_pane">0</property>
+                                        <property name="choices"></property>
+                                        <property name="close_button">1</property>
+                                        <property name="context_help"></property>
+                                        <property name="context_menu">1</property>
+                                        <property name="default_pane">0</property>
+                                        <property name="dock">Dock</property>
+                                        <property name="dock_fixed">0</property>
+                                        <property name="docking">Left</property>
+                                        <property name="enabled">1</property>
+                                        <property name="fg"></property>
+                                        <property name="floatable">1</property>
+                                        <property name="font"></property>
+                                        <property name="gripper">0</property>
+                                        <property name="hidden">0</property>
+                                        <property name="id">wxID_ANY</property>
+                                        <property name="max_size"></property>
+                                        <property name="maximize_button">0</property>
+                                        <property name="maximum_size"></property>
+                                        <property name="min_size"></property>
+                                        <property name="minimize_button">0</property>
                                         <property name="minimum_size"></property>
-                                        <property name="name">sb_cert_radio</property>
-                                        <property name="orient">wxVERTICAL</property>
-                                        <property name="permission">none</property>
-                                        <object class="sizeritem" expanded="1">
-                                            <property name="border">5</property>
-                                            <property name="flag">wxEXPAND</property>
-                                            <property name="proportion">1</property>
-                                            <object class="wxRadioButton" expanded="1">
-                                                <property name="BottomDockable">1</property>
-                                                <property name="LeftDockable">1</property>
-                                                <property name="RightDockable">1</property>
-                                                <property name="TopDockable">1</property>
-                                                <property name="aui_layer"></property>
-                                                <property name="aui_name"></property>
-                                                <property name="aui_position"></property>
-                                                <property name="aui_row"></property>
-                                                <property name="best_size"></property>
-                                                <property name="bg"></property>
-                                                <property name="caption"></property>
-                                                <property name="caption_visible">1</property>
-                                                <property name="center_pane">0</property>
-                                                <property name="close_button">1</property>
-                                                <property name="context_help"></property>
-                                                <property name="context_menu">1</property>
-                                                <property name="default_pane">0</property>
-                                                <property name="dock">Dock</property>
-                                                <property name="dock_fixed">0</property>
-                                                <property name="docking">Left</property>
-                                                <property name="enabled">1</property>
-                                                <property name="fg"></property>
-                                                <property name="floatable">1</property>
-                                                <property name="font"></property>
-                                                <property name="gripper">0</property>
-                                                <property name="hidden">0</property>
-                                                <property name="id">wxID_ANY</property>
-                                                <property name="label">Co&amp;nnect without providing a client certificate</property>
-                                                <property name="max_size"></property>
-                                                <property name="maximize_button">0</property>
-                                                <property name="maximum_size"></property>
-                                                <property name="min_size"></property>
-                                                <property name="minimize_button">0</property>
-                                                <property name="minimum_size"></property>
-                                                <property name="moveable">1</property>
-                                                <property name="name">m_cert_none</property>
-                                                <property name="pane_border">1</property>
-                                                <property name="pane_position"></property>
-                                                <property name="pane_size"></property>
-                                                <property name="permission">protected</property>
-                                                <property name="pin_button">1</property>
-                                                <property name="pos"></property>
-                                                <property name="resize">Resizable</property>
-                                                <property name="show">1</property>
-                                                <property name="size"></property>
-                                                <property name="style">wxRB_GROUP</property>
-                                                <property name="subclass"></property>
-                                                <property name="toolbar_pane">0</property>
-                                                <property name="tooltip">Select if your server does not require you to provide a client certificate</property>
-                                                <property name="validator_data_type"></property>
-                                                <property name="validator_style">wxFILTER_NONE</property>
-                                                <property name="validator_type">wxDefaultValidator</property>
-                                                <property name="validator_variable"></property>
-                                                <property name="value">0</property>
-                                                <property name="window_extra_style"></property>
-                                                <property name="window_name"></property>
-                                                <property name="window_style"></property>
-                                                <event name="OnChar"></event>
-                                                <event name="OnEnterWindow"></event>
-                                                <event name="OnEraseBackground"></event>
-                                                <event name="OnKeyDown"></event>
-                                                <event name="OnKeyUp"></event>
-                                                <event name="OnKillFocus"></event>
-                                                <event name="OnLeaveWindow"></event>
-                                                <event name="OnLeftDClick"></event>
-                                                <event name="OnLeftDown"></event>
-                                                <event name="OnLeftUp"></event>
-                                                <event name="OnMiddleDClick"></event>
-                                                <event name="OnMiddleDown"></event>
-                                                <event name="OnMiddleUp"></event>
-                                                <event name="OnMotion"></event>
-                                                <event name="OnMouseEvents"></event>
-                                                <event name="OnMouseWheel"></event>
-                                                <event name="OnPaint"></event>
-                                                <event name="OnRadioButton"></event>
-                                                <event name="OnRightDClick"></event>
-                                                <event name="OnRightDown"></event>
-                                                <event name="OnRightUp"></event>
-                                                <event name="OnSetFocus"></event>
-                                                <event name="OnSize"></event>
-                                                <event name="OnUpdateUI"></event>
-                                            </object>
-                                        </object>
-                                        <object class="sizeritem" expanded="1">
-                                            <property name="border">5</property>
-                                            <property name="flag">wxEXPAND</property>
-                                            <property name="proportion">1</property>
-                                            <object class="wxBoxSizer" expanded="1">
-                                                <property name="minimum_size"></property>
-                                                <property name="name">sb_cert_select</property>
-                                                <property name="orient">wxHORIZONTAL</property>
-                                                <property name="permission">none</property>
-                                                <object class="sizeritem" expanded="1">
-                                                    <property name="border">5</property>
-                                                    <property name="flag">wxEXPAND</property>
-                                                    <property name="proportion">0</property>
-                                                    <object class="wxRadioButton" expanded="1">
-                                                        <property name="BottomDockable">1</property>
-                                                        <property name="LeftDockable">1</property>
-                                                        <property name="RightDockable">1</property>
-                                                        <property name="TopDockable">1</property>
-                                                        <property name="aui_layer"></property>
-                                                        <property name="aui_name"></property>
-                                                        <property name="aui_position"></property>
-                                                        <property name="aui_row"></property>
-                                                        <property name="best_size"></property>
-                                                        <property name="bg"></property>
-                                                        <property name="caption"></property>
-                                                        <property name="caption_visible">1</property>
-                                                        <property name="center_pane">0</property>
-                                                        <property name="close_button">1</property>
-                                                        <property name="context_help"></property>
-                                                        <property name="context_menu">1</property>
-                                                        <property name="default_pane">0</property>
-                                                        <property name="dock">Dock</property>
-                                                        <property name="dock_fixed">0</property>
-                                                        <property name="docking">Left</property>
-                                                        <property name="enabled">1</property>
-                                                        <property name="fg"></property>
-                                                        <property name="floatable">1</property>
-                                                        <property name="font"></property>
-                                                        <property name="gripper">0</property>
-                                                        <property name="hidden">0</property>
-                                                        <property name="id">wxID_ANY</property>
-                                                        <property name="label">Use the following &amp;certificate:</property>
-                                                        <property name="max_size"></property>
-                                                        <property name="maximize_button">0</property>
-                                                        <property name="maximum_size"></property>
-                                                        <property name="min_size"></property>
-                                                        <property name="minimize_button">0</property>
-                                                        <property name="minimum_size"></property>
-                                                        <property name="moveable">1</property>
-                                                        <property name="name">m_cert_select</property>
-                                                        <property name="pane_border">1</property>
-                                                        <property name="pane_position"></property>
-                                                        <property name="pane_size"></property>
-                                                        <property name="permission">protected</property>
-                                                        <property name="pin_button">1</property>
-                                                        <property name="pos"></property>
-                                                        <property name="resize">Resizable</property>
-                                                        <property name="show">1</property>
-                                                        <property name="size"></property>
-                                                        <property name="style"></property>
-                                                        <property name="subclass"></property>
-                                                        <property name="toolbar_pane">0</property>
-                                                        <property name="tooltip">Select if you need to provide a client certificate when connecting</property>
-                                                        <property name="validator_data_type"></property>
-                                                        <property name="validator_style">wxFILTER_NONE</property>
-                                                        <property name="validator_type">wxDefaultValidator</property>
-                                                        <property name="validator_variable"></property>
-                                                        <property name="value">0</property>
-                                                        <property name="window_extra_style"></property>
-                                                        <property name="window_name"></property>
-                                                        <property name="window_style"></property>
-                                                        <event name="OnChar"></event>
-                                                        <event name="OnEnterWindow"></event>
-                                                        <event name="OnEraseBackground"></event>
-                                                        <event name="OnKeyDown"></event>
-                                                        <event name="OnKeyUp"></event>
-                                                        <event name="OnKillFocus"></event>
-                                                        <event name="OnLeaveWindow"></event>
-                                                        <event name="OnLeftDClick"></event>
-                                                        <event name="OnLeftDown"></event>
-                                                        <event name="OnLeftUp"></event>
-                                                        <event name="OnMiddleDClick"></event>
-                                                        <event name="OnMiddleDown"></event>
-                                                        <event name="OnMiddleUp"></event>
-                                                        <event name="OnMotion"></event>
-                                                        <event name="OnMouseEvents"></event>
-                                                        <event name="OnMouseWheel"></event>
-                                                        <event name="OnPaint"></event>
-                                                        <event name="OnRadioButton"></event>
-                                                        <event name="OnRightDClick"></event>
-                                                        <event name="OnRightDown"></event>
-                                                        <event name="OnRightUp"></event>
-                                                        <event name="OnSetFocus"></event>
-                                                        <event name="OnSize"></event>
-                                                        <event name="OnUpdateUI"></event>
-                                                    </object>
-                                                </object>
-                                                <object class="sizeritem" expanded="1">
-                                                    <property name="border">5</property>
-                                                    <property name="flag">wxEXPAND</property>
-                                                    <property name="proportion">1</property>
-                                                    <object class="wxChoice" expanded="1">
-                                                        <property name="BottomDockable">1</property>
-                                                        <property name="LeftDockable">1</property>
-                                                        <property name="RightDockable">1</property>
-                                                        <property name="TopDockable">1</property>
-                                                        <property name="aui_layer"></property>
-                                                        <property name="aui_name"></property>
-                                                        <property name="aui_position"></property>
-                                                        <property name="aui_row"></property>
-                                                        <property name="best_size"></property>
-                                                        <property name="bg"></property>
-                                                        <property name="caption"></property>
-                                                        <property name="caption_visible">1</property>
-                                                        <property name="center_pane">0</property>
-                                                        <property name="choices"></property>
-                                                        <property name="close_button">1</property>
-                                                        <property name="context_help"></property>
-                                                        <property name="context_menu">1</property>
-                                                        <property name="default_pane">0</property>
-                                                        <property name="dock">Dock</property>
-                                                        <property name="dock_fixed">0</property>
-                                                        <property name="docking">Left</property>
-                                                        <property name="enabled">1</property>
-                                                        <property name="fg"></property>
-                                                        <property name="floatable">1</property>
-                                                        <property name="font"></property>
-                                                        <property name="gripper">0</property>
-                                                        <property name="hidden">0</property>
-                                                        <property name="id">wxID_ANY</property>
-                                                        <property name="max_size"></property>
-                                                        <property name="maximize_button">0</property>
-                                                        <property name="maximum_size"></property>
-                                                        <property name="min_size"></property>
-                                                        <property name="minimize_button">0</property>
-                                                        <property name="minimum_size"></property>
-                                                        <property name="moveable">1</property>
-                                                        <property name="name">m_cert_select_val</property>
-                                                        <property name="pane_border">1</property>
-                                                        <property name="pane_position"></property>
-                                                        <property name="pane_size"></property>
-                                                        <property name="permission">protected</property>
-                                                        <property name="pin_button">1</property>
-                                                        <property name="pos"></property>
-                                                        <property name="resize">Resizable</property>
-                                                        <property name="selection">0</property>
-                                                        <property name="show">1</property>
-                                                        <property name="size"></property>
-                                                        <property name="style">wxCB_SORT</property>
-                                                        <property name="subclass">; </property>
-                                                        <property name="toolbar_pane">0</property>
-                                                        <property name="tooltip">Client certificate to use for authentication</property>
-                                                        <property name="validator_data_type"></property>
-                                                        <property name="validator_style">wxFILTER_NONE</property>
-                                                        <property name="validator_type">wxDefaultValidator</property>
-                                                        <property name="validator_variable"></property>
-                                                        <property name="window_extra_style"></property>
-                                                        <property name="window_name"></property>
-                                                        <property name="window_style"></property>
-                                                        <event name="OnChar"></event>
-                                                        <event name="OnChoice"></event>
-                                                        <event name="OnEnterWindow"></event>
-                                                        <event name="OnEraseBackground"></event>
-                                                        <event name="OnKeyDown"></event>
-                                                        <event name="OnKeyUp"></event>
-                                                        <event name="OnKillFocus"></event>
-                                                        <event name="OnLeaveWindow"></event>
-                                                        <event name="OnLeftDClick"></event>
-                                                        <event name="OnLeftDown"></event>
-                                                        <event name="OnLeftUp"></event>
-                                                        <event name="OnMiddleDClick"></event>
-                                                        <event name="OnMiddleDown"></event>
-                                                        <event name="OnMiddleUp"></event>
-                                                        <event name="OnMotion"></event>
-                                                        <event name="OnMouseEvents"></event>
-                                                        <event name="OnMouseWheel"></event>
-                                                        <event name="OnPaint"></event>
-                                                        <event name="OnRightDClick"></event>
-                                                        <event name="OnRightDown"></event>
-                                                        <event name="OnRightUp"></event>
-                                                        <event name="OnSetFocus"></event>
-                                                        <event name="OnSize"></event>
-                                                        <event name="OnUpdateUI"></event>
-                                                    </object>
-                                                </object>
-                                            </object>
-                                        </object>
+                                        <property name="moveable">1</property>
+                                        <property name="name">m_certificate</property>
+                                        <property name="pane_border">1</property>
+                                        <property name="pane_position"></property>
+                                        <property name="pane_size"></property>
+                                        <property name="permission">protected</property>
+                                        <property name="pin_button">1</property>
+                                        <property name="pos"></property>
+                                        <property name="resize">Resizable</property>
+                                        <property name="selection">0</property>
+                                        <property name="show">1</property>
+                                        <property name="size"></property>
+                                        <property name="style">wxCB_SORT</property>
+                                        <property name="subclass"></property>
+                                        <property name="toolbar_pane">0</property>
+                                        <property name="tooltip">Client certificate to use for authentication</property>
+                                        <property name="validator_data_type"></property>
+                                        <property name="validator_style">wxFILTER_NONE</property>
+                                        <property name="validator_type">wxDefaultValidator</property>
+                                        <property name="validator_variable"></property>
+                                        <property name="window_extra_style"></property>
+                                        <property name="window_name"></property>
+                                        <property name="window_style"></property>
+                                        <event name="OnChar"></event>
+                                        <event name="OnChoice"></event>
+                                        <event name="OnEnterWindow"></event>
+                                        <event name="OnEraseBackground"></event>
+                                        <event name="OnKeyDown"></event>
+                                        <event name="OnKeyUp"></event>
+                                        <event name="OnKillFocus"></event>
+                                        <event name="OnLeaveWindow"></event>
+                                        <event name="OnLeftDClick"></event>
+                                        <event name="OnLeftDown"></event>
+                                        <event name="OnLeftUp"></event>
+                                        <event name="OnMiddleDClick"></event>
+                                        <event name="OnMiddleDown"></event>
+                                        <event name="OnMiddleUp"></event>
+                                        <event name="OnMotion"></event>
+                                        <event name="OnMouseEvents"></event>
+                                        <event name="OnMouseWheel"></event>
+                                        <event name="OnPaint"></event>
+                                        <event name="OnRightDClick"></event>
+                                        <event name="OnRightDown"></event>
+                                        <event name="OnRightUp"></event>
+                                        <event name="OnSetFocus"></event>
+                                        <event name="OnSize"></event>
+                                        <event name="OnUpdateUI"></event>
                                     </object>
                                 </object>
                                 <object class="sizeritem" expanded="1">
                                     <property name="border">5</property>
                                     <property name="flag">wxEXPAND|wxALL</property>
-                                    <property name="proportion">1</property>
+                                    <property name="proportion">0</property>
                                     <object class="wxBoxSizer" expanded="1">
                                         <property name="minimum_size"></property>
                                         <property name="name">sb_identity</property>
@@ -1621,7 +1423,7 @@
                                         </object>
                                         <object class="sizeritem" expanded="1">
                                             <property name="border">5</property>
-                                            <property name="flag">wxEXPAND|wxBOTTOM</property>
+                                            <property name="flag">wxEXPAND</property>
                                             <property name="proportion">0</property>
                                             <object class="wxTextCtrl" expanded="1">
                                                 <property name="BottomDockable">1</property>
@@ -1710,177 +1512,6 @@
                                                 <event name="OnUpdateUI"></event>
                                             </object>
                                         </object>
-                                        <object class="sizeritem" expanded="1">
-                                            <property name="border">5</property>
-                                            <property name="flag">wxALIGN_RIGHT</property>
-                                            <property name="proportion">0</property>
-                                            <object class="wxStaticText" expanded="1">
-                                                <property name="BottomDockable">1</property>
-                                                <property name="LeftDockable">1</property>
-                                                <property name="RightDockable">1</property>
-                                                <property name="TopDockable">1</property>
-                                                <property name="aui_layer"></property>
-                                                <property name="aui_name"></property>
-                                                <property name="aui_position"></property>
-                                                <property name="aui_row"></property>
-                                                <property name="best_size"></property>
-                                                <property name="bg"></property>
-                                                <property name="caption"></property>
-                                                <property name="caption_visible">1</property>
-                                                <property name="center_pane">0</property>
-                                                <property name="close_button">1</property>
-                                                <property name="context_help"></property>
-                                                <property name="context_menu">1</property>
-                                                <property name="default_pane">0</property>
-                                                <property name="dock">Dock</property>
-                                                <property name="dock_fixed">0</property>
-                                                <property name="docking">Left</property>
-                                                <property name="enabled">1</property>
-                                                <property name="fg"></property>
-                                                <property name="floatable">1</property>
-                                                <property name="font"></property>
-                                                <property name="gripper">0</property>
-                                                <property name="hidden">0</property>
-                                                <property name="id">wxID_ANY</property>
-                                                <property name="label">(Example: user@contoso.com)</property>
-                                                <property name="max_size"></property>
-                                                <property name="maximize_button">0</property>
-                                                <property name="maximum_size"></property>
-                                                <property name="min_size"></property>
-                                                <property name="minimize_button">0</property>
-                                                <property name="minimum_size"></property>
-                                                <property name="moveable">1</property>
-                                                <property name="name">m_identity_note</property>
-                                                <property name="pane_border">1</property>
-                                                <property name="pane_position"></property>
-                                                <property name="pane_size"></property>
-                                                <property name="permission">protected</property>
-                                                <property name="pin_button">1</property>
-                                                <property name="pos"></property>
-                                                <property name="resize">Resizable</property>
-                                                <property name="show">1</property>
-                                                <property name="size"></property>
-                                                <property name="style"></property>
-                                                <property name="subclass"></property>
-                                                <property name="toolbar_pane">0</property>
-                                                <property name="tooltip"></property>
-                                                <property name="window_extra_style"></property>
-                                                <property name="window_name"></property>
-                                                <property name="window_style"></property>
-                                                <property name="wrap">-1</property>
-                                                <event name="OnChar"></event>
-                                                <event name="OnEnterWindow"></event>
-                                                <event name="OnEraseBackground"></event>
-                                                <event name="OnKeyDown"></event>
-                                                <event name="OnKeyUp"></event>
-                                                <event name="OnKillFocus"></event>
-                                                <event name="OnLeaveWindow"></event>
-                                                <event name="OnLeftDClick"></event>
-                                                <event name="OnLeftDown"></event>
-                                                <event name="OnLeftUp"></event>
-                                                <event name="OnMiddleDClick"></event>
-                                                <event name="OnMiddleDown"></event>
-                                                <event name="OnMiddleUp"></event>
-                                                <event name="OnMotion"></event>
-                                                <event name="OnMouseEvents"></event>
-                                                <event name="OnMouseWheel"></event>
-                                                <event name="OnPaint"></event>
-                                                <event name="OnRightDClick"></event>
-                                                <event name="OnRightDown"></event>
-                                                <event name="OnRightUp"></event>
-                                                <event name="OnSetFocus"></event>
-                                                <event name="OnSize"></event>
-                                                <event name="OnUpdateUI"></event>
-                                            </object>
-                                        </object>
-                                    </object>
-                                </object>
-                                <object class="sizeritem" expanded="1">
-                                    <property name="border">5</property>
-                                    <property name="flag">wxALL|wxEXPAND</property>
-                                    <property name="proportion">0</property>
-                                    <object class="wxCheckBox" expanded="1">
-                                        <property name="BottomDockable">1</property>
-                                        <property name="LeftDockable">1</property>
-                                        <property name="RightDockable">1</property>
-                                        <property name="TopDockable">1</property>
-                                        <property name="aui_layer"></property>
-                                        <property name="aui_name"></property>
-                                        <property name="aui_position"></property>
-                                        <property name="aui_row"></property>
-                                        <property name="best_size"></property>
-                                        <property name="bg"></property>
-                                        <property name="caption"></property>
-                                        <property name="caption_visible">1</property>
-                                        <property name="center_pane">0</property>
-                                        <property name="checked">0</property>
-                                        <property name="close_button">1</property>
-                                        <property name="context_help">Check if you would like to save certificate selection</property>
-                                        <property name="context_menu">1</property>
-                                        <property name="default_pane">0</property>
-                                        <property name="dock">Dock</property>
-                                        <property name="dock_fixed">0</property>
-                                        <property name="docking">Left</property>
-                                        <property name="enabled">1</property>
-                                        <property name="fg"></property>
-                                        <property name="floatable">1</property>
-                                        <property name="font"></property>
-                                        <property name="gripper">0</property>
-                                        <property name="hidden">0</property>
-                                        <property name="id">wxID_ANY</property>
-                                        <property name="label">&amp;Remember</property>
-                                        <property name="max_size"></property>
-                                        <property name="maximize_button">0</property>
-                                        <property name="maximum_size"></property>
-                                        <property name="min_size"></property>
-                                        <property name="minimize_button">0</property>
-                                        <property name="minimum_size"></property>
-                                        <property name="moveable">1</property>
-                                        <property name="name">m_remember</property>
-                                        <property name="pane_border">1</property>
-                                        <property name="pane_position"></property>
-                                        <property name="pane_size"></property>
-                                        <property name="permission">protected</property>
-                                        <property name="pin_button">1</property>
-                                        <property name="pos"></property>
-                                        <property name="resize">Resizable</property>
-                                        <property name="show">1</property>
-                                        <property name="size"></property>
-                                        <property name="style"></property>
-                                        <property name="subclass"></property>
-                                        <property name="toolbar_pane">0</property>
-                                        <property name="tooltip"></property>
-                                        <property name="validator_data_type"></property>
-                                        <property name="validator_style">wxFILTER_NONE</property>
-                                        <property name="validator_type">wxDefaultValidator</property>
-                                        <property name="validator_variable"></property>
-                                        <property name="window_extra_style"></property>
-                                        <property name="window_name"></property>
-                                        <property name="window_style"></property>
-                                        <event name="OnChar"></event>
-                                        <event name="OnCheckBox"></event>
-                                        <event name="OnEnterWindow"></event>
-                                        <event name="OnEraseBackground"></event>
-                                        <event name="OnKeyDown"></event>
-                                        <event name="OnKeyUp"></event>
-                                        <event name="OnKillFocus"></event>
-                                        <event name="OnLeaveWindow"></event>
-                                        <event name="OnLeftDClick"></event>
-                                        <event name="OnLeftDown"></event>
-                                        <event name="OnLeftUp"></event>
-                                        <event name="OnMiddleDClick"></event>
-                                        <event name="OnMiddleDown"></event>
-                                        <event name="OnMiddleUp"></event>
-                                        <event name="OnMotion"></event>
-                                        <event name="OnMouseEvents"></event>
-                                        <event name="OnMouseWheel"></event>
-                                        <event name="OnPaint"></event>
-                                        <event name="OnRightDClick"></event>
-                                        <event name="OnRightDown"></event>
-                                        <event name="OnRightUp"></event>
-                                        <event name="OnSetFocus"></event>
-                                        <event name="OnSize"></event>
-                                        <event name="OnUpdateUI"></event>
                                     </object>
                                 </object>
                             </object>

lib/TLS_UI/res/wxTLS_UI.h

@@ -11,6 +11,9 @@
 #include <wx/artprov.h>
 #include <wx/xrc/xmlres.h>
 #include <wx/intl.h>
+class wxEAPCredentialsPanelBase;
+
+#include "../../EAPBase_UI/include/wxEAP_UIBase.h"
 #include <wx/bitmap.h>
 #include <wx/image.h>
 #include <wx/icon.h>
@@ -27,16 +30,14 @@
 #include <wx/textctrl.h>
 #include <wx/statbox.h>
 #include <wx/panel.h>
-#include <wx/radiobut.h>
 #include <wx/choice.h>
-#include <wx/checkbox.h>
 
 ///////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////////////////////////////////
-/// Class wxEAPTLSServerTrustConfigPanelBase
+/// Class wxTLSServerTrustPanelBase
 ///////////////////////////////////////////////////////////////////////////////
-class wxEAPTLSServerTrustConfigPanelBase : public wxPanel 
+class wxTLSServerTrustPanelBase : public wxPanel 
 {
 	private:
 	
@@ -62,28 +63,26 @@ class wxEAPTLSServerTrustConfigPanelBase : public wxPanel
 	
 	public:
 		
-		wxEAPTLSServerTrustConfigPanelBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( 500,-1 ), long style = wxTAB_TRAVERSAL ); 
-		~wxEAPTLSServerTrustConfigPanelBase();
+		wxTLSServerTrustPanelBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( 500,-1 ), long style = wxTAB_TRAVERSAL ); 
+		~wxTLSServerTrustPanelBase();
 	
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 /// Class wxTLSCredentialsPanelBase
 ///////////////////////////////////////////////////////////////////////////////
-class wxTLSCredentialsPanelBase : public wxPanel 
+class wxTLSCredentialsPanelBase : public wxEAPCredentialsPanelBase
 {
 	private:
 	
 	protected:
+		wxStaticBoxSizer* m_sb_credentials;
 		wxStaticBitmap* m_credentials_icon;
-		wxStaticText* m_credentials_label;
-		wxRadioButton* m_cert_none;
-		wxRadioButton* m_cert_select;
-		wxChoice* m_cert_select_val;
+		wxBoxSizer* m_sb_credentials_vert;
+		wxStaticText* m_certificate_label;
+		wxChoice* m_certificate;
 		wxStaticText* m_identity_label;
 		wxTextCtrl* m_identity;
-		wxStaticText* m_identity_note;
-		wxCheckBox* m_remember;
 		
 		// Virtual event handlers, overide them in your derived class
 		virtual void OnUpdateUI( wxUpdateUIEvent& event ) { event.Skip(); }

lib/TLS_UI/src/TLS_UI.cpp

@@ -316,14 +316,15 @@ wxTLSCredentialsPanel::wxTLSCredentialsPanel(const eap::config_provider &prov, c
 {
     // Load and set icon.
     winstd::library lib_shell32;
-    if (lib_shell32.load(_T("shell32.dll"), NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE))
-        m_credentials_icon->SetIcon(wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(269)));
+    if (lib_shell32.load(_T("certmgr.dll"), NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE))
+        m_credentials_icon->SetIcon(wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(6170)));
 }
 
 
 bool wxTLSCredentialsPanel::TransferDataToWindow()
 {
     // Populate certificate list.
+    m_certificate->Append(_("<empty>"), (wxCertificateClientData*)NULL);
     bool is_found = false;
     winstd::cert_store store;
     if (store.create(CERT_STORE_PROV_SYSTEM, X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, (HCRYPTPROV)NULL, CERT_SYSTEM_STORE_CURRENT_USER, _T("My"))) {
@@ -343,21 +344,16 @@ bool wxTLSCredentialsPanel::TransferDataToWindow()
                 m_cred.m_cert->cbCertEncoded == data->m_cert->cbCertEncoded &&
                 memcmp(m_cred.m_cert->pbCertEncoded, data->m_cert->pbCertEncoded, m_cred.m_cert->cbCertEncoded) == 0;
             winstd::tstring name(std::move(eap::get_cert_title(cert)));
-            int i = m_cert_select_val->Append(name, data.release());
+            int i = m_certificate->Append(name, data.release());
             if (is_selected) {
-                m_cert_select_val->SetSelection(i);
+                m_certificate->SetSelection(i);
                 is_found = true;
             }
         }
     }
 
-    if (is_found) {
-        m_cert_select->SetValue(true);
-    } else {
-        m_cert_none->SetValue(true);
-        if (!m_cert_select_val->IsEmpty())
-            m_cert_select_val->SetSelection(0);
-    }
+    if (!is_found)
+        m_certificate->SetSelection(0);
 
     m_identity->SetValue(m_cred.m_identity);
 
@@ -367,15 +363,16 @@ bool wxTLSCredentialsPanel::TransferDataToWindow()
 
 bool wxTLSCredentialsPanel::TransferDataFromWindow()
 {
-    if (m_cert_none->GetValue())
+    // Check if m_certificate control has selected item, and has client object data (at least one user certificate on the list). Then try to get the data from selected item.
+    int sel = m_certificate->GetSelection();
+    const wxCertificateClientData *data =
+        sel != wxNOT_FOUND && m_certificate->HasClientObjectData() ?
+            dynamic_cast<const wxCertificateClientData*>(m_certificate->GetClientObject(sel)) :
+            NULL;
+    if (data)
+        m_cred.m_cert.attach_duplicated(data->m_cert);
+    else
         m_cred.m_cert.free();
-    else {
-        const wxCertificateClientData *data = dynamic_cast<const wxCertificateClientData*>(m_cert_select_val->GetClientObject(m_cert_select_val->GetSelection()));
-        if (data)
-            m_cred.m_cert.attach_duplicated(data->m_cert);
-        else
-            m_cred.m_cert.free();
-    }
 
     m_cred.m_identity = m_identity->GetValue();
 
@@ -387,22 +384,14 @@ bool wxTLSCredentialsPanel::TransferDataFromWindow()
 
 void wxTLSCredentialsPanel::OnUpdateUI(wxUpdateUIEvent& /*event*/)
 {
-    if (!m_is_config && m_cfg.m_use_preshared) {
-        // Credential prompt mode & Using pre-shared credentials
-        // To avoid run-away selection of radio buttons, disable the selected one last.
-        if (m_cert_none->GetValue()) {
-            m_cert_select->Enable(false);
-            m_cert_none  ->Enable(false);
-        } else {
-            m_cert_none  ->Enable(false);
-            m_cert_select->Enable(false);
-        }
-        m_cert_select_val->Enable(false);
-        m_identity->Enable(false);
+    if (!m_is_config && m_cfg.m_use_cred) {
+        // Credential prompt mode & Using configured credentials
+        m_certificate->Enable(false);
+        m_identity   ->Enable(false);
     } else {
-        // Configuration mode or using own credentials. Selectively enable/disable controls.
-        m_cert_select_val->Enable(m_cert_select->GetValue());
-        m_identity->Enable(true);
+        // Configuration mode or using stored credentials. Enable controls.
+        m_certificate->Enable(true);
+        m_identity   ->Enable(true);
     }
 }
 
@@ -414,12 +403,12 @@ void wxTLSCredentialsPanel::OnUpdateUI(wxUpdateUIEvent& /*event*/)
 wxTLSServerTrustPanel::wxTLSServerTrustPanel(const eap::config_provider &prov, eap::config_method_tls &cfg, wxWindow* parent) :
     m_prov(prov),
     m_cfg(cfg),
-    wxEAPTLSServerTrustConfigPanelBase(parent)
+    wxTLSServerTrustPanelBase(parent)
 {
     // Load and set icon.
     winstd::library lib_certmgr;
     if (lib_certmgr.load(_T("certmgr.dll"), NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE))
-        m_server_trust_icon->SetIcon(wxLoadIconFromResource(lib_certmgr, MAKEINTRESOURCE(218)));
+        m_server_trust_icon->SetIcon(wxLoadIconFromResource(lib_certmgr, MAKEINTRESOURCE(379)));
 
     // Do not use cfg.m_server_names directly, so we can decide not to store the value in case of provider-locked configuration.
     // Never rely on control disabled state alone, as they can be enabled using external tool like Spy++.
@@ -436,13 +425,13 @@ bool wxTLSServerTrustPanel::TransferDataToWindow()
     // Set server acceptable names. The edit control will get populated by validator.
     m_server_names_val = m_cfg.m_server_names;
 
-    return wxEAPTLSServerTrustConfigPanelBase::TransferDataToWindow();
+    return wxTLSServerTrustPanelBase::TransferDataToWindow();
 }
 
 
 bool wxTLSServerTrustPanel::TransferDataFromWindow()
 {
-    wxCHECK(wxEAPTLSServerTrustConfigPanelBase::TransferDataFromWindow(), false);
+    wxCHECK(wxTLSServerTrustPanelBase::TransferDataFromWindow(), false);
 
     if (!m_prov.m_read_only) {
         // This is not a provider-locked configuration. Save the data.
@@ -579,7 +568,7 @@ wxTLSConfigPanel::wxTLSConfigPanel(const eap::config_provider &prov, eap::config
     m_server_trust = new wxTLSServerTrustPanel(prov, cfg, this);
     sb_content->Add(m_server_trust, 0, wxDOWN|wxEXPAND, 5);
 
-    m_credentials = new wxTLSCredentialsConfigPanel(prov, cfg, this);
+    m_credentials = new wxTLSCredentialsConfigPanel(prov, cfg, this, _("User Certificate"));
     sb_content->Add(m_credentials, 0, wxUP|wxEXPAND, 5);
 
     this->SetSizer(sb_content);

lib/TTLS/include/Credentials.h

@@ -180,9 +180,9 @@ namespace eap
         /// \param[in] pszTargetName  The name in Windows Credential Manager to retrieve credentials from (optional, can be \c NULL)
         ///
         /// \returns
-        /// - \c source_cache      Credentials were obtained from EapHost cache
-        /// - \c source_preshared  Credentials were set by method configuration
-        /// - \c source_storage    Credentials were loaded from Windows Credential Manager
+        /// - \c source_cache   Credentials were obtained from EapHost cache
+        /// - \c source_config  Credentials were set by method configuration
+        /// - \c source_storage Credentials were loaded from Windows Credential Manager
         ///
         virtual source_t combine(
             _In_       const credentials             *cred_cached,

lib/TTLS/include/Method.h

@@ -40,6 +40,8 @@ namespace eap
 {
     class method_ttls : public method_tls
     {
+        WINSTD_NONCOPYABLE(method_ttls)
+
     public:
         ///
         /// Constructs an EAP method

lib/TTLS/include/Module.h

@@ -37,6 +37,8 @@ namespace eap
 {
     class peer_ttls : public peer
     {
+        WINSTD_NONCOPYABLE(peer_ttls)
+
     public:
         ///
         /// Constructs a EAP TTLS peer module

lib/TTLS/src/Config.cpp

@@ -32,8 +32,8 @@ eap::config_method_ttls::config_method_ttls(_In_ module &mod, _In_ unsigned int
     m_inner(new config_method_pap(mod, level + 1)),
     config_method_tls(mod, level)
 {
-    // TTLS is using blank pre-shared credentials per default.
-    m_use_preshared = true;
+    // TTLS is using blank configured credentials per default.
+    m_use_cred = true;
 }
 
 
@@ -94,7 +94,7 @@ void eap::config_method_ttls::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode
 
     // <ClientSideCredential>
     com_obj<IXMLDOMElement> pXmlElClientSideCredential;
-    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:ClientSideCredential"), bstr(L"ClientSideCredential"), namespace_eapmetadata, &pXmlElClientSideCredential)))
+    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:ClientSideCredential"), bstr(L"ClientSideCredential"), namespace_eapmetadata, pXmlElClientSideCredential)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <ClientSideCredential> element.");
 
     // <ClientSideCredential>/<AnonymousIdentity>
@@ -104,7 +104,7 @@ void eap::config_method_ttls::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode
 
     // <InnerAuthenticationMethod>
     com_obj<IXMLDOMElement> pXmlElInnerAuthenticationMethod;
-    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:InnerAuthenticationMethod"), bstr(L"InnerAuthenticationMethod"), namespace_eapmetadata, &pXmlElInnerAuthenticationMethod)))
+    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:InnerAuthenticationMethod"), bstr(L"InnerAuthenticationMethod"), namespace_eapmetadata, pXmlElInnerAuthenticationMethod)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <InnerAuthenticationMethod> element.");
 
     eap_type_t eap_type = m_inner->get_method_id();
@@ -123,20 +123,20 @@ void eap::config_method_ttls::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode
 
     {
         com_obj<IXMLDOMNode> pXmlElClientSideCredential;
-        if (SUCCEEDED(hr = eapxml::select_node(pConfigRoot, bstr(L"eap-metadata:ClientSideCredential"), &pXmlElClientSideCredential))) {
-            // Fix 1: Pre-shared outer credentials in draft-winter-opsawg-eap-metadata has some bizarre presence/absence/blank logic for EAP-TTLS methods only.
+        if (SUCCEEDED(hr = eapxml::select_node(pConfigRoot, bstr(L"eap-metadata:ClientSideCredential"), pXmlElClientSideCredential))) {
+            // Fix 1: Configured outer credentials in draft-winter-opsawg-eap-metadata has some bizarre presence/absence/blank logic for EAP-TTLS methods only.
             // To keep our code clean, we do some post-processing, to make draft compliant XML on output, while keeping things simple on the inside.
-            if (m_use_preshared && m_preshared->empty()) {
-                // For empty pre-shared client certificate <ClientCertificate/> must not be present.
+            if (m_use_cred && m_cred->empty()) {
+                // For empty configured client certificate <ClientCertificate/> must not be present.
                 com_obj<IXMLDOMNode> pXmlElClientCertificate;
-                if (SUCCEEDED(hr = eapxml::select_node(pXmlElClientSideCredential, bstr(L"eap-metadata:ClientCertificate"), &pXmlElClientCertificate))) {
+                if (SUCCEEDED(hr = eapxml::select_node(pXmlElClientSideCredential, bstr(L"eap-metadata:ClientCertificate"), pXmlElClientCertificate))) {
                     com_obj<IXMLDOMNode> pXmlElClientCertificateOld;
                     hr = pXmlElClientSideCredential->removeChild(pXmlElClientCertificate, &pXmlElClientCertificateOld);
                 }
-            } else if (!m_use_preshared) {
-                // When not using pre-shared (user must supply one), add empty <ClientCertificate/>.
+            } else if (!m_use_cred) {
+                // When not using configured client certificate (user must supply one), add empty <ClientCertificate/>.
                 com_obj<IXMLDOMElement> pXmlElClientCertificate;
-                hr = eapxml::create_element(pDoc, pXmlElClientSideCredential, bstr(L"eap-metadata:ClientCertificate"), bstr(L"ClientCertificate"), namespace_eapmetadata, &pXmlElClientCertificate);
+                hr = eapxml::create_element(pDoc, pXmlElClientSideCredential, bstr(L"eap-metadata:ClientCertificate"), bstr(L"ClientCertificate"), namespace_eapmetadata, pXmlElClientCertificate);
             }
         }
     }
@@ -150,23 +150,23 @@ void eap::config_method_ttls::load(_In_ IXMLDOMNode *pConfigRoot)
 
     {
         com_obj<IXMLDOMNode> pXmlElClientSideCredential;
-        if (SUCCEEDED(hr = eapxml::select_node(pConfigRoot, bstr(L"eap-metadata:ClientSideCredential"), &pXmlElClientSideCredential))) {
+        if (SUCCEEDED(hr = eapxml::select_node(pConfigRoot, bstr(L"eap-metadata:ClientSideCredential"), pXmlElClientSideCredential))) {
             com_obj<IXMLDOMDocument> pDoc;
             if (SUCCEEDED(hr = pXmlElClientSideCredential->get_ownerDocument(&pDoc))) {
-                // Fix 1: Pre-shared outer credentials in draft-winter-opsawg-eap-metadata has some bizarre presence/absence/blank logic for EAP-TTLS methods only.
+                // Fix 1: Configured outer credentials in draft-winter-opsawg-eap-metadata has some bizarre presence/absence/blank logic for EAP-TTLS methods only.
                 // To keep our code clean, we do some pre-processing, to accept draft compliant XML on input, while keeping things simple on the inside.
                 com_obj<IXMLDOMNode> pXmlElClientCertificate;
-                if (SUCCEEDED(hr = eapxml::select_node(pXmlElClientSideCredential, bstr(L"eap-metadata:ClientCertificate"), &pXmlElClientCertificate))) {
+                if (SUCCEEDED(hr = eapxml::select_node(pXmlElClientSideCredential, bstr(L"eap-metadata:ClientCertificate"), pXmlElClientCertificate))) {
                     VARIANT_BOOL has_children;
                     if (SUCCEEDED(hr = pXmlElClientCertificate->hasChildNodes(&has_children)) && !has_children) {
-                        // Empty <ClientCertificate/> means: do not use pre-shared credentials.
+                        // Empty <ClientCertificate/> means: do not use configured credentials.
                         com_obj<IXMLDOMNode> pXmlElClientCertificateOld;
                         hr = pXmlElClientSideCredential->removeChild(pXmlElClientCertificate, &pXmlElClientCertificateOld);
                     }
                 } else {
-                    // Nonexisting <ClientSideCredential> means: use blank pre-shared credentials.
+                    // Nonexisting <ClientSideCredential> means: use blank configured credentials.
                     com_obj<IXMLDOMElement> pXmlElClientCertificate;
-                    hr = eapxml::create_element(pDoc, pXmlElClientSideCredential, bstr(L"eap-metadata:ClientCertificate"), bstr(L"ClientCertificate"), namespace_eapmetadata, &pXmlElClientCertificate);
+                    hr = eapxml::create_element(pDoc, pXmlElClientSideCredential, bstr(L"eap-metadata:ClientCertificate"), bstr(L"ClientCertificate"), namespace_eapmetadata, pXmlElClientCertificate);
                 }
             }
         }
@@ -180,7 +180,7 @@ void eap::config_method_ttls::load(_In_ IXMLDOMNode *pConfigRoot)
 
     // <ClientSideCredential>
     com_obj<IXMLDOMElement> pXmlElClientSideCredential;
-    if (SUCCEEDED(eapxml::select_element(pConfigRoot, bstr(L"eap-metadata:ClientSideCredential"), &pXmlElClientSideCredential))) {
+    if (SUCCEEDED(eapxml::select_element(pConfigRoot, bstr(L"eap-metadata:ClientSideCredential"), pXmlElClientSideCredential))) {
         wstring xpathClientSideCredential(xpath + L"/ClientSideCredential");
 
         // <AnonymousIdentity>
@@ -190,18 +190,18 @@ void eap::config_method_ttls::load(_In_ IXMLDOMNode *pConfigRoot)
 
     // <InnerAuthenticationMethod>
     com_obj<IXMLDOMElement> pXmlElInnerAuthenticationMethod;
-    if (FAILED(hr = eapxml::select_element(pConfigRoot, bstr(L"eap-metadata:InnerAuthenticationMethod"), &pXmlElInnerAuthenticationMethod)))
+    if (FAILED(hr = eapxml::select_element(pConfigRoot, bstr(L"eap-metadata:InnerAuthenticationMethod"), pXmlElInnerAuthenticationMethod)))
         throw com_runtime_error(hr, __FUNCTION__ " Error selecting <InnerAuthenticationMethod> element.");
 
     // Determine inner authentication type (<EAPMethod> and <NonEAPAuthMethod>).
     DWORD dwMethod;
     bstr bstrMethod;
-    if (SUCCEEDED(eapxml::get_element_value(pXmlElInnerAuthenticationMethod, bstr(L"eap-metadata:EAPMethod"), &dwMethod)) &&
+    if (SUCCEEDED(eapxml::get_element_value(pXmlElInnerAuthenticationMethod, bstr(L"eap-metadata:EAPMethod"), dwMethod)) &&
         eap_type_start <= dwMethod && dwMethod < eap_type_end)
     {
         m_inner.reset(make_config_method((eap_type_t)dwMethod));
         m_module.log_config((xpath + L"/EAPMethod").c_str(), m_inner->get_method_str());
-    } else if (SUCCEEDED(eapxml::get_element_value(pXmlElInnerAuthenticationMethod, bstr(L"eap-metadata:NonEAPAuthMethod"), &bstrMethod))) {
+    } else if (SUCCEEDED(eapxml::get_element_value(pXmlElInnerAuthenticationMethod, bstr(L"eap-metadata:NonEAPAuthMethod"), bstrMethod))) {
         m_inner.reset(make_config_method(bstrMethod));
         m_module.log_config((xpath + L"/NonEAPAuthMethod").c_str(), m_inner->get_method_str());
     } else

lib/TTLS/src/Credentials.cpp

@@ -100,7 +100,7 @@ void eap::credentials_ttls::save(_In_ IXMLDOMDocument *pDoc, _In_ IXMLDOMNode *p
 
     // <InnerAuthenticationMethod>
     com_obj<IXMLDOMElement> pXmlElInnerAuthenticationMethod;
-    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:InnerAuthenticationMethod"), bstr(L"InnerAuthenticationMethod"), namespace_eapmetadata, &pXmlElInnerAuthenticationMethod)))
+    if (FAILED(hr = eapxml::create_element(pDoc, pConfigRoot, bstr(L"eap-metadata:InnerAuthenticationMethod"), bstr(L"InnerAuthenticationMethod"), namespace_eapmetadata, pXmlElInnerAuthenticationMethod)))
         throw com_runtime_error(hr, __FUNCTION__ " Error creating <InnerAuthenticationMethod> element.");
 
     // <InnerAuthenticationMethod>/...
@@ -117,7 +117,7 @@ void eap::credentials_ttls::load(_In_ IXMLDOMNode *pConfigRoot)
 
     // Load inner credentials.
     com_obj<IXMLDOMNode> pXmlElInnerAuthenticationMethod;
-    if (SUCCEEDED(hr = eapxml::select_node(pConfigRoot, bstr(L"eap-metadata:InnerAuthenticationMethod"), &pXmlElInnerAuthenticationMethod)))
+    if (SUCCEEDED(hr = eapxml::select_node(pConfigRoot, bstr(L"eap-metadata:InnerAuthenticationMethod"), pXmlElInnerAuthenticationMethod)))
         m_inner->load(pXmlElInnerAuthenticationMethod);
     else
         m_inner->clear();

lib/TTLS_UI/include/TTLS_UI.h

@@ -18,6 +18,11 @@
     along with GÉANTLink. If not, see <http://www.gnu.org/licenses/>.
 */
 
+///
+/// TTLS credential panel
+///
+class wxTTLSCredentialsPanel;
+
 ///
 /// TTLS configuration panel
 ///
@@ -28,11 +33,6 @@ class wxTTLSConfigPanel;
 ///
 class wxTTLSConfigWindow;
 
-///
-/// TTLS credential panel
-///
-class wxTTLSCredentialsPanel;
-
 #pragma once
 
 #include "../res/wxTTLS_UI.h"
@@ -52,6 +52,42 @@ class wxTTLSCredentialsPanel;
 #include <Windows.h>
 
 
+class wxTTLSCredentialsPanel : public wxPanel
+{
+public:
+    ///
+    /// Constructs a configuration panel
+    ///
+    /// \param[in]    prov       Provider configuration data
+    /// \param[in]    cfg        Configuration data
+    /// \param[inout] cred       Credentials data
+    /// \param[in]    parent     Parent window
+    /// \param[in]    is_config  Is this panel used to config credentials?
+    ///
+    wxTTLSCredentialsPanel(const eap::config_provider &prov, const eap::config_method_ttls &cfg, eap::credentials_ttls &cred, wxWindow* parent, bool is_config = false);
+
+    ///
+    /// Destructs the configuration panel
+    ///
+    virtual ~wxTTLSCredentialsPanel();
+
+protected:
+    /// \cond internal
+    virtual void OnInitDialog(wxInitDialogEvent& event);
+    /// \endcond
+
+public:
+    wxTLSCredentialsPanel *m_outer_cred;        ///< Outer credentials panel
+    wxEAPCredentialsPanelBase *m_inner_cred;    ///< Inner credentials panel
+
+protected:
+    const eap::config_provider &m_prov;         ///< EAP provider
+    const eap::config_method_ttls &m_cfg;       ///< TTLS configuration
+    wxStaticText *m_outer_title;                ///< Outer authentication title
+    wxStaticText *m_inner_title;                ///< Inner authentication title
+};
+
+
 class wxTTLSConfigPanel : public wxTTLSConfigPanelBase
 {
 public:
@@ -110,39 +146,3 @@ protected:
     eap::config_method_pap      m_cfg_pap;       ///< PAP configuration
     eap::config_method_mschapv2 m_cfg_mschapv2;  ///< MSCHAPv2 configuration
 };
-
-
-class wxTTLSCredentialsPanel : public wxPanel
-{
-public:
-    ///
-    /// Constructs a configuration panel
-    ///
-    /// \param[in]    prov       Provider configuration data
-    /// \param[in]    cfg        Configuration data
-    /// \param[inout] cred       Credentials data
-    /// \param[in]    parent     Parent window
-    /// \param[in]    is_config  Is this panel used to pre-enter credentials? When \c true, the "Remember" checkbox is always selected and disabled.
-    ///
-    wxTTLSCredentialsPanel(const eap::config_provider &prov, const eap::config_method &cfg, eap::credentials &cred, wxWindow* parent, bool is_config = false);
-
-    ///
-    /// Destructs the configuration panel
-    ///
-    virtual ~wxTTLSCredentialsPanel();
-
-protected:
-    /// \cond internal
-    virtual void OnInitDialog(wxInitDialogEvent& event);
-    /// \endcond
-
-public:
-    wxTLSCredentialsPanel *m_outer_cred;        ///< Outer credentials panel
-    wxEAPCredentialsPanelBase *m_inner_cred;    ///< Inner credentials panel
-
-protected:
-    const eap::config_provider &m_prov;         ///< EAP provider
-    const eap::config_method_ttls &m_cfg;       ///< TTLS configuration
-    wxStaticText *m_outer_title;                ///< Outer authentication title
-    wxStaticText *m_inner_title;                ///< Inner authentication title
-};

lib/TTLS_UI/src/TTLS_UI.cpp

@@ -21,6 +21,79 @@
 #include "StdAfx.h"
 
 
+//////////////////////////////////////////////////////////////////////
+// wxTTLSCredentialsPanel
+//////////////////////////////////////////////////////////////////////
+
+wxTTLSCredentialsPanel::wxTTLSCredentialsPanel(const eap::config_provider &prov, const eap::config_method_ttls &cfg, eap::credentials_ttls &cred, wxWindow* parent, bool is_config) :
+    m_prov(prov),
+    m_cfg(cfg),
+    wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
+{
+    wxBoxSizer* sb_content;
+    sb_content = new wxBoxSizer( wxVERTICAL );
+
+    m_inner_title = new wxStaticText(this, wxID_ANY, _("Inner Authentication"), wxDefaultPosition, wxDefaultSize, 0);
+    m_inner_title->SetFont(wxFont(18, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, wxEmptyString));
+    m_inner_title->SetForegroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_INACTIVECAPTION ) );
+    sb_content->Add(m_inner_title, 0, wxALL|wxALIGN_RIGHT, 5);
+
+    assert(m_cfg.m_inner);
+
+    if (eap::config_method_with_cred::status_cred_begin <= m_cfg.m_inner->m_last_status && m_cfg.m_inner->m_last_status < eap::config_method_with_cred::status_cred_end)
+        sb_content->Add(new wxEAPCredentialWarningPanel(m_prov, m_cfg.m_inner->m_last_status, this), 0, wxALL|wxEXPAND, 5);
+
+    const eap::config_method_pap *cfg_inner_pap;
+    const eap::config_method_mschapv2 *cfg_inner_mschapv2;
+    if ((cfg_inner_pap = dynamic_cast<const eap::config_method_pap*>(m_cfg.m_inner.get())) != NULL) {
+        if (!cred.m_inner) cred.m_inner.reset(new eap::credentials_pass(cred.m_module));
+        m_inner_cred = new wxPAPCredentialsPanel(m_prov, *cfg_inner_pap, *(eap::credentials_pass*)cred.m_inner.get(), this, is_config);
+        sb_content->Add(m_inner_cred, 0, wxALL|wxEXPAND, 5);
+    } else if ((cfg_inner_mschapv2 = dynamic_cast<const eap::config_method_mschapv2*>(m_cfg.m_inner.get())) != NULL) {
+        if (!cred.m_inner) cred.m_inner.reset(new eap::credentials_pass(cred.m_module));
+        m_inner_cred = new wxMSCHAPv2CredentialsPanel(m_prov, *cfg_inner_mschapv2, *(eap::credentials_pass*)cred.m_inner.get(), this, is_config);
+        sb_content->Add(m_inner_cred, 0, wxALL|wxEXPAND, 5);
+    } else
+        assert(0); // Unsupported inner authentication method type.
+
+    sb_content->Add(20, 20, 1, wxALL|wxEXPAND, 5);
+
+    m_outer_title = new wxStaticText(this, wxID_ANY, _("Outer Authentication"), wxDefaultPosition, wxDefaultSize, 0);
+    m_outer_title->SetFont(wxFont(18, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, wxEmptyString));
+    m_outer_title->SetForegroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_INACTIVECAPTION ) );
+    sb_content->Add(m_outer_title, 0, wxALL|wxALIGN_RIGHT, 5);
+
+    if (eap::config_method_with_cred::status_cred_begin <= m_cfg.m_last_status && m_cfg.m_last_status < eap::config_method_with_cred::status_cred_end)
+        sb_content->Add(new wxEAPCredentialWarningPanel(m_prov, m_cfg.m_last_status, this), 0, wxALL|wxEXPAND, 5);
+
+    m_outer_cred = new wxTLSCredentialsPanel(m_prov, m_cfg, cred, this, is_config);
+    sb_content->Add(m_outer_cred, 0, wxALL|wxEXPAND, 5);
+
+    this->SetSizer(sb_content);
+    this->Layout();
+
+    m_inner_cred->SetFocusFromKbd();
+
+    // Connect Events
+    this->Connect(wxEVT_INIT_DIALOG, wxInitDialogEventHandler(wxTTLSCredentialsPanel::OnInitDialog));
+}
+
+
+wxTTLSCredentialsPanel::~wxTTLSCredentialsPanel()
+{
+    // Disconnect Events
+    this->Disconnect(wxEVT_INIT_DIALOG, wxInitDialogEventHandler(wxTTLSCredentialsPanel::OnInitDialog));
+}
+
+
+void wxTTLSCredentialsPanel::OnInitDialog(wxInitDialogEvent& event)
+{
+    // Forward the event to child panels.
+    m_outer_cred->GetEventHandler()->ProcessEvent(event);
+    m_inner_cred->GetEventHandler()->ProcessEvent(event);
+}
+
+
 //////////////////////////////////////////////////////////////////////
 // wxTTLSConfigPanel
 //////////////////////////////////////////////////////////////////////
@@ -218,78 +291,3 @@ void wxTTLSConfigWindow::OnUpdateUI(wxUpdateUIEvent& /*event*/)
 {
     m_inner_type->GetChoiceCtrl()->Enable(!m_prov.m_read_only);
 }
-
-
-//////////////////////////////////////////////////////////////////////
-// wxTTLSCredentialsPanel
-//////////////////////////////////////////////////////////////////////
-
-wxTTLSCredentialsPanel::wxTTLSCredentialsPanel(const eap::config_provider &prov, const eap::config_method &cfg, eap::credentials &cred, wxWindow* parent, bool is_config) :
-    m_prov(prov),
-    m_cfg((eap::config_method_ttls&)cfg),
-    wxPanel(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize)
-{
-    wxBoxSizer* sb_content;
-    sb_content = new wxBoxSizer( wxVERTICAL );
-
-    m_inner_title = new wxStaticText(this, wxID_ANY, _("Inner Authentication"), wxDefaultPosition, wxDefaultSize, 0);
-    m_inner_title->SetFont(wxFont(18, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, wxEmptyString));
-    m_inner_title->SetForegroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_INACTIVECAPTION ) );
-    sb_content->Add(m_inner_title, 0, wxALL|wxALIGN_RIGHT, 5);
-
-    assert(m_cfg.m_inner);
-
-    if (eap::config_method_with_cred::status_cred_begin <= m_cfg.m_inner->m_last_status && m_cfg.m_inner->m_last_status < eap::config_method_with_cred::status_cred_end)
-        sb_content->Add(new wxEAPCredentialWarningPanel(m_prov, m_cfg.m_inner->m_last_status, this), 0, wxALL|wxEXPAND, 5);
-
-    const eap::config_method_pap *cfg_inner_pap;
-    const eap::config_method_mschapv2 *cfg_inner_mschapv2;
-    if ((cfg_inner_pap = dynamic_cast<const eap::config_method_pap*>(m_cfg.m_inner.get())) != NULL) {
-        eap::credentials_ttls &cred_ttls = (eap::credentials_ttls&)cred;
-        if (!cred_ttls.m_inner) cred_ttls.m_inner.reset(new eap::credentials_pass(cred.m_module));
-        m_inner_cred = new wxPAPCredentialsPanel(m_prov, *cfg_inner_pap, *(eap::credentials_pass*)cred_ttls.m_inner.get(), this, is_config);
-        sb_content->Add(m_inner_cred, 0, wxALL|wxEXPAND, 5);
-    } else if ((cfg_inner_mschapv2 = dynamic_cast<const eap::config_method_mschapv2*>(m_cfg.m_inner.get())) != NULL) {
-        eap::credentials_ttls &cred_ttls = (eap::credentials_ttls&)cred;
-        if (!cred_ttls.m_inner) cred_ttls.m_inner.reset(new eap::credentials_pass(cred.m_module));
-        m_inner_cred = new wxMSCHAPv2CredentialsPanel(m_prov, *cfg_inner_mschapv2, *(eap::credentials_pass*)cred_ttls.m_inner.get(), this, is_config);
-        sb_content->Add(m_inner_cred, 0, wxALL|wxEXPAND, 5);
-    } else
-        assert(0); // Unsupported inner authentication method type.
-
-    sb_content->Add(20, 20, 1, wxALL|wxEXPAND, 5);
-
-    m_outer_title = new wxStaticText(this, wxID_ANY, _("Outer Authentication"), wxDefaultPosition, wxDefaultSize, 0);
-    m_outer_title->SetFont(wxFont(18, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, wxEmptyString));
-    m_outer_title->SetForegroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_INACTIVECAPTION ) );
-    sb_content->Add(m_outer_title, 0, wxALL|wxALIGN_RIGHT, 5);
-
-    if (eap::config_method_with_cred::status_cred_begin <= m_cfg.m_last_status && m_cfg.m_last_status < eap::config_method_with_cred::status_cred_end)
-        sb_content->Add(new wxEAPCredentialWarningPanel(m_prov, m_cfg.m_last_status, this), 0, wxALL|wxEXPAND, 5);
-
-    m_outer_cred = new wxTLSCredentialsPanel(m_prov, (const eap::config_method_tls&)m_cfg, (eap::credentials_tls&)cred, this, is_config);
-    sb_content->Add(m_outer_cred, 0, wxALL|wxEXPAND, 5);
-
-    this->SetSizer(sb_content);
-    this->Layout();
-
-    m_inner_cred->SetFocusFromKbd();
-
-    // Connect Events
-    this->Connect(wxEVT_INIT_DIALOG, wxInitDialogEventHandler(wxTTLSCredentialsPanel::OnInitDialog));
-}
-
-
-wxTTLSCredentialsPanel::~wxTTLSCredentialsPanel()
-{
-    // Disconnect Events
-    this->Disconnect(wxEVT_INIT_DIALOG, wxInitDialogEventHandler(wxTTLSCredentialsPanel::OnInitDialog));
-}
-
-
-void wxTTLSCredentialsPanel::OnInitDialog(wxInitDialogEvent& event)
-{
-    // Forward the event to child panels.
-    m_outer_cred->GetEventHandler()->ProcessEvent(event);
-    m_inner_cred->GetEventHandler()->ProcessEvent(event);
-}