#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;
}
*/