/* Allocate a block of storage; abort execution if it cannot be done. */ static void *allocate_memory (size_t size) { void *address = malloc(size); if (address == NULL) { system_error("memory allocation"); } return address; }
bool loop_impl::run_once( bool block ) { if (block) _sem.wait(); else { if (!_sem.wait(0)) { return false; } } shared_ptr<task_t> task; { concurrency_task_queue::ref ref(_task_queue); task = ref->front(); ref->pop(); } if (task->empty()) { throw system_error(-1, "you do run after ended!"); } try { (*task)(); } catch (std::exception &e) { LOG_ERROR(e.what()); } return true; }
/// Executes an external binary and replaces the current process. /// /// This differs from process::exec() in that this function reports errors /// caused by the exec(2) system call to let the caller decide how to handle /// them. /// /// This function must not use any of the logging features so that the output /// of the subprocess is not "polluted" by our own messages. /// /// This function must also not affect the global state of the current process /// as otherwise we would not be able to use vfork(). Only state stored in the /// stack can be touched. /// /// \param program The binary to execute. /// \param args The arguments to pass to the binary, without the program name. /// /// \throw system_error If the exec(2) call fails. void process::exec_unsafe(const fs::path& program, const args_vector& args) { PRE(args.size() < MAX_ARGS); int original_errno = 0; try { const char* argv[MAX_ARGS + 1]; argv[0] = program.c_str(); for (args_vector::size_type i = 0; i < args.size(); i++) argv[1 + i] = args[i].c_str(); argv[1 + args.size()] = NULL; const int ret = ::execv(program.c_str(), (char* const*)(unsigned long)(const void*)argv); original_errno = errno; INV(ret == -1); std::cerr << "Failed to execute " << program << ": " << std::strerror(original_errno) << "\n"; } catch (const std::runtime_error& error) { std::cerr << "Failed to execute " << program << ": " << error.what() << "\n"; std::abort(); } catch (...) { std::cerr << "Failed to execute " << program << "; got unexpected " "exception during exec\n"; std::abort(); } // We must do this here to prevent our exception from being caught by the // generic handlers above. INV(original_errno != 0); throw system_error("Failed to execute " + program.str(), original_errno); }
TORRENT_DEPRECATED void set_piece_hashes(create_torrent& t, std::wstring const& p, Fun f) { error_code ec; set_piece_hashes_deprecated(t, p, f, ec); if (ec) throw system_error(ec); }
void parent(pid_t pid, int* cmd_stdout, int* cmd_stderr) { /* We dont need input descriptors, we'll be only reading from the child */ close(cmd_stderr[1]); close(cmd_stdout[1]); string buf = read_all(cmd_stderr[0]); buf += read_all(cmd_stdout[0]); /* We've read it all, not needed any more */ close(cmd_stderr[0]); close(cmd_stdout[0]); /* Clean up child's status */ int status; if(waitpid(pid, &status, 0/*options*/) == -1) throw system_error("waitpid", errno); #ifdef REPORT_COMPILER_EXIT_STATUS /* Compiler process reported errors - throw exception */ stringstream exit_info; if(WIFSIGNALED(status)) { exit_info << "Compiler exited due to signal "<< WTERMSIG(status) << endl; }else if(WIFEXITED(status) && WEXITSTATUS(status) != 0){ exit_info << "Compiler exited normaly with status " << WEXITSTATUS(status) << endl; } buf.insert(0, exit_info.str() + "\n"); #endif if(!buf.empty()) { throw compiler_error(buf); } }
static int write_galaxy(const char *filename, struct galaxy *g) { FILE *fp; if ((fp = open_file(filename, FMODE_WB))) { struct head H; H.N_num = host_to_net_int(g->N_num); H.S_num = host_to_net_int(g->S_num); if (fwrite(&H, sizeof (struct head), 1, fp) == 1) { int i; for (i = 0; i < g->N_num; ++i) node_write_bin(g->N + i, fp); for (i = 0; i < g->S_num; ++i) star_write_bin(g->S + i, fp); } fclose(fp); return 1; } else error("Galaxy file '%s': %s", filename, system_error()); return 0; }
TORRENT_DEPRECATED inline void set_piece_hashes(create_torrent& t, std::wstring const& p) { error_code ec; set_piece_hashes_deprecated(t, p, detail::nop, ec); if (ec) throw system_error(ec); }
static int parse_galaxy(const char *filename, struct galaxy *g) { FILE *fp; int i; if ((fp = open_file(filename, FMODE_RB))) { struct head H; if (fread(&H, sizeof (struct head), 1, fp) == 1) { g->magnitude = 1.0; g->N_num = ntohl(H.N_num); g->S_num = ntohl(H.S_num); if ((g->N = (struct node *) calloc(g->N_num, sizeof(struct node)))) for (i = 0; i < g->N_num; ++i) node_parse_bin(g->N + i, fp); if ((g->S = (struct star *) calloc(g->S_num, sizeof(struct star)))) for (i = 0; i < g->S_num; ++i) star_parse_bin(g->S + i, fp); } fclose(fp); return 1; } else error("Galaxy file '%s': %s", filename, system_error()); return 0; }
void impl::stream_capture::prepare(void) { if (pipe(m_pipefds) == -1) throw system_error(IMPL_NAME "::stream_capture::prepare", "Failed to create pipe", errno); }
/** * Remove inotify watch */ void inotify_watch::remove(bool force) { if (inotify_rm_watch(m_fd, m_wd) == -1 && !force) { throw system_error("Failed to remove inotify watch"); } m_wd = -1; m_mask = 0; }
// public emergency stop void slight_StepperManager::system_emergencystop() { motor.stop(); motor.disable(); // something went wrong error_type = ERROR_emergencystop; system_error(); }
/** * @copydoc * data::output::copy_to_destination */ virtual void copy_to_destination ( object_type const* src, std::size_t src_size ) final override { ::ssize_t swrote; while (src_size > 0) { swrote = ::write(STDOUT_FILENO, src, src_size * sizeof(ObjectT)); if (swrote == 0) { throw out_of_space("End of file reached."); } else if (swrote == -1) { throw system_error("write"); } src += static_cast<std::size_t>(swrote); src_size -= static_cast<std::size_t>(swrote); } }
basic_string< TargetChar > convert( const basic_string< SourceChar > &sourceString, size_t ( *convertFunction )( TargetChar *dst, const SourceChar **src, size_t len, mbstate_t *state )) { constexpr auto LENGTH_ERROR = static_cast< size_t >( -1 ); mbstate_t state = mbstate_t(); // Find out how much space we need: const SourceChar *sourceStringData = sourceString.data(); size_t expectedTargetStringLength = convertFunction( nullptr, &sourceStringData, sourceString.length(), &state ); if ( expectedTargetStringLength == LENGTH_ERROR ) throw make_errno_system_error(); // Convert the string: basic_string< TargetChar > targetString( expectedTargetStringLength, TargetChar() ); size_t actualTargetStringLength = convertFunction( &targetString[ 0 ], &sourceStringData, sourceString.length(), &state ); if ( actualTargetStringLength == LENGTH_ERROR ) throw make_errno_system_error(); // Could all characters be converted? if ( expectedTargetStringLength != actualTargetStringLength ) throw system_error( make_error_code( errc::illegal_byte_sequence )); return targetString; }
//! //! \brief Configures child process' input streams. //! //! Sets up the current process' input streams to behave according to the //! information in the \a info map. \a closeflags is modified to reflect //! those descriptors that should not be closed because they where modified //! by the function. //! //! Modifies the current execution environment, so this should only be run //! on the child process after the fork(2) has happened. //! //! \throw system_error If any error occurs during the configuration. //! inline void setup_input(info_map& info, bool* closeflags, int maxdescs) { for (info_map::iterator iter = info.begin(); iter != info.end(); iter++) { int d = (*iter).first; stream_info& si = (*iter).second; BOOST_ASSERT(d < maxdescs); closeflags[d] = false; if (si.m_type == stream_info::use_file) { int fd = ::open(si.m_file.c_str(), O_RDONLY); if (fd == -1) boost::throw_exception (system_error("boost::process::detail::setup_input", "open(2) of " + si.m_file + " failed", errno)); if (fd != d) { file_handle h(fd); h.posix_remap(d); h.disown(); } } else if (si.m_type == stream_info::use_handle) { if (si.m_handle.get() != d) si.m_handle.posix_remap(d); } else if (si.m_type == stream_info::use_pipe) { si.m_pipe->wend().close(); if (d != si.m_pipe->rend().get()) si.m_pipe->rend().posix_remap(d); } else BOOST_ASSERT(si.m_type == stream_info::inherit); } }
leptr find_correct_splitedge(evfptr oldsplitedge,vertype breakpos) { leptr forwardle,backle,oldsplitle; vertype nearpt; /* dummy here since we know breakpos */ evfptr splitedge; Boolean searchforwards = TRUE,searchbackwards = TRUE; double dummyt; ; /* change this call to be pt_near_lineseg_3d and make sure *that* routine */ /* doesn't let t+- tol's to slip through anymore, ok? */ oldsplitle = oldsplitedge->le1; if (pt_near_lineseg_3d(oldsplitle->facevert->pos, oldsplitle->next->facevert->pos,breakpos,nearpt, &dummyt,Ptonlinetol)) return(oldsplitle); #ifdef debug printf("\t\t*** Doing find_correct_splitedge!\n\n"); #endif forwardle = oldsplitle->next; backle = oldsplitle->prev; while (searchforwards || searchbackwards) { if (searchforwards) { if (pt_near_lineseg_3d(forwardle->facevert->pos, Twin_le(forwardle)->facevert->pos, breakpos,nearpt,&dummyt,Ptonlinetol)) return(forwardle); else { forwardle = forwardle->next; /* make sure you didn't branch... if you did you're no longer on */ /* the broken up edge. */ if ((forwardle == oldsplitle) || ((Twin_le(Twin_le(forwardle->prev)->prev)) != forwardle)) searchforwards = FALSE; } } if (searchbackwards) { if (pt_near_lineseg_3d(backle->facevert->pos, Twin_le(backle)->facevert->pos, breakpos,nearpt,&dummyt,Ptonlinetol)) return(backle); else { backle = backle->prev; /* make sure you didn't branch... if you did you're no longer on */ /* the broken up edge. */ if ((backle == oldsplitle) || ((Twin_le(Twin_le(backle->next)->next)) != backle)) searchbackwards = FALSE; } } } system_error("find_correct_splitedge: break edge search failure!!\n"); return 0; // We'll never get here... -- LJE }
void thread::detach() { if (joinable()) { m_handle = thread_uninitialized; } else { throw system_error(make_error_code(errc::invalid_argument), "Can not detach an unjoinable thread."); } }
/* Return the name of group GID. The return value is a buffer * that the caller must deallocate with free. GID must be a * valid group ID. */ static char* get_group_name(gid_t gid) { struct group* entry = getgrgid(gid); if (entry == NULL) { system_error("getgrgid"); } return xstrdup(entry->gr_name); }
void unix_socket::bind(const std::string& sun_path) { struct sockaddr_un local; local.sun_family = AF_UNIX; strncpy(local.sun_path,sun_path.c_str(), UNIX_PATH_MAX); unlink(local.sun_path); if(::bind(sockfd, reinterpret_cast<sockaddr*>(&local), sizeof(local)) == -1) throw system_error("bind",errno); }
void compiler::process(const string& cpp_path, const string& out_path, const vector<string>& params) { int cmd_stdout[2];//0-read, 1-write; int cmd_stderr[2];//0-read, 1-write; if(pipe(cmd_stdout) == -1 || pipe(cmd_stderr) == -1) throw system_error("pipe",errno); pid_t pid = fork(); switch(pid){ case -1: throw system_error("fork", errno); case 0: //child setup_descriptors(cmd_stdout, cmd_stderr); compiler_main(cpp_path, out_path, params); break; default: parent(pid, cmd_stdout, cmd_stderr); } }
/* Return the name of group GID. The return value is a buffer that the * caller must allocate with free. GID must be a valid group ID. */ static char* get_group_name (gid_t gid) {/*{{{*/ struct group* entry; entry = getgrgid (gid); if (entry == NULL) system_error ("getgrgid"); return xstrdup (entry->gr_name); }/*}}}*/
/* Return the name of user UID. The return value is a buffer that the * caller must allocate with free. UID must be a valid user ID. */ static char* get_user_name (uid_t uid) {/*{{{*/ struct passwd* entry; entry = getpwuid (uid); if (entry == NULL) system_error ("getpwuid"); return xstrdup (entry->pw_name); }/*}}}*/
void Calculator::calculate_answer() throw(ZeroDivide) { if(expression==NULL) throw system_error("in void Calculator::calculate_answer(): call set_expression(const PreExpression& s, Expression& exp) before calling this metod"); if(has_answer==true) return; expression->calculate_answer(); expression_history.add(*source,*expression); has_answer=true; }
void slight_StepperManager::system_state_calibrating_global_checks() { // check if motor is stopped if (motor_move_state == 0) { // something went wrong error_type = ERROR_motorstop; system_error(); } else { // check timeout uint32_t move_duration = millis() - motor_move_started_timestamp; if (move_duration > motor_move_timeout) { motor.stop(); error_type = ERROR_timeout; system_error(); } } }
torrent_handle add_magnet_uri(session& ses, std::string const& uri , add_torrent_params const& p) { error_code ec; torrent_handle ret = add_magnet_uri_deprecated(ses, uri, p, ec); if (ec) throw system_error(ec); return ret; }
/* A核用户数据 */ int dump_st_026(void) { char *p; p = kmalloc(4096, GFP_KERNEL); memset(p,1,4096); system_error(0x88,1,2,p,4096); return 0; }
void buffered_file::close() { if (!file_) return; int result = FMT_SYSTEM(fclose(file_)); file_ = FMT_NULL; if (result != 0) FMT_THROW(system_error(errno, "cannot close file")); }
void file::dup2(int fd) { int result = 0; FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd))); if (result == -1) { FMT_THROW(system_error(errno, "cannot duplicate file descriptor {} to {}", fd_, fd)); } }
file file::dup(int fd) { // Don't retry as dup doesn't return EINTR. // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html int new_fd = FMT_POSIX_CALL(dup(fd)); if (new_fd == -1) FMT_THROW(system_error(errno, "cannot duplicate file descriptor {}", fd)); return file(new_fd); }
handle handle::dup() const { if (!*this) BOOST_THROW_EXCEPTION(handle_is_closed_error()); #if defined(BOOST_POSIX_API) const implementation fd = ::fcntl(**this, F_DUPFD_CLOEXEC, 0); if (fd < 0) BOOST_THROW_EXCEPTION(system_error("fcntl") << system_error::handle(**this)); #elif defined(BOOST_WINDOWS_API) implementation fd; if (!::DuplicateHandle(::GetCurrentProcess(), **this, ::GetCurrentProcess(), &fd, 0, /* not inheritable */ false, DUPLICATE_SAME_ACCESS)) { BOOST_THROW_EXCEPTION(system_error("DuplicateHandle") << system_error::handle(**this)); } #endif return handle(fd); }
handle handle::dup2(const implementation new_fd) const { if (!*this) BOOST_THROW_EXCEPTION(handle_is_closed_error()); const implementation fd = ::dup3(**this, new_fd, O_CLOEXEC); if (fd < 0) BOOST_THROW_EXCEPTION(system_error("dup3") << system_error::handle(**this) << system_error::new_handle(new_fd)); return handle(fd); }