pgpgroups.c

可以实现对邮件的加密解密以及签名

	return( err );
}


	PGPError
PGPGetIndGroupID(
	PGPGroupSetRef	set,
	PGPUInt32			index,
	PGPGroupID *		id)
{
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidatePtr( id );
	*id	= kPGPInvalidGroupID;
	PGPValidateGroupSet( set );
	PGPValidateParam( index < set->numGroups );
	
	pgpEnterPGPErrorFunction();

	*id	= set->groupArray[ index ].id;
	
	return( err );
}









	static PGPError
sReadGroupSetHeaderFromIO(
	PGPIORef		io,
	PGPGroupSet *	set )
{
	PGPError	err	= kPGPError_NoErr;
	
	err	= sReadUInt32FromIO( io, &set->magic);
	if ( IsntPGPError( err ) )
	{
		if ( set->magic != kPGPGroupSetMagic )
			err	= kPGPError_BadParams;
		else
			err	= sReadUInt32FromIO( io, &set->numGroups );
	}
	if ( IsntPGPError( err ) )
	{
		err	= sReadUInt32FromIO( io, &set->version );
	}
	if ( IsntPGPError( err ) )
	{
		err	= sReadUInt32FromIO( io, &set->nextAvailGroupID );
	}
	if ( IsntPGPError( err ) )
	{
		err	= PGPIORead( io, sizeof( set->pad ), set->pad, NULL );
	}
	
	if ( IsntPGPError( err ) )
	{
		err	= sVerifyChecksumFromIO( sComputeGroupSetChecksum( set ), io );
	}
	
	return( err );
}



	static PGPError
sReadGroupItemFromIO(
	PGPIORef			io,
	PGPGroupItem *		item )
{
	PGPError				err	= kPGPError_NoErr;
	PGPUInt32				temp;
	PGPExportedGroupItem	exportedItem;
	
	err	= sReadUInt32FromIO( io, &temp );
	if ( IsntPGPError( err ) )
	{
		exportedItem.type = (PGPGroupItemType)temp;
		
		if ( exportedItem.type == kPGPGroupItem_Group )
		{
			err	= sReadUInt32FromIO( io, &temp );
			exportedItem.u.groupID	= (PGPGroupID)temp;
			pgpAssert( exportedItem.u.groupID != kPGPInvalidGroupID );
		}
		else if ( exportedItem.type == kPGPGroupItem_KeyID )
		{
			err	= PGPIORead( io, sizeof( PGPKeyID ),
								&exportedItem.u.keyID, NULL);
		}
	}
	
	if ( IsntPGPError( err ) )
	{
		err	= sVerifyChecksumFromIO( sComputeExportedGroupItemChecksum(
							&exportedItem ), io );
		if( IsntPGPError( err ) )
		{
			item->type = exportedItem.type;
			
			if( exportedItem.type == kPGPGroupItem_Group )
			{
				item->u.groupID = exportedItem.u.groupID;
			}
			else if( exportedItem.type == kPGPGroupItem_KeyID )
			{
				item->u.keyID = exportedItem.u.keyID;
			}
		}
	}
	
	return( err );
}


	static PGPError
sReadGroupFromIO(
	PGPContextRef	context,
	PGPIORef		io,
	PGPGroup *		group )
{
	PGPError		err	= kPGPError_NoErr;
	PGPUInt32		index;
	PGPUInt32		temp;
	
	err	= sReadUInt32FromIO( io, &temp );
	if ( IsntPGPError( err ) )
	{
		group->id	= (PGPGroupID)temp;
		err	= PGPIORead( io, sizeof( group->name ), group->name, NULL);
	}
	if ( IsntPGPError( err ) )
	{
		err	= PGPIORead( io,
				sizeof( group->description ), group->description, NULL);
	}
	if ( IsntPGPError( err ) )
	{
		err	= sReadUInt32FromIO( io, &group->numItems);
	}
	
	if ( IsntPGPError( err ) )
	{
		err	= sVerifyChecksumFromIO( sComputeGroupChecksum( group ), io );
	}
	
	if ( IsntPGPError( err ) )
	{
		if ( group->numItems != 0 )
		{
			group->itemsArray	= (PGPGroupItem *)pgpContextMemAlloc( context,
					( group->numItems * sizeof(group->itemsArray[ 0 ]) ),
					kPGPMemoryMgrFlags_Clear );
			if ( IsNull( group->itemsArray ) )
			{
				err	= kPGPError_OutOfMemory;
			}
		}
		
		if ( IsntPGPError( err ) )
		{
			/* now read all the items in */
			for ( index = 0; index < group->numItems; ++index )
			{
				err	= sReadGroupItemFromIO( io, &group->itemsArray[ index ] );
				if ( IsPGPError( err ) )
					break;
			}
		}
	}
	
	pgpAssertNoErr( err );
	return( err );
}



	static PGPError
