int main(int argc, char *argv[]) { Hashmap *packages; if (!(packages = readPackages(PACKAGES))) return -1; //hashmapForEach(packages, dumpPackage, NULL); printf("Found packages: %u\n", (int) hashmapSize(packages)); initUsers(); if (argc == 2) { APK *package = (APK *) hashmapGet(packages, argv[1]); if (package) checkPackage(NULL, package, NULL); else printf("Package %s not found\n", argv[1]); } else hashmapForEach(packages, checkPackage, NULL); hashmapForEach(packages, freePackage, NULL); hashmapFree(packages); return 0; }
/** * Called when the peer dies. */ static void peerProxyKill(PeerProxy* peerProxy, bool errnoIsSet) { if (errnoIsSet) { ALOGI("Peer %d died. errno: %s", peerProxy->credentials.pid, strerror(errno)); } else { ALOGI("Peer %d died.", peerProxy->credentials.pid); } // If we lost the master, we're up a creek. We can't let this happen. if (peerProxy->master) { LOG_ALWAYS_FATAL("Lost connection to master."); } Peer* localPeer = peerProxy->peer; pid_t pid = peerProxy->credentials.pid; peerLock(localPeer); // Remember for awhile that the peer died. localPeer->deadPeers[localPeer->deadPeerCursor] = peerProxy->credentials.pid; localPeer->deadPeerCursor++; if (localPeer->deadPeerCursor == PEER_HISTORY) { localPeer->deadPeerCursor = 0; } // Remove from peer map. hashmapRemove(localPeer->peerProxies, &pid); // External threads can no longer get to this peer proxy, so we don't // need the lock anymore. peerUnlock(localPeer); // Remove the fd from the selector. if (peerProxy->fd != NULL) { peerProxy->fd->remove = true; } // Clear outgoing packet queue. while (peerProxyNextPacket(peerProxy)) {} bufferFree(peerProxy->inputBuffer); // This only applies to the master. if (peerProxy->connections != NULL) { // We can't leave these other maps pointing to freed memory. hashmapForEach(peerProxy->connections, &peerProxyRemoveConnection, peerProxy); hashmapFree(peerProxy->connections); } // Invoke death listener. localPeer->onDeath(pid); // Free the peer proxy itself. free(peerProxy); }
/* * Frees ctx and all entries within it */ static void freeCtx(struct ctx *ctx) { if (ctx) { Node *n = list_getHead(&ctx->list); while (list_isNode(n)) { Node *next = list_getNext(n); list_remove(n); // This will free n and the ScheduleIndex instance node_free(n); n = next; } if (ctx->tiploc) hashmapFree(ctx->tiploc); if (ctx->activity) hashmapFree(ctx->activity); free(ctx); } }
static void cleanup(int sig) { killed = 1; printf( "Restoring arp table ...\n" ); int i, j; struct ether_addr gateway_mac; if( netmap == NULL ) { if( arp_lookup( gateway_ip, &gateway_mac, iface ) == 0 ) { for( i = 0; i < 3; i++ ) { /* XXX - on BSD, requires ETHERSPOOF kernel. */ arp_send( lnet, ARPOP_REPLY, (unsigned char *)&gateway_mac, gateway_ip, (unsigned char *)&target_mac, target_ip ); sleep(1); } } } else { if( arp_lookup( gateway_ip, &gateway_mac, iface ) == 0 ) { for( i = 0; i < 3; i++ ) { for( j = 0; j < netmap->bucketCount; j++ ) { Entry* hentry = netmap->buckets[j]; while( hentry != NULL ) { Entry *next = hentry->next; network_entry_t *entry = ( network_entry_t * )hentry->value; arp_send( lnet, ARPOP_REPLY, (unsigned char *)&gateway_mac, gateway_ip, entry->mac, entry->address ); hentry = next; } } sleep(1); } } hashmapFree( netmap ); } exit(0); }
void endGame() { hashmapFree(currentGame.gameMap); }
void fileHelperLoad(FileHelper fileHelper) { FileHelperInternal *m = (FileHelperInternal *) fileHelper; fileHelperCheckCreate(m->filePath); int sizeOfInt = sizeof(int); struct direct **schemasIds = {0}; struct direct *schenaId; int size = scandir(m->filePath, &schemasIds, 0, alphasort); // loop all schemas int i; for (i = 0; i < size; i++) { schenaId = (struct direct *) schemasIds[i]; char *schemaIdString = schenaId->d_name; int schemaId = atoi(schemaIdString); if (schemaId != 0) { printf("schema %s\n", schenaId->d_name); struct direct **pagesIds = {0}; struct direct *pageStruct; char endOdString = '\0'; int pageDirLength = strlen(m->filePath); int schemaIdStringLength = strlen(schemaIdString); char slesh = '/'; char *pageDir = (char *) memoryAlloc(pageDirLength + 1 + schemaIdStringLength + 1); memcpy(pageDir, m->filePath, pageDirLength); memcpy(pageDir + pageDirLength, &slesh, 1); memcpy(pageDir + pageDirLength + 1, schemaIdString, schemaIdStringLength); memcpy(pageDir + pageDirLength + 1 + schemaIdStringLength, &endOdString, 1); // cleanBuffer(pageDir); // strcat(pageDir,m->filePath); // strcat(pageDir,"/"); // strcat(pageDir,schemaIdString); HashMap childrenRelations = hashmapCreate(SMALL_CONTAINER_SIZE); Registry registry = registryCreate(); hashmapPut(m->registryMap, schemaId, registry); PageManager pageManager = pageManagerCreate(schemaId, pageDir); hashmapPut(m->managers, schemaId, pageManager); int size = scandir(pageDir, &pagesIds, 0, alphasort); int h; //loop pages for (h = 0; h < size; h++) { //scandir (pageDir, &pagesIds, 0, alphasort); pageStruct = (struct direct *) pagesIds[h]; char *pageString = pageStruct->d_name; int pageId = atoi(pageString); if (pageId != 0) { printf("page %s\n", pageStruct->d_name); // create file path. //int i=0; int pageDirLength = strlen(pageDir); int pageStringLength = strlen(pageString); char slesh = '/'; char *filePath = (char *) memoryAlloc(pageDirLength + 1 + pageStringLength + 1); memcpy(filePath, pageDir, pageDirLength); memcpy(filePath + pageDirLength, &slesh, 1); memcpy(filePath + pageDirLength + 1, pageString, pageStringLength); memcpy(filePath + pageDirLength + 1 + pageStringLength, &endOdString, 1); FILE *fp; long len; // Create pointer to file. fp = fopen(filePath, "rb"); if (fp == NULL) { printf("couldn't open the properties file"); } fseek(fp, 0, SEEK_END); // Go to end len = ftell(fp); // Get position at end (length) // Read data to buffer char *buffer = memoryAlloc(sizeof(char) * len); // Create buffer char *pointerToFreeBuffer = buffer; fseek(fp, 0, SEEK_SET); // Go to the beginning. int result = fread(buffer, len, 1, fp); // Read into buffer if (result < 0) { printf("Fail to read file : %s", buffer); } fclose(fp); int order = 0; long index = 0; long step = 0; while (index < len) { char *start = buffer; int id; int schemaId; int numberOfAttributes; int childrenSize; int attributeSize; memcpy(&schemaId, buffer + SIZE_OF_INT * 0, SIZE_OF_INT); memcpy(&id, buffer + SIZE_OF_INT * 1, SIZE_OF_INT); memcpy(&numberOfAttributes, buffer + SIZE_OF_INT * 2, SIZE_OF_INT); buffer += SIZE_OF_INT * 3; Node node; nodeCreate(registry, id, schemaId, FALSE, &node); int h; for (h = 0; h < numberOfAttributes; h++) { memcpy(&attributeSize, buffer, SIZE_OF_INT); Attribute attribute = attributeDeserializeLocal(buffer); buffer += attributeSize; stringHashmapPut(node->attributes, attribute->name, attribute->nameLength, attribute); } memcpy(&childrenSize, buffer, SIZE_OF_INT); Array children = arrayCreate(childrenSize); hashmapPut(childrenRelations, id, children); int i; buffer += SIZE_OF_INT; int childrenIdBuffer; for (i = 0; i < childrenSize; i++) { memcpy(&childrenIdBuffer, buffer + SIZE_OF_INT, SIZE_OF_INT); void *bufferElement = memoryAlloc(childrenIdBuffer + SIZE_OF_INT * 2); memcpy(bufferElement, buffer, SIZE_OF_INT * 2 + childrenIdBuffer); arrayInsertObject(children, bufferElement); buffer += SIZE_OF_INT * 2 + childrenIdBuffer; } step = buffer - start; index += step; pageManagerRegister(pageManager, pageId, id, index - step, index, order, filePath); order++; } // Free the file buffer memoryFree(pointerToFreeBuffer); } } if (size > 0) { while (size) { size = size - 1; free(pagesIds[size]); } free(pagesIds); } hashmapIterate(childrenRelations, &updateChildren, registry); hashmapFree(childrenRelations); } } if (size > 0) { while (size) { size = size - 1; free(schemasIds[size]); } free(schemasIds); } }
void s2_touch_event_free(struct s2_touch_event * self) { hashmapFree(self->touches); }
void sprite_frame_cache_free(struct sprite_frame_cache* self) { hashmapFree(self->cache); s_free(self); }
void texture_cache_free(struct texture_cache* self) { hashmapFree(self->cache); s_free(self); }
void massdns_scan(lookup_context_t *context) { memset(&stats, 0, sizeof(dns_stats_t)); size_t line_buflen = 4096; char *line = safe_malloc(line_buflen); size_t line_len = 0; struct sockaddr_in server_addr; server_addr.sin_family = AF_INET; server_addr.sin_addr.s_addr = INADDR_ANY; server_addr.sin_port = 0; int sock = socket(AF_INET, SOCK_DGRAM, 0); int socketbuf = 1024 * 1024 * 100; if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &socketbuf, sizeof(socketbuf)) != 0) { perror("Failed to adjust socket send buffer size."); } if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &socketbuf, sizeof(socketbuf)) != 0) { perror("Failed to adjust socket receive buffer size."); } bind(sock, (sockaddr_t *) &server_addr, sizeof(server_addr)); fcntl(sock, F_SETFL, fcntl(sock, F_GETFL, 0) | O_NONBLOCK); if (sock < 0) { perror("Failed to create socket"); exit(1); } FILE *f; if(context->cmd_args.show_progress) { f = fopen(context->cmd_args.domains, "r"); if (f == NULL) { perror("Failed to open domain file"); exit(1); } while(!feof(f)) { if (0 <= getline(&line, &line_buflen, f)) { trim_end(line); strtolower(line); if (strcmp(line, "") != 0) { context->total_domains++; } } } fclose(f); } f = fopen(context->cmd_args.domains, "r"); if (f == NULL) { perror("Failed to open domain file"); exit(1); } if (geteuid() == 0) { fprintf(stderr, "You have started the program with root privileges.\n"); struct passwd *nobody = getpwnam(UNPRIVILEGED_USER); if (!context->cmd_args.root) { if (nobody && setuid(nobody->pw_uid) == 0) { fprintf(stderr, "Privileges have been dropped to \"%s\" for security reasons.\n\n", UNPRIVILEGED_USER); } else if (!context->cmd_args.root) { fprintf(stderr, "Privileges could not be dropped to \"%s\".\n" "For security reasons, this program will only run as root user when supplied with --root" "which is not recommended.\n" "It is better practice to run this program as a different user.\n", UNPRIVILEGED_USER); exit(1); } } else { fprintf(stderr, "[WARNING] Privileges were not dropped. This is not recommended.\n\n"); } } FILE *randomness = fopen("/dev/urandom", "r"); if (!randomness) { fprintf(stderr, "Failed to open /dev/urandom.\n"); exit(1); } context->current_rate = 0; context->sock = sock; context->resolvers = massdns_resolvers_from_file(context->cmd_args.resolvers); context->map = hashmapCreate(context->cmd_args.hashmap_size, hash_string, cmp_lookup); context->initial = true; gettimeofday(&context->start_time, NULL); context->next_update = context->start_time; while (true) { while (hashmapSize(context->map) < context->cmd_args.hashmap_size && !feof(f)) { if (0 <= getline(&line, &line_buflen, f)) { trim_end(line); line_len = strlen(line); strtolower(line); if(strcmp(line, "") == 0) { continue; } if (line_len > 0 && line[line_len - 1] == '.') { // Remove trailing dot from FQDN line[line_len] = 0; } lookup_t *lookup = hashmapGet(context->map, line); if (lookup == NULL) { char *value = safe_malloc(line_len + 1); strcpy(value, line); lookup = safe_malloc(sizeof(*lookup)); lookup->domain = value; lookup->tries = 0; if (fread(&lookup->transaction, 1, sizeof(lookup->transaction), randomness) != sizeof(lookup->transaction)) { fprintf(stderr, "Failed to get randomness for transaction id.\n"); exit(1); } gettimeofday(&lookup->next_lookup, NULL); hashmapPut(context->map, value, lookup); } } } if(!context->cooldown && hashmapSize(context->map) < context->cmd_args.hashmap_size) { context->cooldown = true; gettimeofday(&context->cooldown_time, NULL); } while (massdns_receive_packet(sock, massdns_handle_packet, context)); if (feof(f) && hashmapSize(context->map) == 0) { break; } hashmapForEach(context->map, handle_domain, context); } for (size_t i = 0; i < context->resolvers.len; i++) { free(((sockaddr_in_t **) context->resolvers.data)[i]); ((sockaddr_in_t **) context->resolvers.data)[i] = NULL; } free(line); free(context->resolvers.data); context->resolvers.data = NULL; print_stats(context); hashmapFree(context->map); context->map = NULL; fclose(f); fclose(randomness); }
static int load_config(const char *config) { struct config_parser *cp; char *value; int i; if (!config || strlen(config) == 0) cp = config_parser_init(TBOOT_CONFIG); else cp = config_parser_init(config); if (!cp) goto err; /* init config with default values */ tboot_config = hashmapCreate(array_size(tc_keys), strhash, strcompare); if (!tboot_config) goto err; for (i = 0; tc_keys[i]; i++) hashmapPut(tboot_config, (void *)tc_keys[i], (void *)tc_values[i]); /* parse config file */ value = config_parser_get(cp, UI_CONF_KEY); if (value) tboot_config_set(UI_CONF_KEY, value); value = config_parser_get(cp, DISK_CONFIG_KEY); if (value) tboot_config_set(DISK_CONFIG_KEY, value); value = config_parser_get(cp, PUSH_DIR_KEY); if (value) tboot_config_set(PUSH_DIR_KEY, value); value = config_parser_get(cp, ROOTFS_KEY); if (value) tboot_config_set(ROOTFS_KEY, value); value = config_parser_get(cp, ENABLE_NFS_KEY); if (value) tboot_config_set(ENABLE_NFS_KEY, value); value = config_parser_get(cp, NFSURL_KEY); if (value) tboot_config_set(NFSURL_KEY, value); value = config_parser_get(cp, DISK_FORCE_KEY); if (value) tboot_config_set(DISK_FORCE_KEY, value); value = config_parser_get(cp, BAT_THRESHOLD_KEY); if (value) tboot_config_set(BAT_THRESHOLD_KEY, value); value = config_parser_get(cp, LCD_DIM_TIMEOUT_KEY); if (value) tboot_config_set(LCD_DIM_TIMEOUT_KEY, value); value = config_parser_get(cp, LCD_OFF_TIMEOUT_KEY); if (value) tboot_config_set(LCD_OFF_TIMEOUT_KEY, value); value = config_parser_get(cp, LCD_DIM_BRIGHTNESS_KEY); if (value) tboot_config_set(LCD_DIM_BRIGHTNESS_KEY, value); config_parser_free(cp); tboot_config_dump(); return 0; err: if (cp) config_parser_free(cp); if (tboot_config) hashmapFree(tboot_config); return -1; }
int main(int argc, char **argv) { pthread_t t_auto, t_input, t_uevent, t_sighandler; //Volume *vol; int ret; char *disk_conf; void (*ui_update)(void *) = NULL; sigset_t set; /* block signals for all theads */ sigemptyset(&set); sigaddset(&set, SIGPIPE); sigaddset(&set, SIGALRM); if (pthread_sigmask(SIG_BLOCK, &set, NULL)) pr_critial("block signal failed.\n"); /* create a dedicate thread to handle signals */ if (pthread_create(&t_sighandler, NULL, sig_handler, &set)) pr_critial("create signal handler thread failed.\n"); if (argc > 1) ret = load_config(argv[1]); else ret = load_config(NULL); /* currently, missing config file is not critical */ if (ret) pr_warning("can't load tboot configuration.\n"); if (ret = tboot_ui_init(tboot_config_get(UI_CONF_KEY))) pr_error("UI crashed!\n"); tboot_config_set(UI_CONF_KEY, tboot_ui_getconfpath()); ev_init(input_callback, NULL); display_sysinfo(ret); if (!ret) { ui_update = ui_callback; } pr_info(" -- preos v%s for %s --\n", preos_version, DEVICE_NAME); import_kernel_cmdline(parse_cmdline_option); disk_conf = tboot_config_get(DISK_CONFIG_KEY); if (!disk_conf) { pr_error("Invalid tboot config disk_conf.\n"); die(); } setup_disk_information(disk_conf); aboot_register_commands(); register_tboot_plugins(); if (pthread_create(&t_input, NULL, input_listener_thread, NULL)) { pr_perror("pthread_create"); die(); } lcd_state_init(); if (pthread_create(&t_uevent, NULL, uevent_thread, ui_update)) { pr_perror("pthread_create t_uevent"); die(); } /* vol = volume_for_path(SDCARD_VOLUME); if (vol) try_update_sw(vol, 1); */ if (g_use_autoboot && !g_update_location) { /* * Create menu items for debug boot, this is a feature for developers * only. * * Developers (kernel developers) put kernel, cmdline, * rmadisk.img(optional) to platform boot directory in kexec enabled * preos. * * Generally, there are two ways to do that. * * 1. you can put these files into /boot after the system boot * into rootfs. * 2. you can put these files into platform.img.gz and create a new * platform.img.gz and then flash it to target device. * * Previous, if the system can't boot into rootfs, the only way left * is flash a new platform image. Apparently, it's a huge effort. * * To make more choice, two kernels are supported now, so make sure * there is a works kernel in /boot , you can always boot into * normal system and put a new kernel by any other way, such as scp, * ftp and etc. */ /* * make our menu acts more like grub which more users familiar with. */ tboot_ui_menu_item("Boot: kernel", start_default_kernel); tboot_ui_menu_item("Boot: kernel.bak", start_backup_kernel); tboot_ui_menu_item("Boot: kernel/rootfs on TF/micro-SD card", start_mmc_kernel); /* * boot from NFS is quite useless now because the usb network bandwidth * is too narrow to satisfy the boot up sequence. It may (80%) hang at * system boot up, especially at X server start up * * So, by default, disable it. */ if (strcasecmp(tboot_config_get(ENABLE_NFS_KEY), "yes") == 0) tboot_ui_menu_item("Boot: kernel/rootfs on NFS", start_nfs_kernel); tboot_ui_menu_selected(3); // set debug boot: kernel selected if (pthread_create(&t_auto, NULL, autoboot_thread, NULL)) { pr_perror("pthread_create"); die(); } } /* * dealy to start tboot server */ do { sleep(1); } while (autoboot_enabled || power_pressed); pr_info("Listening for the fastboot protocol over USB.\n"); fastboot_init(g_scratch_size * MEGABYTE); /* Shouldn't get here */ tboot_ui_exit(); if (tboot_config) hashmapFree(tboot_config); // tboot_cmds_free(); exit(1); }