@@ -1,7 +1,22 @@

+#include <string>

+#include <vector>

+#include <security/pam_modules.h>

+

+#include "request.h"

 #include "dual_control.h"

 #include "conversation.h"

 #include "validator.h"

+int dual_control_ifc::authenticate (const pam_request &request)

+{

+    return PAM_SERVICE_ERR;

+}

+

+int dual_control_ifc::setcred ( const pam_request &request)

+{

+    return PAM_SERVICE_ERR;

+}

+

 class impl : public dual_control_ifc

 {

 private:

@@ -10,10 +25,8 @@ private:

     logger logger_;

 public:

     impl (const dual_control_configuration &configuration);

-    int authenticate (pam_handle *handle, int flags,

-                      const std::vector<const std::string> &arguments );

-    int setcred (pam_handle *handle, int flags,

-                 const std::vector<const std::string> &arguments);

+    int authenticate (const pam_request &request);

+    int setcred (const pam_request &request);

 };

 impl::impl (const dual_control_configuration &configuration) :

@@ -21,14 +34,12 @@ impl::impl (const dual_control_configuration &configuration) :

     validator_ (configuration.validator),

     logger_ (configuration.logger) {}

-int impl::setcred (pam_handle *handle, int flags,

-                   const std::vector<const std::string> &arguments)

+int impl::setcred (const pam_request &request)

 {

     return PAM_SUCCESS;

 }

-int impl::authenticate (pam_handle *handle, int flags,

-                        const std::vector<const std::string> &arguments)

