void ndfs_print_state_stats (run_t* run, wctx_t* ctx, int index, float waittime) { size_t db_elts = global->stats.elts; size_t explored = run->total.explored; //size_t trans = run->total.trans; size_t rtrans = run->reduced->red_work.trans; size_t rexplored = run->reduced->red_work.explored; size_t bogus = run->reduced->red.bogus_red; size_t waits = run->reduced->red.waits; size_t allred = run->reduced->blue.allred; size_t rallred = run->reduced->red.allred; Warning (info, "%s_%d (permutation: %s) stats:", key_search(strategies, ctx->local->strat & ~Strat_TA), index, key_search(permutations, permutation)); Warning (info, "blue states: %zu (%.2f%%), transitions: %zu (per worker)", explored, ((double)explored/db_elts)*100, rtrans); Warning (info, "red states: %zu (%.2f%%), bogus: %zu (%.2f%%), " "transitions: %zu, waits: %zu (%.2f sec)", rexplored, ((double)rexplored/db_elts)*100, bogus, ((double)bogus/db_elts), rtrans, waits, waittime); if ( all_red ) Warning (info, "all-red states: %zu (%.2f%%), bogus %zu (%.2f%%)", allred, ((double)allred/db_elts)*100, rallred, ((double)rallred/db_elts)*100); }
/** * Import a key defined by a fingerprint into the local keyring. * @param handle the context handle * @param fpr the fingerprint key ID to import * @return 0 on success, -1 on error */ int _alpm_key_import(alpm_handle_t *handle, const char *fpr) { int answer = 0, ret = -1; alpm_pgpkey_t fetch_key; memset(&fetch_key, 0, sizeof(fetch_key)); if(key_search(handle, fpr, &fetch_key) == 1) { _alpm_log(handle, ALPM_LOG_DEBUG, "unknown key, found %s on keyserver\n", fetch_key.uid); if(!_alpm_access(handle, handle->gpgdir, "pubring.gpg", W_OK)) { QUESTION(handle, ALPM_QUESTION_IMPORT_KEY, &fetch_key, NULL, NULL, &answer); if(answer) { if(key_import(handle, &fetch_key) == 0) { ret = 0; } else { _alpm_log(handle, ALPM_LOG_ERROR, _("key \"%s\" could not be imported\n"), fetch_key.uid); } } } else { /* keyring directory was not writable, so we don't even try */ _alpm_log(handle, ALPM_LOG_WARNING, _("key %s, \"%s\" found on keyserver, keyring is not writable\n"), fetch_key.fingerprint, fetch_key.uid); } } else { _alpm_log(handle, ALPM_LOG_ERROR, _("key \"%s\" could not be looked up remotely\n"), fpr); } gpgme_key_unref(fetch_key.data); return ret; }
void cndfs_local_setup (run_t *run, wctx_t *ctx) { cndfs_alg_local_t *cloc = (cndfs_alg_local_t *) ctx->local; cloc->timer = RTcreateTimer (); ndfs_local_setup (run, ctx); size_t len = state_info_serialize_int_size (ctx->state); cloc->in_stack = dfs_stack_create (len); cloc->out_stack = dfs_stack_create (len); if ((get_strategy(run->alg) & Strat_TA) == 0) { cloc->pink = fset_create (sizeof(ref_t), sizeof(size_t), FSET_MIN_SIZE, 24); } if (get_strategy(run->alg) & Strat_CNDFS) return; if (run->shared->rec == NULL) { Abort ("Missing recursive strategy for %s!", key_search(strategies, get_strategy(run->alg))); return; } HREassert (ctx->global != NULL, "Run global before local init"); // We also need to finalize the worker initialization: ctx->global->rec = run_init (run->shared->rec, ctx->model); // Recursive strategy maybe unaware of its caller, so here we update its // recursive bits (top-level strategy always has rec_bits == 0, which // is ensured by ndfs_local_setup): ctx->global->rec->local->rec_bits = run->shared->color_bit_shift; cloc->rec = ctx->global->rec->local; }
int icn_title_proccess(ICN_CONTEXT icn) { /** Set Identity Array **/ u8 language_string[MAX_TITLE_NUM][15]; strcpy(language_string[0], "Japanese"); strcpy(language_string[1], "English"); strcpy(language_string[2], "French"); strcpy(language_string[3], "German"); strcpy(language_string[4], "Italian"); strcpy(language_string[5], "Spanish"); strcpy(language_string[6], "SimpChinese"); strcpy(language_string[7], "Korean"); strcpy(language_string[8], "Dutch"); strcpy(language_string[9], "Portuguese"); strcpy(language_string[10], "Russian"); strcpy(language_string[11], "TradChinese"); /** Temporary Arrays **/ u8 *short_title = malloc(sizeof(u8)*SIZE_SHORT_TITLE); u8 *long_title = malloc(sizeof(u8)*SIZE_LONG_TITLE); u8 *publisher = malloc(sizeof(u8)*SIZE_PUBLISHER_TITLE); /** File Position Recorders **/ long int pos0; long int pos1; /** Read Title Strings **/ rewind(icn.bsf); if(key_search("ApplicationTitleData", icn.bsf) == FOUND){ pos0 = ftell(icn.bsf); for(int i = 0; i < MAX_TITLE_NUM; i++){ fseek(icn.bsf, pos0, SEEK_SET); if(key_search(language_string[i], icn.bsf) == FOUND){ pos1 = ftell(icn.bsf); /** for(int j = 0; j < 3; j++){ fseek(icn.bsf, pos1, SEEK_SET); if(get_value(title_set[j],title_value_size[j],title_key[j],icn.bsf) != FOUND){ printf("[!] Warning %s was not specified for %s\n",title_key[j],language_string[i]); } } **/ if(get_value(short_title,SIZE_SHORT_TITLE,"ShortTitle",icn.bsf) != 0){ printf("[!] Warning, No 'ShortTitle' string for %s\n",language_string[i]); } fseek(icn.bsf, pos1, SEEK_SET); if(get_value(long_title,SIZE_LONG_TITLE,"LongTitle",icn.bsf) != 0){ printf("[!] Warning, No 'LongTitle' string for %s\n",language_string[i]); } fseek(icn.bsf, pos1, SEEK_SET); if(get_value(publisher,SIZE_PUBLISHER_TITLE,"Publisher",icn.bsf) != 0){ printf("[!] Warning, No 'Publisher' string for %s\n",language_string[i]); } //Writing Language Strings to Data Struct if(icn.verbose_bool) printf("[+]%s : [%s] [%s] [%s]\n",language_string[i],short_title,long_title,publisher); icn.titles.title_array[i] = string_ICN_conv(short_title,long_title,publisher); } else{ printf("[!] Warning, Could Not Find Title Strings for %s, i = %d\n",language_string[i], i); } } } else{ key_find_fail("ApplicationTitleData"); printf("return fail = %d\n",TITLE_FAIL); return TITLE_FAIL; } free(short_title); free(long_title); free(publisher); /** Write To File **/ fseek(icn.output, TITLE_OFFSET, SEEK_SET); fwrite(&icn.titles, sizeof(icn.titles), 1, icn.output); return 0; }
int icn_settings_proccess(ICN_CONTEXT icn) { /** Creating Buffer **/ u8 buff[100]; /** Processing Bitmask Flags **/ //Creating Identity Arrays u8 bit_flag_key_0[MAX_BIT_NUM][20] = {"Visable", "AutoBoot", "Flag3DEffect", "RequireAcceptEULA", "AutoSaveOnExit", "UseExtendedBanner", "UseAgeRestrictions", "UseSaveData"}; u8 bit_flag_key_1[MAX_BIT_NUM][20] = {"IconDatabase", "", "", "", "", "", "", ""}; u8 bit_flag_value[MAX_BIT_NUM] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; //Creating bit flag 0 counter u8 bit_flag[MAX_BIT_NUM]; //memset(bit_flag, 0, MAX_BIT_NUM); //Region Age Rating flag int use_age_ratings = FALSE; fseek(icn.bsf, 0x00, SEEK_SET); if(key_search("Options", icn.bsf) == FOUND){ if(key_search("Flags", icn.bsf) == FOUND){ long int pos0 = ftell(icn.bsf); for(int i = 0; i < MAX_BIT_NUM; i++){ fseek(icn.bsf, pos0, SEEK_SET); if (get_boolean(bit_flag_key_0[i], icn.bsf) == TRUE){ if(icn.verbose_bool) printf("[+] %s was True\n",bit_flag_key_0[i]); icn.settings.byte_flag[0] += bit_flag_value[i]; if(i == 6) use_age_ratings = TRUE; } else if(icn.verbose_bool) printf("[+] %s was False\n",bit_flag_key_0[i]); } } else{ key_find_fail("Flags"); return FLAG_FAIL; } } else{ key_find_fail("Options"); return FLAG_FAIL; } fseek(icn.bsf, 0x00, SEEK_SET); if(key_search("Options", icn.bsf) == FOUND){ if(key_search("Flags", icn.bsf) == FOUND){ long int pos0 = ftell(icn.bsf); for(int i = 0; i < 1; i++){ fseek(icn.bsf, pos0, SEEK_SET); if (get_boolean(bit_flag_key_1[i], icn.bsf) == TRUE){ if(icn.verbose_bool) printf("[+] %s was True\n",bit_flag_key_1[i]); icn.settings.byte_flag[1] += bit_flag_value[i]; if(i == 6) use_age_ratings = TRUE; } else if(icn.verbose_bool) printf("[+] %s was False\n",bit_flag_key_1[i]); } } else{ key_find_fail("Flags"); return FLAG_FAIL; } } else{ key_find_fail("Options"); return FLAG_FAIL; } /** Processing Age Ratings **/ /*** Seting Up Region Key Array and Input Array***/ u8 region_rating_key[MAX_RATING_NUM][12] = {"Japan", "USA", "German", "Europe", "Portugual", "England", "Australia"}; u8 region_rating_struct_index[MAX_RATING_NUM] = {0,1,3,4,6,7,8}; u8 region_rating_string[2]; //memset(region_rating_string, 0x00, sizeof(region_rating_string)); /*** Setting Up Age Restriction Rules ***/ u8 region_age[MAX_RATING_NUM][10]; int region_age_num[MAX_RATING_NUM] = {5,5,5,5,5,8,5}; memcpy(region_age[RATING_JPN], (u8[]) {0,12,15,17,18}, region_age_num[RATING_JPN]); memcpy(region_age[RATING_USA], (u8[]) {3,6,10,13,17}, region_age_num[RATING_USA]); memcpy(region_age[RATING_GER], (u8[]) {0,6,12,16,17}, region_age_num[RATING_GER]); memcpy(region_age[RATING_EUR], (u8[]) {3,7,12,16,18}, region_age_num[RATING_EUR]); memcpy(region_age[RATING_PRT], (u8[]) {4,6,12,16,18}, region_age_num[RATING_PRT]); memcpy(region_age[RATING_ENG], (u8[]) {3,4,7,8,12,15,16,18}, region_age_num[RATING_ENG]); memcpy(region_age[RATING_AUS], (u8[]) {0,7,14,15,18}, region_age_num[RATING_AUS]); /*** Iterating Through Input File for Age Restrictions ***/ if(use_age_ratings == TRUE){//Checking If Age Restictions Are To be used fseek(icn.bsf, 0x00, SEEK_SET); if(key_search("RegionRatings", icn.bsf) == FOUND){ long int pos0 = ftell(icn.bsf); u8 region_rating; for(int i = 0; i < MAX_RATING_NUM; i++){ fseek(icn.bsf, pos0, SEEK_SET); u8 rating_index = region_rating_struct_index[i]; if(get_value(region_rating_string,2,region_rating_key[i],icn.bsf) == FOUND){ char_to_int_array(®ion_rating, region_rating_string, 1, BIG_ENDIAN, DEC); int rating_type = INVALID_RATING; for(int j = 0; j < region_age_num[i]; j++){ if(region_age[i][j] == region_rating){ rating_type = VALID_RATING; break; } } if(rating_type == VALID_RATING){ region_rating += 0x80; //Active Rating bitflag icn.settings.ratings.rating[rating_index] = region_rating; if(icn.verbose_bool) printf("[+] Age Restriction for %s was set to %d\n",region_rating_key[i], (region_rating - 0x80)); } else{ printf("[!] Age Restriction for %s %d, is Invalid.\n",region_rating_key[i], region_rating); icn.settings.ratings.rating[rating_index] = 0x00; } } else{ value_find_fail(region_rating_key[i]); icn.settings.ratings.rating[rating_index] = 0x00; } } } } else{//If Age Restrictions are not to be used for(int i = 0; i < MAX_RATING_NUM; i++){ u8 rating_index = region_rating_struct_index[i]; icn.settings.ratings.rating[rating_index] = 0x00; } } /** Processing Region Lock **/ u8 region_lock_list[MAX_REGION_LOCK_NUM][15] = {"Japan", "America", "Europe", "Australia", "China", "Korea", "Taiwan"}; u8 region_bit_flag_value[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; fseek(icn.bsf, 0x00, SEEK_SET); if(key_search("Options", icn.bsf) == FOUND){ if(key_search("RegionLockout", icn.bsf) == FOUND){ long int pos0 = ftell(icn.bsf); for(int i = 0; i < MAX_REGION_LOCK_NUM; i++){ fseek(icn.bsf, pos0, SEEK_SET); if (get_boolean(region_lock_list[i], icn.bsf) == TRUE){ if(icn.verbose_bool) printf("[+] Region Lock was set to include %s\n",region_lock_list[i]); icn.settings.region_lock[0] += region_bit_flag_value[i]; } else if(icn.verbose_bool) printf("[+] Region Lock was set to exclude %s\n",region_lock_list[i]); } } else{ key_find_fail("RegionLockout"); return REGION_LOCKOUT_FAIL; } } else{ key_find_fail("Options"); return REGION_LOCKOUT_FAIL; } /** // This may need to be more complex u8 region_lock_list_1[MAX_REGION_LOCK_NUM][15] = {"Region_Free", "Japan", "America", "Europe", "Australia", "China", "Korea", "Taiwan"}; u8 region_lock_list_2[MAX_REGION_LOCK_NUM][5] = {"All", "JPN", "USA", "EUR", "AUS", "CHN", "KOR", "TWN"}; u8 region_lock_hex[MAX_REGION_LOCK_NUM][8] = {"7FFFFFFF", "00000001", "00000002", "00000004", "00000008", "0000010", "00000020", "00000040"}; fseek(icn.bsf, 0x00, SEEK_SET); if(key_search("Options", icn.bsf) == FOUND){ if (get_value(buff,15,"RegionLockout", icn.bsf) == FOUND){ for(int i = 0; i < MAX_REGION_LOCK_NUM; i++){ if(strcmp(buff, region_lock_list_1[i]) == 0 || strcmp(buff, region_lock_list_2[i]) == 0){ if(icn.verbose_bool) printf("[+] Region Lock was set to %s\n",region_lock_list_1[i]); char_to_int_array(icn.settings.region_lock, region_lock_hex[i], 4, LITTLE_ENDIAN, HEX); break; } else if( i == (MAX_REGION_LOCK_NUM - 1)){ printf("[!] Invalid Region-Lockout Code: '%s'\n", buff); return REGION_LOCKOUT_FAIL; } } } else{ printf("[!] No Region-Lockout Code was Specified\n"); return REGION_LOCKOUT_FAIL; } } else{ key_find_fail("Options"); return REGION_LOCKOUT_FAIL; } **/ /** Processing EULA Version **/ fseek(icn.bsf, 0x00, SEEK_SET); if(key_search("Options", icn.bsf) == FOUND){ long int pos0 = ftell(icn.bsf); if (get_value(buff,2,"EulaMajorVersion",icn.bsf) == FOUND){ char_to_int_array(&icn.settings.eula_major, buff, 1, BIG_ENDIAN, HEX); } else{ printf("[!] EulaMajorVersion was not specified\n"); return EULA_VER_FAIL; } fseek(icn.bsf, pos0, SEEK_SET); if (get_value(buff,2,"EulaMinorVersion",icn.bsf) == FOUND){ char_to_int_array(&icn.settings.eula_minor, buff, 1, BIG_ENDIAN, HEX); } else{ printf("[!] EulaMinorVersion was not specified\n"); return EULA_VER_FAIL; } if(icn.verbose_bool){ printf("[+] EULA Version was set to %02x.%02x\n",icn.settings.eula_major,icn.settings.eula_minor); } } else{ key_find_fail("Options"); return REGION_LOCKOUT_FAIL; } /** Processing Default Banner Frame **/ u8 default_frame[MAX_READ_LEN]; fseek(icn.bsf, 0x00, SEEK_SET); if(key_search("Options", icn.bsf) == FOUND){ if (get_value(default_frame,100,"OptimalBNRFrame",icn.bsf) == FOUND){ //if(icn.verbose_bool) // printf("[+] OptimalBNRFrame was set to %f\n",default_frame); //Doesn't work union { float f; unsigned char b[sizeof(float)]; } v = { atof(default_frame) }; u8 default_frame_hex[8]; sprintf(default_frame_hex, "%02X%02X%02X%02X\0",v.b[3],v.b[2],v.b[1],v.b[0]); char_to_int_array(icn.settings.optimal_bnr_frame, default_frame_hex, 4, LITTLE_ENDIAN, HEX); } else{ value_find_fail("Default BNR Frame"); return OPTM_BNR_FAIL; } } else{ key_find_fail("Options"); return OPTM_BNR_FAIL; } /** Processing IDs **/ fseek(icn.bsf, 0x00, SEEK_SET); if(key_search("IDs", icn.bsf) == FOUND){ long int pos0 = ftell(icn.bsf); //MatchMaker ID if(get_value(buff,0x8,"MatchMakerID",icn.bsf) == FOUND){ char_to_int_array(icn.settings.match_maker_id, buff, sizeof(icn.settings.match_maker_id), LITTLE_ENDIAN, HEX); printf("Not MMID\n"); } else{ value_find_fail("MatchMakerID"); return ID_FAIL; } //MatchMakerBIT ID fseek(icn.bsf, pos0, SEEK_SET); if(get_value(buff,0x10,"MatchMakerBITID",icn.bsf) == FOUND){ printf("Is MMBID\n"); char_to_int_array(icn.settings.match_maker_bit_id, buff, sizeof(icn.settings.match_maker_bit_id), LITTLE_ENDIAN, HEX); printf("Not MMBID\n"); } else{ value_find_fail("MatchMakerBITID"); return ID_FAIL; } //CEC ID fseek(icn.bsf, pos0, SEEK_SET); if(get_value(buff,0x8,"CECID",icn.bsf) == FOUND){ char_to_int_array(icn.settings.cec_id, buff, sizeof(icn.settings.cec_id), LITTLE_ENDIAN, HEX); printf("Not CECID\n"); } else{ value_find_fail("CECID"); return ID_FAIL; } } else{ key_find_fail("IDs"); return ID_FAIL; } /** Writing To File **/ fseek(icn.output, FLAG_OFFSET, SEEK_SET); fwrite(&icn.settings, sizeof(icn.settings), 1, icn.output); /** Return, all is good **/ return 0; }