checkuser/cpp/pamwrapper.cpp

#include "pamwrapper.h"

#include <string>
#include <vector>

using std::string;
using std::vector;

extern "C" int conversation(int num_msg, const pam_message **msg, 
                pam_response **resp, void *appdata_prt)
{
        
        if (num_msg <= 0)
                return PAM_CONV_ERR;

        PamWrapper *wrap = (PamWrapper*) appdata_prt;

        pam_response* reply = static_cast<pam_response*> 
                                (::calloc(num_msg, sizeof(pam_response)));
        if (!reply)
                return PAM_SYSTEM_ERR;

        for (int replies = 0; replies < num_msg; replies++) {
                switch (msg[replies]->msg_style) {
                        case PAM_PROMPT_ECHO_OFF: {
                                string tmp = wrap->promptEchoOff(msg[replies]->msg);
                                reply[replies].resp = (char*) tmp.c_str();
                                reply[replies].resp_retcode = PAM_SUCCESS;
                                break;
                        }
                        case PAM_PROMPT_ECHO_ON: {
                                string tmp = wrap->promptEchoOn(msg[replies]->msg);
                                reply[replies].resp = (char*) tmp.c_str();
                                reply[replies].resp_retcode = PAM_SUCCESS;
                                break;
                        }
                        case PAM_ERROR_MSG: {
                                wrap->errorMsg(msg[replies]->msg);
                                reply[replies].resp_retcode = PAM_SUCCESS;
                                break;
                        }
                        case PAM_TEXT_INFO: {
                                wrap->textInfo(msg[replies]->msg);
                                reply[replies].resp_retcode = PAM_SUCCESS;
                                break;
                        }
                        default:
                                ::free(reply);
                                return PAM_CONV_ERR;
                }
        }

        *resp = reply;
        return PAM_SUCCESS;
}

PamWrapper::PamWrapper(string service )
{
        m_pamh = NULL;
        m_isStarted = false;
        m_service = service;
        m_conv.conv = conversation;
        m_conv.appdata_ptr = (void*)this;
}

PamWrapper::~PamWrapper()
{
        if ( m_isStarted )
                end();
}

int PamWrapper::start(string username)
{
        m_isStarted = true;
        if (username.size() == 0)
                return pam_start(m_service.c_str(), NULL, &m_conv, &m_pamh);
        else
                return pam_start(m_service.c_str(), username.c_str(), &m_conv, &m_pamh);
}

int PamWrapper::end(int status)
{
        m_isStarted = false;
        return pam_end(m_pamh,status);
}

int PamWrapper::authenticate( int flags )
{
        return pam_authenticate(m_pamh, flags);
}

int PamWrapper::account(int flags )
{
        return pam_acct_mgmt(m_pamh, flags);
}

int PamWrapper::setCred(int flags)
{
        return pam_setcred(m_pamh,flags);
}

int PamWrapper::openSession(int flags)
{
        return pam_open_session(m_pamh, flags);
}

int PamWrapper::closeSession(int flags)
{
        return pam_close_session(m_pamh, flags);
}

int PamWrapper::changeAuthToken(int flags)
{
        return pam_chauthtok(m_pamh, flags);
}

string PamWrapper::strError(int err)
{
        return pam_strerror(m_pamh, err);
}

int PamWrapper::putEnv(string nameValue)
{
        return pam_putenv(m_pamh, nameValue.c_str() );
}

string PamWrapper::getEnv(string name)
{
        const char *buf = pam_getenv(m_pamh, name.c_str() );
        return (buf != NULL) ? string(buf) : string("NULL");
}


int PamWrapper::failDelay(unsigned int usec)
{
#ifdef PAM_FAIL_DELAY
        return pam_fail_delay(m_pamh, usec);
#else
#warning PAM_FAIL_DELAY not defined
        return 0;
#endif //PAM_FAIL_DELAY
}


int PamWrapper::setItem(int item_type, const void *item)
{
        return pam_set_item(m_pamh, item_type, item);
}

int PamWrapper::getItem(int item_type, const void **item)
{
        return pam_get_item(m_pamh, item_type, item);
}

bool PamWrapper::checkUser(string username, bool checkAccount)
{
        this->start(username);
        int auth = this->authenticate();
        int acc = checkAccount ? this->account() : PAM_SUCCESS;
        this->end();
        return (auth == PAM_SUCCESS && acc == PAM_SUCCESS);
}

