@@ -101,7 +101,7 @@ public:

             throw std::string ("unexpected handle");

         }

-        conv_.appdata_ptr = (void*) (&conversation_data_);

+        conv_.appdata_ptr = (void *) (&conversation_data_);

         conv_.conv = fake_conv;

         *out = &conv_;

         return PAM_SUCCESS;

@@ -49,7 +49,7 @@ impl::impl (const dual_control_configuration &configuration) :

     conversation_ (configuration.conversation),

     validator_ (configuration.validator),

     logger_ (configuration.logger),

-    sessions_(configuration.sessions) {}

+    sessions_ (configuration.sessions) {}

 int impl::setcred (const pam_request &request)

 {

@@ -60,9 +60,9 @@ int impl::authenticate (const pam_request &request)

 {

     conversation_result input (conversation_.initiate (request));

-    sessions_.user_name(request);

+    sessions_.user_name (request);

-    auto requester_user_name = sessions_.user_name(request);

+    auto requester_user_name = sessions_.user_name (request);

     int auth_result = validator_.validate ("anyone", input.user_name,

                                            input.token) ? PAM_SUCCESS : PAM_AUTH_ERR;

@@ -47,7 +47,7 @@ dual_control initialize()

     conversation conversation (conversation::create (pam));

     sys_syslog sys_syslog (sys_syslog::create());

     logger logger (logger::create (sys_syslog));

-    sessions sessions (sessions::create(pam));

+    sessions sessions (sessions::create (pam));

     configuration.validator = validator;

     configuration.logger = logger;

     configuration.conversation = conversation;

@@ -92,7 +92,8 @@ private:

 public:

     fake_validator (const std::string &user,

                     const std::string &token): user_ (user), token_ (token) {}

-    bool validate (const std::string &requester, const std::string &user, const std::string &token)

+    bool validate (const std::string &requester, const std::string &user,

+                   const std::string &token)

     {

         return user_ == user && token_ == token;

     }

@@ -1,3 +1,14 @@

+/* 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 <memory>

 #include <string>

@@ -7,20 +18,24 @@

 namespace

 {

-class impl : public sessions_ifc {

-    private:

-        pam pam_;

-    public:

-    impl(const pam &pam) : pam_(pam) {}

-    std::string user_name (const pam_request &request)  const {

+class impl : public sessions_ifc

+{

+private:

+    pam pam_;

+public:

+    impl (const pam &pam) : pam_ (pam) {}

+    std::string user_name (const pam_request &request)  const

+    {

         const char *user_name;

-        pam_.get_user(request.handle(), &user_name);

+        pam_.get_user (request.handle(), &user_name);

         return user_name;

     }

 };

 }

-sessions sessions::create(const pam &pam) {

-    return sessions(std::make_shared<impl>(pam));

+sessions sessions::create (const pam &pam)

+{

+    return sessions (std::make_shared<impl> (pam));

 }

+

@@ -1,3 +1,14 @@

+/* 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.

+ */

+

 #ifndef _SESSION_H_

 #define _SESSION_H_

@@ -6,23 +17,28 @@

 #include "request.h"

 #include "sys_pam.h"

-class sessions_ifc {

-    public:

-        virtual ~sessions_ifc () {}

-        virtual std::string user_name (const pam_request &request)  const {

-            return "";

-        }

+class sessions_ifc

+{

+public:

+    virtual ~sessions_ifc () {}

+    virtual std::string user_name (const pam_request &request)  const

+    {

+        return "";

+    }

 };

-class sessions {

-    private:

-        std::shared_ptr<sessions_ifc> delegate_;

-    public:

-        sessions(std::shared_ptr<sessions_ifc> delegate = std::make_shared<sessions_ifc>()) : delegate_(delegate) {}

-        std::string user_name (const pam_request &request) const {

-            return delegate_->user_name(request);

-        }

-        static sessions create(const pam &pam);

+class sessions

+{

+private:

+    std::shared_ptr<sessions_ifc> delegate_;

+public:

+    sessions (std::shared_ptr<sessions_ifc> delegate =

+                  std::make_shared<sessions_ifc>()) : delegate_ (delegate) {}

+    std::string user_name (const pam_request &request) const

+    {

+        return delegate_->user_name (request);

+    }

+    static sessions create (const pam &pam);

 };

 #endif

@@ -1,3 +1,14 @@

+/* 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 <string>

 #include <memory>

@@ -6,38 +17,44 @@

 #include "sys_pam.h"

 #include "request.h"

-class fake_sys_pam : public pam_ifc {

-    private:

-        std::string user_name_;

-    public:

-    fake_sys_pam(std::string user_name) : user_name_(user_name) {}

-    int get_user (pam_handle *handle, const char **out) const {

+class fake_sys_pam : public pam_ifc

+{

+private:

+    std::string user_name_;

+public:

+    fake_sys_pam (std::string user_name) : user_name_ (user_name) {}

+    int get_user (pam_handle *handle, const char **out) const

+    {

         *out = user_name_.c_str();

         return PAM_SUCCESS;

     }

 };

-int gets_user_from_pam() {

+int gets_user_from_pam()

+{

     //given

-    std::string user_name("user");

-    pam fake_sys_pam(std::make_shared<fake_sys_pam>(user_name));

-    sessions sessions(sessions::create(fake_sys_pam));

-    pam_request request(0, 0, 0, 0);

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

+    pam fake_sys_pam (std::make_shared<fake_sys_pam> (user_name));

+    sessions sessions (sessions::create (fake_sys_pam));

+    pam_request request (0, 0, 0, 0);

     //when

-    std::string actual = sessions.user_name(request);

+    std::string actual = sessions.user_name (request);

     //

     //then

-    check(actual == user_name, "returned wrong user name");

+    check (actual == user_name, "returned wrong user name");

     succeed();

 }

-int run_tests() {

-    test(gets_user_from_pam);

+int run_tests()

+{

+    test (gets_user_from_pam);

     succeed();

 }

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

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

+{

     return !run_tests();

 }

+

@@ -19,7 +19,8 @@ class pam_ifc

 {

 public:

     virtual ~pam_ifc() {}

-    virtual int get_user (pam_handle *handle, const char **out) const {

+    virtual int get_user (pam_handle *handle, const char **out) const

+    {

         return PAM_SERVICE_ERR;

     }

     virtual int get_conv (pam_handle *handle, const pam_conv **out) const

@@ -36,8 +37,9 @@ private:

 public:

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

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

-    int get_user(pam_handle *handle, const char **out) const {

-        return delegate_->get_user(handle, out);

+    int get_user (pam_handle *handle, const char **out) const

+    {

+        return delegate_->get_user (handle, out);

     }

     int get_conv (pam_handle *handle, const pam_conv **out) const

     {

@@ -39,9 +39,12 @@ public:

         (delegate) {}

     validator() : validator (std::shared_ptr<validator_ifc>

                                  (new validator_ifc)) {}

-    bool validate (const std::string &requester_user_name, const std::string &authorizer_user_name, const std::string &authorizer_token)

+    bool validate (const std::string &requester_user_name,

+                   const std::string &authorizer_user_name,

+                   const std::string &authorizer_token)

     {

-        return delegate_->validate (requester_user_name, authorizer_user_name, authorizer_token);

+        return delegate_->validate (requester_user_name, authorizer_user_name,

+                                    authorizer_token);

     }

     static validator create (const directory &directory,

                              const user_token_supplier &token_supplier);

@@ -113,40 +113,44 @@ bool validator_fails_incorrect_token()

     succeed();

 }

-bool validator_fails_with_own_token() {

+bool validator_fails_with_own_token()

+{

     // given

-    std::string requester_user_name("requester");

-    std::string authorizer_user_name(requester_user_name);

-    std::string authorizer_token("token");

+    std::string requester_user_name ("requester");

+    std::string authorizer_user_name (requester_user_name);

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

     directory directory (share (new fake_directory (authorizer_user_name)));

     user_token_supplier user_token_supplier (share (new

-            fake_user_token_supplier(authorizer_token)));

+            fake_user_token_supplier (authorizer_token)));

     validator validator = validator::create (directory, user_token_supplier);

     // when

-    bool actual = validator.validate (requester_user_name, authorizer_user_name, authorizer_token);

+    bool actual = validator.validate (requester_user_name, authorizer_user_name,

+                                      authorizer_token);

     // then

-    check(!actual, "should not be valid");

+    check (!actual, "should not be valid");

     succeed();

 }

-bool validator_fails_with_unknown_requester() {

+bool validator_fails_with_unknown_requester()

+{

     // given

-    std::string requester_user_name("");

-    std::string authorizer_user_name("authorizer");

-    std::string authorizer_token("token");

+    std::string requester_user_name ("");

+    std::string authorizer_user_name ("authorizer");

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

     directory directory (share (new fake_directory (authorizer_user_name)));

     user_token_supplier user_token_supplier (share (new

-            fake_user_token_supplier(authorizer_token)));

+            fake_user_token_supplier (authorizer_token)));

     validator validator = validator::create (directory, user_token_supplier);

     // when

-    bool actual = validator.validate (requester_user_name, authorizer_user_name, authorizer_token);

+    bool actual = validator.validate (requester_user_name, authorizer_user_name,

+                                      authorizer_token);

     // then

-    check(!actual, "should not be valid");

+    check (!actual, "should not be valid");

     succeed();

 }