cpgpdiskuserset.cpp

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*____________________________________________________________________________
		Copyright (C) 2002 PGP Corporation
        All rights reserved.

        $Id: CPGPdiskUserSet.cpp,v 1.5 2002/08/06 20:09:36 dallen Exp $
____________________________________________________________________________*/

#include "pgpClassesConfig.h"

#include "CString.h"

#if defined(PGP_WIN32) && !defined(PGP_DRIVER98) && !defined(PGP_DRIVERNT)
#include "CPath.h"
#endif

#include "CPGPdiskDisk.h"
#include "CPGPdiskUser.h"
#include "CPGPdiskUserSet.h"

_USING_PGP

// Class CPGPdiskUserSet ember functions

CPGPdiskUserSet::CPGPdiskUserSet(const CPGPdiskUser& user)
{
	Singleton(user);
}

CPGPdiskUserSet::CPGPdiskUserSet(const CPGPdiskUserSet& userSet)
{
	Assign(userSet);
}

CPGPdiskUserSet::~CPGPdiskUserSet()
{
	pgpAssert(mUserIters.IsEmpty());
	Empty();
}

CPGPdiskUserSet& 
CPGPdiskUserSet::operator=(const CPGPdiskUserSet& userSet)
{
	Assign(userSet);
	return (*this);
}

void 
CPGPdiskUserSet::Add(const CPGPdiskUserSet& usersToAdd)
{
	if (&usersToAdd == this)
		return;

	CPGPdiskUser	*pUser	= usersToAdd.mUsers.Head();

	while (IsntNull(pUser))
	{
		if (IsNull(FindEqualUser(*pUser)))
			mUsers.AddTail(new CPGPdiskUser(*pUser));

		pUser = usersToAdd.mUsers.Next(pUser);
	}

	RewindAllUserIters();
}

void 
CPGPdiskUserSet::Add(const CPGPdiskUser& userToAdd)
{
	if (IsNull(FindEqualUser(userToAdd)))
		mUsers.AddTail(new CPGPdiskUser(userToAdd));

	RewindAllUserIters();
}

void 
CPGPdiskUserSet::Remove(const CPGPdiskUserSet& usersToRemove)
{
	if (&usersToRemove == this)
	{
		Empty();	// uhh, ok.
		return;
	}

	CPGPdiskUser	*pUser	= usersToRemove.mUsers.Head();

	while (IsntNull(pUser))
	{
		CPGPdiskUser	*pEqualUser	= FindEqualUser(*pUser);

		if (IsntNull(pEqualUser))
		{
			mUsers.Remove(pEqualUser);
			delete pEqualUser;
		}

		pUser = usersToRemove.mUsers.Next(pUser);
	}

	RewindAllUserIters();
}

void 
CPGPdiskUserSet::Remove(const CPGPdiskUser& userToRemove)
{
	CPGPdiskUser	*pEqualUser	= FindEqualUser(userToRemove);

	if (IsntNull(pEqualUser))
	{
		mUsers.Remove(pEqualUser);
		delete pEqualUser;
	}

	RewindAllUserIters();
}

void 
CPGPdiskUserSet::Singleton(const CPGPdiskUser& user)
{
	pgpAssert(user.IsAssigned());

	Empty();
	mUsers.AddTail(new CPGPdiskUser(user));

	RewindAllUserIters();
}

void 
CPGPdiskUserSet::Assign(const CPGPdiskUserSet& userSet)
{
	if (&userSet == this)
		return;

	Empty();
	Add(userSet);

	RewindAllUserIters();
}

void 
CPGPdiskUserSet::Empty()
{
	mUsers.EmptyWithDelete();
	RewindAllUserIters();
}

CPGPdiskUser * 
CPGPdiskUserSet::FindEqualUser(const CPGPdiskUser& user) const
{
	CPGPdiskUser	*pCurUser	= mUsers.Head();

	// Search on operator==.
	while (IsntNull(pCurUser))
	{
		if (user == *pCurUser)
			return pCurUser;

		pCurUser = mUsers.Next(pCurUser);
	}

	return NULL;
}

void 
CPGPdiskUserSet::RewindAllUserIters()
{
	CPGPdiskUserIter	*pUserIter	= mUserIters.Head();

	while (IsntNull(pUserIter))
	{
		pUserIter->Rewind();
		pUserIter = mUserIters.Next(pUserIter);
	}
}

void 
CPGPdiskUserSet::RegisterUserIter(CPGPdiskUserIter *pUserIter) const
{
	pgpAssertAddrValid(pUserIter, CPGPdiskUserIter);
	mUserIters.AddTail(pUserIter);
}

void 
CPGPdiskUserSet::DeregisterUserIter(CPGPdiskUserIter *pUserIter) const
{
	pgpAssertAddrValid(pUserIter, CPGPdiskUserIter);
	mUserIters.Remove(pUserIter);
}


// Class CPGPdiskUserIter member functions

CPGPdiskUserIter::CPGPdiskUserIter(const CPGPdiskUserSet *pUserSet) : 
	CIter<CPGPdiskUser>(&pUserSet->mUsers), mPUserSet(pUserSet)
{
	pgpAssertAddrValid(pUserSet, CPGPdiskUserSet);
	pUserSet->RegisterUserIter(this);
}

CPGPdiskUserIter::~CPGPdiskUserIter()
{
	UserSet()->DeregisterUserIter(this);
}

CPGPdiskUser * 
CPGPdiskUserIter::SearchOnUserName(const char *userName)
{
	pgpAssertStrValid(userName);

	Rewind();
	CPGPdiskUser	*pUser;

	while (TRUE)
	{
		pUser = Next();

		if (IsNull(pUser))
			break;

		CString	curUserName;
		pUser->GetUserName(curUserName);

		if (curUserName.Compare(userName))
			break;
	}

	return pUser;
}

CPGPdiskUser * 
CPGPdiskUserIter::FindEqualUser(const CPGPdiskUser& user) const
{
	return UserSet()->FindEqualUser(user);
}

CPGPdiskUser * 
CPGPdiskUserIter::FindAdminUser()
{	
	Rewind();
	CPGPdiskUser	*pUser;

	while (TRUE)
	{
		pUser = Next();

		if (IsNull(pUser))
			break;

		if (pUser->IsAdminUser())
			break;
	}

	return pUser;
}

void 
CPGPdiskUserIter::SafeSetAdminUser(
	CPGPdiskUser	*pNewAdmin, 
	CPGPdiskUser	*pOldAdmin)
{
	pgpAssertAddrValid(pNewAdmin, CPGPdiskUser);
	pgpAssert(pNewAdmin->IsAssigned());

	// User must be from this user set.
	if (!mPUserSet->mUsers.Contains(pNewAdmin))
		THROW_PGPERROR(kPGPError_BadParams);

	// Client must show he can decrypt with the new Admin.
	if (!pNewAdmin->IsCipheringEnabled())
		THROW_PGPERROR(kPGPError_BadParams);

	// If there was an old admin, we must have it.
	CPGPdiskUser	*pActualOldAdmin	= FindAdminUser();

	if (IsntNull(pActualOldAdmin))
	{
		if (pActualOldAdmin != pOldAdmin)
			THROW_PGPERROR(kPGPError_BadParams);

		pOldAdmin->SetIsAdminUser(FALSE);
	}

	// Set new admin.
	pNewAdmin->SetIsReadOnly(FALSE);
	pNewAdmin->SetIsDisabled(FALSE);
	pNewAdmin->SetIsAdminUser(TRUE);
}