KVServer::KVServer() { // Initialize our hash table MallocFactory* mf = standard_malloc_factory_init(); hash_table_init(&db, mf, hash, cmp); // Create the server's socket sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (sock == -1) { fprintf(stderr, "(KeyValueServer) Failed to open server socket!\n"); exit(1); } bzero((char*)&server_addr, sizeof(server_addr)); server_addr.sin_family = AF_INET; server_addr.sin_port = htons(KEYVAL_PORT); server_addr.sin_addr.s_addr = htonl(INADDR_ANY); if (bind(sock, (sockaddr*)&server_addr, sizeof(server_addr)) == -1) { fprintf(stderr, "(KeyValueServer) Failed to bind server socket!\n"); exit(1); } }
hash_table_t * load_alts(const char * path, size_t hs, char a[][BUFSIZ]) { char buffer[BUFSIZ]; FILE * alts_file; hash_table_t * hash_table; uint32_t i, j, k; hash_table = hash_table_init(hs); alts_file = fopen(path, "r"); for (i = 0; i < NUMA; i++) { fgets(buffer, BUFSIZ, alts_file); char * key = malloc(BUFSIZ); char * val = malloc(BUFSIZ); memset(key, '\0', BUFSIZ); memset(val, '\0', BUFSIZ); for (j = 0; j < BUFSIZ; j++) { if (buffer[j] == ',') { key[j] = '\0'; break; } key[j] = buffer[j]; } for (k = j + 1; k < BUFSIZ; k++) { if (buffer[k] == '\n') { val[k-j-1] = '\0'; break; } val[k-j-1] = buffer[k]; if (buffer[k] == '\0') break; } snprintf(a[i], BUFSIZ, "%s", key); key_val_t * kv = make_kv(key, strlen(key)+1, val, strlen(val)+1); hash_table_insert(hash_table, kv); free(kv); } fclose(alts_file); return hash_table; }
int pkg_hash_init(const char *name, hash_table_t *hash, int len) { return hash_table_init(name, hash, len); }
int main(int argc, char **argv) { int n, a, b, choice, ris, i, j; int *path; char tmp1[MAX_STR], tmp2[MAX_STR]; Hash_table ht; Graph g; FILE *fp; if(argc < 2){ fprintf(stderr, "Parameters error!\nUsage: %s <input file>\n", argv[0]); return -1; } if((fp=fopen(argv[1], "r")) == NULL){ fprintf(stderr, "Can't open file %s\n", argv[1]); return -2; } fscanf(fp, "%d", &n); ht = hash_table_init(n); g = graph_init(n); while(fscanf(fp, "%s %s", tmp1, tmp2) == 2) { if((a = hash_table_get(ht, tmp1)) == -1) a = hash_table_insert(ht, tmp1); if((b = hash_table_get(ht, tmp2)) == -1) b = hash_table_insert(ht, tmp2); graph_insert(g, create_edge(a,b)); } fclose(fp); printf( "===== G R A P H =====\n" "1 - Shortest simple path between two nodes\n" "2 - Longest simple path between two nodes\n" "3 - Number of all simple paths between two nodes\n" "4 - Show strong connected nodes\n" "5 - Show edges to strong connect the graph\n" "6 - Exit\n"); do{ printf("\nChoice: "); scanf("%d", &choice); switch(choice) { case 1: printf("Start node: "); scanf("%s", tmp1); printf("End node: "); scanf("%s", tmp2); if(hash_table_get(ht, tmp1) != -1 && hash_table_get(ht, tmp2) != -1) { ris = graph_get_shortest_path(g, hash_table_get(ht, tmp1), hash_table_get(ht, tmp2), &path); if(ris > 0) { printf("\nDistance = %d\n\nPath:\n", ris); for(i=0; i<=ris; i++) printf("%s\n", hash_table_get_name(ht, path[i])); free(path); } else printf("There is no path between these two nodes\n"); } else printf("Error, inexistent nodes\n"); break; case 2: printf("Start node: "); scanf("%s", tmp1); printf("End node: "); scanf("%s", tmp2); if(hash_table_get(ht, tmp1) != -1 && hash_table_get(ht, tmp2) != -1) { ris = graph_get_longest_path(g, hash_table_get(ht, tmp1), hash_table_get(ht, tmp2), &path); if(ris > 0) { printf("\nDistance = %d\n\nPath:\n", ris); for(i=0; i<=ris; i++) printf("%s\n", hash_table_get_name(ht, path[i])); free(path); } else printf("There is no path between these two nodes\n"); } else printf("Error, inexistent nodes\n"); break; case 3: printf("Start node: "); scanf("%s", tmp1); printf("End node: "); scanf("%s", tmp2); if(hash_table_get(ht, tmp1) != -1 && hash_table_get(ht, tmp2) != -1) printf("Number of simple paths: %d\n", graph_number_of_simple_path(g, hash_table_get(ht, tmp1), hash_table_get(ht, tmp2))); else printf("Error, inexistent nodes\n"); break; case 4: path = graph_get_scc(g); //for every scc group for(i=0; i<n; i++) { a = 0; //counter for(j=0; j<n; j++) if(path[j] == i) { printf("%s\n", hash_table_get_name(ht, j)); a++; } if(a != 0) printf("============\n"); else break; } break; } }while(choice != 6); hash_table_destroy(ht); graph_destroy(g); return 0; }
int main(int argc, char **argv) { int c; /* command line arg */ int server_s; /* boa socket */ /* set umask to u+rw, u-x, go-rwx */ c = umask(~0600); if (c == -1) { perror("umask"); exit(1); } devnullfd = open("/dev/null", 0); /* make STDIN and STDOUT point to /dev/null */ if (devnullfd == -1) { DIE("can't open /dev/null"); } #if 0 if (dup2(devnullfd, STDIN_FILENO) == -1) { DIE("can't dup2 /dev/null to STDIN_FILENO"); } if (dup2(devnullfd, STDOUT_FILENO) == -1) { DIE("can't dup2 /dev/null to STDOUT_FILENO"); } #endif /* but first, update timestamp, because log_error_time uses it */ (void) time(¤t_time); while ((c = getopt(argc, argv, "c:r:d")) != -1) { switch (c) { case 'c': if (server_root) free(server_root); server_root = strdup(optarg); if (!server_root) { perror("strdup (for server_root)"); exit(1); } break; case 'r': if (chdir(optarg) == -1) { log_error_time(); perror("chdir (to chroot)"); exit(1); } if (chroot(optarg) == -1) { log_error_time(); perror("chroot"); exit(1); } if (chdir("/") == -1) { log_error_time(); perror("chdir (after chroot)"); exit(1); } break; case 'd': do_fork = 1; break; default: fprintf(stderr, "Usage: %s [-c serverroot] [-r chroot] [-d] [-b] [-q bitrate]\n", argv[0]); exit(1); } } #ifdef DAVINCI_IPCAM if(ApproDrvInit(BOA_MSG_TYPE) < 0){ exit(1); } //printf("func_get_mem Begin\n"); if (func_get_mem(NULL)) { ApproDrvExit(); exit(1); } //printf("SysDrvInit Begin\n"); if(SysDrvInit(SYS_BOA_MSG) < 0){ ApproDrvExit(); exit(1); } //printf("InitFileMsgDrv Begin\n"); if (InitFileMsgDrv(FILE_MSG_KEY, FILE_BOA_MSG) < 0) { ApproDrvExit(); SysDrvExit(); exit(1); } //printf("hash_table_init Begin\n"); if (hash_table_init() < 0) { exit(1); } //printf("arg_hash_table_init Begin\n"); if(arg_hash_table_init() < 0) { exit(1); } //printf("uri_hash_table_init Begin\n"); if(uri_hash_table_init() < 0) { exit(1); } #endif #ifdef PSIA_MEDIA //printf("psia_uri_hash_table_init Begin\n"); if(psia_uri_hash_table_init() < 0) { exit(1); } #endif //printf("fixup_server_root Begin\n"); fixup_server_root(); printf("read_config_files Begin\n"); read_config_files(); #ifdef DAVINCI_IPCAM { //printf("ControlSystemData Begin\n"); unsigned short value; #if 1 if (ControlSystemData(SFIELD_GET_HTTPPORT, (void *)&value, sizeof(value)) >= 0) server_port = value; #endif dbg("server_port=%d\n", server_port); } #endif open_logs(); server_s = create_server_socket(); init_signals(); drop_privs(); create_common_env(); build_needs_escape(); if (max_connections < 1) { struct rlimit rl; /* has not been set explicitly */ c = getrlimit(RLIMIT_NOFILE, &rl); if (c < 0) { perror("getrlimit"); exit(1); } max_connections = rl.rlim_cur; } /* background ourself */ if (do_fork) { switch(fork()) { case -1: /* error */ perror("fork"); exit(1); break; case 0: /* child, success */ break; default: /* parent, success */ exit(0); break; } } /* Ask system server to start upnp */ //system("/opt/dvr/boot_proc 2\n");//add by sxh upnp /* main loop */ timestamp(); status.requests = 0; status.errors = 0; start_time = current_time; select_loop(server_s); return 0; }
/*********************************************************************** * Creates and links a new module to a process */ struct module* module_new(struct process* pcs, const WCHAR* name, enum module_type type, BOOL virtual, DWORD64 mod_addr, DWORD64 size, unsigned long stamp, unsigned long checksum) { struct module* module; unsigned i; assert(type == DMT_ELF || type == DMT_PE || type == DMT_MACHO); if (!(module = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*module)))) return NULL; module->next = pcs->lmodules; pcs->lmodules = module; TRACE("=> %s %s-%s %s\n", get_module_type(type, virtual), wine_dbgstr_longlong(mod_addr), wine_dbgstr_longlong(mod_addr + size), debugstr_w(name)); pool_init(&module->pool, 65536); module->process = pcs; module->module.SizeOfStruct = sizeof(module->module); module->module.BaseOfImage = mod_addr; module->module.ImageSize = size; module_set_module(module, name); module->module.ImageName[0] = '\0'; lstrcpynW(module->module.LoadedImageName, name, sizeof(module->module.LoadedImageName) / sizeof(WCHAR)); module->module.SymType = SymNone; module->module.NumSyms = 0; module->module.TimeDateStamp = stamp; module->module.CheckSum = checksum; memset(module->module.LoadedPdbName, 0, sizeof(module->module.LoadedPdbName)); module->module.CVSig = 0; memset(module->module.CVData, 0, sizeof(module->module.CVData)); module->module.PdbSig = 0; memset(&module->module.PdbSig70, 0, sizeof(module->module.PdbSig70)); module->module.PdbAge = 0; module->module.PdbUnmatched = FALSE; module->module.DbgUnmatched = FALSE; module->module.LineNumbers = FALSE; module->module.GlobalSymbols = FALSE; module->module.TypeInfo = FALSE; module->module.SourceIndexed = FALSE; module->module.Publics = FALSE; module->reloc_delta = 0; module->type = type; module->is_virtual = virtual; for (i = 0; i < DFI_LAST; i++) module->format_info[i] = NULL; module->sortlist_valid = FALSE; module->sorttab_size = 0; module->addr_sorttab = NULL; module->num_sorttab = 0; module->num_symbols = 0; vector_init(&module->vsymt, sizeof(struct symt*), 128); /* FIXME: this seems a bit too high (on a per module basis) * need some statistics about this */ hash_table_init(&module->pool, &module->ht_symbols, 4096); hash_table_init(&module->pool, &module->ht_types, 4096); vector_init(&module->vtypes, sizeof(struct symt*), 32); module->sources_used = 0; module->sources_alloc = 0; module->sources = 0; wine_rb_init(&module->sources_offsets_tree, &source_rb_functions); return module; }
/* Open a network interface to look at packets on the network */ int pksh_pkopen (int argc, char * argv []) { /* GNU long options */ static struct option const long_options [] = { { "help", no_argument, NULL, 'h' }, { "snapshot", required_argument, NULL, 's' }, { "promiscuous", no_argument, NULL, 'p' }, { "timeout", required_argument, NULL, 't' }, { "hardware-size", required_argument, NULL, 128 }, { "ip-size" , required_argument, NULL, 129 }, { "hostname-size", required_argument, NULL, 130 }, { "hw", required_argument, NULL, 128 }, { "ip", required_argument, NULL, 129 }, { "ht", required_argument, NULL, 130 }, { NULL, 0, NULL, 0 } }; int option; /* Local variables */ int rc = 0; char * name = NULL; int as_parameter = 0; int snapshot = DEFAULT_SNAPSHOT; int promiscuous = 1; int timeout = DEFAULT_TIMEOUT; int hwsize = DEFAULT_HW_SIZE; int ipsize = DEFAULT_IP_SIZE; int hostsize = DEFAULT_HOST_SIZE; char ebuf [PCAP_ERRBUF_SIZE] = { '\0' }; char * ptrptr; /* pcap descriptor */ pcap_t * pcap = NULL; interface_t * interface; /* BPF filter */ char * filter = NULL; /* Parse command line options */ #define OPTSTRING "hs:pt:" optind = 0; optarg = NULL; while ((option = getopt_long (argc, argv, OPTSTRING, long_options, NULL)) != -1) { switch (option) { default: usage (argv [0]); return -1; case 'h': usage (argv [0]); return 0; case 's': snapshot = atoi (optarg); break; case 'p': promiscuous = 0; break; case 't': timeout = atoi (optarg); break; case 128: hwsize = atoi (optarg); break; case 129: ipsize = atoi (optarg); break; case 130: hostsize = atoi (optarg); break; } } /* Check if the user has specified one (or more) parameters */ if (optind >= argc) { /* None chosen via command line parameters, then find a suitable interface using pcap_lookupdev() */ if (! (name = pcap_lookupdev (ebuf))) { printf ("Unable to locate the default interface (%s).\n", ebuf); if (getuid () && geteuid ()) printf ("Maybe you do not have permissions to look at packets on the network\n"), printf ("since opening a network interface in promiscuous mode is a privileged operation\n"); else printf ("Please obtain the list of all suitable interfaces via the 'lsdev' command,\n"), printf ("then issue again this command passing the interface name as parameter\n"); return -1; } printf ("interface %s has been chosen by default for packet sniffing\n", name); as_parameter = 0; } else { int roomsize = 0; as_parameter = 1; /* More than one interface may be specified in a comma separated list */ name = strtok_r (argv [optind ++], ",", & ptrptr); /* Build a filter from all remaining command line arguments */ roomsize = 0; filter = NULL; while (optind < argc) { roomsize += (strlen (argv [optind]) + 1 + 1); filter = realloc (filter, roomsize); strcat (filter, argv [optind ++]); if (optind != argc - 1) strcat (filter, " "); } } /* Start processing first interface */ while (name) { /* * Lookup for the given name in the table of enabled interfaces * (to avoid multiple open on the same network interface) */ if ((interface = intfbyname (interfaces, name))) printf ("%s: interface %s already enabled for packet capturing. Skipping it!\n", argv [0], name); else { /* Time to initialize pcap library for the specified interface */ if (! (pcap = pcap_open_live (name, snapshot, promiscuous, timeout, ebuf))) { rc = -1; printf ("%s: cannot open interface %s (%s)\n", argv [0], name, ebuf); } else { /* Get a new descriptor and save current parameters to the table of interfaces managed by this program */ if (! (interfaces = intfadd (interfaces, name, snapshot, promiscuous, timeout, filter, pcap, & interface))) { rc = -1; printf ("Sorry! There is no space left. Too many open network interfaces\n"); /* Release the pcap descriptor */ pcap_close (pcap); } else { /* Initialize the hash tables for host management */ interface -> hwnames . size = hwsize; hash_table_init (& interface -> hwnames); interface -> ipnames . size = ipsize; hash_table_init (& interface -> ipnames); interface -> hostnames . size = hostsize; hash_table_init (& interface -> hostnames); /* Keep track of the last active interface */ setactiveintf (interface); /* Update user prompt to include the active interface */ pkshprompt (name); } } } /* Process next interface (if any) */ name = as_parameter ? strtok_r (NULL, ",", & ptrptr) : NULL; } if (filter) free (filter); return rc; }
struct hash_table* hash_table_create(hash_fn_t hash_fn, eql_fn_t eql_fn) { struct hash_table* ht = calloc(1, sizeof(*ht)); hash_table_init(ht, hash_fn, eql_fn, HASH_TABLE_DEFAULT_INITIAL_CAPACITY); return ht; }
int ipkg_conf_init(ipkg_conf_t *conf, const args_t *args) { int err; char *tmp_dir_base; nv_pair_list_t tmp_dest_nv_pair_list; char * lists_dir =NULL; glob_t globbuf; char *etc_ipkg_conf_pattern = "/etc/ipkg/*.conf"; char *pending_dir =NULL; memset(conf, 0, sizeof(ipkg_conf_t)); pkg_src_list_init(&conf->pkg_src_list); nv_pair_list_init(&tmp_dest_nv_pair_list); pkg_dest_list_init(&conf->pkg_dest_list); nv_pair_list_init(&conf->arch_list); conf->restrict_to_default_dest = 0; conf->default_dest = NULL; if (args->tmp_dir) tmp_dir_base = args->tmp_dir; else tmp_dir_base = getenv("TMPDIR"); sprintf_alloc(&conf->tmp_dir, "%s/%s", tmp_dir_base ? tmp_dir_base : IPKG_CONF_DEFAULT_TMP_DIR_BASE, IPKG_CONF_TMP_DIR_SUFFIX); conf->tmp_dir = mkdtemp(conf->tmp_dir); if (conf->tmp_dir == NULL) { fprintf(stderr, "%s: Failed to create temporary directory `%s': %s\n", __FUNCTION__, conf->tmp_dir, strerror(errno)); return errno; } conf->force_depends = 0; conf->force_defaults = 0; conf->force_overwrite = 0; conf->force_downgrade = 0; conf->force_reinstall = 0; conf->force_space = 0; conf->force_removal_of_essential_packages = 0; conf->force_removal_of_dependent_packages = 0; conf->nodeps = 0; conf->verbose_wget = 0; conf->ipkg_libdir = NULL; conf->offline_root = NULL; conf->offline_root_pre_script_cmd = NULL; conf->offline_root_post_script_cmd = NULL; conf->multiple_providers = 0; conf->verbosity = 1; conf->noaction = 0; conf->http_proxy = NULL; conf->ftp_proxy = NULL; conf->no_proxy = NULL; conf->proxy_user = NULL; conf->proxy_passwd = NULL; pkg_hash_init("pkg-hash", &conf->pkg_hash, IPKG_CONF_DEFAULT_HASH_LEN); hash_table_init("file-hash", &conf->file_hash, IPKG_CONF_DEFAULT_HASH_LEN); hash_table_init("obs-file-hash", &conf->obs_file_hash, IPKG_CONF_DEFAULT_HASH_LEN); lists_dir=(char *)malloc(1); lists_dir[0]='\0'; if (args->conf_file) { struct stat stat_buf; err = stat(args->conf_file, &stat_buf); if (err == 0) if (ipkg_conf_parse_file(conf, args->conf_file, &conf->pkg_src_list, &tmp_dest_nv_pair_list,&lists_dir)<0) { /* Memory leakage from ipkg_conf_parse-file */ return -1; } } /* if (!lists_dir ){*/ if (strlen(lists_dir)<=1 ){ if (args->ipkg_libdir) { lists_dir = realloc(lists_dir,strlen(args->ipkg_libdir)+strlen("/lists")+2); sprintf (lists_dir,"%s/lists",args->ipkg_libdir); }else if (conf->ipkg_libdir) { lists_dir = realloc(lists_dir,strlen(conf->ipkg_libdir)+strlen("/lists")+2); sprintf (lists_dir,"%s/lists",conf->ipkg_libdir); }else{ lists_dir = realloc(lists_dir,strlen(IPKG_CONF_LISTS_DIR)+2); sprintf (lists_dir,"%s",IPKG_CONF_LISTS_DIR); } } if (args->offline_root) { char *tmp = malloc(strlen(lists_dir) + strlen(args->offline_root) + 1); sprintf_alloc(&tmp, "%s/%s",args->offline_root,lists_dir); free(lists_dir); lists_dir = tmp; } pending_dir = malloc(strlen(lists_dir)+strlen("/pending")+5); snprintf(pending_dir,strlen(lists_dir)+strlen("/pending") ,"%s%s",lists_dir,"/pending"); conf->lists_dir = strdup(lists_dir); conf->pending_dir = strdup(pending_dir); if (args->offline_root) sprintf_alloc(&etc_ipkg_conf_pattern, "%s/etc/ipkg/*.conf", args->offline_root); memset(&globbuf, 0, sizeof(globbuf)); err = glob(etc_ipkg_conf_pattern, 0, NULL, &globbuf); if (!err) { int i; for (i = 0; i < globbuf.gl_pathc; i++) { if (globbuf.gl_pathv[i]) if ( ipkg_conf_parse_file(conf, globbuf.gl_pathv[i], &conf->pkg_src_list, &tmp_dest_nv_pair_list,&lists_dir)<0) { /* Memory leakage from ipkg_conf_parse-file */ return -1; } } } globfree(&globbuf); /* if no architectures were defined, then default all, noarch, and host architecture */ if (nv_pair_list_empty(&conf->arch_list)) { nv_pair_list_append(&conf->arch_list, "all", "1"); nv_pair_list_append(&conf->arch_list, "noarch", "1"); nv_pair_list_append(&conf->arch_list, HOST_CPU_STR, "10"); } /* Even if there is no conf file, we'll need at least one dest. */ if (tmp_dest_nv_pair_list.head == NULL) { nv_pair_list_append(&tmp_dest_nv_pair_list, IPKG_CONF_DEFAULT_DEST_NAME, IPKG_CONF_DEFAULT_DEST_ROOT_DIR); } /* After parsing the file, set options from command-line, (so that command-line arguments take precedence) */ /* XXX: CLEANUP: The interaction between args.c and ipkg_conf.c really needs to be cleaned up. There is so much duplication right now it is ridiculous. Maybe ipkg_conf_t should just save a pointer to args_t (which could then not be freed), rather than duplicating every field here? */ if (args->force_depends) { conf->force_depends = 1; } if (args->force_defaults) { conf->force_defaults = 1; } if (args->force_overwrite) { conf->force_overwrite = 1; } if (args->force_downgrade) { conf->force_downgrade = 1; } if (args->force_reinstall) { conf->force_reinstall = 1; } if (args->force_removal_of_dependent_packages) { conf->force_removal_of_dependent_packages = 1; } if (args->force_removal_of_essential_packages) { conf->force_removal_of_essential_packages = 1; } if (args->nodeps) { conf->nodeps = 1; } if (args->noaction) { conf->noaction = 1; } if (args->query_all) { conf->query_all = 1; } if (args->verbose_wget) { conf->verbose_wget = 1; } if (args->multiple_providers) { conf->multiple_providers = 1; } if (args->verbosity != conf->verbosity) { conf->verbosity = args->verbosity; } ipkg_conf_override_string(&conf->ipkg_libdir, args->ipkg_libdir); ipkg_conf_override_string(&conf->offline_root, args->offline_root); ipkg_conf_override_string(&conf->offline_root_pre_script_cmd, args->offline_root_pre_script_cmd); ipkg_conf_override_string(&conf->offline_root_post_script_cmd, args->offline_root_post_script_cmd); /* Pigi: added a flag to disable the checking of structures if the command does not need to read anything from there. */ if ( !(args->nocheckfordirorfile)){ /* need to run load the source list before dest list -Jamey */ if ( !(args->noreadfeedsfile)) set_and_load_pkg_src_list(conf, &conf->pkg_src_list); /* Now that we have resolved conf->offline_root, we can commit to the directory names for the dests and load in all the package lists. */ set_and_load_pkg_dest_list(conf, &tmp_dest_nv_pair_list,lists_dir); if (args->dest) { err = ipkg_conf_set_default_dest(conf, args->dest); if (err) { return err; } } } nv_pair_list_deinit(&tmp_dest_nv_pair_list); free(lists_dir); free(pending_dir); return 0; }
/*********************************************************************** * Creates and links a new module to a process */ struct module* module_new(struct process* pcs, const char* name, enum module_type type, BOOL virtual, unsigned long mod_addr, unsigned long size, unsigned long stamp, unsigned long checksum) { struct module* module; assert(type == DMT_ELF || type == DMT_PE); if (!(module = HeapAlloc(GetProcessHeap(), 0, sizeof(*module)))) return NULL; memset(module, 0, sizeof(*module)); module->next = pcs->lmodules; pcs->lmodules = module; TRACE("=> %s %08lx-%08lx %s\n", get_module_type(type, virtual), mod_addr, mod_addr + size, name); pool_init(&module->pool, 65536); module->module.SizeOfStruct = sizeof(module->module); module->module.BaseOfImage = mod_addr; module->module.ImageSize = size; module_fill_module(name, module->module.ModuleName, sizeof(module->module.ModuleName)); module->module.ImageName[0] = '\0'; lstrcpynA(module->module.LoadedImageName, name, sizeof(module->module.LoadedImageName)); module->module.SymType = SymNone; module->module.NumSyms = 0; module->module.TimeDateStamp = stamp; module->module.CheckSum = checksum; memset(module->module.LoadedPdbName, 0, sizeof(module->module.CVData)); module->module.CVSig = 0; memset(module->module.CVData, 0, sizeof(module->module.CVData)); module->module.PdbSig = 0; memset(&module->module.PdbSig70, 0, sizeof(module->module.PdbSig70)); module->module.PdbAge = 0; module->module.PdbUnmatched = FALSE; module->module.DbgUnmatched = FALSE; module->module.LineNumbers = FALSE; module->module.GlobalSymbols = FALSE; module->module.TypeInfo = FALSE; module->module.SourceIndexed = 0; module->module.Publics = 0; module->type = type; module->is_virtual = virtual ? TRUE : FALSE; module->sortlist_valid = FALSE; module->addr_sorttab = NULL; /* FIXME: this seems a bit too high (on a per module basis) * need some statistics about this */ hash_table_init(&module->pool, &module->ht_symbols, 4096); hash_table_init(&module->pool, &module->ht_types, 4096); vector_init(&module->vtypes, sizeof(struct symt*), 32); module->sources_used = 0; module->sources_alloc = 0; module->sources = 0; return module; }
int slang_init_sym_table() { symTable = hash_table_init(sizeof(const char*), sym_hash, sym_key_compare, sym_val_free); return symTable != 0; }
int main(int argc, char **argv) { char *envstr, **cmd_argv, **targv; int i, ret, cmd_argc; struct passwd *pw; struct stat st; char fpath[MAXPATHLEN]; tzset(); TAILQ_INIT(&cvs_variables); SLIST_INIT(&repo_locks); SLIST_INIT(&temp_files); hash_table_init(&created_directories, 100); hash_table_init(&created_cvs_directories, 100); /* check environment so command-line options override it */ if ((envstr = getenv("CVS_RSH")) != NULL) cvs_rsh = envstr; if (((envstr = getenv("CVSEDITOR")) != NULL) || ((envstr = getenv("VISUAL")) != NULL) || ((envstr = getenv("EDITOR")) != NULL)) cvs_editor = envstr; if ((envstr = getenv("CVSREAD")) != NULL) cvs_readonly = 1; if ((envstr = getenv("CVSREADONLYFS")) != NULL) { cvs_readonlyfs = 1; cvs_nolog = 1; } if ((cvs_homedir = getenv("HOME")) == NULL) { if ((pw = getpwuid(getuid())) != NULL) cvs_homedir = pw->pw_dir; } if ((envstr = getenv("TMPDIR")) != NULL) cvs_tmpdir = envstr; ret = cvs_getopt(argc, argv); argc -= ret; argv += ret; if (argc == 0) usage(); cmdp = cvs_findcmd(argv[0]); if (cmdp == NULL) { fprintf(stderr, "Unknown command: `%s'\n\n", argv[0]); fprintf(stderr, "CVS commands are:\n"); for (i = 0; cvs_cdt[i] != NULL; i++) fprintf(stderr, "\t%-16s%s\n", cvs_cdt[i]->cmd_name, cvs_cdt[i]->cmd_descr); exit(1); } /* * check the tmp dir, either specified through * the environment variable TMPDIR, or via * the global option -T <dir> */ if (stat(cvs_tmpdir, &st) == -1) fatal("stat failed on `%s': %s", cvs_tmpdir, strerror(errno)); else if (!S_ISDIR(st.st_mode)) fatal("`%s' is not valid temporary directory", cvs_tmpdir); if (cvs_readrc == 1 && cvs_homedir != NULL) { cvs_read_rcfile(); if (cvs_defargs != NULL) { if ((targv = cvs_makeargv(cvs_defargs, &i)) == NULL) fatal("failed to load default arguments to %s", __progname); cvs_getopt(i, targv); cvs_freeargv(targv, i); xfree(targv); } } /* setup signal handlers */ signal(SIGTERM, sighandler); signal(SIGINT, sighandler); signal(SIGHUP, sighandler); signal(SIGABRT, sighandler); signal(SIGALRM, sighandler); signal(SIGPIPE, sighandler); cvs_cmdop = cmdp->cmd_op; cmd_argc = cvs_build_cmd(&cmd_argv, argv, argc); cvs_file_init(); if (cvs_cmdop == CVS_OP_SERVER) { cmdp->cmd(cmd_argc, cmd_argv); cvs_cleanup(); return (0); } cvs_umask = umask(0); umask(cvs_umask); if ((current_cvsroot = cvsroot_get(".")) == NULL) { cvs_log(LP_ERR, "No CVSROOT specified! Please use the '-d' option"); fatal("or set the CVSROOT environment variable."); } if (current_cvsroot->cr_method != CVS_METHOD_LOCAL) { cmdp->cmd(cmd_argc, cmd_argv); cvs_cleanup(); return (0); } (void)xsnprintf(fpath, sizeof(fpath), "%s/%s", current_cvsroot->cr_dir, CVS_PATH_ROOT); if (stat(fpath, &st) == -1 && cvs_cmdop != CVS_OP_INIT) { if (errno == ENOENT) fatal("repository '%s' does not exist", current_cvsroot->cr_dir); else fatal("%s: %s", current_cvsroot->cr_dir, strerror(errno)); } else { if (!S_ISDIR(st.st_mode)) fatal("'%s' is not a directory", current_cvsroot->cr_dir); } if (cvs_cmdop != CVS_OP_INIT) { cvs_parse_configfile(); cvs_parse_modules(); } cmdp->cmd(cmd_argc, cmd_argv); cvs_cleanup(); return (0); }