pgpldap.c

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

			break;

		default:
			break;
	}

	goto done;
error:

done:
	if( IsntNull( filter ) )
		(void) PGPFreeData( filter );

	if( IsntNull( attr ) )
		(void) PGPFreeData( attr );

	if( IsntNull( substring ) )
		(void) PGPFreeData( substring );

	if( IsntNull( subfilter ) )
		(void) PGPFreeData( subfilter );

	if( IsntNull( value ) )
		(void) PGPFreeData( value );

	return err;
}

	PGPError
PGPldapSearch(
	PGPldapContextRef	pgpLDAP,
	char *				base,
	PGPldapScope		scope,
	char *				filter,
	char *				attrs[],
	PGPBoolean			attrsOnly,
	PGPldapMessageID *	messageID )
{
	PGPError			err		= kPGPError_NoErr;
	PGPberElementRef	ber		= kInvalidPGPberElementRef;

	PGPValidateLDAPContextRef( pgpLDAP );
	PGPValidatePtr( filter );
	PGPValidatePtr( messageID );

	if( IsNull( base ) )
		base = (char *) "";

	err = pgpNewBERElement( pgpLDAP->memMgr, &ber ); CKERR;

	/*
	 * Create the search request.  It looks like this:
	 *	SearchRequest ::=
	 *		[APPLICATION 3] SEQUENCE {
	 *			 baseObject     LDAPDN,
	 *			 scope          ENUMERATED {
	 *								 baseObject            (0),
	 *								 singleLevel           (1),
	 *								 wholeSubtree          (2)
	 *							},
	 *			 derefAliases   ENUMERATED {
	 *								 neverDerefAliases     (0),
	 *								 derefInSearching      (1),
	 *								 derefFindingBaseObj   (2),
	 *								 alwaysDerefAliases    (3)
	 *							},
	 *			 sizeLimit      INTEGER (0 .. maxInt),
	 *							-- value of 0 implies no sizelimit
	 *			 timeLimit      INTEGER (0 .. maxInt),
	 *							-- value of 0 implies no timelimit
	 *			 attrsOnly     BOOLEAN,
	 *							-- TRUE, if only attributes (without values)
	 *							-- to be returned.
	 *			 filter         Filter,
	 *			 attributes     SEQUENCE OF AttributeType
	 *		}
	 * wrapped in an ldap message.
	 */

	err = PGPberAppend( ber, "{it{seeiib",
			++(pgpLDAP->nextMessageID),
			kPGPldapRequest_Search,
			base,
			scope,
			pgpLDAP->deref,
			pgpLDAP->sizelimit,
			pgpLDAP->timelimit,
			attrsOnly ); CKERR;

	err = pgpLDAPAddFilter( pgpLDAP, ber, filter ); CKERR;

	err = PGPberAppend( ber, "{v}}}", attrs ); CKERR;

	err = pgpLDAPSend( pgpLDAP, ber ); CKERR;

	*messageID = pgpLDAP->nextMessageID;

	goto done;
error:

	*messageID = kInvalidPGPldapMessageID;

done:

	if( PGPberElementRefIsValid( ber ) )
		(void) PGPFreeBERElement( ber );

	return err;
}

	PGPError
PGPldapCountEntries(
	PGPldapContextRef	pgpLDAP,
	PGPldapMessageRef	result,
	PGPInt32 *			num )
{
	PGPldapMessageRef		message		= kInvalidPGPldapMessageRef;

	PGPValidateLDAPContextRef( pgpLDAP );
	PGPValidateLDAPMessageRef( result );
	PGPValidatePtr( num );

	(void) pgpLDAP;

	*num = 0;

	for( message = result;
		 message != kInvalidPGPldapMessageRef;
		 message = message->next )
	{
		if( message->type == kPGPldapResponse_SearchEntry )
			(*num)++;
	}

	return kPGPError_NoErr;
}

	PGPError
PGPldapFirstEntry(
	PGPldapContextRef	pgpLDAP,
	PGPldapMessageRef	result,
	PGPldapMessageRef *	outMessage )
{
	PGPValidateLDAPContextRef( pgpLDAP );
	PGPValidateLDAPMessageRef( result );
	PGPValidatePtr( outMessage );

	*outMessage = result;

	return kPGPError_NoErr;
}

	PGPError
