retcode.c

ldap服务器源码

				{
					char		*next;
					if ( rdi.rdi_sleeptime != 0 ) {
						fprintf( stderr, "%s: line %d: retcode: "
							"\"sleeptime\" already provided.\n",
							fname, lineno );
						return 1;
					}

					rdi.rdi_sleeptime = strtol( &argv[ i ][ STRLENOF( "sleeptime=" ) ], &next, 10 );
					if ( next == argv[ i ] || next[ 0 ] != '\0' ) {
						fprintf( stderr, "%s: line %d: retcode: "
							"unable to parse \"sleeptime=%s\".\n",
							fname, lineno, &argv[ i ][ STRLENOF( "sleeptime=" ) ] );
						return 1;
					}

				} else {
					fprintf( stderr, "%s: line %d: retcode: "
						"unknown option \"%s\".\n",
							fname, lineno, argv[ i ] );
					return 1;
				}
			}
		}

		for ( rdip = &rd->rd_item; *rdip; rdip = &(*rdip)->rdi_next )
			/* go to last */ ;

		
		*rdip = ( retcode_item_t * )ch_malloc( sizeof( retcode_item_t ) );
		*(*rdip) = rdi;

	} else if ( strcasecmp( argv0, "indir" ) == 0 ) {
		rd->rd_flags |= RETCODE_FINDIR;

	} else if ( strcasecmp( argv0, "sleep" ) == 0 ) {
		switch ( argc ) {
		case 1:
			fprintf( stderr, "%s: line %d: retcode: "
				"\"retcode-sleep <time>\": missing <time>\n",
				fname, lineno );
			return 1;

		case 2:
			break;

		default:
			fprintf( stderr, "%s: line %d: retcode: "
				"\"retcode-sleep <time>\": extra cruft after <time>\n",
				fname, lineno );
			return 1;
		}

		if ( lutil_atoi( &rd->rd_sleep, argv[ 1 ] ) != 0 ) {
			fprintf( stderr, "%s: line %d: retcode: "
				"\"retcode-sleep <time>\": unable to parse <time>\n",
				fname, lineno );
			return 1;
		}

	} else {
		return SLAP_CONF_UNKNOWN;
	}

	return 0;
}

static int
retcode_db_open( BackendDB *be )
{
	slap_overinst	*on = (slap_overinst *)be->bd_info;
	retcode_t	*rd = (retcode_t *)on->on_bi.bi_private;

	retcode_item_t	*rdi;

	for ( rdi = rd->rd_item; rdi; rdi = rdi->rdi_next ) {
		LDAPRDN			rdn = NULL;
		int			rc, j;
		char*			p;
		struct berval		val[ 3 ];
		char			buf[ SLAP_TEXT_BUFLEN ];

		/* DN */
		rdi->rdi_e.e_name = rdi->rdi_dn;
		rdi->rdi_e.e_nname = rdi->rdi_ndn;

		/* objectClass */
		val[ 0 ] = oc_errObject->soc_cname;
		val[ 1 ] = slap_schema.si_oc_extensibleObject->soc_cname;
		BER_BVZERO( &val[ 2 ] );

		attr_merge( &rdi->rdi_e, slap_schema.si_ad_objectClass, val, NULL );

		/* RDN avas */
		rc = ldap_bv2rdn( &rdi->rdi_dn, &rdn, (char **) &p,
				LDAP_DN_FORMAT_LDAP );

		assert( rc == LDAP_SUCCESS );

		for ( j = 0; rdn[ j ]; j++ ) {
			LDAPAVA			*ava = rdn[ j ];
			AttributeDescription	*ad = NULL;
			const char		*text;

			rc = slap_bv2ad( &ava->la_attr, &ad, &text );
			assert( rc == LDAP_SUCCESS );
			
			attr_merge_normalize_one( &rdi->rdi_e, ad,
					&ava->la_value, NULL );
		}

		ldap_rdnfree( rdn );

		/* error code */
		snprintf( buf, sizeof( buf ), "%d", rdi->rdi_err );
		ber_str2bv( buf, 0, 0, &val[ 0 ] );

		attr_merge_one( &rdi->rdi_e, ad_errCode, &val[ 0 ], NULL );

		if ( rdi->rdi_ref != NULL ) {
			attr_merge_normalize( &rdi->rdi_e, slap_schema.si_ad_ref,
				rdi->rdi_ref, NULL );
		}

		/* text */
		if ( !BER_BVISNULL( &rdi->rdi_text ) ) {
			val[ 0 ] = rdi->rdi_text;

			attr_merge_normalize_one( &rdi->rdi_e, ad_errText, &val[ 0 ], NULL );
		}

		/* matched */
		if ( !BER_BVISNULL( &rdi->rdi_matched ) ) {
			val[ 0 ] = rdi->rdi_matched;

			attr_merge_normalize_one( &rdi->rdi_e, ad_errMatchedDN, &val[ 0 ], NULL );
		}

		/* sleep time */
		if ( rdi->rdi_sleeptime > 0 ) {
			snprintf( buf, sizeof( buf ), "%d", rdi->rdi_sleeptime );
			ber_str2bv( buf, 0, 0, &val[ 0 ] );

			attr_merge_one( &rdi->rdi_e, ad_errSleepTime, &val[ 0 ], NULL );
		}

		/* operations */
		if ( rdi->rdi_mask & SN_DG_OP_ADD ) {
			BER_BVSTR( &val[ 0 ], "add" );
			attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
		}

		if ( rdi->rdi_mask & SN_DG_OP_BIND ) {
			BER_BVSTR( &val[ 0 ], "bind" );
			attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
		}

		if ( rdi->rdi_mask & SN_DG_OP_COMPARE ) {
			BER_BVSTR( &val[ 0 ], "compare" );
			attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
		}

		if ( rdi->rdi_mask & SN_DG_OP_DELETE ) {
			BER_BVSTR( &val[ 0 ], "delete" );
			attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
		}

		if ( rdi->rdi_mask & SN_DG_EXTENDED ) {
			BER_BVSTR( &val[ 0 ], "extended" );
			attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
		}

		if ( rdi->rdi_mask & SN_DG_OP_MODIFY ) {
			BER_BVSTR( &val[ 0 ], "modify" );
			attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
		}

		if ( rdi->rdi_mask & SN_DG_OP_RENAME ) {
			BER_BVSTR( &val[ 0 ], "rename" );
			attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
		}

		if ( rdi->rdi_mask & SN_DG_OP_SEARCH ) {
			BER_BVSTR( &val[ 0 ], "search" );
			attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
		}
	}

	return 0;
}