/*
vector<string> PamWrapper::getEnvList()
{
        vector<string> output;
        char **buf = pam_getenvlist(m_pamh);
        
        for (char **ptr = buf; ptr != NULL; ptr++) {
                string tmp = string(*ptr);
                output.push_back(tmp);
        }
        std::free(buf);

        return output;
}
*/
1	torben	328	#include "pamwrapper.h"
2
3			#include <string>
4			#include <vector>
5
6			using std::string;
7			using std::vector;
8
9			extern "C" int conversation(int num_msg, const pam_message **msg,
10			pam_response *resp, void appdata_prt)
11			{
12
13			if (num_msg <= 0)
14			return PAM_CONV_ERR;
15
16			PamWrapper wrap = (PamWrapper) appdata_prt;
17
18			pam_response* reply = static_cast<pam_response*>
19			(::calloc(num_msg, sizeof(pam_response)));
20			if (!reply)
21			return PAM_SYSTEM_ERR;
22
23			for (int replies = 0; replies < num_msg; replies++) {
24			switch (msg[replies]->msg_style) {
25			case PAM_PROMPT_ECHO_OFF: {
26			string tmp = wrap->promptEchoOff(msg[replies]->msg);
27			reply[replies].resp = (char*) tmp.c_str();
28			reply[replies].resp_retcode = PAM_SUCCESS;
29			break;
30			}
31			case PAM_PROMPT_ECHO_ON: {
32			string tmp = wrap->promptEchoOn(msg[replies]->msg);
33			reply[replies].resp = (char*) tmp.c_str();
34			reply[replies].resp_retcode = PAM_SUCCESS;
35			break;
36			}
37			case PAM_ERROR_MSG: {
38			wrap->errorMsg(msg[replies]->msg);
39			reply[replies].resp_retcode = PAM_SUCCESS;
40			break;
41			}
42			case PAM_TEXT_INFO: {
43			wrap->textInfo(msg[replies]->msg);
44			reply[replies].resp_retcode = PAM_SUCCESS;
45			break;
46			}
47			default:
48			::free(reply);
49			return PAM_CONV_ERR;
50			}
51			}
52
53			*resp = reply;
54			return PAM_SUCCESS;
55			}
56
57			PamWrapper::PamWrapper(string service )
58			{
59			m_pamh = NULL;
60			m_isStarted = false;
61			m_service = service;
62			m_conv.conv = conversation;
63			m_conv.appdata_ptr = (void*)this;
64			}
65
66			PamWrapper::~PamWrapper()
67			{
68			if ( m_isStarted )
69			end();
70			}
71
72			int PamWrapper::start(string username)
73			{
74			m_isStarted = true;
75			if (username.size() == 0)
76			return pam_start(m_service.c_str(), NULL, &m_conv, &m_pamh);
77			else
78			return pam_start(m_service.c_str(), username.c_str(), &m_conv, &m_pamh);
79			}
80
81			int PamWrapper::end(int status)
82			{
83			m_isStarted = false;
84			return pam_end(m_pamh,status);
85			}
86
87			int PamWrapper::authenticate( int flags )
88			{
89			return pam_authenticate(m_pamh, flags);
90			}
91
92			int PamWrapper::account(int flags )
93			{
94			return pam_acct_mgmt(m_pamh, flags);
95			}
96
97			int PamWrapper::setCred(int flags)
98			{
99			return pam_setcred(m_pamh,flags);
100			}
101
102			int PamWrapper::openSession(int flags)
103			{
104			return pam_open_session(m_pamh, flags);
105			}
106
107			int PamWrapper::closeSession(int flags)
108			{
109			return pam_close_session(m_pamh, flags);
110			}
111
112			int PamWrapper::changeAuthToken(int flags)
113			{
114			return pam_chauthtok(m_pamh, flags);
115			}
116
117			string PamWrapper::strError(int err)
118			{
119			return pam_strerror(m_pamh, err);
120			}
121
122			int PamWrapper::putEnv(string nameValue)
123			{
124			return pam_putenv(m_pamh, nameValue.c_str() );
125			}
126
127			string PamWrapper::getEnv(string name)
128			{
129			const char *buf = pam_getenv(m_pamh, name.c_str() );
130			return (buf != NULL) ? string(buf) : string("NULL");
131			}
132
133
134			int PamWrapper::failDelay(unsigned int usec)
135			{
136			#ifdef PAM_FAIL_DELAY
137			return pam_fail_delay(m_pamh, usec);
138			#else
139			#warning PAM_FAIL_DELAY not defined
140			return 0;
141			#endif //PAM_FAIL_DELAY
142			}
143
144
145			int PamWrapper::setItem(int item_type, const void *item)
146			{
147			return pam_set_item(m_pamh, item_type, item);
148			}
149
150			int PamWrapper::getItem(int item_type, const void **item)
151			{
152			return pam_get_item(m_pamh, item_type, item);
153			}
154
155			bool PamWrapper::checkUser(string username, bool checkAccount)
156			{
157			this->start(username);
158			int auth = this->authenticate();
159			int acc = checkAccount ? this->account() : PAM_SUCCESS;
160			this->end();
161			return (auth == PAM_SUCCESS && acc == PAM_SUCCESS);
162			}
163
164			/*
165			vector<string> PamWrapper::getEnvList()
166			{
167			vector<string> output;
168			char **buf = pam_getenvlist(m_pamh);
169
170			for (char **ptr = buf; ptr != NULL; ptr++) {
171			string tmp = string(*ptr);
172			output.push_back(tmp);
173			}
174			std::free(buf);
175
176			return output;
177			}
178			*/