@@ -4,8 +4,8 @@

 #include <string>

 #include "conversation.h"

-#include "pam.h"

+/*

 pam_token_conversation::pam_token_conversation (pam_handle_t *pamh,

         const pam_p pam)

 {

@@ -63,4 +63,5 @@ std::string pam_token_conversation::user_name()

 {

     return user_;

 }

+*/

@@ -1,55 +1,44 @@

 #ifndef _CONVERSATION_H

 #define _CONVERSATION_H

-#include <security/pam_modules.h>

 #include <string>

 #include <memory>

-#include "pam.h"

+#include "request.h"

-class conversation_result

-{

-private:

-    std::string token_;

-    std::string user_name_;

-public:

-    conversation_result (std::string user_name, std::string token)

-        : token_ (token),

-          user_name_ (user_name) {}

-    std::string token()

-    {

-        return token_;

-    }

-    std::string user_name()

-    {

-        return user_name_;

-    }

+struct conversation_result {

+    std::string user_name;

+    std::string token;

 };

-class conversations_ifc

+class conversation_ifc

 {

 public:

-    virtual ~conversations_ifc() {}

-    virtual conversation_result initiate_conversation()

+    virtual conversation_result initiate (const pam_request &request)

     {

-        return conversation_result ("","");

+        return { "", "" };

     }

 };

-class conversations : public conversations_ifc

+class conversation: public conversation_ifc

 {

 private:

-    std::shared_ptr<conversations_ifc> delegate_;

+    std::shared_ptr<conversation_ifc> delegate_;

 public:

-    conversations() : conversations (std::shared_ptr<conversations_ifc>

-                                         (new conversations_ifc)) {}

-    conversations (const std::shared_ptr<conversations_ifc> &delegate) :

+    conversation (const std::shared_ptr<conversation_ifc> &delegate) :

         delegate_ (delegate) {}

-    conversation_result initiate_conversation()

+    conversation() : conversation (std::shared_ptr<conversation_ifc>

+                                       (new conversation_ifc)) {}

+    conversation_result initiate (const pam_request &request)

     {

-        return delegate_->initiate_conversation();

+        return delegate_->initiate (request);

     }

 };

+inline conversation wrap (conversation_ifc *delegate)

+{

+    return conversation (std::shared_ptr<conversation_ifc> (delegate));

+};

+

 #endif

@@ -20,7 +20,7 @@ int dual_control_ifc::setcred ( const pam_request &request)

 class impl : public dual_control_ifc

 {

 private:

-    conversations conversations_;

+    conversation conversation_;

     validator validator_;

     logger logger_;

 public:

@@ -30,7 +30,7 @@ public:

 };

 impl::impl (const dual_control_configuration &configuration) :

-    conversations_ (configuration.conversations),

+    conversation_ (configuration.conversation),

     validator_ (configuration.validator),

     logger_ (configuration.logger) {}

@@ -41,15 +41,12 @@ int impl::setcred (const pam_request &request)

 int impl::authenticate (const pam_request &request)

 {

+    conversation_result input (conversation_.initiate (request));

-    conversation_result conversation = conversations_.initiate_conversation();

-    std::string user_name = conversation.user_name();

-    std::string token = conversation.token();

+    int auth_result = validator_.validate (input.user_name,

+                                           input.token) ? PAM_SUCCESS : PAM_AUTH_ERR;

-    int auth_result = validator_.validate (user_name,

-                                           token) ? PAM_SUCCESS : PAM_AUTH_ERR;

-

-    logger_.log (auth_result, user_name, token);

+    logger_.log (auth_result, input.user_name, input.token);

     return auth_result;

 }

@@ -16,7 +16,7 @@

 struct dual_control_configuration {

     validator validator;

-    conversations conversations;

+    conversation conversation;

     logger logger;

 };

@@ -20,10 +20,10 @@ void use_validator (dual_control_configuration &config,

     config.validator = validator (share (value));

 }

-void use_conversations (dual_control_configuration &config,

-                        conversations_ifc *value)

+void use_conversation (dual_control_configuration &config,

+                       conversation_ifc *value)

 {

-    config.conversations = conversations (share (value));

+    config.conversation = conversation (share (value));

 }

 void use_logger (dual_control_configuration &config, logger_ifc *value)

@@ -59,17 +59,17 @@ public:

     }

 };

-class fake_conversations : public conversations_ifc