PGPldapNextEntry(
	PGPldapContextRef	pgpLDAP,
	PGPldapMessageRef	prevEntry,
	PGPldapMessageRef *	outMessage )
{
	PGPValidateLDAPContextRef( pgpLDAP );
	PGPValidateLDAPMessageRef( prevEntry );
	PGPValidatePtr( outMessage );

	*outMessage = prevEntry->next;

	if( IsNull( *outMessage ) )
	{
		*outMessage = kInvalidPGPldapMessageRef;
		goto done;
	}

	if( (*outMessage)->type == kPGPldapResponse_SearchResult )
		*outMessage = kInvalidPGPldapMessageRef;

done:
	return kPGPError_NoErr;
}

	PGPError
PGPldapGetDN(
	PGPldapContextRef	pgpLDAP,
	PGPldapMessageRef	entry,
	char **				dn )
{
	PGPError			err			= kPGPError_NoErr;
	PGPberElementRef	ber			= kInvalidPGPberElementRef;
	PGPberType			tag			= kPGPberType_None;
	PGPSize				len			= 0;
	PGPUInt32			index		= 0;

	PGPValidateLDAPContextRef( pgpLDAP );
	PGPValidateLDAPMessageRef( entry );
	PGPValidatePtr( dn );

	if( entry->type != kPGPldapResponse_SearchEntry )
		return kPGPError_BadParams;

	ber = entry->ber;

	err = PGPberGetIndex( ber, &index ); CKERR;

	err = PGPberRewind( ber ); CKERR;

	/* Skip MessageID */
	err = PGPberNextPrimitive( ber ); CKERR;
	err = PGPberSkip( ber ); CKERR;

	err = PGPberNextPrimitive( ber ); CKERR;
	err = PGPberPeek( ber, &tag, &len ); CKERR;

	*dn = PGPNewData( pgpLDAP->memMgr, len + 1, kPGPMemoryMgrFlags_Clear );
	if( IsNull( *dn ) )
	{
		err = kPGPError_OutOfMemory;
		goto error;
	}

	err = PGPberRead( ber, "s", *dn ); CKERR;

	err = PGPberSetIndex( ber, index ); CKERR;

error:

	return err;
}

	PGPError
PGPldapFirstAttribute(
	PGPldapContextRef	pgpLDAP,
	PGPldapMessageRef	entry,
	PGPberElementRef *	ber,
	char **				attr )
{
	PGPError			err			= kPGPError_NoErr;
	PGPldapType			tag			= kPGPldapType_None;
	PGPSize				len			= 0;
	PGPUInt32			index		= 0;

	PGPValidateLDAPContextRef( pgpLDAP );
	PGPValidateLDAPMessageRef( entry );
	PGPValidatePtr( ber );
	PGPValidatePtr( attr );

	*ber = entry->ber;

	err = PGPberRewind( *ber ); CKERR;

	/* Skip MessageID */
	err = PGPberNextPrimitive( *ber ); CKERR;
	err = PGPberSkip( *ber ); CKERR;

	/* Skip DN */
	err = PGPberNextPrimitive( *ber ); CKERR;
	err = PGPberSkip( *ber ); CKERR;

	err = PGPberNextConstructed( *ber );
	if( err == kPGPError_EndOfIteration )
	{
		/*
		 * There doesn't appear to be anything else.  This could be 
		 * something funny like a referral.  At any rate, it's not an
		 * error, so we should handle it gracefully.
		 */

		 *attr = NULL;
		 err = kPGPError_NoErr;
		 goto done;
	}
	CKERR;
	if( (*ber)->nextReadIndex == (*ber)->length )
	{
		*attr = NULL;
		goto done;
	}

	err = PGPberGetLength( *ber, &len ); CKERR;
	err = PGPberGetIndex( *ber, &index ); CKERR;
	if( len == index )
	{
		/* No attributes */
		*attr = NULL;
		goto done;
	}

	/* Read attribute */
	err = PGPberNextPrimitive( *ber ); CKERR;

	err = PGPberPeek( *ber, (PGPberType *)&tag, &len ); CKERR;
	*attr = PGPNewData( (*ber)->memMgr, len + 1, kPGPMemoryMgrFlags_Clear );
	if( IsNull( *attr ) )
	{
		err = kPGPError_OutOfMemory;
		goto error;
	}

	err = PGPberRead( *ber, "s", *attr ); CKERR;

error:
done:
	return err;
}

	PGPError