static int
retcode_db_destroy( BackendDB *be )
{
	slap_overinst	*on = (slap_overinst *)be->bd_info;
	retcode_t	*rd = (retcode_t *)on->on_bi.bi_private;

	if ( rd ) {
		retcode_item_t	*rdi, *next;

		for ( rdi = rd->rd_item; rdi != NULL; rdi = next ) {
			ber_memfree( rdi->rdi_dn.bv_val );
			ber_memfree( rdi->rdi_ndn.bv_val );

			if ( !BER_BVISNULL( &rdi->rdi_text ) ) {
				ber_memfree( rdi->rdi_text.bv_val );
			}

			if ( !BER_BVISNULL( &rdi->rdi_matched ) ) {
				ber_memfree( rdi->rdi_matched.bv_val );
			}

			if ( rdi->rdi_ref ) {
				ber_bvarray_free( rdi->rdi_ref );
			}

			BER_BVZERO( &rdi->rdi_e.e_name );
			BER_BVZERO( &rdi->rdi_e.e_nname );

			entry_clean( &rdi->rdi_e );

			next = rdi->rdi_next;

			ch_free( rdi );
		}

		if ( !BER_BVISNULL( &rd->rd_pdn ) ) {
			ber_memfree( rd->rd_pdn.bv_val );
		}

		if ( !BER_BVISNULL( &rd->rd_npdn ) ) {
			ber_memfree( rd->rd_npdn.bv_val );
		}

		ber_memfree( rd );
	}

	return 0;
}