+class fake_conversation : public conversation_ifc

 {

 private:

     std::string user_name_;

     std::string token_;

 public:

-    fake_conversations (const std::string &user_name,

-                        const std::string &token) : user_name_ (user_name), token_ (token) {}

-    conversation_result initiate_conversation()

+    fake_conversation (const std::string &user_name,

+                       const std::string &token) : user_name_ (user_name), token_ (token) {}

+    conversation_result initiate (const pam_request &request)

     {

-        return conversation_result (user_name_, token_);

+        return {user_name_, token_};

     }

 };

@@ -114,7 +114,7 @@ int authenticate_validates_with_received_token()

     std::string user ("user");

     std::string token ("token");

     use_validator (configuration, new fake_validator (user, token));

-    use_conversations (configuration, new fake_conversations (user, token));

+    use_conversation (configuration, new fake_conversation (user, token));

     dual_control dc (create_dual_control (configuration));

     pam_handle_t *handle (0);

     std::vector<const std::string> arguments;

@@ -133,8 +133,8 @@ int authenticate_fails_with_wrong_user()

     dual_control_configuration configuration;

     std::string token ("token");

     use_validator (configuration, new fake_validator ("user", token));

-    use_conversations (configuration, new fake_conversations ("wrong user",

-                       token));

+    use_conversation (configuration, new fake_conversation ("wrong user",

+                      token));

     dual_control dc (create_dual_control (configuration));

     // when

@@ -151,8 +151,8 @@ int authenticate_fails_with_wrong_token()

     dual_control_configuration configuration;

     std::string user ("user");

     use_validator (configuration, new fake_validator (user, "token"));

-    use_conversations (configuration, new fake_conversations (user,

-                       "wrong token"));

+    use_conversation (configuration, new fake_conversation (user,

+                      "wrong token"));

     dual_control dc (create_dual_control (configuration));

     // when

@@ -170,7 +170,7 @@ int logs_authentication()

     std::string user ("user");

     std::string token ("token");

     use_validator (configuration, new fake_validator (user, token));

-    use_conversations (configuration, new fake_conversations (user, token));

+    use_conversation (configuration, new fake_conversation (user, token));

     mock_logger *test_logger;

     use_logger (configuration, test_logger = new mock_logger);

     dual_control dc (create_dual_control (configuration));

@@ -196,7 +196,7 @@ int logs_authentication_failure()

     std::string token ("token");

     use_validator (configuration, new fake_validator (user,

                    "not the received token"));

-    use_conversations (configuration, new fake_conversations (user, token));

+    use_conversation (configuration, new fake_conversation (user, token));

     mock_logger *test_logger;

     use_logger (configuration, test_logger = new mock_logger);

     dual_control dc (create_dual_control (configuration));

@@ -1,11 +1,17 @@

-#include <string>

 #include <vector>

-#include <memory>

+#include <tuple>

 #include <security/pam_modules.h>

 #include <security/pam_appl.h>

 #include "pam.h"

+std::tuple<int,std::vector<pam_response>> pam_ifc::conv (pam_handle *handle,

+                                       const std::vector<pam_message> &prompts)

+{

+    return std::make_tuple (PAM_SERVICE_ERR, std::vector<pam_response>());

+}

+

+/*

 class pam_conversation_impl : public pam_conversation

 {

 private:

@@ -45,4 +51,5 @@ pam_p get_system_pam()

 {

     return (pam_p)new pam_impl;

 }

+*/

@@ -3,25 +3,33 @@

 #include <string>

 #include <vector>

 #include <memory>

+#include <tuple>

 #include <security/pam_modules.h>

-class pam_conversation

+class pam_ifc

 {

 public:

-    virtual int conv (const std::vector<const struct pam_message *> &prompts,

-                      std::vector<struct pam_response *> &answers) = 0;

+    virtual std::tuple<int,std::vector<pam_response>> conv (pam_handle *handle,

+            const std::vector<pam_message> &prompts);

+

 };

-typedef std::shared_ptr<pam_conversation> pam_conversation_p;

-class pam

+class pam : public pam_ifc

 {

+    typedef std::shared_ptr<pam_ifc> delegate;

+private:

+    delegate delegate_;

 public:

-    virtual int get_conversation (pam_handle_t *pamh,

-                                  std::shared_ptr<pam_conversation> &conversation) = 0;

+    pam (const delegate &delegate) : delegate_ (delegate) {}

+    pam() : pam (delegate (new pam_ifc)) {}

+    std::tuple<int,std::vector<pam_response>> conv (pam_handle *handle,

+                                           const std::vector<pam_message> &prompts)

+    {

+        return delegate_-> conv (handle, prompts);

+    }

 };

-typedef std::shared_ptr<pam> pam_p;

-pam_p get_system_pam();

+pam system_pam();

 #endif