@@ -2,8 +2,8 @@ CXXFLAGS += -fPIC -fno-stack-protector -std=c++14

 CFLAGS += -fPIC -fno-stack-protector

 OBJS = dual_control.o request.o dual_control_integrate.o validator.o conversation.o user.o \

-	   sys_unistd.o sys_pwd.o

-TESTS = dual_control_test validator_test conversation_test request_test user_test

+	   sys_unistd.o sys_pwd.o token.o

+TESTS = dual_control_test validator_test conversation_test request_test user_test token_test

 TESTOBJS = $(patsubst %,%.o,$(TESTS))

 SRCS := $(OBJS:.o=.cc) $(TESTOBJS:.o=.cc)

@@ -71,69 +71,3 @@ conversation create_conversation (pam &pam)

 {

     return conversation (std::shared_ptr<conversation_ifc> (new impl (pam)));

 }

-

-/*

-int (*conv)(int num_msg, const struct pam_message **msg,

-                struct pam_response **resp, void *appdata_ptr)

-   */

-

-/*

-pam_token_conversation::pam_token_conversation (pam_handle_t *pamh,

-        const pam_p pam)

-{

-    pam_conversation_p pam_conversation;

-    int get_conversation_result = pam->get_conversation (pamh,

-                                  pam_conversation);

-

-    if (get_conversation_result != 0) {

-        return;

-    }

-

-    struct pam_message prompt;

-

-    std::string message ("Dual control token: ");

-

-    prompt.msg = const_cast<char *> (message.c_str());

-

-    prompt.msg_style = PAM_PROMPT_ECHO_OFF;

-

-    std::vector<const struct pam_message *> prompts (1);

-

-    prompts[0] = &prompt;

-

-    std::vector<struct pam_response *> answers (1);

-

-    int conversation_result = pam_conversation->conv (prompts, answers);

-

-    if (conversation_result) {

-        return;

-    }

-

-    if (answers[0]->resp_retcode) {

-        return;

-    }

-

-    std::string answer (answers[0]->resp);

-    std::string::iterator delim = std::find (answer.begin(), answer.end(), ':');

-

-    if (delim == answer.end()) {

-        return;

-    }

-

-    std::string user_name (answer.begin(), delim);

-    std::string token (delim + 1, answer.end());

-    user_ = user_name;

-    token_ = token;

-}

-

-std::string pam_token_conversation::token()

-{

-    return token_;

-}

-

-std::string pam_token_conversation::user_name()

-{

-    return user_;

-}

-*/

-

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

 /* Copyright (C) CJ Affiliate

  *

  * You may use, distribute and modify this code under  the

- * terms of the  GNU General Public License  version 2  or

+ * terms of the  GNU General Public License version 2  or

  * later.

  *

  * You should have received a copy of the license with this

@@ -9,17 +9,43 @@

  * at https://github.com/cjdev/dual-control.

  */

-#include <cstdlib>

-#include <cstring>

-#include <security/pam_modules.h>

-#include <pwd.h>

-#include <unistd.h>

-#include <cstdio>

-#include <sys/stat.h>

 #include <string>

 #include <vector>

 #include <memory>

-#include <fstream>

-#include "test_support.h"

+#include "token.h"

+#include "user.h"

+

+namespace

+{

+    class impl : public user_token_supplier_ifc {

+        private:

+            file_reader file_reader_;

+        public:

+            impl(file_reader &file_reader) : file_reader_(file_reader) {}

+            std::string token(user &user) {

+                std::string file_path(user.home_directory() + "/.dual_control");

+                std::string fetched_token(file_reader_.read(file_path));

+                return fetched_token;

+            }

+    };

+

+    class file_reader_impl : public file_reader_ifc {

+        public:

+            std::string read(std::string file_path) {

+                return file_path;

+            }

+    };

+}

+

+file_reader file_reader::create ()

+{

+    return file_reader (std::shared_ptr<file_reader_ifc>(new file_reader_impl ));

+}

+

+user_token_supplier user_token_supplier::create (file_reader &file_reader)

+{

+    return user_token_supplier (std::shared_ptr<user_token_supplier_ifc>(new impl (file_reader)));

+}

+

