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; }