sReadGroupSetFromIO(
	PGPIORef		io,
	PGPGroupSetRef	set )
{
	PGPError		err	= kPGPError_NoErr;
	
	err	= sReadGroupSetHeaderFromIO( io, set );
	if ( IsntPGPError( err )  )
	{
		PGPUInt32	groupIndex;
		
		/* allocate the groups */
		if ( set->numGroups != 0 )
		{
			set->groupArray	= (PGPGroup *)pgpContextMemAlloc( set->context,
					( set->numGroups * sizeof( set->groupArray[ 0 ] ) ),
					kPGPMemoryMgrFlags_Clear );
			if ( IsNull( set->groupArray ) )
				err	= kPGPError_OutOfMemory;
		}
		
		if ( IsntPGPError( err ) )
		{
			for( groupIndex = 0; groupIndex < set->numGroups; ++groupIndex )
			{
				PGPGroup *	group;
				
				group	= &set->groupArray[ groupIndex ];
				sInitGroup( set, kPGPInvalidGroupID, NULL, NULL, group );
				err		= sReadGroupFromIO( set->context, io, group );
				if ( IsPGPError( err ) )
					break;
			}
		}
	}
	
	
	return( err );
}


	static PGPError
sReadGroupSetFromFile(
	PFLFileSpecRef	file,
	PGPGroupSet *	set )
{
	PGPError		err	= kPGPError_NoErr;
	PGPFileIORef	io	= NULL;
	
	PGPValidateGroupSet( set );
	PFLValidateFileSpec( file );
	PGPValidateParam( set->hasBeenModified );
	
	/* open it, and write everything out */
	err	= PGPOpenFileSpec( file,
			kPFLFileOpenFlags_ReadOnly, &io );
	if ( IsntPGPError( err ) )
	{
		err	= sReadGroupSetFromIO( (PGPIORef)io, set);
		PGPFreeIO( (PGPIORef)io );
		
		/* we just read it in and there are no changes */
		set->hasBeenModified	= FALSE;
	}
	
	return( err );
}





	PGPError
PGPNewGroupSetFromFile(
	PGPContextRef		context,
	PGPFileSpecRef		file,
	PGPGroupSetRef *	outSet )
{
	PGPError		err	= kPGPError_NoErr;
	PGPGroupSet *	set	= NULL;
	PGPBoolean		exists	= FALSE;
	PFLFileSpecRef	pflFile = (PFLFileSpecRef) file;
	
	PGPValidatePtr( outSet );
	*outSet	= NULL;
	PFLValidateFileSpec( pflFile );
	
	pgpEnterPGPErrorFunction();

	err	= PFLFileSpecExists( pflFile, &exists );
	if ( IsPGPError( err ) )
		return( err );
	if ( ! exists )
		return( kPGPError_FileNotFound );
	
	err	= PGPNewGroupSet( context, &set );
	if ( IsntPGPError( err ) )
	{
		err	= sReadGroupSetFromFile( pflFile, set );
		if( IsPGPError( err ) )
		{
			PGPFreeGroupSet( set );
			set = kInvalidPGPGroupSetRef;
		}
	}
	
	*outSet	= set;
	return( err );
}


#if PGP_MACINTOSH || PGP_OSX

	PGPError
PGPNewGroupSetFromFSSpec(
	PGPContextRef			context,
	const struct FSSpec *	spec,
	PGPGroupSetRef *		outSet )
{
	PGPError		err;
	PGPFileSpecRef	fileSpec;
	
	PGPValidatePtr( outSet );
	*outSet	= NULL;
	PGPValidateContext( context );
	PGPValidatePtr( spec );
	
	pgpEnterPGPErrorFunction();

	err	= PGPNewFileSpecFromFSSpec( context, spec, &fileSpec );
	if ( IsntPGPError( err ) )
	{
		err	= PGPNewGroupSetFromFile( context, fileSpec, outSet );
		PGPFreeFileSpec( fileSpec );
	}
	
	return( err );
}

#endif




	static PGPError
sWriteGroupSetHeaderToIO(
	PGPGroupSet const *	set,
	PGPIORef			io )
{
	PGPError		err	= kPGPError_NoErr;
	
	err	= sWriteUInt32ToIO( set->magic, io);
	if ( IsntPGPError( err ) )
	{
		err	= sWriteUInt32ToIO( set->numGroups, io );
	}
	if ( IsntPGPError( err ) )
	{
		err	= sWriteUInt32ToIO( set->version, io );
	}
	if ( IsntPGPError( err ) )
	{
		err	= sWriteUInt32ToIO( set->nextAvailGroupID, io );
	}
	if ( IsntPGPError( err ) )
	{
		err	= PGPIOWrite( io, sizeof( set->pad ), set->pad );
	}
	
	if ( IsntPGPError( err ) )
	{
		err	= sWriteChecksumToIO( sComputeGroupSetChecksum( set ), io );
	}
	
	return( err );
}



	static PGPError
