//地址是否合法 PrivateKey::PrivateKey(SignatureType type) { std::string raw_pub_key = ""; type_ = type; if (type_ == SIGNTYPE_ED25519) { utils::MutexGuard guard_(lock_); // ed25519; raw_priv_key_.resize(32); //ed25519_randombytes_unsafe((void*)raw_priv_key_.c_str(), 32); if (!utils::GetStrongRandBytes(raw_priv_key_)){ valid_ = false; return; } raw_pub_key.resize(32); ed25519_publickey((const unsigned char*)raw_priv_key_.c_str(), (unsigned char*)raw_pub_key.c_str()); } else if (type_ == SIGNTYPE_CFCASM2) { utils::EccSm2 key(utils::EccSm2::GetCFCAGroup()); key.NewRandom(); raw_priv_key_ = key.getSkeyBin(); raw_pub_key = key.GetPublicKey(); } else{ LOG_ERROR("Unknown signature type(%d)", type_); } pub_key_.Init(raw_pub_key); pub_key_.type_ = type_; pub_key_.valid_ = true; valid_ = true; }
actor forwarding_actor_proxy::manager() const { actor result; { shared_lock<detail::shared_spinlock> guard_(manager_mtx_); result = manager_; } return result; }
void connection_queue::on_timeout(error_code const& e) { mutex_t::scoped_lock l(m_mutex); INVARIANT_CHECK; #ifdef TORRENT_DEBUG function_guard guard_(m_in_timeout_function); #endif TORRENT_ASSERT(!e || e == asio::error::operation_aborted); if (e) return; ptime next_expire = max_time(); ptime now = time_now_hires() + milliseconds(100); std::list<entry> timed_out; for (std::list<entry>::iterator i = m_queue.begin(); !m_queue.empty() && i != m_queue.end();) { if (i->connecting && i->expires < now) { std::list<entry>::iterator j = i; ++i; timed_out.splice(timed_out.end(), m_queue, j, i); --m_num_connecting; continue; } if (i->expires < next_expire) next_expire = i->expires; ++i; } // we don't want to call the timeout callback while we're locked // since that is a recepie for dead-locks l.unlock(); for (std::list<entry>::iterator i = timed_out.begin() , end(timed_out.end()); i != end; ++i) { #ifndef BOOST_NO_EXCEPTIONS try { #endif i->on_timeout(); #ifndef BOOST_NO_EXCEPTIONS } catch (std::exception&) {} #endif } l.lock(); if (next_expire < max_time()) { error_code ec; m_timer.expires_at(next_expire, ec); m_timer.async_wait(boost::bind(&connection_queue::on_timeout, this, _1)); } try_connect(l); }
void forwarding_actor_proxy::forward_msg(const actor_addr& sender, message_id mid, message msg) { BOOST_ACTOR_LOG_TRACE(BOOST_ACTOR_ARG(id()) << ", " << BOOST_ACTOR_TSARG(sender) << ", " << BOOST_ACTOR_MARG(mid, integer_value) << ", " << BOOST_ACTOR_TSARG(msg)); shared_lock<detail::shared_spinlock> guard_(manager_mtx_); if (manager_) manager_->enqueue(invalid_actor_addr, invalid_message_id, make_message(forward_atom::value, sender, address(), mid, std::move(msg)), nullptr); }
void forwarding_actor_proxy::forward_msg(strong_actor_ptr sender, message_id mid, message msg, const forwarding_stack* fwd) { CAF_LOG_TRACE(CAF_ARG(id()) << CAF_ARG(sender) << CAF_ARG(mid) << CAF_ARG(msg)); forwarding_stack tmp; shared_lock<detail::shared_spinlock> guard_(manager_mtx_); if (! manager_.unsafe()) manager_->enqueue(nullptr, invalid_message_id, make_message(forward_atom::value, std::move(sender), fwd ? *fwd : tmp, strong_actor_ptr{ctrl()}, mid, std::move(msg)), nullptr); }
void connection_queue::on_timeout(error_code const& e) { #if defined TORRENT_ASIO_DEBUGGING complete_async("connection_queue::on_timeout"); #endif mutex_t::scoped_lock l(m_mutex); --m_num_timers; INVARIANT_CHECK; #ifdef TORRENT_DEBUG function_guard guard_(m_in_timeout_function); #endif TORRENT_ASSERT(!e || e == error::operation_aborted); // if there was an error, it's most likely operation aborted, // we should just quit. However, in case there are still connections // in connecting state, and there are no other timer invocations // we need to stick around still. if (e && (m_num_connecting == 0 || m_num_timers > 0)) return; ptime next_expire = max_time(); ptime now = time_now_hires() + milliseconds(100); std::list<entry> timed_out; for (std::list<entry>::iterator i = m_queue.begin(); !m_queue.empty() && i != m_queue.end();) { if (i->connecting && i->expires < now) { std::list<entry>::iterator j = i; ++i; timed_out.splice(timed_out.end(), m_queue, j, i); --m_num_connecting; continue; } if (i->connecting && i->expires < next_expire) next_expire = i->expires; ++i; } // we don't want to call the timeout callback while we're locked // since that is a recepie for dead-locks l.unlock(); for (std::list<entry>::iterator i = timed_out.begin() , end(timed_out.end()); i != end; ++i) { TORRENT_ASSERT(i->connecting); TORRENT_ASSERT(i->ticket != -1); TORRENT_TRY { i->on_timeout(); } TORRENT_CATCH(std::exception&) {} } l.lock(); if (next_expire < max_time()) { #if defined TORRENT_ASIO_DEBUGGING add_outstanding_async("connection_queue::on_timeout"); #endif error_code ec; m_timer.expires_at(next_expire, ec); m_timer.async_wait(boost::bind(&connection_queue::on_timeout, this, _1)); ++m_num_timers; } try_connect(l); }
void forwarding_actor_proxy::manager(actor new_manager) { std::unique_lock<detail::shared_spinlock> guard_(manager_mtx_); manager_.swap(new_manager); }
bool is_condition_met() const { return guard_(); }