pgpgroups.c

vc环境下的pgp源码

	PGPError
PGPCountGroupsInSet(
	PGPGroupSetRef	set,
	PGPUInt32 *			numGroups)
{
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidatePtr( numGroups );
	*numGroups	= 0;
	PGPValidateGroupSet( set );
	
	*numGroups	= set->numGroups;
	
	return( err );
}


	PGPError
PGPGetIndGroupID(
	PGPGroupSetRef	set,
	PGPUInt32			groupIndex,
	PGPGroupID *		id)
{
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidatePtr( id );
	*id	= kPGPInvalidGroupID;
	PGPValidateGroupSet( set );
	PGPValidateParam( groupIndex < set->numGroups );
	
	*id	= set->groupArray[ groupIndex ].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.group.id	= (PGPGroupID)temp;
			pgpAssert( exportedItem.u.group.id != kPGPInvalidGroupID );
		}
		else if ( exportedItem.type == kPGPGroupItem_KeyID )
		{
			err	= sReadUInt32FromIO( io, &exportedItem.u.key.algorithm );
			if ( IsntPGPError( err ) )
				err	= PGPIORead( io, 1, &exportedItem.u.key.length, NULL);
			if ( IsntPGPError( err ) )
			{
				err	= PGPIORead( io,
					exportedItem.u.key.length,
					exportedItem.u.key.exportedKeyID, NULL);
			}
		}
	}
	
	if ( IsntPGPError( err ) )
	{
		err	= sVerifyChecksumFromIO( sComputeExportedGroupItemChecksum(
							&exportedItem ), io );
		if( IsntPGPError( err ) )
		{
			item->type = exportedItem.type;
			
			if( exportedItem.type == kPGPGroupItem_Group )
			{
				item->u.group.id = exportedItem.u.group.id;
			}
			else if( exportedItem.type == kPGPGroupItem_KeyID )
			{
				item->u.key.algorithm = 
						(PGPPublicKeyAlgorithm) exportedItem.u.key.algorithm;
						
				err = PGPImportKeyID( exportedItem.u.key.exportedKeyID,
								&item->u.key.keyID );
			}
		}
	}
	
	return( err );
}


	static PGPError
sReadGroupFromIO(
	PGPContextRef	context,
	PGPIORef		io,
	PGPGroup *		group )
{
	PGPError		err	= kPGPError_NoErr;
	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 ) )
		{
			PGPUInt32		itemIndex;

			/* now read all the items in */
			for ( itemIndex = 0; itemIndex < group->numItems; ++itemIndex )
			{
				err	= sReadGroupItemFromIO( io, &group->itemsArray[ itemIndex ] );
				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 );
	
	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

	PGPError
PGPNewGroupSetFromFSSpec(
	PGPContextRef		context,
	const FSSpec *		spec,
	PGPGroupSetRef *	outSet )
{
	PGPError		err;
	PGPFileSpecRef	fileSpec;
	
	PGPValidatePtr( outSet );
	*outSet	= NULL;
	PGPValidateContext( context );
	PGPValidatePtr( spec );
	
	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.group.id = item->u.group.id;
	}
	else if( item->type == kPGPGroupItem_KeyID )
	{
		PGPSize	dataSize;
		PGPByte	exportedKeyID[kPGPMaxExportedKeyIDSize];
		
		/*
		** PGPExportKeyID() whacks the complete array, so export to
		** a local buffer and then copy to the data structure
		*/
		
		err = PGPExportKeyID( &item->u.key.keyID, exportedKeyID, &dataSize );
		pgpAssert( dataSize <= sizeof( exportedItem.u.key.exportedKeyID ) );
		
		pgpCopyMemory( exportedKeyID, exportedItem.u.key.exportedKeyID,
							sizeof( exportedItem.u.key.exportedKeyID ) );
		exportedItem.u.key.length 		= (PGPByte) dataSize;
		exportedItem.u.key.algorithm 	= item->u.key.algorithm;
		
	}
	
	if( IsntPGPError( err ) )
	{
		err	= sWriteUInt32ToIO( exportedItem.type, io);
		if ( IsntPGPError( err ) )
		{
			if ( exportedItem.type == kPGPGroupItem_Group )
			{
				err	= sWriteUInt32ToIO( (PGPUInt32)exportedItem.u.group.id, io);
			}
			else if ( exportedItem.type == kPGPGroupItem_KeyID )
			{
				err	= sWriteUInt32ToIO( exportedItem.u.key.algorithm, io );
				if ( IsntPGPError( err ) )
					err	= PGPIOWrite( io, 1, &exportedItem.u.key.length);
				if ( IsntPGPError( err ) )
				{
					err	= PGPIOWrite( io, exportedItem.u.key.length,
								exportedItem.u.key.exportedKeyID );
				}
			}
		}
	}
	
	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		itemIndex;
	
		/* now write all the items out */
		for ( itemIndex = 0; itemIndex < group->numItems; ++itemIndex )
		{
			err	= sWriteGroupItemToIO( &group->itemsArray[ itemIndex ], 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 );
	
	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 )
		{