sWriteGroupItemToIO(
	PGPGroupItem const *	item,
	PGPIORef				io )
{
	PGPError				err	= kPGPError_NoErr;
	PGPExportedGroupItem	exportedItem;
	
	exportedItem.type = item->type;
	
	if( item->type == kPGPGroupItem_Group )
	{
		exportedItem.u.groupID = item->u.groupID;
	}
	else if( item->type == kPGPGroupItem_KeyID )
	{
		exportedItem.u.keyID = item->u.keyID;
	}
	
	if( IsntPGPError( err ) )
	{
		err	= sWriteUInt32ToIO( exportedItem.type, io);
		if ( IsntPGPError( err ) )
		{
			if ( exportedItem.type == kPGPGroupItem_Group )
			{
				err	= sWriteUInt32ToIO( (PGPUInt32)exportedItem.u.groupID, io);
			}
			else if ( exportedItem.type == kPGPGroupItem_KeyID )
			{
				err	= PGPIOWrite( io, sizeof( exportedItem.u.keyID ),
							&exportedItem.u.keyID );
			}
		}
	}
	
	if ( IsntPGPError( err ) )
	{
		err	= sWriteChecksumToIO( sComputeExportedGroupItemChecksum(
							&exportedItem ), io );
	}
	
	return( err );
}


	static PGPError
sWriteGroupToIO(
	PGPGroup const *	group,
	PGPIORef			io )
{
	PGPError		err	= kPGPError_NoErr;
	
	err	= sWriteUInt32ToIO( (PGPUInt32)group->id, io );
	if ( IsntPGPError( err ) )
	{
		err	= PGPIOWrite( io, sizeof( group->name ), group->name );
	}
	if ( IsntPGPError( err ) )
	{
		err	= PGPIOWrite( io,
			sizeof( group->description ), group->description );
	}
	if ( IsntPGPError( err ) )
	{
		err	= sWriteUInt32ToIO( group->numItems, io);
	}
	
	if ( IsntPGPError( err ) )
	{
		err	= sWriteChecksumToIO( sComputeGroupChecksum( group ), io );
	}
	
	if ( IsntPGPError( err ) )
	{
		PGPUInt32		index;
	
		/* now write all the items out */
		for ( index = 0; index < group->numItems; ++index )
		{
			err	= sWriteGroupItemToIO( &group->itemsArray[ index ], io );
			if ( IsPGPError( err ) )
				break;
		}
	}
	
	return( err );
}



	static PGPError
sWriteGroupSetToIO(
	PGPGroupSetRef	set,
	PGPIORef		io )
{
	PGPError		err	= kPGPError_NoErr;
	
	err	= sWriteGroupSetHeaderToIO( set, io );
	if ( IsntPGPError( err ) && IsntNull( set->groupArray ) )
	{
		PGPUInt32	groupIndex;
		
		for( groupIndex = 0; groupIndex < set->numGroups; ++groupIndex )
		{
			PGPGroup *	group;
			
			group	= &set->groupArray[ groupIndex ];
			err	= sWriteGroupToIO( group, io );
			if ( IsPGPError( err ) )
				break;
		}
	}
	
	return( err );
}


	PGPError
PGPSaveGroupSetToFile(
	PGPGroupSetRef	set,
	PGPFileSpecRef	file )
{
	PGPError		err	= kPGPError_NoErr;
	PGPFileIORef	io	= NULL;
	PFLFileSpecRef	tempSpec	= NULL;
	PGPBoolean		fileExists	= TRUE;
	PFLFileSpecRef	pflFile = (PFLFileSpecRef) file;
	
	PGPValidateGroupSet( set );
	PFLValidateFileSpec( pflFile );
	
	pgpEnterPGPErrorFunction();

	err	= PFLFileSpecExists( pflFile, &fileExists );
	
	/* get a temp file to work with */
	if ( IsntPGPError( err ) )
		err	= PFLFileSpecGetUniqueSpec( pflFile, &tempSpec );
		
	if ( IsntPGPError( err ) )
	{
		/* create the temp file */
		err	= pgpCreateFile( tempSpec, kPGPFileTypeGroups );
		if ( IsntPGPError( err ) )
		{
			/* open it, and write everything out */
			err	= PGPOpenFileSpec( tempSpec,
					kPFLFileOpenFlags_ReadWrite, &io );
			if ( IsntPGPError( err ) )
			{
				err	= sWriteGroupSetToIO( set, (PGPIORef)io);
				PGPFreeIO( (PGPIORef)io );
			}
		}
		
		/* delete the original and rename the temp */
		if ( IsntPGPError( err ) && fileExists )
		{
			char	name[ 512 ];
			
			/* get original file name */
			err	= PFLGetFileSpecNameBuffer( pflFile,
					sizeof( name ), name );
						
			if ( IsntPGPError( err ) )
			{
				/* delete the original */
				err	= PFLFileSpecDelete( pflFile );
			}
				
			if ( IsntPGPError( err ) )
			{
				/* rename temp to original */
				err	= PFLFileSpecRename( tempSpec, name );
			}

		}
		
		if ( IsntPGPError( err ) )
		{
			/* safely up to date on disk... */
			set->hasBeenModified	= FALSE;
		}
		
		PFLFreeFileSpec( tempSpec );
	}
	
	return( err );
}



	PGPError
PGPExportGroupSetToBuffer(
	PGPGroupSetRef	set,
	void **			buffer,
	PGPSize *		bufferSize )
{
	PGPError		err	= kPGPError_NoErr;
	PGPIORef		io	= NULL;
	void *			tempBuffer = NULL;