@@ -26,27 +26,32 @@ distclean: clean

 	@rm -f Makefile config.h

-t_%.o: %.c

-	$(CC) -c $(CPPFLAGS) $(CFLAGS) -D UNIT_TEST -o $@ $<

 t_%.o: %.cc

 	$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) -D UNIT_TEST -o $@ $<

-dual_control_test: dual_control_test.o t_dual_control.o

-	$(CXX) $(CXXFLAGS) $(CPPLAGS)  -lpam -o $@ $^

+#dual_control_test: dual_control_test.o t_dual_control.o

+#	$(CXX) $(CXXFLAGS) $(CPPLAGS)  -lpam -o $@ $^

+#

+#logging_test: logging_test.o t_logging.o

+#	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -lpam -o $@ $^

+#

+#token_test: token_test.o t_token.o

+#	$(CXX) $(CXXFLAGS) $(CPPFLAGS)  -lpam -o $@ $^

-logging_test: logging_test.o t_logging.o

-	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -lpam -o $@ $^

+user_test: user_test.o user.o

+	$(CXX) $(CXXFLAGS) $(CPPFLAGS)  -o $@ $^

-token_test: token_test.o t_token.o

-	$(CXX) $(CXXFLAGS) $(CPPFLAGS)  -lpam -o $@ $^

 .PHONY: test

-test: dual_control_test logging_test token_test

-	@./dual_control_test

-	@./logging_test

-	@./token_test

-	@echo all tests passed

+test: user_test

+	@./user_test

+

+

+#	@./dual_control_test

+#	@./logging_test

+#	@./token_test

+#	@echo all tests passed

 .PHONY: install

 install: $(OBJS)

@@ -5,97 +5,71 @@

 #include <unistd.h>

 #include <cstdio>

 #include <sys/stat.h>

+#include <string>

+#include <vector>

+#include <memory>

+#include <fstream>

 #include "token.h"

 #include "test_support.h"

-typedef struct buffer {

-    size_t size;

-    char *mem;

-} buffer_t;

-buffer_t allocate_buffer() {

-    buffer_t buffer;

+typedef struct passwd passwd_t;

+class user {

+    private:

+        std::vector<char> passwd_buffer;

+        std::shared_ptr<passwd_t> sys_user_info;

-    buffer.size = (size_t) sysconf(_SC_GETPW_R_SIZE_MAX);

-    buffer.mem = (char *) malloc(buffer.size * sizeof(char));

+    public:

+        user(const std::string &user_name);

+        bool valid();

+        const std::string token();

-    return buffer;

+};

-}

-

-void free_buffer(buffer_t *buffer) {

-    free(buffer->mem);

-    buffer->mem = 0;

-    buffer->size = 0;

-}

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

+    // compute the token file path

+    std::string filepath = (std::string)sys_user_info->pw_dir + "/.dual_control";

+    // does the file exist?

+    std::ifstream token_file(filepath);

+    if (!token_file.good()) {

+        return "";

+    }

-char *use_buffer(buffer_t buffer) {

-    return buffer.mem;

-}

+    // read file

+    int token_length = 6;

+    std::vector<char> token_buffer(token_length + 1);

+    token_file.read(token_buffer.data(), token_length);

-size_t buffer_size(buffer_t buffer) {

-    return buffer.size;

+    // return contents

+    return token_buffer.data();

 }

-

-int get_passwd(const char *user, struct passwd *passwd, buffer_t buffer) {

-    struct passwd *found_passwd = 0;

-    getpwnam_r(user, passwd, use_buffer(buffer), buffer_size(buffer), &found_passwd);

-    return (found_passwd != 0);

+bool user::valid() {

+    return sys_user_info;

 }

+user::user(const std::string &user_name) :

+        passwd_buffer(sysconf(_SC_GETPW_R_SIZE_MAX)) {

+    std::shared_ptr<passwd> temp_passwd(new passwd);

+    struct passwd *found_passwd(0);

+    getpwnam_r(user_name.c_str(), sys_user_info.get(), passwd_buffer.data(), passwd_buffer.size(), &found_passwd);

-int validate_token(const char *user, const char *token) {

-

-    char fetched_token[7];

-    FILE *fp = 0;

-    char *filepath = 0;

-    char *working_token = 0;

-    buffer_t buffer = allocate_buffer();

-

-    int ok = 0;

-    struct passwd passwd;

-    int user_found = get_passwd(user, &passwd, buffer);

-    const char *directory = passwd.pw_dir;

-    int dir_len = strlen(directory);

-    int fname_len = strlen(".dual_control");

-    struct stat file_stat;

-    filepath = (char *)malloc((dir_len + 1 + fname_len + 1) * sizeof(char));

-

-    strcpy(filepath, directory);

-    strcat(filepath, "/");

-    strcat(filepath, ".dual_control");

-    int check_file = stat(filepath, &file_stat);

-    // check if user is known

-    if(!user_found) {

-       goto finally;

-    }

-

-

-    if (check_file) {

-        goto finally;

+    if (found_passwd) {

+        sys_user_info = temp_passwd;

     }

+}

-    // read the file and grab token

-    fp = fopen(filepath, "r");

-    fgets(fetched_token, 7, fp);

-    fclose(fp);

+int validate_token(const char *c_user_name, const char *c_token) {

-    // check if token matches

-    if(strcmp(token, fetched_token)) {

-        goto finally;

+    user user(c_user_name);

+    if (!user.valid()) {

+        return 0;

     }

+    std::string token(c_token);

-    ok = 1;

-

-    finally:

-

-    free(filepath);

-    free(working_token);

-    free_buffer(&buffer);

+    return user.token() == token;

-    return ok;

 }

new file mode 100644

@@ -0,0 +1,18 @@

+#include "user.h"

+

+#include <vector>

+#include <string>

+#include <pwd.h>

+

+

+user::user(struct passwd *sys_info) : info(sys_info) {

+}

+

+bool user::valid() {

+    return info;

+}

+

+std::string user::home_directory() {

+    return info->pw_dir;

+}

+

new file mode 100644

@@ -0,0 +1,27 @@

+#ifndef _USER_H

+#define _USER_H

+#include <vector>

+#include <string>

+#include <pwd.h>

+

+class user {

+    private:

+        struct passwd *info;

+

+    public:

+        user(struct passwd *sys_info);

+        bool valid();

+        std::string home_directory();

+};

+

+class concrete_user : public user {

+    private:

+        std::vector<char> buffer;

+        std::shared_ptr<struct passwd> store;

+    public:

+        concrete_user(const std::string &user_name);

+};

+

+

+#endif

+

new file mode 100644

@@ -0,0 +1,31 @@

+#include "user.h"

+#include "test_util.h"

+

+int gets_home_directory() {

+    //given

+    const char *expected_home_directory = "home/msmith";

+    struct passwd test_passwd;

+    test_passwd.pw_dir = const_cast<char *>(expected_home_directory);

+    user test_user(&test_passwd);

+

+    //when

+    std::string actual_home_directory = test_user.home_directory();

+

+    //then

+    check(expected_home_directory == actual_home_directory, "directories do not match");

+    return expected_home_directory == actual_home_directory;

+}

+

+RESET_VARS_START

+RESET_VARS_END

+

+int run_tests() {

+    test(gets_home_directory);

+    succeed();

+}

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

+    return !run_tests();

+}

+

+

+