#if SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC
static
#endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */
int
retcode_initialize( void )
{
	int		i, code;
	const char	*err;

	static struct {
		char			*name;
		char			*desc;
		AttributeDescription	**ad;
	} retcode_at[] = {
	        { "errCode", "( 1.3.6.1.4.1.4203.666.11.4.1.1 "
		        "NAME ( 'errCode' ) "
		        "DESC 'LDAP error code' "
		        "EQUALITY integerMatch "
		        "ORDERING integerOrderingMatch "
		        "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 "
			"SINGLE-VALUE )",
			&ad_errCode },
		{ "errOp", "( 1.3.6.1.4.1.4203.666.11.4.1.2 "
			"NAME ( 'errOp' ) "
			"DESC 'Operations the errObject applies to' "
			"EQUALITY caseIgnoreMatch "
			"SUBSTR caseIgnoreSubstringsMatch "
			"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
			&ad_errOp},
		{ "errText", "( 1.3.6.1.4.1.4203.666.11.4.1.3 "
			"NAME ( 'errText' ) "
			"DESC 'LDAP error textual description' "
			"EQUALITY caseIgnoreMatch "
			"SUBSTR caseIgnoreSubstringsMatch "
			"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 "
			"SINGLE-VALUE )",
			&ad_errText },
		{ "errSleepTime", "( 1.3.6.1.4.1.4203.666.11.4.1.4 "
			"NAME ( 'errSleepTime' ) "
			"DESC 'Time to wait before returning the error' "
			"EQUALITY integerMatch "
			"SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 "
			"SINGLE-VALUE )",
			&ad_errSleepTime },
		{ "errMatchedDN", "( 1.3.6.1.4.1.4203.666.11.4.1.5 "
			"NAME ( 'errMatchedDN' ) "
			"DESC 'Value to be returned as matched DN' "
			"EQUALITY distinguishedNameMatch "
			"SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 "
			"SINGLE-VALUE )",
			&ad_errMatchedDN },
		{ NULL }
	};

	static struct {
		char		*name;
		char		*desc;
		ObjectClass	**oc;
	} retcode_oc[] = {
		{ "errAbsObject", "( 1.3.6.1.4.1.4203.666.11.4.3.0 "
			"NAME ( 'errAbsObject' ) "
			"SUP top ABSTRACT "
			"MUST ( errCode ) "
			"MAY ( "
				"cn "
				"$ description "
				"$ errOp "
				"$ errText "
				"$ errSleepTime "
				"$ errMatchedDN "
			") )",
			&oc_errAbsObject },
		{ "errObject", "( 1.3.6.1.4.1.4203.666.11.4.3.1 "
			"NAME ( 'errObject' ) "
			"SUP errAbsObject STRUCTURAL "
			")",
			&oc_errObject },
		{ "errAuxObject", "( 1.3.6.1.4.1.4203.666.11.4.3.2 "
			"NAME ( 'errAuxObject' ) "
			"SUP errAbsObject AUXILIARY "
			")",
			&oc_errAuxObject },
		{ NULL }
	};


	for ( i = 0; retcode_at[ i ].name != NULL; i++ ) {
		LDAPAttributeType	*at;

		at = ldap_str2attributetype( retcode_at[ i ].desc,
			&code, &err, LDAP_SCHEMA_ALLOW_ALL );
		if ( !at ) {
			fprintf( stderr, "retcode: "
				"AttributeType load failed: %s %s\n",
				ldap_scherr2str( code ), err );
			return code;
		}

#if LDAP_VENDOR_VERSION_MINOR == X || LDAP_VENDOR_VERSION_MINOR > 2
		code = at_add( at, 0, NULL, &err );
#else
		code = at_add( at, &err );
#endif
		ldap_memfree( at );
		if ( code != LDAP_SUCCESS ) {
			fprintf( stderr, "retcode: "
				"AttributeType load failed: %s %s\n",
				scherr2str( code ), err );
			return code;
		}

		code = slap_str2ad( retcode_at[ i ].name,
				retcode_at[ i ].ad, &err );
		if ( code != LDAP_SUCCESS ) {
			fprintf( stderr, "retcode: unable to find "
				"AttributeDescription \"%s\": %d (%s)\n",
				retcode_at[ i ].name, code, err );
			return 1;
		}
	}

	for ( i = 0; retcode_oc[ i ].name != NULL; i++ ) {
		LDAPObjectClass *oc;

		oc = ldap_str2objectclass( retcode_oc[ i ].desc,
				&code, &err, LDAP_SCHEMA_ALLOW_ALL );
		if ( !oc ) {
			fprintf( stderr, "retcode: "
				"ObjectClass load failed: %s %s\n",
				ldap_scherr2str( code ), err );
			return code;
		}

#if LDAP_VENDOR_VERSION_MINOR == X || LDAP_VENDOR_VERSION_MINOR > 2
		code = oc_add( oc, 0, NULL, &err );
#else
		code = oc_add( oc, &err );
#endif
		ldap_memfree(oc);
		if ( code != LDAP_SUCCESS ) {
			fprintf( stderr, "retcode: "
				"ObjectClass load failed: %s %s\n",
				scherr2str( code ), err );
			return code;
		}

		*retcode_oc[ i ].oc = oc_find( retcode_oc[ i ].name );
		if ( *retcode_oc[ i ].oc == NULL ) {
			fprintf( stderr, "retcode: unable to find "
				"objectClass \"%s\"\n",
				retcode_oc[ i ].name );
			return 1;
		}
	}

	retcode.on_bi.bi_type = "retcode";

	retcode.on_bi.bi_db_init = retcode_db_init;
	retcode.on_bi.bi_db_config = retcode_db_config;
	retcode.on_bi.bi_db_open = retcode_db_open;
	retcode.on_bi.bi_db_destroy = retcode_db_destroy;

	retcode.on_bi.bi_op_add = retcode_op_func;
	retcode.on_bi.bi_op_bind = retcode_op_func;
	retcode.on_bi.bi_op_compare = retcode_op_func;
	retcode.on_bi.bi_op_delete = retcode_op_func;
	retcode.on_bi.bi_op_modify = retcode_op_func;
	retcode.on_bi.bi_op_modrdn = retcode_op_func;
	retcode.on_bi.bi_op_search = retcode_op_func;

	retcode.on_bi.bi_extended = retcode_op_func;

	retcode.on_response = retcode_response;

	return overlay_register( &retcode );
}

#if SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC
int
init_module( int argc, char *argv[] )
{
	return retcode_initialize();
}
#endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */

#endif /* SLAPD_OVER_RETCODE */