PGPldapNextAttribute(
	PGPldapContextRef	pgpLDAP,
	PGPldapMessageRef	entry,
	PGPberElementRef	ber,
	char **				attr )
{
	PGPError			err			= kPGPError_NoErr;
	PGPldapType			tag			= kPGPldapType_None;
	PGPSize				len			= 0;
	PGPSize				berLength	= 0;
	PGPUInt32			index		= 0;

	PGPValidateLDAPContextRef( pgpLDAP );
	PGPValidateLDAPMessageRef( entry );
	PGPValidateBERElementRef( ber );
	PGPValidatePtr( attr );

	/*
	 * The only way to get a valid PGPberElementRef is via
	 * PGPldapFirstAttribute, so we don't really need to have a more
	 * elaborate method of determining if we've already called
	 * PGPldapFirstAttribute.
	 */

	/* We've already called PGPldapFirstAttribute, so we can skip the values */
	err = PGPberSkip( ber ); CKERR;

	err = PGPberGetIndex( ber, &index ); CKERR;
	err = PGPberGetLength( ber, &berLength ); CKERR;
	if( index == berLength )
	{
		*attr = NULL;
		goto done;
	}

	err = PGPberPeek( ber, (PGPberType *)&tag, &len ); CKERR;

	*attr = PGPNewData( pgpLDAP->memMgr, len + 1, kPGPMemoryMgrFlags_Clear );
	if( IsNull( *attr ) )
	{
		err = kPGPError_OutOfMemory;
		goto error;
	}

	err = PGPberRead( ber, "s", *attr ); CKERR;

error:
done:
	return err;
}

	PGPError
pgpLDAPCountValues(
	PGPldapContextRef	pgpLDAP,
	PGPberElementRef	ber,
	PGPSize	*			num )
{
	PGPError			err			= kPGPError_NoErr;
	PGPUInt32			startIndex	= 0;
	PGPUInt32			index		= 0;
	PGPSize				setLength	= 0;
	PGPSize				len			= 0;
	PGPldapType			tag			= kPGPldapType_None;

	PGPValidateLDAPContextRef( pgpLDAP );
	PGPValidateBERElementRef( ber );
	PGPValidatePtr( num );

	*num = 0;

	err = PGPberGetIndex( ber, &startIndex ); CKERR;

	err = PGPberPeek( ber, (PGPberType *)&tag, &setLength ); CKERR;
	err = PGPberGetIndex( ber, &index ); CKERR;
	while( index < startIndex + setLength )
	{
		err = PGPberNextPrimitive( ber ); CKERR;
		err = PGPberPeek( ber, (PGPberType *)&tag, &len ); CKERR;

		err = PGPberSkip( ber ); CKERR;

		(*num)++;

		err = PGPberGetIndex( ber, &index ); CKERR;
	}

	err = PGPberSetIndex( ber, startIndex ); CKERR;

error:
	return err;
}

	PGPError
PGPldapGetValues(
	PGPldapContextRef	pgpLDAP,
	PGPldapMessageRef	entry,
	char *				attr,
	char ***			values )
{
	PGPError			err			= kPGPError_NoErr;
	PGPUInt32			i			= 0;
	PGPSize				numValues	= 0;
	PGPberValue **		berValues	= NULL;

	PGPValidateLDAPContextRef( pgpLDAP );
	PGPValidateLDAPMessageRef( entry );
	PGPValidatePtr( attr );
	PGPValidatePtr( values );


	err = PGPldapGetValuesLen( pgpLDAP, entry, attr, &berValues ); CKERR;

	if( IsNull( berValues ) )
	{
		err = kPGPError_LDAPNoSuchAttribute;
		goto error;
	}

	err = PGPldapCountValuesLen( pgpLDAP, berValues, &numValues ); CKERR;
	
	(*values) = PGPNewData( pgpLDAP->memMgr,
					( numValues + 1 ) * sizeof( char * ),
					kPGPMemoryMgrFlags_Clear );
	if( IsNull( *values ) )
	{
		err = kPGPError_OutOfMemory;
		goto error;
	}

	for( i = 0; IsntNull( berValues[i] ); i++ )
	{
		(*values)[i] = PGPNewData( pgpLDAP->memMgr,
							berValues[i]->length + 1,
							kPGPMemoryMgrFlags_Clear );
		if( IsNull( (*values)[i] ) )
		{
			err = kPGPError_OutOfMemory;
			goto error;
		}

		pgpCopyMemory(
			berValues[i]->value,
			(*values)[i],
			berValues[i]->length );
		(*values)[i][berValues[i]->length] = '\0';
	}
	(*values)[i] = NULL;

	goto done;
error:

	if( IsntNull( *values ) )
		(void) PGPFreeLDAPValues( *values );
	*values = NULL;

done:

	if( IsntNull( berValues ) )
		(void) PGPFreeLDAPValuesLen( berValues );

	return err;
}

	PGPError