@@ -19,25 +19,52 @@

 class user_token_supplier_ifc

 {

 public:

-    virtual std::string token (const user &user)

+    virtual ~user_token_supplier_ifc() {}

+    virtual std::string token (user &user)

     {

-        return "";

+        return "virtual supplier";

     }

 };

+

+class file_reader_ifc {

+    public:

+        virtual std::string read(std::string file_path) {

+            return "";

+        }

+};

+

+class file_reader : public file_reader_ifc {

+    public:

+        typedef std::shared_ptr<file_reader_ifc> delegate;

+    private:

+        delegate delegate_;

+    public:

+        file_reader(delegate delegate) :

+            delegate_(delegate) {}

+        file_reader() : delegate_(delegate(new file_reader_ifc)) {}

+        std::string read(std::string file_path) {

+            return delegate_->read(file_path);

+        }

+    static file_reader create ();

+};

+

 class user_token_supplier : public user_token_supplier_ifc

 {

-private:

-    std::shared_ptr<user_token_supplier_ifc> delegate_;

-public:

-    user_token_supplier (std::shared_ptr<user_token_supplier_ifc> delegate) :

+    public:

+        typedef std::shared_ptr<user_token_supplier_ifc> delegate;

+    private:

+        delegate delegate_;

+    public:

+        user_token_supplier (delegate delegate) :

         delegate_ (delegate) {}

-    user_token_supplier() : user_token_supplier (

-            std::shared_ptr<user_token_supplier_ifc> (new user_token_supplier_ifc)) {}

-    std::string token (const user &user)

-    {

-        return delegate_->token (user);

-    }

+        user_token_supplier() : user_token_supplier (

+           delegate (new user_token_supplier_ifc)) {}

+        std::string token (user &user)

+        {

+            return delegate_->token (user);

+        }

+    static user_token_supplier create (file_reader &file_reader);

 };

 #endif

@@ -9,129 +9,63 @@

  * at https://github.com/cjdev/dual-control.

  */

+#include <memory>

 #include <cstring>

 #include <pwd.h>

 #include <cstdio>

 #include <sys/stat.h>

+

 #include "token.h"

 #include "test_util.h"

-

-const char *fake_user = "";

-const char *fake_user_token = "";

-

-// all the fake system calls

-const char *fake_home_dir = "";

-int fake_getpwnam_r (const char *nam, struct passwd *pwd, char *buffer,

-                     size_t bufsize, struct passwd **result)

-{

-    strcpy (buffer, fake_home_dir);

-    pwd->pw_dir = buffer;

-    int ok = !strcmp (nam, fake_user);

-    *result = ok ? pwd : 0;

-    return !ok;

-}

-

-const char *fake_stat_path = "";

-int fake_stat (const char *path, struct stat *stat)

-{

-    return (strcmp (fake_stat_path, path));

-}

-

-const char *fake_fopen_path = "";

-const char *fake_fopen_mode = "";

-FILE *_fhandle = 0;

-FILE *fake_fopen (const char *path, const char *mode)

-{

-    static FILE handle;

-    int path_matches = !strcmp (fake_fopen_path, path);

-    int mode_matches = !strcmp (fake_fopen_mode, mode);

-

-    if (path_matches && mode_matches) {

-        _fhandle = &handle;

-        return &handle;

-    } else {

-        _fhandle = 0;

-        return 0;

-    }

-}

-

-char *fake_fgets (char *buf, int n, FILE *fp)

-{

-    if (_fhandle == fp && fp != 0) {

-        strncpy (buf, fake_user_token, n - 1);

-        return buf;

-    } else {

-        return 0;

-    }

-}

-

-int fake_fclose (FILE *fp)

-{

-    return 0;

-}

-

-// STDIO

-

-RESET_VARS_START

-fake_user = "msmith";

-fake_user_token = "123456";

-fake_home_dir = "/home/msmith";

-fake_stat_path = "/home/msmith/.dual_control";

-fake_fopen_path = fake_stat_path;

-fake_fopen_mode = "r";

-RESET_VARS_END

-

-int validate_compares_to_user_token()

-{

-

-    // given

-

-    // when

-    int valid = validate_token ("msmith", "123456");

-

-    // then

-    check (valid, "expected result to be valid");

-

-    succeed();

-

-}

