/*! @decl mapping(string:string) all(string map)
*!
*! Returns the whole map as a mapping.
*!
*! @[map] is the YP-map to search in. This must be the full map name,
*! you have to use @tt{passwd.byname@} instead of just @tt{passwd@}.
*/
static void f_all(INT32 args)
{
int err, num=0;
char *retval, *retkey;
int retlen, retkeylen;
char *map;
struct mapping *res_map;
check_all_args(NULL, args, BIT_STRING, 0);
map = sp[-1].u.string->str;
res_map = allocate_mapping( (this->last_size?this->last_size+2:40) );
if(!(err = yp_first(this->domain, map, &retkey,&retkeylen, &retval,&retlen)))
do {
push_string(make_shared_binary_string(retkey, retkeylen));
push_string(make_shared_binary_string(retval, retlen));
mapping_insert( res_map, sp-2, sp-1 );
pop_stack(); pop_stack();
err = yp_next(this->domain, map, retkey, retkeylen,
&retkey, &retkeylen, &retval, &retlen);
num++;
} while(!err);
if(err != YPERR_NOMORE)
{
free_mapping( res_map );
YPERROR( err );
}
this->last_size = num;
pop_n_elems(args);
push_mapping( res_map );
}
INLINE void mapaddsval( struct mapping * mappingen, struct svalue *key)
{
struct svalue *s;
s = LML( mappingen, key );
if( !s ) {
mapping_insert( mappingen, key, &ett);
} else
s->u.integer++;
}
INLINE void mapaddintnum( struct mapping * mappingen, struct svalue *key, struct svalue *count)
{
struct svalue *s;
s = LML( mappingen, key );
if( !s ) {
mapping_insert( mappingen, key, count);
} else
s->u.integer += count->u.integer;
}
INLINE void mapaddint( struct mapping * mappingen, int key)
{
struct svalue *s;
intie.u.integer = key;
s = LML( mappingen, &intie );
if( !s ) {
mapping_insert( mappingen, &intie, &ett);
} else
s->u.integer++;
}
INLINE void mapaddfloatnum( struct mapping * mappingen, struct svalue *key, struct svalue *count)
{
struct svalue *s;
s = LML( mappingen, key );
if( !s ) {
mapping_insert( mappingen, key, count);
} else {
s->u.float_number += count->u.float_number;
}
}
INLINE void mapaddstr( struct mapping * mappingen, struct pike_string *key)
{
struct svalue *s;
struct svalue skey;
skey.type = T_STRING;
skey.u.string = key;
s = LML( mappingen, &skey );
if( !s ) {
mapping_insert( mappingen, &skey, &ett);
} else
s->u.integer++;
}
static int
dict_insert(DICT *dict, struct object *obj, void *data)
{
INFUN();
if (!obj)
return DICT_NULL_OBJECT;
if (!data)
return DICT_NULL_DATA;
if (!dict)
return DICT_NULL_DICT;
if (dict->used && (dict->used >= dict->dict->data->num_keypairs)) {
struct mapping *nmap, *tmp;
nmap = allocate_mapping(dict->dict->data->num_keypairs << 1);
tmp = merge_mappings(dict->dict, nmap, PIKE_ARRAY_OP_AND);
free_mapping(dict->dict);
free_mapping(nmap);
dict->dict = tmp;
}
{
struct svalue skey, sval, *tmp;
char addr[64];
sval.type = T_OBJECT;
sval.u.object = obj;
sprintf(addr, "0x%X", (unsigned)data);
skey.type = T_STRING;
skey.u.string = make_shared_string(addr);
tmp = low_mapping_lookup(dict->dict, &skey);
if (tmp) {
free_string(skey.u.string);
OUTFUN();
return DICT_EXISTS;
}
mapping_insert(dict->dict, &skey, &sval);
dict->used++;
}
OUTFUN();
return DICT_OK;
}
INLINE void map2addint( struct mapping * mappingen, int subkey, struct pike_string *key)
{
struct svalue *s;
intie.u.integer = subkey;
s = LML( mappingen, &intie );
if( !s ) {
struct svalue mappie;
struct mapping *map = allocate_mapping(1);
mappie.type = T_MAPPING;
mappie.u.mapping = map;
mapping_insert( mappingen, &intie, &mappie);
mapaddstr(map, key);
free_mapping(map);
} else
mapaddstr(s->u.mapping, key);
}
INLINE void mapaddstrmap(struct mapping * mappingen, struct pike_string *key,
struct mapping *map)
{
struct svalue *s;
struct svalue skey;
skey.type = T_STRING;
skey.u.string = key;
s = LML( mappingen, &skey );
if( !s ) {
struct svalue mappie;
mappie.type = T_MAPPING;
mappie.u.mapping = map;
mapping_insert( mappingen, &skey, &mappie);
free_mapping(map);
} else
do_map_addition(s->u.mapping, map);
}
INLINE void map2addstr( struct mapping * mappingen,
struct pike_string *key,
struct pike_string *key2)
{
struct svalue *s;
struct svalue mappie;
struct svalue skey;
skey.type = T_STRING;
skey.u.string = key;
s = LML( mappingen, &skey );
if( !s ) {
struct mapping *map = allocate_mapping(1);
mappie.type = T_MAPPING;
mappie.u.mapping = map;
mapping_insert( mappingen, &skey, &mappie);
mapaddstr(map, key2);
free_mapping(map);
} else
mapaddstr(s->u.mapping, key2);
}
INLINE void mapaddstrint( struct mapping * mappingen,
struct pike_string *key,
int subkey)
{
struct svalue *s;
struct svalue skey;
skey.type = T_STRING;
skey.u.string = key;
s = LML( mappingen, &skey );
if( !s ) {
struct svalue mappie;
struct mapping *map = allocate_mapping(1);
mappie.type = T_MAPPING;
mappie.u.mapping = map;
mapping_insert( mappingen, &skey, &mappie);
mapaddint(map, subkey);
/* mapaddint(map, 0);*/
free_mapping(map);
} else {
mapaddint(s->u.mapping, subkey);
/* mapaddint(s->u.mapping, 0);*/
}
}
static void f_buf_append( INT32 args )
{
struct pike_string *str;
struct svalue skey, sval; /* header, value */
int slash_n = 0, cnt, num;
unsigned char *pp,*ep;
struct svalue *tmp;
int os=0, i, j=0, l, qmark = -1;
unsigned char *in, *query;
if( Pike_sp[-1].type != T_STRING )
Pike_error("Wrong type of argument to append()\n");
str = Pike_sp[-1].u.string;
if( str->len >= BUF->free ) {
pop_n_elems(args);
push_int(413); /* Request Entity Too Large */
return;
}
MEMCPY( BUF->pos, str->str, str->len );
for( ep = (BUF->pos + str->len), pp = MAX(BUF->data, BUF->pos-3);
pp < ep && slash_n < 2; pp++ )
if( *pp == '\n' ) slash_n++;
else if( *pp != '\r' ) slash_n=0;
BUF->free -= str->len;
BUF->pos += str->len;
BUF->pos[0] = 0;
pop_n_elems( args );
if( slash_n != 2 )
{
/* need more data */
push_int( 0 );
return;
}
skey.type = sval.type = T_STRING;
sval.u.string = make_shared_binary_string( (char *)pp, BUF->pos - pp);
mapping_insert(BUF->other, SVAL(data), &sval); /* data */
free_string(sval.u.string);
in = BUF->data;
l = pp - BUF->data;
/* find method */
for( i = 0; i < l; i++ ) {
if( in[i] == ' ' )
break;
else if(in[i] == '\n') {
push_int( 400 ); /* Bad Request */
return;
}
}
sval.u.string = make_shared_binary_string((char *)in, i);
mapping_insert(BUF->other, SVAL(method), &sval);
free_string(sval.u.string);
i++; in += i; l -= i;
/* find file */
for( i = 0; i < l; i++ ) {
if(in[i] == ' ') {
break;
} else if(in[i] == '\n') {
push_int( 400 ); /* Bad Request */
return;
}
}
sval.u.string = make_shared_binary_string((char *)in, i);
mapping_insert(BUF->other, SVAL(raw_url), &sval);
free_string(sval.u.string);
/* Decode file part and return pointer to query, if any */
query = char_decode_url(in, i);
/* Decoded, query-less file up to the first \0 */
sval.u.string = make_shared_string((char *)in);
mapping_insert(BUF->other, SVAL(file), &sval);
free_string(sval.u.string);
if(query != NULL) {
/* Store the query string */
sval.u.string = make_shared_binary_string((char *)query, i - (query-in)); /* Also up to first null */
mapping_insert(BUF->other, SVAL(query), &sval);
free_string(sval.u.string);
}
i++; in += i; l -= i;
/* find protocol */
for( i = 0; i < l; i++ ) {
if( in[i] == '\n' ) break;
else if(in[i] == ' ') {
push_int( 400 ); /* Bad Request */
return;
}
}
if( in[i-1] != '\r' )
i++;
sval.u.string = make_shared_binary_string((char *)in, i-1);
mapping_insert(BUF->other, SVAL(protocol), &sval);
free_string(sval.u.string);
in += i; l -= i;
if( *in == '\n' ) (in++),(l--);
for(i = 0; i < l; i++)
{
if(in[i] >= 'A' && in[i] <= 'Z') in[i] |= 32; /* Lowercasing the header */
else if( in[i] == ':' )
{
/* in[os..i-1] == the header */
skey.u.string = make_shared_binary_string((char*)in+os, i - os);
os = i+1;
while(in[os]==' ') os++; /* Remove initial spaces */
for(j=os;j<l;j++) if( in[j] == '\n' || in[j]=='\r') break;
if((tmp = low_mapping_lookup(BUF->headers, &skey)) &&
tmp->type == T_STRING)
{
int len = j - os + 1;
int len2 = len +tmp->u.string->len;
sval.u.string = begin_shared_string(len2);
MEMCPY(sval.u.string->str,
tmp->u.string->str, tmp->u.string->len);
sval.u.string->str[tmp->u.string->len] = ',';
MEMCPY(sval.u.string->str + tmp->u.string->len + 1,
(char*)in + os, len);
sval.u.string = end_shared_string(sval.u.string);
} else {
sval.u.string = make_shared_binary_string((char*)in + os, j - os);
}
mapping_insert(BUF->headers, &skey, &sval);
if( in[j+1] == '\n' ) j++;
os = j+1;
i = j;
free_string(sval.u.string);
free_string(skey.u.string);
}
}
push_int(1);
}
