@@ -2,8 +2,9 @@ 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 token.o sys_fstream.o

-TESTS = dual_control_test validator_test conversation_test request_test user_test token_test

+		sys_unistd.o sys_pwd.o token.o sys_fstream.o sys_syslog.o logger.o

+TESTS = dual_control_test validator_test conversation_test request_test user_test token_test \

+		logger_test

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

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

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

 #include "dual_control.h"

 #include "conversation.h"

 #include "validator.h"

+#include "logger.h"

 int dual_control_ifc::authenticate (const pam_request &request)

 {

@@ -39,7 +39,7 @@ void use_conversation (dual_control_configuration &config,

 void use_logger (dual_control_configuration &config, logger_ifc *value)

 {

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

+    config.logger = logger (logger::delegate (value));

 }

 class mock_logger : public logger_ifc

new file mode 100644

@@ -0,0 +1,36 @@

+/* Copyright (C) CJ Affiliate

+ *

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

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

+ * later.

+ *

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

+ * file. If not, you will find a copy in the "LICENSE" file

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

+ */

+

+#include <syslog.h>

+

+#include "sys_syslog.h"

+#include "logger.h"

+

+namespace {

+    class impl : public logger_ifc {

+        private:

+            sys_syslog syslog_;

+        public:

+            impl(const sys_syslog &sys_syslog) : syslog_(sys_syslog) {}

+            void log (int result, const std::string &user_name,

+              const std::string &token) {

+                std::string message(user_name + " " + token + " success");

+

+                syslog_.openlog("", 0, LOG_AUTHPRIV);

+                syslog_.syslog(LOG_NOTICE, message.c_str());

+                syslog_.closelog();

+            }

+    };

+}

+

+logger logger::create(const sys_syslog &sys_syslog) {

+    return logger(delegate(new impl(sys_syslog)));

+}

@@ -15,6 +15,8 @@

 #include <memory>

 #include <string>

+#include "sys_syslog.h"

+

 class logger_ifc

 {

 public:

@@ -25,17 +27,20 @@ public:

 class logger : public logger_ifc

 {

+    public:

+        typedef std::shared_ptr<logger_ifc> delegate;

 private:

-    std::shared_ptr<logger_ifc> delegate_;

+    delegate delegate_;

 public:

-    logger (const std::shared_ptr<logger_ifc> &delegate) : delegate_

+    logger (const delegate &delegate) : delegate_

         (delegate) {}

-    logger() : logger (std::shared_ptr<logger_ifc> (new logger_ifc)) {}

+    logger() : logger (delegate (new logger_ifc)) {}

     void log (int result, const std::string &user_name,

               const std::string &token)

     {

         delegate_->log (result, user_name, token);

     }

+    static logger create(const sys_syslog &sys_syslog);

 };

 #endif

similarity index 62%

rename from logging_test.cc

rename to logger_test.cc

@@ -9,13 +9,65 @@

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

  */

-#include <cstdio>

-#include <cstring>

 #include <syslog.h>

+#include <security/pam_modules.h>

-// #include "logging.h"

+#include <iostream>

+

+#include "sys_syslog.h"

+#include "logger.h"

 #include "test_util.h"

+class mock_syslog : public sys_syslog_ifc {

+    public:

+        int facility;

+        std::string message;

+        int priority;

+        void openlog(const char *ident, int logopt, int facility) {

+            this->facility = facility;

+        }

+        void vsyslog(int priority, const char *message, va_list args) {

+            this->priority = priority;

+            this->message = message;

+        }

+        void closelog()

+        {}

+

+};

+

+

+int logs_success() {

+    //given

+    mock_syslog *capture = new mock_syslog;

+    sys_syslog::delegate test_delegate(capture);

+    sys_syslog test_syslog(test_delegate);

+    logger logger = logger::create(test_syslog);

+    std::string user("user");

+    std::string token("token");

+

+    //when

+    logger.log(PAM_SUCCESS, user, token);

+

+    //then

+    check(capture->facility == LOG_AUTHPRIV, "facility does not match");

+    check(capture->message == user + " " + token + " " + "success", "message does not match");

+    check(capture->priority == LOG_NOTICE, "priority does not match");

+    succeed();

+}

+

+RESET_VARS_START

+RESET_VARS_END

+

+int run_tests()

+{

+    test (logs_success);

+    succeed();

+}

+

+int main (int numargs, char **args)

+{

+    return !run_tests();

+}

 /*

deleted file mode 100644

@@ -1,32 +0,0 @@

-/* Copyright (C) CJ Affiliate

- *

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

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

- * later.

- *

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

- * file. If not, you will find a copy in the "LICENSE" file

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

- */

-

-#include <syslog.h>

-

-//#include "logging.h"

-#include "test_support.h"

-

-static const char program_name[] = "pam_dual_control";

-

-void log_success()

-{

-    openlog (program_name, 0, LOG_AUTHPRIV);

-    syslog (LOG_NOTICE, "dual control succeeded");

-    closelog();

-}

-

-void log_failure()

-{

-    openlog (program_name, 0, LOG_AUTHPRIV);

-    syslog (LOG_NOTICE, "dual control failed");

-    closelog();

-}

-

new file mode 100644

@@ -0,0 +1,26 @@

+#include <syslog.h>

+

+#include "sys_syslog.h"

+

+namespace {

+class impl : public sys_syslog_ifc {

+    public:

+        void openlog(const char *ident, int logopt, int facility) {

+            ::openlog(ident, logopt, facility);

+        }

+

+        void vsyslog(int priority, const char *message, va_list args) {

+           ::vsyslog(priority, message, args);

+        }

+

+        void closelog() {

+            ::closelog();

+        }

+};

+}

+

+sys_syslog sys_syslog::create() {

+    static sys_syslog singleton(sys_syslog::delegate(new impl));

+    return singleton;

+}

+

new file mode 100644

@@ -0,0 +1,42 @@

+#ifndef SYS_SYSLOG_H

+#define SYS_SYSLOG_H

+

+#include <memory>

+#include <cstdarg>

+#include <syslog.h>

+

+class sys_syslog_ifc {

+    public:

+        virtual void openlog(const char *ident, int logopt, int facility) {}

+        virtual void vsyslog(int priority, const char *message, va_list args) {}

+        virtual void closelog() {}

+};

+

+class sys_syslog : public sys_syslog_ifc {

+    public:

+        typedef std::shared_ptr<sys_syslog_ifc> delegate;

+    private:

+        delegate delegate_;

+    public:

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

+       sys_syslog() : sys_syslog(delegate(new sys_syslog_ifc)) {}

+        void openlog(const char *ident, int logopt, int facility) {

+            delegate_->openlog(ident, logopt, facility);

+        }

+        void syslog(int priority, const char *format, ...) {

+            va_list vargs;

+            va_start(vargs, format);

+            vsyslog(priority, format, vargs);

+            va_end(vargs);

+        }

+         void vsyslog(int priority, const char *message, va_list vargs) {

+            delegate_->vsyslog(priority, message, vargs);

+        }

+        void closelog() {

+           delegate_->closelog();

+        }

+

+        static sys_syslog create();

+};

+

+#endif