/*
* Recursively create directory path
* Returns 0 on success
* NOTE: modifies path while in use
*/
int recursive_mkdir(char *dir)
{
char *slash;
int rc = 0;
struct stat stat_buf;
/* check if dir already exists */
rc = stat(dir, &stat_buf);
if (rc == 0) {
if (S_ISDIR(stat_buf.st_mode)) {
return 0;
} else {
fprintf(stderr,
"\"%s\" exists, but is not a directory\n", dir);
return 1;
}
}
/* recursively check if parent directories exist */
slash = strrchr(dir, '/');
if (slash != NULL) {
*slash = '\0';
rc = recursive_mkdir(dir);
*slash = '/';
if (rc != 0)
return rc;
}
/* make directory */
rc = mkdir(dir, 0777);
if (rc != 0)
fprintf(stderr, "mkdir(\"%s\", 0777) failed: %d\n", dir, errno);
return rc;
}
static int recursive_mkdir( vlc_object_t *p_this, const char *psz_dirname )
{/* stolen from config_CreateDir() */
if( !psz_dirname || !*psz_dirname ) return -1;
if( vlc_mkdir( psz_dirname, 0700 ) == 0 )
return 0;
switch( errno )
{
case EEXIST:
return 0;
case ENOENT:
{
/* Let's try to create the parent directory */
char psz_parent[strlen( psz_dirname ) + 1], *psz_end;
strcpy( psz_parent, psz_dirname );
psz_end = strrchr( psz_parent, DIR_SEP_CHAR );
if( psz_end && psz_end != psz_parent )
{
*psz_end = '\0';
if( recursive_mkdir( p_this, psz_parent ) == 0 )
{
if( !vlc_mkdir( psz_dirname, 0700 ) )
return 0;
}
}
}
}
msg_Warn( p_this, "could not create %s: %m", psz_dirname );
return -1;
}
int main(int argc, char **argv)
{
int i;
struct count_log_data log = {0, 0, NULL};
/* Check for -h parameter before MPI_Init */
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
usage();
}
}
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
if (mpi_rank == 0) {
printf("createabunch is running with %d process(es)\n", mpi_size);
fflush(stdout);
}
parse_command_line(argc, argv);
if (mpi_rank == 0 && recursive_mkdir(args.test_directory_name) != 0) {
MPI_Abort(MPI_COMM_WORLD, 3);
}
enlarge_log(&log);
createabunch(&log);
dump_aggregate_log_data(&log);
if (args.dump_all_tasks_data)
dump_all_log_data(&log);
MPI_Finalize();
exit(0);
}
struct SharedLibrary*
apk_get_shared_libraries(AndroidApk *apk, const char* libdir)
{
assert(apk != NULL);
char filename[PATH_MAX];
FILE *result = NULL;
char buf[64*1024];
int read;
struct SharedLibrary *libs = 0;
struct SharedLibrary *head = 0;
int libdirlen = strlen(libdir);
if (unzGoToFirstFile(apk->zip) != UNZ_OK) {
return NULL;
}
do {
if (unzGetCurrentFileInfo(apk->zip, NULL, filename, sizeof(filename), NULL, 0, NULL, 0) == UNZ_OK) {
if (memcmp(filename, libdir, libdirlen) == 0) {
if (unzOpenCurrentFile(apk->zip) == UNZ_OK) {
#if !defined(PANDORA)
strcpy(filename, "/home/user/.apkenv-XXXXXX");
int fd = mkstemp(filename);
result = fdopen(fd, "w+b");
#else
sprintf(filename,"./%s",strdup(filename));
recursive_mkdir(filename);
result = fopen(filename, "w+b");
#endif
while (!unzeof(apk->zip)) {
read = unzReadCurrentFile(apk->zip, buf, sizeof(buf));
if (read) {
assert(fwrite(buf, read, 1, result) == 1);
}
}
fclose(result);
unzCloseCurrentFile(apk->zip);
#if defined(PANDORA)
sync();
#endif
if (libs==0) {
libs = malloc(sizeof(struct SharedLibrary));
head = libs;
libs->next = 0;
} else {
libs->next = malloc(sizeof(struct SharedLibrary));
libs->next->next = 0;
libs = libs->next;
}
libs->filename = strdup(filename);
}
}
}
} while (unzGoToNextFile(apk->zip) == UNZ_OK);
return head;
}
/* A file in this case is a translation unit. Each .o file built with line
* profiling enabled will emit to a different file. Only one file may be
* started at a time.
*/
void llvm_gcda_start_file(const char *orig_filename, const char version[4],
uint32_t checksum) {
const char *mode = "r+b";
filename = mangle_filename(orig_filename);
/* Try just opening the file. */
new_file = 0;
fd = open(filename, O_RDWR);
if (fd == -1) {
/* Try opening the file, creating it if necessary. */
new_file = 1;
mode = "w+b";
fd = open(filename, O_RDWR | O_CREAT, 0644);
if (fd == -1) {
/* Try creating the directories first then opening the file. */
recursive_mkdir(filename);
fd = open(filename, O_RDWR | O_CREAT, 0644);
if (fd == -1) {
/* Bah! It's hopeless. */
int errnum = errno;
fprintf(stderr, "profiling: %s: cannot open: %s\n", filename,
strerror(errnum));
return;
}
}
}
output_file = fdopen(fd, mode);
/* Initialize the write buffer. */
write_buffer = NULL;
cur_buffer_size = 0;
cur_pos = 0;
if (new_file) {
resize_write_buffer(WRITE_BUFFER_SIZE);
memset(write_buffer, 0, WRITE_BUFFER_SIZE);
} else {
if (map_file() == -1) {
/* mmap failed, try to recover by clobbering */
new_file = 1;
write_buffer = NULL;
cur_buffer_size = 0;
resize_write_buffer(WRITE_BUFFER_SIZE);
memset(write_buffer, 0, WRITE_BUFFER_SIZE);
}
}
/* gcda file, version, stamp checksum. */
write_bytes("adcg", 4);
write_bytes(version, 4);
write_32bit_value(checksum);
#ifdef DEBUG_GCDAPROFILING
fprintf(stderr, "llvmgcda: [%s]\n", orig_filename);
#endif
}
int os_mkdirs(const char *dir)
{
struct dstr dir_str;
int ret;
dstr_init_copy(&dir_str, dir);
dstr_replace(&dir_str, "\\", "/");
ret = recursive_mkdir(dir_str.array);
dstr_free(&dir_str);
return ret;
}
static int InstallFile( addons_storage_t *p_this, const char *psz_downloadlink,
const char *psz_dest )
{
stream_t *p_stream;
FILE *p_destfile;
char buffer[1<<10];
int i_read = 0;
p_stream = stream_UrlNew( p_this, psz_downloadlink );
if( !p_stream )
{
msg_Err( p_this, "Failed to access Addon download url %s", psz_downloadlink );
return VLC_EGENERIC;
}
char *psz_path = strdup( psz_dest );
if ( !psz_path )
{
stream_Delete( p_stream );
return VLC_ENOMEM;
}
char *psz_buf = strrchr( psz_path, DIR_SEP_CHAR );
if( psz_buf )
{
*++psz_buf = '\0';
/* ensure directory exists */
if( !EMPTY_STR( psz_path ) ) recursive_mkdir( VLC_OBJECT(p_this), psz_path );
free( psz_path );
}
p_destfile = vlc_fopen( psz_dest, "w" );
if( !p_destfile )
{
msg_Err( p_this, "Failed to open Addon storage file %s", psz_dest );
stream_Delete( p_stream );
return VLC_EGENERIC;
}
while ( ( i_read = stream_Read( p_stream, &buffer, 1<<10 ) ) > 0 )
{
if ( fwrite( &buffer, i_read, 1, p_destfile ) < 1 )
{
msg_Err( p_this, "Failed to write to Addon file" );
fclose( p_destfile );
stream_Delete( p_stream );
return VLC_EGENERIC;
}
}
fclose( p_destfile );
stream_Delete( p_stream );
return VLC_SUCCESS;
}
// this function writes an IPv6 compliance warning, with its description and
// the current process stack, and writes the log
void write_problem(int is_an_error, char *title, char *content)
{
FILE *file;
char *directory_path_alloc, *directory_path;
char *full_filename_alloc;
directory_path = get_or_create_the_directory_related_to_the_thread();
if (directory_path != NULL)
{
asprintf(&directory_path_alloc, "%s/%s/%s", directory_path,
(is_an_error == ERROR) ? __IPV6_COMPLIANCE_ERRORS_DIR : __IPV6_COMPLIANCE_WARNINGS_DIR,
title);
// try to create the directory
if (recursive_mkdir(directory_path_alloc) != 0)
{ // error already reported in recursive_mkdir()
free(directory_path_alloc);
return;
}
else
{
// write stack
write_stack_file(directory_path_alloc);
// create problem description filename
asprintf(&full_filename_alloc, "%s/%s", directory_path_alloc, __PROBLEM_DESCRIPTION_FILENAME);
free(directory_path_alloc);
// open the file
file = fopen(full_filename_alloc, "w");
free(full_filename_alloc);
// write content
fprintf(file, "%s", content);
if (interpreted_language == 1)
{
fprintf(file, "%s", WARNING_INTERPRETED_LANGUAGE);
}
// close
fclose(file);
log_if_needed();
}
}
}
/* Returns:
* 0 if everything was OK,
* -1 for a general error (sets errno),
* -2 if an existing path element was not a directory.
*/
static int
recursive_mkdir (const char *path)
{
int loop = 0;
int r;
char *ppath, *p;
struct stat buf;
again:
r = mkdir (path, 0777);
if (r == -1) {
if (errno == EEXIST) { /* Something exists here, might not be a dir. */
r = lstat (path, &buf);
if (r == -1) return -1;
if (!S_ISDIR (buf.st_mode)) return -2;
return 0; /* OK - directory exists here already. */
}
if (!loop && errno == ENOENT) {
loop = 1; /* Stops it looping forever. */
/* If we're at the root, and we failed, just give up. */
if (path[0] == '/' && path[1] == '\0') return -1;
/* Try to make the parent directory first. */
ppath = strdup (path);
if (ppath == NULL) return -1;
p = strrchr (ppath, '/');
if (p) *p = '\0';
r = recursive_mkdir (ppath);
free (ppath);
if (r != 0) return r;
goto again;
} else /* Failed for some other reason, so return error. */
return -1;
}
return 0;
}
int
do_mkdir_p (const char *path)
{
int r;
CHROOT_IN;
r = recursive_mkdir (path);
CHROOT_OUT;
if (r == -1) {
reply_with_perror ("%s", path);
return -1;
}
if (r == -2) {
reply_with_error ("%s: a path element was not a directory", path);
return -1;
}
return 0;
}
bool
recursive_mkdir(const string& dir, mode_t mode)
{
struct stat sb;
if (stat(dir.c_str(), &sb) == 0)
return S_ISDIR(sb.st_mode);
size_t sepIdx = dir.find_last_of('/');
bool success = true;
if (sepIdx != dir.npos)
success = recursive_mkdir(dir.substr(0, sepIdx), mode);
if (success)
{
success = mkdir(dir.c_str(), mode) == 0;
success = success || (!success && errno != EEXIST);
}
return success;
}
int
MakeDir( const char* path, int permissions )
{
int retValue = recursive_mkdir( path, permissions );
if ( retValue == 0 )
{
FLOGI( "created dir: %s", path );
}
else
{
if ( EEXIST == errno )
{
FLOGI( "found existing dir: %s", path );
return 1;
}
else
{
FLOGI( "error %i creating dir: %s", errno, path );
}
}
return retValue == 0 ? 1 : 0;
}
static int recursive_mkdir(char *path)
{
char *last_slash;
int ret;
ret = os_mkdir(path);
if (ret != MKDIR_ERROR)
return ret;
last_slash = strrchr(path, '/');
if (!last_slash)
return MKDIR_ERROR;
*last_slash = 0;
ret = recursive_mkdir(path);
*last_slash = '/';
if (ret == MKDIR_ERROR)
return MKDIR_ERROR;
ret = os_mkdir(path);
return ret;
}
static FILE*
dir_fopen(const char *dir, const char *path, const char *mode)
{
char outfn[512];
char *p;
int len;
strcpy(outfn, "./");
strcat(outfn, dir);
len = strlen(outfn);
if (outfn[len-1] != '/' && path[0] != '/')
strcat(outfn, "/");
strcat(outfn, path);
/* If there's a directory path in there, create it */
p = strrchr(outfn, '/');
if (*p) {
*p = '\0';
recursive_mkdir(outfn);
*p = '/';
}
return fopen(outfn, mode);
}
static int WriteCatalog( addons_storage_t *p_storage,
addon_entry_t **pp_entries, int i_entries )
{
addon_entry_t *p_entry;
char *psz_file;
char *psz_file_tmp;
char *psz_tempstring;
char *psz_userdir = config_GetUserDir( VLC_DATA_DIR );
if ( !psz_userdir ) return VLC_ENOMEM;
if ( asprintf( &psz_file, "%s%s", psz_userdir, ADDONS_CATALOG ) < 1 )
{
free( psz_userdir );
return VLC_ENOMEM;
}
free( psz_userdir );
if ( asprintf( &psz_file_tmp, "%s.tmp%"PRIu32, psz_file, (uint32_t)getpid() ) < 1 )
{
free( psz_file );
return VLC_ENOMEM;
}
char *psz_path = strdup( psz_file );
if ( !psz_path )
{
free( psz_file );
free( psz_file_tmp );
return VLC_ENOMEM;
}
char *psz_buf = strrchr( psz_path, DIR_SEP_CHAR );
if( psz_buf )
{
*++psz_buf = '\0';
/* ensure directory exists */
if( !EMPTY_STR( psz_path ) ) recursive_mkdir( VLC_OBJECT(p_storage), psz_path );
}
free( psz_path );
FILE *p_catalog = vlc_fopen( psz_file_tmp, "wt" );
if ( !p_catalog )
{
free( psz_file );
free( psz_file_tmp );
return VLC_EGENERIC;
}
/* write XML header */
fprintf( p_catalog, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" );
fprintf( p_catalog, "<videolan xmlns=\"http://videolan.org/ns/vlc/addons/1.0\">\n" );
fprintf( p_catalog, "\t<addons>\n" );
for ( int i=0; i<i_entries; i++ )
{
p_entry = pp_entries[i];
vlc_mutex_lock( &p_entry->lock );
psz_tempstring = NULL;
if ( ( p_entry->e_state != ADDON_INSTALLED ) ||
!( p_entry->e_flags & ADDON_MANAGEABLE ) )
{
vlc_mutex_unlock( &p_entry->lock );
continue;
}
if ( p_entry->psz_source_module )
psz_tempstring = vlc_xml_encode( p_entry->psz_source_module );
char *psz_uuid = addons_uuid_to_psz( ( const addon_uuid_t * ) & p_entry->uuid );
fprintf( p_catalog, "\t\t<addon source=\"%s\" type=\"%s\" id=\"%s\" "
"downloads=\"%ld\" score=\"%d\"",
( psz_tempstring ) ? psz_tempstring : "",
getTypePsz( p_entry->e_type ),
psz_uuid,
p_entry->i_downloads,
p_entry->i_score );
free( psz_uuid );
free( psz_tempstring );
WRITE_WITH_ENTITIES( " version=\"%s\"", p_entry->psz_version )
fprintf( p_catalog, ">\n" );
WRITE_WITH_ENTITIES( "\t\t\t<name>%s</name>\n", p_entry->psz_name )
WRITE_WITH_ENTITIES( "\t\t\t<summary>%s</summary>\n", p_entry->psz_summary )
if ( p_entry->psz_description )
{
psz_tempstring = p_entry->psz_description;
/* FIXME: do real escaping */
while( ( psz_tempstring = strstr( psz_tempstring, "]]>" ) ) )
*psz_tempstring = ' ';
fprintf( p_catalog, "\t\t\t<description><![CDATA[%s]]></description>\n", p_entry->psz_description );
}
WRITE_WITH_ENTITIES( "\t\t\t<image>%s</image>\n", p_entry->psz_image_data )
WRITE_WITH_ENTITIES( "\t\t\t<archive>%s</archive>\n", p_entry->psz_archive_uri )
fprintf( p_catalog, "\t\t\t<authorship>\n" );
WRITE_WITH_ENTITIES( "\t\t\t\t<creator>%s</creator>\n", p_entry->psz_author )
WRITE_WITH_ENTITIES( "\t\t\t\t<sourceurl>%s</sourceurl>\n", p_entry->psz_source_uri )
fprintf( p_catalog, "\t\t\t</authorship>\n" );
FOREACH_ARRAY( addon_file_t *p_file, p_entry->files )
psz_tempstring = vlc_xml_encode( p_file->psz_filename );
fprintf( p_catalog, "\t\t\t<resource type=\"%s\">%s</resource>\n",
getTypePsz( p_file->e_filetype ), psz_tempstring );
free( psz_tempstring );
FOREACH_END();
fprintf( p_catalog, "\t\t</addon>\n" );
vlc_mutex_unlock( &p_entry->lock );
}
fprintf( p_catalog, "\t</addons>\n" );
fprintf( p_catalog, "</videolan>\n" );
fclose( p_catalog );
int i_ret = vlc_rename( psz_file_tmp, psz_file );
free( psz_file );
free( psz_file_tmp );
if( i_ret == -1 )
{
msg_Err( p_storage, "could not rename temp catalog: %s",
vlc_strerror_c(errno) );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
int
nandroid_back_exe()
{
SetDataState("Starting", "backup", 0, 0);
if (ensure_path_mounted(SDCARD_ROOT) != 0) {
ui_print("-- Could not mount: %s.\n-- Aborting.\n",SDCARD_ROOT);
SetDataState("Unable to mount", "/sdcard", 1, 1);
return 1;
}
// Create backup folder
struct tm *t;
char timestamp[64];
char image_dir[255];
char exe[255];
time_t start, stop;
time_t seconds;
seconds = time(0);
t = localtime(&seconds);
sprintf(timestamp,"%04d-%02d-%02d--%02d-%02d-%02d",t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec); // make time stamp
sprintf(image_dir,"%s/%s/%s/", backup_folder, device_id, timestamp); // for backup folder
if (recursive_mkdir(image_dir))
{
LOGE("Unable to create folder: '%s'\n", backup_folder);
SetDataState("Backup failed", image_dir, 1, 1);
return -1;
}
// Record the start time
time(&start);
// Prepare operation
ui_print("\n[BACKUP STARTED]\n");
ui_print(" * Backup Folder: %s\n", backup_folder);
ui_print(" * Verifying filesystems...\n");
verifyFst();
createFstab();
ui_print(" * Verifying partition sizes...\n");
updateUsedSized();
unsigned long long sdc_free = sdcext.sze - sdcext.used;
// Compute totals
int total = 0;
unsigned long long total_img_bytes = 0, total_file_bytes = 0;
CalculateBackupDetails(&total, &total_img_bytes, &total_file_bytes);
unsigned long long total_bytes = total_img_bytes + total_file_bytes;
if (total == 0 || total_bytes == 0)
{
LOGE("Unable to compute target usage (%d partitions, %llu bytes)\n", total, total_bytes);
SetDataState("Backup failed", image_dir, 1, 1);
return -1;
}
ui_print(" * Total number of partition to back up: %d\n", total);
ui_print(" * Total size of all data, in KB: %llu\n", total_bytes / 1024);
ui_print(" * Available space on the SD card, in KB: %llu\n", sdc_free / 1024);
// We can't verify sufficient space on devices where sdcard is a portion of the data partition
#ifndef RECOVERY_SDCARD_ON_DATA
// Verify space
if (sdc_free < (total_bytes + 0x2000000)) // We require at least 32MB of additional space
{
LOGE("Insufficient space on SDCARD. Required space is %lluKB, available %lluKB\n", (total_bytes + 0x2000000) / 1024, sdc_free / 1024);
SetDataState("Backup failed", image_dir, 1, 1);
return -1;
}
#else
ui_print(" * This device does not support verifying available free space.\n");
#endif
// Prepare progress bar...
unsigned long long img_bytes_remaining = total_img_bytes;
unsigned long long file_bytes_remaining = total_file_bytes;
unsigned long img_byte_time = 0, file_byte_time = 0;
struct stat st;
ui_set_progress(0.0);
// SYSTEM
if (phx_do_backup(VAR_BACKUP_SYSTEM_VAR, &sys, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// DATA
if (phx_do_backup(VAR_BACKUP_DATA_VAR, &dat, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// BOOT
if (phx_do_backup(VAR_BACKUP_BOOT_VAR, &boo, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// RECOVERY
if (phx_do_backup(VAR_BACKUP_RECOVERY_VAR, &rec, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// CACHE
if (phx_do_backup(VAR_BACKUP_CACHE_VAR, &cac, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// SP1
if (phx_do_backup(VAR_BACKUP_SP1_VAR, &sp1, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// SP2
if (phx_do_backup(VAR_BACKUP_SP2_VAR, &sp2, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// SP3
if (phx_do_backup(VAR_BACKUP_SP3_VAR, &sp3, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// ANDROID-SECURE
if (stat(ase.dev, &st) ==0)
if (phx_do_backup(VAR_BACKUP_ANDSEC_VAR, &ase, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
// SD-EXT
if (stat(sde.dev, &st) ==0)
if (phx_do_backup(VAR_BACKUP_SDEXT_VAR, &sde, image_dir, total_img_bytes, total_file_bytes, &img_bytes_remaining, &file_bytes_remaining, &img_byte_time, &file_byte_time)) return 1;
ui_print(" * Verifying filesystems...\n");
verifyFst();
createFstab();
ui_print(" * Verifying partition sizes...\n");
updateUsedSized();
time(&stop);
// Average BPS
unsigned long int img_bps = total_img_bytes / img_byte_time;
unsigned long int file_bps = total_file_bytes / file_byte_time;
LOGI("img_bps = %lu total_img_bytes = %llu img_byte_time = %lu\n", img_bps, total_img_bytes, img_byte_time);
ui_print("Average backup rate for file systems: %lu MB/sec\n", (file_bps / (1024 * 1024)));
ui_print("Average backup rate for imaged drives: %lu MB/sec\n", (img_bps / (1024 * 1024)));
if (DataManager_GetIntValue(VAR_SKIP_MD5_GENERATE_VAR) == 1)
{
// If we're skipping MD5 generation, our BPS is faster by about 1.65
file_bps = (unsigned long) (file_bps / 1.65);
img_bps = (unsigned long) (img_bps / 1.65);
}
img_bps += (DataManager_GetIntValue(VAR_BACKUP_AVG_IMG_RATE) * 4);
img_bps /= 5;
if (DataManager_GetIntValue(VAR_USE_COMPRESSION_VAR)) file_bps += (DataManager_GetIntValue(VAR_BACKUP_AVG_FILE_COMP_RATE) * 4);
else file_bps += (DataManager_GetIntValue(VAR_BACKUP_AVG_FILE_RATE) * 4);
file_bps /= 5;
DataManager_SetIntValue(VAR_BACKUP_AVG_IMG_RATE, img_bps);
if (DataManager_GetIntValue(VAR_USE_COMPRESSION_VAR)) DataManager_SetIntValue(VAR_BACKUP_AVG_FILE_COMP_RATE, file_bps);
else DataManager_SetIntValue(VAR_BACKUP_AVG_FILE_RATE, file_bps);
int total_time = (int) difftime(stop, start);
unsigned long long new_sdc_free = (sdcext.sze - sdcext.used) / (1024 * 1024);
sdc_free /= (1024 * 1024);
ui_print("[%lu MB TOTAL BACKED UP TO SDCARD]\n",(unsigned long) (sdc_free - new_sdc_free));
ui_print("[BACKUP COMPLETED IN %d SECONDS]\n\n", total_time); // the end
SetDataState("Backup Succeeded", "", 0, 1);
return 0;
}
int extract_entry(const int fd, struct tar_t * entry, const char verbosity){
V_PRINT(stdout, "%s\n", entry -> name);
if ((entry -> type == REGULAR) || (entry -> type == NORMAL) || (entry -> type == CONTIGUOUS)){
// create intermediate directories
size_t len = strlen(entry -> name);
char * path = calloc(len + 1, sizeof(char));
strncpy(path, entry -> name, len);
// remove file from path
while (--len && (path[len] != '/'));
path[len] = '\0'; // if nothing was found, path is terminated
if (recursive_mkdir(path, DEFAULT_DIR_MODE, verbosity) < 0){
V_PRINT(stderr, "Error: Could not make directory %s\n", path);
free(path);
return -1;
}
free(path);
if ((entry -> type == REGULAR) || (entry -> type == NORMAL) || (entry -> type == CONTIGUOUS)){
// create file
const unsigned int size = oct2uint(entry -> size, 11);
int f = open(entry -> name, O_WRONLY | O_CREAT | O_TRUNC, oct2uint(entry -> mode, 7) & 0777);
if (f < 0){
RC_ERROR(stderr, "Error: Unable to open file %s: %s\n", entry -> name, strerror(rc));
}
// move archive pointer to data location
if (lseek(fd, 512 + entry -> begin, SEEK_SET) == (off_t) (-1)){
RC_ERROR(stderr, "Error: Bad index: %s\n", strerror(rc));
}
// copy data to file
char buf[512];
int got = 0;
while (got < size){
int r;
if ((r = read_size(fd, buf, MIN(size - got, 512))) < 0){
EXIST_ERROR(stderr, "Error: Unable to read from archive: %s\n", strerror(rc));
}
if (write(f, buf, r) != r){
EXIST_ERROR(stderr, "Error: Unable to write to %s: %s\n", entry -> name, strerror(rc));
}
got += r;
}
close(f);
}
else if ((entry -> type == CHAR) || (entry -> type == BLOCK)){
if (mknod(entry -> name, oct2uint(entry -> mode, 7), (oct2uint(entry -> major, 7) << 20) | oct2uint(entry -> minor, 7)) < 0){
EXIST_ERROR(stderr, "Error: Unable to make device %s: %s\n", entry -> name, strerror(rc));
}
}
}
else if (entry -> type == HARDLINK){
if (link(entry -> link_name, entry -> name) < 0){
EXIST_ERROR(stderr, "Error: Unable to create hardlink %s: %s\n", entry -> name, strerror(rc));
}
}
else if (entry -> type == SYMLINK){
if (symlink(entry -> link_name, entry -> name) < 0){
EXIST_ERROR(stderr, "Error: Unable to make symlink %s: %s\n", entry -> name, strerror(rc));
}
}
else if (entry -> type == CHAR){
if (mknod(entry -> name, S_IFCHR | (oct2uint(entry -> mode, 7) & 0777), (oct2uint(entry -> major, 7) << 20) | oct2uint(entry -> minor, 7)) < 0){
EXIST_ERROR(stderr, "Error: Unable to create directory %s: %s\n", entry -> name, strerror(rc));
}
}
else if (entry -> type == BLOCK){
if (mknod(entry -> name, S_IFBLK | (oct2uint(entry -> mode, 7) & 0777), (oct2uint(entry -> major, 7) << 20) | oct2uint(entry -> minor, 7)) < 0){
EXIST_ERROR(stderr, "Error: Unable to create directory %s: %s\n", entry -> name, strerror(rc));
}
}
else if (entry -> type == DIRECTORY){
if (recursive_mkdir(entry -> name, oct2uint(entry -> mode, 7) & 0777, verbosity) < 0){
EXIST_ERROR(stderr, "Error: Unable to create directory %s: %s\n", entry -> name, strerror(rc));
}
}
else if (entry -> type == FIFO){
if (mkfifo(entry -> name, oct2uint(entry -> mode, 7) & 0777) < 0){
EXIST_ERROR(stderr, "Error: Unable to make pipe %s: %s\n", entry -> name, strerror(rc));
}
}
return 0;
}
/* A file in this case is a translation unit. Each .o file built with line
* profiling enabled will emit to a different file. Only one file may be
* started at a time.
*/
void llvm_gcda_start_file(const char *orig_filename, const char version[4],
uint32_t checksum) {
const char *mode = "r+b";
filename = mangle_filename(orig_filename);
/* Try just opening the file. */
new_file = 0;
fd = open(filename, O_RDWR);
if (fd == -1) {
/* Try opening the file, creating it if necessary. */
new_file = 1;
mode = "w+b";
fd = open(filename, O_RDWR | O_CREAT, 0644);
if (fd == -1) {
/* Try creating the directories first then opening the file. */
recursive_mkdir(filename);
fd = open(filename, O_RDWR | O_CREAT, 0644);
if (fd == -1) {
/* Bah! It's hopeless. */
int errnum = errno;
fprintf(stderr, "profiling: %s: cannot open: %s\n", filename,
strerror(errnum));
return;
}
}
}
/* Try to flock the file to serialize concurrent processes writing out to the
* same GCDA. This can fail if the filesystem doesn't support it, but in that
* case we'll just carry on with the old racy behaviour and hope for the best.
*/
flock(fd, LOCK_EX);
output_file = fdopen(fd, mode);
/* Initialize the write buffer. */
write_buffer = NULL;
cur_buffer_size = 0;
cur_pos = 0;
if (new_file) {
resize_write_buffer(WRITE_BUFFER_SIZE);
memset(write_buffer, 0, WRITE_BUFFER_SIZE);
} else {
if (map_file() == -1) {
/* mmap failed, try to recover by clobbering */
new_file = 1;
write_buffer = NULL;
cur_buffer_size = 0;
resize_write_buffer(WRITE_BUFFER_SIZE);
memset(write_buffer, 0, WRITE_BUFFER_SIZE);
}
}
/* gcda file, version, stamp checksum. */
write_bytes("adcg", 4);
write_bytes(version, 4);
write_32bit_value(checksum);
#ifdef DEBUG_GCDAPROFILING
fprintf(stderr, "llvmgcda: [%s]\n", orig_filename);
#endif
}
int start_ripping_gui(int ripping_flags)
{
char *albumdir, *musicfilename, *file_path = 0;
sacd_reader_t *sacd_reader;
scarletbook_handle_t *handle;
scarletbook_output_t *output;
msgType dialog_type;
int area_idx, i, ret;
uint32_t prev_upper_progress = 0;
uint32_t prev_lower_progress = 0;
uint32_t delta;
int prev_current_track = 0;
uint32_t prev_stats_total_sectors_processed = 0;
uint32_t prev_stats_current_file_sectors_processed = 0;
uint64_t tb_start, tb_freq;
uint64_t tmp_total_ripping_sectors = 0;
char progress_message[64];
sysAtomicSet(&stats_total_sectors, 0);
sysAtomicSet(&stats_total_sectors_processed, 0);
sysAtomicSet(&stats_current_file_total_sectors, 0);
sysAtomicSet(&stats_current_file_sectors_processed, 0);
sysAtomicSet(&stats_current_track, 0);
sysAtomicSet(&stats_total_tracks, 0);
sacd_reader = sacd_open("/dev_bdvd");
if (sacd_reader)
{
handle = scarletbook_open(sacd_reader, 0);
if (check_disc_space(sacd_reader, handle, ripping_flags))
{
ret = sacd_authenticate(sacd_reader);
if (ret != 0)
{
LOG(lm_main, LOG_ERROR, ("authentication failed: %x", ret));
}
// select the channel area
area_idx = ((has_multi_channel(handle) && ripping_flags & RIP_MCH) || !has_two_channel(handle)) ? handle->mulch_area_idx : handle->twoch_area_idx;
albumdir = get_album_dir(handle);
output = scarletbook_output_create(handle, handle_status_update_track_callback, handle_status_update_progress_callback, safe_fwprintf);
if (ripping_flags & RIP_ISO)
{
#define FAT32_SECTOR_LIMIT 2090000
uint32_t total_sectors = sacd_get_total_sectors(sacd_reader);
uint32_t sector_size = FAT32_SECTOR_LIMIT;
uint32_t sector_offset = 0;
if (total_sectors > FAT32_SECTOR_LIMIT)
{
musicfilename = (char *) malloc(512);
file_path = make_filename(output_device, 0, albumdir, "iso");
for (i = 1; total_sectors != 0; i++)
{
sector_size = min(total_sectors, FAT32_SECTOR_LIMIT);
snprintf(musicfilename, 512, "%s.%03d", file_path, i);
scarletbook_output_enqueue_raw_sectors(output, sector_offset, sector_size, musicfilename, "iso");
sector_offset += sector_size;
total_sectors -= sector_size;
}
free(file_path);
free(musicfilename);
}
else
{
file_path = make_filename(output_device, 0, albumdir, "iso");
scarletbook_output_enqueue_raw_sectors(output, 0, total_sectors, file_path, "iso");
free(file_path);
}
tmp_total_ripping_sectors = sacd_get_total_sectors(sacd_reader);
}
else
{
// do not overwrite previous dump
get_unique_dir(output_device, &albumdir);
// fill the queue with items to rip
for (i = 0; i < handle->area[area_idx].area_toc->track_count; i++)
{
musicfilename = get_music_filename(handle, area_idx, i, 0);
if (ripping_flags & RIP_DSF)
{
file_path = make_filename(output_device, albumdir, musicfilename, "dsf");
scarletbook_output_enqueue_track(output, area_idx, i, file_path, "dsf",
1 /* always decode to DSD */);
}
else if (ripping_flags & RIP_DSDIFF)
{
file_path = make_filename(output_device, albumdir, musicfilename, "dff");
scarletbook_output_enqueue_track(output, area_idx, i, file_path, "dsdiff",
((ripping_flags & RIP_2CH_DST || ripping_flags & RIP_MCH_DST) ? 0 : 1));
}
tmp_total_ripping_sectors += handle->area[area_idx].area_tracklist_offset->track_length_lsn[i];
free(musicfilename);
free(file_path);
}
file_path = make_filename(output_device, albumdir, 0, 0);
LOG(lm_main, LOG_NOTICE, ("setting output folder to: %s", file_path));
recursive_mkdir(file_path, 0777);
free(file_path);
}
scarletbook_output_start(output);
tb_freq = sysGetTimebaseFrequency();
tb_start = __gettime();
{
char *message = (char *) malloc(512);
file_path = make_filename(output_device, albumdir, 0, 0);
snprintf(message, 512, "Title: %s\nOutput: %s\nFormat: %s\nSize: %.2fGB\nArea: %s\nEncoding: %s",
substr(albumdir, 0, 100),
file_path,
(ripping_flags & RIP_DSDIFF ? "DSDIFF" : (ripping_flags & RIP_DSF ? "DSF" : "ISO")),
((double) ((tmp_total_ripping_sectors * SACD_LSN_SIZE) / 1073741824.00)),
(ripping_flags & RIP_2CH ? "2ch" : "mch"),
(ripping_flags & RIP_2CH_DST || ripping_flags & RIP_MCH_DST ? "DST" : (ripping_flags & RIP_ISO ? "DECRYPTED" : "DSD"))
);
free(file_path);
dialog_action = 0;
dialog_type = MSG_DIALOG_MUTE_ON | MSG_DIALOG_DOUBLE_PROGRESSBAR;
msgDialogOpen2(dialog_type, message, dialog_handler, NULL, NULL);
while (!user_requested_exit() && dialog_action == 0 && scarletbook_output_is_busy(output))
{
uint32_t tmp_stats_total_sectors_processed = sysAtomicRead(&stats_total_sectors_processed);
uint32_t tmp_stats_total_sectors = sysAtomicRead(&stats_total_sectors);
uint32_t tmp_stats_current_file_sectors_processed = sysAtomicRead(&stats_current_file_sectors_processed);
uint32_t tmp_stats_current_file_total_sectors = sysAtomicRead(&stats_current_file_total_sectors);
int tmp_current_track = sysAtomicRead(&stats_current_track);
if (tmp_current_track != 0 && tmp_current_track != prev_current_track)
{
memset(progress_message, 0, 64);
musicfilename = get_music_filename(handle, area_idx, tmp_current_track - 1, 0);
// HACK: substr is not thread safe, but it's only used in this thread..
snprintf(progress_message, 63, "Track (%d/%d): [%s...]", tmp_current_track, sysAtomicRead(&stats_total_tracks), substr(musicfilename, 0, 40));
free(musicfilename);
msgDialogProgressBarReset(MSG_PROGRESSBAR_INDEX0);
msgDialogProgressBarSetMsg(MSG_PROGRESSBAR_INDEX1, progress_message);
prev_upper_progress = 0;
prev_stats_current_file_sectors_processed = 0;
prev_current_track = tmp_current_track;
}
if (tmp_stats_total_sectors != 0 && prev_stats_total_sectors_processed != tmp_stats_total_sectors_processed)
{
delta = (tmp_stats_current_file_sectors_processed + (tmp_stats_current_file_sectors_processed - prev_stats_current_file_sectors_processed)) * 100 / tmp_stats_current_file_total_sectors - prev_upper_progress;
prev_upper_progress += delta;
msgDialogProgressBarInc(MSG_PROGRESSBAR_INDEX0, delta);
delta = (tmp_stats_total_sectors_processed + (tmp_stats_total_sectors_processed - prev_stats_total_sectors_processed)) * 100 / tmp_stats_total_sectors - prev_lower_progress;
prev_lower_progress += delta;
msgDialogProgressBarInc(MSG_PROGRESSBAR_INDEX1, delta);
snprintf(progress_message, 64, "Ripping %.1fMB/%.1fMB at %.2fMB/sec",
((float)(tmp_stats_current_file_sectors_processed * SACD_LSN_SIZE) / 1048576.00),
((float)(tmp_stats_current_file_total_sectors * SACD_LSN_SIZE) / 1048576.00),
(float)((float) tmp_stats_total_sectors_processed * SACD_LSN_SIZE / 1048576.00) / (float)((__gettime() - tb_start) / (float)(tb_freq)));
msgDialogProgressBarSetMsg(MSG_PROGRESSBAR_INDEX0, progress_message);
prev_stats_total_sectors_processed = tmp_stats_total_sectors_processed;
prev_stats_current_file_sectors_processed = tmp_stats_current_file_sectors_processed;
}
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
free(message);
}
free(albumdir);
scarletbook_output_destroy(output);
}
scarletbook_close(handle);
}
sacd_close(sacd_reader);
if (user_requested_exit())
{
return 0;
}
else if (1)
{
dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_OK | MSG_DIALOG_DISABLE_CANCEL_ON);
msgDialogOpen2(dialog_type, "ripping process completed.", dialog_handler, NULL, NULL);
dialog_action = 0;
while (!dialog_action && !user_requested_exit())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
}
return 0;
}
int main(int argc, char* argv[])
{
char *albumdir = 0, *musicfilename, *file_path = 0;
int i, area_idx;
sacd_reader_t *sacd_reader;
#ifdef PTW32_STATIC_LIB
pthread_win32_process_attach_np();
pthread_win32_thread_attach_np();
#endif
init();
if (parse_options(argc, argv))
{
setlocale(LC_ALL, "");
if (fwide(stdout, 1) < 0)
{
fprintf(stderr, "ERROR: Output not set to wide.\n");
}
// default to 2 channel
if (opts.two_channel == 0 && opts.multi_channel == 0)
{
opts.two_channel = 1;
}
sacd_reader = sacd_open(opts.input_device);
if (sacd_reader)
{
handle = scarletbook_open(sacd_reader, 0);
if (handle)
{
if (opts.print)
{
scarletbook_print(handle);
}
if (opts.output_dsf || opts.output_iso || opts.output_dsdiff || opts.output_dsdiff_em || opts.export_cue_sheet)
{
output = scarletbook_output_create(handle, handle_status_update_track_callback, handle_status_update_progress_callback, safe_fwprintf);
// select the channel area
area_idx = ((has_multi_channel(handle) && opts.multi_channel) || !has_two_channel(handle)) ? handle->mulch_area_idx : handle->twoch_area_idx;
albumdir = (strlen(opts.output_file) > 0 ? strdup(opts.output_file) : get_album_dir(handle));
if (opts.output_iso)
{
uint32_t total_sectors = sacd_get_total_sectors(sacd_reader);
#ifdef SECTOR_LIMIT
#define FAT32_SECTOR_LIMIT 2090000
uint32_t sector_size = FAT32_SECTOR_LIMIT;
uint32_t sector_offset = 0;
if (total_sectors > FAT32_SECTOR_LIMIT)
{
musicfilename = (char *) malloc(512);
file_path = make_filename(0, 0, albumdir, "iso");
for (i = 1; total_sectors != 0; i++)
{
sector_size = min(total_sectors, FAT32_SECTOR_LIMIT);
snprintf(musicfilename, 512, "%s.%03d", file_path, i);
scarletbook_output_enqueue_raw_sectors(output, sector_offset, sector_size, musicfilename, "iso");
sector_offset += sector_size;
total_sectors -= sector_size;
}
free(musicfilename);
}
else
#endif
{
get_unique_filename(&albumdir, "iso");
file_path = make_filename(0, 0, albumdir, "iso");
scarletbook_output_enqueue_raw_sectors(output, 0, total_sectors, file_path, "iso");
}
}
else if (opts.output_dsdiff_em)
{
get_unique_filename(&albumdir, "dff");
file_path = make_filename(0, 0, albumdir, "dff");
scarletbook_output_enqueue_track(output, area_idx, 0, file_path, "dsdiff_edit_master",
(opts.convert_dst ? 1 : handle->area[area_idx].area_toc->frame_format != FRAME_FORMAT_DST));
}
else if (opts.output_dsf || opts.output_dsdiff)
{
// create the output folder
get_unique_dir(0, &albumdir);
recursive_mkdir(albumdir, 0774);
// fill the queue with items to rip
for (i = 0; i < handle->area[area_idx].area_toc->track_count; i++)
{
if (opts.select_tracks && opts.selected_tracks[i] == 0)
continue;
musicfilename = get_music_filename(handle, area_idx, i, opts.output_file);
if (opts.output_dsf)
{
file_path = make_filename(0, albumdir, musicfilename, "dsf");
scarletbook_output_enqueue_track(output, area_idx, i, file_path, "dsf",
1 /* always decode to DSD */);
}
else if (opts.output_dsdiff)
{
file_path = make_filename(0, albumdir, musicfilename, "dff");
scarletbook_output_enqueue_track(output, area_idx, i, file_path, "dsdiff",
(opts.convert_dst ? 1 : handle->area[area_idx].area_toc->frame_format != FRAME_FORMAT_DST));
}
free(musicfilename);
free(file_path);
file_path = 0;
}
}
if (opts.export_cue_sheet)
{
char *cue_file_path = make_filename(0, 0, albumdir, "cue");
#ifdef _WIN32
wchar_t *wide_filename = (wchar_t *) charset_convert(cue_file_path, strlen(cue_file_path), "UTF-8", sizeof(wchar_t) == 2 ? "UCS-2-INTERNAL" : "UCS-4-INTERNAL");
#else
wchar_t *wide_filename = (wchar_t *) charset_convert(cue_file_path, strlen(cue_file_path), "UTF-8", "WCHAR_T");
#endif
fwprintf(stdout, L"Exporting CUE sheet [%ls]\n", wide_filename);
if (!file_path)
file_path = make_filename(0, 0, albumdir, "dff");
write_cue_sheet(handle, file_path, area_idx, cue_file_path);
free(cue_file_path);
free(wide_filename);
}
free(file_path);
started_processing = time(0);
scarletbook_output_start(output);
scarletbook_output_destroy(output);
fprintf(stdout, "\rWe are done.. \n");
}
scarletbook_close(handle);
free(albumdir);
}
}
sacd_close(sacd_reader);
#ifndef _WIN32
freopen(0, "w", stdout);
#endif
if (fwide(stdout, -1) >= 0)
{
fprintf(stderr, "ERROR: Output not set to byte oriented.\n");
}
}
free_lock(g_fwprintf_lock);
destroy_logging();
#ifdef PTW32_STATIC_LIB
pthread_win32_process_detach_np();
pthread_win32_thread_detach_np();
#endif
printf("\n");
return 0;
}
void mkpath (char *path) {
recursive_mkdir (path);
}
struct SharedLibrary*
apk_get_shared_libraries(AndroidApk *apk, const char *libdir, const char *datadir)
{
assert(apk != NULL);
char filename[PATH_MAX];
char pathname[PATH_MAX];
FILE *result = NULL;
char buf[64*1024];
int read;
struct SharedLibrary *libs = 0;
struct SharedLibrary *head = 0;
int libdirlen = strlen(libdir);
char *p;
if (unzGoToFirstFile(apk->zip) != UNZ_OK) {
return NULL;
}
do {
if (unzGetCurrentFileInfo(apk->zip, NULL, filename, sizeof(filename), NULL, 0, NULL, 0) == UNZ_OK) {
if (memcmp(filename, libdir, libdirlen) == 0) {
if (unzOpenCurrentFile(apk->zip) == UNZ_OK) {
snprintf(pathname, sizeof(pathname), "%s%s", datadir, filename);
recursive_mkdir(pathname);
result = fopen(pathname, "w+b");
if (result == NULL) {
fprintf(stderr, "can't open %s for writing\n", pathname);
unzCloseCurrentFile(apk->zip);
break;
}
while (!unzeof(apk->zip)) {
read = unzReadCurrentFile(apk->zip, buf, sizeof(buf));
if (read) {
assert(fwrite(buf, read, 1, result) == 1);
}
}
fclose(result);
unzCloseCurrentFile(apk->zip);
if (libs==0) {
libs = malloc(sizeof(struct SharedLibrary));
head = libs;
libs->next = 0;
} else {
libs->next = malloc(sizeof(struct SharedLibrary));
libs->next->next = 0;
libs = libs->next;
}
libs->filename = strdup(pathname);
p = strrchr(pathname, '/');
*p = 0;
libs->dirname = strdup(pathname);
}
}
}
} while (unzGoToNextFile(apk->zip) == UNZ_OK);
return head;
}