-

-int validates_from_the_right_user()

-{

+#include "user.h"

+

+class fake_file_reader : public file_reader_ifc {

+    public:

+        std::string read(std::string file_path) {

+            return file_path;

+        }

+};

+

+class fake_user : public user_ifc {

+    private:

+        std::string home_directory_;

+    public:

+        fake_user(std::string &user_name) :

+            home_directory_("home/" + user_name) {

+            }

+        std::string home_directory() {

+            return home_directory_;

+        }

+};

+

+int reads_from_the_right_file () {

     //given

+    file_reader test_file_reader(file_reader::delegate(new fake_file_reader));

+    std::string user_name = "user";

+    std::string expected = "home/" + user_name + "/.dual_control";

+    user test_user(user::delegate(new fake_user(user_name)));

+    user_token_supplier supplier(user_token_supplier::create(test_file_reader));

     //when

-    int valid = validate_token ("jbalcita", "12346");

+    std::string actual = supplier.token(test_user);

     //then

-    check (!valid, "expected result to be invalid");

+    check(actual == expected, "read wrong file");

     succeed();

 }

-int validates_user_specific_token()

-{

-    //given

-    //when

-    int valid = validate_token ("msmith", "654321");

-    //then

-    check (!valid, "expected result to be invalid");

-    succeed();

-}

+RESET_VARS_START

+RESET_VARS_END

-int runtests()

-{

-    test (validate_compares_to_user_token);

-    test (validates_from_the_right_user);

-    test (validates_user_specific_token);

+int run_tests() {

+    test(reads_from_the_right_file);

     succeed();

 }

-int main (int argc, char **argv)

-{

-    int rval = !runtests();

-    return rval;

+int main(int argc, char *argv[]) {

+    return !run_tests();

 }

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

 #include <memory>

 #include <vector>

+#include <iostream>

 #include "user.h"

 #include "sys_unistd.h"

@@ -18,6 +19,19 @@

 namespace

 {

+class user_impl : public user_ifc {

+    private:

+        std::string home_directory_;

+        std::string user_name_;

+    public:

+        user_impl(const passwd user_info) :

+            home_directory_(std::string(user_info.pw_dir)),

+            user_name_(std::string(user_info.pw_name)) {}

+        std::string home_directory() {

+            return home_directory_;

+        }

+};

+

 class directory_impl : public directory_ifc

 {

 private:

@@ -35,7 +49,7 @@ public:

         std::vector<user> return_value;

         if (!result && found_passwd) {

-            return_value.push_back (user());

+            return_value.push_back (std::shared_ptr<user_ifc>(new user_impl(sys_passwd)));

         }

         return return_value;

@@ -14,7 +14,7 @@

 #include <vector>

 #include <string>

 #include <memory>

-

+#include <iostream>

 #include "sys_unistd.h"

 #include "sys_pwd.h"

@@ -22,15 +22,25 @@ class user_ifc

 {

 public:

     virtual ~user_ifc() {}

+    virtual std::string home_directory() {

+        return "virtual";

+    }

 };

 class user : public user_ifc

 {

-private:

-    std::shared_ptr<user_ifc> delegate_;

-public:

-    user (std::shared_ptr<user_ifc> delegate) : delegate_ (delegate) {}

-    user() : user (std::shared_ptr<user_ifc> (new user_ifc)) {}

+    public:

+        typedef std::shared_ptr<user_ifc> delegate;

+    private:

+        delegate delegate_;

+    public:

+        user (delegate delegate) : delegate_ (delegate) {

+        }

+        user() : user (delegate (new user_ifc)) {}

+        std::string home_directory() {

+            return delegate_-> home_directory();

+        }

+    static user create (const passwd &passwd);

 };

 class directory_ifc

@@ -34,7 +34,6 @@ public:

         if (user_name == user_name_) {

             result.push_back (user());

         }

-

         return result;

     }

 };

@@ -46,7 +45,7 @@ private:

 public:

     fake_user_token_supplier (const std::string &token) : token_ (token) {}

     fake_user_token_supplier() : token_ ("_NOT_A_TOKEN") {}

-    virtual std::string token (const user &user)

+    std::string token (user &user)

     {

         return token_;

     }