Ftp客户端

开发平台：
Visual C++

user.cpp：源码内容
							// This is part of the WAR SOFTWARE SERIES initiated by Jarle Aase
// Copyright 1996 by Jarle Aase. All rights reserved.
// See the "War Software Series Licende Agreement" for details concerning 
// use and distribution.
// ---
// This source code, executables and programs containing source code or
// binaries or proprietetary technology from the War Software Series are
// NOT alloed used, viewed or tested by any governmental agencies in
// any countries. This includes the government, departments, police, 
// military etc.
// ---
// This file is intended for use with Tab space = 2
// Created and maintained in MSVC Developer Studio
// ---
// NAME			:	user.cpp
// PURPOSE	:	User management
// PROGRAM	: 
// DATE			:	Sept. 28 1996
// AUTHOR		:	Jarle Aase
// ---
// REVISION HISTORY
// 
#include "stdafx.h"
#include "WarDaemon.h"
#include "User.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
CUsr *CUsr::m_pUserMngr = NULL;
LPCSTR CUsr::m_pIniFile = ".\User.ini";
CLog *CUsr::m_Log = NULL;
int CUsr::m_NextUserNum;
CUsr::CUsr()
{
	m_pUserMngr = this;
}
CUsr::~CUsr()
{
	m_pUserMngr = NULL;
	m_Log = NULL;
}
BOOL CUsr::Create(CLog *Log)
{
	m_Log = Log;
	::GetIniItem(NULL, m_pIniFile, "@hdr@", "Next", m_NextUserNum, 0);
	if (!m_NextUserNum)
	{
		int sSystem, cSysAdmin, cUser, cVisitor;
		m_NextUserNum++;
		LogMsg(LOGF_SYSTEM,"Creating new user database.");
		// Create user database
		int User;
		sSystem = User = AddUser(UT_SYSTEM, "System", 2, USERPRI_ANON);
		if (!User)
		{
			LogMsg(LOGF_ERROR,"Failed to create System.");
			return FALSE;
		}
		SetParam(User,"Home","/");
		SetParam(User,"Root","/");
		SetParam(User,"RemoteAdmin Access", TRUE);
		SetParam(User,"FTP Access", TRUE);
		SetParam(User,"IP Shitlist", "*.gov;*.mil;*.gov.*;*.mil.*");
		SetParam(User,"Enable IP Shitlist", TRUE);
		SetParam(User,"Umask", 22);
		
		User = cVisitor = AddUser(UT_CLASS, "Visitor", TRUE, USERPRI_ANON);
		SetParam(User,"FTP Access", TRUE);
		SetParam(User,"AssignFilesTo", "LocalAdmin");
		User = cUser = AddUser(UT_CLASS, "User", FALSE, USERPRI_ANON);
		SetParam(User,"FTP Access", TRUE);
		User = cSysAdmin = AddUser(UT_CLASS, "Sysadmin", 2, USERPRI_ANON);
		SetParam(User,"FTP Access", TRUE);
		SetParam(User,"RemoteAdmin Access", TRUE);
		User = AddUser(UT_USER,"Anonymous", TRUE, USERPRI_ANON);
		SetParam(User,"Class", cVisitor);
		SetParam(User,"PWmode", PW_EMAIL);
		CreateAlias("Anonymous", "ftp");
		CreateAlias("Anonymous", "guest");
		User = AddUser(UT_GROUP,"Ftp", FALSE, USERPRI_ANON);
		SetParam(User,"Class", cUser);
		SetParam(User,"FTP Access", TRUE);
		// Create system user for maintainance
		User = AddUser(UT_USER, "LocalAdmin", 2, USERPRI_ADMIN);
		if (!User)
		{
			LogMsg(LOGF_ERROR,"Failed to create Local Admin user.");
			return FALSE;
		}
		SetParam(User,"Class", cSysAdmin);
		SetParam(User,"PWmode", PW_NORMAL);
		SetParam(User,"Home","/");
		SetParam(User,"Root","/");
		SetParam(User,"Administrator",TRUE);
		SetParam(User,"Local Only",TRUE);
		SetParam(User,"Password","sd&jkfhw387r");
		SetParam(User,"RemoteAdmin Access",TRUE);
		SetParam(User,"FTP Access",TRUE);
		// Create support user for maintainance
		User = AddUser(UT_USER, "SupportAdmin", TRUE, USERPRI_ADMIN);
		if (!User)
		{
			LogMsg(LOGF_ERROR,"Failed to create Support Admin user.");
			return FALSE;
		}
		SetParam(User,"Class", cSysAdmin);
		SetParam(User,"PWmode", PW_NORMAL);
		SetParam(User,"Home","/");
		SetParam(User,"Root","/");
		SetParam(User,"Administrator",TRUE);
		SetParam(User,"Password","sd&jkfhw387r");
		SetParam(User,"RemoteAdmin Access",FALSE);
		SetParam(User,"FTP Access",FALSE);
	}
	return TRUE;
}
BOOL CUsr::CreateAlias(LPCSTR Name, LPCSTR Alias)
{
	int OrgUser = FindUser(UT_USER, Name), User;
	if (FindUser(UT_USER, Alias))
	{
		LogMsg(LOGF_WARNINGS,"Failed to create alias '%s' for user '%s'. Alias name exist.",
			Alias, Name);
		return FALSE;
	}
	if (!OrgUser)
	{
		LogMsg(LOGF_WARNINGS,"Failed to create alias '%s' for user '%s'. User not found.",
			Alias, Name);
		return FALSE;
	}
	CString cBuf;
	if ((User = AddUser(UT_USER, Alias)) == INVALID_USER_VALUE)
		return FALSE;
	SetParam(User, "Alias to", OrgUser);
	LogMsg(LOGF_SYSTEM,"Created alias name '%s' for user '%s'", Alias, Name);
	return TRUE;
}
void CUsr::SetParam(int UserNum, LPCSTR Key, LPCSTR Value)
{
	CString cSection;
	char buf[128];
	// Special cases
	if (Value && *Value && !stricmp(Key, "password"))
	{
		Value = crypt(Value, "", buf);
	}
	cSection.Format("U %d", UserNum);
	::PutIniItem(NULL, m_pIniFile, cSection, Key, Value);
}
void CUsr::SetParam(int UserNum, LPCSTR Key, int Value)
{
	CString cSection;
	cSection.Format("U %d", UserNum);
	::PutIniItem(NULL, m_pIniFile, cSection, Key, Value);
}
int CUsr::GetParam(int UserNum, LPCSTR Key, int DefValue)
{
	CString cSection;
	int Value;
	cSection.Format("U %d", UserNum);
	::GetIniItem(NULL, m_pIniFile, cSection, Key, Value, DefValue);
	return Value;
}
LPCSTR CUsr::GetParam(int UserNum, LPCSTR Key, LPCSTR DefValue, CString& cBuf)
{
	CString cSection;
	cSection.Format("U %d", UserNum);
	::GetIniItem(NULL, m_pIniFile, cSection, Key, cBuf, DefValue);
	return cBuf.IsEmpty() ? NULL : (LPCSTR)cBuf;
}
int CUsr::AddUser(int UserType, LPCSTR UserID, BOOL Protect, int PrivLevel)
{
	ASSERT(AfxIsValidString(UserID));
	ASSERT(UserType >= UT_USER);
	ASSERT(UserType < UT_INVALID);
	ASSERT(PrivLevel >= USERPRI_ANON);
	ASSERT(PrivLevel < USERPRI_INVALID);
	ASSERT((Protect == TRUE) || (Protect == FALSE) || (Protect == 2));
	CString cUserID, cBuf;
	if (FindUser(UserType, UserID))
	{
		LogMsg(LOGF_DEBUG,"AddUser() User '%s' exist. Cannot add user.", UserID);
		return 0;
	}
	// Refresh just in case...
	::GetIniItem(NULL, m_pIniFile, "@hdr@", "Next", m_NextUserNum, 0);
	if (m_NextUserNum == 0)
		m_NextUserNum = 1;
	if (FindUser(m_NextUserNum, cBuf))
	{
		LogMsg(LOGF_ERROR,"AddUser() User number %d exist. Cannot add user.", m_NextUserNum);
		return 0;
	}
	
	// Update next user counter
	::PutIniItem(NULL, m_pIniFile, "@hdr@", "Next", ++m_NextUserNum);
	// Update the name to number reference
	cUserID.Format("N %d %s", UserType, UserID);
	::PutIniItem(NULL, m_pIniFile, cUserID, "UserNum", m_NextUserNum - 1);
	// Update the data record (section is number)
	cUserID.Format("U %d", m_NextUserNum - 1);
	::PutIniItem(NULL, m_pIniFile, cUserID,  "UserID", UserID);
	::PutIniItem(NULL, m_pIniFile, cUserID,  "Protect", Protect);
	::PutIniItem(NULL, m_pIniFile, cUserID,  "PrivLevel", PrivLevel);
	::PutIniItem(NULL, m_pIniFile, cUserID,  "Type", UserType);
	LogMsg(LOGF_SYSTEM,"AddUsr(): Added user #%d '%s'.", m_NextUserNum - 1, UserID);
	return m_NextUserNum -1;
}
// Find a user from user number
// Return ID
LPCSTR CUsr::FindUser(int UserNo, CString& cBuf)
{
	CString cSection;
	cSection.Format("U %d", UserNo);
	::GetIniItem(NULL, m_pIniFile, cSection, "UserID", cBuf, "");
	if (cBuf.IsEmpty())
		return NULL;
	return (LPCSTR)cBuf;
}
// Find a user from type and name
// Return number
int CUsr::FindUser(int UserType, LPCSTR UserID)
{
	ASSERT(AfxIsValidString(UserID));
	ASSERT(UserType >= UT_USER);
	ASSERT(UserType < UT_INVALID);
	int UserNum = 0;
	CString cSection;
	cSection.Format("N %d %s", UserType, UserID);
	::GetIniItem(NULL, m_pIniFile, cSection,  "UserNum", UserNum, 0);
	return UserNum;
}
void CUsr::LogMsg(int flag, LPCSTR Format, ...)
{
	CString cBuf;
	if (!ShouldLog(m_Log, flag))
		return;
	ASSERT(AfxIsValidString(Format, FALSE));
	cBuf.Format("CUsr: %s", Format);
	va_list argList;
	va_start(argList, Format);
	m_Log->LogMsgV(flag, cBuf, argList);
	va_end(argList);
}
///////////////////////////////////////////////////////////////////////////////////
// Higher level 
// General login function
// Rerturns user number or 0 on failure.
// Sends message back to the user
int CUsr::Login(int LoginMode, LPCSTR UserID, LPCSTR Password, CTextSock *Sock)
{
	int User;
	int PWmode = PW_NORMAL;
	CString cBuf, cKey;
	int err;
	LOGINPRMS lp;
	lp.LoginMode = LoginMode;
	lp.UserID = UserID;
	lp.Password = Password;
	lp.Sock = Sock;
	// First - let's check global options :-)
	switch(LoginMode)
	{
		case LT_REMOTE:
			if ((COptions::GetOption(COPTION_RA_DAEMON,RA_OPTIONS__ALLOWNETWORK) != "TRUE")
				&& (Sock->m_PeerName != "127.0.0.1"))
			{
				Sock->LogMsg(LOGF_SECURITY,"Login rejected. Remote admin is not allowed over the network.");
				Sock->SendMsg(530, "Login rejected. Remote admin is not allowed over the network.");
				return 0;
			}
			break;
	}
	// EXT module
	if (err = PrcExt(CAPIHandler::OnLogin,0,(WPARAM)&User,(LPARAM)&lp))
	{
		if (err == CFuncList::AbortError)
			goto fool_me;
		if (err == CFuncList::OkAllDone)
			return User;
	}
	
	User = m_pUserMngr->FindUser(UT_USER, UserID);
	User = MapUser(User);
	
	if (User != INVALID_USER_VALUE)
		PWmode = m_pUserMngr->GetParam(User,"PWmode", PW_NORMAL);
	cKey.Format("%s Access", SafeStringIndex(CSock::DaemonTypes,LoginMode,LT_INVALID));
	Sock->m_IsLoggedInAnonymously = TRUE;
	if (!User || !m_pUserMngr->HasPermission(User, cKey))
	{
		// Update log
		if (User)
			Sock->LogMsg(LOGF_SECURITY,"Login rejected. User account '%s' is not authorized for %s.", 
				UserID, SafeStringIndex(CSock::DaemonTypes, Sock->m_Type, LT_INVALID));
		else
			Sock->LogMsg(LOGF_SECURITY,"Login attepmted to unknown user '%s'", UserID);
fool_me:
		if (Password)
			goto deny_me;
		// Send message to user
		if (Sock)
		{
				Sock->SendMsg(331, "User name okay. Need password.");
		}
		return 0;
	}
	if (m_pUserMngr->GetParam(User, "Local Only", FALSE))
	{
		// User can only log on from local machine
		if (Sock->m_PeerName != Sock->m_HostName)
		{
			LogMsg(LOGF_SECURITY,
				"Login rejected. User account '%s' is only authorized for local access.", 
				UserID);
			goto fool_me;
		}
	}
	if (Password && *Password)
	{
		// EXT module
		if (err = PrcExt(CAPIHandler::OnPassword,0,(WPARAM)&User,(LPARAM)&lp))
		{
			if (err == CFuncList::AbortError)
				goto deny_me;
			if (err == CFuncList::OkAllDone)
				goto allow_me;
		}
		if (PWmode == PW_EMAIL)
		{
			CString cBuf("");
			LPCSTR p = Password;
			while(*p && (*p != '@'))
				cBuf += *(p++);
			if (!p || (*p != '@'))
			{
				// EXT module
				if (err = Sock->PrcSockExt(CSock::iOnBadPassword,0,0,(LPARAM)Password))
				{
					return 0;
				}		
				Sock->LogMsg(LOGF_SECURITY,"Login rejected for user '%s'. Bad email address!", UserID);
				Sock->SendMsg(530, "Please use your full email address as password!");
				return 0;
			}
			
			Sock->m_LoginName.Format("%s@%s", cBuf, p[1] ? p : Sock->m_DNSName);
			Sock->SetName(Sock->m_LoginName);
			if (err = Sock->PrcSockExt(CSock::iOnVerifyLogin,1,(WPARAM)&User,(LPARAM)&lp))
			{
				if (err == CFuncList::AbortError)
					goto fool_me;
				if (err == CFuncList::OkAllDone)
					return User;
			}	
			Sock->m_IsLoggedIn = TRUE;
			Sock->LogMsg(LOGF_INOUT,"%s Logged on anonymously with email '%s' as password", UserID, Password);
		}
		else if (PWmode == PW_NORMAL)
		{
			// Normal password
			m_pUserMngr->GetParam(User, "Password", "", cBuf);
			if (cBuf.IsEmpty())
			{
				Sock->LogMsg(LOGF_SECURITY,"Login rejected for user '%s'. Missing password!", UserID);
				goto deny_me;
			}
			if (!IsDES13validPwd(Password,m_pUserMngr->GetParam(User, "Password", "", cBuf)))
			{
				// Not accepted!
				Sock->LogMsg(LOGF_SECURITY,"Login rejected for user '%s'. Bad password!", UserID);
deny_me:
				// EXT module
				if (err = Sock->PrcSockExt(CSock::iOnBadPassword,0,0,(LPARAM)Password))
				{
					return 0;
				}		
				Sock->SendMsg(530, "User %s access denied....", UserID);
				return 0;
			}
			else
			{
allow_me:
				Sock->m_IsLoggedInAnonymously = FALSE;
				Sock->m_LoginName = UserID;
				Sock->SetName(Sock->m_LoginName);
				if (err = Sock->PrcSockExt(CSock::iOnVerifyLogin,0,(WPARAM)&User,(LPARAM)&lp))
				{
					if (err == CFuncList::AbortError)
						goto fool_me;
					if (err == CFuncList::OkAllDone)
						return User;
				}	
				Sock->m_IsLoggedIn = TRUE;
				Sock->LogMsg(LOGF_INOUT,"Logged on with normal password");
			}
		}
		else // No password
			goto skip_pwd;
	}
	else 
	{
		if (PWmode == PW_NORMAL)
		{
			Sock->SendMsg(331, "User name okay. Need password.");
			return 0;
		}
		else if (PWmode == PW_EMAIL)
		{
			Sock->SendMsg(331, "User name okay. Give your full email address as password.");
			return 0;
		}
		else
		{
skip_pwd:
			Sock->m_LoginName = UserID;
			Sock->SetName(Sock->m_LoginName);
			if (err = Sock->PrcSockExt(CSock::iOnVerifyLogin,1,(WPARAM)&User,(LPARAM)&lp))
			{
				if (err == CFuncList::AbortError)
					goto fool_me;
				if (err == CFuncList::OkAllDone)
					return User;
			}	
			Sock->m_IsLoggedIn = TRUE;
			Sock->LogMsg(LOGF_INOUT,"Logged on anonymously with no password");
		}
	}
	Sock->PrcSockExt(CSock::iOnHasLoggedOn,User,(WPARAM)UserID,(LPARAM)Password);
	return User;
}
// Is system administrator?
BOOL CUsr::IsAdmin(int User)
{
	return m_pUserMngr->GetParam(User, "Administrator", FALSE);
}
USER CUsr::GetUserClass(USER OrgUser)
{
	int User = MapUser(OrgUser);
	return m_pUserMngr->GetParam(User, "Class", INVALID_USER_VALUE);
}
USER CUsr::GetUserGroup(USER OrgUser)
{
	int User = MapUser(OrgUser);
	return m_pUserMngr->GetParam(User, "Group", INVALID_USER_VALUE);
}
USER CUsr::GetUserSystem(USER OrgUser)
{
	int User = MapUser(OrgUser);
	USER System = m_pUserMngr->GetParam(User, "System", INVALID_USER_VALUE);
	if (System == INVALID_USER_VALUE)
		System =  m_pUserMngr->FindUser(UT_SYSTEM,"System");
	if (System == INVALID_USER_VALUE)
		LogMsg(LOGF_ERROR,"*** No system user in the user database!");
	return System;
}
int CUsr::GetType(USER OrgUser)
{
	int User = MapUser(OrgUser);
	return m_pUserMngr->GetParam(User, "Type", 0);
}
USER CUsr::MapUser(USER User)
{
	return GetParam(User,"Alias to", User);
}
BOOL CUsr::ListUsers(int Type, LPCSTR Pattern, CString& cBuf, BOOL IsInteractive)
{
	cBuf.Empty();
	CString cNames, cTmp, cPwd;
	CString MyPattern;
	LPSTR p;
	int User;
	CString cAliasFor;
	int System = -2, Class = -2, Group = -2;
	int uSystem, uClass, uGroup;
	int Count = 0;
	int numidx = 5, nameidx = 24;
	int PWmode, Protected, nAliasFor;
	// Check to see if pattern is a specifier for System,Class,Group
	// Pattern can be either a tag[*] or System,Class,Group
	if (Pattern && strchr(Pattern,','))
	{
		if (sscanf(Pattern, "%d,%d,%d", &System, &Class, &Group) == 3)
		{
			// Move the pattern pointer beoind the stuff we just parsed...
			while(*Pattern)
			{
				if (isdigit(*Pattern) || (*Pattern == ',') || (*Pattern == '-') || isspace(*Pattern))
					++Pattern;
				else
					break;
			}
		}
		else
			System = Class = Group = 0;
	}
	MyPattern.Format("N %d %s", Type, (Pattern && *Pattern) ? Pattern : "*");
	if (!::GetIniItemSectionNames(NULL, m_pIniFile, MyPattern, cNames))
		return FALSE;
	if (IsInteractive)
		cBuf.Format("%-24s %5s T %5s %5s %5s %5s %srn", 
			"Name", "Num", "Flags", "Syst", "Class", "Group", "Alias for");
	else
	{
		numidx = nameidx = 0;
		cBuf.Empty();
	}
	for(p = strtok(cNames.GetBuffer(1)," "); p; p = strtok(NULL," "))
	{
		if ((p = strtok(NULL," ")) == NULL)
			break;
		if ((p = strtok(NULL,"rn")) == NULL)
			break;
		if ((User = FindUser(Type, p)) == 0)
			continue;
		if ((nAliasFor = GetParam(User, "Alias to", INVALID_USER_VALUE)) != INVALID_USER_VALUE)
		{
			if (!FindUser(nAliasFor,cAliasFor))
			continue;
		}
		else
			cAliasFor.Empty();
		uSystem = GetUserSystem(User);
		uClass = GetUserClass(User);
		uGroup = GetUserGroup(User);
		// Check System, Class & Group limitations
		//if ((Class != INVALID_USER_VALUE) && /*(uClass != INVALID_USER_VALUE) &&*/ (Class != uClass))
		//	continue;
		//
		//if ((System != INVALID_USER_VALUE) && (System != uSystem))
		//	continue;
		//
		//if ((Group != INVALID_USER_VALUE) && /*(uGroup != INVALID_USER_VALUE) &&*/ (Group != uGroup))
		//	continue;
	
		if ((Class != -2) && /*(uClass != INVALID_USER_VALUE) &&*/ (Class != uClass))
			continue;
		if ((System != -2) && (System != uSystem))
			continue;
		if ((Group != -2) && /*(uGroup != INVALID_USER_VALUE) &&*/ (Group != uGroup))
			continue;
		++Count;
		PWmode = GetParam(User,"PWmode", PW_NORMAL);
		Protected = GetParam(User,"Protect", FALSE);
		cTmp.Format("%-*s %*d %d %c%c%c%c%c %*d %*d %*d %d %srn", 
			nameidx, p, 
			numidx, User, 
			GetType(User), 
			IsAdmin(User) ? 'A' : '-',
			GetParam(User,"FTP Access", FALSE) ? 'F' : '-',
			GetParam(User,"RemoteAdmin Access", FALSE) ? 'R' : '-',
			(PWmode == PW_NONE) ? 'n' : (PWmode == PW_EMAIL) ? 'e' : 'p',
			Protected == 1 ? 's' : Protected == 2 ? 'S' : '-',
			numidx, uSystem, 
			numidx, uClass, 
			numidx, uGroup,
			nAliasFor == INVALID_USER_VALUE ? 0 : nAliasFor,
			cAliasFor);
		cBuf += cTmp;
	}
	
	return Count > 0;
}
BOOL CUsr::ListUserParams(int Type, LPCSTR Name, CString& cBuf)
{
	CString cKey;
	int User;
	if ((User = atoi(Name)) == 0) // Ignore type when using the number
		if ((User = FindUser(Type,Name)) == 0)
			return FALSE;
	cKey.Format("U %d", User);
	if (!::GetIniItemSection(NULL, m_pIniFile, cKey, NULL, cBuf))
		return FALSE;
	return TRUE;
}
BOOL CUsr::SetUserOption(int Type, LPCSTR Option)
{
	LPSTR buf = strdup(Option), p;
	CString cKey;
	int User;
	int Rval = FALSE;
	if ((p = strtok(buf,"/")) == NULL)
		goto done;
	if ((User = atoi(p)) != 0) // Ignore type when using the number
	{
		if (!FindUser(User,cKey))
			goto done;
	}
	else if ((User = FindUser(Type,p)) == 0)
		goto done;
	if ((p = strtok(NULL,"=")) == NULL)
		goto done;
	cKey = p;
	p = strtok(NULL,"");
	SetParam(User, cKey, p ? p : "");
	Rval = TRUE;
done:
	free(buf);
	return Rval;
}
BOOL CUsr::GetUserOption(int Type, LPCSTR Option, CString& cReturnValue)
{
	LPSTR buf = strdup(Option), p;
	CString cKey;
	int User;
	int Rval = FALSE;
	if ((p = strtok(buf,"/")) == NULL)
		goto done;
	if ((User = atoi(p)) != 0) // Ignore type when using the number
	{
		if (!FindUser(User,cKey))
			goto done;
	}
	else if ((User = FindUser(Type,p)) == 0)
		goto done;
	if ((p = strtok(NULL,"=")) == NULL)
		goto done;
	cKey = p;
	p = strtok(NULL,"");
	if (!GetParam(User, cKey, p ? p : "", cReturnValue))
		goto done;
	Rval = TRUE;
done:
	free(buf);
	return Rval;
}
// Recursive permission.
// Only true if the whole path (from system to user) has the
// permission.
BOOL CUsr::HasPermission(USER User, LPCSTR Option)
{
	int Parent;
	if (!GetParam(User, Option, FALSE))
		return FALSE;
	if ((Parent = GetUserGroup(User)) != INVALID_USER_VALUE)
	{
		if (!GetParam(Parent, Option, FALSE))
			return FALSE;
	}
	if ((Parent = GetUserClass(User)) != INVALID_USER_VALUE)
	{
		if (!GetParam(Parent, Option, FALSE))
			return FALSE;
	}
	if ((Parent = GetUserSystem(User)) != INVALID_USER_VALUE)
	{
		if (!GetParam(Parent, Option, FALSE))
			return FALSE;
	}
	
	return TRUE;
}
// Recursive permission.
// Only true if the whole path (from system to user) has the
// permission.
LPCSTR CUsr::GetRecursiveParam(USER UserNum, LPCSTR Key, LPCSTR DefValue, CString& cBuf)
{
	USER Parent;
	GetParam(UserNum, Key, "", cBuf);
	if (cBuf != "")
		return cBuf;
	
	if ((Parent = GetUserGroup(UserNum)) != INVALID_USER_VALUE)
	{
		GetParam(Parent, Key, "", cBuf);
		if (cBuf != "")
			return cBuf;
	}
	if ((Parent = GetUserClass(UserNum)) != INVALID_USER_VALUE)
	{
		GetParam(Parent, Key, "", cBuf);
		if (cBuf != "")
			return cBuf;
	}
	if ((Parent = GetUserSystem(UserNum)) != INVALID_USER_VALUE)
	{
		GetParam(Parent, Key, "", cBuf);
		if (cBuf != "")
			return cBuf;
	}
	
	cBuf = DefValue;
	return cBuf;
}
int CUsr::GetRecursiveParam(USER UserNum, LPCSTR Key, int DefValue)
{
	CString cBuf, cValue;
	cBuf.Format("%d", DefValue);
	GetRecursiveParam(UserNum, Key, cBuf, cValue);
	return atoi(cValue);
}
// Delete user
BOOL CUsr::DeleteUser(LPCSTR UserName)
{
	USER User;
	CString cUserID, cBuf;
	int UserType;
	CString UserID;
	if ((User = atoi(UserName)) == 0)
		User = FindUser(UT_USER, UserName);
	if (!User || (User == INVALID_USER_VALUE) || !FindUser(User, cUserID))
	{
		LogMsg(LOGF_WARNINGS,"DeleteUser(%s) - Can't find the user.", UserName);
		return FALSE;
	}
	UserType = GetType(User);
	if (GetParam(User,"Protect",0))
	{
		LogMsg(LOGF_WARNINGS,"DeleteUser(%s) - User is protected.", UserName);
		return FALSE;
	}
	if (!atoi(UserName) && (cUserID != UserName))
		return DeleteAlias(UserName);
	cBuf.Format("N %d %s", UserType, cUserID);
	::ResetSection(NULL, m_pIniFile, cBuf);
	cBuf.Format("U %d", User);
	::ResetSection(NULL, m_pIniFile, cBuf);
	LogMsg(LOGF_SYSTEM,"User %s (%d) is deleted.", cUserID, User);
	return TRUE;
}
BOOL CUsr::DeleteAlias(LPCSTR AliasName)
{
	CString cBuf;
	cBuf.Format("N 1 %s", AliasName);
	::ResetSection(NULL, m_pIniFile, cBuf);
	return TRUE;
}
BOOL CUsr::RenameUser(LPCSTR UserName, LPCSTR NewName)
{
	USER User;
	CString cUserID, cBuf;
	int UserType;
	CString UserID;
	if ((User = atoi(UserName)) == 0)
		User = FindUser(UT_USER, UserName);
	if (!User || (User == INVALID_USER_VALUE) || !FindUser(User, cUserID))
	{
		LogMsg(LOGF_WARNINGS,"RenameUser(%s) - Can't find the user.", UserName);
		return FALSE;
	}
	UserType = GetType(User);
	if (GetParam(User,"Protect",0))
	{
		LogMsg(LOGF_WARNINGS,"RenameUser(%s) - User is protected.", UserName);
		return FALSE;
	}
	if (FindUser(UserType, NewName))
	{
		LogMsg(LOGF_WARNINGS,"RenameUser(%s,%s) - New user name exist .", 
			UserName, NewName);
		return FALSE;
	}
	//Validiate user name
	LPCSTR p = NewName;
	while(*p)
	{
		if (!isalpha(*p) && !isdigit(*p) && !strchr("(){}._-$@#!", *p))
		{
			LogMsg(LOGF_WARNINGS,"RenameUser(%s,%s) - New user name is illegal .", 
			UserName, NewName);
			return FALSE;
		}
		++p;
	}
	cBuf.Format("N %d %s", UserType, cUserID);
	::ResetSection(NULL, m_pIniFile, cBuf);
	cBuf.Format("N %d %s", UserType, NewName);
	::PutIniItem(NULL, m_pIniFile, cBuf, "UserNum", User);
	if (atoi(UserName) || (cUserID == UserName))
	{
		// Update the user ID unless this is an alias...
		SetParam(User, "UserID", NewName);
	}
	LogMsg(LOGF_SYSTEM,"User %s (%d) is renamed (%s).", cUserID, User, NewName);
	return TRUE;
}

						