Version set to 1.0-beta6

Sub-module update
Configuration dialog banner title updated to include method name
2016-09-26 13:14:15 +02:00 · 2016-09-26 13:12:24 +02:00 · 2016-09-26 12:01:46 +02:00 · 2016-09-26 11:43:40 +02:00 · 2016-09-26 11:11:10 +02:00 · 2016-09-26 10:20:14 +02:00
32 changed files with 424 additions and 355 deletions
--- a/EAPMethods/src/Main.cpp
+++ b/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;
        }
--- a/EAPMethods/src/Main_UI.cpp
+++ b/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;
        }
--- a/MSI/MSIBuild
+++ b/MSI/MSIBuild
--- a/include/Version.h
+++ b/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          0x00ff1700
+#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      23
+#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-beta5"
+#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.23"
+#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
--- a/lib/EAPBase/include/EAPXML.h
+++ b/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;
        }
--- a/lib/EAPBase/include/Method.h
+++ b/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
--- a/lib/EAPBase/include/Module.h
+++ b/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
--- a/lib/EAPBase/src/Config.cpp
+++ b/lib/EAPBase/src/Config.cpp
@@ -219,7 +219,7 @@ 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>
@@ -241,11 +241,11 @@ void eap::config_method_with_cred::load(_In_ IXMLDOMNode *pConfigRoot)

    // <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 {
@@ -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);
--- a/lib/EAPBase/src/Credentials.cpp
+++ b/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
@@ -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();
--- a/lib/EAPBase_UI/include/EAP_UI.h
+++ b/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,7 +570,7 @@ 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_storage(false),
@@ -574,6 +578,8 @@ public:
        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))
@@ -617,7 +623,7 @@ protected:
        if (!m_prov.m_read_only) {
            // This is not a provider-locked configuration. Save the data.
            m_cfg.m_use_cred = !m_storage->GetValue();
-            *m_cfg.m_cred    = m_cred_config;
+            *(_Tcred*)m_cfg.m_cred.get() = m_cred_config;
        }

        return true;
@@ -770,7 +776,7 @@ protected:

 private:
    bool m_has_storage;                     ///< Does the user has (some sort of) credentials stored in Credential Manager?
-    _Tcred m_cred_storage;                  ///< Temporary own credential data
+    _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),
@@ -841,9 +847,10 @@ 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.
@@ -879,7 +886,8 @@ 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_cred) {
            // Credential prompt mode & Using configured credentials
@@ -898,24 +906,23 @@ protected:
            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)
 {
--- a/lib/EAPBase_UI/res/wxEAP_UI.cpp
+++ b/lib/EAPBase_UI/res/wxEAP_UI.cpp
@@ -226,23 +226,22 @@ 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, _("Select the source where your username, password, or certificate used to connect are stored."), 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 );
 	
