static int process_file(const char *fpath, const struct stat *sb, int tflag, struct FTW *ftwbuf) { int is_file = (tflag == FTW_F); if (!is_file) return 0; // don't search .git dirs int is_git_dir = (strstr(fpath, "/.git/") != NULL); if (is_git_dir) return 0; FILE *fd = fopen(fpath, "r"); if (fd == NULL) { perror("Error opening file for reading"); return 0; } if (is_binary_file(fd)) { fclose(fd); return 0; } print_matching_lines(fd, fpath); fclose(fd); return 0; // To tell nftw() to continue }
static int check_file_type_consistency(int num_files, char *file_list[]) { int i; const char *fn_ptr; int n4_offset = 0; for (i = 0; i < num_files; i++) { fn_ptr = file_list[i]; /* Numaris 4 DICOM CD/Export file? if so, bytes 128-131 will * contain the string `DICM' with no null termination. */ if (is_cdexport_file(fn_ptr)) { if (G.file_type == UNDEF) { G.file_type = N4DCM; n4_offset = 1; printf("File %s appears to be DICOM (CD/Export).\n", fn_ptr); } else if (G.file_type != N4DCM || n4_offset != 1) { printf("MISMATCH: File %s appears to be DICOM (CD/Export).\n", fn_ptr); return (-1); } } else if (is_ima_file(fn_ptr)) { if (G.file_type == UNDEF) { G.file_type = IMA; printf("File %s appears to be Siemens IMA.\n", fn_ptr); } else if (G.file_type != IMA) { printf("MISMATCH: File %s appears to be Siemens IMA.\n", fn_ptr); return (-1); } } else if (is_binary_file(fn_ptr)) { if (G.file_type == UNDEF) { G.file_type = N4DCM; n4_offset = 0; printf("File %s appears to be standard DICOM.\n", fn_ptr); } else if (G.file_type != N4DCM || n4_offset != 0) { printf("MISMATCH: File %s appears to be standard DICOM.\n", fn_ptr); return (-1); } } } return (0); }
// If the do_exec fails we try to emulate what the shell does (I used // bash as a guide). It's worth noting that the shell can execute some // things that VG_(do_exec)() (which subsitutes for the kernel's exec()) // will refuse to (eg. scripts lacking a "#!" prefix). static Int do_exec_shell_followup(Int ret, HChar* exe_name, ExeInfo* info) { Char* default_interp_name = "/bin/sh"; SysRes res; struct vg_stat st; if (VKI_ENOEXEC == ret) { // It was an executable file, but in an unacceptable format. Probably // is a shell script lacking the "#!" prefix; try to execute it so. // Is it a binary file? if (is_binary_file(exe_name)) { VG_(printf)("valgrind: %s: cannot execute binary file\n", exe_name); VG_(exit)(126); // 126 == NOEXEC } // Looks like a script. Run it with /bin/sh. This includes // zero-length files. info->interp_name = VG_(strdup)("ume.desf.1", default_interp_name); info->interp_args = NULL; if (info->argv && info->argv[0] != NULL) info->argv[0] = (char *)exe_name; ret = VG_(do_exec_inner)(info->interp_name, info); if (0 != ret) { // Something went wrong with executing the default interpreter VG_(printf)("valgrind: %s: bad interpreter (%s): %s\n", exe_name, info->interp_name, VG_(strerror)(ret)); VG_(exit)(126); // 126 == NOEXEC } } else if (0 != ret) { // Something else went wrong. Try to make the error more specific, // and then print a message and abort. // Was it a directory? res = VG_(stat)(exe_name, &st); if (!sr_isError(res) && VKI_S_ISDIR(st.mode)) { VG_(printf)("valgrind: %s: is a directory\n", exe_name); // Was it not executable? } else if (0 != VG_(check_executable)(NULL, exe_name, False/*allow_setuid*/)) { VG_(printf)("valgrind: %s: %s\n", exe_name, VG_(strerror)(ret)); // Did it start with "#!"? If so, it must have been a bad interpreter. } else if (is_hash_bang_file(exe_name)) { VG_(printf)("valgrind: %s: bad interpreter: %s\n", exe_name, VG_(strerror)(ret)); // Otherwise it was something else. } else { VG_(printf)("valgrind: %s: %s\n", exe_name, VG_(strerror)(ret)); } // 126 means NOEXEC; I think this is Posix, and that in some cases we // should be returning 127, meaning NOTFOUND. Oh well. VG_(exit)(126); } return ret; }
// If the do_exec fails we try to emulate what the shell does (I used // bash as a guide). It's worth noting that the shell can execute some // things that VG_(do_exec)() (which subsitutes for the kernel's exec()) // will refuse to (eg. scripts lacking a "#!" prefix). static Int do_exec_shell_followup(Int ret, const HChar* exe_name, ExeInfo* info) { # if defined(VGPV_arm_linux_android) \ || defined(VGPV_x86_linux_android) \ || defined(VGPV_mips32_linux_android) \ || defined(VGPV_arm64_linux_android) const HChar* default_interp_name = "/system/bin/sh"; # else const HChar* default_interp_name = "/bin/sh"; # endif SysRes res; struct vg_stat st; if (VKI_ENOEXEC == ret) { // It was an executable file, but in an unacceptable format. Probably // is a shell script lacking the "#!" prefix; try to execute it so. // Is it a binary file? if (is_binary_file(exe_name)) { VG_(fmsg)("%s: cannot execute binary file\n", exe_name); VG_(exit)(126); // 126 == NOEXEC } // Looks like a script. Run it with /bin/sh. This includes // zero-length files. VG_(free)(info->interp_name); info->interp_name = VG_(strdup)("ume.desf.1", default_interp_name); VG_(free)(info->interp_args); info->interp_args = NULL; if (info->argv && info->argv[0] != NULL) info->argv[0] = exe_name; ret = VG_(do_exec_inner)(info->interp_name, info); if (0 != ret) { // Something went wrong with executing the default interpreter VG_(fmsg)("%s: bad interpreter (%s): %s\n", exe_name, info->interp_name, VG_(strerror)(ret)); VG_(exit)(126); // 126 == NOEXEC } } else if (0 != ret) { // Something else went wrong. Try to make the error more specific, // and then print a message and abort. Int exit_code = 126; // 126 == NOEXEC (bash) res = VG_(stat)(exe_name, &st); // Does the file exist ? if (sr_isError(res) && sr_Err(res) == VKI_ENOENT) { VG_(fmsg)("%s: %s\n", exe_name, VG_(strerror)(ret)); exit_code = 127; // 127 == NOTFOUND (bash) // Was it a directory? } else if (!sr_isError(res) && VKI_S_ISDIR(st.mode)) { VG_(fmsg)("%s: is a directory\n", exe_name); // Was it not executable? } else if (0 != VG_(check_executable)(NULL, exe_name, False/*allow_setuid*/)) { VG_(fmsg)("%s: %s\n", exe_name, VG_(strerror)(ret)); // Did it start with "#!"? If so, it must have been a bad interpreter. } else if (is_hash_bang_file(exe_name)) { VG_(fmsg)("%s: bad interpreter: %s\n", exe_name, VG_(strerror)(ret)); // Otherwise it was something else. } else { VG_(fmsg)("%s: %s\n", exe_name, VG_(strerror)(ret)); } VG_(exit)(exit_code); } return ret; }
void bcp_implementation::copy_path(const fs::path& p) { assert(!fs::is_directory(m_boost_path / p)); if(fs::exists(m_dest_path / p)) { std::cout << "Copying (and overwriting) file: " << p.string() << "\n"; fs::remove(m_dest_path / p); } else std::cout << "Copying file: " << p.string() << "\n"; // // create the path to the new file if it doesn't already exist: // create_path(p.branch_path()); // // do text based copy if requested: // if(p.leaf() == "Jamroot") { static std::vector<char> v1, v2; v1.clear(); v2.clear(); std::ifstream is((m_boost_path / p).c_str()); std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1)); static boost::regex libname_matcher; if(libname_matcher.empty()) { libname_matcher.assign("boost_"); } regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), libname_matcher, m_namespace_name + "_"); std::swap(v1, v2); v2.clear(); std::ofstream os; if(m_unix_lines) os.open((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); else os.open((m_dest_path / p).c_str(), std::ios_base::out); os.write(&*v1.begin(), v1.size()); os.close(); } else if(m_namespace_name.size() && m_lib_names.size() && is_jam_file(p)) { static std::vector<char> v1, v2; v1.clear(); v2.clear(); std::ifstream is((m_boost_path / p).c_str()); std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1)); static boost::regex libname_matcher; if(libname_matcher.empty()) { std::string re = "\\<"; re += *m_lib_names.begin(); for(std::set<std::string>::const_iterator i = ++m_lib_names.begin(); i != m_lib_names.end(); ++i) { re += "|" + *i; } re += "\\>"; libname_matcher.assign(re); } regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), libname_matcher, get_new_library_name(m_namespace_name)); std::swap(v1, v2); v2.clear(); std::ofstream os; if(m_unix_lines) os.open((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); else os.open((m_dest_path / p).c_str(), std::ios_base::out); os.write(&*v1.begin(), v1.size()); os.close(); } else if(m_namespace_name.size() && is_source_file(p)) { // // v1 hold the current content, v2 is temp buffer. // Each time we do a search and replace the new content // ends up in v2: we then swap v1 and v2, and clear v2. // static std::vector<char> v1, v2; v1.clear(); v2.clear(); std::ifstream is((m_boost_path / p).c_str()); std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1)); static const boost::regex namespace_matcher( "(?|" "(namespace\\s+)boost(_\\w+)?(?:(\\s*::\\s*)phoenix)?" "|" "(namespace\\s+)(adstl|phoenix|rapidxml)\\>" "|" "()\\<boost((?:_(?!intrusive_tags)\\w+)?\\s*(?:::))(?:(\\s*)phoenix)?" "|" "()\\<((?:adstl|phoenix|rapidxml)\\s*(?:::))" "|" "(namespace\\s+\\w+\\s*=\\s*(?:::\\s*)?)boost(_\\w+)?(?:(\\s*::\\s*)phoenix)?" "|" "(namespace\\s+\\w+\\s*=\\s*(?:::\\s*)?(?:\\w+\\s*::\\s*)?)(adstl|phoenix|rapidxml)\\>" "|" "(^\\s*#\\s*define\\s+\\w+\\s+)boost((?:_\\w+)?\\s*)$" "|" "(^\\s*#\\s*define[^\\n]+)((?:adstl|phoenix|rapidxml)\\s*)$" "|" "()boost(_asio_detail_posix_thread_function|_regex_free_static_mutex)" "|" "()(lw_thread_routine|at_thread_exit|on_process_enter|on_process_exit|on_thread_enter|on_thread_exit|tss_cleanup_implemented)" "|" "(BOOST_CLASS_REQUIRE4?[^;]*)boost((?:_\\w+)?\\s*,)" "|" "(\\(\\s*)boost(\\s*\\))" ")" ); regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), namespace_matcher, "$1" + m_namespace_name + "$2(?3$3" + m_namespace_name + "phoenix)", boost::regex_constants::format_all); std::swap(v1, v2); v2.clear(); if(m_namespace_alias) { static const boost::regex namespace_alias( /* "namespace\\s+" + m_namespace_name + "\\s*" "(" "\\{" "(?:" "(?>[^\\{\\}/]+)" "(?>" "(?:" "(?1)" "|//[^\\n]+$" "|/[^/]" "|(?:^\\s*#[^\\n]*" "(?:(?<=\\\\)\\n[^\\n]*)*)" ")" "[^\\{\\}]+" ")*" ")*" "\\}" ")" */ /* "(namespace\\s+" + m_namespace_name + "\\s*\\{.*" "\\})([^\\{\\};]*)\\z" */ "namespace\\s+" + m_namespace_name + "\\s*\\{" ); regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), namespace_alias, "namespace " + m_namespace_name + "{} namespace boost = " + m_namespace_name + "; namespace " + m_namespace_name + "{"); std::swap(v1, v2); v2.clear(); } std::ofstream os; if(m_unix_lines) os.open((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); else os.open((m_dest_path / p).c_str(), std::ios_base::out); if(v1.size()) os.write(&*v1.begin(), v1.size()); os.close(); } else if(m_unix_lines && !is_binary_file(p)) { std::ifstream is((m_boost_path / p).c_str()); std::istreambuf_iterator<char> isi(is); std::istreambuf_iterator<char> end; std::ofstream os((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); std::ostreambuf_iterator<char> osi(os); std::copy(isi, end, osi); } else { // binary copy: fs::copy_file(m_boost_path / p, m_dest_path / p); } }