void region_test_truncate() { header(); struct region region; region_create(®ion, &cache); void *ptr = region_alloc(®ion, 10); fail_unless(ptr); size_t used = region_used(®ion); region_alloc(®ion, 10000); region_alloc(®ion, 10000000); region_truncate(®ion, used); fail_unless(region_used(®ion) == used); region_free(®ion); footer(); }
ExprType *instantiate(ExprType *type, Hashtable *type_table, int replaceFreeVars, Region *r) { ExprType **paramTypes; int i; ExprType *typeInst; int changed = 0; switch(getNodeType(type)) { case T_VAR: typeInst = dereference(type, type_table, r); if(typeInst == type) { return replaceFreeVars?newSimpType(T_UNSPECED, r): type; } else { return instantiate(typeInst, type_table, replaceFreeVars, r); } default: if(type->degree != 0) { paramTypes = (ExprType **) region_alloc(r,sizeof(ExprType *)*type->degree); for(i=0;i<type->degree;i++) { paramTypes[i] = instantiate(type->subtrees[i], type_table, replaceFreeVars, r); if(paramTypes[i]!=type->subtrees[i]) { changed = 1; } } } if(changed) { ExprType *inst = (ExprType *) region_alloc(r, sizeof(ExprType)); memcpy(inst, type, sizeof(ExprType)); inst->subtrees = paramTypes; return inst; } else { return type; } } }
stack_type* stack_create(struct region* region, size_t size) { stack_type* stack = (stack_type*)region_alloc(region, sizeof(stack_type)); stack->capacity = size; stack->num = 0; stack->data = (void**) region_alloc(region, sizeof(void*)*size); memset(stack->data, 0, sizeof(void*)*size); return stack; }
TypingConstraint *newTypingConstraint(ExprType *a, ExprType *b, NodeType type, Node *node, Region *r) { TypingConstraint *tc = (TypingConstraint *)region_alloc(r, sizeof (TypingConstraint)); memset(tc, 0, sizeof(TypingConstraint)); tc->subtrees = (Node **)region_alloc(r, sizeof(Node *)*4); TC_A(tc) = a; TC_B(tc) = b; setNodeType(tc, type); TC_NODE(tc) = node; TC_NEXT(tc) = NULL; tc->degree = 4; return tc; }
/* * setup parse */ void zonec_setup_parser(namedb_type* db) { region_type* rr_region = region_create(xalloc, free); parser = zparser_create(db->region, rr_region, db); assert(parser); /* Unique pointers used to mark errors. */ error_dname = (dname_type *) region_alloc(db->region, 1); error_domain = (domain_type *) region_alloc(db->region, 1); /* Open the network database */ setprotoent(1); setservent(1); }
ExprType *dupTypeAux(ExprType *ty, Region *r, Hashtable *varTable) { ExprType **paramTypes; int i; ExprType *newt; ExprType *exist; char *name; char buf[128]; switch(getNodeType(ty)) { case T_CONS: paramTypes = (ExprType **) region_alloc(r,sizeof(ExprType *)*T_CONS_ARITY(ty)); for(i=0;i<T_CONS_ARITY(ty);i++) { paramTypes[i] = dupTypeAux(T_CONS_TYPE_ARG(ty, i),r,varTable); } newt = newConsType(T_CONS_ARITY(ty), T_CONS_TYPE_NAME(ty), paramTypes, r); newt->option = ty->option; break; case T_TUPLE: paramTypes = (ExprType **) region_alloc(r,sizeof(ExprType *)*T_CONS_ARITY(ty)); for(i=0;i<T_CONS_ARITY(ty);i++) { paramTypes[i] = dupTypeAux(T_CONS_TYPE_ARG(ty, i),r,varTable); } newt = newTupleType(T_CONS_ARITY(ty), paramTypes, r); newt->option = ty->option; break; case T_VAR: name = getTVarName(T_VAR_ID(ty), buf); exist = (ExprType *)lookupFromHashTable(varTable, name); if(exist != NULL) newt = exist; else { newt = newTVar2(T_VAR_NUM_DISJUNCTS(ty), T_VAR_DISJUNCTS(ty), r); insertIntoHashTable(varTable, name, newt); } newt->option = ty->option; break; case T_FLEX: paramTypes = (ExprType **) region_alloc(r,sizeof(ExprType *)*1); paramTypes[0] = dupTypeAux(ty->subtrees[0],r,varTable); newt = newExprType(T_FLEX, 1, paramTypes, r); newt->option = ty->option; break; default: newt = ty; break; } return newt; }
static int read_rdata_atom(namedb_type *db, uint16_t type, int index, uint32_t domain_count, domain_type **domains, rdata_atom_type *result) { uint8_t data[65536]; if (rdata_atom_is_domain(type, index)) { result->domain = read_domain(db, domain_count, domains); if (!result->domain) return 0; } else { uint16_t size; if (fread(&size, sizeof(size), 1, db->fd) != 1) return 0; size = ntohs(size); if (fread(data, sizeof(uint8_t), size, db->fd) != size) return 0; result->data = (uint16_t *) region_alloc( db->region, sizeof(uint16_t) + size); memcpy(result->data, &size, sizeof(uint16_t)); memcpy((uint8_t *) result->data + sizeof(uint16_t), data, size); } return 1; }
Env *newEnv(Hashtable *current, Env *previous, Env *callerEnv, Region *r) { Env *env = (Env *)region_alloc(r, sizeof(Env)); env->current = current; env->previous = previous; env->lower = callerEnv; return env; }
Res* newRes(Region *r) { Res *res1 = (Res *) region_alloc(r,sizeof (Res)); memset(res1, 0, sizeof(Res)); setNodeType(res1, N_VAL); setIOType(res1, IO_TYPE_INPUT); return res1; }
/* used in cpRes only */ Res* newCollRes2(int size, Region *r) { Res *res1 = newRes(r); res1->exprType = NULL; res1->degree = size; res1->subtrees = (Res **)region_alloc(r, sizeof(Res *)*size); return res1; }
Res* newCollRes(int size, ExprType *elemType, Region *r) { Res *res1 = newRes(r); res1->exprType = newCollType(elemType, r); res1->degree = size; res1->subtrees = (Res **)region_alloc(r, sizeof(Res *)*size); return res1; }
FunctionDesc *newExternalFD(Node *type, Region *r) { FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc)); memset(desc, 0, sizeof(FunctionDesc)); desc->exprType = type; setNodeType(desc, N_FD_EXTERNAL); return desc; }
/* * Allocate SIZE+sizeof(uint16_t) bytes and store SIZE in the first * element. Return a pointer to the allocation. */ static uint16_t * alloc_rdata(region_type *region, size_t size) { uint16_t *result = region_alloc(region, sizeof(uint16_t) + size); *result = size; return result; }
/** * Used for TXT RR's to grow with undefined number of strings. */ void zadd_rdata_txt_wireformat(uint16_t *data, int first) { rdata_atom_type *rd; if (parser->current_rr.rdata_count >= MAXRDATALEN) { zc_error_prev_line("too many rdata txt elements"); return; } /* First STR in str_seq, allocate 65K in first unused rdata * else find last used rdata */ if (first) { rd = &parser->current_rr.rdatas[parser->current_rr.rdata_count]; if ((rd->data = (uint16_t *) region_alloc(parser->rr_region, sizeof(uint16_t) + 65535 * sizeof(uint8_t))) == NULL) { zc_error_prev_line("Could not allocate memory for TXT RR"); return; } parser->current_rr.rdata_count++; rd->data[0] = 0; } else rd = &parser->current_rr.rdatas[parser->current_rr.rdata_count-1]; if ((size_t)rd->data[0] + (size_t)data[0] > 65535) { zc_error_prev_line("too large rdata element"); return; } memcpy((uint8_t *)rd->data + 2 + rd->data[0], data + 1, data[0]); rd->data[0] += data[0]; }
pattern_options_t* pattern_options_create(region_type* region) { pattern_options_t* p; p = (pattern_options_t*)region_alloc(region, sizeof(pattern_options_t)); p->node = *RBTREE_NULL; p->pname = 0; p->zonefile = 0; p->zonestats = 0; p->allow_notify = 0; p->request_xfr = 0; p->notify = 0; p->provide_xfr = 0; p->outgoing_interface = 0; p->notify_retry = 5; p->notify_retry_is_default = 1; p->allow_axfr_fallback = 1; p->allow_axfr_fallback_is_default = 1; p->implicit = 0; p->xfrd_flags = 0; #ifdef RATELIMIT p->rrl_whitelist = 0; #endif return p; }
/** add tsig_key contents */ void key_options_setup(region_type* region, key_options_t* key) { uint8_t data[16384]; /* 16KB */ int size; if(!key->tsig_key) { /* create it */ key->tsig_key = (tsig_key_type *) region_alloc(region, sizeof(tsig_key_type)); /* create name */ key->tsig_key->name = dname_parse(region, key->name); if(!key->tsig_key->name) { log_msg(LOG_ERR, "Failed to parse tsig key name %s", key->name); /* key and base64 were checked during syntax parse */ exit(1); } key->tsig_key->size = 0; key->tsig_key->data = NULL; } size = b64_pton(key->secret, data, sizeof(data)); if(size == -1) { log_msg(LOG_ERR, "Failed to parse tsig key data %s", key->name); /* key and base64 were checked during syntax parse */ exit(1); } key->tsig_key->size = size; key->tsig_key->data = (uint8_t *)region_alloc_init(region, data, size); }
FunctionDesc *newConstructorFD2(Node *type, Region *r) { FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc)); memset(desc, 0, sizeof(FunctionDesc)); desc->exprType = type; setNodeType(desc, N_FD_CONSTRUCTOR); return desc; }
/* * The main server simply waits for signals and child processes to * terminate. Child processes are restarted as necessary. */ void server_main(struct nsd *nsd) { region_type *server_region = region_create(xalloc, free); netio_handler_type xfrd_listener; /* Ensure we are the main process */ assert(nsd->server_kind == NSD_SERVER_MAIN); xfrd_listener.user_data = (struct ipc_handler_conn_data*)region_alloc( server_region, sizeof(struct ipc_handler_conn_data)); xfrd_listener.fd = -1; ((struct ipc_handler_conn_data*)xfrd_listener.user_data)->nsd = nsd; ((struct ipc_handler_conn_data*)xfrd_listener.user_data)->conn = xfrd_tcp_create(server_region); nsd->pid = 0; nsd->child_count = 0; nsd->server_kind = NSD_SERVER_UDP; nsd->this_child = &nsd->children[0]; /* remove signal flags inherited from parent the parent will handle them. */ nsd->signal_hint_reload = 0; nsd->signal_hint_child = 0; nsd->signal_hint_quit = 0; nsd->signal_hint_shutdown = 0; nsd->signal_hint_stats = 0; nsd->signal_hint_statsusr = 0; close(nsd->this_child->child_fd); nsd->this_child->child_fd = -1; server_child(nsd); abort(); }
const dname_type * dname_replace(region_type* region, const dname_type* name, const dname_type* src, const dname_type* dest) { /* nomenclature: name is said to be <x>.<src>. x can be null. */ dname_type* res; int x_labels = name->label_count - src->label_count; int x_len = name->name_size - src->name_size; int i; assert(dname_is_subdomain(name, src)); /* check if final size is acceptable */ if(x_len+dest->name_size > MAXDOMAINLEN) return NULL; res = (dname_type*)region_alloc(region, sizeof(dname_type) + (x_labels+dest->label_count + x_len+dest->name_size) *sizeof(uint8_t)); res->name_size = x_len+dest->name_size; res->label_count = x_labels+dest->label_count; for(i=0; i<dest->label_count; i++) ((uint8_t*)dname_label_offsets(res))[i] = dname_label_offsets(dest)[i] + x_len; for(i=dest->label_count; i<res->label_count; i++) ((uint8_t*)dname_label_offsets(res))[i] = dname_label_offsets(name)[i - dest->label_count + src->label_count]; memcpy((uint8_t*)dname_name(res), dname_name(name), x_len); memcpy((uint8_t*)dname_name(res)+x_len, dname_name(dest), dest->name_size); assert(dname_is_subdomain(res, dest)); return res; }
/** * Unify non tvar or union types. * return The most general instance if unifiable * NULL if not */ ExprType* unifyNonTvars(ExprType *type, ExprType *expected, Hashtable *varTypes, Region *r) { if(getNodeType(type) == T_CONS && getNodeType(expected) == T_CONS) { if(strcmp(T_CONS_TYPE_NAME(type), T_CONS_TYPE_NAME(expected)) == 0 && T_CONS_ARITY(type) == T_CONS_ARITY(expected)) { ExprType **subtrees = (ExprType **) region_alloc(r, sizeof(ExprType *) * T_CONS_ARITY(expected)); int i; for(i=0;i<T_CONS_ARITY(type);i++) { ExprType *elemType = unifyWith( T_CONS_TYPE_ARG(type, i), T_CONS_TYPE_ARG(expected, i), varTypes,r); /* unifyWithCoercion performs dereference */ if(elemType == NULL) { return NULL; } subtrees[i] = elemType; } return dereference(newConsType(T_CONS_ARITY(expected), T_CONS_TYPE_NAME(expected), subtrees, r), varTypes, r); } else { return NULL; } } else if(getNodeType(type) == T_IRODS || getNodeType(expected) == T_IRODS) { if(strcmp(type->text, expected->text)!=0) { return NULL; } return expected; } else if(getNodeType(expected) == getNodeType(type)) { /* primitive types */ return expected; } else { return newErrorType(RE_TYPE_ERROR, r); } }
void key_options_tsig_add(nsd_options_t* opt) { key_options_t* optkey; uint8_t data[4000]; tsig_key_type* tsigkey; const dname_type* dname; int size; for(optkey = opt->keys; optkey; optkey = optkey->next) { dname = dname_parse(opt->region, optkey->name); if(!dname) { log_msg(LOG_ERR, "Failed to parse tsig key name %s", optkey->name); continue; } size = b64_pton(optkey->secret, data, sizeof(data)); if(size == -1) { log_msg(LOG_ERR, "Failed to parse tsig key data %s", optkey->name); continue; } tsigkey = (tsig_key_type *) region_alloc(opt->region, sizeof(tsig_key_type)); tsigkey->name = dname; tsigkey->size = size; tsigkey->data = (uint8_t *) region_alloc_init(opt->region, data, tsigkey->size); tsig_add_key(tsigkey); optkey->tsig_key = tsigkey; } }
static int sys_sbrk(uint32_t inc) { // LAB3: your code sbrk here... region_alloc(curenv, (void *)(curenv->env_cur_brk + inc), inc); return curenv->env_cur_brk; }
uint16_t * alloc_rdata_init(region_type *region, const void *data, size_t size) { uint16_t *result = region_alloc(region, sizeof(uint16_t) + size); *result = size; memcpy(result + 1, data, size); return result; }
Res* newStringBasedRes(Region *r, char *s) { Res *res1 = newRes(r); RES_STRING_STR_LEN(res1) = strlen(s); int size = (RES_STRING_STR_LEN(res1)+1)*sizeof(char); res1->text = (char *)region_alloc(r, size); memcpy(res1->text, s, size); return res1; }
FunctionDesc *newFunctionFD(char *type, SmsiFuncTypePtr func, Region *r) { FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc)); memset(desc, 0, sizeof(FunctionDesc)); FD_SMSI_FUNC_PTR_LVAL(desc) = func; desc->exprType = type == NULL? NULL:parseFuncTypeFromString(type, r); setNodeType(desc, N_FD_FUNCTION); return desc; }
void * region_alloc_zero(region_type *region, size_t size) { void *result = region_alloc(region, size); if (!result) return NULL; memset(result, 0, size); return result; }
void * region_alloc_init(region_type *region, const void *init, size_t size) { void *result = region_alloc(region, size); if (!result) return NULL; memcpy(result, init, size); return result; }
FunctionDesc *newRuleIndexListFD(RuleIndexList *ruleIndexList, ExprType *type, Region *r) { FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc)); memset(desc, 0, sizeof(FunctionDesc)); FD_RULE_INDEX_LIST_LVAL(desc) = ruleIndexList; desc->exprType = type; setNodeType(desc, N_FD_RULE_INDEX_LIST); return desc; }
FunctionDesc *newDeconstructorFD(char *type, int proj, Region *r) { FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc)); memset(desc, 0, sizeof(FunctionDesc)); desc->exprType = type == NULL? NULL:parseFuncTypeFromString(type, r); setNodeType(desc, N_FD_DECONSTRUCTOR); FD_PROJ(desc) = proj; return desc; }
// initialize void render_init(void) { // scrolling boot region region_alloc((region*)(&bootScrollRegion)); scroll_init(&bootScroll, &bootScrollRegion); print_dbg("\r\n init rendering regions.. "); // screen regions allocated here region_alloc((region*)(&headRegion_pr)); region_alloc((region*)(&(footRegion_pr[0]))); region_alloc((region*)(&(footRegion_pr[1]))); region_alloc((region*)(&(footRegion_pr[2]))); region_alloc((region*)(&(footRegion_pr[3]))); // region_alloc((region*)(&selectRegion_pr)); region_alloc((region*)(&lineRegion_pr)); headRegion = &headRegion_pr; footRegion[0] = &(footRegion_pr[0]); footRegion[1] = &(footRegion_pr[1]); footRegion[2] = &(footRegion_pr[2]); footRegion[3] = &(footRegion_pr[3]); // selectRegion = &selectRegion_pr; lineRegion = &lineRegion_pr; }