int symcopy(struct sym *from, struct sym *to, struct allocator *al) { iter_t iter; void *key, *data; to->flags = from->flags & 0xFFFF; to->idl_type = dupstr(from->idl_type, al); to->ndr_type = dupstr(from->ndr_type, al); to->interface = from->interface; hashmap_iterate(&from->attrs, &iter); while ((key = hashmap_next(&from->attrs, &iter))) { if ((data = hashmap_get(&from->attrs, key)) == NULL || hashmap_put(&to->attrs, key, data) == -1) { AMSG(""); return -1; } } linkedlist_iterate(&from->mems, &iter); while ((data = linkedlist_next(&from->mems, &iter))) { if (linkedlist_add(&to->mems, data) == -1) { AMSG(""); return -1; } } to->name = dupstr(from->name, al); to->value = dupstr(from->value, al); to->ptr = from->ptr; to->align = from->align; return 0; }
void freeStuff() { iter_t iter; Expr el; linkedlist_iterate(&exprPool, &iter); while ((el = linkedlist_next(&exprPool, &iter))){ vc_deleteExpr(el); } linkedlist_clear(&exprPool, NULL, NULL); }
void freeStuff() { iter_t iter; char* varname; hashmap_iterate(&vars, &iter); while ((varname = (char*) hashmap_next(&vars, &iter))) free(varname); hashmap_clear(&vars, NULL, NULL, NULL); Expr el; linkedlist_iterate(&exprPool, &iter); while ((el = linkedlist_next(&exprPool, &iter))){ vc_deleteExpr(el); } linkedlist_clear(&exprPool, NULL, NULL); }
struct sym * get_descriminant(struct sym *u) { const char *switch_is = hashmap_get(&u->attrs, "switch_is"); iter_t iter; struct sym *mem; linkedlist_iterate(&u->parent->mems, &iter); while ((mem = linkedlist_next(&u->parent->mems, &iter))) { if (ident_index(switch_is, mem->name)) { return mem; } } return NULL; }
int print_tree(struct idl *idl, struct sym *sym, int indent) { char buf[1024]; iter_t iter; struct sym *mem; sprint_sym(buf, sym, indent, 14); fputs(buf, stderr); if (*buf) fputc('\n', stderr); linkedlist_iterate(&sym->mems, &iter); while ((mem = linkedlist_next(&sym->mems, &iter))) { print_tree(idl, mem, indent + 2); } return 0; }
int inherit_iface(struct idl *idl, struct sym *sym, char *name) { iter_t iter; struct sym *mem; if (!sym->interface) { sym->interface = name; } if (strcmp(idl->interface, sym->interface) != 0) { sym->flags |= FLAGS_IMPORTED; } linkedlist_iterate(&sym->mems, &iter); while ((mem = linkedlist_next(&sym->mems, &iter))) { if (inherit_iface(idl, mem, name) == -1) { AMSG(""); return -1; } } return 0; }
int symresolve(struct idl *idl, struct sym *sym) { struct sym *s; char *key; iter_t iter; int align; size_t size; s = symlook(idl, sym->idl_type); if (s) { /* merge stuff */ sym->flags |= s->flags & 0xFFFF; sym->ndr_type = s->ndr_type; if (sym->ptr && (!IS_PRIMATIVE(sym) || hashmap_get(&sym->attrs, "string"))) { sym->ndr_size = 4; } else { sym->ndr_size = s->ndr_size; } sym->align = sym->ptr ? 4 : sym->ndr_size; /* inherit attributes */ hashmap_iterate(&s->attrs, &iter); while ((key = hashmap_next(&s->attrs, &iter))) { /* Only add attributes that the symbol does not have already */ if (hashmap_get(&sym->attrs, key) == NULL) { char *data; data = hashmap_get(&s->attrs, key); hashmap_put(&sym->attrs, key, data); } } if (sym->out_type == NULL) { if (s->out_type) { sym->out_type = s->out_type; } else if (IS_TYPEDEFD(sym)) { sym->out_type = sym->idl_type = sym->name; } else if (strncmp(sym->idl_type, "struct ", 7) == 0 || strncmp(sym->idl_type, "union ", 6) == 0) { char buf[255]; if (*sym->idl_type == 's') { sprintf(buf, "struct_%s", sym->idl_type + 7); } else { sprintf(buf, "union_%s", sym->idl_type + 7); } sym->out_type = dupstr(buf, idl->al); } if ((strcmp(idl->type, "java") == 0 || strcmp(idl->type, "jcifs") == 0) && IS_IMPORTED(sym)) { char buf[255]; sprintf(buf, "%s.%s", sym->interface, sym->out_type); sym->out_type = dupstr(buf, idl->al); } } } align = 0; size = 0; linkedlist_iterate(&sym->mems, &iter); while ((s = linkedlist_next(&sym->mems, &iter))) { size_t msiz, mali, m; symresolve(idl, s); if (s->align > align) { align = s->align; } if (s->ptr) { msiz = mali = 4; } else { msiz = s->ndr_size; mali = s->align; } m = mali - 1; size = (size + m) & ~m; /* align the type */ s->offset = size; if (IS_ENUM(sym)) { size = msiz; /* size only size of member not sum of mems */ } else if (IS_UNION(sym)) { /* size is largest of mems (not really used for any logic so far) */ if (msiz > size) { size = msiz; } } else { size += msiz; /* and size of type */ } } if (align) { sym->align = align; } if (size) { sym->ndr_size = size; } /* check array conformance */ hashmap_iterate(&sym->attrs, &iter); while ((key = hashmap_next(&sym->attrs, &iter))) { if (!IS_FIXED(sym) && (strcmp(key, "size_is") == 0 || strcmp(key, "max_is") == 0)) { sym->flags |= FLAGS_CONFORMANT; break; } } if (IS_PRIMATIVE(sym)) { if (!IS_OPERATION(sym)) { sym->interface = NULL; } sym->flags &= ~FLAGS_IMPORTED; } return 0; }
int symexpand(struct idl *idl, struct sym *sym) { char *key; struct sym *mem; iter_t iter; if (IS_EXPANDED(sym)) { return 0; } sym->flags |= FLAGS_EXPANDED; sym->orig = sym; if (IS_INTERFACE(sym)) { const char *pd = hashmap_get(&sym->attrs, "pointer_default"); idl->ptr_default = PTR_TYPE_UNIQUE; if (pd) { if (strcmp(pd, "ptr") == 0) { idl->ptr_default = PTR_TYPE_PTR; } else if (strcmp(pd, "ref") == 0) { idl->ptr_default = PTR_TYPE_REF; } } } else if (IS_ENUM(sym)) { char buf[16]; int val = 0; linkedlist_iterate(&sym->mems, &iter); while ((mem = linkedlist_next(&sym->mems, &iter))) { mem->flags = FLAGS_CONST | FLAGS_PRIMATIVE; if (mem->value) { val = strtoul(mem->value, NULL, 0); } sprintf(buf, "%d", val++); mem->value = dupstr(buf, idl->al); } } else if (sym->ptr) { if (hashmap_get(&sym->attrs, "unique")) { sym->ptr_type = PTR_TYPE_UNIQUE; } else if (hashmap_get(&sym->attrs, "ptr")) { sym->ptr_type = PTR_TYPE_PTR; } else if (hashmap_get(&sym->attrs, "ref")) { sym->ptr_type = PTR_TYPE_REF; } else if (IS_PARAMETER(sym) || IS_OPERATION(sym)) { sym->ptr_type = PTR_TYPE_REF; } else { sym->ptr_type = idl->ptr_default; } } /* If the symbol is typedef'd add it to the table using the * typedef'd name too */ if (IS_TYPEDEFD(sym) && sym->name) { if (IS_ENUM(sym) && (mem = hashmap_get(idl->syms, sym->idl_type))) { mem->noemit = 1; /* supress redundant enum */ } key = sym->name; } else { key = sym->idl_type; } if (hashmap_get(idl->syms, key) == NULL) { if (hashmap_put(idl->syms, key, sym) == -1) { AMSG(""); } } /* If the symbol has members it is already expanded */ if (linkedlist_size(&sym->mems) == 0) { struct sym *s = symlook(idl, sym->idl_type); if (s) { sym->interface = s->interface; linkedlist_iterate(&s->mems, &iter); while ((mem = linkedlist_next(&s->mems, &iter))) { struct sym *cpy = symnew(idl->al); symcopy(mem, cpy, idl->al); linkedlist_add(&sym->mems, cpy); } } else { AMSG(""); return -1; } } sym->id = idl->symid++; /* Perform expansion recursively on all symbols */ linkedlist_iterate(&sym->mems, &iter); while ((mem = linkedlist_next(&sym->mems, &iter))) { symexpand(idl, mem); mem->parent = sym; } return 0; }
int main(int argc, char **argv) { int exit_code=0; CERBFIG* cer_config=NULL; // linked list to store the messages in struct linkedlist* messages=NULL; CXMLROOT* xml_root=NULL; CFILE* file=NULL; CFSYS* cfsys=NULL; // log struct CLOG_INFO* log=NULL; #ifdef MEMWATCH EF_ALIGNMENT=1; EF_PROTECT_BELOW=1; EF_PROTECT_FREE=1; #endif // memory checking // mtrace(); // ########################################################################## // ############=- CHECK CMD LINE PARAMETERS -=############################### // ########################################################################## // start the logging so we can log! if( !(argc==4) ) { fprintf(stderr, "\nUsage:\n%.80s xml_config_file log_level log.txt \n\n", argv[0]); } // ########################################################################## // ############=- Run Test Suite -=########################################## // ########################################################################## #ifndef NOTEST if(1==argc) { CuString *output = CuStringNew(); CuSuite* suite = CuSuiteNew(); printf("Running Test Suite\n"); CuSuiteAddSuite(suite, CuGetSuite()); CuSuiteAddSuite(suite, CuStringGetSuite()); CuSuiteAddSuite(suite, TestSuite__cstring()); CuSuiteAddSuite(suite, TestSuite__cfile()); CuSuiteAddSuite(suite, TestSuite__cxml()); // CuSuiteAddSuite(suite, TestSuite__cmime()); CuSuiteRun(suite); CuSuiteSummary(suite, output); CuSuiteDetails(suite, output); printf("%s\n", output->buffer); CuStringFree(output); CuSuiteFree(suite); return EX_USAGE; } #endif log = clog_open(argv[3], clog_getlevel(argv[2]), NULL, 0); // if we couldn't log to the file, let's log to stderr! if(NULL!=log && NULL==log->s_logfile) { clog_setcallback(log, clog_stderr); clog_setcallbacklevel(log, clog_getlevel(argv[2])); clog(log, CERROR, "Could not log to file, logging to stderr!"); } clog(log, CMARK, "Cerberus v. 2.x build %s Starting", BUILDNUMBER); clog(log, CDEBUG, "CMDLINE: Command line: %.80s %.80s %.80s", argv[0], argv[1], argv[2]); clog(log, CDEBUG, "CMDLINE: Command line arguments check passed"); clog(log, CMARK, "Cerberus Starting..."); // ########################################################################## // ############=- LOAD XML CONFIG FILE -=#################################### // ########################################################################## // parse the XML now clog(log, CDEBUG, "XML: Starting XML config file parsing"); clog(log, CDEBUG, "XML: Creating XML DOM Variable"); xml_root = cxml_root_new(log); clog(log, CDEBUG, "XML: XML DOM Variable Created"); // make a new cer filesystem obj cfsys = cfile_init(0); cer_config = malloc(sizeof(CERBFIG)); memset(cer_config, 0, sizeof(CERBFIG)); cer_config->cfsys = cfsys; exit_code = cer_load_config(log, &xml_root, argv[1], &cer_config); // ########################################################################## // ################=- READ IN FILES -=####################################### // ########################################################################## if(0==exit_code) { CPOP3* pop3 = NULL; char *filename = NULL; messages = linkedlist_new(0); // if there is something in the list, process via pop3 if(NULL!=cer_config->poplist) { exit_code = cer_curl_init(log, &cer_config, cer_config->curl_location); clog(log, CMARK, "Parser is in POP3 mode."); while(NULL!=(pop3=linkedlist_remove_last(cer_config->poplist))) { if(0==exit_code) { if(NULL!=pop3->user && NULL!=pop3->pass) { if(0==cpop3_connect(log, pop3)){ if(0==cpop3_user(log, pop3, pop3->user)) { if(0==cpop3_pass(log, pop3, pop3->pass)) { int x=0; int y=0; x = cpop3_stat(log, pop3); while(y<x && y<cer_config->pop3_max) { if(NULL!=(filename = cpop3_retr(log, pop3, cer_config->tmp_cerbmail->string))) { int pid = 0; linkedlist_add(messages, filename); pid = cer_fork(); if(-1==pid) { clog(log, CDEBUG, "FORK: Could not fork, running straight through"); // if we couldn't fork run the parser and risk killing entire process exit_code = cer_parse_files(log, &cer_config, xml_root, &messages); if(pop3->dele) { if(1==cer_config->pop3_max_delete) { cpop3_dele(log, pop3); } else if(0==exit_code) { cpop3_dele(log, pop3); } } } else if(0==pid) { clog(log, CDEBUG, "FORK: Forked, running file parser"); exit_code = cer_parse_files(log, &cer_config, xml_root, &messages); if(pop3->dele) { if(1==cer_config->pop3_max_delete) { cpop3_dele(log, pop3); } else if(0==exit_code) { cpop3_dele(log, pop3); } } // didn't send quit, just close the fork'd connection cpop3_disconnect(log, pop3); cpop3_free(log, &pop3); // remove the emails from the list that we've processed linkedlist_iterate(messages); while(NULL!=(filename=linkedlist_remove_last(messages))) { free(filename); filename = NULL; } linkedlist_del(cer_config->poplist, free); linkedlist_del(messages, free); goto CLEANUP; } else { // must be the parent process // clean up any forked children that are sitting around clog(log, CDEBUG, "FORK: Forked, am parent waiting for child process"); while(0<(pid=cer_wait4(0, NULL, 0, NULL))) { clog(log, CDEBUG, "WAIT: cleaned up after child %d!", pid); }; } // remove the emails from the list that we've processed linkedlist_iterate(messages); while(NULL!=(filename=linkedlist_remove_last(messages))) { free(filename); filename = NULL; } } ++y; } } } cpop3_quit(log, pop3); cpop3_disconnect(log, pop3); } } else { clog(log, CERROR, "POP3: User or Password was NULL, skipping"); } } cpop3_free(log, &pop3); } linkedlist_del(cer_config->poplist, free); } // otherwise it's stdin else { clog(log, CMARK, "Parser is in PIPE mode, waiting for input"); file = cer_save_input(log, cfsys, cer_config->tmp_cerbmail->string); if(NULL!=file) { filename = strdup(file->filename); linkedlist_add(messages, filename); cfile_close(&file); cfile_free(&file); exit_code = cer_curl_init(log, &cer_config, cer_config->curl_location); if(0==exit_code) { exit_code = cer_parse_files(log, &cer_config, xml_root, &messages); } } } // free the linked list linkedlist_del(messages, free); } // this is above cleanup to keep the forks from clobbering each other cfile_cleanup(&cfsys); CLEANUP: if(NULL!=dl_curl_easy_cleanup) { // clean up the info in cURL dl_curl_easy_cleanup(cer_config->curl); } if(NULL!=dl_curl_global_cleanup) { // close down curl dl_curl_global_cleanup(); } #ifndef WIN32 if(NULL!=dl_curl) { dlclose(dl_curl); dl_curl=NULL; } #endif dl_curl = NULL; dl_curl_formadd=NULL; dl_curl_formfree=NULL; dl_curl_global_init=NULL; dl_curl_easy_init=NULL; dl_curl_easy_setopt=NULL; dl_curl_easy_perform=NULL; dl_curl_easy_cleanup=NULL; dl_curl_global_cleanup=NULL; // free the xml data cxml_root_free(log, &xml_root); if(NULL!=cer_config->xsp) cstring_free(&cer_config->xsp); cstring_free(&cer_config->curl_location); cstring_free(&cer_config->tmp_cerbmail); cstring_free(&cer_config->tmp_cerbmime); // free the optional SSL data cstring_free(&cer_config->curl_cainfo); cstring_free(&cer_config->curl_capath); cer_config->curl_verifyhostpeer = 0; clog(log, CMARK, "Shutting Down"); // close the log file clog_close(log); free(cer_config); cer_config=NULL; return exit_code; }
static int run(int argc, char **argv, const char *filename, const char *outname, const char *type, const char *symtabpath, struct hashmap *macros, int verbose) { struct idl idl; struct sym iface; unsigned char _outname[PATH_MAX]; memset(&idl, 0, sizeof(idl)); idl.argc = argc; idl.argv = argv; idl.type = type; idl.macros = macros; idl.verbose = verbose; idl.al = NULL; if ((idl.syms = hashmap_new(hash_str, cmp_str, NULL, idl.al)) == NULL || (idl.consts = hashmap_new(hash_str, cmp_str, NULL, idl.al)) == NULL || (idl.tmp = hashmap_new(hash_str, cmp_str, NULL, idl.al)) == NULL) { AMSG(""); return -1; } if (symload(&idl, symtabpath) == -1) { if (errno != ENOENT || symload(&idl, path_filename(symtabpath)) == -1) { AMSG(""); return -1; } } /* generate parse tree in iface */ syminit(&iface, idl.al); if (idl_process_file(&idl, filename, &iface) == -1) { AMSG(""); return -1; } if (idl.verbose > 1) { print_tree(&idl, &iface, 0); /* print everything */ } else if (idl.verbose) { iter_t iter; struct sym *mem; linkedlist_iterate(&iface.mems, &iter); while ((mem = linkedlist_next(&iface.mems, &iter))) { if (IS_OPERATION(mem) == 0) { continue; } print_tree(&idl, mem, 0); /* only print operations and their params */ } } if (idl.verbose) fprintf(stderr, " No Flg Type Ptr Name OutType NdrType Siz Aln Off Attributes\n"); mkoutname(_outname, outname ? outname : filename, ""); idl.outname = dupstr(path_filename(_outname), NULL); if (strcmp(type, "jcifs") == 0) { mkoutname(_outname, outname ? outname : filename, ".java"); if (run_one(&idl, &iface, _outname, emit_stub_jcifs) == -1) { AMSG(""); return -1; } } else if (strcmp(type, "java") == 0) { mkoutname(_outname, outname ? outname : filename, ".java"); if (run_one(&idl, &iface, _outname, emit_stub_java) == -1) { AMSG(""); return -1; } } else if (*type == 's') { mkoutname(_outname, outname ? outname : filename, ".c"); if (run_one(&idl, &iface, _outname, emit_stub_samba) == -1) { AMSG(""); return -1; } } else if (*type == 'c') { mkoutname(_outname, outname ? outname : filename, ".h"); if (run_one(&idl, &iface, _outname, emit_hdr_c) == -1) { AMSG(""); return -1; } mkoutname(_outname, outname ? outname : filename, "_s.c"); if (run_one(&idl, &iface, _outname, emit_svr_stub_c) == -1) { AMSG(""); return -1; } mkoutname(_outname, outname ? outname : filename, "_c.c"); } return 0; }
int LinkedlistExercise(int verbose, struct cfg *cfg, char *args[]) { int rate, i, n = 0, idx; char *str; struct linkedlist *l = linkedlist_new(EXERCISE_MED_COUNT, NULL); cfg = NULL; args[0] = NULL; if (l == NULL) { AMSG(""); return -1; } rate = EXERCISE_R0; for (i = 0; i < EXERCISE_MED_COUNT; i++) { if (i == EXERCISE_MED_P1) { rate = EXERCISE_R1; } else if (i == EXERCISE_MED_P2) { rate = EXERCISE_R2; } else if (i == EXERCISE_MED_P3) { rate = EXERCISE_R3; } if (rand() % 10 < rate) { idx = 0; str = malloc(8); sprintf(str, "%07d", n++); if (rand() % 5) { idx = linkedlist_size(l); if (idx) { idx = rand() % idx; } } if (linkedlist_insert(l, idx, str) == -1) { PMNO(errno); return -1; } tcase_printf(verbose, "INSERT: %s size now %d\n", str, linkedlist_size(l)); } else { if (linkedlist_is_empty(l)) { tcase_printf(verbose, "EMPTY\n"); } else { idx = rand() % linkedlist_size(l); str = linkedlist_get(l, idx); if (linkedlist_remove_data(l, str) == NULL) { PMNO(errno); return -1; } if ((idx % 10) == 0) { unsigned int count = 0; iter_t iter; linkedlist_iterate(l, &iter); while (linkedlist_next(l, &iter)) { count++; } if (count != linkedlist_size(l)) { PMSG("count=%u,linkedlist_size=%u\n", count, linkedlist_size(l)); return -1; } } if (str) { tcase_printf(verbose, "REMOVE: %s %d\n", str, linkedlist_size(l)); free(str); } else { PMSG("remove failure"); return -1; } } } } linkedlist_del(l, allocator_free, NULL); return 0; }