+ bv->bv_len = ptr - bv->bv_val;
+ btmp.bv_val = ptr;
+ btmp.bv_len = 0;
+ if ( limits_unparse_one( &lim->lm_limits,
+ SLAP_LIMIT_SIZE|SLAP_LIMIT_TIME,
+ &btmp, WHATSLEFT ) )
+ {
+ return -1;
+ }
+ bv->bv_len += btmp.bv_len;
+ return 0;
+}
+
+/* Caller must provide an adequately sized buffer in bv */
+int
+limits_unparse_one( struct slap_limits_set *lim, int which, struct berval *bv, ber_len_t buflen )
+{
+ char *ptr;
+
+ if ( !bv || !bv->bv_val ) return -1;
+
+ ptr = bv->bv_val;
+
+ if ( which & SLAP_LIMIT_SIZE ) {
+ if ( lim->lms_s_soft != SLAPD_DEFAULT_SIZELIMIT ) {
+
+ /* If same as global limit, drop it */
+ if ( lim != &frontendDB->be_def_limit &&
+ lim->lms_s_soft == frontendDB->be_def_limit.lms_s_soft )
+ {
+ goto s_hard;
+ /* If there's also a hard limit, fully qualify this one */
+ } else if ( lim->lms_s_hard ) {
+ if ( WHATSLEFT <= STRLENOF( " size.soft=" ) ) return -1;
+ ptr = lutil_strcopy( ptr, " size.soft=" );
+
+ /* If doing both size & time, qualify this */
+ } else if ( which & SLAP_LIMIT_TIME ) {
+ if ( WHATSLEFT <= STRLENOF( " size=" ) ) return -1;
+ ptr = lutil_strcopy( ptr, " size=" );
+ }
+
+ if ( lim->lms_s_soft == -1 ) {
+ if ( WHATSLEFT <= STRLENOF( "unlimited" ) ) return -1;
+ ptr = lutil_strcopy( ptr, "unlimited" );
+ } else {
+ ptr += snprintf( ptr, WHATSLEFT, "%d", lim->lms_s_soft );
+ if ( WHATSLEFT < 0 ) return -1;
+ }
+ *ptr++ = ' ';
+ }
+s_hard:
+ if ( lim->lms_s_hard ) {
+ if ( WHATSLEFT <= STRLENOF( " size.hard=" ) ) return -1;
+ ptr = lutil_strcopy( ptr, " size.hard=" );
+ if ( lim->lms_s_hard == -1 ) {
+ if ( WHATSLEFT <= STRLENOF( "unlimited" ) ) return -1;
+ ptr = lutil_strcopy( ptr, "unlimited" );
+ } else {
+ ptr += snprintf( ptr, WHATSLEFT, "%d", lim->lms_s_hard );
+ if ( WHATSLEFT < 0 ) return -1;
+ }
+ *ptr++ = ' ';
+ }
+ if ( lim->lms_s_unchecked != -1 ) {
+ if ( WHATSLEFT <= STRLENOF( " size.unchecked=" ) ) return -1;
+ ptr = lutil_strcopy( ptr, " size.unchecked=" );
+ if ( lim->lms_s_unchecked == 0 ) {
+ if ( WHATSLEFT <= STRLENOF( "disabled" ) ) return -1;
+ ptr = lutil_strcopy( ptr, "disabled" );
+ } else {
+ ptr += snprintf( ptr, WHATSLEFT, "%d", lim->lms_s_unchecked );
+ if ( WHATSLEFT < 0 ) return -1;
+ }
+ *ptr++ = ' ';
+ }
+ if ( lim->lms_s_pr_hide ) {
+ if ( WHATSLEFT <= STRLENOF( " size.pr=noEstimate " ) ) return -1;
+ ptr = lutil_strcopy( ptr, " size.pr=noEstimate " );
+ }
+ if ( lim->lms_s_pr ) {
+ if ( WHATSLEFT <= STRLENOF( " size.pr=" ) ) return -1;
+ ptr = lutil_strcopy( ptr, " size.pr=" );
+ if ( lim->lms_s_pr == -1 ) {
+ if ( WHATSLEFT <= STRLENOF( "unlimited" ) ) return -1;
+ ptr = lutil_strcopy( ptr, "unlimited" );
+ } else {
+ ptr += snprintf( ptr, WHATSLEFT, "%d", lim->lms_s_pr );
+ if ( WHATSLEFT < 0 ) return -1;
+ }
+ *ptr++ = ' ';
+ }
+ if ( lim->lms_s_pr_total ) {
+ if ( WHATSLEFT <= STRLENOF( " size.prtotal=" ) ) return -1;
+ ptr = lutil_strcopy( ptr, " size.prtotal=" );
+ if ( lim->lms_s_pr_total == -1 ) {
+ if ( WHATSLEFT <= STRLENOF( "unlimited" ) ) return -1;
+ ptr = lutil_strcopy( ptr, "unlimited" );
+ } else if ( lim->lms_s_pr_total == -2 ) {
+ if ( WHATSLEFT <= STRLENOF( "disabled" ) ) return -1;
+ ptr = lutil_strcopy( ptr, "disabled" );
+ } else {
+ ptr += snprintf( ptr, WHATSLEFT, "%d", lim->lms_s_pr_total );
+ if ( WHATSLEFT < 0 ) return -1;
+ }
+ *ptr++ = ' ';
+ }
+ }
+
+ if ( which & SLAP_LIMIT_TIME ) {
+ if ( lim->lms_t_soft != SLAPD_DEFAULT_TIMELIMIT ) {
+
+ /* If same as global limit, drop it */
+ if ( lim != &frontendDB->be_def_limit &&
+ lim->lms_t_soft == frontendDB->be_def_limit.lms_t_soft )
+ {
+ goto t_hard;
+
+ /* If there's also a hard limit, fully qualify this one */
+ } else if ( lim->lms_t_hard ) {
+ if ( WHATSLEFT <= STRLENOF( " time.soft=" ) ) return -1;
+ ptr = lutil_strcopy( ptr, " time.soft=" );
+
+ /* If doing both size & time, qualify this */
+ } else if ( which & SLAP_LIMIT_SIZE ) {
+ if ( WHATSLEFT <= STRLENOF( " time=" ) ) return -1;
+ ptr = lutil_strcopy( ptr, " time=" );
+ }
+
+ if ( lim->lms_t_soft == -1 ) {
+ if ( WHATSLEFT <= STRLENOF( "unlimited" ) ) return -1;
+ ptr = lutil_strcopy( ptr, "unlimited" );
+ } else {
+ ptr += snprintf( ptr, WHATSLEFT, "%d", lim->lms_t_soft );
+ if ( WHATSLEFT < 0 ) return -1;
+ }
+ *ptr++ = ' ';
+ }
+t_hard:
+ if ( lim->lms_t_hard ) {
+ if ( WHATSLEFT <= STRLENOF( " time.hard=" ) ) return -1;
+ ptr = lutil_strcopy( ptr, " time.hard=" );
+ if ( lim->lms_t_hard == -1 ) {
+ if ( WHATSLEFT <= STRLENOF( "unlimited" ) ) return -1;
+ ptr = lutil_strcopy( ptr, "unlimited" );
+ } else {
+ ptr += snprintf( ptr, WHATSLEFT, "%d", lim->lms_t_hard );
+ if ( WHATSLEFT < 0 ) return -1;
+ }
+ *ptr++ = ' ';
+ }
+ }
+ if ( ptr != bv->bv_val ) {
+ ptr--;
+ *ptr = '\0';
+ bv->bv_len = ptr - bv->bv_val;
+ }
+
+ return 0;
+}
+
+int
+limits_check( Operation *op, SlapReply *rs )
+{
+ assert( op != NULL );
+ assert( rs != NULL );
+ /* FIXME: should this be always true? */
+ assert( op->o_tag == LDAP_REQ_SEARCH);
+
+ /* protocol only allows 0..maxInt;
+ *
+ * internal searches:
+ * - may use SLAP_NO_LIMIT ( = -1 ) to indicate no limits;
+ * - should use slimit = N and tlimit = SLAP_NO_LIMIT to
+ * indicate searches that should return exactly N matches,
+ * and handle errors thru a callback (see for instance
+ * slap_sasl_match() and slap_sasl2dn())
+ */
+ if ( op->ors_tlimit == SLAP_NO_LIMIT && op->ors_slimit == SLAP_NO_LIMIT ) {
+ return 0;
+ }
+
+ /* allow root to set no limit */
+ if ( be_isroot( op ) ) {
+ op->ors_limit = NULL;
+
+ if ( op->ors_tlimit == 0 ) {
+ op->ors_tlimit = SLAP_NO_LIMIT;
+ }
+
+ if ( op->ors_slimit == 0 ) {
+ op->ors_slimit = SLAP_NO_LIMIT;
+ }
+
+ /* if paged results and slimit are requested */
+ if ( get_pagedresults( op ) > SLAP_CONTROL_IGNORED &&
+ op->ors_slimit != SLAP_NO_LIMIT ) {
+ PagedResultsState *ps = op->o_pagedresults_state;
+ int total = op->ors_slimit - ps->ps_count;
+ if ( total > 0 ) {
+ op->ors_slimit = total;
+ } else {
+ op->ors_slimit = 0;
+ }
+ }
+
+ /* if not root, get appropriate limits */
+ } else {
+ ( void ) limits_get( op, &op->o_ndn, &op->ors_limit );
+
+ assert( op->ors_limit != NULL );
+
+ /* if no limit is required, use soft limit */
+ if ( op->ors_tlimit == 0 ) {
+ op->ors_tlimit = op->ors_limit->lms_t_soft;
+
+ /* limit required: check if legal */
+ } else {
+ if ( op->ors_limit->lms_t_hard == 0 ) {
+ if ( op->ors_limit->lms_t_soft > 0
+ && ( op->ors_tlimit > op->ors_limit->lms_t_soft ) ) {
+ op->ors_tlimit = op->ors_limit->lms_t_soft;
+ }
+
+ } else if ( op->ors_limit->lms_t_hard > 0 ) {
+#ifdef ABOVE_HARD_LIMIT_IS_ERROR
+ if ( op->ors_tlimit == SLAP_MAX_LIMIT ) {
+ op->ors_tlimit = op->ors_limit->lms_t_hard;
+
+ } else if ( op->ors_tlimit > op->ors_limit->lms_t_hard ) {
+ /* error if exceeding hard limit */
+ rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
+ send_ldap_result( op, rs );
+ rs->sr_err = LDAP_SUCCESS;
+ return -1;
+ }
+#else /* ! ABOVE_HARD_LIMIT_IS_ERROR */
+ if ( op->ors_tlimit > op->ors_limit->lms_t_hard ) {
+ op->ors_tlimit = op->ors_limit->lms_t_hard;
+ }
+#endif /* ! ABOVE_HARD_LIMIT_IS_ERROR */
+ }
+ }
+
+ /* else leave as is */
+
+ /* don't even get to backend if candidate check is disabled */
+ if ( op->ors_limit->lms_s_unchecked == 0 ) {
+ rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
+ send_ldap_result( op, rs );
+ rs->sr_err = LDAP_SUCCESS;
+ return -1;
+ }
+
+ /* if paged results is requested */
+ if ( get_pagedresults( op ) > SLAP_CONTROL_IGNORED ) {
+ int slimit = -2;
+ int pr_total;
+ PagedResultsState *ps = op->o_pagedresults_state;
+
+ /* paged results is not allowed */
+ if ( op->ors_limit->lms_s_pr_total == -2 ) {
+ rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
+ rs->sr_text = "pagedResults control not allowed";
+ send_ldap_result( op, rs );
+ rs->sr_err = LDAP_SUCCESS;
+ rs->sr_text = NULL;
+ return -1;
+ }
+
+ if ( op->ors_limit->lms_s_pr > 0 && ps->ps_size > op->ors_limit->lms_s_pr ) {
+ rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
+ rs->sr_text = "illegal pagedResults page size";
+ send_ldap_result( op, rs );
+ rs->sr_err = LDAP_SUCCESS;
+ rs->sr_text = NULL;
+ return -1;
+ }
+
+ if ( op->ors_limit->lms_s_pr_total == 0 ) {
+ if ( op->ors_limit->lms_s_hard == 0 ) {
+ pr_total = op->ors_limit->lms_s_soft;
+ } else {
+ pr_total = op->ors_limit->lms_s_hard;
+ }
+ } else {
+ pr_total = op->ors_limit->lms_s_pr_total;
+ }
+
+ if ( pr_total == -1 ) {
+ if ( op->ors_slimit == 0 || op->ors_slimit == SLAP_MAX_LIMIT ) {
+ slimit = -1;
+
+ } else {
+ slimit = op->ors_slimit - ps->ps_count;
+ }
+
+#ifdef ABOVE_HARD_LIMIT_IS_ERROR
+ } else if ( pr_total > 0 && op->ors_slimit != SLAP_MAX_LIMIT
+ && ( op->ors_slimit == SLAP_NO_LIMIT || op->ors_slimit > pr_total ) )
+ {
+ rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
+ send_ldap_result( op, rs );
+ rs->sr_err = LDAP_SUCCESS;
+ return -1;
+#endif /* ! ABOVE_HARD_LIMIT_IS_ERROR */