PGPldapGetValuesLen(
	PGPldapContextRef	pgpLDAP,
	PGPldapMessageRef	entry,
	char *				attr,
	PGPberValue ***		values )
{
	PGPberElementRef	ber			= kInvalidPGPberElementRef;
	PGPldapType			tag			= kPGPldapType_None;
	char *				attribute	= NULL;
	PGPSize				numValues	= 0;
	PGPSize				len			= 0;
	PGPUInt32			startIndex	= 0;
	PGPUInt32			i			= 0;
	PGPError			err			= kPGPError_NoErr;

	PGPValidateLDAPContextRef( pgpLDAP );
	PGPValidateLDAPMessageRef( entry );
	PGPValidatePtr( attr );
	PGPValidatePtr( values );

	ber = entry->ber;

	err = PGPberGetIndex( ber, &startIndex ); CKERR;

	err = PGPldapFirstAttribute( pgpLDAP, entry, &ber, &attribute ); CKERR;
	while( IsntNull( attribute ) )
	{
		if( pgpCompareStringsIgnoreCase( (char *)attribute, (char *)attr ) == 0 )
		{
			err = pgpLDAPCountValues( pgpLDAP, ber, &numValues ); CKERR;

			*values = PGPNewData( pgpLDAP->memMgr,
						( numValues + 1 ) * sizeof( PGPberValue * ),
						kPGPMemoryMgrFlags_Clear );
			if( IsNull( *values ) )
			{
				err = kPGPError_OutOfMemory;
				goto error;
			}

			/* Skip the set tag - go right to the string */
			err = PGPberNextPrimitive( ber ); CKERR;

			for( i = 0; i < numValues; i++ )
			{
				err = PGPberPeek( ber, (PGPberType *)&tag, &len ); CKERR;
				(*values)[i] = PGPNewData( pgpLDAP->memMgr,
									sizeof( PGPberValue ),
									kPGPMemoryMgrFlags_Clear );
				if( IsNull( (*values)[i] ) )
				{
					err = kPGPError_OutOfMemory;
					goto error;
				}
				(*values)[i]->value = PGPNewData( pgpLDAP->memMgr, len + 1,
									kPGPMemoryMgrFlags_Clear );
				if( IsNull( (*values)[i] ) )
				{
					err = kPGPError_OutOfMemory;
					goto error;
				}

				(*values)[i]->length = len;

				err = PGPberRead( ber, "o", (*values)[i]->value ); CKERR;
			}
			(*values)[i] = NULL;

			goto done;
		}

		(void) PGPFreeData( attribute );
		err = PGPldapNextAttribute( pgpLDAP, entry, ber, &attribute ); CKERR;
	}
	/* Not found */
	*values = NULL;
	err = kPGPError_LDAPNoSuchAttribute;

error:
done:
	(void) PGPberSetIndex( ber, startIndex );

	if( IsntNull( attribute ) )
		(void) PGPFreeData( attribute );

	return err;
}

	PGPError
PGPldapCountValues(
	PGPldapContextRef	pgpLDAP,
	char **				values,
	PGPSize *			num )
{
	PGPSize				i		= 0;

	PGPValidateLDAPContextRef( pgpLDAP );
	PGPValidatePtr( values );