/*! @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); }