-	m_storage = new wxRadioButton( sb_credentials->GetStaticBox(), wxID_ANY, _("Use credentials from Credential &Manager:"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
+	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") );
 	
 	sb_credentials_vert->Add( m_storage, 0, wxEXPAND|wxTOP|wxRIGHT|wxLEFT, 5 );
@@ -250,7 +249,7 @@ wxEAPCredentialsConfigPanelBase::wxEAPCredentialsConfigPanelBase( wxWindow* pare
 	wxBoxSizer* sz_storage;
 	sz_storage = new wxBoxSizer( wxVERTICAL );
 	
-	m_storage_identity = new wxTextCtrl( sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
+	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_storage->Add( m_storage_identity, 3, wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );
@@ -258,12 +257,12 @@ wxEAPCredentialsConfigPanelBase::wxEAPCredentialsConfigPanelBase( wxWindow* pare
 	wxBoxSizer* sb_buttons_storage;
 	sb_buttons_storage = new wxBoxSizer( wxHORIZONTAL );
 	
-	m_storage_clear = new wxButton( sb_credentials->GetStaticBox(), wxID_ANY, _("&Clear Credentials"), wxDefaultPosition, wxDefaultSize, 0 );
+	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( sb_credentials->GetStaticBox(), wxID_ANY, _("&Set Credentials..."), wxDefaultPosition, wxDefaultSize, 0 );
+	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 );
@@ -274,7 +273,7 @@ wxEAPCredentialsConfigPanelBase::wxEAPCredentialsConfigPanelBase( wxWindow* pare
 	
 	sb_credentials_vert->Add( sz_storage, 0, wxEXPAND|wxALL, 5 );
 	
-	m_config = new wxRadioButton( sb_credentials->GetStaticBox(), wxID_ANY, _("Use credentials from &profile configuration:"), wxDefaultPosition, wxDefaultSize, 0 );
+	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 );
@@ -282,7 +281,7 @@ wxEAPCredentialsConfigPanelBase::wxEAPCredentialsConfigPanelBase( wxWindow* pare
 	wxBoxSizer* sz_config;
 	sz_config = new wxBoxSizer( wxVERTICAL );
 	
-	m_config_identity = new wxTextCtrl( sb_credentials->GetStaticBox(), wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY );
+	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 );
@@ -290,7 +289,7 @@ wxEAPCredentialsConfigPanelBase::wxEAPCredentialsConfigPanelBase( wxWindow* pare
 	wxBoxSizer* sb_buttons_config;
 	sb_buttons_config = new wxBoxSizer( wxHORIZONTAL );
 	
-	m_config_set = new wxButton( sb_credentials->GetStaticBox(), wxID_ANY, _("&Set Credentials..."), wxDefaultPosition, wxDefaultSize, 0 );
+	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 );
@@ -305,10 +304,10 @@ wxEAPCredentialsConfigPanelBase::wxEAPCredentialsConfigPanelBase( wxWindow* pare
 	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_storage.SetOwner( this, wxID_ANY );
 	
@@ -333,7 +332,7 @@ wxEAPCredentialsConfigPanelBase::~wxEAPCredentialsConfigPanelBase()

 wxPasswordCredentialsPanelBase::wxPasswordCredentialsPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : wxEAPCredentialsPanelBase( parent, id, pos, size, style )
 {
-	m_sb_credentials = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("User Password") ), 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 );
@@ -383,10 +382,16 @@ wxPasswordCredentialsPanelBase::wxPasswordCredentialsPanelBase( wxWindow* parent
 	
 	this->SetSizer( m_sb_credentials );
 	this->Layout();
+	
+	// Connect Events
+	m_password->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( wxPasswordCredentialsPanelBase::OnPasswordText ), NULL, this );
 }

 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 )
--- a/lib/EAPBase_UI/res/wxEAP_UI.fbp
+++ b/lib/EAPBase_UI/res/wxEAP_UI.fbp
@@ -46,7 +46,7 @@
            <property name="pos"></property>
            <property name="size"></property>
            <property name="style">wxDEFAULT_DIALOG_STYLE</property>
-            <property name="subclass">; </property>
+            <property name="subclass"></property>
            <property name="title">EAP Connection Configuration</property>
            <property name="tooltip"></property>
            <property name="window_extra_style"></property>
@@ -596,7 +596,7 @@
            <property name="pos"></property>
            <property name="size"></property>
            <property name="style">wxDEFAULT_DIALOG_STYLE</property>
-            <property name="subclass">; </property>
+            <property name="subclass"></property>
            <property name="title"></property>
            <property name="tooltip"></property>
            <property name="window_extra_style"></property>
@@ -787,7 +787,7 @@
            <property name="pos"></property>
            <property name="size"></property>
            <property name="style">wxDEFAULT_DIALOG_STYLE</property>
-            <property name="subclass">; </property>
+            <property name="subclass"></property>
            <property name="title">EAP Credentials</property>
            <property name="tooltip"></property>
            <property name="window_extra_style"></property>
@@ -1461,11 +1461,11 @@
            <event name="OnUpdateUI">OnUpdateUI</event>
            <object class="wxStaticBoxSizer" expanded="1">
                <property name="id">wxID_ANY</property>
-                <property name="label">Client Credentials</property>
+                <property name="label">%s User Credentials</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>
@@ -1598,7 +1598,7 @@
                                        <property name="gripper">0</property>
                                        <property name="hidden">0</property>
                                        <property name="id">wxID_ANY</property>
-                                        <property name="label">Select the source where your username, password, or certificate used to connect are stored.</property>
+                                        <property name="label">Select the source where your credentials used to connect are stored.</property>
                                        <property name="max_size"></property>
                                        <property name="maximize_button">0</property>
                                        <property name="maximum_size"></property>
@@ -2384,7 +2384,7 @@
            <event name="OnUpdateUI"></event>
            <object class="wxStaticBoxSizer" expanded="1">
                <property name="id">wxID_ANY</property>
-                <property name="label">User Password</property>
+                <property name="label">User ID and Password</property>
                <property name="minimum_size"></property>
                <property name="name">m_sb_credentials</property>
                <property name="orient">wxVERTICAL</property>
@@ -2929,7 +2929,7 @@
                                                <event name="OnRightUp"></event>
                                                <event name="OnSetFocus"></event>
                                                <event name="OnSize"></event>
-                                                <event name="OnText"></event>
+                                                <event name="OnText">OnPasswordText</event>
                                                <event name="OnTextEnter"></event>
                                                <event name="OnTextMaxLen"></event>
                                                <event name="OnTextURL"></event>
--- a/lib/EAPBase_UI/res/wxEAP_UI.h
+++ b/lib/EAPBase_UI/res/wxEAP_UI.h
@@ -165,6 +165,7 @@ class wxEAPCredentialsConfigPanelBase : public wxPanel
 	private:
 	
 	protected:
+		wxStaticBoxSizer* m_sb_credentials;
 		wxStaticBitmap* m_credentials_icon;
 		wxStaticText* m_credentials_label;
 		wxRadioButton* m_storage;
@@ -207,6 +208,10 @@ class wxPasswordCredentialsPanelBase : public wxEAPCredentialsPanelBase
 		wxTextCtrl* m_identity;
 		wxStaticText* m_password_label;
 		wxTextCtrl* m_password;
+		
+		// Virtual event handlers, overide them in your derived class
+		virtual void OnPasswordText( wxCommandEvent& event ) { event.Skip(); }
+		
 	
 	public:
 		
--- a/lib/EAPBase_UI/src/EAP_UI.cpp
+++ b/lib/EAPBase_UI/src/EAP_UI.cpp
@@ -27,7 +27,6 @@

 wxEAPBannerPanel::wxEAPBannerPanel(wxWindow* parent) : wxEAPBannerPanelBase(parent)
 {
-    m_title->SetLabelText(wxT(PRODUCT_NAME_STR));
 }


--- a/lib/MSCHAPv2/include/Method.h
+++ b/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
--- a/lib/MSCHAPv2_UI/src/MSCHAPv2_UI.cpp
+++ b/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);
--- a/lib/PAP/include/Method.h
+++ b/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
--- a/lib/PAP_UI/src/PAP_UI.cpp
+++ b/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);
--- a/lib/TLS/include/Method.h
+++ b/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)
--- a/lib/TLS/src/Config.cpp
+++ b/lib/TLS/src/Config.cpp
@@ -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;
--- a/lib/TLS/src/Credentials.cpp
+++ b/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;
--- a/lib/TLS/src/Method.cpp
+++ b/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
--- a/lib/TLS_UI/include/TLS_UI.h
+++ b/lib/TLS_UI/include/TLS_UI.h
@@ -68,7 +68,7 @@ class wxTLSServerTrustPanel;
 ///
 /// TLS credentials configuration panel
 ///
