static apr_status_t serf_headers_readline(serf_bucket_t *bucket,
int acceptable, int *found,
const char **data, apr_size_t *len)
{
headers_context_t *ctx = bucket->data;
apr_status_t status;
/* ### what behavior should we use here? APR_EGENERAL for now */
if ((acceptable & SERF_NEWLINE_CRLF) == 0)
return APR_EGENERAL;
/* get whatever is in this chunk */
select_value(ctx, data, len);
if (ctx->state == READ_DONE)
return APR_EOF;
/* we consumed this chunk. advance the state. */
status = consume_chunk(ctx);
/* the type of newline found is easy... */
*found = (ctx->state == READ_CRLF || ctx->state == READ_TERM)
? SERF_NEWLINE_CRLF : SERF_NEWLINE_NONE;
return status;
}
static apr_status_t serf_headers_read(serf_bucket_t *bucket,
apr_size_t requested,
const char **data, apr_size_t *len)
{
headers_context_t *ctx = bucket->data;
apr_size_t avail;
select_value(ctx, data, &avail);
if (ctx->state == READ_DONE)
return APR_EOF;
if (requested >= avail) {
/* return everything from this chunk */
*len = avail;
/* we consumed this chunk. advance the state. */
return consume_chunk(ctx);
}
/* return just the amount requested, and advance our pointer */
*len = requested;
ctx->amt_read += requested;
/* there is more that can be read immediately */
return APR_SUCCESS;
}
int drop_single(GPtrArray *array, int heur_id, int query_type, double argument)
{
sort_by_heuristic(array,heur_id);
switch (query_type)
{
case VALUE_ABOVE:
return select_value(array,heur_id,VALUE_BELOW,argument+DBL_EPSILON);
case VALUE_BELOW:
return select_value(array,heur_id,VALUE_ABOVE,argument-DBL_EPSILON);
case POSITION_FROM_TOP:
return select_position(array,heur_id,POSITION_FROM_BOTTOM,array->len - argument);
case POSITION_FROM_BOTTOM:
return select_position(array,heur_id,POSITION_FROM_TOP,array->len - argument);
case PERCENT_FROM_TOP:
return select_percentage(array,heur_id,PERCENT_FROM_BOTTOM,1-argument+1.0/array->len);
case PERCENT_FROM_BOTTOM:
return select_percentage(array,heur_id,PERCENT_FROM_TOP,1-argument+1.0/array->len);
default: die("Unsupported query_type for drop");
}
}
static apr_status_t serf_headers_peek(serf_bucket_t *bucket,
const char **data,
apr_size_t *len)
{
headers_context_t *ctx = bucket->data;
select_value(ctx, data, len);
/* already done or returning the CRLF terminator? return EOF */
if (ctx->state == READ_DONE || ctx->state == READ_TERM)
return APR_EOF;
return APR_SUCCESS;
}
void
select_single(GPtrArray *array, int heur_id, int query_type, double argument)
{
sort_by_heuristic(array,heur_id);
switch (query_type)
{
case VALUE_ABOVE:
case VALUE_BELOW:
select_value(array,heur_id,query_type,argument);
break;
case POSITION_FROM_TOP:
case POSITION_FROM_MIDDLE:
case POSITION_FROM_BOTTOM:
select_position(array,heur_id,query_type,argument);
break;
case PERCENT_FROM_TOP:
case PERCENT_FROM_MIDDLE:
case PERCENT_FROM_BOTTOM:
select_percentage(array,heur_id,query_type,argument);
break;
default: die("Unsupported query_type for select_single");
}
}
void params::re_select_value()
{
select_value(v_bits+0.2);
}
static int sssvlv_op_response(
Operation *op,
SlapReply *rs )
{
sort_ctrl *sc = op->o_controls[sss_cid];
sort_op *so = op->o_callback->sc_private;
if ( rs->sr_type == REP_SEARCH ) {
int i;
size_t len;
sort_node *sn, *sn2;
struct berval *bv;
char *ptr;
len = sizeof(sort_node) + sc->sc_nkeys * sizeof(struct berval) +
rs->sr_entry->e_nname.bv_len + 1;
sn = op->o_tmpalloc( len, op->o_tmpmemctx );
sn->sn_vals = (struct berval *)(sn+1);
/* Build tmp list of key values */
for ( i=0; i<sc->sc_nkeys; i++ ) {
Attribute *a = attr_find( rs->sr_entry->e_attrs,
sc->sc_keys[i].sk_ad );
if ( a ) {
if ( a->a_numvals > 1 ) {
bv = select_value( a, &sc->sc_keys[i] );
} else {
bv = a->a_nvals;
}
sn->sn_vals[i] = *bv;
len += bv->bv_len + 1;
} else {
BER_BVZERO( &sn->sn_vals[i] );
}
}
/* Now dup into regular memory */
sn2 = ch_malloc( len );
sn2->sn_vals = (struct berval *)(sn2+1);
memcpy( sn2->sn_vals, sn->sn_vals,
sc->sc_nkeys * sizeof(struct berval));
ptr = (char *)(sn2->sn_vals + sc->sc_nkeys);
sn2->sn_dn.bv_val = ptr;
sn2->sn_dn.bv_len = rs->sr_entry->e_nname.bv_len;
memcpy( ptr, rs->sr_entry->e_nname.bv_val,
rs->sr_entry->e_nname.bv_len );
ptr += rs->sr_entry->e_nname.bv_len;
*ptr++ = '\0';
for ( i=0; i<sc->sc_nkeys; i++ ) {
if ( !BER_BVISNULL( &sn2->sn_vals[i] )) {
memcpy(ptr, sn2->sn_vals[i].bv_val, sn2->sn_vals[i].bv_len);
sn2->sn_vals[i].bv_val = ptr;
ptr += sn2->sn_vals[i].bv_len;
*ptr++ = '\0';
}
}
op->o_tmpfree( sn, op->o_tmpmemctx );
sn = sn2;
sn->sn_conn = op->o_conn->c_conn_idx;
sn->sn_session = find_session_by_so( so->so_info->svi_max_percon, op->o_conn->c_conn_idx, so );
/* Insert into the AVL tree */
tavl_insert(&(so->so_tree), sn, node_insert, avl_dup_error);
so->so_nentries++;
/* Collected the keys so that they can be sorted. Thus, stop
* the entry from propagating.
*/
rs->sr_err = LDAP_SUCCESS;
}
else if ( rs->sr_type == REP_RESULT ) {
/* Remove serversort response callback.
* We don't want the entries that we are about to send to be
* processed by serversort response again. */
slap_callback **scp = &op->o_callback;
while ( *scp ) {
if ( (*scp)->sc_response == sssvlv_op_response ) {
*scp = (*scp)->sc_next;
break;
}
scp = &(*scp)->sc_next;
}
send_entry( op, rs, so );
send_result( op, rs, so );
}
return rs->sr_err;
}
