static void ParseOptGameList(SourceFileType file_type) { Move *move_list = NULL; while(ParseGame(&move_list) && !finished_processing()) { if(file_type == NORMALFILE) { DealWithGame(move_list); } else if(file_type == CHECKFILE) { DealWithGame(move_list); } else if(file_type == ECOFILE) { if(move_list != NULL) { DealWithEcoLine(move_list); } else { fprintf(GlobalState.logfile,"ECO line with zero moves.\n"); report_details(GlobalState.logfile); } } else { /* Unknown type. */ free_tags(); free_move_list(move_list); } move_list = NULL; setup_for_new_game(); } }
void cleanup(void) { pcap_freecode(&fp); pcap_close(handle); if(buff_frag) free(buff_frag); free_tags(); }
void handle_sighup(int signo) { print_stats(); total_mysql_pkts = total_mysql_bytes = 0; free_tags(); printf("Connection tracking has been reset\n"); }
void free_slice(Slice *s) /* Free the space associated with the vectors in the given Slice */ /* Then free the Slice variable itself */ { free_tags(s); free_data(s); free(s); return; }
VIOAPI void free_tag_points( int n_volumes, int n_tag_points, VIO_Real **tags_volume1, VIO_Real **tags_volume2, VIO_Real weights[], int structure_ids[], int patient_ids[], char **labels ) { int i; if( n_tag_points > 0 ) { free_tags( tags_volume1, n_tag_points ); if( n_volumes == 2 ) free_tags( tags_volume2, n_tag_points ); if( weights != (VIO_Real *) NULL ) FREE( weights ); if( structure_ids != (int *) NULL ) FREE( structure_ids ); if( patient_ids != (int *) NULL ) FREE( patient_ids ); if( labels != (char **) NULL ) { for( i = 0; i < n_tag_points; ++i ) delete_string( labels[i] ); if( n_tag_points > 0 ) FREE( labels ); } } }
int he_seek_sample (DB_fileinfo_t *_info, int sample) { he_info_t *info = (he_info_t *)_info; unsigned long int s = sample; if (s < info->samples_played) { struct psf_load_state state; memset( &state, 0, sizeof(state) ); state.emu = info->emu; if ( !info->psf2fs ) { psx_clear_state( info->emu, 1 ); if ( psf_load( info->path, &psf_file_system, 1, psf1_load, &state, psf_info_meta, &state, 0 ) <= 0 ) { trace( "he: invalid PSF file\n" ); return -1; } } else { psx_clear_state( info->emu, 2 ); if ( psf_load( info->path, &psf_file_system, 2, 0, 0, psf_info_meta, &state, 0 ) <= 0 ) { trace( "he: invalid PSF file\n" ); return -1; } psx_set_readfile( info->emu, virtual_readfile, info->psf2fs ); } if ( state.refresh ) psx_set_refresh( info->emu, state.refresh ); info->samples_played = 0; free_tags(state.tags); } while ( info->samples_played < s ) { int to_skip = s - info->samples_played; if ( to_skip > 32768 ) to_skip = 1024; if ( he_read( _info, NULL, to_skip * 2 * sizeof(short) ) < 0 ) { return -1; } } _info->readpos = s/(float)_info->fmt.samplerate; return 0; }
int he_init (DB_fileinfo_t *_info, const char * uri) { he_info_t *info = (he_info_t *)_info; info->path = strdup( uri ); // int psf_version = psf_load( uri, &psf_file_system, 0, 0, 0, 0, 0, 0 ); requiredLib[0]= 0; int psf_version = psf_load( uri, &psf_file_system, 0, 0, 0, psf_lib_meta, 0, 0 ); if (psf_version < 0) { trace ("he: failed to open %s\n", uri); return -1; } if (strlen(requiredLib)) { // lib must be loaded here or else the psf loading will fail.. // (enter "retry-mode" if something is missing) // make sure the file will be available in the FS when the song asks for it later.. char tmpFileName[PATH_MAX]; char *p= strrchr(uri, '/'); int pathlen= p?(p-uri+1):0; memcpy(tmpFileName, uri, pathlen); snprintf(tmpFileName+pathlen, PATH_MAX-pathlen, "%s", requiredLib); int r= psx_request_file(tmpFileName); // trigger load & check if ready if (r <0) { return -1; // file not ready } } char he_bios_path[PATH_MAX]; memset(he_bios_path, 0, PATH_MAX); // set specific BIOS here if needed he_install_bios(he_bios_path); psx_init(); struct psf_load_state state; memset( &state, 0, sizeof(state) ); state.first = 1; state.emu= set_emu(info, malloc( psx_get_state_size( psf_version ) )); if ( !state.emu ) { trace( "he: out of memory\n" ); return -1; } psx_clear_state( state.emu, psf_version ); if ( psf_version == 1 ) { if ( psf_load( uri, &psf_file_system, 1, psf1_load, &state, psf_info_meta, &state, 0 ) <= 0 ) { trace( "he: invalid PSF file\n" ); return -1; } } else if ( psf_version == 2 ) { info->psf2fs = psf2fs_create(); if ( !info->psf2fs ) { trace( "he: out of memory\n" ); return -1; } if ( psf_load( uri, &psf_file_system, 2, psf2fs_load_callback, info->psf2fs, psf_info_meta, &state, 0 ) <= 0 ) { trace( "he: invalid PSF file\n" ); return -1; } psx_set_readfile( info->emu, virtual_readfile, info->psf2fs ); } if ( state.refresh ) psx_set_refresh( info->emu, state.refresh ); int tag_song_ms = state.tag_song_ms; int tag_fade_ms = state.tag_fade_ms; if (!tag_song_ms) { tag_song_ms = ( 2 * 60 + 50 ) * 1000; tag_fade_ms = 10 * 1000; } const int srate = psf_version == 2 ? 48000 : 44100; info->samples_played = 0; info->samples_to_play = (uint64_t)tag_song_ms * (uint64_t)srate / 1000; info->samples_to_fade = (uint64_t)tag_fade_ms * (uint64_t)srate / 1000; _info->fmt.channels = 2; _info->fmt.bps = 16; _info->fmt.samplerate = srate; _info->readpos = 0; free_tags(state.tags); return 0; }
static int psf_load_internal( psf_load_state * state, const char * file_name ) { psf_tag * tags = NULL; psf_tag * tag; char * full_path; void * file; long file_size, tag_size; int n; uint8_t header_buffer[16]; uint8_t * exe_compressed_buffer = NULL; uint8_t * exe_decompressed_buffer = NULL; uint8_t * reserved_buffer = NULL; char * tag_buffer = NULL; uint32_t exe_compressed_size, exe_crc32, reserved_size; uLong exe_decompressed_size, try_exe_decompressed_size; int zerr; size_t full_path_size; if ( ++state->depth > max_recursion_depth ) return -1; full_path_size = strlen(state->base_path) + strlen(file_name) + 1; full_path = (char *) malloc( full_path_size ); if ( !full_path ) return -1; #if _MSC_VER >= 1300 strcpy_s( full_path, full_path_size, state->base_path ); strcat_s( full_path, full_path_size, file_name ); #else strcpy( full_path, state->base_path ); strcat( full_path, file_name ); #endif file = state->file_callbacks->fopen( full_path ); free( full_path ); if ( !file ) return -1; if ( state->file_callbacks->fread( header_buffer, 1, 16, file ) < 16 ) goto error_close_file; if ( memcmp( header_buffer, "PSF", 3 ) ) goto error_close_file; if ( state->allowed_version && ( header_buffer[ 3 ] != state->allowed_version ) ) goto error_close_file; reserved_size = header_buffer[ 4 ] | ( header_buffer[ 5 ] << 8 ) | ( header_buffer[ 6 ] << 16 ) | ( header_buffer[ 7 ] << 24 ); exe_compressed_size = header_buffer[ 8 ] | ( header_buffer[ 9 ] << 8 ) | ( header_buffer[ 10 ] << 16 ) | ( header_buffer[ 11 ] << 24 ); exe_crc32 = header_buffer[ 12 ] | ( header_buffer[ 13 ] << 8 ) | ( header_buffer[ 14 ] << 16 ) | ( header_buffer[ 15 ] << 24 ); if ( state->file_callbacks->fseek( file, 0, SEEK_END ) ) goto error_close_file; file_size = state->file_callbacks->ftell( file ); if ( file_size <= 0 ) goto error_close_file; if ( (unsigned long)file_size >= 16 + reserved_size + exe_compressed_size + 5 ) { tag_size = file_size - ( 16 + reserved_size + exe_compressed_size ); if ( state->file_callbacks->fseek( file, -tag_size, SEEK_CUR ) ) goto error_close_file; tag_buffer = (char *) malloc( tag_size + 1 ); if ( !tag_buffer ) goto error_close_file; if ( state->file_callbacks->fread( tag_buffer, 1, tag_size, file ) < (size_t)tag_size ) goto error_free_buffers; tag_buffer[ tag_size ] = 0; if ( !memcmp( tag_buffer, "[TAG]", 5 ) ) tags = process_tags( tag_buffer + 5 ); free( tag_buffer ); tag_buffer = NULL; if ( tags && state->info_target && ( state->depth == 1 || state->info_want_nested_tags ) ) { tag = tags; while ( tag->next ) tag = tag->next; while ( tag ) { state->info_target( state->info_context, tag->name, tag->value ); tag = tag->prev; } } } if ( !state->load_target ) goto done; tag = find_tag( tags, "_lib" ); if ( tag ) { if ( psf_load_internal( state, tag->value ) < 0 ) goto error_free_tags; } reserved_buffer = (uint8_t *) malloc( reserved_size ); if ( !reserved_buffer ) goto error_free_tags; exe_compressed_buffer = (uint8_t *) malloc( exe_compressed_size ); if ( !exe_compressed_buffer ) goto error_free_tags; if ( state->file_callbacks->fseek( file, 16, SEEK_SET ) ) goto error_free_tags; if ( reserved_size && state->file_callbacks->fread( reserved_buffer, 1, reserved_size, file ) < reserved_size ) goto error_free_tags; if ( exe_compressed_size && state->file_callbacks->fread( exe_compressed_buffer, 1, exe_compressed_size, file ) < exe_compressed_size ) goto error_free_tags; state->file_callbacks->fclose( file ); file = NULL; if ( exe_compressed_size ) { if ( exe_crc32 != crc32(crc32(0L, Z_NULL, 0), exe_compressed_buffer, exe_compressed_size) ) goto error_free_tags; exe_decompressed_size = try_exe_decompressed_size = exe_compressed_size * 3; exe_decompressed_buffer = (uint8_t *) malloc( exe_decompressed_size ); if ( !exe_decompressed_buffer ) goto error_free_tags; while ( Z_OK != ( zerr = uncompress( exe_decompressed_buffer, &exe_decompressed_size, exe_compressed_buffer, exe_compressed_size ) ) ) { void * try_exe_decompressed_buffer; if ( Z_MEM_ERROR != zerr && Z_BUF_ERROR != zerr ) goto error_free_tags; if ( try_exe_decompressed_size < 1 * 1024 * 1024 ) try_exe_decompressed_size += 1 * 1024 * 1024; else try_exe_decompressed_size += try_exe_decompressed_size; exe_decompressed_size = try_exe_decompressed_size; try_exe_decompressed_buffer = realloc( exe_decompressed_buffer, exe_decompressed_size ); if ( !try_exe_decompressed_buffer ) goto error_free_tags; exe_decompressed_buffer = (uint8_t *) try_exe_decompressed_buffer; } } else { exe_decompressed_size = 0; exe_decompressed_buffer = (uint8_t *) malloc( exe_decompressed_size ); if ( !exe_decompressed_buffer ) goto error_free_tags; } free( exe_compressed_buffer ); exe_compressed_buffer = NULL; if ( state->load_target( state->load_context, exe_decompressed_buffer, exe_decompressed_size, reserved_buffer, reserved_size ) ) goto error_free_tags; free( reserved_buffer ); reserved_buffer = NULL; free( exe_decompressed_buffer ); exe_decompressed_buffer = NULL; n = 2; snprintf( state->lib_name_temp, 31, "_lib%u", n ); state->lib_name_temp[ 31 ] = '\0'; tag = find_tag( tags, state->lib_name_temp ); while ( tag ) { if ( psf_load_internal( state, tag->value ) < 0 ) goto error_free_tags; ++n; snprintf( state->lib_name_temp, 31, "_lib%u", n ); state->lib_name_temp[ 31 ] = '\0'; tag = find_tag( tags, state->lib_name_temp ); } done: if ( file ) state->file_callbacks->fclose( file ); free_tags( tags ); --state->depth; return header_buffer[ 3 ]; error_free_tags: free_tags( tags ); error_free_buffers: if ( exe_compressed_buffer ) free( exe_compressed_buffer ); if ( exe_decompressed_buffer ) free( exe_decompressed_buffer ); if ( reserved_buffer ) free( reserved_buffer ); if ( tag_buffer ) free( tag_buffer ); error_close_file: if ( file ) state->file_callbacks->fclose( file ); return -1; }
struct uuid_result create_and_log_uuids(const struct Options *opt) { struct uuid_result retval; char *rcfile = NULL, *logfile = NULL; unsigned int i, count; struct Rc rc; struct Entry entry; struct Logs logs; assert(opt); logs.logfp = NULL; count = opt->count; retval.count = 0; memset(retval.lastuuid, 0, UUID_LENGTH + 1); retval.success = TRUE; init_xml_entry(&entry); /* * Get information about the environment; hostname, current directory, * tty, location of rc file and log directory, etc. */ if (init_randomness() == EXIT_FAILURE) { retval.success = FALSE; goto cleanup; } rcfile = get_rcfilename(opt); if (read_rcfile(rcfile, &rc) == EXIT_FAILURE) { retval.success = FALSE; goto cleanup; } if (fill_entry_struct(&entry, &rc, opt) == EXIT_FAILURE) { retval.success = FALSE; goto cleanup; } logfile = get_log_prefix(&rc, opt, ".xml"); if (!logfile) { retval.success = FALSE; goto cleanup; } signal(SIGHUP, sighandler); signal(SIGINT, sighandler); signal(SIGQUIT, sighandler); signal(SIGPIPE, sighandler); signal(SIGTERM, sighandler); /* * Open the log file. If it's missing, create it. */ logs.logfp = open_logfile(logfile); if (!logs.logfp) { retval.success = FALSE; goto cleanup; } /* * Generate the UUIDs and write them to the log file. */ if (opt->uuid) count = 1; for (i = 0; i < count; i++) { if (!process_uuid(&logs, &rc, opt, &entry)) { retval.success = FALSE; goto cleanup; } retval.count++; if (should_terminate) break; } if (valid_uuid(entry.uuid, TRUE)) strncpy(retval.lastuuid, entry.uuid, UUID_LENGTH + 1); /* * Check that the correct amount of UUIDs were created. */ if (retval.count < opt->count) fprintf(stderr, "%s: Generated only %u of %u UUIDs\n", progname, retval.count, opt->count); /* * Close up the shop and go home. */ cleanup: if (logs.logfp && (close_logfile(logs.logfp) == EXIT_FAILURE)) retval.success = FALSE; free(logfile); free_sess(&entry); free_tags(&entry); free(rc.uuidcmd); free(rc.macaddr); free(rc.hostname); free(entry.txt); free(entry.date); free(entry.cwd); free(rcfile); return retval; }