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;
}