+int impl::authenticate (const pam_request &request)

 {

     conversation_result conversation = conversations_.initiate_conversation();

@@ -45,6 +56,7 @@ int impl::authenticate (pam_handle *handle, int flags,

 dual_control create_dual_control (const dual_control_configuration

                                   &configuration)

 {

-    return dual_control (new impl (configuration));

+    return dual_control (std::shared_ptr<dual_control_ifc> (new impl (

+                             configuration)));

 }

@@ -7,31 +7,47 @@

 #ifndef _DUAL_CONTROL_H

 #define _DUAL_CONTROL_H

-#include <string>

 #include <memory>

-#include <vector>

-#include <security/pam_modules.h>

+#include "request.h"

 #include "validator.h"

 #include "conversation.h"

 #include "logger.h"

+struct dual_control_configuration {

+    validator validator;

+    conversations conversations;

+    logger logger;

+};

+

 class dual_control_ifc

 {

 public:

     virtual ~dual_control_ifc() {}

-    virtual int authenticate (pam_handle_t *handle, int flags,

-                              const std::vector<const std::string> &arguments ) = 0;

-    virtual int setcred (pam_handle_t *handle, int flags,

-                         const std::vector<const std::string> &arguments) = 0;

+    virtual int authenticate (const pam_request &request);

+    virtual int setcred (const pam_request &request);

 };

-typedef std::shared_ptr<dual_control_ifc> dual_control;

-struct dual_control_configuration {

-    validator validator;

-    conversations conversations;

-    logger logger;

+class dual_control : public dual_control_ifc

+{

+private:

+    std::shared_ptr<dual_control_ifc> delegate_;

+public:

+    dual_control (std::shared_ptr<dual_control_ifc> delegate) : delegate_

+        (delegate) {}

+    dual_control() : dual_control (std::shared_ptr<dual_control_ifc>

+                                       (new dual_control_ifc)) {}

+    int authenticate (const pam_request &request)

+    {

+        return delegate_->authenticate (request);

+    }

+    int setcred (const pam_request &request)

+    {

+        return delegate_->setcred (request);

+    }

+

 };

+

 dual_control create_dual_control (const dual_control_configuration

                                   &configuration);

@@ -6,7 +6,7 @@

 #include <memory>

 #include <vector>

-#include "argument.h"

+#include "request.h"

 #include "dual_control.h"

 extern dual_control dc;

@@ -14,8 +14,7 @@ extern dual_control dc;

 PAM_EXTERN int pam_sm_authenticate (pam_handle_t *pamh, int flags, int argc,

                                     const char **argv)

 {

-    std::vector<const std::string> arguments = convert_arguments (argc, argv);

-    return dc->authenticate (pamh, flags, arguments);

+    return dc->authenticate (pam_request (pamh, flags, argc, argv));

 }

 PAM_EXTERN int pam_sm_setcred (pam_handle_t *pamh, int flags, int argc,

@@ -1,6 +1,7 @@

 #include <security/pam_modules.h>

 #include <string>

+#include "request.h"

 #include "dual_control.h"

 #include "validator.h"

 #include "conversation.h"

@@ -86,16 +87,19 @@ public:

     }

 };

+pam_request req()

+{

+    return pam_request (0, 0, 0, 0);

+}

+

 int setcred_returns_success()

 {

     //given

     dual_control_configuration configuration;

-    pam_handle *pamh (0);

     dual_control dc (create_dual_control (configuration));

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

     //when

-    int result = dc->setcred (pamh, 0, arguments);

+    int result = dc.setcred (req());

     //then

     checkint (PAM_SUCCESS, result, "function return");

@@ -116,7 +120,7 @@ int authenticate_validates_with_received_token()

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

     // when

-    int actual = dc->authenticate (handle, 0, arguments);

+    int actual = dc.authenticate (req());

     // then

     check (actual == PAM_SUCCESS, "should be success");

@@ -132,11 +136,9 @@ int authenticate_fails_with_wrong_user()

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

                        token));

     dual_control dc (create_dual_control (configuration));

-    pam_handle_t *handle (0);

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

     // when

-    int actual = dc->authenticate (handle, 0, arguments);

+    int actual = dc.authenticate (req());

     // then

     check (actual == PAM_AUTH_ERR, "should be auth err");

@@ -152,11 +154,9 @@ int authenticate_fails_with_wrong_token()

     use_conversations (configuration, new fake_conversations (user,

                        "wrong token"));

     dual_control dc (create_dual_control (configuration));

-    pam_handle_t *handle (0);

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

     // when

-    int actual = dc->authenticate (handle, 0, arguments);

+    int actual = dc.authenticate (req());

     // then

     check (actual == PAM_AUTH_ERR, "should be auth err");

@@ -174,11 +174,9 @@ int logs_authentication()

     mock_logger *test_logger;

     use_logger (configuration, test_logger = new mock_logger);

     dual_control dc (create_dual_control (configuration));

-    pam_handle_t *handle (0);

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

     //when

-    dc->authenticate (handle, 0, arguments);

+    dc.authenticate (req());

     //then

     check (test_logger->logged_result() == PAM_SUCCESS,

@@ -202,11 +200,9 @@ int logs_authentication_failure()

     mock_logger *test_logger;

     use_logger (configuration, test_logger = new mock_logger);

     dual_control dc (create_dual_control (configuration));

-    pam_handle_t *handle (0);

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

     //when

-    dc->authenticate (handle, 0, arguments);

+    dc.authenticate (req());

     //then

     check (test_logger->logged_result() == PAM_AUTH_ERR,

@@ -3,41 +3,14 @@

 #include "request.h"

-

-/*

- * #ifndef ARGUMENT_H

-#define ARGUMENT_H

-

-#include <string>

-#include <vector>

-#include <security/pam_modules.h>

-

-class pam_request {

-        int argc_;

-        char **argv_;

-        int flags_;

-        pam_handle *handle_;

-    public:

-        pam_request(pam_handle *handle, int flags, int argc, char **argv)

-            : handle_(handle),

-              flags_(flags),

-              argc_(argc),

-              argv_(argv) {}

-        std::vector<std::string> arguments();

-        int flags() { return flags_; }

-        pam_handle *handle() {return handle_; }

-};

-

-#endif

-

-*/

-

-std::vector<std::string> pam_request::arguments() {

+std::vector<std::string> pam_request::arguments()

+{

     std::vector<std::string> rval;

-    for(int i= 0; i < argc_; i++) {

-        rval.push_back(argv_[i]);

+

+    for (int i= 0; i < argc_; i++) {

+        rval.push_back (argv_[i]);

     }

+

     return rval;

 }

-

@@ -5,20 +5,27 @@

 #include <vector>

 #include <security/pam_modules.h>

-class pam_request {

-        int argc_;

-        const char **argv_;

-        int flags_;

-        pam_handle *handle_;

-    public:

-        pam_request(pam_handle *handle, int flags, int argc, const char **argv)

-            : handle_(handle),

-              flags_(flags),

-              argc_(argc),

-              argv_(argv) {}

-        std::vector<std::string> arguments();

-        int flags() { return flags_; }

-        pam_handle *handle() {return handle_; }

+class pam_request

+{

+    int argc_;

+    const char **argv_;

+    int flags_;

+    pam_handle *handle_;

+public:

+    pam_request (pam_handle *handle, int flags, int argc, const char **argv)

+        : handle_ (handle),

+          flags_ (flags),

+          argc_ (argc),

+          argv_ (argv) {}

+    std::vector<std::string> arguments();

+    int flags()

+    {

+        return flags_;

+    }

+    pam_handle *handle()

+    {

+        return handle_;

+    }

 };

 #endif

@@ -5,82 +5,56 @@

 #include "request.h"

 #include "test_util.h"

-bool construction_happy() {

+bool construction_happy()

+{

     // given

-    pam_handle *handle = reinterpret_cast<pam_handle *>(975);

+    pam_handle *handle = reinterpret_cast<pam_handle *> (975);

     int flags = 0x23;

     const char *arg = "an argument";

     // when

-    pam_request actual(handle, flags, 1, &arg);

+    pam_request actual (handle, flags, 1, &arg);

     // then

-    check(handle == actual.handle(), "handle does not match");

-    check(flags == actual.flags(), "flags does not match");

+    check (handle == actual.handle(), "handle does not match");

+    check (flags == actual.flags(), "flags does not match");

     std::vector<std::string> expected_args;

-    expected_args.push_back(arg);

-    check(expected_args == actual.arguments(), "arguments does not match");

+    expected_args.push_back (arg);

+    check (expected_args == actual.arguments(), "arguments does not match");

     succeed();

 }

+bool multiple_arguments()

+{

+    // given

+    const char *arg1 = "arg1";

+    const char *arg2 = "arg2";

+    const char *arg3 = "arg3";

+    const char *argv[] = {arg1,arg2, arg3};

+

+    // when

+    pam_request actual (0, 0, 3, argv);

-//int convert_single_argument_to_cplusplus()

-//{

-//    //given

-//    int nargs = 1;

-//    const char *arg = "blah";

-//    const char **argv = &arg;

-//

-//    //when

-//    std::vector<const std::string> actual = convert_arguments (nargs, argv);

-//

-//    //then

-//    std::vector<std::string> temp (1);

-//    temp[0] = arg;

-//    std::vector<const std::string> expected (temp.begin(), temp.end());

-//

-//    check (actual == expected, "did not convert to c++");

-//    succeed();

-//}

-//

-//int convert_no_arguments_to_cplusplus()

-//{

-//    //given

-//    int nargs = 0;

-//    const char **argv = 0;

-//

-//    //when

-//    std::vector<const std::string> actual = convert_arguments (nargs, argv);

-//

-//    //then

-//    std::vector<const std::string> expected;

-//

-//    check (actual == expected, "did not convert to c++");

-//    succeed();

-//}

-//

-//int convert_multiple_arguments_to_cplusplus()

-//{

-//    //given

-//    int nargs = 3;

-//    const char *arg1 = "one";

-//    const char *arg2 = "two";

-//    const char *arg3 = "three";

-//    const char *argv[] = {arg1,arg2,arg3};

-//

-//    //when

-//    std::vector<const std::string> actual = convert_arguments (nargs, argv);

-//

-//    //then

-//    std::vector<std::string> temp;

-//    temp.push_back (arg1);

-//    temp.push_back (arg2);

-//    temp.push_back (arg3);

-//    std::vector<const std::string> expected (temp.begin(), temp.end());

-//

-//    check (actual == expected, "did not convert to c++");

-//    succeed();

-//}

+    // then

+    std::vector<std::string> expected_args;

+    expected_args.push_back (arg1);

+    expected_args.push_back (arg2);

+    expected_args.push_back (arg3);

+    check (expected_args == actual.arguments(), "arguments does not match");

+    succeed();

+}

+

+bool zero_arguments()

+{

+

+    // when

+    pam_request actual (0, 0, 0, 0);

+

+    // then

+    check (std::vector<std::string> (0) == actual.arguments(),

+           "arguments does not match");

+    succeed();

+}

 RESET_VARS_START

 RESET_VARS_END

@@ -88,6 +62,8 @@ RESET_VARS_END

 int run_tests()

 {

     test (construction_happy);

+    test (multiple_arguments);

+    test (zero_arguments);

     succeed();

 }