-typedef wxEAPCredentialsConfigPanel<eap::credentials_tls, wxTLSCredentialsPanel> wxEAPCredentialsPromptTLSConfigPanel;
+typedef wxEAPCredentialsConfigPanel<eap::credentials_tls, wxTLSCredentialsPanel> wxTLSCredentialsConfigPanel;

 ///
 /// TLS configuration panel
@@ -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);

@@ -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
-    wxEAPCredentialsPromptTLSConfigPanel *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
 };
--- a/lib/TLS_UI/res/wxTLS_UI.fbp
+++ b/lib/TLS_UI/res/wxTLS_UI.fbp
@@ -1293,7 +1293,7 @@
                                        <property name="show">1</property>
                                        <property name="size"></property>
                                        <property name="style">wxCB_SORT</property>
-                                        <property name="subclass">; </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>
--- a/lib/TLS_UI/src/TLS_UI.cpp
+++ b/lib/TLS_UI/src/TLS_UI.cpp
@@ -324,7 +324,7 @@ wxTLSCredentialsPanel::wxTLSCredentialsPanel(const eap::config_provider &prov, c
 bool wxTLSCredentialsPanel::TransferDataToWindow()
 {
    // Populate certificate list.
-    m_certificate->Append(_("<empty>"));
+    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"))) {
@@ -363,7 +363,12 @@ bool wxTLSCredentialsPanel::TransferDataToWindow()

 bool wxTLSCredentialsPanel::TransferDataFromWindow()
 {
-    const wxCertificateClientData *data = dynamic_cast<const wxCertificateClientData*>(m_certificate->GetClientObject(m_certificate->GetSelection()));
+    // 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
@@ -384,7 +389,7 @@ void wxTLSCredentialsPanel::OnUpdateUI(wxUpdateUIEvent& /*event*/)
        m_certificate->Enable(false);
        m_identity   ->Enable(false);
    } else {
-        // Configuration mode or using own credentials. Enable controls.
+        // Configuration mode or using stored credentials. Enable controls.
        m_certificate->Enable(true);
        m_identity   ->Enable(true);
    }
@@ -563,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 wxEAPCredentialsPromptTLSConfigPanel(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);
--- a/lib/TTLS/include/Method.h
+++ b/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
--- a/lib/TTLS/include/Module.h
+++ b/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
--- a/lib/TTLS/src/Config.cpp
+++ b/lib/TTLS/src/Config.cpp
@@ -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))) {
+        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_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_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,13 +150,13 @@ 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: 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 configured credentials.
@@ -166,7 +166,7 @@ void eap::config_method_ttls::load(_In_ IXMLDOMNode *pConfigRoot)
                } else {
                    // 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
--- a/lib/TTLS/src/Credentials.cpp
+++ b/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();
--- a/lib/TTLS_UI/include/TTLS_UI.h
+++ b/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_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
-};
--- a/lib/TTLS_UI/src/TTLS_UI.cpp
+++ b/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,76 +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_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);
-}
--- a/lib/WinStd
+++ b/lib/WinStd
Author	SHA1	Message	Date
Simon Rozman	8704ab938f	Version set to 1.0-beta6	2016-09-26 13:14:15 +02:00
Simon Rozman	7169e66eb0	Sub-module update	2016-09-26 13:12:24 +02:00
Simon Rozman	a5f4cafc55	Configuration dialog banner title updated to include method name	2016-09-26 12:01:46 +02:00
Simon Rozman	52c0c82979	wxEAPCredentials title is no longer static for easier disambiguation between outer and inner credential set in EAP-TTLS configuration dialog (closes #20)	2016-09-26 11:43:40 +02:00
Simon Rozman	a4b9c36242	Over-paranoid Debug Alert with empty certificate list resolved - The "<empty>" certificate on the list of certificates has now wxCertificateClientData of NULL to declare wxChoice will use client object data; - wxChoice selection index and availability of client object data are now verified before wxChoice::GetClientObject() call is made (closes #21)	2016-09-26 11:11:10 +02:00
Simon Rozman	27ea8802e0	<Password> element is stored encrypted now in profile configuration XML (closes #18)	2016-09-26 10:20:14 +02:00
Simon Rozman	bb8e766db7	Module decryption templates fixed	2016-09-26 10:18:55 +02:00
Simon Rozman	36b2f3c8a8	Always saving blank configured credentials issue fixed	2016-09-26 10:17:47 +02:00
Simon Rozman	c41bc3908e	Password change detection updated not to rely on default password value any more, but monitors password control change events	2016-09-26 10:16:37 +02:00
Simon Rozman	79cc1af86f	Clean-up and XML handling enhancement: - XML helper functions always return objects by winstd::com_obj or winstd::bstr reference now to ensure proper release by caller - get_element_value()/put_element_value() can optionally return reference to the XML object if required - WinStd macros to simplify dplhandle<> and handle<> inherited classes reused by non-copyable classes	2016-09-23 14:43:31 +02:00
Simon Rozman	640c1abdbd	XML get_element_value() and put_element_value() extended to support optional returning of XML element for later reference	2016-09-23 09:50:50 +02:00
Simon Rozman	9b14bd023f	Synced with credmerge branch	2016-09-23 05:37:38 +02:00