font_resource_factory::font_resource_factory(const ::std::string& family, error_code& ec, ::std::experimental::io2d::font_slant fs, ::std::experimental::io2d::font_weight fw, const ::std::experimental::io2d::matrix_2d& fm, const ::std::experimental::io2d::font_options& fo, const ::std::experimental::io2d::matrix_2d& sm) noexcept : _Family() , _Font_slant(fs) , _Font_weight(fw) , _Font_options(fo) , _Font_matrix(fm) , _Surface_matrix(sm) { auto font = cairo_toy_font_face_create(family.c_str(), _Font_slant_to_cairo_font_slant_t(fs), _Font_weight_to_cairo_font_weight_t(fw)); unique_ptr<cairo_font_face_t, decltype(&cairo_font_face_destroy)> ff(font, &cairo_font_face_destroy); ec = _Cairo_status_t_to_std_error_code(cairo_font_face_status(font)); if (static_cast<bool>(ec)) { return; } ::std::string s; try { s = cairo_toy_font_face_get_family(font); } catch (const ::std::bad_alloc&) { ec = make_error_code(errc::not_enough_memory); return; } catch (const ::std::length_error&) { ec = make_error_code(errc::not_enough_memory); return; } _Family = move(s); ec.clear(); }
void on_piece_write(size_t l,error_code ec) { if (write_cnt_>MAX_PIECE) return; if (!ec) { cache_impl_->read_piece("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",write_cnt_++, boost::bind(&disk_cache_test::on_piece_read,this,_1,_2) ); std::string dummy=boost::lexical_cast<std::string>(write_cnt_); safe_buffer buf; safe_buffer_io io(&buf); io.write(dummy.c_str(),dummy.length()+1); cache_impl_->write_piece("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",1024*1024,write_cnt_,buf, boost::bind(&disk_cache_test::on_piece_write,this,_1,_2) ); } else { std::cout<<"on_piece_write, ec.message="<<ec.message()<<std::endl; } }
size_t XMLClient::bytesToRead(const error_code& error, size_t bytes_read) { size_t result = bytes_read; _timer->cancel(); // Connection closed cleanly by peer // asio errors http://www.boost.org/doc/libs/1_44_0/doc/html/boost_asio/reference/error__basic_errors.html if (error == boost::asio::error::eof || boost::asio::error::connection_reset == error) { Disconnect(); return 0; } else if (error == boost::asio::error::operation_aborted) { Globals::ErrorMessage(" In bytesToRead Timer expired error \n"); } else if (error) { // This error stops asynchronous reads std::stringstream s; s << "unknown bytesToRead error = (" << error << ") " << error.message() << std::endl; Globals::ErrorMessage(s.str()); return 0; } if (bytes_read > 0) { AppendBuffer(std::string(data_, data_ + bytes_read)); if (_endtag == NonsenseTag()) { _endtag = FindLeadingElement(_current); if (_endtag.empty()) _endtag = NonsenseTag(); } //BufferHandler(std::string(data_, data_+bytes_read), "</CRCLStatus>") ; BufferHandler(_endtag); } StartAyncRead(); return result; }
static bool error(error_code ec, Twine path = Twine()) { if (ec) { error(ec.message(), path); return true; } return false; }
ResolverIterator resolve( implementation_type & impl, NetName const & name, error_code & ec) { boost::mutex::scoped_lock lock(sync_data_->mtx); LOG_DEBUG("[resolve] (name = %1%)" % name.to_string()); resolve_no_block(impl, name, ec); if (ec == boost::asio::error::would_block) { while (impl->state == ResolveTask::waiting) { sync_data_->cond.wait(lock); } ec = impl->ec; } if (!ec) { LOG_DEBUG("[resolve] resolved (name = %1%, endpoints = %2%)" % name.to_string() % format(impl->endpoints)); return ResolverIterator(svc_, impl, impl->endpoints[0]); } else { LOG_WARN("[resolve] resolved (name = %1%, ec = %2%)" % name.to_string() % ec.message()); return ResolverIterator(); } }
void close(char const* fmt, error_code const& ec) { end_time = clock_type::now(); char tmp[1024]; std::snprintf(tmp, sizeof(tmp), fmt, ec.message().c_str()); int time = int(total_milliseconds(end_time - start_time)); if (time == 0) time = 1; float up = (boost::int64_t(blocks_sent) * 0x4000) / time / 1000.f; float down = (boost::int64_t(blocks_received) * 0x4000) / time / 1000.f; error_code e; char ep_str[200]; address const& addr = s.local_endpoint(e).address(); #if TORRENT_USE_IPV6 if (addr.is_v6()) std::snprintf(ep_str, sizeof(ep_str), "[%s]:%d", addr.to_string(e).c_str() , s.local_endpoint(e).port()); else #endif std::snprintf(ep_str, sizeof(ep_str), "%s:%d", addr.to_string(e).c_str() , s.local_endpoint(e).port()); std::printf("%s ep: %s sent: %d received: %d duration: %d ms up: %.1fMB/s down: %.1fMB/s\n" , tmp, ep_str, blocks_sent, blocks_received, time, up, down); if (seed) --num_seeds; }
void save_settings::save(error_code& ec) const { // back-up current settings file as .bak before saving the new one std::string backup = m_settings_file + ".bak"; bool has_settings = exists(m_settings_file); bool has_backup = exists(backup); if (has_settings && has_backup) remove(backup, ec); if (has_settings) rename(m_settings_file, backup, ec); ec.clear(); entry sett; m_ses.save_state(sett); for (std::map<std::string, int>::const_iterator i = m_ints.begin() , end(m_ints.end()); i != end; ++i) { sett[i->first] = i->second; } for (std::map<std::string, std::string>::const_iterator i = m_strings.begin() , end(m_strings.end()); i != end; ++i) { sett[i->first] = i->second; } std::vector<char> buf; bencode(std::back_inserter(buf), sett); save_file(m_settings_file, buf, ec); }
void disk_engine::complete_io(aio_task *aio, error_code err, uint32_t bytes, int delay_milliseconds) { if (err != ERR_OK) { dinfo("disk operation failure with code %s, err = %s, aio_task_id = %016" PRIx64, aio->spec().name.c_str(), err.to_string(), aio->id()); } // batching if (aio->code() == LPC_AIO_BATCH_WRITE) { aio->enqueue(err, (size_t)bytes); aio->release_ref(); // added in process_write } // no batching else { auto df = (disk_file *)(aio->aio()->file_object); if (aio->aio()->type == AIO_Read) { auto wk = df->on_read_completed(aio, err, (size_t)bytes); if (wk) { _provider->aio(wk); } } // write else { uint32_t sz; auto wk = df->on_write_completed(aio, (void *)&sz, err, (size_t)bytes); if (wk) { process_write(wk, sz); } } } }
void run_test(std::string const& url, int size, int status, int connected , boost::optional<error_code> ec, proxy_settings const& ps) { reset_globals(); std::cerr << " ===== TESTING: " << url << " =====" << std::endl; std::cerr << " expecting: size: " << size << " status: " << status << " connected: " << connected << " error: " << (ec?ec->message():"no error") << std::endl; boost::shared_ptr<http_connection> h(new http_connection(ios, cq , &::http_handler, true, &::http_connect_handler)); h->get(url, seconds(1), 0, &ps); ios.reset(); error_code e; ios.run(e); std::cerr << "connect_handler_called: " << connect_handler_called << std::endl; std::cerr << "handler_called: " << handler_called << std::endl; std::cerr << "status: " << http_status << std::endl; std::cerr << "size: " << data_size << std::endl; std::cerr << "error_code: " << g_error_code.message() << std::endl; TEST_CHECK(connect_handler_called == connected); TEST_CHECK(handler_called == 1); TEST_CHECK(data_size == size || size == -1); TEST_CHECK(!ec || g_error_code == *ec); TEST_CHECK(http_status == status || status == -1); }
/// @brief If ec is not success, print the error and return true. static bool error(error_code ec) { if (!ec) return false; outs() << ToolName << ": error reading file: " << ec.message() << ".\n"; outs().flush(); return true; }
void daemon_s_service::on_update_configuration_on_meta_server_reply( ::dsn::replication::config_type::type type, std::shared_ptr<app_internal> && app, error_code err, dsn_message_t request, dsn_message_t response ) { if (false == _online) { err.end_tracking(); return; } configuration_update_response resp; if (err == ERR_OK) { ::dsn::unmarshall(response, resp); err = resp.err; } else if (err == ERR_TIMEOUT) { rpc::call( _fd->get_servers(), request, this, [=, cap_app = std::move(app)](error_code err, dsn_message_t reqmsg, dsn_message_t response) mutable { on_update_configuration_on_meta_server_reply(type, std::move(cap_app), err, reqmsg, response); } ); } else { if (type == config_type::CT_ADD_SECONDARY) kill_app(std::move(app)); } }
void on_connected(const error_code& ec) { if(ec) { std::cout<<ec.message()<<std::endl; return; } std::cout<<"connected ppc succeed!"<<std::endl; socket_->disconnected_signal().bind(&this_type::on_disconnected,this,_1); if(re_connect_timer_) re_connect_timer_->cancel(); std::string tracker = "/p2p-live/127.0.0.1:9082/default_channel_key/default_channel_uuid.ts"; std::string host = "127.0.0.1:9906"; http::request req; req.url(tracker); req.host(host); safe_buffer buf; safe_buffer_io bio(&buf); bio<<req; socket_->async_send(buf); }
void part_file::move_partfile(std::string const& path, error_code& ec) { std::lock_guard<std::mutex> l(m_mutex); flush_metadata_impl(ec); if (ec) return; m_file.close(); if (!m_piece_map.empty()) { std::string old_path = combine_path(m_path, m_name); std::string new_path = combine_path(path, m_name); rename(old_path, new_path, ec); if (ec == boost::system::errc::no_such_file_or_directory) ec.clear(); if (ec) { copy_file(old_path, new_path, ec); if (ec) return; remove(old_path, ec); } } m_path = path; }
void callback(int mapping, address const& ip, int port, int protocol, error_code const& err) { callback_info info = {mapping, port, err}; callbacks.push_back(info); std::cerr << "mapping: " << mapping << ", port: " << port << ", IP: " << ip << ", proto: " << protocol << ", error: \"" << err.message() << "\"\n"; }
boost::uint64_t TsDemuxer::get_end_time( error_code & ec) { if (!is_open(ec)) { return 0; } boost::uint64_t beg = archive_.tellg(); archive_.seekg(0, std::ios::end); assert(archive_); boost::uint64_t end = archive_.tellg(); assert(end > TsPacket::PACKET_SIZE); end = (end / TsPacket::PACKET_SIZE) * TsPacket::PACKET_SIZE; if (parse_offset2_ + TsPacket::PACKET_SIZE * 20 < end) { parse_offset2_ = end - TsPacket::PACKET_SIZE * 20; } if (parse_offset2_ <= parse_offset_) { archive_.seekg(beg, std::ios::beg); return get_cur_time(ec); } else { archive_.seekg(parse_offset2_, std::ios::beg); assert(archive_); while (parse_offset2_ <= end && get_packet(pkt2_, ec)) { parse_offset2_ += TsPacket::PACKET_SIZE; archive_.seekg(parse_offset2_, std::ios::beg); } ec.clear(); archive_.seekg(beg, std::ios::beg); boost::uint64_t pcr = time_pcr2_.transfer( ((boost::uint64_t)pkt2_.adaptation.program_clock_reference_base) << 1); pcr /= (TsPacket::TIME_SCALE / 1000); return pcr > timestamp_offset_ms_ ? pcr - timestamp_offset_ms_ : 0; } }
static void reportError(StringRef Input, error_code EC) { if (Input == "-") Input = "<stdin>"; errs() << Input << ": " << EC.message() << "\n"; errs().flush(); }
static bool error(error_code EC, Twine Path = Twine()) { if (EC) { error(EC.message(), Path); return true; } return false; }
void udp_tracker_connection::fail(error_code const& ec, int code , char const* msg, int interval, int min_interval) { // m_target failed. remove it from the endpoint list std::list<tcp::endpoint>::iterator i = std::find(m_endpoints.begin() , m_endpoints.end(), tcp::endpoint(m_target.address(), m_target.port())); if (i != m_endpoints.end()) m_endpoints.erase(i); // if that was the last one, fail the whole announce if (m_endpoints.empty()) { tracker_connection::fail(ec, code, msg, interval, min_interval); return; } #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING boost::shared_ptr<request_callback> cb = requester(); if (cb) cb->debug_log("*** UDP_TRACKER [ host: \"%s\" ip: \"%s\" | error: \"%s\" ]" , m_hostname.c_str(), print_endpoint(m_target).c_str(), ec.message().c_str()); #endif // pick another target endpoint and try again m_target = pick_target_endpoint(); #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING if (cb) cb->debug_log("*** UDP_TRACKER trying next IP [ host: \"%s\" ip: \"%s\" ]" , m_hostname.c_str(), print_endpoint(m_target).c_str()); #endif m_ses.m_io_service.post(boost::bind( &udp_tracker_connection::start_announce, self())); }
void MAVConnUDP::async_sendto_end(error_code error, size_t bytes_transferred) { if (error) { logError(PFXd "sendto: %s", channel, error.message().c_str()); close(); return; } iostat_tx_add(bytes_transferred); lock_guard lock(mutex); if (tx_q.empty()) { tx_in_progress = false; return; } MsgBuffer *buf = tx_q.front(); buf->pos += bytes_transferred; if (buf->nbytes() == 0) { tx_q.pop_front(); delete buf; } if (!tx_q.empty()) do_sendto(false); else tx_in_progress = false; }
void MAVConnUDP::async_receive_end(error_code error, size_t bytes_transferred) { mavlink_message_t message; mavlink_status_t status; if (error) { logError(PFXd "receive: %s", channel, error.message().c_str()); close(); return; } if (remote_ep != last_remote_ep) { logInform(PFXd "Remote address: %s", channel, to_string_ss(remote_ep).c_str()); remote_exists = true; last_remote_ep = remote_ep; } iostat_rx_add(bytes_transferred); for (size_t i = 0; i < bytes_transferred; i++) { if (mavlink_parse_char(channel, rx_buf[i], &message, &status)) { logDebug(PFXd "recv: Message-Id: %d [%d bytes] Sys-Id: %d Comp-Id: %d Seq: %d", channel, message.msgid, message.len, message.sysid, message.compid, message.seq); /* emit */ message_received(&message, message.sysid, message.compid); } } do_recvfrom(); }
void peer_conn::close(char const* fmt, error_code const& ec) { end_time = clock_type::now(); char tmp[1024]; #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wformat-nonliteral" #endif std::snprintf(tmp, sizeof(tmp), fmt, ec.message().c_str()); #ifdef __clang__ #pragma clang diagnostic pop #endif int time = int(total_milliseconds(end_time - start_time)); if (time == 0) time = 1; double const up = (std::int64_t(blocks_sent) * 0x4000) / time / 1000.0; double const down = (std::int64_t(blocks_received) * 0x4000) / time / 1000.0; error_code e; char ep_str[200]; address const& addr = s.local_endpoint(e).address(); #if TORRENT_USE_IPV6 if (addr.is_v6()) std::snprintf(ep_str, sizeof(ep_str), "[%s]:%d", addr.to_string(e).c_str() , s.local_endpoint(e).port()); else #endif std::snprintf(ep_str, sizeof(ep_str), "%s:%d", addr.to_string(e).c_str() , s.local_endpoint(e).port()); std::printf("%s ep: %s sent: %d received: %d duration: %d ms up: %.1fMB/s down: %.1fMB/s\n" , tmp, ep_str, blocks_sent, blocks_received, time, up, down); }
directory::directory(std::string const& path, error_code& ec) : m_done(false) { ec.clear(); #ifdef TORRENT_WINDOWS // the path passed to FindFirstFile() must be // a pattern std::string f = convert_separators(path); if (!f.empty() && f[f.size()-1] != '\\') f += "\\*"; else f += "*"; #if TORRENT_USE_WSTRING #define FindFirstFile_ FindFirstFileW std::wstring p = convert_to_wstring(f); #else #define FindFirstFile_ FindFirstFileA std::string p = convert_to_native(f); #endif m_handle = FindFirstFile_(p.c_str(), &m_fd); if (m_handle == INVALID_HANDLE_VALUE) { ec.assign(GetLastError(), boost::system::get_system_category()); m_done = true; return; } #else memset(&m_dirent, 0, sizeof(dirent)); m_name[0] = 0; // the path passed to opendir() may not // end with a / std::string p = path; if (!path.empty() && path[path.size()-1] == '/') p.resize(path.size()-1); p = convert_to_native(p); m_handle = opendir(p.c_str()); if (m_handle == 0) { ec.assign(errno, boost::system::get_generic_category()); m_done = true; return; } // read the first entry next(ec); #endif }
url_seed_alert::url_seed_alert( torrent_handle const& h , std::string const& u , error_code const& e) : torrent_alert(h) , url(u) , msg(convert_from_native(e.message())) {}
bool websocket::check_err(error_code const& err, string const& reason) { if ( err ) { return check_err(false, reason + ": " + err.message()); } return true; }
inline void clear_error(error_code& ec) { #if defined(ASIOEXT_USE_BOOST_ASIO) || defined(ASIO_HAS_STD_SYSTEM_ERROR) ec.clear(); #else ec = error_code(); #endif }
void on_error(error_code const& code) { if (code) { if // usually, by on_receive ((code.category() == error::misc_category && code.value () == error::eof) || // and these - by on_send (code.category() == error::system_category && code.value () == error::connection_reset) || (code.category() == error::system_category && code.value () == error::broken_pipe )) { on_discon_(code); } else on_error_(code); } }
void callback(int mapping, address extip, int port, error_code const& err) { std::cerr << "mapping: " << mapping << ", port: " << port << ", external-IP: " << print_address(extip) << ", error: \"" << err.message() << "\"\n"; }
static bool error(error_code ec) { if (!ec) return false; outs() << "Cpu0RelocationHandler.cpp : error reading file: " << ec.message() << ".\n"; outs().flush(); return true; }
void callback(int mapping, address const& ip, int port, error_code const& err) { callback_info info = {mapping, port, err}; callbacks.push_back(info); std::cerr << "mapping: " << mapping << ", port: " << port << ", IP: " << ip << ", error: \"" << err.message() << "\"\n"; //TODO: store the callbacks and verify that the ports were successful }
scrape_failed_alert::scrape_failed_alert(torrent_handle const& h , std::string const& u , error_code const& e) : tracker_alert(h, u) , msg(convert_from_native(e.message())) { TORRENT_ASSERT(!url.empty()); }