FILTER* interpolateFilter(FILTER* filter1,FILTER* filter2, float ratio, interpolation_t* inter) { if(!filter1 && !filter2) return 0; int filter_type; if (!filter1) filter_type = filter2->type; else if (!filter2) filter_type = filter1->type; else if(filter2->type != filter1->type) syntaxerror("can't interpolate between %s and %s filters yet", filtername[filter1->type], filtername[filter2->type]); else filter_type = filter1->type; switch (filter_type) { case FILTERTYPE_BLUR: return interpolateBlur(filter1, filter2, ratio, inter); case FILTERTYPE_BEVEL: return interpolateBevel(filter1, filter2, ratio, inter); case FILTERTYPE_DROPSHADOW: return interpolateDropshadow(filter1, filter2, ratio, inter); case FILTERTYPE_GRADIENTGLOW: return interpolateGradientGlow(filter1, filter2, ratio, inter); default: syntaxerror("Filtertype %s not supported yet.\n", filtername[filter1->type]); } return 0; }
void initialize_file(char*filename) { if(state) { syntaxerror("invalid call to initialize_file during parsing of another file"); } new_state(); state->package = internal_filename_package = strdup(filename); global->token2info = dict_lookup(global->file2token2info, current_filename // use long version ); if(!global->token2info) { global->token2info = dict_new2(&ptr_type); dict_put(global->file2token2info, current_filename, global->token2info); } if(as3_pass==1) { state->method = rfx_calloc(sizeof(methodstate_t)); dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method); state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope state->method->allvars = dict_new(); } else { state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount); state->method->variable_count = 0; if(!state->method) syntaxerror("internal error: skewed tokencount"); function_initvars(state->method, 0, 0, 0, 1); global->init = 0; } }
struct instruction *parse_instruction(void) { struct expr *expr; struct instruction *res; switch (lookahead[0]->type) { case WHILE: return parse_while(); case DO: return parse_do(); case IDENTIFIER: case LPAREN: expr = parse_expression(); switch(lookahead[0]->type) { case ASSIGN: return parse_assignment_instr(expr); case EOL: if (expr->exprtype != funcalltype) { if (expr->exprtype == binopexprtype && expr->val.binopexpr.op == EQ) { error(expr->pos, "unexpected =, did you mean <- ?"); exit(1); } else syntaxerror("expected instruction, not expression"); } eat(EOL); res = funcallinstr(expr->val.funcall.fun_ident, expr->val.funcall.args, expr->pos); free(expr); return res; default: next(); syntaxerror("unexpected %s", tok->val); return parse_instruction(); } case RETURN: eat(RETURN); if (lookahead[0]->type == EOL) { eat(EOL); return return_stmt(NULL); } else { expr = parse_expression(); eat(EOL); return return_stmt(expr); } case FOR: return parse_for(); case IF: return parse_if(); case SWITCH: return parse_switch(); case ENDOFFILE: return NULL; default: next(); syntaxerror("expected instruction, not %s", tok->val); return parse_instruction(); } }
struct expr *infix(struct expr *left, char *expect) { exprlist_t args; int toktype = tok->type; char *ident; switch (toktype) { case PLUS: case MINUS: case STAR: case SLASH: case OR: case XOR: case LT: case LE: case GT: case GE: case NEQ: case EQ: case AND: return binopexpr(left, toktype, expression(lbp(toktype))); case LPAREN: if (left->exprtype != identtype) syntaxerror("calling non-callable expression"); args = empty_exprlist(); if (lookahead[0]->type != COMMA && lookahead[0]->type != RPAREN) list_push_back(args, expression(0)); while (lookahead[0]->type == COMMA) { eat(COMMA); list_push_back(args, expression(0)); } eat(RPAREN); ident = strdup(left->val.ident); left->type = NULL; // To prevent segfaults when freeing the expr free_expression(left); return funcallexpr(ident, args); case LSQBRACKET: args = empty_exprlist(); list_push_back(args, expression(0)); while (lookahead[0]->type == COMMA) { eat(COMMA); list_push_back(args, expression(0)); } eat(RSQBRACKET); return arrayexpr(left, args); case DOT: eat(IDENTIFIER); char *ident = strdup(tok->val); return record_access(left, ident); case DEREF: return make_deref(left); default: syntaxerror("expected %s, not %s", expect, tok->val); next(); switch (tok->type) { case ENDOFFILE: return expr_from_val(0); default: return infix(left, "expression"); } } }
FILTER* copyFilter(FILTER* original) { if (!original) return original; FILTER* copy = swf_NewFilter(original->type); switch (original->type) { case FILTERTYPE_BLUR: memcpy(copy, original, sizeof(FILTER_BLUR)); break; case FILTERTYPE_GRADIENTGLOW: { memcpy(copy, original, sizeof(FILTER_GRADIENTGLOW)); FILTER_GRADIENTGLOW* ggcopy = (FILTER_GRADIENTGLOW*)copy; ggcopy->gradient = (GRADIENT*)malloc(sizeof(GRADIENT)); ggcopy->gradient->ratios = (U8*)malloc(16 * sizeof(U8)); ggcopy->gradient->rgba = (RGBA*)malloc(16 * sizeof(RGBA)); copyGradient(ggcopy->gradient, ((FILTER_GRADIENTGLOW*)original)->gradient); } break; case FILTERTYPE_DROPSHADOW: memcpy(copy, original, sizeof(FILTER_DROPSHADOW)); break; case FILTERTYPE_BEVEL: memcpy(copy, original, sizeof(FILTER_BEVEL)); break; default: syntaxerror("Internal error: unsupported filterype, cannot copy"); } return copy; }
void SyntaxAnalyzer::endcheck(std::set<symboltype> &followers) { if (followers.find(symbol) == followers.end()) { syntaxerror(othersy); skipto(followers); } }
variable_t* find_variable_safe(state_t*s, char*name) { variable_t* v = find_variable(s, name); if(!v) syntaxerror("undefined variable: %s", name); return v; }
struct expr *prefix(char *expect) { struct expr *res = NULL; int toktype = tok->type; switch (toktype) { case IDENTIFIER: return identexpr(strdup(tok->val)); case LPAREN: res = expression(0); eat(RPAREN); return res; case PLUS: case MINUS: case NOT: return unopexpr(toktype, expression(lbp(toktype) - 1)); case REAL: return expr_from_val(realval(atof(tok->val))); case INT: return expr_from_val(intval(atoi(tok->val))); case CHAR: return expr_from_val(charval(tok->val[1])); case STRING: return expr_from_val(strval(strdup(tok->val))); case TRUE: return expr_from_val(boolval(1)); case FALSE: return expr_from_val(boolval(0)); case NULLKW: return nullexpr(); default: syntaxerror("expected %s, not %s", expect, tok->val); return NULL; } }
int history_change(history_t* past, U16 frame, char* parameter) { state_t* first = dict_lookup(past->states, parameter); if (first) //should always be true. return state_differs(first, frame); syntaxerror("no history found to predict changes for parameter %s.\n", parameter); return 0; }
float history_value(history_t* past, U16 frame, char* parameter) { state_t* state = dict_lookup(past->states, parameter); if (state) //should always be true. return state_value(state, frame); syntaxerror("no history found to get a value for parameter %s.\n", parameter); return 0; }
int history_changeFilter(history_t* past, U16 frame) { filterState_t* first = dict_lookup(past->states, "filter"); if (first) //should always be true. return filterState_differs(first, frame); syntaxerror("no history found to predict changes for parameter filter.\n"); return 0; }
FILTERLIST* history_filterValue(history_t* past, U16 frame) { filterState_t* first = dict_lookup(past->states, "filter"); if (first) //should always be true. return filterState_value(first, frame); syntaxerror("no history found to get a value for parameter filter.\n"); return 0; }
void history_rememberFilter(history_t* past, U16 frame, int function, FILTERLIST* value, interpolation_t* inter) { past->lastFrame = frame; filterState_t* first = dict_lookup(past->states, "filter"); if (first) //should always be true { filterState_t* next = filterState_new(frame, function, value, inter); filterState_append(first, next); } else syntaxerror("Internal error: changing a filter not set for the instance."); }
void history_remember(history_t* past, char* parameter, U16 frame, int function, float value, interpolation_t* inter) { past->lastFrame = frame; state_t* state = dict_lookup(past->states, parameter); if (state) //should always be true { state_t* next = state_new(frame, function, value, inter); state_append(state, next); } else syntaxerror("Internal error: changing parameter %s, which is unknown for the instance.", parameter); }
bool SyntaxAnalyzer::startcheck( std::set<symboltype> &starters, std::set<symboltype> &followers ) { if (starters.find(symbol) == starters.end()) { syntaxerror(othersy); skipto(starters, followers); return false; //symbol not in starters } else { return true; //symbol in starters } }
void filterState_append(filterState_t* first, filterState_t* newChange) { while (first->next) first = first->next; if (!first->value || !newChange->value) first->next = newChange; else { int i, mergedCount = 0; int common = first->value->num < newChange->value->num ? first->value->num : newChange->value->num; for (i = 0; i < common; i++) { mergedCount++; if (newChange->value->filter[i]->type != first->value->filter[i]->type) mergedCount++; } mergedCount = mergedCount + first->value->num - common + newChange->value->num - common; if (mergedCount > 8) { char* list1; char* list2; char* newList; list1 = (char*)malloc(1); *list1 = '\0'; for (i = 0; i < first->value->num; i++) { char*filter = filtername[first->value->filter[i]->type]; newList = (char*)malloc(strlen(list1) + strlen(filter) + 2); strcpy(newList, list1); strcat(newList, "+"); strcat(newList, filtername[first->value->filter[i]->type]); free(list1); list1 = newList; } list2 = (char*)malloc(1); *list2 = '\0'; for (i = 0; i < newChange->value->num; i++) { char*filter = filtername[newChange->value->filter[i]->type]; newList = (char*)malloc(strlen(list2) + strlen(filter) + 2); strcpy(newList, list2); strcat(newList, "+"); strcat(newList, filter); free(list2); list2 = newList; } syntaxerror("filterlists %s and %s cannot be interpolated.", list1, list2); } first->next = newChange; } }
variable_t* new_variable2(methodstate_t*method, const char*name, classinfo_t*type, char init, char maybeslot) { if(maybeslot) { variable_t*v = find_slot(method, name); if(v) { alloc_local(); return v; } } NEW(variable_t, v); v->type = type; v->init = v->kill = init; if(name) { if(!method->no_variable_scoping) { if(dict_contains(state->vars, name)) { syntaxerror("variable %s already defined", name); } v->index = alloc_local(); dict_put(state->vars, name, v); } else { if(as3_pass==2 && dict_contains(state->method->allvars, name)) { variable_t*v = dict_lookup(state->method->allvars, name); if(v->type != type && (!v->type || v->type->kind!=INFOTYPE_UNRESOLVED)) { syntaxerror("variable %s already defined.", name); } return v; } v->index = alloc_local(); } dict_put(state->method->allvars, name, v); } else { v->index = alloc_local(); } return v; }
struct val *parse_val(void) { next(); switch (tok->type) { case INT: return intval(atoi(tok->val)); case REAL: return realval(atof(tok->val)); case STRING: return strval(tok->val); case TRUE: return boolval(true); case FALSE: return boolval(false); case CHAR: return charval(tok->val[1]); default: syntaxerror("expected a value, not %s", tok->val); return intval(0); } }
struct type_decl *parse_typedecl(void) { eat(IDENTIFIER); struct pos pos = *tok->pos; char *ident = strdup(tok->val); struct type_def *type_def = NULL; eat(EQ); switch (lookahead[0]->type) { case LPAREN: type_def = parse_enum_def(); break; case RECORD: type_def = parse_record_def(); break; case INT: case IDENTIFIER: type_def = parse_array_def(); break; case DEREF: type_def = parse_pointer_def(); break; default: syntaxerror("expected type definition, not %s", tok->val); } return make_type_decl(ident, type_def, pos); }
GRADIENT* interpolateNodes(GRADIENT* g1, GRADIENT* g2, float fraction, interpolation_t* inter) { if (g1->num != g2->num) syntaxerror("Internal error: gradients are not equal in size"); int i; GRADIENT* g = (GRADIENT*) malloc(sizeof(GRADIENT)); g->ratios = rfx_calloc(16*sizeof(U8)); g->rgba = rfx_calloc(16*sizeof(RGBA)); g->num = g1->num; for (i = 0; i < g->num; i++) { g->ratios[i] = interpolateScalar(g1->ratios[i], g2->ratios[i], fraction, inter); g->rgba[i] = interpolateColor(g1->rgba[i], g2->rgba[i], fraction, inter); } return g; }
void old_state() { if(!state || !state->old) syntaxerror("invalid nesting"); state_t*leaving = state; state = state->old; if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) { methodstate_destroy(leaving->method);leaving->method=0; } if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) { free(leaving->cls); leaving->cls=0; } state_destroy(leaving); }
// <statement> ::= <simple statement> // | <complex statement> void SyntaxAnalyzer::statement(std::set<symboltype> followers) { //ako neterminala ne se vika ot drugo mqsto //ne se pravi startcheck & endcheck v tqh a samo v parenta if (statementStarters.find(symbol) != statementStarters.end()) { switch(symbol) { case ident: assignment(followers); break; case beginsy: compoundStatement(followers); break; case ifsy: ifStatement(followers); break; case whilesy: whileStatement(followers); break; case readsy: readStatement(followers); break; case writesy: writeStatement(followers); break; default: break; } // swtich } else { syntaxerror(othersy); } } // statement()
void finish_file() { if(!state || state->level!=1) { syntaxerror("unexpected end of file in pass %d", as3_pass); } if(as3_pass==2) { dict_del(global->file2token2info, current_filename); code_t*header = method_header(state->method); //if(global->init->method->body->code || global->init->traits) { if(global->init) { code_t*c = wrap_function(header, 0, global->init->method->body->code); global->init->method->body->code = abc_returnvoid(c); free(state->method);state->method=0; } } //free(state->package);state->package=0; // used in registry state_destroy(state);state=0; }
struct expr* build_dim(struct token* tok) { switch(tok->type) { case INT: return expr_from_val(intval(atoi(tok->val))); case IDENTIFIER: { struct expr *e = malloc(sizeof(struct expr)); e->exprtype = identtype; e->val.ident = strdup(tok->val); e->type = NULL; e->pos = *tok->pos; return e; } default: syntaxerror("expected integer or identifier not %s", tok->val); } return NULL; }
FILTER* noFilter(int type) { switch (type) { case FILTERTYPE_BLUR: return (FILTER*)noBlur; break; case FILTERTYPE_BEVEL: return (FILTER*)noBevel; break; case FILTERTYPE_DROPSHADOW: return (FILTER*)noDropshadow; break; case FILTERTYPE_GRADIENTGLOW: return (FILTER*)noGradientGlow; break; default: syntaxerror("Internal error: unsupported filtertype, cannot match filterlists"); } return 0; }
float history_rotateValue(history_t* past, U16 frame) { state_t* rotations = dict_lookup(past->states, "rotate"); if (rotations) //should always be true. { float angle = state_value(rotations, frame); state_t* flags = dict_lookup(past->states, "flags"); U16 currentflags = state_value(flags, frame); if (currentflags & IF_FIXED_ALIGNMENT) { flags = state_at(flags, frame); if (frame == past->firstFrame) frame++; state_t *x, *y; float dx, dy, pathAngle; do { x = dict_lookup(past->states, "x"); dx = state_value(x, frame) - state_value(x, frame - 1); y = dict_lookup(past->states, "y"); dy = state_value(y, frame) - state_value(y, frame - 1); frame--; } while (dx == 0 && dy == 0 && frame > past->firstFrame); if (frame == past->firstFrame) pathAngle = 0; else pathAngle = getAngle(dx, dy) / M_PI * 180; return angle + flags->params.instanceAngle + pathAngle - flags->params.pathAngle; } else return angle; } syntaxerror("no history found to get a value for parameter rotate.\n"); return 0; }
code_t*defaultvalue(code_t*c, classinfo_t*type) { as3_assert(!type || type->kind!=INFOTYPE_UNRESOLVED); if(TYPE_IS_INT(type)) { c = abc_pushbyte(c, 0); } else if(TYPE_IS_UINT(type)) { c = abc_pushuint(c, 0); } else if(TYPE_IS_FLOAT(type)) { c = abc_pushnan(c); } else if(TYPE_IS_BOOLEAN(type)) { c = abc_pushfalse(c); } else if(TYPE_IS_STRING(type)) { c = abc_pushnull(c); c = abc_coerce_s(c); } else if(!type) { //c = abc_pushundefined(c); syntaxerror("internal error: can't generate default value for * type"); } else { c = abc_pushnull(c); MULTINAME(m, type); c = abc_coerce2(c, &m); } return c; }
int main() { int fddata; int i; int j; int k; char ch; unsigned long ttl; char ttd[8]; char loc[2]; unsigned long u; char ip[4]; char ip6[16]; char type[2]; char soa[20]; char buf[4]; umask(022); fddata = open_read("data"); if (fddata == -1) strerr_die2sys(111,FATAL,"unable to open data: "); defaultsoa_init(fddata); buffer_init(&b,buffer_unixread,fddata,bspace,sizeof bspace); fdcdb = open_trunc("data.tmp"); if (fdcdb == -1) die_datatmp(); if (cdb_make_start(&cdb,fdcdb) == -1) die_datatmp(); while (match) { ++linenum; if (getln(&b,&line,&match,'\n') == -1) strerr_die2sys(111,FATAL,"unable to read line: "); while (line.len) { ch = line.s[line.len - 1]; if ((ch != ' ') && (ch != '\t') && (ch != '\n')) break; --line.len; } if (!line.len) continue; if (line.s[0] == '#') continue; if (line.s[0] == '-') continue; j = 1; for (i = 0;i < NUMFIELDS;++i) { if (j >= line.len) { if (!stralloc_copys(&f[i],"")) nomem(); } else { k = byte_chr(line.s + j,line.len - j,':'); if (!stralloc_copyb(&f[i],line.s + j,k)) nomem(); j += k + 1; } } switch(line.s[0]) { case '%': locparse(&f[0],loc); if (!stralloc_copyb(&key,"\0%",2)) nomem(); if (!stralloc_0(&f[1])) nomem(); ipprefix_cat(&key,f[1].s); if (cdb_make_add(&cdb,key.s,key.len,loc,2) == -1) die_datatmp(); break; case 'Z': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[3])) nomem(); if (!scan_ulong(f[3].s,&u)) uint32_unpack_big(defaultsoa,&u); uint32_pack_big(soa,u); if (!stralloc_0(&f[4])) nomem(); if (!scan_ulong(f[4].s,&u)) uint32_unpack_big(defaultsoa + 4,&u); uint32_pack_big(soa + 4,u); if (!stralloc_0(&f[5])) nomem(); if (!scan_ulong(f[5].s,&u)) uint32_unpack_big(defaultsoa + 8,&u); uint32_pack_big(soa + 8,u); if (!stralloc_0(&f[6])) nomem(); if (!scan_ulong(f[6].s,&u)) uint32_unpack_big(defaultsoa + 12,&u); uint32_pack_big(soa + 12,u); if (!stralloc_0(&f[7])) nomem(); if (!scan_ulong(f[7].s,&u)) uint32_unpack_big(defaultsoa + 16,&u); uint32_pack_big(soa + 16,u); if (!stralloc_0(&f[8])) nomem(); if (!scan_ulong(f[8].s,&ttl)) ttl = TTL_NEGATIVE; ttdparse(&f[9],ttd); locparse(&f[10],loc); rr_start(DNS_T_SOA,ttl,ttd,loc); if (!dns_domain_fromdot(&d2,f[1].s,f[1].len)) nomem(); rr_addname(d2); if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem(); rr_addname(d2); rr_add(soa,20); rr_finish(d1); break; case '.': case '&': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[3])) nomem(); if (!scan_ulong(f[3].s,&ttl)) ttl = TTL_NS; ttdparse(&f[4],ttd); locparse(&f[5],loc); if (!stralloc_0(&f[1])) nomem(); if (byte_chr(f[2].s,f[2].len,'.') >= f[2].len) { if (!stralloc_cats(&f[2],".ns.")) nomem(); if (!stralloc_catb(&f[2],f[0].s,f[0].len)) nomem(); } if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem(); if (line.s[0] == '.') { rr_start(DNS_T_SOA,ttl ? TTL_NEGATIVE : 0,ttd,loc); rr_addname(d2); rr_add("\12hostmaster",11); rr_addname(d1); rr_add(defaultsoa,20); rr_finish(d1); } rr_start(DNS_T_NS,ttl,ttd,loc); rr_addname(d2); rr_finish(d1); if (ip4_scan(f[1].s,ip)) { rr_start(DNS_T_A,ttl,ttd,loc); rr_add(ip,4); rr_finish(d2); } break; case '+': case '=': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[2])) nomem(); if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE; ttdparse(&f[3],ttd); locparse(&f[4],loc); if (!stralloc_0(&f[1])) nomem(); if (ip4_scan(f[1].s,ip)) { rr_start(DNS_T_A,ttl,ttd,loc); rr_add(ip,4); rr_finish(d1); if (line.s[0] == '=') { dns_name4_domain(dptr,ip); rr_start(DNS_T_PTR,ttl,ttd,loc); rr_addname(d1); rr_finish(dptr); } } break; case '6': case '3': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[2])) nomem(); if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE; ttdparse(&f[3],ttd); locparse(&f[4],loc); if (!stralloc_0(&f[1])) nomem(); if (ip6_scan_flat(f[1].s,ip6)) { rr_start(DNS_T_AAAA,ttl,ttd,loc); rr_add(ip6,16); rr_finish(d1); if (line.s[0] == '6') { /* emit both .ip6.arpa and .ip6.int */ dns_name6_domain(d6ptr,ip6,DNS_IP6_ARPA); rr_start(DNS_T_PTR,ttl,ttd,loc); rr_addname(d1); rr_finish(d6ptr); dns_name6_domain(d6ptr,ip6,DNS_IP6_INT); rr_start(DNS_T_PTR,ttl,ttd,loc); rr_addname(d1); rr_finish(d6ptr); } } break; case '@': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[4])) nomem(); if (!scan_ulong(f[4].s,&ttl)) ttl = TTL_POSITIVE; ttdparse(&f[5],ttd); locparse(&f[6],loc); if (!stralloc_0(&f[1])) nomem(); if (byte_chr(f[2].s,f[2].len,'.') >= f[2].len) { if (!stralloc_cats(&f[2],".mx.")) nomem(); if (!stralloc_catb(&f[2],f[0].s,f[0].len)) nomem(); } if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem(); if (!stralloc_0(&f[3])) nomem(); if (!scan_ulong(f[3].s,&u)) u = 0; rr_start(DNS_T_MX,ttl,ttd,loc); uint16_pack_big(buf,u); rr_add(buf,2); rr_addname(d2); rr_finish(d1); if (ip4_scan(f[1].s,ip)) { rr_start(DNS_T_A,ttl,ttd,loc); rr_add(ip,4); rr_finish(d2); } break; case '^': case 'C': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!dns_domain_fromdot(&d2,f[1].s,f[1].len)) nomem(); if (!stralloc_0(&f[2])) nomem(); if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE; ttdparse(&f[3],ttd); locparse(&f[4],loc); if (line.s[0] == 'C') rr_start(DNS_T_CNAME,ttl,ttd,loc); else rr_start(DNS_T_PTR,ttl,ttd,loc); rr_addname(d2); rr_finish(d1); break; case '\'': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[2])) nomem(); if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE; ttdparse(&f[3],ttd); locparse(&f[4],loc); rr_start(DNS_T_TXT,ttl,ttd,loc); txtparse(&f[1]); i = 0; while (i < f[1].len) { k = f[1].len - i; if (k > 127) k = 127; ch = k; rr_add(&ch,1); rr_add(f[1].s + i,k); i += k; } rr_finish(d1); break; case ':': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[3])) nomem(); if (!scan_ulong(f[3].s,&ttl)) ttl = TTL_POSITIVE; ttdparse(&f[4],ttd); locparse(&f[5],loc); if (!stralloc_0(&f[1])) nomem(); scan_ulong(f[1].s,&u); uint16_pack_big(type,u); if (byte_equal(type,2,DNS_T_AXFR)) syntaxerror(": type AXFR prohibited"); if (byte_equal(type,2,"\0\0")) syntaxerror(": type 0 prohibited"); if (byte_equal(type,2,DNS_T_SOA)) syntaxerror(": type SOA prohibited"); if (byte_equal(type,2,DNS_T_NS)) syntaxerror(": type NS prohibited"); if (byte_equal(type,2,DNS_T_CNAME)) syntaxerror(": type CNAME prohibited"); if (byte_equal(type,2,DNS_T_PTR)) syntaxerror(": type PTR prohibited"); if (byte_equal(type,2,DNS_T_MX)) syntaxerror(": type MX prohibited"); txtparse(&f[2]); rr_start(type,ttl,ttd,loc); rr_add(f[2].s,f[2].len); rr_finish(d1); break; default: syntaxerror(": unrecognized leading character"); } } if (cdb_make_finish(&cdb) == -1) die_datatmp(); if (fsync(fdcdb) == -1) die_datatmp(); if (close(fdcdb) == -1) die_datatmp(); /* NFS stupidity */ if (rename("data.tmp","data.cdb") == -1) strerr_die2sys(111,FATAL,"unable to move data.tmp to data.cdb: "); _exit(0); }
int main() { char ip[4]; unsigned long u; unsigned int j; unsigned int k; char ch; umask(022); fd = open_read("data"); if (fd == -1) strerr_die2sys(111,FATAL,"unable to open data: "); buffer_init(&b,buffer_unixread,fd,bspace,sizeof bspace); fdcdb = open_trunc("data.tmp"); if (fdcdb == -1) die_datatmp(); if (cdb_make_start(&cdb,fdcdb) == -1) die_datatmp(); while (match) { ++linenum; if (getln(&b,&line,&match,'\n') == -1) strerr_die2sys(111,FATAL,"unable to read line: "); while (line.len) { ch = line.s[line.len - 1]; if ((ch != ' ') && (ch != '\t') && (ch != '\n')) break; --line.len; } if (!line.len) continue; switch(line.s[0]) { default: syntaxerror(": unrecognized leading character"); case '#': break; case ':': j = byte_chr(line.s + 1,line.len - 1,':'); if (j >= line.len - 1) syntaxerror(": missing colon"); if (ip4_scan(line.s + 1,ip) != j) syntaxerror(": malformed IP address"); if (!stralloc_copyb(&tmp,ip,4)) nomem(); if (!stralloc_catb(&tmp,line.s + j + 2,line.len - j - 2)) nomem(); if (cdb_make_add(&cdb,"",0,tmp.s,tmp.len) == -1) die_datatmp(); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (!stralloc_0(&line)) nomem(); j = 0; if (!stralloc_copys(&tmp,"")) nomem(); for (;;) { k = scan_ulong(line.s + j,&u); if (!k) break; ch = u; if (!stralloc_catb(&tmp,&ch,1)) nomem(); j += k; if (line.s[j] != '.') break; ++j; } if (!stralloc_catb(&tmp,"\0\0\0\0",4)) nomem(); tmp.len = 4; if (line.s[j] == '/') scan_ulong(line.s + j + 1,&u); else u = 32; if (u > 32) u = 32; ch = u; if (!stralloc_catb(&tmp,&ch,1)) nomem(); if (cdb_make_add(&cdb,tmp.s,tmp.len,"",0) == -1) die_datatmp(); break; } } if (cdb_make_finish(&cdb) == -1) die_datatmp(); if (fsync(fdcdb) == -1) die_datatmp(); if (close(fdcdb) == -1) die_datatmp(); /* NFS stupidity */ if (rename("data.tmp","data.cdb") == -1) strerr_die2sys(111,FATAL,"unable to move data.tmp to data.cdb: "); return 0; }
int main(int argc, char **argv) { int fddata; uint32 loc; //int v; char ipa[4]; //char ipb[4]; //ip4_cidr_t *subnets = (ip4_cidr_t *)NULL; //unsigned int slen = 0; uint32 ipinta = 0U; //unsigned int ipintb = 0; unsigned short mask; uint32 uid = 0; uint32 mid = 0; int i; int j; int k; char ch; unsigned long ttl; char ttd[8]; //uint32 loc; unsigned char keyloc[15]; unsigned long u; char ip[4]; char locp[4]; //char map[9]; char type[2]; char soa[20]; char buf[4]; //int namlen = 0; umask(022); fddata = STDIN_FILENO; if (argc != 3) { fddata = open_read("data"); if (fddata == -1) strerr_die2sys(111,FATAL,"unable to open data: "); if ( (fdcdb = open_trunc("data.tmp")) == -1) die_datatmp(); } else { fddata = STDIN_FILENO; if ( (fdcdb = open_trunc(argv[1])) == -1) die_datatmp(); } defaultsoa_init(fddata); buffer_init(&b,buffer_unixread,fddata,bspace,sizeof bspace); if (cdb_make_start(&cdb,fdcdb) == -1) die_datatmp(); while (match) { ++linenum; if (getln(&b,&line,&match,'\n') == -1) strerr_die2sys(111,FATAL,"unable to read line: "); while (line.len) { ch = line.s[line.len - 1]; if ((ch != ' ') && (ch != '\t') && (ch != '\n')) break; --line.len; } if (!line.len) continue; if (line.s[0] == '#') continue; if (line.s[0] == '-') continue; //write(1,line.s,line.len); //write(1,"\n",1); j = 1; for (i = 0;i < NUMFIELDS;++i) { if (j >= line.len) { if (!stralloc_copys(&f[i],"")) nomem(); } else { k = byte_chr(line.s + j,line.len - j,':'); if (!stralloc_copyb(&f[i],line.s + j,k)) nomem(); j += k + 1; } } switch(line.s[0]) { #ifdef USE_LOCMAPS case '%': //locparse(&f[0],loc); loc = gethash(f[0].s,f[0].len); uint32_pack(locp,loc); if (!stralloc_0(&f[1])) nomem(); if (!stralloc_0(&f[2])) nomem(); ip4_scan(f[1].s,ipa); //ip4_scan(f[2].s,ipb); scan_ushort(f[2].s,&mask); ip4_num(&ipinta,ipa); //ip4_num(&ipintb,ipb); //if (ipintb<ipinta) nomem(); //if (ip4_deaggregate(ipinta,ipintb,&subnets,&slen) <= 0) nomem(); mid = gethash(f[3].s,f[3].len); uid = gethash(f[4].s,f[4].len); //for (v = 0; v < slen; v++) { ipdb_key4build(keyloc,ipinta,(unsigned char )mask&0xff,mid,uid); //ipdb_key_from_uint(keyloc,ipinta,(unsigned char )mask&0xff,0,mid,uid); cdb_make_add(&cdb,keyloc,15,locp,4); //} uid = 0; //alloc_free(subnets); //subnets = NULL; //slen = 0; byte_zero(ipa,4);ipinta=0; //byte_zero(ipb,4);ipinta=0;ipintb=0; break; #endif case 'Z': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[3])) nomem(); if (!scan_ulong(f[3].s,&u)) uint32_unpack_big(defaultsoa,&u); uint32_pack_big(soa,u); if (!stralloc_0(&f[4])) nomem(); if (!scan_ulong(f[4].s,&u)) uint32_unpack_big(defaultsoa + 4,&u); uint32_pack_big(soa + 4,u); if (!stralloc_0(&f[5])) nomem(); if (!scan_ulong(f[5].s,&u)) uint32_unpack_big(defaultsoa + 8,&u); uint32_pack_big(soa + 8,u); if (!stralloc_0(&f[6])) nomem(); if (!scan_ulong(f[6].s,&u)) uint32_unpack_big(defaultsoa + 12,&u); uint32_pack_big(soa + 12,u); if (!stralloc_0(&f[7])) nomem(); if (!scan_ulong(f[7].s,&u)) uint32_unpack_big(defaultsoa + 16,&u); uint32_pack_big(soa + 16,u); if (!stralloc_0(&f[8])) nomem(); if (!scan_ulong(f[8].s,&ttl)) ttl = TTL_NEGATIVE; ttdparse(&f[9],ttd); loc = gethash(f[10].s,f[10].len); mid = gethash(f[11].s,f[11].len); uid = gethash(f[12].s,f[12].len); rr_addloq(DNS_T_SOA,d1,loc,mid,uid); rr_start(DNS_T_SOA,ttl,ttd,loc); if (!dns_domain_fromdot(&d2,f[1].s,f[1].len)) nomem(); rr_addname(d2); if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem(); rr_addname(d2); rr_add(soa,20); rr_finish(d1); break; case '.': case '&': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[3])) nomem(); if (!scan_ulong(f[3].s,&ttl)) ttl = TTL_NS; ttdparse(&f[4],ttd); loc = gethash(f[5].s,f[5].len); mid = gethash(f[6].s,f[6].len); uid = gethash(f[7].s,f[7].len); if (!stralloc_0(&f[1])) nomem(); if (byte_chr(f[2].s,f[2].len,'.') >= f[2].len) { if (!stralloc_cats(&f[2],".ns.")) nomem(); if (!stralloc_catb(&f[2],f[0].s,f[0].len)) nomem(); } if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem(); if (line.s[0] == '.') { rr_start(DNS_T_SOA,ttl ? TTL_NEGATIVE : 0,ttd,loc); rr_addloq(DNS_T_SOA,d1,loc,mid,uid); rr_addname(d2); rr_add("\12hostmaster",11); rr_addname(d1); rr_add(defaultsoa,20); rr_finish(d1); } rr_start(DNS_T_NS,ttl,ttd,loc); rr_addname(d2); rr_addloq(DNS_T_NS,d2,loc,mid,uid); rr_finish(d1); if (ip4_scan(f[1].s,ip)) { rr_start(DNS_T_A,ttl,ttd,loc); rr_addloq(DNS_T_A,d2,loc,mid,uid); rr_add(ip,4); rr_finish(d2); } break; case '+': case '=': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[2])) nomem(); if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE; ttdparse(&f[3],ttd); loc = gethash(f[4].s,f[4].len); mid = gethash(f[5].s,f[5].len); uid = gethash(f[6].s,f[6].len); if (!stralloc_0(&f[1])) nomem(); if (ip4_scan(f[1].s,ip)) { rr_addloq(DNS_T_A,d1,loc,mid,uid); rr_start(DNS_T_A,ttl,ttd,loc); //dbger("+addloq:d=%s,loc=%u,uid=%u,mid=%u",d1,loc,uid,mid); rr_add(ip,4); rr_finish(d1); if (line.s[0] == '=') { rr_addloq(DNS_T_PTR,d1,loc,mid,uid); //??????????????????/ TODO: checkthis dns_name4_domain(dptr,ip); rr_start(DNS_T_PTR,ttl,ttd,loc); rr_addname(d1); rr_finish(dptr); } } break; case '@': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[4])) nomem(); if (!scan_ulong(f[4].s,&ttl)) ttl = TTL_POSITIVE; ttdparse(&f[5],ttd); loc = gethash(f[6].s,f[6].len); mid = gethash(f[7].s,f[7].len); uid = gethash(f[8].s,f[8].len); if (!stralloc_0(&f[1])) nomem(); if (byte_chr(f[2].s,f[2].len,'.') >= f[2].len) { if (!stralloc_cats(&f[2],".mx.")) nomem(); if (!stralloc_catb(&f[2],f[0].s,f[0].len)) nomem(); } if (!dns_domain_fromdot(&d2,f[2].s,f[2].len)) nomem(); if (!stralloc_0(&f[3])) nomem(); if (!scan_ulong(f[3].s,&u)) u = 0; rr_addloq(DNS_T_MX,d1,loc,mid,uid); rr_start(DNS_T_MX,ttl,ttd,loc); uint16_pack_big(buf,u); rr_add(buf,2); rr_addname(d2); rr_finish(d1); if (ip4_scan(f[1].s,ip)) { rr_addloq(DNS_T_A,d2,loc,mid,uid); rr_start(DNS_T_A,ttl,ttd,loc); rr_add(ip,4); rr_finish(d2); } break; case '^': case 'C': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!dns_domain_fromdot(&d2,f[1].s,f[1].len)) nomem(); if (!stralloc_0(&f[2])) nomem(); if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE; ttdparse(&f[3],ttd); loc = gethash(f[4].s,f[4].len); mid = gethash(f[5].s,f[5].len); uid = gethash(f[6].s,f[6].len); if (line.s[0] == 'C') { //rr_addloq(DNS_T_CNAME,d1,loc,mid,uid); //dbger("add loq for cname!"); rr_addloq(DNS_T_A,d1,loc,mid,uid); rr_addloq(DNS_T_CNAME,d1,loc,mid,uid); rr_start(DNS_T_CNAME,ttl,ttd,loc); } else { rr_addloq(DNS_T_PTR,d1,loc,mid,uid); rr_start(DNS_T_PTR,ttl,ttd,loc); } rr_addname(d2); rr_finish(d1); break; case '\'': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[2])) nomem(); if (!scan_ulong(f[2].s,&ttl)) ttl = TTL_POSITIVE; ttdparse(&f[3],ttd); loc = gethash(f[4].s,f[4].len); mid = gethash(f[5].s,f[5].len); uid = gethash(f[6].s,f[6].len); rr_addloq(DNS_T_TXT,d1,loc,mid,uid); rr_start(DNS_T_TXT,ttl,ttd,loc); txtparse(&f[1]); i = 0; while (i < f[1].len) { k = f[1].len - i; if (k > 127) k = 127; ch = k; rr_add(&ch,1); rr_add(f[1].s + i,k); i += k; } rr_finish(d1); break; case ':': if (!dns_domain_fromdot(&d1,f[0].s,f[0].len)) nomem(); if (!stralloc_0(&f[3])) nomem(); if (!scan_ulong(f[3].s,&ttl)) ttl = TTL_POSITIVE; ttdparse(&f[4],ttd); loc = gethash(f[5].s,f[5].len); mid = gethash(f[6].s,f[6].len); uid = gethash(f[7].s,f[7].len); if (!stralloc_0(&f[1])) nomem(); scan_ulong(f[1].s,&u); uint16_pack_big(type,u); if (byte_equal(type,2,DNS_T_AXFR)) syntaxerror(": type AXFR prohibited"); if (byte_equal(type,2,"\0\0")) syntaxerror(": type 0 prohibited"); if (byte_equal(type,2,DNS_T_SOA)) syntaxerror(": type SOA prohibited"); if (byte_equal(type,2,DNS_T_NS)) syntaxerror(": type NS prohibited"); if (byte_equal(type,2,DNS_T_CNAME)) syntaxerror(": type CNAME prohibited"); if (byte_equal(type,2,DNS_T_PTR)) syntaxerror(": type PTR prohibited"); if (byte_equal(type,2,DNS_T_MX)) syntaxerror(": type MX prohibited"); txtparse(&f[2]); rr_addloq(type,d1,loc,mid,uid); rr_start(type,ttl,ttd,loc); rr_add(f[2].s,f[2].len); rr_finish(d1); break; default: dienow("error here: %s\n", line.s); syntaxerror(": unrecognized leading character"); } } if (cdb_make_finish(&cdb) == -1) die_datatmp(); if (fsync(fdcdb) == -1) die_datatmp(); if (close(fdcdb) == -1) die_datatmp(); /* NFS stupidity */ if (argc == 3) { if (rename(argv[1],argv[2]) == -1) strerr_die2sys(111,FATAL,"unable to move data.tmp to data.cdb: "); } else { if (rename("data.tmp","data.cdb") == -1) strerr_die2sys(111,FATAL,"unable to move data.tmp to data.cdb: "); } _exit(0); }