text
stringlengths 5
1.04M
|
|---|
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include <opencv/highgui.h> // GB this include is needed with opencv 3.0 (for CV_CAP_PROP_XXX)
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <cstdlib>
using namespace cv;
using namespace std;
Mat src; Mat src_gray;
int thresh = 100;
int max_thresh = 255;
RNG rng(12345);
/// Function header
void thresh_callback(int, void* );
/** @function main */
int main( int argc, char** argv )
{
if(argc < 2) throw std::string("Usage:") + argv[0] + " EITHER_camera-number_OR_input-video-file-name [video-out-file-name]";
cv::VideoCapture cap(argv[1]); // try to open as a video file or image sequence.
if (!cap.isOpened()) cap.open(atoi(argv[1])); // try to open as a video camera.
if (!cap.isOpened())
throw "Failed to open the video device, video file or image sequence!\n";
while(1) {
/// Load an image
cap >> src;
/// Convert image to gray and blur it
cvtColor( src, src_gray, CV_BGR2GRAY );
blur( src_gray, src_gray, Size(3,3) );
/// Create Window
const char* source_window = "Source";
namedWindow( source_window, CV_WINDOW_AUTOSIZE );
imshow( source_window, src );
createTrackbar( " Canny thresh:", "Source", &thresh, max_thresh, thresh_callback );
thresh_callback( 0, 0 );
if(waitKey(1) == 27) break;
}
return(0);
}
/** @function thresh_callback */
void thresh_callback(int, void* )
{
Mat canny_output;
vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
/// Detect edges using canny
Canny( src_gray, canny_output, thresh, thresh*2, 3 );
/// Find contours
findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
/// Get the moments
vector<Moments> mu(contours.size() );
for( int i = 0; i < contours.size(); i++ )
{ mu[i] = moments( contours[i], false ); }
/// Get the mass centers:
vector<Point2f> mc( contours.size() );
for( int i = 0; i < contours.size(); i++ )
{ mc[i] = Point2f( mu[i].m10/mu[i].m00 , mu[i].m01/mu[i].m00 ); }
/// Draw contours
Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
for( int i = 0; i< contours.size(); i++ )
{
Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() );
circle( drawing, mc[i], 4, color, -1, 8, 0 );
}
/// Show in a window
namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
imshow( "Contours", drawing );
/// Calculate the area with the moments 00 and compare with the result of the OpenCV function
cout << "\t Info: Area and Contour Length \n";
for( int i = 0; i< contours.size(); i++ )
{
#if 1
printf(" * Contour[%d] - Area (M_00) = %.2f - Area OpenCV: %.2f - Length: %.2f \n",
i, mu[i].m00, contourArea(contours[i]), arcLength( contours[i], true ) );
#else
stringstream ss;
ss << " * Contour[" << i << "]"
" - Area (M_00) = " << setprecision(2) << mu[i].m00
<< " - Area OpenCV: " << setprecision(2) << contourArea(contours[i])
<< " - Length: " << setprecision(2) << arcLength( contours[i], true )
<< "\n";
cout << ss.str();
#endif
Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() );
circle( drawing, mc[i], 4, color, -1, 8, 0 );
}
}
|
/********************************************************
File: Image.hh
Abstract: A general 2 dimensional image template.
Created: 06/02/1998
Author: Chris L. Wyatt
Last Revision ($Revision: 1.1.1.1 $)
by $Author: hongli $
on $Date: 2002/12/06 21:49:33 $
*********************************************************/
//prevent recursive includes
#ifndef _Image_hh
#define _Image_hh 1
#ifdef IRIX
#include <assert.h>
#include <math.h>
#else
#include <cassert>
#include <cmath>
#endif
#include <iostream>
#include "Data.hh"
#include "NDArray.hh"
#include "Subscript.hh"
/** 2 dimensional image template.
A base class template implementing the storage of 2D
grid based data and basic element mathmatics. Data type is
specified when instanciated and must have defined
the appropriate overloads (+ - * / =).
NOTE: A left-handed coordinate system is used to get and set pixel
locations (notice this differs from the default NDArray get/set).
The bounds, inherited from NDArray, specify volume boundaries in X, Y order.
\begin{verbatim}
_________ y
|
|
|
|
x
\end{verbatim}
@author Chris L. Wyatt <cwyatt@wfubmc.edu>
@version $Revision: 1.1.1.1 $
*/
namespace IMTK{
template <class T>
class Image: public NDArray<T,2>
{
private:
protected:
public:
/// Default Constructor
Image(): NDArray<T,2>(){}
/**
* Construct Image with diminsions
*
* @param theDims subscript list of dimensions
*/
Image(Subscript<2> theDims): NDArray<T,2>(theDims){}
/**
* Construct Image with diminsions and data
*
* @param theDims subscript list of dimensions
* @param theDataPtr pointer to array data
*/
Image(Subscript<2> theDims, T * theDataPtr): NDArray<T,2>(theDims, theDataPtr){}
/// Copy Constructor for NDArray to Image
Image(const NDArray<T,2> & A): NDArray<T,2>(A){}
/// Copy Constructor for Image to Image
Image(const Image<T> & I): NDArray<T,2>(I){}
/// Destructor
~Image(){}
/**
* Set value of Image
*
* @param theX
* @param theY
* @param value value to set location too
*/
inline void setPixel(unsigned int theX, unsigned int theY, T value){
Subscript<2> sub;
sub[0] = theX;
sub[1] = theY;
this->set(sub, value);
}
/**
* Return value of Image
*
* @param theX
* @param theY
* @return value
*/
inline T getPixel(unsigned int theX, unsigned int theY) const{
Subscript<2> sub;
sub[0] = theX;
sub[1] = theY;
return this->get(sub);
}
};
}
#endif
|
// Copyright (c) 2014-2019, The Monero Project
// Copyright (c) 2018, The Loki Project
// Copyright (c) 2018, The Worktips Project
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
#include <numeric>
#include <tuple>
#include <boost/format.hpp>
#include <boost/optional/optional.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/join.hpp>
#include <boost/asio/ip/address.hpp>
#include <boost/range/adaptor/transformed.hpp>
#include <boost/preprocessor/stringize.hpp>
#include "include_base_utils.h"
using namespace epee;
#include "common/rules.h"
#include "cryptonote_config.h"
#include "wallet2.h"
#include "cryptonote_basic/cryptonote_format_utils.h"
#include "rpc/core_rpc_server_commands_defs.h"
#include "misc_language.h"
#include "cryptonote_basic/cryptonote_basic_impl.h"
#include "multisig/multisig.h"
#include "common/boost_serialization_helper.h"
#include "common/command_line.h"
#include "common/threadpool.h"
#include "profile_tools.h"
#include "crypto/crypto.h"
#include "serialization/binary_utils.h"
#include "serialization/string.h"
#include "cryptonote_basic/blobdatatype.h"
#include "mnemonics/electrum-words.h"
#include "common/i18n.h"
#include "common/util.h"
#include "common/apply_permutation.h"
#include "rapidjson/document.h"
#include "rapidjson/writer.h"
#include "rapidjson/stringbuffer.h"
#include "common/json_util.h"
#include "memwipe.h"
#include "common/base58.h"
#include "common/combinator.h"
#include "common/dns_utils.h"
#include "common/notify.h"
#include "common/perf_timer.h"
#include "ringct/rctSigs.h"
#include "ringdb.h"
#include "device/device_cold.hpp"
#include "device_trezor/device_trezor.hpp"
#include "net/socks_connect.h"
#include "cryptonote_core/service_node_list.h"
#include "cryptonote_core/service_node_rules.h"
#include "common/worktips.h"
#include "common/worktips_integration_test_hooks.h"
extern "C"
{
#include "crypto/keccak.h"
#include "crypto/crypto-ops.h"
}
using namespace std;
using namespace crypto;
using namespace cryptonote;
#undef WORKTIPS_DEFAULT_LOG_CATEGORY
#define WORKTIPS_DEFAULT_LOG_CATEGORY "wallet.wallet2"
// used to choose when to stop adding outputs to a tx
#define APPROXIMATE_INPUT_BYTES 80
// used to target a given block weight (additional outputs may be added on top to build fee)
#define TX_WEIGHT_TARGET(bytes) (bytes*2/3)
// arbitrary, used to generate different hashes from the same input
#define CHACHA8_KEY_TAIL 0x8c
#define CACHE_KEY_TAIL 0x8d
#define UNSIGNED_TX_PREFIX "Worktips unsigned tx set\004"
#define SIGNED_TX_PREFIX "Worktips signed tx set\004"
#define MULTISIG_UNSIGNED_TX_PREFIX "Worktips multisig unsigned tx set\001"
#define RECENT_OUTPUT_RATIO (0.5) // 50% of outputs are from the recent zone
#define RECENT_OUTPUT_DAYS (1.8) // last 1.8 day makes up the recent zone (taken from monerolink.pdf, Miller et al)
#define RECENT_OUTPUT_ZONE ((time_t)(RECENT_OUTPUT_DAYS * 86400))
#define RECENT_OUTPUT_BLOCKS (RECENT_OUTPUT_DAYS * 720)
#define FEE_ESTIMATE_GRACE_BLOCKS 10 // estimate fee valid for that many blocks
#define SECOND_OUTPUT_RELATEDNESS_THRESHOLD 0.0f
#define KEY_IMAGE_EXPORT_FILE_MAGIC "Worktips key image export\002"
#define MULTISIG_EXPORT_FILE_MAGIC "Worktips multisig export\001"
#define OUTPUT_EXPORT_FILE_MAGIC "Worktips output export\003"
#define SEGREGATION_FORK_HEIGHT 99999999
#define TESTNET_SEGREGATION_FORK_HEIGHT 99999999
#define STAGENET_SEGREGATION_FORK_HEIGHT 99999999
#define SEGREGATION_FORK_VICINITY 1500 /* blocks */
#define FIRST_REFRESH_GRANULARITY 1024
#define GAMMA_SHAPE 19.28
#define GAMMA_SCALE (1/1.61)
#define DEFAULT_MIN_OUTPUT_COUNT 5
#define DEFAULT_MIN_OUTPUT_VALUE (2*COIN)
static const std::string MULTISIG_SIGNATURE_MAGIC = "SigMultisigPkV1";
static const std::string MULTISIG_EXTRA_INFO_MAGIC = "MultisigxV1";
namespace
{
std::string get_default_ringdb_path()
{
boost::filesystem::path dir = tools::get_default_data_dir();
// remove .worktips, replace with .shared-ringdb
dir = dir.remove_filename();
dir /= ".shared-ringdb";
return dir.string();
}
std::string pack_multisignature_keys(const std::string& prefix, const std::vector<crypto::public_key>& keys, const crypto::secret_key& signer_secret_key)
{
std::string data;
crypto::public_key signer;
CHECK_AND_ASSERT_THROW_MES(crypto::secret_key_to_public_key(signer_secret_key, signer), "Failed to derive public spend key");
data += std::string((const char *)&signer, sizeof(crypto::public_key));
for (const auto &key: keys)
{
data += std::string((const char *)&key, sizeof(crypto::public_key));
}
data.resize(data.size() + sizeof(crypto::signature));
crypto::hash hash;
crypto::cn_fast_hash(data.data(), data.size() - sizeof(crypto::signature), hash);
crypto::signature &signature = *(crypto::signature*)&data[data.size() - sizeof(crypto::signature)];
crypto::generate_signature(hash, signer, signer_secret_key, signature);
return MULTISIG_EXTRA_INFO_MAGIC + tools::base58::encode(data);
}
std::vector<crypto::public_key> secret_keys_to_public_keys(const std::vector<crypto::secret_key>& keys)
{
std::vector<crypto::public_key> public_keys;
public_keys.reserve(keys.size());
std::transform(keys.begin(), keys.end(), std::back_inserter(public_keys), [] (const crypto::secret_key& k) -> crypto::public_key {
crypto::public_key p;
CHECK_AND_ASSERT_THROW_MES(crypto::secret_key_to_public_key(k, p), "Failed to derive public spend key");
return p;
});
return public_keys;
}
bool keys_intersect(const std::unordered_set<crypto::public_key>& s1, const std::unordered_set<crypto::public_key>& s2)
{
if (s1.empty() || s2.empty())
return false;
for (const auto& e: s1)
{
if (s2.find(e) != s2.end())
return true;
}
return false;
}
std::string get_text_reason(const cryptonote::COMMAND_RPC_SEND_RAW_TX::response &res, cryptonote::transaction const *tx, bool blink)
{
if (blink) {
return res.reason;
}
else {
std::string reason = print_tx_verification_context (res.tvc, tx);
reason += print_vote_verification_context(res.tvc.m_vote_ctx);
return reason;
}
}
}
namespace
{
// Create on-demand to prevent static initialization order fiasco issues.
struct options {
const command_line::arg_descriptor<std::string> daemon_address = {"daemon-address", tools::wallet2::tr("Use daemon instance at <host>:<port>"), ""};
const command_line::arg_descriptor<std::string> daemon_host = {"daemon-host", tools::wallet2::tr("Use daemon instance at host <arg> instead of localhost"), ""};
const command_line::arg_descriptor<std::string> proxy = {"proxy", tools::wallet2::tr("[<ip>:]<port> socks proxy to use for daemon connections"), {}, true};
const command_line::arg_descriptor<bool> trusted_daemon = {"trusted-daemon", tools::wallet2::tr("Enable commands which rely on a trusted daemon"), false};
const command_line::arg_descriptor<bool> untrusted_daemon = {"untrusted-daemon", tools::wallet2::tr("Disable commands which rely on a trusted daemon"), false};
const command_line::arg_descriptor<std::string> password = {"password", tools::wallet2::tr("Wallet password (escape/quote as needed)"), "", true};
const command_line::arg_descriptor<std::string> password_file = {"password-file", tools::wallet2::tr("Wallet password file"), "", true};
const command_line::arg_descriptor<int> daemon_port = {"daemon-port", tools::wallet2::tr("Use daemon instance at port <arg> instead of 18081"), 0};
const command_line::arg_descriptor<std::string> daemon_login = {"daemon-login", tools::wallet2::tr("Specify username[:password] for daemon RPC client"), "", true};
const command_line::arg_descriptor<std::string> daemon_ssl = {"daemon-ssl", tools::wallet2::tr("Enable SSL on daemon RPC connections: enabled|disabled|autodetect"), "autodetect"};
const command_line::arg_descriptor<std::string> daemon_ssl_private_key = {"daemon-ssl-private-key", tools::wallet2::tr("Path to a PEM format private key"), ""};
const command_line::arg_descriptor<std::string> daemon_ssl_certificate = {"daemon-ssl-certificate", tools::wallet2::tr("Path to a PEM format certificate"), ""};
const command_line::arg_descriptor<std::string> daemon_ssl_ca_certificates = {"daemon-ssl-ca-certificates", tools::wallet2::tr("Path to file containing concatenated PEM format certificate(s) to replace system CA(s).")};
const command_line::arg_descriptor<std::vector<std::string>> daemon_ssl_allowed_fingerprints = {"daemon-ssl-allowed-fingerprints", tools::wallet2::tr("List of valid fingerprints of allowed RPC servers")};
const command_line::arg_descriptor<bool> daemon_ssl_allow_any_cert = {"daemon-ssl-allow-any-cert", tools::wallet2::tr("Allow any SSL certificate from the daemon"), false};
const command_line::arg_descriptor<bool> daemon_ssl_allow_chained = {"daemon-ssl-allow-chained", tools::wallet2::tr("Allow user (via --daemon-ssl-ca-certificates) chain certificates"), false};
const command_line::arg_descriptor<bool> testnet = {"testnet", tools::wallet2::tr("For testnet. Daemon must also be launched with --testnet flag"), false};
const command_line::arg_descriptor<bool> stagenet = {"stagenet", tools::wallet2::tr("For stagenet. Daemon must also be launched with --stagenet flag"), false};
#if defined(WORKTIPS_ENABLE_INTEGRATION_TEST_HOOKS)
const command_line::arg_descriptor<bool> fakenet = {"fakenet", tools::wallet2::tr("For worktips integration tests, fakenet"), false};
#endif
const command_line::arg_descriptor<std::string, false, true, 2> shared_ringdb_dir = {
"shared-ringdb-dir", tools::wallet2::tr("Set shared ring database path"),
get_default_ringdb_path(),
{{ &testnet, &stagenet }},
[](std::array<bool, 2> testnet_stagenet, bool defaulted, std::string val)->std::string {
if (testnet_stagenet[0])
return (boost::filesystem::path(val) / "testnet").string();
else if (testnet_stagenet[1])
return (boost::filesystem::path(val) / "stagenet").string();
return val;
}
};
const command_line::arg_descriptor<uint64_t> kdf_rounds = {"kdf-rounds", tools::wallet2::tr("Number of rounds for the key derivation function"), 1};
const command_line::arg_descriptor<std::string> hw_device = {"hw-device", tools::wallet2::tr("HW device to use"), ""};
const command_line::arg_descriptor<std::string> hw_device_derivation_path = {"hw-device-deriv-path", tools::wallet2::tr("HW device wallet derivation path (e.g., SLIP-10)"), ""};
const command_line::arg_descriptor<std::string> tx_notify = { "tx-notify" , "Run a program for each new incoming transaction, '%s' will be replaced by the transaction hash" , "" };
const command_line::arg_descriptor<bool> offline = {"offline", tools::wallet2::tr("Do not connect to a daemon"), false};
};
void do_prepare_file_names(const std::string& file_path, std::string& keys_file, std::string& wallet_file, std::string &mms_file)
{
keys_file = file_path;
wallet_file = file_path;
boost::system::error_code e;
if(string_tools::get_extension(keys_file) == "keys")
{//provided keys file name
wallet_file = string_tools::cut_off_extension(wallet_file);
}else
{//provided wallet file name
keys_file += ".keys";
}
mms_file = file_path + ".mms";
}
uint64_t calculate_fee_from_weight(byte_and_output_fees base_fees, uint64_t weight, uint64_t outputs, uint64_t fee_percent, uint64_t fee_fixed, uint64_t fee_quantization_mask)
{
uint64_t fee = (weight * base_fees.first + outputs * base_fees.second) * fee_percent / 100;
fee = (fee + fee_quantization_mask - 1) / fee_quantization_mask * fee_quantization_mask + fee_fixed;
return fee;
}
std::string get_weight_string(size_t weight)
{
return std::to_string(weight) + " weight";
}
std::string get_weight_string(const cryptonote::transaction &tx, size_t blob_size)
{
return get_weight_string(get_transaction_weight(tx, blob_size));
}
std::unique_ptr<tools::wallet2> make_basic(const boost::program_options::variables_map& vm, bool unattended, const options& opts, const std::function<boost::optional<tools::password_container>(const char *, bool)> &password_prompter)
{
namespace ip = boost::asio::ip;
const bool testnet = command_line::get_arg(vm, opts.testnet);
const bool stagenet = command_line::get_arg(vm, opts.stagenet);
network_type nettype = testnet ? TESTNET : stagenet ? STAGENET : MAINNET;
#if defined(WORKTIPS_ENABLE_INTEGRATION_TEST_HOOKS)
if (command_line::get_arg(vm, opts.fakenet))
{
assert(!testnet &&!stagenet); // NOTE(worktips): Developer error
nettype = FAKECHAIN;
}
#endif
const uint64_t kdf_rounds = command_line::get_arg(vm, opts.kdf_rounds);
THROW_WALLET_EXCEPTION_IF(kdf_rounds == 0, tools::error::wallet_internal_error, "KDF rounds must not be 0");
const bool use_proxy = command_line::has_arg(vm, opts.proxy);
auto daemon_address = command_line::get_arg(vm, opts.daemon_address);
auto daemon_host = command_line::get_arg(vm, opts.daemon_host);
auto daemon_port = command_line::get_arg(vm, opts.daemon_port);
auto device_name = command_line::get_arg(vm, opts.hw_device);
auto device_derivation_path = command_line::get_arg(vm, opts.hw_device_derivation_path);
auto daemon_ssl_private_key = command_line::get_arg(vm, opts.daemon_ssl_private_key);
auto daemon_ssl_certificate = command_line::get_arg(vm, opts.daemon_ssl_certificate);
auto daemon_ssl_ca_file = command_line::get_arg(vm, opts.daemon_ssl_ca_certificates);
auto daemon_ssl_allowed_fingerprints = command_line::get_arg(vm, opts.daemon_ssl_allowed_fingerprints);
auto daemon_ssl_allow_any_cert = command_line::get_arg(vm, opts.daemon_ssl_allow_any_cert);
auto daemon_ssl = command_line::get_arg(vm, opts.daemon_ssl);
// user specified CA file or fingeprints implies enabled SSL by default
epee::net_utils::ssl_options_t ssl_options = epee::net_utils::ssl_support_t::e_ssl_support_enabled;
if (command_line::get_arg(vm, opts.daemon_ssl_allow_any_cert))
ssl_options.verification = epee::net_utils::ssl_verification_t::none;
else if (!daemon_ssl_ca_file.empty() || !daemon_ssl_allowed_fingerprints.empty())
{
std::vector<std::vector<uint8_t>> ssl_allowed_fingerprints{ daemon_ssl_allowed_fingerprints.size() };
std::transform(daemon_ssl_allowed_fingerprints.begin(), daemon_ssl_allowed_fingerprints.end(), ssl_allowed_fingerprints.begin(), epee::from_hex::vector);
for (const auto &fpr: ssl_allowed_fingerprints)
{
THROW_WALLET_EXCEPTION_IF(fpr.size() != SSL_FINGERPRINT_SIZE, tools::error::wallet_internal_error,
"SHA-256 fingerprint should be " BOOST_PP_STRINGIZE(SSL_FINGERPRINT_SIZE) " bytes long.");
}
ssl_options = epee::net_utils::ssl_options_t{
std::move(ssl_allowed_fingerprints), std::move(daemon_ssl_ca_file)
};
if (command_line::get_arg(vm, opts.daemon_ssl_allow_chained))
ssl_options.verification = epee::net_utils::ssl_verification_t::user_ca;
}
if (ssl_options.verification != epee::net_utils::ssl_verification_t::user_certificates || !command_line::is_arg_defaulted(vm, opts.daemon_ssl))
{
THROW_WALLET_EXCEPTION_IF(!epee::net_utils::ssl_support_from_string(ssl_options.support, daemon_ssl), tools::error::wallet_internal_error,
tools::wallet2::tr("Invalid argument for ") + std::string(opts.daemon_ssl.name));
}
ssl_options.auth = epee::net_utils::ssl_authentication_t{
std::move(daemon_ssl_private_key), std::move(daemon_ssl_certificate)
};
THROW_WALLET_EXCEPTION_IF(!daemon_address.empty() && !daemon_host.empty() && 0 != daemon_port,
tools::error::wallet_internal_error, tools::wallet2::tr("can't specify daemon host or port more than once"));
boost::optional<epee::net_utils::http::login> login{};
if (command_line::has_arg(vm, opts.daemon_login))
{
auto parsed = tools::login::parse(
command_line::get_arg(vm, opts.daemon_login), false, [password_prompter](bool verify) {
return password_prompter("Daemon client password", verify);
}
);
if (!parsed)
return nullptr;
login.emplace(std::move(parsed->username), std::move(parsed->password).password());
}
if (daemon_host.empty())
daemon_host = "localhost";
if (!daemon_port)
{
daemon_port = get_config(nettype).RPC_DEFAULT_PORT;
}
if (daemon_address.empty())
daemon_address = std::string("http://") + daemon_host + ":" + std::to_string(daemon_port);
{
const boost::string_ref real_daemon = boost::string_ref{daemon_address}.substr(0, daemon_address.rfind(':'));
/* If SSL or proxy is enabled, then a specific cert, CA or fingerprint must
be specified. This is specific to the wallet. */
const bool verification_required =
ssl_options.verification != epee::net_utils::ssl_verification_t::none &&
(ssl_options.support == epee::net_utils::ssl_support_t::e_ssl_support_enabled || use_proxy);
THROW_WALLET_EXCEPTION_IF(
verification_required && !ssl_options.has_strong_verification(real_daemon),
tools::error::wallet_internal_error,
tools::wallet2::tr("Enabling --") + std::string{use_proxy ? opts.proxy.name : opts.daemon_ssl.name} + tools::wallet2::tr(" requires --") +
opts.daemon_ssl_ca_certificates.name + tools::wallet2::tr(" or --") + opts.daemon_ssl_allowed_fingerprints.name + tools::wallet2::tr(" or use of a .onion/.i2p domain")
);
}
boost::asio::ip::tcp::endpoint proxy{};
if (use_proxy)
{
namespace ip = boost::asio::ip;
const auto proxy_address = command_line::get_arg(vm, opts.proxy);
boost::string_ref proxy_port{proxy_address};
boost::string_ref proxy_host = proxy_port.substr(0, proxy_port.rfind(":"));
if (proxy_port.size() == proxy_host.size())
proxy_host = "127.0.0.1";
else
proxy_port = proxy_port.substr(proxy_host.size() + 1);
uint16_t port_value = 0;
THROW_WALLET_EXCEPTION_IF(
!epee::string_tools::get_xtype_from_string(port_value, std::string{proxy_port}),
tools::error::wallet_internal_error,
std::string{"Invalid port specified for --"} + opts.proxy.name
);
boost::system::error_code error{};
proxy = ip::tcp::endpoint{ip::address::from_string(std::string{proxy_host}, error), port_value};
THROW_WALLET_EXCEPTION_IF(bool(error), tools::error::wallet_internal_error, std::string{"Invalid IP address specified for --"} + opts.proxy.name);
}
bool trusted_daemon;
THROW_WALLET_EXCEPTION_IF(!command_line::is_arg_defaulted(vm, opts.trusted_daemon) && !command_line::is_arg_defaulted(vm, opts.untrusted_daemon),
tools::error::wallet_internal_error, tools::wallet2::tr("--trusted-daemon and --untrusted-daemon cannot both be specified"));
if (!command_line::is_arg_defaulted(vm, opts.trusted_daemon) || !command_line::is_arg_defaulted(vm, opts.untrusted_daemon))
trusted_daemon = command_line::get_arg(vm, opts.trusted_daemon) && !command_line::get_arg(vm, opts.untrusted_daemon);
else
{
// set --trusted-daemon if local and not overridden
trusted_daemon = false;
try
{
if (tools::is_local_address(daemon_address))
{
MINFO(tools::wallet2::tr("Daemon is local, assuming trusted"));
trusted_daemon = true;
}
}
catch (const std::exception &e) { }
}
std::unique_ptr<tools::wallet2> wallet(new tools::wallet2(nettype, kdf_rounds, unattended));
wallet->init(std::move(daemon_address), std::move(login), std::move(proxy), 0, trusted_daemon, std::move(ssl_options));
boost::filesystem::path ringdb_path = command_line::get_arg(vm, opts.shared_ringdb_dir);
wallet->set_ring_database(ringdb_path.string());
wallet->get_message_store().set_options(vm);
wallet->device_name(device_name);
wallet->device_derivation_path(device_derivation_path);
if (command_line::get_arg(vm, opts.offline))
wallet->set_offline();
try
{
if (!command_line::is_arg_defaulted(vm, opts.tx_notify))
wallet->set_tx_notify(std::shared_ptr<tools::Notify>(new tools::Notify(command_line::get_arg(vm, opts.tx_notify).c_str())));
}
catch (const std::exception &e)
{
MERROR("Failed to parse tx notify spec");
}
return wallet;
}
boost::optional<tools::password_container> get_password(const boost::program_options::variables_map& vm, const options& opts, const std::function<boost::optional<tools::password_container>(const char*, bool)> &password_prompter, const bool verify)
{
if (command_line::has_arg(vm, opts.password) && command_line::has_arg(vm, opts.password_file))
{
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("can't specify more than one of --password and --password-file"));
}
if (command_line::has_arg(vm, opts.password))
{
return tools::password_container{command_line::get_arg(vm, opts.password)};
}
if (command_line::has_arg(vm, opts.password_file))
{
std::string password;
bool r = epee::file_io_utils::load_file_to_string(command_line::get_arg(vm, opts.password_file),
password);
THROW_WALLET_EXCEPTION_IF(!r, tools::error::wallet_internal_error, tools::wallet2::tr("the password file specified could not be read"));
// Remove line breaks the user might have inserted
boost::trim_right_if(password, boost::is_any_of("\r\n"));
return {tools::password_container{std::move(password)}};
}
THROW_WALLET_EXCEPTION_IF(!password_prompter, tools::error::wallet_internal_error, tools::wallet2::tr("no password specified; use --prompt-for-password to prompt for a password"));
return password_prompter(verify ? tools::wallet2::tr("Enter a new password for the wallet") : tools::wallet2::tr("Wallet password"), verify);
}
std::pair<std::unique_ptr<tools::wallet2>, tools::password_container> generate_from_json(const std::string& json_file, const boost::program_options::variables_map& vm, bool unattended, const options& opts, const std::function<boost::optional<tools::password_container>(const char *, bool)> &password_prompter)
{
const bool testnet = command_line::get_arg(vm, opts.testnet);
const bool stagenet = command_line::get_arg(vm, opts.stagenet);
const network_type nettype = testnet ? TESTNET : stagenet ? STAGENET : MAINNET;
/* GET_FIELD_FROM_JSON_RETURN_ON_ERROR Is a generic macro that can return
false. Gcc will coerce this into unique_ptr(nullptr), but clang correctly
fails. This large wrapper is for the use of that macro */
std::unique_ptr<tools::wallet2> wallet;
epee::wipeable_string password;
const auto do_generate = [&]() -> bool {
std::string buf;
if (!epee::file_io_utils::load_file_to_string(json_file, buf)) {
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, std::string(tools::wallet2::tr("Failed to load file ")) + json_file);
return false;
}
rapidjson::Document json;
if (json.Parse(buf.c_str()).HasParseError()) {
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("Failed to parse JSON"));
return false;
}
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, version, unsigned, Uint, true, 0);
const int current_version = 1;
THROW_WALLET_EXCEPTION_IF(field_version > current_version, tools::error::wallet_internal_error,
((boost::format(tools::wallet2::tr("Version %u too new, we can only grok up to %u")) % field_version % current_version)).str());
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, filename, std::string, String, true, std::string());
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, scan_from_height, uint64_t, Uint64, false, 0);
const bool recover = true;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, password, std::string, String, false, std::string());
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, viewkey, std::string, String, false, std::string());
crypto::secret_key viewkey;
if (field_viewkey_found)
{
cryptonote::blobdata viewkey_data;
if(!epee::string_tools::parse_hexstr_to_binbuff(field_viewkey, viewkey_data) || viewkey_data.size() != sizeof(crypto::secret_key))
{
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("failed to parse view key secret key"));
}
viewkey = *reinterpret_cast<const crypto::secret_key*>(viewkey_data.data());
crypto::public_key pkey;
if (!crypto::secret_key_to_public_key(viewkey, pkey)) {
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("failed to verify view key secret key"));
}
}
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, spendkey, std::string, String, false, std::string());
crypto::secret_key spendkey;
if (field_spendkey_found)
{
cryptonote::blobdata spendkey_data;
if(!epee::string_tools::parse_hexstr_to_binbuff(field_spendkey, spendkey_data) || spendkey_data.size() != sizeof(crypto::secret_key))
{
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("failed to parse spend key secret key"));
}
spendkey = *reinterpret_cast<const crypto::secret_key*>(spendkey_data.data());
crypto::public_key pkey;
if (!crypto::secret_key_to_public_key(spendkey, pkey)) {
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("failed to verify spend key secret key"));
}
}
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, seed, std::string, String, false, std::string());
std::string old_language;
crypto::secret_key recovery_key;
bool restore_deterministic_wallet = false;
if (field_seed_found)
{
if (!crypto::ElectrumWords::words_to_bytes(field_seed, recovery_key, old_language))
{
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("Electrum-style word list failed verification"));
}
restore_deterministic_wallet = true;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, seed_passphrase, std::string, String, false, std::string());
if (field_seed_passphrase_found)
{
if (!field_seed_passphrase.empty())
recovery_key = cryptonote::decrypt_key(recovery_key, field_seed_passphrase);
}
}
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, address, std::string, String, false, std::string());
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, create_address_file, int, Int, false, false);
bool create_address_file = field_create_address_file;
// compatibility checks
if (!field_seed_found && !field_viewkey_found && !field_spendkey_found)
{
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("At least one of either an Electrum-style word list, private view key, or private spend key must be specified"));
}
if (field_seed_found && (field_viewkey_found || field_spendkey_found))
{
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("Both Electrum-style word list and private key(s) specified"));
}
// if an address was given, we check keys against it, and deduce the spend
// public key if it was not given
if (field_address_found)
{
cryptonote::address_parse_info info;
if(!get_account_address_from_str(info, nettype, field_address))
{
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("invalid address"));
}
if (field_viewkey_found)
{
crypto::public_key pkey;
if (!crypto::secret_key_to_public_key(viewkey, pkey)) {
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("failed to verify view key secret key"));
}
if (info.address.m_view_public_key != pkey) {
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("view key does not match standard address"));
}
}
if (field_spendkey_found)
{
crypto::public_key pkey;
if (!crypto::secret_key_to_public_key(spendkey, pkey)) {
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("failed to verify spend key secret key"));
}
if (info.address.m_spend_public_key != pkey) {
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("spend key does not match standard address"));
}
}
}
const bool deprecated_wallet = restore_deterministic_wallet && ((old_language == crypto::ElectrumWords::old_language_name) ||
crypto::ElectrumWords::get_is_old_style_seed(field_seed));
THROW_WALLET_EXCEPTION_IF(deprecated_wallet, tools::error::wallet_internal_error,
tools::wallet2::tr("Cannot generate deprecated wallets from JSON"));
wallet.reset(make_basic(vm, unattended, opts, password_prompter).release());
wallet->set_refresh_from_block_height(field_scan_from_height);
wallet->explicit_refresh_from_block_height(field_scan_from_height_found);
if (!old_language.empty())
wallet->set_seed_language(old_language);
try
{
if (!field_seed.empty())
{
wallet->generate(field_filename, field_password, recovery_key, recover, false, create_address_file);
password = field_password;
}
else if (field_viewkey.empty() && !field_spendkey.empty())
{
wallet->generate(field_filename, field_password, spendkey, recover, false, create_address_file);
password = field_password;
}
else
{
cryptonote::account_public_address address;
if (!crypto::secret_key_to_public_key(viewkey, address.m_view_public_key)) {
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("failed to verify view key secret key"));
}
if (field_spendkey.empty())
{
// if we have an address but no spend key, we can deduce the spend public key
// from the address
if (field_address_found)
{
cryptonote::address_parse_info info;
if(!get_account_address_from_str(info, nettype, field_address))
{
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, std::string(tools::wallet2::tr("failed to parse address: ")) + field_address);
}
address.m_spend_public_key = info.address.m_spend_public_key;
}
else
{
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("Address must be specified in order to create watch-only wallet"));
}
wallet->generate(field_filename, field_password, address, viewkey, create_address_file);
password = field_password;
}
else
{
if (!crypto::secret_key_to_public_key(spendkey, address.m_spend_public_key)) {
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, tools::wallet2::tr("failed to verify spend key secret key"));
}
wallet->generate(field_filename, field_password, address, spendkey, viewkey, create_address_file);
password = field_password;
}
}
}
catch (const std::exception& e)
{
THROW_WALLET_EXCEPTION(tools::error::wallet_internal_error, std::string(tools::wallet2::tr("failed to generate new wallet: ")) + e.what());
}
return true;
};
if (do_generate())
{
return {std::move(wallet), tools::password_container(password)};
}
return {nullptr, tools::password_container{}};
}
std::string strjoin(const std::vector<size_t> &V, const char *sep)
{
std::stringstream ss;
bool first = true;
for (const auto &v: V)
{
if (!first)
ss << sep;
ss << std::to_string(v);
first = false;
}
return ss.str();
}
static bool emplace_or_replace(std::unordered_multimap<crypto::hash, tools::wallet2::pool_payment_details> &container,
const crypto::hash &key, const tools::wallet2::pool_payment_details &pd)
{
auto range = container.equal_range(key);
for (auto i = range.first; i != range.second; ++i)
{
if (i->second.m_pd.m_tx_hash == pd.m_pd.m_tx_hash && i->second.m_pd.m_subaddr_index == pd.m_pd.m_subaddr_index)
{
i->second = pd;
return false;
}
}
container.emplace(key, pd);
return true;
}
void drop_from_short_history(std::list<crypto::hash> &short_chain_history, size_t N)
{
std::list<crypto::hash>::iterator right;
// drop early N off, skipping the genesis block
if (short_chain_history.size() > N) {
right = short_chain_history.end();
std::advance(right,-1);
std::list<crypto::hash>::iterator left = right;
std::advance(left, -N);
short_chain_history.erase(left, right);
}
}
size_t estimate_rct_tx_size(int n_inputs, int mixin, int n_outputs, size_t extra_size)
{
size_t size = 0;
// tx prefix
// first few bytes
size += 1 + 6;
// vin
size += n_inputs * (1+6+(mixin+1)*2+32);
// vout
size += n_outputs * (6+32);
// extra
size += extra_size;
// rct signatures
// type
size += 1;
// rangeSigs
size_t log_padded_outputs = 0;
while ((1<<log_padded_outputs) < n_outputs)
++log_padded_outputs;
size += (2 * (6 + log_padded_outputs) + 4 + 5) * 32 + 3;
// MGs
size += n_inputs * (64 * (mixin+1) + 32);
// mixRing - not serialized, can be reconstructed
/* size += 2 * 32 * (mixin+1) * n_inputs; */
// pseudoOuts
size += 32 * n_inputs;
// ecdhInfo
size += 8 * n_outputs;
// outPk - only commitment is saved
size += 32 * n_outputs;
// txnFee
size += 4;
LOG_PRINT_L2("estimated bulletproof rct tx size for " << n_inputs << " inputs with ring size " << (mixin+1) << " and " << n_outputs << " outputs: " << size << " (" << ((32 * n_inputs/*+1*/) + 2 * 32 * (mixin+1) * n_inputs + 32 * n_outputs) << " saved)");
return size;
}
uint64_t estimate_tx_weight(int n_inputs, int mixin, int n_outputs, size_t extra_size)
{
size_t size = estimate_rct_tx_size(n_inputs, mixin, n_outputs, extra_size);
if (n_outputs > 2)
{
const uint64_t bp_base = 368;
size_t log_padded_outputs = 2;
while ((1<<log_padded_outputs) < n_outputs)
++log_padded_outputs;
uint64_t nlr = 2 * (6 + log_padded_outputs);
const uint64_t bp_size = 32 * (9 + nlr);
const uint64_t bp_clawback = (bp_base * (1<<log_padded_outputs) - bp_size) * 4 / 5;
MDEBUG("clawback on size " << size << ": " << bp_clawback);
size += bp_clawback;
}
return size;
}
uint64_t estimate_fee(int n_inputs, int mixin, int n_outputs, size_t extra_size, byte_and_output_fees base_fees, uint64_t fee_percent, uint64_t fee_fixed, uint64_t fee_quantization_mask)
{
const size_t estimated_tx_weight = estimate_tx_weight(n_inputs, mixin, n_outputs, extra_size);
return calculate_fee_from_weight(base_fees, estimated_tx_weight, n_outputs, fee_percent, fee_fixed, fee_quantization_mask);
}
uint64_t calculate_fee(const cryptonote::transaction &tx, size_t blob_size, byte_and_output_fees base_fees, uint64_t fee_percent, uint64_t fee_fixed, uint64_t fee_quantization_mask)
{
return calculate_fee_from_weight(base_fees, cryptonote::get_transaction_weight(tx, blob_size), tx.vout.size(), fee_percent, fee_fixed, fee_quantization_mask);
}
bool get_short_payment_id(crypto::hash8 &payment_id8, const tools::wallet2::pending_tx &ptx, hw::device &hwdev)
{
std::vector<tx_extra_field> tx_extra_fields;
parse_tx_extra(ptx.tx.extra, tx_extra_fields); // ok if partially parsed
cryptonote::tx_extra_nonce extra_nonce;
if (find_tx_extra_field_by_type(tx_extra_fields, extra_nonce))
{
if(get_encrypted_payment_id_from_tx_extra_nonce(extra_nonce.nonce, payment_id8))
{
if (ptx.dests.empty())
{
MWARNING("Encrypted payment id found, but no destinations public key, cannot decrypt");
return false;
}
return hwdev.decrypt_payment_id(payment_id8, ptx.dests[0].addr.m_view_public_key, ptx.tx_key);
}
}
return false;
}
tools::wallet2::tx_construction_data get_construction_data_with_decrypted_short_payment_id(const tools::wallet2::pending_tx &ptx, hw::device &hwdev)
{
tools::wallet2::tx_construction_data construction_data = ptx.construction_data;
crypto::hash8 payment_id = null_hash8;
if (get_short_payment_id(payment_id, ptx, hwdev))
{
// Remove encrypted
remove_field_from_tx_extra(construction_data.extra, typeid(cryptonote::tx_extra_nonce));
// Add decrypted
std::string extra_nonce;
set_encrypted_payment_id_to_tx_extra_nonce(extra_nonce, payment_id);
THROW_WALLET_EXCEPTION_IF(!add_extra_nonce_to_tx_extra(construction_data.extra, extra_nonce),
tools::error::wallet_internal_error, "Failed to add decrypted payment id to tx extra");
LOG_PRINT_L1("Decrypted payment ID: " << payment_id);
}
return construction_data;
}
uint32_t get_subaddress_clamped_sum(uint32_t idx, uint32_t extra)
{
static constexpr uint32_t uint32_max = std::numeric_limits<uint32_t>::max();
if (idx > uint32_max - extra)
return uint32_max;
return idx + extra;
}
static void setup_shim(hw::wallet_shim * shim, tools::wallet2 * wallet)
{
shim->get_tx_pub_key_from_received_outs = boost::bind(&tools::wallet2::get_tx_pub_key_from_received_outs, wallet, _1);
}
bool get_pruned_tx(const cryptonote::COMMAND_RPC_GET_TRANSACTIONS::entry &entry, cryptonote::transaction &tx, crypto::hash &tx_hash)
{
cryptonote::blobdata bd;
// easy case if we have the whole tx
if (!entry.as_hex.empty() || (!entry.prunable_as_hex.empty() && !entry.pruned_as_hex.empty()))
{
CHECK_AND_ASSERT_MES(epee::string_tools::parse_hexstr_to_binbuff(entry.as_hex.empty() ? entry.pruned_as_hex + entry.prunable_as_hex : entry.as_hex, bd), false, "Failed to parse tx data");
CHECK_AND_ASSERT_MES(cryptonote::parse_and_validate_tx_from_blob(bd, tx), false, "Invalid tx data");
tx_hash = cryptonote::get_transaction_hash(tx);
// if the hash was given, check it matches
CHECK_AND_ASSERT_MES(entry.tx_hash.empty() || epee::string_tools::pod_to_hex(tx_hash) == entry.tx_hash, false,
"Response claims a different hash than the data yields");
return true;
}
// case of a pruned tx with its prunable data hash
if (!entry.pruned_as_hex.empty() && !entry.prunable_hash.empty())
{
crypto::hash ph;
CHECK_AND_ASSERT_MES(epee::string_tools::hex_to_pod(entry.prunable_hash, ph), false, "Failed to parse prunable hash");
CHECK_AND_ASSERT_MES(epee::string_tools::parse_hexstr_to_binbuff(entry.pruned_as_hex, bd), false, "Failed to parse pruned data");
CHECK_AND_ASSERT_MES(parse_and_validate_tx_base_from_blob(bd, tx), false, "Invalid base tx data");
// only v2 txes can calculate their txid after pruned
if (bd[0] > 1)
{
tx_hash = cryptonote::get_pruned_transaction_hash(tx, ph);
}
else
{
// for v1, we trust the dameon
CHECK_AND_ASSERT_MES(epee::string_tools::hex_to_pod(entry.tx_hash, tx_hash), false, "Failed to parse tx hash");
}
return true;
}
return false;
}
//-----------------------------------------------------------------
} //namespace
namespace tools
{
// for now, limit to 30 attempts. TODO: discuss a good number to limit to.
const size_t MAX_SPLIT_ATTEMPTS = 30;
constexpr const std::chrono::seconds wallet2::rpc_timeout;
const char* wallet2::tr(const char* str) { return i18n_translate(str, "tools::wallet2"); }
gamma_picker::gamma_picker(const std::vector<uint64_t> &rct_offsets, double shape, double scale):
rct_offsets(rct_offsets)
{
gamma = std::gamma_distribution<double>(shape, scale);
THROW_WALLET_EXCEPTION_IF(rct_offsets.size() <= CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE, error::wallet_internal_error, "Bad offset calculation");
const size_t blocks_in_a_year = 86400 * 365 / DIFFICULTY_TARGET_V2;
const size_t blocks_to_consider = std::min<size_t>(rct_offsets.size(), blocks_in_a_year);
const size_t outputs_to_consider = rct_offsets.back() - (blocks_to_consider < rct_offsets.size() ? rct_offsets[rct_offsets.size() - blocks_to_consider - 1] : 0);
begin = rct_offsets.data();
end = rct_offsets.data() + rct_offsets.size() - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE;
num_rct_outputs = *(end - 1);
THROW_WALLET_EXCEPTION_IF(num_rct_outputs == 0, error::wallet_internal_error, "No rct outputs");
average_output_time = DIFFICULTY_TARGET_V2 * blocks_to_consider / outputs_to_consider; // this assumes constant target over the whole rct range
};
gamma_picker::gamma_picker(const std::vector<uint64_t> &rct_offsets): gamma_picker(rct_offsets, GAMMA_SHAPE, GAMMA_SCALE) {}
uint64_t gamma_picker::pick()
{
double x = gamma(engine);
x = exp(x);
uint64_t output_index = x / average_output_time;
if (output_index >= num_rct_outputs)
return std::numeric_limits<uint64_t>::max(); // bad pick
output_index = num_rct_outputs - 1 - output_index;
const uint64_t *it = std::lower_bound(begin, end, output_index);
THROW_WALLET_EXCEPTION_IF(it == end, error::wallet_internal_error, "output_index not found");
uint64_t index = std::distance(begin, it);
const uint64_t first_rct = index == 0 ? 0 : rct_offsets[index - 1];
const uint64_t n_rct = rct_offsets[index] - first_rct;
if (n_rct == 0)
return std::numeric_limits<uint64_t>::max(); // bad pick
MTRACE("Picking 1/" << n_rct << " in block " << index);
return first_rct + crypto::rand_idx(n_rct);
};
wallet_keys_unlocker::wallet_keys_unlocker(wallet2 &w, const boost::optional<tools::password_container> &password):
w(w),
locked(password != boost::none)
{
if (!locked || w.is_unattended() || w.ask_password() != tools::wallet2::AskPasswordToDecrypt || w.watch_only())
{
locked = false;
return;
}
const epee::wipeable_string pass = password->password();
w.generate_chacha_key_from_password(pass, key);
w.decrypt_keys(key);
}
wallet_keys_unlocker::wallet_keys_unlocker(wallet2 &w, bool locked, const epee::wipeable_string &password):
w(w),
locked(locked)
{
if (!locked)
return;
w.generate_chacha_key_from_password(password, key);
w.decrypt_keys(key);
}
wallet_keys_unlocker::~wallet_keys_unlocker()
{
if (!locked)
return;
try { w.encrypt_keys(key); }
catch (...)
{
MERROR("Failed to re-encrypt wallet keys");
// do not propagate through dtor, we'd crash
}
}
void wallet_device_callback::on_button_request(uint64_t code)
{
if (wallet)
wallet->on_device_button_request(code);
}
void wallet_device_callback::on_button_pressed()
{
if (wallet)
wallet->on_device_button_pressed();
}
boost::optional<epee::wipeable_string> wallet_device_callback::on_pin_request()
{
if (wallet)
return wallet->on_device_pin_request();
return boost::none;
}
boost::optional<epee::wipeable_string> wallet_device_callback::on_passphrase_request(bool on_device)
{
if (wallet)
return wallet->on_device_passphrase_request(on_device);
return boost::none;
}
void wallet_device_callback::on_progress(const hw::device_progress& event)
{
if (wallet)
wallet->on_device_progress(event);
}
wallet2::wallet2(network_type nettype, uint64_t kdf_rounds, bool unattended):
m_multisig_rescan_info(NULL),
m_multisig_rescan_k(NULL),
m_upper_transaction_weight_limit(0),
m_run(true),
m_callback(0),
m_trusted_daemon(false),
m_nettype(nettype),
m_multisig_rounds_passed(0),
m_always_confirm_transfers(true),
m_print_ring_members(false),
m_store_tx_info(true),
m_default_mixin(0),
m_default_priority(0),
m_refresh_type(RefreshOptimizeCoinbase),
m_auto_refresh(true),
m_first_refresh_done(false),
m_refresh_from_block_height(0),
m_explicit_refresh_from_block_height(true),
m_confirm_missing_payment_id(true),
m_confirm_non_default_ring_size(true),
m_ask_password(AskPasswordToDecrypt),
m_min_output_count(0),
m_min_output_value(0),
m_merge_destinations(false),
m_confirm_backlog(true),
m_confirm_backlog_threshold(0),
m_confirm_export_overwrite(true),
m_auto_low_priority(true),
m_segregate_pre_fork_outputs(true),
m_key_reuse_mitigation2(true),
m_segregation_height(0),
m_ignore_fractional_outputs(true),
m_track_uses(false),
m_setup_background_mining(BackgroundMiningMaybe),
m_is_initialized(false),
m_kdf_rounds(kdf_rounds),
is_old_file_format(false),
m_watch_only(false),
m_multisig(false),
m_multisig_threshold(0),
m_node_rpc_proxy(m_http_client, m_daemon_rpc_mutex),
m_account_public_address{crypto::null_pkey, crypto::null_pkey},
m_subaddress_lookahead_major(SUBADDRESS_LOOKAHEAD_MAJOR),
m_subaddress_lookahead_minor(SUBADDRESS_LOOKAHEAD_MINOR),
m_light_wallet(false),
m_light_wallet_scanned_block_height(0),
m_light_wallet_blockchain_height(0),
m_light_wallet_connected(false),
m_light_wallet_balance(0),
m_light_wallet_unlocked_balance(0),
m_original_keys_available(false),
m_message_store(),
m_key_device_type(hw::device::device_type::SOFTWARE),
m_ring_history_saved(false),
m_ringdb(),
m_last_block_reward(0),
m_encrypt_keys_after_refresh(boost::none),
m_unattended(unattended),
m_devices_registered(false),
m_device_last_key_image_sync(0),
m_offline(false)
{
}
wallet2::~wallet2()
{
}
bool wallet2::has_testnet_option(const boost::program_options::variables_map& vm)
{
return command_line::get_arg(vm, options().testnet);
}
bool wallet2::has_stagenet_option(const boost::program_options::variables_map& vm)
{
return command_line::get_arg(vm, options().stagenet);
}
std::string wallet2::device_name_option(const boost::program_options::variables_map& vm)
{
return command_line::get_arg(vm, options().hw_device);
}
std::string wallet2::device_derivation_path_option(const boost::program_options::variables_map &vm)
{
return command_line::get_arg(vm, options().hw_device_derivation_path);
}
void wallet2::init_options(boost::program_options::options_description& desc_params)
{
const options opts{};
command_line::add_arg(desc_params, opts.daemon_address);
command_line::add_arg(desc_params, opts.daemon_host);
command_line::add_arg(desc_params, opts.proxy);
command_line::add_arg(desc_params, opts.trusted_daemon);
command_line::add_arg(desc_params, opts.untrusted_daemon);
command_line::add_arg(desc_params, opts.password);
command_line::add_arg(desc_params, opts.password_file);
command_line::add_arg(desc_params, opts.daemon_port);
command_line::add_arg(desc_params, opts.daemon_login);
command_line::add_arg(desc_params, opts.daemon_ssl);
command_line::add_arg(desc_params, opts.daemon_ssl_private_key);
command_line::add_arg(desc_params, opts.daemon_ssl_certificate);
command_line::add_arg(desc_params, opts.daemon_ssl_ca_certificates);
command_line::add_arg(desc_params, opts.daemon_ssl_allowed_fingerprints);
command_line::add_arg(desc_params, opts.daemon_ssl_allow_any_cert);
command_line::add_arg(desc_params, opts.daemon_ssl_allow_chained);
command_line::add_arg(desc_params, opts.testnet);
command_line::add_arg(desc_params, opts.stagenet);
#if defined(WORKTIPS_ENABLE_INTEGRATION_TEST_HOOKS)
command_line::add_arg(desc_params, opts.fakenet);
#endif
command_line::add_arg(desc_params, opts.shared_ringdb_dir);
command_line::add_arg(desc_params, opts.kdf_rounds);
mms::message_store::init_options(desc_params);
command_line::add_arg(desc_params, opts.hw_device);
command_line::add_arg(desc_params, opts.hw_device_derivation_path);
command_line::add_arg(desc_params, opts.tx_notify);
command_line::add_arg(desc_params, opts.offline);
}
std::pair<std::unique_ptr<wallet2>, tools::password_container> wallet2::make_from_json(const boost::program_options::variables_map& vm, bool unattended, const std::string& json_file, const std::function<boost::optional<tools::password_container>(const char *, bool)> &password_prompter)
{
const options opts{};
return generate_from_json(json_file, vm, unattended, opts, password_prompter);
}
std::pair<std::unique_ptr<wallet2>, password_container> wallet2::make_from_file(
const boost::program_options::variables_map& vm, bool unattended, const std::string& wallet_file, const std::function<boost::optional<tools::password_container>(const char *, bool)> &password_prompter)
{
const options opts{};
auto pwd = get_password(vm, opts, password_prompter, false);
if (!pwd)
{
return {nullptr, password_container{}};
}
auto wallet = make_basic(vm, unattended, opts, password_prompter);
if (wallet && !wallet_file.empty())
{
wallet->load(wallet_file, pwd->password());
}
return {std::move(wallet), std::move(*pwd)};
}
std::pair<std::unique_ptr<wallet2>, password_container> wallet2::make_new(const boost::program_options::variables_map& vm, bool unattended, const std::function<boost::optional<password_container>(const char *, bool)> &password_prompter)
{
const options opts{};
auto pwd = get_password(vm, opts, password_prompter, true);
if (!pwd)
{
return {nullptr, password_container{}};
}
return {make_basic(vm, unattended, opts, password_prompter), std::move(*pwd)};
}
std::unique_ptr<wallet2> wallet2::make_dummy(const boost::program_options::variables_map& vm, bool unattended, const std::function<boost::optional<tools::password_container>(const char *, bool)> &password_prompter)
{
const options opts{};
return make_basic(vm, unattended, opts, password_prompter);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::set_daemon(std::string daemon_address, boost::optional<epee::net_utils::http::login> daemon_login, bool trusted_daemon, epee::net_utils::ssl_options_t ssl_options)
{
boost::lock_guard<boost::recursive_mutex> lock(m_daemon_rpc_mutex);
if(m_http_client.is_connected())
m_http_client.disconnect();
m_daemon_address = std::move(daemon_address);
m_daemon_login = std::move(daemon_login);
m_trusted_daemon = trusted_daemon;
MINFO("setting daemon to " << get_daemon_address());
return m_http_client.set_server(get_daemon_address(), get_daemon_login(), std::move(ssl_options));
}
//----------------------------------------------------------------------------------------------------
bool wallet2::init(std::string daemon_address, boost::optional<epee::net_utils::http::login> daemon_login, boost::asio::ip::tcp::endpoint proxy, uint64_t upper_transaction_weight_limit, bool trusted_daemon, epee::net_utils::ssl_options_t ssl_options)
{
m_is_initialized = true;
m_upper_transaction_weight_limit = upper_transaction_weight_limit;
if (proxy != boost::asio::ip::tcp::endpoint{})
m_http_client.set_connector(net::socks::connector{std::move(proxy)});
return set_daemon(daemon_address, daemon_login, trusted_daemon, std::move(ssl_options));
}
//----------------------------------------------------------------------------------------------------
bool wallet2::is_deterministic() const
{
crypto::secret_key second;
keccak((uint8_t *)&get_account().get_keys().m_spend_secret_key, sizeof(crypto::secret_key), (uint8_t *)&second, sizeof(crypto::secret_key));
sc_reduce32((uint8_t *)&second);
return memcmp(second.data,get_account().get_keys().m_view_secret_key.data, sizeof(crypto::secret_key)) == 0;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::get_seed(epee::wipeable_string& electrum_words, const epee::wipeable_string &passphrase) const
{
bool keys_deterministic = is_deterministic();
if (!keys_deterministic)
{
std::cout << "This is not a deterministic wallet" << std::endl;
return false;
}
if (seed_language.empty())
{
std::cout << "seed_language not set" << std::endl;
return false;
}
crypto::secret_key key = get_account().get_keys().m_spend_secret_key;
if (!passphrase.empty())
key = cryptonote::encrypt_key(key, passphrase);
if (!crypto::ElectrumWords::bytes_to_words(key, electrum_words, seed_language))
{
std::cout << "Failed to create seed from key for language: " << seed_language << std::endl;
return false;
}
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::get_multisig_seed(epee::wipeable_string& seed, const epee::wipeable_string &passphrase, bool raw) const
{
bool ready;
uint32_t threshold, total;
if (!multisig(&ready, &threshold, &total))
{
std::cout << "This is not a multisig wallet" << std::endl;
return false;
}
if (!ready)
{
std::cout << "This multisig wallet is not yet finalized" << std::endl;
return false;
}
if (!raw && seed_language.empty())
{
std::cout << "seed_language not set" << std::endl;
return false;
}
crypto::secret_key skey;
crypto::public_key pkey;
const account_keys &keys = get_account().get_keys();
epee::wipeable_string data;
data.append((const char*)&threshold, sizeof(uint32_t));
data.append((const char*)&total, sizeof(uint32_t));
skey = keys.m_spend_secret_key;
data.append((const char*)&skey, sizeof(skey));
pkey = keys.m_account_address.m_spend_public_key;
data.append((const char*)&pkey, sizeof(pkey));
skey = keys.m_view_secret_key;
data.append((const char*)&skey, sizeof(skey));
pkey = keys.m_account_address.m_view_public_key;
data.append((const char*)&pkey, sizeof(pkey));
for (const auto &skey: keys.m_multisig_keys)
data.append((const char*)&skey, sizeof(skey));
for (const auto &signer: m_multisig_signers)
data.append((const char*)&signer, sizeof(signer));
if (!passphrase.empty())
{
crypto::secret_key key;
crypto::cn_slow_hash(passphrase.data(), passphrase.size(), (crypto::hash&)key, crypto::cn_slow_hash_type::heavy_v1);
sc_reduce32((unsigned char*)key.data);
data = encrypt(data, key, true);
}
if (raw)
{
seed = epee::to_hex::wipeable_string({(const unsigned char*)data.data(), data.size()});
}
else
{
if (!crypto::ElectrumWords::bytes_to_words(data.data(), data.size(), seed, seed_language))
{
std::cout << "Failed to encode seed";
return false;
}
}
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::reconnect_device()
{
bool r = true;
hw::device &hwdev = lookup_device(m_device_name);
hwdev.set_name(m_device_name);
hwdev.set_network_type(m_nettype);
hwdev.set_derivation_path(m_device_derivation_path);
hwdev.set_callback(get_device_callback());
r = hwdev.init();
if (!r){
MERROR("Could not init device");
return false;
}
r = hwdev.connect();
if (!r){
MERROR("Could not connect to the device");
return false;
}
m_account.set_device(hwdev);
return true;
}
//----------------------------------------------------------------------------------------------------
/*!
* \brief Gets the seed language
*/
const std::string &wallet2::get_seed_language() const
{
return seed_language;
}
/*!
* \brief Sets the seed language
* \param language Seed language to set to
*/
void wallet2::set_seed_language(const std::string &language)
{
seed_language = language;
}
//----------------------------------------------------------------------------------------------------
cryptonote::account_public_address wallet2::get_subaddress(const cryptonote::subaddress_index& index) const
{
hw::device &hwdev = m_account.get_device();
return hwdev.get_subaddress(m_account.get_keys(), index);
}
//----------------------------------------------------------------------------------------------------
boost::optional<cryptonote::subaddress_index> wallet2::get_subaddress_index(const cryptonote::account_public_address& address) const
{
auto index = m_subaddresses.find(address.m_spend_public_key);
if (index == m_subaddresses.end())
return boost::none;
return index->second;
}
//----------------------------------------------------------------------------------------------------
crypto::public_key wallet2::get_subaddress_spend_public_key(const cryptonote::subaddress_index& index) const
{
hw::device &hwdev = m_account.get_device();
return hwdev.get_subaddress_spend_public_key(m_account.get_keys(), index);
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::get_subaddress_as_str(const cryptonote::subaddress_index& index) const
{
cryptonote::account_public_address address = get_subaddress(index);
return cryptonote::get_account_address_as_str(m_nettype, !index.is_zero(), address);
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::get_integrated_address_as_str(const crypto::hash8& payment_id) const
{
return cryptonote::get_account_integrated_address_as_str(m_nettype, get_address(), payment_id);
}
//----------------------------------------------------------------------------------------------------
void wallet2::add_subaddress_account(const std::string& label)
{
uint32_t index_major = (uint32_t)get_num_subaddress_accounts();
expand_subaddresses({index_major, 0});
m_subaddress_labels[index_major][0] = label;
}
//----------------------------------------------------------------------------------------------------
void wallet2::add_subaddress(uint32_t index_major, const std::string& label)
{
THROW_WALLET_EXCEPTION_IF(index_major >= m_subaddress_labels.size(), error::account_index_outofbound);
uint32_t index_minor = (uint32_t)get_num_subaddresses(index_major);
expand_subaddresses({index_major, index_minor});
m_subaddress_labels[index_major][index_minor] = label;
}
//----------------------------------------------------------------------------------------------------
void wallet2::expand_subaddresses(const cryptonote::subaddress_index& index)
{
hw::device &hwdev = m_account.get_device();
if (m_subaddress_labels.size() <= index.major)
{
// add new accounts
cryptonote::subaddress_index index2;
const uint32_t major_end = get_subaddress_clamped_sum(index.major, m_subaddress_lookahead_major);
for (index2.major = m_subaddress_labels.size(); index2.major < major_end; ++index2.major)
{
const uint32_t end = get_subaddress_clamped_sum((index2.major == index.major ? index.minor : 0), m_subaddress_lookahead_minor);
const std::vector<crypto::public_key> pkeys = hwdev.get_subaddress_spend_public_keys(m_account.get_keys(), index2.major, 0, end);
for (index2.minor = 0; index2.minor < end; ++index2.minor)
{
const crypto::public_key &D = pkeys[index2.minor];
m_subaddresses[D] = index2;
}
}
m_subaddress_labels.resize(index.major + 1, {"Untitled account"});
m_subaddress_labels[index.major].resize(index.minor + 1);
get_account_tags();
}
else if (m_subaddress_labels[index.major].size() <= index.minor)
{
// add new subaddresses
const uint32_t end = get_subaddress_clamped_sum(index.minor, m_subaddress_lookahead_minor);
const uint32_t begin = m_subaddress_labels[index.major].size();
cryptonote::subaddress_index index2 = {index.major, begin};
const std::vector<crypto::public_key> pkeys = hwdev.get_subaddress_spend_public_keys(m_account.get_keys(), index2.major, index2.minor, end);
for (; index2.minor < end; ++index2.minor)
{
const crypto::public_key &D = pkeys[index2.minor - begin];
m_subaddresses[D] = index2;
}
m_subaddress_labels[index.major].resize(index.minor + 1);
}
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::get_subaddress_label(const cryptonote::subaddress_index& index) const
{
if (index.major >= m_subaddress_labels.size() || index.minor >= m_subaddress_labels[index.major].size())
{
MERROR("Subaddress label doesn't exist");
return "";
}
return m_subaddress_labels[index.major][index.minor];
}
//----------------------------------------------------------------------------------------------------
void wallet2::set_subaddress_label(const cryptonote::subaddress_index& index, const std::string &label)
{
THROW_WALLET_EXCEPTION_IF(index.major >= m_subaddress_labels.size(), error::account_index_outofbound);
THROW_WALLET_EXCEPTION_IF(index.minor >= m_subaddress_labels[index.major].size(), error::address_index_outofbound);
m_subaddress_labels[index.major][index.minor] = label;
}
//----------------------------------------------------------------------------------------------------
void wallet2::set_subaddress_lookahead(size_t major, size_t minor)
{
THROW_WALLET_EXCEPTION_IF(major > 0xffffffff, error::wallet_internal_error, "Subaddress major lookahead is too large");
THROW_WALLET_EXCEPTION_IF(minor > 0xffffffff, error::wallet_internal_error, "Subaddress minor lookahead is too large");
m_subaddress_lookahead_major = major;
m_subaddress_lookahead_minor = minor;
}
//----------------------------------------------------------------------------------------------------
/*!
* \brief Tells if the wallet file is deprecated.
*/
bool wallet2::is_deprecated() const
{
return is_old_file_format;
}
//----------------------------------------------------------------------------------------------------
void wallet2::set_spent(size_t idx, uint64_t height)
{
transfer_details &td = m_transfers[idx];
LOG_PRINT_L2("Setting SPENT at " << height << ": ki " << td.m_key_image << ", amount " << print_money(td.m_amount));
td.m_spent = true;
td.m_spent_height = height;
}
//----------------------------------------------------------------------------------------------------
void wallet2::set_unspent(size_t idx)
{
transfer_details &td = m_transfers[idx];
LOG_PRINT_L2("Setting UNSPENT: ki " << td.m_key_image << ", amount " << print_money(td.m_amount));
td.m_spent = false;
td.m_spent_height = 0;
}
//----------------------------------------------------------------------------------------------------
void wallet2::freeze(size_t idx)
{
CHECK_AND_ASSERT_THROW_MES(idx < m_transfers.size(), "Invalid transfer_details index");
transfer_details &td = m_transfers[idx];
td.m_frozen = true;
}
//----------------------------------------------------------------------------------------------------
void wallet2::thaw(size_t idx)
{
CHECK_AND_ASSERT_THROW_MES(idx < m_transfers.size(), "Invalid transfer_details index");
transfer_details &td = m_transfers[idx];
td.m_frozen = false;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::frozen(size_t idx) const
{
CHECK_AND_ASSERT_THROW_MES(idx < m_transfers.size(), "Invalid transfer_details index");
const transfer_details &td = m_transfers[idx];
return td.m_frozen;
}
//----------------------------------------------------------------------------------------------------
void wallet2::freeze(const crypto::key_image &ki)
{
freeze(get_transfer_details(ki));
}
//----------------------------------------------------------------------------------------------------
void wallet2::thaw(const crypto::key_image &ki)
{
thaw(get_transfer_details(ki));
}
//----------------------------------------------------------------------------------------------------
bool wallet2::frozen(const crypto::key_image &ki) const
{
return frozen(get_transfer_details(ki));
}
//----------------------------------------------------------------------------------------------------
size_t wallet2::get_transfer_details(const crypto::key_image &ki) const
{
for (size_t idx = 0; idx < m_transfers.size(); ++idx)
{
const transfer_details &td = m_transfers[idx];
if (td.m_key_image_known && td.m_key_image == ki)
return idx;
}
CHECK_AND_ASSERT_THROW_MES(false, "Key image not found");
}
//----------------------------------------------------------------------------------------------------
bool wallet2::frozen(const transfer_details &td) const
{
return td.m_frozen;
}
//----------------------------------------------------------------------------------------------------
void wallet2::check_acc_out_precomp(const tx_out &o, const crypto::key_derivation &derivation, const std::vector<crypto::key_derivation> &additional_derivations, size_t i, tx_scan_info_t &tx_scan_info) const
{
hw::device &hwdev = m_account.get_device();
boost::unique_lock<hw::device> hwdev_lock (hwdev);
hwdev.set_mode(hw::device::TRANSACTION_PARSE);
if (o.target.type() != typeid(txout_to_key))
{
tx_scan_info.error = true;
LOG_ERROR("wrong type id in transaction out");
return;
}
tx_scan_info.received = is_out_to_acc_precomp(m_subaddresses, boost::get<txout_to_key>(o.target).key, derivation, additional_derivations, i, hwdev);
if(tx_scan_info.received)
{
tx_scan_info.money_transfered = o.amount; // may be 0 for ringct outputs
}
else
{
tx_scan_info.money_transfered = 0;
}
tx_scan_info.error = false;
}
//----------------------------------------------------------------------------------------------------
void wallet2::check_acc_out_precomp(const tx_out &o, const crypto::key_derivation &derivation, const std::vector<crypto::key_derivation> &additional_derivations, size_t i, const is_out_data *is_out_data, tx_scan_info_t &tx_scan_info) const
{
if (!is_out_data || i >= is_out_data->received.size())
return check_acc_out_precomp(o, derivation, additional_derivations, i, tx_scan_info);
tx_scan_info.received = is_out_data->received[i];
if(tx_scan_info.received)
{
tx_scan_info.money_transfered = o.amount; // may be 0 for ringct outputs
}
else
{
tx_scan_info.money_transfered = 0;
}
tx_scan_info.error = false;
}
//----------------------------------------------------------------------------------------------------
void wallet2::check_acc_out_precomp_once(const tx_out &o, const crypto::key_derivation &derivation, const std::vector<crypto::key_derivation> &additional_derivations, size_t i, const is_out_data *is_out_data, tx_scan_info_t &tx_scan_info, bool &already_seen) const
{
tx_scan_info.received = boost::none;
if (already_seen)
return;
check_acc_out_precomp(o, derivation, additional_derivations, i, is_out_data, tx_scan_info);
if (tx_scan_info.received)
already_seen = true;
}
//----------------------------------------------------------------------------------------------------
static uint64_t decodeRct(const rct::rctSig & rv, const crypto::key_derivation &derivation, unsigned int i, rct::key & mask, hw::device &hwdev)
{
crypto::secret_key scalar1;
hwdev.derivation_to_scalar(derivation, i, scalar1);
try
{
switch (rv.type)
{
case rct::RCTTypeSimple:
case rct::RCTTypeBulletproof:
case rct::RCTTypeBulletproof2:
return rct::decodeRctSimple(rv, rct::sk2rct(scalar1), i, mask, hwdev);
case rct::RCTTypeFull:
return rct::decodeRct(rv, rct::sk2rct(scalar1), i, mask, hwdev);
default:
LOG_ERROR(__func__ << ": Unsupported rct type: " << rv.type);
return 0;
}
}
catch (const std::exception &e)
{
LOG_ERROR("Failed to decode input " << i);
return 0;
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::scan_output(const cryptonote::transaction &tx, bool miner_tx, const crypto::public_key &tx_pub_key, size_t vout_index, tx_scan_info_t &tx_scan_info, std::vector<tx_money_got_in_out> &tx_money_got_in_outs, std::vector<size_t> &outs, bool pool, bool blink)
{
THROW_WALLET_EXCEPTION_IF(vout_index >= tx.vout.size(), error::wallet_internal_error, "Invalid vout index");
// if keys are encrypted, ask for password
if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only && !m_multisig_rescan_k)
{
static critical_section password_lock;
CRITICAL_REGION_LOCAL(password_lock);
if (!m_encrypt_keys_after_refresh)
{
boost::optional<epee::wipeable_string> pwd = m_callback->on_get_password(pool ? blink ? "blink output receive in pool" : "output found in pool" : "output received");
THROW_WALLET_EXCEPTION_IF(!pwd, error::password_needed, tr("Password is needed to compute key image for incoming WORKTIPS"));
THROW_WALLET_EXCEPTION_IF(!verify_password(*pwd), error::password_needed, tr("Invalid password: password is needed to compute key image for incoming WORKTIPS"));
decrypt_keys(*pwd);
m_encrypt_keys_after_refresh = *pwd;
}
}
if (m_multisig)
{
tx_scan_info.in_ephemeral.pub = boost::get<cryptonote::txout_to_key>(tx.vout[vout_index].target).key;
tx_scan_info.in_ephemeral.sec = crypto::null_skey;
tx_scan_info.ki = rct::rct2ki(rct::zero());
}
else
{
bool r = cryptonote::generate_key_image_helper_precomp(m_account.get_keys(), boost::get<cryptonote::txout_to_key>(tx.vout[vout_index].target).key, tx_scan_info.received->derivation, vout_index, tx_scan_info.received->index, tx_scan_info.in_ephemeral, tx_scan_info.ki, m_account.get_device());
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
THROW_WALLET_EXCEPTION_IF(tx_scan_info.in_ephemeral.pub != boost::get<cryptonote::txout_to_key>(tx.vout[vout_index].target).key,
error::wallet_internal_error, "key_image generated ephemeral public key not matched with output_key");
}
THROW_WALLET_EXCEPTION_IF(std::find(outs.begin(), outs.end(), vout_index) != outs.end(), error::wallet_internal_error, "Same output cannot be added twice");
if (tx_scan_info.money_transfered == 0 && !miner_tx)
{
tx_scan_info.money_transfered = tools::decodeRct(tx.rct_signatures, tx_scan_info.received->derivation, vout_index, tx_scan_info.mask, m_account.get_device());
}
if (tx_scan_info.money_transfered == 0)
{
MERROR("Invalid output amount, skipping");
tx_scan_info.error = true;
return;
}
outs.push_back(vout_index);
uint64_t unlock_time = tx.get_unlock_time(vout_index);
tx_money_got_in_out entry = {};
entry.type = pay_type::in;
entry.index = tx_scan_info.received->index;
entry.amount = tx_scan_info.money_transfered;
entry.unlock_time = unlock_time;
if (cryptonote::is_coinbase(tx))
{
// TODO(doyle): When batched governance comes in, this needs to check that the TX has a governance output, can't assume last one is governance
if (vout_index == 0) entry.type = pay_type::miner;
// else if (vout_index == tx.vout.size() - 1) entry.type = pay_type::governance;
else entry.type = pay_type::service_node;
}
tx_money_got_in_outs.push_back(entry);
tx_scan_info.amount = tx_scan_info.money_transfered;
tx_scan_info.unlock_time = unlock_time;
}
//----------------------------------------------------------------------------------------------------
void wallet2::cache_tx_data(const cryptonote::transaction& tx, const crypto::hash &txid, tx_cache_data &tx_cache_data) const
{
if(!parse_tx_extra(tx.extra, tx_cache_data.tx_extra_fields))
{
// Extra may only be partially parsed, it's OK if tx_extra_fields contains public key
LOG_PRINT_L0("Transaction extra has unsupported format: " << txid);
if (tx_cache_data.tx_extra_fields.empty())
return;
}
// Don't try to extract tx public key if tx has no ouputs
const bool is_miner = tx.vin.size() == 1 && tx.vin[0].type() == typeid(cryptonote::txin_gen);
if (!is_miner || m_refresh_type != RefreshType::RefreshNoCoinbase)
{
const size_t rec_size = is_miner && m_refresh_type == RefreshType::RefreshOptimizeCoinbase ? 1 : tx.vout.size();
if (!tx.vout.empty())
{
// if tx.vout is not empty, we loop through all tx pubkeys
const std::vector<boost::optional<cryptonote::subaddress_receive_info>> rec(rec_size, boost::none);
tx_extra_pub_key pub_key_field;
size_t pk_index = 0;
while (find_tx_extra_field_by_type(tx_cache_data.tx_extra_fields, pub_key_field, pk_index++))
tx_cache_data.primary.push_back({pub_key_field.pub_key, {}, rec});
// additional tx pubkeys and derivations for multi-destination transfers involving one or more subaddresses
tx_extra_additional_pub_keys additional_tx_pub_keys;
if (find_tx_extra_field_by_type(tx_cache_data.tx_extra_fields, additional_tx_pub_keys))
{
for (size_t i = 0; i < additional_tx_pub_keys.data.size(); ++i)
tx_cache_data.additional.push_back({additional_tx_pub_keys.data[i], {}, {}});
}
}
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::process_new_transaction(const crypto::hash &txid, const cryptonote::transaction& tx, const std::vector<uint64_t> &o_indices,
uint64_t height, uint64_t ts, bool miner_tx, bool pool, bool blink, bool double_spend_seen,
const tx_cache_data &tx_cache_data, std::map<std::pair<uint64_t, uint64_t>, size_t> *output_tracker_cache)
{
if (!tx.is_transfer() || tx.version <= txversion::v1)
return;
PERF_TIMER(process_new_transaction);
// In this function, tx (probably) only contains the base information
// (that is, the prunable stuff may or may not be included)
if (!miner_tx && !pool)
process_unconfirmed(txid, tx, height);
// NOTE: tx_scan_info contains the decoded amounts from the transaction destined for us
// tx_money_got_in_outs contains decoded amounts from the transaction,
// that removes amounts from our scanned outputs that got invalidated
// i.e. duplicated key images
std::vector<tx_money_got_in_out> tx_money_got_in_outs;
tx_money_got_in_outs.reserve(tx.vout.size());
crypto::public_key tx_pub_key = null_pkey;
bool notify = false;
std::vector<tx_extra_field> local_tx_extra_fields;
if (tx_cache_data.tx_extra_fields.empty())
{
if(!parse_tx_extra(tx.extra, local_tx_extra_fields))
{
// Extra may only be partially parsed, it's OK if tx_extra_fields contains public key
LOG_PRINT_L0("Transaction extra has unsupported format: " << txid);
}
}
const std::vector<tx_extra_field> &tx_extra_fields = tx_cache_data.tx_extra_fields.empty() ? local_tx_extra_fields : tx_cache_data.tx_extra_fields;
// Don't try to extract tx public key if tx has no ouputs
size_t pk_index = 0;
std::vector<tx_scan_info_t> tx_scan_info(tx.vout.size());
std::deque<bool> output_found(tx.vout.size(), false);
uint64_t total_received_1 = 0;
// NOTE: This handles the case where you have multiple outputs in the same
// transaction with duplicated output keys. Unlock times is lost when it's
// stored into m_transfers so we cannot determine if the entry in m_transfers
// came from this transaction or a previous transaction.
// TODO(worktips): This case might be feasible at all where a key image is
// duplicated in the _same_ tx in different output indexes, because the
// algorithm for making a key image uses the output index. Investigate, and if
// it's not feasible to construct a malicious one without absolutely breaking
// everything in the system then we can delete the code for it.
using unlock_time_t = uint64_t;
std::unordered_map<crypto::public_key, unlock_time_t> pk_to_unlock_times;
std::vector<size_t> outs;
bool blink_got_mined = false;
while (!tx.vout.empty())
{
// if tx.vout is not empty, we loop through all tx pubkeys
outs.clear();
tx_extra_pub_key pub_key_field;
if(!find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, pk_index++))
{
if (pk_index > 1)
break;
LOG_PRINT_L0("Public key wasn't found in the transaction extra. Skipping transaction " << txid);
if(0 != m_callback)
m_callback->on_skip_transaction(height, txid, tx);
break;
}
if (!tx_cache_data.primary.empty())
{
THROW_WALLET_EXCEPTION_IF(tx_cache_data.primary.size() < pk_index || pub_key_field.pub_key != tx_cache_data.primary[pk_index - 1].pkey,
error::wallet_internal_error, "tx_cache_data is out of sync");
}
tx_pub_key = pub_key_field.pub_key;
tools::threadpool& tpool = tools::threadpool::getInstance();
tools::threadpool::waiter waiter;
const cryptonote::account_keys& keys = m_account.get_keys();
crypto::key_derivation derivation;
std::vector<crypto::key_derivation> additional_derivations;
tx_extra_additional_pub_keys additional_tx_pub_keys;
const wallet2::is_out_data *is_out_data_ptr = NULL;
if (tx_cache_data.primary.empty())
{
hw::device &hwdev = m_account.get_device();
boost::unique_lock<hw::device> hwdev_lock (hwdev);
hw::reset_mode rst(hwdev);
hwdev.set_mode(hw::device::TRANSACTION_PARSE);
if (!hwdev.generate_key_derivation(tx_pub_key, keys.m_view_secret_key, derivation))
{
MWARNING("Failed to generate key derivation from tx pubkey in " << txid << ", skipping");
static_assert(sizeof(derivation) == sizeof(rct::key), "Mismatched sizes of key_derivation and rct::key");
memcpy(&derivation, rct::identity().bytes, sizeof(derivation));
}
if (pk_index == 1)
{
// additional tx pubkeys and derivations for multi-destination transfers involving one or more subaddresses
if (find_tx_extra_field_by_type(tx_extra_fields, additional_tx_pub_keys))
{
for (size_t i = 0; i < additional_tx_pub_keys.data.size(); ++i)
{
additional_derivations.push_back({});
if (!hwdev.generate_key_derivation(additional_tx_pub_keys.data[i], keys.m_view_secret_key, additional_derivations.back()))
{
MWARNING("Failed to generate key derivation from additional tx pubkey in " << txid << ", skipping");
memcpy(&additional_derivations.back(), rct::identity().bytes, sizeof(crypto::key_derivation));
}
}
}
}
}
else
{
THROW_WALLET_EXCEPTION_IF(pk_index - 1 >= tx_cache_data.primary.size(),
error::wallet_internal_error, "pk_index out of range of tx_cache_data");
is_out_data_ptr = &tx_cache_data.primary[pk_index - 1];
derivation = tx_cache_data.primary[pk_index - 1].derivation;
if (pk_index == 1)
{
for (size_t n = 0; n < tx_cache_data.additional.size(); ++n)
{
additional_tx_pub_keys.data.push_back(tx_cache_data.additional[n].pkey);
additional_derivations.push_back(tx_cache_data.additional[n].derivation);
}
}
}
if (miner_tx && m_refresh_type == RefreshNoCoinbase)
{
// assume coinbase isn't for us
continue;
}
// NOTE(worktips): (miner_tx && m_refresh_type == RefreshOptimiseCoinbase) used
// to be an optimisation step that checks if the first output was destined
// for us otherwise skip. This is not possible for us because our
// block-reward now always has more than 1 output, mining, service node
// and governance rewards which can all have different dest addresses, so we
// always need to check all outputs.
if ((tx.vout.size() > 1 && tools::threadpool::getInstance().get_max_concurrency() > 1 && !is_out_data_ptr) ||
(miner_tx && m_refresh_type == RefreshOptimizeCoinbase))
{
for (size_t i = 0; i < tx.vout.size(); ++i)
{
tpool.submit(&waiter, boost::bind(&wallet2::check_acc_out_precomp_once, this, std::cref(tx.vout[i]), std::cref(derivation), std::cref(additional_derivations), i,
std::cref(is_out_data_ptr), std::ref(tx_scan_info[i]), std::ref(output_found[i])), true);
}
waiter.wait(&tpool);
hw::device &hwdev = m_account.get_device();
boost::unique_lock<hw::device> hwdev_lock (hwdev);
hwdev.set_mode(hw::device::NONE);
for (size_t i = 0; i < tx.vout.size(); ++i)
{
THROW_WALLET_EXCEPTION_IF(tx_scan_info[i].error, error::acc_outs_lookup_error, tx, tx_pub_key, m_account.get_keys());
if (tx_scan_info[i].received)
{
hwdev.conceal_derivation(tx_scan_info[i].received->derivation, tx_pub_key, additional_tx_pub_keys.data, derivation, additional_derivations);
scan_output(tx, miner_tx, tx_pub_key, i, tx_scan_info[i], tx_money_got_in_outs, outs, pool, blink);
}
}
}
else
{
for (size_t i = 0; i < tx.vout.size(); ++i)
{
check_acc_out_precomp_once(tx.vout[i], derivation, additional_derivations, i, is_out_data_ptr, tx_scan_info[i], output_found[i]);
THROW_WALLET_EXCEPTION_IF(tx_scan_info[i].error, error::acc_outs_lookup_error, tx, tx_pub_key, m_account.get_keys());
if (tx_scan_info[i].received)
{
hw::device &hwdev = m_account.get_device();
boost::unique_lock<hw::device> hwdev_lock (hwdev);
hwdev.set_mode(hw::device::NONE);
hwdev.conceal_derivation(tx_scan_info[i].received->derivation, tx_pub_key, additional_tx_pub_keys.data, derivation, additional_derivations);
scan_output(tx, miner_tx, tx_pub_key, i, tx_scan_info[i], tx_money_got_in_outs, outs, pool, blink);
}
}
}
if(!outs.empty())
{
//good news - got money! take care about it
//usually we have only one transfer for user in transaction
if (!pool)
{
THROW_WALLET_EXCEPTION_IF(tx.vout.size() != o_indices.size(), error::wallet_internal_error,
"transactions outputs size=" + std::to_string(tx.vout.size()) +
" not match with daemon response size=" + std::to_string(o_indices.size()));
}
for(size_t o: outs)
{
THROW_WALLET_EXCEPTION_IF(tx.vout.size() <= o, error::wallet_internal_error, "wrong out in transaction: internal index=" +
std::to_string(o) + ", total_outs=" + std::to_string(tx.vout.size()));
auto kit = m_pub_keys.find(tx_scan_info[o].in_ephemeral.pub);
THROW_WALLET_EXCEPTION_IF(kit != m_pub_keys.end() && kit->second >= m_transfers.size(),
error::wallet_internal_error, std::string("Unexpected transfer index from public key: ")
+ "got " + (kit == m_pub_keys.end() ? "<none>" : boost::lexical_cast<std::string>(kit->second))
+ ", m_transfers.size() is " + boost::lexical_cast<std::string>(m_transfers.size()));
bool process_transaction = !pool || blink;
bool unmined_blink = pool && blink;
if (kit == m_pub_keys.end())
{
uint64_t amount = tx.vout[o].amount ? tx.vout[o].amount : tx_scan_info[o].amount;
if (process_transaction)
{
pk_to_unlock_times[tx_scan_info[o].in_ephemeral.pub] = tx_scan_info[o].unlock_time;
m_transfers.emplace_back();
transfer_details& td = m_transfers.back();
td.m_block_height = height; // NB: will be zero for a blink; we update when the blink tx gets mined
td.m_internal_output_index = o;
td.m_global_output_index = unmined_blink ? 0 : o_indices[o]; // blink tx doesn't have this; will get updated when it gets into a block
td.m_unmined_blink = unmined_blink;
td.m_was_blink = blink;
td.m_tx = (const cryptonote::transaction_prefix&)tx;
td.m_txid = txid;
td.m_key_image = tx_scan_info[o].ki;
td.m_key_image_known = !m_watch_only && !m_multisig;
if (!td.m_key_image_known)
{
// we might have cold signed, and have a mapping to key images
std::unordered_map<crypto::public_key, crypto::key_image>::const_iterator i = m_cold_key_images.find(tx_scan_info[o].in_ephemeral.pub);
if (i != m_cold_key_images.end())
{
td.m_key_image = i->second;
td.m_key_image_known = true;
}
}
if (m_watch_only)
{
// for view wallets, that flag means "we want to request it"
td.m_key_image_request = true;
}
else
{
td.m_key_image_request = false;
}
td.m_key_image_partial = m_multisig;
td.m_amount = amount;
td.m_pk_index = pk_index - 1;
td.m_subaddr_index = tx_scan_info[o].received->index;
expand_subaddresses(tx_scan_info[o].received->index);
if (tx.vout[o].amount == 0)
{
td.m_mask = tx_scan_info[o].mask;
td.m_rct = true;
}
else if (miner_tx && tx.version >= txversion::v2_ringct)
{
td.m_mask = rct::identity();
td.m_rct = true;
}
else
{
td.m_mask = rct::identity();
td.m_rct = false;
}
td.m_frozen = false;
set_unspent(m_transfers.size()-1);
if (td.m_key_image_known)
m_key_images[td.m_key_image] = m_transfers.size()-1;
m_pub_keys[tx_scan_info[o].in_ephemeral.pub] = m_transfers.size()-1;
if (output_tracker_cache)
(*output_tracker_cache)[std::make_pair(tx.vout[o].amount, td.m_global_output_index)] = m_transfers.size() - 1;
if (m_multisig)
{
THROW_WALLET_EXCEPTION_IF(!m_multisig_rescan_k && m_multisig_rescan_info,
error::wallet_internal_error, "NULL m_multisig_rescan_k");
if (m_multisig_rescan_info && m_multisig_rescan_info->front().size() >= m_transfers.size())
update_multisig_rescan_info(*m_multisig_rescan_k, *m_multisig_rescan_info, m_transfers.size() - 1);
}
LOG_PRINT_L0("Received money: " << print_money(td.amount()) << ", with tx: " << txid);
if (0 != m_callback)
m_callback->on_money_received(height, txid, tx, td.m_amount, td.m_subaddr_index, td.m_tx.unlock_time, blink);
}
total_received_1 += amount;
notify = true;
continue;
}
// NOTE: Pre-existing transfer already exists for the output
auto &transfer = m_transfers[kit->second];
THROW_WALLET_EXCEPTION_IF(blink && transfer.m_unmined_blink,
error::wallet_internal_error,
"Sanity check failed: A blink tx replacing an pre-existing wallet tx should not be possible; when a "
"transaction is mined blink metadata is dropped and the TX should just be a normal TX");
THROW_WALLET_EXCEPTION_IF(pool && transfer.m_unmined_blink,
error::wallet_internal_error,
"Sanity check failed: An output replacing a unmined blink output must not be from the pool.");
if (transfer.m_spent || transfer.amount() >= tx_scan_info[o].amount)
{
if (transfer.amount() > tx_scan_info[o].amount)
{
LOG_ERROR("Public key " << epee::string_tools::pod_to_hex(kit->first)
<< " from received " << print_money(tx_scan_info[o].amount) << " output already exists with "
<< (transfer.m_spent ? "spent" : "unspent") << " "
<< print_money(transfer.amount()) << " in tx " << transfer.m_txid << ", received output ignored");
}
if (transfer.m_unmined_blink)
{
blink_got_mined = true;
THROW_WALLET_EXCEPTION_IF(transfer.amount() != tx_scan_info[o].amount, error::wallet_internal_error, "A blink should credit the amount exactly as we recorded it when it arrived in the mempool");
THROW_WALLET_EXCEPTION_IF(transfer.m_spent, error::wallet_internal_error, "Blink can not be spent before it is mined, this should never happen");
MINFO("Public key " << epee::string_tools::pod_to_hex(kit->first)
<< " of blink tx " << transfer.m_txid << " (for " << print_money(tx_scan_info[o].amount) << ")"
<< " status updated: now mined in block " << height);
// We previous had this as a blink, but now it's been mined so update the tx status with the height and output index
transfer.m_block_height = height;
transfer.m_global_output_index = o_indices[o];
transfer.m_unmined_blink = false;
}
auto iter = std::find_if(
tx_money_got_in_outs.begin(),
tx_money_got_in_outs.end(),
[&tx_scan_info,&o](const tx_money_got_in_out& value)
{
return value.index == tx_scan_info[o].received->index &&
value.amount == tx_scan_info[o].amount &&
value.unlock_time == tx_scan_info[o].unlock_time;
}
);
THROW_WALLET_EXCEPTION_IF(iter == tx_money_got_in_outs.end(), error::wallet_internal_error, "Could not find the output we just added, this should never happen");
tx_money_got_in_outs.erase(iter);
}
else if (transfer.m_spent || transfer.amount() >= tx_scan_info[o].amount)
{
LOG_ERROR("Public key " << epee::string_tools::pod_to_hex(kit->first)
<< " from received " << print_money(tx_scan_info[o].amount) << " output already exists with "
<< (transfer.m_spent ? "spent" : "unspent") << " "
<< print_money(transfer.amount()) << " in tx " << transfer.m_txid << ", received output ignored");
auto iter = std::find_if(
tx_money_got_in_outs.begin(),
tx_money_got_in_outs.end(),
[&tx_scan_info,&o](const tx_money_got_in_out& value)
{
return value.index == tx_scan_info[o].received->index &&
value.amount == tx_scan_info[o].amount &&
value.unlock_time == tx_scan_info[o].unlock_time;
}
);
THROW_WALLET_EXCEPTION_IF(iter == tx_money_got_in_outs.end(), error::wallet_internal_error, "Could not find the output we just added, this should never happen");
tx_money_got_in_outs.erase(iter);
}
else
{
LOG_ERROR("Public key " << epee::string_tools::pod_to_hex(kit->first)
<< " from received " << print_money(tx_scan_info[o].amount) << " output already exists with "
<< print_money(transfer.amount()) << ", replacing with new output");
// The new larger output replaced a previous smaller one
auto unlock_time_it = pk_to_unlock_times.find(kit->first);
if (unlock_time_it == pk_to_unlock_times.end())
{
// NOTE: This output previously existed in m_transfers before any
// outputs in this transaction was processed, so we couldn't find.
// That's fine, we don't need to modify tx_money_got_in_outs.
// - 27/09/2018 Doyle
}
else
{
tx_money_got_in_out smaller_output = {};
smaller_output.unlock_time = unlock_time_it->second;
smaller_output.amount = transfer.amount();
smaller_output.index = transfer.m_subaddr_index;
auto iter = std::find_if(
tx_money_got_in_outs.begin(),
tx_money_got_in_outs.end(),
[&smaller_output](const tx_money_got_in_out& value)
{
return value.index == smaller_output.index &&
value.amount == smaller_output.amount &&
value.unlock_time == smaller_output.unlock_time;
}
);
// Monero fix - 25/9/2018 rtharp, doyle, maxim
THROW_WALLET_EXCEPTION_IF(transfer.amount() > iter->amount, error::wallet_internal_error, "Unexpected values of new and old outputs, new output is meant to be larger");
THROW_WALLET_EXCEPTION_IF(iter == tx_money_got_in_outs.end(), error::wallet_internal_error, "Could not find the output we just added, this should never happen");
tx_money_got_in_outs.erase(iter);
}
auto iter = std::find_if(
tx_money_got_in_outs.begin(),
tx_money_got_in_outs.end(),
[&tx_scan_info, &o](const tx_money_got_in_out& value)
{
return value.index == tx_scan_info[o].received->index &&
value.amount == tx_scan_info[o].amount &&
value.unlock_time == tx_scan_info[o].unlock_time;
}
);
THROW_WALLET_EXCEPTION_IF(transfer.amount() > iter->amount, error::wallet_internal_error, "Unexpected values of new and old outputs, new output is meant to be larger");
THROW_WALLET_EXCEPTION_IF(iter == tx_money_got_in_outs.end(), error::wallet_internal_error, "Could not find the output we just added, this should never happen");
iter->amount -= transfer.amount();
if (iter->amount == 0)
tx_money_got_in_outs.erase(iter);
uint64_t amount = tx.vout[o].amount ? tx.vout[o].amount : tx_scan_info[o].amount;
uint64_t extra_amount = amount - transfer.amount();
if (process_transaction)
{
transfer.m_block_height = height;
transfer.m_internal_output_index = o;
transfer.m_global_output_index = unmined_blink ? 0 : o_indices[o]; // blink tx doesn't have this; will get updated when it gets into a block
transfer.m_unmined_blink = unmined_blink;
transfer.m_tx = (const cryptonote::transaction_prefix&)tx;
transfer.m_txid = txid;
transfer.m_amount = amount;
transfer.m_pk_index = pk_index - 1;
transfer.m_subaddr_index = tx_scan_info[o].received->index;
expand_subaddresses(tx_scan_info[o].received->index);
if (tx.vout[o].amount == 0)
{
transfer.m_mask = tx_scan_info[o].mask;
transfer.m_rct = true;
}
else if (miner_tx && tx.version >= txversion::v2_ringct)
{
transfer.m_mask = rct::identity();
transfer.m_rct = true;
}
else
{
transfer.m_mask = rct::identity();
transfer.m_rct = false;
}
if (output_tracker_cache)
(*output_tracker_cache)[std::make_pair(tx.vout[o].amount, transfer.m_global_output_index)] = kit->second;
if (m_multisig)
{
THROW_WALLET_EXCEPTION_IF(!m_multisig_rescan_k && m_multisig_rescan_info,
error::wallet_internal_error, "NULL m_multisig_rescan_k");
if (m_multisig_rescan_info && m_multisig_rescan_info->front().size() >= m_transfers.size())
update_multisig_rescan_info(*m_multisig_rescan_k, *m_multisig_rescan_info, m_transfers.size() - 1);
}
THROW_WALLET_EXCEPTION_IF(transfer.get_public_key() != tx_scan_info[o].in_ephemeral.pub, error::wallet_internal_error, "Inconsistent public keys");
THROW_WALLET_EXCEPTION_IF(transfer.m_spent, error::wallet_internal_error, "Inconsistent spent status");
LOG_PRINT_L0("Received money: " << print_money(transfer.amount()) << ", with tx: " << txid);
if (0 != m_callback)
m_callback->on_money_received(height, txid, tx, transfer.m_amount, transfer.m_subaddr_index, transfer.m_tx.unlock_time, blink);
}
total_received_1 += extra_amount;
notify = true;
}
}
}
}
uint64_t tx_money_spent_in_ins = 0;
// The line below is equivalent to "boost::optional<uint32_t> subaddr_account;", but avoids the GCC warning: '*((void*)& subaddr_account +4)' may be used uninitialized in this function
// It's a GCC bug with boost::optional, see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47679
auto subaddr_account ([]()->boost::optional<uint32_t> {return boost::none;}());
std::set<uint32_t> subaddr_indices;
// check all outputs for spending (compare key images)
for(auto& in: tx.vin)
{
if(in.type() != typeid(cryptonote::txin_to_key))
continue;
const cryptonote::txin_to_key &in_to_key = boost::get<cryptonote::txin_to_key>(in);
auto it = m_key_images.find(in_to_key.k_image);
if(it != m_key_images.end())
{
transfer_details& td = m_transfers[it->second];
uint64_t amount = in_to_key.amount;
if (amount > 0)
{
if(amount != td.amount())
{
MERROR("Inconsistent amount in tx input: got " << print_money(amount) <<
", expected " << print_money(td.amount()));
// this means:
// 1) the same output pub key was used as destination multiple times,
// 2) the wallet set the highest amount among them to transfer_details::m_amount, and
// 3) the wallet somehow spent that output with an amount smaller than the above amount, causing inconsistency
td.m_amount = amount;
}
}
else
{
amount = td.amount();
}
tx_money_spent_in_ins += amount;
if (subaddr_account && *subaddr_account != td.m_subaddr_index.major)
LOG_ERROR("spent funds are from different subaddress accounts; count of incoming/outgoing payments will be incorrect");
subaddr_account = td.m_subaddr_index.major;
subaddr_indices.insert(td.m_subaddr_index.minor);
if (!pool)
{
LOG_PRINT_L0("Spent money: " << print_money(amount) << ", with tx: " << txid);
set_spent(it->second, height);
if (0 != m_callback)
m_callback->on_money_spent(height, txid, tx, amount, tx, td.m_subaddr_index);
}
}
if (!pool && m_track_uses)
{
PERF_TIMER(track_uses);
const uint64_t amount = in_to_key.amount;
std::vector<uint64_t> offsets = cryptonote::relative_output_offsets_to_absolute(in_to_key.key_offsets);
if (output_tracker_cache)
{
for (uint64_t offset: offsets)
{
const std::map<std::pair<uint64_t, uint64_t>, size_t>::const_iterator i = output_tracker_cache->find(std::make_pair(amount, offset));
if (i != output_tracker_cache->end())
{
size_t idx = i->second;
THROW_WALLET_EXCEPTION_IF(idx >= m_transfers.size(), error::wallet_internal_error, "Output tracker cache index out of range");
m_transfers[idx].m_uses.push_back(std::make_pair(height, txid));
}
}
}
else for (transfer_details &td: m_transfers)
{
if (amount != in_to_key.amount)
continue;
for (uint64_t offset: offsets)
if (offset == td.m_global_output_index)
td.m_uses.push_back(std::make_pair(height, txid));
}
}
}
uint64_t fee = miner_tx ? 0 : tx.version == txversion::v1 ? tx_money_spent_in_ins - get_outs_money_amount(tx) : tx.rct_signatures.txnFee;
if (tx_money_spent_in_ins > 0 && !pool)
{
uint64_t self_received = std::accumulate<decltype(tx_money_got_in_outs.begin()), uint64_t>(tx_money_got_in_outs.begin(), tx_money_got_in_outs.end(), 0,
[&subaddr_account] (uint64_t acc, const tx_money_got_in_out& p)
{
return acc + (p.index.major == *subaddr_account ? p.amount : 0);
});
process_outgoing(txid, tx, height, ts, tx_money_spent_in_ins, self_received, *subaddr_account, subaddr_indices);
// if sending to yourself at the same subaddress account, set the outgoing payment amount to 0 so that it's less confusing
if (tx_money_spent_in_ins == self_received + fee)
{
auto i = m_confirmed_txs.find(txid);
THROW_WALLET_EXCEPTION_IF(i == m_confirmed_txs.end(), error::wallet_internal_error,
"confirmed tx wasn't found: " + string_tools::pod_to_hex(txid));
i->second.m_change = self_received;
}
}
// remove change sent to the spending subaddress account from the list of received funds
uint64_t sub_change = 0;
for (auto i = tx_money_got_in_outs.begin(); i != tx_money_got_in_outs.end();)
{
if (subaddr_account && i->index.major == *subaddr_account)
{
sub_change += i->amount;
i = tx_money_got_in_outs.erase(i);
}
else
++i;
}
// create payment_details for each incoming transfer to a subaddress index
crypto::hash payment_id = null_hash;
if (tx_money_got_in_outs.size() > 0 || blink_got_mined)
{
tx_extra_nonce extra_nonce;
if (find_tx_extra_field_by_type(tx_extra_fields, extra_nonce))
{
crypto::hash8 payment_id8 = null_hash8;
if(get_encrypted_payment_id_from_tx_extra_nonce(extra_nonce.nonce, payment_id8))
{
// We got a payment ID to go with this tx
LOG_PRINT_L2("Found encrypted payment ID: " << payment_id8);
MINFO("Consider using subaddresses instead of encrypted payment IDs");
if (tx_pub_key != null_pkey)
{
if (!m_account.get_device().decrypt_payment_id(payment_id8, tx_pub_key, m_account.get_keys().m_view_secret_key))
{
LOG_PRINT_L0("Failed to decrypt payment ID: " << payment_id8);
}
else
{
LOG_PRINT_L2("Decrypted payment ID: " << payment_id8);
// put the 64 bit decrypted payment id in the first 8 bytes
memcpy(payment_id.data, payment_id8.data, 8);
// rest is already 0, but guard against code changes above
memset(payment_id.data + 8, 0, 24);
}
}
else
{
LOG_PRINT_L1("No public key found in tx, unable to decrypt payment id");
}
}
else if (get_payment_id_from_tx_extra_nonce(extra_nonce.nonce, payment_id))
{
LOG_PRINT_L2("Found unencrypted payment ID: " << payment_id);
MWARNING("Found unencrypted payment ID: these are bad for privacy, consider using subaddresses instead");
}
}
}
if (tx_money_got_in_outs.size() > 0)
{
uint64_t total_received_2 = sub_change;
for (const auto& i : tx_money_got_in_outs)
total_received_2 += i.amount;
if (total_received_1 != total_received_2)
{
const el::Level level = el::Level::Warning;
MCLOG_RED(level, "global", "**********************************************************************");
MCLOG_RED(level, "global", "Consistency failure in amounts received");
MCLOG_RED(level, "global", "Check transaction " << txid);
MCLOG_RED(level, "global", "**********************************************************************");
exit(1);
return;
}
bool all_same = true;
for (const auto& i : tx_money_got_in_outs)
{
payment_details payment;
payment.m_tx_hash = txid;
payment.m_fee = fee;
payment.m_amount = i.amount;
payment.m_block_height = height;
payment.m_unlock_time = i.unlock_time;
payment.m_timestamp = ts;
payment.m_subaddr_index = i.index;
payment.m_type = i.type;
payment.m_unmined_blink = pool && blink;
payment.m_was_blink = blink;
if (pool && !blink) {
if (emplace_or_replace(m_unconfirmed_payments, payment_id, pool_payment_details{payment, double_spend_seen}))
all_same = false;
if (0 != m_callback)
m_callback->on_unconfirmed_money_received(height, txid, tx, payment.m_amount, payment.m_subaddr_index);
}
else
m_payments.emplace(payment_id, payment);
LOG_PRINT_L2("Payment found in " << (pool ? blink ? "blink pool" : "pool" : "block") << ": " << payment_id << " / " << payment.m_tx_hash << " / " << payment.m_amount);
}
// if it's a pool tx and we already had it, don't notify again
if (pool && all_same)
notify = false;
}
if (blink_got_mined) {
// If a blink tx that we already knew about moved from the mempool into a block then we have to
// go back and fix up the heights in the payment_details because they'll have been set to 0 from
// the initial blink.
auto range = m_payments.equal_range(payment_id);
for (auto it = range.first; it != range.second; ++it)
{
auto &pd = it->second;
if (pd.m_tx_hash == txid && pd.m_unmined_blink)
{
pd.m_block_height = height;
pd.m_unmined_blink = false;
}
}
}
if (notify)
{
std::shared_ptr<tools::Notify> tx_notify = m_tx_notify;
if (tx_notify)
tx_notify->notify("%s", epee::string_tools::pod_to_hex(txid).c_str(), NULL);
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::process_unconfirmed(const crypto::hash &txid, const cryptonote::transaction& tx, uint64_t height)
{
if (m_unconfirmed_txs.empty())
return;
auto unconf_it = m_unconfirmed_txs.find(txid);
if(unconf_it != m_unconfirmed_txs.end()) {
if (store_tx_info()) {
try {
m_confirmed_txs.emplace(txid, confirmed_transfer_details(unconf_it->second, height));
}
catch (...) {
// can fail if the tx has unexpected input types
LOG_PRINT_L0("Failed to add outgoing transaction to confirmed transaction map");
}
}
m_unconfirmed_txs.erase(unconf_it);
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::process_outgoing(const crypto::hash &txid, const cryptonote::transaction &tx, uint64_t height, uint64_t ts, uint64_t spent, uint64_t received, uint32_t subaddr_account, const std::set<uint32_t>& subaddr_indices)
{
std::pair<std::unordered_map<crypto::hash, confirmed_transfer_details>::iterator, bool> entry = m_confirmed_txs.insert(std::make_pair(txid, confirmed_transfer_details()));
// fill with the info we know, some info might already be there
if (entry.second)
{
// this case will happen if the tx is from our outputs, but was sent by another
// wallet (eg, we're a cold wallet and the hot wallet sent it). For RCT transactions,
// we only see 0 input amounts, so have to deduce amount out from other parameters.
entry.first->second.m_amount_in = spent;
if (tx.version == txversion::v1)
entry.first->second.m_amount_out = get_outs_money_amount(tx);
else
entry.first->second.m_amount_out = spent - tx.rct_signatures.txnFee;
entry.first->second.m_change = received;
std::vector<tx_extra_field> tx_extra_fields;
parse_tx_extra(tx.extra, tx_extra_fields); // ok if partially parsed
tx_extra_nonce extra_nonce;
if (find_tx_extra_field_by_type(tx_extra_fields, extra_nonce))
{
// we do not care about failure here
get_payment_id_from_tx_extra_nonce(extra_nonce.nonce, entry.first->second.m_payment_id);
}
entry.first->second.m_subaddr_account = subaddr_account;
entry.first->second.m_subaddr_indices = subaddr_indices;
}
entry.first->second.m_rings.clear();
for (const auto &in: tx.vin)
{
if (in.type() != typeid(cryptonote::txin_to_key))
continue;
const auto &txin = boost::get<cryptonote::txin_to_key>(in);
entry.first->second.m_rings.push_back(std::make_pair(txin.k_image, txin.key_offsets));
}
entry.first->second.m_block_height = height;
entry.first->second.m_timestamp = ts;
entry.first->second.m_unlock_time = tx.unlock_time;
entry.first->second.m_unlock_times = tx.output_unlock_times;
add_rings(tx);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::should_skip_block(const cryptonote::block &b, uint64_t height) const
{
// seeking only for blocks that are not older then the wallet creation time plus 1 day. 1 day is for possible user incorrect time setup
return !(b.timestamp + 60*60*24 > m_account.get_createtime() && height >= m_refresh_from_block_height);
}
//----------------------------------------------------------------------------------------------------
void wallet2::process_new_blockchain_entry(const cryptonote::block& b, const cryptonote::block_complete_entry& bche, const parsed_block &parsed_block, const crypto::hash& bl_id, uint64_t height, const std::vector<tx_cache_data> &tx_cache_data, size_t tx_cache_data_offset, std::map<std::pair<uint64_t, uint64_t>, size_t> *output_tracker_cache)
{
THROW_WALLET_EXCEPTION_IF(bche.txs.size() + 1 != parsed_block.o_indices.indices.size(), error::wallet_internal_error,
"block transactions=" + std::to_string(bche.txs.size()) +
" not match with daemon response size=" + std::to_string(parsed_block.o_indices.indices.size()));
//handle transactions from new block
//optimization: seeking only for blocks that are not older then the wallet creation time plus 1 day. 1 day is for possible user incorrect time setup
if (!should_skip_block(b, height))
{
TIME_MEASURE_START(miner_tx_handle_time);
if (m_refresh_type != RefreshNoCoinbase)
process_new_transaction(get_transaction_hash(b.miner_tx), b.miner_tx, parsed_block.o_indices.indices[0].indices, height, b.timestamp, true, false, false, false, tx_cache_data[tx_cache_data_offset], output_tracker_cache);
++tx_cache_data_offset;
TIME_MEASURE_FINISH(miner_tx_handle_time);
TIME_MEASURE_START(txs_handle_time);
THROW_WALLET_EXCEPTION_IF(bche.txs.size() != b.tx_hashes.size(), error::wallet_internal_error, "Wrong amount of transactions for block");
THROW_WALLET_EXCEPTION_IF(bche.txs.size() != parsed_block.txes.size(), error::wallet_internal_error, "Wrong amount of transactions for block");
for (size_t idx = 0; idx < b.tx_hashes.size(); ++idx)
{
process_new_transaction(b.tx_hashes[idx], parsed_block.txes[idx], parsed_block.o_indices.indices[idx+1].indices, height, b.timestamp, false, false, false, false, tx_cache_data[tx_cache_data_offset++], output_tracker_cache);
}
TIME_MEASURE_FINISH(txs_handle_time);
m_last_block_reward = cryptonote::get_outs_money_amount(b.miner_tx);
if (height > 0 && ((height % 2000) == 0))
LOG_PRINT_L0("Blockchain sync progress: " << bl_id << ", height " << height);
LOG_PRINT_L2("Processed block: " << bl_id << ", height " << height << ", " << miner_tx_handle_time + txs_handle_time << "(" << miner_tx_handle_time << "/" << txs_handle_time <<")ms");
}else
{
if (!(height % 128))
LOG_PRINT_L2( "Skipped block by timestamp, height: " << height << ", block time " << b.timestamp << ", account time " << m_account.get_createtime());
}
m_blockchain.push_back(bl_id);
if (0 != m_callback)
m_callback->on_new_block(height, b);
}
//----------------------------------------------------------------------------------------------------
void wallet2::get_short_chain_history(std::list<crypto::hash>& ids, uint64_t granularity) const
{
size_t i = 0;
size_t current_multiplier = 1;
size_t blockchain_size = std::max((size_t)(m_blockchain.size() / granularity * granularity), m_blockchain.offset());
size_t sz = blockchain_size - m_blockchain.offset();
if(!sz)
{
ids.push_back(m_blockchain.genesis());
return;
}
size_t current_back_offset = 1;
bool base_included = false;
while(current_back_offset < sz)
{
ids.push_back(m_blockchain[m_blockchain.offset() + sz-current_back_offset]);
if(sz-current_back_offset == 0)
base_included = true;
if(i < 10)
{
++current_back_offset;
}else
{
current_back_offset += current_multiplier *= 2;
}
++i;
}
if(!base_included)
ids.push_back(m_blockchain[m_blockchain.offset()]);
if(m_blockchain.offset())
ids.push_back(m_blockchain.genesis());
}
//----------------------------------------------------------------------------------------------------
void wallet2::parse_block_round(const cryptonote::blobdata &blob, cryptonote::block &bl, crypto::hash &bl_id, bool &error) const
{
error = !cryptonote::parse_and_validate_block_from_blob(blob, bl, bl_id);
}
//----------------------------------------------------------------------------------------------------
void wallet2::pull_blocks(uint64_t start_height, uint64_t &blocks_start_height, const std::list<crypto::hash> &short_chain_history, std::vector<cryptonote::block_complete_entry> &blocks, std::vector<cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::block_output_indices> &o_indices)
{
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::request req{};
cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::response res{};
req.block_ids = short_chain_history;
req.prune = true;
req.start_height = start_height;
req.no_miner_tx = m_refresh_type == RefreshNoCoinbase;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_bin("/getblocks.bin", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "getblocks.bin");
THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "getblocks.bin");
THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::get_blocks_error, get_rpc_status(res.status));
THROW_WALLET_EXCEPTION_IF(res.blocks.size() != res.output_indices.size(), error::wallet_internal_error,
"mismatched blocks (" + boost::lexical_cast<std::string>(res.blocks.size()) + ") and output_indices (" +
boost::lexical_cast<std::string>(res.output_indices.size()) + ") sizes from daemon");
blocks_start_height = res.start_height;
blocks = std::move(res.blocks);
o_indices = std::move(res.output_indices);
}
//----------------------------------------------------------------------------------------------------
void wallet2::pull_hashes(uint64_t start_height, uint64_t &blocks_start_height, const std::list<crypto::hash> &short_chain_history, std::vector<crypto::hash> &hashes)
{
cryptonote::COMMAND_RPC_GET_HASHES_FAST::request req{};
cryptonote::COMMAND_RPC_GET_HASHES_FAST::response res{};
req.block_ids = short_chain_history;
req.start_height = start_height;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_bin("/gethashes.bin", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "gethashes.bin");
THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "gethashes.bin");
THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::get_hashes_error, get_rpc_status(res.status));
blocks_start_height = res.start_height;
hashes = std::move(res.m_block_ids);
}
//----------------------------------------------------------------------------------------------------
void wallet2::process_parsed_blocks(uint64_t start_height, const std::vector<cryptonote::block_complete_entry> &blocks, const std::vector<parsed_block> &parsed_blocks, uint64_t& blocks_added, std::map<std::pair<uint64_t, uint64_t>, size_t> *output_tracker_cache)
{
size_t current_index = start_height;
blocks_added = 0;
THROW_WALLET_EXCEPTION_IF(blocks.size() != parsed_blocks.size(), error::wallet_internal_error, "size mismatch");
THROW_WALLET_EXCEPTION_IF(!m_blockchain.is_in_bounds(current_index), error::out_of_hashchain_bounds_error);
tools::threadpool& tpool = tools::threadpool::getInstance();
tools::threadpool::waiter waiter;
size_t num_txes = 0;
std::vector<tx_cache_data> tx_cache_data;
for (size_t i = 0; i < blocks.size(); ++i)
num_txes += 1 + parsed_blocks[i].txes.size();
tx_cache_data.resize(num_txes);
size_t txidx = 0;
for (size_t i = 0; i < blocks.size(); ++i)
{
THROW_WALLET_EXCEPTION_IF(parsed_blocks[i].txes.size() != parsed_blocks[i].block.tx_hashes.size(),
error::wallet_internal_error, "Mismatched parsed_blocks[i].txes.size() and parsed_blocks[i].block.tx_hashes.size()");
if (should_skip_block(parsed_blocks[i].block, start_height + i))
{
txidx += 1 + parsed_blocks[i].block.tx_hashes.size();
continue;
}
if (m_refresh_type != RefreshNoCoinbase)
tpool.submit(&waiter, [&, i, txidx](){ cache_tx_data(parsed_blocks[i].block.miner_tx, get_transaction_hash(parsed_blocks[i].block.miner_tx), tx_cache_data[txidx]); });
++txidx;
for (size_t idx = 0; idx < parsed_blocks[i].txes.size(); ++idx)
{
tpool.submit(&waiter, [&, i, idx, txidx](){ cache_tx_data(parsed_blocks[i].txes[idx], parsed_blocks[i].block.tx_hashes[idx], tx_cache_data[txidx]); });
++txidx;
}
}
THROW_WALLET_EXCEPTION_IF(txidx != num_txes, error::wallet_internal_error, "txidx does not match tx_cache_data size");
waiter.wait(&tpool);
hw::device &hwdev = m_account.get_device();
hw::reset_mode rst(hwdev);
hwdev.set_mode(hw::device::TRANSACTION_PARSE);
const cryptonote::account_keys &keys = m_account.get_keys();
auto gender = [&](wallet2::is_out_data &iod) {
if (!hwdev.generate_key_derivation(iod.pkey, keys.m_view_secret_key, iod.derivation))
{
MWARNING("Failed to generate key derivation from tx pubkey, skipping");
static_assert(sizeof(iod.derivation) == sizeof(rct::key), "Mismatched sizes of key_derivation and rct::key");
memcpy(&iod.derivation, rct::identity().bytes, sizeof(iod.derivation));
}
};
for (size_t i = 0; i < tx_cache_data.size(); ++i)
{
if (tx_cache_data[i].empty())
continue;
tpool.submit(&waiter, [&hwdev, &gender, &tx_cache_data, i]() {
auto &slot = tx_cache_data[i];
boost::unique_lock<hw::device> hwdev_lock(hwdev);
for (auto &iod: slot.primary)
gender(iod);
for (auto &iod: slot.additional)
gender(iod);
}, true);
}
waiter.wait(&tpool);
auto geniod = [&](const cryptonote::transaction &tx, size_t n_vouts, size_t txidx) {
for (size_t k = 0; k < n_vouts; ++k)
{
const auto &o = tx.vout[k];
if (o.target.type() == typeid(cryptonote::txout_to_key))
{
std::vector<crypto::key_derivation> additional_derivations;
additional_derivations.reserve(tx_cache_data[txidx].additional.size());
for (const auto &iod: tx_cache_data[txidx].additional)
additional_derivations.push_back(iod.derivation);
const auto &key = boost::get<txout_to_key>(o.target).key;
for (size_t l = 0; l < tx_cache_data[txidx].primary.size(); ++l)
{
THROW_WALLET_EXCEPTION_IF(tx_cache_data[txidx].primary[l].received.size() != n_vouts,
error::wallet_internal_error, "Unexpected received array size");
tx_cache_data[txidx].primary[l].received[k] = is_out_to_acc_precomp(m_subaddresses, key, tx_cache_data[txidx].primary[l].derivation, additional_derivations, k, hwdev);
additional_derivations.clear();
}
}
}
};
txidx = 0;
for (size_t i = 0; i < blocks.size(); ++i)
{
if (should_skip_block(parsed_blocks[i].block, start_height + i))
{
txidx += 1 + parsed_blocks[i].block.tx_hashes.size();
continue;
}
if (m_refresh_type != RefreshType::RefreshNoCoinbase)
{
THROW_WALLET_EXCEPTION_IF(txidx >= tx_cache_data.size(), error::wallet_internal_error, "txidx out of range");
const size_t n_vouts = m_refresh_type == RefreshType::RefreshOptimizeCoinbase ? 1 : parsed_blocks[i].block.miner_tx.vout.size();
tpool.submit(&waiter, [&, i, n_vouts, txidx](){ geniod(parsed_blocks[i].block.miner_tx, n_vouts, txidx); }, true);
}
++txidx;
for (size_t j = 0; j < parsed_blocks[i].txes.size(); ++j)
{
THROW_WALLET_EXCEPTION_IF(txidx >= tx_cache_data.size(), error::wallet_internal_error, "txidx out of range");
tpool.submit(&waiter, [&, i, j, txidx](){ geniod(parsed_blocks[i].txes[j], parsed_blocks[i].txes[j].vout.size(), txidx); }, true);
++txidx;
}
}
THROW_WALLET_EXCEPTION_IF(txidx != tx_cache_data.size(), error::wallet_internal_error, "txidx did not reach expected value");
waiter.wait(&tpool);
hwdev.set_mode(hw::device::NONE);
size_t tx_cache_data_offset = 0;
for (size_t i = 0; i < blocks.size(); ++i)
{
const crypto::hash &bl_id = parsed_blocks[i].hash;
const cryptonote::block &bl = parsed_blocks[i].block;
if(current_index >= m_blockchain.size())
{
process_new_blockchain_entry(bl, blocks[i], parsed_blocks[i], bl_id, current_index, tx_cache_data, tx_cache_data_offset, output_tracker_cache);
++blocks_added;
}
else if(bl_id != m_blockchain[current_index])
{
//split detected here !!!
THROW_WALLET_EXCEPTION_IF(current_index == start_height, error::wallet_internal_error,
"wrong daemon response: split starts from the first block in response " + string_tools::pod_to_hex(bl_id) +
" (height " + std::to_string(start_height) + "), local block id at this height: " +
string_tools::pod_to_hex(m_blockchain[current_index]));
detach_blockchain(current_index, output_tracker_cache);
process_new_blockchain_entry(bl, blocks[i], parsed_blocks[i], bl_id, current_index, tx_cache_data, tx_cache_data_offset, output_tracker_cache);
}
else
{
LOG_PRINT_L2("Block is already in blockchain: " << string_tools::pod_to_hex(bl_id));
}
++current_index;
tx_cache_data_offset += 1 + parsed_blocks[i].txes.size();
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::refresh(bool trusted_daemon)
{
uint64_t blocks_fetched = 0;
refresh(trusted_daemon, 0, blocks_fetched);
}
//----------------------------------------------------------------------------------------------------
void wallet2::refresh(bool trusted_daemon, uint64_t start_height, uint64_t & blocks_fetched)
{
bool received_money = false;
refresh(trusted_daemon, start_height, blocks_fetched, received_money);
}
//----------------------------------------------------------------------------------------------------
void wallet2::pull_and_parse_next_blocks(uint64_t start_height, uint64_t &blocks_start_height, std::list<crypto::hash> &short_chain_history, const std::vector<cryptonote::block_complete_entry> &prev_blocks, const std::vector<parsed_block> &prev_parsed_blocks, std::vector<cryptonote::block_complete_entry> &blocks, std::vector<parsed_block> &parsed_blocks, bool &error)
{
error = false;
try
{
drop_from_short_history(short_chain_history, 3);
THROW_WALLET_EXCEPTION_IF(prev_blocks.size() != prev_parsed_blocks.size(), error::wallet_internal_error, "size mismatch");
// prepend the last 3 blocks, should be enough to guard against a block or two's reorg
auto s = std::next(prev_parsed_blocks.rbegin(), std::min((size_t)3, prev_parsed_blocks.size())).base();
for (; s != prev_parsed_blocks.end(); ++s)
{
short_chain_history.push_front(s->hash);
}
// pull the new blocks
std::vector<cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::block_output_indices> o_indices;
pull_blocks(start_height, blocks_start_height, short_chain_history, blocks, o_indices);
THROW_WALLET_EXCEPTION_IF(blocks.size() != o_indices.size(), error::wallet_internal_error, "Mismatched sizes of blocks and o_indices");
tools::threadpool& tpool = tools::threadpool::getInstance();
tools::threadpool::waiter waiter;
parsed_blocks.resize(blocks.size());
for (size_t i = 0; i < blocks.size(); ++i)
{
tpool.submit(&waiter, boost::bind(&wallet2::parse_block_round, this, std::cref(blocks[i].block),
std::ref(parsed_blocks[i].block), std::ref(parsed_blocks[i].hash), std::ref(parsed_blocks[i].error)), true);
}
waiter.wait(&tpool);
for (size_t i = 0; i < blocks.size(); ++i)
{
if (parsed_blocks[i].error)
{
error = true;
break;
}
parsed_blocks[i].o_indices = std::move(o_indices[i]);
}
boost::mutex error_lock;
for (size_t i = 0; i < blocks.size(); ++i)
{
parsed_blocks[i].txes.resize(blocks[i].txs.size());
for (size_t j = 0; j < blocks[i].txs.size(); ++j)
{
tpool.submit(&waiter, [&, i, j](){
if (!parse_and_validate_tx_base_from_blob(blocks[i].txs[j], parsed_blocks[i].txes[j]))
{
boost::unique_lock<boost::mutex> lock(error_lock);
error = true;
}
}, true);
}
}
waiter.wait(&tpool);
}
catch(...)
{
error = true;
}
}
void wallet2::remove_obsolete_pool_txs(const std::vector<crypto::hash> &tx_hashes)
{
// remove pool txes to us that aren't in the pool anymore
std::unordered_multimap<crypto::hash, wallet2::pool_payment_details>::iterator uit = m_unconfirmed_payments.begin();
while (uit != m_unconfirmed_payments.end())
{
const crypto::hash &txid = uit->second.m_pd.m_tx_hash;
bool found = false;
for (const auto &it2: tx_hashes)
{
if (it2 == txid)
{
found = true;
break;
}
}
auto pit = uit++;
if (!found)
{
MDEBUG("Removing " << txid << " from unconfirmed payments, not found in pool");
m_unconfirmed_payments.erase(pit);
if (0 != m_callback)
m_callback->on_pool_tx_removed(txid);
}
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::update_pool_state(bool refreshed)
{
MTRACE("update_pool_state start");
auto keys_reencryptor = epee::misc_utils::create_scope_leave_handler([&, this]() {
if (m_encrypt_keys_after_refresh)
{
encrypt_keys(*m_encrypt_keys_after_refresh);
m_encrypt_keys_after_refresh = boost::none;
}
});
// get the pool state
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES_BIN::request req;
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_HASHES_BIN::response res;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/get_transaction_pool_hashes.bin", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_transaction_pool_hashes.bin");
THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_transaction_pool_hashes.bin");
THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::get_tx_pool_error);
MTRACE("update_pool_state got pool");
// remove any pending tx that's not in the pool
std::unordered_map<crypto::hash, wallet2::unconfirmed_transfer_details>::iterator it = m_unconfirmed_txs.begin();
while (it != m_unconfirmed_txs.end())
{
const crypto::hash &txid = it->first;
bool found = false;
for (const auto &it2: res.tx_hashes)
{
if (it2 == txid)
{
found = true;
break;
}
}
auto pit = it++;
if (!found)
{
// we want to avoid a false positive when we ask for the pool just after
// a tx is removed from the pool due to being found in a new block, but
// just before the block is visible by refresh. So we keep a boolean, so
// that the first time we don't see the tx, we set that boolean, and only
// delete it the second time it is checked (but only when refreshed, so
// we're sure we've seen the blockchain state first)
if (pit->second.m_state == wallet2::unconfirmed_transfer_details::pending)
{
LOG_PRINT_L1("Pending txid " << txid << " not in pool, marking as not in pool");
pit->second.m_state = wallet2::unconfirmed_transfer_details::pending_not_in_pool;
}
else if (pit->second.m_state == wallet2::unconfirmed_transfer_details::pending_not_in_pool && refreshed)
{
LOG_PRINT_L1("Pending txid " << txid << " not in pool, marking as failed");
pit->second.m_state = wallet2::unconfirmed_transfer_details::failed;
// the inputs aren't spent anymore, since the tx failed
remove_rings(pit->second.m_tx);
for (size_t vini = 0; vini < pit->second.m_tx.vin.size(); ++vini)
{
if (pit->second.m_tx.vin[vini].type() == typeid(txin_to_key))
{
txin_to_key &tx_in_to_key = boost::get<txin_to_key>(pit->second.m_tx.vin[vini]);
for (size_t i = 0; i < m_transfers.size(); ++i)
{
const transfer_details &td = m_transfers[i];
if (td.m_key_image == tx_in_to_key.k_image)
{
LOG_PRINT_L1("Resetting spent status for output " << vini << ": " << td.m_key_image);
set_unspent(i);
break;
}
}
}
}
}
}
}
MTRACE("update_pool_state done first loop");
// remove pool txes to us that aren't in the pool anymore
// but only if we just refreshed, so that the tx can go in
// the in transfers list instead (or nowhere if it just
// disappeared without being mined)
if (refreshed)
remove_obsolete_pool_txs(res.tx_hashes);
MTRACE("update_pool_state done second loop");
// gather txids of new pool txes to us
std::vector<std::pair<crypto::hash, bool>> txids;
for (const auto &txid: res.tx_hashes)
{
bool txid_found_in_up = false;
for (const auto &up: m_unconfirmed_payments)
{
if (up.second.m_pd.m_tx_hash == txid)
{
txid_found_in_up = true;
break;
}
}
if (m_scanned_pool_txs[0].find(txid) != m_scanned_pool_txs[0].end() || m_scanned_pool_txs[1].find(txid) != m_scanned_pool_txs[1].end())
{
// if it's for us, we want to keep track of whether we saw a double spend, so don't bail out
if (!txid_found_in_up)
{
LOG_PRINT_L2("Already seen " << txid << ", and not for us, skipped");
continue;
}
}
if (!txid_found_in_up)
{
LOG_PRINT_L1("Found new pool tx: " << txid);
bool found = false;
for (const auto &i: m_unconfirmed_txs)
{
if (i.first == txid)
{
found = true;
// if this is a payment to yourself at a different subaddress account, don't skip it
// so that you can see the incoming pool tx with 'show_transfers' on that receiving subaddress account
const unconfirmed_transfer_details& utd = i.second;
for (const auto& dst : utd.m_dests)
{
auto subaddr_index = m_subaddresses.find(dst.addr.m_spend_public_key);
if (subaddr_index != m_subaddresses.end() && subaddr_index->second.major != utd.m_subaddr_account)
{
found = false;
break;
}
}
break;
}
}
if (!found)
{
// not one of those we sent ourselves
txids.push_back({txid, false});
}
else
{
LOG_PRINT_L1("We sent that one");
}
}
else
{
LOG_PRINT_L1("Already saw that one, it's for us");
txids.push_back({txid, true});
}
}
// get those txes
if (!txids.empty())
{
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::request req;
cryptonote::COMMAND_RPC_GET_TRANSACTIONS::response res;
for (const auto &p: txids)
req.txs_hashes.push_back(epee::string_tools::pod_to_hex(p.first));
MDEBUG("asking for " << txids.size() << " transactions");
req.decode_as_json = false;
req.prune = true;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/gettransactions", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
MDEBUG("Got " << r << " and " << res.status);
if (r && res.status == CORE_RPC_STATUS_OK)
{
if (res.txs.size() == txids.size())
{
for (const auto &tx_entry: res.txs)
{
if (tx_entry.in_pool)
{
cryptonote::transaction tx;
cryptonote::blobdata bd;
crypto::hash tx_hash;
if (get_pruned_tx(tx_entry, tx, tx_hash))
{
auto i = std::find_if(txids.begin(), txids.end(),
[tx_hash](const std::pair<crypto::hash, bool> &e) { return e.first == tx_hash; });
if (i != txids.end())
{
process_new_transaction(tx_hash, tx, {}, 0, time(NULL), false, true, tx_entry.blink, tx_entry.double_spend_seen, {});
m_scanned_pool_txs[0].insert(tx_hash);
if (m_scanned_pool_txs[0].size() > 5000)
{
std::swap(m_scanned_pool_txs[0], m_scanned_pool_txs[1]);
m_scanned_pool_txs[0].clear();
}
}
else
{
MERROR("Got txid " << tx_hash << " which we did not ask for");
}
}
else
{
LOG_PRINT_L0("Failed to parse transaction from daemon");
}
}
else
{
LOG_PRINT_L1("Transaction from daemon was in pool, but is no more");
}
}
}
else
{
LOG_PRINT_L0("Expected " << txids.size() << " tx(es), got " << res.txs.size());
}
}
else
{
LOG_PRINT_L0("Error calling gettransactions daemon RPC: r " << r << ", status " << get_rpc_status(res.status));
}
}
MTRACE("update_pool_state end");
}
//----------------------------------------------------------------------------------------------------
void wallet2::fast_refresh(uint64_t stop_height, uint64_t &blocks_start_height, std::list<crypto::hash> &short_chain_history, bool force)
{
std::vector<crypto::hash> hashes;
uint64_t checkpoint_height = 0;
crypto::hash checkpoint_hash = cryptonote::get_newest_hardcoded_checkpoint(nettype(), &checkpoint_height);
if ((stop_height > checkpoint_height && m_blockchain.size()-1 < checkpoint_height) && !force)
{
// we will drop all these, so don't bother getting them
uint64_t missing_blocks = checkpoint_height - m_blockchain.size();
while (missing_blocks-- > 0)
m_blockchain.push_back(crypto::null_hash); // maybe a bit suboptimal, but deque won't do huge reallocs like vector
m_blockchain.push_back(checkpoint_hash);
m_blockchain.trim(checkpoint_height);
short_chain_history.clear();
get_short_chain_history(short_chain_history);
}
size_t current_index = m_blockchain.size();
while(m_run.load(std::memory_order_relaxed) && current_index < stop_height)
{
pull_hashes(0, blocks_start_height, short_chain_history, hashes);
if (hashes.size() <= 3)
return;
if (blocks_start_height < m_blockchain.offset())
{
MERROR("Blocks start before blockchain offset: " << blocks_start_height << " " << m_blockchain.offset());
return;
}
if (hashes.size() + current_index < stop_height) {
drop_from_short_history(short_chain_history, 3);
std::vector<crypto::hash>::iterator right = hashes.end();
// prepend 3 more
for (int i = 0; i<3; i++) {
right--;
short_chain_history.push_front(*right);
}
}
current_index = blocks_start_height;
for(auto& bl_id: hashes)
{
if(current_index >= m_blockchain.size())
{
if (!(current_index % 1024))
LOG_PRINT_L2( "Skipped block by height: " << current_index);
m_blockchain.push_back(bl_id);
if (0 != m_callback)
{ // FIXME: this isn't right, but simplewallet just logs that we got a block.
cryptonote::block dummy;
m_callback->on_new_block(current_index, dummy);
}
}
else if(bl_id != m_blockchain[current_index])
{
//split detected here !!!
return;
}
++current_index;
if (current_index >= stop_height)
return;
}
}
}
bool wallet2::add_address_book_row(const cryptonote::account_public_address &address, const crypto::hash &payment_id, const std::string &description, bool is_subaddress)
{
wallet2::address_book_row a;
a.m_address = address;
a.m_payment_id = payment_id;
a.m_description = description;
a.m_is_subaddress = is_subaddress;
auto old_size = m_address_book.size();
m_address_book.push_back(a);
if(m_address_book.size() == old_size+1)
return true;
return false;
}
bool wallet2::delete_address_book_row(std::size_t row_id) {
if(m_address_book.size() <= row_id)
return false;
m_address_book.erase(m_address_book.begin()+row_id);
return true;
}
//----------------------------------------------------------------------------------------------------
std::shared_ptr<std::map<std::pair<uint64_t, uint64_t>, size_t>> wallet2::create_output_tracker_cache() const
{
std::shared_ptr<std::map<std::pair<uint64_t, uint64_t>, size_t>> cache{new std::map<std::pair<uint64_t, uint64_t>, size_t>()};
for (size_t i = 0; i < m_transfers.size(); ++i)
{
const transfer_details &td = m_transfers[i];
(*cache)[std::make_pair(td.is_rct() ? 0 : td.amount(), td.m_global_output_index)] = i;
}
return cache;
}
//----------------------------------------------------------------------------------------------------
void wallet2::refresh(bool trusted_daemon, uint64_t start_height, uint64_t & blocks_fetched, bool& received_money)
{
if (m_offline)
{
blocks_fetched = 0;
received_money = 0;
return;
}
if(m_light_wallet) {
// MyMonero get_address_info needs to be called occasionally to trigger wallet sync.
// This call is not really needed for other purposes and can be removed if mymonero changes their backend.
tools::COMMAND_RPC_GET_ADDRESS_INFO::response res;
// Get basic info
if(light_wallet_get_address_info(res)) {
// Last stored block height
uint64_t prev_height = m_light_wallet_blockchain_height;
// Update lw heights
m_light_wallet_scanned_block_height = res.scanned_block_height;
m_light_wallet_blockchain_height = res.blockchain_height;
// If new height - call new_block callback
if(m_light_wallet_blockchain_height != prev_height)
{
MDEBUG("new block since last time!");
m_callback->on_lw_new_block(m_light_wallet_blockchain_height - 1);
}
m_light_wallet_connected = true;
MDEBUG("lw scanned block height: " << m_light_wallet_scanned_block_height);
MDEBUG("lw blockchain height: " << m_light_wallet_blockchain_height);
MDEBUG(m_light_wallet_blockchain_height-m_light_wallet_scanned_block_height << " blocks behind");
// TODO: add wallet created block info
light_wallet_get_address_txs();
} else
m_light_wallet_connected = false;
// Lighwallet refresh done
return;
}
received_money = false;
blocks_fetched = 0;
uint64_t added_blocks = 0;
size_t try_count = 0;
crypto::hash last_tx_hash_id = m_transfers.size() ? m_transfers.back().m_txid : null_hash;
std::list<crypto::hash> short_chain_history;
tools::threadpool& tpool = tools::threadpool::getInstance();
tools::threadpool::waiter waiter;
uint64_t blocks_start_height;
std::vector<cryptonote::block_complete_entry> blocks;
std::vector<parsed_block> parsed_blocks;
bool refreshed = false;
std::shared_ptr<std::map<std::pair<uint64_t, uint64_t>, size_t>> output_tracker_cache;
hw::device &hwdev = m_account.get_device();
// pull the first set of blocks
get_short_chain_history(short_chain_history, (m_first_refresh_done || trusted_daemon) ? 1 : FIRST_REFRESH_GRANULARITY);
m_run.store(true, std::memory_order_relaxed);
if (start_height > m_blockchain.size() || m_refresh_from_block_height > m_blockchain.size()) {
if (!start_height)
start_height = m_refresh_from_block_height;
// we can shortcut by only pulling hashes up to the start_height
fast_refresh(start_height, blocks_start_height, short_chain_history);
// regenerate the history now that we've got a full set of hashes
short_chain_history.clear();
get_short_chain_history(short_chain_history, (m_first_refresh_done || trusted_daemon) ? 1 : FIRST_REFRESH_GRANULARITY);
start_height = 0;
// and then fall through to regular refresh processing
}
// If stop() is called during fast refresh we don't need to continue
if(!m_run.load(std::memory_order_relaxed))
return;
// always reset start_height to 0 to force short_chain_ history to be used on
// subsequent pulls in this refresh.
start_height = 0;
auto keys_reencryptor = epee::misc_utils::create_scope_leave_handler([&, this]() {
if (m_encrypt_keys_after_refresh)
{
encrypt_keys(*m_encrypt_keys_after_refresh);
m_encrypt_keys_after_refresh = boost::none;
}
});
auto scope_exit_handler_hwdev = epee::misc_utils::create_scope_leave_handler([&](){hwdev.computing_key_images(false);});
bool first = true;
while(m_run.load(std::memory_order_relaxed))
{
uint64_t next_blocks_start_height;
std::vector<cryptonote::block_complete_entry> next_blocks;
std::vector<parsed_block> next_parsed_blocks;
bool error;
try
{
// pull the next set of blocks while we're processing the current one
error = false;
next_blocks.clear();
next_parsed_blocks.clear();
added_blocks = 0;
if (!first && blocks.empty())
{
refreshed = false;
break;
}
tpool.submit(&waiter, [&]{pull_and_parse_next_blocks(start_height, next_blocks_start_height, short_chain_history, blocks, parsed_blocks, next_blocks, next_parsed_blocks, error);});
if (!first)
{
try
{
process_parsed_blocks(blocks_start_height, blocks, parsed_blocks, added_blocks, output_tracker_cache.get());
}
catch (const tools::error::out_of_hashchain_bounds_error&)
{
MINFO("Daemon claims next refresh block is out of hash chain bounds, resetting hash chain");
uint64_t stop_height = m_blockchain.offset();
std::vector<crypto::hash> tip(m_blockchain.size() - m_blockchain.offset());
for (size_t i = m_blockchain.offset(); i < m_blockchain.size(); ++i)
tip[i - m_blockchain.offset()] = m_blockchain[i];
cryptonote::block b;
generate_genesis(b);
m_blockchain.clear();
m_blockchain.push_back(get_block_hash(b));
short_chain_history.clear();
get_short_chain_history(short_chain_history);
fast_refresh(stop_height, blocks_start_height, short_chain_history, true);
THROW_WALLET_EXCEPTION_IF((m_blockchain.size() == stop_height || (m_blockchain.size() == 1 && stop_height == 0) ? false : true), error::wallet_internal_error, "Unexpected hashchain size");
THROW_WALLET_EXCEPTION_IF(m_blockchain.offset() != 0, error::wallet_internal_error, "Unexpected hashchain offset");
for (const auto &h: tip)
m_blockchain.push_back(h);
short_chain_history.clear();
get_short_chain_history(short_chain_history);
start_height = stop_height;
throw std::runtime_error(""); // loop again
}
catch (const std::exception &e)
{
MERROR("Error parsing blocks: " << e.what());
error = true;
}
blocks_fetched += added_blocks;
}
waiter.wait(&tpool);
if(!first && blocks_start_height == next_blocks_start_height)
{
m_node_rpc_proxy.set_height(m_blockchain.size());
refreshed = true;
break;
}
first = false;
// handle error from async fetching thread
if (error)
{
throw std::runtime_error("proxy exception in refresh thread");
}
// if we've got at least 10 blocks to refresh, assume we're starting
// a long refresh, and setup a tracking output cache if we need to
if (m_track_uses && (!output_tracker_cache || output_tracker_cache->empty()) && next_blocks.size() >= 10)
output_tracker_cache = create_output_tracker_cache();
// switch to the new blocks from the daemon
blocks_start_height = next_blocks_start_height;
blocks = std::move(next_blocks);
parsed_blocks = std::move(next_parsed_blocks);
}
catch (const tools::error::password_needed&)
{
blocks_fetched += added_blocks;
waiter.wait(&tpool);
throw;
}
catch (const std::exception&)
{
blocks_fetched += added_blocks;
waiter.wait(&tpool);
if(try_count < 3)
{
LOG_PRINT_L1("Another try pull_blocks (try_count=" << try_count << ")...");
first = true;
start_height = 0;
blocks.clear();
parsed_blocks.clear();
short_chain_history.clear();
get_short_chain_history(short_chain_history, 1);
++try_count;
}
else
{
LOG_ERROR("pull_blocks failed, try_count=" << try_count);
throw;
}
}
}
if(last_tx_hash_id != (m_transfers.size() ? m_transfers.back().m_txid : null_hash))
received_money = true;
uint64_t immutable_height = 0;
boost::optional<std::string> fail_string = m_node_rpc_proxy.get_immutable_height(immutable_height);
if (!fail_string)
m_immutable_height = immutable_height;
try
{
// If stop() is called we don't need to check pending transactions
if (m_run.load(std::memory_order_relaxed))
update_pool_state(refreshed);
}
catch (...)
{
LOG_PRINT_L1("Failed to check pending transactions");
}
m_first_refresh_done = true;
LOG_PRINT_L1("Refresh done, blocks received: " << blocks_fetched << ", balance (all accounts): " << print_money(balance_all()) << ", unlocked: " << print_money(unlocked_balance_all()));
}
//----------------------------------------------------------------------------------------------------
bool wallet2::refresh(bool trusted_daemon, uint64_t & blocks_fetched, bool& received_money, bool& ok)
{
try
{
refresh(trusted_daemon, 0, blocks_fetched, received_money);
ok = true;
}
catch (...)
{
ok = false;
}
return ok;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::get_rct_distribution(uint64_t &start_height, std::vector<uint64_t> &distribution)
{
uint32_t rpc_version;
boost::optional<std::string> result = m_node_rpc_proxy.get_rpc_version(rpc_version);
// no error
if (!!result)
{
// empty string -> not connection
THROW_WALLET_EXCEPTION_IF(result->empty(), tools::error::no_connection_to_daemon, "getversion");
THROW_WALLET_EXCEPTION_IF(*result == CORE_RPC_STATUS_BUSY, tools::error::daemon_busy, "getversion");
if (*result != CORE_RPC_STATUS_OK)
{
MDEBUG("Cannot determine daemon RPC version, not requesting rct distribution");
return false;
}
}
else
{
if (rpc_version >= MAKE_CORE_RPC_VERSION(1, 19))
{
MDEBUG("Daemon is recent enough, requesting rct distribution");
}
else
{
MDEBUG("Daemon is too old, not requesting rct distribution");
return false;
}
}
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::request req{};
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::response res{};
req.amounts.push_back(0);
req.from_height = 0;
req.cumulative = false;
req.binary = true;
req.compress = true;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_bin("/get_output_distribution.bin", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
if (!r)
{
MWARNING("Failed to request output distribution: no connection to daemon");
return false;
}
if (res.status == CORE_RPC_STATUS_BUSY)
{
MWARNING("Failed to request output distribution: daemon is busy");
return false;
}
if (res.status != CORE_RPC_STATUS_OK)
{
MWARNING("Failed to request output distribution: " << res.status);
return false;
}
if (res.distributions.size() != 1)
{
MWARNING("Failed to request output distribution: not the expected single result");
return false;
}
if (res.distributions[0].amount != 0)
{
MWARNING("Failed to request output distribution: results are not for amount 0");
return false;
}
for (size_t i = 1; i < res.distributions[0].data.distribution.size(); ++i)
res.distributions[0].data.distribution[i] += res.distributions[0].data.distribution[i-1];
start_height = res.distributions[0].data.start_height;
distribution = std::move(res.distributions[0].data.distribution);
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::get_output_blacklist(std::vector<uint64_t> &blacklist)
{
uint32_t rpc_version;
boost::optional<std::string> result = m_node_rpc_proxy.get_rpc_version(rpc_version);
if (result)
{
// empty string -> not connection
THROW_WALLET_EXCEPTION_IF(result->empty(), tools::error::no_connection_to_daemon, "getversion");
THROW_WALLET_EXCEPTION_IF(*result == CORE_RPC_STATUS_BUSY, tools::error::daemon_busy, "getversion");
if (*result != CORE_RPC_STATUS_OK)
{
MDEBUG("Cannot determine daemon RPC version, not requesting output blacklist");
return false;
}
}
else
{
if (rpc_version >= MAKE_CORE_RPC_VERSION(2, 3))
{
MDEBUG("Daemon is recent enough, not requesting output blacklist");
}
else
{
MDEBUG("Daemon is too old, not requesting output blacklist");
return false;
}
}
cryptonote::COMMAND_RPC_GET_OUTPUT_BLACKLIST::request req = {};
cryptonote::COMMAND_RPC_GET_OUTPUT_BLACKLIST::response res = {};
m_daemon_rpc_mutex.lock();
bool r = invoke_http_bin("/get_output_blacklist.bin", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
if (!r)
{
MWARNING("Failed to request output blacklist: no connection to daemon");
return false;
}
blacklist = std::move(res.blacklist);
return true;
}
//----------------------------------------------------------------------------------------------------
void wallet2::detach_blockchain(uint64_t height, std::map<std::pair<uint64_t, uint64_t>, size_t> *output_tracker_cache)
{
LOG_PRINT_L0("Detaching blockchain on height " << height);
// size 1 2 3 4 5 6 7 8 9
// block 0 1 2 3 4 5 6 7 8
// C
THROW_WALLET_EXCEPTION_IF(height < m_blockchain.offset() && m_blockchain.size() > m_blockchain.offset(),
error::wallet_internal_error, "Daemon claims reorg below last checkpoint");
size_t transfers_detached = 0;
for (size_t i = 0; i < m_transfers.size(); ++i)
{
wallet2::transfer_details &td = m_transfers[i];
if (td.m_spent && td.m_spent_height >= height)
{
LOG_PRINT_L1("Resetting spent/frozen status for output " << i << ": " << td.m_key_image);
set_unspent(i);
thaw(i);
}
}
for (transfer_details &td: m_transfers)
{
while (!td.m_uses.empty() && td.m_uses.back().first >= height)
td.m_uses.pop_back();
}
if (output_tracker_cache)
output_tracker_cache->clear();
auto it = std::find_if(m_transfers.begin(), m_transfers.end(), [&](const transfer_details& td){return td.m_block_height >= height;});
size_t i_start = it - m_transfers.begin();
for(size_t i = i_start; i!= m_transfers.size();i++)
{
if (!m_transfers[i].m_key_image_known || m_transfers[i].m_key_image_partial)
continue;
auto it_ki = m_key_images.find(m_transfers[i].m_key_image);
THROW_WALLET_EXCEPTION_IF(it_ki == m_key_images.end(), error::wallet_internal_error, "key image not found: index " + std::to_string(i) + ", ki " + epee::string_tools::pod_to_hex(m_transfers[i].m_key_image) + ", " + std::to_string(m_key_images.size()) + " key images known");
m_key_images.erase(it_ki);
}
for(size_t i = i_start; i!= m_transfers.size();i++)
{
auto it_pk = m_pub_keys.find(m_transfers[i].get_public_key());
THROW_WALLET_EXCEPTION_IF(it_pk == m_pub_keys.end(), error::wallet_internal_error, "public key not found");
m_pub_keys.erase(it_pk);
}
m_transfers.erase(it, m_transfers.end());
size_t blocks_detached = m_blockchain.size() - height;
m_blockchain.crop(height);
for (auto it = m_payments.begin(); it != m_payments.end(); )
{
if(height <= it->second.m_block_height)
it = m_payments.erase(it);
else
++it;
}
for (auto it = m_confirmed_txs.begin(); it != m_confirmed_txs.end(); )
{
if(height <= it->second.m_block_height)
it = m_confirmed_txs.erase(it);
else
++it;
}
LOG_PRINT_L0("Detached blockchain on height " << height << ", transfers detached " << transfers_detached << ", blocks detached " << blocks_detached);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::deinit()
{
m_is_initialized=false;
unlock_keys_file();
m_account.deinit();
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::clear()
{
m_blockchain.clear();
m_transfers.clear();
m_key_images.clear();
m_pub_keys.clear();
m_unconfirmed_txs.clear();
m_payments.clear();
m_tx_keys.clear();
m_additional_tx_keys.clear();
m_confirmed_txs.clear();
m_unconfirmed_payments.clear();
m_scanned_pool_txs[0].clear();
m_scanned_pool_txs[1].clear();
m_address_book.clear();
m_subaddresses.clear();
m_subaddress_labels.clear();
m_multisig_rounds_passed = 0;
m_device_last_key_image_sync = 0;
return true;
}
//----------------------------------------------------------------------------------------------------
void wallet2::clear_soft(bool keep_key_images)
{
m_blockchain.clear();
m_transfers.clear();
if (!keep_key_images)
m_key_images.clear();
m_pub_keys.clear();
m_unconfirmed_txs.clear();
m_payments.clear();
m_confirmed_txs.clear();
m_unconfirmed_payments.clear();
m_scanned_pool_txs[0].clear();
m_scanned_pool_txs[1].clear();
cryptonote::block b;
generate_genesis(b);
m_blockchain.push_back(get_block_hash(b));
m_last_block_reward = cryptonote::get_outs_money_amount(b.miner_tx);
}
/*!
* \brief Stores wallet information to wallet file.
* \param keys_file_name Name of wallet file
* \param password Password of wallet file
* \param watch_only true to save only view key, false to save both spend and view keys
* \return Whether it was successful.
*/
bool wallet2::store_keys(const std::string& keys_file_name, const epee::wipeable_string& password, bool watch_only)
{
std::string account_data;
std::string multisig_signers;
std::string multisig_derivations;
cryptonote::account_base account = m_account;
crypto::chacha_key key;
crypto::generate_chacha_key(password.data(), password.size(), key, m_kdf_rounds);
if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only)
{
account.encrypt_viewkey(key);
account.decrypt_keys(key);
}
if (watch_only)
account.forget_spend_key();
account.encrypt_keys(key);
bool r = epee::serialization::store_t_to_binary(account, account_data);
CHECK_AND_ASSERT_MES(r, false, "failed to serialize wallet keys");
wallet2::keys_file_data keys_file_data{};
// Create a JSON object with "key_data" and "seed_language" as keys.
rapidjson::Document json;
json.SetObject();
rapidjson::Value value(rapidjson::kStringType);
value.SetString(account_data.c_str(), account_data.length());
json.AddMember("key_data", value, json.GetAllocator());
if (!seed_language.empty())
{
value.SetString(seed_language.c_str(), seed_language.length());
json.AddMember("seed_language", value, json.GetAllocator());
}
rapidjson::Value value2(rapidjson::kNumberType);
value2.SetInt(m_key_device_type);
json.AddMember("key_on_device", value2, json.GetAllocator());
value2.SetInt(watch_only ? 1 :0); // WTF ? JSON has different true and false types, and not boolean ??
json.AddMember("watch_only", value2, json.GetAllocator());
value2.SetInt(m_multisig ? 1 :0);
json.AddMember("multisig", value2, json.GetAllocator());
value2.SetUint(m_multisig_threshold);
json.AddMember("multisig_threshold", value2, json.GetAllocator());
if (m_multisig)
{
bool r = ::serialization::dump_binary(m_multisig_signers, multisig_signers);
CHECK_AND_ASSERT_MES(r, false, "failed to serialize wallet multisig signers");
value.SetString(multisig_signers.c_str(), multisig_signers.length());
json.AddMember("multisig_signers", value, json.GetAllocator());
r = ::serialization::dump_binary(m_multisig_derivations, multisig_derivations);
CHECK_AND_ASSERT_MES(r, false, "failed to serialize wallet multisig derivations");
value.SetString(multisig_derivations.c_str(), multisig_derivations.length());
json.AddMember("multisig_derivations", value, json.GetAllocator());
value2.SetUint(m_multisig_rounds_passed);
json.AddMember("multisig_rounds_passed", value2, json.GetAllocator());
}
value2.SetInt(m_always_confirm_transfers ? 1 :0);
json.AddMember("always_confirm_transfers", value2, json.GetAllocator());
value2.SetInt(m_print_ring_members ? 1 :0);
json.AddMember("print_ring_members", value2, json.GetAllocator());
value2.SetInt(m_store_tx_info ? 1 :0);
json.AddMember("store_tx_info", value2, json.GetAllocator());
value2.SetUint(m_default_mixin);
json.AddMember("default_mixin", value2, json.GetAllocator());
value2.SetUint(m_default_priority);
json.AddMember("default_priority", value2, json.GetAllocator());
value2.SetInt(m_auto_refresh ? 1 :0);
json.AddMember("auto_refresh", value2, json.GetAllocator());
value2.SetInt(m_refresh_type);
json.AddMember("refresh_type", value2, json.GetAllocator());
value2.SetUint64(m_refresh_from_block_height);
json.AddMember("refresh_height", value2, json.GetAllocator());
value2.SetInt(m_confirm_missing_payment_id ? 1 :0);
json.AddMember("confirm_missing_payment_id", value2, json.GetAllocator());
value2.SetInt(m_confirm_non_default_ring_size ? 1 :0);
json.AddMember("confirm_non_default_ring_size", value2, json.GetAllocator());
value2.SetInt(m_ask_password);
json.AddMember("ask_password", value2, json.GetAllocator());
value2.SetUint(m_min_output_count);
json.AddMember("min_output_count", value2, json.GetAllocator());
value2.SetUint64(m_min_output_value);
json.AddMember("min_output_value", value2, json.GetAllocator());
value2.SetInt(cryptonote::get_default_decimal_point());
json.AddMember("default_decimal_point", value2, json.GetAllocator());
value2.SetInt(m_merge_destinations ? 1 :0);
json.AddMember("merge_destinations", value2, json.GetAllocator());
value2.SetInt(m_confirm_backlog ? 1 :0);
json.AddMember("confirm_backlog", value2, json.GetAllocator());
value2.SetUint(m_confirm_backlog_threshold);
json.AddMember("confirm_backlog_threshold", value2, json.GetAllocator());
value2.SetInt(m_confirm_export_overwrite ? 1 :0);
json.AddMember("confirm_export_overwrite", value2, json.GetAllocator());
value2.SetInt(m_auto_low_priority ? 1 : 0);
json.AddMember("auto_low_priority", value2, json.GetAllocator());
value2.SetUint(m_nettype);
json.AddMember("nettype", value2, json.GetAllocator());
value2.SetInt(m_segregate_pre_fork_outputs ? 1 : 0);
json.AddMember("segregate_pre_fork_outputs", value2, json.GetAllocator());
value2.SetInt(m_key_reuse_mitigation2 ? 1 : 0);
json.AddMember("key_reuse_mitigation2", value2, json.GetAllocator());
value2.SetUint(m_segregation_height);
json.AddMember("segregation_height", value2, json.GetAllocator());
value2.SetInt(m_ignore_fractional_outputs ? 1 : 0);
json.AddMember("ignore_fractional_outputs", value2, json.GetAllocator());
value2.SetInt(m_track_uses ? 1 : 0);
json.AddMember("track_uses", value2, json.GetAllocator());
value2.SetInt(m_setup_background_mining);
json.AddMember("setup_background_mining", value2, json.GetAllocator());
value2.SetUint(m_subaddress_lookahead_major);
json.AddMember("subaddress_lookahead_major", value2, json.GetAllocator());
value2.SetUint(m_subaddress_lookahead_minor);
json.AddMember("subaddress_lookahead_minor", value2, json.GetAllocator());
value2.SetInt(m_original_keys_available ? 1 : 0);
json.AddMember("original_keys_available", value2, json.GetAllocator());
value2.SetUint(1);
json.AddMember("encrypted_secret_keys", value2, json.GetAllocator());
value.SetString(m_device_name.c_str(), m_device_name.size());
json.AddMember("device_name", value, json.GetAllocator());
value.SetString(m_device_derivation_path.c_str(), m_device_derivation_path.size());
json.AddMember("device_derivation_path", value, json.GetAllocator());
std::string original_address;
std::string original_view_secret_key;
if (m_original_keys_available)
{
original_address = get_account_address_as_str(m_nettype, false, m_original_address);
value.SetString(original_address.c_str(), original_address.length());
json.AddMember("original_address", value, json.GetAllocator());
original_view_secret_key = epee::string_tools::pod_to_hex(m_original_view_secret_key);
value.SetString(original_view_secret_key.c_str(), original_view_secret_key.length());
json.AddMember("original_view_secret_key", value, json.GetAllocator());
}
// Serialize the JSON object
rapidjson::StringBuffer buffer;
rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
json.Accept(writer);
account_data = buffer.GetString();
// Encrypt the entire JSON object.
std::string cipher;
cipher.resize(account_data.size());
keys_file_data.iv = crypto::rand<crypto::chacha_iv>();
crypto::chacha20(account_data.data(), account_data.size(), key, keys_file_data.iv, &cipher[0]);
keys_file_data.account_data = cipher;
std::string tmp_file_name = keys_file_name + ".new";
std::string buf;
r = ::serialization::dump_binary(keys_file_data, buf);
r = r && epee::file_io_utils::save_string_to_file(tmp_file_name, buf);
CHECK_AND_ASSERT_MES(r, false, "failed to generate wallet keys file " << tmp_file_name);
unlock_keys_file();
std::error_code e = tools::replace_file(tmp_file_name, keys_file_name);
lock_keys_file();
if (e) {
boost::filesystem::remove(tmp_file_name);
LOG_ERROR("failed to update wallet keys file " << keys_file_name);
return false;
}
return true;
}
//----------------------------------------------------------------------------------------------------
void wallet2::setup_keys(const epee::wipeable_string &password)
{
crypto::chacha_key key;
crypto::generate_chacha_key(password.data(), password.size(), key, m_kdf_rounds);
// re-encrypt, but keep viewkey unencrypted
if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only)
{
m_account.encrypt_keys(key);
m_account.decrypt_viewkey(key);
}
static_assert(HASH_SIZE == sizeof(crypto::chacha_key), "Mismatched sizes of hash and chacha key");
epee::mlocked<tools::scrubbed_arr<char, HASH_SIZE+1>> cache_key_data;
memcpy(cache_key_data.data(), &key, HASH_SIZE);
cache_key_data[HASH_SIZE] = CACHE_KEY_TAIL;
cn_fast_hash(cache_key_data.data(), HASH_SIZE+1, (crypto::hash&)m_cache_key);
get_ringdb_key();
}
//----------------------------------------------------------------------------------------------------
void wallet2::change_password(const std::string &filename, const epee::wipeable_string &original_password, const epee::wipeable_string &new_password)
{
if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only)
decrypt_keys(original_password);
setup_keys(new_password);
rewrite(filename, new_password);
if (!filename.empty())
store();
}
//----------------------------------------------------------------------------------------------------
/*!
* \brief Load wallet information from wallet file.
* \param keys_file_name Name of wallet file
* \param password Password of wallet file
*/
bool wallet2::load_keys(const std::string& keys_file_name, const epee::wipeable_string& password)
{
rapidjson::Document json;
wallet2::keys_file_data keys_file_data;
std::string buf;
bool encrypted_secret_keys = false;
bool r = epee::file_io_utils::load_file_to_string(keys_file_name, buf);
THROW_WALLET_EXCEPTION_IF(!r, error::file_read_error, keys_file_name);
// Decrypt the contents
r = ::serialization::parse_binary(buf, keys_file_data);
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "internal error: failed to deserialize \"" + keys_file_name + '\"');
crypto::chacha_key key;
crypto::generate_chacha_key(password.data(), password.size(), key, m_kdf_rounds);
std::string account_data;
account_data.resize(keys_file_data.account_data.size());
crypto::chacha20(keys_file_data.account_data.data(), keys_file_data.account_data.size(), key, keys_file_data.iv, &account_data[0]);
if (json.Parse(account_data.c_str()).HasParseError() || !json.IsObject())
crypto::chacha8(keys_file_data.account_data.data(), keys_file_data.account_data.size(), key, keys_file_data.iv, &account_data[0]);
// The contents should be JSON if the wallet follows the new format.
if (json.Parse(account_data.c_str()).HasParseError())
{
is_old_file_format = true;
m_watch_only = false;
m_multisig = false;
m_multisig_threshold = 0;
m_multisig_signers.clear();
m_multisig_rounds_passed = 0;
m_multisig_derivations.clear();
m_always_confirm_transfers = false;
m_print_ring_members = false;
m_store_tx_info = true;
m_default_mixin = 0;
m_default_priority = 0;
m_auto_refresh = true;
m_refresh_type = RefreshType::RefreshDefault;
m_refresh_from_block_height = 0;
m_confirm_missing_payment_id = true;
m_confirm_non_default_ring_size = true;
m_ask_password = AskPasswordToDecrypt;
cryptonote::set_default_decimal_point(CRYPTONOTE_DISPLAY_DECIMAL_POINT);
m_min_output_count = 0;
m_min_output_value = 0;
m_merge_destinations = false;
m_confirm_backlog = true;
m_confirm_backlog_threshold = 0;
m_confirm_export_overwrite = true;
m_auto_low_priority = true;
m_segregate_pre_fork_outputs = true;
m_key_reuse_mitigation2 = true;
m_segregation_height = 0;
m_ignore_fractional_outputs = true;
m_track_uses = false;
m_setup_background_mining = BackgroundMiningMaybe;
m_subaddress_lookahead_major = SUBADDRESS_LOOKAHEAD_MAJOR;
m_subaddress_lookahead_minor = SUBADDRESS_LOOKAHEAD_MINOR;
m_original_keys_available = false;
m_device_name = "";
m_device_derivation_path = "";
m_key_device_type = hw::device::device_type::SOFTWARE;
encrypted_secret_keys = false;
}
else if(json.IsObject())
{
if (!json.HasMember("key_data"))
{
LOG_ERROR("Field key_data not found in JSON");
return false;
}
if (!json["key_data"].IsString())
{
LOG_ERROR("Field key_data found in JSON, but not String");
return false;
}
const char *field_key_data = json["key_data"].GetString();
account_data = std::string(field_key_data, field_key_data + json["key_data"].GetStringLength());
if (json.HasMember("key_on_device"))
{
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, key_on_device, int, Int, false, hw::device::device_type::SOFTWARE);
m_key_device_type = static_cast<hw::device::device_type>(field_key_on_device);
}
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, seed_language, std::string, String, false, std::string());
if (field_seed_language_found)
{
set_seed_language(field_seed_language);
}
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, watch_only, int, Int, false, false);
m_watch_only = field_watch_only;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, multisig, int, Int, false, false);
m_multisig = field_multisig;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, multisig_threshold, unsigned int, Uint, m_multisig, 0);
m_multisig_threshold = field_multisig_threshold;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, multisig_rounds_passed, unsigned int, Uint, false, 0);
m_multisig_rounds_passed = field_multisig_rounds_passed;
if (m_multisig)
{
if (!json.HasMember("multisig_signers"))
{
LOG_ERROR("Field multisig_signers not found in JSON");
return false;
}
if (!json["multisig_signers"].IsString())
{
LOG_ERROR("Field multisig_signers found in JSON, but not String");
return false;
}
const char *field_multisig_signers = json["multisig_signers"].GetString();
std::string multisig_signers = std::string(field_multisig_signers, field_multisig_signers + json["multisig_signers"].GetStringLength());
r = ::serialization::parse_binary(multisig_signers, m_multisig_signers);
if (!r)
{
LOG_ERROR("Field multisig_signers found in JSON, but failed to parse");
return false;
}
//previous version of multisig does not have this field
if (json.HasMember("multisig_derivations"))
{
if (!json["multisig_derivations"].IsString())
{
LOG_ERROR("Field multisig_derivations found in JSON, but not String");
return false;
}
const char *field_multisig_derivations = json["multisig_derivations"].GetString();
std::string multisig_derivations = std::string(field_multisig_derivations, field_multisig_derivations + json["multisig_derivations"].GetStringLength());
r = ::serialization::parse_binary(multisig_derivations, m_multisig_derivations);
if (!r)
{
LOG_ERROR("Field multisig_derivations found in JSON, but failed to parse");
return false;
}
}
}
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, always_confirm_transfers, int, Int, false, true);
m_always_confirm_transfers = field_always_confirm_transfers;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, print_ring_members, int, Int, false, true);
m_print_ring_members = field_print_ring_members;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, store_tx_keys, int, Int, false, true);
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, store_tx_info, int, Int, false, true);
m_store_tx_info = ((field_store_tx_keys != 0) || (field_store_tx_info != 0));
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, default_mixin, unsigned int, Uint, false, 0);
m_default_mixin = field_default_mixin;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, default_priority, unsigned int, Uint, false, 0);
if (field_default_priority_found)
{
m_default_priority = field_default_priority;
}
else
{
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, default_fee_multiplier, unsigned int, Uint, false, 0);
if (field_default_fee_multiplier_found)
m_default_priority = field_default_fee_multiplier;
else
m_default_priority = 0;
}
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, auto_refresh, int, Int, false, true);
m_auto_refresh = field_auto_refresh;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, refresh_type, int, Int, false, RefreshType::RefreshDefault);
m_refresh_type = RefreshType::RefreshDefault;
if (field_refresh_type_found)
{
if (field_refresh_type == RefreshFull || field_refresh_type == RefreshOptimizeCoinbase || field_refresh_type == RefreshNoCoinbase)
m_refresh_type = (RefreshType)field_refresh_type;
else
LOG_PRINT_L0("Unknown refresh-type value (" << field_refresh_type << "), using default");
}
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, refresh_height, uint64_t, Uint64, false, 0);
m_refresh_from_block_height = field_refresh_height;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, confirm_missing_payment_id, int, Int, false, true);
m_confirm_missing_payment_id = field_confirm_missing_payment_id;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, confirm_non_default_ring_size, int, Int, false, true);
m_confirm_non_default_ring_size = field_confirm_non_default_ring_size;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, ask_password, AskPasswordType, Int, false, AskPasswordToDecrypt);
m_ask_password = field_ask_password;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, default_decimal_point, int, Int, false, CRYPTONOTE_DISPLAY_DECIMAL_POINT);
cryptonote::set_default_decimal_point(field_default_decimal_point);
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, min_output_count, uint32_t, Uint, false, 0);
m_min_output_count = field_min_output_count;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, min_output_value, uint64_t, Uint64, false, 0);
m_min_output_value = field_min_output_value;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, merge_destinations, int, Int, false, false);
m_merge_destinations = field_merge_destinations;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, confirm_backlog, int, Int, false, true);
m_confirm_backlog = field_confirm_backlog;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, confirm_backlog_threshold, uint32_t, Uint, false, 0);
m_confirm_backlog_threshold = field_confirm_backlog_threshold;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, confirm_export_overwrite, int, Int, false, true);
m_confirm_export_overwrite = field_confirm_export_overwrite;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, auto_low_priority, int, Int, false, true);
m_auto_low_priority = field_auto_low_priority;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, nettype, uint8_t, Uint, false, static_cast<uint8_t>(m_nettype));
// The network type given in the program argument is inconsistent with the network type saved in the wallet
THROW_WALLET_EXCEPTION_IF(static_cast<uint8_t>(m_nettype) != field_nettype, error::wallet_internal_error,
(boost::format("%s wallet cannot be opened as %s wallet")
% (field_nettype == 0 ? "Mainnet" : field_nettype == 1 ? "Testnet" : "Stagenet")
% (m_nettype == MAINNET ? "mainnet" : m_nettype == TESTNET ? "testnet" : "stagenet")).str());
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, segregate_pre_fork_outputs, int, Int, false, true);
m_segregate_pre_fork_outputs = field_segregate_pre_fork_outputs;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, key_reuse_mitigation2, int, Int, false, true);
m_key_reuse_mitigation2 = field_key_reuse_mitigation2;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, segregation_height, int, Uint, false, 0);
m_segregation_height = field_segregation_height;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, ignore_fractional_outputs, int, Int, false, true);
m_ignore_fractional_outputs = field_ignore_fractional_outputs;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, track_uses, int, Int, false, false);
m_track_uses = field_track_uses;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, setup_background_mining, BackgroundMiningSetupType, Int, false, BackgroundMiningMaybe);
m_setup_background_mining = field_setup_background_mining;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, subaddress_lookahead_major, uint32_t, Uint, false, SUBADDRESS_LOOKAHEAD_MAJOR);
m_subaddress_lookahead_major = field_subaddress_lookahead_major;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, subaddress_lookahead_minor, uint32_t, Uint, false, SUBADDRESS_LOOKAHEAD_MINOR);
m_subaddress_lookahead_minor = field_subaddress_lookahead_minor;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, encrypted_secret_keys, uint32_t, Uint, false, false);
encrypted_secret_keys = field_encrypted_secret_keys;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, device_name, std::string, String, false, std::string());
if (m_device_name.empty())
{
if (field_device_name_found)
{
m_device_name = field_device_name;
}
else
{
m_device_name = m_key_device_type == hw::device::device_type::LEDGER ? "Ledger" : "default";
}
}
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, device_derivation_path, std::string, String, false, std::string());
m_device_derivation_path = field_device_derivation_path;
if (json.HasMember("original_keys_available"))
{
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, original_keys_available, int, Int, false, false);
m_original_keys_available = field_original_keys_available;
if (m_original_keys_available)
{
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, original_address, std::string, String, true, std::string());
address_parse_info info;
bool ok = get_account_address_from_str(info, m_nettype, field_original_address);
if (!ok)
{
LOG_ERROR("Failed to parse original_address from JSON");
return false;
}
m_original_address = info.address;
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, original_view_secret_key, std::string, String, true, std::string());
ok = epee::string_tools::hex_to_pod(field_original_view_secret_key, m_original_view_secret_key);
if (!ok)
{
LOG_ERROR("Failed to parse original_view_secret_key from JSON");
return false;
}
}
}
else
{
m_original_keys_available = false;
}
}
else
{
THROW_WALLET_EXCEPTION(error::wallet_internal_error, "invalid password");
return false;
}
r = epee::serialization::load_t_from_binary(m_account, account_data);
THROW_WALLET_EXCEPTION_IF(!r, error::invalid_password);
if (m_key_device_type == hw::device::device_type::LEDGER || m_key_device_type == hw::device::device_type::TREZOR) {
LOG_PRINT_L0("Account on device. Initing device...");
hw::device &hwdev = lookup_device(m_device_name);
THROW_WALLET_EXCEPTION_IF(!hwdev.set_name(m_device_name), error::wallet_internal_error, "Could not set device name " + m_device_name);
hwdev.set_network_type(m_nettype);
hwdev.set_derivation_path(m_device_derivation_path);
hwdev.set_callback(get_device_callback());
THROW_WALLET_EXCEPTION_IF(!hwdev.init(), error::wallet_internal_error, "Could not initialize the device " + m_device_name);
THROW_WALLET_EXCEPTION_IF(!hwdev.connect(), error::wallet_internal_error, "Could not connect to the device " + m_device_name);
m_account.set_device(hwdev);
account_public_address device_account_public_address;
THROW_WALLET_EXCEPTION_IF(!hwdev.get_public_address(device_account_public_address), error::wallet_internal_error, "Cannot get a device address");
THROW_WALLET_EXCEPTION_IF(device_account_public_address != m_account.get_keys().m_account_address, error::wallet_internal_error, "Device wallet does not match wallet address. "
"Device address: " + cryptonote::get_account_address_as_str(m_nettype, false, device_account_public_address) +
", wallet address: " + m_account.get_public_address_str(m_nettype));
LOG_PRINT_L0("Device inited...");
} else if (key_on_device()) {
THROW_WALLET_EXCEPTION(error::wallet_internal_error, "hardware device not supported");
}
if (r)
{
if (encrypted_secret_keys)
{
m_account.decrypt_keys(key);
}
else
{
// rewrite with encrypted keys, ignore errors
if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only)
encrypt_keys(key);
bool saved_ret = store_keys(keys_file_name, password, m_watch_only);
if (!saved_ret)
{
// just moan a bit, but not fatal
MERROR("Error saving keys file with encrypted keys, not fatal");
}
if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only)
decrypt_keys(key);
m_keys_file_locker.reset();
}
}
const cryptonote::account_keys& keys = m_account.get_keys();
hw::device &hwdev = m_account.get_device();
r = r && hwdev.verify_keys(keys.m_view_secret_key, keys.m_account_address.m_view_public_key);
if(!m_watch_only && !m_multisig && hwdev.device_protocol() != hw::device::PROTOCOL_COLD)
r = r && hwdev.verify_keys(keys.m_spend_secret_key, keys.m_account_address.m_spend_public_key);
THROW_WALLET_EXCEPTION_IF(!r, error::invalid_password);
if (r)
setup_keys(password);
return true;
}
/*!
* \brief verify password for default wallet keys file.
* \param password Password to verify
* \return true if password is correct
*
* for verification only
* should not mutate state, unlike load_keys()
* can be used prior to rewriting wallet keys file, to ensure user has entered the correct password
*
*/
bool wallet2::verify_password(const epee::wipeable_string& password)
{
// this temporary unlocking is necessary for Windows (otherwise the file couldn't be loaded).
unlock_keys_file();
bool r = verify_password(m_keys_file, password, m_account.get_device().device_protocol() == hw::device::PROTOCOL_COLD || m_watch_only || m_multisig, m_account.get_device(), m_kdf_rounds);
lock_keys_file();
return r;
}
/*!
* \brief verify password for specified wallet keys file.
* \param keys_file_name Keys file to verify password for
* \param password Password to verify
* \param no_spend_key If set = only verify view keys, otherwise also spend keys
* \param hwdev The hardware device to use
* \return true if password is correct
*
* for verification only
* should not mutate state, unlike load_keys()
* can be used prior to rewriting wallet keys file, to ensure user has entered the correct password
*
*/
bool wallet2::verify_password(const std::string& keys_file_name, const epee::wipeable_string& password, bool no_spend_key, hw::device &hwdev, uint64_t kdf_rounds)
{
rapidjson::Document json;
wallet2::keys_file_data keys_file_data;
std::string buf;
bool encrypted_secret_keys = false;
bool r = epee::file_io_utils::load_file_to_string(keys_file_name, buf);
THROW_WALLET_EXCEPTION_IF(!r, error::file_read_error, keys_file_name);
// Decrypt the contents
r = ::serialization::parse_binary(buf, keys_file_data);
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "internal error: failed to deserialize \"" + keys_file_name + '\"');
crypto::chacha_key key;
crypto::generate_chacha_key(password.data(), password.size(), key, kdf_rounds);
std::string account_data;
account_data.resize(keys_file_data.account_data.size());
crypto::chacha20(keys_file_data.account_data.data(), keys_file_data.account_data.size(), key, keys_file_data.iv, &account_data[0]);
if (json.Parse(account_data.c_str()).HasParseError() || !json.IsObject())
crypto::chacha8(keys_file_data.account_data.data(), keys_file_data.account_data.size(), key, keys_file_data.iv, &account_data[0]);
// The contents should be JSON if the wallet follows the new format.
if (json.Parse(account_data.c_str()).HasParseError())
{
// old format before JSON wallet key file format
}
else
{
account_data = std::string(json["key_data"].GetString(), json["key_data"].GetString() +
json["key_data"].GetStringLength());
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, encrypted_secret_keys, uint32_t, Uint, false, false);
encrypted_secret_keys = field_encrypted_secret_keys;
}
cryptonote::account_base account_data_check;
r = epee::serialization::load_t_from_binary(account_data_check, account_data);
if (encrypted_secret_keys)
account_data_check.decrypt_keys(key);
const cryptonote::account_keys& keys = account_data_check.get_keys();
r = r && hwdev.verify_keys(keys.m_view_secret_key, keys.m_account_address.m_view_public_key);
if(!no_spend_key)
r = r && hwdev.verify_keys(keys.m_spend_secret_key, keys.m_account_address.m_spend_public_key);
return r;
}
void wallet2::encrypt_keys(const crypto::chacha_key &key)
{
m_account.encrypt_keys(key);
m_account.decrypt_viewkey(key);
}
void wallet2::decrypt_keys(const crypto::chacha_key &key)
{
m_account.encrypt_viewkey(key);
m_account.decrypt_keys(key);
}
void wallet2::encrypt_keys(const epee::wipeable_string &password)
{
crypto::chacha_key key;
crypto::generate_chacha_key(password.data(), password.size(), key, m_kdf_rounds);
encrypt_keys(key);
}
void wallet2::decrypt_keys(const epee::wipeable_string &password)
{
crypto::chacha_key key;
crypto::generate_chacha_key(password.data(), password.size(), key, m_kdf_rounds);
decrypt_keys(key);
}
void wallet2::setup_new_blockchain()
{
cryptonote::block b;
generate_genesis(b);
m_blockchain.push_back(get_block_hash(b));
m_last_block_reward = cryptonote::get_outs_money_amount(b.miner_tx);
add_subaddress_account(tr("Primary account"));
}
void wallet2::create_keys_file(const std::string &wallet_, bool watch_only, const epee::wipeable_string &password, bool create_address_file)
{
if (!wallet_.empty())
{
bool r = store_keys(m_keys_file, password, watch_only);
THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_keys_file);
if (create_address_file)
{
r = file_io_utils::save_string_to_file(m_wallet_file + ".address.txt", m_account.get_public_address_str(m_nettype));
if(!r) MERROR("String with address text not saved");
}
}
}
/*!
* \brief determine the key storage for the specified wallet file
* \param device_type (OUT) wallet backend as enumerated in hw::device::device_type
* \param keys_file_name Keys file to verify password for
* \param password Password to verify
* \return true if password correct, else false
*
* for verification only - determines key storage hardware
*
*/
bool wallet2::query_device(hw::device::device_type& device_type, const std::string& keys_file_name, const epee::wipeable_string& password, uint64_t kdf_rounds)
{
rapidjson::Document json;
wallet2::keys_file_data keys_file_data;
std::string buf;
bool r = epee::file_io_utils::load_file_to_string(keys_file_name, buf);
THROW_WALLET_EXCEPTION_IF(!r, error::file_read_error, keys_file_name);
// Decrypt the contents
r = ::serialization::parse_binary(buf, keys_file_data);
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "internal error: failed to deserialize \"" + keys_file_name + '\"');
crypto::chacha_key key;
crypto::generate_chacha_key(password.data(), password.size(), key, kdf_rounds);
std::string account_data;
account_data.resize(keys_file_data.account_data.size());
crypto::chacha20(keys_file_data.account_data.data(), keys_file_data.account_data.size(), key, keys_file_data.iv, &account_data[0]);
if (json.Parse(account_data.c_str()).HasParseError() || !json.IsObject())
crypto::chacha8(keys_file_data.account_data.data(), keys_file_data.account_data.size(), key, keys_file_data.iv, &account_data[0]);
device_type = hw::device::device_type::SOFTWARE;
// The contents should be JSON if the wallet follows the new format.
if (json.Parse(account_data.c_str()).HasParseError())
{
// old format before JSON wallet key file format
}
else
{
account_data = std::string(json["key_data"].GetString(), json["key_data"].GetString() +
json["key_data"].GetStringLength());
if (json.HasMember("key_on_device"))
{
GET_FIELD_FROM_JSON_RETURN_ON_ERROR(json, key_on_device, int, Int, false, hw::device::device_type::SOFTWARE);
device_type = static_cast<hw::device::device_type>(field_key_on_device);
}
}
cryptonote::account_base account_data_check;
r = epee::serialization::load_t_from_binary(account_data_check, account_data);
if (!r) return false;
return true;
}
void wallet2::init_type(hw::device::device_type device_type)
{
m_account_public_address = m_account.get_keys().m_account_address;
m_watch_only = false;
m_multisig = false;
m_multisig_threshold = 0;
m_multisig_signers.clear();
m_original_keys_available = false;
m_key_device_type = device_type;
}
/*!
* \brief Generates a wallet or restores one.
* \param wallet_ Name of wallet file
* \param password Password of wallet file
* \param multisig_data The multisig restore info and keys
* \param create_address_file Whether to create an address file
*/
void wallet2::generate(const std::string& wallet_, const epee::wipeable_string& password,
const epee::wipeable_string& multisig_data, bool create_address_file)
{
clear();
prepare_file_names(wallet_);
if (!wallet_.empty())
{
boost::system::error_code ignored_ec;
THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_keys_file, ignored_ec), error::file_exists, m_keys_file);
}
m_account.generate(rct::rct2sk(rct::zero()), true, false);
THROW_WALLET_EXCEPTION_IF(multisig_data.size() < 32, error::invalid_multisig_seed);
size_t offset = 0;
uint32_t threshold = *(uint32_t*)(multisig_data.data() + offset);
offset += sizeof(uint32_t);
uint32_t total = *(uint32_t*)(multisig_data.data() + offset);
offset += sizeof(uint32_t);
THROW_WALLET_EXCEPTION_IF(threshold < 2, error::invalid_multisig_seed);
THROW_WALLET_EXCEPTION_IF(total != threshold && total != threshold + 1, error::invalid_multisig_seed);
const size_t n_multisig_keys = total == threshold ? 1 : threshold;
THROW_WALLET_EXCEPTION_IF(multisig_data.size() != 8 + 32 * (4 + n_multisig_keys + total), error::invalid_multisig_seed);
std::vector<crypto::secret_key> multisig_keys;
std::vector<crypto::public_key> multisig_signers;
crypto::secret_key spend_secret_key = *(crypto::secret_key*)(multisig_data.data() + offset);
offset += sizeof(crypto::secret_key);
crypto::public_key spend_public_key = *(crypto::public_key*)(multisig_data.data() + offset);
offset += sizeof(crypto::public_key);
crypto::secret_key view_secret_key = *(crypto::secret_key*)(multisig_data.data() + offset);
offset += sizeof(crypto::secret_key);
crypto::public_key view_public_key = *(crypto::public_key*)(multisig_data.data() + offset);
offset += sizeof(crypto::public_key);
for (size_t n = 0; n < n_multisig_keys; ++n)
{
multisig_keys.push_back(*(crypto::secret_key*)(multisig_data.data() + offset));
offset += sizeof(crypto::secret_key);
}
for (size_t n = 0; n < total; ++n)
{
multisig_signers.push_back(*(crypto::public_key*)(multisig_data.data() + offset));
offset += sizeof(crypto::public_key);
}
crypto::public_key calculated_view_public_key;
THROW_WALLET_EXCEPTION_IF(!crypto::secret_key_to_public_key(view_secret_key, calculated_view_public_key), error::invalid_multisig_seed);
THROW_WALLET_EXCEPTION_IF(view_public_key != calculated_view_public_key, error::invalid_multisig_seed);
crypto::public_key local_signer;
THROW_WALLET_EXCEPTION_IF(!crypto::secret_key_to_public_key(spend_secret_key, local_signer), error::invalid_multisig_seed);
THROW_WALLET_EXCEPTION_IF(std::find(multisig_signers.begin(), multisig_signers.end(), local_signer) == multisig_signers.end(), error::invalid_multisig_seed);
rct::key skey = rct::zero();
for (const auto &msk: multisig_keys)
sc_add(skey.bytes, skey.bytes, rct::sk2rct(msk).bytes);
THROW_WALLET_EXCEPTION_IF(!(rct::rct2sk(skey) == spend_secret_key), error::invalid_multisig_seed);
memwipe(&skey, sizeof(rct::key));
m_account.make_multisig(view_secret_key, spend_secret_key, spend_public_key, multisig_keys);
m_account.finalize_multisig(spend_public_key);
// Not possible to restore a multisig wallet that is able to activate the MMS
// (because the original keys are not (yet) part of the restore info), so
// keep m_original_keys_available to false
init_type(hw::device::device_type::SOFTWARE);
m_multisig = true;
m_multisig_threshold = threshold;
m_multisig_signers = multisig_signers;
setup_keys(password);
create_keys_file(wallet_, false, password, m_nettype != MAINNET || create_address_file);
setup_new_blockchain();
if (!wallet_.empty())
store();
}
/*!
* \brief Generates a wallet or restores one.
* \param wallet_ Name of wallet file
* \param password Password of wallet file
* \param recovery_param If it is a restore, the recovery key
* \param recover Whether it is a restore
* \param two_random Whether it is a non-deterministic wallet
* \param create_address_file Whether to create an address file
* \return The secret key of the generated wallet
*/
crypto::secret_key wallet2::generate(const std::string& wallet_, const epee::wipeable_string& password,
const crypto::secret_key& recovery_param, bool recover, bool two_random, bool create_address_file)
{
clear();
prepare_file_names(wallet_);
if (!wallet_.empty())
{
boost::system::error_code ignored_ec;
THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_keys_file, ignored_ec), error::file_exists, m_keys_file);
}
crypto::secret_key retval = m_account.generate(recovery_param, recover, two_random);
init_type(hw::device::device_type::SOFTWARE);
setup_keys(password);
// calculate a starting refresh height
if(m_refresh_from_block_height == 0 && !recover){
m_refresh_from_block_height = estimate_blockchain_height();
}
create_keys_file(wallet_, false, password, m_nettype != MAINNET || create_address_file);
setup_new_blockchain();
if (!wallet_.empty())
store();
return retval;
}
uint64_t wallet2::estimate_blockchain_height()
{
// -1 month for fluctuations in block time and machine date/time setup.
// avg seconds per block
const int seconds_per_block = DIFFICULTY_TARGET_V2;
// ~num blocks per month
const uint64_t blocks_per_month = 60*60*24*30/seconds_per_block;
// try asking the daemon first
std::string err;
uint64_t height = 0;
// we get the max of approximated height and local height.
// approximated height is the least of daemon target height
// (the max of what the other daemons are claiming is their
// height) and the theoretical height based on the local
// clock. This will be wrong only if both the local clock
// is bad *and* a peer daemon claims a highest height than
// the real chain.
// local height is the height the local daemon is currently
// synced to, it will be lower than the real chain height if
// the daemon is currently syncing.
// If we use the approximate height we subtract one month as
// a safety margin.
height = get_approximate_blockchain_height();
uint64_t target_height = get_daemon_blockchain_target_height(err);
if (err.empty()) {
if (target_height < height)
height = target_height;
} else {
// if we couldn't talk to the daemon, check safety margin.
if (height > blocks_per_month)
height -= blocks_per_month;
else
height = 0;
}
uint64_t local_height = get_daemon_blockchain_height(err);
if (err.empty() && local_height > height)
height = local_height;
return height;
}
/*!
* \brief Creates a watch only wallet from a public address and a view secret key.
* \param wallet_ Name of wallet file
* \param password Password of wallet file
* \param account_public_address The account's public address
* \param viewkey view secret key
* \param create_address_file Whether to create an address file
*/
void wallet2::generate(const std::string& wallet_, const epee::wipeable_string& password,
const cryptonote::account_public_address &account_public_address,
const crypto::secret_key& viewkey, bool create_address_file)
{
clear();
prepare_file_names(wallet_);
if (!wallet_.empty())
{
boost::system::error_code ignored_ec;
THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_keys_file, ignored_ec), error::file_exists, m_keys_file);
}
m_account.create_from_viewkey(account_public_address, viewkey);
init_type(hw::device::device_type::SOFTWARE);
m_watch_only = true;
m_account_public_address = account_public_address;
setup_keys(password);
create_keys_file(wallet_, true, password, m_nettype != MAINNET || create_address_file);
setup_new_blockchain();
if (!wallet_.empty())
store();
}
/*!
* \brief Creates a wallet from a public address and a spend/view secret key pair.
* \param wallet_ Name of wallet file
* \param password Password of wallet file
* \param account_public_address The account's public address
* \param spendkey spend secret key
* \param viewkey view secret key
* \param create_address_file Whether to create an address file
*/
void wallet2::generate(const std::string& wallet_, const epee::wipeable_string& password,
const cryptonote::account_public_address &account_public_address,
const crypto::secret_key& spendkey, const crypto::secret_key& viewkey, bool create_address_file)
{
clear();
prepare_file_names(wallet_);
if (!wallet_.empty())
{
boost::system::error_code ignored_ec;
THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_keys_file, ignored_ec), error::file_exists, m_keys_file);
}
m_account.create_from_keys(account_public_address, spendkey, viewkey);
init_type(hw::device::device_type::SOFTWARE);
m_account_public_address = account_public_address;
setup_keys(password);
create_keys_file(wallet_, false, password, create_address_file);
setup_new_blockchain();
if (!wallet_.empty())
store();
}
/*!
* \brief Creates a wallet from a device
* \param wallet_ Name of wallet file
* \param password Password of wallet file
* \param device_name device string address
*/
void wallet2::restore(const std::string& wallet_, const epee::wipeable_string& password, const std::string &device_name, bool create_address_file)
{
clear();
prepare_file_names(wallet_);
boost::system::error_code ignored_ec;
if (!wallet_.empty()) {
THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_wallet_file, ignored_ec), error::file_exists, m_wallet_file);
THROW_WALLET_EXCEPTION_IF(boost::filesystem::exists(m_keys_file, ignored_ec), error::file_exists, m_keys_file);
}
auto &hwdev = lookup_device(device_name);
hwdev.set_name(device_name);
hwdev.set_network_type(m_nettype);
hwdev.set_derivation_path(m_device_derivation_path);
hwdev.set_callback(get_device_callback());
m_account.create_from_device(hwdev);
init_type(m_account.get_device().get_type());
setup_keys(password);
m_device_name = device_name;
create_keys_file(wallet_, false, password, m_nettype != MAINNET || create_address_file);
if (m_subaddress_lookahead_major == SUBADDRESS_LOOKAHEAD_MAJOR && m_subaddress_lookahead_minor == SUBADDRESS_LOOKAHEAD_MINOR)
{
// the default lookahead setting (50:200) is clearly too much for hardware wallet
m_subaddress_lookahead_major = 5;
m_subaddress_lookahead_minor = 20;
}
setup_new_blockchain();
if (!wallet_.empty()) {
store();
}
}
std::string wallet2::make_multisig(const epee::wipeable_string &password,
const std::vector<crypto::secret_key> &view_keys,
const std::vector<crypto::public_key> &spend_keys,
uint32_t threshold)
{
CHECK_AND_ASSERT_THROW_MES(!view_keys.empty(), "empty view keys");
CHECK_AND_ASSERT_THROW_MES(view_keys.size() == spend_keys.size(), "Mismatched view/spend key sizes");
CHECK_AND_ASSERT_THROW_MES(threshold > 1 && threshold <= spend_keys.size() + 1, "Invalid threshold");
std::string extra_multisig_info;
std::vector<crypto::secret_key> multisig_keys;
rct::key spend_pkey = rct::identity();
rct::key spend_skey;
std::vector<crypto::public_key> multisig_signers;
// decrypt keys
epee::misc_utils::auto_scope_leave_caller keys_reencryptor;
if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only)
{
crypto::chacha_key chacha_key;
crypto::generate_chacha_key(password.data(), password.size(), chacha_key, m_kdf_rounds);
m_account.encrypt_viewkey(chacha_key);
m_account.decrypt_keys(chacha_key);
keys_reencryptor = epee::misc_utils::create_scope_leave_handler([&, this, chacha_key]() { m_account.encrypt_keys(chacha_key); m_account.decrypt_viewkey(chacha_key); });
}
// In common multisig scheme there are 4 types of key exchange rounds:
// 1. First round is exchange of view secret keys and public spend keys.
// 2. Middle round is exchange of derivations: Ki = b * Mj, where b - spend secret key,
// M - public multisig key (in first round it equals to public spend key), K - new public multisig key.
// 3. Secret spend establishment round sets your secret multisig keys as follows: kl = H(Ml), where M - is *your* public multisig key,
// k - secret multisig key used to sign transactions. k and M are sets of keys, of course.
// And secret spend key as the sum of all participant's secret multisig keys
// 4. Last round establishes multisig wallet's public spend key. Participants exchange their public multisig keys
// and calculate common spend public key as sum of all unique participants' public multisig keys.
// Note that N/N scheme has only first round. N-1/N has 2 rounds: first and last. Common M/N has all 4 rounds.
// IMPORTANT: wallet's public spend key is not equal to secret_spend_key * G!
// Wallet's public spend key is the sum of unique public multisig keys of all participants.
// secret_spend_key * G = public signer key
if (threshold == spend_keys.size() + 1)
{
// In N / N case we only need to do one round and calculate secret multisig keys and new secret spend key
MINFO("Creating spend key...");
// Calculates all multisig keys and spend key
cryptonote::generate_multisig_N_N(get_account().get_keys(), spend_keys, multisig_keys, spend_skey, spend_pkey);
// Our signer key is b * G, where b is secret spend key.
multisig_signers = spend_keys;
multisig_signers.push_back(get_multisig_signer_public_key(get_account().get_keys().m_spend_secret_key));
}
else
{
// We just got public spend keys of all participants and deriving multisig keys (set of Mi = b * Bi).
// note that derivations are public keys as DH exchange suppose it to be
auto derivations = cryptonote::generate_multisig_derivations(get_account().get_keys(), spend_keys);
spend_pkey = rct::identity();
multisig_signers = std::vector<crypto::public_key>(spend_keys.size() + 1, crypto::null_pkey);
if (threshold == spend_keys.size())
{
// N - 1 / N case
// We need an extra step, so we package all the composite public keys
// we know about, and make a signed string out of them
MINFO("Creating spend key...");
// Calculating set of our secret multisig keys as follows: mi = H(Mi),
// where mi - secret multisig key, Mi - others' participants public multisig key
multisig_keys = cryptonote::calculate_multisig_keys(derivations);
// calculating current participant's spend secret key as sum of all secret multisig keys for current participant.
// IMPORTANT: participant's secret spend key is not an entire wallet's secret spend!
// Entire wallet's secret spend is sum of all unique secret multisig keys
// among all of participants and is not held by anyone!
spend_skey = rct::sk2rct(cryptonote::calculate_multisig_signer_key(multisig_keys));
// Preparing data for the last round to calculate common public spend key. The data contains public multisig keys.
extra_multisig_info = pack_multisignature_keys(MULTISIG_EXTRA_INFO_MAGIC, secret_keys_to_public_keys(multisig_keys), rct::rct2sk(spend_skey));
}
else
{
// M / N case
MINFO("Preparing keys for next exchange round...");
// Preparing data for middle round - packing new public multisig keys to exchage with others.
extra_multisig_info = pack_multisignature_keys(MULTISIG_EXTRA_INFO_MAGIC, derivations, m_account.get_keys().m_spend_secret_key);
spend_skey = rct::sk2rct(m_account.get_keys().m_spend_secret_key);
// Need to store middle keys to be able to proceed in case of wallet shutdown.
m_multisig_derivations = derivations;
}
}
if (!m_original_keys_available)
{
// Save the original i.e. non-multisig keys so the MMS can continue to use them to encrypt and decrypt messages
// (making a wallet multisig overwrites those keys, see account_base::make_multisig)
m_original_address = m_account.get_keys().m_account_address;
m_original_view_secret_key = m_account.get_keys().m_view_secret_key;
m_original_keys_available = true;
}
clear();
MINFO("Creating view key...");
crypto::secret_key view_skey = cryptonote::generate_multisig_view_secret_key(get_account().get_keys().m_view_secret_key, view_keys);
MINFO("Creating multisig address...");
CHECK_AND_ASSERT_THROW_MES(m_account.make_multisig(view_skey, rct::rct2sk(spend_skey), rct::rct2pk(spend_pkey), multisig_keys),
"Failed to create multisig wallet due to bad keys");
memwipe(&spend_skey, sizeof(rct::key));
init_type(hw::device::device_type::SOFTWARE);
m_original_keys_available = true;
m_multisig = true;
m_multisig_threshold = threshold;
m_multisig_signers = multisig_signers;
++m_multisig_rounds_passed;
// re-encrypt keys
keys_reencryptor = epee::misc_utils::auto_scope_leave_caller();
create_keys_file(m_wallet_file, false, password, boost::filesystem::exists(m_wallet_file + ".address.txt"));
setup_new_blockchain();
if (!m_wallet_file.empty())
store();
return extra_multisig_info;
}
std::string wallet2::exchange_multisig_keys(const epee::wipeable_string &password,
const std::vector<std::string> &info)
{
THROW_WALLET_EXCEPTION_IF(info.empty(),
error::wallet_internal_error, "Empty multisig info");
if (info[0].substr(0, MULTISIG_EXTRA_INFO_MAGIC.size()) != MULTISIG_EXTRA_INFO_MAGIC)
{
THROW_WALLET_EXCEPTION(
error::wallet_internal_error, "Unsupported info string");
}
std::vector<crypto::public_key> signers;
std::unordered_set<crypto::public_key> pkeys;
THROW_WALLET_EXCEPTION_IF(!unpack_extra_multisig_info(info, signers, pkeys),
error::wallet_internal_error, "Bad extra multisig info");
return exchange_multisig_keys(password, pkeys, signers);
}
std::string wallet2::exchange_multisig_keys(const epee::wipeable_string &password,
std::unordered_set<crypto::public_key> derivations,
std::vector<crypto::public_key> signers)
{
CHECK_AND_ASSERT_THROW_MES(!derivations.empty(), "empty pkeys");
CHECK_AND_ASSERT_THROW_MES(!signers.empty(), "empty signers");
bool ready = false;
CHECK_AND_ASSERT_THROW_MES(multisig(&ready), "The wallet is not multisig");
CHECK_AND_ASSERT_THROW_MES(!ready, "Multisig wallet creation process has already been finished");
// keys are decrypted
epee::misc_utils::auto_scope_leave_caller keys_reencryptor;
if (m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only)
{
crypto::chacha_key chacha_key;
crypto::generate_chacha_key(password.data(), password.size(), chacha_key, m_kdf_rounds);
m_account.encrypt_viewkey(chacha_key);
m_account.decrypt_keys(chacha_key);
keys_reencryptor = epee::misc_utils::create_scope_leave_handler([&, this, chacha_key]() { m_account.encrypt_keys(chacha_key); m_account.decrypt_viewkey(chacha_key); });
}
if (m_multisig_rounds_passed == multisig_rounds_required(m_multisig_signers.size(), m_multisig_threshold) - 1)
{
// the last round is passed and we have to calculate spend public key
// add ours if not included
crypto::public_key local_signer = get_multisig_signer_public_key();
if (std::find(signers.begin(), signers.end(), local_signer) == signers.end())
{
signers.push_back(local_signer);
for (const auto &msk: get_account().get_multisig_keys())
{
derivations.insert(rct::rct2pk(rct::scalarmultBase(rct::sk2rct(msk))));
}
}
CHECK_AND_ASSERT_THROW_MES(signers.size() == m_multisig_signers.size(), "Bad signers size");
// Summing all of unique public multisig keys to calculate common public spend key
crypto::public_key spend_public_key = cryptonote::generate_multisig_M_N_spend_public_key(std::vector<crypto::public_key>(derivations.begin(), derivations.end()));
m_account_public_address.m_spend_public_key = spend_public_key;
m_account.finalize_multisig(spend_public_key);
m_multisig_signers = signers;
std::sort(m_multisig_signers.begin(), m_multisig_signers.end(), [](const crypto::public_key &e0, const crypto::public_key &e1){ return memcmp(&e0, &e1, sizeof(e0)); });
++m_multisig_rounds_passed;
m_multisig_derivations.clear();
// keys are encrypted again
keys_reencryptor = epee::misc_utils::auto_scope_leave_caller();
if (!m_wallet_file.empty())
{
bool r = store_keys(m_keys_file, password, false);
THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_keys_file);
if (boost::filesystem::exists(m_wallet_file + ".address.txt"))
{
r = file_io_utils::save_string_to_file(m_wallet_file + ".address.txt", m_account.get_public_address_str(m_nettype));
if(!r) MERROR("String with address text not saved");
}
}
m_subaddresses.clear();
m_subaddress_labels.clear();
add_subaddress_account(tr("Primary account"));
if (!m_wallet_file.empty())
store();
return {};
}
// Below are either middle or secret spend key establishment rounds
for (const auto& key: m_multisig_derivations)
derivations.erase(key);
// Deriving multisig keys (set of Mi = b * Bi) according to DH from other participants' multisig keys.
auto new_derivations = cryptonote::generate_multisig_derivations(get_account().get_keys(), std::vector<crypto::public_key>(derivations.begin(), derivations.end()));
std::string extra_multisig_info;
if (m_multisig_rounds_passed == multisig_rounds_required(m_multisig_signers.size(), m_multisig_threshold) - 2) // next round is last
{
// Next round is last therefore we are performing secret spend establishment round as described above.
MINFO("Creating spend key...");
// Calculating our secret multisig keys by hashing our public multisig keys.
auto multisig_keys = cryptonote::calculate_multisig_keys(std::vector<crypto::public_key>(new_derivations.begin(), new_derivations.end()));
// And summing it to get personal secret spend key
crypto::secret_key spend_skey = cryptonote::calculate_multisig_signer_key(multisig_keys);
m_account.make_multisig(m_account.get_keys().m_view_secret_key, spend_skey, rct::rct2pk(rct::identity()), multisig_keys);
// Packing public multisig keys to exchange with others and calculate common public spend key in the last round
extra_multisig_info = pack_multisignature_keys(MULTISIG_EXTRA_INFO_MAGIC, secret_keys_to_public_keys(multisig_keys), spend_skey);
}
else
{
// This is just middle round
MINFO("Preparing keys for next exchange round...");
extra_multisig_info = pack_multisignature_keys(MULTISIG_EXTRA_INFO_MAGIC, new_derivations, m_account.get_keys().m_spend_secret_key);
m_multisig_derivations = new_derivations;
}
++m_multisig_rounds_passed;
create_keys_file(m_wallet_file, false, password, boost::filesystem::exists(m_wallet_file + ".address.txt"));
return extra_multisig_info;
}
void wallet2::unpack_multisig_info(const std::vector<std::string>& info,
std::vector<crypto::public_key> &public_keys,
std::vector<crypto::secret_key> &secret_keys) const
{
// parse all multisig info
public_keys.resize(info.size());
secret_keys.resize(info.size());
for (size_t i = 0; i < info.size(); ++i)
{
THROW_WALLET_EXCEPTION_IF(!verify_multisig_info(info[i], secret_keys[i], public_keys[i]),
error::wallet_internal_error, "Bad multisig info: " + info[i]);
}
// remove duplicates
for (size_t i = 0; i < secret_keys.size(); ++i)
{
for (size_t j = i + 1; j < secret_keys.size(); ++j)
{
if (rct::sk2rct(secret_keys[i]) == rct::sk2rct(secret_keys[j]))
{
MDEBUG("Duplicate key found, ignoring");
secret_keys[j] = secret_keys.back();
public_keys[j] = public_keys.back();
secret_keys.pop_back();
public_keys.pop_back();
--j;
}
}
}
// people may include their own, weed it out
const crypto::secret_key local_skey = cryptonote::get_multisig_blinded_secret_key(get_account().get_keys().m_view_secret_key);
const crypto::public_key local_pkey = get_multisig_signer_public_key(get_account().get_keys().m_spend_secret_key);
for (size_t i = 0; i < secret_keys.size(); ++i)
{
if (secret_keys[i] == local_skey)
{
MDEBUG("Local key is present, ignoring");
secret_keys[i] = secret_keys.back();
public_keys[i] = public_keys.back();
secret_keys.pop_back();
public_keys.pop_back();
--i;
}
else
{
THROW_WALLET_EXCEPTION_IF(public_keys[i] == local_pkey, error::wallet_internal_error,
"Found local spend public key, but not local view secret key - something very weird");
}
}
}
std::string wallet2::make_multisig(const epee::wipeable_string &password,
const std::vector<std::string> &info,
uint32_t threshold)
{
std::vector<crypto::secret_key> secret_keys(info.size());
std::vector<crypto::public_key> public_keys(info.size());
unpack_multisig_info(info, public_keys, secret_keys);
return make_multisig(password, secret_keys, public_keys, threshold);
}
bool wallet2::finalize_multisig(const epee::wipeable_string &password, const std::unordered_set<crypto::public_key> &pkeys, std::vector<crypto::public_key> signers)
{
bool ready;
uint32_t threshold, total;
if (!multisig(&ready, &threshold, &total))
{
MERROR("This is not a multisig wallet");
return false;
}
if (ready)
{
MERROR("This multisig wallet is already finalized");
return false;
}
if (threshold + 1 != total)
{
MERROR("finalize_multisig should only be used for N-1/N wallets, use exchange_multisig_keys instead");
return false;
}
exchange_multisig_keys(password, pkeys, signers);
return true;
}
bool wallet2::unpack_extra_multisig_info(const std::vector<std::string>& info,
std::vector<crypto::public_key> &signers,
std::unordered_set<crypto::public_key> &pkeys) const
{
// parse all multisig info
signers.resize(info.size(), crypto::null_pkey);
for (size_t i = 0; i < info.size(); ++i)
{
if (!verify_extra_multisig_info(info[i], pkeys, signers[i]))
{
return false;
}
}
return true;
}
bool wallet2::finalize_multisig(const epee::wipeable_string &password, const std::vector<std::string> &info)
{
std::unordered_set<crypto::public_key> public_keys;
std::vector<crypto::public_key> signers;
if (!unpack_extra_multisig_info(info, signers, public_keys))
{
MERROR("Bad multisig info");
return false;
}
return finalize_multisig(password, public_keys, signers);
}
std::string wallet2::get_multisig_info() const
{
// It's a signed package of private view key and public spend key
const crypto::secret_key skey = cryptonote::get_multisig_blinded_secret_key(get_account().get_keys().m_view_secret_key);
const crypto::public_key pkey = get_multisig_signer_public_key(get_account().get_keys().m_spend_secret_key);
crypto::hash hash;
std::string data;
data += std::string((const char *)&skey, sizeof(crypto::secret_key));
data += std::string((const char *)&pkey, sizeof(crypto::public_key));
data.resize(data.size() + sizeof(crypto::signature));
crypto::cn_fast_hash(data.data(), data.size() - sizeof(signature), hash);
crypto::signature &signature = *(crypto::signature*)&data[data.size() - sizeof(crypto::signature)];
crypto::generate_signature(hash, pkey, get_multisig_blinded_secret_key(get_account().get_keys().m_spend_secret_key), signature);
return std::string("MultisigV1") + tools::base58::encode(data);
}
bool wallet2::verify_multisig_info(const std::string &data, crypto::secret_key &skey, crypto::public_key &pkey)
{
const size_t header_len = strlen("MultisigV1");
if (data.size() < header_len || data.substr(0, header_len) != "MultisigV1")
{
MERROR("Multisig info header check error");
return false;
}
std::string decoded;
if (!tools::base58::decode(data.substr(header_len), decoded))
{
MERROR("Multisig info decoding error");
return false;
}
if (decoded.size() != sizeof(crypto::secret_key) + sizeof(crypto::public_key) + sizeof(crypto::signature))
{
MERROR("Multisig info is corrupt");
return false;
}
size_t offset = 0;
skey = *(const crypto::secret_key*)(decoded.data() + offset);
offset += sizeof(skey);
pkey = *(const crypto::public_key*)(decoded.data() + offset);
offset += sizeof(pkey);
const crypto::signature &signature = *(const crypto::signature*)(decoded.data() + offset);
crypto::hash hash;
crypto::cn_fast_hash(decoded.data(), decoded.size() - sizeof(signature), hash);
if (!crypto::check_signature(hash, pkey, signature))
{
MERROR("Multisig info signature is invalid");
return false;
}
return true;
}
bool wallet2::verify_extra_multisig_info(const std::string &data, std::unordered_set<crypto::public_key> &pkeys, crypto::public_key &signer)
{
if (data.size() < MULTISIG_EXTRA_INFO_MAGIC.size() || data.substr(0, MULTISIG_EXTRA_INFO_MAGIC.size()) != MULTISIG_EXTRA_INFO_MAGIC)
{
MERROR("Multisig info header check error");
return false;
}
std::string decoded;
if (!tools::base58::decode(data.substr(MULTISIG_EXTRA_INFO_MAGIC.size()), decoded))
{
MERROR("Multisig info decoding error");
return false;
}
if (decoded.size() < sizeof(crypto::public_key) + sizeof(crypto::signature))
{
MERROR("Multisig info is corrupt");
return false;
}
if ((decoded.size() - (sizeof(crypto::public_key) + sizeof(crypto::signature))) % sizeof(crypto::public_key))
{
MERROR("Multisig info is corrupt");
return false;
}
const size_t n_keys = (decoded.size() - (sizeof(crypto::public_key) + sizeof(crypto::signature))) / sizeof(crypto::public_key);
size_t offset = 0;
signer = *(const crypto::public_key*)(decoded.data() + offset);
offset += sizeof(signer);
const crypto::signature &signature = *(const crypto::signature*)(decoded.data() + offset + n_keys * sizeof(crypto::public_key));
crypto::hash hash;
crypto::cn_fast_hash(decoded.data(), decoded.size() - sizeof(signature), hash);
if (!crypto::check_signature(hash, signer, signature))
{
MERROR("Multisig info signature is invalid");
return false;
}
for (size_t n = 0; n < n_keys; ++n)
{
crypto::public_key mspk = *(const crypto::public_key*)(decoded.data() + offset);
pkeys.insert(mspk);
offset += sizeof(mspk);
}
return true;
}
bool wallet2::multisig(bool *ready, uint32_t *threshold, uint32_t *total) const
{
if (!m_multisig)
return false;
if (threshold)
*threshold = m_multisig_threshold;
if (total)
*total = m_multisig_signers.size();
if (ready)
*ready = !(get_account().get_keys().m_account_address.m_spend_public_key == rct::rct2pk(rct::identity()));
return true;
}
bool wallet2::has_multisig_partial_key_images() const
{
if (!m_multisig)
return false;
for (const auto &td: m_transfers)
if (td.m_key_image_partial)
return true;
return false;
}
bool wallet2::has_unknown_key_images() const
{
for (const auto &td: m_transfers)
if (!td.m_key_image_known)
return true;
return false;
}
/*!
* \brief Rewrites to the wallet file for wallet upgrade (doesn't generate key, assumes it's already there)
* \param wallet_name Name of wallet file (should exist)
* \param password Password for wallet file
*/
void wallet2::rewrite(const std::string& wallet_name, const epee::wipeable_string& password)
{
if (wallet_name.empty())
return;
prepare_file_names(wallet_name);
boost::system::error_code ignored_ec;
THROW_WALLET_EXCEPTION_IF(!boost::filesystem::exists(m_keys_file, ignored_ec), error::file_not_found, m_keys_file);
bool r = store_keys(m_keys_file, password, m_watch_only);
THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_keys_file);
}
/*!
* \brief Writes to a file named based on the normal wallet (doesn't generate key, assumes it's already there)
* \param wallet_name Base name of wallet file
* \param password Password for wallet file
* \param new_keys_filename [OUT] Name of new keys file
*/
void wallet2::write_watch_only_wallet(const std::string& wallet_name, const epee::wipeable_string& password, std::string &new_keys_filename)
{
prepare_file_names(wallet_name);
boost::system::error_code ignored_ec;
new_keys_filename = m_wallet_file + "-watchonly.keys";
bool watch_only_keys_file_exists = boost::filesystem::exists(new_keys_filename, ignored_ec);
THROW_WALLET_EXCEPTION_IF(watch_only_keys_file_exists, error::file_save_error, new_keys_filename);
bool r = store_keys(new_keys_filename, password, true);
THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, new_keys_filename);
}
//----------------------------------------------------------------------------------------------------
void wallet2::wallet_exists(const std::string& file_path, bool& keys_file_exists, bool& wallet_file_exists)
{
std::string keys_file, wallet_file, mms_file;
do_prepare_file_names(file_path, keys_file, wallet_file, mms_file);
boost::system::error_code ignore;
keys_file_exists = boost::filesystem::exists(keys_file, ignore);
wallet_file_exists = boost::filesystem::exists(wallet_file, ignore);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::wallet_valid_path_format(const std::string& file_path)
{
return !file_path.empty();
}
//----------------------------------------------------------------------------------------------------
bool wallet2::parse_long_payment_id(const std::string& payment_id_str, crypto::hash& payment_id)
{
cryptonote::blobdata payment_id_data;
if(!epee::string_tools::parse_hexstr_to_binbuff(payment_id_str, payment_id_data))
return false;
if(sizeof(crypto::hash) != payment_id_data.size())
return false;
payment_id = *reinterpret_cast<const crypto::hash*>(payment_id_data.data());
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::parse_short_payment_id(const std::string& payment_id_str, crypto::hash8& payment_id)
{
cryptonote::blobdata payment_id_data;
if(!epee::string_tools::parse_hexstr_to_binbuff(payment_id_str, payment_id_data))
return false;
if(sizeof(crypto::hash8) != payment_id_data.size())
return false;
payment_id = *reinterpret_cast<const crypto::hash8*>(payment_id_data.data());
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::parse_payment_id(const std::string& payment_id_str, crypto::hash& payment_id)
{
if (parse_long_payment_id(payment_id_str, payment_id))
return true;
crypto::hash8 payment_id8;
if (parse_short_payment_id(payment_id_str, payment_id8))
{
memcpy(payment_id.data, payment_id8.data, 8);
memset(payment_id.data + 8, 0, 24);
return true;
}
return false;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::prepare_file_names(const std::string& file_path)
{
do_prepare_file_names(file_path, m_keys_file, m_wallet_file, m_mms_file);
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::is_connected() const
{
if (m_offline) return false;
if (m_light_wallet) return m_light_wallet_connected;
return m_http_client.is_connected(nullptr);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::check_connection(uint32_t *version, bool *ssl, uint32_t timeout)
{
THROW_WALLET_EXCEPTION_IF(!m_is_initialized, error::wallet_not_initialized);
if (m_offline)
{
if (version)
*version = 0;
if (ssl)
*ssl = false;
return false;
}
// TODO: Add light wallet version check.
if(m_light_wallet) {
if (version)
*version = 0;
if (ssl)
*ssl = m_light_wallet_connected; // light wallet is always SSL
return m_light_wallet_connected;
}
{
boost::lock_guard<boost::recursive_mutex> lock(m_daemon_rpc_mutex);
if(!m_http_client.is_connected(ssl))
{
m_node_rpc_proxy.invalidate();
if (!m_http_client.connect(std::chrono::milliseconds(timeout)))
return false;
if(!m_http_client.is_connected(ssl))
return false;
}
}
if (version)
{
cryptonote::COMMAND_RPC_GET_VERSION::request req_t{};
cryptonote::COMMAND_RPC_GET_VERSION::response resp_t{};
bool r = invoke_http_json_rpc("/json_rpc", "get_version", req_t, resp_t);
if(!r) {
*version = 0;
return false;
}
if (resp_t.status != CORE_RPC_STATUS_OK)
*version = 0;
else
*version = resp_t.version;
}
return true;
}
//----------------------------------------------------------------------------------------------------
void wallet2::set_offline(bool offline)
{
m_offline = offline;
m_http_client.set_auto_connect(!offline);
if (offline)
{
boost::lock_guard<boost::recursive_mutex> lock(m_daemon_rpc_mutex);
if(m_http_client.is_connected())
m_http_client.disconnect();
}
}
//----------------------------------------------------------------------------------------------------
bool wallet2::generate_chacha_key_from_secret_keys(crypto::chacha_key &key) const
{
hw::device &hwdev = m_account.get_device();
return hwdev.generate_chacha_key(m_account.get_keys(), key, m_kdf_rounds);
}
//----------------------------------------------------------------------------------------------------
void wallet2::generate_chacha_key_from_password(const epee::wipeable_string &pass, crypto::chacha_key &key) const
{
crypto::generate_chacha_key(pass.data(), pass.size(), key, m_kdf_rounds);
}
//----------------------------------------------------------------------------------------------------
void wallet2::load(const std::string& wallet_, const epee::wipeable_string& password)
{
clear();
prepare_file_names(wallet_);
boost::system::error_code e;
bool exists = boost::filesystem::exists(m_keys_file, e);
THROW_WALLET_EXCEPTION_IF(e || !exists, error::file_not_found, m_keys_file);
lock_keys_file();
THROW_WALLET_EXCEPTION_IF(!is_keys_file_locked(), error::wallet_internal_error, "internal error: \"" + m_keys_file + "\" is opened by another wallet program");
// this temporary unlocking is necessary for Windows (otherwise the file couldn't be loaded).
unlock_keys_file();
if (!load_keys(m_keys_file, password))
{
THROW_WALLET_EXCEPTION_IF(true, error::file_read_error, m_keys_file);
}
LOG_PRINT_L0("Loaded wallet keys file, with public address: " << m_account.get_public_address_str(m_nettype));
lock_keys_file();
wallet_keys_unlocker unlocker(*this, m_ask_password == AskPasswordToDecrypt && !m_unattended && !m_watch_only, password);
//keys loaded ok!
//try to load wallet file. but even if we failed, it is not big problem
if(!boost::filesystem::exists(m_wallet_file, e) || e)
{
LOG_PRINT_L0("file not found: " << m_wallet_file << ", starting with empty blockchain");
m_account_public_address = m_account.get_keys().m_account_address;
}
else
{
wallet2::cache_file_data cache_file_data;
std::string buf;
bool r = epee::file_io_utils::load_file_to_string(m_wallet_file, buf, std::numeric_limits<size_t>::max());
THROW_WALLET_EXCEPTION_IF(!r, error::file_read_error, m_wallet_file);
// try to read it as an encrypted cache
try
{
LOG_PRINT_L1("Trying to decrypt cache data");
r = ::serialization::parse_binary(buf, cache_file_data);
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "internal error: failed to deserialize \"" + m_wallet_file + '\"');
std::string cache_data;
cache_data.resize(cache_file_data.cache_data.size());
crypto::chacha20(cache_file_data.cache_data.data(), cache_file_data.cache_data.size(), m_cache_key, cache_file_data.iv, &cache_data[0]);
try {
std::stringstream iss;
iss << cache_data;
boost::archive::portable_binary_iarchive ar(iss);
ar >> *this;
}
catch(...)
{
// try with previous scheme: direct from keys
crypto::chacha_key key;
generate_chacha_key_from_secret_keys(key);
crypto::chacha20(cache_file_data.cache_data.data(), cache_file_data.cache_data.size(), key, cache_file_data.iv, &cache_data[0]);
try {
std::stringstream iss;
iss << cache_data;
boost::archive::portable_binary_iarchive ar(iss);
ar >> *this;
}
catch (...)
{
crypto::chacha8(cache_file_data.cache_data.data(), cache_file_data.cache_data.size(), key, cache_file_data.iv, &cache_data[0]);
try
{
std::stringstream iss;
iss << cache_data;
boost::archive::portable_binary_iarchive ar(iss);
ar >> *this;
}
catch (...)
{
LOG_PRINT_L0("Failed to open portable binary, trying unportable");
boost::filesystem::copy_file(m_wallet_file, m_wallet_file + ".unportable", boost::filesystem::copy_option::overwrite_if_exists);
std::stringstream iss;
iss.str("");
iss << cache_data;
boost::archive::binary_iarchive ar(iss);
ar >> *this;
}
}
}
}
catch (...)
{
LOG_PRINT_L1("Failed to load encrypted cache, trying unencrypted");
try {
std::stringstream iss;
iss << buf;
boost::archive::portable_binary_iarchive ar(iss);
ar >> *this;
}
catch (...)
{
LOG_PRINT_L0("Failed to open portable binary, trying unportable");
boost::filesystem::copy_file(m_wallet_file, m_wallet_file + ".unportable", boost::filesystem::copy_option::overwrite_if_exists);
std::stringstream iss;
iss.str("");
iss << buf;
boost::archive::binary_iarchive ar(iss);
ar >> *this;
}
}
THROW_WALLET_EXCEPTION_IF(
m_account_public_address.m_spend_public_key != m_account.get_keys().m_account_address.m_spend_public_key ||
m_account_public_address.m_view_public_key != m_account.get_keys().m_account_address.m_view_public_key,
error::wallet_files_doesnt_correspond, m_keys_file, m_wallet_file);
}
cryptonote::block genesis;
generate_genesis(genesis);
crypto::hash genesis_hash = get_block_hash(genesis);
if (m_blockchain.empty())
{
m_blockchain.push_back(genesis_hash);
m_last_block_reward = cryptonote::get_outs_money_amount(genesis.miner_tx);
}
else
{
check_genesis(genesis_hash);
}
trim_hashchain();
if (get_num_subaddress_accounts() == 0)
add_subaddress_account(tr("Primary account"));
try
{
find_and_save_rings(false);
}
catch (const std::exception &e)
{
MERROR("Failed to save rings, will try again next time");
}
try
{
m_message_store.read_from_file(get_multisig_wallet_state(), m_mms_file);
}
catch (const std::exception &e)
{
MERROR("Failed to initialize MMS, it will be unusable");
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::trim_hashchain()
{
uint64_t height = 0;
cryptonote::get_newest_hardcoded_checkpoint(nettype(), &height);
for (const transfer_details &td: m_transfers)
if (td.m_block_height < height)
height = td.m_block_height;
if (!m_blockchain.empty() && m_blockchain.size() == m_blockchain.offset())
{
MINFO("Fixing empty hashchain");
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT::request req{};
cryptonote::COMMAND_RPC_GET_BLOCK_HEADER_BY_HEIGHT::response res{};
m_daemon_rpc_mutex.lock();
req.height = m_blockchain.size() - 1;
bool r = invoke_http_json_rpc("/json_rpc", "getblockheaderbyheight", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
if (r && res.status == CORE_RPC_STATUS_OK)
{
crypto::hash hash;
epee::string_tools::hex_to_pod(res.block_header.hash, hash);
m_blockchain.refill(hash);
}
else
{
MERROR("Failed to request block header from daemon, hash chain may be unable to sync till the wallet is loaded with a usable daemon");
}
}
if (height > 0 && m_blockchain.size() > height)
{
--height;
MDEBUG("trimming to " << height << ", offset " << m_blockchain.offset());
m_blockchain.trim(height);
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::check_genesis(const crypto::hash& genesis_hash) const {
std::string what("Genesis block mismatch. You probably use wallet without testnet (or stagenet) flag with blockchain from test (or stage) network or vice versa");
THROW_WALLET_EXCEPTION_IF(genesis_hash != m_blockchain.genesis(), error::wallet_internal_error, what);
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::path() const
{
return m_wallet_file;
}
//----------------------------------------------------------------------------------------------------
void wallet2::store()
{
if (!m_wallet_file.empty())
store_to("", epee::wipeable_string());
}
//----------------------------------------------------------------------------------------------------
void wallet2::store_to(const std::string &path, const epee::wipeable_string &password)
{
trim_hashchain();
// if file is the same, we do:
// 1. save wallet to the *.new file
// 2. remove old wallet file
// 3. rename *.new to wallet_name
// handle if we want just store wallet state to current files (ex store() replacement);
bool same_file = true;
if (!path.empty())
{
std::string canonical_path = boost::filesystem::canonical(m_wallet_file).string();
size_t pos = canonical_path.find(path);
same_file = pos != std::string::npos;
}
if (!same_file)
{
// check if we want to store to directory which doesn't exists yet
boost::filesystem::path parent_path = boost::filesystem::path(path).parent_path();
// if path is not exists, try to create it
if (!parent_path.empty() && !boost::filesystem::exists(parent_path))
{
boost::system::error_code ec;
if (!boost::filesystem::create_directories(parent_path, ec))
{
throw std::logic_error(ec.message());
}
}
}
// preparing wallet data
std::stringstream oss;
boost::archive::portable_binary_oarchive ar(oss);
ar << *this;
wallet2::cache_file_data cache_file_data{};
cache_file_data.cache_data = oss.str();
std::string cipher;
cipher.resize(cache_file_data.cache_data.size());
cache_file_data.iv = crypto::rand<crypto::chacha_iv>();
crypto::chacha20(cache_file_data.cache_data.data(), cache_file_data.cache_data.size(), m_cache_key, cache_file_data.iv, &cipher[0]);
cache_file_data.cache_data = cipher;
const std::string new_file = same_file ? m_wallet_file + ".new" : path;
const std::string old_file = m_wallet_file;
const std::string old_keys_file = m_keys_file;
const std::string old_address_file = m_wallet_file + ".address.txt";
const std::string old_mms_file = m_mms_file;
// save keys to the new file
// if we here, main wallet file is saved and we only need to save keys and address files
if (!same_file) {
prepare_file_names(path);
bool r = store_keys(m_keys_file, password, false);
THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_keys_file);
if (boost::filesystem::exists(old_address_file))
{
// save address to the new file
const std::string address_file = m_wallet_file + ".address.txt";
r = file_io_utils::save_string_to_file(address_file, m_account.get_public_address_str(m_nettype));
THROW_WALLET_EXCEPTION_IF(!r, error::file_save_error, m_wallet_file);
}
// remove old wallet file
r = boost::filesystem::remove(old_file);
if (!r) {
LOG_ERROR("error removing file: " << old_file);
}
// remove old keys file
r = boost::filesystem::remove(old_keys_file);
if (!r) {
LOG_ERROR("error removing file: " << old_keys_file);
}
// remove old address file
r = boost::filesystem::remove(old_address_file);
if (!r) {
LOG_ERROR("error removing file: " << old_address_file);
}
// remove old message store file
if (boost::filesystem::exists(old_mms_file))
{
r = boost::filesystem::remove(old_mms_file);
if (!r) {
LOG_ERROR("error removing file: " << old_mms_file);
}
}
} else {
// save to new file
#ifdef WIN32
// On Windows avoid using std::ofstream which does not work with UTF-8 filenames
// The price to pay is temporary higher memory consumption for string stream + binary archive
std::ostringstream oss;
binary_archive<true> oar(oss);
bool success = ::serialization::serialize(oar, cache_file_data);
if (success) {
success = epee::file_io_utils::save_string_to_file(new_file, oss.str());
}
THROW_WALLET_EXCEPTION_IF(!success, error::file_save_error, new_file);
#else
std::ofstream ostr;
ostr.open(new_file, std::ios_base::binary | std::ios_base::out | std::ios_base::trunc);
binary_archive<true> oar(ostr);
bool success = ::serialization::serialize(oar, cache_file_data);
ostr.close();
THROW_WALLET_EXCEPTION_IF(!success || !ostr.good(), error::file_save_error, new_file);
#endif
// here we have "*.new" file, we need to rename it to be without ".new"
std::error_code e = tools::replace_file(new_file, m_wallet_file);
THROW_WALLET_EXCEPTION_IF(e, error::file_save_error, m_wallet_file, e);
}
if (m_message_store.get_active())
{
// While the "m_message_store" object of course always exist, a file for the message
// store should only exist if the MMS is really active
m_message_store.write_to_file(get_multisig_wallet_state(), m_mms_file);
}
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::balance(uint32_t index_major) const
{
uint64_t amount = 0;
if(m_light_wallet)
return m_light_wallet_unlocked_balance;
for (const auto& i : balance_per_subaddress(index_major))
amount += i.second;
return amount;
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::unlocked_balance(uint32_t index_major, uint64_t *blocks_to_unlock) const
{
uint64_t amount = 0;
if (blocks_to_unlock)
*blocks_to_unlock = 0;
if(m_light_wallet)
return m_light_wallet_balance;
for (const auto& i : unlocked_balance_per_subaddress(index_major))
{
amount += i.second.first;
if (blocks_to_unlock && i.second.second > *blocks_to_unlock)
*blocks_to_unlock = i.second.second;
}
return amount;
}
//----------------------------------------------------------------------------------------------------
std::map<uint32_t, uint64_t> wallet2::balance_per_subaddress(uint32_t index_major) const
{
std::map<uint32_t, uint64_t> amount_per_subaddr;
for (const auto& td: m_transfers)
{
if (td.m_subaddr_index.major == index_major && !td.m_spent && !td.m_frozen)
{
auto found = amount_per_subaddr.find(td.m_subaddr_index.minor);
if (found == amount_per_subaddr.end())
amount_per_subaddr[td.m_subaddr_index.minor] = td.amount();
else
found->second += td.amount();
}
}
for (const auto& utx: m_unconfirmed_txs)
{
if (utx.second.m_subaddr_account == index_major && utx.second.m_state != wallet2::unconfirmed_transfer_details::failed)
{
// all changes go to 0-th subaddress (in the current subaddress account)
auto found = amount_per_subaddr.find(0);
if (found == amount_per_subaddr.end())
amount_per_subaddr[0] = utx.second.m_change;
else
found->second += utx.second.m_change;
}
}
return amount_per_subaddr;
}
//----------------------------------------------------------------------------------------------------
std::map<uint32_t, std::pair<uint64_t, uint64_t>> wallet2::unlocked_balance_per_subaddress(uint32_t index_major) const
{
std::map<uint32_t, std::pair<uint64_t, uint64_t>> amount_per_subaddr;
const uint64_t blockchain_height = get_blockchain_current_height();
for(const transfer_details& td: m_transfers)
{
if(td.m_subaddr_index.major == index_major && !td.m_spent && !td.m_frozen)
{
uint64_t amount = 0, blocks_to_unlock = 0;
if (is_transfer_unlocked(td))
{
amount = td.amount();
blocks_to_unlock = 0;
}
else
{
uint64_t unlock_height = td.m_unmined_blink && td.m_block_height == 0 ? blockchain_height : td.m_block_height;
unlock_height += std::max<uint64_t>(CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE, CRYPTONOTE_LOCKED_TX_ALLOWED_DELTA_BLOCKS);
if (td.m_tx.unlock_time < CRYPTONOTE_MAX_BLOCK_NUMBER && td.m_tx.unlock_time > unlock_height)
unlock_height = td.m_tx.unlock_time;
blocks_to_unlock = unlock_height > blockchain_height ? unlock_height - blockchain_height : 0;
amount = 0;
}
auto found = amount_per_subaddr.find(td.m_subaddr_index.minor);
if (found == amount_per_subaddr.end())
amount_per_subaddr[td.m_subaddr_index.minor] = std::make_pair(amount, blocks_to_unlock);
else
{
found->second.first += amount;
found->second.second = std::max(found->second.second, blocks_to_unlock);
}
}
}
return amount_per_subaddr;
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::balance_all() const
{
uint64_t r = 0;
for (uint32_t index_major = 0; index_major < get_num_subaddress_accounts(); ++index_major)
r += balance(index_major);
return r;
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::unlocked_balance_all(uint64_t *blocks_to_unlock) const
{
uint64_t r = 0;
if (blocks_to_unlock)
*blocks_to_unlock = 0;
for (uint32_t index_major = 0; index_major < get_num_subaddress_accounts(); ++index_major)
{
uint64_t local_blocks_to_unlock;
r += unlocked_balance(index_major, blocks_to_unlock ? &local_blocks_to_unlock : NULL);
if (blocks_to_unlock)
*blocks_to_unlock = std::max(*blocks_to_unlock, local_blocks_to_unlock);
}
return r;
}
//----------------------------------------------------------------------------------------------------
void wallet2::get_transfers(wallet2::transfer_container& incoming_transfers) const
{
incoming_transfers = m_transfers;
}
//------------------------------------------------------------------------------------------------------------------------------
static void set_confirmations(transfer_view &entry, uint64_t blockchain_height, uint64_t block_reward)
{
if (entry.height >= blockchain_height || (entry.height == 0 && (entry.type == "pending" || entry.type == "pool")))
entry.confirmations = 0;
else
entry.confirmations = blockchain_height - entry.height;
if (block_reward == 0)
entry.suggested_confirmations_threshold = 0;
else
entry.suggested_confirmations_threshold = (entry.amount + block_reward - 1) / block_reward;
}
//----------------------------------------------------------------------------------------------------
transfer_view wallet2::make_transfer_view(const crypto::hash &txid, const crypto::hash &payment_id, const tools::wallet2::payment_details &pd) const
{
transfer_view result = {};
result.txid = string_tools::pod_to_hex(pd.m_tx_hash);
result.hash = txid;
result.payment_id = string_tools::pod_to_hex(payment_id);
if (result.payment_id.substr(16).find_first_not_of('0') == std::string::npos)
result.payment_id = result.payment_id.substr(0,16);
result.height = pd.m_block_height;
result.timestamp = pd.m_timestamp;
result.amount = pd.m_amount;
result.unlock_time = pd.m_unlock_time;
result.fee = pd.m_fee;
result.note = get_tx_note(pd.m_tx_hash);
result.pay_type = pd.m_type;
result.subaddr_index = pd.m_subaddr_index;
result.subaddr_indices.push_back(pd.m_subaddr_index);
result.address = get_subaddress_as_str(pd.m_subaddr_index);
result.confirmed = true;
result.blink_mempool = pd.m_unmined_blink;
result.was_blink = pd.m_was_blink;
// TODO(sacha): is this just for in or also coinbase?
const bool unlocked = is_transfer_unlocked(result.unlock_time, result.height, result.blink_mempool);
result.lock_msg = unlocked ? "unlocked" : "locked";
set_confirmations(result, get_blockchain_current_height(), get_last_block_reward());
result.checkpointed = (result.height == 0 && pd.m_unmined_blink ? false : result.height <= m_immutable_height);
return result;
}
//------------------------------------------------------------------------------------------------------------------------------
transfer_view wallet2::wallet2::make_transfer_view(const crypto::hash &txid, const tools::wallet2::confirmed_transfer_details &pd) const
{
transfer_view result = {};
result.txid = string_tools::pod_to_hex(txid);
result.hash = txid;
result.payment_id = string_tools::pod_to_hex(pd.m_payment_id);
if (result.payment_id.substr(16).find_first_not_of('0') == std::string::npos)
result.payment_id = result.payment_id.substr(0,16);
result.height = pd.m_block_height;
result.timestamp = pd.m_timestamp;
result.unlock_time = pd.m_unlock_time;
result.fee = pd.m_amount_in - pd.m_amount_out;
uint64_t change = pd.m_change == (uint64_t)-1 ? 0 : pd.m_change; // change may not be known
result.amount = pd.m_amount_in - change - result.fee;
result.note = get_tx_note(txid);
for (const auto &d: pd.m_dests) {
result.destinations.push_back({});
transfer_destination &td = result.destinations.back();
td.amount = d.amount;
td.address = d.original.empty() ? get_account_address_as_str(nettype(), d.is_subaddress, d.addr) : d.original;
}
result.pay_type = pay_type::out;
result.subaddr_index = { pd.m_subaddr_account, 0 };
for (uint32_t i: pd.m_subaddr_indices)
result.subaddr_indices.push_back({pd.m_subaddr_account, i});
result.address = get_subaddress_as_str({pd.m_subaddr_account, 0});
result.confirmed = true;
result.checkpointed = result.height <= m_immutable_height;
set_confirmations(result, get_blockchain_current_height(), get_last_block_reward());
return result;
}
//------------------------------------------------------------------------------------------------------------------------------
transfer_view wallet2::make_transfer_view(const crypto::hash &txid, const tools::wallet2::unconfirmed_transfer_details &pd) const
{
transfer_view result = {};
bool is_failed = pd.m_state == tools::wallet2::unconfirmed_transfer_details::failed;
result.txid = string_tools::pod_to_hex(txid);
result.hash = txid;
result.payment_id = string_tools::pod_to_hex(pd.m_payment_id);
result.payment_id = string_tools::pod_to_hex(pd.m_payment_id);
if (result.payment_id.substr(16).find_first_not_of('0') == std::string::npos)
result.payment_id = result.payment_id.substr(0,16);
result.height = 0;
result.timestamp = pd.m_timestamp;
result.fee = pd.m_amount_in - pd.m_amount_out;
result.amount = pd.m_amount_in - pd.m_change - result.fee;
result.unlock_time = pd.m_tx.unlock_time;
result.note = get_tx_note(txid);
for (const auto &d: pd.m_dests) {
result.destinations.push_back({});
transfer_destination &td = result.destinations.back();
td.amount = d.amount;
td.address = d.original.empty() ? get_account_address_as_str(nettype(), d.is_subaddress, d.addr) : d.original;
}
result.pay_type = pay_type::unspecified;
result.type = is_failed ? "failed" : "pending";
result.subaddr_index = { pd.m_subaddr_account, 0 };
for (uint32_t i: pd.m_subaddr_indices)
result.subaddr_indices.push_back({pd.m_subaddr_account, i});
result.address = get_subaddress_as_str({pd.m_subaddr_account, 0});
set_confirmations(result, get_blockchain_current_height(), get_last_block_reward());
return result;
}
//------------------------------------------------------------------------------------------------------------------------------
transfer_view wallet2::make_transfer_view(const crypto::hash &payment_id, const tools::wallet2::pool_payment_details &ppd) const
{
transfer_view result = {};
const tools::wallet2::payment_details &pd = ppd.m_pd;
result.txid = string_tools::pod_to_hex(pd.m_tx_hash);
result.hash = pd.m_tx_hash;
result.payment_id = string_tools::pod_to_hex(payment_id);
if (result.payment_id.substr(16).find_first_not_of('0') == std::string::npos)
result.payment_id = result.payment_id.substr(0,16);
result.height = 0;
result.timestamp = pd.m_timestamp;
result.amount = pd.m_amount;
result.unlock_time = pd.m_unlock_time;
result.fee = pd.m_fee;
result.note = get_tx_note(pd.m_tx_hash);
result.double_spend_seen = ppd.m_double_spend_seen;
result.pay_type = pay_type::unspecified;
result.type = "pool";
result.subaddr_index = pd.m_subaddr_index;
result.subaddr_indices.push_back(pd.m_subaddr_index);
result.address = get_subaddress_as_str(pd.m_subaddr_index);
set_confirmations(result, get_blockchain_current_height(), get_last_block_reward());
return result;
}
//----------------------------------------------------------------------------------------------------
void wallet2::get_transfers(get_transfers_args_t args, std::vector<transfer_view>& transfers)
{
boost::optional<uint32_t> account_index = args.account_index;
if (args.all_accounts)
{
account_index = boost::none;
args.subaddr_indices.clear();
}
if (args.filter_by_height)
{
args.max_height = std::max<uint64_t>(args.max_height, args.min_height);
args.max_height = std::min<uint64_t>(args.max_height, CRYPTONOTE_MAX_BLOCK_NUMBER);
}
std::list<std::pair<crypto::hash, tools::wallet2::payment_details>> in;
std::list<std::pair<crypto::hash, tools::wallet2::confirmed_transfer_details>> out;
std::list<std::pair<crypto::hash, tools::wallet2::unconfirmed_transfer_details>> pending_or_failed;
std::list<std::pair<crypto::hash, tools::wallet2::pool_payment_details>> pool;
MDEBUG("Getting transfers of type(s) " << (args.in ? "in " : "") << (args.out ? "out " : "") << (args.pending ? "pending " : "") << (args.failed ? "failed " : "")
<< (args.pool ? "pool " : "") << " for heights in [" << args.min_height << "," << args.max_height << "]");
if ((args.in || args.out || args.pool) && is_connected())
{
update_pool_state();
}
size_t size = 0;
if (args.in)
{
get_payments(in, args.min_height, args.max_height, account_index, args.subaddr_indices);
size += in.size();
}
if (args.out)
{
get_payments_out(out, args.min_height, args.max_height, account_index, args.subaddr_indices);
size += out.size();
}
if (args.pending || args.failed)
{
get_unconfirmed_payments_out(pending_or_failed, account_index, args.subaddr_indices);
size += pending_or_failed.size();
}
if (args.pool)
{
get_unconfirmed_payments(pool, account_index, args.subaddr_indices);
size += pool.size();
}
// Fill transfers
transfers.reserve(size);
for (const auto &i : in)
transfers.push_back(make_transfer_view(i.second.m_tx_hash, i.first, i.second));
for (const auto &o : out)
transfers.push_back(make_transfer_view(o.first, o.second));
for (const auto &pof : pending_or_failed)
{
bool is_failed = pof.second.m_state == tools::wallet2::unconfirmed_transfer_details::failed;
if (is_failed ? args.failed : args.pending)
transfers.push_back(make_transfer_view(pof.first, pof.second));
}
for (const auto &p : pool)
transfers.push_back(make_transfer_view(p.first, p.second));
std::sort(transfers.begin(), transfers.end(), [](const transfer_view& a, const transfer_view& b) -> bool {
if (a.confirmed != b.confirmed)
return a.confirmed;
if (a.blink_mempool != b.blink_mempool)
return b.blink_mempool;
if (a.height != b.height)
return a.height < b.height;
if (a.timestamp != b.timestamp)
return a.timestamp < b.timestamp;
return a.hash < b.hash;
});
}
std::string wallet2::transfers_to_csv(const std::vector<transfer_view>& transfers, bool formatting) const
{
uint64_t running_balance = 0;
auto data_formatter = boost::format("%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,'%s',%s");
auto title_formatter = boost::format("%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s");
if (formatting)
{
title_formatter = boost::format("%8.8s,%9.9s,%8.8s,%14.14s,%16.16s,%20.20s,%20.20s,%64.64s,%16.16s,%14.14s,%100.100s,%20.20s,%s,%s");
data_formatter = boost::format("%8.8s,%9.9s,%8.8s,%14.14s,%16.16s,%20.20s,%20.20s,%64.64s,%16.16s,%14.14s,%100.100s,%20.20s,\"%s\",%s");
}
auto new_line = [&](std::stringstream& output){
if (formatting)
{
output << std::endl;
} else
{
output << "\r\n";
}
};
std::stringstream output;
output << title_formatter
% tr("block")
% tr("type")
% tr("lock")
% tr("checkpointed")
% tr("timestamp")
% tr("amount")
% tr("running balance")
% tr("hash")
% tr("payment ID")
% tr("fee")
% tr("destination")
% tr("amount")
% tr("index")
% tr("note");
new_line(output);
for (const auto& transfer : transfers)
{
switch (transfer.pay_type)
{
case tools::pay_type::in:
case tools::pay_type::miner:
case tools::pay_type::service_node:
case tools::pay_type::governance:
running_balance += transfer.amount;
break;
case tools::pay_type::stake:
running_balance -= transfer.fee;
break;
case tools::pay_type::out:
running_balance -= transfer.amount + transfer.fee;
break;
default:
MERROR("Warning: Unhandled pay type, this is most likely a developer error, please report it to the Worktips developers.");
break;
}
output << data_formatter
% (transfer.type.size() ? transfer.type : std::to_string(transfer.height))
% pay_type_string(transfer.pay_type)
% transfer.lock_msg
% (transfer.checkpointed ? "checkpointed" : "no")
% tools::get_human_readable_timestamp(transfer.timestamp)
% cryptonote::print_money(transfer.amount)
% cryptonote::print_money(running_balance)
% transfer.txid
% transfer.payment_id
% cryptonote::print_money(transfer.fee)
% (transfer.destinations.size() ? transfer.destinations.front().address : "-")
% (transfer.destinations.size() ? cryptonote::print_money(transfer.destinations.front().amount) : "")
% boost::algorithm::join(transfer.subaddr_indices | boost::adaptors::transformed([](const cryptonote::subaddress_index& index) { return std::to_string(index.minor); }), ", ")
% transfer.note;
new_line(output);
if (transfer.destinations.size() <= 1)
continue;
// print subsequent destination addresses and amounts
// (start at begin + 1 with std::next)
for (auto it = std::next(transfer.destinations.cbegin()); it != transfer.destinations.cend(); ++it)
{
output << data_formatter
% ""
% ""
% ""
% ""
% ""
% ""
% ""
% ""
% ""
% ""
% it->address
% cryptonote::print_money(it->amount)
% ""
% "";
new_line(output);
}
}
return output.str();
}
//----------------------------------------------------------------------------------------------------
void wallet2::get_payments(const crypto::hash& payment_id, std::list<wallet2::payment_details>& payments, uint64_t min_height, const boost::optional<uint32_t>& subaddr_account, const std::set<uint32_t>& subaddr_indices) const
{
auto range = m_payments.equal_range(payment_id);
std::for_each(range.first, range.second, [&payments, &min_height, &subaddr_account, &subaddr_indices](const payment_container::value_type& x) {
if (min_height <= x.second.m_block_height &&
(!subaddr_account || *subaddr_account == x.second.m_subaddr_index.major) &&
(subaddr_indices.empty() || subaddr_indices.count(x.second.m_subaddr_index.minor) == 1))
{
payments.push_back(x.second);
}
});
}
//----------------------------------------------------------------------------------------------------
void wallet2::get_payments(std::list<std::pair<crypto::hash,wallet2::payment_details>>& payments, uint64_t min_height, uint64_t max_height, const boost::optional<uint32_t>& subaddr_account, const std::set<uint32_t>& subaddr_indices) const
{
auto range = std::make_pair(m_payments.begin(), m_payments.end());
std::for_each(range.first, range.second, [&payments, &min_height, &max_height, &subaddr_account, &subaddr_indices](const payment_container::value_type& x) {
if (min_height <= x.second.m_block_height && max_height >= x.second.m_block_height &&
(!subaddr_account || *subaddr_account == x.second.m_subaddr_index.major) &&
(subaddr_indices.empty() || subaddr_indices.count(x.second.m_subaddr_index.minor) == 1))
{
payments.push_back(x);
}
});
}
//----------------------------------------------------------------------------------------------------
void wallet2::get_payments_out(std::list<std::pair<crypto::hash,wallet2::confirmed_transfer_details>>& confirmed_payments,
uint64_t min_height, uint64_t max_height, const boost::optional<uint32_t>& subaddr_account, const std::set<uint32_t>& subaddr_indices) const
{
for (auto i = m_confirmed_txs.begin(); i != m_confirmed_txs.end(); ++i) {
if (i->second.m_block_height < min_height || i->second.m_block_height > max_height)
continue;
if (subaddr_account && *subaddr_account != i->second.m_subaddr_account)
continue;
if (!subaddr_indices.empty() && std::count_if(i->second.m_subaddr_indices.begin(), i->second.m_subaddr_indices.end(), [&subaddr_indices](uint32_t index) { return subaddr_indices.count(index) == 1; }) == 0)
continue;
confirmed_payments.push_back(*i);
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::get_unconfirmed_payments_out(std::list<std::pair<crypto::hash,wallet2::unconfirmed_transfer_details>>& unconfirmed_payments, const boost::optional<uint32_t>& subaddr_account, const std::set<uint32_t>& subaddr_indices) const
{
for (auto i = m_unconfirmed_txs.begin(); i != m_unconfirmed_txs.end(); ++i) {
if (subaddr_account && *subaddr_account != i->second.m_subaddr_account)
continue;
if (!subaddr_indices.empty() && std::count_if(i->second.m_subaddr_indices.begin(), i->second.m_subaddr_indices.end(), [&subaddr_indices](uint32_t index) { return subaddr_indices.count(index) == 1; }) == 0)
continue;
unconfirmed_payments.push_back(*i);
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::get_unconfirmed_payments(std::list<std::pair<crypto::hash,wallet2::pool_payment_details>>& unconfirmed_payments, const boost::optional<uint32_t>& subaddr_account, const std::set<uint32_t>& subaddr_indices) const
{
for (auto i = m_unconfirmed_payments.begin(); i != m_unconfirmed_payments.end(); ++i) {
if ((!subaddr_account || *subaddr_account == i->second.m_pd.m_subaddr_index.major) &&
(subaddr_indices.empty() || subaddr_indices.count(i->second.m_pd.m_subaddr_index.minor) == 1))
unconfirmed_payments.push_back(*i);
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::rescan_spent()
{
// This is RPC call that can take a long time if there are many outputs,
// so we call it several times, in stripes, so we don't time out spuriously
std::vector<int> spent_status;
spent_status.reserve(m_transfers.size());
const size_t chunk_size = 1000;
for (size_t start_offset = 0; start_offset < m_transfers.size(); start_offset += chunk_size)
{
const size_t n_outputs = std::min<size_t>(chunk_size, m_transfers.size() - start_offset);
MDEBUG("Calling is_key_image_spent on " << start_offset << " - " << (start_offset + n_outputs - 1) << ", out of " << m_transfers.size());
COMMAND_RPC_IS_KEY_IMAGE_SPENT::request req{};
COMMAND_RPC_IS_KEY_IMAGE_SPENT::response daemon_resp{};
for (size_t n = start_offset; n < start_offset + n_outputs; ++n)
req.key_images.push_back(string_tools::pod_to_hex(m_transfers[n].m_key_image));
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/is_key_image_spent", req, daemon_resp, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "is_key_image_spent");
THROW_WALLET_EXCEPTION_IF(daemon_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "is_key_image_spent");
THROW_WALLET_EXCEPTION_IF(daemon_resp.status != CORE_RPC_STATUS_OK, error::is_key_image_spent_error, get_rpc_status(daemon_resp.status));
THROW_WALLET_EXCEPTION_IF(daemon_resp.spent_status.size() != n_outputs, error::wallet_internal_error,
"daemon returned wrong response for is_key_image_spent, wrong amounts count = " +
std::to_string(daemon_resp.spent_status.size()) + ", expected " + std::to_string(n_outputs));
std::copy(daemon_resp.spent_status.begin(), daemon_resp.spent_status.end(), std::back_inserter(spent_status));
}
// update spent status
for (size_t i = 0; i < m_transfers.size(); ++i)
{
transfer_details& td = m_transfers[i];
// a view wallet may not know about key images
if (!td.m_key_image_known || td.m_key_image_partial)
continue;
if (td.m_spent != (spent_status[i] != COMMAND_RPC_IS_KEY_IMAGE_SPENT::UNSPENT))
{
if (td.m_spent)
{
LOG_PRINT_L0("Marking output " << i << "(" << td.m_key_image << ") as unspent, it was marked as spent");
set_unspent(i);
td.m_spent_height = 0;
}
else
{
LOG_PRINT_L0("Marking output " << i << "(" << td.m_key_image << ") as spent, it was marked as unspent");
set_spent(i, td.m_spent_height);
// unknown height, if this gets reorged, it might still be missed
}
}
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::rescan_blockchain(bool hard, bool refresh, bool keep_key_images)
{
CHECK_AND_ASSERT_THROW_MES(!hard || !keep_key_images, "Cannot preserve key images on hard rescan");
const size_t transfers_cnt = m_transfers.size();
crypto::hash transfers_hash{};
if(hard)
{
clear();
setup_new_blockchain();
}
else
{
if (keep_key_images && refresh)
hash_m_transfers((int64_t) transfers_cnt, transfers_hash);
clear_soft(keep_key_images);
}
if (refresh)
this->refresh(false);
if (refresh && keep_key_images)
finish_rescan_bc_keep_key_images(transfers_cnt, transfers_hash);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::is_transfer_unlocked(const transfer_details& td) const
{
return is_transfer_unlocked(td.m_tx.get_unlock_time(td.m_internal_output_index), td.m_block_height, td.m_unmined_blink, &td.m_key_image);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::is_transfer_unlocked(uint64_t unlock_time, uint64_t block_height, bool unmined_blink, crypto::key_image const *key_image) const
{
auto blockchain_height = get_blockchain_current_height();
if (block_height == 0 && unmined_blink)
{
// TODO(worktips): this restriction will go away when we add Reblink support, but for now received
// blinks still have to be mined and confirmed like regular transactions before they can be
// spent (blink without reblink just gives you a guarantee that they will be mined).
//
// Guess that the blink will go into the next block (if we're wrong then the displayed
// blocks-to-unlock count will be wrong, but that's not a huge deal).
block_height = blockchain_height;
}
if(!is_tx_spendtime_unlocked(unlock_time, block_height))
return false;
if(block_height + CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE > blockchain_height)
return false;
if (!is_connected())
return true;
if (!key_image) // TODO(worktips): Try make all callees always pass in a key image for accuracy
return true;
blobdata binary_buf;
binary_buf.reserve(sizeof(crypto::key_image));
{
boost::optional<std::string> failed;
// FIXME: can just check one here by adding a is_key_image_blacklisted
std::vector<cryptonote::COMMAND_RPC_GET_SERVICE_NODE_BLACKLISTED_KEY_IMAGES::entry> blacklist = m_node_rpc_proxy.get_service_node_blacklisted_key_images(failed);
if (failed)
{
LOG_PRINT_L1("Failed to query service node for blacklisted transfers, assuming transfer not blacklisted, reason: " << *failed);
return true;
}
for (cryptonote::COMMAND_RPC_GET_SERVICE_NODE_BLACKLISTED_KEY_IMAGES::entry const &entry : blacklist)
{
binary_buf.clear();
if(!string_tools::parse_hexstr_to_binbuff(entry.key_image, binary_buf) || binary_buf.size() != sizeof(crypto::key_image))
{
MERROR("Failed to parse hex representation of key image: " << entry.key_image);
break;
}
crypto::key_image const *check_image = reinterpret_cast<crypto::key_image const *>(binary_buf.data());
if (*key_image == *check_image)
return false;
}
}
{
const std::string primary_address = get_address_as_str();
boost::optional<std::string> failed;
std::vector<cryptonote::COMMAND_RPC_GET_SERVICE_NODES::response::entry> service_nodes_states = m_node_rpc_proxy.get_contributed_service_nodes(primary_address, failed);
if (failed)
{
LOG_PRINT_L1("Failed to query service node for locked transfers, assuming transfer not locked, reason: " << *failed);
return true;
}
for (cryptonote::COMMAND_RPC_GET_SERVICE_NODES::response::entry const &entry : service_nodes_states)
{
for (cryptonote::service_node_contributor const &contributor : entry.contributors)
{
if (primary_address != contributor.address)
continue;
for (cryptonote::service_node_contribution const &contribution : contributor.locked_contributions)
{
binary_buf.clear();
if(!string_tools::parse_hexstr_to_binbuff(contribution.key_image, binary_buf) || binary_buf.size() != sizeof(crypto::key_image))
{
MERROR("Failed to parse hex representation of key image: " << contribution.key_image);
break;
}
crypto::key_image const *check_image = reinterpret_cast<crypto::key_image const *>(binary_buf.data());
if (*key_image == *check_image)
return false;
}
}
}
}
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::is_tx_spendtime_unlocked(uint64_t unlock_time, uint64_t block_height) const
{
return cryptonote::rules::is_output_unlocked(unlock_time, get_blockchain_current_height());
}
//----------------------------------------------------------------------------------------------------
namespace
{
template<typename T>
T pop_index(std::vector<T>& vec, size_t idx)
{
CHECK_AND_ASSERT_MES(!vec.empty(), T(), "Vector must be non-empty");
CHECK_AND_ASSERT_MES(idx < vec.size(), T(), "idx out of bounds");
T res = vec[idx];
if (idx + 1 != vec.size())
{
vec[idx] = vec.back();
}
vec.resize(vec.size() - 1);
return res;
}
template<typename T>
T pop_random_value(std::vector<T>& vec)
{
CHECK_AND_ASSERT_MES(!vec.empty(), T(), "Vector must be non-empty");
size_t idx = crypto::rand_idx(vec.size());
return pop_index (vec, idx);
}
template<typename T>
T pop_back(std::vector<T>& vec)
{
CHECK_AND_ASSERT_MES(!vec.empty(), T(), "Vector must be non-empty");
T res = vec.back();
vec.pop_back();
return res;
}
template<typename T>
void pop_if_present(std::vector<T>& vec, T e)
{
for (size_t i = 0; i < vec.size(); ++i)
{
if (e == vec[i])
{
pop_index (vec, i);
return;
}
}
}
}
//----------------------------------------------------------------------------------------------------
// This returns a handwavy estimation of how much two outputs are related
// If they're from the same tx, then they're fully related. From close block
// heights, they're kinda related. The actual values don't matter, just
// their ordering, but it could become more murky if we add scores later.
float wallet2::get_output_relatedness(const transfer_details &td0, const transfer_details &td1) const
{
int dh;
// expensive test, and same tx will fall onto the same block height below
if (td0.m_txid == td1.m_txid)
return 1.0f;
// same block height -> possibly tx burst, or same tx (since above is disabled)
dh = td0.m_block_height > td1.m_block_height ? td0.m_block_height - td1.m_block_height : td1.m_block_height - td0.m_block_height;
if (dh == 0)
return 0.9f;
// adjacent blocks -> possibly tx burst
if (dh == 1)
return 0.8f;
// could extract the payment id, and compare them, but this is a bit expensive too
// similar block heights
if (dh < 10)
return 0.2f;
// don't think these are particularly related
return 0.0f;
}
//----------------------------------------------------------------------------------------------------
size_t wallet2::pop_best_value_from(const transfer_container &transfers, std::vector<size_t> &unused_indices, const std::vector<size_t>& selected_transfers, bool smallest) const
{
std::vector<size_t> candidates;
float best_relatedness = 1.0f;
for (size_t n = 0; n < unused_indices.size(); ++n)
{
const transfer_details &candidate = transfers[unused_indices[n]];
float relatedness = 0.0f;
for (std::vector<size_t>::const_iterator i = selected_transfers.begin(); i != selected_transfers.end(); ++i)
{
float r = get_output_relatedness(candidate, transfers[*i]);
if (r > relatedness)
{
relatedness = r;
if (relatedness == 1.0f)
break;
}
}
if (relatedness < best_relatedness)
{
best_relatedness = relatedness;
candidates.clear();
}
if (relatedness == best_relatedness)
candidates.push_back(n);
}
// we have all the least related outputs in candidates, so we can pick either
// the smallest, or a random one, depending on request
size_t idx;
if (smallest)
{
idx = 0;
for (size_t n = 0; n < candidates.size(); ++n)
{
const transfer_details &td = transfers[unused_indices[candidates[n]]];
if (td.amount() < transfers[unused_indices[candidates[idx]]].amount())
idx = n;
}
}
else
{
idx = crypto::rand_idx(candidates.size());
}
return pop_index (unused_indices, candidates[idx]);
}
//----------------------------------------------------------------------------------------------------
size_t wallet2::pop_best_value(std::vector<size_t> &unused_indices, const std::vector<size_t>& selected_transfers, bool smallest) const
{
return pop_best_value_from(m_transfers, unused_indices, selected_transfers, smallest);
}
//----------------------------------------------------------------------------------------------------
// Select random input sources for transaction.
// returns:
// direct return: amount of money found
// modified reference: selected_transfers, a list of iterators/indices of input sources
uint64_t wallet2::select_transfers(uint64_t needed_money, std::vector<size_t> unused_transfers_indices, std::vector<size_t>& selected_transfers) const
{
uint64_t found_money = 0;
selected_transfers.reserve(unused_transfers_indices.size());
while (found_money < needed_money && !unused_transfers_indices.empty())
{
size_t idx = pop_best_value(unused_transfers_indices, selected_transfers);
const transfer_container::const_iterator it = m_transfers.begin() + idx;
selected_transfers.push_back(idx);
found_money += it->amount();
}
return found_money;
}
//----------------------------------------------------------------------------------------------------
void wallet2::add_unconfirmed_tx(const cryptonote::transaction& tx, uint64_t amount_in, const std::vector<cryptonote::tx_destination_entry> &dests, const crypto::hash &payment_id, uint64_t change_amount, uint32_t subaddr_account, const std::set<uint32_t>& subaddr_indices)
{
unconfirmed_transfer_details& utd = m_unconfirmed_txs[cryptonote::get_transaction_hash(tx)];
utd.m_amount_in = amount_in;
utd.m_amount_out = 0;
for (const auto &d: dests)
utd.m_amount_out += d.amount;
utd.m_amount_out += change_amount; // dests does not contain change
utd.m_change = change_amount;
utd.m_sent_time = time(NULL);
utd.m_tx = (const cryptonote::transaction_prefix&)tx;
utd.m_dests = dests;
utd.m_payment_id = payment_id;
utd.m_state = wallet2::unconfirmed_transfer_details::pending;
utd.m_timestamp = time(NULL);
utd.m_subaddr_account = subaddr_account;
utd.m_subaddr_indices = subaddr_indices;
for (const auto &in: tx.vin)
{
if (in.type() != typeid(cryptonote::txin_to_key))
continue;
const auto &txin = boost::get<cryptonote::txin_to_key>(in);
utd.m_rings.push_back(std::make_pair(txin.k_image, txin.key_offsets));
}
}
//----------------------------------------------------------------------------------------------------
crypto::hash wallet2::get_payment_id(const pending_tx &ptx) const
{
std::vector<tx_extra_field> tx_extra_fields;
parse_tx_extra(ptx.tx.extra, tx_extra_fields); // ok if partially parsed
tx_extra_nonce extra_nonce;
crypto::hash payment_id = null_hash;
if (find_tx_extra_field_by_type(tx_extra_fields, extra_nonce))
{
crypto::hash8 payment_id8 = null_hash8;
if(get_encrypted_payment_id_from_tx_extra_nonce(extra_nonce.nonce, payment_id8))
{
if (ptx.dests.empty())
{
MWARNING("Encrypted payment id found, but no destinations public key, cannot decrypt");
return crypto::null_hash;
}
if (m_account.get_device().decrypt_payment_id(payment_id8, ptx.dests[0].addr.m_view_public_key, ptx.tx_key))
{
memcpy(payment_id.data, payment_id8.data, 8);
}
}
else if (!get_payment_id_from_tx_extra_nonce(extra_nonce.nonce, payment_id))
{
payment_id = crypto::null_hash;
}
}
return payment_id;
}
//----------------------------------------------------------------------------------------------------
// take a pending tx and actually send it to the daemon
void wallet2::commit_tx(pending_tx& ptx, bool blink)
{
using namespace cryptonote;
if(m_light_wallet)
{
cryptonote::COMMAND_RPC_SUBMIT_RAW_TX::request oreq;
cryptonote::COMMAND_RPC_SUBMIT_RAW_TX::response ores;
oreq.address = get_account().get_public_address_str(m_nettype);
oreq.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
oreq.tx = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(ptx.tx));
oreq.blink = blink;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/submit_raw_tx", oreq, ores, rpc_timeout, "POST");
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "submit_raw_tx");
// MyMonero and OpenMonero use different status strings
THROW_WALLET_EXCEPTION_IF(ores.status != "OK" && ores.status != "success" , error::tx_rejected, ptx.tx, get_rpc_status(ores.status), ores.error);
}
else
{
// Normal submit
COMMAND_RPC_SEND_RAW_TX::request req;
req.tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(ptx.tx));
req.do_not_relay = false;
req.do_sanity_checks = true;
req.blink = blink;
COMMAND_RPC_SEND_RAW_TX::response daemon_send_resp;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/sendrawtransaction", req, daemon_send_resp, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "sendrawtransaction");
THROW_WALLET_EXCEPTION_IF(daemon_send_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "sendrawtransaction");
THROW_WALLET_EXCEPTION_IF(daemon_send_resp.status != CORE_RPC_STATUS_OK, error::tx_rejected, ptx.tx, get_rpc_status(daemon_send_resp.status), get_text_reason(daemon_send_resp, &ptx.tx, blink));
// sanity checks
for (size_t idx: ptx.selected_transfers)
{
THROW_WALLET_EXCEPTION_IF(idx >= m_transfers.size(), error::wallet_internal_error,
"Bad output index in selected transfers: " + boost::lexical_cast<std::string>(idx));
}
}
crypto::hash txid;
txid = get_transaction_hash(ptx.tx);
crypto::hash payment_id = crypto::null_hash;
std::vector<cryptonote::tx_destination_entry> dests;
uint64_t amount_in = 0;
if (store_tx_info())
{
payment_id = get_payment_id(ptx);
dests = ptx.dests;
for(size_t idx: ptx.selected_transfers)
amount_in += m_transfers[idx].amount();
}
add_unconfirmed_tx(ptx.tx, amount_in, dests, payment_id, ptx.change_dts.amount, ptx.construction_data.subaddr_account, ptx.construction_data.subaddr_indices);
if (store_tx_info())
{
m_tx_keys.insert(std::make_pair(txid, ptx.tx_key));
m_additional_tx_keys.insert(std::make_pair(txid, ptx.additional_tx_keys));
}
LOG_PRINT_L2("transaction " << txid << " generated ok and sent to daemon, key_images: [" << ptx.key_images << "]");
for(size_t idx: ptx.selected_transfers)
{
set_spent(idx, 0);
}
// tx generated, get rid of used k values
for (size_t idx: ptx.selected_transfers)
m_transfers[idx].m_multisig_k.clear();
//fee includes dust if dust policy specified it.
LOG_PRINT_L1("Transaction successfully sent. <" << txid << ">" << ENDL
<< "Commission: " << print_money(ptx.fee) << " (dust sent to dust addr: " << print_money((ptx.dust_added_to_fee ? 0 : ptx.dust)) << ")" << ENDL
<< "Balance: " << print_money(balance(ptx.construction_data.subaddr_account)) << ENDL
<< "Unlocked: " << print_money(unlocked_balance(ptx.construction_data.subaddr_account)) << ENDL
<< "Please, wait for confirmation for your balance to be unlocked.");
}
void wallet2::commit_tx(std::vector<pending_tx>& ptx_vector, bool blink)
{
for (auto & ptx : ptx_vector)
{
commit_tx(ptx, blink);
}
}
//----------------------------------------------------------------------------------------------------
bool wallet2::save_tx(const std::vector<pending_tx>& ptx_vector, const std::string &filename) const
{
LOG_PRINT_L0("saving " << ptx_vector.size() << " transactions");
std::string ciphertext = dump_tx_to_str(ptx_vector);
if (ciphertext.empty())
return false;
return epee::file_io_utils::save_string_to_file(filename, ciphertext);
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::dump_tx_to_str(const std::vector<pending_tx> &ptx_vector) const
{
LOG_PRINT_L0("saving " << ptx_vector.size() << " transactions");
unsigned_tx_set txs;
for (auto &tx: ptx_vector)
{
// Short payment id is encrypted with tx_key.
// Since sign_tx() generates new tx_keys and encrypts the payment id, we need to save the decrypted payment ID
// Save tx construction_data to unsigned_tx_set
txs.txes.push_back(get_construction_data_with_decrypted_short_payment_id(tx, m_account.get_device()));
}
txs.transfers = export_outputs();
// save as binary
std::ostringstream oss;
boost::archive::portable_binary_oarchive ar(oss);
try
{
ar << txs;
}
catch (...)
{
return std::string();
}
LOG_PRINT_L2("Saving unsigned tx data: " << oss.str());
std::string ciphertext = encrypt_with_view_secret_key(oss.str());
return std::string(UNSIGNED_TX_PREFIX) + ciphertext;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::load_unsigned_tx(const std::string &unsigned_filename, unsigned_tx_set &exported_txs) const
{
std::string s;
boost::system::error_code errcode;
if (!boost::filesystem::exists(unsigned_filename, errcode))
{
LOG_PRINT_L0("File " << unsigned_filename << " does not exist: " << errcode);
return false;
}
if (!epee::file_io_utils::load_file_to_string(unsigned_filename.c_str(), s))
{
LOG_PRINT_L0("Failed to load from " << unsigned_filename);
return false;
}
return parse_unsigned_tx_from_str(s, exported_txs);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::parse_unsigned_tx_from_str(const std::string &unsigned_tx_st, unsigned_tx_set &exported_txs) const
{
std::string s = unsigned_tx_st;
const size_t magiclen = strlen(UNSIGNED_TX_PREFIX) - 1;
if (strncmp(s.c_str(), UNSIGNED_TX_PREFIX, magiclen))
{
LOG_PRINT_L0("Bad magic from unsigned tx");
return false;
}
s = s.substr(magiclen);
const char version = s[0];
s = s.substr(1);
if (version == '\003')
{
try
{
std::istringstream iss(s);
boost::archive::portable_binary_iarchive ar(iss);
ar >> exported_txs;
}
catch (...)
{
LOG_PRINT_L0("Failed to parse data from unsigned tx");
return false;
}
}
else if (version == '\004')
{
try
{
s = decrypt_with_view_secret_key(s);
try
{
std::istringstream iss(s);
boost::archive::portable_binary_iarchive ar(iss);
ar >> exported_txs;
}
catch (...)
{
LOG_PRINT_L0("Failed to parse data from unsigned tx");
return false;
}
}
catch (const std::exception &e)
{
LOG_PRINT_L0("Failed to decrypt unsigned tx: " << e.what());
return false;
}
}
else
{
LOG_PRINT_L0("Unsupported version in unsigned tx");
return false;
}
LOG_PRINT_L1("Loaded tx unsigned data from binary: " << exported_txs.txes.size() << " transactions");
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::sign_tx(const std::string &unsigned_filename, const std::string &signed_filename, std::vector<wallet2::pending_tx> &txs, std::function<bool(const unsigned_tx_set&)> accept_func, bool export_raw)
{
unsigned_tx_set exported_txs;
if(!load_unsigned_tx(unsigned_filename, exported_txs))
return false;
if (accept_func && !accept_func(exported_txs))
{
LOG_PRINT_L1("Transactions rejected by callback");
return false;
}
return sign_tx(exported_txs, signed_filename, txs, export_raw);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::sign_tx(unsigned_tx_set &exported_txs, std::vector<wallet2::pending_tx> &txs, signed_tx_set &signed_txes)
{
import_outputs(exported_txs.transfers);
// sign the transactions
for (size_t n = 0; n < exported_txs.txes.size(); ++n)
{
tools::wallet2::tx_construction_data &sd = exported_txs.txes[n];
THROW_WALLET_EXCEPTION_IF(sd.sources.empty(), error::wallet_internal_error, "Empty sources");
LOG_PRINT_L1(" " << (n+1) << ": " << sd.sources.size() << " inputs, ring size " << sd.sources[0].outputs.size());
signed_txes.ptx.push_back(pending_tx());
tools::wallet2::pending_tx &ptx = signed_txes.ptx.back();
rct::RCTConfig rct_config = sd.rct_config;
crypto::secret_key tx_key;
std::vector<crypto::secret_key> additional_tx_keys;
rct::multisig_out msout;
worktips_construct_tx_params tx_params;
tx_params.hf_version = sd.hf_version;
tx_params.tx_type = sd.tx_type;
bool r = cryptonote::construct_tx_and_get_tx_key(m_account.get_keys(), m_subaddresses, sd.sources, sd.splitted_dsts, sd.change_dts, sd.extra, ptx.tx, sd.unlock_time, tx_key, additional_tx_keys, rct_config, m_multisig ? &msout : NULL, tx_params);
THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sd.sources, sd.splitted_dsts, sd.unlock_time, m_nettype);
// we don't test tx size, because we don't know the current limit, due to not having a blockchain,
// and it's a bit pointless to fail there anyway, since it'd be a (good) guess only. We sign anyway,
// and if we really go over limit, the daemon will reject when it gets submitted. Chances are it's
// OK anyway since it was generated in the first place, and rerolling should be within a few bytes.
// normally, the tx keys are saved in commit_tx, when the tx is actually sent to the daemon.
// we can't do that here since the tx will be sent from the compromised wallet, which we don't want
// to see that info, so we save it here
if (store_tx_info())
{
const crypto::hash txid = get_transaction_hash(ptx.tx);
m_tx_keys.insert(std::make_pair(txid, tx_key));
m_additional_tx_keys.insert(std::make_pair(txid, additional_tx_keys));
}
std::string key_images;
bool all_are_txin_to_key = std::all_of(ptx.tx.vin.begin(), ptx.tx.vin.end(), [&](const txin_v& s_e) -> bool
{
CHECKED_GET_SPECIFIC_VARIANT(s_e, const txin_to_key, in, false);
key_images += boost::to_string(in.k_image) + " ";
return true;
});
THROW_WALLET_EXCEPTION_IF(!all_are_txin_to_key, error::unexpected_txin_type, ptx.tx);
ptx.key_images = key_images;
ptx.fee = 0;
for (const auto &i: sd.sources) ptx.fee += i.amount;
for (const auto &i: sd.splitted_dsts) ptx.fee -= i.amount;
ptx.dust = 0;
ptx.dust_added_to_fee = false;
ptx.change_dts = sd.change_dts;
ptx.selected_transfers = sd.selected_transfers;
ptx.tx_key = rct::rct2sk(rct::identity()); // don't send it back to the untrusted view wallet
ptx.dests = sd.dests;
ptx.construction_data = sd;
txs.push_back(ptx);
// add tx keys only to ptx
txs.back().tx_key = tx_key;
txs.back().additional_tx_keys = additional_tx_keys;
}
// add key image mapping for these txes
const account_keys &keys = get_account().get_keys();
hw::device &hwdev = m_account.get_device();
for (size_t n = 0; n < exported_txs.txes.size(); ++n)
{
const cryptonote::transaction &tx = signed_txes.ptx[n].tx;
crypto::key_derivation derivation;
std::vector<crypto::key_derivation> additional_derivations;
// compute public keys from out secret keys
crypto::public_key tx_pub_key;
crypto::secret_key_to_public_key(txs[n].tx_key, tx_pub_key);
std::vector<crypto::public_key> additional_tx_pub_keys;
for (const crypto::secret_key &skey: txs[n].additional_tx_keys)
{
additional_tx_pub_keys.resize(additional_tx_pub_keys.size() + 1);
crypto::secret_key_to_public_key(skey, additional_tx_pub_keys.back());
}
// compute derivations
hwdev.set_mode(hw::device::TRANSACTION_PARSE);
if (!hwdev.generate_key_derivation(tx_pub_key, keys.m_view_secret_key, derivation))
{
MWARNING("Failed to generate key derivation from tx pubkey in " << cryptonote::get_transaction_hash(tx) << ", skipping");
static_assert(sizeof(derivation) == sizeof(rct::key), "Mismatched sizes of key_derivation and rct::key");
memcpy(&derivation, rct::identity().bytes, sizeof(derivation));
}
for (size_t i = 0; i < additional_tx_pub_keys.size(); ++i)
{
additional_derivations.push_back({});
if (!hwdev.generate_key_derivation(additional_tx_pub_keys[i], keys.m_view_secret_key, additional_derivations.back()))
{
MWARNING("Failed to generate key derivation from additional tx pubkey in " << cryptonote::get_transaction_hash(tx) << ", skipping");
memcpy(&additional_derivations.back(), rct::identity().bytes, sizeof(crypto::key_derivation));
}
}
for (size_t i = 0; i < tx.vout.size(); ++i)
{
if (tx.vout[i].target.type() != typeid(cryptonote::txout_to_key))
continue;
const cryptonote::txout_to_key &out = boost::get<cryptonote::txout_to_key>(tx.vout[i].target);
// if this output is back to this wallet, we can calculate its key image already
if (!is_out_to_acc_precomp(m_subaddresses, out.key, derivation, additional_derivations, i, hwdev))
continue;
crypto::key_image ki;
cryptonote::keypair in_ephemeral;
if (generate_key_image_helper(keys, m_subaddresses, out.key, tx_pub_key, additional_tx_pub_keys, i, in_ephemeral, ki, hwdev))
signed_txes.tx_key_images[out.key] = ki;
else
MERROR("Failed to calculate key image");
}
}
// add key images
signed_txes.key_images.resize(m_transfers.size());
for (size_t i = 0; i < m_transfers.size(); ++i)
{
if (!m_transfers[i].m_key_image_known || m_transfers[i].m_key_image_partial)
LOG_PRINT_L0("WARNING: key image not known in signing wallet at index " << i);
signed_txes.key_images[i] = m_transfers[i].m_key_image;
}
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::sign_tx(unsigned_tx_set &exported_txs, const std::string &signed_filename, std::vector<wallet2::pending_tx> &txs, bool export_raw)
{
// sign the transactions
signed_tx_set signed_txes;
std::string ciphertext = sign_tx_dump_to_str(exported_txs, txs, signed_txes);
if (ciphertext.empty())
{
LOG_PRINT_L0("Failed to sign unsigned_tx_set");
return false;
}
if (!epee::file_io_utils::save_string_to_file(signed_filename, ciphertext))
{
LOG_PRINT_L0("Failed to save file to " << signed_filename);
return false;
}
// export signed raw tx without encryption
if (export_raw)
{
for (size_t i = 0; i < signed_txes.ptx.size(); ++i)
{
std::string tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(signed_txes.ptx[i].tx));
std::string raw_filename = signed_filename + "_raw" + (signed_txes.ptx.size() == 1 ? "" : ("_" + std::to_string(i)));
if (!epee::file_io_utils::save_string_to_file(raw_filename, tx_as_hex))
{
LOG_PRINT_L0("Failed to save file to " << raw_filename);
return false;
}
}
}
return true;
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::sign_tx_dump_to_str(unsigned_tx_set &exported_txs, std::vector<wallet2::pending_tx> &ptx, signed_tx_set &signed_txes)
{
// sign the transactions
bool r = sign_tx(exported_txs, ptx, signed_txes);
if (!r)
{
LOG_PRINT_L0("Failed to sign unsigned_tx_set");
return std::string();
}
// save as binary
std::ostringstream oss;
boost::archive::portable_binary_oarchive ar(oss);
try
{
ar << signed_txes;
}
catch(...)
{
return std::string();
}
LOG_PRINT_L3("Saving signed tx data (with encryption): " << oss.str());
std::string ciphertext = encrypt_with_view_secret_key(oss.str());
return std::string(SIGNED_TX_PREFIX) + ciphertext;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::load_tx(const std::string &signed_filename, std::vector<tools::wallet2::pending_tx> &ptx, std::function<bool(const signed_tx_set&)> accept_func)
{
std::string s;
boost::system::error_code errcode;
signed_tx_set signed_txs;
if (!boost::filesystem::exists(signed_filename, errcode))
{
LOG_PRINT_L0("File " << signed_filename << " does not exist: " << errcode);
return false;
}
if (!epee::file_io_utils::load_file_to_string(signed_filename.c_str(), s))
{
LOG_PRINT_L0("Failed to load from " << signed_filename);
return false;
}
return parse_tx_from_str(s, ptx, accept_func);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::parse_tx_from_str(const std::string &signed_tx_st, std::vector<tools::wallet2::pending_tx> &ptx, std::function<bool(const signed_tx_set &)> accept_func)
{
std::string s = signed_tx_st;
boost::system::error_code errcode;
signed_tx_set signed_txs;
const size_t magiclen = strlen(SIGNED_TX_PREFIX) - 1;
if (strncmp(s.c_str(), SIGNED_TX_PREFIX, magiclen))
{
LOG_PRINT_L0("Bad magic from signed transaction");
return false;
}
s = s.substr(magiclen);
const char version = s[0];
s = s.substr(1);
if (version == '\003')
{
try
{
std::istringstream iss(s);
boost::archive::portable_binary_iarchive ar(iss);
ar >> signed_txs;
}
catch (...)
{
LOG_PRINT_L0("Failed to parse data from signed transaction");
return false;
}
}
else if (version == '\004')
{
try
{
s = decrypt_with_view_secret_key(s);
try
{
std::istringstream iss(s);
boost::archive::portable_binary_iarchive ar(iss);
ar >> signed_txs;
}
catch (...)
{
LOG_PRINT_L0("Failed to parse decrypted data from signed transaction");
return false;
}
}
catch (const std::exception &e)
{
LOG_PRINT_L0("Failed to decrypt signed transaction: " << e.what());
return false;
}
}
else
{
LOG_PRINT_L0("Unsupported version in signed transaction");
return false;
}
LOG_PRINT_L0("Loaded signed tx data from binary: " << signed_txs.ptx.size() << " transactions");
for (auto &c_ptx: signed_txs.ptx) LOG_PRINT_L0(cryptonote::obj_to_json_str(c_ptx.tx));
if (accept_func && !accept_func(signed_txs))
{
LOG_PRINT_L1("Transactions rejected by callback");
return false;
}
// import key images
bool r = import_key_images(signed_txs.key_images);
if (!r) return false;
// remember key images for this tx, for when we get those txes from the blockchain
for (const auto &e: signed_txs.tx_key_images)
m_cold_key_images.insert(e);
ptx = signed_txs.ptx;
return true;
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::save_multisig_tx(multisig_tx_set txs)
{
LOG_PRINT_L0("saving " << txs.m_ptx.size() << " multisig transactions");
// txes generated, get rid of used k values
for (size_t n = 0; n < txs.m_ptx.size(); ++n)
for (size_t idx: txs.m_ptx[n].construction_data.selected_transfers)
m_transfers[idx].m_multisig_k.clear();
// zero out some data we don't want to share
for (auto &ptx: txs.m_ptx)
{
for (auto &e: ptx.construction_data.sources)
e.multisig_kLRki.k = rct::zero();
}
for (auto &ptx: txs.m_ptx)
{
// Get decrypted payment id from pending_tx
ptx.construction_data = get_construction_data_with_decrypted_short_payment_id(ptx, m_account.get_device());
}
// save as binary
std::ostringstream oss;
boost::archive::portable_binary_oarchive ar(oss);
try
{
ar << txs;
}
catch (...)
{
return std::string();
}
LOG_PRINT_L2("Saving multisig unsigned tx data: " << oss.str());
std::string ciphertext = encrypt_with_view_secret_key(oss.str());
return std::string(MULTISIG_UNSIGNED_TX_PREFIX) + ciphertext;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::save_multisig_tx(const multisig_tx_set &txs, const std::string &filename)
{
std::string ciphertext = save_multisig_tx(txs);
if (ciphertext.empty())
return false;
return epee::file_io_utils::save_string_to_file(filename, ciphertext);
}
//----------------------------------------------------------------------------------------------------
wallet2::multisig_tx_set wallet2::make_multisig_tx_set(const std::vector<pending_tx>& ptx_vector) const
{
multisig_tx_set txs;
txs.m_ptx = ptx_vector;
for (const auto &msk: get_account().get_multisig_keys())
{
crypto::public_key pkey = get_multisig_signing_public_key(msk);
for (auto &ptx: txs.m_ptx) for (auto &sig: ptx.multisig_sigs) sig.signing_keys.insert(pkey);
}
txs.m_signers.insert(get_multisig_signer_public_key());
return txs;
}
std::string wallet2::save_multisig_tx(const std::vector<pending_tx>& ptx_vector)
{
return save_multisig_tx(make_multisig_tx_set(ptx_vector));
}
//----------------------------------------------------------------------------------------------------
bool wallet2::save_multisig_tx(const std::vector<pending_tx>& ptx_vector, const std::string &filename)
{
std::string ciphertext = save_multisig_tx(ptx_vector);
if (ciphertext.empty())
return false;
return epee::file_io_utils::save_string_to_file(filename, ciphertext);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::parse_multisig_tx_from_str(std::string multisig_tx_st, multisig_tx_set &exported_txs) const
{
const size_t magiclen = strlen(MULTISIG_UNSIGNED_TX_PREFIX);
if (strncmp(multisig_tx_st.c_str(), MULTISIG_UNSIGNED_TX_PREFIX, magiclen))
{
LOG_PRINT_L0("Bad magic from multisig tx data");
return false;
}
try
{
multisig_tx_st = decrypt_with_view_secret_key(std::string(multisig_tx_st, magiclen));
}
catch (const std::exception &e)
{
LOG_PRINT_L0("Failed to decrypt multisig tx data: " << e.what());
return false;
}
try
{
std::istringstream iss(multisig_tx_st);
boost::archive::portable_binary_iarchive ar(iss);
ar >> exported_txs;
}
catch (...)
{
LOG_PRINT_L0("Failed to parse multisig tx data");
return false;
}
// sanity checks
for (const auto &ptx: exported_txs.m_ptx)
{
CHECK_AND_ASSERT_MES(ptx.selected_transfers.size() == ptx.tx.vin.size(), false, "Mismatched selected_transfers/vin sizes");
for (size_t idx: ptx.selected_transfers)
CHECK_AND_ASSERT_MES(idx < m_transfers.size(), false, "Transfer index out of range");
CHECK_AND_ASSERT_MES(ptx.construction_data.selected_transfers.size() == ptx.tx.vin.size(), false, "Mismatched cd selected_transfers/vin sizes");
for (size_t idx: ptx.construction_data.selected_transfers)
CHECK_AND_ASSERT_MES(idx < m_transfers.size(), false, "Transfer index out of range");
CHECK_AND_ASSERT_MES(ptx.construction_data.sources.size() == ptx.tx.vin.size(), false, "Mismatched sources/vin sizes");
}
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::load_multisig_tx(cryptonote::blobdata s, multisig_tx_set &exported_txs, std::function<bool(const multisig_tx_set&)> accept_func)
{
if(!parse_multisig_tx_from_str(s, exported_txs))
{
LOG_PRINT_L0("Failed to parse multisig transaction from string");
return false;
}
LOG_PRINT_L1("Loaded multisig tx unsigned data from binary: " << exported_txs.m_ptx.size() << " transactions");
for (auto &ptx: exported_txs.m_ptx) LOG_PRINT_L0(cryptonote::obj_to_json_str(ptx.tx));
if (accept_func && !accept_func(exported_txs))
{
LOG_PRINT_L1("Transactions rejected by callback");
return false;
}
const bool is_signed = exported_txs.m_signers.size() >= m_multisig_threshold;
if (is_signed)
{
for (const auto &ptx: exported_txs.m_ptx)
{
const crypto::hash txid = get_transaction_hash(ptx.tx);
if (store_tx_info())
{
m_tx_keys.insert(std::make_pair(txid, ptx.tx_key));
m_additional_tx_keys.insert(std::make_pair(txid, ptx.additional_tx_keys));
}
}
}
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::load_multisig_tx_from_file(const std::string &filename, multisig_tx_set &exported_txs, std::function<bool(const multisig_tx_set&)> accept_func)
{
std::string s;
boost::system::error_code errcode;
if (!boost::filesystem::exists(filename, errcode))
{
LOG_PRINT_L0("File " << filename << " does not exist: " << errcode);
return false;
}
if (!epee::file_io_utils::load_file_to_string(filename.c_str(), s))
{
LOG_PRINT_L0("Failed to load from " << filename);
return false;
}
if (!load_multisig_tx(s, exported_txs, accept_func))
{
LOG_PRINT_L0("Failed to parse multisig tx data from " << filename);
return false;
}
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::sign_multisig_tx(multisig_tx_set &exported_txs, std::vector<crypto::hash> &txids)
{
THROW_WALLET_EXCEPTION_IF(exported_txs.m_ptx.empty(), error::wallet_internal_error, "No tx found");
const crypto::public_key local_signer = get_multisig_signer_public_key();
THROW_WALLET_EXCEPTION_IF(exported_txs.m_signers.find(local_signer) != exported_txs.m_signers.end(),
error::wallet_internal_error, "Transaction already signed by this private key");
THROW_WALLET_EXCEPTION_IF(exported_txs.m_signers.size() > m_multisig_threshold,
error::wallet_internal_error, "Transaction was signed by too many signers");
THROW_WALLET_EXCEPTION_IF(exported_txs.m_signers.size() == m_multisig_threshold,
error::wallet_internal_error, "Transaction is already fully signed");
txids.clear();
// sign the transactions
for (size_t n = 0; n < exported_txs.m_ptx.size(); ++n)
{
tools::wallet2::pending_tx &ptx = exported_txs.m_ptx[n];
THROW_WALLET_EXCEPTION_IF(ptx.multisig_sigs.empty(), error::wallet_internal_error, "No signatures found in multisig tx");
tools::wallet2::tx_construction_data &sd = ptx.construction_data;
LOG_PRINT_L1(" " << (n+1) << ": " << sd.sources.size() << " inputs, mixin " << (sd.sources[0].outputs.size()-1) <<
", signed by " << exported_txs.m_signers.size() << "/" << m_multisig_threshold);
cryptonote::transaction tx;
rct::multisig_out msout = ptx.multisig_sigs.front().msout;
auto sources = sd.sources;
worktips_construct_tx_params tx_params;
tx_params.hf_version = sd.hf_version;
tx_params.tx_type = sd.tx_type;
rct::RCTConfig rct_config = sd.rct_config;
bool r = cryptonote::construct_tx_with_tx_key(m_account.get_keys(), m_subaddresses, sources, sd.splitted_dsts, ptx.change_dts, sd.extra, tx, sd.unlock_time, ptx.tx_key, ptx.additional_tx_keys, rct_config, &msout, false /*shuffle_outs*/, tx_params);
THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sd.sources, sd.splitted_dsts, sd.unlock_time, m_nettype);
THROW_WALLET_EXCEPTION_IF(get_transaction_prefix_hash (tx) != get_transaction_prefix_hash(ptx.tx),
error::wallet_internal_error, "Transaction prefix does not match data");
// Tests passed, sign
std::vector<unsigned int> indices;
for (const auto &source: sources)
indices.push_back(source.real_output);
for (auto &sig: ptx.multisig_sigs)
{
if (sig.ignore.find(local_signer) == sig.ignore.end())
{
ptx.tx.rct_signatures = sig.sigs;
rct::keyV k;
for (size_t idx: sd.selected_transfers)
k.push_back(get_multisig_k(idx, sig.used_L));
rct::key skey = rct::zero();
for (const auto &msk: get_account().get_multisig_keys())
{
crypto::public_key pmsk = get_multisig_signing_public_key(msk);
if (sig.signing_keys.find(pmsk) == sig.signing_keys.end())
{
sc_add(skey.bytes, skey.bytes, rct::sk2rct(msk).bytes);
sig.signing_keys.insert(pmsk);
}
}
THROW_WALLET_EXCEPTION_IF(!rct::signMultisig(ptx.tx.rct_signatures, indices, k, sig.msout, skey),
error::wallet_internal_error, "Failed signing, transaction likely malformed");
sig.sigs = ptx.tx.rct_signatures;
}
}
const bool is_last = exported_txs.m_signers.size() + 1 >= m_multisig_threshold;
if (is_last)
{
// when the last signature on a multisig tx is made, we select the right
// signature to plug into the final tx
bool found = false;
for (const auto &sig: ptx.multisig_sigs)
{
if (sig.ignore.find(local_signer) == sig.ignore.end() && !keys_intersect(sig.ignore, exported_txs.m_signers))
{
THROW_WALLET_EXCEPTION_IF(found, error::wallet_internal_error, "More than one transaction is final");
ptx.tx.rct_signatures = sig.sigs;
found = true;
}
}
THROW_WALLET_EXCEPTION_IF(!found, error::wallet_internal_error,
"Final signed transaction not found: this transaction was likely made without our export data, so we cannot sign it");
const crypto::hash txid = get_transaction_hash(ptx.tx);
if (store_tx_info())
{
m_tx_keys.insert(std::make_pair(txid, ptx.tx_key));
m_additional_tx_keys.insert(std::make_pair(txid, ptx.additional_tx_keys));
}
txids.push_back(txid);
}
}
// txes generated, get rid of used k values
for (size_t n = 0; n < exported_txs.m_ptx.size(); ++n)
for (size_t idx: exported_txs.m_ptx[n].construction_data.selected_transfers)
m_transfers[idx].m_multisig_k.clear();
exported_txs.m_signers.insert(get_multisig_signer_public_key());
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::sign_multisig_tx_to_file(multisig_tx_set &exported_txs, const std::string &filename, std::vector<crypto::hash> &txids)
{
bool r = sign_multisig_tx(exported_txs, txids);
if (!r)
return false;
return save_multisig_tx(exported_txs, filename);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::sign_multisig_tx_from_file(const std::string &filename, std::vector<crypto::hash> &txids, std::function<bool(const multisig_tx_set&)> accept_func)
{
multisig_tx_set exported_txs;
if(!load_multisig_tx_from_file(filename, exported_txs))
return false;
if (accept_func && !accept_func(exported_txs))
{
LOG_PRINT_L1("Transactions rejected by callback");
return false;
}
return sign_multisig_tx_to_file(exported_txs, filename, txids);
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::get_fee_percent(uint32_t priority, int fee_algorithm) const
{
static constexpr std::array<std::array<uint64_t, 4>, 3> percents = {{
{{100, 400, 2000, 16600}},
{{100, 500, 2500, 100000}},
{{100, 500, 2500, 12500}},
}};
if (fee_algorithm == -1)
fee_algorithm = get_fee_algorithm();
// 0 -> default (here, x1 till fee algorithm 2, x4 from it)
if (priority == 0)
priority = m_default_priority;
if (priority == 0)
priority = fee_algorithm >= 1 ? 2 : 1;
if (priority == BLINK_PRIORITY)
{
THROW_WALLET_EXCEPTION_IF(!use_fork_rules(HF_VERSION_BLINK, 0), error::invalid_priority);
return BLINK_MINER_TX_FEE_PERCENT + BLINK_BURN_TX_FEE_PERCENT;
}
THROW_WALLET_EXCEPTION_IF(
fee_algorithm < 0 || fee_algorithm >= (int)percents.size() ||
priority < 1 || priority > percents[0].size(),
error::invalid_priority);
return percents[fee_algorithm][priority-1];
}
//----------------------------------------------------------------------------------------------------
byte_and_output_fees wallet2::get_dynamic_base_fee_estimate() const
{
byte_and_output_fees fees;
boost::optional<std::string> failure = m_node_rpc_proxy.get_dynamic_base_fee_estimate(FEE_ESTIMATE_GRACE_BLOCKS, fees);
if (!failure)
return fees;
if (use_fork_rules(HF_VERSION_PER_OUTPUT_FEE))
fees = {FEE_PER_BYTE, FEE_PER_OUTPUT}; // v13 switches back from v12 per-byte fees, add per-output
else
fees = {FEE_PER_BYTE_V12, 0};
LOG_PRINT_L1("Failed to query base fee, using " << print_money(fees.first) << "/byte + " << print_money(fees.second) << "/output");
return fees;
}
//----------------------------------------------------------------------------------------------------
byte_and_output_fees wallet2::get_base_fees() const
{
if(m_light_wallet)
return {m_light_wallet_per_kb_fee / 1024, FEE_PER_OUTPUT};
return get_dynamic_base_fee_estimate();
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::get_fee_quantization_mask() const
{
if(m_light_wallet)
{
return 1; // TODO
}
uint64_t fee_quantization_mask;
boost::optional<std::string> result = m_node_rpc_proxy.get_fee_quantization_mask(fee_quantization_mask);
if (result)
return 1;
return fee_quantization_mask;
}
//----------------------------------------------------------------------------------------------------
int wallet2::get_fee_algorithm() const
{
// changes at v13
if (use_fork_rules(HF_VERSION_PER_OUTPUT_FEE, 0))
return 2;
return 1; // last changed at v10
}
//------------------------------------------------------------------------------------------------------------------------------
uint64_t wallet2::adjust_mixin(uint64_t mixin) const
{
if (mixin != 9) {
MWARNING("Requested ring size " << (mixin + 1) << " incorrect for worktips, using 10");
mixin = 9;
}
return mixin;
}
//----------------------------------------------------------------------------------------------------
uint32_t wallet2::adjust_priority(uint32_t priority)
{
if (priority == 0 && m_default_priority == 0 && auto_low_priority())
{
try
{
// check if there's a backlog in the tx pool
const uint64_t base_fee = get_base_fees().first;
const uint64_t fee_percent = get_fee_percent(1);
const double fee_level = base_fee * fee_percent / 100;
// NOTE (Worktips): We don't include the per-output fee here because we typically don't actually
// know how many outputs we will need yet, but it's okay: fee_level being too low will just
// make us a little over-cautious about using low-priority but will still work fine when the
// pool is empty.
const std::vector<std::pair<uint64_t, uint64_t>> blocks = estimate_backlog({std::make_pair(fee_level, fee_level)});
if (blocks.size() != 1)
{
MERROR("Bad estimated backlog array size");
return priority;
}
else if (blocks[0].first > 0)
{
MINFO("We don't use the low priority because there's a backlog in the tx pool.");
return priority;
}
// get the current full reward zone
uint64_t block_weight_limit = 0;
const auto result = m_node_rpc_proxy.get_block_weight_limit(block_weight_limit);
throw_on_rpc_response_error(result, "get_info");
const uint64_t full_reward_zone = block_weight_limit / 2;
// get the last N block headers and sum the block sizes
const size_t N = 10;
if (m_blockchain.size() < N)
{
MERROR("The blockchain is too short");
return priority;
}
cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::request getbh_req{};
cryptonote::COMMAND_RPC_GET_BLOCK_HEADERS_RANGE::response getbh_res{};
m_daemon_rpc_mutex.lock();
getbh_req.start_height = m_blockchain.size() - N;
getbh_req.end_height = m_blockchain.size() - 1;
bool r = invoke_http_json_rpc("/json_rpc", "getblockheadersrange", getbh_req, getbh_res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "getblockheadersrange");
THROW_WALLET_EXCEPTION_IF(getbh_res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "getblockheadersrange");
THROW_WALLET_EXCEPTION_IF(getbh_res.status != CORE_RPC_STATUS_OK, error::get_blocks_error, get_rpc_status(getbh_res.status));
if (getbh_res.headers.size() != N)
{
MERROR("Bad blockheaders size");
return priority;
}
size_t block_weight_sum = 0;
for (const cryptonote::block_header_response &i : getbh_res.headers)
{
block_weight_sum += i.block_weight;
}
// estimate how 'full' the last N blocks are
const size_t P = 100 * block_weight_sum / (N * full_reward_zone);
MINFO((boost::format("The last %d blocks fill roughly %d%% of the full reward zone.") % N % P).str());
if (P > 80)
{
MINFO("We don't use the low priority because recent blocks are quite full.");
return priority;
}
MINFO("We'll use the low priority because probably it's safe to do so.");
return 1;
}
catch (const std::exception &e)
{
MERROR(e.what());
}
}
return priority;
}
worktips_construct_tx_params wallet2::construct_params(uint32_t priority)
{
worktips_construct_tx_params tx_params;
if (priority == BLINK_PRIORITY)
{
tx_params.burn_fixed = BLINK_BURN_FIXED;
tx_params.burn_percent = BLINK_BURN_TX_FEE_PERCENT;
}
return tx_params;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::set_ring_database(const std::string &filename)
{
m_ring_database = filename;
MINFO("ringdb path set to " << filename);
m_ringdb.reset();
if (!m_ring_database.empty())
{
try
{
cryptonote::block b;
generate_genesis(b);
m_ringdb.reset(new tools::ringdb(m_ring_database, epee::string_tools::pod_to_hex(get_block_hash(b))));
}
catch (const std::exception &e)
{
MERROR("Failed to initialize ringdb: " << e.what());
m_ring_database = "";
return false;
}
}
return true;
}
crypto::chacha_key wallet2::get_ringdb_key()
{
if (!m_ringdb_key)
{
MINFO("caching ringdb key");
crypto::chacha_key key;
generate_chacha_key_from_secret_keys(key);
m_ringdb_key = key;
}
return *m_ringdb_key;
}
void wallet2::register_devices(){
hw::trezor::register_all();
}
hw::device& wallet2::lookup_device(const std::string & device_descriptor){
if (!m_devices_registered){
m_devices_registered = true;
register_devices();
}
return hw::get_device(device_descriptor);
}
bool wallet2::add_rings(const crypto::chacha_key &key, const cryptonote::transaction_prefix &tx)
{
if (!m_ringdb)
return false;
try { return m_ringdb->add_rings(key, tx); }
catch (const std::exception &e) { return false; }
}
bool wallet2::add_rings(const cryptonote::transaction_prefix &tx)
{
try { return add_rings(get_ringdb_key(), tx); }
catch (const std::exception &e) { return false; }
}
bool wallet2::remove_rings(const cryptonote::transaction_prefix &tx)
{
if (!m_ringdb)
return false;
try { return m_ringdb->remove_rings(get_ringdb_key(), tx); }
catch (const std::exception &e) { return false; }
}
bool wallet2::get_ring(const crypto::chacha_key &key, const crypto::key_image &key_image, std::vector<uint64_t> &outs)
{
if (!m_ringdb)
return false;
try { return m_ringdb->get_ring(key, key_image, outs); }
catch (const std::exception &e) { return false; }
}
bool wallet2::get_rings(const crypto::hash &txid, std::vector<std::pair<crypto::key_image, std::vector<uint64_t>>> &outs)
{
for (auto i: m_confirmed_txs)
{
if (txid == i.first)
{
for (const auto &x: i.second.m_rings)
outs.push_back({x.first, cryptonote::relative_output_offsets_to_absolute(x.second)});
return true;
}
}
for (auto i: m_unconfirmed_txs)
{
if (txid == i.first)
{
for (const auto &x: i.second.m_rings)
outs.push_back({x.first, cryptonote::relative_output_offsets_to_absolute(x.second)});
return true;
}
}
return false;
}
bool wallet2::get_ring(const crypto::key_image &key_image, std::vector<uint64_t> &outs)
{
try { return get_ring(get_ringdb_key(), key_image, outs); }
catch (const std::exception &e) { return false; }
}
bool wallet2::set_ring(const crypto::key_image &key_image, const std::vector<uint64_t> &outs, bool relative)
{
if (!m_ringdb)
return false;
try { return m_ringdb->set_ring(get_ringdb_key(), key_image, outs, relative); }
catch (const std::exception &e) { return false; }
}
bool wallet2::unset_ring(const std::vector<crypto::key_image> &key_images)
{
if (!m_ringdb)
return false;
try { return m_ringdb->remove_rings(get_ringdb_key(), key_images); }
catch (const std::exception &e) { return false; }
}
bool wallet2::unset_ring(const crypto::hash &txid)
{
if (!m_ringdb)
return false;
COMMAND_RPC_GET_TRANSACTIONS::request req;
COMMAND_RPC_GET_TRANSACTIONS::response res;
req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
req.decode_as_json = false;
req.prune = true;
m_daemon_rpc_mutex.lock();
bool ok = invoke_http_json("/gettransactions", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to get transaction from daemon");
if (res.txs.empty())
return false;
THROW_WALLET_EXCEPTION_IF(res.txs.size(), error::wallet_internal_error, "Failed to get transaction from daemon");
cryptonote::transaction tx;
crypto::hash tx_hash;
if (!get_pruned_tx(res.txs.front(), tx, tx_hash))
return false;
THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error, "Failed to get the right transaction from daemon");
try { return m_ringdb->remove_rings(get_ringdb_key(), tx); }
catch (const std::exception &e) { return false; }
}
bool wallet2::find_and_save_rings(bool force)
{
if (!force && m_ring_history_saved)
return true;
if (!m_ringdb)
return false;
COMMAND_RPC_GET_TRANSACTIONS::request req{};
COMMAND_RPC_GET_TRANSACTIONS::response res{};
MDEBUG("Finding and saving rings...");
// get payments we made
std::vector<crypto::hash> txs_hashes;
std::list<std::pair<crypto::hash,wallet2::confirmed_transfer_details>> payments;
get_payments_out(payments, 0, std::numeric_limits<uint64_t>::max(), boost::none, std::set<uint32_t>());
for (const std::pair<crypto::hash,wallet2::confirmed_transfer_details> &entry: payments)
{
const crypto::hash &txid = entry.first;
txs_hashes.push_back(txid);
}
MDEBUG("Found " << std::to_string(txs_hashes.size()) << " transactions");
// get those transactions from the daemon
auto it = txs_hashes.begin();
static const size_t SLICE_SIZE = 200;
for (size_t slice = 0; slice < txs_hashes.size(); slice += SLICE_SIZE)
{
req.decode_as_json = false;
req.prune = true;
req.txs_hashes.clear();
size_t ntxes = slice + SLICE_SIZE > txs_hashes.size() ? txs_hashes.size() - slice : SLICE_SIZE;
for (size_t s = slice; s < slice + ntxes; ++s)
req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txs_hashes[s]));
bool r;
{
const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
r = invoke_http_json("/gettransactions", req, res, rpc_timeout);
}
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.txs.size() != req.txs_hashes.size(), error::wallet_internal_error,
"daemon returned wrong response for gettransactions, wrong txs count = " +
std::to_string(res.txs.size()) + ", expected " + std::to_string(req.txs_hashes.size()));
MDEBUG("Scanning " << res.txs.size() << " transactions");
THROW_WALLET_EXCEPTION_IF(slice + res.txs.size() > txs_hashes.size(), error::wallet_internal_error, "Unexpected tx array size");
for (size_t i = 0; i < res.txs.size(); ++i, ++it)
{
const auto &tx_info = res.txs[i];
cryptonote::transaction tx;
crypto::hash tx_hash;
THROW_WALLET_EXCEPTION_IF(!get_pruned_tx(tx_info, tx, tx_hash), error::wallet_internal_error,
"Failed to get transaction from daemon");
THROW_WALLET_EXCEPTION_IF(!(tx_hash == *it), error::wallet_internal_error, "Wrong txid received");
THROW_WALLET_EXCEPTION_IF(!add_rings(get_ringdb_key(), tx), error::wallet_internal_error, "Failed to save ring");
}
}
MINFO("Found and saved rings for " << txs_hashes.size() << " transactions");
m_ring_history_saved = true;
return true;
}
bool wallet2::blackball_output(const std::pair<uint64_t, uint64_t> &output)
{
if (!m_ringdb)
return false;
try { return m_ringdb->blackball(output); }
catch (const std::exception &e) { return false; }
}
bool wallet2::set_blackballed_outputs(const std::vector<std::pair<uint64_t, uint64_t>> &outputs, bool add)
{
if (!m_ringdb)
return false;
try
{
bool ret = true;
if (!add)
ret &= m_ringdb->clear_blackballs();
ret &= m_ringdb->blackball(outputs);
return ret;
}
catch (const std::exception &e) { return false; }
}
bool wallet2::unblackball_output(const std::pair<uint64_t, uint64_t> &output)
{
if (!m_ringdb)
return false;
try { return m_ringdb->unblackball(output); }
catch (const std::exception &e) { return false; }
}
bool wallet2::is_output_blackballed(const std::pair<uint64_t, uint64_t> &output) const
{
if (!m_ringdb)
return false;
try { return m_ringdb->blackballed(output); }
catch (const std::exception &e) { return false; }
}
static const char *ERR_MSG_NETWORK_VERSION_QUERY_FAILED = tr("Could not query the current network version, try later");
static const char *ERR_MSG_NETWORK_HEIGHT_QUERY_FAILED = tr("Could not query the current network block height, try later: ");
static const char *ERR_MSG_SERVICE_NODE_LIST_QUERY_FAILED = tr("Failed to query daemon for service node list");
static const char *ERR_MSG_TOO_MANY_TXS_CONSTRUCTED = tr("Constructed too many transations, please sweep_all first");
static const char *ERR_MSG_EXCEPTION_THROWN = tr("Exception thrown, staking process could not be completed: ");
wallet2::stake_result wallet2::check_stake_allowed(const crypto::public_key& sn_key, const cryptonote::address_parse_info& addr_info, uint64_t& amount, double fraction)
{
wallet2::stake_result result = {};
result.status = wallet2::stake_result_status::invalid;
result.msg.reserve(128);
if (addr_info.has_payment_id)
{
result.status = stake_result_status::payment_id_disallowed;
result.msg = tr("Payment IDs cannot be used in a staking transaction");
return result;
}
if (addr_info.is_subaddress)
{
result.status = stake_result_status::subaddress_disallowed;
result.msg = tr("Subaddresses cannot be used in a staking transaction");
return result;
}
cryptonote::account_public_address const primary_address = get_address();
if (primary_address != addr_info.address)
{
result.status = stake_result_status::address_must_be_primary;
result.msg = tr("The specified address must be owned by this wallet and be the primary address of the wallet");
return result;
}
/// check that the service node is registered
boost::optional<std::string> failed;
const auto& response = this->get_service_nodes({ epee::string_tools::pod_to_hex(sn_key) }, failed);
if (failed)
{
result.status = stake_result_status::service_node_list_query_failed;
result.msg.reserve(failed->size() + 128);
result.msg = ERR_MSG_NETWORK_VERSION_QUERY_FAILED;
result.msg += *failed;
return result;
}
if (response.size() != 1)
{
result.status = stake_result_status::service_node_not_registered;
result.msg = tr("Could not find service node in service node list, please make sure it is registered first.");
return result;
}
const boost::optional<uint8_t> res = m_node_rpc_proxy.get_hardfork_version();
if (!res)
{
result.status = stake_result_status::network_version_query_failed;
result.msg = ERR_MSG_NETWORK_VERSION_QUERY_FAILED;
return result;
}
const auto& snode_info = response.front();
if (amount == 0) amount = snode_info.staking_requirement * fraction;
size_t total_num_locked_contributions = 0;
for (service_node_contributor const &contributor : snode_info.contributors)
total_num_locked_contributions += contributor.locked_contributions.size();
uint8_t const hf_version = *res;
uint64_t max_contrib_total = snode_info.staking_requirement - snode_info.total_reserved;
uint64_t min_contrib_total = service_nodes::get_min_node_contribution(hf_version, snode_info.staking_requirement, snode_info.total_reserved, total_num_locked_contributions);
bool is_preexisting_contributor = false;
for (const auto& contributor : snode_info.contributors)
{
address_parse_info info;
if (!cryptonote::get_account_address_from_str(info, m_nettype, contributor.address))
continue;
if (info.address == addr_info.address)
{
uint64_t const reserved_amount_not_contributed_yet = contributor.reserved - contributor.amount;
max_contrib_total += reserved_amount_not_contributed_yet;
is_preexisting_contributor = true;
min_contrib_total = std::max(min_contrib_total, reserved_amount_not_contributed_yet);
break;
}
}
if (max_contrib_total == 0)
{
result.status = stake_result_status::service_node_contribution_maxed;
result.msg = tr("The service node cannot receive any more Worktips from this wallet");
return result;
}
const bool full = snode_info.contributors.size() >= MAX_NUMBER_OF_CONTRIBUTORS;
if (full && !is_preexisting_contributor)
{
result.status = stake_result_status::service_node_contributors_maxed;
result.msg = tr("The service node already has the maximum number of participants and this wallet is not one of them");
return result;
}
if (amount < min_contrib_total)
{
const uint64_t DUST = MAX_NUMBER_OF_CONTRIBUTORS;
if (min_contrib_total - amount <= DUST)
{
amount = min_contrib_total;
result.msg += tr("Seeing as this is insufficient by dust amounts, amount was increased automatically to ");
result.msg += print_money(min_contrib_total);
result.msg += "\n";
}
else
{
result.status = stake_result_status::service_node_insufficient_contribution;
result.msg.reserve(128);
result.msg = tr("You must contribute at least ");
result.msg += print_money(min_contrib_total);
result.msg += tr(" worktips to become a contributor for this service node.");
return result;
}
}
if (amount > max_contrib_total)
{
result.msg += tr("You may only contribute up to ");
result.msg += print_money(max_contrib_total);
result.msg += tr(" more worktips to this service node. ");
result.msg += tr("Reducing your stake from ");
result.msg += print_money(amount);
result.msg += tr(" to ");
result.msg += print_money(max_contrib_total);
result.msg += tr("\n");
amount = max_contrib_total;
}
result.status = stake_result_status::success;
return result;
}
wallet2::stake_result wallet2::create_stake_tx(const crypto::public_key& service_node_key, const cryptonote::address_parse_info& addr_info, uint64_t amount, double amount_fraction, uint32_t priority, uint32_t subaddr_account, std::set<uint32_t> subaddr_indices)
{
wallet2::stake_result result = {};
result.status = wallet2::stake_result_status::invalid;
try
{
result = check_stake_allowed(service_node_key, addr_info, amount, amount_fraction);
if (result.status != stake_result_status::success)
return result;
}
catch (const std::exception& e)
{
result.status = stake_result_status::exception_thrown;
result.msg = ERR_MSG_EXCEPTION_THROWN;
result.msg += e.what();
return result;
}
const cryptonote::account_public_address& address = addr_info.address;
std::vector<uint8_t> extra;
add_service_node_pubkey_to_tx_extra(extra, service_node_key);
add_service_node_contributor_to_tx_extra(extra, address);
vector<cryptonote::tx_destination_entry> dsts;
cryptonote::tx_destination_entry de = {};
de.addr = address;
de.is_subaddress = false;
de.amount = amount;
dsts.push_back(de);
std::string err, err2;
const uint64_t bc_height = std::max(get_daemon_blockchain_height(err),
get_daemon_blockchain_target_height(err2));
if (!err.empty() || !err2.empty())
{
result.msg = ERR_MSG_NETWORK_HEIGHT_QUERY_FAILED;
result.msg += (err.empty() ? err2 : err);
result.status = stake_result_status::network_height_query_failed;
return result;
}
constexpr uint64_t unlock_at_block = 0; // Infinite staking, no time lock
if (subaddr_account != 0)
{
result.msg = tr("Infinite staking does not allow staking from a subaddress");
result.status = stake_result_status::subaddress_disallowed;
return result;
}
try
{
priority = adjust_priority(priority);
if (priority == BLINK_PRIORITY)
{
result.status = stake_result_status::no_blink;
result.msg += tr("Service node stakes cannot use blink priority");
return result;
}
boost::optional<uint8_t> hf_version = get_hard_fork_version();
if (!hf_version)
{
result.status = stake_result_status::network_version_query_failed;
result.msg = ERR_MSG_NETWORK_VERSION_QUERY_FAILED;
return result;
}
auto ptx_vector = create_transactions_2(dsts, CRYPTONOTE_DEFAULT_TX_MIXIN, unlock_at_block, priority, extra, subaddr_account, subaddr_indices, txtype::stake);
if (ptx_vector.size() == 1)
{
result.status = stake_result_status::success;
result.ptx = ptx_vector[0];
}
else
{
result.status = stake_result_status::too_many_transactions_constructed;
result.msg = ERR_MSG_TOO_MANY_TXS_CONSTRUCTED;
}
}
catch (const std::exception& e)
{
result.status = stake_result_status::exception_thrown;
result.msg = ERR_MSG_EXCEPTION_THROWN;
result.msg += e.what();
return result;
}
assert(result.status != stake_result_status::invalid);
return result;
}
wallet2::register_service_node_result wallet2::create_register_service_node_tx(const std::vector<std::string> &args_, uint32_t subaddr_account)
{
std::vector<std::string> local_args = args_;
register_service_node_result result = {};
result.status = register_service_node_result_status::invalid;
//
// Parse Tx Args
//
std::set<uint32_t> subaddr_indices;
uint32_t priority = 0;
{
if (local_args.size() > 0 && local_args[0].substr(0, 6) == "index=")
{
if (!tools::parse_subaddress_indices(local_args[0], subaddr_indices))
{
result.status = register_service_node_result_status::subaddr_indices_parse_fail;
result.msg = tr("Could not parse subaddress indices argument: ") + local_args[0];
return result;
}
local_args.erase(local_args.begin());
}
if (local_args.size() > 0 && parse_priority(local_args[0], priority))
local_args.erase(local_args.begin());
priority = adjust_priority(priority);
if (priority == BLINK_PRIORITY)
{
result.status = register_service_node_result_status::no_blink;
result.msg += tr("Service node registrations cannot use blink priority");
return result;
}
if (local_args.size() < 6)
{
result.status = register_service_node_result_status::insufficient_num_args;
result.msg += tr("\nPrepare this command in the daemon with the prepare_registration command");
result.msg += tr("\nThis command must be run from the daemon that will be acting as a service node");
return result;
}
}
//
// Parse Registration Contributor Args
//
boost::optional<uint8_t> hf_version = get_hard_fork_version();
if (!hf_version)
{
result.status = register_service_node_result_status::network_version_query_failed;
result.msg = ERR_MSG_NETWORK_VERSION_QUERY_FAILED;
return result;
}
uint64_t staking_requirement = 0, bc_height = 0;
service_nodes::converted_registration_args converted_args = {};
{
std::string err, err2;
bc_height = std::max(get_daemon_blockchain_height(err),
get_daemon_blockchain_target_height(err2));
{
if (!err.empty() || !err2.empty())
{
result.msg = ERR_MSG_NETWORK_HEIGHT_QUERY_FAILED;
result.msg += (err.empty() ? err2 : err);
result.status = register_service_node_result_status::network_height_query_failed;
return result;
}
if (!is_synced())
{
result.status = register_service_node_result_status::wallet_not_synced;
result.msg = tr("Wallet is not synced. Please synchronise your wallet to the blockchain");
return result;
}
}
staking_requirement = service_nodes::get_staking_requirement(nettype(), bc_height, *hf_version);
std::vector<std::string> const registration_args(local_args.begin(), local_args.begin() + local_args.size() - 3);
converted_args = service_nodes::convert_registration_args(nettype(), registration_args, staking_requirement, *hf_version);
if (!converted_args.success)
{
result.status = register_service_node_result_status::convert_registration_args_failed;
result.msg = tr("Could not convert registration args, reason: ") + converted_args.err_msg;
return result;
}
}
cryptonote::account_public_address address = converted_args.addresses[0];
if (!contains_address(address))
{
result.status = register_service_node_result_status::first_address_must_be_primary_address;
result.msg = tr(
"The first reserved address for this registration does not belong to this wallet.\n"
"Service node operator must specify an address owned by this wallet for service node registration."
);
return result;
}
//
// Parse Registration Metadata Args
//
size_t const timestamp_index = local_args.size() - 3;
size_t const key_index = local_args.size() - 2;
size_t const signature_index = local_args.size() - 1;
const std::string &service_node_key_as_str = local_args[key_index];
crypto::public_key service_node_key;
crypto::signature signature;
uint64_t expiration_timestamp = 0;
{
try
{
expiration_timestamp = boost::lexical_cast<uint64_t>(local_args[timestamp_index]);
if (expiration_timestamp <= (uint64_t)time(nullptr) + 600 /* 10 minutes */)
{
result.status = register_service_node_result_status::registration_timestamp_expired;
result.msg = tr("The registration timestamp has expired.");
return result;
}
}
catch (const std::exception &e)
{
result.status = register_service_node_result_status::registration_timestamp_expired;
result.msg = tr("The registration timestamp failed to parse: ") + local_args[timestamp_index];
return result;
}
if (!epee::string_tools::hex_to_pod(local_args[key_index], service_node_key))
{
result.status = register_service_node_result_status::service_node_key_parse_fail;
result.msg = tr("Failed to parse service node pubkey");
return result;
}
if (!epee::string_tools::hex_to_pod(local_args[signature_index], signature))
{
result.status = register_service_node_result_status::service_node_signature_parse_fail;
result.msg = tr("Failed to parse service node signature");
return result;
}
}
std::vector<uint8_t> extra;
add_service_node_contributor_to_tx_extra(extra, address);
add_service_node_pubkey_to_tx_extra(extra, service_node_key);
if (!add_service_node_register_to_tx_extra(extra, converted_args.addresses, converted_args.portions_for_operator, converted_args.portions, expiration_timestamp, signature))
{
result.status = register_service_node_result_status::service_node_register_serialize_to_tx_extra_fail;
result.msg = tr("Failed to serialize service node registration tx extra");
return result;
}
//
// Check service is able to be registered
//
refresh(false);
{
boost::optional<std::string> failed;
const std::vector<cryptonote::COMMAND_RPC_GET_SERVICE_NODES::response::entry> response = get_service_nodes({service_node_key_as_str}, failed);
if (failed)
{
result.status = register_service_node_result_status::service_node_list_query_failed;
result.msg = ERR_MSG_NETWORK_VERSION_QUERY_FAILED;
return result;
}
if (response.size() >= 1)
{
result.status = register_service_node_result_status::service_node_cannot_reregister;
result.msg = tr("This service node is already registered");
return result;
}
}
//
// Create Register Transaction
//
{
uint64_t amount_payable_by_operator = 0;
{
const uint64_t DUST = MAX_NUMBER_OF_CONTRIBUTORS;
uint64_t amount_left = staking_requirement;
for (size_t i = 0; i < converted_args.portions.size(); i++)
{
uint64_t amount = service_nodes::portions_to_amount(staking_requirement, converted_args.portions[i]);
if (i == 0) amount_payable_by_operator += amount;
amount_left -= amount;
}
if (amount_left <= DUST)
amount_payable_by_operator += amount_left;
}
vector<cryptonote::tx_destination_entry> dsts;
cryptonote::tx_destination_entry de;
de.addr = address;
de.is_subaddress = false;
de.amount = amount_payable_by_operator;
dsts.push_back(de);
try
{
// NOTE(worktips): We know the address should always be a primary address and has no payment id, so we can ignore the subaddress/payment id field here
cryptonote::address_parse_info dest = {};
dest.address = address;
auto ptx_vector = create_transactions_2(dsts, CRYPTONOTE_DEFAULT_TX_MIXIN, 0 /* unlock_time */, priority, extra, subaddr_account, subaddr_indices, txtype::stake);
if (ptx_vector.size() == 1)
{
result.status = register_service_node_result_status::success;
result.ptx = ptx_vector[0];
}
else
{
result.status = register_service_node_result_status::too_many_transactions_constructed;
result.msg = ERR_MSG_TOO_MANY_TXS_CONSTRUCTED;
}
}
catch (const std::exception& e)
{
result.status = register_service_node_result_status::exception_thrown;
result.msg = ERR_MSG_EXCEPTION_THROWN;
result.msg += e.what();
return result;
}
}
assert(result.status != register_service_node_result_status::invalid);
return result;
}
wallet2::request_stake_unlock_result wallet2::can_request_stake_unlock(const crypto::public_key &sn_key)
{
request_stake_unlock_result result = {};
result.ptx.tx.version = cryptonote::txversion::v4_tx_types;
result.ptx.tx.type = cryptonote::txtype::key_image_unlock;
std::string const sn_key_as_str = epee::string_tools::pod_to_hex(sn_key);
{
using namespace cryptonote;
boost::optional<std::string> failed;
const std::vector<COMMAND_RPC_GET_SERVICE_NODES::response::entry> response = get_service_nodes({sn_key_as_str}, failed);
if (failed)
{
result.msg = *failed;
return result;
}
if (response.empty())
{
result.msg = tr("No service node is known for: ") + sn_key_as_str;
return result;
}
cryptonote::account_public_address const primary_address = get_address();
std::vector<service_node_contribution> const *contributions = nullptr;
COMMAND_RPC_GET_SERVICE_NODES::response::entry const &node_info = response[0];
for (service_node_contributor const &contributor : node_info.contributors)
{
address_parse_info address_info = {};
cryptonote::get_account_address_from_str(address_info, nettype(), contributor.address);
if (address_info.address != primary_address)
continue;
contributions = &contributor.locked_contributions;
break;
}
if (!contributions)
{
result.msg = tr("No contributions recognised by this wallet in service node: ") + sn_key_as_str;
return result;
}
if (contributions->empty())
{
result.msg = tr("Unexpected 0 contributions in service node for this wallet ") + sn_key_as_str;
return result;
}
cryptonote::tx_extra_tx_key_image_unlock unlock = {};
{
uint64_t curr_height = 0;
{
std::string err_msg;
curr_height = get_daemon_blockchain_height(err_msg);
if (!err_msg.empty())
{
result.msg = tr("unable to get network blockchain height from daemon: ") + err_msg;
return result;
}
}
result.msg.reserve(1024);
service_node_contribution const &contribution = (*contributions)[0];
if (node_info.requested_unlock_height != 0)
{
result.msg.append("Key image: ");
result.msg.append(contribution.key_image);
result.msg.append(" has already been requested to be unlocked, unlocking at height: ");
result.msg.append(std::to_string(node_info.requested_unlock_height));
result.msg.append(" (about ");
result.msg.append(tools::get_human_readable_timespan(std::chrono::seconds((node_info.requested_unlock_height - curr_height) * DIFFICULTY_TARGET_V2)));
result.msg.append(")");
return result;
}
result.msg.append("You are requesting to unlock a stake of: ");
result.msg.append(cryptonote::print_money(contribution.amount));
result.msg.append(" Worktips from the service node network.\nThis will schedule the service node: ");
result.msg.append(node_info.service_node_pubkey);
result.msg.append(" for deactivation.");
if (node_info.contributors.size() > 1) {
result.msg.append(" The stakes of the service node's ");
result.msg.append(std::to_string(node_info.contributors.size() - 1));
result.msg.append(" other contributors will unlock at the same time.");
}
result.msg.append("\n\n");
uint64_t unlock_height = service_nodes::get_locked_key_image_unlock_height(nettype(), node_info.registration_height, curr_height);
result.msg.append("You will continue receiving rewards until the service node expires at the estimated height: ");
result.msg.append(std::to_string(unlock_height));
result.msg.append(" (about ");
result.msg.append(tools::get_human_readable_timespan(std::chrono::seconds((unlock_height - curr_height) * DIFFICULTY_TARGET_V2)));
result.msg.append(")");
cryptonote::blobdata binary_buf;
if(!string_tools::parse_hexstr_to_binbuff(contribution.key_image, binary_buf) || binary_buf.size() != sizeof(crypto::key_image))
{
result.msg = tr("Failed to parse hex representation of key image: ") + contribution.key_image;
return result;
}
unlock.key_image = *reinterpret_cast<const crypto::key_image*>(binary_buf.data());
if (!generate_signature_for_request_stake_unlock(unlock.key_image, unlock.signature, unlock.nonce))
{
result.msg = tr("Failed to generate signature to sign request. The key image: ") + contribution.key_image + (" doesn't belong to this wallet");
return result;
}
}
add_service_node_pubkey_to_tx_extra(result.ptx.tx.extra, sn_key);
add_tx_key_image_unlock_to_tx_extra(result.ptx.tx.extra, unlock);
}
result.success = true;
return result;
}
bool wallet2::lock_keys_file()
{
if (m_keys_file_locker)
{
MDEBUG(m_keys_file << " is already locked.");
return false;
}
m_keys_file_locker.reset(new tools::file_locker(m_keys_file));
return true;
}
bool wallet2::unlock_keys_file()
{
if (!m_keys_file_locker)
{
MDEBUG(m_keys_file << " is already unlocked.");
return false;
}
m_keys_file_locker.reset();
return true;
}
bool wallet2::is_keys_file_locked() const
{
return m_keys_file_locker->locked();
}
bool wallet2::tx_add_fake_output(std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs, uint64_t global_index, const crypto::public_key& output_public_key, const rct::key& mask, uint64_t real_index, bool unlocked) const
{
if (!unlocked) // don't add locked outs
return false;
if (global_index == real_index) // don't re-add real one
return false;
auto item = std::make_tuple(global_index, output_public_key, mask);
CHECK_AND_ASSERT_MES(!outs.empty(), false, "internal error: outs is empty");
if (std::find(outs.back().begin(), outs.back().end(), item) != outs.back().end()) // don't add duplicates
return false;
// check the keys are valid
if (!rct::isInMainSubgroup(rct::pk2rct(output_public_key)))
{
// TODO(worktips): FIXME(worktips): Payouts to the null service node address are
// transactions constructed with an invalid public key and fail this check.
// Technically we should not be mixing them- but in test environments like
// stagenet/testnet where there may be extended periods of time where there
// are many payouts to the null service node, then during fake output
// selection they are considered invalid.
// And upon removing all of them, we end up with insufficient outputs to
// construct a valid mixin for the transaction. This causes construction to
// spuriously fail reliably on such networks.
// So for now, let it slide on test networks. Ideally we want to fix this,
// such that we never include them for "correctness" of the network.
// For mainnet though, enforce this check. If we start failing to construct
// transaction(s) on the mainnet due to invalid keys then we want to know
// and address it, as it is at the moment mainnet is not affected by this
// and so we want the added correctness this check offers.
if (nettype() == cryptonote::MAINNET)
{
MWARNING("Key " << output_public_key << " at index " << global_index << " is not in the main subgroup");
return false;
}
}
if (!rct::isInMainSubgroup(mask))
{
MWARNING("Commitment " << mask << " at index " << global_index << " is not in the main subgroup");
return false;
}
// if (is_output_blackballed(output_public_key)) // don't add blackballed outputs
// return false;
outs.back().push_back(item);
return true;
}
void wallet2::light_wallet_get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs, const std::vector<size_t> &selected_transfers, size_t fake_outputs_count) {
MDEBUG("LIGHTWALLET - Getting random outs");
cryptonote::COMMAND_RPC_GET_RANDOM_OUTS::request oreq;
cryptonote::COMMAND_RPC_GET_RANDOM_OUTS::response ores;
size_t light_wallet_requested_outputs_count = (size_t)((fake_outputs_count + 1) * 1.5 + 1);
// Amounts to ask for
// MyMonero api handle amounts and fees as strings
for(size_t idx: selected_transfers) {
const uint64_t ask_amount = m_transfers[idx].is_rct() ? 0 : m_transfers[idx].amount();
std::ostringstream amount_ss;
amount_ss << ask_amount;
oreq.amounts.push_back(amount_ss.str());
}
oreq.count = light_wallet_requested_outputs_count;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/get_random_outs", oreq, ores, rpc_timeout, "POST");
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_random_outs");
THROW_WALLET_EXCEPTION_IF(ores.amount_outs.empty() , error::wallet_internal_error, "No outputs received from light wallet node. Error: " + ores.Error);
// Check if we got enough outputs for each amount
for(auto& out: ores.amount_outs) {
const uint64_t out_amount = boost::lexical_cast<uint64_t>(out.amount);
THROW_WALLET_EXCEPTION_IF(out.outputs.size() < light_wallet_requested_outputs_count , error::wallet_internal_error, "Not enough outputs for amount: " + boost::lexical_cast<std::string>(out.amount));
MDEBUG(out.outputs.size() << " outputs for amount "+ boost::lexical_cast<std::string>(out.amount) + " received from light wallet node");
}
MDEBUG("selected transfers size: " << selected_transfers.size());
for(size_t idx: selected_transfers)
{
// Create new index
outs.push_back(std::vector<get_outs_entry>());
outs.back().reserve(fake_outputs_count + 1);
// add real output first
const transfer_details &td = m_transfers[idx];
const uint64_t amount = td.is_rct() ? 0 : td.amount();
outs.back().push_back(std::make_tuple(td.m_global_output_index, td.get_public_key(), rct::commit(td.amount(), td.m_mask)));
MDEBUG("added real output " << string_tools::pod_to_hex(td.get_public_key()));
// Even if the lightwallet server returns random outputs, we pick them randomly.
std::vector<size_t> order;
order.resize(light_wallet_requested_outputs_count);
for (size_t n = 0; n < order.size(); ++n)
order[n] = n;
std::shuffle(order.begin(), order.end(), std::default_random_engine(crypto::rand<unsigned>()));
LOG_PRINT_L2("Looking for " << (fake_outputs_count+1) << " outputs with amounts " << print_money(td.is_rct() ? 0 : td.amount()));
MDEBUG("OUTS SIZE: " << outs.back().size());
for (size_t o = 0; o < light_wallet_requested_outputs_count && outs.back().size() < fake_outputs_count + 1; ++o)
{
// Random pick
size_t i = order[o];
// Find which random output key to use
bool found_amount = false;
size_t amount_key;
for(amount_key = 0; amount_key < ores.amount_outs.size(); ++amount_key)
{
if(boost::lexical_cast<uint64_t>(ores.amount_outs[amount_key].amount) == amount) {
found_amount = true;
break;
}
}
THROW_WALLET_EXCEPTION_IF(!found_amount , error::wallet_internal_error, "Outputs for amount " + boost::lexical_cast<std::string>(ores.amount_outs[amount_key].amount) + " not found" );
LOG_PRINT_L2("Index " << i << "/" << light_wallet_requested_outputs_count << ": idx " << ores.amount_outs[amount_key].outputs[i].global_index << " (real " << td.m_global_output_index << "), unlocked " << "(always in light)" << ", key " << ores.amount_outs[0].outputs[i].public_key);
// Convert light wallet string data to proper data structures
crypto::public_key tx_public_key;
rct::key mask{}; // decrypted mask - not used here
rct::key rct_commit{};
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, ores.amount_outs[amount_key].outputs[i].public_key), error::wallet_internal_error, "Invalid public_key");
string_tools::hex_to_pod(ores.amount_outs[amount_key].outputs[i].public_key, tx_public_key);
const uint64_t global_index = ores.amount_outs[amount_key].outputs[i].global_index;
if(!light_wallet_parse_rct_str(ores.amount_outs[amount_key].outputs[i].rct, tx_public_key, 0, mask, rct_commit, false))
rct_commit = rct::zeroCommit(td.amount());
if (tx_add_fake_output(outs, global_index, tx_public_key, rct_commit, td.m_global_output_index, true)) {
MDEBUG("added fake output " << ores.amount_outs[amount_key].outputs[i].public_key);
MDEBUG("index " << global_index);
}
}
THROW_WALLET_EXCEPTION_IF(outs.back().size() < fake_outputs_count + 1 , error::wallet_internal_error, "Not enough fake outputs found" );
// Real output is the first. Shuffle outputs
MTRACE(outs.back().size() << " outputs added. Sorting outputs by index:");
std::sort(outs.back().begin(), outs.back().end(), [](const get_outs_entry &a, const get_outs_entry &b) { return std::get<0>(a) < std::get<0>(b); });
// Print output order
for(auto added_out: outs.back())
MTRACE(std::get<0>(added_out));
}
}
void wallet2::get_outs(std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs, const std::vector<size_t> &selected_transfers, size_t fake_outputs_count, bool has_rct)
{
LOG_PRINT_L2("fake_outputs_count: " << fake_outputs_count);
outs.clear();
if(m_light_wallet && fake_outputs_count > 0) {
light_wallet_get_outs(outs, selected_transfers, fake_outputs_count);
return;
}
if (fake_outputs_count > 0)
{
uint64_t segregation_fork_height = get_segregation_fork_height();
// check whether we're shortly after the fork
uint64_t height;
boost::optional<std::string> result = m_node_rpc_proxy.get_height(height);
throw_on_rpc_response_error(result, "get_info");
bool is_shortly_after_segregation_fork = height >= segregation_fork_height && height < segregation_fork_height + SEGREGATION_FORK_VICINITY;
bool is_after_segregation_fork = height >= segregation_fork_height;
// if we have at least one rct out, get the distribution, or fall back to the previous system
uint64_t rct_start_height;
std::vector<uint64_t> rct_offsets;
const bool has_rct_distribution = has_rct && get_rct_distribution(rct_start_height, rct_offsets);
// get histogram for the amounts we need
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request req_t{};
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response resp_t{};
{
uint64_t max_rct_index = 0;
for (size_t idx: selected_transfers)
{
if (m_transfers[idx].is_rct())
{
max_rct_index = std::max(max_rct_index, m_transfers[idx].m_global_output_index);
}
// request histogram for all outputs, except 0 if we have the rct distribution
if (!m_transfers[idx].is_rct() || !has_rct_distribution)
{
req_t.amounts.push_back(m_transfers[idx].is_rct() ? 0 : m_transfers[idx].amount());
}
}
if (has_rct_distribution)
{
// check we're clear enough of rct start, to avoid corner cases below
THROW_WALLET_EXCEPTION_IF(rct_offsets.size() <= CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE,
error::get_output_distribution, "Not enough rct outputs");
THROW_WALLET_EXCEPTION_IF(rct_offsets.back() <= max_rct_index,
error::get_output_distribution, "Daemon reports suspicious number of rct outputs");
}
}
std::vector<uint64_t> output_blacklist;
if (bool get_output_blacklist_failed = !get_output_blacklist(output_blacklist))
THROW_WALLET_EXCEPTION_IF(get_output_blacklist_failed, error::get_output_blacklist, "Couldn't retrive list of outputs that are to be exlcuded from selection");
std::sort(output_blacklist.begin(), output_blacklist.end());
if (output_blacklist.size() * 0.05 > (double)rct_offsets.size())
{
MWARNING("More than 5% of outputs are blacklisted ("
<< output_blacklist.size() << "/" << rct_offsets.size()
<< "), please notify the Worktips developers");
}
if (!req_t.amounts.empty())
{
std::sort(req_t.amounts.begin(), req_t.amounts.end());
auto end = std::unique(req_t.amounts.begin(), req_t.amounts.end());
req_t.amounts.resize(std::distance(req_t.amounts.begin(), end));
req_t.unlocked = true;
req_t.recent_cutoff = time(NULL) - RECENT_OUTPUT_ZONE;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json_rpc("/json_rpc", "get_output_histogram", req_t, resp_t, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "transfer_selected");
THROW_WALLET_EXCEPTION_IF(resp_t.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_output_histogram");
THROW_WALLET_EXCEPTION_IF(resp_t.status != CORE_RPC_STATUS_OK, error::get_histogram_error, get_rpc_status(resp_t.status));
}
// if we want to segregate fake outs pre or post fork, get distribution
std::unordered_map<uint64_t, std::pair<uint64_t, uint64_t>> segregation_limit;
if (is_after_segregation_fork && (m_segregate_pre_fork_outputs || m_key_reuse_mitigation2))
{
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::request req_t{};
cryptonote::COMMAND_RPC_GET_OUTPUT_DISTRIBUTION::response resp_t{};
for(size_t idx: selected_transfers)
req_t.amounts.push_back(m_transfers[idx].is_rct() ? 0 : m_transfers[idx].amount());
std::sort(req_t.amounts.begin(), req_t.amounts.end());
auto end = std::unique(req_t.amounts.begin(), req_t.amounts.end());
req_t.amounts.resize(std::distance(req_t.amounts.begin(), end));
req_t.from_height = std::max<uint64_t>(segregation_fork_height, RECENT_OUTPUT_BLOCKS) - RECENT_OUTPUT_BLOCKS;
req_t.to_height = segregation_fork_height + 1;
req_t.cumulative = true;
req_t.binary = true;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json_rpc("/json_rpc", "get_output_distribution", req_t, resp_t, rpc_timeout * 1000);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "transfer_selected");
THROW_WALLET_EXCEPTION_IF(resp_t.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_output_distribution");
THROW_WALLET_EXCEPTION_IF(resp_t.status != CORE_RPC_STATUS_OK, error::get_output_distribution, get_rpc_status(resp_t.status));
// check we got all data
for(size_t idx: selected_transfers)
{
const uint64_t amount = m_transfers[idx].is_rct() ? 0 : m_transfers[idx].amount();
bool found = false;
for (const auto &d: resp_t.distributions)
{
if (d.amount == amount)
{
THROW_WALLET_EXCEPTION_IF(d.data.start_height > segregation_fork_height, error::get_output_distribution, "Distribution start_height too high");
THROW_WALLET_EXCEPTION_IF(segregation_fork_height - d.data.start_height >= d.data.distribution.size(), error::get_output_distribution, "Distribution size too small");
THROW_WALLET_EXCEPTION_IF(segregation_fork_height - RECENT_OUTPUT_BLOCKS - d.data.start_height >= d.data.distribution.size(), error::get_output_distribution, "Distribution size too small");
THROW_WALLET_EXCEPTION_IF(segregation_fork_height <= RECENT_OUTPUT_BLOCKS, error::wallet_internal_error, "Fork height too low");
THROW_WALLET_EXCEPTION_IF(segregation_fork_height - RECENT_OUTPUT_BLOCKS < d.data.start_height, error::get_output_distribution, "Bad start height");
uint64_t till_fork = d.data.distribution[segregation_fork_height - d.data.start_height];
uint64_t recent = till_fork - d.data.distribution[segregation_fork_height - RECENT_OUTPUT_BLOCKS - d.data.start_height];
segregation_limit[amount] = std::make_pair(till_fork, recent);
found = true;
break;
}
}
THROW_WALLET_EXCEPTION_IF(!found, error::get_output_distribution, "Requested amount not found in response");
}
}
// we ask for more, to have spares if some outputs are still locked
size_t base_requested_outputs_count = (size_t)((fake_outputs_count + 1) * 1.5 + 1);
LOG_PRINT_L2("base_requested_outputs_count: " << base_requested_outputs_count);
// generate output indices to request
COMMAND_RPC_GET_OUTPUTS_BIN::request req{};
COMMAND_RPC_GET_OUTPUTS_BIN::response daemon_resp{};
std::unique_ptr<gamma_picker> gamma;
if (has_rct_distribution)
gamma.reset(new gamma_picker(rct_offsets));
size_t num_selected_transfers = 0;
for(size_t idx: selected_transfers)
{
++num_selected_transfers;
const transfer_details &td = m_transfers[idx];
const uint64_t amount = td.is_rct() ? 0 : td.amount();
std::unordered_set<uint64_t> seen_indices;
// request more for rct in base recent (locked) coinbases are picked, since they're locked for longer
size_t requested_outputs_count = base_requested_outputs_count + (td.is_rct() ? CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE : 0);
size_t start = req.outputs.size();
bool use_histogram = amount != 0 || !has_rct_distribution;
const bool output_is_pre_fork = td.m_block_height < segregation_fork_height;
uint64_t num_outs = 0, num_recent_outs = 0;
uint64_t num_post_fork_outs = 0;
float pre_fork_num_out_ratio = 0.0f;
float post_fork_num_out_ratio = 0.0f;
if (is_after_segregation_fork && m_segregate_pre_fork_outputs && output_is_pre_fork)
{
num_outs = segregation_limit[amount].first;
num_recent_outs = segregation_limit[amount].second;
}
else
{
// if there are just enough outputs to mix with, use all of them.
// Eventually this should become impossible.
for (const auto &he: resp_t.histogram)
{
if (he.amount == amount)
{
LOG_PRINT_L2("Found " << print_money(amount) << ": " << he.total_instances << " total, "
<< he.unlocked_instances << " unlocked, " << he.recent_instances << " recent");
num_outs = he.unlocked_instances;
num_recent_outs = he.recent_instances;
break;
}
}
if (is_after_segregation_fork && m_key_reuse_mitigation2)
{
if (output_is_pre_fork)
{
if (is_shortly_after_segregation_fork)
{
pre_fork_num_out_ratio = 33.4/100.0f * (1.0f - RECENT_OUTPUT_RATIO);
}
else
{
pre_fork_num_out_ratio = 33.4/100.0f * (1.0f - RECENT_OUTPUT_RATIO);
post_fork_num_out_ratio = 33.4/100.0f * (1.0f - RECENT_OUTPUT_RATIO);
}
}
else
{
if (is_shortly_after_segregation_fork)
{
}
else
{
post_fork_num_out_ratio = 67.8/100.0f * (1.0f - RECENT_OUTPUT_RATIO);
}
}
}
num_post_fork_outs = num_outs - segregation_limit[amount].first;
}
if (use_histogram)
{
LOG_PRINT_L1("" << num_outs << " unlocked outputs of size " << print_money(amount));
THROW_WALLET_EXCEPTION_IF(num_outs == 0, error::wallet_internal_error,
"histogram reports no unlocked outputs for " + boost::lexical_cast<std::string>(amount) + ", not even ours");
THROW_WALLET_EXCEPTION_IF(num_recent_outs > num_outs, error::wallet_internal_error,
"histogram reports more recent outs than outs for " + boost::lexical_cast<std::string>(amount));
}
else
{
// the base offset of the first rct output in the first unlocked block (or the one to be if there's none)
num_outs = rct_offsets[rct_offsets.size() - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE];
LOG_PRINT_L1("" << num_outs << " unlocked rct outputs");
THROW_WALLET_EXCEPTION_IF(num_outs == 0, error::wallet_internal_error,
"histogram reports no unlocked rct outputs, not even ours");
}
// how many fake outs to draw on a pre-fork distribution
size_t pre_fork_outputs_count = requested_outputs_count * pre_fork_num_out_ratio;
size_t post_fork_outputs_count = requested_outputs_count * post_fork_num_out_ratio;
// how many fake outs to draw otherwise
size_t normal_output_count = requested_outputs_count - pre_fork_outputs_count - post_fork_outputs_count;
size_t recent_outputs_count = 0;
if (use_histogram)
{
// X% of those outs are to be taken from recent outputs
recent_outputs_count = normal_output_count * RECENT_OUTPUT_RATIO;
if (recent_outputs_count == 0)
recent_outputs_count = 1; // ensure we have at least one, if possible
if (recent_outputs_count > num_recent_outs)
recent_outputs_count = num_recent_outs;
if (td.m_global_output_index >= num_outs - num_recent_outs && recent_outputs_count > 0)
--recent_outputs_count; // if the real out is recent, pick one less recent fake out
}
LOG_PRINT_L1("Fake output makeup: " << requested_outputs_count << " requested: " << recent_outputs_count << " recent, " <<
pre_fork_outputs_count << " pre-fork, " << post_fork_outputs_count << " post-fork, " <<
(requested_outputs_count - recent_outputs_count - pre_fork_outputs_count - post_fork_outputs_count) << " full-chain");
uint64_t num_found = 0;
// if we have a known ring, use it
if (td.m_key_image_known && !td.m_key_image_partial)
{
std::vector<uint64_t> ring;
if (get_ring(get_ringdb_key(), td.m_key_image, ring))
{
MINFO("This output has a known ring, reusing (size " << ring.size() << ")");
THROW_WALLET_EXCEPTION_IF(ring.size() > fake_outputs_count + 1, error::wallet_internal_error,
"An output in this transaction was previously spent on another chain with ring size " +
std::to_string(ring.size()) + ", it cannot be spent now with ring size " +
std::to_string(fake_outputs_count + 1) + " as it is smaller: use a higher ring size");
bool own_found = false;
for (const auto &out: ring)
{
MINFO("Ring has output " << out);
if (out < num_outs)
{
MINFO("Using it");
req.outputs.push_back({amount, out});
++num_found;
seen_indices.emplace(out);
if (out == td.m_global_output_index)
{
MINFO("This is the real output");
own_found = true;
}
}
else
{
MINFO("Ignoring output " << out << ", too recent");
}
}
THROW_WALLET_EXCEPTION_IF(!own_found, error::wallet_internal_error,
"Known ring does not include the spent output: " + std::to_string(td.m_global_output_index));
}
}
if (num_outs <= requested_outputs_count)
{
for (uint64_t i = 0; i < num_outs; i++)
req.outputs.push_back({amount, i});
// duplicate to make up shortfall: this will be caught after the RPC call,
// so we can also output the amounts for which we can't reach the required
// mixin after checking the actual unlockedness
for (uint64_t i = num_outs; i < requested_outputs_count; ++i)
req.outputs.push_back({amount, num_outs - 1});
}
else
{
// start with real one
if (num_found == 0)
{
num_found = 1;
seen_indices.emplace(td.m_global_output_index);
req.outputs.push_back({amount, td.m_global_output_index});
LOG_PRINT_L1("Selecting real output: " << td.m_global_output_index << " for " << print_money(amount));
}
std::unordered_map<const char*, std::set<uint64_t>> picks;
// while we still need more mixins
uint64_t num_usable_outs = num_outs;
bool allow_blackballed_or_blacklisted = false;
MDEBUG("Starting gamma picking with " << num_outs << ", num_usable_outs " << num_usable_outs
<< ", requested_outputs_count " << requested_outputs_count);
while (num_found < requested_outputs_count)
{
// if we've gone through every possible output, we've gotten all we can
if (seen_indices.size() == num_usable_outs)
{
// there is a first pass which rejects blackballed/listed outputs, then a second pass
// which allows them if we don't have enough non blackballed/list outputs to reach
// the required amount of outputs (since consensus does not care about blackballed/listed
// outputs, we still need to reach the minimum ring size)
if (allow_blackballed_or_blacklisted)
break;
MINFO("Not enough output not marked as spent, we'll allow outputs marked as spent and outputs with known destinations and amounts");
allow_blackballed_or_blacklisted = true;
num_usable_outs = num_outs;
}
// get a random output index from the DB. If we've already seen it,
// return to the top of the loop and try again, otherwise add it to the
// list of output indices we've seen.
uint64_t i;
const char *type = "";
if (amount == 0 && has_rct_distribution)
{
THROW_WALLET_EXCEPTION_IF(!gamma, error::wallet_internal_error, "No gamma picker");
// gamma distribution
if (num_found -1 < recent_outputs_count + pre_fork_outputs_count)
{
do i = gamma->pick(); while (i >= segregation_limit[amount].first);
type = "pre-fork gamma";
}
else if (num_found -1 < recent_outputs_count + pre_fork_outputs_count + post_fork_outputs_count)
{
do i = gamma->pick(); while (i < segregation_limit[amount].first || i >= num_outs);
type = "post-fork gamma";
}
else
{
do i = gamma->pick(); while (i >= num_outs);
type = "gamma";
}
}
else if (num_found - 1 < recent_outputs_count) // -1 to account for the real one we seeded with
{
// triangular distribution over [a,b) with a=0, mode c=b=up_index_limit
uint64_t r = crypto::rand<uint64_t>() % ((uint64_t)1 << 53);
double frac = std::sqrt((double)r / ((uint64_t)1 << 53));
i = (uint64_t)(frac*num_recent_outs) + num_outs - num_recent_outs;
// just in case rounding up to 1 occurs after calc
if (i == num_outs)
--i;
type = "recent";
}
else if (num_found -1 < recent_outputs_count + pre_fork_outputs_count)
{
// triangular distribution over [a,b) with a=0, mode c=b=up_index_limit
uint64_t r = crypto::rand<uint64_t>() % ((uint64_t)1 << 53);
double frac = std::sqrt((double)r / ((uint64_t)1 << 53));
i = (uint64_t)(frac*segregation_limit[amount].first);
// just in case rounding up to 1 occurs after calc
if (i == num_outs)
--i;
type = " pre-fork";
}
else if (num_found -1 < recent_outputs_count + pre_fork_outputs_count + post_fork_outputs_count)
{
// triangular distribution over [a,b) with a=0, mode c=b=up_index_limit
uint64_t r = crypto::rand<uint64_t>() % ((uint64_t)1 << 53);
double frac = std::sqrt((double)r / ((uint64_t)1 << 53));
i = (uint64_t)(frac*num_post_fork_outs) + segregation_limit[amount].first;
// just in case rounding up to 1 occurs after calc
if (i == num_post_fork_outs+segregation_limit[amount].first)
--i;
type = "post-fork";
}
else
{
// triangular distribution over [a,b) with a=0, mode c=b=up_index_limit
uint64_t r = crypto::rand<uint64_t>() % ((uint64_t)1 << 53);
double frac = std::sqrt((double)r / ((uint64_t)1 << 53));
i = (uint64_t)(frac*num_outs);
// just in case rounding up to 1 occurs after calc
if (i == num_outs)
--i;
type = "triangular";
}
if (seen_indices.count(i))
continue;
if (!allow_blackballed_or_blacklisted)
{
if (is_output_blackballed(std::make_pair(amount, i)) ||
std::binary_search(output_blacklist.begin(), output_blacklist.end(), i))
{
--num_usable_outs;
continue;
}
}
seen_indices.emplace(i);
picks[type].insert(i);
req.outputs.push_back({amount, i});
++num_found;
MDEBUG("picked " << i << ", " << num_found << " now picked");
}
for (const auto &pick: picks)
MDEBUG("picking " << pick.first << " outputs: " <<
boost::join(pick.second | boost::adaptors::transformed([](uint64_t out){return std::to_string(out);}), " "));
// if we had enough unusable outputs, we might fall off here and still
// have too few outputs, so we stuff with one to keep counts good, and
// we'll error out later
while (num_found < requested_outputs_count)
{
req.outputs.push_back({amount, 0});
++num_found;
}
}
// sort the subsection, to ensure the daemon doesn't know which output is ours
std::sort(req.outputs.begin() + start, req.outputs.end(),
[](const get_outputs_out &a, const get_outputs_out &b) { return a.index < b.index; });
}
if (ELPP->vRegistry()->allowed(el::Level::Debug, WORKTIPS_DEFAULT_LOG_CATEGORY))
{
std::map<uint64_t, std::set<uint64_t>> outs;
for (const auto &i: req.outputs)
outs[i.amount].insert(i.index);
for (const auto &o: outs)
MDEBUG("asking for outputs with amount " << print_money(o.first) << ": " <<
boost::join(o.second | boost::adaptors::transformed([](uint64_t out){return std::to_string(out);}), " "));
}
// get the keys for those
req.get_txid = false;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_bin("/get_outs.bin", req, daemon_resp, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_outs.bin");
THROW_WALLET_EXCEPTION_IF(daemon_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_outs.bin");
THROW_WALLET_EXCEPTION_IF(daemon_resp.status != CORE_RPC_STATUS_OK, error::get_outs_error, get_rpc_status(daemon_resp.status));
THROW_WALLET_EXCEPTION_IF(daemon_resp.outs.size() != req.outputs.size(), error::wallet_internal_error,
"daemon returned wrong response for get_outs.bin, wrong amounts count = " +
std::to_string(daemon_resp.outs.size()) + ", expected " + std::to_string(req.outputs.size()));
std::unordered_map<uint64_t, uint64_t> scanty_outs;
size_t base = 0;
outs.reserve(num_selected_transfers);
for(size_t idx: selected_transfers)
{
const transfer_details &td = m_transfers[idx];
size_t requested_outputs_count = base_requested_outputs_count + (td.is_rct() ? CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE : 0);
outs.push_back(std::vector<get_outs_entry>());
outs.back().reserve(fake_outputs_count + 1);
const rct::key mask = td.is_rct() ? rct::commit(td.amount(), td.m_mask) : rct::zeroCommit(td.amount());
uint64_t num_outs = 0;
const uint64_t amount = td.is_rct() ? 0 : td.amount();
const bool output_is_pre_fork = td.m_block_height < segregation_fork_height;
if (is_after_segregation_fork && m_segregate_pre_fork_outputs && output_is_pre_fork)
num_outs = segregation_limit[amount].first;
else for (const auto &he: resp_t.histogram)
{
if (he.amount == amount)
{
num_outs = he.unlocked_instances;
break;
}
}
bool use_histogram = amount != 0 || !has_rct_distribution;
if (!use_histogram)
num_outs = rct_offsets[rct_offsets.size() - CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE];
// make sure the real outputs we asked for are really included, along
// with the correct key and mask: this guards against an active attack
// where the node sends dummy data for all outputs, and we then send
// the real one, which the node can then tell from the fake outputs,
// as it has different data than the dummy data it had sent earlier
bool real_out_found = false;
for (size_t n = 0; n < requested_outputs_count; ++n)
{
size_t i = base + n;
if (req.outputs[i].index == td.m_global_output_index)
if (daemon_resp.outs[i].key == boost::get<txout_to_key>(td.m_tx.vout[td.m_internal_output_index].target).key)
if (daemon_resp.outs[i].mask == mask)
{
real_out_found = true;
break;
}
}
THROW_WALLET_EXCEPTION_IF(!real_out_found, error::wallet_internal_error,
"Daemon response did not include the requested real output");
// pick real out first (it will be sorted when done)
outs.back().push_back(std::make_tuple(td.m_global_output_index, boost::get<txout_to_key>(td.m_tx.vout[td.m_internal_output_index].target).key, mask));
// then pick outs from an existing ring, if any
if (td.m_key_image_known && !td.m_key_image_partial)
{
std::vector<uint64_t> ring;
if (get_ring(get_ringdb_key(), td.m_key_image, ring))
{
for (uint64_t out: ring)
{
if (out < num_outs)
{
if (out != td.m_global_output_index)
{
bool found = false;
for (size_t o = 0; o < requested_outputs_count; ++o)
{
size_t i = base + o;
if (req.outputs[i].index == out)
{
LOG_PRINT_L2("Index " << i << "/" << requested_outputs_count << ": idx " << req.outputs[i].index << " (real " << td.m_global_output_index << "), unlocked " << daemon_resp.outs[i].unlocked << ", key " << daemon_resp.outs[i].key << " (from existing ring)");
tx_add_fake_output(outs, req.outputs[i].index, daemon_resp.outs[i].key, daemon_resp.outs[i].mask, td.m_global_output_index, daemon_resp.outs[i].unlocked);
found = true;
break;
}
}
THROW_WALLET_EXCEPTION_IF(!found, error::wallet_internal_error, "Falied to find existing ring output in daemon out data");
}
}
}
}
}
// then pick others in random order till we reach the required number
// since we use an equiprobable pick here, we don't upset the triangular distribution
std::vector<size_t> order;
order.resize(requested_outputs_count);
for (size_t n = 0; n < order.size(); ++n)
order[n] = n;
std::shuffle(order.begin(), order.end(), std::default_random_engine(crypto::rand<unsigned>()));
LOG_PRINT_L2("Looking for " << (fake_outputs_count+1) << " outputs of size " << print_money(td.is_rct() ? 0 : td.amount()));
for (size_t o = 0; o < requested_outputs_count && outs.back().size() < fake_outputs_count + 1; ++o)
{
size_t i = base + order[o];
LOG_PRINT_L2("Index " << i << "/" << requested_outputs_count << ": idx " << req.outputs[i].index << " (real " << td.m_global_output_index << "), unlocked " << daemon_resp.outs[i].unlocked << ", key " << daemon_resp.outs[i].key);
tx_add_fake_output(outs, req.outputs[i].index, daemon_resp.outs[i].key, daemon_resp.outs[i].mask, td.m_global_output_index, daemon_resp.outs[i].unlocked);
}
if (outs.back().size() < fake_outputs_count + 1)
{
scanty_outs[td.is_rct() ? 0 : td.amount()] = outs.back().size();
}
else
{
// sort the subsection, so any spares are reset in order
std::sort(outs.back().begin(), outs.back().end(), [](const get_outs_entry &a, const get_outs_entry &b) { return std::get<0>(a) < std::get<0>(b); });
}
base += requested_outputs_count;
}
THROW_WALLET_EXCEPTION_IF(!scanty_outs.empty(), error::not_enough_outs_to_mix, scanty_outs, fake_outputs_count);
}
else
{
for (size_t idx: selected_transfers)
{
const transfer_details &td = m_transfers[idx];
std::vector<get_outs_entry> v;
const rct::key mask = td.is_rct() ? rct::commit(td.amount(), td.m_mask) : rct::zeroCommit(td.amount());
v.push_back(std::make_tuple(td.m_global_output_index, td.get_public_key(), mask));
outs.push_back(v);
}
}
// save those outs in the ringdb for reuse
for (size_t i = 0; i < selected_transfers.size(); ++i)
{
const size_t idx = selected_transfers[i];
THROW_WALLET_EXCEPTION_IF(idx >= m_transfers.size(), error::wallet_internal_error, "selected_transfers entry out of range");
const transfer_details &td = m_transfers[idx];
std::vector<uint64_t> ring;
ring.reserve(outs[i].size());
for (const auto &e: outs[i])
ring.push_back(std::get<0>(e));
if (!set_ring(td.m_key_image, ring, false))
MERROR("Failed to set ring for " << td.m_key_image);
}
}
void wallet2::transfer_selected_rct(std::vector<cryptonote::tx_destination_entry> dsts, const std::vector<size_t>& selected_transfers, size_t fake_outputs_count,
std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs,
uint64_t unlock_time, uint64_t fee, const std::vector<uint8_t>& extra, cryptonote::transaction& tx, pending_tx &ptx, const rct::RCTConfig &rct_config, const worktips_construct_tx_params &tx_params)
{
using namespace cryptonote;
// throw if attempting a transaction with no destinations
THROW_WALLET_EXCEPTION_IF(dsts.empty(), error::zero_destination);
uint64_t upper_transaction_weight_limit = get_upper_transaction_weight_limit();
uint64_t needed_money = fee;
LOG_PRINT_L2("transfer_selected_rct: starting with fee " << print_money (needed_money));
LOG_PRINT_L2("selected transfers: " << strjoin(selected_transfers, " "));
// calculate total amount being sent to all destinations
// throw if total amount overflows uint64_t
for(auto& dt: dsts)
{
THROW_WALLET_EXCEPTION_IF(0 == dt.amount, error::zero_destination);
needed_money += dt.amount;
LOG_PRINT_L2("transfer: adding " << print_money(dt.amount) << ", for a total of " << print_money (needed_money));
THROW_WALLET_EXCEPTION_IF(needed_money < dt.amount, error::tx_sum_overflow, dsts, fee, m_nettype);
}
// if this is a multisig wallet, create a list of multisig signers we can use
std::deque<crypto::public_key> multisig_signers;
size_t n_multisig_txes = 0;
std::vector<std::unordered_set<crypto::public_key>> ignore_sets;
if (m_multisig && !m_transfers.empty())
{
const crypto::public_key local_signer = get_multisig_signer_public_key();
size_t n_available_signers = 1;
// At this step we need to define set of participants available for signature,
// i.e. those of them who exchanged with multisig info's
for (const crypto::public_key &signer: m_multisig_signers)
{
if (signer == local_signer)
continue;
for (const auto &i: m_transfers[0].m_multisig_info)
{
if (i.m_signer == signer)
{
multisig_signers.push_back(signer);
++n_available_signers;
break;
}
}
}
// n_available_signers includes the transaction creator, but multisig_signers doesn't
MDEBUG("We can use " << n_available_signers << "/" << m_multisig_signers.size() << " other signers");
THROW_WALLET_EXCEPTION_IF(n_available_signers < m_multisig_threshold, error::multisig_import_needed);
if (n_available_signers > m_multisig_threshold)
{
// If there more potential signers (those who exchanged with multisig info)
// than threshold needed some of them should be skipped since we don't know
// who will sign tx and who won't. Hence we don't contribute their LR pairs to the signature.
// We create as many transactions as many combinations of excluded signers may be.
// For example, if we have 2/4 wallet and wallets are: A, B, C and D. Let A be
// transaction creator, so we need just 1 signature from set of B, C, D.
// Using "excluding" logic here we have to exclude 2-of-3 wallets. Combinations go as follows:
// BC, BD, and CD. We save these sets to use later and counting the number of required txs.
tools::Combinator<crypto::public_key> c(std::vector<crypto::public_key>(multisig_signers.begin(), multisig_signers.end()));
auto ignore_combinations = c.combine(multisig_signers.size() + 1 - m_multisig_threshold);
for (const auto& combination: ignore_combinations)
{
ignore_sets.push_back(std::unordered_set<crypto::public_key>(combination.begin(), combination.end()));
}
n_multisig_txes = ignore_sets.size();
}
else
{
// If we have exact count of signers just to fit in threshold we don't exclude anyone and create 1 transaction
n_multisig_txes = 1;
}
MDEBUG("We will create " << n_multisig_txes << " txes");
}
uint64_t found_money = 0;
uint32_t subaddr_account = 0;
bool has_rct = false;
for (size_t i = 0; i < selected_transfers.size(); i++)
{
size_t transfer_idx = selected_transfers[i];
transfer_details const &td = m_transfers[transfer_idx];
has_rct |= td.is_rct();
found_money += td.amount();
if (i == 0)
subaddr_account = m_transfers[transfer_idx].m_subaddr_index.major;
else
THROW_WALLET_EXCEPTION_IF(subaddr_account != m_transfers[transfer_idx].m_subaddr_index.major, error::wallet_internal_error, "the tx uses funds from multiple accounts");
}
LOG_PRINT_L2("wanted " << print_money(needed_money) << ", found " << print_money(found_money) << ", fee " << print_money(fee));
THROW_WALLET_EXCEPTION_IF(found_money < needed_money, error::not_enough_unlocked_money, found_money, needed_money - fee, fee);
if (outs.empty())
get_outs(outs, selected_transfers, fake_outputs_count, has_rct); // may throw
//prepare inputs
LOG_PRINT_L2("preparing outputs");
size_t i = 0, out_index = 0;
std::vector<cryptonote::tx_source_entry> sources;
std::unordered_set<rct::key> used_L;
for(size_t idx: selected_transfers)
{
sources.resize(sources.size()+1);
cryptonote::tx_source_entry& src = sources.back();
const transfer_details& td = m_transfers[idx];
src.amount = td.amount();
src.rct = td.is_rct();
//paste mixin transaction
THROW_WALLET_EXCEPTION_IF(outs.size() < out_index + 1 , error::wallet_internal_error, "outs.size() < out_index + 1");
THROW_WALLET_EXCEPTION_IF(outs[out_index].size() < fake_outputs_count , error::wallet_internal_error, "fake_outputs_count > random outputs found");
typedef cryptonote::tx_source_entry::output_entry tx_output_entry;
for (size_t n = 0; n < fake_outputs_count + 1; ++n)
{
tx_output_entry oe;
oe.first = std::get<0>(outs[out_index][n]);
oe.second.dest = rct::pk2rct(std::get<1>(outs[out_index][n]));
oe.second.mask = std::get<2>(outs[out_index][n]);
src.outputs.push_back(oe);
}
++i;
//paste real transaction to the random index
auto it_to_replace = std::find_if(src.outputs.begin(), src.outputs.end(), [&](const tx_output_entry& a)
{
return a.first == td.m_global_output_index;
});
THROW_WALLET_EXCEPTION_IF(it_to_replace == src.outputs.end(), error::wallet_internal_error,
"real output not found");
tx_output_entry real_oe;
real_oe.first = td.m_global_output_index;
real_oe.second.dest = rct::pk2rct(td.get_public_key());
real_oe.second.mask = rct::commit(td.amount(), td.m_mask);
*it_to_replace = real_oe;
src.real_out_tx_key = get_tx_pub_key_from_extra(td.m_tx, td.m_pk_index);
src.real_out_additional_tx_keys = get_additional_tx_pub_keys_from_extra(td.m_tx);
src.real_output = it_to_replace - src.outputs.begin();
src.real_output_in_tx_index = td.m_internal_output_index;
src.mask = td.m_mask;
if (m_multisig)
{
auto ignore_set = ignore_sets.empty() ? std::unordered_set<crypto::public_key>() : ignore_sets.front();
src.multisig_kLRki = get_multisig_composite_kLRki(idx, ignore_set, used_L, used_L);
}
else
src.multisig_kLRki = rct::multisig_kLRki({rct::zero(), rct::zero(), rct::zero(), rct::zero()});
detail::print_source_entry(src);
++out_index;
}
LOG_PRINT_L2("outputs prepared");
// we still keep a copy, since we want to keep dsts free of change for user feedback purposes
std::vector<cryptonote::tx_destination_entry> splitted_dsts = dsts;
cryptonote::tx_destination_entry change_dts{};
change_dts.amount = found_money - needed_money;
if (change_dts.amount == 0)
{
if (splitted_dsts.size() == 1)
{
// If the change is 0, send it to a random address, to avoid confusing
// the sender with a 0 amount output. We send a 0 amount in order to avoid
// letting the destination be able to work out which of the inputs is the
// real one in our rings
LOG_PRINT_L2("generating dummy address for 0 change");
cryptonote::account_base dummy;
dummy.generate();
change_dts.addr = dummy.get_keys().m_account_address;
LOG_PRINT_L2("generated dummy address for 0 change");
splitted_dsts.push_back(change_dts);
}
}
else
{
change_dts.addr = get_subaddress({subaddr_account, 0});
change_dts.is_subaddress = subaddr_account != 0;
splitted_dsts.push_back(change_dts);
}
crypto::secret_key tx_key;
std::vector<crypto::secret_key> additional_tx_keys;
rct::multisig_out msout;
LOG_PRINT_L2("constructing tx");
auto sources_copy = sources;
bool r = cryptonote::construct_tx_and_get_tx_key(m_account.get_keys(), m_subaddresses, sources, splitted_dsts, change_dts, extra, tx, unlock_time, tx_key, additional_tx_keys, rct_config, m_multisig ? &msout : NULL, tx_params);
LOG_PRINT_L2("constructed tx, r="<<r);
THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sources, dsts, unlock_time, m_nettype);
THROW_WALLET_EXCEPTION_IF(upper_transaction_weight_limit <= get_transaction_weight(tx), error::tx_too_big, tx, upper_transaction_weight_limit);
// work out the permutation done on sources
std::vector<size_t> ins_order;
for (size_t n = 0; n < sources.size(); ++n)
{
for (size_t idx = 0; idx < sources_copy.size(); ++idx)
{
THROW_WALLET_EXCEPTION_IF((size_t)sources_copy[idx].real_output >= sources_copy[idx].outputs.size(),
error::wallet_internal_error, "Invalid real_output");
if (sources_copy[idx].outputs[sources_copy[idx].real_output].second.dest == sources[n].outputs[sources[n].real_output].second.dest)
ins_order.push_back(idx);
}
}
THROW_WALLET_EXCEPTION_IF(ins_order.size() != sources.size(), error::wallet_internal_error, "Failed to work out sources permutation");
std::vector<tools::wallet2::multisig_sig> multisig_sigs;
if (m_multisig)
{
auto ignore = ignore_sets.empty() ? std::unordered_set<crypto::public_key>() : ignore_sets.front();
multisig_sigs.push_back({tx.rct_signatures, ignore, used_L, std::unordered_set<crypto::public_key>(), msout});
if (m_multisig_threshold < m_multisig_signers.size())
{
const crypto::hash prefix_hash = cryptonote::get_transaction_prefix_hash(tx);
// create the other versions, one for every other participant (the first one's already done above)
for (size_t ignore_index = 1; ignore_index < ignore_sets.size(); ++ignore_index)
{
std::unordered_set<rct::key> new_used_L;
size_t src_idx = 0;
THROW_WALLET_EXCEPTION_IF(selected_transfers.size() != sources.size(), error::wallet_internal_error, "mismatched selected_transfers and sources sixes");
for(size_t idx: selected_transfers)
{
cryptonote::tx_source_entry& src = sources_copy[src_idx];
src.multisig_kLRki = get_multisig_composite_kLRki(idx, ignore_sets[ignore_index], used_L, new_used_L);
++src_idx;
}
LOG_PRINT_L2("Creating supplementary multisig transaction");
cryptonote::transaction ms_tx;
auto sources_copy_copy = sources_copy;
bool r = cryptonote::construct_tx_with_tx_key(m_account.get_keys(),
m_subaddresses,
sources_copy_copy,
splitted_dsts,
change_dts,
extra,
ms_tx,
unlock_time,
tx_key,
additional_tx_keys,
rct_config,
&msout,
/*shuffle_outs*/ true,
tx_params);
LOG_PRINT_L2("constructed tx, r="<<r);
THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sources, splitted_dsts, unlock_time, m_nettype);
THROW_WALLET_EXCEPTION_IF(upper_transaction_weight_limit <= get_transaction_weight(tx), error::tx_too_big, tx, upper_transaction_weight_limit);
THROW_WALLET_EXCEPTION_IF(cryptonote::get_transaction_prefix_hash(ms_tx) != prefix_hash, error::wallet_internal_error, "Multisig txes do not share prefix");
multisig_sigs.push_back({ms_tx.rct_signatures, ignore_sets[ignore_index], new_used_L, std::unordered_set<crypto::public_key>(), msout});
ms_tx.rct_signatures = tx.rct_signatures;
THROW_WALLET_EXCEPTION_IF(cryptonote::get_transaction_hash(ms_tx) != cryptonote::get_transaction_hash(tx), error::wallet_internal_error, "Multisig txes differ by more than the signatures");
}
}
}
LOG_PRINT_L2("gathering key images");
std::string key_images;
bool all_are_txin_to_key = std::all_of(tx.vin.begin(), tx.vin.end(), [&](const txin_v& s_e) -> bool
{
CHECKED_GET_SPECIFIC_VARIANT(s_e, const txin_to_key, in, false);
key_images += boost::to_string(in.k_image) + " ";
return true;
});
THROW_WALLET_EXCEPTION_IF(!all_are_txin_to_key, error::unexpected_txin_type, tx);
LOG_PRINT_L2("gathered key images");
ptx = {};
ptx.key_images = key_images;
ptx.fee = fee;
ptx.dust = 0;
ptx.dust_added_to_fee = false;
ptx.tx = tx;
ptx.change_dts = change_dts;
ptx.selected_transfers = selected_transfers;
tools::apply_permutation(ins_order, ptx.selected_transfers);
ptx.tx_key = tx_key;
ptx.additional_tx_keys = additional_tx_keys;
ptx.dests = dsts;
ptx.multisig_sigs = multisig_sigs;
ptx.construction_data.sources = sources_copy;
ptx.construction_data.change_dts = change_dts;
ptx.construction_data.splitted_dsts = splitted_dsts;
ptx.construction_data.selected_transfers = ptx.selected_transfers;
ptx.construction_data.extra = tx.extra;
ptx.construction_data.unlock_time = unlock_time;
ptx.construction_data.tx_type = tx_params.tx_type;
ptx.construction_data.hf_version = tx_params.hf_version;
ptx.construction_data.rct_config = { tx.rct_signatures.p.bulletproofs.empty() ? rct::RangeProofBorromean : rct::RangeProofPaddedBulletproof, 2 };
ptx.construction_data.dests = dsts;
// record which subaddress indices are being used as inputs
ptx.construction_data.subaddr_account = subaddr_account;
ptx.construction_data.subaddr_indices.clear();
for (size_t idx: selected_transfers)
ptx.construction_data.subaddr_indices.insert(m_transfers[idx].m_subaddr_index.minor);
LOG_PRINT_L2("transfer_selected_rct done");
}
std::vector<size_t> wallet2::pick_preferred_rct_inputs(uint64_t needed_money, uint32_t subaddr_account, const std::set<uint32_t> &subaddr_indices) const
{
std::vector<size_t> picks;
float current_output_relatdness = 1.0f;
LOG_PRINT_L2("pick_preferred_rct_inputs: needed_money " << print_money(needed_money));
// try to find a rct input of enough size
for (size_t i = 0; i < m_transfers.size(); ++i)
{
const transfer_details& td = m_transfers[i];
if (!td.m_spent && !td.m_frozen && td.is_rct() && td.amount() >= needed_money && is_transfer_unlocked(td) && td.m_subaddr_index.major == subaddr_account && subaddr_indices.count(td.m_subaddr_index.minor) == 1)
{
LOG_PRINT_L2("We can use " << i << " alone: " << print_money(td.amount()));
picks.push_back(i);
return picks;
}
}
// then try to find two outputs
// this could be made better by picking one of the outputs to be a small one, since those
// are less useful since often below the needed money, so if one can be used in a pair,
// it gets rid of it for the future
for (size_t i = 0; i < m_transfers.size(); ++i)
{
const transfer_details& td = m_transfers[i];
if (!td.m_spent && !td.m_frozen && !td.m_key_image_partial && td.is_rct() && is_transfer_unlocked(td) && td.m_subaddr_index.major == subaddr_account && subaddr_indices.count(td.m_subaddr_index.minor) == 1)
{
LOG_PRINT_L2("Considering input " << i << ", " << print_money(td.amount()));
for (size_t j = i + 1; j < m_transfers.size(); ++j)
{
const transfer_details& td2 = m_transfers[j];
if (!td2.m_spent && !td2.m_frozen && !td.m_key_image_partial && td2.is_rct() && td.amount() + td2.amount() >= needed_money && is_transfer_unlocked(td2) && td2.m_subaddr_index == td.m_subaddr_index)
{
// update our picks if those outputs are less related than any we
// already found. If the same, don't update, and oldest suitable outputs
// will be used in preference.
float relatedness = get_output_relatedness(td, td2);
LOG_PRINT_L2(" with input " << j << ", " << print_money(td2.amount()) << ", relatedness " << relatedness);
if (relatedness < current_output_relatdness)
{
// reset the current picks with those, and return them directly
// if they're unrelated. If they are related, we'll end up returning
// them if we find nothing better
picks.clear();
picks.push_back(i);
picks.push_back(j);
LOG_PRINT_L0("we could use " << i << " and " << j);
if (relatedness == 0.0f)
return picks;
current_output_relatdness = relatedness;
}
}
}
}
}
return picks;
}
bool wallet2::should_pick_a_second_output(size_t n_transfers, const std::vector<size_t> &unused_transfers_indices, const std::vector<size_t> &unused_dust_indices) const
{
if (n_transfers > 1)
return false;
if (unused_dust_indices.empty() && unused_transfers_indices.empty())
return false;
// we want at least one free rct output to avoid a corner case where
// we'd choose a non rct output which doesn't have enough "siblings"
// value-wise on the chain, and thus can't be mixed
bool found = false;
for (auto i: unused_dust_indices)
{
if (m_transfers[i].is_rct())
{
found = true;
break;
}
}
if (!found) for (auto i: unused_transfers_indices)
{
if (m_transfers[i].is_rct())
{
found = true;
break;
}
}
if (!found)
return false;
return true;
}
std::vector<size_t> wallet2::get_only_rct(const std::vector<size_t> &unused_dust_indices, const std::vector<size_t> &unused_transfers_indices) const
{
std::vector<size_t> indices;
for (size_t n: unused_dust_indices)
if (m_transfers[n].is_rct())
indices.push_back(n);
for (size_t n: unused_transfers_indices)
if (m_transfers[n].is_rct())
indices.push_back(n);
return indices;
}
static uint32_t get_count_above(const std::vector<wallet2::transfer_details> &transfers, const std::vector<size_t> &indices, uint64_t threshold)
{
uint32_t count = 0;
for (size_t idx: indices)
if (transfers[idx].amount() >= threshold)
++count;
return count;
}
bool wallet2::light_wallet_login(bool &new_address)
{
MDEBUG("Light wallet login request");
m_light_wallet_connected = false;
tools::COMMAND_RPC_LOGIN::request request;
tools::COMMAND_RPC_LOGIN::response response;
request.address = get_account().get_public_address_str(m_nettype);
request.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
// Always create account if it doesn't exist.
request.create_account = true;
m_daemon_rpc_mutex.lock();
bool connected = invoke_http_json("/login", request, response, rpc_timeout, "POST");
m_daemon_rpc_mutex.unlock();
// MyMonero doesn't send any status message. OpenMonero does.
m_light_wallet_connected = connected && (response.status.empty() || response.status == "success");
new_address = response.new_address;
MDEBUG("Status: " << response.status);
MDEBUG("Reason: " << response.reason);
MDEBUG("New wallet: " << response.new_address);
if(m_light_wallet_connected)
{
// Clear old data on successful login.
// m_transfers.clear();
// m_payments.clear();
// m_unconfirmed_payments.clear();
}
return m_light_wallet_connected;
}
bool wallet2::light_wallet_import_wallet_request(tools::COMMAND_RPC_IMPORT_WALLET_REQUEST::response &response)
{
MDEBUG("Light wallet import wallet request");
tools::COMMAND_RPC_IMPORT_WALLET_REQUEST::request oreq;
oreq.address = get_account().get_public_address_str(m_nettype);
oreq.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/import_wallet_request", oreq, response, rpc_timeout, "POST");
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "import_wallet_request");
return true;
}
void wallet2::light_wallet_get_unspent_outs()
{
MDEBUG("Getting unspent outs");
tools::COMMAND_RPC_GET_UNSPENT_OUTS::request oreq;
tools::COMMAND_RPC_GET_UNSPENT_OUTS::response ores;
oreq.amount = "0";
oreq.address = get_account().get_public_address_str(m_nettype);
oreq.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
// openMonero specific
oreq.dust_threshold = boost::lexical_cast<std::string>(::config::DEFAULT_DUST_THRESHOLD);
// below are required by openMonero api - but are not used.
oreq.mixin = 0;
oreq.use_dust = true;
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/get_unspent_outs", oreq, ores, rpc_timeout, "POST");
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_unspent_outs");
THROW_WALLET_EXCEPTION_IF(ores.status == "error", error::wallet_internal_error, ores.reason);
m_light_wallet_per_kb_fee = ores.per_kb_fee;
std::unordered_map<crypto::hash,bool> transfers_txs;
for(const auto &t: m_transfers)
transfers_txs.emplace(t.m_txid,t.m_spent);
MDEBUG("FOUND " << ores.outputs.size() <<" outputs");
// return if no outputs found
if(ores.outputs.empty())
return;
// Clear old outputs
m_transfers.clear();
for (const auto &o: ores.outputs) {
bool spent = false;
bool add_transfer = true;
crypto::key_image unspent_key_image;
crypto::public_key tx_public_key{};
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, o.tx_pub_key), error::wallet_internal_error, "Invalid tx_pub_key field");
string_tools::hex_to_pod(o.tx_pub_key, tx_public_key);
for (const std::string &ski: o.spend_key_images) {
spent = false;
// Check if key image is ours
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, ski), error::wallet_internal_error, "Invalid key image");
string_tools::hex_to_pod(ski, unspent_key_image);
if(light_wallet_key_image_is_ours(unspent_key_image, tx_public_key, o.index)){
MTRACE("Output " << o.public_key << " is spent. Key image: " << ski);
spent = true;
break;
} {
MTRACE("Unspent output found. " << o.public_key);
}
}
// Check if tx already exists in m_transfers.
crypto::hash txid;
crypto::public_key tx_pub_key;
crypto::public_key public_key;
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, o.tx_hash), error::wallet_internal_error, "Invalid tx_hash field");
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, o.public_key), error::wallet_internal_error, "Invalid public_key field");
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, o.tx_pub_key), error::wallet_internal_error, "Invalid tx_pub_key field");
string_tools::hex_to_pod(o.tx_hash, txid);
string_tools::hex_to_pod(o.public_key, public_key);
string_tools::hex_to_pod(o.tx_pub_key, tx_pub_key);
for(auto &t: m_transfers){
if(t.get_public_key() == public_key) {
t.m_spent = spent;
add_transfer = false;
break;
}
}
if(!add_transfer)
continue;
m_transfers.emplace_back();
transfer_details& td = m_transfers.back();
td.m_block_height = o.height;
td.m_global_output_index = o.global_index;
td.m_txid = txid;
// Add to extra
add_tx_pub_key_to_extra(td.m_tx, tx_pub_key);
td.m_key_image = unspent_key_image;
td.m_key_image_known = !m_watch_only && !m_multisig;
td.m_key_image_request = false;
td.m_key_image_partial = m_multisig;
td.m_amount = o.amount;
td.m_pk_index = 0;
td.m_internal_output_index = o.index;
td.m_spent = spent;
td.m_frozen = false;
tx_out txout;
txout.target = txout_to_key(public_key);
txout.amount = td.m_amount;
td.m_tx.vout.resize(td.m_internal_output_index + 1);
td.m_tx.vout[td.m_internal_output_index] = txout;
THROW_WALLET_EXCEPTION_IF(true, error::wallet_internal_error, "Light wallet multiple output unlock time not supported yet");
// Add unlock time and coinbase bool got from get_address_txs api call
std::unordered_map<crypto::hash,address_tx>::const_iterator found = m_light_wallet_address_txs.find(txid);
THROW_WALLET_EXCEPTION_IF(found == m_light_wallet_address_txs.end(), error::wallet_internal_error, "Lightwallet: tx not found in m_light_wallet_address_txs");
bool miner_tx = found->second.is_coinbase();
td.m_tx.unlock_time = found->second.m_unlock_time;
if (!o.rct.empty())
{
// Coinbase tx's
if(miner_tx)
{
td.m_mask = rct::identity();
}
else
{
// rct txs
// decrypt rct mask, calculate commit hash and compare against blockchain commit hash
rct::key rct_commit;
light_wallet_parse_rct_str(o.rct, tx_pub_key, td.m_internal_output_index, td.m_mask, rct_commit, true);
bool valid_commit = (rct_commit == rct::commit(td.amount(), td.m_mask));
if(!valid_commit)
{
MDEBUG("output index: " << o.global_index);
MDEBUG("mask: " + string_tools::pod_to_hex(td.m_mask));
MDEBUG("calculated commit: " + string_tools::pod_to_hex(rct::commit(td.amount(), td.m_mask)));
MDEBUG("expected commit: " + string_tools::pod_to_hex(rct_commit));
MDEBUG("amount: " << td.amount());
}
THROW_WALLET_EXCEPTION_IF(!valid_commit, error::wallet_internal_error, "Lightwallet: rct commit hash mismatch!");
}
td.m_rct = true;
}
else
{
td.m_mask = rct::identity();
td.m_rct = false;
}
if(!spent)
set_unspent(m_transfers.size()-1);
m_key_images[td.m_key_image] = m_transfers.size()-1;
m_pub_keys[td.get_public_key()] = m_transfers.size()-1;
}
}
bool wallet2::light_wallet_get_address_info(tools::COMMAND_RPC_GET_ADDRESS_INFO::response &response)
{
MTRACE(__FUNCTION__);
tools::COMMAND_RPC_GET_ADDRESS_INFO::request request;
request.address = get_account().get_public_address_str(m_nettype);
request.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/get_address_info", request, response, rpc_timeout, "POST");
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_address_info");
// TODO: Validate result
return true;
}
void wallet2::light_wallet_get_address_txs()
{
MDEBUG("Refreshing light wallet");
tools::COMMAND_RPC_GET_ADDRESS_TXS::request ireq;
tools::COMMAND_RPC_GET_ADDRESS_TXS::response ires;
ireq.address = get_account().get_public_address_str(m_nettype);
ireq.view_key = string_tools::pod_to_hex(get_account().get_keys().m_view_secret_key);
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/get_address_txs", ireq, ires, rpc_timeout, "POST");
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_address_txs");
//OpenMonero sends status=success, Mymonero doesn't.
THROW_WALLET_EXCEPTION_IF((!ires.status.empty() && ires.status != "success"), error::no_connection_to_daemon, "get_address_txs");
// Abort if no transactions
if(ires.transactions.empty())
return;
// Create searchable vectors
std::vector<crypto::hash> payments_txs;
for(const auto &p: m_payments)
payments_txs.push_back(p.second.m_tx_hash);
std::vector<crypto::hash> unconfirmed_payments_txs;
for(const auto &up: m_unconfirmed_payments)
unconfirmed_payments_txs.push_back(up.second.m_pd.m_tx_hash);
// for balance calculation
uint64_t wallet_total_sent = 0;
// txs in pool
std::vector<crypto::hash> pool_txs;
for (const auto &t: ires.transactions) {
const uint64_t total_received = t.total_received;
uint64_t total_sent = t.total_sent;
// Check key images - subtract fake outputs from total_sent
for(const auto &so: t.spent_outputs)
{
crypto::public_key tx_public_key;
crypto::key_image key_image;
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, so.tx_pub_key), error::wallet_internal_error, "Invalid tx_pub_key field");
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, so.key_image), error::wallet_internal_error, "Invalid key_image field");
string_tools::hex_to_pod(so.tx_pub_key, tx_public_key);
string_tools::hex_to_pod(so.key_image, key_image);
if(!light_wallet_key_image_is_ours(key_image, tx_public_key, so.out_index)) {
THROW_WALLET_EXCEPTION_IF(so.amount > t.total_sent, error::wallet_internal_error, "Lightwallet: total sent is negative!");
total_sent -= so.amount;
}
}
// Do not add tx if empty.
if(total_sent == 0 && total_received == 0)
continue;
crypto::hash payment_id = null_hash;
crypto::hash tx_hash;
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, t.payment_id), error::wallet_internal_error, "Invalid payment_id field");
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, t.hash), error::wallet_internal_error, "Invalid hash field");
string_tools::hex_to_pod(t.payment_id, payment_id);
string_tools::hex_to_pod(t.hash, tx_hash);
// lightwallet specific info
bool incoming = (total_received > total_sent);
address_tx address_tx;
address_tx.m_tx_hash = tx_hash;
address_tx.m_incoming = incoming;
address_tx.m_amount = incoming ? total_received - total_sent : total_sent - total_received;
address_tx.m_fee = 0; // TODO
address_tx.m_unmined_blink = false;
address_tx.m_was_blink = false;
address_tx.m_block_height = t.height;
address_tx.m_unlock_time = t.unlock_time;
address_tx.m_timestamp = t.timestamp;
address_tx.m_type = t.coinbase ? pay_type::miner : pay_type::in; // TODO(worktips): Only accounts for miner, but wait, do we even care about this code? Looks like openmonero code
address_tx.m_mempool = t.mempool;
m_light_wallet_address_txs.emplace(tx_hash,address_tx);
// populate data needed for history (m_payments, m_unconfirmed_payments, m_confirmed_txs)
// INCOMING transfers
if(total_received > total_sent) {
payment_details payment;
payment.m_tx_hash = tx_hash;
payment.m_amount = total_received - total_sent;
payment.m_fee = 0; // TODO
payment.m_unmined_blink = false;
payment.m_was_blink = false;
payment.m_block_height = t.height;
payment.m_unlock_time = t.unlock_time;
payment.m_timestamp = t.timestamp;
payment.m_type = t.coinbase ? pay_type::miner : pay_type::in; // TODO(worktips): Only accounts for miner, but wait, do we even care about this code? Looks like openmonero code
if (t.mempool) {
if (std::find(unconfirmed_payments_txs.begin(), unconfirmed_payments_txs.end(), tx_hash) == unconfirmed_payments_txs.end()) {
pool_txs.push_back(tx_hash);
// assume false as we don't get that info from the light wallet server
crypto::hash payment_id;
THROW_WALLET_EXCEPTION_IF(!epee::string_tools::hex_to_pod(t.payment_id, payment_id),
error::wallet_internal_error, "Failed to parse payment id");
emplace_or_replace(m_unconfirmed_payments, payment_id, pool_payment_details{payment, false});
if (0 != m_callback) {
m_callback->on_lw_unconfirmed_money_received(t.height, payment.m_tx_hash, payment.m_amount);
}
}
} else {
if (std::find(payments_txs.begin(), payments_txs.end(), tx_hash) == payments_txs.end()) {
m_payments.emplace(tx_hash, payment);
if (0 != m_callback) {
m_callback->on_lw_money_received(t.height, payment.m_tx_hash, payment.m_amount);
}
}
}
// Outgoing transfers
} else {
uint64_t amount_sent = total_sent - total_received;
cryptonote::transaction dummy_tx; // not used by light wallet
// increase wallet total sent
wallet_total_sent += total_sent;
if (t.mempool)
{
// Handled by add_unconfirmed_tx in commit_tx
// If sent from another wallet instance we need to add it
if(m_unconfirmed_txs.find(tx_hash) == m_unconfirmed_txs.end())
{
unconfirmed_transfer_details utd;
utd.m_amount_in = amount_sent;
utd.m_amount_out = amount_sent;
utd.m_change = 0;
utd.m_payment_id = payment_id;
utd.m_timestamp = t.timestamp;
utd.m_state = wallet2::unconfirmed_transfer_details::pending;
m_unconfirmed_txs.emplace(tx_hash,utd);
}
}
else
{
// Only add if new
auto confirmed_tx = m_confirmed_txs.find(tx_hash);
if(confirmed_tx == m_confirmed_txs.end()) {
// tx is added to m_unconfirmed_txs - move to confirmed
if(m_unconfirmed_txs.find(tx_hash) != m_unconfirmed_txs.end())
{
process_unconfirmed(tx_hash, dummy_tx, t.height);
}
// Tx sent by another wallet instance
else
{
confirmed_transfer_details ctd;
ctd.m_amount_in = amount_sent;
ctd.m_amount_out = amount_sent;
ctd.m_change = 0;
ctd.m_payment_id = payment_id;
ctd.m_block_height = t.height;
ctd.m_timestamp = t.timestamp;
m_confirmed_txs.emplace(tx_hash,ctd);
}
if (0 != m_callback)
{
m_callback->on_lw_money_spent(t.height, tx_hash, amount_sent);
}
}
// If not new - check the amount and update if necessary.
// when sending a tx to same wallet the receiving amount has to be credited
else
{
if(confirmed_tx->second.m_amount_in != amount_sent || confirmed_tx->second.m_amount_out != amount_sent)
{
MDEBUG("Adjusting amount sent/received for tx: <" + t.hash + ">. Is tx sent to own wallet? " << print_money(amount_sent) << " != " << print_money(confirmed_tx->second.m_amount_in));
confirmed_tx->second.m_amount_in = amount_sent;
confirmed_tx->second.m_amount_out = amount_sent;
confirmed_tx->second.m_change = 0;
}
}
}
}
}
// TODO: purge old unconfirmed_txs
remove_obsolete_pool_txs(pool_txs);
// Calculate wallet balance
m_light_wallet_balance = ires.total_received-wallet_total_sent;
// MyMonero doesn't send unlocked balance
if(ires.total_received_unlocked > 0)
m_light_wallet_unlocked_balance = ires.total_received_unlocked-wallet_total_sent;
else
m_light_wallet_unlocked_balance = m_light_wallet_balance;
}
bool wallet2::light_wallet_parse_rct_str(const std::string& rct_string, const crypto::public_key& tx_pub_key, uint64_t internal_output_index, rct::key& decrypted_mask, rct::key& rct_commit, bool decrypt) const
{
// rct string is empty if output is non RCT
if (rct_string.empty())
return false;
// rct_string is a string with length 64+64+64 (<rct commit> + <encrypted mask> + <rct amount>)
rct::key encrypted_mask;
std::string rct_commit_str = rct_string.substr(0,64);
std::string encrypted_mask_str = rct_string.substr(64,64);
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, rct_commit_str), error::wallet_internal_error, "Invalid rct commit hash: " + rct_commit_str);
THROW_WALLET_EXCEPTION_IF(string_tools::validate_hex(64, encrypted_mask_str), error::wallet_internal_error, "Invalid rct mask: " + encrypted_mask_str);
string_tools::hex_to_pod(rct_commit_str, rct_commit);
string_tools::hex_to_pod(encrypted_mask_str, encrypted_mask);
if (decrypt) {
// Decrypt the mask
crypto::key_derivation derivation;
bool r = generate_key_derivation(tx_pub_key, get_account().get_keys().m_view_secret_key, derivation);
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key derivation");
crypto::secret_key scalar;
crypto::derivation_to_scalar(derivation, internal_output_index, scalar);
sc_sub(decrypted_mask.bytes,encrypted_mask.bytes,rct::hash_to_scalar(rct::sk2rct(scalar)).bytes);
}
return true;
}
bool wallet2::light_wallet_key_image_is_ours(const crypto::key_image& key_image, const crypto::public_key& tx_public_key, uint64_t out_index)
{
// Lookup key image from cache
std::map<uint64_t, crypto::key_image> index_keyimage_map;
std::unordered_map<crypto::public_key, std::map<uint64_t, crypto::key_image> >::const_iterator found_pub_key = m_key_image_cache.find(tx_public_key);
if(found_pub_key != m_key_image_cache.end()) {
// pub key found. key image for index cached?
index_keyimage_map = found_pub_key->second;
std::map<uint64_t,crypto::key_image>::const_iterator index_found = index_keyimage_map.find(out_index);
if(index_found != index_keyimage_map.end())
return key_image == index_found->second;
}
// Not in cache - calculate key image
crypto::key_image calculated_key_image;
cryptonote::keypair in_ephemeral;
// Subaddresses aren't supported in mymonero/openmonero yet. Roll out the original scheme:
// compute D = a*R
// compute P = Hs(D || i)*G + B
// compute x = Hs(D || i) + b (and check if P==x*G)
// compute I = x*Hp(P)
const account_keys& ack = get_account().get_keys();
crypto::key_derivation derivation;
bool r = crypto::generate_key_derivation(tx_public_key, ack.m_view_secret_key, derivation);
CHECK_AND_ASSERT_MES(r, false, "failed to generate_key_derivation(" << tx_public_key << ", " << ack.m_view_secret_key << ")");
r = crypto::derive_public_key(derivation, out_index, ack.m_account_address.m_spend_public_key, in_ephemeral.pub);
CHECK_AND_ASSERT_MES(r, false, "failed to derive_public_key (" << derivation << ", " << out_index << ", " << ack.m_account_address.m_spend_public_key << ")");
crypto::derive_secret_key(derivation, out_index, ack.m_spend_secret_key, in_ephemeral.sec);
crypto::public_key out_pkey_test;
r = crypto::secret_key_to_public_key(in_ephemeral.sec, out_pkey_test);
CHECK_AND_ASSERT_MES(r, false, "failed to secret_key_to_public_key(" << in_ephemeral.sec << ")");
CHECK_AND_ASSERT_MES(in_ephemeral.pub == out_pkey_test, false, "derived secret key doesn't match derived public key");
crypto::generate_key_image(in_ephemeral.pub, in_ephemeral.sec, calculated_key_image);
index_keyimage_map.emplace(out_index, calculated_key_image);
m_key_image_cache.emplace(tx_public_key, index_keyimage_map);
return key_image == calculated_key_image;
}
// Before we have the final fee we can't determine the amount to burn, so we stick in this
// placeholder then go back once we know the fee and replace it. This value (~4398 WORKTIPS) was chosen
// because it's unlikely to ever be needed to be burned in a single transaction, and is the maximum
// encoded value we can store in 6 bytes (tx extra integers are encoded 7 bits per byte -- see
// common/varint.h). 7 bytes is likely just wasteful (we don't need more than 4400 WORKTIPS burned at a
// time), and 5 bytes (max 34.3 WORKTIPS) might conceivable not be enough.
static constexpr uint64_t BURN_FEE_PLACEHOLDER = (1ULL << (6*7)) - 1;
// Another implementation of transaction creation that is hopefully better
// While there is anything left to pay, it goes through random outputs and tries
// to fill the next destination/amount. If it fully fills it, it will use the
// remainder to try to fill the next one as well.
// The tx size if roughly estimated as a linear function of only inputs, and a
// new tx will be created when that size goes above a given fraction of the
// max tx size. At that point, more outputs may be added if the fee cannot be
// satisfied.
// If the next output in the next tx would go to the same destination (ie, we
// cut off at a tx boundary in the middle of paying a given destination), the
// fee will be carved out of the current input if possible, to avoid having to
// add another output just for the fee and getting change.
// This system allows for sending (almost) the entire balance, since it does
// not generate spurious change in all txes, thus decreasing the instantaneous
// usable balance.
std::vector<wallet2::pending_tx> wallet2::create_transactions_2(std::vector<cryptonote::tx_destination_entry> dsts, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector<uint8_t>& extra_base, uint32_t subaddr_account, std::set<uint32_t> subaddr_indices, cryptonote::txtype tx_type)
{
//ensure device is let in NONE mode in any case
hw::device &hwdev = m_account.get_device();
boost::unique_lock<hw::device> hwdev_lock (hwdev);
hw::reset_mode rst(hwdev);
auto original_dsts = dsts;
if(m_light_wallet) {
// Populate m_transfers
light_wallet_get_unspent_outs();
}
std::vector<std::pair<uint32_t, std::vector<size_t>>> unused_transfers_indices_per_subaddr;
std::vector<std::pair<uint32_t, std::vector<size_t>>> unused_dust_indices_per_subaddr;
uint64_t needed_money;
uint64_t accumulated_fee, accumulated_outputs, accumulated_change;
struct TX {
std::vector<size_t> selected_transfers;
std::vector<cryptonote::tx_destination_entry> dsts;
cryptonote::transaction tx;
pending_tx ptx;
size_t weight;
uint64_t needed_fee;
std::vector<std::vector<tools::wallet2::get_outs_entry>> outs;
TX() : weight(0), needed_fee(0) {}
void add(const cryptonote::tx_destination_entry &de, uint64_t amount, unsigned int original_output_index, bool merge_destinations) {
if (merge_destinations)
{
std::vector<cryptonote::tx_destination_entry>::iterator i;
i = std::find_if(dsts.begin(), dsts.end(), [&](const cryptonote::tx_destination_entry &d) { return !memcmp (&d.addr, &de.addr, sizeof(de.addr)); });
if (i == dsts.end())
{
dsts.push_back(de);
i = dsts.end() - 1;
i->amount = 0;
}
i->amount += amount;
}
else
{
THROW_WALLET_EXCEPTION_IF(original_output_index > dsts.size(), error::wallet_internal_error,
std::string("original_output_index too large: ") + std::to_string(original_output_index) + " > " + std::to_string(dsts.size()));
if (original_output_index == dsts.size())
{
dsts.push_back(de);
dsts.back().amount = 0;
}
THROW_WALLET_EXCEPTION_IF(memcmp(&dsts[original_output_index].addr, &de.addr, sizeof(de.addr)), error::wallet_internal_error, "Mismatched destination address");
dsts[original_output_index].amount += amount;
}
}
};
std::vector<TX> txes;
bool adding_fee; // true if new outputs go towards fee, rather than destinations
uint64_t needed_fee, available_for_fee = 0;
uint64_t upper_transaction_weight_limit = get_upper_transaction_weight_limit();
const rct::RCTConfig rct_config { rct::RangeProofPaddedBulletproof, 2 };
const auto base_fee = get_base_fees();
const uint64_t fee_percent = get_fee_percent(priority, get_fee_algorithm());
uint64_t fixed_fee = 0;
const uint64_t fee_quantization_mask = get_fee_quantization_mask();
boost::optional<uint8_t> hf_version = get_hard_fork_version();
THROW_WALLET_EXCEPTION_IF(!hf_version, error::get_hard_fork_version_error, "Failed to query current hard fork version");
worktips_construct_tx_params worktips_tx_params = tools::wallet2::construct_params(priority);
worktips_tx_params.tx_type = tx_type;
worktips_tx_params.hf_version = *hf_version;
uint64_t burn_fixed = 0, burn_percent = 0;
// Swap these out because we don't want them present for building intermediate temporary tx
// calculations (which we don't actually use); we'll set them again at the end before we build the
// real transactions.
std::swap(burn_fixed, worktips_tx_params.burn_fixed);
std::swap(burn_percent, worktips_tx_params.burn_percent);
bool burning = burn_fixed || burn_percent;
THROW_WALLET_EXCEPTION_IF(burning && worktips_tx_params.hf_version < HF_VERSION_FEE_BURNING, error::wallet_internal_error, "cannot construct transaction: cannot burn amounts under the current hard fork");
std::vector<uint8_t> extra_plus; // Copy and modified from input if modification needed
const std::vector<uint8_t> &extra = burning ? extra_plus : extra_base;
if (burning)
{
extra_plus = extra_base;
add_burned_amount_to_tx_extra(extra_plus, BURN_FEE_PLACEHOLDER);
fixed_fee += burn_fixed;
THROW_WALLET_EXCEPTION_IF(burn_percent > fee_percent, error::wallet_internal_error, "invalid burn fees: cannot burn more than the tx fee");
}
// throw if attempting a transaction with no destinations
THROW_WALLET_EXCEPTION_IF(dsts.empty(), error::zero_destination);
// calculate total amount being sent to all destinations
// throw if total amount overflows uint64_t
needed_money = 0;
for(auto& dt: dsts)
{
THROW_WALLET_EXCEPTION_IF(0 == dt.amount, error::zero_destination);
needed_money += dt.amount;
LOG_PRINT_L2("transfer: adding " << print_money(dt.amount) << ", for a total of " << print_money (needed_money));
THROW_WALLET_EXCEPTION_IF(needed_money < dt.amount, error::tx_sum_overflow, dsts, 0, m_nettype);
}
// throw if attempting a transaction with no money
THROW_WALLET_EXCEPTION_IF(needed_money == 0, error::zero_destination);
std::map<uint32_t, std::pair<uint64_t, uint64_t>> unlocked_balance_per_subaddr = unlocked_balance_per_subaddress(subaddr_account);
std::map<uint32_t, uint64_t> balance_per_subaddr = balance_per_subaddress(subaddr_account);
if (subaddr_indices.empty()) // "index=<N1>[,<N2>,...]" wasn't specified -> use all the indices with non-zero unlocked balance
{
for (const auto& i : balance_per_subaddr)
subaddr_indices.insert(i.first);
}
// early out if we know we can't make it anyway
// we could also check for being within FEE_PER_KB, but if the fee calculation
// ever changes, this might be missed, so let this go through
constexpr uint64_t num_outputs = 2;
uint64_t min_fee = (
base_fee.first * estimate_rct_tx_size(1, fake_outs_count, num_outputs, extra.size()) +
base_fee.second * num_outputs
) * fee_percent / 100;
uint64_t balance_subtotal = 0;
uint64_t unlocked_balance_subtotal = 0;
for (uint32_t index_minor : subaddr_indices)
{
balance_subtotal += balance_per_subaddr[index_minor];
unlocked_balance_subtotal += unlocked_balance_per_subaddr[index_minor].first;
}
THROW_WALLET_EXCEPTION_IF(needed_money + min_fee + fixed_fee > balance_subtotal, error::not_enough_money,
balance_subtotal, needed_money, 0);
// first check overall balance is enough, then unlocked one, so we throw distinct exceptions
THROW_WALLET_EXCEPTION_IF(needed_money + min_fee + fixed_fee > unlocked_balance_subtotal, error::not_enough_unlocked_money,
unlocked_balance_subtotal, needed_money, 0);
for (uint32_t i : subaddr_indices)
LOG_PRINT_L2("Candidate subaddress index for spending: " << i);
// determine threshold for fractional amount
const size_t tx_weight_one_ring = estimate_tx_weight(1, fake_outs_count, 2, 0);
const size_t tx_weight_two_rings = estimate_tx_weight(2, fake_outs_count, 2, 0);
THROW_WALLET_EXCEPTION_IF(tx_weight_one_ring > tx_weight_two_rings, error::wallet_internal_error, "Estimated tx weight with 1 input is larger than with 2 inputs!");
const size_t tx_weight_per_ring = tx_weight_two_rings - tx_weight_one_ring;
const uint64_t fractional_threshold = base_fee.first * fee_percent / 100 * tx_weight_per_ring;
// gather all dust and non-dust outputs belonging to specified subaddresses
size_t num_nondust_outputs = 0;
size_t num_dust_outputs = 0;
for (size_t i = 0; i < m_transfers.size(); ++i)
{
const transfer_details& td = m_transfers[i];
if (m_ignore_fractional_outputs && td.amount() < fractional_threshold)
{
MDEBUG("Ignoring output " << i << " of amount " << print_money(td.amount()) << " which is below threshold " << print_money(fractional_threshold));
continue;
}
if (!td.m_spent && !td.m_frozen && !td.m_key_image_partial && is_transfer_unlocked(td) && td.m_subaddr_index.major == subaddr_account && subaddr_indices.count(td.m_subaddr_index.minor) == 1)
{
const uint32_t index_minor = td.m_subaddr_index.minor;
auto find_predicate = [&index_minor](const std::pair<uint32_t, std::vector<size_t>>& x) { return x.first == index_minor; };
if ((td.is_rct()) || is_valid_decomposed_amount(td.amount()))
{
auto found = std::find_if(unused_transfers_indices_per_subaddr.begin(), unused_transfers_indices_per_subaddr.end(), find_predicate);
if (found == unused_transfers_indices_per_subaddr.end())
{
unused_transfers_indices_per_subaddr.push_back({index_minor, {i}});
}
else
{
found->second.push_back(i);
}
++num_nondust_outputs;
}
else
{
auto found = std::find_if(unused_dust_indices_per_subaddr.begin(), unused_dust_indices_per_subaddr.end(), find_predicate);
if (found == unused_dust_indices_per_subaddr.end())
{
unused_dust_indices_per_subaddr.push_back({index_minor, {i}});
}
else
{
found->second.push_back(i);
}
++num_dust_outputs;
}
}
}
// sort output indices
{
auto sort_predicate = [&unlocked_balance_per_subaddr] (const std::pair<uint32_t, std::vector<size_t>>& x, const std::pair<uint32_t, std::vector<size_t>>& y)
{
return unlocked_balance_per_subaddr[x.first].first > unlocked_balance_per_subaddr[y.first].first;
};
std::sort(unused_transfers_indices_per_subaddr.begin(), unused_transfers_indices_per_subaddr.end(), sort_predicate);
std::sort(unused_dust_indices_per_subaddr.begin(), unused_dust_indices_per_subaddr.end(), sort_predicate);
}
LOG_PRINT_L2("Starting with " << num_nondust_outputs << " non-dust outputs and " << num_dust_outputs << " dust outputs");
if (unused_dust_indices_per_subaddr.empty() && unused_transfers_indices_per_subaddr.empty())
return std::vector<wallet2::pending_tx>();
// if empty, put dummy entry so that the front can be referenced later in the loop
if (unused_dust_indices_per_subaddr.empty())
unused_dust_indices_per_subaddr.push_back({});
if (unused_transfers_indices_per_subaddr.empty())
unused_transfers_indices_per_subaddr.push_back({});
// start with an empty tx
txes.push_back(TX());
accumulated_fee = 0;
accumulated_outputs = 0;
accumulated_change = 0;
adding_fee = false;
needed_fee = 0;
std::vector<std::vector<tools::wallet2::get_outs_entry>> outs;
// for rct, since we don't see the amounts, we will try to make all transactions
// look the same, with 1 or 2 inputs, and 2 outputs. One input is preferable, as
// this prevents linking to another by provenance analysis, but two is ok if we
// try to pick outputs not from the same block. We will get two outputs, one for
// the destination, and one for change.
LOG_PRINT_L2("checking preferred");
std::vector<size_t> preferred_inputs;
uint64_t rct_outs_needed = 2 * (fake_outs_count + 1);
rct_outs_needed += 100; // some fudge factor since we don't know how many are locked
{
// this is used to build a tx that's 1 or 2 inputs, and 2 outputs, which
// will get us a known fee.
uint64_t estimated_fee = estimate_fee(2, fake_outs_count, 2, extra.size(), base_fee, fee_percent, fixed_fee, fee_quantization_mask);
preferred_inputs = pick_preferred_rct_inputs(needed_money + estimated_fee, subaddr_account, subaddr_indices);
if (!preferred_inputs.empty())
{
string s;
for (auto i: preferred_inputs) s += boost::lexical_cast<std::string>(i) + " (" + print_money(m_transfers[i].amount()) + ") ";
LOG_PRINT_L1("Found preferred rct inputs for rct tx: " << s);
// bring the list of available outputs stored by the same subaddress index to the front of the list
uint32_t index_minor = m_transfers[preferred_inputs[0]].m_subaddr_index.minor;
for (size_t i = 1; i < unused_transfers_indices_per_subaddr.size(); ++i)
{
if (unused_transfers_indices_per_subaddr[i].first == index_minor)
{
std::swap(unused_transfers_indices_per_subaddr[0], unused_transfers_indices_per_subaddr[i]);
break;
}
}
for (size_t i = 1; i < unused_dust_indices_per_subaddr.size(); ++i)
{
if (unused_dust_indices_per_subaddr[i].first == index_minor)
{
std::swap(unused_dust_indices_per_subaddr[0], unused_dust_indices_per_subaddr[i]);
break;
}
}
}
}
LOG_PRINT_L2("done checking preferred");
// while:
// - we have something to send
// - or we need to gather more fee
// - or we have just one input in that tx, which is rct (to try and make all/most rct txes 2/2)
unsigned int original_output_index = 0;
std::vector<size_t>* unused_transfers_indices = &unused_transfers_indices_per_subaddr[0].second;
std::vector<size_t>* unused_dust_indices = &unused_dust_indices_per_subaddr[0].second;
hwdev.set_mode(hw::device::TRANSACTION_CREATE_FAKE);
while ((!dsts.empty() && dsts[0].amount > 0) || adding_fee || !preferred_inputs.empty() || should_pick_a_second_output(txes.back().selected_transfers.size(), *unused_transfers_indices, *unused_dust_indices)) {
TX &tx = txes.back();
LOG_PRINT_L2("Start of loop with " << unused_transfers_indices->size() << " " << unused_dust_indices->size() << ", tx.dsts.size() " << tx.dsts.size());
LOG_PRINT_L2("unused_transfers_indices: " << strjoin(*unused_transfers_indices, " "));
LOG_PRINT_L2("unused_dust_indices: " << strjoin(*unused_dust_indices, " "));
LOG_PRINT_L2("dsts size " << dsts.size() << ", first " << (dsts.empty() ? "-" : cryptonote::print_money(dsts[0].amount)));
LOG_PRINT_L2("adding_fee " << adding_fee);
// if we need to spend money and don't have any left, we fail
if (unused_dust_indices->empty() && unused_transfers_indices->empty()) {
LOG_PRINT_L2("No more outputs to choose from");
THROW_WALLET_EXCEPTION_IF(1, error::tx_not_possible, unlocked_balance(subaddr_account), needed_money, accumulated_fee + needed_fee);
}
// get a random unspent output and use it to pay part (or all) of the current destination (and maybe next one, etc)
// This could be more clever, but maybe at the cost of making probabilistic inferences easier
size_t idx;
if (!preferred_inputs.empty()) {
idx = pop_back(preferred_inputs);
pop_if_present(*unused_transfers_indices, idx);
pop_if_present(*unused_dust_indices, idx);
} else if ((dsts.empty() || dsts[0].amount == 0) && !adding_fee) {
// the "make rct txes 2/2" case - we pick a small value output to "clean up" the wallet too
std::vector<size_t> indices = get_only_rct(*unused_dust_indices, *unused_transfers_indices);
idx = pop_best_value(indices, tx.selected_transfers, true);
// we might not want to add it if it's a large output and we don't have many left
uint64_t min_output_value = m_min_output_value;
uint32_t min_output_count = m_min_output_count;
if (min_output_value == 0 && min_output_count == 0)
{
min_output_value = DEFAULT_MIN_OUTPUT_VALUE;
min_output_count = DEFAULT_MIN_OUTPUT_COUNT;
}
if (m_transfers[idx].amount() >= min_output_value) {
if (get_count_above(m_transfers, *unused_transfers_indices, min_output_value) < min_output_count) {
LOG_PRINT_L2("Second output was not strictly needed, and we're running out of outputs above " << print_money(min_output_value) << ", not adding");
break;
}
}
// since we're trying to add a second output which is not strictly needed,
// we only add it if it's unrelated enough to the first one
float relatedness = get_output_relatedness(m_transfers[idx], m_transfers[tx.selected_transfers.front()]);
if (relatedness > SECOND_OUTPUT_RELATEDNESS_THRESHOLD)
{
LOG_PRINT_L2("Second output was not strictly needed, and relatedness " << relatedness << ", not adding");
break;
}
pop_if_present(*unused_transfers_indices, idx);
pop_if_present(*unused_dust_indices, idx);
} else
idx = pop_best_value(unused_transfers_indices->empty() ? *unused_dust_indices : *unused_transfers_indices, tx.selected_transfers);
const transfer_details &td = m_transfers[idx];
LOG_PRINT_L2("Picking output " << idx << ", amount " << print_money(td.amount()) << ", ki " << td.m_key_image);
// add this output to the list to spend
tx.selected_transfers.push_back(idx);
uint64_t available_amount = td.amount();
accumulated_outputs += available_amount;
// clear any fake outs we'd already gathered, since we'll need a new set
outs.clear();
if (adding_fee)
{
LOG_PRINT_L2("We need more fee, adding it to fee");
available_for_fee += available_amount;
}
else
{
while (!dsts.empty() && dsts[0].amount <= available_amount && estimate_tx_weight(tx.selected_transfers.size(), fake_outs_count, tx.dsts.size()+1, extra.size()) < TX_WEIGHT_TARGET(upper_transaction_weight_limit))
{
// we can fully pay that destination
LOG_PRINT_L2("We can fully pay " << get_account_address_as_str(m_nettype, dsts[0].is_subaddress, dsts[0].addr) <<
" for " << print_money(dsts[0].amount));
tx.add(dsts[0], dsts[0].amount, original_output_index, m_merge_destinations);
available_amount -= dsts[0].amount;
dsts[0].amount = 0;
pop_index(dsts, 0);
++original_output_index;
}
if (available_amount > 0 && !dsts.empty() && estimate_tx_weight(tx.selected_transfers.size(), fake_outs_count, tx.dsts.size()+1, extra.size()) < TX_WEIGHT_TARGET(upper_transaction_weight_limit)) {
// we can partially fill that destination
LOG_PRINT_L2("We can partially pay " << get_account_address_as_str(m_nettype, dsts[0].is_subaddress, dsts[0].addr) <<
" for " << print_money(available_amount) << "/" << print_money(dsts[0].amount));
tx.add(dsts[0], available_amount, original_output_index, m_merge_destinations);
dsts[0].amount -= available_amount;
available_amount = 0;
}
}
// here, check if we need to sent tx and start a new one
LOG_PRINT_L2("Considering whether to create a tx now, " << tx.selected_transfers.size() << " inputs, tx limit "
<< upper_transaction_weight_limit);
bool try_tx = false;
// if we have preferred picks, but haven't yet used all of them, continue
if (preferred_inputs.empty())
{
if (adding_fee)
{
/* might not actually be enough if adding this output bumps size to next kB, but we need to try */
try_tx = available_for_fee >= needed_fee;
}
else
{
const size_t estimated_rct_tx_weight = estimate_tx_weight(tx.selected_transfers.size(), fake_outs_count, tx.dsts.size()+1, extra.size());
try_tx = dsts.empty() || (estimated_rct_tx_weight >= TX_WEIGHT_TARGET(upper_transaction_weight_limit));
THROW_WALLET_EXCEPTION_IF(try_tx && tx.dsts.empty(), error::tx_too_big, estimated_rct_tx_weight, upper_transaction_weight_limit);
}
}
if (try_tx) {
cryptonote::transaction test_tx;
pending_tx test_ptx;
needed_fee = estimate_fee(tx.selected_transfers.size(), fake_outs_count, tx.dsts.size()+1, extra.size(), base_fee, fee_percent, fixed_fee, fee_quantization_mask);
uint64_t inputs = 0, outputs = needed_fee;
for (size_t idx: tx.selected_transfers) inputs += m_transfers[idx].amount();
for (const auto &o: tx.dsts) outputs += o.amount;
if (inputs < outputs)
{
LOG_PRINT_L2("We don't have enough for the basic fee, switching to adding_fee");
adding_fee = true;
goto skip_tx;
}
LOG_PRINT_L2("Trying to create a tx now, with " << tx.dsts.size() << " outputs and " <<
tx.selected_transfers.size() << " inputs");
transfer_selected_rct(tx.dsts, tx.selected_transfers, fake_outs_count, outs, unlock_time, needed_fee, extra,
test_tx, test_ptx, rct_config, worktips_tx_params);
auto txBlob = t_serializable_object_to_blob(test_ptx.tx);
needed_fee = calculate_fee(test_ptx.tx, txBlob.size(), base_fee, fee_percent, fixed_fee, fee_quantization_mask);
available_for_fee = test_ptx.fee + test_ptx.change_dts.amount + (!test_ptx.dust_added_to_fee ? test_ptx.dust : 0);
LOG_PRINT_L2("Made a " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_money(available_for_fee) << " available for fee (" <<
print_money(needed_fee) << " needed)");
if (needed_fee > available_for_fee && !dsts.empty() && dsts[0].amount > 0)
{
// we don't have enough for the fee, but we've only partially paid the current address,
// so we can take the fee from the paid amount, since we'll have to make another tx anyway
std::vector<cryptonote::tx_destination_entry>::iterator i;
i = std::find_if(tx.dsts.begin(), tx.dsts.end(),
[&](const cryptonote::tx_destination_entry &d) { return !memcmp (&d.addr, &dsts[0].addr, sizeof(dsts[0].addr)); });
THROW_WALLET_EXCEPTION_IF(i == tx.dsts.end(), error::wallet_internal_error, "paid address not found in outputs");
if (i->amount > needed_fee)
{
uint64_t new_paid_amount = i->amount /*+ test_ptx.fee*/ - needed_fee;
LOG_PRINT_L2("Adjusting amount paid to " << get_account_address_as_str(m_nettype, i->is_subaddress, i->addr) << " from " <<
print_money(i->amount) << " to " << print_money(new_paid_amount) << " to accommodate " <<
print_money(needed_fee) << " fee");
dsts[0].amount += i->amount - new_paid_amount;
i->amount = new_paid_amount;
test_ptx.fee = needed_fee;
available_for_fee = needed_fee;
}
}
if (needed_fee > available_for_fee)
{
LOG_PRINT_L2("We could not make a tx, switching to fee accumulation");
adding_fee = true;
}
else
{
LOG_PRINT_L2("We made a tx, adjusting fee and saving it, we need " << print_money(needed_fee) << " and we have " << print_money(test_ptx.fee));
while (needed_fee > test_ptx.fee) {
transfer_selected_rct(tx.dsts, tx.selected_transfers, fake_outs_count, outs, unlock_time, needed_fee, extra,
test_tx, test_ptx, rct_config, worktips_tx_params);
txBlob = t_serializable_object_to_blob(test_ptx.tx);
needed_fee = calculate_fee(test_ptx.tx, txBlob.size(), base_fee, fee_percent, fixed_fee, fee_quantization_mask);
LOG_PRINT_L2("Made an attempt at a final " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_money(test_ptx.fee) <<
" fee and " << print_money(test_ptx.change_dts.amount) << " change");
}
LOG_PRINT_L2("Made a final " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_money(test_ptx.fee) <<
" fee and " << print_money(test_ptx.change_dts.amount) << " change");
tx.tx = test_tx;
tx.ptx = test_ptx;
tx.weight = get_transaction_weight(test_tx, txBlob.size());
tx.outs = outs;
tx.needed_fee = test_ptx.fee;
accumulated_fee += test_ptx.fee;
accumulated_change += test_ptx.change_dts.amount;
adding_fee = false;
if (!dsts.empty())
{
LOG_PRINT_L2("We have more to pay, starting another tx");
txes.push_back(TX());
original_output_index = 0;
}
}
}
skip_tx:
// if unused_*_indices is empty while unused_*_indices_per_subaddr has multiple elements, and if we still have something to pay,
// pop front of unused_*_indices_per_subaddr and have unused_*_indices point to the front of unused_*_indices_per_subaddr
if ((!dsts.empty() && dsts[0].amount > 0) || adding_fee)
{
if (unused_transfers_indices->empty() && unused_transfers_indices_per_subaddr.size() > 1)
{
unused_transfers_indices_per_subaddr.erase(unused_transfers_indices_per_subaddr.begin());
unused_transfers_indices = &unused_transfers_indices_per_subaddr[0].second;
}
if (unused_dust_indices->empty() && unused_dust_indices_per_subaddr.size() > 1)
{
unused_dust_indices_per_subaddr.erase(unused_dust_indices_per_subaddr.begin());
unused_dust_indices = &unused_dust_indices_per_subaddr[0].second;
}
}
}
if (adding_fee)
{
LOG_PRINT_L1("We ran out of outputs while trying to gather final fee");
THROW_WALLET_EXCEPTION_IF(1, error::tx_not_possible, unlocked_balance(subaddr_account), needed_money, accumulated_fee + needed_fee);
}
LOG_PRINT_L1("Done creating " << txes.size() << " transactions, " << print_money(accumulated_fee) <<
" total fee, " << print_money(accumulated_change) << " total change");
hwdev.set_mode(hw::device::TRANSACTION_CREATE_REAL);
for (auto &tx : txes)
{
// Convert burn percent into a fixed burn amount because this is the last place we can back out
// the base fee that would apply at 100% (the actual fee here is that times the priority-based
// fee percent)
if (burning)
{
worktips_tx_params.burn_fixed = burn_fixed + tx.needed_fee * burn_percent / fee_percent;
// Make sure we can't enlarge the tx because that could make it invalid:
THROW_WALLET_EXCEPTION_IF(worktips_tx_params.burn_fixed > BURN_FEE_PLACEHOLDER, error::wallet_internal_error, "attempt to burn a larger amount than is internally supported");
}
cryptonote::transaction test_tx;
pending_tx test_ptx;
transfer_selected_rct( tx.dsts, /* NOMOD std::vector<cryptonote::tx_destination_entry> dsts,*/
tx.selected_transfers, /* const std::list<size_t> selected_transfers */
fake_outs_count, /* CONST size_t fake_outputs_count, */
tx.outs, /* MOD std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs, */
unlock_time, /* CONST uint64_t unlock_time, */
tx.needed_fee, /* CONST uint64_t fee, */
extra, /* const std::vector<uint8_t>& extra, */
test_tx, /* OUT cryptonote::transaction& tx, */
test_ptx, /* OUT cryptonote::transaction& tx, */
rct_config,
worktips_tx_params);
auto txBlob = t_serializable_object_to_blob(test_ptx.tx);
tx.tx = test_tx;
tx.ptx = test_ptx;
tx.weight = get_transaction_weight(test_tx, txBlob.size());
}
std::vector<wallet2::pending_tx> ptx_vector;
for (std::vector<TX>::iterator i = txes.begin(); i != txes.end(); ++i)
{
TX &tx = *i;
uint64_t tx_money = 0;
for (size_t idx: tx.selected_transfers)
tx_money += m_transfers[idx].amount();
LOG_PRINT_L1(" Transaction " << (1+std::distance(txes.begin(), i)) << "/" << txes.size() <<
" " << get_transaction_hash(tx.ptx.tx) << ": " << get_weight_string(tx.weight) << ", sending " << print_money(tx_money) << " in " << tx.selected_transfers.size() <<
" outputs to " << tx.dsts.size() << " destination(s), including " <<
print_money(tx.ptx.fee) << " fee, " << print_money(tx.ptx.change_dts.amount) << " change");
ptx_vector.push_back(tx.ptx);
}
THROW_WALLET_EXCEPTION_IF(!sanity_check(ptx_vector, original_dsts), error::wallet_internal_error, "Created transaction(s) failed sanity check");
// if we made it this far, we're OK to actually send the transactions
return ptx_vector;
}
bool wallet2::sanity_check(const std::vector<wallet2::pending_tx> &ptx_vector, std::vector<cryptonote::tx_destination_entry> dsts) const
{
MDEBUG("sanity_check: " << ptx_vector.size() << " txes, " << dsts.size() << " destinations");
hw::device &hwdev = m_account.get_device();
THROW_WALLET_EXCEPTION_IF(ptx_vector.empty(), error::wallet_internal_error, "No transactions");
// check every party in there does receive at least the required amount
std::unordered_map<account_public_address, std::pair<uint64_t, bool>> required;
for (const auto &d: dsts)
{
required[d.addr].first += d.amount;
required[d.addr].second = d.is_subaddress;
}
// add change
uint64_t change = 0;
for (const auto &ptx: ptx_vector)
{
for (size_t idx: ptx.selected_transfers)
change += m_transfers[idx].amount();
change -= ptx.fee;
}
for (const auto &r: required)
change -= r.second.first;
MDEBUG("Adding " << cryptonote::print_money(change) << " expected change");
// for all txes that have actual change, check change is coming back to the sending wallet
for (const pending_tx &ptx: ptx_vector)
{
if (ptx.change_dts.amount == 0)
continue;
THROW_WALLET_EXCEPTION_IF(m_subaddresses.find(ptx.change_dts.addr.m_spend_public_key) == m_subaddresses.end(),
error::wallet_internal_error, "Change address is not ours");
required[ptx.change_dts.addr].first += ptx.change_dts.amount;
required[ptx.change_dts.addr].second = ptx.change_dts.is_subaddress;
}
for (const auto &r: required)
{
const account_public_address &address = r.first;
const crypto::public_key &view_pkey = address.m_view_public_key;
uint64_t total_received = 0;
for (const auto &ptx: ptx_vector)
{
uint64_t received = 0;
try
{
std::string proof = get_tx_proof(ptx.tx, ptx.tx_key, ptx.additional_tx_keys, address, r.second.second, "automatic-sanity-check");
check_tx_proof(ptx.tx, address, r.second.second, "automatic-sanity-check", proof, received);
}
catch (const std::exception &e) { received = 0; }
total_received += received;
}
std::stringstream ss;
ss << "Total received by " << cryptonote::get_account_address_as_str(m_nettype, r.second.second, address) << ": "
<< cryptonote::print_money(total_received) << ", expected " << cryptonote::print_money(r.second.first);
MDEBUG(ss.str());
THROW_WALLET_EXCEPTION_IF(total_received < r.second.first, error::wallet_internal_error, ss.str());
}
return true;
}
std::vector<wallet2::pending_tx> wallet2::create_transactions_all(uint64_t below, const cryptonote::account_public_address &address, bool is_subaddress, const size_t outputs, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector<uint8_t>& extra, uint32_t subaddr_account, std::set<uint32_t> subaddr_indices, cryptonote::txtype tx_type)
{
std::vector<size_t> unused_transfers_indices;
std::vector<size_t> unused_dust_indices;
THROW_WALLET_EXCEPTION_IF(unlocked_balance(subaddr_account) == 0, error::wallet_internal_error, "No unlocked balance in the entire wallet");
std::map<uint32_t, std::pair<std::vector<size_t>, std::vector<size_t>>> unused_transfer_dust_indices_per_subaddr;
// gather all dust and non-dust outputs of specified subaddress (if any) and below specified threshold (if any)
bool fund_found = false;
for (size_t i = 0; i < m_transfers.size(); ++i)
{
const transfer_details& td = m_transfers[i];
if (!td.m_spent && !td.m_frozen && !td.m_key_image_partial && is_transfer_unlocked(td) && td.m_subaddr_index.major == subaddr_account && (subaddr_indices.empty() || subaddr_indices.count(td.m_subaddr_index.minor) == 1))
{
fund_found = true;
if (below == 0 || td.amount() < below)
{
if (td.m_tx.version <= txversion::v1)
continue;
if ((td.is_rct()) || is_valid_decomposed_amount(td.amount()))
unused_transfer_dust_indices_per_subaddr[td.m_subaddr_index.minor].first.push_back(i);
else
unused_transfer_dust_indices_per_subaddr[td.m_subaddr_index.minor].second.push_back(i);
}
}
}
THROW_WALLET_EXCEPTION_IF(!fund_found, error::wallet_internal_error, "No unlocked balance in the specified subaddress(es)");
THROW_WALLET_EXCEPTION_IF(unused_transfer_dust_indices_per_subaddr.empty(), error::wallet_internal_error, "The smallest amount found is not below the specified threshold");
if (subaddr_indices.empty())
{
// in case subaddress index wasn't specified, choose non-empty subaddress randomly (with index=0 being chosen last)
if (unused_transfer_dust_indices_per_subaddr.count(0) == 1 && unused_transfer_dust_indices_per_subaddr.size() > 1)
unused_transfer_dust_indices_per_subaddr.erase(0);
auto i = unused_transfer_dust_indices_per_subaddr.begin();
std::advance(i, crypto::rand_idx(unused_transfer_dust_indices_per_subaddr.size()));
unused_transfers_indices = i->second.first;
unused_dust_indices = i->second.second;
LOG_PRINT_L2("Spending from subaddress index " << i->first);
}
else
{
for (const auto& p : unused_transfer_dust_indices_per_subaddr)
{
unused_transfers_indices.insert(unused_transfers_indices.end(), p.second.first.begin(), p.second.first.end());
unused_dust_indices.insert(unused_dust_indices.end(), p.second.second.begin(), p.second.second.end());
LOG_PRINT_L2("Spending from subaddress index " << p.first);
}
}
return create_transactions_from(address, is_subaddress, outputs, unused_transfers_indices, unused_dust_indices, fake_outs_count, unlock_time, priority, extra, tx_type);
}
std::vector<wallet2::pending_tx> wallet2::create_transactions_single(const crypto::key_image &ki, const cryptonote::account_public_address &address, bool is_subaddress, const size_t outputs, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector<uint8_t>& extra, cryptonote::txtype tx_type)
{
std::vector<size_t> unused_transfers_indices;
std::vector<size_t> unused_dust_indices;
// find output with the given key image
for (size_t i = 0; i < m_transfers.size(); ++i)
{
const transfer_details& td = m_transfers[i];
if (td.m_key_image_known && td.m_key_image == ki && !td.m_spent && !td.m_frozen && is_transfer_unlocked(td))
{
if (td.is_rct() || is_valid_decomposed_amount(td.amount()))
unused_transfers_indices.push_back(i);
else
unused_dust_indices.push_back(i);
break;
}
}
return create_transactions_from(address, is_subaddress, outputs, unused_transfers_indices, unused_dust_indices, fake_outs_count, unlock_time, priority, extra, tx_type);
}
std::vector<wallet2::pending_tx> wallet2::create_transactions_from(const cryptonote::account_public_address &address, bool is_subaddress, const size_t outputs, std::vector<size_t> unused_transfers_indices, std::vector<size_t> unused_dust_indices, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector<uint8_t>& extra_base, cryptonote::txtype tx_type)
{
//ensure device is let in NONE mode in any case
hw::device &hwdev = m_account.get_device();
boost::unique_lock<hw::device> hwdev_lock (hwdev);
hw::reset_mode rst(hwdev);
uint64_t accumulated_fee, accumulated_outputs, accumulated_change;
struct TX {
std::vector<size_t> selected_transfers;
std::vector<cryptonote::tx_destination_entry> dsts;
cryptonote::transaction tx;
pending_tx ptx;
size_t weight;
uint64_t needed_fee;
std::vector<std::vector<get_outs_entry>> outs;
TX() : weight(0), needed_fee(0) {}
};
std::vector<TX> txes;
uint64_t needed_fee, available_for_fee = 0;
uint64_t upper_transaction_weight_limit = get_upper_transaction_weight_limit();
std::vector<std::vector<get_outs_entry>> outs;
const rct::RCTConfig rct_config { rct::RangeProofPaddedBulletproof, 2 };
const auto base_fee = get_base_fees();
const uint64_t fee_percent = get_fee_percent(priority, get_fee_algorithm());
const uint64_t fee_quantization_mask = get_fee_quantization_mask();
uint64_t fixed_fee = 0;
boost::optional<uint8_t> hf_version = get_hard_fork_version();
THROW_WALLET_EXCEPTION_IF(!hf_version, error::get_hard_fork_version_error, "Failed to query current hard fork version");
worktips_construct_tx_params worktips_tx_params = tools::wallet2::construct_params(priority);
worktips_tx_params.tx_type = tx_type;
worktips_tx_params.hf_version = *hf_version;
uint64_t burn_fixed = 0, burn_percent = 0;
// Swap these out because we don't want them present for building intermediate temporary tx
// calculations (which we don't actually use); we'll set them again at the end before we build the
// real transactions.
std::swap(burn_fixed, worktips_tx_params.burn_fixed);
std::swap(burn_percent, worktips_tx_params.burn_percent);
bool burning = burn_fixed || burn_percent;
THROW_WALLET_EXCEPTION_IF(burning && worktips_tx_params.hf_version < HF_VERSION_FEE_BURNING, error::wallet_internal_error, "cannot construct transaction: cannot burn amounts under the current hard fork");
std::vector<uint8_t> extra_plus; // Copy and modified from input if modification needed
const std::vector<uint8_t> &extra = burning ? extra_plus : extra_base;
if (burning)
{
extra_plus = extra_base;
add_burned_amount_to_tx_extra(extra_plus, BURN_FEE_PLACEHOLDER);
fixed_fee += burn_fixed;
THROW_WALLET_EXCEPTION_IF(burn_percent > fee_percent, error::wallet_internal_error, "invalid burn fees: cannot burn more than the tx fee");
}
LOG_PRINT_L2("Starting with " << unused_transfers_indices.size() << " non-dust outputs and " << unused_dust_indices.size() << " dust outputs");
if (unused_dust_indices.empty() && unused_transfers_indices.empty())
return std::vector<wallet2::pending_tx>();
// start with an empty tx
txes.push_back(TX());
accumulated_fee = 0;
accumulated_outputs = 0;
accumulated_change = 0;
needed_fee = 0;
// while we have something to send
hwdev.set_mode(hw::device::TRANSACTION_CREATE_FAKE);
while (!unused_dust_indices.empty() || !unused_transfers_indices.empty()) {
TX &tx = txes.back();
// get a random unspent output and use it to pay next chunk. We try to alternate
// dust and non dust to ensure we never get with only dust, from which we might
// get a tx that can't pay for itself
uint64_t fee_dust_threshold;
{
const uint64_t estimated_tx_weight_with_one_extra_output = estimate_tx_weight(tx.selected_transfers.size() + 1, fake_outs_count, tx.dsts.size()+1, extra.size());
fee_dust_threshold = calculate_fee_from_weight(base_fee, estimated_tx_weight_with_one_extra_output, outputs, fee_percent, fixed_fee, fee_quantization_mask);
}
size_t idx =
unused_transfers_indices.empty()
? pop_best_value(unused_dust_indices, tx.selected_transfers)
: unused_dust_indices.empty()
? pop_best_value(unused_transfers_indices, tx.selected_transfers)
: ((tx.selected_transfers.size() & 1) || accumulated_outputs > fee_dust_threshold)
? pop_best_value(unused_dust_indices, tx.selected_transfers)
: pop_best_value(unused_transfers_indices, tx.selected_transfers);
const transfer_details &td = m_transfers[idx];
LOG_PRINT_L2("Picking output " << idx << ", amount " << print_money(td.amount()));
// add this output to the list to spend
tx.selected_transfers.push_back(idx);
uint64_t available_amount = td.amount();
accumulated_outputs += available_amount;
// clear any fake outs we'd already gathered, since we'll need a new set
outs.clear();
// here, check if we need to sent tx and start a new one
LOG_PRINT_L2("Considering whether to create a tx now, " << tx.selected_transfers.size() << " inputs, tx limit "
<< upper_transaction_weight_limit);
const size_t estimated_rct_tx_weight = estimate_tx_weight(tx.selected_transfers.size(), fake_outs_count, tx.dsts.size() + 2, extra.size());
bool try_tx = (unused_dust_indices.empty() && unused_transfers_indices.empty()) || ( estimated_rct_tx_weight >= TX_WEIGHT_TARGET(upper_transaction_weight_limit));
if (try_tx) {
cryptonote::transaction test_tx;
pending_tx test_ptx;
needed_fee = estimate_fee(tx.selected_transfers.size(), fake_outs_count, tx.dsts.size()+1, extra.size(), base_fee, fee_percent, fixed_fee, fee_quantization_mask);
// add N - 1 outputs for correct initial fee estimation
for (size_t i = 0; i < ((outputs > 1) ? outputs - 1 : outputs); ++i)
tx.dsts.push_back(tx_destination_entry(1, address, is_subaddress));
LOG_PRINT_L2("Trying to create a tx now, with " << tx.dsts.size() << " destinations and " <<
tx.selected_transfers.size() << " outputs");
transfer_selected_rct(tx.dsts, tx.selected_transfers, fake_outs_count, outs, unlock_time, needed_fee, extra,
test_tx, test_ptx, rct_config, worktips_tx_params);
auto txBlob = t_serializable_object_to_blob(test_ptx.tx);
needed_fee = calculate_fee(test_ptx.tx, txBlob.size(), base_fee, fee_percent, fixed_fee, fee_quantization_mask);
available_for_fee = test_ptx.fee + test_ptx.change_dts.amount;
for (auto &dt: test_ptx.dests)
available_for_fee += dt.amount;
LOG_PRINT_L2("Made a " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_money(available_for_fee) << " available for fee (" <<
print_money(needed_fee) << " needed)");
// add last output, missed for fee estimation
if (outputs > 1)
tx.dsts.push_back(tx_destination_entry(1, address, is_subaddress));
THROW_WALLET_EXCEPTION_IF(needed_fee > available_for_fee, error::wallet_internal_error, "Transaction cannot pay for itself");
do {
LOG_PRINT_L2("We made a tx, adjusting fee and saving it");
// distribute total transferred amount between outputs
uint64_t amount_transferred = available_for_fee - needed_fee;
uint64_t dt_amount = amount_transferred / outputs;
// residue is distributed as one atomic unit per output until it reaches zero
uint64_t residue = amount_transferred % outputs;
for (auto &dt: tx.dsts)
{
uint64_t dt_residue = 0;
if (residue > 0)
{
dt_residue = 1;
residue -= 1;
}
dt.amount = dt_amount + dt_residue;
}
transfer_selected_rct(tx.dsts, tx.selected_transfers, fake_outs_count, outs, unlock_time, needed_fee, extra,
test_tx, test_ptx, rct_config, worktips_tx_params);
txBlob = t_serializable_object_to_blob(test_ptx.tx);
needed_fee = calculate_fee(test_ptx.tx, txBlob.size(), base_fee, fee_percent, fixed_fee, fee_quantization_mask);
LOG_PRINT_L2("Made an attempt at a final " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_money(test_ptx.fee) <<
" fee and " << print_money(test_ptx.change_dts.amount) << " change");
} while (needed_fee > test_ptx.fee);
LOG_PRINT_L2("Made a final " << get_weight_string(test_ptx.tx, txBlob.size()) << " tx, with " << print_money(test_ptx.fee) <<
" fee and " << print_money(test_ptx.change_dts.amount) << " change");
tx.tx = test_tx;
tx.ptx = test_ptx;
tx.weight = get_transaction_weight(test_tx, txBlob.size());
tx.outs = outs;
tx.needed_fee = test_ptx.fee;
accumulated_fee += test_ptx.fee;
accumulated_change += test_ptx.change_dts.amount;
if (!unused_transfers_indices.empty() || !unused_dust_indices.empty())
{
LOG_PRINT_L2("We have more to pay, starting another tx");
txes.push_back(TX());
}
}
}
LOG_PRINT_L1("Done creating " << txes.size() << " transactions, " << print_money(accumulated_fee) <<
" total fee, " << print_money(accumulated_change) << " total change");
hwdev.set_mode(hw::device::TRANSACTION_CREATE_REAL);
for (auto &tx : txes)
{
// Convert burn percent into a fixed burn amount because this is the last place we can back out
// the base fee that would apply at 100% (the actual fee here is that times the priority-based
// fee percent)
if (burning)
{
worktips_tx_params.burn_fixed = burn_fixed + tx.needed_fee * burn_percent / fee_percent;
// Make sure we can't enlarge the tx because that could make it invalid:
THROW_WALLET_EXCEPTION_IF(worktips_tx_params.burn_fixed > BURN_FEE_PLACEHOLDER, error::wallet_internal_error, "attempt to burn a larger amount than is internally supported");
}
cryptonote::transaction test_tx;
pending_tx test_ptx;
transfer_selected_rct(tx.dsts, tx.selected_transfers, fake_outs_count, tx.outs, unlock_time, tx.needed_fee, extra, test_tx, test_ptx, rct_config, worktips_tx_params);
auto txBlob = t_serializable_object_to_blob(test_ptx.tx);
tx.tx = test_tx;
tx.ptx = test_ptx;
tx.weight = get_transaction_weight(test_tx, txBlob.size());
}
std::vector<wallet2::pending_tx> ptx_vector;
for (std::vector<TX>::iterator i = txes.begin(); i != txes.end(); ++i)
{
TX &tx = *i;
uint64_t tx_money = 0;
for (size_t idx: tx.selected_transfers)
tx_money += m_transfers[idx].amount();
LOG_PRINT_L1(" Transaction " << (1+std::distance(txes.begin(), i)) << "/" << txes.size() <<
" " << get_transaction_hash(tx.ptx.tx) << ": " << get_weight_string(tx.weight) << ", sending " << print_money(tx_money) << " in " << tx.selected_transfers.size() <<
" outputs to " << tx.dsts.size() << " destination(s), including " <<
print_money(tx.ptx.fee) << " fee, " << print_money(tx.ptx.change_dts.amount) << " change");
ptx_vector.push_back(tx.ptx);
}
uint64_t a = 0;
for (const TX &tx: txes)
{
for (size_t idx: tx.selected_transfers)
{
a += m_transfers[idx].amount();
}
a -= tx.ptx.fee;
}
std::vector<cryptonote::tx_destination_entry> synthetic_dsts(1, cryptonote::tx_destination_entry("", a, address, is_subaddress));
THROW_WALLET_EXCEPTION_IF(!sanity_check(ptx_vector, synthetic_dsts), error::wallet_internal_error, "Created transaction(s) failed sanity check");
// if we made it this far, we're OK to actually send the transactions
return ptx_vector;
}
//----------------------------------------------------------------------------------------------------
void wallet2::cold_tx_aux_import(const std::vector<pending_tx> & ptx, const std::vector<std::string> & tx_device_aux)
{
CHECK_AND_ASSERT_THROW_MES(ptx.size() == tx_device_aux.size(), "TX aux has invalid size");
for (size_t i = 0; i < ptx.size(); ++i){
crypto::hash txid;
txid = get_transaction_hash(ptx[i].tx);
set_tx_device_aux(txid, tx_device_aux[i]);
}
}
//----------------------------------------------------------------------------------------------------
void wallet2::cold_sign_tx(const std::vector<pending_tx>& ptx_vector, signed_tx_set &exported_txs, std::vector<cryptonote::address_parse_info> &dsts_info, std::vector<std::string> & tx_device_aux)
{
auto & hwdev = get_account().get_device();
if (!hwdev.has_tx_cold_sign()){
throw std::invalid_argument("Device does not support cold sign protocol");
}
unsigned_tx_set txs;
for (auto &tx: ptx_vector)
{
txs.txes.push_back(get_construction_data_with_decrypted_short_payment_id(tx, m_account.get_device()));
}
txs.transfers = std::make_pair(0, m_transfers);
auto dev_cold = dynamic_cast<::hw::device_cold*>(&hwdev);
CHECK_AND_ASSERT_THROW_MES(dev_cold, "Device does not implement cold signing interface");
hw::tx_aux_data aux_data;
hw::wallet_shim wallet_shim;
setup_shim(&wallet_shim, this);
aux_data.tx_recipients = dsts_info;
aux_data.bp_version = 2;
dev_cold->tx_sign(&wallet_shim, txs, exported_txs, aux_data);
tx_device_aux = aux_data.tx_device_aux;
MDEBUG("Signed tx data from hw: " << exported_txs.ptx.size() << " transactions");
for (auto &c_ptx: exported_txs.ptx) LOG_PRINT_L0(cryptonote::obj_to_json_str(c_ptx.tx));
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::cold_key_image_sync(uint64_t &spent, uint64_t &unspent) {
auto & hwdev = get_account().get_device();
CHECK_AND_ASSERT_THROW_MES(hwdev.has_ki_cold_sync(), "Device does not support cold ki sync protocol");
auto dev_cold = dynamic_cast<::hw::device_cold*>(&hwdev);
CHECK_AND_ASSERT_THROW_MES(dev_cold, "Device does not implement cold signing interface");
std::vector<std::pair<crypto::key_image, crypto::signature>> ski;
hw::wallet_shim wallet_shim;
setup_shim(&wallet_shim, this);
dev_cold->ki_sync(&wallet_shim, m_transfers, ski);
// Call COMMAND_RPC_IS_KEY_IMAGE_SPENT only if daemon is trusted.
uint64_t import_res = import_key_images(ski, 0, spent, unspent, is_trusted_daemon());
m_device_last_key_image_sync = time(NULL);
return import_res;
}
//----------------------------------------------------------------------------------------------------
void wallet2::get_hard_fork_info(uint8_t version, uint64_t &earliest_height) const
{
boost::optional<std::string> result = m_node_rpc_proxy.get_earliest_height(version, earliest_height);
throw_on_rpc_response_error(result, "get_hard_fork_info");
}
//----------------------------------------------------------------------------------------------------
bool wallet2::use_fork_rules(uint8_t version, uint64_t early_blocks) const
{
// TODO: How to get fork rule info from light wallet node?
if(m_light_wallet)
return true;
uint64_t height, earliest_height;
boost::optional<std::string> result = m_node_rpc_proxy.get_height(height);
throw_on_rpc_response_error(result, "get_info");
result = m_node_rpc_proxy.get_earliest_height(version, earliest_height);
throw_on_rpc_response_error(result, "get_hard_fork_info");
bool close_enough = height >= earliest_height - early_blocks; // start using the rules that many blocks beforehand
if (early_blocks > earliest_height) // Start using rules early if early_blocks would underflow earliest_height, in prev calc
close_enough = true;
if (close_enough)
LOG_PRINT_L2("Using v" << (unsigned)version << " rules");
else
LOG_PRINT_L2("Not using v" << (unsigned)version << " rules");
return close_enough;
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::get_upper_transaction_weight_limit() const
{
if (m_upper_transaction_weight_limit > 0)
return m_upper_transaction_weight_limit;
return CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE_V5 / 2 - CRYPTONOTE_COINBASE_BLOB_RESERVED_SIZE;
}
//----------------------------------------------------------------------------------------------------
std::vector<size_t> wallet2::select_available_outputs(const std::function<bool(const transfer_details &td)> &f) const
{
std::vector<size_t> outputs;
size_t n = 0;
for (transfer_container::const_iterator i = m_transfers.begin(); i != m_transfers.end(); ++i, ++n)
{
if (i->m_spent)
continue;
if (i->m_frozen)
continue;
if (i->m_key_image_partial)
continue;
if (!is_transfer_unlocked(*i))
continue;
if (f(*i))
outputs.push_back(n);
}
return outputs;
}
//----------------------------------------------------------------------------------------------------
std::vector<uint64_t> wallet2::get_unspent_amounts_vector() const
{
std::set<uint64_t> set;
for (const auto &td: m_transfers)
{
if (!td.m_spent && !td.m_frozen)
set.insert(td.is_rct() ? 0 : td.amount());
}
std::vector<uint64_t> vector;
vector.reserve(set.size());
for (const auto &i: set)
{
vector.push_back(i);
}
return vector;
}
//----------------------------------------------------------------------------------------------------
std::vector<size_t> wallet2::select_available_outputs_from_histogram(uint64_t count, bool atleast, bool unlocked, bool allow_rct)
{
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request req_t{};
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response resp_t{};
m_daemon_rpc_mutex.lock();
if (is_trusted_daemon())
req_t.amounts = get_unspent_amounts_vector();
req_t.min_count = count;
req_t.max_count = 0;
req_t.unlocked = unlocked;
req_t.recent_cutoff = 0;
bool r = invoke_http_json_rpc("/json_rpc", "get_output_histogram", req_t, resp_t, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "select_available_outputs_from_histogram");
THROW_WALLET_EXCEPTION_IF(resp_t.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_output_histogram");
THROW_WALLET_EXCEPTION_IF(resp_t.status != CORE_RPC_STATUS_OK, error::get_histogram_error, resp_t.status);
std::set<uint64_t> mixable;
for (const auto &i: resp_t.histogram)
{
mixable.insert(i.amount);
}
return select_available_outputs([mixable, atleast, allow_rct](const transfer_details &td) {
if (!allow_rct && td.is_rct())
return false;
const uint64_t amount = td.is_rct() ? 0 : td.amount();
if (atleast) {
if (mixable.find(amount) != mixable.end())
return true;
}
else {
if (mixable.find(amount) == mixable.end())
return true;
}
return false;
});
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::get_num_rct_outputs()
{
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::request req_t{};
cryptonote::COMMAND_RPC_GET_OUTPUT_HISTOGRAM::response resp_t{};
m_daemon_rpc_mutex.lock();
req_t.amounts.push_back(0);
req_t.min_count = 0;
req_t.max_count = 0;
req_t.unlocked = true;
req_t.recent_cutoff = 0;
bool r = invoke_http_json_rpc("/json_rpc", "get_output_histogram", req_t, resp_t, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_num_rct_outputs");
THROW_WALLET_EXCEPTION_IF(resp_t.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_output_histogram");
THROW_WALLET_EXCEPTION_IF(resp_t.status != CORE_RPC_STATUS_OK, error::get_histogram_error, resp_t.status);
THROW_WALLET_EXCEPTION_IF(resp_t.histogram.size() != 1, error::get_histogram_error, "Expected exactly one response");
THROW_WALLET_EXCEPTION_IF(resp_t.histogram[0].amount != 0, error::get_histogram_error, "Expected 0 amount");
return resp_t.histogram[0].total_instances;
}
//----------------------------------------------------------------------------------------------------
const wallet2::transfer_details &wallet2::get_transfer_details(size_t idx) const
{
THROW_WALLET_EXCEPTION_IF(idx >= m_transfers.size(), error::wallet_internal_error, "Bad transfer index");
return m_transfers[idx];
}
//----------------------------------------------------------------------------------------------------
std::vector<size_t> wallet2::select_available_unmixable_outputs()
{
// request all outputs with not enough available mixins
constexpr size_t min_mixin = 9;
return select_available_outputs_from_histogram(min_mixin + 1, false, true, false);
}
//----------------------------------------------------------------------------------------------------
std::vector<size_t> wallet2::select_available_mixable_outputs()
{
// request all outputs with at least 10nstances, so we can use mixin 9 with
constexpr size_t min_mixin = 9;
return select_available_outputs_from_histogram(min_mixin + 1, true, true, true);
}
//----------------------------------------------------------------------------------------------------
std::vector<wallet2::pending_tx> wallet2::create_unmixable_sweep_transactions()
{
const auto base_fee = get_base_fees();
// may throw
std::vector<size_t> unmixable_outputs = select_available_unmixable_outputs();
size_t num_dust_outputs = unmixable_outputs.size();
if (num_dust_outputs == 0)
{
return std::vector<wallet2::pending_tx>();
}
// split in "dust" and "non dust" to make it easier to select outputs
std::vector<size_t> unmixable_transfer_outputs, unmixable_dust_outputs;
for (auto n: unmixable_outputs)
{
if (m_transfers[n].amount() < base_fee.first)
unmixable_dust_outputs.push_back(n);
else
unmixable_transfer_outputs.push_back(n);
}
return create_transactions_from(m_account_public_address, false, 1, unmixable_transfer_outputs, unmixable_dust_outputs, 0 /*fake_outs_count */, 0 /* unlock_time */, 1 /*priority */, std::vector<uint8_t>{});
}
//----------------------------------------------------------------------------------------------------
void wallet2::discard_unmixable_outputs()
{
// may throw
std::vector<size_t> unmixable_outputs = select_available_unmixable_outputs();
for (size_t idx : unmixable_outputs)
{
freeze(idx);
}
}
bool wallet2::get_tx_key_cached(const crypto::hash &txid, crypto::secret_key &tx_key, std::vector<crypto::secret_key> &additional_tx_keys) const
{
additional_tx_keys.clear();
const std::unordered_map<crypto::hash, crypto::secret_key>::const_iterator i = m_tx_keys.find(txid);
if (i == m_tx_keys.end())
return false;
tx_key = i->second;
const auto j = m_additional_tx_keys.find(txid);
if (j != m_additional_tx_keys.end())
additional_tx_keys = j->second;
return true;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::get_tx_key(const crypto::hash &txid, crypto::secret_key &tx_key, std::vector<crypto::secret_key> &additional_tx_keys)
{
bool r = get_tx_key_cached(txid, tx_key, additional_tx_keys);
if (r)
{
return true;
}
auto & hwdev = get_account().get_device();
// So far only Cold protocol devices are supported.
if (hwdev.device_protocol() != hw::device::PROTOCOL_COLD)
{
return false;
}
const auto tx_data_it = m_tx_device.find(txid);
if (tx_data_it == m_tx_device.end())
{
MDEBUG("Aux data not found for txid: " << txid);
return false;
}
auto dev_cold = dynamic_cast<::hw::device_cold*>(&hwdev);
CHECK_AND_ASSERT_THROW_MES(dev_cold, "Device does not implement cold signing interface");
if (!dev_cold->is_get_tx_key_supported())
{
MDEBUG("get_tx_key not supported by the device");
return false;
}
hw::device_cold::tx_key_data_t tx_key_data;
dev_cold->load_tx_key_data(tx_key_data, tx_data_it->second);
// Load missing tx prefix hash
if (tx_key_data.tx_prefix_hash.empty())
{
COMMAND_RPC_GET_TRANSACTIONS::request req;
COMMAND_RPC_GET_TRANSACTIONS::response res;
req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
req.decode_as_json = false;
req.prune = true;
m_daemon_rpc_mutex.lock();
bool ok = invoke_http_json("/gettransactions", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!ok || (res.txs.size() != 1 && res.txs_as_hex.size() != 1),
error::wallet_internal_error, "Failed to get transaction from daemon");
cryptonote::transaction tx;
crypto::hash tx_hash{};
cryptonote::blobdata tx_data;
crypto::hash tx_prefix_hash{};
ok = string_tools::parse_hexstr_to_binbuff(res.txs_as_hex.front(), tx_data);
THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
THROW_WALLET_EXCEPTION_IF(!cryptonote::parse_and_validate_tx_from_blob(tx_data, tx, tx_hash, tx_prefix_hash),
error::wallet_internal_error, "Failed to validate transaction from daemon");
THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error,
"Failed to get the right transaction from daemon");
tx_key_data.tx_prefix_hash = std::string(tx_prefix_hash.data, 32);
}
std::vector<crypto::secret_key> tx_keys;
dev_cold->get_tx_key(tx_keys, tx_key_data, m_account.get_keys().m_view_secret_key);
if (tx_keys.empty())
{
return false;
}
tx_key = tx_keys[0];
tx_keys.erase(tx_keys.begin());
additional_tx_keys = tx_keys;
return true;
}
//----------------------------------------------------------------------------------------------------
void wallet2::set_tx_key(const crypto::hash &txid, const crypto::secret_key &tx_key, const std::vector<crypto::secret_key> &additional_tx_keys)
{
// fetch tx from daemon and check if secret keys agree with corresponding public keys
COMMAND_RPC_GET_TRANSACTIONS::request req{};
req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
req.decode_as_json = false;
req.prune = true;
COMMAND_RPC_GET_TRANSACTIONS::response res{};
bool r;
{
const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
r = invoke_http_json("/gettransactions", req, res, rpc_timeout);
}
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.txs.size() != 1, error::wallet_internal_error,
"daemon returned wrong response for gettransactions, wrong txs count = " +
std::to_string(res.txs.size()) + ", expected 1");
cryptonote::transaction tx;
crypto::hash tx_hash;
THROW_WALLET_EXCEPTION_IF(!get_pruned_tx(res.txs[0], tx, tx_hash), error::wallet_internal_error,
"Failed to get transaction from daemon");
THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error, "txid mismatch");
std::vector<tx_extra_field> tx_extra_fields;
THROW_WALLET_EXCEPTION_IF(!parse_tx_extra(tx.extra, tx_extra_fields), error::wallet_internal_error, "Transaction extra has unsupported format");
tx_extra_pub_key pub_key_field;
bool found = false;
size_t index = 0;
while (find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, index++))
{
crypto::public_key calculated_pub_key;
crypto::secret_key_to_public_key(tx_key, calculated_pub_key);
if (calculated_pub_key == pub_key_field.pub_key)
{
found = true;
break;
}
}
THROW_WALLET_EXCEPTION_IF(!found, error::wallet_internal_error, "Given tx secret key doesn't agree with the tx public key in the blockchain");
tx_extra_additional_pub_keys additional_tx_pub_keys;
find_tx_extra_field_by_type(tx_extra_fields, additional_tx_pub_keys);
THROW_WALLET_EXCEPTION_IF(additional_tx_keys.size() != additional_tx_pub_keys.data.size(), error::wallet_internal_error, "The number of additional tx secret keys doesn't agree with the number of additional tx public keys in the blockchain" );
m_tx_keys.insert(std::make_pair(txid, tx_key));
m_additional_tx_keys.insert(std::make_pair(txid, additional_tx_keys));
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::get_spend_proof(const crypto::hash &txid, const std::string &message)
{
THROW_WALLET_EXCEPTION_IF(m_watch_only, error::wallet_internal_error,
"get_spend_proof requires spend secret key and is not available for a watch-only wallet");
// fetch tx from daemon
COMMAND_RPC_GET_TRANSACTIONS::request req{};
req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
req.decode_as_json = false;
req.prune = true;
COMMAND_RPC_GET_TRANSACTIONS::response res{};
bool r;
{
const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
r = invoke_http_json("/gettransactions", req, res, rpc_timeout);
}
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.txs.size() != 1, error::wallet_internal_error,
"daemon returned wrong response for gettransactions, wrong txs count = " +
std::to_string(res.txs.size()) + ", expected 1");
cryptonote::transaction tx;
crypto::hash tx_hash;
THROW_WALLET_EXCEPTION_IF(!get_pruned_tx(res.txs[0], tx, tx_hash), error::wallet_internal_error, "Failed to get tx from daemon");
std::vector<std::vector<crypto::signature>> signatures;
// get signature prefix hash
std::string sig_prefix_data((const char*)&txid, sizeof(crypto::hash));
sig_prefix_data += message;
crypto::hash sig_prefix_hash;
crypto::cn_fast_hash(sig_prefix_data.data(), sig_prefix_data.size(), sig_prefix_hash);
for(size_t i = 0; i < tx.vin.size(); ++i)
{
const txin_to_key* const in_key = boost::get<txin_to_key>(std::addressof(tx.vin[i]));
if (in_key == nullptr)
continue;
// check if the key image belongs to us
const auto found = m_key_images.find(in_key->k_image);
if(found == m_key_images.end())
{
THROW_WALLET_EXCEPTION_IF(i > 0, error::wallet_internal_error, "subset of key images belong to us, very weird!");
THROW_WALLET_EXCEPTION_IF(true, error::wallet_internal_error, "This tx wasn't generated by this wallet!");
}
// derive the real output keypair
const transfer_details& in_td = m_transfers[found->second];
const txout_to_key* const in_tx_out_pkey = boost::get<txout_to_key>(std::addressof(in_td.m_tx.vout[in_td.m_internal_output_index].target));
THROW_WALLET_EXCEPTION_IF(in_tx_out_pkey == nullptr, error::wallet_internal_error, "Output is not txout_to_key");
const crypto::public_key in_tx_pub_key = get_tx_pub_key_from_extra(in_td.m_tx, in_td.m_pk_index);
const std::vector<crypto::public_key> in_additionakl_tx_pub_keys = get_additional_tx_pub_keys_from_extra(in_td.m_tx);
keypair in_ephemeral;
crypto::key_image in_img;
THROW_WALLET_EXCEPTION_IF(!generate_key_image_helper(m_account.get_keys(), m_subaddresses, in_tx_out_pkey->key, in_tx_pub_key, in_additionakl_tx_pub_keys, in_td.m_internal_output_index, in_ephemeral, in_img, m_account.get_device()),
error::wallet_internal_error, "failed to generate key image");
THROW_WALLET_EXCEPTION_IF(in_key->k_image != in_img, error::wallet_internal_error, "key image mismatch");
// get output pubkeys in the ring
const std::vector<uint64_t> absolute_offsets = cryptonote::relative_output_offsets_to_absolute(in_key->key_offsets);
const size_t ring_size = in_key->key_offsets.size();
THROW_WALLET_EXCEPTION_IF(absolute_offsets.size() != ring_size, error::wallet_internal_error, "absolute offsets size is wrong");
COMMAND_RPC_GET_OUTPUTS_BIN::request req{};
req.outputs.resize(ring_size);
for (size_t j = 0; j < ring_size; ++j)
{
req.outputs[j].amount = in_key->amount;
req.outputs[j].index = absolute_offsets[j];
}
COMMAND_RPC_GET_OUTPUTS_BIN::response res{};
bool r;
{
const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
r = invoke_http_bin("/get_outs.bin", req, res, rpc_timeout);
}
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_outs.bin");
THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_outs.bin");
THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "get_outs.bin");
THROW_WALLET_EXCEPTION_IF(res.outs.size() != ring_size, error::wallet_internal_error,
"daemon returned wrong response for get_outs.bin, wrong amounts count = " +
std::to_string(res.outs.size()) + ", expected " + std::to_string(ring_size));
// copy pubkey pointers
std::vector<const crypto::public_key *> p_output_keys;
for (const COMMAND_RPC_GET_OUTPUTS_BIN::outkey &out : res.outs)
p_output_keys.push_back(&out.key);
// figure out real output index and secret key
size_t sec_index = -1;
for (size_t j = 0; j < ring_size; ++j)
{
if (res.outs[j].key == in_ephemeral.pub)
{
sec_index = j;
break;
}
}
THROW_WALLET_EXCEPTION_IF(sec_index >= ring_size, error::wallet_internal_error, "secret index not found");
// generate ring sig for this input
signatures.push_back(std::vector<crypto::signature>());
std::vector<crypto::signature>& sigs = signatures.back();
sigs.resize(in_key->key_offsets.size());
crypto::generate_ring_signature(sig_prefix_hash, in_key->k_image, p_output_keys, in_ephemeral.sec, sec_index, sigs.data());
}
std::string sig_str = "SpendProofV1";
for (const std::vector<crypto::signature>& ring_sig : signatures)
for (const crypto::signature& sig : ring_sig)
sig_str += tools::base58::encode(std::string((const char *)&sig, sizeof(crypto::signature)));
return sig_str;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::check_spend_proof(const crypto::hash &txid, const std::string &message, const std::string &sig_str)
{
const std::string header = "SpendProofV1";
const size_t header_len = header.size();
THROW_WALLET_EXCEPTION_IF(sig_str.size() < header_len || sig_str.substr(0, header_len) != header, error::wallet_internal_error,
"Signature header check error");
// fetch tx from daemon
COMMAND_RPC_GET_TRANSACTIONS::request req{};
req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
req.decode_as_json = false;
req.prune = true;
COMMAND_RPC_GET_TRANSACTIONS::response res{};
bool r;
{
const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
r = invoke_http_json("/gettransactions", req, res, rpc_timeout);
}
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "gettransactions");
THROW_WALLET_EXCEPTION_IF(res.txs.size() != 1, error::wallet_internal_error,
"daemon returned wrong response for gettransactions, wrong txs count = " +
std::to_string(res.txs.size()) + ", expected 1");
cryptonote::transaction tx;
crypto::hash tx_hash;
THROW_WALLET_EXCEPTION_IF(!get_pruned_tx(res.txs[0], tx, tx_hash), error::wallet_internal_error, "failed to get tx from daemon");
// check signature size
size_t num_sigs = 0;
for(size_t i = 0; i < tx.vin.size(); ++i)
{
const txin_to_key* const in_key = boost::get<txin_to_key>(std::addressof(tx.vin[i]));
if (in_key != nullptr)
num_sigs += in_key->key_offsets.size();
}
std::vector<std::vector<crypto::signature>> signatures = { std::vector<crypto::signature>(1) };
const size_t sig_len = tools::base58::encode(std::string((const char *)&signatures[0][0], sizeof(crypto::signature))).size();
if( sig_str.size() != header_len + num_sigs * sig_len ) {
return false;
}
// decode base58
signatures.clear();
size_t offset = header_len;
for(size_t i = 0; i < tx.vin.size(); ++i)
{
const txin_to_key* const in_key = boost::get<txin_to_key>(std::addressof(tx.vin[i]));
if (in_key == nullptr)
continue;
signatures.resize(signatures.size() + 1);
signatures.back().resize(in_key->key_offsets.size());
for (size_t j = 0; j < in_key->key_offsets.size(); ++j)
{
std::string sig_decoded;
THROW_WALLET_EXCEPTION_IF(!tools::base58::decode(sig_str.substr(offset, sig_len), sig_decoded), error::wallet_internal_error, "Signature decoding error");
THROW_WALLET_EXCEPTION_IF(sizeof(crypto::signature) != sig_decoded.size(), error::wallet_internal_error, "Signature decoding error");
memcpy(&signatures.back()[j], sig_decoded.data(), sizeof(crypto::signature));
offset += sig_len;
}
}
// get signature prefix hash
std::string sig_prefix_data((const char*)&txid, sizeof(crypto::hash));
sig_prefix_data += message;
crypto::hash sig_prefix_hash;
crypto::cn_fast_hash(sig_prefix_data.data(), sig_prefix_data.size(), sig_prefix_hash);
std::vector<std::vector<crypto::signature>>::const_iterator sig_iter = signatures.cbegin();
for(size_t i = 0; i < tx.vin.size(); ++i)
{
const txin_to_key* const in_key = boost::get<txin_to_key>(std::addressof(tx.vin[i]));
if (in_key == nullptr)
continue;
// get output pubkeys in the ring
COMMAND_RPC_GET_OUTPUTS_BIN::request req{};
const std::vector<uint64_t> absolute_offsets = cryptonote::relative_output_offsets_to_absolute(in_key->key_offsets);
req.outputs.resize(absolute_offsets.size());
for (size_t j = 0; j < absolute_offsets.size(); ++j)
{
req.outputs[j].amount = in_key->amount;
req.outputs[j].index = absolute_offsets[j];
}
COMMAND_RPC_GET_OUTPUTS_BIN::response res{};
bool r;
{
const boost::lock_guard<boost::recursive_mutex> lock{m_daemon_rpc_mutex};
r = invoke_http_bin("/get_outs.bin", req, res, rpc_timeout);
}
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "get_outs.bin");
THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_outs.bin");
THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::wallet_internal_error, "get_outs.bin");
THROW_WALLET_EXCEPTION_IF(res.outs.size() != req.outputs.size(), error::wallet_internal_error,
"daemon returned wrong response for get_outs.bin, wrong amounts count = " +
std::to_string(res.outs.size()) + ", expected " + std::to_string(req.outputs.size()));
// copy pointers
std::vector<const crypto::public_key *> p_output_keys;
for (const COMMAND_RPC_GET_OUTPUTS_BIN::outkey &out : res.outs)
p_output_keys.push_back(&out.key);
// check this ring
if (!crypto::check_ring_signature(sig_prefix_hash, in_key->k_image, p_output_keys, sig_iter->data()))
return false;
++sig_iter;
}
THROW_WALLET_EXCEPTION_IF(sig_iter != signatures.cend(), error::wallet_internal_error, "Signature iterator didn't reach the end");
return true;
}
//----------------------------------------------------------------------------------------------------
void wallet2::check_tx_key(const crypto::hash &txid, const crypto::secret_key &tx_key, const std::vector<crypto::secret_key> &additional_tx_keys, const cryptonote::account_public_address &address, uint64_t &received, bool &in_pool, uint64_t &confirmations)
{
crypto::key_derivation derivation;
THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(address.m_view_public_key, tx_key, derivation), error::wallet_internal_error,
"Failed to generate key derivation from supplied parameters");
std::vector<crypto::key_derivation> additional_derivations;
additional_derivations.resize(additional_tx_keys.size());
for (size_t i = 0; i < additional_tx_keys.size(); ++i)
THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(address.m_view_public_key, additional_tx_keys[i], additional_derivations[i]), error::wallet_internal_error,
"Failed to generate key derivation from supplied parameters");
check_tx_key_helper(txid, derivation, additional_derivations, address, received, in_pool, confirmations);
}
void wallet2::check_tx_key_helper(const cryptonote::transaction &tx, const crypto::key_derivation &derivation, const std::vector<crypto::key_derivation> &additional_derivations, const cryptonote::account_public_address &address, uint64_t &received) const
{
received = 0;
for (size_t n = 0; n < tx.vout.size(); ++n)
{
const cryptonote::txout_to_key* const out_key = boost::get<cryptonote::txout_to_key>(std::addressof(tx.vout[n].target));
if (!out_key)
continue;
crypto::public_key derived_out_key;
bool r = crypto::derive_public_key(derivation, n, address.m_spend_public_key, derived_out_key);
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to derive public key");
bool found = out_key->key == derived_out_key;
crypto::key_derivation found_derivation = derivation;
if (!found && !additional_derivations.empty())
{
r = crypto::derive_public_key(additional_derivations[n], n, address.m_spend_public_key, derived_out_key);
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to derive public key");
found = out_key->key == derived_out_key;
found_derivation = additional_derivations[n];
}
if (found)
{
uint64_t amount;
if (tx.version == txversion::v1 || tx.rct_signatures.type == rct::RCTTypeNull)
{
amount = tx.vout[n].amount;
}
else
{
crypto::secret_key scalar1;
crypto::derivation_to_scalar(found_derivation, n, scalar1);
rct::ecdhTuple ecdh_info = tx.rct_signatures.ecdhInfo[n];
rct::ecdhDecode(ecdh_info, rct::sk2rct(scalar1), tx.rct_signatures.type == rct::RCTTypeBulletproof2);
const rct::key C = tx.rct_signatures.outPk[n].mask;
rct::key Ctmp;
THROW_WALLET_EXCEPTION_IF(sc_check(ecdh_info.mask.bytes) != 0, error::wallet_internal_error, "Bad ECDH input mask");
THROW_WALLET_EXCEPTION_IF(sc_check(ecdh_info.amount.bytes) != 0, error::wallet_internal_error, "Bad ECDH input amount");
rct::addKeys2(Ctmp, ecdh_info.mask, ecdh_info.amount, rct::H);
if (rct::equalKeys(C, Ctmp))
amount = rct::h2d(ecdh_info.amount);
else
amount = 0;
}
received += amount;
}
}
}
void wallet2::check_tx_key_helper(const crypto::hash &txid, const crypto::key_derivation &derivation, const std::vector<crypto::key_derivation> &additional_derivations, const cryptonote::account_public_address &address, uint64_t &received, bool &in_pool, uint64_t &confirmations)
{
COMMAND_RPC_GET_TRANSACTIONS::request req;
COMMAND_RPC_GET_TRANSACTIONS::response res;
req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
req.decode_as_json = false;
req.prune = true;
m_daemon_rpc_mutex.lock();
bool ok = invoke_http_json("/gettransactions", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!ok || (res.txs.size() != 1 && res.txs_as_hex.size() != 1),
error::wallet_internal_error, "Failed to get transaction from daemon");
cryptonote::transaction tx;
crypto::hash tx_hash;
if (res.txs.size() == 1)
{
ok = get_pruned_tx(res.txs.front(), tx, tx_hash);
THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
}
else
{
cryptonote::blobdata tx_data;
ok = string_tools::parse_hexstr_to_binbuff(res.txs_as_hex.front(), tx_data);
THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
THROW_WALLET_EXCEPTION_IF(!cryptonote::parse_and_validate_tx_from_blob(tx_data, tx),
error::wallet_internal_error, "Failed to validate transaction from daemon");
tx_hash = cryptonote::get_transaction_hash(tx);
}
THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error,
"Failed to get the right transaction from daemon");
THROW_WALLET_EXCEPTION_IF(!additional_derivations.empty() && additional_derivations.size() != tx.vout.size(), error::wallet_internal_error,
"The size of additional derivations is wrong");
check_tx_key_helper(tx, derivation, additional_derivations, address, received);
in_pool = res.txs.front().in_pool;
confirmations = 0;
if (!in_pool)
{
std::string err;
uint64_t bc_height = get_daemon_blockchain_height(err);
if (err.empty())
confirmations = bc_height - res.txs.front().block_height;
}
}
std::string wallet2::get_tx_proof(const crypto::hash &txid, const cryptonote::account_public_address &address, bool is_subaddress, const std::string &message)
{
// fetch tx pubkey from the daemon
COMMAND_RPC_GET_TRANSACTIONS::request req;
COMMAND_RPC_GET_TRANSACTIONS::response res;
req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
req.decode_as_json = false;
req.prune = true;
m_daemon_rpc_mutex.lock();
bool ok = invoke_http_json("/gettransactions", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!ok || (res.txs.size() != 1 && res.txs_as_hex.size() != 1),
error::wallet_internal_error, "Failed to get transaction from daemon");
cryptonote::transaction tx;
crypto::hash tx_hash;
if (res.txs.size() == 1)
{
ok = get_pruned_tx(res.txs.front(), tx, tx_hash);
THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
}
else
{
cryptonote::blobdata tx_data;
ok = string_tools::parse_hexstr_to_binbuff(res.txs_as_hex.front(), tx_data);
THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
THROW_WALLET_EXCEPTION_IF(!cryptonote::parse_and_validate_tx_from_blob(tx_data, tx),
error::wallet_internal_error, "Failed to validate transaction from daemon");
tx_hash = cryptonote::get_transaction_hash(tx);
}
THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error, "Failed to get the right transaction from daemon");
// determine if the address is found in the subaddress hash table (i.e. whether the proof is outbound or inbound)
crypto::secret_key tx_key = crypto::null_skey;
std::vector<crypto::secret_key> additional_tx_keys;
const bool is_out = m_subaddresses.count(address.m_spend_public_key) == 0;
if (is_out)
{
THROW_WALLET_EXCEPTION_IF(!get_tx_key(txid, tx_key, additional_tx_keys), error::wallet_internal_error, "Tx secret key wasn't found in the wallet file.");
}
return get_tx_proof(tx, tx_key, additional_tx_keys, address, is_subaddress, message);
}
std::string wallet2::get_tx_proof(const cryptonote::transaction &tx, const crypto::secret_key &tx_key, const std::vector<crypto::secret_key> &additional_tx_keys, const cryptonote::account_public_address &address, bool is_subaddress, const std::string &message) const
{
hw::device &hwdev = m_account.get_device();
rct::key aP;
// determine if the address is found in the subaddress hash table (i.e. whether the proof is outbound or inbound)
const bool is_out = m_subaddresses.count(address.m_spend_public_key) == 0;
const crypto::hash txid = cryptonote::get_transaction_hash(tx);
std::string prefix_data((const char*)&txid, sizeof(crypto::hash));
prefix_data += message;
crypto::hash prefix_hash;
crypto::cn_fast_hash(prefix_data.data(), prefix_data.size(), prefix_hash);
std::vector<crypto::public_key> shared_secret;
std::vector<crypto::signature> sig;
std::string sig_str;
if (is_out)
{
const size_t num_sigs = 1 + additional_tx_keys.size();
shared_secret.resize(num_sigs);
sig.resize(num_sigs);
hwdev.scalarmultKey(aP, rct::pk2rct(address.m_view_public_key), rct::sk2rct(tx_key));
shared_secret[0] = rct::rct2pk(aP);
crypto::public_key tx_pub_key;
if (is_subaddress)
{
hwdev.scalarmultKey(aP, rct::pk2rct(address.m_spend_public_key), rct::sk2rct(tx_key));
tx_pub_key = rct2pk(aP);
hwdev.generate_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, address.m_spend_public_key, shared_secret[0], tx_key, sig[0]);
}
else
{
hwdev.secret_key_to_public_key(tx_key, tx_pub_key);
hwdev.generate_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, boost::none, shared_secret[0], tx_key, sig[0]);
}
for (size_t i = 1; i < num_sigs; ++i)
{
hwdev.scalarmultKey(aP, rct::pk2rct(address.m_view_public_key), rct::sk2rct(additional_tx_keys[i - 1]));
shared_secret[i] = rct::rct2pk(aP);
if (is_subaddress)
{
hwdev.scalarmultKey(aP, rct::pk2rct(address.m_spend_public_key), rct::sk2rct(additional_tx_keys[i - 1]));
tx_pub_key = rct2pk(aP);
hwdev.generate_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, address.m_spend_public_key, shared_secret[i], additional_tx_keys[i - 1], sig[i]);
}
else
{
hwdev.secret_key_to_public_key(additional_tx_keys[i - 1], tx_pub_key);
hwdev.generate_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, boost::none, shared_secret[i], additional_tx_keys[i - 1], sig[i]);
}
}
sig_str = std::string("OutProofV1");
}
else
{
crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(tx);
THROW_WALLET_EXCEPTION_IF(tx_pub_key == null_pkey, error::wallet_internal_error, "Tx pubkey was not found");
std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(tx);
const size_t num_sigs = 1 + additional_tx_pub_keys.size();
shared_secret.resize(num_sigs);
sig.resize(num_sigs);
const crypto::secret_key& a = m_account.get_keys().m_view_secret_key;
hwdev.scalarmultKey(aP, rct::pk2rct(tx_pub_key), rct::sk2rct(a));
shared_secret[0] = rct2pk(aP);
if (is_subaddress)
{
hwdev.generate_tx_proof(prefix_hash, address.m_view_public_key, tx_pub_key, address.m_spend_public_key, shared_secret[0], a, sig[0]);
}
else
{
hwdev.generate_tx_proof(prefix_hash, address.m_view_public_key, tx_pub_key, boost::none, shared_secret[0], a, sig[0]);
}
for (size_t i = 1; i < num_sigs; ++i)
{
hwdev.scalarmultKey(aP,rct::pk2rct(additional_tx_pub_keys[i - 1]), rct::sk2rct(a));
shared_secret[i] = rct2pk(aP);
if (is_subaddress)
{
hwdev.generate_tx_proof(prefix_hash, address.m_view_public_key, additional_tx_pub_keys[i - 1], address.m_spend_public_key, shared_secret[i], a, sig[i]);
}
else
{
hwdev.generate_tx_proof(prefix_hash, address.m_view_public_key, additional_tx_pub_keys[i - 1], boost::none, shared_secret[i], a, sig[i]);
}
}
sig_str = std::string("InProofV1");
}
const size_t num_sigs = shared_secret.size();
// check if this address actually received any funds
crypto::key_derivation derivation;
THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(shared_secret[0], rct::rct2sk(rct::I), derivation), error::wallet_internal_error, "Failed to generate key derivation");
std::vector<crypto::key_derivation> additional_derivations(num_sigs - 1);
for (size_t i = 1; i < num_sigs; ++i)
THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(shared_secret[i], rct::rct2sk(rct::I), additional_derivations[i - 1]), error::wallet_internal_error, "Failed to generate key derivation");
uint64_t received;
check_tx_key_helper(tx, derivation, additional_derivations, address, received);
THROW_WALLET_EXCEPTION_IF(!received, error::wallet_internal_error, tr("No funds received in this tx."));
// concatenate all signature strings
for (size_t i = 0; i < num_sigs; ++i)
sig_str +=
tools::base58::encode(std::string((const char *)&shared_secret[i], sizeof(crypto::public_key))) +
tools::base58::encode(std::string((const char *)&sig[i], sizeof(crypto::signature)));
return sig_str;
}
bool wallet2::check_tx_proof(const crypto::hash &txid, const cryptonote::account_public_address &address, bool is_subaddress, const std::string &message, const std::string &sig_str, uint64_t &received, bool &in_pool, uint64_t &confirmations)
{
// fetch tx pubkey from the daemon
COMMAND_RPC_GET_TRANSACTIONS::request req;
COMMAND_RPC_GET_TRANSACTIONS::response res;
req.txs_hashes.push_back(epee::string_tools::pod_to_hex(txid));
req.decode_as_json = false;
req.prune = true;
m_daemon_rpc_mutex.lock();
bool ok = invoke_http_json("/gettransactions", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!ok || (res.txs.size() != 1 && res.txs_as_hex.size() != 1),
error::wallet_internal_error, "Failed to get transaction from daemon");
cryptonote::transaction tx;
crypto::hash tx_hash;
if (res.txs.size() == 1)
{
ok = get_pruned_tx(res.txs.front(), tx, tx_hash);
THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
}
else
{
cryptonote::blobdata tx_data;
ok = string_tools::parse_hexstr_to_binbuff(res.txs_as_hex.front(), tx_data);
THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
THROW_WALLET_EXCEPTION_IF(!cryptonote::parse_and_validate_tx_from_blob(tx_data, tx),
error::wallet_internal_error, "Failed to validate transaction from daemon");
tx_hash = cryptonote::get_transaction_hash(tx);
}
THROW_WALLET_EXCEPTION_IF(tx_hash != txid, error::wallet_internal_error, "Failed to get the right transaction from daemon");
if (!check_tx_proof(tx, address, is_subaddress, message, sig_str, received))
return false;
in_pool = res.txs.front().in_pool;
confirmations = 0;
if (!in_pool)
{
std::string err;
uint64_t bc_height = get_daemon_blockchain_height(err);
if (err.empty())
confirmations = bc_height - res.txs.front().block_height;
}
return true;
}
bool wallet2::check_tx_proof(const cryptonote::transaction &tx, const cryptonote::account_public_address &address, bool is_subaddress, const std::string &message, const std::string &sig_str, uint64_t &received) const
{
const bool is_out = sig_str.substr(0, 3) == "Out";
const std::string header = is_out ? "OutProofV1" : "InProofV1";
const size_t header_len = header.size();
THROW_WALLET_EXCEPTION_IF(sig_str.size() < header_len || sig_str.substr(0, header_len) != header, error::wallet_internal_error,
"Signature header check error");
// decode base58
std::vector<crypto::public_key> shared_secret(1);
std::vector<crypto::signature> sig(1);
const size_t pk_len = tools::base58::encode(std::string((const char *)&shared_secret[0], sizeof(crypto::public_key))).size();
const size_t sig_len = tools::base58::encode(std::string((const char *)&sig[0], sizeof(crypto::signature))).size();
const size_t num_sigs = (sig_str.size() - header_len) / (pk_len + sig_len);
THROW_WALLET_EXCEPTION_IF(sig_str.size() != header_len + num_sigs * (pk_len + sig_len), error::wallet_internal_error,
"Wrong signature size");
shared_secret.resize(num_sigs);
sig.resize(num_sigs);
for (size_t i = 0; i < num_sigs; ++i)
{
std::string pk_decoded;
std::string sig_decoded;
const size_t offset = header_len + i * (pk_len + sig_len);
THROW_WALLET_EXCEPTION_IF(!tools::base58::decode(sig_str.substr(offset, pk_len), pk_decoded), error::wallet_internal_error,
"Signature decoding error");
THROW_WALLET_EXCEPTION_IF(!tools::base58::decode(sig_str.substr(offset + pk_len, sig_len), sig_decoded), error::wallet_internal_error,
"Signature decoding error");
THROW_WALLET_EXCEPTION_IF(sizeof(crypto::public_key) != pk_decoded.size() || sizeof(crypto::signature) != sig_decoded.size(), error::wallet_internal_error,
"Signature decoding error");
memcpy(&shared_secret[i], pk_decoded.data(), sizeof(crypto::public_key));
memcpy(&sig[i], sig_decoded.data(), sizeof(crypto::signature));
}
crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(tx);
THROW_WALLET_EXCEPTION_IF(tx_pub_key == null_pkey, error::wallet_internal_error, "Tx pubkey was not found");
std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(tx);
THROW_WALLET_EXCEPTION_IF(additional_tx_pub_keys.size() + 1 != num_sigs, error::wallet_internal_error, "Signature size mismatch with additional tx pubkeys");
const crypto::hash txid = cryptonote::get_transaction_hash(tx);
std::string prefix_data((const char*)&txid, sizeof(crypto::hash));
prefix_data += message;
crypto::hash prefix_hash;
crypto::cn_fast_hash(prefix_data.data(), prefix_data.size(), prefix_hash);
// check signature
std::vector<int> good_signature(num_sigs, 0);
if (is_out)
{
good_signature[0] = is_subaddress ?
crypto::check_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, address.m_spend_public_key, shared_secret[0], sig[0]) :
crypto::check_tx_proof(prefix_hash, tx_pub_key, address.m_view_public_key, boost::none, shared_secret[0], sig[0]);
for (size_t i = 0; i < additional_tx_pub_keys.size(); ++i)
{
good_signature[i + 1] = is_subaddress ?
crypto::check_tx_proof(prefix_hash, additional_tx_pub_keys[i], address.m_view_public_key, address.m_spend_public_key, shared_secret[i + 1], sig[i + 1]) :
crypto::check_tx_proof(prefix_hash, additional_tx_pub_keys[i], address.m_view_public_key, boost::none, shared_secret[i + 1], sig[i + 1]);
}
}
else
{
good_signature[0] = is_subaddress ?
crypto::check_tx_proof(prefix_hash, address.m_view_public_key, tx_pub_key, address.m_spend_public_key, shared_secret[0], sig[0]) :
crypto::check_tx_proof(prefix_hash, address.m_view_public_key, tx_pub_key, boost::none, shared_secret[0], sig[0]);
for (size_t i = 0; i < additional_tx_pub_keys.size(); ++i)
{
good_signature[i + 1] = is_subaddress ?
crypto::check_tx_proof(prefix_hash, address.m_view_public_key, additional_tx_pub_keys[i], address.m_spend_public_key, shared_secret[i + 1], sig[i + 1]) :
crypto::check_tx_proof(prefix_hash, address.m_view_public_key, additional_tx_pub_keys[i], boost::none, shared_secret[i + 1], sig[i + 1]);
}
}
if (std::any_of(good_signature.begin(), good_signature.end(), [](int i) { return i > 0; }))
{
// obtain key derivation by multiplying scalar 1 to the shared secret
crypto::key_derivation derivation;
if (good_signature[0])
THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(shared_secret[0], rct::rct2sk(rct::I), derivation), error::wallet_internal_error, "Failed to generate key derivation");
std::vector<crypto::key_derivation> additional_derivations(num_sigs - 1);
for (size_t i = 1; i < num_sigs; ++i)
if (good_signature[i])
THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(shared_secret[i], rct::rct2sk(rct::I), additional_derivations[i - 1]), error::wallet_internal_error, "Failed to generate key derivation");
check_tx_key_helper(tx, derivation, additional_derivations, address, received);
return true;
}
return false;
}
std::string wallet2::get_reserve_proof(const boost::optional<std::pair<uint32_t, uint64_t>> &account_minreserve, const std::string &message)
{
THROW_WALLET_EXCEPTION_IF(m_watch_only || m_multisig, error::wallet_internal_error, "Reserve proof can only be generated by a full wallet");
THROW_WALLET_EXCEPTION_IF(balance_all() == 0, error::wallet_internal_error, "Zero balance");
THROW_WALLET_EXCEPTION_IF(account_minreserve && balance(account_minreserve->first) < account_minreserve->second, error::wallet_internal_error,
"Not enough balance in this account for the requested minimum reserve amount");
// determine which outputs to include in the proof
std::vector<size_t> selected_transfers;
for (size_t i = 0; i < m_transfers.size(); ++i)
{
const transfer_details &td = m_transfers[i];
if (!td.m_spent && !td.m_frozen && (!account_minreserve || account_minreserve->first == td.m_subaddr_index.major))
selected_transfers.push_back(i);
}
if (account_minreserve)
{
THROW_WALLET_EXCEPTION_IF(account_minreserve->second == 0, error::wallet_internal_error, "Proved amount must be greater than 0");
// minimize the number of outputs included in the proof, by only picking the N largest outputs that can cover the requested min reserve amount
std::sort(selected_transfers.begin(), selected_transfers.end(), [&](const size_t a, const size_t b)
{ return m_transfers[a].amount() > m_transfers[b].amount(); });
while (selected_transfers.size() >= 2 && m_transfers[selected_transfers[1]].amount() >= account_minreserve->second)
selected_transfers.erase(selected_transfers.begin());
size_t sz = 0;
uint64_t total = 0;
while (total < account_minreserve->second)
{
total += m_transfers[selected_transfers[sz]].amount();
++sz;
}
selected_transfers.resize(sz);
}
// compute signature prefix hash
std::string prefix_data = message;
prefix_data.append((const char*)&m_account.get_keys().m_account_address, sizeof(cryptonote::account_public_address));
for (size_t i = 0; i < selected_transfers.size(); ++i)
{
prefix_data.append((const char*)&m_transfers[selected_transfers[i]].m_key_image, sizeof(crypto::key_image));
}
crypto::hash prefix_hash;
crypto::cn_fast_hash(prefix_data.data(), prefix_data.size(), prefix_hash);
// generate proof entries
std::vector<reserve_proof_entry> proofs(selected_transfers.size());
std::unordered_set<cryptonote::subaddress_index> subaddr_indices = { {0,0} };
for (size_t i = 0; i < selected_transfers.size(); ++i)
{
const transfer_details &td = m_transfers[selected_transfers[i]];
reserve_proof_entry& proof = proofs[i];
proof.txid = td.m_txid;
proof.index_in_tx = td.m_internal_output_index;
proof.key_image = td.m_key_image;
subaddr_indices.insert(td.m_subaddr_index);
// get tx pub key
const crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(td.m_tx, td.m_pk_index);
THROW_WALLET_EXCEPTION_IF(tx_pub_key == crypto::null_pkey, error::wallet_internal_error, "The tx public key isn't found");
const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(td.m_tx);
// determine which tx pub key was used for deriving the output key
const crypto::public_key *tx_pub_key_used = &tx_pub_key;
for (int i = 0; i < 2; ++i)
{
proof.shared_secret = rct::rct2pk(rct::scalarmultKey(rct::pk2rct(*tx_pub_key_used), rct::sk2rct(m_account.get_keys().m_view_secret_key)));
crypto::key_derivation derivation;
THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(proof.shared_secret, rct::rct2sk(rct::I), derivation),
error::wallet_internal_error, "Failed to generate key derivation");
crypto::public_key subaddress_spendkey;
THROW_WALLET_EXCEPTION_IF(!derive_subaddress_public_key(td.get_public_key(), derivation, proof.index_in_tx, subaddress_spendkey),
error::wallet_internal_error, "Failed to derive subaddress public key");
if (m_subaddresses.count(subaddress_spendkey) == 1)
break;
THROW_WALLET_EXCEPTION_IF(additional_tx_pub_keys.empty(), error::wallet_internal_error,
"Normal tx pub key doesn't derive the expected output, while the additional tx pub keys are empty");
THROW_WALLET_EXCEPTION_IF(i == 1, error::wallet_internal_error,
"Neither normal tx pub key nor additional tx pub key derive the expected output key");
tx_pub_key_used = &additional_tx_pub_keys[proof.index_in_tx];
}
// generate signature for shared secret
crypto::generate_tx_proof(prefix_hash, m_account.get_keys().m_account_address.m_view_public_key, *tx_pub_key_used, boost::none, proof.shared_secret, m_account.get_keys().m_view_secret_key, proof.shared_secret_sig);
// derive ephemeral secret key
crypto::key_image ki;
cryptonote::keypair ephemeral;
const bool r = cryptonote::generate_key_image_helper(m_account.get_keys(), m_subaddresses, td.get_public_key(), tx_pub_key, additional_tx_pub_keys, td.m_internal_output_index, ephemeral, ki, m_account.get_device());
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
THROW_WALLET_EXCEPTION_IF(ephemeral.pub != td.get_public_key(), error::wallet_internal_error, "Derived public key doesn't agree with the stored one");
// generate signature for key image
const std::vector<const crypto::public_key*> pubs = { &ephemeral.pub };
crypto::generate_ring_signature(prefix_hash, td.m_key_image, &pubs[0], 1, ephemeral.sec, 0, &proof.key_image_sig);
}
// collect all subaddress spend keys that received those outputs and generate their signatures
std::unordered_map<crypto::public_key, crypto::signature> subaddr_spendkeys;
for (const cryptonote::subaddress_index &index : subaddr_indices)
{
crypto::secret_key subaddr_spend_skey = m_account.get_keys().m_spend_secret_key;
if (!index.is_zero())
{
crypto::secret_key m = m_account.get_device().get_subaddress_secret_key(m_account.get_keys().m_view_secret_key, index);
crypto::secret_key tmp = subaddr_spend_skey;
sc_add((unsigned char*)&subaddr_spend_skey, (unsigned char*)&m, (unsigned char*)&tmp);
}
crypto::public_key subaddr_spend_pkey;
secret_key_to_public_key(subaddr_spend_skey, subaddr_spend_pkey);
crypto::generate_signature(prefix_hash, subaddr_spend_pkey, subaddr_spend_skey, subaddr_spendkeys[subaddr_spend_pkey]);
}
// serialize & encode
std::ostringstream oss;
boost::archive::portable_binary_oarchive ar(oss);
ar << proofs << subaddr_spendkeys;
return "ReserveProofV1" + tools::base58::encode(oss.str());
}
bool wallet2::check_reserve_proof(const cryptonote::account_public_address &address, const std::string &message, const std::string &sig_str, uint64_t &total, uint64_t &spent)
{
uint32_t rpc_version;
THROW_WALLET_EXCEPTION_IF(!check_connection(&rpc_version), error::wallet_internal_error, "Failed to connect to daemon: " + get_daemon_address());
THROW_WALLET_EXCEPTION_IF(rpc_version < MAKE_CORE_RPC_VERSION(1, 0), error::wallet_internal_error, "Daemon RPC version is too old");
static constexpr char header[] = "ReserveProofV1";
THROW_WALLET_EXCEPTION_IF(!boost::string_ref{sig_str}.starts_with(header), error::wallet_internal_error,
"Signature header check error");
std::string sig_decoded;
THROW_WALLET_EXCEPTION_IF(!tools::base58::decode(sig_str.substr(std::strlen(header)), sig_decoded), error::wallet_internal_error,
"Signature decoding error");
std::istringstream iss(sig_decoded);
boost::archive::portable_binary_iarchive ar(iss);
std::vector<reserve_proof_entry> proofs;
std::unordered_map<crypto::public_key, crypto::signature> subaddr_spendkeys;
ar >> proofs >> subaddr_spendkeys;
THROW_WALLET_EXCEPTION_IF(subaddr_spendkeys.count(address.m_spend_public_key) == 0, error::wallet_internal_error,
"The given address isn't found in the proof");
// compute signature prefix hash
std::string prefix_data;
prefix_data.reserve(message.size() + sizeof(cryptonote::account_public_address) + proofs.size() * sizeof(crypto::key_image));
prefix_data.append(message);
prefix_data.append((const char*)&address, sizeof(cryptonote::account_public_address));
for (size_t i = 0; i < proofs.size(); ++i)
{
prefix_data.append((const char*)&proofs[i].key_image, sizeof(crypto::key_image));
}
crypto::hash prefix_hash;
crypto::cn_fast_hash(prefix_data.data(), prefix_data.size(), prefix_hash);
// fetch txes from daemon
COMMAND_RPC_GET_TRANSACTIONS::request gettx_req;
COMMAND_RPC_GET_TRANSACTIONS::response gettx_res;
for (size_t i = 0; i < proofs.size(); ++i)
gettx_req.txs_hashes.push_back(epee::string_tools::pod_to_hex(proofs[i].txid));
gettx_req.decode_as_json = false;
gettx_req.prune = true;
m_daemon_rpc_mutex.lock();
bool ok = invoke_http_json("/gettransactions", gettx_req, gettx_res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!ok || gettx_res.txs.size() != proofs.size(),
error::wallet_internal_error, "Failed to get transaction from daemon");
// check spent status
COMMAND_RPC_IS_KEY_IMAGE_SPENT::request kispent_req;
COMMAND_RPC_IS_KEY_IMAGE_SPENT::response kispent_res;
for (size_t i = 0; i < proofs.size(); ++i)
kispent_req.key_images.push_back(epee::string_tools::pod_to_hex(proofs[i].key_image));
m_daemon_rpc_mutex.lock();
ok = invoke_http_json("/is_key_image_spent", kispent_req, kispent_res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!ok || kispent_res.spent_status.size() != proofs.size(),
error::wallet_internal_error, "Failed to get key image spent status from daemon");
total = spent = 0;
for (size_t i = 0; i < proofs.size(); ++i)
{
const reserve_proof_entry& proof = proofs[i];
THROW_WALLET_EXCEPTION_IF(gettx_res.txs[i].in_pool, error::wallet_internal_error, "Tx is unconfirmed");
cryptonote::transaction tx;
crypto::hash tx_hash;
ok = get_pruned_tx(gettx_res.txs[i], tx, tx_hash);
THROW_WALLET_EXCEPTION_IF(!ok, error::wallet_internal_error, "Failed to parse transaction from daemon");
THROW_WALLET_EXCEPTION_IF(tx_hash != proof.txid, error::wallet_internal_error, "Failed to get the right transaction from daemon");
THROW_WALLET_EXCEPTION_IF(proof.index_in_tx >= tx.vout.size(), error::wallet_internal_error, "index_in_tx is out of bound");
const cryptonote::txout_to_key* const out_key = boost::get<cryptonote::txout_to_key>(std::addressof(tx.vout[proof.index_in_tx].target));
THROW_WALLET_EXCEPTION_IF(!out_key, error::wallet_internal_error, "Output key wasn't found")
// TODO(worktips): We should make a catch-all function that gets all the public
// keys out into an array and iterate through all insteaad of multiple code
// paths for additional keys and the main public key storage which can then
// have multiple keys ..
// But for now, the minimal fix to avoid re-architecting everything prematurely.
// check singature for shared secret
const bool is_miner = tx.vin.size() == 1 && tx.vin[0].type() == typeid(cryptonote::txin_gen);
if (is_miner)
{
// NOTE(worktips): The service node reward is added as a duplicate TX public
// key instead of into the additional public key, so we need to check upto
// 2 public keys when we're checking miner transactions.
// TODO(worktips): This might still be broken for governance rewards since it uses a deterministic key iirc.
crypto::public_key main_keys[2] = {
get_tx_pub_key_from_extra(tx, 0),
get_tx_pub_key_from_extra(tx, 1),
};
for (crypto::public_key const &tx_pub_key : main_keys)
{
ok = crypto::check_tx_proof(prefix_hash, address.m_view_public_key, tx_pub_key, boost::none, proof.shared_secret, proof.shared_secret_sig);
if (ok) break;
}
}
else
{
const crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(tx);
THROW_WALLET_EXCEPTION_IF(tx_pub_key == crypto::null_pkey, error::wallet_internal_error, "The tx public key isn't found");
ok = crypto::check_tx_proof(prefix_hash, address.m_view_public_key, tx_pub_key, boost::none, proof.shared_secret, proof.shared_secret_sig);
}
if (!ok)
{
const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(tx);
if (additional_tx_pub_keys.size() == tx.vout.size())
ok = crypto::check_tx_proof(prefix_hash, address.m_view_public_key, additional_tx_pub_keys[proof.index_in_tx], boost::none, proof.shared_secret, proof.shared_secret_sig);
}
if (!ok)
return false;
// check signature for key image
const std::vector<const crypto::public_key*> pubs = { &out_key->key };
ok = crypto::check_ring_signature(prefix_hash, proof.key_image, &pubs[0], 1, &proof.key_image_sig);
if (!ok)
return false;
// check if the address really received the fund
crypto::key_derivation derivation;
THROW_WALLET_EXCEPTION_IF(!crypto::generate_key_derivation(proof.shared_secret, rct::rct2sk(rct::I), derivation), error::wallet_internal_error, "Failed to generate key derivation");
crypto::public_key subaddr_spendkey;
crypto::derive_subaddress_public_key(out_key->key, derivation, proof.index_in_tx, subaddr_spendkey);
THROW_WALLET_EXCEPTION_IF(subaddr_spendkeys.count(subaddr_spendkey) == 0, error::wallet_internal_error,
"The address doesn't seem to have received the fund");
// check amount
uint64_t amount = tx.vout[proof.index_in_tx].amount;
if (amount == 0)
{
// decode rct
crypto::secret_key shared_secret;
crypto::derivation_to_scalar(derivation, proof.index_in_tx, shared_secret);
rct::ecdhTuple ecdh_info = tx.rct_signatures.ecdhInfo[proof.index_in_tx];
rct::ecdhDecode(ecdh_info, rct::sk2rct(shared_secret), tx.rct_signatures.type == rct::RCTTypeBulletproof2);
amount = rct::h2d(ecdh_info.amount);
}
total += amount;
if (kispent_res.spent_status[i])
spent += amount;
}
// check signatures for all subaddress spend keys
for (const auto &i : subaddr_spendkeys)
{
if (!crypto::check_signature(prefix_hash, i.first, i.second))
return false;
}
return true;
}
std::string wallet2::get_wallet_file() const
{
return m_wallet_file;
}
std::string wallet2::get_keys_file() const
{
return m_keys_file;
}
std::string wallet2::get_daemon_address() const
{
return m_daemon_address;
}
uint64_t wallet2::get_daemon_blockchain_height(string &err) const
{
uint64_t height;
boost::optional<std::string> result = m_node_rpc_proxy.get_height(height);
if (result)
{
if (m_trusted_daemon)
err = *result;
else
err = "daemon error";
return 0;
}
err = "";
return height;
}
uint64_t wallet2::get_daemon_blockchain_target_height(string &err)
{
err = "";
uint64_t target_height = 0;
const auto result = m_node_rpc_proxy.get_target_height(target_height);
if (result && *result != CORE_RPC_STATUS_OK)
{
if (m_trusted_daemon)
err = *result;
else
err = "daemon error";
return 0;
}
return target_height;
}
uint64_t wallet2::get_approximate_blockchain_height() const
{
const int seconds_per_block = DIFFICULTY_TARGET_V2;
const time_t epochTimeMiningStarted = (m_nettype == TESTNET || m_nettype == STAGENET ? 1551950093: 1525067730) + (60 * 60 * 24 * 7); // 2018-04-30 ~3:55PM + 1 week to be conservative.
const time_t currentTime = time(NULL);
uint64_t approx_blockchain_height = (currentTime < epochTimeMiningStarted) ? 0 : (currentTime - epochTimeMiningStarted)/seconds_per_block;
LOG_PRINT_L2("Calculated blockchain height: " << approx_blockchain_height);
return approx_blockchain_height;
}
void wallet2::set_tx_note(const crypto::hash &txid, const std::string ¬e)
{
m_tx_notes[txid] = note;
}
std::string wallet2::get_tx_note(const crypto::hash &txid) const
{
std::unordered_map<crypto::hash, std::string>::const_iterator i = m_tx_notes.find(txid);
if (i == m_tx_notes.end())
return std::string();
return i->second;
}
void wallet2::set_tx_device_aux(const crypto::hash &txid, const std::string &aux)
{
m_tx_device[txid] = aux;
}
std::string wallet2::get_tx_device_aux(const crypto::hash &txid) const
{
std::unordered_map<crypto::hash, std::string>::const_iterator i = m_tx_device.find(txid);
if (i == m_tx_device.end())
return std::string();
return i->second;
}
void wallet2::set_attribute(const std::string &key, const std::string &value)
{
m_attributes[key] = value;
}
std::string wallet2::get_attribute(const std::string &key) const
{
std::unordered_map<std::string, std::string>::const_iterator i = m_attributes.find(key);
if (i == m_attributes.end())
return std::string();
return i->second;
}
void wallet2::set_description(const std::string &description)
{
set_attribute(ATTRIBUTE_DESCRIPTION, description);
}
std::string wallet2::get_description() const
{
return get_attribute(ATTRIBUTE_DESCRIPTION);
}
const std::pair<std::map<std::string, std::string>, std::vector<std::string>>& wallet2::get_account_tags()
{
// ensure consistency
if (m_account_tags.second.size() != get_num_subaddress_accounts())
m_account_tags.second.resize(get_num_subaddress_accounts(), "");
for (const std::string& tag : m_account_tags.second)
{
if (!tag.empty() && m_account_tags.first.count(tag) == 0)
m_account_tags.first.insert({tag, ""});
}
for (auto i = m_account_tags.first.begin(); i != m_account_tags.first.end(); )
{
if (std::find(m_account_tags.second.begin(), m_account_tags.second.end(), i->first) == m_account_tags.second.end())
i = m_account_tags.first.erase(i);
else
++i;
}
return m_account_tags;
}
void wallet2::set_account_tag(const std::set<uint32_t> &account_indices, const std::string& tag)
{
for (uint32_t account_index : account_indices)
{
THROW_WALLET_EXCEPTION_IF(account_index >= get_num_subaddress_accounts(), error::wallet_internal_error, "Account index out of bound");
if (m_account_tags.second[account_index] == tag)
MDEBUG("This tag is already assigned to this account");
else
m_account_tags.second[account_index] = tag;
}
get_account_tags();
}
void wallet2::set_account_tag_description(const std::string& tag, const std::string& description)
{
THROW_WALLET_EXCEPTION_IF(tag.empty(), error::wallet_internal_error, "Tag must not be empty");
THROW_WALLET_EXCEPTION_IF(m_account_tags.first.count(tag) == 0, error::wallet_internal_error, "Tag is unregistered");
m_account_tags.first[tag] = description;
}
std::string wallet2::sign(const std::string &data) const
{
crypto::hash hash;
crypto::cn_fast_hash(data.data(), data.size(), hash);
const cryptonote::account_keys &keys = m_account.get_keys();
crypto::signature signature;
crypto::generate_signature(hash, keys.m_account_address.m_spend_public_key, keys.m_spend_secret_key, signature);
return std::string("SigV1") + tools::base58::encode(std::string((const char *)&signature, sizeof(signature)));
}
bool wallet2::verify(const std::string &data, const cryptonote::account_public_address &address, const std::string &signature) const
{
const size_t header_len = strlen("SigV1");
if (signature.size() < header_len || signature.substr(0, header_len) != "SigV1") {
LOG_PRINT_L0("Signature header check error");
return false;
}
crypto::hash hash;
crypto::cn_fast_hash(data.data(), data.size(), hash);
std::string decoded;
if (!tools::base58::decode(signature.substr(header_len), decoded)) {
LOG_PRINT_L0("Signature decoding error");
return false;
}
crypto::signature s;
if (sizeof(s) != decoded.size()) {
LOG_PRINT_L0("Signature decoding error");
return false;
}
memcpy(&s, decoded.data(), sizeof(s));
return crypto::check_signature(hash, address.m_spend_public_key, s);
}
std::string wallet2::sign_multisig_participant(const std::string& data) const
{
CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
crypto::hash hash;
crypto::cn_fast_hash(data.data(), data.size(), hash);
const cryptonote::account_keys &keys = m_account.get_keys();
crypto::signature signature;
crypto::generate_signature(hash, get_multisig_signer_public_key(), keys.m_spend_secret_key, signature);
return MULTISIG_SIGNATURE_MAGIC + tools::base58::encode(std::string((const char *)&signature, sizeof(signature)));
}
bool wallet2::verify_with_public_key(const std::string &data, const crypto::public_key &public_key, const std::string &signature) const
{
if (signature.size() < MULTISIG_SIGNATURE_MAGIC.size() || signature.substr(0, MULTISIG_SIGNATURE_MAGIC.size()) != MULTISIG_SIGNATURE_MAGIC) {
MERROR("Signature header check error");
return false;
}
crypto::hash hash;
crypto::cn_fast_hash(data.data(), data.size(), hash);
std::string decoded;
if (!tools::base58::decode(signature.substr(MULTISIG_SIGNATURE_MAGIC.size()), decoded)) {
MERROR("Signature decoding error");
return false;
}
crypto::signature s;
if (sizeof(s) != decoded.size()) {
MERROR("Signature decoding error");
return false;
}
memcpy(&s, decoded.data(), sizeof(s));
return crypto::check_signature(hash, public_key, s);
}
//----------------------------------------------------------------------------------------------------
static bool try_get_tx_pub_key_using_td(const tools::wallet2::transfer_details &td, crypto::public_key &pub_key)
{
std::vector<tx_extra_field> tx_extra_fields;
if(!parse_tx_extra(td.m_tx.extra, tx_extra_fields))
{
// Extra may only be partially parsed, it's OK if tx_extra_fields contains public key
}
if (td.m_pk_index >= tx_extra_fields.size())
return false;
tx_extra_pub_key pub_key_field;
if (find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, td.m_pk_index))
{
pub_key = pub_key_field.pub_key;
return true;
}
return false;
}
crypto::public_key wallet2::get_tx_pub_key_from_received_outs(const tools::wallet2::transfer_details &td) const
{
std::vector<tx_extra_field> tx_extra_fields;
if(!parse_tx_extra(td.m_tx.extra, tx_extra_fields))
{
// Extra may only be partially parsed, it's OK if tx_extra_fields contains public key
}
// Due to a previous bug, there might be more than one tx pubkey in extra, one being
// the result of a previously discarded signature.
// For speed, since scanning for outputs is a slow process, we check whether extra
// contains more than one pubkey. If not, the first one is returned. If yes, they're
// checked for whether they yield at least one output
tx_extra_pub_key pub_key_field;
THROW_WALLET_EXCEPTION_IF(!find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, 0), error::wallet_internal_error,
"Public key wasn't found in the transaction extra");
const crypto::public_key tx_pub_key = pub_key_field.pub_key;
bool two_found = find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, 1);
if (!two_found) {
// easy case, just one found
return tx_pub_key;
}
// more than one, loop and search
const cryptonote::account_keys& keys = m_account.get_keys();
size_t pk_index = 0;
hw::device &hwdev = m_account.get_device();
while (find_tx_extra_field_by_type(tx_extra_fields, pub_key_field, pk_index++)) {
const crypto::public_key tx_pub_key = pub_key_field.pub_key;
crypto::key_derivation derivation;
bool r = hwdev.generate_key_derivation(tx_pub_key, keys.m_view_secret_key, derivation);
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key derivation");
for (size_t i = 0; i < td.m_tx.vout.size(); ++i)
{
tx_scan_info_t tx_scan_info;
check_acc_out_precomp(td.m_tx.vout[i], derivation, {}, i, tx_scan_info);
if (!tx_scan_info.error && tx_scan_info.received)
return tx_pub_key;
}
}
// we found no key yielding an output, but it might be in the additional
// tx pub keys only, which we do not need to check, so return the first one
return tx_pub_key;
}
bool wallet2::export_key_images(const std::string &filename, bool requested_only) const
{
PERF_TIMER(export_key_images);
std::pair<size_t, std::vector<std::pair<crypto::key_image, crypto::signature>>> ski = export_key_images(requested_only);
std::string magic(KEY_IMAGE_EXPORT_FILE_MAGIC, strlen(KEY_IMAGE_EXPORT_FILE_MAGIC));
const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
const uint32_t offset = ski.first;
std::string data;
data.reserve(4 + ski.second.size() * (sizeof(crypto::key_image) + sizeof(crypto::signature)) + 2 * sizeof(crypto::public_key));
data.resize(4);
data[0] = offset & 0xff;
data[1] = (offset >> 8) & 0xff;
data[2] = (offset >> 16) & 0xff;
data[3] = (offset >> 24) & 0xff;
data += std::string((const char *)&keys.m_spend_public_key, sizeof(crypto::public_key));
data += std::string((const char *)&keys.m_view_public_key, sizeof(crypto::public_key));
for (const auto &i: ski.second)
{
data += std::string((const char *)&i.first, sizeof(crypto::key_image));
data += std::string((const char *)&i.second, sizeof(crypto::signature));
}
// encrypt data, keep magic plaintext
PERF_TIMER(export_key_images_encrypt);
std::string ciphertext = encrypt_with_view_secret_key(data);
return epee::file_io_utils::save_string_to_file(filename, magic + ciphertext);
}
//----------------------------------------------------------------------------------------------------
std::pair<size_t, std::vector<std::pair<crypto::key_image, crypto::signature>>> wallet2::export_key_images(bool requested_only) const
{
PERF_TIMER(export_key_images_raw);
std::vector<std::pair<crypto::key_image, crypto::signature>> ski;
size_t offset = 0;
if (requested_only)
{
while (offset < m_transfers.size() && !m_transfers[offset].m_key_image_request)
++offset;
}
ski.reserve(m_transfers.size() - offset);
for (size_t n = offset; n < m_transfers.size(); ++n)
{
const transfer_details &td = m_transfers[n];
// get ephemeral public key
const cryptonote::tx_out &out = td.m_tx.vout[td.m_internal_output_index];
THROW_WALLET_EXCEPTION_IF(out.target.type() != typeid(txout_to_key), error::wallet_internal_error,
"Output is not txout_to_key");
const cryptonote::txout_to_key &o = boost::get<const cryptonote::txout_to_key>(out.target);
const crypto::public_key pkey = o.key;
crypto::public_key tx_pub_key;
if (!try_get_tx_pub_key_using_td(td, tx_pub_key))
{
// TODO(doyle): TODO(worktips): Fallback to old get tx pub key method for
// incase for now. But we need to go find out why we can't just use
// td.m_pk_index for everything? If we were able to decode the output
// using that, why not use it for everthing?
tx_pub_key = get_tx_pub_key_from_received_outs(td);
}
const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(td.m_tx);
// generate ephemeral secret key
crypto::key_image ki;
cryptonote::keypair in_ephemeral;
bool r = cryptonote::generate_key_image_helper(m_account.get_keys(), m_subaddresses, pkey, tx_pub_key, additional_tx_pub_keys, td.m_internal_output_index, in_ephemeral, ki, m_account.get_device());
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
THROW_WALLET_EXCEPTION_IF(td.m_key_image_known && !td.m_key_image_partial && ki != td.m_key_image,
error::wallet_internal_error, "key_image generated not matched with cached key image");
THROW_WALLET_EXCEPTION_IF(in_ephemeral.pub != pkey,
error::wallet_internal_error, "key_image generated ephemeral public key not matched with output_key");
// sign the key image with the output secret key
crypto::signature signature;
std::vector<const crypto::public_key*> key_ptrs;
key_ptrs.push_back(&pkey);
crypto::generate_ring_signature((const crypto::hash&)td.m_key_image, td.m_key_image, key_ptrs, in_ephemeral.sec, 0, &signature);
ski.push_back(std::make_pair(td.m_key_image, signature));
}
return std::make_pair(offset, ski);
}
uint64_t wallet2::import_key_images(const std::string &filename, uint64_t &spent, uint64_t &unspent)
{
PERF_TIMER(import_key_images_fsu);
std::string data;
bool r = epee::file_io_utils::load_file_to_string(filename, data);
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, std::string(tr("failed to read file ")) + filename);
const size_t magiclen = strlen(KEY_IMAGE_EXPORT_FILE_MAGIC);
if (data.size() < magiclen || memcmp(data.data(), KEY_IMAGE_EXPORT_FILE_MAGIC, magiclen))
{
THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Bad key image export file magic in ") + filename);
}
try
{
PERF_TIMER(import_key_images_decrypt);
data = decrypt_with_view_secret_key(std::string(data, magiclen));
}
catch (const std::exception &e)
{
THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Failed to decrypt ") + filename + ": " + e.what());
}
const size_t headerlen = 4 + 2 * sizeof(crypto::public_key);
THROW_WALLET_EXCEPTION_IF(data.size() < headerlen, error::wallet_internal_error, std::string("Bad data size from file ") + filename);
const uint32_t offset = (uint8_t)data[0] | (((uint8_t)data[1]) << 8) | (((uint8_t)data[2]) << 16) | (((uint8_t)data[3]) << 24);
const crypto::public_key &public_spend_key = *(const crypto::public_key*)&data[4];
const crypto::public_key &public_view_key = *(const crypto::public_key*)&data[4 + sizeof(crypto::public_key)];
const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
if (public_spend_key != keys.m_spend_public_key || public_view_key != keys.m_view_public_key)
{
THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string( "Key images from ") + filename + " are for a different account");
}
THROW_WALLET_EXCEPTION_IF(offset > m_transfers.size(), error::wallet_internal_error, "Offset larger than known outputs");
const size_t record_size = sizeof(crypto::key_image) + sizeof(crypto::signature);
THROW_WALLET_EXCEPTION_IF((data.size() - headerlen) % record_size,
error::wallet_internal_error, std::string("Bad data size from file ") + filename);
size_t nki = (data.size() - headerlen) / record_size;
std::vector<std::pair<crypto::key_image, crypto::signature>> ski;
ski.reserve(nki);
for (size_t n = 0; n < nki; ++n)
{
crypto::key_image key_image = *reinterpret_cast<const crypto::key_image*>(&data[headerlen + n * record_size]);
crypto::signature signature = *reinterpret_cast<const crypto::signature*>(&data[headerlen + n * record_size + sizeof(crypto::key_image)]);
ski.push_back(std::make_pair(key_image, signature));
}
return import_key_images(ski, offset, spent, unspent);
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::import_key_images(const std::vector<std::pair<crypto::key_image, crypto::signature>> &signed_key_images, size_t offset, uint64_t &spent, uint64_t &unspent, bool check_spent)
{
PERF_TIMER(import_key_images_lots);
COMMAND_RPC_IS_KEY_IMAGE_SPENT::request req{};
COMMAND_RPC_IS_KEY_IMAGE_SPENT::response daemon_resp{};
THROW_WALLET_EXCEPTION_IF(offset > m_transfers.size(), error::wallet_internal_error, "Offset larger than known outputs");
THROW_WALLET_EXCEPTION_IF(signed_key_images.size() > m_transfers.size() - offset, error::wallet_internal_error,
"The blockchain is out of date compared to the signed key images");
if (signed_key_images.empty() && offset == 0)
{
spent = 0;
unspent = 0;
return 0;
}
req.key_images.reserve(signed_key_images.size());
PERF_TIMER_START(import_key_images_A);
for (size_t n = 0; n < signed_key_images.size(); ++n)
{
const transfer_details &td = m_transfers[n + offset];
const crypto::key_image &key_image = signed_key_images[n].first;
const crypto::signature &signature = signed_key_images[n].second;
// get ephemeral public key
const cryptonote::tx_out &out = td.m_tx.vout[td.m_internal_output_index];
THROW_WALLET_EXCEPTION_IF(out.target.type() != typeid(txout_to_key), error::wallet_internal_error,
"Non txout_to_key output found");
const cryptonote::txout_to_key &o = boost::get<cryptonote::txout_to_key>(out.target);
const crypto::public_key pkey = o.key;
if (!td.m_key_image_known || !(key_image == td.m_key_image))
{
std::vector<const crypto::public_key*> pkeys;
pkeys.push_back(&pkey);
THROW_WALLET_EXCEPTION_IF(!(rct::scalarmultKey(rct::ki2rct(key_image), rct::curveOrder()) == rct::identity()),
error::wallet_internal_error, "Key image out of validity domain: input " + boost::lexical_cast<std::string>(n + offset) + "/"
+ boost::lexical_cast<std::string>(signed_key_images.size()) + ", key image " + epee::string_tools::pod_to_hex(key_image));
THROW_WALLET_EXCEPTION_IF(!crypto::check_ring_signature((const crypto::hash&)key_image, key_image, pkeys, &signature),
error::signature_check_failed, boost::lexical_cast<std::string>(n + offset) + "/"
+ boost::lexical_cast<std::string>(signed_key_images.size()) + ", key image " + epee::string_tools::pod_to_hex(key_image)
+ ", signature " + epee::string_tools::pod_to_hex(signature) + ", pubkey " + epee::string_tools::pod_to_hex(*pkeys[0]));
}
req.key_images.push_back(epee::string_tools::pod_to_hex(key_image));
}
PERF_TIMER_STOP(import_key_images_A);
PERF_TIMER_START(import_key_images_B);
for (size_t n = 0; n < signed_key_images.size(); ++n)
{
m_transfers[n + offset].m_key_image = signed_key_images[n].first;
m_key_images[m_transfers[n + offset].m_key_image] = n + offset;
m_transfers[n + offset].m_key_image_known = true;
m_transfers[n + offset].m_key_image_request = false;
m_transfers[n + offset].m_key_image_partial = false;
}
PERF_TIMER_STOP(import_key_images_B);
if(check_spent)
{
PERF_TIMER(import_key_images_RPC);
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/is_key_image_spent", req, daemon_resp, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "is_key_image_spent");
THROW_WALLET_EXCEPTION_IF(daemon_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "is_key_image_spent");
THROW_WALLET_EXCEPTION_IF(daemon_resp.status != CORE_RPC_STATUS_OK, error::is_key_image_spent_error, daemon_resp.status);
THROW_WALLET_EXCEPTION_IF(daemon_resp.spent_status.size() != signed_key_images.size(), error::wallet_internal_error,
"daemon returned wrong response for is_key_image_spent, wrong amounts count = " +
std::to_string(daemon_resp.spent_status.size()) + ", expected " + std::to_string(signed_key_images.size()));
for (size_t n = 0; n < daemon_resp.spent_status.size(); ++n)
{
transfer_details &td = m_transfers[n + offset];
td.m_spent = daemon_resp.spent_status[n] != COMMAND_RPC_IS_KEY_IMAGE_SPENT::UNSPENT;
}
}
spent = 0;
unspent = 0;
std::unordered_set<crypto::hash> spent_txids; // For each spent key image, search for a tx in m_transfers that uses it as input.
std::vector<size_t> swept_transfers; // If such a spending tx wasn't found in m_transfers, this means the spending tx
// was created by sweep_all, so we can't know the spent height and other detailed info.
std::unordered_map<crypto::key_image, crypto::hash> spent_key_images;
PERF_TIMER_START(import_key_images_C);
for (const transfer_details &td: m_transfers)
{
for (const cryptonote::txin_v& in : td.m_tx.vin)
{
if (in.type() == typeid(cryptonote::txin_to_key))
spent_key_images.insert(std::make_pair(boost::get<cryptonote::txin_to_key>(in).k_image, td.m_txid));
}
}
PERF_TIMER_STOP(import_key_images_C);
// accumulate outputs before the updated data
for(size_t i = 0; i < offset; ++i)
{
const transfer_details &td = m_transfers[i];
if (td.m_frozen)
continue;
uint64_t amount = td.amount();
if (td.m_spent)
spent += amount;
else
unspent += amount;
}
PERF_TIMER_START(import_key_images_D);
for(size_t i = 0; i < signed_key_images.size(); ++i)
{
const transfer_details &td = m_transfers[i + offset];
if (td.m_frozen)
continue;
uint64_t amount = td.amount();
if (td.m_spent)
spent += amount;
else
unspent += amount;
LOG_PRINT_L2("Transfer " << i << ": " << print_money(amount) << " (" << td.m_global_output_index << "): "
<< (td.m_spent ? "spent" : "unspent") << " (key image " << req.key_images[i] << ")");
if (i < daemon_resp.spent_status.size() && daemon_resp.spent_status[i] == COMMAND_RPC_IS_KEY_IMAGE_SPENT::SPENT_IN_BLOCKCHAIN)
{
const std::unordered_map<crypto::key_image, crypto::hash>::const_iterator skii = spent_key_images.find(td.m_key_image);
if (skii == spent_key_images.end())
swept_transfers.push_back(i);
else
spent_txids.insert(skii->second);
}
}
PERF_TIMER_STOP(import_key_images_D);
MDEBUG("Total: " << print_money(spent) << " spent, " << print_money(unspent) << " unspent");
if (check_spent)
{
// query outgoing txes
COMMAND_RPC_GET_TRANSACTIONS::request gettxs_req;
COMMAND_RPC_GET_TRANSACTIONS::response gettxs_res;
gettxs_req.decode_as_json = false;
gettxs_req.prune = true;
gettxs_req.txs_hashes.reserve(spent_txids.size());
for (const crypto::hash& spent_txid : spent_txids)
gettxs_req.txs_hashes.push_back(epee::string_tools::pod_to_hex(spent_txid));
PERF_TIMER_START(import_key_images_E);
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json("/gettransactions", gettxs_req, gettxs_res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "gettransactions");
THROW_WALLET_EXCEPTION_IF(gettxs_res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "gettransactions");
THROW_WALLET_EXCEPTION_IF(gettxs_res.txs.size() != spent_txids.size(), error::wallet_internal_error,
"daemon returned wrong response for gettransactions, wrong count = " + std::to_string(gettxs_res.txs.size()) + ", expected " + std::to_string(spent_txids.size()));
PERF_TIMER_STOP(import_key_images_E);
// process each outgoing tx
PERF_TIMER_START(import_key_images_F);
auto spent_txid = spent_txids.begin();
hw::device &hwdev = m_account.get_device();
auto it = spent_txids.begin();
for (const COMMAND_RPC_GET_TRANSACTIONS::entry& e : gettxs_res.txs)
{
THROW_WALLET_EXCEPTION_IF(e.in_pool, error::wallet_internal_error, "spent tx isn't supposed to be in txpool");
cryptonote::transaction spent_tx;
crypto::hash spnet_txid_parsed;
THROW_WALLET_EXCEPTION_IF(!get_pruned_tx(e, spent_tx, spnet_txid_parsed), error::wallet_internal_error, "Failed to get tx from daemon");
THROW_WALLET_EXCEPTION_IF(!(spnet_txid_parsed == *it), error::wallet_internal_error, "parsed txid mismatch");
++it;
// get received (change) amount
uint64_t tx_money_got_in_outs = 0;
const cryptonote::account_keys& keys = m_account.get_keys();
const crypto::public_key tx_pub_key = get_tx_pub_key_from_extra(spent_tx);
crypto::key_derivation derivation;
bool r = hwdev.generate_key_derivation(tx_pub_key, keys.m_view_secret_key, derivation);
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key derivation");
const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(spent_tx);
std::vector<crypto::key_derivation> additional_derivations;
for (size_t i = 0; i < additional_tx_pub_keys.size(); ++i)
{
additional_derivations.push_back({});
r = hwdev.generate_key_derivation(additional_tx_pub_keys[i], keys.m_view_secret_key, additional_derivations.back());
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key derivation");
}
size_t output_index = 0;
bool miner_tx = cryptonote::is_coinbase(spent_tx);
for (const cryptonote::tx_out& out : spent_tx.vout)
{
tx_scan_info_t tx_scan_info;
check_acc_out_precomp(out, derivation, additional_derivations, output_index, tx_scan_info);
THROW_WALLET_EXCEPTION_IF(tx_scan_info.error, error::wallet_internal_error, "check_acc_out_precomp failed");
if (tx_scan_info.received)
{
if (tx_scan_info.money_transfered == 0 && !miner_tx)
{
rct::key mask;
tx_scan_info.money_transfered = tools::decodeRct(spent_tx.rct_signatures, tx_scan_info.received->derivation, output_index, mask, hwdev);
}
THROW_WALLET_EXCEPTION_IF(tx_money_got_in_outs >= std::numeric_limits<uint64_t>::max() - tx_scan_info.money_transfered,
error::wallet_internal_error, "Overflow in received amounts");
tx_money_got_in_outs += tx_scan_info.money_transfered;
}
++output_index;
}
// get spent amount
uint64_t tx_money_spent_in_ins = 0;
uint32_t subaddr_account = (uint32_t)-1;
std::set<uint32_t> subaddr_indices;
for (const cryptonote::txin_v& in : spent_tx.vin)
{
if (in.type() != typeid(cryptonote::txin_to_key))
continue;
auto it = m_key_images.find(boost::get<cryptonote::txin_to_key>(in).k_image);
if (it != m_key_images.end())
{
THROW_WALLET_EXCEPTION_IF(it->second >= m_transfers.size(), error::wallet_internal_error, std::string("Key images cache contains illegal transfer offset: ") + std::to_string(it->second) + std::string(" m_transfers.size() = ") + std::to_string(m_transfers.size()));
const transfer_details& td = m_transfers[it->second];
uint64_t amount = boost::get<cryptonote::txin_to_key>(in).amount;
if (amount > 0)
{
THROW_WALLET_EXCEPTION_IF(amount != td.amount(), error::wallet_internal_error,
std::string("Inconsistent amount in tx input: got ") + print_money(amount) +
std::string(", expected ") + print_money(td.amount()));
}
amount = td.amount();
tx_money_spent_in_ins += amount;
LOG_PRINT_L0("Spent money: " << print_money(amount) << ", with tx: " << *spent_txid);
set_spent(it->second, e.block_height);
if (m_callback)
m_callback->on_money_spent(e.block_height, *spent_txid, spent_tx, amount, spent_tx, td.m_subaddr_index);
if (subaddr_account != (uint32_t)-1 && subaddr_account != td.m_subaddr_index.major)
LOG_PRINT_L0("WARNING: This tx spends outputs received by different subaddress accounts, which isn't supposed to happen");
subaddr_account = td.m_subaddr_index.major;
subaddr_indices.insert(td.m_subaddr_index.minor);
}
}
// create outgoing payment
process_outgoing(*spent_txid, spent_tx, e.block_height, e.block_timestamp, tx_money_spent_in_ins, tx_money_got_in_outs, subaddr_account, subaddr_indices);
// erase corresponding incoming payment
for (auto j = m_payments.begin(); j != m_payments.end(); ++j)
{
if (j->second.m_tx_hash == *spent_txid)
{
m_payments.erase(j);
break;
}
}
++spent_txid;
}
PERF_TIMER_STOP(import_key_images_F);
PERF_TIMER_START(import_key_images_G);
for (size_t n : swept_transfers)
{
const transfer_details& td = m_transfers[n];
confirmed_transfer_details pd;
pd.m_change = (uint64_t)-1; // change is unknown
pd.m_amount_in = pd.m_amount_out = td.amount(); // fee is unknown
pd.m_block_height = 0; // spent block height is unknown
const crypto::hash &spent_txid = crypto::null_hash; // spent txid is unknown
m_confirmed_txs.insert(std::make_pair(spent_txid, pd));
}
PERF_TIMER_STOP(import_key_images_G);
}
// this can be 0 if we do not know the height
return m_transfers[signed_key_images.size() + offset - 1].m_block_height;
}
bool wallet2::import_key_images(std::vector<crypto::key_image> key_images, size_t offset, boost::optional<std::unordered_set<size_t>> selected_transfers)
{
if (key_images.size() + offset > m_transfers.size())
{
LOG_PRINT_L1("More key images returned that we know outputs for");
return false;
}
for (size_t ki_idx = 0; ki_idx < key_images.size(); ++ki_idx)
{
const size_t transfer_idx = ki_idx + offset;
if (selected_transfers && selected_transfers.get().find(transfer_idx) == selected_transfers.get().end())
continue;
transfer_details &td = m_transfers[transfer_idx];
if (td.m_key_image_known && !td.m_key_image_partial && td.m_key_image != key_images[ki_idx])
LOG_PRINT_L0("WARNING: imported key image differs from previously known key image at index " << ki_idx << ": trusting imported one");
td.m_key_image = key_images[ki_idx];
m_key_images[td.m_key_image] = transfer_idx;
td.m_key_image_known = true;
td.m_key_image_request = false;
td.m_key_image_partial = false;
m_pub_keys[td.get_public_key()] = transfer_idx;
}
return true;
}
bool wallet2::import_key_images(signed_tx_set & signed_tx, size_t offset, bool only_selected_transfers)
{
std::unordered_set<size_t> selected_transfers;
if (only_selected_transfers)
{
for (const pending_tx & ptx : signed_tx.ptx)
{
for (const size_t s: ptx.selected_transfers)
selected_transfers.insert(s);
}
}
return import_key_images(signed_tx.key_images, offset, only_selected_transfers ? boost::make_optional(selected_transfers) : boost::none);
}
wallet2::payment_container wallet2::export_payments() const
{
payment_container payments;
for (auto const &p : m_payments)
{
payments.emplace(p);
}
return payments;
}
void wallet2::import_payments(const payment_container &payments)
{
m_payments.clear();
for (auto const &p : payments)
{
m_payments.emplace(p);
}
}
void wallet2::import_payments_out(const std::list<std::pair<crypto::hash,wallet2::confirmed_transfer_details>> &confirmed_payments)
{
m_confirmed_txs.clear();
for (auto const &p : confirmed_payments)
{
m_confirmed_txs.emplace(p);
}
}
std::tuple<size_t,crypto::hash,std::vector<crypto::hash>> wallet2::export_blockchain() const
{
std::tuple<size_t, crypto::hash, std::vector<crypto::hash>> bc;
std::get<0>(bc) = m_blockchain.offset();
std::get<1>(bc) = m_blockchain.empty() ? crypto::null_hash: m_blockchain.genesis();
for (size_t n = m_blockchain.offset(); n < m_blockchain.size(); ++n)
{
std::get<2>(bc).push_back(m_blockchain[n]);
}
return bc;
}
void wallet2::import_blockchain(const std::tuple<size_t, crypto::hash, std::vector<crypto::hash>> &bc)
{
m_blockchain.clear();
if (std::get<0>(bc))
{
for (size_t n = std::get<0>(bc); n > 0; --n)
m_blockchain.push_back(std::get<1>(bc));
m_blockchain.trim(std::get<0>(bc));
}
for (auto const &b : std::get<2>(bc))
{
m_blockchain.push_back(b);
}
cryptonote::block genesis;
generate_genesis(genesis);
crypto::hash genesis_hash = get_block_hash(genesis);
check_genesis(genesis_hash);
m_last_block_reward = cryptonote::get_outs_money_amount(genesis.miner_tx);
}
//----------------------------------------------------------------------------------------------------
std::pair<size_t, std::vector<tools::wallet2::transfer_details>> wallet2::export_outputs(bool all) const
{
PERF_TIMER(export_outputs);
std::vector<tools::wallet2::transfer_details> outs;
size_t offset = 0;
if (!all)
while (offset < m_transfers.size() && (m_transfers[offset].m_key_image_known && !m_transfers[offset].m_key_image_request))
++offset;
outs.reserve(m_transfers.size() - offset);
for (size_t n = offset; n < m_transfers.size(); ++n)
{
const transfer_details &td = m_transfers[n];
outs.push_back(td);
}
return std::make_pair(offset, outs);
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::export_outputs_to_str(bool all) const
{
PERF_TIMER(export_outputs_to_str);
std::stringstream oss;
boost::archive::portable_binary_oarchive ar(oss);
const auto& outputs = export_outputs(all);
ar << outputs;
std::string magic(OUTPUT_EXPORT_FILE_MAGIC, strlen(OUTPUT_EXPORT_FILE_MAGIC));
const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
std::string header;
header += std::string((const char *)&keys.m_spend_public_key, sizeof(crypto::public_key));
header += std::string((const char *)&keys.m_view_public_key, sizeof(crypto::public_key));
PERF_TIMER(export_outputs_encryption);
std::string ciphertext = encrypt_with_view_secret_key(header + oss.str());
return magic + ciphertext;
}
//----------------------------------------------------------------------------------------------------
size_t wallet2::import_outputs(const std::pair<size_t, std::vector<tools::wallet2::transfer_details>> &outputs)
{
PERF_TIMER(import_outputs);
THROW_WALLET_EXCEPTION_IF(outputs.first > m_transfers.size(), error::wallet_internal_error,
"Imported outputs omit more outputs that we know of");
const size_t offset = outputs.first;
const size_t original_size = m_transfers.size();
m_transfers.resize(offset + outputs.second.size());
for (size_t i = 0; i < offset; ++i)
m_transfers[i].m_key_image_request = false;
for (size_t i = 0; i < outputs.second.size(); ++i)
{
transfer_details td = outputs.second[i];
// skip those we've already imported, or which have different data
if (i + offset < original_size)
{
// compare the data used to create the key image below
const transfer_details &org_td = m_transfers[i + offset];
if (!org_td.m_key_image_known)
goto process;
#define CMPF(f) if (!(td.f == org_td.f)) goto process
CMPF(m_txid);
CMPF(m_key_image);
CMPF(m_internal_output_index);
#undef CMPF
if (!(get_transaction_prefix_hash(td.m_tx) == get_transaction_prefix_hash(org_td.m_tx)))
goto process;
// copy anyway, since the comparison does not include ancillary fields which may have changed
m_transfers[i + offset] = std::move(td);
continue;
}
process:
// the hot wallet wouldn't have known about key images (except if we already exported them)
cryptonote::keypair in_ephemeral;
THROW_WALLET_EXCEPTION_IF(td.m_tx.vout.empty(), error::wallet_internal_error, "tx with no outputs at index " + boost::lexical_cast<std::string>(i + offset));
crypto::public_key tx_pub_key;
if (!try_get_tx_pub_key_using_td(td, tx_pub_key))
{
// TODO(doyle): TODO(worktips): Fallback to old get tx pub key method for
// incase for now. But we need to go find out why we can't just use
// td.m_pk_index for everything? If we were able to decode the output
// using that, why not use it for everthing?
tx_pub_key = get_tx_pub_key_from_received_outs(td);
}
const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(td.m_tx);
THROW_WALLET_EXCEPTION_IF(td.m_tx.vout[td.m_internal_output_index].target.type() != typeid(cryptonote::txout_to_key),
error::wallet_internal_error, "Unsupported output type");
const crypto::public_key& out_key = boost::get<cryptonote::txout_to_key>(td.m_tx.vout[td.m_internal_output_index].target).key;
bool r = cryptonote::generate_key_image_helper(m_account.get_keys(), m_subaddresses, out_key, tx_pub_key, additional_tx_pub_keys, td.m_internal_output_index, in_ephemeral, td.m_key_image, m_account.get_device());
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
expand_subaddresses(td.m_subaddr_index);
td.m_key_image_known = true;
td.m_key_image_request = true;
td.m_key_image_partial = false;
THROW_WALLET_EXCEPTION_IF(in_ephemeral.pub != out_key,
error::wallet_internal_error, "key_image generated ephemeral public key not matched with output_key at index " + boost::lexical_cast<std::string>(i + offset));
m_key_images[td.m_key_image] = i + offset;
m_pub_keys[td.get_public_key()] = i + offset;
m_transfers[i + offset] = std::move(td);
}
return m_transfers.size();
}
//----------------------------------------------------------------------------------------------------
size_t wallet2::import_outputs_from_str(const std::string &outputs_st)
{
PERF_TIMER(import_outputs_from_str);
std::string data = outputs_st;
const size_t magiclen = strlen(OUTPUT_EXPORT_FILE_MAGIC);
if (data.size() < magiclen || memcmp(data.data(), OUTPUT_EXPORT_FILE_MAGIC, magiclen))
{
THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Bad magic from outputs"));
}
try
{
PERF_TIMER(import_outputs_decrypt);
data = decrypt_with_view_secret_key(std::string(data, magiclen));
}
catch (const std::exception &e)
{
THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Failed to decrypt outputs: ") + e.what());
}
const size_t headerlen = 2 * sizeof(crypto::public_key);
if (data.size() < headerlen)
{
THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Bad data size for outputs"));
}
const crypto::public_key &public_spend_key = *(const crypto::public_key*)&data[0];
const crypto::public_key &public_view_key = *(const crypto::public_key*)&data[sizeof(crypto::public_key)];
const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
if (public_spend_key != keys.m_spend_public_key || public_view_key != keys.m_view_public_key)
{
THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Outputs from are for a different account"));
}
size_t imported_outputs = 0;
try
{
std::string body(data, headerlen);
std::stringstream iss;
iss << body;
std::pair<size_t, std::vector<tools::wallet2::transfer_details>> outputs;
try
{
boost::archive::portable_binary_iarchive ar(iss);
ar >> outputs;
}
catch (...)
{
iss.str("");
iss << body;
boost::archive::binary_iarchive ar(iss);
ar >> outputs;
}
imported_outputs = import_outputs(outputs);
}
catch (const std::exception &e)
{
THROW_WALLET_EXCEPTION(error::wallet_internal_error, std::string("Failed to import outputs") + e.what());
}
return imported_outputs;
}
//----------------------------------------------------------------------------------------------------
crypto::public_key wallet2::get_multisig_signer_public_key(const crypto::secret_key &spend_skey) const
{
crypto::public_key pkey;
crypto::secret_key_to_public_key(get_multisig_blinded_secret_key(spend_skey), pkey);
return pkey;
}
//----------------------------------------------------------------------------------------------------
crypto::public_key wallet2::get_multisig_signer_public_key() const
{
CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
crypto::public_key signer;
CHECK_AND_ASSERT_THROW_MES(crypto::secret_key_to_public_key(get_account().get_keys().m_spend_secret_key, signer), "Failed to generate signer public key");
return signer;
}
//----------------------------------------------------------------------------------------------------
crypto::public_key wallet2::get_multisig_signing_public_key(const crypto::secret_key &msk) const
{
CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
crypto::public_key pkey;
CHECK_AND_ASSERT_THROW_MES(crypto::secret_key_to_public_key(msk, pkey), "Failed to derive public key");
return pkey;
}
//----------------------------------------------------------------------------------------------------
crypto::public_key wallet2::get_multisig_signing_public_key(size_t idx) const
{
CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
CHECK_AND_ASSERT_THROW_MES(idx < get_account().get_multisig_keys().size(), "Multisig signing key index out of range");
return get_multisig_signing_public_key(get_account().get_multisig_keys()[idx]);
}
//----------------------------------------------------------------------------------------------------
rct::key wallet2::get_multisig_k(size_t idx, const std::unordered_set<rct::key> &used_L) const
{
CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
CHECK_AND_ASSERT_THROW_MES(idx < m_transfers.size(), "idx out of range");
for (const auto &k: m_transfers[idx].m_multisig_k)
{
rct::key L;
rct::scalarmultBase(L, k);
if (used_L.find(L) != used_L.end())
return k;
}
THROW_WALLET_EXCEPTION(tools::error::multisig_export_needed);
return rct::zero();
}
//----------------------------------------------------------------------------------------------------
rct::multisig_kLRki wallet2::get_multisig_kLRki(size_t n, const rct::key &k) const
{
CHECK_AND_ASSERT_THROW_MES(n < m_transfers.size(), "Bad m_transfers index");
rct::multisig_kLRki kLRki;
kLRki.k = k;
cryptonote::generate_multisig_LR(m_transfers[n].get_public_key(), rct::rct2sk(kLRki.k), (crypto::public_key&)kLRki.L, (crypto::public_key&)kLRki.R);
kLRki.ki = rct::ki2rct(m_transfers[n].m_key_image);
return kLRki;
}
//----------------------------------------------------------------------------------------------------
rct::multisig_kLRki wallet2::get_multisig_composite_kLRki(size_t n, const std::unordered_set<crypto::public_key> &ignore_set, std::unordered_set<rct::key> &used_L, std::unordered_set<rct::key> &new_used_L) const
{
CHECK_AND_ASSERT_THROW_MES(n < m_transfers.size(), "Bad transfer index");
const transfer_details &td = m_transfers[n];
rct::multisig_kLRki kLRki = get_multisig_kLRki(n, rct::skGen());
// pick a L/R pair from every other participant but one
size_t n_signers_used = 1;
for (const auto &p: m_transfers[n].m_multisig_info)
{
if (ignore_set.find(p.m_signer) != ignore_set.end())
continue;
for (const auto &lr: p.m_LR)
{
if (used_L.find(lr.m_L) != used_L.end())
continue;
used_L.insert(lr.m_L);
new_used_L.insert(lr.m_L);
rct::addKeys(kLRki.L, kLRki.L, lr.m_L);
rct::addKeys(kLRki.R, kLRki.R, lr.m_R);
++n_signers_used;
break;
}
}
CHECK_AND_ASSERT_THROW_MES(n_signers_used >= m_multisig_threshold, "LR not found for enough participants");
return kLRki;
}
//----------------------------------------------------------------------------------------------------
crypto::key_image wallet2::get_multisig_composite_key_image(size_t n) const
{
CHECK_AND_ASSERT_THROW_MES(n < m_transfers.size(), "Bad output index");
const transfer_details &td = m_transfers[n];
crypto::public_key tx_key;
if (!try_get_tx_pub_key_using_td(td, tx_key))
{
// TODO(doyle): TODO(worktips): Fallback to old get tx pub key method for
// incase for now. But we need to go find out why we can't just use
// td.m_pk_index for everything? If we were able to decode the output
// using that, why not use it for everthing?
tx_key = get_tx_pub_key_from_received_outs(td);
}
const std::vector<crypto::public_key> additional_tx_keys = cryptonote::get_additional_tx_pub_keys_from_extra(td.m_tx);
crypto::key_image ki;
std::vector<crypto::key_image> pkis;
for (const auto &info: td.m_multisig_info)
for (const auto &pki: info.m_partial_key_images)
pkis.push_back(pki);
bool r = cryptonote::generate_multisig_composite_key_image(get_account().get_keys(), m_subaddresses, td.get_public_key(), tx_key, additional_tx_keys, td.m_internal_output_index, pkis, ki);
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
return ki;
}
//----------------------------------------------------------------------------------------------------
cryptonote::blobdata wallet2::export_multisig()
{
std::vector<tools::wallet2::multisig_info> info;
const crypto::public_key signer = get_multisig_signer_public_key();
info.resize(m_transfers.size());
for (size_t n = 0; n < m_transfers.size(); ++n)
{
transfer_details &td = m_transfers[n];
crypto::key_image ki;
td.m_multisig_k.clear();
info[n].m_LR.clear();
info[n].m_partial_key_images.clear();
for (size_t m = 0; m < get_account().get_multisig_keys().size(); ++m)
{
// we want to export the partial key image, not the full one, so we can't use td.m_key_image
bool r = generate_multisig_key_image(get_account().get_keys(), m, td.get_public_key(), ki);
CHECK_AND_ASSERT_THROW_MES(r, "Failed to generate key image");
info[n].m_partial_key_images.push_back(ki);
}
// Wallet tries to create as many transactions as many signers combinations. We calculate the maximum number here as follows:
// if we have 2/4 wallet with signers: A, B, C, D and A is a transaction creator it will need to pick up 1 signer from 3 wallets left.
// That means counting combinations for excluding 2-of-3 wallets (k = total signers count - threshold, n = total signers count - 1).
size_t nlr = tools::combinations_count(m_multisig_signers.size() - m_multisig_threshold, m_multisig_signers.size() - 1);
for (size_t m = 0; m < nlr; ++m)
{
td.m_multisig_k.push_back(rct::skGen());
const rct::multisig_kLRki kLRki = get_multisig_kLRki(n, td.m_multisig_k.back());
info[n].m_LR.push_back({kLRki.L, kLRki.R});
}
info[n].m_signer = signer;
}
std::stringstream oss;
boost::archive::portable_binary_oarchive ar(oss);
ar << info;
const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
std::string header;
header += std::string((const char *)&keys.m_spend_public_key, sizeof(crypto::public_key));
header += std::string((const char *)&keys.m_view_public_key, sizeof(crypto::public_key));
header += std::string((const char *)&signer, sizeof(crypto::public_key));
std::string ciphertext = encrypt_with_view_secret_key(header + oss.str());
return MULTISIG_EXPORT_FILE_MAGIC + ciphertext;
}
//----------------------------------------------------------------------------------------------------
void wallet2::update_multisig_rescan_info(const std::vector<std::vector<rct::key>> &multisig_k, const std::vector<std::vector<tools::wallet2::multisig_info>> &info, size_t n)
{
CHECK_AND_ASSERT_THROW_MES(n < m_transfers.size(), "Bad index in update_multisig_info");
CHECK_AND_ASSERT_THROW_MES(multisig_k.size() >= m_transfers.size(), "Mismatched sizes of multisig_k and info");
MDEBUG("update_multisig_rescan_info: updating index " << n);
transfer_details &td = m_transfers[n];
td.m_multisig_info.clear();
for (const auto &pi: info)
{
CHECK_AND_ASSERT_THROW_MES(n < pi.size(), "Bad pi size");
td.m_multisig_info.push_back(pi[n]);
}
m_key_images.erase(td.m_key_image);
td.m_key_image = get_multisig_composite_key_image(n);
td.m_key_image_known = true;
td.m_key_image_request = false;
td.m_key_image_partial = false;
td.m_multisig_k = multisig_k[n];
m_key_images[td.m_key_image] = n;
}
//----------------------------------------------------------------------------------------------------
size_t wallet2::import_multisig(std::vector<cryptonote::blobdata> blobs)
{
CHECK_AND_ASSERT_THROW_MES(m_multisig, "Wallet is not multisig");
std::vector<std::vector<tools::wallet2::multisig_info>> info;
std::unordered_set<crypto::public_key> seen;
for (cryptonote::blobdata &data: blobs)
{
const size_t magiclen = strlen(MULTISIG_EXPORT_FILE_MAGIC);
THROW_WALLET_EXCEPTION_IF(data.size() < magiclen || memcmp(data.data(), MULTISIG_EXPORT_FILE_MAGIC, magiclen),
error::wallet_internal_error, "Bad multisig info file magic in ");
data = decrypt_with_view_secret_key(std::string(data, magiclen));
const size_t headerlen = 3 * sizeof(crypto::public_key);
THROW_WALLET_EXCEPTION_IF(data.size() < headerlen, error::wallet_internal_error, "Bad data size");
const crypto::public_key &public_spend_key = *(const crypto::public_key*)&data[0];
const crypto::public_key &public_view_key = *(const crypto::public_key*)&data[sizeof(crypto::public_key)];
const crypto::public_key &signer = *(const crypto::public_key*)&data[2*sizeof(crypto::public_key)];
const cryptonote::account_public_address &keys = get_account().get_keys().m_account_address;
THROW_WALLET_EXCEPTION_IF(public_spend_key != keys.m_spend_public_key || public_view_key != keys.m_view_public_key,
error::wallet_internal_error, "Multisig info is for a different account");
if (get_multisig_signer_public_key() == signer)
{
MINFO("Multisig info from this wallet ignored");
continue;
}
if (seen.find(signer) != seen.end())
{
MINFO("Duplicate multisig info ignored");
continue;
}
seen.insert(signer);
std::string body(data, headerlen);
std::istringstream iss(body);
std::vector<tools::wallet2::multisig_info> i;
boost::archive::portable_binary_iarchive ar(iss);
ar >> i;
MINFO(boost::format("%u outputs found") % boost::lexical_cast<std::string>(i.size()));
info.push_back(std::move(i));
}
CHECK_AND_ASSERT_THROW_MES(info.size() + 1 <= m_multisig_signers.size() && info.size() + 1 >= m_multisig_threshold, "Wrong number of multisig sources");
std::vector<std::vector<rct::key>> k;
k.reserve(m_transfers.size());
for (const auto &td: m_transfers)
k.push_back(td.m_multisig_k);
// how many outputs we're going to update
size_t n_outputs = m_transfers.size();
for (const auto &pi: info)
if (pi.size() < n_outputs)
n_outputs = pi.size();
if (n_outputs == 0)
return 0;
// check signers are consistent
for (const auto &pi: info)
{
CHECK_AND_ASSERT_THROW_MES(std::find(m_multisig_signers.begin(), m_multisig_signers.end(), pi[0].m_signer) != m_multisig_signers.end(),
"Signer is not a member of this multisig wallet");
for (size_t n = 1; n < n_outputs; ++n)
CHECK_AND_ASSERT_THROW_MES(pi[n].m_signer == pi[0].m_signer, "Mismatched signers in imported multisig info");
}
// trim data we don't have info for from all participants
for (auto &pi: info)
pi.resize(n_outputs);
// sort by signer
if (!info.empty() && !info.front().empty())
{
std::sort(info.begin(), info.end(), [](const std::vector<tools::wallet2::multisig_info> &i0, const std::vector<tools::wallet2::multisig_info> &i1){ return memcmp(&i0[0].m_signer, &i1[0].m_signer, sizeof(i0[0].m_signer)); });
}
// first pass to determine where to detach the blockchain
for (size_t n = 0; n < n_outputs; ++n)
{
const transfer_details &td = m_transfers[n];
if (!td.m_key_image_partial)
continue;
MINFO("Multisig info importing from block height " << td.m_block_height);
detach_blockchain(td.m_block_height);
break;
}
for (size_t n = 0; n < n_outputs && n < m_transfers.size(); ++n)
{
update_multisig_rescan_info(k, info, n);
}
m_multisig_rescan_k = &k;
m_multisig_rescan_info = &info;
try
{
refresh(false);
}
catch (...)
{
m_multisig_rescan_info = NULL;
m_multisig_rescan_k = NULL;
throw;
}
m_multisig_rescan_info = NULL;
m_multisig_rescan_k = NULL;
return n_outputs;
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::encrypt(const char *plaintext, size_t len, const crypto::secret_key &skey, bool authenticated) const
{
crypto::chacha_key key;
crypto::generate_chacha_key(&skey, sizeof(skey), key, m_kdf_rounds);
std::string ciphertext;
crypto::chacha_iv iv = crypto::rand<crypto::chacha_iv>();
ciphertext.resize(len + sizeof(iv) + (authenticated ? sizeof(crypto::signature) : 0));
crypto::chacha20(plaintext, len, key, iv, &ciphertext[sizeof(iv)]);
memcpy(&ciphertext[0], &iv, sizeof(iv));
if (authenticated)
{
crypto::hash hash;
crypto::cn_fast_hash(ciphertext.data(), ciphertext.size() - sizeof(signature), hash);
crypto::public_key pkey;
crypto::secret_key_to_public_key(skey, pkey);
crypto::signature &signature = *(crypto::signature*)&ciphertext[ciphertext.size() - sizeof(crypto::signature)];
crypto::generate_signature(hash, pkey, skey, signature);
}
return ciphertext;
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::encrypt(const epee::span<char> &plaintext, const crypto::secret_key &skey, bool authenticated) const
{
return encrypt(plaintext.data(), plaintext.size(), skey, authenticated);
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::encrypt(const std::string &plaintext, const crypto::secret_key &skey, bool authenticated) const
{
return encrypt(plaintext.data(), plaintext.size(), skey, authenticated);
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::encrypt(const epee::wipeable_string &plaintext, const crypto::secret_key &skey, bool authenticated) const
{
return encrypt(plaintext.data(), plaintext.size(), skey, authenticated);
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::encrypt_with_view_secret_key(const std::string &plaintext, bool authenticated) const
{
return encrypt(plaintext, get_account().get_keys().m_view_secret_key, authenticated);
}
//----------------------------------------------------------------------------------------------------
template<typename T>
T wallet2::decrypt(const std::string &ciphertext, const crypto::secret_key &skey, bool authenticated) const
{
const size_t prefix_size = sizeof(chacha_iv) + (authenticated ? sizeof(crypto::signature) : 0);
THROW_WALLET_EXCEPTION_IF(ciphertext.size() < prefix_size,
error::wallet_internal_error, "Unexpected ciphertext size");
crypto::chacha_key key;
crypto::generate_chacha_key(&skey, sizeof(skey), key, m_kdf_rounds);
const crypto::chacha_iv &iv = *(const crypto::chacha_iv*)&ciphertext[0];
if (authenticated)
{
crypto::hash hash;
crypto::cn_fast_hash(ciphertext.data(), ciphertext.size() - sizeof(signature), hash);
crypto::public_key pkey;
crypto::secret_key_to_public_key(skey, pkey);
const crypto::signature &signature = *(const crypto::signature*)&ciphertext[ciphertext.size() - sizeof(crypto::signature)];
THROW_WALLET_EXCEPTION_IF(!crypto::check_signature(hash, pkey, signature),
error::wallet_internal_error, "Failed to authenticate ciphertext");
}
std::unique_ptr<char[]> buffer{new char[ciphertext.size() - prefix_size]};
auto wiper = epee::misc_utils::create_scope_leave_handler([&]() { memwipe(buffer.get(), ciphertext.size() - prefix_size); });
crypto::chacha20(ciphertext.data() + sizeof(iv), ciphertext.size() - prefix_size, key, iv, buffer.get());
return T(buffer.get(), ciphertext.size() - prefix_size);
}
//----------------------------------------------------------------------------------------------------
template epee::wipeable_string wallet2::decrypt(const std::string &ciphertext, const crypto::secret_key &skey, bool authenticated) const;
//----------------------------------------------------------------------------------------------------
std::string wallet2::decrypt_with_view_secret_key(const std::string &ciphertext, bool authenticated) const
{
return decrypt(ciphertext, get_account().get_keys().m_view_secret_key, authenticated);
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::make_uri(const std::string &address, const std::string &payment_id, uint64_t amount, const std::string &tx_description, const std::string &recipient_name, std::string &error) const
{
cryptonote::address_parse_info info;
if(!get_account_address_from_str(info, nettype(), address))
{
error = std::string("wrong address: ") + address;
return std::string();
}
// we want only one payment id
if (info.has_payment_id && !payment_id.empty())
{
error = "A single payment id is allowed";
return std::string();
}
if (!payment_id.empty())
{
crypto::hash pid32;
crypto::hash8 pid8;
if (!wallet2::parse_long_payment_id(payment_id, pid32) && !wallet2::parse_short_payment_id(payment_id, pid8))
{
error = "Invalid payment id";
return std::string();
}
}
std::string uri = "worktips:" + address;
unsigned int n_fields = 0;
if (!payment_id.empty())
{
uri += (n_fields++ ? "&" : "?") + std::string("tx_payment_id=") + payment_id;
}
if (amount > 0)
{
// URI encoded amount is in decimal units, not atomic units
uri += (n_fields++ ? "&" : "?") + std::string("tx_amount=") + cryptonote::print_money(amount);
}
if (!recipient_name.empty())
{
uri += (n_fields++ ? "&" : "?") + std::string("recipient_name=") + epee::net_utils::conver_to_url_format(recipient_name);
}
if (!tx_description.empty())
{
uri += (n_fields++ ? "&" : "?") + std::string("tx_description=") + epee::net_utils::conver_to_url_format(tx_description);
}
return uri;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::parse_uri(const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector<std::string> &unknown_parameters, std::string &error)
{
if (uri.substr(0, 5) != "worktips:")
{
error = std::string("URI has wrong scheme (expected \"worktips:\"): ") + uri;
return false;
}
std::string remainder = uri.substr(5);
const char *ptr = strchr(remainder.c_str(), '?');
address = ptr ? remainder.substr(0, ptr-remainder.c_str()) : remainder;
cryptonote::address_parse_info info;
if(!get_account_address_from_str(info, nettype(), address))
{
error = std::string("URI has wrong address: ") + address;
return false;
}
if (!strchr(remainder.c_str(), '?')) {
return true;
}
std::vector<std::string> arguments;
std::string body = remainder.substr(address.size() + 1);
if (body.empty())
return true;
boost::split(arguments, body, boost::is_any_of("&"));
std::set<std::string> have_arg;
for (const auto &arg: arguments)
{
std::vector<std::string> kv;
boost::split(kv, arg, boost::is_any_of("="));
if (kv.size() != 2)
{
error = std::string("URI has wrong parameter: ") + arg;
return false;
}
if (have_arg.find(kv[0]) != have_arg.end())
{
error = std::string("URI has more than one instance of " + kv[0]);
return false;
}
have_arg.insert(kv[0]);
if (kv[0] == "tx_amount")
{
amount = 0;
if (!cryptonote::parse_amount(amount, kv[1]))
{
error = std::string("URI has invalid amount: ") + kv[1];
return false;
}
}
else if (kv[0] == "tx_payment_id")
{
if (info.has_payment_id)
{
error = "Separate payment id given with an integrated address";
return false;
}
crypto::hash hash;
crypto::hash8 hash8;
if (!wallet2::parse_long_payment_id(kv[1], hash) && !wallet2::parse_short_payment_id(kv[1], hash8))
{
error = "Invalid payment id: " + kv[1];
return false;
}
payment_id = kv[1];
}
else if (kv[0] == "recipient_name")
{
recipient_name = epee::net_utils::convert_from_url_format(kv[1]);
}
else if (kv[0] == "tx_description")
{
tx_description = epee::net_utils::convert_from_url_format(kv[1]);
}
else
{
unknown_parameters.push_back(arg);
}
}
return true;
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::get_blockchain_height_by_date(uint16_t year, uint8_t month, uint8_t day)
{
uint32_t version;
if (!check_connection(&version))
{
throw std::runtime_error("failed to connect to daemon: " + get_daemon_address());
}
if (version < MAKE_CORE_RPC_VERSION(1, 6))
{
throw std::runtime_error("this function requires RPC version 1.6 or higher");
}
std::tm date = { 0, 0, 0, 0, 0, 0, 0, 0 };
date.tm_year = year - 1900;
date.tm_mon = month - 1;
date.tm_mday = day;
if (date.tm_mon < 0 || 11 < date.tm_mon || date.tm_mday < 1 || 31 < date.tm_mday)
{
throw std::runtime_error("month or day out of range");
}
uint64_t timestamp_target = std::mktime(&date);
std::string err;
uint64_t height_min = 0;
uint64_t height_max = get_daemon_blockchain_height(err) - 1;
if (!err.empty())
{
throw std::runtime_error("failed to get blockchain height");
}
while (true)
{
COMMAND_RPC_GET_BLOCKS_BY_HEIGHT::request req;
COMMAND_RPC_GET_BLOCKS_BY_HEIGHT::response res;
uint64_t height_mid = (height_min + height_max) / 2;
req.heights =
{
height_min,
height_mid,
height_max
};
bool r = invoke_http_bin("/getblocks_by_height.bin", req, res, rpc_timeout);
if (!r || res.status != CORE_RPC_STATUS_OK)
{
std::ostringstream oss;
oss << "failed to get blocks by heights: ";
for (auto height : req.heights)
oss << height << ' ';
oss << endl << "reason: ";
if (!r)
oss << "possibly lost connection to daemon";
else if (res.status == CORE_RPC_STATUS_BUSY)
oss << "daemon is busy";
else
oss << get_rpc_status(res.status);
throw std::runtime_error(oss.str());
}
cryptonote::block blk_min, blk_mid, blk_max;
if (res.blocks.size() < 3) throw std::runtime_error("Not enough blocks returned from daemon");
if (!parse_and_validate_block_from_blob(res.blocks[0].block, blk_min)) throw std::runtime_error("failed to parse blob at height " + std::to_string(height_min));
if (!parse_and_validate_block_from_blob(res.blocks[1].block, blk_mid)) throw std::runtime_error("failed to parse blob at height " + std::to_string(height_mid));
if (!parse_and_validate_block_from_blob(res.blocks[2].block, blk_max)) throw std::runtime_error("failed to parse blob at height " + std::to_string(height_max));
uint64_t timestamp_min = blk_min.timestamp;
uint64_t timestamp_mid = blk_mid.timestamp;
uint64_t timestamp_max = blk_max.timestamp;
if (!(timestamp_min <= timestamp_mid && timestamp_mid <= timestamp_max))
{
// the timestamps are not in the chronological order.
// assuming they're sufficiently close to each other, simply return the smallest height
return std::min({height_min, height_mid, height_max});
}
if (timestamp_target > timestamp_max)
{
throw std::runtime_error("specified date is in the future");
}
if (timestamp_target <= timestamp_min + 2 * 24 * 60 * 60) // two days of "buffer" period
{
return height_min;
}
if (timestamp_target <= timestamp_mid)
height_max = height_mid;
else
height_min = height_mid;
if (height_max - height_min <= 2 * 24 * 30) // don't divide the height range finer than two days
{
return height_min;
}
}
}
//----------------------------------------------------------------------------------------------------
bool wallet2::is_synced() const
{
uint64_t height;
boost::optional<std::string> result = m_node_rpc_proxy.get_target_height(height);
if (result && *result != CORE_RPC_STATUS_OK)
return false;
return get_blockchain_current_height() >= height;
}
//----------------------------------------------------------------------------------------------------
std::vector<std::pair<uint64_t, uint64_t>> wallet2::estimate_backlog(const std::vector<std::pair<double, double>> &fee_levels)
{
for (const auto &fee_level: fee_levels)
{
THROW_WALLET_EXCEPTION_IF(fee_level.first == 0.0, error::wallet_internal_error, "Invalid 0 fee");
THROW_WALLET_EXCEPTION_IF(fee_level.second == 0.0, error::wallet_internal_error, "Invalid 0 fee");
}
// get txpool backlog
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_BACKLOG::request req{};
cryptonote::COMMAND_RPC_GET_TRANSACTION_POOL_BACKLOG::response res{};
m_daemon_rpc_mutex.lock();
bool r = invoke_http_json_rpc("/json_rpc", "get_txpool_backlog", req, res, rpc_timeout);
m_daemon_rpc_mutex.unlock();
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "Failed to connect to daemon");
THROW_WALLET_EXCEPTION_IF(res.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "get_txpool_backlog");
THROW_WALLET_EXCEPTION_IF(res.status != CORE_RPC_STATUS_OK, error::get_tx_pool_error);
uint64_t block_weight_limit = 0;
const auto result = m_node_rpc_proxy.get_block_weight_limit(block_weight_limit);
throw_on_rpc_response_error(result, "get_info");
uint64_t full_reward_zone = block_weight_limit / 2;
THROW_WALLET_EXCEPTION_IF(full_reward_zone == 0, error::wallet_internal_error, "Invalid block weight limit from daemon");
std::vector<std::pair<uint64_t, uint64_t>> blocks;
for (const auto &fee_level: fee_levels)
{
const double our_fee_byte_min = fee_level.first;
const double our_fee_byte_max = fee_level.second;
uint64_t priority_weight_min = 0, priority_weight_max = 0;
for (const auto &i: res.backlog)
{
if (i.weight == 0)
{
MWARNING("Got 0 weight tx from txpool, ignored");
continue;
}
double this_fee_byte = i.fee / (double)i.weight;
if (this_fee_byte >= our_fee_byte_min)
priority_weight_min += i.weight;
if (this_fee_byte >= our_fee_byte_max)
priority_weight_max += i.weight;
}
uint64_t nblocks_min = priority_weight_min / full_reward_zone;
uint64_t nblocks_max = priority_weight_max / full_reward_zone;
MDEBUG("estimate_backlog: priority_weight " << priority_weight_min << " - " << priority_weight_max << " for "
<< our_fee_byte_min << " - " << our_fee_byte_max << " rok byte fee, "
<< nblocks_min << " - " << nblocks_max << " blocks at block weight " << full_reward_zone);
blocks.push_back(std::make_pair(nblocks_min, nblocks_max));
}
return blocks;
}
//----------------------------------------------------------------------------------------------------
std::vector<std::pair<uint64_t, uint64_t>> wallet2::estimate_backlog(uint64_t min_tx_weight, uint64_t max_tx_weight, const std::vector<uint64_t> &fees)
{
THROW_WALLET_EXCEPTION_IF(min_tx_weight == 0, error::wallet_internal_error, "Invalid 0 fee");
THROW_WALLET_EXCEPTION_IF(max_tx_weight == 0, error::wallet_internal_error, "Invalid 0 fee");
for (uint64_t fee: fees)
{
THROW_WALLET_EXCEPTION_IF(fee == 0, error::wallet_internal_error, "Invalid 0 fee");
}
std::vector<std::pair<double, double>> fee_levels;
for (uint64_t fee: fees)
{
double our_fee_byte_min = fee / (double)min_tx_weight, our_fee_byte_max = fee / (double)max_tx_weight;
fee_levels.emplace_back(our_fee_byte_min, our_fee_byte_max);
}
return estimate_backlog(fee_levels);
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::get_segregation_fork_height() const
{
if (m_nettype == TESTNET)
return TESTNET_SEGREGATION_FORK_HEIGHT;
if (m_nettype == STAGENET)
return STAGENET_SEGREGATION_FORK_HEIGHT;
if (m_nettype == FAKECHAIN)
return SEGREGATION_FORK_HEIGHT;
THROW_WALLET_EXCEPTION_IF(m_nettype != MAINNET, tools::error::wallet_internal_error, "Invalid network type");
if (m_segregation_height > 0)
return m_segregation_height;
return SEGREGATION_FORK_HEIGHT;
}
//----------------------------------------------------------------------------------------------------
void wallet2::generate_genesis(cryptonote::block& b) const {
cryptonote::generate_genesis_block(b, get_config(m_nettype).GENESIS_TX, get_config(m_nettype).GENESIS_NONCE);
}
//----------------------------------------------------------------------------------------------------
bool wallet2::contains_address(const cryptonote::account_public_address& address) const {
size_t accounts = get_num_subaddress_accounts() + m_subaddress_lookahead_major;
for (uint32_t i = 0; i < accounts; i++) {
size_t subaddresses = get_num_subaddresses(i) + m_subaddress_lookahead_minor;
for (uint32_t j = 0; j < subaddresses; j++)
if (get_subaddress({i, j}) == address)
return true;
}
return false;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::contains_key_image(const crypto::key_image& key_image) const {
const auto &key_image_it = m_key_images.find(key_image);
bool result = (key_image_it != m_key_images.end());
return result;
}
//----------------------------------------------------------------------------------------------------
bool wallet2::generate_signature_for_request_stake_unlock(crypto::key_image const &key_image, crypto::signature &signature, uint32_t &nonce) const
{
const auto &key_image_it = m_key_images.find(key_image);
if (key_image_it == m_key_images.end())
return false;
size_t transfer_details_index = key_image_it->second;
transfer_details const &td = m_transfers[transfer_details_index];
cryptonote::keypair in_ephemeral;
{
// get ephemeral public key
const cryptonote::tx_out &out = td.m_tx.vout[td.m_internal_output_index];
THROW_WALLET_EXCEPTION_IF(out.target.type() != typeid(txout_to_key), error::wallet_internal_error, "Output is not txout_to_key");
const cryptonote::txout_to_key &o = boost::get<const cryptonote::txout_to_key>(out.target);
const crypto::public_key pkey = o.key;
crypto::public_key tx_pub_key;
if (!try_get_tx_pub_key_using_td(td, tx_pub_key))
{
// TODO(doyle): TODO(worktips): Fallback to old get tx pub key method for
// incase for now. But we need to go find out why we can't just use
// td.m_pk_index for everything? If we were able to decode the output
// using that, why not use it for everthing?
tx_pub_key = get_tx_pub_key_from_received_outs(td);
}
const std::vector<crypto::public_key> additional_tx_pub_keys = get_additional_tx_pub_keys_from_extra(td.m_tx);
// generate ephemeral secret key
crypto::key_image ki;
bool r = cryptonote::generate_key_image_helper(m_account.get_keys(), m_subaddresses, pkey, tx_pub_key, additional_tx_pub_keys, td.m_internal_output_index, in_ephemeral, ki, m_account.get_device());
THROW_WALLET_EXCEPTION_IF(!r, error::wallet_internal_error, "Failed to generate key image");
THROW_WALLET_EXCEPTION_IF(td.m_key_image_known && !td.m_key_image_partial && ki != td.m_key_image, error::wallet_internal_error, "key_image generated not matched with cached key image");
THROW_WALLET_EXCEPTION_IF(in_ephemeral.pub != pkey, error::wallet_internal_error, "key_image generated ephemeral public key not matched with output_key");
}
nonce = static_cast<uint32_t>(time(nullptr));
crypto::hash hash = service_nodes::generate_request_stake_unlock_hash(nonce);
crypto::generate_signature(hash, in_ephemeral.pub, in_ephemeral.sec, signature);
return true;
}
//----------------------------------------------------------------------------------------------------
mms::multisig_wallet_state wallet2::get_multisig_wallet_state() const
{
mms::multisig_wallet_state state;
state.nettype = m_nettype;
state.multisig = multisig(&state.multisig_is_ready);
state.has_multisig_partial_key_images = has_multisig_partial_key_images();
state.multisig_rounds_passed = m_multisig_rounds_passed;
state.num_transfer_details = m_transfers.size();
if (state.multisig)
{
THROW_WALLET_EXCEPTION_IF(!m_original_keys_available, error::wallet_internal_error, "MMS use not possible because own original Monero address not available");
state.address = m_original_address;
state.view_secret_key = m_original_view_secret_key;
}
else
{
state.address = m_account.get_keys().m_account_address;
state.view_secret_key = m_account.get_keys().m_view_secret_key;
}
state.mms_file=m_mms_file;
return state;
}
//----------------------------------------------------------------------------------------------------
wallet_device_callback * wallet2::get_device_callback()
{
if (!m_device_callback){
m_device_callback.reset(new wallet_device_callback(this));
}
return m_device_callback.get();
}//----------------------------------------------------------------------------------------------------
void wallet2::on_device_button_request(uint64_t code)
{
if (nullptr != m_callback)
m_callback->on_device_button_request(code);
}
//----------------------------------------------------------------------------------------------------
void wallet2::on_device_button_pressed()
{
if (nullptr != m_callback)
m_callback->on_device_button_pressed();
}
//----------------------------------------------------------------------------------------------------
boost::optional<epee::wipeable_string> wallet2::on_device_pin_request()
{
if (nullptr != m_callback)
return m_callback->on_device_pin_request();
return boost::none;
}
//----------------------------------------------------------------------------------------------------
boost::optional<epee::wipeable_string> wallet2::on_device_passphrase_request(bool on_device)
{
if (nullptr != m_callback)
return m_callback->on_device_passphrase_request(on_device);
return boost::none;
}
//----------------------------------------------------------------------------------------------------
void wallet2::on_device_progress(const hw::device_progress& event)
{
if (nullptr != m_callback)
m_callback->on_device_progress(event);
}
//----------------------------------------------------------------------------------------------------
std::string wallet2::get_rpc_status(const std::string &s) const
{
if (m_trusted_daemon)
return s;
return "<error>";
}
//----------------------------------------------------------------------------------------------------
void wallet2::throw_on_rpc_response_error(const boost::optional<std::string> &status, const char *method) const
{
// no error
if (!status)
return;
MERROR("RPC error: " << method << ": status " << *status);
// empty string -> not connection
THROW_WALLET_EXCEPTION_IF(status->empty(), tools::error::no_connection_to_daemon, method);
THROW_WALLET_EXCEPTION_IF(*status == CORE_RPC_STATUS_BUSY, tools::error::daemon_busy, method);
THROW_WALLET_EXCEPTION_IF(*status != CORE_RPC_STATUS_OK, tools::error::wallet_generic_rpc_error, method, m_trusted_daemon ? *status : "daemon error");
}
//----------------------------------------------------------------------------------------------------
void wallet2::hash_m_transfer(const transfer_details & transfer, crypto::hash &hash) const
{
KECCAK_CTX state;
keccak_init(&state);
keccak_update(&state, (const uint8_t *) transfer.m_txid.data, sizeof(transfer.m_txid.data));
keccak_update(&state, (const uint8_t *) transfer.m_internal_output_index, sizeof(transfer.m_internal_output_index));
keccak_update(&state, (const uint8_t *) transfer.m_global_output_index, sizeof(transfer.m_global_output_index));
keccak_update(&state, (const uint8_t *) transfer.m_amount, sizeof(transfer.m_amount));
keccak_finish(&state, (uint8_t *) hash.data);
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::hash_m_transfers(int64_t transfer_height, crypto::hash &hash) const
{
CHECK_AND_ASSERT_THROW_MES(transfer_height > (int64_t)m_transfers.size(), "Hash height is greater than number of transfers");
KECCAK_CTX state;
crypto::hash tmp_hash{};
uint64_t current_height = 0;
keccak_init(&state);
for(const transfer_details & transfer : m_transfers){
if (transfer_height >= 0 && current_height >= (uint64_t)transfer_height){
break;
}
hash_m_transfer(transfer, tmp_hash);
keccak_update(&state, (const uint8_t *) transfer.m_block_height, sizeof(transfer.m_block_height));
keccak_update(&state, (const uint8_t *) tmp_hash.data, sizeof(tmp_hash.data));
current_height += 1;
}
keccak_finish(&state, (uint8_t *) hash.data);
return current_height;
}
constexpr std::array<const char* const, 5> allowed_priority_strings = {{"default", "unimportant", "normal", "elevated", "priority"}};
bool parse_subaddress_indices(const std::string& arg, std::set<uint32_t>& subaddr_indices, std::string *err_msg)
{
subaddr_indices.clear();
if (arg.substr(0, 6) != "index=")
return false;
std::string subaddr_indices_str_unsplit = arg.substr(6, arg.size() - 6);
std::vector<std::string> subaddr_indices_str;
boost::split(subaddr_indices_str, subaddr_indices_str_unsplit, boost::is_any_of(","));
for (const auto& subaddr_index_str : subaddr_indices_str)
{
uint32_t subaddr_index;
if(!epee::string_tools::get_xtype_from_string(subaddr_index, subaddr_index_str))
{
subaddr_indices.clear();
if (err_msg) *err_msg = tr("failed to parse index: ") + subaddr_index_str;
return false;
}
subaddr_indices.insert(subaddr_index);
}
return true;
}
bool parse_priority(const std::string& arg, uint32_t& priority)
{
auto priority_pos = std::find(
allowed_priority_strings.begin(),
allowed_priority_strings.end(),
arg);
if(priority_pos != allowed_priority_strings.end()) {
priority = std::distance(allowed_priority_strings.begin(), priority_pos);
return true;
} else if (arg == "blink") {
priority = wallet2::BLINK_PRIORITY;
return true;
}
return false;
}
//----------------------------------------------------------------------------------------------------
void wallet2::finish_rescan_bc_keep_key_images(uint64_t transfer_height, const crypto::hash &hash)
{
// Compute hash of m_transfers, if differs there had to be BC reorg.
crypto::hash new_transfers_hash{};
hash_m_transfers((int64_t) transfer_height, new_transfers_hash);
if (new_transfers_hash != hash)
{
// Soft-Reset to avoid inconsistency in case of BC reorg.
clear_soft(false); // keep_key_images works only with soft reset.
THROW_WALLET_EXCEPTION_IF(true, error::wallet_internal_error, "Transfers changed during rescan, soft or hard rescan is needed");
}
// Restore key images in m_transfers from m_key_images
for(auto it = m_key_images.begin(); it != m_key_images.end(); it++)
{
THROW_WALLET_EXCEPTION_IF(it->second >= m_transfers.size(), error::wallet_internal_error, "Key images cache contains illegal transfer offset");
m_transfers[it->second].m_key_image = it->first;
m_transfers[it->second].m_key_image_known = true;
}
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::get_bytes_sent() const
{
return m_http_client.get_bytes_sent();
}
//----------------------------------------------------------------------------------------------------
uint64_t wallet2::get_bytes_received() const
{
return m_http_client.get_bytes_received();
}
}
|
#include "WindowSystem.h"
#include "Config.h"
#include "Game.h"
#include "GuiComponent.h"
#include "WindowComponent.h"
namespace sand {
//----------------------------------------------------------------------------------------------------
bool WindowSystem::StartUp()
{
if (SDL_Init(SDL_INIT_VIDEO) == SDL_ERROR) {
ELOG("SDL video subsystem could not be initialized! SDL Error: %s", SDL_GetError());
return false;
}
std::weak_ptr<WindowComponent> windowComponent = g_game->GetWindowComponent();
U32 windowFlags = SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL | SDL_WINDOW_ALLOW_HIGHDPI;
std::string name;
#ifdef _CLIENT
name = "Bot Battles (Client)";
#elif defined(_SERVER)
name = "Bot Battles (Server)";
#endif
windowComponent.lock()->m_window = SDL_CreateWindow(name.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, windowComponent.lock()->m_currentResolution.x, windowComponent.lock()->m_currentResolution.y, windowFlags);
if (windowComponent.lock()->m_window == nullptr) {
ELOG("Window could not be created! SDL Error: %s", SDL_GetError());
return false;
}
std::string iconPath = TEXTURES_DIR;
iconPath.append("icon.png");
windowComponent.lock()->m_iconSurface = IMG_Load(iconPath.c_str());
windowComponent.lock()->UpdateIcon();
return true;
}
//----------------------------------------------------------------------------------------------------
bool WindowSystem::ShutDown()
{
std::weak_ptr<WindowComponent> windowComponent = g_game->GetWindowComponent();
SDL_FreeSurface(windowComponent.lock()->m_iconSurface);
windowComponent.lock()->m_iconSurface = nullptr;
SDL_DestroyWindow(windowComponent.lock()->m_window);
windowComponent.lock()->m_window = nullptr;
ILOG("Quitting SDL video subsystem");
SDL_QuitSubSystem(SDL_INIT_VIDEO);
return true;
}
}
|
/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the LICENSE
* file in the root directory of this source tree.
*/
#include <gtest/gtest.h>
#include "bistro/bistro/utils/SymbolTable.h"
using namespace std;
using namespace facebook::bistro;
TEST(TestSymbolTable, HandleLookup) {
StringTable t;
EXPECT_EQ(0, t.size());
EXPECT_EQ(0, t.insert("cat"));
EXPECT_EQ(1, t.size());
EXPECT_EQ(1, t.insert("dog"));
EXPECT_EQ(2, t.size());
EXPECT_EQ(2, t.insert("cow"));
EXPECT_EQ(3, t.size());
EXPECT_EQ(0, t.lookup("cat"));
EXPECT_EQ(1, t.lookup("dog"));
EXPECT_EQ(2, t.lookup("cow"));
EXPECT_EQ(0, t.insert("cat"));
EXPECT_EQ(1, t.insert("dog"));
EXPECT_EQ(2, t.insert("cow"));
EXPECT_EQ("cat", t.lookup(0));
EXPECT_EQ("dog", t.lookup(1));
EXPECT_EQ("cow", t.lookup(2));
EXPECT_EQ((vector<string>{"cat", "dog", "cow"}), t.all());
}
TEST(TestSymbolTable, HandleNotFound) {
StringTable t{"cat", "dog", "cow"};
EXPECT_EQ(StringTable::NotFound, t.lookup("unknown"));
EXPECT_NE(StringTable::NotFound, t.lookup("cat"));
}
|
//
// Created by bs674 on 5/22/19.
//
#include "PairSequenceAlginmentResult.h"
PairSequenceAlginmentResult::PairSequenceAlginmentResult(const std::string &refName, const std::string &altName,
const std::string &refSeq, const std::string &altSeq)
: refName(refName), altName(altName), refSeq(refSeq), altSeq(altSeq) {}
const std::string &PairSequenceAlginmentResult::getRefName() const {
return refName;
}
void PairSequenceAlginmentResult::setRefName(const std::string &refName) {
PairSequenceAlginmentResult::refName = refName;
}
const std::string &PairSequenceAlginmentResult::getAltName() const {
return altName;
}
void PairSequenceAlginmentResult::setAltName(const std::string &altName) {
PairSequenceAlginmentResult::altName = altName;
}
const std::string &PairSequenceAlginmentResult::getRefSeq() const {
return refSeq;
}
void PairSequenceAlginmentResult::setRefSeq(const std::string &refSeq) {
PairSequenceAlginmentResult::refSeq = refSeq;
}
const std::string &PairSequenceAlginmentResult::getAltSeq() const {
return altSeq;
}
void PairSequenceAlginmentResult::setAltSeq(const std::string &altSeq) {
PairSequenceAlginmentResult::altSeq = altSeq;
}
void PairSequenceAlginmentResult::addDel(const int & position){
this->refSeq.insert(position, "-");
this->altSeq.insert(position, "-");
}
|
#include "PN532_SPI.h"
#include "PN532_debug.h"
#include "Arduino.h"
#define STATUS_READ 2
#define DATA_WRITE 1
#define DATA_READ 3
PN532_SPI::PN532_SPI(SPIClass &spi, uint8_t ss)
{
command = 0;
_spi = &spi;
_ss = ss;
}
void PN532_SPI::begin()
{
pinMode(_ss, OUTPUT);
_spi->setClockDivider(SPI_CLOCK_DIV16); // Photon runs at 120Mhz so 3.75Mhz
_spi->setDataMode(SPI_MODE0); // PN532 only supports mode0
_spi->setBitOrder(LSBFIRST);
_spi->begin(_ss);
}
void PN532_SPI::wakeup()
{
digitalWrite(_ss, LOW);
delay(2);
digitalWrite(_ss, HIGH);
}
int8_t PN532_SPI::writeCommand(const uint8_t *header, uint8_t hlen, const uint8_t *body, uint8_t blen)
{
command = header[0];
writeFrame(header, hlen, body, blen);
uint8_t timeout = PN532_ACK_WAIT_TIME;
while (!isReady()) {
delay(1);
timeout--;
if (0 == timeout) {
DMSG("Time out when waiting for ACK\n");
return -2;
}
}
if (readAckFrame()) {
DMSG("Invalid ACK\n");
return PN532_INVALID_ACK;
}
return 0;
}
int16_t PN532_SPI::readResponse(uint8_t buf[], uint8_t len, uint16_t timeout)
{
uint16_t time = 0;
while (!isReady()) {
delay(1);
time++;
if (timeout > 0 && time > timeout) {
return PN532_TIMEOUT;
}
}
digitalWrite(_ss, LOW);
delay(1);
int16_t result;
do {
write(DATA_READ);
if (0x00 != read() || // PREAMBLE
0x00 != read() || // STARTCODE1
0xFF != read() // STARTCODE2
) {
result = PN532_INVALID_FRAME;
break;
}
uint8_t length = read();
if (0 != (uint8_t)(length + read())) { // checksum of length
result = PN532_INVALID_FRAME;
break;
}
uint8_t cmd = command + 1; // response command
if (PN532_PN532TOHOST != read() || (cmd) != read()) {
result = PN532_INVALID_FRAME;
break;
}
DMSG("read: ");
DMSG_HEX(cmd);
length -= 2;
if (length > len) {
for (uint8_t i = 0; i < length; i++) {
DMSG_HEX(read()); // dump message
}
DMSG("\nNot enough space\n");
read();
read();
result = PN532_NO_SPACE; // not enough space
break;
}
uint8_t sum = PN532_PN532TOHOST + cmd;
for (uint8_t i = 0; i < length; i++) {
buf[i] = read();
sum += buf[i];
DMSG_HEX(buf[i]);
}
DMSG('\n');
uint8_t checksum = read();
if (0 != (uint8_t)(sum + checksum)) {
DMSG("checksum is not ok\n");
result = PN532_INVALID_FRAME;
break;
}
read(); // POSTAMBLE
result = length;
} while (0);
digitalWrite(_ss, HIGH);
return result;
}
boolean PN532_SPI::isReady()
{
digitalWrite(_ss, LOW);
write(STATUS_READ);
uint8_t status = read() & 1;
digitalWrite(_ss, HIGH);
return status;
}
void PN532_SPI::writeFrame(const uint8_t *header, uint8_t hlen, const uint8_t *body, uint8_t blen)
{
digitalWrite(_ss, LOW);
delay(2); // wake up PN532
write(DATA_WRITE);
write(PN532_PREAMBLE);
write(PN532_STARTCODE1);
write(PN532_STARTCODE2);
uint8_t length = hlen + blen + 1; // length of data field: TFI + DATA
write(length);
write(~length + 1); // checksum of length
write(PN532_HOSTTOPN532);
uint8_t sum = PN532_HOSTTOPN532; // sum of TFI + DATA
DMSG("write: ");
for (uint8_t i = 0; i < hlen; i++) {
write(header[i]);
sum += header[i];
DMSG_HEX(header[i]);
}
for (uint8_t i = 0; i < blen; i++) {
write(body[i]);
sum += body[i];
DMSG_HEX(body[i]);
}
uint8_t checksum = ~sum + 1; // checksum of TFI + DATA
write(checksum);
write(PN532_POSTAMBLE);
digitalWrite(_ss, HIGH);
DMSG('\n');
}
int8_t PN532_SPI::readAckFrame()
{
const uint8_t PN532_ACK[] = {0, 0, 0xFF, 0, 0xFF, 0};
uint8_t ackBuf[sizeof(PN532_ACK)];
digitalWrite(_ss, LOW);
delay(1);
write(DATA_READ);
for (uint8_t i = 0; i < sizeof(PN532_ACK); i++) {
ackBuf[i] = read();
}
digitalWrite(_ss, HIGH);
return memcmp(ackBuf, PN532_ACK, sizeof(PN532_ACK));
}
|
// Copyright (C) 2011-2020 Roki. Distributed under the MIT License
#ifndef INCLUDED_SROOK_MEMORY_ALLOCATOR_HPP
#define INCLUDED_SROOK_MEMORY_ALLOCATOR_HPP
#include <srook/memory/allocator/allocated_ptr.hpp>
#include <srook/memory/allocator/new_allocator.hpp>
#include <srook/memory/allocator/malloc_allocator.hpp>
#endif
|
// Copyright (c) 2014-2016 The Dash developers
// Copyright (c) 2015-2017 The PIVX developers
// Copyright (c) 2019 The Blastx Developers
// Copyright (c) 2019 The Blastx developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "activemasternode.h"
#include "addrman.h"
#include "masternode.h"
#include "masternodeconfig.h"
#include "masternodeman.h"
#include "masternode-helpers.h"
#include "protocol.h"
#include "spork.h"
// Keep track of the active Masternode
CActiveMasternode activeMasternode;
//
// Bootup the Masternode, look for a BLAST collateral input and register on the network
//
void CActiveMasternode::ManageStatus()
{
std::string errorMessage;
if (!fMasterNode) return;
if (fDebug) LogPrintf("CActiveMasternode::ManageStatus() - Begin\n");
//need correct blocks to send ping
if (Params().NetworkID() != CBaseChainParams::REGTEST && !masternodeSync.IsBlockchainSynced()) {
status = ACTIVE_MASTERNODE_SYNC_IN_PROCESS;
LogPrintf("CActiveMasternode::ManageStatus() - %s\n", GetStatus());
return;
}
if (status == ACTIVE_MASTERNODE_SYNC_IN_PROCESS) status = ACTIVE_MASTERNODE_INITIAL;
if (status == ACTIVE_MASTERNODE_INITIAL) {
CMasternode* pmn;
pmn = mnodeman.Find(pubKeyMasternode);
if (pmn != NULL) {
pmn->Check();
if (pmn->IsEnabled() && pmn->protocolVersion == PROTOCOL_VERSION) EnableHotColdMasterNode(pmn->vin, pmn->addr);
}
}
if (status != ACTIVE_MASTERNODE_STARTED) {
// Set defaults
status = ACTIVE_MASTERNODE_NOT_CAPABLE;
notCapableReason = "";
if (pwalletMain->IsLocked()) {
notCapableReason = "Wallet is locked.";
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
return;
}
if (pwalletMain->GetBalance() == 0) {
notCapableReason = "Hot node, waiting for remote activation.";
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
return;
}
if (strMasterNodeAddr.empty()) {
if (!GetLocal(service)) {
notCapableReason = "Can't detect external address. Please use the masternodeaddr configuration option.";
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
return;
}
} else {
service = CService(strMasterNodeAddr);
}
// if (Params().NetworkID() == CBaseChainParams::MAIN) {
// if (service.GetPort() != 30009) {
// notCapableReason = strprintf("Invalid port: %u - only 30009 is supported on mainnet.", service.GetPort());
// LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
// return;
// }
// } else if (service.GetPort() == 30009) {
// notCapableReason = strprintf("Invalid port: %u - 30009 is only supported on mainnet.", service.GetPort());
// LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
// return;
// }
LogPrintf("CActiveMasternode::ManageStatus() - Checking inbound connection to '%s'\n", service.ToString());
CNode* pnode = ConnectNode((CAddress)service, NULL);
if (!pnode) {
notCapableReason = "Could not connect to " + service.ToString();
LogPrintf("CActiveMasternode::ManageStatus() - not capable: %s\n", notCapableReason);
return;
}
pnode->Release();
// Choose coins to use
CPubKey pubKeyCollateralAddress;
CKey keyCollateralAddress;
if (GetMasterNodeVin(vin, pubKeyCollateralAddress, keyCollateralAddress)) {
if (GetInputAge(vin) < MASTERNODE_MIN_CONFIRMATIONS) {
status = ACTIVE_MASTERNODE_INPUT_TOO_NEW;
notCapableReason = strprintf("%s - %d confirmations", GetStatus(), GetInputAge(vin));
LogPrintf("CActiveMasternode::ManageStatus() - %s\n", notCapableReason);
return;
}
LOCK(pwalletMain->cs_wallet);
pwalletMain->LockCoin(vin.prevout);
// send to all nodes
CPubKey pubKeyMasternode;
CKey keyMasternode;
if (!masternodeSigner.SetKey(strMasterNodePrivKey, errorMessage, keyMasternode, pubKeyMasternode)) {
notCapableReason = "Error upon calling SetKey: " + errorMessage;
LogPrintf("Register::ManageStatus() - %s\n", notCapableReason);
return;
}
if (!Register(vin, service, keyCollateralAddress, pubKeyCollateralAddress, keyMasternode, pubKeyMasternode, errorMessage)) {
notCapableReason = "Error on Register: " + errorMessage;
LogPrintf("Register::ManageStatus() - %s\n", notCapableReason);
return;
}
LogPrintf("CActiveMasternode::ManageStatus() - Is capable master node!\n");
status = ACTIVE_MASTERNODE_STARTED;
return;
} else {
notCapableReason = "Could not find suitable coins!";
LogPrintf("CActiveMasternode::ManageStatus() - %s\n", notCapableReason);
return;
}
}
//send to all peers
if (!SendMasternodePing(errorMessage)) {
LogPrintf("CActiveMasternode::ManageStatus() - Error on Ping: %s\n", errorMessage);
}
}
std::string CActiveMasternode::GetStatus()
{
switch (status) {
case ACTIVE_MASTERNODE_INITIAL:
return "Node just started, not yet activated";
case ACTIVE_MASTERNODE_SYNC_IN_PROCESS:
return "Sync in progress. Must wait until sync is complete to start Masternode";
case ACTIVE_MASTERNODE_INPUT_TOO_NEW:
return strprintf("Masternode input must have at least %d confirmations", MASTERNODE_MIN_CONFIRMATIONS);
case ACTIVE_MASTERNODE_NOT_CAPABLE:
return "Not capable masternode: " + notCapableReason;
case ACTIVE_MASTERNODE_STARTED:
return "Masternode successfully started";
default:
return "unknown";
}
}
bool CActiveMasternode::SendMasternodePing(std::string& errorMessage)
{
if (status != ACTIVE_MASTERNODE_STARTED) {
errorMessage = "Masternode is not in a running status";
return false;
}
CPubKey pubKeyMasternode;
CKey keyMasternode;
if (!masternodeSigner.SetKey(strMasterNodePrivKey, errorMessage, keyMasternode, pubKeyMasternode)) {
errorMessage = strprintf("Error upon calling SetKey: %s\n", errorMessage);
return false;
}
LogPrintf("CActiveMasternode::SendMasternodePing() - Relay Masternode Ping vin = %s\n", vin.ToString());
CMasternodePing mnp(vin);
if (!mnp.Sign(keyMasternode, pubKeyMasternode)) {
errorMessage = "Couldn't sign Masternode Ping";
return false;
}
// Update lastPing for our masternode in Masternode list
CMasternode* pmn = mnodeman.Find(vin);
if (pmn != NULL) {
if (pmn->IsPingedWithin(MASTERNODE_PING_SECONDS, mnp.sigTime)) {
errorMessage = "Too early to send Masternode Ping";
return false;
}
pmn->lastPing = mnp;
mnodeman.mapSeenMasternodePing.insert(make_pair(mnp.GetHash(), mnp));
//mnodeman.mapSeenMasternodeBroadcast.lastPing is probably outdated, so we'll update it
CMasternodeBroadcast mnb(*pmn);
uint256 hash = mnb.GetHash();
if (mnodeman.mapSeenMasternodeBroadcast.count(hash)) mnodeman.mapSeenMasternodeBroadcast[hash].lastPing = mnp;
mnp.Relay();
return true;
} else {
// Seems like we are trying to send a ping while the Masternode is not registered in the network
errorMessage = "Masternode List doesn't include our Masternode, shutting down Masternode pinging service! " + vin.ToString();
status = ACTIVE_MASTERNODE_NOT_CAPABLE;
notCapableReason = errorMessage;
return false;
}
}
bool CActiveMasternode::Register(std::string strService, std::string strKeyMasternode, std::string strTxHash, std::string strOutputIndex, std::string& errorMessage)
{
CTxIn vin;
CPubKey pubKeyCollateralAddress;
CKey keyCollateralAddress;
CPubKey pubKeyMasternode;
CKey keyMasternode;
//need correct blocks to send ping
if (!masternodeSync.IsBlockchainSynced()) {
errorMessage = GetStatus();
LogPrintf("CActiveMasternode::Register() - %s\n", errorMessage);
return false;
}
if (!masternodeSigner.SetKey(strKeyMasternode, errorMessage, keyMasternode, pubKeyMasternode)) {
errorMessage = strprintf("Can't find keys for masternode %s - %s", strService, errorMessage);
LogPrintf("CActiveMasternode::Register() - %s\n", errorMessage);
return false;
}
if (!GetMasterNodeVin(vin, pubKeyCollateralAddress, keyCollateralAddress, strTxHash, strOutputIndex)) {
errorMessage = strprintf("Could not allocate vin %s:%s for masternode %s", strTxHash, strOutputIndex, strService);
LogPrintf("CActiveMasternode::Register() - %s\n", errorMessage);
return false;
}
// CService service = CService(strService);
// if (Params().NetworkID() == CBaseChainParams::MAIN) {
// if (service.GetPort() != 30009) {
// errorMessage = strprintf("Invalid port %u for masternode %s - only 30009 is supported on mainnet.", service.GetPort(), strService);
// LogPrintf("CActiveMasternode::Register() - %s\n", errorMessage);
// return false;
// }
// } else if (service.GetPort() == 30009) {
// errorMessage = strprintf("Invalid port %u for masternode %s - 30009 is only supported on mainnet.", service.GetPort(), strService);
// LogPrintf("CActiveMasternode::Register() - %s\n", errorMessage);
// return false;
// }
addrman.Add(CAddress(service), CNetAddr("127.0.0.1"), 2 * 60 * 60);
return Register(vin, CService(strService), keyCollateralAddress, pubKeyCollateralAddress, keyMasternode, pubKeyMasternode, errorMessage);
}
bool CActiveMasternode::Register(CTxIn vin, CService service, CKey keyCollateralAddress, CPubKey pubKeyCollateralAddress, CKey keyMasternode, CPubKey pubKeyMasternode, std::string& errorMessage)
{
CMasternodeBroadcast mnb;
CMasternodePing mnp(vin);
if (!mnp.Sign(keyMasternode, pubKeyMasternode)) {
errorMessage = strprintf("Failed to sign ping, vin: %s", vin.ToString());
LogPrintf("CActiveMasternode::Register() - %s\n", errorMessage);
return false;
}
mnodeman.mapSeenMasternodePing.insert(make_pair(mnp.GetHash(), mnp));
LogPrintf("CActiveMasternode::Register() - Adding to Masternode list\n service: %s\n vin: %s\n", service.ToString(), vin.ToString());
mnb = CMasternodeBroadcast(service, vin, pubKeyCollateralAddress, pubKeyMasternode, PROTOCOL_VERSION);
mnb.lastPing = mnp;
if (!mnb.Sign(keyCollateralAddress)) {
errorMessage = strprintf("Failed to sign broadcast, vin: %s", vin.ToString());
LogPrintf("CActiveMasternode::Register() - %s\n", errorMessage);
return false;
}
mnodeman.mapSeenMasternodeBroadcast.insert(make_pair(mnb.GetHash(), mnb));
masternodeSync.AddedMasternodeList(mnb.GetHash());
CMasternode* pmn = mnodeman.Find(vin);
if (pmn == NULL) {
CMasternode mn(mnb);
mnodeman.Add(mn);
} else {
pmn->UpdateFromNewBroadcast(mnb);
}
//send to all peers
LogPrintf("CActiveMasternode::Register() - RelayElectionEntry vin = %s\n", vin.ToString());
mnb.Relay();
return true;
}
bool CActiveMasternode::GetMasterNodeVin(CTxIn& vin, CPubKey& pubkey, CKey& secretKey)
{
return GetMasterNodeVin(vin, pubkey, secretKey, "", "");
}
bool CActiveMasternode::GetMasterNodeVin(CTxIn& vin, CPubKey& pubkey, CKey& secretKey, std::string strTxHash, std::string strOutputIndex)
{
// Find possible candidates
TRY_LOCK(pwalletMain->cs_wallet, fWallet);
if (!fWallet) return false;
vector<COutput> possibleCoins = SelectCoinsMasternode();
COutput* selectedOutput;
// Find the vin
if (!strTxHash.empty()) {
// Let's find it
uint256 txHash(strTxHash);
int outputIndex;
try {
outputIndex = std::stoi(strOutputIndex.c_str());
} catch (const std::exception& e) {
LogPrintf("%s: %s on strOutputIndex\n", __func__, e.what());
return false;
}
bool found = false;
BOOST_FOREACH (COutput& out, possibleCoins) {
if (out.tx->GetHash() == txHash && out.i == outputIndex) {
selectedOutput = &out;
found = true;
break;
}
}
if (!found) {
LogPrintf("CActiveMasternode::GetMasterNodeVin - Could not locate valid vin\n");
return false;
}
} else {
// No output specified, Select the first one
if (possibleCoins.size() > 0) {
selectedOutput = &possibleCoins[0];
} else {
LogPrintf("CActiveMasternode::GetMasterNodeVin - Could not locate specified vin from possible list\n");
return false;
}
}
// At this point we have a selected output, retrieve the associated info
return GetVinFromOutput(*selectedOutput, vin, pubkey, secretKey);
}
// Extract Masternode vin information from output
bool CActiveMasternode::GetVinFromOutput(COutput out, CTxIn& vin, CPubKey& pubkey, CKey& secretKey)
{
CScript pubScript;
vin = CTxIn(out.tx->GetHash(), out.i);
pubScript = out.tx->vout[out.i].scriptPubKey; // the inputs PubKey
CTxDestination address1;
ExtractDestination(pubScript, address1);
CBitcoinAddress address2(address1);
CKeyID keyID;
if (!address2.GetKeyID(keyID)) {
LogPrintf("CActiveMasternode::GetMasterNodeVin - Address does not refer to a key\n");
return false;
}
if (!pwalletMain->GetKey(keyID, secretKey)) {
LogPrintf("CActiveMasternode::GetMasterNodeVin - Private key for address is not known\n");
return false;
}
pubkey = secretKey.GetPubKey();
return true;
}
// get all possible outputs for running Masternode
vector<COutput> CActiveMasternode::SelectCoinsMasternode()
{
vector<COutput> vCoins;
vector<COutput> filteredCoins;
vector<COutPoint> confLockedCoins;
// Temporary unlock MN coins from masternode.conf
if (GetBoolArg("-mnconflock", true)) {
uint256 mnTxHash;
BOOST_FOREACH (CMasternodeConfig::CMasternodeEntry mne, masternodeConfig.getEntries()) {
mnTxHash.SetHex(mne.getTxHash());
int nIndex;
if(!mne.castOutputIndex(nIndex))
continue;
COutPoint outpoint = COutPoint(mnTxHash, nIndex);
confLockedCoins.push_back(outpoint);
pwalletMain->UnlockCoin(outpoint);
}
}
// Retrieve all possible outputs
pwalletMain->AvailableCoins(vCoins);
// Lock MN coins from masternode.conf back if they where temporary unlocked
if (!confLockedCoins.empty()) {
BOOST_FOREACH (COutPoint outpoint, confLockedCoins)
pwalletMain->LockCoin(outpoint);
}
// Filter
BOOST_FOREACH (const COutput& out, vCoins) {
if (out.tx->vout[out.i].nValue == MASTERNODE_COLLATERAL * COIN) { //exactly
filteredCoins.push_back(out);
}
}
return filteredCoins;
}
// when starting a Masternode, this can enable to run as a hot wallet with no funds
bool CActiveMasternode::EnableHotColdMasterNode(CTxIn& newVin, CService& newService)
{
if (!fMasterNode) return false;
status = ACTIVE_MASTERNODE_STARTED;
//The values below are needed for signing mnping messages going forward
vin = newVin;
service = newService;
LogPrintf("CActiveMasternode::EnableHotColdMasterNode() - Enabled! You may shut down the cold daemon.\n");
return true;
}
|
#include <EditorPluginAssetsPCH.h>
#include <Core/Assets/AssetFileHeader.h>
#include <EditorFramework/Assets/AssetCurator.h>
#include <EditorFramework/EditorApp/EditorApp.moc.h>
#include <EditorPluginAssets/MaterialAsset/MaterialAssetManager.h>
#include <EditorPluginAssets/MaterialAsset/ShaderTypeRegistry.h>
#include <EditorPluginAssets/VisualShader/VsCodeGenerator.h>
#include <Foundation/IO/FileSystem/FileReader.h>
#include <GuiFoundation/NodeEditor/NodeScene.moc.h>
#include <GuiFoundation/PropertyGrid/PropertyMetaState.h>
#include <ToolsFoundation/Command/NodeCommands.h>
#include <ToolsFoundation/Command/TreeCommands.h>
#include <ToolsFoundation/Document/PrefabCache.h>
#include <ToolsFoundation/Document/PrefabUtils.h>
#include <ToolsFoundation/Object/ObjectAccessorBase.h>
#include <ToolsFoundation/Serialization/DocumentObjectConverter.h>
#ifdef BUILDSYSTEM_ENABLE_ZSTD_SUPPORT
# include <Foundation/IO/CompressedStreamZstd.h>
#endif
// clang-format off
EZ_BEGIN_STATIC_REFLECTED_ENUM(ezMaterialShaderMode, 1)
EZ_ENUM_CONSTANTS(ezMaterialShaderMode::BaseMaterial, ezMaterialShaderMode::File, ezMaterialShaderMode::Custom)
EZ_END_STATIC_REFLECTED_ENUM;
EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezMaterialAssetProperties, 4, ezRTTIDefaultAllocator<ezMaterialAssetProperties>)
{
EZ_BEGIN_PROPERTIES
{
EZ_ENUM_ACCESSOR_PROPERTY("ShaderMode", ezMaterialShaderMode, GetShaderMode, SetShaderMode),
EZ_ACCESSOR_PROPERTY("BaseMaterial", GetBaseMaterial, SetBaseMaterial)->AddAttributes(new ezAssetBrowserAttribute("Material")),
EZ_ACCESSOR_PROPERTY("Surface", GetSurface, SetSurface)->AddAttributes(new ezAssetBrowserAttribute("Surface")),
EZ_ACCESSOR_PROPERTY("Shader", GetShader, SetShader)->AddAttributes(new ezFileBrowserAttribute("Select Shader", "*.ezShader")),
// This property holds the phantom shader properties type so it is only used in the object graph but not actually in the instance of this object.
EZ_ACCESSOR_PROPERTY("ShaderProperties", GetShaderProperties, SetShaderProperties)->AddFlags(ezPropertyFlags::PointerOwner)->AddAttributes(new ezContainerAttribute(false, false, false)),
}
EZ_END_PROPERTIES;
}
EZ_END_DYNAMIC_REFLECTED_TYPE;
EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezMaterialAssetDocument, 5, ezRTTINoAllocator)
EZ_END_DYNAMIC_REFLECTED_TYPE;
// clang-format on
ezUuid ezMaterialAssetDocument::s_LitBaseMaterial;
ezUuid ezMaterialAssetDocument::s_LitAlphaTextBaseMaterial;
ezUuid ezMaterialAssetDocument::s_NeutralNormalMap;
void ezMaterialAssetProperties::SetBaseMaterial(const char* szBaseMaterial)
{
if (m_sBaseMaterial == szBaseMaterial)
return;
m_sBaseMaterial = szBaseMaterial;
// If no doc is present, we are de-serializing the document so do nothing yet.
if (!m_pDocument)
return;
if (m_pDocument->GetCommandHistory()->IsInUndoRedo())
return;
m_pDocument->SetBaseMaterial(m_sBaseMaterial);
}
const char* ezMaterialAssetProperties::GetBaseMaterial() const
{
return m_sBaseMaterial;
}
void ezMaterialAssetProperties::SetShader(const char* szShader)
{
if (m_sShader != szShader)
{
m_sShader = szShader;
UpdateShader();
}
}
const char* ezMaterialAssetProperties::GetShader() const
{
return m_sShader;
}
void ezMaterialAssetProperties::SetShaderProperties(ezReflectedClass* pProperties)
{
// This property represents the phantom shader type, so it is never actually used.
}
ezReflectedClass* ezMaterialAssetProperties::GetShaderProperties() const
{
// This property represents the phantom shader type, so it is never actually used.
return nullptr;
}
void ezMaterialAssetProperties::SetShaderMode(ezEnum<ezMaterialShaderMode> mode)
{
if (m_ShaderMode == mode)
return;
m_ShaderMode = mode;
// If no doc is present, we are de-serializing the document so do nothing yet.
if (!m_pDocument)
return;
ezCommandHistory* pHistory = m_pDocument->GetCommandHistory();
ezObjectAccessorBase* pAccessor = m_pDocument->GetObjectAccessor();
// Do not make new commands if we got here in a response to an undo / redo action.
if (pHistory->IsInUndoRedo())
return;
ezStringBuilder tmp;
switch (m_ShaderMode)
{
case ezMaterialShaderMode::BaseMaterial:
{
pAccessor->SetValue(m_pDocument->GetPropertyObject(), "BaseMaterial", "");
pAccessor->SetValue(m_pDocument->GetPropertyObject(), "Shader", "");
}
break;
case ezMaterialShaderMode::File:
{
pAccessor->SetValue(m_pDocument->GetPropertyObject(), "BaseMaterial", "");
pAccessor->SetValue(m_pDocument->GetPropertyObject(), "Shader", "");
}
break;
case ezMaterialShaderMode::Custom:
{
pAccessor->SetValue(m_pDocument->GetPropertyObject(), "BaseMaterial", "");
pAccessor->SetValue(m_pDocument->GetPropertyObject(), "Shader", ezConversionUtils::ToString(m_pDocument->GetGuid(), tmp).GetData());
}
break;
}
}
void ezMaterialAssetProperties::SetDocument(ezMaterialAssetDocument* pDocument)
{
m_pDocument = pDocument;
if (!m_sBaseMaterial.IsEmpty())
{
m_pDocument->SetBaseMaterial(m_sBaseMaterial);
}
UpdateShader(true);
}
void ezMaterialAssetProperties::UpdateShader(bool bForce)
{
// If no doc is present, we are de-serializing the document so do nothing yet.
if (!m_pDocument)
return;
ezCommandHistory* pHistory = m_pDocument->GetCommandHistory();
// Do not make new commands if we got here in a response to an undo / redo action.
if (pHistory->IsInUndoRedo())
return;
EZ_ASSERT_DEBUG(pHistory->IsInTransaction(), "Missing undo scope on stack.");
ezDocumentObject* pPropObject = m_pDocument->GetShaderPropertyObject();
// TODO: If m_sShader is empty, we need to get the shader of our base material and use that one instead
// for the code below. The type name is the clean path to the shader at the moment.
ezStringBuilder sShaderPath = ResolveRelativeShaderPath();
sShaderPath.MakeCleanPath();
if (sShaderPath.IsEmpty())
{
// No shader, delete any existing properties object.
if (pPropObject)
{
DeleteProperties();
}
}
else
{
if (pPropObject)
{
// We already have a shader properties object, test whether
// it has a different type than the newly set shader. The type name
// is the clean path to the shader at the moment.
const ezRTTI* pType = pPropObject->GetTypeAccessor().GetType();
if (sShaderPath != pType->GetTypeName() || bForce) // TODO: Is force even necessary anymore?
{
// Shader has changed, delete old and create new one.
DeleteProperties();
CreateProperties(sShaderPath);
}
else
{
// Same shader but it could have changed so try to update it anyway.
ezShaderTypeRegistry::GetSingleton()->GetShaderType(sShaderPath);
}
}
if (!pPropObject)
{
// No shader properties exist yet, so create a new one.
CreateProperties(sShaderPath);
}
}
}
void ezMaterialAssetProperties::DeleteProperties()
{
SaveOldValues();
ezCommandHistory* pHistory = m_pDocument->GetCommandHistory();
ezDocumentObject* pPropObject = m_pDocument->GetShaderPropertyObject();
ezRemoveObjectCommand cmd;
cmd.m_Object = pPropObject->GetGuid();
auto res = pHistory->AddCommand(cmd);
EZ_ASSERT_DEV(res.m_Result.Succeeded(), "Removal of old properties should never fail.");
}
void ezMaterialAssetProperties::CreateProperties(const char* szShaderPath)
{
ezCommandHistory* pHistory = m_pDocument->GetCommandHistory();
const ezRTTI* pType = ezShaderTypeRegistry::GetSingleton()->GetShaderType(szShaderPath);
if (!pType && m_ShaderMode == ezMaterialShaderMode::Custom)
{
// Force generate if custom shader is missing
ezAssetFileHeader AssetHeader;
AssetHeader.SetFileHashAndVersion(0, m_pDocument->GetAssetTypeVersion());
m_pDocument->RecreateVisualShaderFile(AssetHeader);
pType = ezShaderTypeRegistry::GetSingleton()->GetShaderType(szShaderPath);
}
if (pType)
{
ezAddObjectCommand cmd;
cmd.m_pType = pType;
cmd.m_sParentProperty = "ShaderProperties";
cmd.m_Parent = m_pDocument->GetPropertyObject()->GetGuid();
cmd.m_NewObjectGuid = cmd.m_Parent;
cmd.m_NewObjectGuid.CombineWithSeed(ezUuid::StableUuidForString("ShaderProperties"));
auto res = pHistory->AddCommand(cmd);
EZ_ASSERT_DEV(res.m_Result.Succeeded(), "Addition of new properties should never fail.");
LoadOldValues();
}
}
void ezMaterialAssetProperties::SaveOldValues()
{
ezDocumentObject* pPropObject = m_pDocument->GetShaderPropertyObject();
if (pPropObject)
{
const ezIReflectedTypeAccessor& accessor = pPropObject->GetTypeAccessor();
const ezRTTI* pType = accessor.GetType();
ezHybridArray<ezAbstractProperty*, 32> properties;
pType->GetAllProperties(properties);
for (ezAbstractProperty* pProp : properties)
{
if (pProp->GetCategory() == ezPropertyCategory::Member)
{
m_CachedProperties[pProp->GetPropertyName()] = accessor.GetValue(pProp->GetPropertyName());
}
}
}
}
void ezMaterialAssetProperties::LoadOldValues()
{
ezDocumentObject* pPropObject = m_pDocument->GetShaderPropertyObject();
ezCommandHistory* pHistory = m_pDocument->GetCommandHistory();
if (pPropObject)
{
const ezIReflectedTypeAccessor& accessor = pPropObject->GetTypeAccessor();
const ezRTTI* pType = accessor.GetType();
ezHybridArray<ezAbstractProperty*, 32> properties;
pType->GetAllProperties(properties);
for (ezAbstractProperty* pProp : properties)
{
if (pProp->GetCategory() == ezPropertyCategory::Member)
{
ezString sPropName = pProp->GetPropertyName();
auto it = m_CachedProperties.Find(sPropName);
if (it.IsValid())
{
if (it.Value() != accessor.GetValue(sPropName.GetData()))
{
ezSetObjectPropertyCommand cmd;
cmd.m_Object = pPropObject->GetGuid();
cmd.m_sProperty = sPropName;
cmd.m_NewValue = it.Value();
// Do not check for success, if a cached value failed to apply, simply ignore it.
pHistory->AddCommand(cmd);
}
}
}
}
}
}
ezString ezMaterialAssetProperties::GetAutoGenShaderPathAbs() const
{
ezAssetDocumentManager* pManager = ezDynamicCast<ezAssetDocumentManager*>(m_pDocument->GetDocumentManager());
ezString sAbsOutputPath = pManager->GetAbsoluteOutputFileName(m_pDocument->GetAssetDocumentTypeDescriptor(), m_pDocument->GetDocumentPath(), ezMaterialAssetDocumentManager::s_szShaderOutputTag);
return sAbsOutputPath;
}
void ezMaterialAssetProperties::PropertyMetaStateEventHandler(ezPropertyMetaStateEvent& e)
{
if (e.m_pObject->GetTypeAccessor().GetType() == ezGetStaticRTTI<ezMaterialAssetProperties>())
{
ezInt64 shaderMode = e.m_pObject->GetTypeAccessor().GetValue("ShaderMode").ConvertTo<ezInt64>();
auto& props = *e.m_pPropertyStates;
if (shaderMode == ezMaterialShaderMode::File)
props["Shader"].m_Visibility = ezPropertyUiState::Default;
else
props["Shader"].m_Visibility = ezPropertyUiState::Invisible;
if (shaderMode == ezMaterialShaderMode::BaseMaterial)
props["BaseMaterial"].m_Visibility = ezPropertyUiState::Default;
else
props["BaseMaterial"].m_Visibility = ezPropertyUiState::Invisible;
}
}
ezString ezMaterialAssetProperties::ResolveRelativeShaderPath() const
{
bool isGuid = ezConversionUtils::IsStringUuid(m_sShader);
if (isGuid)
{
ezUuid guid = ezConversionUtils::ConvertStringToUuid(m_sShader);
auto pAsset = ezAssetCurator::GetSingleton()->GetSubAsset(guid);
if (pAsset)
{
EZ_ASSERT_DEV(pAsset->m_pAssetInfo->GetManager() == m_pDocument->GetDocumentManager(), "Referenced shader via guid by this material is not of type material asset (ezMaterialShaderMode::Custom).");
ezStringBuilder sProjectDir = ezAssetCurator::GetSingleton()->FindDataDirectoryForAsset(pAsset->m_pAssetInfo->m_sAbsolutePath);
ezStringBuilder sResult = pAsset->m_pAssetInfo->GetManager()->GetRelativeOutputFileName(m_pDocument->GetAssetDocumentTypeDescriptor(), sProjectDir, pAsset->m_pAssetInfo->m_sAbsolutePath, ezMaterialAssetDocumentManager::s_szShaderOutputTag);
sResult.Prepend("AssetCache/");
return sResult;
}
else
{
ezLog::Error("Could not resolve guid '{0}' for the material shader.", m_sShader);
return "";
}
}
else
{
return m_sShader;
}
return m_sShader;
}
//////////////////////////////////////////////////////////////////////////
ezMaterialAssetDocument::ezMaterialAssetDocument(const char* szDocumentPath)
: ezSimpleAssetDocument<ezMaterialAssetProperties>(EZ_DEFAULT_NEW(ezMaterialObjectManager), szDocumentPath, ezAssetDocEngineConnection::Simple)
{
ezQtEditorApp::GetSingleton()->m_Events.AddEventHandler(ezMakeDelegate(&ezMaterialAssetDocument::EditorEventHandler, this));
}
ezMaterialAssetDocument::~ezMaterialAssetDocument()
{
ezQtEditorApp::GetSingleton()->m_Events.RemoveEventHandler(ezMakeDelegate(&ezMaterialAssetDocument::EditorEventHandler, this));
}
void ezMaterialAssetDocument::InitializeAfterLoading(bool bFirstTimeCreation)
{
SUPER::InitializeAfterLoading(bFirstTimeCreation);
{
ezCommandHistory* pHistory = GetCommandHistory();
pHistory->StartTransaction("Update Material Shader");
GetProperties()->SetDocument(this);
pHistory->FinishTransaction();
}
bool bSetModified = false;
// The above command may patch the doc with the newest shader properties so we need to clear the undo history here.
GetCommandHistory()->ClearUndoHistory();
SetModified(bSetModified);
}
ezDocumentObject* ezMaterialAssetDocument::GetShaderPropertyObject()
{
ezDocumentObject* pObject = GetObjectManager()->GetRootObject()->GetChildren()[0];
ezIReflectedTypeAccessor& accessor = pObject->GetTypeAccessor();
ezUuid propObjectGuid = accessor.GetValue("ShaderProperties").ConvertTo<ezUuid>();
ezDocumentObject* pPropObject = nullptr;
if (propObjectGuid.IsValid())
{
pPropObject = GetObjectManager()->GetObject(propObjectGuid);
}
return pPropObject;
}
const ezDocumentObject* ezMaterialAssetDocument::GetShaderPropertyObject() const
{
return const_cast<ezMaterialAssetDocument*>(this)->GetShaderPropertyObject();
}
void ezMaterialAssetDocument::SetBaseMaterial(const char* szBaseMaterial)
{
ezDocumentObject* pObject = GetPropertyObject();
auto pAssetInfo = ezAssetCurator::GetSingleton()->FindSubAsset(szBaseMaterial);
if (pAssetInfo == nullptr)
{
ezDeque<const ezDocumentObject*> sel;
sel.PushBack(pObject);
UnlinkPrefabs(sel);
}
else
{
const ezStringBuilder& sNewBase = ezPrefabCache::GetSingleton()->GetCachedPrefabDocument(pAssetInfo->m_Data.m_Guid);
const ezAbstractObjectGraph* pBaseGraph = ezPrefabCache::GetSingleton()->GetCachedPrefabGraph(pAssetInfo->m_Data.m_Guid);
ezUuid seed = GetSeedFromBaseMaterial(pBaseGraph);
if (sNewBase.IsEmpty() || !pBaseGraph || !seed.IsValid())
{
ezLog::Error("The selected base material '{0}' is not a valid material file!", szBaseMaterial);
return;
}
{
auto pMeta = m_DocumentObjectMetaData.BeginModifyMetaData(pObject->GetGuid());
if (pMeta->m_CreateFromPrefab != pAssetInfo->m_Data.m_Guid)
{
pMeta->m_sBasePrefab = sNewBase;
pMeta->m_CreateFromPrefab = pAssetInfo->m_Data.m_Guid;
pMeta->m_PrefabSeedGuid = seed;
}
m_DocumentObjectMetaData.EndModifyMetaData(ezDocumentObjectMetaData::PrefabFlag);
}
UpdatePrefabs();
}
}
ezUuid ezMaterialAssetDocument::GetSeedFromBaseMaterial(const ezAbstractObjectGraph* pBaseGraph)
{
if (!pBaseGraph)
return ezUuid();
ezUuid instanceGuid = GetPropertyObject()->GetGuid();
ezUuid baseGuid = ezMaterialAssetDocument::GetMaterialNodeGuid(*pBaseGraph);
if (baseGuid.IsValid())
{
// Create seed that converts base guid into instance guid
instanceGuid.RevertCombinationWithSeed(baseGuid);
return instanceGuid;
}
return ezUuid();
}
ezUuid ezMaterialAssetDocument::GetMaterialNodeGuid(const ezAbstractObjectGraph& graph)
{
for (auto it = graph.GetAllNodes().GetIterator(); it.IsValid(); ++it)
{
if (ezStringUtils::IsEqual(it.Value()->GetType(), ezGetStaticRTTI<ezMaterialAssetProperties>()->GetTypeName()))
{
return it.Value()->GetGuid();
}
}
return ezUuid();
}
void ezMaterialAssetDocument::UpdatePrefabObject(ezDocumentObject* pObject, const ezUuid& PrefabAsset, const ezUuid& PrefabSeed,
const char* szBasePrefab)
{
// Base
ezAbstractObjectGraph baseGraph;
ezPrefabUtils::LoadGraph(baseGraph, szBasePrefab);
baseGraph.PruneGraph(GetMaterialNodeGuid(baseGraph));
// NewBase
const ezStringBuilder& sLeft = ezPrefabCache::GetSingleton()->GetCachedPrefabDocument(PrefabAsset);
const ezAbstractObjectGraph* pLeftGraph = ezPrefabCache::GetSingleton()->GetCachedPrefabGraph(PrefabAsset);
ezAbstractObjectGraph leftGraph;
if (pLeftGraph)
{
pLeftGraph->Clone(leftGraph);
}
else
{
ezStringBuilder sGuid;
ezConversionUtils::ToString(PrefabAsset, sGuid);
ezLog::Error("Can't update prefab, new base graph does not exist: {0}", sGuid);
return;
}
leftGraph.PruneGraph(GetMaterialNodeGuid(leftGraph));
// Instance
ezAbstractObjectGraph rightGraph;
{
ezDocumentObjectConverterWriter writer(&rightGraph, pObject->GetDocumentObjectManager());
writer.AddObjectToGraph(pObject);
rightGraph.ReMapNodeGuids(PrefabSeed, true);
}
// Merge diffs relative to base
ezDeque<ezAbstractGraphDiffOperation> mergedDiff;
ezPrefabUtils::Merge(baseGraph, leftGraph, rightGraph, mergedDiff);
// Skip 'ShaderMode' as it should not be inherited, and 'ShaderProperties' is being set by the 'Shader' property
ezDeque<ezAbstractGraphDiffOperation> cleanedDiff;
for (const ezAbstractGraphDiffOperation& op : mergedDiff)
{
if (op.m_Operation == ezAbstractGraphDiffOperation::Op::PropertyChanged)
{
if (op.m_sProperty == "ShaderMode" || op.m_sProperty == "ShaderProperties")
continue;
cleanedDiff.PushBack(op);
}
}
// Apply diff to base, making it the new instance
baseGraph.ApplyDiff(cleanedDiff);
// Do not allow 'Shader' to be overridden, always use the prefab template version.
if (ezAbstractObjectNode* pNode = leftGraph.GetNode(GetMaterialNodeGuid(leftGraph)))
{
if (auto pProp = pNode->FindProperty("Shader"))
{
if (ezAbstractObjectNode* pNodeBase = baseGraph.GetNode(GetMaterialNodeGuid(baseGraph)))
{
pNodeBase->ChangeProperty("Shader", pProp->m_Value);
}
}
}
// Create a new diff that changes our current instance to the new instance
ezDeque<ezAbstractGraphDiffOperation> newInstanceToCurrentInstance;
baseGraph.CreateDiffWithBaseGraph(rightGraph, newInstanceToCurrentInstance);
if (false)
{
ezFileWriter file;
file.Open("C:\\temp\\Material - diff.txt");
ezStringBuilder sDiff;
sDiff.Append("######## New Instance To Instance #######\n");
ezPrefabUtils::WriteDiff(newInstanceToCurrentInstance, sDiff);
file.WriteBytes(sDiff.GetData(), sDiff.GetElementCount());
}
// Apply diff to current instance
// Shader needs to be set first
for (ezUInt32 i = 0; i < newInstanceToCurrentInstance.GetCount(); ++i)
{
if (newInstanceToCurrentInstance[i].m_sProperty == "Shader")
{
ezAbstractGraphDiffOperation op = newInstanceToCurrentInstance[i];
newInstanceToCurrentInstance.RemoveAtAndCopy(i);
newInstanceToCurrentInstance.Insert(op, 0);
break;
}
}
for (const ezAbstractGraphDiffOperation& op : newInstanceToCurrentInstance)
{
if (op.m_Operation == ezAbstractGraphDiffOperation::Op::PropertyChanged)
{
// Never change this material's mode, as it should not be inherited from prefab base
if (op.m_sProperty == "ShaderMode")
continue;
// these properties may not exist and we do not want to change them either
if (op.m_sProperty == "MetaBasePrefab" || op.m_sProperty == "MetaPrefabSeed" || op.m_sProperty == "MetaFromPrefab")
continue;
ezSetObjectPropertyCommand cmd;
cmd.m_Object = op.m_Node;
cmd.m_Object.CombineWithSeed(PrefabSeed);
cmd.m_NewValue = op.m_Value;
cmd.m_sProperty = op.m_sProperty;
GetCommandHistory()->AddCommand(cmd);
}
}
// Update prefab meta data
{
auto pMeta = m_DocumentObjectMetaData.BeginModifyMetaData(pObject->GetGuid());
pMeta->m_CreateFromPrefab = PrefabAsset; // Should not change
pMeta->m_PrefabSeedGuid = PrefabSeed; // Should not change
pMeta->m_sBasePrefab = sLeft;
m_DocumentObjectMetaData.EndModifyMetaData(ezDocumentObjectMetaData::PrefabFlag);
}
}
class ezVisualShaderErrorLog : public ezLogInterface
{
public:
ezStringBuilder m_sResult;
ezResult m_Status;
ezVisualShaderErrorLog()
: m_Status(EZ_SUCCESS)
{
}
virtual void HandleLogMessage(const ezLoggingEventData& le) override
{
switch (le.m_EventType)
{
case ezLogMsgType::ErrorMsg:
m_Status = EZ_FAILURE;
m_sResult.Append("Error: ", le.m_szText, "\n");
break;
case ezLogMsgType::SeriousWarningMsg:
case ezLogMsgType::WarningMsg:
m_sResult.Append("Warning: ", le.m_szText, "\n");
break;
default:
return;
}
}
};
ezStatus ezMaterialAssetDocument::InternalTransformAsset(const char* szTargetFile, const char* szOutputTag,
const ezPlatformProfile* pAssetProfile, const ezAssetFileHeader& AssetHeader,
ezBitflags<ezTransformFlags> transformFlags)
{
if (ezStringUtils::IsEqual(szOutputTag, ezMaterialAssetDocumentManager::s_szShaderOutputTag))
{
ezStatus ret = RecreateVisualShaderFile(AssetHeader);
if (transformFlags.IsSet(ezTransformFlags::ForceTransform))
{
ezMaterialVisualShaderEvent e;
if (GetProperties()->m_ShaderMode == ezMaterialShaderMode::Custom)
{
e.m_Type = ezMaterialVisualShaderEvent::TransformFailed;
e.m_sTransformError = ret.m_sMessage;
if (ret.Succeeded())
{
e.m_Type = ezMaterialVisualShaderEvent::TransformSucceeded;
ezStringBuilder sAutoGenShader = GetProperties()->GetAutoGenShaderPathAbs();
QStringList arguments;
ezStringBuilder temp;
arguments << "-project";
arguments << QString::fromUtf8(ezToolsProject::GetSingleton()->GetProjectDirectory().GetData());
arguments << "-shader";
arguments << QString::fromUtf8(sAutoGenShader.GetData());
arguments << "-platform";
arguments << "DX11_SM50"; /// \todo Rendering platform is currently hardcoded
// determine the permutation variables that should get fixed values
{
// m_sCheckPermutations are just all fixed perm vars from every node in the VS
ezStringBuilder temp = m_sCheckPermutations;
ezDeque<ezStringView> perms;
temp.Split(false, perms, "\n");
// remove duplicates
ezSet<ezString> uniquePerms;
for (const ezStringView& perm : perms)
{
uniquePerms.Insert(perm);
}
// pass permutation variable definitions to the compiler: "SOME_VAR=SOME_VAL"
arguments << "-perm";
for (auto it = uniquePerms.GetIterator(); it.IsValid(); ++it)
{
arguments << it.Key().GetData();
}
}
ezVisualShaderErrorLog log;
ret = ezQtEditorApp::GetSingleton()->ExecuteTool("ShaderCompiler.exe", arguments, 60, &log);
if (ret.Failed())
{
e.m_Type = ezMaterialVisualShaderEvent::TransformFailed;
e.m_sTransformError = ret.m_sMessage;
}
else
{
e.m_Type =
log.m_Status.Succeeded() ? ezMaterialVisualShaderEvent::TransformSucceeded : ezMaterialVisualShaderEvent::TransformFailed;
e.m_sTransformError = log.m_sResult;
ezLog::Info("Compiled Visual Shader.");
}
}
}
else
{
e.m_Type = ezMaterialVisualShaderEvent::VisualShaderNotUsed;
}
if (e.m_Type == ezMaterialVisualShaderEvent::TransformFailed)
{
TagVisualShaderFileInvalid(pAssetProfile, e.m_sTransformError);
}
m_VisualShaderEvents.Broadcast(e);
}
return ret;
}
else
{
return SUPER::InternalTransformAsset(szTargetFile, szOutputTag, pAssetProfile, AssetHeader, transformFlags);
}
}
ezStatus ezMaterialAssetDocument::InternalTransformAsset(ezStreamWriter& stream, const char* szOutputTag,
const ezPlatformProfile* pAssetProfile, const ezAssetFileHeader& AssetHeader,
ezBitflags<ezTransformFlags> transformFlags)
{
EZ_ASSERT_DEV(ezStringUtils::IsNullOrEmpty(szOutputTag), "Additional output '{0}' not implemented!", szOutputTag);
return WriteMaterialAsset(stream, pAssetProfile, true);
}
ezStatus ezMaterialAssetDocument::InternalCreateThumbnail(const ThumbnailInfo& ThumbnailInfo)
{
return ezAssetDocument::RemoteCreateThumbnail(ThumbnailInfo);
}
void ezMaterialAssetDocument::InternalGetMetaDataHash(const ezDocumentObject* pObject, ezUInt64& inout_uiHash) const
{
const ezDocumentNodeManager* pManager = static_cast<const ezDocumentNodeManager*>(GetObjectManager());
if (pManager->IsNode(pObject))
{
auto outputs = pManager->GetOutputPins(pObject);
for (const ezPin* pPinSource : outputs)
{
auto inputs = pPinSource->GetConnections();
for (const ezConnection* pConnection : inputs)
{
const ezPin* pPinTarget = pConnection->GetTargetPin();
inout_uiHash = ezHashingUtils::xxHash64(&pPinSource->GetParent()->GetGuid(), sizeof(ezUuid), inout_uiHash);
inout_uiHash = ezHashingUtils::xxHash64(&pPinTarget->GetParent()->GetGuid(), sizeof(ezUuid), inout_uiHash);
inout_uiHash =
ezHashingUtils::xxHash64(pPinSource->GetName(), ezStringUtils::GetStringElementCount(pPinSource->GetName()), inout_uiHash);
inout_uiHash =
ezHashingUtils::xxHash64(pPinTarget->GetName(), ezStringUtils::GetStringElementCount(pPinTarget->GetName()), inout_uiHash);
}
}
}
}
void ezMaterialAssetDocument::AttachMetaDataBeforeSaving(ezAbstractObjectGraph& graph) const
{
SUPER::AttachMetaDataBeforeSaving(graph);
const ezDocumentNodeManager* pManager = static_cast<const ezDocumentNodeManager*>(GetObjectManager());
pManager->AttachMetaDataBeforeSaving(graph);
}
void ezMaterialAssetDocument::RestoreMetaDataAfterLoading(const ezAbstractObjectGraph& graph, bool bUndoable)
{
SUPER::RestoreMetaDataAfterLoading(graph, bUndoable);
ezDocumentNodeManager* pManager = static_cast<ezDocumentNodeManager*>(GetObjectManager());
pManager->RestoreMetaDataAfterLoading(graph, bUndoable);
}
void ezMaterialAssetDocument::UpdateAssetDocumentInfo(ezAssetDocumentInfo* pInfo) const
{
SUPER::UpdateAssetDocumentInfo(pInfo);
if (GetProperties()->m_ShaderMode != ezMaterialShaderMode::BaseMaterial)
{
// remove base material dependency, if it isn't used
pInfo->m_AssetTransformDependencies.Remove(GetProperties()->GetBaseMaterial());
}
if (GetProperties()->m_ShaderMode != ezMaterialShaderMode::File)
{
// remove shader file dependency, if it isn't used
pInfo->m_AssetTransformDependencies.Remove(GetProperties()->GetShader());
}
if (GetProperties()->m_ShaderMode == ezMaterialShaderMode::Custom)
{
// We write our own guid into the shader field so BaseMaterial materials can find the shader file.
// This would cause us to have a dependency to ourselves so we need to remove it.
ezStringBuilder tmp;
pInfo->m_AssetTransformDependencies.Remove(ezConversionUtils::ToString(GetGuid(), tmp));
ezVisualShaderCodeGenerator codeGen;
ezSet<ezString> cfgFiles;
codeGen.DetermineConfigFileDependencies(static_cast<const ezDocumentNodeManager*>(GetObjectManager()), cfgFiles);
for (const auto& sCfgFile : cfgFiles)
{
pInfo->m_AssetTransformDependencies.Insert(sCfgFile);
}
pInfo->m_Outputs.Insert(ezMaterialAssetDocumentManager::s_szShaderOutputTag);
/// \todo The Visual Shader node configuration files would need to be a dependency of the auto-generated shader.
}
}
ezStatus ezMaterialAssetDocument::WriteMaterialAsset(ezStreamWriter& stream0, const ezPlatformProfile* pAssetProfile,
bool bEmbedLowResData) const
{
const ezMaterialAssetProperties* pProp = GetProperties();
ezStringBuilder sValue;
// now generate the .ezMaterialBin file
{
const ezUInt8 uiVersion = 6;
stream0 << uiVersion;
ezUInt8 uiCompressionMode = 0;
#ifdef BUILDSYSTEM_ENABLE_ZSTD_SUPPORT
uiCompressionMode = 1;
ezCompressedStreamWriterZstd stream(&stream0, ezCompressedStreamWriterZstd::Compression::Average);
#else
ezStreamWriter& stream = stream0;
#endif
stream0 << uiCompressionMode;
stream << pProp->m_sBaseMaterial;
stream << pProp->m_sSurface;
stream << pProp->ResolveRelativeShaderPath();
ezHybridArray<ezAbstractProperty*, 16> Textures2D;
ezHybridArray<ezAbstractProperty*, 16> TexturesCube;
ezHybridArray<ezAbstractProperty*, 16> Permutation;
ezHybridArray<ezAbstractProperty*, 16> Constants;
const ezDocumentObject* pObject = GetShaderPropertyObject();
if (pObject)
{
bool hasBaseMaterial = ezPrefabUtils::GetPrefabRoot(pObject, m_DocumentObjectMetaData).IsValid();
auto pType = pObject->GetTypeAccessor().GetType();
ezHybridArray<ezAbstractProperty*, 32> properties;
pType->GetAllProperties(properties);
for (auto* pProp : properties)
{
if (hasBaseMaterial && IsDefaultValue(pObject, pProp->GetPropertyName(), false))
continue;
const ezCategoryAttribute* pCategory = pProp->GetAttributeByType<ezCategoryAttribute>();
EZ_ASSERT_DEBUG(pCategory, "Category cannot be null for a shader property");
if (pCategory == nullptr)
continue;
if (ezStringUtils::IsEqual(pCategory->GetCategory(), "Texture 2D"))
{
Textures2D.PushBack(pProp);
}
else if (ezStringUtils::IsEqual(pCategory->GetCategory(), "Texture Cube"))
{
TexturesCube.PushBack(pProp);
}
else if (ezStringUtils::IsEqual(pCategory->GetCategory(), "Permutation"))
{
Permutation.PushBack(pProp);
}
else if (ezStringUtils::IsEqual(pCategory->GetCategory(), "Constant"))
{
Constants.PushBack(pProp);
}
else
{
EZ_REPORT_FAILURE("Invalid shader property type '{0}'", pCategory->GetCategory());
}
}
}
// write out the permutation variables
{
const ezUInt16 uiPermVars = Permutation.GetCount();
stream << uiPermVars;
for (ezUInt32 p = 0; p < uiPermVars; ++p)
{
const char* szName = Permutation[p]->GetPropertyName();
if (Permutation[p]->GetSpecificType()->GetVariantType() == ezVariantType::Bool)
{
sValue = pObject->GetTypeAccessor().GetValue(szName).Get<bool>() ? "TRUE" : "FALSE";
}
else if (Permutation[p]->GetFlags().IsAnySet(ezPropertyFlags::IsEnum | ezPropertyFlags::Bitflags))
{
ezStringBuilder s;
ezReflectionUtils::EnumerationToString(Permutation[p]->GetSpecificType(),
pObject->GetTypeAccessor().GetValue(szName).ConvertTo<ezInt64>(), s);
sValue = s.FindLastSubString("::") + 2;
}
else
{
EZ_REPORT_FAILURE("Invalid shader permutation property type '{0}'", Permutation[p]->GetSpecificType()->GetTypeName());
}
stream << szName;
stream << sValue;
}
}
// write out the 2D textures
{
const ezUInt16 uiTextures = Textures2D.GetCount();
stream << uiTextures;
for (ezUInt32 p = 0; p < uiTextures; ++p)
{
const char* szName = Textures2D[p]->GetPropertyName();
sValue = pObject->GetTypeAccessor().GetValue(szName).ConvertTo<ezString>();
stream << szName;
stream << sValue;
}
}
// write out the Cube textures
{
const ezUInt16 uiTextures = TexturesCube.GetCount();
stream << uiTextures;
for (ezUInt32 p = 0; p < uiTextures; ++p)
{
const char* szName = TexturesCube[p]->GetPropertyName();
sValue = pObject->GetTypeAccessor().GetValue(szName).ConvertTo<ezString>();
stream << szName;
stream << sValue;
}
}
// write out the constants
{
const ezUInt16 uiConstants = Constants.GetCount();
stream << uiConstants;
for (ezUInt32 p = 0; p < uiConstants; ++p)
{
const char* szName = Constants[p]->GetPropertyName();
ezVariant value = pObject->GetTypeAccessor().GetValue(szName);
stream << szName;
stream << value;
}
}
// find and embed low res texture data
{
if (bEmbedLowResData)
{
ezStringBuilder sFilename, sResourceName;
ezDynamicArray<ezUInt32> content;
// embed 2D texture data
for (ezAbstractProperty* prop : Textures2D)
{
const char* szName = prop->GetPropertyName();
sValue = pObject->GetTypeAccessor().GetValue(szName).ConvertTo<ezString>();
if (sValue.IsEmpty())
continue;
sResourceName = sValue;
auto asset = ezAssetCurator::GetSingleton()->FindSubAsset(sValue);
if (!asset.isValid())
continue;
sValue = asset->m_pAssetInfo->GetManager()->GetAbsoluteOutputFileName(asset->m_pAssetInfo->m_pDocumentTypeDescriptor, asset->m_pAssetInfo->m_sAbsolutePath, "", pAssetProfile);
sFilename = sValue.GetFileName();
sFilename.Append("-lowres");
sValue.ChangeFileName(sFilename);
ezFileReader file;
if (file.Open(sValue).Failed())
continue;
content.SetCountUninitialized(file.GetFileSize());
file.ReadBytes(content.GetData(), content.GetCount());
stream << sResourceName;
stream << content.GetCount();
stream.WriteBytes(content.GetData(), content.GetCount());
}
}
// marker: end of embedded data
stream << "";
}
#ifdef BUILDSYSTEM_ENABLE_ZSTD_SUPPORT
stream.FinishCompressedStream();
ezLog::Dev("Compressed material data from {0} KB to {1} KB ({2}%%)", ezArgF((float)stream.GetUncompressedSize() / 1024.0f, 1),
ezArgF((float)stream.GetCompressedSize() / 1024.0f, 1),
ezArgF(100.0f * stream.GetCompressedSize() / stream.GetUncompressedSize(), 1));
#endif
}
return ezStatus(EZ_SUCCESS);
}
void ezMaterialAssetDocument::TagVisualShaderFileInvalid(const ezPlatformProfile* pAssetProfile, const char* szError)
{
if (GetProperties()->m_ShaderMode != ezMaterialShaderMode::Custom)
return;
ezAssetDocumentManager* pManager = ezDynamicCast<ezAssetDocumentManager*>(GetDocumentManager());
ezString sAutoGenShader = pManager->GetAbsoluteOutputFileName(GetAssetDocumentTypeDescriptor(), GetDocumentPath(), ezMaterialAssetDocumentManager::s_szShaderOutputTag);
ezStringBuilder all;
// read shader source
{
ezFileReader file;
if (file.Open(sAutoGenShader).Failed())
return;
all.ReadAll(file);
}
all.PrependFormat("/*\n{0}\n*/\n", szError);
// write adjusted shader source
{
ezFileWriter fileOut;
if (fileOut.Open(sAutoGenShader).Failed())
return;
fileOut.WriteBytes(all.GetData(), all.GetElementCount());
}
}
ezStatus ezMaterialAssetDocument::RecreateVisualShaderFile(const ezAssetFileHeader& AssetHeader)
{
if (GetProperties()->m_ShaderMode != ezMaterialShaderMode::Custom)
{
return ezStatus(EZ_SUCCESS);
}
ezAssetDocumentManager* pManager = ezDynamicCast<ezAssetDocumentManager*>(GetDocumentManager());
ezString sAutoGenShader = pManager->GetAbsoluteOutputFileName(GetAssetDocumentTypeDescriptor(), GetDocumentPath(), ezMaterialAssetDocumentManager::s_szShaderOutputTag);
ezVisualShaderCodeGenerator codeGen;
EZ_SUCCEED_OR_RETURN(codeGen.GenerateVisualShader(static_cast<const ezDocumentNodeManager*>(GetObjectManager()), m_sCheckPermutations));
ezFileWriter file;
if (file.Open(sAutoGenShader).Succeeded())
{
ezStringBuilder shader = codeGen.GetFinalShaderCode();
shader.PrependFormat("//{0}|{1}\n", AssetHeader.GetFileHash(), AssetHeader.GetFileVersion());
file.WriteBytes(shader.GetData(), shader.GetElementCount());
file.Close();
InvalidateCachedShader();
return ezStatus(EZ_SUCCESS);
}
else
return ezStatus(ezFmt("Failed to write auto-generated shader to '{0}'", sAutoGenShader));
}
void ezMaterialAssetDocument::InvalidateCachedShader()
{
ezAssetDocumentManager* pManager = ezDynamicCast<ezAssetDocumentManager*>(GetDocumentManager());
ezString sShader;
if (GetProperties()->m_ShaderMode == ezMaterialShaderMode::Custom)
{
sShader = pManager->GetAbsoluteOutputFileName(GetAssetDocumentTypeDescriptor(), GetDocumentPath(), ezMaterialAssetDocumentManager::s_szShaderOutputTag);
}
else
{
sShader = GetProperties()->GetShader();
}
// This should update the shader parameter section in all affected materials
ezShaderTypeRegistry::GetSingleton()->GetShaderType(sShader);
}
void ezMaterialAssetDocument::EditorEventHandler(const ezEditorAppEvent& e)
{
if (e.m_Type == ezEditorAppEvent::Type::ReloadResources)
{
InvalidateCachedShader();
}
}
static void MarkReachableNodes(ezMap<const ezDocumentObject*, bool>& AllNodes, const ezDocumentObject* pRoot,
ezDocumentNodeManager* pNodeManager)
{
if (AllNodes[pRoot])
return;
AllNodes[pRoot] = true;
auto allInputs = pNodeManager->GetInputPins(pRoot);
// we start at the final output, so use the inputs on a node and then walk backwards
for (ezPin* pTargetPin : allInputs)
{
const ezArrayPtr<const ezConnection* const> connections = pTargetPin->GetConnections();
// all incoming connections at the input pin, there should only be one though
for (const ezConnection* const pConnection : connections)
{
// output pin on other node connecting to this node
const ezPin* pSourcePin = pConnection->GetSourcePin();
// recurse from here
MarkReachableNodes(AllNodes, pSourcePin->GetParent(), pNodeManager);
}
}
}
void ezMaterialAssetDocument::RemoveDisconnectedNodes()
{
ezDocumentNodeManager* pNodeManager = static_cast<ezDocumentNodeManager*>(GetObjectManager());
const ezDocumentObject* pRoot = pNodeManager->GetRootObject();
const ezRTTI* pNodeBaseRtti = ezVisualShaderTypeRegistry::GetSingleton()->GetNodeBaseType();
const ezHybridArray<ezDocumentObject*, 8>& children = pRoot->GetChildren();
ezMap<const ezDocumentObject*, bool> AllNodes;
for (ezUInt32 i = 0; i < children.GetCount(); ++i)
{
if (children[i]->GetType()->IsDerivedFrom(pNodeBaseRtti))
{
AllNodes[children[i]] = false;
}
}
for (auto it = AllNodes.GetIterator(); it.IsValid(); ++it)
{
// skip nodes that have already been marked
if (it.Value())
continue;
auto pDesc = ezVisualShaderTypeRegistry::GetSingleton()->GetDescriptorForType(it.Key()->GetType());
if (pDesc->m_NodeType == ezVisualShaderNodeType::Main)
{
MarkReachableNodes(AllNodes, it.Key(), pNodeManager);
}
}
// now purge all nodes that haven't been reached
{
auto pHistory = GetCommandHistory();
pHistory->StartTransaction("Purge unreachable nodes");
for (auto it = AllNodes.GetIterator(); it.IsValid(); ++it)
{
// skip nodes that have been marked
if (it.Value())
continue;
ezRemoveNodeCommand rem;
rem.m_Object = it.Key()->GetGuid();
pHistory->AddCommand(rem);
}
pHistory->FinishTransaction();
}
}
ezUuid ezMaterialAssetDocument::GetLitBaseMaterial()
{
if (!s_LitBaseMaterial.IsValid())
{
static const char* szLitMaterialAssetPath = "Base/Materials/BaseMaterials/Lit.ezMaterialAsset";
auto assetInfo = ezAssetCurator::GetSingleton()->FindSubAsset(szLitMaterialAssetPath);
if (assetInfo)
s_LitBaseMaterial = assetInfo->m_Data.m_Guid;
else
ezLog::Error("Can't find default lit material {0}", szLitMaterialAssetPath);
}
return s_LitBaseMaterial;
}
ezUuid ezMaterialAssetDocument::GetLitAlphaTextBaseMaterial()
{
if (!s_LitAlphaTextBaseMaterial.IsValid())
{
static const char* szLitAlphaTestMaterialAssetPath = "Base/Materials/BaseMaterials/LitAlphaTest.ezMaterialAsset";
auto assetInfo = ezAssetCurator::GetSingleton()->FindSubAsset(szLitAlphaTestMaterialAssetPath);
if (assetInfo)
s_LitAlphaTextBaseMaterial = assetInfo->m_Data.m_Guid;
else
ezLog::Error("Can't find default lit alpha test material {0}", szLitAlphaTestMaterialAssetPath);
}
return s_LitAlphaTextBaseMaterial;
}
ezUuid ezMaterialAssetDocument::GetNeutralNormalMap()
{
if (!s_NeutralNormalMap.IsValid())
{
static const char* szNeutralNormalMapAssetPath = "Base/Textures/NeutralNormal.ezTextureAsset";
auto assetInfo = ezAssetCurator::GetSingleton()->FindSubAsset(szNeutralNormalMapAssetPath);
if (assetInfo)
s_NeutralNormalMap = assetInfo->m_Data.m_Guid;
else
ezLog::Error("Can't find neutral normal map texture {0}", szNeutralNormalMapAssetPath);
}
return s_NeutralNormalMap;
}
void ezMaterialAssetDocument::GetSupportedMimeTypesForPasting(ezHybridArray<ezString, 4>& out_MimeTypes) const
{
out_MimeTypes.PushBack("application/ezEditor.NodeGraph");
}
bool ezMaterialAssetDocument::CopySelectedObjects(ezAbstractObjectGraph& out_objectGraph, ezStringBuilder& out_MimeType) const
{
out_MimeType = "application/ezEditor.NodeGraph";
const auto& selection = GetSelectionManager()->GetSelection();
if (selection.IsEmpty())
return false;
const ezDocumentNodeManager* pManager = static_cast<const ezDocumentNodeManager*>(GetObjectManager());
ezDocumentObjectConverterWriter writer(&out_objectGraph, pManager);
for (const ezDocumentObject* pNode : selection)
{
// objects are required to be named root but this is not enforced or obvious by the interface.
writer.AddObjectToGraph(pNode, "root");
}
pManager->AttachMetaDataBeforeSaving(out_objectGraph);
return true;
}
bool ezMaterialAssetDocument::Paste(const ezArrayPtr<PasteInfo>& info, const ezAbstractObjectGraph& objectGraph, bool bAllowPickedPosition,
const char* szMimeType)
{
bool bAddedAll = true;
ezDeque<const ezDocumentObject*> AddedNodes;
for (const PasteInfo& pi : info)
{
// only add nodes that are allowed to be added
if (GetObjectManager()->CanAdd(pi.m_pObject->GetTypeAccessor().GetType(), nullptr, "Children", pi.m_Index).m_Result.Succeeded())
{
AddedNodes.PushBack(pi.m_pObject);
GetObjectManager()->AddObject(pi.m_pObject, nullptr, "Children", pi.m_Index);
}
else
{
bAddedAll = false;
}
}
m_DocumentObjectMetaData.RestoreMetaDataFromAbstractGraph(objectGraph);
RestoreMetaDataAfterLoading(objectGraph, true);
if (!AddedNodes.IsEmpty() && bAllowPickedPosition)
{
ezDocumentNodeManager* pManager = static_cast<ezDocumentNodeManager*>(GetObjectManager());
ezVec2 vAvgPos(0);
for (const ezDocumentObject* pNode : AddedNodes)
{
vAvgPos += pManager->GetNodePos(pNode);
}
vAvgPos /= AddedNodes.GetCount();
const ezVec2 vMoveNode = -vAvgPos + ezQtNodeScene::GetLastMouseInteractionPos();
for (const ezDocumentObject* pNode : AddedNodes)
{
ezMoveNodeCommand move;
move.m_Object = pNode->GetGuid();
move.m_NewPos = pManager->GetNodePos(pNode) + vMoveNode;
GetCommandHistory()->AddCommand(move);
}
if (!bAddedAll)
{
ezLog::Info("[EditorStatus]Not all nodes were allowed to be added to the document");
}
}
GetSelectionManager()->SetSelection(AddedNodes);
return true;
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
#include <Foundation/Serialization/GraphPatch.h>
class ezMaterialAssetPropertiesPatch_1_2 : public ezGraphPatch
{
public:
ezMaterialAssetPropertiesPatch_1_2()
: ezGraphPatch("ezMaterialAssetProperties", 2)
{
}
virtual void Patch(ezGraphPatchContext& context, ezAbstractObjectGraph* pGraph, ezAbstractObjectNode* pNode) const override
{
pNode->RenameProperty("Shader Mode", "ShaderMode");
pNode->RenameProperty("Base Material", "BaseMaterial");
}
};
ezMaterialAssetPropertiesPatch_1_2 g_ezMaterialAssetPropertiesPatch_1_2;
class ezMaterialAssetPropertiesPatch_2_3 : public ezGraphPatch
{
public:
ezMaterialAssetPropertiesPatch_2_3()
: ezGraphPatch("ezMaterialAssetProperties", 3)
{
}
virtual void Patch(ezGraphPatchContext& context, ezAbstractObjectGraph* pGraph, ezAbstractObjectNode* pNode) const override
{
auto* pBaseMatProp = pNode->FindProperty("BaseMaterial");
auto* pShaderModeProp = pNode->FindProperty("ShaderMode");
if (pBaseMatProp && pBaseMatProp->m_Value.IsA<ezString>())
{
if (!pBaseMatProp->m_Value.Get<ezString>().IsEmpty())
{
// BaseMaterial is set
pNode->ChangeProperty("ShaderMode", (ezInt32)ezMaterialShaderMode::BaseMaterial);
}
else
{
pNode->ChangeProperty("ShaderMode", (ezInt32)ezMaterialShaderMode::File);
}
}
}
};
ezMaterialAssetPropertiesPatch_2_3 g_ezMaterialAssetPropertiesPatch_2_3;
|
#include <iostream>
#include <time.h>
#include <QFile>
#include <QPainter>
#include <GL/glew.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
// Save images
#include "lodepng.h"
#include "rendering/Sampler.hpp"
using namespace std;
Sampler::Sampler(QWidget *parent, const QGLFormat &format) : QGLWidget(format, parent)
{
}
Sampler::~Sampler()
{
glDeleteProgram(mShader);
glDeleteTextures(1, &outTex);
glDeleteBuffers(1, &ebo);
glDeleteBuffers(1, &vbo);
glDeleteVertexArrays(1, &vao);
}
void Sampler::initializeGL()
{
// Initialise GLEW
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (GLEW_OK != err)
fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
loadShader();
glGenTextures(1, &outTex);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, outTex);
loadSampler();
createQuad();
glm::mat4 view = glm::lookAt(glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(), glm::vec3(0.0f, 1.0f, 0.0f));
GLint uniView = glGetUniformLocation(mShader, "view");
glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(view));
glm::mat4 proj = glm::ortho(-1.0f, 1.0f, -1.0f, 1.0f, -2.0f, 2.0f);
GLint uniProj = glGetUniformLocation(mShader, "ortho");
glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(proj));
glm::mat4 trans;
trans = glm::rotate(trans, 180.0f, glm::vec3(1.0f, 0.0f, 0.0f));
GLint uniTrans = glGetUniformLocation(mShader, "model");
glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(trans));
}
void Sampler::resizeGL(int width, int height)
{
glViewport(0, 0, width, height);
updateGL();
}
void Sampler::paintGL()
{
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
}
void Sampler::loadShader()
{
QFile vertexFile, fragmentFile;
// - Vertex Shader
vertexFile.setFileName(":/shaders/base.vert");
vertexFile.open(QIODevice::ReadOnly | QIODevice::Text);
QByteArray vertexData = vertexFile.readAll();
vertexFile.close();
const GLchar* vertexSource = vertexData.data();
string str = vertexSource;
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexSource, NULL);
glCompileShader(vertexShader);
// - Fragment Shader
fragmentFile.setFileName(":/shaders/base.frag");
fragmentFile.open(QIODevice::ReadOnly | QIODevice::Text);
QByteArray fragmentData = fragmentFile.readAll();
fragmentFile.close();
const GLchar* fragmentSource = fragmentData.data();
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
glCompileShader(fragmentShader);
// Check whether a shader has successfully been compiled
GLint statusV, statusF;
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &statusV);
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &statusF);
// Create final shader workflow
mShader = glCreateProgram();
glAttachShader(mShader, vertexShader);
glAttachShader(mShader, fragmentShader);
glBindAttribLocation(mShader, 0, "position");
glBindAttribLocation(mShader, 1, "colour");
glBindAttribLocation(mShader, 2, "texcoord");
glBindFragDataLocation(mShader, 0, "outColour");
glLinkProgram(mShader);
glUseProgram(mShader);
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
}
void Sampler::loadSampler()
{
defineCleanTexture();
glUniform1i(glGetUniformLocation(mShader, "tex"), 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
void Sampler::defineCleanTexture()
{
vector<GLuint> emptyTextureTemplate(windowSize*windowSize, 0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, windowSize, windowSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, emptyTextureTemplate.data());
}
void Sampler::createQuad()
{
// Define quad to render the texture
GLfloat vertices[] =
{
1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
-1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
-1.0f, 1.0f, 0.5f, 0.5f, 0.5f, 0.0f, 0.0f
};
GLuint faces[] = { 0, 1, 2, 0, 2, 3 };
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glGenBuffers(1, &ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(faces), faces, GL_STATIC_DRAW);
glEnableVertexAttribArray((GLuint)0);
glVertexAttribPointer((GLuint)0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*7, 0);
glEnableVertexAttribArray((GLuint)1);
glVertexAttribPointer((GLuint)1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*7, (const GLvoid*)(sizeof(GLfloat)*2));
glEnableVertexAttribArray((GLuint)2);
glVertexAttribPointer((GLuint)2, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*7, (const GLvoid*)(sizeof(GLfloat)*5));
}
void Sampler::transferViewportImg(GLubyte* viewportImg, int x, int y)
{
// First of all, context need to be activated to render in this window
makeCurrent();
// Redefine an already existing 2D texture only in the specified subregion
glTexSubImage2D(GL_TEXTURE_2D, 0, x*sizeSample, y*sizeSample, sizeSample, sizeSample, GL_RGBA, GL_UNSIGNED_BYTE, viewportImg);
}
void Sampler::transferViewportDepth(GLubyte* viewportDepth)
{
// makeCurrent();
// glTexSubImage2D(GL_TEXTURE_2D, 0, x*sizeSample, y*sizeSample, sizeSample, sizeSample, GL_DEPTH_COMPONENT, GL_FLOAT, viewportDepth);
unsigned int max = viewportDepth[0];
unsigned int min = viewportDepth[0];
for(unsigned int pix = 1; pix < 256*256; pix++)
{
unsigned int val = viewportDepth[pix];
if(val > max)
max = val;
if(val < min)
min = val;
}
vector<GLuint> colouredDepth(766*766*3, 0);
int nPix = 0;
for(unsigned int pix = 0; pix < 766*766; pix++)
{
colouredDepth[nPix+0] = (float)(viewportDepth[pix]-min)/(max-min)*255;
colouredDepth[nPix+1] = (float)(viewportDepth[pix]-min)/(max-min)*255;
colouredDepth[nPix+2] = (float)(viewportDepth[pix]-min)/(max-min)*255;
nPix+=3;
}
}
void Sampler::saveToImg(string& imgPath)
{
makeCurrent();
updateGL();
updateGL();
// Get texture information with transparency (glReadPixels does not provide transparency but background colour)
vector<GLubyte> texDataRGBA(windowSize*windowSize*4);
vector<GLubyte> revTexDataRGBA(windowSize*windowSize*4);
glReadPixels(0, 0, windowSize, windowSize, GL_RGBA, GL_UNSIGNED_BYTE, texDataRGBA.data());
//glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, texDataRGBA.data());
for(int col = 0; col < 4*windowSize; col += 4)
for(int row = 0; row < windowSize; row += 1)
{
revTexDataRGBA[row*4*windowSize + col + 0] = texDataRGBA[(windowSize-1 - row)*4*windowSize + col + 0];
revTexDataRGBA[row*4*windowSize + col + 1] = texDataRGBA[(windowSize-1 - row)*4*windowSize + col + 1];
revTexDataRGBA[row*4*windowSize + col + 2] = texDataRGBA[(windowSize-1 - row)*4*windowSize + col + 2];
revTexDataRGBA[row*4*windowSize + col + 3] = texDataRGBA[(windowSize-1 - row)*4*windowSize + col + 3];
}
lodepng::encode(imgPath.c_str(), revTexDataRGBA.data(), windowSize, windowSize);
}
void Sampler::updateTexture()
{
windowSize = sizeSample*numSamples;
loadSampler();
parentWidget()->setFixedWidth(windowSize);
parentWidget()->setFixedHeight(windowSize);
updateGL();
}
|
//==============================================================================
/*
Software License Agreement (BSD License)
Copyright (c) 2003-2016, CHAI3D.
(www.chai3d.org)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of CHAI3D nor the names of its contributors may
be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
\author <http://www.chai3d.org>
\author Krzysztof Kondrak
\author Francois Conti
\version 3.2.0 $Rev: 2190 $
*/
//==============================================================================
//------------------------------------------------------------------------------
#include "COculusDevice.h"
//------------------------------------------------------------------------------
#include "OVR_CAPI_GL.h"
#include "OVR_CAPI.h"
//------------------------------------------------------------------------------
namespace chai3d {
//------------------------------------------------------------------------------
cOVRDevice::OVRBuffer::OVRBuffer(const ovrSession &session, int eyeIdx)
{
ovrHmdDesc hmdDesc = ovr_GetHmdDesc(session);
m_eyeTextureSize = ovr_GetFovTextureSize(session, (ovrEyeType)eyeIdx, hmdDesc.DefaultEyeFov[eyeIdx], 1.0f);
m_eyeTextureSize.w = 1 * m_eyeTextureSize.w;
m_eyeTextureSize.h = 1 * m_eyeTextureSize.h;
ovrTextureSwapChainDesc desc = {};
desc.Type = ovrTexture_2D;
desc.ArraySize = 1;
desc.Width = m_eyeTextureSize.w;
desc.Height = m_eyeTextureSize.h;
desc.MipLevels = 1;
desc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB;
desc.SampleCount = 1;
desc.StaticImage = ovrFalse;
ovrResult result = ovr_CreateTextureSwapChainGL(session, &desc, &m_swapTextureChain);
int textureCount = 0;
ovr_GetTextureSwapChainLength(session, m_swapTextureChain, &textureCount);
for (int j = 0; j < textureCount; ++j)
{
GLuint chainTexId;
ovr_GetTextureSwapChainBufferGL(session, m_swapTextureChain, j, &chainTexId);
glBindTexture(GL_TEXTURE_2D, chainTexId);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
glGenFramebuffers(1, &m_eyeFbo);
// create depth buffer
glGenTextures(1, &m_depthBuffer);
glBindTexture(GL_TEXTURE_2D, m_depthBuffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, m_eyeTextureSize.w, m_eyeTextureSize.h, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
// MSAA color texture and fbo setup
// simply comment this line out to skip MSAA altogether
setupMSAA();
}
//------------------------------------------------------------------------------
void cOVRDevice::OVRBuffer::setupMSAA()
{
glGenFramebuffers(1, &m_msaaEyeFbo);
// create color MSAA texture
int samples = 4;
int mipcount = 1;
glGenTextures(1, &m_eyeTexMSAA);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, m_eyeTexMSAA);
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, samples, GL_RGBA, m_eyeTextureSize.w, m_eyeTextureSize.h, false);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
// linear filter
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LEVEL, mipcount - 1);
// create MSAA depth buffer
glGenTextures(1, &m_depthTexMSAA);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, m_depthTexMSAA);
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, samples, GL_DEPTH_COMPONENT, m_eyeTextureSize.w, m_eyeTextureSize.h, false);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LEVEL, mipcount - 1);
}
//------------------------------------------------------------------------------
void cOVRDevice::OVRBuffer::onRenderMSAA()
{
glBindFramebuffer(GL_FRAMEBUFFER, m_msaaEyeFbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, m_eyeTexMSAA, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D_MULTISAMPLE, m_depthTexMSAA, 0);
glViewport(0, 0, m_eyeTextureSize.w, m_eyeTextureSize.h);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
//------------------------------------------------------------------------------
void cOVRDevice::OVRBuffer::onRenderMSAAFinish()
{
// blit the contents of MSAA FBO to the regular eye buffer "connected" to the HMD
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_msaaEyeFbo);
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, m_eyeTexMSAA, 0);
glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_eyeFbo);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_eyeTexId, 0);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
glBlitFramebuffer(0, 0, m_eyeTextureSize.w, m_eyeTextureSize.h,
0, 0, m_eyeTextureSize.w, m_eyeTextureSize.h, GL_COLOR_BUFFER_BIT, GL_NEAREST);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
//------------------------------------------------------------------------------
void cOVRDevice::OVRBuffer::onRender()
{
// Switch to eye render target
glBindFramebuffer(GL_FRAMEBUFFER, m_eyeFbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_eyeTexId, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_depthBuffer, 0);
glViewport(0, 0, m_eyeTextureSize.w, m_eyeTextureSize.h);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
//------------------------------------------------------------------------------
void cOVRDevice::OVRBuffer::onRenderFinish()
{
glBindFramebuffer(GL_FRAMEBUFFER, m_eyeFbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
}
//------------------------------------------------------------------------------
void cOVRDevice::OVRBuffer::destroy(const ovrSession &session)
{
if (glIsFramebuffer(m_eyeFbo))
glDeleteFramebuffers(1, &m_eyeFbo);
if (glIsTexture(m_depthBuffer))
glDeleteTextures(1, &m_depthBuffer);
if (glIsFramebuffer(m_msaaEyeFbo))
glDeleteFramebuffers(1, &m_msaaEyeFbo);
if (glIsTexture(m_eyeTexMSAA))
glDeleteTextures(1, &m_eyeTexMSAA);
if (glIsTexture(m_depthTexMSAA))
glDeleteTextures(1, &m_depthTexMSAA);
ovr_DestroyTextureSwapChain(session, m_swapTextureChain);
}
//------------------------------------------------------------------------------
cOVRDevice::~cOVRDevice()
{
ovr_Destroy(m_hmdSession);
ovr_Shutdown();
m_hmdSession = nullptr;
}
//------------------------------------------------------------------------------
bool cOVRDevice::initVR()
{
ovrResult result = ovr_Initialize(nullptr);
ovrGraphicsLuid luid; // as of SDK 0.7.0.0 luid is not supported with OpenGL
if (result != ovrSuccess)
{
return false;
}
result = ovr_Create(&m_hmdSession, &luid);
if (result != ovrSuccess)
{
return false;
}
m_hmdDesc = ovr_GetHmdDesc(m_hmdSession);
return result == ovrSuccess;
}
//------------------------------------------------------------------------------
bool cOVRDevice::initVRBuffers(int windowWidth, int windowHeight)
{
for (int eyeIdx = 0; eyeIdx < ovrEye_Count; eyeIdx++)
{
m_eyeBuffers[eyeIdx] = new OVRBuffer(m_hmdSession, eyeIdx);
m_eyeRenderDesc[eyeIdx] = ovr_GetRenderDesc(m_hmdSession, (ovrEyeType)eyeIdx, m_hmdDesc.DefaultEyeFov[eyeIdx]);
}
memset(&m_mirrorDesc, 0, sizeof(m_mirrorDesc));
m_mirrorDesc.Width = windowWidth;
m_mirrorDesc.Height = windowHeight;
m_mirrorDesc.Format = OVR_FORMAT_R8G8B8A8_UNORM_SRGB;
// since SDK 0.6 we're using a mirror texture + FBO which in turn copies contents of mirror to back buffer
ovr_CreateMirrorTextureGL(m_hmdSession, &m_mirrorDesc, &m_mirrorTexture);
// Configure the mirror read buffer
GLuint texId;
ovr_GetMirrorTextureBufferGL(m_hmdSession, m_mirrorTexture, &texId);
glGenFramebuffers(1, &m_mirrorFBO);
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_mirrorFBO);
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texId, 0);
glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
glDeleteFramebuffers(1, &m_mirrorFBO);
return false;
}
return true;
}
//------------------------------------------------------------------------------
bool cOVRDevice::initNonDistortMirror(int windowWidth, int windowHeight)
{
// we render per-eye only, so take only half of the target window width
windowWidth /= 2;
m_nonDistortViewPortWidth = windowWidth;
m_nonDistortViewPortHeight = windowHeight;
// Configure non-distorted frame buffer
glGenTextures(1, &m_nonDistortTexture);
glBindTexture(GL_TEXTURE_2D, m_nonDistortTexture);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, windowWidth, windowHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
// create depth buffer
glGenTextures(1, &m_nonDistortDepthBuffer);
glBindTexture(GL_TEXTURE_2D, m_nonDistortDepthBuffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
GLenum internalFormat = GL_DEPTH_COMPONENT24;
GLenum type = GL_UNSIGNED_INT;
glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, windowWidth, windowHeight, 0, GL_DEPTH_COMPONENT, type, NULL);
// create FBO for non-disortion mirror
glGenFramebuffers(1, &m_nonDistortFBO);
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_nonDistortFBO);
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_nonDistortTexture, 0);
glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
glDeleteFramebuffers(1, &m_nonDistortFBO);
return false;
}
return true;
}
//------------------------------------------------------------------------------
void cOVRDevice::destroyVR()
{
if (m_hmdSession)
{
if (glIsFramebuffer(m_mirrorFBO))
glDeleteFramebuffers(1, &m_mirrorFBO);
if (glIsFramebuffer(m_nonDistortFBO))
glDeleteFramebuffers(1, &m_nonDistortFBO);
if (glIsTexture(m_nonDistortTexture))
glDeleteTextures(1, &m_nonDistortTexture);
if (glIsTexture(m_nonDistortDepthBuffer))
glDeleteTextures(1, &m_nonDistortDepthBuffer);
ovr_DestroyMirrorTexture(m_hmdSession, m_mirrorTexture);
for (int eyeIdx = 0; eyeIdx < ovrEye_Count; eyeIdx++)
{
m_eyeBuffers[eyeIdx]->destroy(m_hmdSession);
delete m_eyeBuffers[eyeIdx];
m_eyeBuffers[eyeIdx] = nullptr;
}
}
}
//------------------------------------------------------------------------------
const ovrSizei cOVRDevice::getResolution() const
{
ovrSizei resolution = { m_hmdDesc.Resolution.w, m_hmdDesc.Resolution.h };
return resolution;
}
//------------------------------------------------------------------------------
void cOVRDevice::onRenderStart()
{
m_hmdToEyeOffset[0] = m_eyeRenderDesc[0].HmdToEyeOffset;
m_hmdToEyeOffset[1] = m_eyeRenderDesc[1].HmdToEyeOffset;
// this data is fetched only for the debug display, no need to do this to just get the rendering work
m_frameTiming = ovr_GetPredictedDisplayTime(m_hmdSession, 0);
m_trackingState = ovr_GetTrackingState(m_hmdSession, m_frameTiming, ovrTrue);
// Get both eye poses simultaneously, with IPD offset already included.
ovr_GetEyePoses(m_hmdSession, m_frameIndex, ovrTrue, m_hmdToEyeOffset, m_eyeRenderPose, &m_sensorSampleTime);
}
//------------------------------------------------------------------------------
const OVR::Matrix4f cOVRDevice::onEyeRender(int eyeIndex)
{
// set the current eye texture in swap chain
int curIndex;
ovr_GetTextureSwapChainCurrentIndex(m_hmdSession, m_eyeBuffers[eyeIndex]->m_swapTextureChain, &curIndex);
ovr_GetTextureSwapChainBufferGL(m_hmdSession, m_eyeBuffers[eyeIndex]->m_swapTextureChain, curIndex, &m_eyeBuffers[eyeIndex]->m_eyeTexId);
if (m_msaaEnabled)
m_eyeBuffers[eyeIndex]->onRenderMSAA();
else
m_eyeBuffers[eyeIndex]->onRender();
m_projectionMatrix[eyeIndex] = OVR::Matrix4f(ovrMatrix4f_Projection(m_eyeRenderDesc[eyeIndex].Fov, 0.01f, 10000.0f, ovrProjection_None));
m_eyeOrientation[eyeIndex] = OVR::Matrix4f(OVR::Quatf(m_eyeRenderPose[eyeIndex].Orientation).Inverted());
m_eyePose[eyeIndex] = OVR::Matrix4f::Translation(-OVR::Vector3f(m_eyeRenderPose[eyeIndex].Position));
return m_projectionMatrix[eyeIndex] * m_eyeOrientation[eyeIndex] * m_eyePose[eyeIndex];
}
//------------------------------------------------------------------------------
void cOVRDevice::onEyeRender(int eyeIndex, cTransform& a_projectionMatrix, cTransform& a_modelViewMatrix)
{
// set the current eye texture in swap chain
int curIndex;
ovr_GetTextureSwapChainCurrentIndex(m_hmdSession, m_eyeBuffers[eyeIndex]->m_swapTextureChain, &curIndex);
ovr_GetTextureSwapChainBufferGL(m_hmdSession, m_eyeBuffers[eyeIndex]->m_swapTextureChain, curIndex, &m_eyeBuffers[eyeIndex]->m_eyeTexId);
if (m_msaaEnabled)
m_eyeBuffers[eyeIndex]->onRenderMSAA();
else
m_eyeBuffers[eyeIndex]->onRender();
m_projectionMatrix[eyeIndex] = OVR::Matrix4f(ovrMatrix4f_Projection(m_eyeRenderDesc[eyeIndex].Fov, 0.001f, 1000.0f, ovrProjection_None));
m_eyeViewOffset[eyeIndex] = OVR::Matrix4f::Translation(OVR::Vector3f(m_hmdToEyeOffset[eyeIndex]));
m_eyeOrientation[eyeIndex] = OVR::Matrix4f(OVR::Quatf(m_eyeRenderPose[eyeIndex].Orientation).Inverted());
m_eyePose[eyeIndex] = OVR::Matrix4f::Translation(-OVR::Vector3f(m_eyeRenderPose[eyeIndex].Position));
a_projectionMatrix = cOVRConvert(m_projectionMatrix[eyeIndex]);
a_modelViewMatrix = cOVRConvert(m_eyeOrientation[eyeIndex] * m_eyePose[eyeIndex]);
//a_modelViewMatrix = cOVRConvert(m_eyePose[eyeIndex] * m_eyeOrientation[eyeIndex] * m_eyeViewOffset[eyeIndex]);
}
//------------------------------------------------------------------------------
void cOVRDevice::onEyeRenderFinish(int eyeIndex)
{
if (m_msaaEnabled)
m_eyeBuffers[eyeIndex]->onRenderMSAAFinish();
else
m_eyeBuffers[eyeIndex]->onRenderFinish();
ovr_CommitTextureSwapChain(m_hmdSession, m_eyeBuffers[eyeIndex]->m_swapTextureChain);
}
//------------------------------------------------------------------------------
const OVR::Matrix4f cOVRDevice::getEyeMVPMatrix(int eyeIndex) const
{
return m_projectionMatrix[eyeIndex] * m_eyeViewOffset[eyeIndex] * m_eyeOrientation[eyeIndex] * m_eyePose[eyeIndex];
}
//------------------------------------------------------------------------------
void cOVRDevice::submitFrame()
{
// set up positional data
ovrViewScaleDesc viewScaleDesc;
viewScaleDesc.HmdSpaceToWorldScaleInMeters = 1.0f;
viewScaleDesc.HmdToEyeOffset[0] = m_hmdToEyeOffset[0];
viewScaleDesc.HmdToEyeOffset[1] = m_hmdToEyeOffset[1];
// create the main eye layer
ovrLayerEyeFov eyeLayer;
eyeLayer.Header.Type = ovrLayerType_EyeFov;
eyeLayer.Header.Flags = ovrLayerFlag_TextureOriginAtBottomLeft; // Because OpenGL.
for (int eye = 0; eye < ovrEye_Count; eye++)
{
eyeLayer.ColorTexture[eye] = m_eyeBuffers[eye]->m_swapTextureChain;
eyeLayer.Viewport[eye] = OVR::Recti(m_eyeBuffers[eye]->m_eyeTextureSize);
eyeLayer.Fov[eye] = m_hmdDesc.DefaultEyeFov[eye];
eyeLayer.RenderPose[eye] = m_eyeRenderPose[eye];
eyeLayer.SensorSampleTime = m_sensorSampleTime;
}
// append all the layers to global list
ovrLayerHeader* layerList = &eyeLayer.Header;
ovrResult result = ovr_SubmitFrame(m_hmdSession, m_frameIndex, nullptr, &layerList, 1);
}
//------------------------------------------------------------------------------
void cOVRDevice::blitMirror(ovrEyeType numEyes, int offset)
{
// Blit mirror texture to back buffer
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_mirrorFBO);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
GLint w = m_mirrorDesc.Width;
GLint h = m_mirrorDesc.Height;
switch (numEyes)
{
case ovrEye_Count:
glBlitFramebuffer(0, h, w, 0, 0, 0, w, h, GL_COLOR_BUFFER_BIT, GL_NEAREST);
break;
case ovrEye_Left:
glBlitFramebuffer(0, h, w / 2, 0, offset, 0, w / 2 + offset, h, GL_COLOR_BUFFER_BIT, GL_NEAREST);
break;
case ovrEye_Right:
glBlitFramebuffer(w / 2, h, w, 0, offset, 0, w / 2 + offset, h, GL_COLOR_BUFFER_BIT, GL_NEAREST);
break;
default:
break;
}
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
}
//------------------------------------------------------------------------------
void cOVRDevice::onNonDistortMirrorStart()
{
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_nonDistortFBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_nonDistortTexture, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_nonDistortDepthBuffer, 0);
glViewport(0, 0, m_nonDistortViewPortWidth, m_nonDistortViewPortHeight);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
//------------------------------------------------------------------------------
void cOVRDevice::blitNonDistortMirror(int offset)
{
// Blit non distorted mirror to backbuffer
glBindFramebuffer(GL_READ_FRAMEBUFFER, m_nonDistortFBO);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
GLint dstX = 0 + offset;
GLint dstW = m_nonDistortViewPortWidth + offset;
glBlitFramebuffer(0, 0, m_nonDistortViewPortWidth, m_nonDistortViewPortHeight, dstX, 0, dstW, m_nonDistortViewPortHeight, GL_COLOR_BUFFER_BIT, GL_NEAREST);
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
}
//------------------------------------------------------------------------------
void cOVRDevice::renderTrackerFrustum()
{
}
//------------------------------------------------------------------------------
void cOVRDevice::showPerfStats(ovrPerfHudMode statsMode)
{
if (!isDebugHMD())
{
ovr_SetInt(m_hmdSession, "PerfHudMode", (int)statsMode);
}
else
{
}
}
//------------------------------------------------------------------------------
} // namespace chai3d
//------------------------------------------------------------------------------
|
/* Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of NVIDIA CORPORATION nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "whoop.hpp"
//An output-stationary inner product
int main(int argc, char** argv)
{
using namespace whoop;
int kTileWidth = 8;
int kTileHeight = 2;
int kTileDepth = 4;
int kOuterTileNumAcross = 2;
int kOuterTileNumDown = 8;
whoop::AddOption(&kTileWidth, "tile_width,w", "Width of the L0 tile.");
whoop::AddOption(&kTileHeight, "tile_height,h", "Height of the L0 tile.");
whoop::AddOption(&kTileDepth, "tile_depth,d", "Depth of the L0 tile.");
whoop::AddOption(&kOuterTileNumAcross, "outer_num_across,x", "Number of L0 tiles across an L1 tile.");
whoop::AddOption(&kOuterTileNumDown, "outer_num_down,y", "Number of L0 tiles down an L1 tile.");
TensorIn input_a("input_a");
TensorIn input_b("input_b");
TensorOut outputs("outputs");
whoop::Init(argc, argv);
int kInputAWidth = input_a.Size(0); // K
int kInputBWidth = input_b.Size(0); // N
int kInputAHeight = input_a.Size(1); // M
int kInputBHeight = input_b.Size(1); // K
const int kOutputWidth = kInputBWidth;
const int kOutputHeight = kInputAHeight;
outputs.Resize({kOutputHeight, kOutputWidth});
whoop::T(0) << "Input A Width: " << kInputAWidth << whoop::EndT;
whoop::T(0) << "Input A Height: " << kInputAHeight << whoop::EndT;
whoop::T(0) << "Input B Width: " << kInputBWidth << whoop::EndT;
whoop::T(0) << "Input B Height: " << kInputBHeight << whoop::EndT;
whoop::T(0) << "Output Width: " << kOutputWidth << whoop::EndT;
whoop::T(0) << "Output Height: " << kOutputHeight << whoop::EndT;
whoop::T(0) << "Inner Tile Width: " << kTileWidth << whoop::EndT;
whoop::T(0) << "Inner Tile Height: " << kTileHeight << whoop::EndT;
whoop::T(0) << "Inner Tile Depth: " << kTileDepth << whoop::EndT;
whoop::T(0) << "Num Inner Tiles Across: " << kInputBWidth / kTileWidth << whoop::EndT;
whoop::T(0) << "Num Inner Tiles Down: " << kInputAHeight / kTileHeight << whoop::EndT;
whoop::T(0) << "Num Inner Tiles Back: " << kInputBHeight / kTileDepth << whoop::EndT;
whoop::T(0) << "Outer Tile Num L0 Across: " << kOuterTileNumAcross << whoop::EndT;
whoop::T(0) << "Outer Tile Num L0 Down: " << kOuterTileNumDown << whoop::EndT;
whoop::T(0) << "Outer Tile Total Width: " << kOuterTileNumAcross * kTileWidth << whoop::EndT;
whoop::T(0) << "Outer Tile Total Height: " << kOuterTileNumDown * kTileHeight << whoop::EndT;
whoop::T(0) << "Num Outer Tiles Across: " << kInputBWidth / (kOuterTileNumAcross * kTileWidth) << whoop::EndT;
whoop::T(0) << "Num Outer Tiles Down: " << kInputAHeight / (kOuterTileNumDown * kTileHeight) << whoop::EndT;
whoop::T(0) << whoop::EndT;
whoop::ASSERT(kInputAWidth == kInputBHeight) << "The width of Matrix A must equal the height of Matrix B. A width: " << kInputAWidth << ", B height: " << kInputBHeight << whoop::EndT;
whoop::ASSERT(kInputBWidth % (kOuterTileNumAcross * kTileWidth) == 0) << "The width of the tile must equally divide the width of matrix B. B width: " << kInputBWidth << ", tile width: " << kTileWidth << whoop::EndT;
whoop::ASSERT(kInputAHeight % (kOuterTileNumDown * kTileHeight) == 0) << "The height of the tile must equally divide the height of matrix A. A height: " << kInputAHeight << ", tile height: " << kTileHeight << whoop::EndT;
whoop::ASSERT(kInputBHeight % kTileDepth == 0) << "The depth of the tile must equally divide the height of matrix B (and width of A). B height: " << kInputBHeight << ", tile depth: " << kTileDepth << whoop::EndT;
// Short-form variable names
const int M = kInputAHeight;
const int K = kInputAWidth;
const int N = kInputBWidth;
const int M1 = kOuterTileNumDown;
const int N1 = kOuterTileNumAcross;
const int M0 = kTileHeight;
const int K0 = kTileDepth;
const int N0 = kTileWidth;
const int M2 = M / (M1 * M0);
const int K1 = K / K0;
const int N2 = N / (N1 * N0);
whoop::T(0) << "====== Buffer Entries ======" << whoop::EndT;
whoop::T(0) << "L0:" << whoop::EndT;
whoop::T(0) << " Input A: 1" << whoop::EndT;
whoop::T(0) << " Input B: " << N0 << whoop::EndT;
whoop::T(0) << " Output: " << M0*N0 << whoop::EndT;
whoop::T(0) << " Total: " << M0*N0+N0+1 << whoop::EndT;
whoop::T(0) << "L1:" << whoop::EndT;
whoop::T(0) << " Input A: " << M0*K0 << whoop::EndT;
whoop::T(0) << " Input B: " << N1*K0*N0 << whoop::EndT;
whoop::T(0) << " Output: " << M1*M0*N1*N0 << whoop::EndT;
whoop::T(0) << " Total: " << M1*M0*N1*N0+N1*K0*N0+M0*K0 << whoop::EndT;
Var m("m");
Var k("k");
Var n("n");
Var m2("m2");
Var n2("n2");
Var m1("m1");
Var k1("k1");
Var n1("n1");
Var m0("m0");
Var k0("k0");
Var n0("n0");
t_for(m2, 0, M2);
{
t_for(n2, 0, N2);
{
t_for(k1, 0, K1);
{
// Output-stationary, row-major
input_a.AddTileLevel(M0*K0); // Reloaded N2 times from offchip
input_b.AddTileLevel(N1*K0*N0); // Reloaded M2 times from offchip
outputs.AddTileLevel(M1*N1*M0*N0); // Never reloaded (output stationary)
t_for(m1, 0, M1);
{
s_for(n1, 0, N1);
{
t_for(k0, 0, K0);
{
// A-stationary, col-major L0.
input_b.AddTileLevel(N0);
k = k1 * K0 + k0;
s_for(m0, 0, M0);
{
input_a.AddTileLevel(1);
outputs.AddTileLevel(N0);
m = m2 * M1 * M0 + m1 * M0 + m0;
t_for(n0, 0, N0);
{
n = n2 * N1 * N0 + n1 * N0 + n0;
outputs[m][n] += input_a[m][k] * input_b[k][n];
}
end();
}
end();
}
end();
}
end();
}
end();
}
end();
}
end();
}
end();
whoop::T(0) << "RUNNING..." << whoop::EndT;
whoop::Run();
whoop::Done();
}
|
/**********************************************************************
* File: tface.cpp (Formerly tface.c)
* Description: C side of the Tess/tessedit C/C++ interface.
* Author: Ray Smith
*
* (C) Copyright 1992, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#include "callcpp.h"
#include "chop.h"
#include "globals.h"
#include "pageres.h"
#include "wordrec.h"
#include "featdefs.h"
#include "params_model.h"
#include <cmath>
namespace tesseract {
/**
* @name program_editup
*
* Initialize all the things in the program that need to be initialized.
* init_permute determines whether to initialize the permute functions
* and Dawg models.
*/
void Wordrec::program_editup(const char *textbase,
TessdataManager *init_classifier,
TessdataManager *init_dict) {
if (textbase != nullptr) imagefile = textbase;
#ifndef DISABLED_LEGACY_ENGINE
InitFeatureDefs(&feature_defs_);
InitAdaptiveClassifier(init_classifier);
if (init_dict) {
getDict().SetupForLoad(Dict::GlobalDawgCache());
getDict().Load(lang, init_dict);
getDict().FinishLoad();
}
pass2_ok_split = chop_ok_split;
#endif // ndef DISABLED_LEGACY_ENGINE
}
/**
* @name end_recog
*
* Cleanup and exit the recog program.
*/
int Wordrec::end_recog() {
program_editdown (0);
return (0);
}
/**
* @name program_editdown
*
* This function holds any necessary post processing for the Wise Owl
* program.
*/
void Wordrec::program_editdown(int32_t elasped_time) {
#ifndef DISABLED_LEGACY_ENGINE
EndAdaptiveClassifier();
#endif // ndef DISABLED_LEGACY_ENGINE
getDict().End();
}
#ifndef DISABLED_LEGACY_ENGINE
/**
* @name set_pass1
*
* Get ready to do some pass 1 stuff.
*/
void Wordrec::set_pass1() {
chop_ok_split.set_value(70.0);
language_model_->getParamsModel().SetPass(ParamsModel::PTRAIN_PASS1);
SettupPass1();
}
/**
* @name set_pass2
*
* Get ready to do some pass 2 stuff.
*/
void Wordrec::set_pass2() {
chop_ok_split.set_value(pass2_ok_split);
language_model_->getParamsModel().SetPass(ParamsModel::PTRAIN_PASS2);
SettupPass2();
}
/**
* @name cc_recog
*
* Recognize a word.
*/
void Wordrec::cc_recog(WERD_RES *word) {
getDict().reset_hyphen_vars(word->word->flag(W_EOL));
chop_word_main(word);
word->DebugWordChoices(getDict().stopper_debug_level >= 1,
getDict().word_to_debug.string());
ASSERT_HOST(word->StatesAllValid());
}
#endif // ndef DISABLED_LEGACY_ENGINE
/**
* @name dict_word()
*
* Test the dictionaries, returning NO_PERM (0) if not found, or one
* of the PermuterType values if found, according to the dictionary.
*/
int Wordrec::dict_word(const WERD_CHOICE &word) {
return getDict().valid_word(word);
}
#ifndef DISABLED_LEGACY_ENGINE
/**
* @name call_matcher
*
* Called from Tess with a blob in tess form.
* The blob may need rotating to the correct orientation for classification.
*/
BLOB_CHOICE_LIST *Wordrec::call_matcher(TBLOB *tessblob) {
// Rotate the blob for classification if necessary.
TBLOB* rotated_blob = tessblob->ClassifyNormalizeIfNeeded();
if (rotated_blob == nullptr) {
rotated_blob = tessblob;
}
BLOB_CHOICE_LIST *ratings = new BLOB_CHOICE_LIST(); // matcher result
AdaptiveClassifier(rotated_blob, ratings);
if (rotated_blob != tessblob) {
delete rotated_blob;
}
return ratings;
}
#endif // ndef DISABLED_LEGACY_ENGINE
} // namespace tesseract
|
/*
* Linked List implentation in C++
*/
#include <iostream>
using namespace std;
struct node {
int data;
node *next;
};
class Linked_list {
private:
node *head, *tail;
unsigned int size;
public:
Linked_list() {
head = NULL;
tail = NULL;
size = 0;
}
void insert(int n) {
node * tmp = new node;
tmp -> data = n;
tmp -> next = NULL;
if(head == NULL) {
head = tmp;
tail = tmp;
}else{
tail->next =tmp;
tail = tail->next;
}
size++;
}
unsigned int count() const {
return size;
}
bool insertAt(unsigned int index, int value) {
if(index > size)
return false;
size++;
// Insert at the end of the list
if(index == size){
insert(value);
return true;
}
node * tmp = new node;
tmp -> data = value;
tmp -> next = NULL;
// Insert at the begining of the list
if(index == 0){
tmp -> next = head;
head = tmp;
return true;
}
// Insert in between list
unsigned int current_index = 0;
node *temp = head;
while(temp){
if(current_index == index - 1){
tmp -> next = temp -> next;
temp -> next = tmp;
return true;;
}
temp = temp -> next;
current_index++;
}
return true;
}
bool remove(unsigned int index) {
if(index >= size){
return false;
}
node * prev = NULL;
node * curr = head;
unsigned int curr_index = 0;
while(curr){
if(curr_index == index){
if(prev == NULL){
head = head -> next;
}
else {
prev -> next = curr -> next;
}
delete curr;
curr = NULL;
size--;
return true;
}
prev = curr;
curr = curr->next;
curr_index++;
}
return false;
}
void display() {
node *tmp;
tmp = head;
while(tmp != NULL) {
cout << tmp -> data << " ";
tmp = tmp -> next;
}
}
void clear(){
while(head){
node * curr = head;
head = head -> next;
delete curr;
curr = NULL;
--size;
}
head = NULL;
}
void reverse()
{
node *aux, *current=head, *previous=NULL;
while(current!=NULL)
{
aux=current->next;
current->next=previous;
previous=current;
current=aux;
}
aux=tail;
tail=head;
head=aux;
}
~Linked_list(){
// This is a destructor for Linked list class.
// This will be called when a stack allocated object of this class will go out of scope.
// Or when a heap allocated object of this class is deleted.
// This will release all allocated memory.
clear();
}
};
int main() {
Linked_list list;
list.insert(1);
list.insert(2);
list.insert(3);
list.insert(4);
list.insert(5);
cout << "\nThe linked list is: " << endl;
list.display();
cout << "\nSize of the list: " << list.count();
cout << "\nThe linked list after reverse() is: " << endl;
list.reverse();
list.display();
list.reverse();
list.insertAt(1, 5);
cout<< "\nThe linked list after insertAt(2,5)" << endl;
list.display();
cout << "\nSize of the list: " << list.count();
list.remove(1);
cout<< "\nThe linked list after remove(1)" << endl;
list.display();
cout << "\nSize of the list: " << list.count();
list.clear();
cout << "\nSize of the list after clear(): " << list.count() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int binaryToDecimal(int n){
int temp = 1,ans = 0,lastdigit;
while(n > 0){
lastdigit = n % 10;
ans = ans + temp*lastdigit;
temp = temp*2;
n= n/10;
}
return ans;
}
int octalToDecimal(int n){
int sum = 0,temp = 1,lastdigit;
while (n > 0)
{
lastdigit = n % 10;
sum = sum + temp * lastdigit;
temp = temp * 8;
n = n/10;
}
return sum ;
}
int hexaToDecimal(string n){
int base=1,sum = 0;
int size = n.size();
for(int i = size - 1; i >= 0;i--){
if(n[i] >= '0' && n[i] <= '9'){
sum = sum + base *(n[i]-'0');
}
else if(n[i] >= 'A' && n[i] <= 'F'){
sum = sum + base *(n[i] - 'A' + 10);
}
base *= 16;
}
return sum;
}
int decimalToBinary(int n){
int sum = 0,base = 1;
while(n >= base){
base = base *2;
}
base = base / 2;
while(base > 0){
int lastdigit = n/base;
n = n - base*lastdigit;
sum = sum*10 + lastdigit;
base = base/2;
}
return sum ;
}
int decimalToOctal(int n){
int sum = 0,base = 1,lastdigit;
while(n>=base){
base *= 8;
}
base/=8;
while(base > 0){
lastdigit = n/base;
n -= base*lastdigit;
sum = sum *10 + lastdigit;
base /= 8;
}
return sum;
}
string decimalToHexa(int n){
string sum = "";
int base = 1,lastdigit;
while( n >= base){
base*=16;
}
base/=16;
while(base > 0){
lastdigit = n/base;
n -= lastdigit*base;
base/=16;
if( lastdigit <= 9){
sum = sum + to_string(lastdigit);
}
else{
char c = 'A' + lastdigit-10;
sum.push_back(c);
}
}
return sum;
}
int main(){
int n;
string s;
cin >> n;
cin >> s;
cout << "Binary To Decimal:" << binaryToDecimal(n) << endl;
cout << "Octal To Decimal:" << octalToDecimal(n) << endl;
cout << "Hexa To Decimal:" << hexaToDecimal(s) << endl;
cout << "Decimal To Binary:" << decimalToBinary(n) << endl;
cout << "Decimal To Octal:" << decimalToOctal(n) << endl;
cout << "Decimal To Hexa:" << decimalToHexa(n) << endl;
return 0;
}
|
#include <examples/zurg/slave/Heartbeat.h>
#include <examples/zurg/slave/SlaveConfig.h>
#include <examples/zurg/proto/master.pb.h>
#include <muduo/protorpc2/rpc2.pb.h>
#include <muduo/base/FileUtil.h>
#include <muduo/base/Logging.h>
#include <muduo/base/ProcessInfo.h>
#include <muduo/base/Timestamp.h>
#include <muduo/net/EventLoop.h>
#include <algorithm>
#include <sys/utsname.h>
namespace zurg
{
void ignoreCallback(const ::rpc2::EmptyPtr&)
{
}
// unique_ptr is better
typedef std::shared_ptr<muduo::FileUtil::ReadSmallFile> SmallFilePtr;
class ProcFs : muduo::noncopyable
{
public:
typedef std::map<muduo::StringPiece, SmallFilePtr> FileMap;
// char* to save construction of string.
int readTo(const char* filename, std::string* out)
{
FileMap::iterator it = files_.find(filename);
if (it == files_.end())
{
SmallFilePtr ptr(new muduo::FileUtil::ReadSmallFile(filename));
it = files_.insert(std::make_pair(filename, ptr)).first;
}
assert (it != files_.end());
int size = 0;
int err = it->second->readToBuffer(&size);
LOG_TRACE << filename << " " << err << " " << size;
if (size > 0)
{
out->assign(it->second->buffer(), size);
}
return err;
}
private:
FileMap files_;
};
void strip_cpuinfo(std::string* cpuinfo)
{
// FIXME:
}
void fill_uname(SlaveHeartbeat* hb)
{
struct utsname buf;
if (::uname(&buf) == 0)
{
SlaveHeartbeat::Uname* p = hb->mutable_uname();
p->set_sysname(buf.sysname);
p->set_nodename(buf.nodename);
p->set_release(buf.release);
p->set_version(buf.version);
p->set_machine(buf.machine);
p->set_domainname(buf.domainname);
}
else
{
LOG_SYSERR << "uname";
}
}
void strip_diskstats(std::string* diskstats)
{
std::string result;
result.reserve(diskstats->size());
muduo::StringPiece zeros(" 0 0 0 0 0 0 0 0 0 0 0\n");
const char* p = diskstats->c_str();
const char* nl = NULL;
while ( (nl = ::strchr(p, '\n')) != NULL)
{
int pos = static_cast<int>(nl - p + 1);
muduo::StringPiece line(p, pos);
if (line.size() > zeros.size())
{
muduo::StringPiece end(line.data() + line.size()-zeros.size(), zeros.size());
if (end != zeros)
{
result.append(line.data(), line.size());
}
}
p += pos;
}
assert(p == &*diskstats->end());
diskstats->swap(result);
}
struct AreBothSpaces
{
bool operator()(char x, char y) const
{
return x == ' ' && y == ' ';
}
};
void strip_meminfo(std::string* meminfo)
{
std::string::iterator it = std::unique(meminfo->begin(), meminfo->end(), AreBothSpaces());
meminfo->erase(it, meminfo->end());
}
void strip_stat(std::string* proc_stat)
{
const char* intr = ::strstr(proc_stat->c_str(), "\nintr ");
if (intr != NULL)
{
const char* nl = ::strchr(intr + 1, '\n');
assert(nl != NULL);
muduo::StringPiece line(intr+1, static_cast<int>(nl-intr-1));
const char* p = nl;
while (p[-1] == '0' && p[-2] == ' ')
{
p -= 2;
}
++p;
proc_stat->erase(p - proc_stat->c_str(), nl-p);
}
}
}
extern const char* slave_version;
using namespace zurg;
using namespace muduo;
using namespace muduo::net;
Heartbeat::Heartbeat(muduo::net::EventLoop* loop,
const SlaveConfig& config,
MasterService_Stub* stub)
: loop_(loop),
name_(config.name_),
port_(config.listenPort_),
stub_(stub),
procFs_(new ProcFs),
beating_(false)
{
loop_->runEvery(config.heartbeatInterval_, std::bind(&Heartbeat::onTimer, this));
}
Heartbeat::~Heartbeat()
{
}
void Heartbeat::start()
{
beating_ = true;
beat(true);
}
void Heartbeat::stop()
{
beating_ = false;
}
void Heartbeat::onTimer()
{
if (beating_)
{
beat(false);
}
}
#define FILL_HB(PROC_FILE, FIELD) \
if (procFs_->readTo(PROC_FILE, hb.mutable_##FIELD()) != 0) \
hb.clear_##FIELD();
void Heartbeat::beat(bool showStatic)
{
LOG_DEBUG << (showStatic ? "full" : "");
SlaveHeartbeat hb;
hb.set_slave_name(name_);
if (showStatic)
{
hb.set_host_name(ProcessInfo::hostname().c_str());
if (port_ > 0)
{
hb.set_listen_port(port_);
}
hb.set_slave_pid(ProcessInfo::pid());
hb.set_start_time_us(ProcessInfo::startTime().microSecondsSinceEpoch());
hb.set_slave_version(slave_version);
FILL_HB("/proc/cpuinfo", cpuinfo);
FILL_HB("/proc/version", version);
FILL_HB("/etc/mtab", etc_mtab);
strip_cpuinfo(hb.mutable_cpuinfo());
// sysctl
fill_uname(&hb);
}
hb.set_send_time_us(Timestamp::now().microSecondsSinceEpoch());
FILL_HB("/proc/meminfo", meminfo);
FILL_HB("/proc/stat", proc_stat);
FILL_HB("/proc/loadavg", loadavg);
FILL_HB("/proc/diskstats", diskstats);
FILL_HB("/proc/net/dev", net_dev);
FILL_HB("/proc/net/tcp", net_tcp);
strip_diskstats(hb.mutable_diskstats());
strip_meminfo(hb.mutable_meminfo());
strip_stat(hb.mutable_proc_stat());
stub_->slaveHeartbeat(hb, ignoreCallback);
}
|
/*=========================================================================
Program: ParaView
Module: $RCSfile$
Copyright (c) Kitware, Inc.
All rights reserved.
See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "vtkPVWebApplication.h"
#include "vtkBase64Utilities.h"
#include "vtkCamera.h"
#include "vtkCommand.h"
#include "vtkDataEncoder.h"
#include "vtkImageData.h"
#include "vtkJPEGWriter.h"
#include "vtkNew.h"
#include "vtkObjectFactory.h"
#include "vtkPNGWriter.h"
#include "vtkPVRenderView.h"
#include "vtkPointData.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRendererCollection.h"
#include "vtkSMContextViewProxy.h"
#include "vtkSMPropertyHelper.h"
#include "vtkSMRenderViewProxy.h"
#include "vtkSMViewProxy.h"
#include "vtkSmartPointer.h"
#include "vtkTimerLog.h"
#include "vtkUnsignedCharArray.h"
#include "vtkWebGLExporter.h"
#include "vtkWebGLObject.h"
#include "vtkWebInteractionEvent.h"
#include <cassert>
#include <cmath>
#include <map>
class vtkPVWebApplication::vtkInternals
{
public:
struct ImageCacheValueType
{
public:
vtkSmartPointer<vtkUnsignedCharArray> Data;
bool NeedsRender;
bool HasImagesBeingProcessed;
vtkObject* ViewPointer;
unsigned long ObserverId;
ImageCacheValueType()
: NeedsRender(true)
, HasImagesBeingProcessed(false)
, ViewPointer(nullptr)
, ObserverId(0)
{
}
void SetListener(vtkObject* view)
{
if (this->ViewPointer == view)
{
return;
}
if (this->ViewPointer && this->ObserverId)
{
this->ViewPointer->RemoveObserver(this->ObserverId);
this->ObserverId = 0;
}
this->ViewPointer = view;
if (this->ViewPointer)
{
this->ObserverId = this->ViewPointer->AddObserver(
vtkCommand::AnyEvent, this, &ImageCacheValueType::ViewEventListener);
}
}
void RemoveListener(vtkObject* view)
{
if (this->ViewPointer && this->ViewPointer == view && this->ObserverId)
{
this->ViewPointer->RemoveObserver(this->ObserverId);
this->ObserverId = 0;
this->ViewPointer = nullptr;
}
}
void ViewEventListener(vtkObject*, unsigned long, void*) { this->NeedsRender = true; }
};
typedef std::map<void*, ImageCacheValueType> ImageCacheType;
ImageCacheType ImageCache;
typedef std::map<void*, unsigned int> ButtonStatesType;
ButtonStatesType ButtonStates;
vtkNew<vtkDataEncoder> Encoder;
// WebGL related struct
struct WebGLObjCacheValue
{
public:
int ObjIndex;
std::map<int, std::string> BinaryParts;
};
// map for <vtkWebGLExporter, <webgl-objID, WebGLObjCacheValue> >
typedef std::map<std::string, WebGLObjCacheValue> WebGLObjId2IndexMap;
std::map<vtkWebGLExporter*, WebGLObjId2IndexMap> WebGLExporterObjIdMap;
// map for <vtkSMViewProxy, vtkWebGLExporter>
std::map<vtkSMViewProxy*, vtkSmartPointer<vtkWebGLExporter>> ViewWebGLMap;
std::string LastAllWebGLBinaryObjects;
};
vtkStandardNewMacro(vtkPVWebApplication);
//----------------------------------------------------------------------------
vtkPVWebApplication::vtkPVWebApplication()
: ImageEncoding(ENCODING_BASE64)
, ImageCompression(COMPRESSION_JPEG)
, Internals(new vtkPVWebApplication::vtkInternals())
{
}
//----------------------------------------------------------------------------
vtkPVWebApplication::~vtkPVWebApplication()
{
delete this->Internals;
this->Internals = nullptr;
}
//----------------------------------------------------------------------------
bool vtkPVWebApplication::GetHasImagesBeingProcessed(vtkSMViewProxy* view)
{
const vtkInternals::ImageCacheValueType& value = this->Internals->ImageCache[view];
return value.HasImagesBeingProcessed;
}
//----------------------------------------------------------------------------
vtkUnsignedCharArray* vtkPVWebApplication::InteractiveRender(vtkSMViewProxy* view, int quality)
{
// for now, just do the same as StillRender().
return this->StillRender(view, quality);
}
//----------------------------------------------------------------------------
void vtkPVWebApplication::InvalidateCache(vtkSMViewProxy* view)
{
this->Internals->ImageCache[view].NeedsRender = true;
}
//----------------------------------------------------------------------------
vtkUnsignedCharArray* vtkPVWebApplication::StillRender(vtkSMViewProxy* view, int quality)
{
if (!view)
{
vtkErrorMacro("No view specified.");
return nullptr;
}
// threading can be tricky to debug -
bool doThread = true;
vtkInternals::ImageCacheValueType& value = this->Internals->ImageCache[view];
value.SetListener(view);
if (value.NeedsRender == false && value.Data != nullptr && view->GetNeedsUpdate() == false)
{
// cout << "Reusing cache" << endl;
if (doThread)
{
bool latest = this->Internals->Encoder->GetLatestOutput(view->GetGlobalID(), value.Data);
value.HasImagesBeingProcessed = !latest;
}
else
{
value.HasImagesBeingProcessed = false;
}
return value.Data;
}
// cout << "Regenerating " << endl;
// vtkTimerLog::ResetLog();
// vtkTimerLog::CleanupLog();
// vtkTimerLog::MarkStartEvent("StillRenderToString");
// vtkTimerLog::MarkStartEvent("CaptureWindow");
// TODO: We should add logic to check if a new rendering needs to be done and
// then alone do a new rendering otherwise use the cached image.
vtkImageData* image = view->CaptureWindow(1);
image->GetDimensions(this->LastStillRenderImageSize);
// vtkTimerLog::MarkEndEvent("CaptureWindow");
// vtkTimerLog::MarkEndEvent("StillRenderToString");
// vtkTimerLog::DumpLogWithIndents(&cout, 0.0);
if (doThread || this->ImageEncoding)
{
this->Internals->Encoder->PushAndTakeReference(
view->GetGlobalID(), image, quality, this->ImageEncoding);
assert(image == nullptr);
if (value.Data == nullptr)
{
// we need to wait till output is processed.
// cout << "Flushing" << endl;
this->Internals->Encoder->Flush(view->GetGlobalID());
// cout << "Done Flushing" << endl;
}
bool latest = this->Internals->Encoder->GetLatestOutput(view->GetGlobalID(), value.Data);
value.HasImagesBeingProcessed = !latest;
}
else
{
vtkNew<vtkJPEGWriter> writer;
writer->WriteToMemoryOn();
writer->SetInputData(image);
writer->SetQuality(quality);
writer->Write();
// smart pointer does the right thing, even if Data was null
value.Data = writer->GetResult();
}
value.NeedsRender = false;
return value.Data;
}
//----------------------------------------------------------------------------
const char* vtkPVWebApplication::StillRenderToString(
vtkSMViewProxy* view, unsigned long time, int quality)
{
vtkUnsignedCharArray* array = this->StillRender(view, quality);
if (array && array->GetMTime() != time)
{
this->LastStillRenderToMTime = array->GetMTime();
// cout << "Image size: " << array->GetNumberOfTuples() << endl;
return reinterpret_cast<char*>(array->GetPointer(0));
}
return nullptr;
}
//----------------------------------------------------------------------------
vtkUnsignedCharArray* vtkPVWebApplication::StillRenderToBuffer(
vtkSMViewProxy* view, unsigned long time, int quality)
{
vtkUnsignedCharArray* array = this->StillRender(view, quality);
if (array && array->GetMTime() != time)
{
this->LastStillRenderToMTime = array->GetMTime();
return array;
}
return nullptr;
}
//----------------------------------------------------------------------------
bool vtkPVWebApplication::HandleInteractionEvent(
vtkSMViewProxy* view, vtkWebInteractionEvent* event)
{
vtkRenderWindowInteractor* iren = nullptr;
if (view->GetRenderWindow())
{
iren = view->GetRenderWindow()->GetInteractor();
}
else
{
vtkErrorMacro("Interaction not supported for view : " << view);
return false;
}
int viewSize[2];
vtkSMPropertyHelper(view, "ViewSize").Get(viewSize, 2);
int posX = std::floor(viewSize[0] * event->GetX() + 0.5);
int posY = std::floor(viewSize[1] * event->GetY() + 0.5);
int ctrlKey = (event->GetModifiers() & vtkWebInteractionEvent::CTRL_KEY) != 0 ? 1 : 0;
int shiftKey = (event->GetModifiers() & vtkWebInteractionEvent::SHIFT_KEY) != 0 ? 1 : 0;
iren->SetEventInformation(posX, posY, ctrlKey, shiftKey, event->GetKeyCode());
unsigned int prev_buttons = this->Internals->ButtonStates[view];
unsigned int changed_buttons = (event->GetButtons() ^ prev_buttons);
iren->MouseMoveEvent();
if ((changed_buttons & vtkWebInteractionEvent::LEFT_BUTTON) != 0)
{
if ((event->GetButtons() & vtkWebInteractionEvent::LEFT_BUTTON) != 0)
{
iren->LeftButtonPressEvent();
}
else
{
iren->LeftButtonReleaseEvent();
}
}
if ((changed_buttons & vtkWebInteractionEvent::RIGHT_BUTTON) != 0)
{
if ((event->GetButtons() & vtkWebInteractionEvent::RIGHT_BUTTON) != 0)
{
iren->RightButtonPressEvent();
}
else
{
iren->RightButtonReleaseEvent();
}
}
if ((changed_buttons & vtkWebInteractionEvent::MIDDLE_BUTTON) != 0)
{
if ((event->GetButtons() & vtkWebInteractionEvent::MIDDLE_BUTTON) != 0)
{
iren->MiddleButtonPressEvent();
}
else
{
iren->MiddleButtonReleaseEvent();
}
}
this->Internals->ButtonStates[view] = event->GetButtons();
bool needs_render = (changed_buttons != 0 || event->GetButtons());
this->Internals->ImageCache[view].NeedsRender = needs_render;
return needs_render;
}
// ---------------------------------------------------------------------------
const char* vtkPVWebApplication::GetWebGLSceneMetaData(vtkSMViewProxy* view)
{
if (!view)
{
vtkErrorMacro("No view specified.");
return nullptr;
}
vtkRenderWindow* renWin = view->GetRenderWindow();
vtkPVRenderView* pvRenderView = vtkPVRenderView::SafeDownCast(view->GetClientSideView());
if (renWin == nullptr || pvRenderView == nullptr)
{
vtkErrorMacro("The view is supported for WebGL export: " << view);
return nullptr;
}
// We use the camera focal point to be the center of rotation
double centerOfRotation[3];
vtkCamera* cam = pvRenderView->GetActiveCamera();
cam->GetFocalPoint(centerOfRotation);
if (this->Internals->ViewWebGLMap.find(view) == this->Internals->ViewWebGLMap.end())
{
this->Internals->ViewWebGLMap[view] = vtkSmartPointer<vtkWebGLExporter>::New();
}
vtkWebGLExporter* webglExporter = this->Internals->ViewWebGLMap[view];
webglExporter->parseScene(renWin->GetRenderers(), view->GetGlobalIDAsString(), VTK_PARSEALL);
vtkInternals::WebGLObjId2IndexMap webglMap;
for (int i = 0; i < webglExporter->GetNumberOfObjects(); ++i)
{
vtkWebGLObject* wObj = webglExporter->GetWebGLObject(i);
if (wObj && wObj->isVisible())
{
vtkInternals::WebGLObjCacheValue val;
val.ObjIndex = i;
for (int j = 0; j < wObj->GetNumberOfParts(); ++j)
{
val.BinaryParts[j] = "";
}
webglMap[wObj->GetId()] = val;
}
}
this->Internals->WebGLExporterObjIdMap[webglExporter] = webglMap;
webglExporter->SetCenterOfRotation(static_cast<float>(centerOfRotation[0]),
static_cast<float>(centerOfRotation[1]), static_cast<float>(centerOfRotation[2]));
return webglExporter->GenerateMetadata();
}
//----------------------------------------------------------------------------
const char* vtkPVWebApplication::GetWebGLBinaryData(vtkSMViewProxy* view, const char* id, int part)
{
if (!view)
{
vtkErrorMacro("No view specified.");
return nullptr;
}
if (this->Internals->ViewWebGLMap.find(view) == this->Internals->ViewWebGLMap.end())
{
if (this->GetWebGLSceneMetaData(view) == nullptr)
{
vtkErrorMacro("Failed to generate WebGL MetaData for: " << view);
return nullptr;
}
}
vtkWebGLExporter* webglExporter = this->Internals->ViewWebGLMap[view];
if (webglExporter == nullptr)
{
vtkErrorMacro("There is no cached WebGL Exporter for: " << view);
return nullptr;
}
if (!this->Internals->WebGLExporterObjIdMap[webglExporter].empty() &&
this->Internals->WebGLExporterObjIdMap[webglExporter].find(id) !=
this->Internals->WebGLExporterObjIdMap[webglExporter].end())
{
vtkInternals::WebGLObjCacheValue* cachedVal =
&(this->Internals->WebGLExporterObjIdMap[webglExporter][id]);
if (cachedVal->BinaryParts.find(part) != cachedVal->BinaryParts.end())
{
if (cachedVal->BinaryParts[part].empty())
{
vtkWebGLObject* obj = webglExporter->GetWebGLObject(cachedVal->ObjIndex);
if (obj && obj->isVisible())
{
// Manage Base64
vtkNew<vtkBase64Utilities> base64;
unsigned char* output = new unsigned char[obj->GetBinarySize(part) * 2];
int size =
base64->Encode(obj->GetBinaryData(part), obj->GetBinarySize(part), output, false);
cachedVal->BinaryParts[part] = std::string((const char*)output, size);
delete[] output;
}
}
return cachedVal->BinaryParts[part].c_str();
}
}
return nullptr;
}
//----------------------------------------------------------------------------
void vtkPVWebApplication::PrintSelf(ostream& os, vtkIndent indent)
{
this->Superclass::PrintSelf(os, indent);
os << indent << "ImageEncoding: " << this->ImageEncoding << endl;
os << indent << "ImageCompression: " << this->ImageCompression << endl;
}
|
/*
Image Blurring with Threads
Víctor Rendón Suárez
A01022462
*/
#include <iostream>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <chrono>
using namespace std;
#define SIZE 5
// Image blurring function, receives (Opencv mat, output)
void blur_image(const cv::Mat& input, cv::Mat& output)
{
cout << "Input image; step: " << input.step << " rows: " << input.rows << " cols: " << input.cols << endl;
int nBase = floor(SIZE/2.0);
int x, y;
#pragma omp parallel for collapse(2) private(x, y) shared(input, output)
// Iterate on image pixels
for (int y = 0; y < input.rows; y++) {
for (int x = 0; x < input.cols; x++) {
int red_avg = 0;
int green_avg = 0;
int blue_avg = 0;
int ct = 0;
// Handle surrounding pixels
for (int i = -nBase; i <= nBase; i++) {
for (int j = -nBase; j <= nBase; j++) {
int xn = x + j;
int yn = y + i;
// Handle borders
if ((xn > 0 && yn > 0) && (xn < input.cols && yn < input.rows)) {
ct++;
red_avg += input.at<cv::Vec3b>(yn,xn)[2];
green_avg += input.at<cv::Vec3b>(yn,xn)[1];
blue_avg += input.at<cv::Vec3b>(yn,xn)[0];
}
}
}
output.at<cv::Vec3b>(y,x)[2] = red_avg / ct;
output.at<cv::Vec3b>(y,x)[1] = green_avg / ct;
output.at<cv::Vec3b>(y,x)[0] = blue_avg / ct;
}
}
}
int main(int argc, char *argv[])
{
string input_image;
// Use default image if none specified in command
if (argc < 2)
input_image = "image.jpg";
else
input_image = argv[1];
cv::Mat input = cv::imread(input_image, CV_LOAD_IMAGE_COLOR);
if (input.empty()) {
cout << "Error: Specified image not found." << std::endl;
return -1;
}
// Output image
cv::Mat output(input.rows, input.cols, input.type());
// Blur image, measure time elapsed
auto start_time = std::chrono::high_resolution_clock::now();
blur_image(input, output);
auto end_time = std::chrono::high_resolution_clock::now();
chrono::duration<float, milli> duration_ms = end_time - start_time;
printf("Image blurring with threads, time elapsed: %f ms\n", duration_ms.count());
// Resize and show images
namedWindow("Input", cv::WINDOW_NORMAL);
namedWindow("Output", cv::WINDOW_NORMAL);
imshow("Input", input);
imshow("Output", output);
// Close with keypress
cv::waitKey();
return 0;
}
|
#ifndef SHARED_ENVIRONMENTMAPPING_ENVSTATE_HPP
#define SHARED_ENVIRONMENTMAPPING_ENVSTATE_HPP
/****************************************************************************************************************************************************
* Copyright (c) 2015 Freescale Semiconductor, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* * Neither the name of the Freescale Semiconductor, Inc. nor the names of
* its contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************************************************************************************/
#include <FslBase/BasicTypes.hpp>
#include <FslBase/Math/Point2.hpp>
#include <FslBase/Math/Matrix.hpp>
#include <FslBase/Math/Vector3.hpp>
#include <FslBase/Math/Vector4.hpp>
namespace Fsl
{
class EnvState
{
Point2 m_screenResolution;
float m_stepsPerCircle;
float m_time;
float m_timeStep;
public:
Vector3 Eye;
Vector3 LookAt;
Vector3 UpVec;
Vector3 EyeVector;
Matrix ViewMatrix;
Matrix ProjMatrix;
EnvState(const Point2& screenResolution);
~EnvState();
Point2 GetScreenResolution() const { return m_screenResolution; }
void Update(const float deltaTime);
//! @brief Extract the transformation matrix.
void ExtractTransform(Matrix& rMatrix);
};
}
#endif
|
/*
* This file is part of the CitizenFX project - http://citizen.re/
*
* See LICENSE and MENTIONS in the root of the source tree for information
* regarding licensing.
*/
#include "StdInc.h"
#include "ResourceUI.h"
#include <include/cef_origin_whitelist.h>
#include <NUISchemeHandlerFactory.h>
#include <ResourceMetaDataComponent.h>
#include <ResourceGameLifetimeEvents.h>
#include <ResourceManager.h>
#include <boost/algorithm/string/predicate.hpp>
#include <mutex>
ResourceUI::ResourceUI(Resource* resource)
: m_resource(resource), m_hasFrame(false), m_hasCallbacks(false)
{
}
ResourceUI::~ResourceUI()
{
}
bool ResourceUI::Create()
{
// initialize callback handlers
auto resourceName = m_resource->GetName();
std::transform(resourceName.begin(), resourceName.end(), resourceName.begin(), ::ToLower);
nui::RegisterSchemeHandlerFactory("http", resourceName, Instance<NUISchemeHandlerFactory>::Get());
nui::RegisterSchemeHandlerFactory("https", resourceName, Instance<NUISchemeHandlerFactory>::Get());
// get the metadata component
fwRefContainer<fx::ResourceMetaDataComponent> metaData = m_resource->GetComponent<fx::ResourceMetaDataComponent>();
// get the UI page list and a number of pages
auto uiPageData = metaData->GetEntries("ui_page");
int pageCount = std::distance(uiPageData.begin(), uiPageData.end());
// if no page exists, return
if (pageCount == 0)
{
return false;
}
// if more than one, warn
if (pageCount > 1)
{
trace(__FUNCTION__ ": more than one ui_page in resource %s\n", m_resource->GetName().c_str());
return false;
}
// mark us as having a frame
m_hasFrame = true;
// get the page name from the iterator
std::string pageName = uiPageData.begin()->second;
nui::RegisterSchemeHandlerFactory("https", "cfx-nui-" + resourceName, Instance<NUISchemeHandlerFactory>::Get());
// create the NUI frame
auto rmvRes = metaData->IsManifestVersionBetween("cerulean", "");
auto uiPrefix = (!rmvRes || !*rmvRes) ? "nui://" : "https://cfx-nui-";
std::string path = uiPrefix + m_resource->GetName() + "/" + pageName;
// allow direct mentions of absolute URIs
if (pageName.find("://") != std::string::npos)
{
path = pageName;
}
auto uiPagePreloadData = metaData->GetEntries("ui_page_preload");
bool uiPagePreload = std::distance(uiPagePreloadData.begin(), uiPagePreloadData.end()) > 0;
if (uiPagePreload)
{
nui::CreateFrame(m_resource->GetName(), path);
}
else
{
nui::PrepareFrame(m_resource->GetName(), path);
}
// add a cross-origin entry to allow fetching the callback handler
CefAddCrossOriginWhitelistEntry(va("nui://%s", m_resource->GetName().c_str()), "http", m_resource->GetName(), true);
CefAddCrossOriginWhitelistEntry(va("nui://%s", m_resource->GetName().c_str()), "https", m_resource->GetName(), true);
CefAddCrossOriginWhitelistEntry(va("https://cfx-nui-%s", m_resource->GetName().c_str()), "https", m_resource->GetName(), true);
CefAddCrossOriginWhitelistEntry(va("https://cfx-nui-%s", m_resource->GetName().c_str()), "nui", m_resource->GetName(), true);
return true;
}
void ResourceUI::Destroy()
{
// destroy the target frame
nui::DestroyFrame(m_resource->GetName());
}
void ResourceUI::AddCallback(const std::string& type, ResUICallback callback)
{
m_callbacks.insert({ type, callback });
}
void ResourceUI::RemoveCallback(const std::string& type)
{
// Note: This is called by UNREGISTER_RAW_NUI_CALLBACK but
// can still technically target event based NUI Callbacks
m_callbacks.erase(type);
}
bool ResourceUI::InvokeCallback(const std::string& type, const std::string& query, const std::multimap<std::string, std::string>& headers, const std::string& data, ResUIResultCallback resultCB)
{
auto set = fx::GetIteratorView(m_callbacks.equal_range(type));
if (set.begin() == set.end())
{
// try mapping only the first part
auto firstType = type.substr(0, type.find_first_of('/'));
set = fx::GetIteratorView(m_callbacks.equal_range(firstType));
if (set.begin() == set.end())
{
return false;
}
}
for (auto& cb : set)
{
cb.second(type, query, headers, data, resultCB);
}
return true;
}
void ResourceUI::SignalPoll()
{
nui::SignalPoll(m_resource->GetName());
}
static std::map<std::string, fwRefContainer<ResourceUI>> g_resourceUIs;
static std::mutex g_resourceUIMutex;
#include <boost/algorithm/string.hpp>
static bool NameMatches(std::string_view name, std::string_view match)
{
if (name == match)
{
return true;
}
if (boost::algorithm::starts_with(name, match))
{
if (name[match.length()] == '/')
{
return true;
}
}
return false;
}
static InitFunction initFunction([] ()
{
fx::ResourceManager::OnInitializeInstance.Connect([](fx::ResourceManager* manager)
{
nui::SetResourceLookupFunction([manager](const std::string& resourceName, const std::string& fileName) -> std::string
{
fwRefContainer<fx::Resource> resource;
fx::ResourceManager* resourceManager = Instance<fx::ResourceManager>::Get();
resourceManager->ForAllResources([&resourceName, &resource](const fwRefContainer<fx::Resource>& resourceRef)
{
if (_stricmp(resourceRef->GetName().c_str(), resourceName.c_str()) == 0)
{
resource = resourceRef;
}
});
if (resource.GetRef())
{
auto path = resource->GetPath();
if (!boost::algorithm::ends_with(path, "/"))
{
path += "/";
}
// check if it's a client script of any sorts
std::stringstream normalFileName;
char lastC = '/';
for (size_t i = 0; i < fileName.length(); i++)
{
char c = fileName[i];
if (c != '/' || lastC != '/')
{
normalFileName << c;
}
lastC = c;
}
auto nfn = normalFileName.str();
auto mdComponent = resource->GetComponent<fx::ResourceMetaDataComponent>();
bool valid = false;
if (NameMatches(nfn, "__resource.lua") || NameMatches(nfn, "fxmanifest.lua"))
{
return "common:/data/gameconfig.xml";
}
for (auto& entry : mdComponent->GlobEntriesVector("client_script"))
{
if (NameMatches(nfn, entry))
{
auto files = mdComponent->GlobEntriesVector("file");
bool isFile = false;
for (auto& fileEntry : files)
{
if (NameMatches(nfn, fileEntry))
{
isFile = true;
break;
}
}
if (!isFile)
{
return "common:/data/gameconfig.xml";
}
}
}
return path + fileName;
}
return fmt::sprintf("resources:/%s/%s", resourceName, fileName);
});
});
Resource::OnInitializeInstance.Connect([] (Resource* resource)
{
// create the UI instance
fwRefContainer<ResourceUI> resourceUI(new ResourceUI(resource));
// start event
resource->OnCreate.Connect([=] ()
{
std::unique_lock<std::mutex> lock(g_resourceUIMutex);
resourceUI->Create();
g_resourceUIs[resource->GetName()] = resourceUI;
});
// stop event
resource->OnStop.Connect([=] ()
{
std::unique_lock<std::mutex> lock(g_resourceUIMutex);
if (g_resourceUIs.find(resource->GetName()) != g_resourceUIs.end())
{
resourceUI->Destroy();
g_resourceUIs.erase(resource->GetName());
}
});
#ifdef GTA_FIVE
// pre-disconnect handling
resource->GetComponent<fx::ResourceGameLifetimeEvents>()->OnBeforeGameShutdown.Connect([=]()
{
std::unique_lock<std::mutex> lock(g_resourceUIMutex);
if (g_resourceUIs.find(resource->GetName()) != g_resourceUIs.end())
{
resourceUI->Destroy();
g_resourceUIs.erase(resource->GetName());
}
});
#endif
// add component
resource->SetComponent(resourceUI);
});
});
#include <CefOverlay.h>
#include <HttpClient.h>
static InitFunction httpInitFunction([]()
{
nui::RequestNUIBlocklist.Connect([](std::function<void(bool, const char*, size_t)> cb)
{
auto httpClient = Instance<HttpClient>::Get();
httpClient->DoGetRequest("https://runtime.fivem.net/nui-blacklist.json", cb);
});
});
|
// Distributed under the MIT License.
// See LICENSE.txt for details.
#include "tests/Unit/TestingFramework.hpp"
#include <array>
#include <cmath>
#include <cstddef>
#include <string>
#include "DataStructures/DataBox/DataBox.hpp"
#include "DataStructures/DataBox/DataBoxTag.hpp"
#include "DataStructures/DataVector.hpp"
#include "DataStructures/Tensor/EagerMath/Magnitude.hpp"
#include "DataStructures/Tensor/Tensor.hpp"
#include "Utilities/MakeWithValue.hpp"
#include "Utilities/TMPL.hpp"
// IWYU pragma: no_forward_declare Tensor
namespace {
void test_euclidean_magnitude() {
// Check for DataVectors
{
const size_t npts = 5;
const DataVector one(npts, 1.0);
const DataVector two(npts, 2.0);
const DataVector minus_three(npts, -3.0);
const DataVector four(npts, 4.0);
const DataVector minus_five(npts, -5.0);
const DataVector twelve(npts, 12.0);
const tnsr::i<DataVector, 1, Frame::Grid> one_d_covector{{{two}}};
CHECK_ITERABLE_APPROX(get(magnitude(one_d_covector)), two);
const tnsr::i<DataVector, 1, Frame::Grid> negative_one_d_covector{
{{minus_three}}};
CHECK_ITERABLE_APPROX(get(magnitude(negative_one_d_covector)),
(DataVector{npts, 3.0}));
const tnsr::A<DataVector, 1, Frame::Grid> one_d_vector{
{{minus_three, four}}};
CHECK_ITERABLE_APPROX(get(magnitude(one_d_vector)),
(DataVector{npts, 5.0}));
const tnsr::I<DataVector, 2, Frame::Grid> two_d_vector{
{{minus_five, twelve}}};
CHECK_ITERABLE_APPROX(get(magnitude(two_d_vector)),
(DataVector{npts, 13.0}));
const tnsr::i<DataVector, 3, Frame::Grid> three_d_covector{
{{minus_three, twelve, four}}};
CHECK_ITERABLE_APPROX(get(magnitude(three_d_covector)),
(DataVector{npts, 13.0}));
const tnsr::a<DataVector, 4, Frame::Grid> five_d_covector{
{{two, twelve, four, one, two}}};
CHECK_ITERABLE_APPROX(get(magnitude(five_d_covector)),
(DataVector{npts, 13.0}));
}
// Check case for doubles
{
const tnsr::i<double, 1, Frame::Grid> one_d_covector_double{{{2.}}};
CHECK(get(magnitude(one_d_covector_double)) == 2.);
const tnsr::a<double, 4, Frame::Grid> five_d_covector_double{
{{2, 12, 4, 1, 2}}};
CHECK(get(magnitude(five_d_covector_double)) == 13.);
}
}
void test_magnitude() {
// Check for DataVectors
{
const size_t npts = 5;
const DataVector one(npts, 1.0);
const DataVector two(npts, 2.0);
const DataVector minus_three(npts, -3.0);
const DataVector four(npts, 4.0);
const DataVector minus_five(npts, -5.0);
const DataVector twelve(npts, 12.0);
const DataVector thirteen(npts, 13.0);
const tnsr::i<DataVector, 1, Frame::Grid> one_d_covector{{{two}}};
const tnsr::II<DataVector, 1, Frame::Grid> inv_h = [&four]() {
tnsr::II<DataVector, 1, Frame::Grid> tensor;
get<0, 0>(tensor) = four;
return tensor;
}();
CHECK_ITERABLE_APPROX(get(magnitude(one_d_covector, inv_h)),
(DataVector{npts, 4.0}));
const tnsr::i<DataVector, 3, Frame::Grid> three_d_covector{
{{minus_three, twelve, four}}};
const tnsr::II<DataVector, 3, Frame::Grid> inv_g =
[&two, &minus_three, &four, &minus_five, &twelve, &thirteen]() {
tnsr::II<DataVector, 3, Frame::Grid> tensor;
get<0, 0>(tensor) = two;
get<0, 1>(tensor) = minus_three;
get<0, 2>(tensor) = four;
get<1, 1>(tensor) = minus_five;
get<1, 2>(tensor) = twelve;
get<2, 2>(tensor) = thirteen;
return tensor;
}();
CHECK_ITERABLE_APPROX(get(magnitude(three_d_covector, inv_g)),
(DataVector{npts, sqrt(778.0)}));
}
{
// Check for doubles
const tnsr::i<double, 1, Frame::Grid> one_d_covector{2.0};
const tnsr::II<double, 1, Frame::Grid> inv_h = []() {
tnsr::II<double, 1, Frame::Grid> tensor{};
get<0, 0>(tensor) = 4.0;
return tensor;
}();
CHECK(get(magnitude(one_d_covector, inv_h)) == 4.0);
const tnsr::i<double, 3, Frame::Grid> three_d_covector{{{-3.0, 12.0, 4.0}}};
const tnsr::II<double, 3, Frame::Grid> inv_g = []() {
tnsr::II<double, 3, Frame::Grid> tensor{};
get<0, 0>(tensor) = 2.0;
get<0, 1>(tensor) = -3.0;
get<0, 2>(tensor) = 4.0;
get<1, 1>(tensor) = -5.0;
get<1, 2>(tensor) = 12.0;
get<2, 2>(tensor) = 13.0;
return tensor;
}();
CHECK(get(magnitude(three_d_covector, inv_g)) == sqrt(778.0));
}
}
struct Vector : db::SimpleTag {
static std::string name() noexcept { return "Vector"; }
using type = tnsr::I<DataVector, 3, Frame::Grid>;
};
template <size_t Dim>
struct Covector : db::SimpleTag {
static std::string name() noexcept { return "Covector"; }
using type = tnsr::i<DataVector, Dim, Frame::Grid>;
};
struct Metric : db::SimpleTag {
static std::string name() noexcept { return "Metric"; }
using type = tnsr::ii<DataVector, 3, Frame::Grid>;
};
struct InverseMetric : db::SimpleTag {
static std::string name() noexcept { return "InverseMetric"; }
using type = tnsr::II<DataVector, 3, Frame::Grid>;
};
void test_magnitude_tags() {
const auto box =
db::create<db::AddSimpleTags<Vector, Covector<2>>,
db::AddComputeTags<Tags::EuclideanMagnitude<Vector>,
Tags::EuclideanMagnitude<Covector<2>>,
Tags::Normalized<Vector>,
Tags::Normalized<Covector<2>>>>(
db::item_type<Vector>({{{1., 2.}, {2., 3.}, {2., 6.}}}),
db::item_type<Covector<2>>({{{3., 5.}, {4., 12.}}}));
CHECK(db::get<Tags::EuclideanMagnitude<Vector>>(box) ==
Scalar<DataVector>({{{3., 7.}}}));
CHECK(db::get<Tags::EuclideanMagnitude<Covector<2>>>(box) ==
Scalar<DataVector>({{{5., 13.}}}));
CHECK(db::get<Tags::Normalized<Vector>>(box) ==
db::item_type<Vector>(
{{{1. / 3., 2. / 7.}, {2. / 3., 3. / 7.}, {2. / 3., 6. / 7.}}}));
CHECK(db::get<Tags::Normalized<Covector<2>>>(box) ==
db::item_type<Covector<2>>(
{{{3. / 5., 5. / 13.}, {4. / 5., 12. / 13.}}}));
using Tag = Vector;
/// [magnitude_name]
CHECK(Tags::Magnitude<Tag>::name() == "Magnitude(" + Tag::name() + ")");
/// [magnitude_name]
/// [normalized_name]
CHECK(Tags::Normalized<Tag>::name() == "Normalized(" + Tag::name() + ")");
/// [normalized_name]
}
void test_general_magnitude_tags() {
constexpr size_t npts = 5;
const tnsr::i<DataVector, 3, Frame::Grid> covector{
{{DataVector{npts, -3.0}, DataVector{npts, 12.0},
DataVector{npts, 4.0}}}};
const tnsr::II<DataVector, 3, Frame::Grid> inv_metric = []() noexcept {
auto tensor = make_with_value<tnsr::II<DataVector, 3, Frame::Grid>>(
DataVector{npts}, 0.0);
get<0, 0>(tensor) = 2.0;
get<0, 1>(tensor) = -3.0;
get<0, 2>(tensor) = 4.0;
get<1, 1>(tensor) = -5.0;
get<1, 2>(tensor) = 12.0;
get<2, 2>(tensor) = 13.0;
return tensor;
}
();
const tnsr::I<DataVector, 3, Frame::Grid> vector{
{{DataVector{npts, -3.0}, DataVector{npts, 12.0},
DataVector{npts, 4.0}}}};
const tnsr::ii<DataVector, 3, Frame::Grid> metric = []() noexcept {
auto tensor = make_with_value<tnsr::ii<DataVector, 3, Frame::Grid>>(
DataVector{npts}, 0.0);
get<0, 0>(tensor) = 2.0;
get<0, 1>(tensor) = -3.0;
get<0, 2>(tensor) = 4.0;
get<1, 1>(tensor) = -5.0;
get<1, 2>(tensor) = 12.0;
get<2, 2>(tensor) = 13.0;
return tensor;
}
();
const auto box =
db::create<db::AddSimpleTags<Vector, Covector<3>, Metric, InverseMetric>,
db::AddComputeTags<
Tags::NonEuclideanMagnitude<Vector, Metric>,
Tags::NonEuclideanMagnitude<Covector<3>, InverseMetric>,
Tags::Normalized<Vector>, Tags::Normalized<Covector<3>>>>(
vector, covector, metric, inv_metric);
CHECK_ITERABLE_APPROX(get(db::get<Tags::Magnitude<Vector>>(box)),
(DataVector{npts, sqrt(778.0)}));
CHECK_ITERABLE_APPROX(get<0>(db::get<Tags::Normalized<Vector>>(box)),
get<0>(vector) / sqrt(778.0));
CHECK_ITERABLE_APPROX(get<1>(db::get<Tags::Normalized<Vector>>(box)),
get<1>(vector) / sqrt(778.0));
CHECK_ITERABLE_APPROX(get<2>(db::get<Tags::Normalized<Vector>>(box)),
get<2>(vector) / sqrt(778.0));
CHECK_ITERABLE_APPROX(get(db::get<Tags::Magnitude<Covector<3>>>(box)),
(DataVector{npts, sqrt(778.0)}));
CHECK_ITERABLE_APPROX(get<0>(db::get<Tags::Normalized<Covector<3>>>(box)),
get<0>(covector) / sqrt(778.0));
CHECK_ITERABLE_APPROX(get<1>(db::get<Tags::Normalized<Covector<3>>>(box)),
get<1>(covector) / sqrt(778.0));
CHECK_ITERABLE_APPROX(get<2>(db::get<Tags::Normalized<Covector<3>>>(box)),
get<2>(covector) / sqrt(778.0));
}
} // namespace
SPECTRE_TEST_CASE("Unit.DataStructures.Tensor.EagerMath.Magnitude",
"[DataStructures][Unit]") {
test_euclidean_magnitude();
test_magnitude();
test_magnitude_tags();
test_general_magnitude_tags();
}
|
#ifndef MIGRAPHX_GUARD_RTGLIB_DEVICE_LOGICAL_AND_HPP
#define MIGRAPHX_GUARD_RTGLIB_DEVICE_LOGICAL_AND_HPP
#include <migraphx/argument.hpp>
#include <migraphx/config.hpp>
#include <hip/hip_runtime_api.h>
namespace migraphx {
inline namespace MIGRAPHX_INLINE_NS {
namespace gpu {
namespace device {
void logical_and(hipStream_t stream,
const argument& result,
const argument& arg1,
const argument& arg2);
} // namespace device
} // namespace gpu
} // namespace MIGRAPHX_INLINE_NS
} // namespace migraphx
#endif
|
#include "kernel.hpp"
#include "../mossc/cstdio"
#include "disk/ata/controller.hpp"
#include "disk/disk.hpp"
#include "graphics/gui/manager.hpp"
#include "graphics/vesa/controller.hpp"
#include "graphics/vesa/framebuffer.hpp"
#include "graphics/vga/terminal.hpp"
#include "graphics/color.hpp"
#include "input/devices/controller_ps2.hpp"
//#include "input/devices/mouse_ps2.hpp"
#include "input/keys.hpp"
#include "input/mouse.hpp"
namespace MOSS {
Kernel* kernel;
Kernel::Kernel(void) {
#ifdef MOSS_DEBUG
terminal = nullptr;
vga = nullptr;
graphics = nullptr;
gui = nullptr;
controller_ps2 = nullptr;
controller_ata = nullptr;
disk = nullptr;
filesystem = nullptr;
memory = nullptr;
#endif
}
void Kernel::handle_key_down(Input::Keys::Event const&/* event*/) {
/*//terminal->write('A');
if (Input::Keys::is_printable(event.key)) {
//write("Keyboard got scan code %d!\n",scan_code);
write(Input::Keys::get_printable(event.key));
}*/
}
void Kernel::handle_key_up(Input::Keys::Event const&/* event*/) {
}
void Kernel::handle_mouse_move(Input::Mouse::EventMouseMove const& event) {
//write("Mouse position: %d, %d\n",event.x,event.y);
/*graphics->current_framebuffer->set_pixel(event.x,event.y, Graphics::Color(255u,0u,255u,255u));
char buffer[64];
MOSSC::sprintf(buffer,"Mouse position: (%+5d,%+5d)",event.x,event.y);
graphics->current_framebuffer->draw_text(50,50, buffer, Graphics::Color(0u,255u,255u),Graphics::Color(32u,32u,32u));*/
//graphics->draw_text(50,50, "Hello World!", Graphics::Color(0u,255u,255u));
gui->handle_mouse(event);
}
void Kernel::handle_mouse_click(Input::Mouse::EventMouseClick const& event) {
gui->handle_mouse(event);
}
void Kernel::handle_mouse_unclick(Input::Mouse::EventMouseUnclick const& event) {
gui->handle_mouse(event);
}
void Kernel::write(char const* format,...) {
va_list args;
va_start(args,format);
terminal->write(format,args);
va_end(args);
}
void Kernel::write_sys(int level, char const* format,...) {
switch (level) {
case 0: terminal->set_color_text(Graphics::VGA::Terminal::Color::YELLOW); break;
case 1: terminal->set_color_text(Graphics::VGA::Terminal::Color:: CYAN); break;
default: //Fallthrough; any higher levels get this color too.
case 2: terminal->set_color_text(Graphics::VGA::Terminal::Color:: BROWN); break;
}
while (level>0) { write(" "); --level; }
va_list args;
va_start(args,format);
terminal->write(format,args);
va_end(args);
}
void Kernel::init(void) {
#if 1
/*for (int i=0;i<graphics->numof_modes;++i) {
graphics->modes[i]->print(terminal);
delay(1000);
}*/
//Graphics::VESA::Mode* mode = graphics->get_mode_closest( 800,600,32);
Graphics::VESA::Mode* mode = graphics->get_mode_closest(1024,768,32);
//Graphics::VESA::Mode* mode = graphics->get_mode_closest(1152,864,32);
//write("Setting mode "); mode->print(terminal); write(" . . .\n"); delay(5000);
graphics->set_mode(mode);
//graphics->set_pixel(5,5, 255,0,0,255);
#endif
}
void Kernel::main(void) {
#if 0
char buffer[256];
graphics->current_mode->get_printable(buffer);
graphics->draw_text(50,graphics->current_mode->info.YResolution-50, buffer, Graphics::Color(255u,255u,255u));
#endif
#if 0
//graphics->fill(Graphics::Color(255u,0u,0u,255u));
graphics->draw_text(50,70, "TEST WRITING!", Graphics::Color(0u,255u,255u),Graphics::Color(32u,32u,32u));
int x = 20;
int y = 600;
for (int r=0;r<255;r+=64) {
for (int g=0;g<255;g+=64) {
for (int b=0;b<255;b+=64) {
MOSSC::sprintf(buffer,"=(%3d,%3d,%3d)",r,g,b);
graphics->draw_text(x+110,y, buffer, Graphics::Color(255u,255u,255u),Graphics::Color(32u,32u,32u));
graphics->draw_rect(x,y,100,10, Graphics::Color(r,g,b));
y -= 15;
if (y<100) {
y = 600;
x += 250;
}
}
}
}
#endif
#if 0
terminal->write("Hanging in kernel!\n"); while (true);
#endif
/*for (int r=0;r<=255;++r) {
for (int g=0;g<=255;++g) {
graphics->set_pixel(5+r,5+g, Graphics::Color(255,0,0));
}
}*/
//gui->load_bg("/files/sunspirenight.ppm");
gui->add_frame("Hello world!", 50,500, 300,200);
while (true) {
gui->update();
Kernel::graphics->frame_start();
gui->draw(Kernel::graphics->current_framebuffer);
Kernel::graphics->frame_end();
Kernel::graphics->frame_flip();
}
}
}
|
#include <ripple/protocol/STLedgerEntry.h>
#include <ripple/basics/contract.h>
#include <ripple/basics/Log.h>
#include <ripple/basics/safe_cast.h>
#include <ripple/json/to_string.h>
#include <ripple/protocol/Indexes.h>
#include <ripple/protocol/jss.h>
#include <boost/format.hpp>
namespace ripple {
STLedgerEntry::STLedgerEntry (Keylet const& k)
: STObject(sfLedgerEntry)
, key_ (k.key)
, type_ (k.type)
{
if (!(0u <= type_ &&
type_ <= std::min<unsigned>(std::numeric_limits<std::uint16_t>::max(),
std::numeric_limits<std::underlying_type_t<LedgerEntryType>>::max())))
Throw<std::runtime_error> ("invalid ledger entry type: out of range");
auto const format =
LedgerFormats::getInstance().findByType (type_);
if (format == nullptr)
Throw<std::runtime_error> ("invalid ledger entry type");
set (format->getSOTemplate());
setFieldU16 (sfLedgerEntryType,
static_cast <std::uint16_t> (type_));
}
STLedgerEntry::STLedgerEntry (
SerialIter& sit,
uint256 const& index)
: STObject (sfLedgerEntry)
, key_ (index)
{
set (sit);
setSLEType ();
}
STLedgerEntry::STLedgerEntry (
STObject const& object,
uint256 const& index)
: STObject (object)
, key_ (index)
{
setSLEType ();
}
void STLedgerEntry::setSLEType ()
{
auto format = LedgerFormats::getInstance().findByType (
safe_cast <LedgerEntryType> (
getFieldU16 (sfLedgerEntryType)));
if (format == nullptr)
Throw<std::runtime_error> ("invalid ledger entry type");
type_ = format->getType ();
applyTemplate (format->getSOTemplate());
}
std::string STLedgerEntry::getFullText () const
{
auto const format =
LedgerFormats::getInstance().findByType (type_);
if (format == nullptr)
Throw<std::runtime_error> ("invalid ledger entry type");
std::string ret = "\"";
ret += to_string (key_);
ret += "\" = { ";
ret += format->getName ();
ret += ", ";
ret += STObject::getFullText ();
ret += "}";
return ret;
}
std::string STLedgerEntry::getText () const
{
return str (boost::format ("{ %s, %s }")
% to_string (key_)
% STObject::getText ());
}
Json::Value STLedgerEntry::getJson (JsonOptions options) const
{
Json::Value ret (STObject::getJson (options));
ret[jss::index] = to_string (key_);
return ret;
}
bool STLedgerEntry::isThreadedType () const
{
return getFieldIndex (sfPreviousTxnID) != -1;
}
bool STLedgerEntry::thread (
uint256 const& txID,
std::uint32_t ledgerSeq,
uint256& prevTxID,
std::uint32_t& prevLedgerID)
{
uint256 oldPrevTxID = getFieldH256 (sfPreviousTxnID);
JLOG (debugLog().info())
<< "Thread Tx:" << txID << " prev:" << oldPrevTxID;
if (oldPrevTxID == txID)
{
assert (getFieldU32 (sfPreviousTxnLgrSeq) == ledgerSeq);
return false;
}
prevTxID = oldPrevTxID;
prevLedgerID = getFieldU32 (sfPreviousTxnLgrSeq);
setFieldH256 (sfPreviousTxnID, txID);
setFieldU32 (sfPreviousTxnLgrSeq, ledgerSeq);
return true;
}
}
|
/*
* Software License Agreement (BSD License)
*
* Copyright (c) 2011-2014, Willow Garage, Inc.
* Copyright (c) 2014-2015, Open Source Robotics Foundation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Open Source Robotics Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/** \author Dalibor Matura, Jia Pan */
#include "fcl/articulated_model/joint_config.h"
#include "fcl/articulated_model/joint.h"
namespace fcl
{
JointConfig::JointConfig() {}
JointConfig::JointConfig(const JointConfig& joint_cfg) :
joint_(joint_cfg.joint_),
values_(joint_cfg.values_),
limits_min_(joint_cfg.limits_min_),
limits_max_(joint_cfg.limits_max_)
{
}
JointConfig::JointConfig(const std::shared_ptr<Joint>& joint,
FCL_REAL default_value,
FCL_REAL default_value_min,
FCL_REAL default_value_max) :
joint_(joint)
{
values_.resize(joint->getNumDofs(), default_value);
limits_min_.resize(joint->getNumDofs(), default_value_min);
limits_max_.resize(joint->getNumDofs(), default_value_max);
}
std::size_t JointConfig::getDim() const
{
return values_.size();
}
FCL_REAL JointConfig::getValue(std::size_t i) const
{
return values_[i];
}
FCL_REAL& JointConfig::getValue(std::size_t i)
{
return values_[i];
}
FCL_REAL JointConfig::getLimitMin(std::size_t i) const
{
return limits_min_[i];
}
FCL_REAL& JointConfig::getLimitMin(std::size_t i)
{
return limits_min_[i];
}
FCL_REAL JointConfig::getLimitMax(std::size_t i) const
{
return limits_max_[i];
}
FCL_REAL& JointConfig::getLimitMax(std::size_t i)
{
return limits_max_[i];
}
std::shared_ptr<Joint> JointConfig::getJoint() const
{
return joint_.lock();
}
}
|
/*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <aws/redshift/model/CreateSnapshotScheduleResult.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/core/AmazonWebServiceResult.h>
#include <aws/core/utils/StringUtils.h>
#include <aws/core/utils/logging/LogMacros.h>
#include <utility>
using namespace Aws::Redshift::Model;
using namespace Aws::Utils::Xml;
using namespace Aws::Utils::Logging;
using namespace Aws::Utils;
using namespace Aws;
CreateSnapshotScheduleResult::CreateSnapshotScheduleResult() :
m_associatedClusterCount(0)
{
}
CreateSnapshotScheduleResult::CreateSnapshotScheduleResult(const Aws::AmazonWebServiceResult<XmlDocument>& result) :
m_associatedClusterCount(0)
{
*this = result;
}
CreateSnapshotScheduleResult& CreateSnapshotScheduleResult::operator =(const Aws::AmazonWebServiceResult<XmlDocument>& result)
{
const XmlDocument& xmlDocument = result.GetPayload();
XmlNode rootNode = xmlDocument.GetRootElement();
XmlNode resultNode = rootNode;
if (!rootNode.IsNull() && (rootNode.GetName() != "CreateSnapshotScheduleResult"))
{
resultNode = rootNode.FirstChild("CreateSnapshotScheduleResult");
}
if(!resultNode.IsNull())
{
XmlNode scheduleDefinitionsNode = resultNode.FirstChild("ScheduleDefinitions");
if(!scheduleDefinitionsNode.IsNull())
{
XmlNode scheduleDefinitionsMember = scheduleDefinitionsNode.FirstChild("ScheduleDefinition");
while(!scheduleDefinitionsMember.IsNull())
{
m_scheduleDefinitions.push_back(scheduleDefinitionsMember.GetText());
scheduleDefinitionsMember = scheduleDefinitionsMember.NextNode("ScheduleDefinition");
}
}
XmlNode scheduleIdentifierNode = resultNode.FirstChild("ScheduleIdentifier");
if(!scheduleIdentifierNode.IsNull())
{
m_scheduleIdentifier = scheduleIdentifierNode.GetText();
}
XmlNode scheduleDescriptionNode = resultNode.FirstChild("ScheduleDescription");
if(!scheduleDescriptionNode.IsNull())
{
m_scheduleDescription = scheduleDescriptionNode.GetText();
}
XmlNode tagsNode = resultNode.FirstChild("Tags");
if(!tagsNode.IsNull())
{
XmlNode tagsMember = tagsNode.FirstChild("Tag");
while(!tagsMember.IsNull())
{
m_tags.push_back(tagsMember);
tagsMember = tagsMember.NextNode("Tag");
}
}
XmlNode nextInvocationsNode = resultNode.FirstChild("NextInvocations");
if(!nextInvocationsNode.IsNull())
{
XmlNode nextInvocationsMember = nextInvocationsNode.FirstChild("SnapshotTime");
while(!nextInvocationsMember.IsNull())
{
m_nextInvocations.push_back(DateTime(StringUtils::Trim(nextInvocationsMember.GetText().c_str()).c_str(), DateFormat::ISO_8601));
nextInvocationsMember = nextInvocationsMember.NextNode("SnapshotTime");
}
}
XmlNode associatedClusterCountNode = resultNode.FirstChild("AssociatedClusterCount");
if(!associatedClusterCountNode.IsNull())
{
m_associatedClusterCount = StringUtils::ConvertToInt32(StringUtils::Trim(associatedClusterCountNode.GetText().c_str()).c_str());
}
XmlNode associatedClustersNode = resultNode.FirstChild("AssociatedClusters");
if(!associatedClustersNode.IsNull())
{
XmlNode associatedClustersMember = associatedClustersNode.FirstChild("ClusterAssociatedToSchedule");
while(!associatedClustersMember.IsNull())
{
m_associatedClusters.push_back(associatedClustersMember);
associatedClustersMember = associatedClustersMember.NextNode("ClusterAssociatedToSchedule");
}
}
}
if (!rootNode.IsNull()) {
XmlNode responseMetadataNode = rootNode.FirstChild("ResponseMetadata");
m_responseMetadata = responseMetadataNode;
AWS_LOGSTREAM_DEBUG("Aws::Redshift::Model::CreateSnapshotScheduleResult", "x-amzn-request-id: " << m_responseMetadata.GetRequestId() );
}
return *this;
}
|
/**
* @file tst_Ex_9_22.cpp
*
* @brief Test the functionality of the Time class to represent the time as the number
* of seconds after midnight.
*
* @author Matt Randazzo
*/
#include <Ex_9_22.h>
#include <gtest/gtest.h>
/**
* @brief Set zero seconds since midnight
*/
TEST(Constructor, ZeroSeconds) {
Time time_zero;
EXPECT_EQ(time_zero.getHour(), static_cast<unsigned int>(0));
EXPECT_EQ(time_zero.getMinute(), static_cast<unsigned int>(0));
EXPECT_EQ(time_zero.getSecond(), static_cast<unsigned int>(0));
EXPECT_EQ(time_zero.toStandardString(), "12:00:00 AM");
EXPECT_EQ(time_zero.toUniversalString(), "00:00:00");
}
/**
* @brief Set valid time before noon
*/
TEST(Constructor, SetValidTimeBeforeNoon) {
Time sample_time(6, 30, 30);
EXPECT_EQ(sample_time.getHour(), static_cast<unsigned int>(6));
EXPECT_EQ(sample_time.getMinute(), static_cast<unsigned int>(30));
EXPECT_EQ(sample_time.getSecond(), static_cast<unsigned int>(30));
EXPECT_EQ(sample_time.toStandardString(), "06:30:30 AM");
EXPECT_EQ(sample_time.toUniversalString(), "06:30:30");
}
/**
* @brief Set maximum valid time after noon
*/
TEST(Constructor, SetValidTimeAfterNoon) {
Time sample_time(23, 59, 59);
EXPECT_EQ(sample_time.getHour(), static_cast<unsigned int>(23));
EXPECT_EQ(sample_time.getMinute(), static_cast<unsigned int>(59));
EXPECT_EQ(sample_time.getSecond(), static_cast<unsigned int>(59));
EXPECT_EQ(sample_time.toStandardString(), "11:59:59 PM");
EXPECT_EQ(sample_time.toUniversalString(), "23:59:59");
}
/**
* @brief Set invalid hour
*/
TEST(SetHour, SetInvalidHour) {
try {
Time sample_time(24, 30, 30);
} catch (std::invalid_argument const &err) {
EXPECT_STRCASEEQ(err.what(), "hour must be 0-23");
}
}
/**
* @brief Set invalid minute parameter
*/
TEST(SetMinute, SetInvalidMinute) {
try {
Time sample_time(23, 60, 30);
} catch (std::invalid_argument const &err) {
EXPECT_STRCASEEQ(err.what(), "minute must be 0-59");
}
}
/**
* @brief Set invalid second parameter
*/
TEST(SetSecond, SetInvalidSecond) {
try {
Time sample_time(23, 59, 60);
} catch (std::invalid_argument const &err) {
EXPECT_STRCASEEQ(err.what(), "second must be 0-59");
}
}
|
#include "sendcoinsentry.h"
#include "ui_sendcoinsentry.h"
#include "guiutil.h"
#include "bitcoinunits.h"
#include "addressbookpage.h"
#include "walletmodel.h"
#include "optionsmodel.h"
#include "addresstablemodel.h"
#include <QApplication>
#include <QClipboard>
SendCoinsEntry::SendCoinsEntry(QWidget *parent) :
QFrame(parent),
ui(new Ui::SendCoinsEntry),
model(0)
{
ui->setupUi(this);
#ifdef Q_OS_MAC
ui->payToLayout->setSpacing(4);
#endif
#if QT_VERSION >= 0x040700
/* Do not move this to the XML file, Qt before 4.7 will choke on it */
ui->addAsLabel->setPlaceholderText(tr("Enter a label for this address to add it to your address book"));
ui->payTo->setPlaceholderText(tr("Enter a valid CinniCoin address"));
#endif
setFocusPolicy(Qt::TabFocus);
setFocusProxy(ui->payTo);
GUIUtil::setupAddressWidget(ui->payTo, this);
}
SendCoinsEntry::~SendCoinsEntry()
{
delete ui;
}
void SendCoinsEntry::on_pasteButton_clicked()
{
// Paste text from clipboard into recipient field
ui->payTo->setText(QApplication::clipboard()->text());
}
void SendCoinsEntry::on_addressBookButton_clicked()
{
if(!model)
return;
AddressBookPage dlg(AddressBookPage::ForSending, AddressBookPage::SendingTab, this);
dlg.setModel(model->getAddressTableModel());
if(dlg.exec())
{
ui->payTo->setText(dlg.getReturnValue());
ui->payAmount->setFocus();
}
}
void SendCoinsEntry::on_payTo_textChanged(const QString &address)
{
if(!model)
return;
// Fill in label from address book, if address has an associated label
QString associatedLabel = model->getAddressTableModel()->labelForAddress(address);
if(!associatedLabel.isEmpty())
ui->addAsLabel->setText(associatedLabel);
}
void SendCoinsEntry::setModel(WalletModel *model)
{
this->model = model;
if(model && model->getOptionsModel())
connect(model->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));
connect(ui->payAmount, SIGNAL(textChanged()), this, SIGNAL(payAmountChanged()));
clear();
}
void SendCoinsEntry::setRemoveEnabled(bool enabled)
{
ui->deleteButton->setEnabled(enabled);
}
void SendCoinsEntry::clear()
{
ui->payTo->clear();
ui->addAsLabel->clear();
ui->payAmount->clear();
ui->payTo->setFocus();
// update the display unit, to not use the default ("BTC")
updateDisplayUnit();
}
void SendCoinsEntry::on_deleteButton_clicked()
{
emit removeEntry(this);
}
bool SendCoinsEntry::validate()
{
// Check input validity
bool retval = true;
if(!ui->payAmount->validate())
{
retval = false;
}
else
{
if(ui->payAmount->value() <= 0)
{
// Cannot send 0 coins or less
ui->payAmount->setValid(false);
retval = false;
}
}
if(!ui->payTo->hasAcceptableInput() ||
(model && !model->validateAddress(ui->payTo->text())))
{
ui->payTo->setValid(false);
retval = false;
}
return retval;
}
SendCoinsRecipient SendCoinsEntry::getValue()
{
SendCoinsRecipient rv;
rv.address = ui->payTo->text();
rv.label = ui->addAsLabel->text();
rv.amount = ui->payAmount->value();
return rv;
}
QWidget *SendCoinsEntry::setupTabChain(QWidget *prev)
{
QWidget::setTabOrder(prev, ui->payTo);
QWidget::setTabOrder(ui->payTo, ui->addressBookButton);
QWidget::setTabOrder(ui->addressBookButton, ui->pasteButton);
QWidget::setTabOrder(ui->pasteButton, ui->deleteButton);
QWidget::setTabOrder(ui->deleteButton, ui->addAsLabel);
return ui->payAmount->setupTabChain(ui->addAsLabel);
}
void SendCoinsEntry::setValue(const SendCoinsRecipient &value)
{
ui->payTo->setText(value.address);
ui->addAsLabel->setText(value.label);
ui->payAmount->setValue(value.amount);
}
bool SendCoinsEntry::isClear()
{
return ui->payTo->text().isEmpty();
}
void SendCoinsEntry::setFocus()
{
ui->payTo->setFocus();
}
void SendCoinsEntry::updateDisplayUnit()
{
if(model && model->getOptionsModel())
{
// Update payAmount with the current unit
ui->payAmount->setDisplayUnit(model->getOptionsModel()->getDisplayUnit());
}
}
|
//problema3.15 "dia de la semana"
#include<iostream>
using namespace std;
int main(){
int dia;
cout<<"introdusca un numero entre 1-10: ";
cin>>dia;
switch (dia){
case 1 :cout<<"es el dia lunes"<<endl;break;
case 2 :cout<<"es el dia martes"<<endl;break;
case 3 :cout<<"es el dia miercoles"<<endl;break;
case 4 :cout<<"es el dia jueves"<<endl;break;
case 5 :cout<<"es el dia viernes"<<endl;break;
case 6 :cout<<"es el dia sabado"<<endl;break;
case 7 :cout<<"es el dia domingo"<<endl;break;
default :cout<<"no es un numero valido entre 1-10"<<endl;break;
}
return 0;
}
|
/***************************************************************************
# Copyright (c) 2015-21, NVIDIA CORPORATION. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of NVIDIA CORPORATION nor the names of its
# contributors may be used to endorse or promote products derived
# from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS "AS IS" AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**************************************************************************/
#include "stdafx.h"
#include "CopyContext.h"
#include "Texture.h"
#include "Buffer.h"
#include "GpuFence.h"
namespace Falcor
{
CopyContext::~CopyContext() = default;
CopyContext::CopyContext(LowLevelContextData::CommandQueueType type, CommandQueueHandle queue)
{
mpLowLevelData = LowLevelContextData::create(type, queue);
FALCOR_ASSERT(mpLowLevelData);
}
CopyContext::SharedPtr CopyContext::create(CommandQueueHandle queue)
{
FALCOR_ASSERT(queue);
return SharedPtr(new CopyContext(LowLevelContextData::CommandQueueType::Copy, queue));
}
void CopyContext::flush(bool wait)
{
if (mCommandsPending)
{
mpLowLevelData->flush();
mCommandsPending = false;
}
else
{
// We need to signal even if there are no commands to execute. We need this because some resources may have been released since the last flush(), and unless we signal they will not be released
mpLowLevelData->getFence()->gpuSignal(mpLowLevelData->getCommandQueue());
}
bindDescriptorHeaps();
if (wait)
{
mpLowLevelData->getFence()->syncCpu();
}
}
CopyContext::ReadTextureTask::SharedPtr CopyContext::asyncReadTextureSubresource(const Texture* pTexture, uint32_t subresourceIndex)
{
return CopyContext::ReadTextureTask::create(this, pTexture, subresourceIndex);
}
std::vector<uint8_t> CopyContext::readTextureSubresource(const Texture* pTexture, uint32_t subresourceIndex)
{
CopyContext::ReadTextureTask::SharedPtr pTask = asyncReadTextureSubresource(pTexture, subresourceIndex);
return pTask->getData();
}
bool CopyContext::resourceBarrier(const Resource* pResource, Resource::State newState, const ResourceViewInfo* pViewInfo)
{
const Texture* pTexture = dynamic_cast<const Texture*>(pResource);
if (pTexture)
{
bool globalBarrier = pTexture->isStateGlobal();
if (pViewInfo)
{
globalBarrier = globalBarrier && pViewInfo->firstArraySlice == 0;
globalBarrier = globalBarrier && pViewInfo->mostDetailedMip == 0;
globalBarrier = globalBarrier && pViewInfo->mipCount == pTexture->getMipCount();
globalBarrier = globalBarrier && pViewInfo->arraySize == pTexture->getArraySize();
}
if (globalBarrier)
{
return textureBarrier(pTexture, newState);
}
else
{
return subresourceBarriers(pTexture, newState, pViewInfo);
}
}
else
{
const Buffer* pBuffer = dynamic_cast<const Buffer*>(pResource);
return bufferBarrier(pBuffer, newState);
}
}
bool CopyContext::subresourceBarriers(const Texture* pTexture, Resource::State newState, const ResourceViewInfo* pViewInfo)
{
ResourceViewInfo fullResource;
bool setGlobal = false;
if (pViewInfo == nullptr)
{
fullResource.arraySize = pTexture->getArraySize();
fullResource.firstArraySlice = 0;
fullResource.mipCount = pTexture->getMipCount();
fullResource.mostDetailedMip = 0;
setGlobal = true;
pViewInfo = &fullResource;
}
bool entireViewTransitioned = true;
for (uint32_t a = pViewInfo->firstArraySlice; a < pViewInfo->firstArraySlice + pViewInfo->arraySize; a++)
{
for (uint32_t m = pViewInfo->mostDetailedMip; m < pViewInfo->mipCount + pViewInfo->mostDetailedMip; m++)
{
Resource::State oldState = pTexture->getSubresourceState(a, m);
if (oldState != newState)
{
apiSubresourceBarrier(pTexture, newState, oldState, a, m);
if (setGlobal == false) pTexture->setSubresourceState(a, m, newState);
mCommandsPending = true;
}
else entireViewTransitioned = false;
}
}
if (setGlobal) pTexture->setGlobalState(newState);
return entireViewTransitioned;
}
void CopyContext::updateTextureData(const Texture* pTexture, const void* pData)
{
mCommandsPending = true;
uint32_t subresourceCount = pTexture->getArraySize() * pTexture->getMipCount();
if (pTexture->getType() == Texture::Type::TextureCube)
{
subresourceCount *= 6;
}
updateTextureSubresources(pTexture, 0, subresourceCount, pData);
}
void CopyContext::updateSubresourceData(const Texture* pDst, uint32_t subresource, const void* pData, const uint3& offset, const uint3& size)
{
mCommandsPending = true;
updateTextureSubresources(pDst, subresource, 1, pData, offset, size);
}
void CopyContext::updateBuffer(const Buffer* pBuffer, const void* pData, size_t offset, size_t numBytes)
{
if (numBytes == 0)
{
numBytes = pBuffer->getSize() - offset;
}
if (pBuffer->adjustSizeOffsetParams(numBytes, offset) == false)
{
logWarning("CopyContext::updateBuffer() - size and offset are invalid. Nothing to update.");
return;
}
mCommandsPending = true;
// Allocate a buffer on the upload heap
Buffer::SharedPtr pUploadBuffer = Buffer::create(numBytes, Buffer::BindFlags::None, Buffer::CpuAccess::Write, pData);
copyBufferRegion(pBuffer, offset, pUploadBuffer.get(), 0, numBytes);
}
}
|
/*
题目满足不共线所有点，输入点坐标都是浮点数
最小矩形覆盖一定唯一，注意题目要求输出点坐标的顺序
定理：最小矩形覆盖的一条边一定和凸包轮廓的一条边重合
旋转卡壳O(N), 凸包O(NlogN) 总复杂度O(NlogN)
*/
#include <bits/stdc++.h>
using namespace std;
#define x first
#define y second
typedef pair<double, double> pdd;
const int N = 50010; //开总点数即可
const double eps = 1e-12, INF = 1e20;
const double PI = acos(-1);
int n;
pdd q[N];
pdd ans[N]; //每次旋转卡壳后的矩形的四个顶点
double min_area = INF;
int stk[N], top;
bool used[N];
int sign(double x) {
if (fabs(x) < eps) return 0;
if (x < 0) return -1;
return 1;
}
int dcmp(double x, double y) {
if (fabs(x - y) < eps) return 0;
if (x < y) return -1;
return 1;
}
pdd operator+ (pdd a, pdd b) {
return {a.x + b.x, a.y + b.y};
}
pdd operator- (pdd a, pdd b) {
return {a.x - b.x, a.y - b.y};
}
pdd operator* (pdd a, double t) {
return {a.x * t, a.y * t};
}
pdd operator/ (pdd a, double t) {
return {a.x / t, a.y / t};
}
double operator* (pdd a, pdd b) {
return a.x * b.y - a.y * b.x;
}
double operator&(pdd a, pdd b) {
return a.x * b.x + a.y * b.y;
}
double area(pdd a, pdd b, pdd c) {
return (b - a) * (c - a);
}
double get_len(pdd a) {
return sqrt(a & a);
}
double project(pdd a, pdd b, pdd c) { //ac在ab上的投影 有正负之分
return ((b - a) & (c - a)) / get_len(b - a);
}
pdd norm(pdd a) { //得到a的单位向量
return a / get_len(a);
}
pdd rotate(pdd a, double b) {
return {a.x * cos(b) + a.y * sin(b), -a.x * sin(b) + a.y * cos(b)};
}
//旋转卡壳凸包模板
void get_convex() {
sort(q, q + n);
for (int i = 0; i < n; i++) { //下凸壳
while (top >= 2 && sign(area(q[stk[top - 2]], q[stk[top - 1]], q[i])) <= 0) {
// 凸包边界上的点即使被从栈中删掉，也不能删掉used上的标记
if (area(q[stk[top - 2]], q[stk[top - 1]], q[i]) < 0)
used[stk[--top]] = false;
else top --;
}
stk[top++] = i; //栈顶下标从0开始
used[i] = true;
}
//将起点再一次入栈
used[0] = false;
for (int i = n - 1; i >= 0; i--) { //求上凸壳
if (used[i]) continue;
while (top >= 2 && sign(area(q[stk[top - 2]], q[stk[top - 1]], q[i])) <= 0)
top -- ;
stk[top++] = i;
}
top --; //将栈顶后移 栈内删除0号元素 但是stk数组中还是存在0的 只不过top没指向
}
void rotating_calipers() {
for (int i = 0, a = 2, b = 2, c = 2; i < top; i ++ ) {
auto d = q[stk[i]], e = q[stk[i + 1]];
while (dcmp(area(d, e, q[stk[a]]), area(d, e, q[stk[a + 1]])) < 0) a = (a + 1) % top;
while (dcmp(project(d, e, q[stk[b]]), project(d, e, q[stk[b + 1]])) < 0) b = (b + 1) % top;
if (!i) c = a;
while (dcmp(project(d, e, q[stk[c]]), project(d, e, q[stk[c + 1]])) > 0) c = (c + 1) % top;
auto x = q[stk[a]], y = q[stk[b]], z = q[stk[c]];
auto h = area(d, e, x) / get_len(e - d);
auto w = ((y - z) & (e - d)) / get_len(e - d);
if (h * w < min_area) {
min_area = h * w;
ans[0] = d + norm(e - d) * project(d, e, y);
ans[3] = d + norm(e - d) * project(d, e, z);
auto u = norm(rotate(e - d, -PI / 2));
ans[1] = ans[0] + u * h;
ans[2] = ans[3] + u * h;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%lf%lf", &q[i].x, &q[i].y);
get_convex();
rotating_calipers();
int k = 0;
for (int i = 1; i < 4; i++) //找到第一个输出的点 最靠左下的一个
if (dcmp(ans[i].y, ans[k].y) < 0 || !dcmp(ans[i].y, ans[k].y) && dcmp(ans[i].x, ans[k].x) < 0)
k = i;
if (!sign(min_area)) min_area = 0;
printf("%.5lf\n", min_area);
for (int i = 0; i < 4 ; i++, k++) {
auto x = ans[k % 4].x, y = ans[k % 4].y;
if (!sign(x)) x = 0; //防止出现小数点截断后 -0.00000
if (!sign(y)) y = 0;
printf("%.5lf %.5lf\n", x, y);
}
return 0;
}
|
#pragma once
#include <arbor/export.hpp>
typedef unsigned long long tick_type;
// Assuming POSIX monotonic clock is available; add
// feature test if we need to fall back to generic or
// other implementation.
namespace arb {
namespace profile {
ARB_ARBOR_API tick_type posix_clock_gettime_monotonic_ns();
struct posix_clock_monotonic {
static constexpr double seconds_per_tick() { return 1.e-9; }
static unsigned long long now() {
return posix_clock_gettime_monotonic_ns();
}
};
using default_clock = posix_clock_monotonic;
} // namespace profile
} // namespace arb
|
#include <vx_ext_rpp.h>
#include <VX/vx_compatibility.h>
#include "node_warp_affine.h"
#include "exception.h"
WarpAffineNode::WarpAffineNode(const std::vector<Image*>& inputs, const std::vector<Image*>& outputs):
Node(inputs, outputs),
_x0(COEFFICIENT_X0_OVX_PARAM_IDX, COEFFICIENT_RANGE_1[0], COEFFICIENT_RANGE_1[1]),
_x1(COEFFICIENT_X1_OVX_PARAM_IDX, COEFFICIENT_RANGE_0[0], COEFFICIENT_RANGE_0[1]),
_y0(COEFFICIENT_Y0_OVX_PARAM_IDX, COEFFICIENT_RANGE_0[0], COEFFICIENT_RANGE_0[1]),
_y1(COEFFICIENT_Y1_OVX_PARAM_IDX, COEFFICIENT_RANGE_1[0], COEFFICIENT_RANGE_1[1]),
_o0(COEFFICIENT_O0_OVX_PARAM_IDX, COEFFICIENT_RANGE_OFFSET[0], COEFFICIENT_RANGE_OFFSET[1]),
_o1(COEFFICIENT_O1_OVX_PARAM_IDX, COEFFICIENT_RANGE_OFFSET[0], COEFFICIENT_RANGE_OFFSET[1])
{
}
void WarpAffineNode::create(std::shared_ptr<Graph> graph)
{
if(_node)
return;
_graph = graph;
if(_outputs.empty() || _inputs.empty())
THROW("Uninitialized input/output arguments")
_node = vxExtrppNode_WarpAffine(_graph->get(), _inputs[0]->handle(), _outputs[0]->handle(), _outputs[0]->info().width(), _outputs[0]->info().height_batch(),
_x0.default_value(), _y0.default_value(), _o0.default_value(), _x1.default_value(), _y1.default_value(), _o1.default_value());
vx_status status;
if((status = vxGetStatus((vx_reference)_node)) != VX_SUCCESS)
THROW("Adding the warp affine (vxExtrppNode_WarpAffine) node failed: "+ TOSTR(status))
_x0.create(_node);
_x1.create(_node);
_y0.create(_node);
_y1.create(_node);
_o0.create(_node);
_o1.create(_node);
}
void WarpAffineNode::init(float x0, float x1, float y0, float y1, float o0, float o1)
{
_x0.set_param(x0);
_x1.set_param(x1);
_y0.set_param(y0);
_y1.set_param(y1);
_o0.set_param(o0);
_o1.set_param(o1);
}
void WarpAffineNode::init(FloatParam* x0, FloatParam* x1, FloatParam* y0, FloatParam* y1, FloatParam* o0, FloatParam* o1)
{
_x0.set_param(core(x0));
_x1.set_param(core(x1));
_y0.set_param(core(y0));
_y1.set_param(core(y1));
_o0.set_param(core(o0));
_o1.set_param(core(o1));
}
void WarpAffineNode::update_parameters()
{
_x0.update();
_y0.update();
_x1.update();
_y1.update();
_o0.update();
_o1.update();
}
|
/*
GRT MIT License
Copyright (c) <2012> <Nicholas Gillian, Media Lab, MIT>
Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial
portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "DeadZone.h"
namespace GRT{
//Register the DeadZone module with the PreProcessing base class
RegisterPreProcessingModule< DeadZone > DeadZone::registerModule("DeadZone");
DeadZone::DeadZone(double lowerLimit,double upperLimit,UINT numDimensions){
preProcessingType = "DeadZone";
debugLog.setProceedingText("[DEBUG HPF]");
errorLog.setProceedingText("[ERROR HPF]");
warningLog.setProceedingText("[WARNING HPF]");
init(lowerLimit,upperLimit,numDimensions);
}
DeadZone::DeadZone(const DeadZone &rhs){
this->lowerLimit = rhs.lowerLimit;
this->upperLimit = rhs.upperLimit;
copyBaseVariables( (PreProcessing*)&rhs );
}
DeadZone::~DeadZone(){
}
DeadZone& DeadZone::operator=(const DeadZone &rhs){
if(this!=&rhs){
this->lowerLimit = rhs.lowerLimit;
this->upperLimit = rhs.upperLimit;
copyBaseVariables( (PreProcessing*)&rhs );
}
return *this;
}
bool DeadZone::clone(const PreProcessing *preProcessing){
if( preProcessing == NULL ) return false;
if( this->getPreProcessingType() == preProcessing->getPreProcessingType() ){
DeadZone *ptr = (DeadZone*)preProcessing;
//Clone the DeadZone values
this->lowerLimit = ptr->lowerLimit;
this->upperLimit = ptr->upperLimit;
//Clone the base class variables
return copyBaseVariables( preProcessing );
}
errorLog << "clone(const PreProcessing *preProcessing) - PreProcessing Types Do Not Match!" << endl;
return false;
}
bool DeadZone::process(const vector< double > &inputVector){
#ifdef GRT_SAFE_CHECKING
if( !initialized ){
errorLog << "process(const vector< double > &inputVector) - Not initialized!" << endl;
return false;
}
if( inputVector.size() != numInputDimensions ){
errorLog << "process(const vector< double > &inputVector) - The size of the inputVector (" << inputVector.size() << ") does not match that of the filter (" << numInputDimensions << ")!" << endl;
return false;
}
#endif
filter( inputVector );
if( processedData.size() == numOutputDimensions ) return true;
return false;
}
bool DeadZone::reset(){
return true;
}
bool DeadZone::saveSettingsToFile(string filename){
if( !initialized ){
errorLog << "saveSettingsToFile(string filename) - The DeadZone has not been initialized" << endl;
return false;
}
std::fstream file;
file.open(filename.c_str(), std::ios::out);
if( !saveSettingsToFile( file ) ){
file.close();
return false;
}
file.close();
return true;
}
bool DeadZone::saveSettingsToFile(fstream &file){
if( !file.is_open() ){
errorLog << "saveSettingsToFile(fstream &file) - The file is not open!" << endl;
return false;
}
file << "GRT_DEAD_ZONE_FILE_V1.0" << endl;
file << "NumInputDimensions: " << numInputDimensions << endl;
file << "NumOutputDimensions: " << numOutputDimensions << endl;
file << "LowerLimit: " << lowerLimit << endl;
file << "UpperLimit: " << upperLimit << endl;
return true;
}
bool DeadZone::loadSettingsFromFile(string filename){
std::fstream file;
file.open(filename.c_str(), std::ios::in);
if( !loadSettingsFromFile( file ) ){
file.close();
initialized = false;
return false;
}
file.close();
return true;
}
bool DeadZone::loadSettingsFromFile(fstream &file){
if( !file.is_open() ){
errorLog << "loadSettingsFromFile(fstream &file) - The file is not open!" << endl;
return false;
}
string word;
//Load the header
file >> word;
if( word != "GRT_DEAD_ZONE_FILE_V1.0" ){
errorLog << "loadSettingsFromFile(fstream &file) - Invalid file format!" << endl;
return false;
}
//Load the number of input dimensions
file >> word;
if( word != "NumInputDimensions:" ){
errorLog << "loadSettingsFromFile(fstream &file) - Failed to read NumInputDimensions header!" << endl;
return false;
}
file >> numInputDimensions;
//Load the number of output dimensions
file >> word;
if( word != "NumOutputDimensions:" ){
errorLog << "loadSettingsFromFile(fstream &file) - Failed to read NumOutputDimensions header!" << endl;
return false;
}
file >> numOutputDimensions;
//Load the lower limit
file >> word;
if( word != "LowerLimit:" ){
errorLog << "loadSettingsFromFile(fstream &file) - Failed to read LowerLimit header!" << endl;
return false;
}
file >> lowerLimit;
file >> word;
if( word != "UpperLimit:" ){
errorLog << "loadSettingsFromFile(fstream &file) - Failed to read UpperLimit header!" << endl;
return false;
}
file >> upperLimit;
//Init the deadzone module to ensure everything is initialized correctly
return init(lowerLimit,upperLimit,numInputDimensions);
}
bool DeadZone::init(double lowerLimit,double upperLimit,UINT numDimensions){
initialized = false;
#ifdef GRT_SAFE_CHECKING
if( numDimensions == 0 ){
errorLog << "init(double lowerLimit,double upperLimit,UINT numDimensions) - NumDimensions must be greater than 0!" << endl;
return false;
}
if( lowerLimit >= upperLimit ){
errorLog << "init(double lowerLimit,double upperLimit,UINT numDimensions) - The lower limit must be less than the upperlimit!" << endl;
return false;
}
#endif
this->lowerLimit = lowerLimit;
this->upperLimit = upperLimit;
this->numInputDimensions = numDimensions;
this->numOutputDimensions = numDimensions;
processedData.clear();
processedData.resize(numOutputDimensions,0);
initialized = true;
return true;
}
double DeadZone::filter(double x){
vector< double > y = filter(vector<double>(1,x));
if( y.size() == 0 ) return 0;
return y[0];
}
vector< double > DeadZone::filter(const vector< double > &x){
#ifdef GRT_SAFE_CHECKING
if( !initialized ){
errorLog << "filter(vector< double > x) - Not Initialized!" << endl;
return vector<double>();
}
if( x.size() != numInputDimensions ){
errorLog << "filter(vector< double > x) - The Number Of Input Dimensions (" << numInputDimensions << ") does not match the size of the input vector (" << x.size() << ")!" << endl;
return vector<double>();
}
#endif
for(UINT n=0; n<numInputDimensions; n++){
if( x[n] > lowerLimit && x[n] < upperLimit ){
processedData[n] = 0;
}else{
if( x[n] >= upperLimit ) processedData[n] = x[n] - upperLimit;
else processedData[n] = x[n] - lowerLimit;
}
}
return processedData;
}
bool DeadZone::setLowerLimit(double lowerLimit){
this->lowerLimit = lowerLimit;
return true;
}
bool DeadZone::setUpperLimit(double upperLimit){
this->upperLimit = upperLimit;
return true;
}
}//End of namespace GRT
|
/*
Copyright (C) 2004, 2005, 2006 Nikolas Zimmermann <zimmermann@kde.org>
2004, 2005 Rob Buis <buis@kde.org>
This file is part of the KDE project
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "wtf/Platform.h"
#if ENABLE(SVG)
#include "SVGPathSegLinetoHorizontal.h"
#include "SVGStyledElement.h"
namespace WebCore
{
SVGPathSegLinetoHorizontalAbs::SVGPathSegLinetoHorizontalAbs(float x)
: SVGPathSeg()
, m_x(x)
{
}
SVGPathSegLinetoHorizontalAbs::~SVGPathSegLinetoHorizontalAbs()
{
}
void SVGPathSegLinetoHorizontalAbs::setX(float x)
{
m_x = x;
}
float SVGPathSegLinetoHorizontalAbs::x() const
{
return m_x;
}
SVGPathSegLinetoHorizontalRel::SVGPathSegLinetoHorizontalRel(float x)
: SVGPathSeg()
, m_x(x)
{
}
SVGPathSegLinetoHorizontalRel::~SVGPathSegLinetoHorizontalRel()
{
}
void SVGPathSegLinetoHorizontalRel::setX(float x)
{
m_x = x;
}
float SVGPathSegLinetoHorizontalRel::x() const
{
return m_x;
}
}
#endif // ENABLE(SVG)
|
//
// detail/pop_options.hpp
// ~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2018 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// No header guard
#if defined(__COMO__)
// Comeau C++
#elif defined(__DMC__)
// Digital Mars C++
#elif defined(__INTEL_COMPILER) || defined(__ICL) \
|| defined(__ICC) || defined(__ECC)
// Intel C++
# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
# pragma GCC visibility pop
# endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
#elif defined(__clang__)
// Clang
# if defined(__OBJC__)
# if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1)
# if defined(ASIO_OBJC_WORKAROUND)
# undef Protocol
# undef id
# undef ASIO_OBJC_WORKAROUND
# endif
# endif
# endif
# if !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32)
# pragma GCC visibility pop
# endif // !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32)
#elif defined(__GNUC__)
// GNU C++
# if defined(__MINGW32__) || defined(__CYGWIN__)
# pragma pack (pop)
# endif
# if defined(__OBJC__)
# if !defined(__APPLE_CC__) || (__APPLE_CC__ <= 1)
# if defined(ASIO_OBJC_WORKAROUND)
# undef Protocol
# undef id
# undef ASIO_OBJC_WORKAROUND
# endif
# endif
# endif
# if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
# pragma GCC visibility pop
# endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 4)
# if (__GNUC__ >= 7)
# pragma GCC diagnostic pop
# endif // (__GNUC__ >= 7)
#elif defined(__KCC)
// Kai C++
#elif defined(__sgi)
// SGI MIPSpro C++
#elif defined(__DECCXX)
// Compaq Tru64 Unix cxx
#elif defined(__ghs)
// Greenhills C++
#elif defined(__BORLANDC__)
// Borland C++
# pragma option pop
# pragma nopushoptwarn
# pragma nopackwarning
#elif defined(__MWERKS__)
// Metrowerks CodeWarrior
#elif defined(__SUNPRO_CC)
// Sun Workshop Compiler C++
#elif defined(__HP_aCC)
// HP aCC
#elif defined(__MRC__) || defined(__SC__)
// MPW MrCpp or SCpp
#elif defined(__IBMCPP__)
// IBM Visual Age
#elif defined(_MSC_VER)
// Microsoft Visual C++
//
// Must remain the last #elif since some other vendors (Metrowerks, for example)
// also #define _MSC_VER
# pragma warning (pop)
# pragma pack (pop)
# if defined(__cplusplus_cli) || defined(__cplusplus_winrt)
# if defined(ASIO_CLR_WORKAROUND)
# undef generic
# undef ASIO_CLR_WORKAROUND
# endif
# endif
#endif
|
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! [all code]
//! [bigtable includes]
#include "google/cloud/bigtable/table.h"
#include "google/cloud/bigtable/table_admin.h"
//! [bigtable includes]
#include <google/protobuf/text_format.h>
#include <deque>
#include <list>
#include <sstream>
namespace {
/**
* The key used for ReadRow(), ReadModifyWrite(), CheckAndMutate.
*
* Using the same key makes it possible for the user to see the effect of
* the different APIs on one row.
*/
const std::string MAGIC_ROW_KEY = "key-000009";
struct Usage {
std::string msg;
};
char const* ConsumeArg(int& argc, char* argv[]) {
if (argc < 2) {
return nullptr;
}
char const* result = argv[1];
std::copy(argv + 2, argv + argc, argv + 1);
argc--;
return result;
}
std::string command_usage;
void PrintUsage(int argc, char* argv[], std::string const& msg) {
std::string const cmd = argv[0];
auto last_slash = std::string(cmd).find_last_of('/');
auto program = cmd.substr(last_slash + 1);
std::cerr << msg << "\nUsage: " << program << " <command> [arguments]\n\n"
<< "Commands:\n"
<< command_usage << "\n";
}
void Apply(google::cloud::bigtable::Table table, int argc, char* argv[]) {
if (argc != 1) {
throw Usage{"apply: <project-id> <instance-id> <table-id>"};
}
//! [apply] [START bigtable_create_row]
[](google::cloud::bigtable::Table table) {
// Write several rows with some trivial data.
for (int i = 0; i != 20; ++i) {
// Note: This example uses sequential numeric IDs for simplicity, but
// this can result in poor performance in a production application.
// Since rows are stored in sorted order by key, sequential keys can
// result in poor distribution of operations across nodes.
//
// For more information about how to design a Bigtable schema for the
// best performance, see the documentation:
//
// https://cloud.google.com/bigtable/docs/schema-design
char buf[32];
snprintf(buf, sizeof(buf), "key-%06d", i);
google::cloud::bigtable::SingleRowMutation mutation(buf);
mutation.emplace_back(google::cloud::bigtable::SetCell(
"fam", "col0", "value0-" + std::to_string(i)));
mutation.emplace_back(google::cloud::bigtable::SetCell(
"fam", "col1", "value2-" + std::to_string(i)));
mutation.emplace_back(google::cloud::bigtable::SetCell(
"fam", "col2", "value3-" + std::to_string(i)));
mutation.emplace_back(google::cloud::bigtable::SetCell(
"fam", "col3", "value4-" + std::to_string(i)));
google::cloud::Status status = table.Apply(std::move(mutation));
if (!status.ok()) {
throw std::runtime_error(status.message());
}
}
}
//! [apply] [END bigtable_create_row]
(std::move(table));
}
void BulkApply(google::cloud::bigtable::Table table, int argc, char* argv[]) {
if (argc != 1) {
throw Usage{"bulk-apply: <project-id> <instance-id> <table-id>"};
}
//! [bulk apply] [START bigtable_mutate_insert_rows]
[](google::cloud::bigtable::Table table) {
// Write several rows in a single operation, each row has some trivial data.
google::cloud::bigtable::BulkMutation bulk;
for (int i = 0; i != 5000; ++i) {
// Note: This example uses sequential numeric IDs for simplicity, but
// this can result in poor performance in a production application.
// Since rows are stored in sorted order by key, sequential keys can
// result in poor distribution of operations across nodes.
//
// For more information about how to design a Bigtable schema for the
// best performance, see the documentation:
//
// https://cloud.google.com/bigtable/docs/schema-design
char buf[32];
snprintf(buf, sizeof(buf), "key-%06d", i);
google::cloud::bigtable::SingleRowMutation mutation(buf);
mutation.emplace_back(google::cloud::bigtable::SetCell(
"fam", "col0", "value0-" + std::to_string(i)));
mutation.emplace_back(google::cloud::bigtable::SetCell(
"fam", "col1", "value2-" + std::to_string(i)));
mutation.emplace_back(google::cloud::bigtable::SetCell(
"fam", "col2", "value3-" + std::to_string(i)));
mutation.emplace_back(google::cloud::bigtable::SetCell(
"fam", "col3", "value4-" + std::to_string(i)));
bulk.emplace_back(std::move(mutation));
}
auto failures = table.BulkApply(std::move(bulk));
if (!failures.empty()) {
auto status = failures.front().status();
throw std::runtime_error(status.message());
}
}
//! [bulk apply] [END bigtable_mutate_insert_rows]
(std::move(table));
}
void ReadRow(google::cloud::bigtable::Table table, int argc, char* argv[]) {
if (argc != 1) {
throw Usage{"read-row: <project-id> <instance-id> <table-id>"};
}
//! [read row] [START bigtable_get_row] [START bigtable_read_error]
[](google::cloud::bigtable::Table table) {
// Filter the results, only include the latest value on each cell.
auto filter = google::cloud::bigtable::Filter::Latest(1);
// Read a row, this returns a tuple (bool, row)
auto tuple = table.ReadRow(MAGIC_ROW_KEY, std::move(filter));
if (!tuple) {
throw std::runtime_error(tuple.status().message());
}
if (!tuple->first) {
std::cout << "Row " << MAGIC_ROW_KEY << " not found\n";
return;
}
std::cout << "key: " << tuple->second.row_key() << "\n";
for (auto& cell : tuple->second.cells()) {
std::cout << " " << cell.family_name() << ":"
<< cell.column_qualifier() << " = <";
if (cell.column_qualifier() == "counter") {
// This example uses "counter" to store 64-bit numbers in big-endian
// format, extract them as follows:
std::cout << cell.decode_big_endian_integer<std::int64_t>().value();
} else {
std::cout << cell.value();
}
std::cout << ">\n";
}
std::cout << std::flush;
}
//! [read row] [END bigtable_get_row] [END bigtable_read_error]
(std::move(table));
}
void ReadRows(google::cloud::bigtable::Table table, int argc, char* argv[]) {
if (argc != 1) {
throw Usage{"read-rows: <project-id> <instance-id> <table-id>"};
}
//! [read rows] [START bigtable_get_rows] [START bigtable_table_readstream]
// [START bigtable_read_range]
[](google::cloud::bigtable::Table table) {
// Create the range of rows to read.
auto range =
google::cloud::bigtable::RowRange::Range("key-000010", "key-000020");
// Filter the results, only include values from the "col0" column in the
// "fam" column family, and only get the latest value.
auto filter = google::cloud::bigtable::Filter::Chain(
google::cloud::bigtable::Filter::ColumnRangeClosed("fam", "col0",
"col0"),
google::cloud::bigtable::Filter::Latest(1));
// Read and print the rows.
for (auto const& row : table.ReadRows(range, filter)) {
if (!row) {
throw std::runtime_error(row.status().message());
}
if (row->cells().size() != 1) {
std::ostringstream os;
os << "Unexpected number of cells in " << row->row_key();
throw std::runtime_error(os.str());
}
auto const& cell = row->cells().at(0);
std::cout << cell.row_key() << " = [" << cell.value() << "]\n";
}
std::cout << std::flush;
}
// [END bigtable_read_range]
//! [read rows] [END bigtable_get_rows] [END bigtable_table_readstream]
(std::move(table));
}
void ReadRowsWithLimit(google::cloud::bigtable::Table table, int argc,
char* argv[]) {
if (argc != 1) {
throw Usage{"read-rows-with-limit: <project-id> <instance-id> <table-id>"};
}
//! [read rows with limit] [START bigtable_read_filter]
[](google::cloud::bigtable::Table table) {
// Create the range of rows to read.
auto range =
google::cloud::bigtable::RowRange::Range("key-000010", "key-000020");
// Filter the results, only include values from the "col0" column in the
// "fam" column family, and only get the latest value.
auto filter = google::cloud::bigtable::Filter::Chain(
google::cloud::bigtable::Filter::ColumnRangeClosed("fam", "col0",
"col0"),
google::cloud::bigtable::Filter::Latest(1));
// Read and print the first 5 rows in the range.
for (auto const& row : table.ReadRows(range, 5, filter)) {
if (!row) {
throw std::runtime_error(row.status().message());
}
if (row->cells().size() != 1) {
std::ostringstream os;
os << "Unexpected number of cells in " << row->row_key();
throw std::runtime_error(os.str());
}
auto const& cell = row->cells().at(0);
std::cout << cell.row_key() << " = [" << cell.value() << "]\n";
}
std::cout << std::flush;
}
//! [read rows with limit] [END bigtable_read_filter]
(std::move(table));
}
void PopulateTableHierarchy(google::cloud::bigtable::Table table, int argc,
char* argv[]) {
if (argc != 1) {
throw Usage{
"populate-table-hierarchy: <project-id> <instance-id> <table-id>"};
}
//! [populate table hierarchy]
[](google::cloud::bigtable::Table table) {
// Write several rows.
int q = 0;
for (int i = 0; i != 4; ++i) {
for (int j = 0; j != 4; ++j) {
for (int k = 0; k != 4; ++k) {
std::string row_key = "root/" + std::to_string(i) + "/";
row_key += std::to_string(j) + "/";
row_key += std::to_string(k);
google::cloud::bigtable::SingleRowMutation mutation(row_key);
mutation.emplace_back(google::cloud::bigtable::SetCell(
"fam", "col0", "value-" + std::to_string(q)));
++q;
google::cloud::Status status = table.Apply(std::move(mutation));
if (!status.ok()) {
throw std::runtime_error(status.message());
}
}
}
}
}
//! [populate table hierarchy]
(std::move(table));
}
void ReadKeysSet(google::cloud::bigtable::Table table, int argc, char* argv[]) {
if (argc < 3) {
throw Usage{
"read-keys-set <project-id> <instance-id> <table-id>"
" key1 [key2 ...]"};
}
std::vector<std::string> row_keys;
while (argc > 1) {
row_keys.emplace_back(ConsumeArg(argc, argv));
}
// [START bigtable_read_keys_set]
namespace cbt = google::cloud::bigtable;
[](cbt::Table table, std::vector<std::string> row_keys) {
auto row_set = cbt::RowSet();
for (auto const& row_key : row_keys) {
row_set.Append(row_key);
}
auto filter = google::cloud::bigtable::Filter::Latest(1);
for (auto& row : table.ReadRows(std::move(row_set), filter)) {
if (!row) {
throw std::runtime_error(row.status().message());
}
std::cout << row->row_key() << ":\n";
for (auto& cell : row->cells()) {
std::cout << "\t" << cell.family_name() << ":"
<< cell.column_qualifier() << " @ "
<< cell.timestamp().count() << "us\n"
<< "\t\"" << cell.value() << '"' << "\n";
}
}
std::cout << std::flush;
}
// [END bigtable_read_keys_set]
(std::move(table), std::move(row_keys));
}
void ReadRowSetPrefix(google::cloud::bigtable::Table table, int argc,
char* argv[]) {
if (argc != 2) {
throw Usage{
"read-rowset-prefix: <project-id> <instance-id> <table-id> <prefix>"};
}
std::string prefix = ConsumeArg(argc, argv);
//! [read rowset prefix] [START bigtable_read_prefix]
[](google::cloud::bigtable::Table table, std::string prefix) {
namespace cbt = google::cloud::bigtable;
auto row_set = cbt::RowSet();
auto range_prefix = cbt::RowRange::Prefix(prefix);
row_set.Append(range_prefix);
auto filter = google::cloud::bigtable::Filter::Latest(1);
for (auto& row : table.ReadRows(std::move(row_set), filter)) {
if (!row) {
throw std::runtime_error(row.status().message());
}
std::cout << row->row_key() << ":\n";
for (auto& cell : row->cells()) {
std::cout << "\t" << cell.family_name() << ":"
<< cell.column_qualifier() << " @ "
<< cell.timestamp().count() << "us\n"
<< "\t\"" << cell.value() << '"' << "\n";
}
}
std::cout << std::flush;
}
//! [read rowset prefix] [END bigtable_read_prefix]
(std::move(table), prefix);
}
void ReadPrefixList(google::cloud::bigtable::Table table, int argc,
char* argv[]) {
if (argc < 2) {
throw Usage{
"read-prefix-list: <project-id> <instance-id> <table-id> "
"[prefixes]"};
}
std::vector<std::string> prefix_list;
while (argc > 1) {
prefix_list.emplace_back(ConsumeArg(argc, argv));
}
//! [read prefix list] [START bigtable_read_prefix_list]
[](google::cloud::bigtable::Table table,
std::vector<std::string> prefix_list) {
namespace cbt = google::cloud::bigtable;
auto row_set = cbt::RowSet();
auto filter = google::cloud::bigtable::Filter::Latest(1);
for (auto prefix : prefix_list) {
auto row_range_prefix = cbt::RowRange::Prefix(prefix);
row_set.Append(row_range_prefix);
}
for (auto& row : table.ReadRows(std::move(row_set), filter)) {
if (!row) {
throw std::runtime_error(row.status().message());
}
std::cout << row->row_key() << ":\n";
for (auto& cell : row->cells()) {
std::cout << "\t" << cell.family_name() << ":"
<< cell.column_qualifier() << " @ "
<< cell.timestamp().count() << "us\n"
<< "\t\"" << cell.value() << '"' << "\n";
}
}
std::cout << std::flush;
}
//! [read prefix list] [END bigtable_read_prefix_list]
(std::move(table), prefix_list);
}
void ReadMultipleRanges(google::cloud::bigtable::Table table, int argc,
char* argv[]) {
if (argc < 3) {
throw Usage{
"read-multiple-ranges <project-id> <instance-id> <table-id>"
" <begin1> <end1> [<begin2> <end2> ...]"};
}
std::vector<std::pair<std::string, std::string>> ranges;
while (argc > 1) {
auto begin = ConsumeArg(argc, argv);
if (argc <= 1) {
throw Usage{"read-multiple-ranges - error: mismatched [begin,end) pair"};
}
auto end = ConsumeArg(argc, argv);
ranges.emplace_back(std::make_pair(begin, end));
}
// [START bigtable_read_multiple_ranges]
namespace cbt = google::cloud::bigtable;
[](cbt::Table table,
std::vector<std::pair<std::string, std::string>> ranges) {
auto row_set = cbt::RowSet();
for (auto&& range : ranges) {
row_set.Append(cbt::RowRange::Range(range.first, range.second));
}
auto filter = cbt::Filter::Latest(1);
for (auto& row : table.ReadRows(std::move(row_set), filter)) {
if (!row) {
throw std::runtime_error(row.status().message());
}
std::cout << row->row_key() << ":\n";
for (auto& cell : row->cells()) {
std::cout << "\t" << cell.family_name() << ":"
<< cell.column_qualifier() << " @ "
<< cell.timestamp().count() << "us\n"
<< "\t\"" << cell.value() << '"' << "\n";
}
}
}
// [END bigtable_read_multiple_ranges]
(std::move(table), std::move(ranges));
}
void CheckAndMutate(google::cloud::bigtable::Table table, int argc,
char* argv[]) {
if (argc != 1) {
throw Usage{"check-and-mutate: <project-id> <instance-id> <table-id>"};
}
//! [check and mutate] [START bigtable_row_filter]
[](google::cloud::bigtable::Table table) {
// Check if the latest value of the flip-flop column is "on".
auto predicate = google::cloud::bigtable::Filter::Chain(
google::cloud::bigtable::Filter::ColumnRangeClosed("fam", "flip-flop",
"flip-flop"),
google::cloud::bigtable::Filter::Latest(1),
google::cloud::bigtable::Filter::ValueRegex("on"));
// If the predicate matches, change the latest value to "off", otherwise,
// change the latest value to "on". Modify the "flop-flip" column at the
// same time.
auto mut = table.CheckAndMutateRow(
MAGIC_ROW_KEY, std::move(predicate),
{google::cloud::bigtable::SetCell("fam", "flip-flop", "off"),
google::cloud::bigtable::SetCell("fam", "flop-flip", "on")},
{google::cloud::bigtable::SetCell("fam", "flip-flop", "on"),
google::cloud::bigtable::SetCell("fam", "flop-flip", "off")});
if (!mut) {
throw std::runtime_error(mut.status().message());
}
}
//! [check and mutate] [END bigtable_row_filter]
(std::move(table));
}
void ReadModifyWrite(google::cloud::bigtable::Table table, int argc,
char* argv[]) {
if (argc != 1) {
throw Usage{"read-modify-write: <project-id> <instance-id> <table-id>"};
}
//! [read modify write] [START bigtable_row_increment]
[](google::cloud::bigtable::Table table) {
auto row = table.ReadModifyWriteRow(
MAGIC_ROW_KEY,
google::cloud::bigtable::ReadModifyWriteRule::IncrementAmount(
"fam", "counter", 1),
google::cloud::bigtable::ReadModifyWriteRule::AppendValue("fam", "list",
";element"));
if (!row) {
throw std::runtime_error(row.status().message());
}
std::cout << row->row_key() << "\n";
}
//! [read modify write] [END bigtable_row_increment]
(std::move(table));
}
void SampleRows(google::cloud::bigtable::Table table, int argc, char* argv[]) {
if (argc != 1) {
throw Usage{"sample-rows: <project-id> <instance-id> <table-id>"};
}
//! [sample row keys] [START bigtable_table_sample_splits]
[](google::cloud::bigtable::Table table) {
auto samples = table.SampleRows<>();
if (!samples) {
throw std::runtime_error(samples.status().message());
}
for (auto const& sample : *samples) {
std::cout << "key=" << sample.row_key << " - " << sample.offset_bytes
<< "\n";
}
std::cout << std::flush;
}
//! [sample row keys] [END bigtable_table_sample_splits]
(std::move(table));
}
void SampleRowsCollections(google::cloud::bigtable::Table table, int argc,
char* argv[]) {
if (argc != 1) {
throw Usage{
"sample-rows-collections: <project-id> <instance-id> <table-id>"};
}
//! [sample row keys collections]
[](google::cloud::bigtable::Table table) {
auto list_samples = table.SampleRows<std::list>();
if (!list_samples) {
throw std::runtime_error(list_samples.status().message());
}
for (auto const& sample : *list_samples) {
std::cout << "key=" << sample.row_key << " - " << sample.offset_bytes
<< "\n";
}
auto deque_samples = table.SampleRows<std::deque>();
if (!deque_samples) {
throw std::runtime_error(deque_samples.status().message());
}
for (auto const& sample : *deque_samples) {
std::cout << "key=" << sample.row_key << " - " << sample.offset_bytes
<< "\n";
}
std::cout << std::flush;
}
//! [sample row keys collections]
(std::move(table));
}
void GetFamily(google::cloud::bigtable::Table table, int argc, char* argv[]) {
if (argc != 1) {
throw Usage{"get-family: <project-id> <instance-id> <table-id>"};
}
//! [get family] [START bigtable_get_family] [START bigtable_family_ref]
[](google::cloud::bigtable::Table table) {
// Create the range of rows to read.
auto range = google::cloud::bigtable::RowRange::InfiniteRange();
// Filter the results, only get the latest value
auto filter = google::cloud::bigtable::Filter::Latest(1);
// Read and print the family name.
for (auto const& row : table.ReadRows(range, filter)) {
if (!row) {
throw std::runtime_error(row.status().message());
}
auto const& cell = row->cells().at(0);
std::cout << cell.family_name() << "\n";
break;
}
std::cout << std::flush;
}
//! [get family] [END bigtable_get_family] [END bigtable_family_ref]
(std::move(table));
}
void DeleteAllCells(google::cloud::bigtable::Table table, int argc,
char* argv[]) {
if (argc != 2) {
throw Usage{
"delete-all-cells: <project-id> <instance-id> <table-id> <row-key>"};
}
auto row_key = ConsumeArg(argc, argv);
//! [delete all cells] [START bigtable_delete_all_cells]
[](google::cloud::bigtable::Table table, std::string row_key) {
auto status = table.Apply(google::cloud::bigtable::SingleRowMutation(
row_key, google::cloud::bigtable::DeleteFromRow()));
if (!status.ok()) {
throw std::runtime_error(status.message());
}
}
//! [delete all cells] [END bigtable_delete_all_cells]
(std::move(table), row_key);
}
void DeleteFamilyCells(google::cloud::bigtable::Table table, int argc,
char* argv[]) {
if (argc != 3) {
throw Usage{
"delete-family-cells: <project-id> <instance-id> <table-id> "
"<row-key> <family-name>"};
}
auto row_key = ConsumeArg(argc, argv);
auto family_name = ConsumeArg(argc, argv);
//! [delete family cells] [START bigtable_delete_family_cells]
[](google::cloud::bigtable::Table table, std::string row_key,
std::string family_name) {
// Delete all cells within a family.
auto status = table.Apply(google::cloud::bigtable::SingleRowMutation(
row_key, google::cloud::bigtable::DeleteFromFamily(family_name)));
if (!status.ok()) {
throw std::runtime_error(status.message());
}
}
//! [delete family cells] [END bigtable_delete_family_cells]
(std::move(table), row_key, family_name);
}
void DeleteSelectiveFamilyCells(google::cloud::bigtable::Table table, int argc,
char* argv[]) {
if (argc != 4) {
throw Usage{
"delete-selective-family-cells: <project-id> <instance-id> <table-id> "
"<row-key> <family-name> <column-name>"};
}
auto row_key = ConsumeArg(argc, argv);
auto family_name = ConsumeArg(argc, argv);
auto column_name = ConsumeArg(argc, argv);
//! [delete selective family cells]
// [START bigtable_delete_selective_family_cells]
[](google::cloud::bigtable::Table table, std::string row_key,
std::string family_name, std::string column_name) {
// Delete selective cell within a family.
auto status = table.Apply(google::cloud::bigtable::SingleRowMutation(
row_key,
google::cloud::bigtable::DeleteFromColumn(family_name, column_name)));
if (!status.ok()) {
throw std::runtime_error(status.message());
}
}
// [END bigtable_delete_selective_family_cells]
//! [delete selective family cells]
(std::move(table), row_key, family_name, column_name);
}
void RowExists(google::cloud::bigtable::Table table, int argc, char* argv[]) {
if (argc != 2) {
throw Usage{"row-exists: <project-id> <instance-id> <table-id> <row-key>"};
}
auto row_key = ConsumeArg(argc, argv);
//! [row exists] [START bigtable_row_exists]
[](google::cloud::bigtable::Table table, std::string row_key) {
// Filter the results, turn any value into an empty string.
auto filter = google::cloud::bigtable::Filter::StripValueTransformer();
// Read a row, this returns a tuple (bool, row)
auto status = table.ReadRow(row_key, std::move(filter));
if (!status) {
throw std::runtime_error("Table does not exist!");
}
if (!status->first) {
std::cout << "Row not found\n";
return;
}
std::cout << "Row exists.\n";
}
//! [row exists] [END bigtable_row_exists]
(std::move(table), row_key);
}
} // anonymous namespace
int main(int argc, char* argv[]) try {
using CommandType =
std::function<void(google::cloud::bigtable::Table, int, char* [])>;
std::map<std::string, CommandType> commands = {
{"apply", &Apply},
{"bulk-apply", &BulkApply},
{"read-row", &ReadRow},
{"read-rows", &ReadRows},
{"populate-table-hierarchy", &PopulateTableHierarchy},
{"read-keys-set", &ReadKeysSet},
{"read-rowset-prefix", &ReadRowSetPrefix},
{"read-prefix-list", &ReadPrefixList},
{"read-multiple-ranges", &ReadMultipleRanges},
{"read-rows-with-limit", &ReadRowsWithLimit},
{"check-and-mutate", &CheckAndMutate},
{"read-modify-write", &ReadModifyWrite},
{"sample-rows", &SampleRows},
{"sample-rows-collections", &SampleRowsCollections},
{"get-family", &GetFamily},
{"delete-all-cells", &DeleteAllCells},
{"delete-family-cells", &DeleteFamilyCells},
{"delete-selective-family-cells", &DeleteSelectiveFamilyCells},
{"row-exists", &RowExists}};
{
// Force each command to generate its Usage string, so we can provide a good
// usage string for the whole program. We need to create an Table
// object to do this, but that object is never used, it is passed to the
// commands, without any calls made to it.
google::cloud::bigtable::Table unused(
google::cloud::bigtable::CreateDefaultDataClient(
"unused-project", "Unused-instance",
google::cloud::bigtable::ClientOptions()),
"Unused-table");
for (auto&& kv : commands) {
try {
int fake_argc = 0;
kv.second(unused, fake_argc, argv);
} catch (Usage const& u) {
command_usage += " ";
command_usage += u.msg;
command_usage += "\n";
} catch (...) {
// ignore other exceptions.
}
}
}
if (argc < 5) {
PrintUsage(argc, argv,
"Missing command and/or project-id/ or instance-id or table-id");
return 1;
}
std::string const command_name = ConsumeArg(argc, argv);
std::string const project_id = ConsumeArg(argc, argv);
std::string const instance_id = ConsumeArg(argc, argv);
std::string const table_id = ConsumeArg(argc, argv);
auto command = commands.find(command_name);
if (commands.end() == command) {
PrintUsage(argc, argv, "Unknown command: " + command_name);
return 1;
}
// Connect to the Cloud Bigtable endpoint.
//! [connect data]
google::cloud::bigtable::Table table(
google::cloud::bigtable::CreateDefaultDataClient(
project_id, instance_id, google::cloud::bigtable::ClientOptions()),
table_id);
//! [connect data]
command->second(table, argc, argv);
return 0;
} catch (Usage const& ex) {
PrintUsage(argc, argv, ex.msg);
return 1;
} catch (std::exception const& ex) {
std::cerr << "Standard C++ exception raised: " << ex.what() << "\n";
return 1;
}
//! [all code]
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/common/wm/overview/window_selector_controller.h"
#include <vector>
#include "ash/common/session/session_state_delegate.h"
#include "ash/common/system/tray/system_tray_delegate.h"
#include "ash/common/wm/mru_window_tracker.h"
#include "ash/common/wm/overview/window_selector.h"
#include "ash/common/wm/window_state.h"
#include "ash/common/wm_shell.h"
#include "ash/common/wm_window.h"
#include "base/metrics/histogram.h"
namespace ash {
WindowSelectorController::WindowSelectorController() {}
WindowSelectorController::~WindowSelectorController() {
// Destroy widgets that may be still animating if shell shuts down soon after
// exiting overview mode.
for (std::unique_ptr<DelayedAnimationObserver>& animation_observer :
delayed_animations_) {
animation_observer->Shutdown();
}
}
// static
bool WindowSelectorController::CanSelect() {
// Don't allow a window overview if the screen is locked or a modal dialog is
// open or running in kiosk app session.
SessionStateDelegate* session_state_delegate =
WmShell::Get()->GetSessionStateDelegate();
return session_state_delegate->IsActiveUserSessionStarted() &&
!session_state_delegate->IsScreenLocked() &&
!WmShell::Get()->IsSystemModalWindowOpen() &&
!WmShell::Get()->IsPinned() &&
WmShell::Get()->system_tray_delegate()->GetUserLoginStatus() !=
LoginStatus::KIOSK_APP;
}
void WindowSelectorController::ToggleOverview() {
if (IsSelecting()) {
OnSelectionEnded();
} else {
// Don't start overview if window selection is not allowed.
if (!CanSelect())
return;
std::vector<WmWindow*> windows =
WmShell::Get()->mru_window_tracker()->BuildMruWindowList();
auto end =
std::remove_if(windows.begin(), windows.end(),
std::not1(std::ptr_fun(&WindowSelector::IsSelectable)));
windows.resize(end - windows.begin());
// Don't enter overview mode with no windows.
if (windows.empty())
return;
WmShell::Get()->OnOverviewModeStarting();
window_selector_.reset(new WindowSelector(this));
window_selector_->Init(windows);
OnSelectionStarted();
}
}
bool WindowSelectorController::IsSelecting() {
return window_selector_.get() != NULL;
}
bool WindowSelectorController::IsRestoringMinimizedWindows() const {
return window_selector_.get() != NULL &&
window_selector_->restoring_minimized_windows();
}
// TODO(flackr): Make WindowSelectorController observe the activation of
// windows, so we can remove WindowSelectorDelegate.
void WindowSelectorController::OnSelectionEnded() {
window_selector_->Shutdown();
window_selector_.reset();
last_selection_time_ = base::Time::Now();
WmShell::Get()->OnOverviewModeEnded();
}
void WindowSelectorController::AddDelayedAnimationObserver(
std::unique_ptr<DelayedAnimationObserver> animation_observer) {
animation_observer->SetOwner(this);
delayed_animations_.push_back(std::move(animation_observer));
}
void WindowSelectorController::RemoveAndDestroyAnimationObserver(
DelayedAnimationObserver* animation_observer) {
class IsEqual {
public:
explicit IsEqual(DelayedAnimationObserver* animation_observer)
: animation_observer_(animation_observer) {}
bool operator()(const std::unique_ptr<DelayedAnimationObserver>& other) {
return (other.get() == animation_observer_);
}
private:
const DelayedAnimationObserver* animation_observer_;
};
delayed_animations_.erase(
std::remove_if(delayed_animations_.begin(), delayed_animations_.end(),
IsEqual(animation_observer)),
delayed_animations_.end());
}
void WindowSelectorController::OnSelectionStarted() {
if (!last_selection_time_.is_null()) {
UMA_HISTOGRAM_LONG_TIMES("Ash.WindowSelector.TimeBetweenUse",
base::Time::Now() - last_selection_time_);
}
}
} // namespace ash
|
// Copyright (c) 2011-2014 The Bitcoin developers
// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2017 The PIVX developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "splashscreen.h"
#include "clientversion.h"
#include "init.h"
#include "networkstyle.h"
#include "ui_interface.h"
#include "util.h"
#include "version.h"
#ifdef ENABLE_WALLET
#include "wallet.h"
#endif
#include <QApplication>
#include <QCloseEvent>
#include <QDesktopWidget>
#include <QPainter>
SplashScreen::SplashScreen(Qt::WindowFlags f, const NetworkStyle* networkStyle) : QWidget(0, f), curAlignment(0)
{
// set reference point, paddings
int paddingLeft = 14;
int paddingTop = 470;
int titleVersionVSpace = 17;
// int titleCopyrightVSpace = 32;
float fontFactor = 1.0;
// define text to place
QString titleText = tr("Altbet Core");
QString versionText = QString(tr("Version %1")).arg(QString::fromStdString(FormatFullVersion()));
// QString copyrightTextBtc = QChar(0xA9) + QString(" 2009-%1 ").arg(COPYRIGHT_YEAR) + QString(tr("The Bitcoin Core developers"));
// QString copyrightTextDash = QChar(0xA9) + QString(" 2014-%1 ").arg(COPYRIGHT_YEAR) + QString(tr("The Dash Core developers"));
// QString copyrightTextPIVX = QChar(0xA9) + QString(" 2015-%1 ").arg(COPYRIGHT_YEAR) + QString(tr("The PIVX Core developers"));
// QString copyrightTextAltbet = QChar(0xA9) + QString(" 2017-%1 ").arg(COPYRIGHT_YEAR) + QString(tr("The Altbet Core developers"));
QString titleAddText = networkStyle->getTitleAddText();
QString font = QApplication::font().toString();
// load the bitmap for writing some text over it
pixmap = networkStyle->getSplashImage();
// pixmap = pixmap.scaled(QSize(400,400), Qt::KeepAspectRatio,Qt::SmoothTransformation);
QPainter pixPaint(&pixmap);
pixPaint.setRenderHint(QPainter::Antialiasing);
pixPaint.setRenderHint(QPainter::HighQualityAntialiasing);
pixPaint.setPen(QColor(73, 84, 94));
// check font size and drawing with
// pixPaint.setFont(QFont(font, 28 * fontFactor));
// QFontMetrics fm = pixPaint.fontMetrics();
// int titleTextWidth = fm.width(titleText);
// if (titleTextWidth > 160) {
// strange font rendering, Arial probably not found
// fontFactor = 0.75;
// }
// pixPaint.setFont(QFont(font, 28 * fontFactor));
// fm = pixPaint.fontMetrics();
//titleTextWidth = fm.width(titleText);
// pixPaint.drawText(paddingLeft, paddingTop, titleText);
// pixPaint.setFont(QFont(font, 15 * fontFactor));
// pixPaint.drawText(paddingLeft, paddingTop + titleVersionVSpace, versionText);
// // draw copyright stuff
// pixPaint.setFont(QFont(font, 10 * fontFactor));
// pixPaint.drawText(paddingLeft, paddingTop + titleCopyrightVSpace, copyrightTextBtc);
// pixPaint.drawText(paddingLeft, paddingTop + titleCopyrightVSpace + 12, copyrightTextDash);
// pixPaint.drawText(paddingLeft, paddingTop + titleCopyrightVSpace + 24, copyrightTextPIVX);
// pixPaint.drawText(paddingLeft, paddingTop + titleCopyrightVSpace + 36, copyrightTextAltbet);
// draw additional text if special network
// if (!titleAddText.isEmpty()) {
// QFont boldFont = QFont(font, 10 * fontFactor);
// boldFont.setWeight(QFont::Bold);
// pixPaint.setFont(boldFont);
// fm = pixPaint.fontMetrics();
// int titleAddTextWidth = fm.width(titleAddText);
// pixPaint.drawText(pixmap.width() - titleAddTextWidth - 10, pixmap.height() - 25, titleAddText);
// }
pixPaint.end();
// Set window title
setWindowTitle(titleText + " " + titleAddText);
// Resize window and move to center of desktop, disallow resizing
//QRect r(QPoint(), pixmap.size());
// QRect r(QPoint(), QSize(pixmap.size().width()/2, pixmap.size().height()/2)); //retina
QRect r(QPoint(), pixmap.size());
resize(r.size());
setFixedSize(r.size());
move(QApplication::desktop()->screenGeometry().center() - r.center());
subscribeToCoreSignals();
}
SplashScreen::~SplashScreen()
{
unsubscribeFromCoreSignals();
}
void SplashScreen::slotFinish(QWidget* mainWin)
{
Q_UNUSED(mainWin);
hide();
}
static void InitMessage(SplashScreen* splash, const std::string& message)
{
QMetaObject::invokeMethod(splash, "showMessage",
Qt::QueuedConnection,
Q_ARG(QString, QString::fromStdString(message)),
Q_ARG(int, Qt::AlignBottom | Qt::AlignHCenter),
Q_ARG(QColor, QColor(73, 84, 94)));
}
static void ShowProgress(SplashScreen* splash, const std::string& title, int nProgress)
{
InitMessage(splash, title + strprintf("%d", nProgress) + "%");
}
#ifdef ENABLE_WALLET
static void ConnectWallet(SplashScreen* splash, CWallet* wallet)
{
wallet->ShowProgress.connect(boost::bind(ShowProgress, splash, _1, _2));
}
#endif
void SplashScreen::subscribeToCoreSignals()
{
// Connect signals to client
uiInterface.InitMessage.connect(boost::bind(InitMessage, this, _1));
uiInterface.ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
#ifdef ENABLE_WALLET
uiInterface.LoadWallet.connect(boost::bind(ConnectWallet, this, _1));
#endif
}
void SplashScreen::unsubscribeFromCoreSignals()
{
// Disconnect signals from client
uiInterface.InitMessage.disconnect(boost::bind(InitMessage, this, _1));
uiInterface.ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
#ifdef ENABLE_WALLET
if (pwalletMain)
pwalletMain->ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
#endif
}
void SplashScreen::showMessage(const QString& message, int alignment, const QColor& color)
{
curMessage = message;
curAlignment = alignment;
curColor = color;
update();
}
void SplashScreen::paintEvent(QPaintEvent* event)
{
QPainter painter(this);
painter.drawPixmap(0, 0, pixmap);
QRect r = rect().adjusted(5, 5, -5, -5);
painter.setPen(curColor);
painter.drawText(r, curAlignment, curMessage);
}
void SplashScreen::closeEvent(QCloseEvent* event)
{
StartShutdown(); // allows an "emergency" shutdown during startup
event->ignore();
}
|
// Copyright (c) 2014-2020, The Monero Project
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "common/dns_utils.h"
#include "common/command_line.h"
#include "net/parse.h"
#include "daemon/command_parser_executor.h"
#undef MONERO_DEFAULT_LOG_CATEGORY
#define MONERO_DEFAULT_LOG_CATEGORY "daemon"
namespace daemonize {
t_command_parser_executor::t_command_parser_executor(
uint32_t ip
, uint16_t port
, const boost::optional<tools::login>& login
, const epee::net_utils::ssl_options_t& ssl_options
, bool is_rpc
, cryptonote::core_rpc_server* rpc_server
)
: m_executor(ip, port, login, ssl_options, is_rpc, rpc_server)
{}
bool t_command_parser_executor::print_peer_list(const std::vector<std::string>& args)
{
if (args.size() > 3)
{
std::cout << "use: print_pl [white] [gray] [<limit>] [pruned] [publicrpc]" << std::endl;
return true;
}
bool white = false;
bool gray = false;
bool pruned = false;
bool publicrpc = false;
size_t limit = 0;
for (size_t i = 0; i < args.size(); ++i)
{
if (args[i] == "white")
{
white = true;
}
else if (args[i] == "gray")
{
gray = true;
}
else if (args[i] == "pruned")
{
pruned = true;
}
else if (args[i] == "publicrpc")
{
publicrpc = true;
}
else if (!epee::string_tools::get_xtype_from_string(limit, args[i]))
{
std::cout << "unexpected argument: " << args[i] << std::endl;
return true;
}
}
const bool print_both = !white && !gray;
return m_executor.print_peer_list(white | print_both, gray | print_both, limit, pruned, publicrpc);
}
bool t_command_parser_executor::print_peer_list_stats(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.print_peer_list_stats();
}
bool t_command_parser_executor::save_blockchain(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.save_blockchain();
}
bool t_command_parser_executor::show_hash_rate(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.show_hash_rate();
}
bool t_command_parser_executor::hide_hash_rate(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.hide_hash_rate();
}
bool t_command_parser_executor::show_difficulty(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.show_difficulty();
}
bool t_command_parser_executor::show_status(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.show_status();
}
bool t_command_parser_executor::print_connections(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.print_connections();
}
bool t_command_parser_executor::print_net_stats(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.print_net_stats();
}
bool t_command_parser_executor::print_blockchain_info(const std::vector<std::string>& args)
{
if(!args.size())
{
std::cout << "need block index parameter" << std::endl;
return false;
}
uint64_t start_index = 0;
uint64_t end_index = 0;
if (args[0][0] == '-')
{
int64_t nblocks;
if(!epee::string_tools::get_xtype_from_string(nblocks, args[0]))
{
std::cout << "wrong number of blocks" << std::endl;
return false;
}
return m_executor.print_blockchain_info(nblocks, (uint64_t)-nblocks);
}
if(!epee::string_tools::get_xtype_from_string(start_index, args[0]))
{
std::cout << "wrong starter block index parameter" << std::endl;
return false;
}
if(args.size() >1 && !epee::string_tools::get_xtype_from_string(end_index, args[1]))
{
std::cout << "wrong end block index parameter" << std::endl;
return false;
}
return m_executor.print_blockchain_info(start_index, end_index);
}
bool t_command_parser_executor::set_log_level(const std::vector<std::string>& args)
{
if(args.size() > 1)
{
std::cout << "use: set_log [<log_level_number_0-4> | <categories>]" << std::endl;
return true;
}
if (args.empty())
{
return m_executor.set_log_categories("+");
}
uint16_t l = 0;
if(epee::string_tools::get_xtype_from_string(l, args[0]))
{
if(4 < l)
{
std::cout << "wrong number range, use: set_log <log_level_number_0-4>" << std::endl;
return true;
}
return m_executor.set_log_level(l);
}
else
{
return m_executor.set_log_categories(args.front());
}
}
bool t_command_parser_executor::print_height(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.print_height();
}
bool t_command_parser_executor::print_block(const std::vector<std::string>& args)
{
bool include_hex = false;
// Assumes that optional flags come after mandatory argument <transaction_hash>
for (unsigned int i = 1; i < args.size(); ++i) {
if (args[i] == "+hex")
include_hex = true;
else
{
std::cout << "unexpected argument: " << args[i] << std::endl;
return true;
}
}
if (args.empty())
{
std::cout << "expected: print_block (<block_hash> | <block_height>) [+hex]" << std::endl;
return false;
}
const std::string& arg = args.front();
try
{
uint64_t height = boost::lexical_cast<uint64_t>(arg);
return m_executor.print_block_by_height(height, include_hex);
}
catch (const boost::bad_lexical_cast&)
{
crypto::hash block_hash;
if (parse_hash256(arg, block_hash))
{
return m_executor.print_block_by_hash(block_hash, include_hex);
}
}
return false;
}
bool t_command_parser_executor::print_transaction(const std::vector<std::string>& args)
{
bool include_metadata = false;
bool include_hex = false;
bool include_json = false;
// Assumes that optional flags come after mandatory argument <transaction_hash>
for (unsigned int i = 1; i < args.size(); ++i) {
if (args[i] == "+meta")
include_metadata = true;
else if (args[i] == "+hex")
include_hex = true;
else if (args[i] == "+json")
include_json = true;
else
{
std::cout << "unexpected argument: " << args[i] << std::endl;
return true;
}
}
if (args.empty())
{
std::cout << "expected: print_tx <transaction_hash> [+meta] [+hex] [+json]" << std::endl;
return true;
}
const std::string& str_hash = args.front();
crypto::hash tx_hash;
if (parse_hash256(str_hash, tx_hash))
{
m_executor.print_transaction(tx_hash, include_metadata, include_hex, include_json);
}
return true;
}
bool t_command_parser_executor::is_key_image_spent(const std::vector<std::string>& args)
{
if (args.empty())
{
std::cout << "expected: is_key_image_spent <key_image>" << std::endl;
return true;
}
const std::string& str = args.front();
crypto::key_image ki;
crypto::hash hash;
if (parse_hash256(str, hash))
{
memcpy(&ki, &hash, sizeof(ki));
m_executor.is_key_image_spent(ki);
}
return true;
}
bool t_command_parser_executor::print_transaction_pool_long(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.print_transaction_pool_long();
}
bool t_command_parser_executor::print_transaction_pool_short(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.print_transaction_pool_short();
}
bool t_command_parser_executor::print_transaction_pool_stats(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.print_transaction_pool_stats();
}
bool t_command_parser_executor::start_mining(const std::vector<std::string>& args)
{
if(!args.size())
{
std::cout << "Please specify a wallet address to mine for: start_mining <addr> [<threads>|auto]" << std::endl;
return true;
}
cryptonote::address_parse_info info;
cryptonote::network_type nettype = cryptonote::MAINNET;
if(!cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, args.front()))
{
if(!cryptonote::get_account_address_from_str(info, cryptonote::TESTNET, args.front()))
{
if(!cryptonote::get_account_address_from_str(info, cryptonote::STAGENET, args.front()))
{
bool dnssec_valid;
std::string address_str = tools::dns_utils::get_account_address_as_str_from_url(args.front(), dnssec_valid,
[](const std::string &url, const std::vector<std::string> &addresses, bool dnssec_valid){return addresses[0];});
if(!cryptonote::get_account_address_from_str(info, cryptonote::MAINNET, address_str))
{
if(!cryptonote::get_account_address_from_str(info, cryptonote::TESTNET, address_str))
{
if(!cryptonote::get_account_address_from_str(info, cryptonote::STAGENET, address_str))
{
std::cout << "target account address has wrong format" << std::endl;
return true;
}
else
{
nettype = cryptonote::STAGENET;
}
}
else
{
nettype = cryptonote::TESTNET;
}
}
}
else
{
nettype = cryptonote::STAGENET;
}
}
else
{
nettype = cryptonote::TESTNET;
}
}
if (info.is_subaddress)
{
tools::fail_msg_writer() << "subaddress for mining reward is not yet supported!" << std::endl;
return true;
}
if(nettype != cryptonote::MAINNET)
std::cout << "Mining to a " << (nettype == cryptonote::TESTNET ? "testnet" : "stagenet") << " address, make sure this is intentional!" << std::endl;
uint64_t threads_count = 1;
bool do_background_mining = false;
bool ignore_battery = false;
if(args.size() > 4)
{
return false;
}
if(args.size() == 4)
{
if(args[3] == "true" || command_line::is_yes(args[3]) || args[3] == "1")
{
ignore_battery = true;
}
else if(args[3] != "false" && !command_line::is_no(args[3]) && args[3] != "0")
{
return false;
}
}
if(args.size() >= 3)
{
if(args[2] == "true" || command_line::is_yes(args[2]) || args[2] == "1")
{
do_background_mining = true;
}
else if(args[2] != "false" && !command_line::is_no(args[2]) && args[2] != "0")
{
return false;
}
}
if(args.size() >= 2)
{
if (args[1] == "auto" || args[1] == "autodetect")
{
threads_count = 0;
}
else
{
bool ok = epee::string_tools::get_xtype_from_string(threads_count, args[1]);
threads_count = (ok && 0 < threads_count) ? threads_count : 1;
}
}
m_executor.start_mining(info.address, threads_count, nettype, do_background_mining, ignore_battery);
return true;
}
bool t_command_parser_executor::stop_mining(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.stop_mining();
}
bool t_command_parser_executor::mining_status(const std::vector<std::string>& args)
{
return m_executor.mining_status();
}
bool t_command_parser_executor::stop_daemon(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.stop_daemon();
}
bool t_command_parser_executor::print_status(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.print_status();
}
bool t_command_parser_executor::set_limit(const std::vector<std::string>& args)
{
if(args.size()>1) return false;
if(args.size()==0) {
return m_executor.get_limit();
}
int64_t limit;
try {
limit = std::stoll(args[0]);
}
catch(const std::exception& ex) {
std::cout << "failed to parse argument" << std::endl;
return false;
}
return m_executor.set_limit(limit, limit);
}
bool t_command_parser_executor::set_limit_up(const std::vector<std::string>& args)
{
if(args.size()>1) return false;
if(args.size()==0) {
return m_executor.get_limit_up();
}
int64_t limit;
try {
limit = std::stoll(args[0]);
}
catch(const std::exception& ex) {
std::cout << "failed to parse argument" << std::endl;
return false;
}
return m_executor.set_limit(0, limit);
}
bool t_command_parser_executor::set_limit_down(const std::vector<std::string>& args)
{
if(args.size()>1) return false;
if(args.size()==0) {
return m_executor.get_limit_down();
}
int64_t limit;
try {
limit = std::stoll(args[0]);
}
catch(const std::exception& ex) {
std::cout << "failed to parse argument" << std::endl;
return false;
}
return m_executor.set_limit(limit, 0);
}
bool t_command_parser_executor::out_peers(const std::vector<std::string>& args)
{
bool set = false;
uint32_t limit = 0;
try {
if (!args.empty())
{
limit = std::stoi(args[0]);
set = true;
}
}
catch(const std::exception& ex) {
_erro("stoi exception");
return false;
}
return m_executor.out_peers(set, limit);
}
bool t_command_parser_executor::in_peers(const std::vector<std::string>& args)
{
bool set = false;
uint32_t limit = 0;
try {
if (!args.empty())
{
limit = std::stoi(args[0]);
set = true;
}
}
catch(const std::exception& ex) {
_erro("stoi exception");
return false;
}
return m_executor.in_peers(set, limit);
}
bool t_command_parser_executor::hard_fork_info(const std::vector<std::string>& args)
{
int version;
if (args.size() == 0) {
version = 0;
}
else if (args.size() == 1) {
try {
version = std::stoi(args[0]);
}
catch(const std::exception& ex) {
return false;
}
if (version <= 0 || version > 255)
return false;
}
else {
return false;
}
return m_executor.hard_fork_info(version);
}
bool t_command_parser_executor::show_bans(const std::vector<std::string>& args)
{
if (!args.empty()) return false;
return m_executor.print_bans();
}
bool t_command_parser_executor::ban(const std::vector<std::string>& args)
{
if (args.size() != 1 && args.size() != 2) return false;
time_t seconds = P2P_IP_BLOCKTIME;
if (args.size() > 1)
{
try
{
seconds = std::stoi(args[1]);
}
catch (const std::exception &e)
{
return false;
}
if (seconds == 0)
{
return false;
}
}
if (boost::starts_with(args[0], "@"))
{
const std::string ban_list = args[0].substr(1);
try
{
const boost::filesystem::path ban_list_path(ban_list);
boost::system::error_code ec;
if (!boost::filesystem::exists(ban_list_path, ec))
{
std::cout << "Can't find ban list file " + ban_list + " - " + ec.message() << std::endl;
return true;
}
bool ret = true;
std::ifstream ifs(ban_list_path.string());
for (std::string line; std::getline(ifs, line); )
{
auto subnet = net::get_ipv4_subnet_address(line);
if (subnet)
{
ret &= m_executor.ban(subnet->str(), seconds);
continue;
}
const expect<epee::net_utils::network_address> parsed_addr = net::get_network_address(line, 0);
if (parsed_addr)
{
ret &= m_executor.ban(parsed_addr->host_str(), seconds);
continue;
}
std::cout << "Invalid IP address or IPv4 subnet: " << line << std::endl;
}
return ret;
}
catch (const std::exception &e)
{
std::cout << "Error loading ban list: " << e.what() << std::endl;
return false;
}
}
else
{
const std::string ip = args[0];
return m_executor.ban(ip, seconds);
}
}
bool t_command_parser_executor::unban(const std::vector<std::string>& args)
{
if (args.size() != 1) return false;
std::string ip = args[0];
return m_executor.unban(ip);
}
bool t_command_parser_executor::banned(const std::vector<std::string>& args)
{
if (args.size() != 1) return false;
std::string address = args[0];
return m_executor.banned(address);
}
bool t_command_parser_executor::flush_txpool(const std::vector<std::string>& args)
{
if (args.size() > 1) return false;
std::string txid;
if (args.size() == 1)
{
crypto::hash hash;
if (!parse_hash256(args[0], hash))
{
std::cout << "failed to parse tx id" << std::endl;
return true;
}
txid = args[0];
}
return m_executor.flush_txpool(txid);
}
bool t_command_parser_executor::output_histogram(const std::vector<std::string>& args)
{
std::vector<uint64_t> amounts;
uint64_t min_count = 3;
uint64_t max_count = 0;
size_t n_raw = 0;
for (size_t n = 0; n < args.size(); ++n)
{
if (args[n][0] == '@')
{
amounts.push_back(boost::lexical_cast<uint64_t>(args[n].c_str() + 1));
}
else if (n_raw == 0)
{
min_count = boost::lexical_cast<uint64_t>(args[n]);
n_raw++;
}
else if (n_raw == 1)
{
max_count = boost::lexical_cast<uint64_t>(args[n]);
n_raw++;
}
else
{
std::cout << "Invalid syntax: more than two non-amount parameters" << std::endl;
return true;
}
}
return m_executor.output_histogram(amounts, min_count, max_count);
}
bool t_command_parser_executor::print_coinbase_tx_sum(const std::vector<std::string>& args)
{
if(!args.size())
{
std::cout << "need block height parameter" << std::endl;
return false;
}
uint64_t height = 0;
uint64_t count = 0;
if(!epee::string_tools::get_xtype_from_string(height, args[0]))
{
std::cout << "wrong starter block height parameter" << std::endl;
return false;
}
if(args.size() >1 && !epee::string_tools::get_xtype_from_string(count, args[1]))
{
std::cout << "wrong count parameter" << std::endl;
return false;
}
return m_executor.print_coinbase_tx_sum(height, count);
}
bool t_command_parser_executor::alt_chain_info(const std::vector<std::string>& args)
{
if(args.size() > 1)
{
std::cout << "usage: alt_chain_info [block_hash|>N|-N]" << std::endl;
return false;
}
std::string tip;
size_t above = 0;
uint64_t last_blocks = 0;
if (args.size() == 1)
{
if (args[0].size() > 0 && args[0][0] == '>')
{
if (!epee::string_tools::get_xtype_from_string(above, args[0].c_str() + 1))
{
std::cout << "invalid above parameter" << std::endl;
return false;
}
}
else if (args[0].size() > 0 && args[0][0] == '-')
{
if (!epee::string_tools::get_xtype_from_string(last_blocks, args[0].c_str() + 1))
{
std::cout << "invalid last_blocks parameter" << std::endl;
return false;
}
}
else
{
tip = args[0];
}
}
return m_executor.alt_chain_info(tip, above, last_blocks);
}
bool t_command_parser_executor::print_blockchain_dynamic_stats(const std::vector<std::string>& args)
{
if(args.size() != 1)
{
std::cout << "Exactly one parameter is needed" << std::endl;
return false;
}
uint64_t nblocks = 0;
if(!epee::string_tools::get_xtype_from_string(nblocks, args[0]) || nblocks == 0)
{
std::cout << "wrong number of blocks" << std::endl;
return false;
}
return m_executor.print_blockchain_dynamic_stats(nblocks);
}
bool t_command_parser_executor::update(const std::vector<std::string>& args)
{
if(args.size() != 1)
{
std::cout << "Exactly one parameter is needed: check, download, or update" << std::endl;
return false;
}
return m_executor.update(args.front());
}
bool t_command_parser_executor::relay_tx(const std::vector<std::string>& args)
{
if (args.size() != 1) return false;
std::string txid;
crypto::hash hash;
if (!parse_hash256(args[0], hash))
{
std::cout << "failed to parse tx id" << std::endl;
return true;
}
txid = args[0];
return m_executor.relay_tx(txid);
}
bool t_command_parser_executor::sync_info(const std::vector<std::string>& args)
{
if (args.size() != 0) return false;
return m_executor.sync_info();
}
bool t_command_parser_executor::pop_blocks(const std::vector<std::string>& args)
{
if (args.size() != 1)
{
std::cout << "Exactly one parameter is needed" << std::endl;
return false;
}
try
{
uint64_t nblocks = boost::lexical_cast<uint64_t>(args[0]);
if (nblocks < 1)
{
std::cout << "number of blocks must be greater than 0" << std::endl;
return false;
}
return m_executor.pop_blocks(nblocks);
}
catch (const boost::bad_lexical_cast&)
{
std::cout << "number of blocks must be a number greater than 0" << std::endl;
}
return false;
}
bool t_command_parser_executor::rpc_payments(const std::vector<std::string>& args)
{
if (args.size() != 0) return false;
return m_executor.rpc_payments();
}
bool t_command_parser_executor::version(const std::vector<std::string>& args)
{
return m_executor.version();
}
bool t_command_parser_executor::prune_blockchain(const std::vector<std::string>& args)
{
if (args.size() > 1) return false;
if (args.empty() || args[0] != "confirm")
{
std::cout << "Warning: pruning from within phiblockd will not shrink the database file size." << std::endl;
std::cout << "Instead, parts of the file will be marked as free, so the file will not grow" << std::endl;
std::cout << "until that newly free space is used up. If you want a smaller file size now," << std::endl;
std::cout << "exit phiblockd and run phiblock-blockchain-prune (you will temporarily need more" << std::endl;
std::cout << "disk space for the database conversion though). If you are OK with the database" << std::endl;
std::cout << "file keeping the same size, re-run this command with the \"confirm\" parameter." << std::endl;
return true;
}
return m_executor.prune_blockchain();
}
bool t_command_parser_executor::check_blockchain_pruning(const std::vector<std::string>& args)
{
return m_executor.check_blockchain_pruning();
}
bool t_command_parser_executor::set_bootstrap_daemon(const std::vector<std::string>& args)
{
const size_t args_count = args.size();
if (args_count < 1 || args_count > 3)
{
return false;
}
return m_executor.set_bootstrap_daemon(
args[0] != "none" ? args[0] : std::string(),
args_count > 1 ? args[1] : std::string(),
args_count > 2 ? args[2] : std::string());
}
bool t_command_parser_executor::flush_cache(const std::vector<std::string>& args)
{
bool bad_txs = false, bad_blocks = false;
std::string arg;
if (args.empty())
goto show_list;
for (size_t i = 0; i < args.size(); ++i)
{
arg = args[i];
if (arg == "bad-txs")
bad_txs = true;
else if (arg == "bad-blocks")
bad_blocks = true;
else
goto show_list;
}
return m_executor.flush_cache(bad_txs, bad_blocks);
show_list:
std::cout << "Invalid cache type: " << arg << std::endl;
std::cout << "Cache types: bad-txs bad-blocks" << std::endl;
return true;
}
} // namespace daemonize
|
// (C) Copyright John Maddock 2007.
// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// This file is machine generated, do not edit by hand
// Polynomial evaluation using second order Horners rule
#ifndef BOOST_MATH_TOOLS_POLY_EVAL_16_HPP
#define BOOST_MATH_TOOLS_POLY_EVAL_16_HPP
namespace boost{ namespace math{ namespace tools{ namespace detail{
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T*, const V&, const boost::integral_constant<int, 0>*) BOOST_MATH_NOEXCEPT(V)
{
return static_cast<V>(0);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V&, const boost::integral_constant<int, 1>*) BOOST_MATH_NOEXCEPT(V)
{
return static_cast<V>(a[0]);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 2>*) BOOST_MATH_NOEXCEPT(V)
{
return static_cast<V>(a[1] * x + a[0]);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 3>*) BOOST_MATH_NOEXCEPT(V)
{
return static_cast<V>((a[2] * x + a[1]) * x + a[0]);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 4>*) BOOST_MATH_NOEXCEPT(V)
{
return static_cast<V>(((a[3] * x + a[2]) * x + a[1]) * x + a[0]);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 5>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>((a[4] * x2 + a[2]) * x2 + a[0] + (a[3] * x2 + a[1]) * x);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 6>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>(((a[5] * x2 + a[3]) * x2 + a[1]) * x + (a[4] * x2 + a[2]) * x2 + a[0]);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 7>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>(((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((a[5] * x2 + a[3]) * x2 + a[1]) * x);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 8>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>((((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((a[6] * x2 + a[4]) * x2 + a[2]) * x2 + a[0]);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 9>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>((((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((a[7] * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 10>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>(((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((a[8] * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 11>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>(((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((a[9] * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 12>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>((((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((a[10] * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 13>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>((((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + (((((a[11] * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 14>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>(((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + (((((a[12] * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 15>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>(((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0] + ((((((a[13] * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x);
}
template <class T, class V>
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const boost::integral_constant<int, 16>*) BOOST_MATH_NOEXCEPT(V)
{
V x2 = x * x;
return static_cast<V>((((((((a[15] * x2 + a[13]) * x2 + a[11]) * x2 + a[9]) * x2 + a[7]) * x2 + a[5]) * x2 + a[3]) * x2 + a[1]) * x + ((((((a[14] * x2 + a[12]) * x2 + a[10]) * x2 + a[8]) * x2 + a[6]) * x2 + a[4]) * x2 + a[2]) * x2 + a[0]);
}
}}}} // namespaces
#endif // include guard
|
/*
* Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <tencentcloud/sms/v20210111/model/ModifySmsSignResponse.h>
#include <tencentcloud/core/utils/rapidjson/document.h>
#include <tencentcloud/core/utils/rapidjson/writer.h>
#include <tencentcloud/core/utils/rapidjson/stringbuffer.h>
using TencentCloud::CoreInternalOutcome;
using namespace TencentCloud::Sms::V20210111::Model;
using namespace std;
ModifySmsSignResponse::ModifySmsSignResponse() :
m_modifySignStatusHasBeenSet(false)
{
}
CoreInternalOutcome ModifySmsSignResponse::Deserialize(const string &payload)
{
rapidjson::Document d;
d.Parse(payload.c_str());
if (d.HasParseError() || !d.IsObject())
{
return CoreInternalOutcome(Error("response not json format"));
}
if (!d.HasMember("Response") || !d["Response"].IsObject())
{
return CoreInternalOutcome(Error("response `Response` is null or not object"));
}
rapidjson::Value &rsp = d["Response"];
if (!rsp.HasMember("RequestId") || !rsp["RequestId"].IsString())
{
return CoreInternalOutcome(Error("response `Response.RequestId` is null or not string"));
}
string requestId(rsp["RequestId"].GetString());
SetRequestId(requestId);
if (rsp.HasMember("Error"))
{
if (!rsp["Error"].IsObject() ||
!rsp["Error"].HasMember("Code") || !rsp["Error"]["Code"].IsString() ||
!rsp["Error"].HasMember("Message") || !rsp["Error"]["Message"].IsString())
{
return CoreInternalOutcome(Error("response `Response.Error` format error").SetRequestId(requestId));
}
string errorCode(rsp["Error"]["Code"].GetString());
string errorMsg(rsp["Error"]["Message"].GetString());
return CoreInternalOutcome(Error(errorCode, errorMsg).SetRequestId(requestId));
}
if (rsp.HasMember("ModifySignStatus") && !rsp["ModifySignStatus"].IsNull())
{
if (!rsp["ModifySignStatus"].IsObject())
{
return CoreInternalOutcome(Error("response `ModifySignStatus` is not object type").SetRequestId(requestId));
}
CoreInternalOutcome outcome = m_modifySignStatus.Deserialize(rsp["ModifySignStatus"]);
if (!outcome.IsSuccess())
{
outcome.GetError().SetRequestId(requestId);
return outcome;
}
m_modifySignStatusHasBeenSet = true;
}
return CoreInternalOutcome(true);
}
ModifySignStatus ModifySmsSignResponse::GetModifySignStatus() const
{
return m_modifySignStatus;
}
bool ModifySmsSignResponse::ModifySignStatusHasBeenSet() const
{
return m_modifySignStatusHasBeenSet;
}
|
/**
* Root object in the case hierarchy; owns all of the managers whose job
* is to run the currently-loaded case.
*
* @author GabuEx, dawnmew
* @since 1.0
*
* Licensed under the MIT License.
*
* Copyright (c) 2014 Equestrian Dreamers
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include "Case.h"
#include "../FileFunctions.h"
#include "../miniz.h"
#include "../globals.h"
#include "../MouseHelper.h"
#include "../ResourceLoader.h"
#include "../XmlReader.h"
#include "../XmlWriter.h"
#include "../Events/EventProviders.h"
#include "../Events/CaseParsingEventProvider.h"
#include <iostream>
#include <ctime>
Case *Case::pInstance = NULL;
SDL_sem *Case::pInstanceSemaphore = SDL_CreateSemaphore(1);
Case::Case()
: playerCharacterId("")
, loadStage("")
{
pAnimationManager = new AnimationManager(ManagerSourceCaseFile);
pAudioManager = new AudioManager();
pContentManager = new ContentManager();
pDialogCharacterManager = new DialogCharacterManager();
pDialogCutsceneManager = new DialogCutsceneManager();
pEvidenceManager = new EvidenceManager();
pFieldCharacterManager = new FieldCharacterManager();
pFieldCutsceneManager = new FieldCutsceneManager();
pFlagManager = new FlagManager();
pPartnerManager = new PartnerManager();
pSpriteManager = new SpriteManager(ManagerSourceCaseFile);
isFinished = false;
isLoadingSprites = false;
isReady = false;
waitUntilLoaded = true;
wantsToLoadResources = false;
pCurrentArea = NULL;
pLoadStageSemaphore = SDL_CreateSemaphore(1);
}
Case::Case(const Case &other)
: playerCharacterId("")
, loadStage("")
{
pAnimationManager = new AnimationManager(ManagerSourceCaseFile);
pAudioManager = new AudioManager();
pContentManager = new ContentManager();
pDialogCharacterManager = new DialogCharacterManager();
pDialogCutsceneManager = new DialogCutsceneManager();
pEvidenceManager = new EvidenceManager();
pFieldCharacterManager = new FieldCharacterManager();
pFieldCutsceneManager = new FieldCutsceneManager();
pFlagManager = new FlagManager();
pPartnerManager = new PartnerManager();
pSpriteManager = new SpriteManager(ManagerSourceCaseFile);
isFinished = false;
isLoadingSprites = false;
isReady = false;
waitUntilLoaded = true;
wantsToLoadResources = false;
pCurrentArea = NULL;
pLoadStageSemaphore = SDL_CreateSemaphore(1);
}
Case::~Case()
{
delete pAnimationManager;
pAnimationManager = NULL;
delete pAudioManager;
pAudioManager = NULL;
delete pContentManager;
pContentManager = NULL;
delete pDialogCharacterManager;
pDialogCharacterManager = NULL;
delete pDialogCutsceneManager;
pDialogCutsceneManager = NULL;
delete pEvidenceManager;
pEvidenceManager = NULL;
delete pFieldCharacterManager;
pFieldCharacterManager = NULL;
delete pFieldCutsceneManager;
pFieldCutsceneManager = NULL;
delete pFlagManager;
pFlagManager = NULL;
delete pPartnerManager;
pPartnerManager = NULL;
delete pSpriteManager;
pSpriteManager = NULL;
SDL_DestroySemaphore(pLoadStageSemaphore);
pLoadStageSemaphore = NULL;
}
void Case::LoadFromXml(const string &caseFilePath)
{
ReplaceInstance();
pInstance->isUnloaded = false;
pInstance->filePath = caseFilePath;
pInstance->uuid = GetUuidFromFilePath(caseFilePath);
LoadDialogsSeenListForCase(pInstance->uuid);
{
XmlReader reader("case.xml");
reader.StartElement("Case");
pInstance->SetLoadStage(gpLocalizableContent->GetText("Case/AnimationsLoadStageText"));
pInstance->pAnimationManager->LoadFromXml(&reader);
pInstance->SetLoadStage(gpLocalizableContent->GetText("Case/AudioLoadStageText"));
pInstance->pAudioManager->LoadFromXml(&reader);
pInstance->SetLoadStage(gpLocalizableContent->GetText("Case/CaseInformationLoadStageText"));
pInstance->pContentManager->LoadFromXml(&reader);
pInstance->SetLoadStage(gpLocalizableContent->GetText("Case/DialogResourcesLoadStageText"));
pInstance->pDialogCharacterManager->LoadFromXml(&reader);
pInstance->pDialogCutsceneManager->LoadFromXml(&reader);
pInstance->SetLoadStage(gpLocalizableContent->GetText("Case/EvidenceLoadStageText"));
pInstance->pEvidenceManager->LoadFromXml(&reader);
pInstance->SetLoadStage(gpLocalizableContent->GetText("Case/FieldResourcesLoadStageText"));
pInstance->pFieldCharacterManager->LoadFromXml(&reader);
pInstance->pFieldCutsceneManager->LoadFromXml(&reader);
pInstance->SetLoadStage(gpLocalizableContent->GetText("Case/FlagsLoadStageText"));
pInstance->pFlagManager->LoadFromXml(&reader);
pInstance->SetLoadStage(gpLocalizableContent->GetText("Case/PartnerInformationLoadStageText"));
pInstance->pPartnerManager->LoadFromXml(&reader);
pInstance->SetLoadStage(gpLocalizableContent->GetText("Case/SpriteSheetsLoadStageText"));
pInstance->pSpriteManager->LoadFromXml(&reader);
reader.StartElement("ParentLocationListsBySpriteSheetId");
reader.StartList("Entry");
while (reader.MoveToNextListItem())
{
string spriteSheetId = reader.ReadTextElement("SpriteSheetId");
reader.StartElement("LocationList");
reader.StartList("Entry");
while (reader.MoveToNextListItem())
{
string locationId = reader.ReadTextElement("LocationId");
pInstance->parentLocationListsBySpriteSheetId[spriteSheetId].push_back(locationId);
}
reader.EndElement();
}
reader.EndElement();
reader.StartElement("ParentLocationListsByVideoId");
reader.StartList("Entry");
while (reader.MoveToNextListItem())
{
string videoId = reader.ReadTextElement("VideoId");
reader.StartElement("LocationList");
reader.StartList("Entry");
while (reader.MoveToNextListItem())
{
string locationId = reader.ReadTextElement("LocationId");
pInstance->parentLocationListsByVideoId[videoId].push_back(locationId);
}
reader.EndElement();
}
reader.EndElement();
reader.EndElement();
}
pInstance->playerCharacterId = pInstance->pFieldCharacterManager->playerCharacterId;
pInstance->isReady = true;
EventProviders::GetCaseParsingEventProvider()->RaiseCaseParsingComplete("case.xml");
}
void Case::ValidateXml()
{
// TODO: Check to make sure that everything exists that should exist.
/*ReplaceInstance();
pInstance->isUnloaded = false;
{
XmlReader reader("case.xml");
reader.StartElement("Case");
pInstance->SetLoadStage("animations");
pInstance->pAnimationManager->LoadFromXml(&reader);
pInstance->SetLoadStage("audio");
pInstance->pAudioManager->LoadFromXml(&reader);
pInstance->SetLoadStage("case information");
pInstance->pContentManager->LoadFromXml(&reader);
pInstance->SetLoadStage("dialog resources");
pInstance->pDialogCharacterManager->LoadFromXml(&reader);
pInstance->pDialogCutsceneManager->LoadFromXml(&reader);
pInstance->SetLoadStage("evidence");
pInstance->pEvidenceManager->LoadFromXml(&reader);
pInstance->SetLoadStage("field resources");
pInstance->pFieldCharacterManager->LoadFromXml(&reader);
pInstance->pFieldCutsceneManager->LoadFromXml(&reader);
pInstance->SetLoadStage("flags");
pInstance->pFlagManager->LoadFromXml(&reader);
pInstance->SetLoadStage("partner information");
pInstance->pPartnerManager->LoadFromXml(&reader);
pInstance->SetLoadStage("sprite sheets");
pInstance->pSpriteManager->LoadFromXml(&reader);
reader.StartElement("ParentLocationListsBySpriteSheetId");
reader.StartList("Entry");
while (reader.MoveToNextListItem())
{
string spriteSheetId = reader.ReadTextElement("SpriteSheetId");
reader.StartElement("LocationList");
reader.StartList("Entry");
while (reader.MoveToNextListItem())
{
string locationId = reader.ReadTextElement("LocationId");
pInstance->parentLocationListsBySpriteSheetId[spriteSheetId].push_back(locationId);
}
reader.EndElement();
}
reader.EndElement();
reader.StartElement("ParentLocationListsByVideoId");
reader.StartList("Entry");
while (reader.MoveToNextListItem())
{
string videoId = reader.ReadTextElement("VideoId");
reader.StartElement("LocationList");
reader.StartList("Entry");
while (reader.MoveToNextListItem())
{
string locationId = reader.ReadTextElement("LocationId");
pInstance->parentLocationListsByVideoId[videoId].push_back(locationId);
}
reader.EndElement();
}
reader.EndElement();
reader.EndElement();
}
{
XmlReader reader("caseMetadata.xml");
reader.StartElement("CaseMetadata");
pInstance->uuid = reader.ReadTextElement("UUID");
reader.EndElement();
}
pInstance->playerCharacterId = pInstance->pFieldCharacterManager->playerCharacterId;
pInstance->isReady = true;
EventProviders::GetCaseParsingEventProvider()->RaiseCaseParsingComplete("case.xml");
pInstance->SetLoadStage("");*/
}
void Case::Begin()
{
pCurrentArea->Begin(Case::GetInstance()->GetContentManager()->GetInitialLocationId(), false /* isLoadingFromSaveFile */);
}
void Case::Update(int delta)
{
pCurrentArea->Update(delta);
}
void Case::Draw()
{
pCurrentArea->Draw();
}
void Case::DrawForScreenshot()
{
pCurrentArea->DrawForScreenshot();
}
void Case::Reset()
{
pContentManager->Reset();
pEvidenceManager->Reset();
pFieldCutsceneManager->Reset();
pFlagManager->Reset();
SetIsFinished(false);
SetLoadStage("");
pCurrentArea = Case::GetInstance()->GetContentManager()->GetAreaFromId(Case::GetInstance()->GetContentManager()->GetInitialAreaId());
}
void Case::SaveToSaveFile(const string &filePath, const string &fileExtension, const string &saveName)
{
XmlWriter writer(filePath.c_str(), fileExtension.length() > 0 ? fileExtension.c_str() : NULL);
writer.StartElement("Case");
pContentManager->SaveToSaveFile(&writer);
pEvidenceManager->SaveToSaveFile(&writer);
pFieldCutsceneManager->SaveToSaveFile(&writer);
pFlagManager->SaveToSaveFile(&writer);
pPartnerManager->SaveToSaveFile(&writer);
pCurrentArea->SaveToSaveFile(&writer);
writer.EndElement();
writer.StartElement("CaseMetadata");
writer.WriteTextElement("SaveName", saveName);
writer.WriteIntElement("Timestamp", (int)time(NULL));
void *pPngMemory = NULL;
size_t pngSize = 0;
Case::GetInstance()->GetFieldScreenshot(&pPngMemory, &pngSize);
writer.WritePngElement("Screenshot", pPngMemory, pngSize);
free(pPngMemory);
writer.EndElement();
}
void Case::Autosave()
{
SaveToSaveFile(GetSaveFolderPathForCase(uuid) + "00000000-0000-0000-0000-000000000000.sav", "", gpLocalizableContent->GetText("SelectionScreen/AutosaveText"));
}
void Case::GetFieldScreenshot(void **ppPngMemory, size_t *pPngSize)
{
gIsSavingScreenshot = true;
gScreenshotWidth = 246;
gScreenshotHeight = 138;
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
Uint32 targetPixelFormat = SDL_PIXELFORMAT_ABGR8888;
#else
Uint32 targetPixelFormat = SDL_PIXELFORMAT_RGBA8888;
#endif
SDL_SetRenderDrawColor(gpRenderer, 0, 0, 0, 255);
SDL_RenderClear(gpRenderer);
DrawForScreenshot();
Uint8 targetBytesPerPixel = SDL_BYTESPERPIXEL(targetPixelFormat);
int targetPitch = gScreenshotWidth * targetBytesPerPixel;
Uint8 *pPixels = new Uint8[gScreenshotHeight * targetPitch];
SDL_Rect rect = { 0, 0, gScreenshotWidth, gScreenshotHeight };
SDL_RenderReadPixels(gpRenderer, &rect, targetPixelFormat, pPixels, targetPitch);
*ppPngMemory = tdefl_write_image_to_png_file_in_memory(pPixels, gScreenshotWidth, gScreenshotHeight, targetBytesPerPixel, pPngSize);
delete [] pPixels;
gIsSavingScreenshot = false;
}
void Case::LoadFromSaveFile(const string &filePath)
{
XmlReader reader(filePath.c_str());
reader.StartElement("Case");
pContentManager->LoadFromSaveFile(&reader);
pEvidenceManager->LoadFromSaveFile(&reader);
pFieldCutsceneManager->LoadFromSaveFile(&reader);
pFlagManager->LoadFromSaveFile(&reader);
pPartnerManager->LoadFromSaveFile(&reader);
Area::LoadFromSaveFile(&reader, &pCurrentArea);
reader.EndElement();
SetIsFinished(false);
SetLoadStage("");
}
void Case::CacheState()
{
pEvidenceManager->CacheState();
pFlagManager->CacheState();
pPartnerManager->CacheState();
}
void Case::LoadCachedState()
{
pEvidenceManager->LoadCachedState();
pFlagManager->LoadCachedState();
pPartnerManager->LoadCachedState();
}
string Case::GetLoadStage()
{
string loadStage;
SDL_SemWait(pLoadStageSemaphore);
loadStage = this->loadStage;
SDL_SemPost(pLoadStageSemaphore);
return loadStage;
}
void Case::SetLoadStage(const string &loadStage)
{
SDL_SemWait(pLoadStageSemaphore);
this->loadStage = loadStage;
SDL_SemPost(pLoadStageSemaphore);
}
bool Case::IsLoading()
{
if (!waitUntilLoaded)
{
return false;
}
if (isLoadingSprites)
{
return true;
}
if (ResourceLoader::GetInstance()->HasImageTexturesToLoad())
{
return true;
}
return false;
}
bool Case::IsReady()
{
return isReady;
}
void Case::LoadResources()
{
wantsToLoadResources = false;
ResourceLoader::GetInstance()->SnapLoadStepQueue();
}
void Case::UpdateLoadedTextures(const string &newLocationId, bool waitUntilLoaded)
{
SetWaitUntilLoaded(waitUntilLoaded);
SetIsLoadingSprites(true);
#ifdef MLI_DEBUG
cout << "Loading sprites for location \"" << newLocationId << "\"." << endl;
#endif
pSpriteManager->FinishUpdateLoadedTextures(newLocationId);
pAnimationManager->FinishUpdateLoadedTextures(newLocationId);
SetWantsToLoadResources(true);
}
int Case::FinishUpdateLoadedTexturesStatic(void *pData)
{
UpdateLoadedTexturesParameters *pParams = reinterpret_cast<UpdateLoadedTexturesParameters *>(pData);
Case *pThis = pParams->pCase;
string newLocationId = pParams->newLocationId;
delete pParams;
pThis->FinishUpdateLoadedTextures(newLocationId);
return 0;
}
void Case::FinishUpdateLoadedTextures(const string &newLocationId)
{
pSpriteManager->FinishUpdateLoadedTextures(newLocationId);
pAnimationManager->FinishUpdateLoadedTextures(newLocationId);
SetWantsToLoadResources(true);
}
void Case::UnloadResources()
{
pAnimationManager->UnloadResources();
pSpriteManager->UnloadResources();
isUnloaded = true;
}
vector<string> Case::GetParentLocationListForSpriteSheetId(const string &id)
{
return parentLocationListsBySpriteSheetId[id];
}
vector<string> Case::GetParentLocationListForVideoId(const string &id)
{
return parentLocationListsByVideoId[id];
}
|
//
// Copyright 2012 Francisco Jerez
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
//
#include <algorithm>
#include "core/device.hpp"
#include "core/platform.hpp"
#include "pipe/p_screen.h"
#include "pipe/p_state.h"
#include "spirv/invocation.hpp"
#include "util/bitscan.h"
#include "util/u_debug.h"
#include "spirv/invocation.hpp"
#include "nir/invocation.hpp"
#include <fstream>
using namespace clover;
namespace {
template<typename T>
std::vector<T>
get_compute_param(pipe_screen *pipe, pipe_shader_ir ir_format,
pipe_compute_cap cap) {
int sz = pipe->get_compute_param(pipe, ir_format, cap, NULL);
std::vector<T> v(sz / sizeof(T));
pipe->get_compute_param(pipe, ir_format, cap, &v.front());
return v;
}
cl_version
get_highest_supported_version(const device &dev) {
// All the checks below assume that the device supports FULL_PROFILE
// (which is the only profile support by clover) and that a device is
// not CUSTOM.
assert(dev.type() != CL_DEVICE_TYPE_CUSTOM);
cl_version version = CL_MAKE_VERSION(0, 0, 0);
const auto has_extension =
[extensions = dev.supported_extensions()](const char *extension_name){
return std::find_if(extensions.begin(), extensions.end(),
[extension_name](const cl_name_version &extension){
return strcmp(extension.name, extension_name) == 0;
}) != extensions.end();
};
const bool supports_images = dev.image_support();
// Check requirements for OpenCL 1.0
if (dev.max_compute_units() < 1 ||
dev.max_block_size().size() < 3 ||
// TODO: Check CL_DEVICE_MAX_WORK_ITEM_SIZES
dev.max_threads_per_block() < 1 ||
(dev.address_bits() != 32 && dev.address_bits() != 64) ||
dev.max_mem_alloc_size() < std::max(dev.max_mem_global() / 4,
(cl_ulong)128 * 1024 * 1024) ||
dev.max_mem_input() < 256 ||
dev.max_const_buffer_size() < 64 * 1024 ||
dev.max_const_buffers() < 8 ||
dev.max_mem_local() < 16 * 1024 ||
dev.clc_version < CL_MAKE_VERSION(1, 0, 0)) {
return version;
}
version = CL_MAKE_VERSION(1, 0, 0);
// Check requirements for OpenCL 1.1
if (!has_extension("cl_khr_byte_addressable_store") ||
!has_extension("cl_khr_global_int32_base_atomics") ||
!has_extension("cl_khr_global_int32_extended_atomics") ||
!has_extension("cl_khr_local_int32_base_atomics") ||
!has_extension("cl_khr_local_int32_extended_atomics") ||
// OpenCL 1.1 increased the minimum value for
// CL_DEVICE_MAX_PARAMETER_SIZE to 1024 bytes.
dev.max_mem_input() < 1024 ||
dev.mem_base_addr_align() < sizeof(cl_long16) ||
// OpenCL 1.1 increased the minimum value for
// CL_DEVICE_LOCAL_MEM_SIZE to 32 KB.
dev.max_mem_local() < 32 * 1024 ||
dev.clc_version < CL_MAKE_VERSION(1, 1, 0)) {
return version;
}
version = CL_MAKE_VERSION(1, 1, 0);
// Check requirements for OpenCL 1.2
if ((dev.has_doubles() && !has_extension("cl_khr_fp64")) ||
dev.clc_version < CL_MAKE_VERSION(1, 2, 0) ||
dev.max_printf_buffer_size() < 1 * 1024 * 1024 ||
(supports_images &&
(dev.max_image_buffer_size() < 65536 ||
dev.max_image_array_number() < 2048))) {
return version;
}
version = CL_MAKE_VERSION(1, 2, 0);
// Check requirements for OpenCL 3.0
if (dev.max_mem_alloc_size() < std::max(std::min((cl_ulong)1024 * 1024 * 1024,
dev.max_mem_global() / 4),
(cl_ulong)128 * 1024 * 1024) ||
// TODO: If pipes are supported, check:
// * CL_DEVICE_MAX_PIPE_ARGS
// * CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS
// * CL_DEVICE_PIPE_MAX_PACKET_SIZE
// TODO: If on-device queues are supported, check:
// * CL_DEVICE_QUEUE_ON_DEVICE_PROPERTIES
// * CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE
// * CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE
// * CL_DEVICE_MAX_ON_DEVICE_QUEUES
// * CL_DEVICE_MAX_ON_DEVICE_EVENTS
dev.clc_version < CL_MAKE_VERSION(3, 0, 0) ||
(supports_images &&
(dev.max_images_write() < 64 ||
dev.max_image_size() < 16384))) {
return version;
}
version = CL_MAKE_VERSION(3, 0, 0);
return version;
}
}
device::device(clover::platform &platform, pipe_loader_device *ldev) :
platform(platform), clc_cache(NULL), ldev(ldev) {
pipe = pipe_loader_create_screen(ldev);
if (pipe && pipe->get_param(pipe, PIPE_CAP_COMPUTE)) {
const bool has_supported_ir = supports_ir(PIPE_SHADER_IR_NATIVE) ||
supports_ir(PIPE_SHADER_IR_NIR_SERIALIZED);
if (has_supported_ir) {
unsigned major = 1, minor = 1;
debug_get_version_option("CLOVER_DEVICE_CLC_VERSION_OVERRIDE",
&major, &minor);
clc_version = CL_MAKE_VERSION(major, minor, 0);
version = get_highest_supported_version(*this);
major = CL_VERSION_MAJOR(version);
minor = CL_VERSION_MINOR(version);
debug_get_version_option("CLOVER_DEVICE_VERSION_OVERRIDE", &major,
&minor);
version = CL_MAKE_VERSION(major, minor, 0);
}
if (supports_ir(PIPE_SHADER_IR_NATIVE))
return;
#ifdef HAVE_CLOVER_SPIRV
if (supports_ir(PIPE_SHADER_IR_NIR_SERIALIZED)) {
nir::check_for_libclc(*this);
clc_cache = nir::create_clc_disk_cache();
clc_nir = lazy<std::shared_ptr<nir_shader>>([&] () { std::string log; return std::shared_ptr<nir_shader>(nir::load_libclc_nir(*this, log), ralloc_free); });
return;
}
#endif
}
if (pipe)
pipe->destroy(pipe);
throw error(CL_INVALID_DEVICE);
}
device::~device() {
if (clc_cache)
disk_cache_destroy(clc_cache);
if (pipe)
pipe->destroy(pipe);
if (ldev)
pipe_loader_release(&ldev, 1);
}
bool
device::operator==(const device &dev) const {
return this == &dev;
}
cl_device_type
device::type() const {
switch (ldev->type) {
case PIPE_LOADER_DEVICE_SOFTWARE:
return CL_DEVICE_TYPE_CPU;
case PIPE_LOADER_DEVICE_PCI:
case PIPE_LOADER_DEVICE_PLATFORM:
return CL_DEVICE_TYPE_GPU;
default:
unreachable("Unknown device type.");
}
}
cl_uint
device::vendor_id() const {
switch (ldev->type) {
case PIPE_LOADER_DEVICE_SOFTWARE:
case PIPE_LOADER_DEVICE_PLATFORM:
return 0;
case PIPE_LOADER_DEVICE_PCI:
return ldev->u.pci.vendor_id;
default:
unreachable("Unknown device type.");
}
}
size_t
device::max_images_read() const {
return pipe->get_shader_param(pipe, PIPE_SHADER_COMPUTE,
PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS);
}
size_t
device::max_images_write() const {
return pipe->get_shader_param(pipe, PIPE_SHADER_COMPUTE,
PIPE_SHADER_CAP_MAX_SHADER_IMAGES);
}
size_t
device::max_image_buffer_size() const {
return pipe->get_param(pipe, PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE);
}
cl_uint
device::max_image_size() const {
return pipe->get_param(pipe, PIPE_CAP_MAX_TEXTURE_2D_SIZE);
}
cl_uint
device::max_image_size_3d() const {
return 1 << (pipe->get_param(pipe, PIPE_CAP_MAX_TEXTURE_3D_LEVELS) - 1);
}
size_t
device::max_image_array_number() const {
return pipe->get_param(pipe, PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS);
}
cl_uint
device::max_samplers() const {
return pipe->get_shader_param(pipe, PIPE_SHADER_COMPUTE,
PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS);
}
cl_ulong
device::max_mem_global() const {
return get_compute_param<uint64_t>(pipe, ir_format(),
PIPE_COMPUTE_CAP_MAX_GLOBAL_SIZE)[0];
}
cl_ulong
device::max_mem_local() const {
return get_compute_param<uint64_t>(pipe, ir_format(),
PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE)[0];
}
cl_ulong
device::max_mem_input() const {
return get_compute_param<uint64_t>(pipe, ir_format(),
PIPE_COMPUTE_CAP_MAX_INPUT_SIZE)[0];
}
cl_ulong
device::max_const_buffer_size() const {
return pipe->get_shader_param(pipe, PIPE_SHADER_COMPUTE,
PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE);
}
cl_uint
device::max_const_buffers() const {
return pipe->get_shader_param(pipe, PIPE_SHADER_COMPUTE,
PIPE_SHADER_CAP_MAX_CONST_BUFFERS);
}
size_t
device::max_threads_per_block() const {
return get_compute_param<uint64_t>(
pipe, ir_format(), PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK)[0];
}
cl_ulong
device::max_mem_alloc_size() const {
return get_compute_param<uint64_t>(pipe, ir_format(),
PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE)[0];
}
cl_uint
device::max_clock_frequency() const {
return get_compute_param<uint32_t>(pipe, ir_format(),
PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY)[0];
}
cl_uint
device::max_compute_units() const {
return get_compute_param<uint32_t>(pipe, ir_format(),
PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS)[0];
}
cl_uint
device::max_printf_buffer_size() const {
return 1024 * 1024;
}
bool
device::image_support() const {
bool supports_images = get_compute_param<uint32_t>(pipe, ir_format(),
PIPE_COMPUTE_CAP_IMAGES_SUPPORTED)[0];
if (!supports_images)
return false;
/* If the gallium driver supports images, but does not support the
* minimum requirements for opencl 1.0 images, then don't claim to
* support images.
*/
if (max_images_read() < 128 ||
max_images_write() < 8 ||
max_image_size() < 8192 ||
max_image_size_3d() < 2048 ||
max_samplers() < 16)
return false;
return true;
}
bool
device::has_doubles() const {
return pipe->get_param(pipe, PIPE_CAP_DOUBLES);
}
bool
device::has_halves() const {
return pipe->get_shader_param(pipe, PIPE_SHADER_COMPUTE,
PIPE_SHADER_CAP_FP16);
}
bool
device::has_int64_atomics() const {
return pipe->get_shader_param(pipe, PIPE_SHADER_COMPUTE,
PIPE_SHADER_CAP_INT64_ATOMICS);
}
bool
device::has_unified_memory() const {
return pipe->get_param(pipe, PIPE_CAP_UMA);
}
size_t
device::mem_base_addr_align() const {
uint64_t page_size = 0;
os_get_page_size(&page_size);
return std::max((size_t)page_size, sizeof(cl_long) * 16);
}
cl_device_svm_capabilities
device::svm_support() const {
// Without CAP_RESOURCE_FROM_USER_MEMORY SVM and CL_MEM_USE_HOST_PTR
// interactions won't work according to spec as clover manages a GPU side
// copy of the host data.
//
// The biggest problem are memory buffers created with CL_MEM_USE_HOST_PTR,
// but the application and/or the kernel updates the memory via SVM and not
// the cl_mem buffer.
// We can't even do proper tracking on what memory might have been accessed
// as the host ptr to the buffer could be within a SVM region, where through
// the CL API there is no reliable way of knowing if a certain cl_mem buffer
// was accessed by a kernel or not and the runtime can't reliably know from
// which side the GPU buffer content needs to be updated.
//
// Another unsolvable scenario is a cl_mem object passed by cl_mem reference
// and SVM pointer into the same kernel at the same time.
if (allows_user_pointers() && pipe->get_param(pipe, PIPE_CAP_SYSTEM_SVM))
// we can emulate all lower levels if we support fine grain system
return CL_DEVICE_SVM_FINE_GRAIN_SYSTEM |
CL_DEVICE_SVM_COARSE_GRAIN_BUFFER |
CL_DEVICE_SVM_FINE_GRAIN_BUFFER;
return 0;
}
bool
device::allows_user_pointers() const {
return pipe->get_param(pipe, PIPE_CAP_RESOURCE_FROM_USER_MEMORY) ||
pipe->get_param(pipe, PIPE_CAP_RESOURCE_FROM_USER_MEMORY_COMPUTE_ONLY);
}
std::vector<size_t>
device::max_block_size() const {
auto v = get_compute_param<uint64_t>(pipe, ir_format(),
PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE);
return { v.begin(), v.end() };
}
cl_uint
device::subgroup_size() const {
return get_compute_param<uint32_t>(pipe, ir_format(),
PIPE_COMPUTE_CAP_SUBGROUP_SIZE)[0];
}
cl_uint
device::address_bits() const {
return get_compute_param<uint32_t>(pipe, ir_format(),
PIPE_COMPUTE_CAP_ADDRESS_BITS)[0];
}
std::string
device::device_name() const {
return pipe->get_name(pipe);
}
std::string
device::vendor_name() const {
return pipe->get_device_vendor(pipe);
}
enum pipe_shader_ir
device::ir_format() const {
if (supports_ir(PIPE_SHADER_IR_NATIVE))
return PIPE_SHADER_IR_NATIVE;
assert(supports_ir(PIPE_SHADER_IR_NIR_SERIALIZED));
return PIPE_SHADER_IR_NIR_SERIALIZED;
}
std::string
device::ir_target() const {
std::vector<char> target = get_compute_param<char>(
pipe, ir_format(), PIPE_COMPUTE_CAP_IR_TARGET);
return { target.data() };
}
enum pipe_endian
device::endianness() const {
return (enum pipe_endian)pipe->get_param(pipe, PIPE_CAP_ENDIANNESS);
}
std::string
device::device_version_as_string() const {
static const std::string version_string =
std::to_string(CL_VERSION_MAJOR(version)) + "." +
std::to_string(CL_VERSION_MINOR(version));
return version_string;
}
std::string
device::device_clc_version_as_string() const {
int major = CL_VERSION_MAJOR(clc_version);
int minor = CL_VERSION_MINOR(clc_version);
/* for CL 3.0 we need this to be 1.2 until we support 2.0. */
if (major == 3) {
major = 1;
minor = 2;
}
static const std::string version_string =
std::to_string(major) + "." +
std::to_string(minor);
return version_string;
}
bool
device::supports_ir(enum pipe_shader_ir ir) const {
return pipe->get_shader_param(pipe, PIPE_SHADER_COMPUTE,
PIPE_SHADER_CAP_SUPPORTED_IRS) & (1 << ir);
}
std::vector<cl_name_version>
device::supported_extensions() const {
std::vector<cl_name_version> vec;
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_khr_byte_addressable_store" } );
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_khr_global_int32_base_atomics" } );
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_khr_global_int32_extended_atomics" } );
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_khr_local_int32_base_atomics" } );
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_khr_local_int32_extended_atomics" } );
if (has_int64_atomics()) {
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_khr_int64_base_atomics" } );
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_khr_int64_extended_atomics" } );
}
if (has_doubles())
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_khr_fp64" } );
if (has_halves())
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_khr_fp16" } );
if (svm_support())
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_arm_shared_virtual_memory" } );
if (!clover::spirv::supported_versions().empty() &&
supports_ir(PIPE_SHADER_IR_NIR_SERIALIZED))
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_khr_il_program" } );
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "cl_khr_extended_versioning" } );
return vec;
}
std::string
device::supported_extensions_as_string() const {
static std::string extensions_string;
if (!extensions_string.empty())
return extensions_string;
const auto extension_list = supported_extensions();
for (const auto &extension : extension_list) {
if (!extensions_string.empty())
extensions_string += " ";
extensions_string += extension.name;
}
return extensions_string;
}
std::vector<cl_name_version>
device::supported_il_versions() const {
return clover::spirv::supported_versions();
}
const void *
device::get_compiler_options(enum pipe_shader_ir ir) const {
return pipe->get_compiler_options(pipe, ir, PIPE_SHADER_COMPUTE);
}
cl_version
device::device_version() const {
return version;
}
cl_version
device::device_clc_version(bool api) const {
/*
* For the API we have to limit this to 1.2,
* but internally we want 3.0 if it works.
*/
if (!api)
return clc_version;
int major = CL_VERSION_MAJOR(clc_version);
/* for CL 3.0 we need this to be 1.2 until we support 2.0. */
if (major == 3) {
return CL_MAKE_VERSION(1, 2, 0);
}
return clc_version;
}
std::vector<cl_name_version>
device::opencl_c_all_versions() const {
std::vector<cl_name_version> vec;
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 0, 0), "OpenCL C" } );
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 1, 0), "OpenCL C" } );
if (CL_VERSION_MAJOR(clc_version) == 1 &&
CL_VERSION_MINOR(clc_version) == 2)
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 2, 0), "OpenCL C" } );
if (CL_VERSION_MAJOR(clc_version) == 3) {
vec.push_back( cl_name_version{ CL_MAKE_VERSION(1, 2, 0), "OpenCL C" } );
vec.push_back( cl_name_version{ CL_MAKE_VERSION(3, 0, 0), "OpenCL C" } );
}
return vec;
}
std::vector<cl_name_version>
device::opencl_c_features() const {
std::vector<cl_name_version> vec;
vec.push_back( cl_name_version {CL_MAKE_VERSION(3, 0, 0), "__opencl_c_int64" });
if (has_doubles())
vec.push_back( cl_name_version {CL_MAKE_VERSION(3, 0, 0), "__opencl_c_fp64" });
return vec;
}
|
/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/
Copyright (c) 2000-2014 Torus Knot Software Ltd
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#include "OgreGLSLExtSupport.h"
#include "OgreGLSLLinkProgram.h"
#include "OgreStringConverter.h"
#include "OgreGLSLProgram.h"
#include "OgreGLSLLinkProgramManager.h"
#include "OgreException.h"
#include "OgreGpuProgramManager.h"
#include "OgreGLSLProgramCommon.h"
namespace Ogre {
namespace GLSL {
static GLint getGLGeometryInputPrimitiveType(RenderOperation::OperationType operationType)
{
switch (operationType)
{
case RenderOperation::OT_POINT_LIST:
return GL_POINTS;
case RenderOperation::OT_LINE_LIST:
case RenderOperation::OT_LINE_STRIP:
return GL_LINES;
case RenderOperation::OT_LINE_LIST_ADJ:
case RenderOperation::OT_LINE_STRIP_ADJ:
return GL_LINES_ADJACENCY_EXT;
case RenderOperation::OT_TRIANGLE_LIST_ADJ:
case RenderOperation::OT_TRIANGLE_STRIP_ADJ:
return GL_TRIANGLES_ADJACENCY_EXT;
default:
case RenderOperation::OT_TRIANGLE_LIST:
case RenderOperation::OT_TRIANGLE_STRIP:
case RenderOperation::OT_TRIANGLE_FAN:
return GL_TRIANGLES;
}
}
//-----------------------------------------------------------------------
static GLint getGLGeometryOutputPrimitiveType(RenderOperation::OperationType operationType)
{
switch (operationType)
{
case RenderOperation::OT_POINT_LIST:
return GL_POINTS;
case RenderOperation::OT_LINE_STRIP:
return GL_LINE_STRIP;
default:
case RenderOperation::OT_TRIANGLE_STRIP:
return GL_TRIANGLE_STRIP;
}
}
//-----------------------------------------------------------------------
GLSLLinkProgram::GLSLLinkProgram(GLSLProgram* vertexProgram, GLSLProgram* geometryProgram, GLSLProgram* fragmentProgram)
: GLSLProgramCommon(vertexProgram)
, mGeometryProgram(geometryProgram)
, mFragmentProgram(fragmentProgram)
{
// Initialise uniform cache
mUniformCache = new GLUniformCache();
}
//-----------------------------------------------------------------------
GLSLLinkProgram::~GLSLLinkProgram(void)
{
glDeleteObjectARB(mGLProgramHandle);
delete mUniformCache;
mUniformCache = 0;
}
//-----------------------------------------------------------------------
void GLSLLinkProgram::activate(void)
{
if (!mLinked)
{
glGetError(); //Clean up the error. Otherwise will flood log.
mGLProgramHandle = glCreateProgramObjectARB();
GLenum glErr = glGetError();
if(glErr != GL_NO_ERROR)
{
reportGLSLError( glErr, "GLSLLinkProgram::activate", "Error Creating GLSL Program Object", 0 );
}
uint32 hash = 0;
GpuProgram* progs[] = {mVertexShader, mGeometryProgram, mFragmentProgram};
for(auto p : progs)
{
if(!p) continue;
hash = p->_getHash(hash);
}
if ( GpuProgramManager::getSingleton().canGetCompiledShaderBuffer() &&
GpuProgramManager::getSingleton().isMicrocodeAvailableInCache(hash) &&
!mGeometryProgram)
{
getMicrocodeFromCache(hash);
}
else
{
compileAndLink();
}
buildGLUniformReferences();
extractAttributes();
}
if (mLinked)
{
GLenum glErr = glGetError();
if(glErr != GL_NO_ERROR)
{
reportGLSLError( glErr, "GLSLLinkProgram::Activate",
"Error prior to using GLSL Program Object : ", mGLProgramHandle, false, false);
}
glUseProgramObjectARB( mGLProgramHandle );
glErr = glGetError();
if(glErr != GL_NO_ERROR)
{
reportGLSLError( glErr, "GLSLLinkProgram::Activate",
"Error using GLSL Program Object : ", mGLProgramHandle, false, false);
}
}
}
//-----------------------------------------------------------------------
void GLSLLinkProgram::getMicrocodeFromCache(uint32 id)
{
GpuProgramManager::Microcode cacheMicrocode =
GpuProgramManager::getSingleton().getMicrocodeFromCache(id);
GLenum binaryFormat = *((GLenum *)(cacheMicrocode->getPtr()));
uint8 * programBuffer = cacheMicrocode->getPtr() + sizeof(GLenum);
size_t sizeOfBuffer = cacheMicrocode->size() - sizeof(GLenum);
glProgramBinary(mGLProgramHandle,
binaryFormat,
programBuffer,
static_cast<GLsizei>(sizeOfBuffer)
);
glGetProgramiv(mGLProgramHandle, GL_LINK_STATUS, &mLinked);
if (!mLinked)
{
//
// Something must have changed since the program binaries
// were cached away. Fallback to source shader loading path,
// and then retrieve and cache new program binaries once again.
//
compileAndLink();
}
}
//-----------------------------------------------------------------------
void GLSLLinkProgram::extractAttributes(void)
{
size_t numAttribs = sizeof(msCustomAttributes)/sizeof(CustomAttribute);
for (size_t i = 0; i < numAttribs; ++i)
{
const CustomAttribute& a = msCustomAttributes[i];
GLint attrib = glGetAttribLocationARB(mGLProgramHandle, a.name);
if (attrib != -1)
{
mValidAttributes.insert(a.attrib);
}
}
}
//-----------------------------------------------------------------------
bool GLSLLinkProgram::isAttributeValid(VertexElementSemantic semantic, uint index)
{
return mValidAttributes.find(getFixedAttributeIndex(semantic, index)) != mValidAttributes.end();
}
//-----------------------------------------------------------------------
void GLSLLinkProgram::buildGLUniformReferences(void)
{
if (!mUniformRefsBuilt)
{
const GpuConstantDefinitionMap* vertParams = 0;
const GpuConstantDefinitionMap* fragParams = 0;
const GpuConstantDefinitionMap* geomParams = 0;
if (mVertexShader)
{
vertParams = &(mVertexShader->getConstantDefinitions().map);
}
if (mGeometryProgram)
{
geomParams = &(mGeometryProgram->getConstantDefinitions().map);
}
if (mFragmentProgram)
{
fragParams = &(mFragmentProgram->getConstantDefinitions().map);
}
GLSLLinkProgramManager::extractUniforms(
mGLProgramHandle, vertParams, geomParams, fragParams, mGLUniformReferences);
mUniformRefsBuilt = true;
}
}
//-----------------------------------------------------------------------
void GLSLLinkProgram::updateUniforms(GpuProgramParametersSharedPtr params,
uint16 mask, GpuProgramType fromProgType)
{
// iterate through uniform reference list and update uniform values
GLUniformReferenceIterator currentUniform = mGLUniformReferences.begin();
GLUniformReferenceIterator endUniform = mGLUniformReferences.end();
// determine if we need to transpose matrices when binding
bool transpose = GL_TRUE;
if ((fromProgType == GPT_FRAGMENT_PROGRAM && mVertexShader && (!mVertexShader->getColumnMajorMatrices())) ||
(fromProgType == GPT_VERTEX_PROGRAM && mFragmentProgram && (!mFragmentProgram->getColumnMajorMatrices())) ||
(fromProgType == GPT_GEOMETRY_PROGRAM && mGeometryProgram && (!mGeometryProgram->getColumnMajorMatrices())))
{
transpose = GL_FALSE;
}
for (;currentUniform != endUniform; ++currentUniform)
{
// Only pull values from buffer it's supposed to be in (vertex or fragment)
// This method will be called twice, once for vertex program params,
// and once for fragment program params.
if (fromProgType == currentUniform->mSourceProgType)
{
const GpuConstantDefinition* def = currentUniform->mConstantDef;
if (def->variability & mask)
{
GLsizei glArraySize = (GLsizei)def->arraySize;
bool shouldUpdate = true;
switch (def->constType)
{
case GCT_INT1:
case GCT_INT2:
case GCT_INT3:
case GCT_INT4:
case GCT_SAMPLER1D:
case GCT_SAMPLER1DSHADOW:
case GCT_SAMPLER2D:
case GCT_SAMPLER2DSHADOW:
case GCT_SAMPLER2DARRAY:
case GCT_SAMPLER3D:
case GCT_SAMPLERCUBE:
shouldUpdate = mUniformCache->updateUniform(currentUniform->mLocation,
params->getIntPointer(def->physicalIndex),
static_cast<GLsizei>(def->elementSize * def->arraySize * sizeof(int)));
break;
default:
shouldUpdate = mUniformCache->updateUniform(currentUniform->mLocation,
params->getFloatPointer(def->physicalIndex),
static_cast<GLsizei>(def->elementSize * def->arraySize * sizeof(float)));
break;
}
if(!shouldUpdate)
continue;
// get the index in the parameter real list
switch (def->constType)
{
case GCT_FLOAT1:
glUniform1fvARB(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex));
break;
case GCT_FLOAT2:
glUniform2fvARB(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex));
break;
case GCT_FLOAT3:
glUniform3fvARB(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex));
break;
case GCT_FLOAT4:
glUniform4fvARB(currentUniform->mLocation, glArraySize,
params->getFloatPointer(def->physicalIndex));
break;
case GCT_MATRIX_2X2:
glUniformMatrix2fvARB(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex));
break;
case GCT_MATRIX_2X3:
if (GLEW_VERSION_2_1)
{
glUniformMatrix2x3fv(currentUniform->mLocation, glArraySize,
GL_FALSE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_2X4:
if (GLEW_VERSION_2_1)
{
glUniformMatrix2x4fv(currentUniform->mLocation, glArraySize,
GL_FALSE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_3X2:
if (GLEW_VERSION_2_1)
{
glUniformMatrix3x2fv(currentUniform->mLocation, glArraySize,
GL_FALSE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_3X3:
glUniformMatrix3fvARB(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex));
break;
case GCT_MATRIX_3X4:
if (GLEW_VERSION_2_1)
{
glUniformMatrix3x4fv(currentUniform->mLocation, glArraySize,
GL_FALSE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_4X2:
if (GLEW_VERSION_2_1)
{
glUniformMatrix4x2fv(currentUniform->mLocation, glArraySize,
GL_FALSE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_4X3:
if (GLEW_VERSION_2_1)
{
glUniformMatrix4x3fv(currentUniform->mLocation, glArraySize,
GL_FALSE, params->getFloatPointer(def->physicalIndex));
}
break;
case GCT_MATRIX_4X4:
glUniformMatrix4fvARB(currentUniform->mLocation, glArraySize,
transpose, params->getFloatPointer(def->physicalIndex));
break;
case GCT_SAMPLER1D:
case GCT_SAMPLER1DSHADOW:
case GCT_SAMPLER2D:
case GCT_SAMPLER2DSHADOW:
case GCT_SAMPLER2DARRAY:
case GCT_SAMPLER3D:
case GCT_SAMPLERCUBE:
// samplers handled like 1-element ints
case GCT_INT1:
glUniform1ivARB(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex));
break;
case GCT_INT2:
glUniform2ivARB(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex));
break;
case GCT_INT3:
glUniform3ivARB(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex));
break;
case GCT_INT4:
glUniform4ivARB(currentUniform->mLocation, glArraySize,
(GLint*)params->getIntPointer(def->physicalIndex));
break;
case GCT_UNKNOWN:
default:
break;
} // end switch
#if OGRE_DEBUG_MODE
GLenum glErr = glGetError();
if(glErr != GL_NO_ERROR)
{
reportGLSLError( glErr, "GLSLLinkProgram::updateUniforms", "Error updating uniform", 0 );
}
#endif
} // variability & mask
} // fromProgType == currentUniform->mSourceProgType
} // end for
}
//-----------------------------------------------------------------------
Ogre::String GLSLLinkProgram::getCombinedName()
{
String name;
if (mVertexShader)
{
name += "Vertex Program:" ;
name += mVertexShader->getName();
}
if (mFragmentProgram)
{
name += " Fragment Program:" ;
name += mFragmentProgram->getName();
}
if (mGeometryProgram)
{
name += " Geometry Program:" ;
name += mGeometryProgram->getName();
}
return name;
}
//-----------------------------------------------------------------------
void GLSLLinkProgram::compileAndLink()
{
uint32 hash = 0;
if (mVertexShader)
{
// attach Vertex Program
mVertexShader->attachToProgramObject(mGLProgramHandle);
setSkeletalAnimationIncluded(mVertexShader->isSkeletalAnimationIncluded());
// Some drivers (e.g. OS X on nvidia) incorrectly determine the attribute binding automatically
// and end up aliasing existing built-ins. So avoid!
// Bind all used attribs - not all possible ones otherwise we'll get
// lots of warnings in the log, and also may end up aliasing names used
// as varyings by accident
// Because we can't ask GL whether an attribute is used in the shader
// until it is linked (chicken and egg!) we have to parse the source
size_t numAttribs = sizeof(msCustomAttributes)/sizeof(CustomAttribute);
const String& vpSource = mVertexShader->getSource();
hash = mVertexShader->_getHash(hash);
for (size_t i = 0; i < numAttribs; ++i)
{
const CustomAttribute& a = msCustomAttributes[i];
// we're looking for either:
// attribute vec<n> <semantic_name>
// in vec<n> <semantic_name>
// The latter is recommended in GLSL 1.3 onwards
// be slightly flexible about formatting
String::size_type pos = vpSource.find(a.name);
bool foundAttr = false;
while (pos != String::npos && !foundAttr)
{
String::size_type startpos = vpSource.find("attribute", pos < 20 ? 0 : pos-20);
if (startpos == String::npos)
startpos = vpSource.find("in", pos-20);
if (startpos != String::npos && startpos < pos)
{
// final check
String expr = vpSource.substr(startpos, pos + strlen(a.name) - startpos);
StringVector vec = StringUtil::split(expr);
if ((vec[0] == "in" || vec[0] == "attribute") && vec[2] == a.name)
{
glBindAttribLocationARB(mGLProgramHandle, a.attrib, a.name);
foundAttr = true;
}
}
// Find the position of the next occurrence if needed
pos = vpSource.find(a.name, pos + strlen(a.name));
}
}
}
if (mGeometryProgram)
{
hash = mGeometryProgram->_getHash(hash);
// attach Geometry Program
mGeometryProgram->attachToProgramObject(mGLProgramHandle);
//Don't set adjacency flag. We handle it internally and expose "false"
RenderOperation::OperationType inputOperationType = mGeometryProgram->getInputOperationType();
glProgramParameteriEXT(mGLProgramHandle, GL_GEOMETRY_INPUT_TYPE_EXT,
getGLGeometryInputPrimitiveType(inputOperationType));
RenderOperation::OperationType outputOperationType = mGeometryProgram->getOutputOperationType();
glProgramParameteriEXT(mGLProgramHandle, GL_GEOMETRY_OUTPUT_TYPE_EXT,
getGLGeometryOutputPrimitiveType(outputOperationType));
glProgramParameteriEXT(mGLProgramHandle, GL_GEOMETRY_VERTICES_OUT_EXT,
mGeometryProgram->getMaxOutputVertices());
}
if (mFragmentProgram)
{
hash = mFragmentProgram->_getHash(hash);
// attach Fragment Program
mFragmentProgram->attachToProgramObject(mGLProgramHandle);
}
// now the link
glLinkProgramARB( mGLProgramHandle );
glGetObjectParameterivARB( mGLProgramHandle, GL_OBJECT_LINK_STATUS_ARB, &mLinked );
// force logging and raise exception if not linked
GLenum glErr = glGetError();
if(glErr != GL_NO_ERROR)
{
reportGLSLError( glErr, "GLSLLinkProgram::compileAndLink",
"Error linking GLSL Program Object : ", mGLProgramHandle, !mLinked, !mLinked );
}
if(mLinked)
{
logObjectInfo( getCombinedName() + String(" GLSL link result : "), mGLProgramHandle );
}
if (mLinked)
{
if ( GpuProgramManager::getSingleton().getSaveMicrocodesToCache() )
{
// add to the microcode to the cache
// get buffer size
GLint binaryLength = 0;
glGetProgramiv(mGLProgramHandle, GL_PROGRAM_BINARY_LENGTH, &binaryLength);
// turns out we need this param when loading
// it will be the first bytes of the array in the microcode
GLenum binaryFormat = 0;
// create microcode
GpuProgramManager::Microcode newMicrocode =
GpuProgramManager::getSingleton().createMicrocode(binaryLength + sizeof(GLenum));
// get binary
uint8 * programBuffer = newMicrocode->getPtr() + sizeof(GLenum);
glGetProgramBinary(mGLProgramHandle, binaryLength, NULL, &binaryFormat, programBuffer);
// save binary format
memcpy(newMicrocode->getPtr(), &binaryFormat, sizeof(GLenum));
// add to the microcode to the cache
GpuProgramManager::getSingleton().addMicrocodeToCache(hash, newMicrocode);
}
}
}
//-----------------------------------------------------------------------
} // namespace GLSL
} // namespace Ogre
|
/*
* This file is part of hipSYCL, a SYCL implementation based on CUDA/HIP
*
* Copyright (c) 2018 Aksel Alpay
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef HIPSYCL_EVENT_HPP
#define HIPSYCL_EVENT_HPP
#include "types.hpp"
#include "backend/backend.hpp"
#include "exception.hpp"
#include "info/info.hpp"
#include "detail/task_graph.hpp"
namespace cl {
namespace sycl {
// ToDo: Replace with detail::task_graph_node
class event {
public:
event()
: _is_null_event{true}
{}
event(const detail::task_graph_node_ptr& evt)
: _is_null_event{false}, _evt{evt}
{}
/* CL Interop is not supported
event(cl_event clEvent, const context& syclContext);
cl_event get();
*/
vector_class<event> get_wait_list()
{
return vector_class<event>{};
}
void wait()
{
if(!this->_is_null_event)
this->_evt->wait();
}
static void wait(const vector_class<event> &eventList)
{
for(const event& evt: eventList)
const_cast<event&>(evt).wait();
}
void wait_and_throw()
{
wait();
}
static void wait_and_throw(const vector_class<event> &eventList)
{
wait(eventList);
}
template <info::event param>
typename info::param_traits<info::event, param>::return_type get_info() const;
template <info::event_profiling param>
typename info::param_traits<info::event_profiling, param>::return_type get_profiling_info() const
{ throw unimplemented{"event::get_profiling_info() is unimplemented."}; }
bool operator ==(const event& rhs) const
{ return _evt == rhs._evt; }
bool operator !=(const event& rhs) const
{ return !(*this == rhs); }
private:
bool _is_null_event;
detail::task_graph_node_ptr _evt;
};
HIPSYCL_SPECIALIZE_GET_INFO(event, command_execution_status)
{
if(_evt->is_done())
return info::event_command_status::complete;
if(_evt->is_submitted())
return info::event_command_status::running;
return info::event_command_status::submitted;
}
HIPSYCL_SPECIALIZE_GET_INFO(event, reference_count)
{
return _evt.use_count();
}
} // namespace sycl
} // namespace cl
#endif
|
// Copyright (c) 2016 Till Kolditz
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
* File: Euclidean.hpp
* Author: Till Kolditz <till.kolditz@gmail.com>
*
* Created on 6. Dezember 2016, 00:55
*/
#ifndef EUCLIDEAN_HPP
#define EUCLIDEAN_HPP
#include <iostream>
#include <vector>
#include <cinttypes>
#include <exception>
#include <climits>
#include <boost/multiprecision/cpp_int.hpp>
using boost::multiprecision::uint128_t;
namespace Private {
template<typename T, typename S>
struct extractor {
};
template<typename T>
struct extractor<T, uint128_t> {
static T doIt(
const uint128_t source) {
const constexpr unsigned nBitsLimb = sizeof(boost::multiprecision::limb_type) * CHAR_BIT; // size of limb in bits
boost::multiprecision::limb_type target = 0;
const unsigned nLimbs = source.backend().size(); // number of limbs
auto pLimbs = source.backend().limbs();
for (unsigned i = 0; i < nLimbs && ((i * nBitsLimb) < (sizeof(T) * CHAR_BIT)); ++i) {
target |= (pLimbs[i]) << (i * nBitsLimb);
}
return static_cast<T>(target);
}
};
}
/*
* This algorithm actually computes the modulo inverse of the given first argument
* b0 in the residual class ring modulo <codewidth> (the second argument). One
* requirement of this algorithm is, that template type <T> is large enough to
* store <codewidth>+1 bits!
*/
template<typename T>
T ext_euclidean(
T b0,
size_t codewidth) {
if ((sizeof(T) * CHAR_BIT) <= codewidth) {
throw std::runtime_error("The template datatype is too small!");
}
T a0(1);
a0 <<= codewidth;
// T a[20], b[20], q[20], r[20], s[20], t[20];
std::vector<T> a(32), b(32), q(32), r(32), s(32), t(32);
// std::vector<uint128_t> a(32), b(32), q(32), r(32), s(32), t(32);
uint8_t aI = 1, bI = 1, qI = 0, rI = 0, sI = 1, tI = 1;
a[0] = a0;
b[0] = b0;
s[0] = 0;
t[0] = 0;
ssize_t i = 0;
do {
q[qI++] = a[i] / b[i];
r[rI++] = a[i] % b[i];
a[aI++] = b[i];
b[bI++] = r[i];
s[sI++] = 0;
t[tI++] = 0;
} while (b[++i] > 0);
s[i] = 1;
t[i] = 0;
for (ssize_t j = i; j > 0; --j) {
s[j - 1] = t[j];
t[j - 1] = s[j] - q[j - 1] * t[j];
}
T result = ((b0 * t[0]) % a0);
result += result < 0 ? a0 : 0;
if (result == 1) {
if constexpr (std::is_fundamental_v<T>) {
return t[0];
} else if constexpr (std::is_base_of_v<T, uint128_t>) {
return Private::extractor<T, uint128_t>::doIt(t[0]);
} else {
throw std::runtime_error("ext_euclidean not supported for this type!");
}
}
return 0;
}
#endif /* EUCLIDEAN_HPP */
|
/////////////////////////////////
/// @file MovUT.cpp
///
/// @brief Unit Test for MOV Instruction
///
/// @author Luke Karavolis
/////////////////////////////////
// SYSTEM INCLUDES
// (None)
// C PROJECT INCLUDES
// (None)
// C++ PROJECT INCLUDES
#include <catch2/catch.hpp>
#include "InstructionBase.hpp"
#include "InstructionBuilder.hpp"
#include "Process.hpp"
TEST_CASE("MOV Instruction", "[instruction][ArithAndLogic]")
{
Process myProc = Process();
InstructionBuilder& builder = InstructionBuilder::GetInstance();
InstructionBase* pInstruction = nullptr;
std::string instructionStr;
uint32_t a = GENERATE(take(5, random(INT32_MIN, INT32_MAX)));
myProc.GetProcessRegisters().genRegs[1] = a;
SECTION("Move a register")
{
instructionStr = "MOV R0, R1";
pInstruction = builder.BuildInstruction(instructionStr, &myProc);
pInstruction->Execute(myProc.GetProcessRegisters());
REQUIRE(myProc.GetProcessRegisters().genRegs[0] == a);
delete pInstruction;
}
SECTION("Move a literal")
{
instructionStr = "MOV R0, #" + std::to_string(a);
pInstruction = builder.BuildInstruction(instructionStr, &myProc);
pInstruction->Execute(myProc.GetProcessRegisters());
REQUIRE(myProc.GetProcessRegisters().genRegs[0] == a);
delete pInstruction;
}
SECTION("MOVS Test")
{
instructionStr = "MOVS R0, #0";
pInstruction = builder.BuildInstruction(instructionStr, &myProc);
pInstruction->Execute(myProc.GetProcessRegisters());
REQUIRE(myProc.GetProcessRegisters().GetZeroFlag());
REQUIRE(!myProc.GetProcessRegisters().GetNegativeFlag());
delete pInstruction;
instructionStr = "MOVS R0, #0xFFFFFFFF";
pInstruction = builder.BuildInstruction(instructionStr, &myProc);
pInstruction->Execute(myProc.GetProcessRegisters());
REQUIRE(!myProc.GetProcessRegisters().GetZeroFlag());
REQUIRE(myProc.GetProcessRegisters().GetNegativeFlag());
delete pInstruction;
}
}
|
/* $Id: display_vrdp.cpp 69500 2017-10-28 15:14:05Z vboxsync $ */
/** @file
* Presenter API: CrFbDisplayVrdp class implementation -- display content over VRDP.
*/
/*
* Copyright (C) 2014-2017 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#include "server_presenter.h"
CrFbDisplayVrdp::CrFbDisplayVrdp()
{
memset(&mPos, 0, sizeof (mPos));
}
int CrFbDisplayVrdp::EntryCreated(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
{
int rc = CrFbDisplayBase::EntryCreated(pFb, hEntry);
if (!RT_SUCCESS(rc))
{
WARN(("EntryAdded failed rc %d", rc));
return rc;
}
Assert(!CrFbDDataEntryGet(hEntry, slotGet()));
rc = vrdpCreate(pFb, hEntry);
if (!RT_SUCCESS(rc))
{
WARN(("vrdpCreate failed rc %d", rc));
return rc;
}
return VINF_SUCCESS;
}
int CrFbDisplayVrdp::EntryReplaced(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hNewEntry, HCR_FRAMEBUFFER_ENTRY hReplacedEntry)
{
int rc = CrFbDisplayBase::EntryReplaced(pFb, hNewEntry, hReplacedEntry);
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
const VBOXVR_SCR_COMPOSITOR_ENTRY* pReplacedEntry = CrFbEntryGetCompositorEntry(hReplacedEntry);
CR_TEXDATA *pReplacedTex = CrVrScrCompositorEntryTexGet(pReplacedEntry);
const VBOXVR_SCR_COMPOSITOR_ENTRY* pNewEntry = CrFbEntryGetCompositorEntry(hNewEntry);
CR_TEXDATA *pNewTex = CrVrScrCompositorEntryTexGet(pNewEntry);
CrTdBltDataInvalidateNe(pReplacedTex);
rc = CrTdBltEnter(pNewTex);
if (RT_SUCCESS(rc))
{
rc = vrdpFrame(hNewEntry);
CrTdBltLeave(pNewTex);
}
else
WARN(("CrTdBltEnter failed %d", rc));
return rc;
}
int CrFbDisplayVrdp::EntryTexChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
{
int rc = CrFbDisplayBase::EntryTexChanged(pFb, hEntry);
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
const VBOXVR_SCR_COMPOSITOR_ENTRY* pEntry = CrFbEntryGetCompositorEntry(hEntry);
CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(pEntry);
rc = CrTdBltEnter(pTex);
if (RT_SUCCESS(rc))
{
rc = vrdpFrame(hEntry);
CrTdBltLeave(pTex);
}
else
WARN(("CrTdBltEnter failed %d", rc));
return rc;
}
int CrFbDisplayVrdp::EntryRemoved(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
{
int rc = CrFbDisplayBase::EntryRemoved(pFb, hEntry);
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
const VBOXVR_SCR_COMPOSITOR_ENTRY* pEntry = CrFbEntryGetCompositorEntry(hEntry);
CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(pEntry);
CrTdBltDataInvalidateNe(pTex);
return vrdpRegions(pFb, hEntry);
}
int CrFbDisplayVrdp::EntryDestroyed(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
{
int rc = CrFbDisplayBase::EntryDestroyed(pFb, hEntry);
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
vrdpDestroy(hEntry);
return VINF_SUCCESS;
}
int CrFbDisplayVrdp::EntryPosChanged(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
{
int rc = CrFbDisplayBase::EntryPosChanged(pFb, hEntry);
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
vrdpGeometry(hEntry);
return VINF_SUCCESS;
}
int CrFbDisplayVrdp::RegionsChanged(struct CR_FRAMEBUFFER *pFb)
{
int rc = CrFbDisplayBase::RegionsChanged(pFb);
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
return vrdpRegionsAll(pFb);
}
int CrFbDisplayVrdp::FramebufferChanged(struct CR_FRAMEBUFFER *pFb)
{
int rc = CrFbDisplayBase::FramebufferChanged(pFb);
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
syncPos();
rc = vrdpSyncEntryAll(pFb);
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
return vrdpRegionsAll(pFb);
}
void CrFbDisplayVrdp::syncPos()
{
const struct VBVAINFOSCREEN* pScreenInfo = CrFbGetScreenInfo(getFramebuffer());
mPos.x = pScreenInfo->i32OriginX;
mPos.y = pScreenInfo->i32OriginY;
}
int CrFbDisplayVrdp::fbCleanup()
{
int rc = fbCleanupRemoveAllEntries();
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
return CrFbDisplayBase::fbCleanup();
}
int CrFbDisplayVrdp::fbSync()
{
syncPos();
int rc = fbSynchAddAllEntries();
if (!RT_SUCCESS(rc))
{
WARN(("err"));
return rc;
}
return CrFbDisplayBase::fbSync();
}
void CrFbDisplayVrdp::vrdpDestroy(HCR_FRAMEBUFFER_ENTRY hEntry)
{
void *pVrdp = CrFbDDataEntryGet(hEntry, slotGet());
cr_server.outputRedirect.CROREnd(pVrdp);
}
void CrFbDisplayVrdp::vrdpGeometry(HCR_FRAMEBUFFER_ENTRY hEntry)
{
void *pVrdp = CrFbDDataEntryGet(hEntry, slotGet());
const VBOXVR_SCR_COMPOSITOR_ENTRY* pEntry = CrFbEntryGetCompositorEntry(hEntry);
cr_server.outputRedirect.CRORGeometry(
pVrdp,
mPos.x + CrVrScrCompositorEntryRectGet(pEntry)->xLeft,
mPos.y + CrVrScrCompositorEntryRectGet(pEntry)->yTop,
CrVrScrCompositorEntryTexGet(pEntry)->Tex.width,
CrVrScrCompositorEntryTexGet(pEntry)->Tex.height);
}
int CrFbDisplayVrdp::vrdpRegions(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
{
void *pVrdp = CrFbDDataEntryGet(hEntry, slotGet());
const struct VBOXVR_SCR_COMPOSITOR* pCompositor = CrFbGetCompositor(pFb);
const VBOXVR_SCR_COMPOSITOR_ENTRY* pEntry = CrFbEntryGetCompositorEntry(hEntry);
uint32_t cRects;
const RTRECT *pRects;
int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRects, &pRects, NULL, NULL);
if (!RT_SUCCESS(rc))
{
WARN(("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc));
return rc;
}
cr_server.outputRedirect.CRORVisibleRegion(pVrdp, cRects, pRects);
return VINF_SUCCESS;
}
int CrFbDisplayVrdp::vrdpFrame(HCR_FRAMEBUFFER_ENTRY hEntry)
{
void *pVrdp = CrFbDDataEntryGet(hEntry, slotGet());
const VBOXVR_SCR_COMPOSITOR_ENTRY* pEntry = CrFbEntryGetCompositorEntry(hEntry);
CR_TEXDATA *pTex = CrVrScrCompositorEntryTexGet(pEntry);
const CR_BLITTER_IMG *pImg;
CrTdBltDataInvalidateNe(pTex);
int rc = CrTdBltDataAcquire(pTex, GL_BGRA, !!(CrVrScrCompositorEntryFlagsGet(pEntry) & CRBLT_F_INVERT_SRC_YCOORDS), &pImg);
if (!RT_SUCCESS(rc))
{
WARN(("CrTdBltDataAcquire failed rc %d", rc));
return rc;
}
cr_server.outputRedirect.CRORFrame(pVrdp, pImg->pvData, pImg->cbData);
CrTdBltDataRelease(pTex);
return VINF_SUCCESS;
}
int CrFbDisplayVrdp::vrdpRegionsAll(struct CR_FRAMEBUFFER *pFb)
{
const struct VBOXVR_SCR_COMPOSITOR* pCompositor = CrFbGetCompositor(pFb);
VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR Iter;
CrVrScrCompositorConstIterInit(pCompositor, &Iter);
const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
while ((pEntry = CrVrScrCompositorConstIterNext(&Iter)) != NULL)
{
HCR_FRAMEBUFFER_ENTRY hEntry = CrFbEntryFromCompositorEntry(pEntry);
vrdpRegions(pFb, hEntry);
}
return VINF_SUCCESS;
}
int CrFbDisplayVrdp::vrdpSynchEntry(struct CR_FRAMEBUFFER *pFb, HCR_FRAMEBUFFER_ENTRY hEntry)
{
vrdpGeometry(hEntry);
return vrdpRegions(pFb, hEntry);;
}
int CrFbDisplayVrdp::vrdpSyncEntryAll(struct CR_FRAMEBUFFER *pFb)
{
const struct VBOXVR_SCR_COMPOSITOR* pCompositor = CrFbGetCompositor(pFb);
VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR Iter;
CrVrScrCompositorConstIterInit(pCompositor, &Iter);
const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
while ((pEntry = CrVrScrCompositorConstIterNext(&Iter)) != NULL)
{
HCR_FRAMEBUFFER_ENTRY hEntry = CrFbEntryFromCompositorEntry(pEntry);
int rc = vrdpSynchEntry(pFb, hEntry);
if (!RT_SUCCESS(rc))
{
WARN(("vrdpSynchEntry failed rc %d", rc));
return rc;
}
}
return VINF_SUCCESS;
}
int CrFbDisplayVrdp::vrdpCreate(HCR_FRAMEBUFFER hFb, HCR_FRAMEBUFFER_ENTRY hEntry)
{
void *pVrdp;
/* Query supported formats. */
uint32_t cbFormats = 4096;
char *pachFormats = (char *)crAlloc(cbFormats);
if (!pachFormats)
{
WARN(("crAlloc failed"));
return VERR_NO_MEMORY;
}
int rc = cr_server.outputRedirect.CRORContextProperty(cr_server.outputRedirect.pvContext,
0 /* H3DOR_PROP_FORMATS */, /// @todo from a header
pachFormats, cbFormats, &cbFormats);
if (RT_SUCCESS(rc))
{
if (RTStrStr(pachFormats, "H3DOR_FMT_RGBA_TOPDOWN"))
{
cr_server.outputRedirect.CRORBegin(
cr_server.outputRedirect.pvContext,
&pVrdp,
"H3DOR_FMT_RGBA_TOPDOWN"); /// @todo from a header
if (pVrdp)
{
rc = CrFbDDataEntryPut(hEntry, slotGet(), pVrdp);
if (RT_SUCCESS(rc))
{
vrdpGeometry(hEntry);
vrdpRegions(hFb, hEntry);
//vrdpFrame(hEntry);
return VINF_SUCCESS;
}
else
WARN(("CrFbDDataEntryPut failed rc %d", rc));
cr_server.outputRedirect.CROREnd(pVrdp);
}
else
{
WARN(("CRORBegin failed"));
rc = VERR_GENERAL_FAILURE;
}
}
}
else
WARN(("CRORContextProperty failed rc %d", rc));
crFree(pachFormats);
return rc;
}
|
/********************************************************************************
* This file is part of CinoLib *
* Copyright(C) 2016: Marco Livesu *
* *
* The MIT License *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the "Software"), *
* to deal in the Software without restriction, including without limitation *
* the rights to use, copy, modify, merge, publish, distribute, sublicense, *
* and/or sell copies of the Software, and to permit persons to whom the *
* Software is furnished to do so, subject to the following conditions: *
* *
* The above copyright notice and this permission notice shall be included in *
* all copies or substantial portions of the Software. *
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
* FITNESS FOR A PARTICULAR PURPOSE AND NON INFRINGEMENT. IN NO EVENT SHALL THE *
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS *
* IN THE SOFTWARE. *
* *
* Author(s): *
* *
* Marco Livesu (marco.livesu@gmail.com) *
* http://pers.ge.imati.cnr.it/livesu/ *
* *
* Italian National Research Council (CNR) *
* Institute for Applied Mathematics and Information Technologies (IMATI) *
* Via de Marini, 6 *
* 16149 Genoa, *
* Italy *
*********************************************************************************/
#include <cinolib/drawable_vector_field.h>
namespace cinolib
{
CINO_INLINE
DrawableVectorField::DrawableVectorField()
{
arrow_color = Color::RED();
arrow_size = 1.0;
}
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
CINO_INLINE
DrawableVectorField::DrawableVectorField(const uint size) : VectorField(size)
{
pos.resize(size);
arrow_color = Color::RED();
arrow_size = 1.0;
}
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
CINO_INLINE
DrawableVectorField::DrawableVectorField(const std::vector<vec3d> & data,
const std::vector<vec3d> & pos)
: VectorField(data)
, pos(pos)
{
arrow_color = Color::RED();
arrow_size = 1.0;
}
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
template<class M, class V, class E, class P>
CINO_INLINE
DrawableVectorField::DrawableVectorField(const AbstractMesh<M,V,E,P> &m, const bool field_on_poly)
{
if(field_on_poly)
{
setZero(3*m.num_polys());
pos.resize(m.num_polys());
for(uint pid=0; pid<m.num_polys(); ++pid)
{
pos.at(pid) = m.poly_centroid(pid);
}
}
else
{
setZero(3*m.num_verts());
pos.resize(m.num_verts());
for(uint vid=0; vid<m.num_verts(); ++vid)
{
pos.at(vid) = m.vert(vid);
}
}
arrow_color = Color::RED();
arrow_size = 0.5 * m.edge_avg_length();
}
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
CINO_INLINE
void DrawableVectorField::draw(const float) const
{
for(uint i=0; i<pos.size(); ++i)
{
vec3d tip = pos.at(i) + (double)arrow_size * vec_at(i);
arrow<vec3d>(pos.at(i), tip, arrow_size*0.1, arrow_color.rgba);
}
}
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
CINO_INLINE
void DrawableVectorField::set_arrow_color(const Color &c)
{
arrow_color = c;
}
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
CINO_INLINE
void DrawableVectorField::set_arrow_size(float s)
{
arrow_size = s;
}
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
CINO_INLINE
Color DrawableVectorField::get_arrow_color() const
{
return arrow_color;
}
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
CINO_INLINE
float DrawableVectorField::get_arrow_size() const
{
return arrow_size;
}
}
|
#include <QtWidgets>
#include "dragwidget.h"
DragWidget::DragWidget(DragWidgetType dragType, QWidget *parent)
: QLabel(parent)
{
setMinimumSize(32, 32);
setFrameStyle(QFrame::Sunken | QFrame::StyledPanel);
// setAcceptDrops(true);
QString imgPath;
switch (dragType) {
case DragWidgetType::ShipNK:
imgPath = ":/images/ShipNK.png";
break;
case DragWidgetType::ShipSK:
imgPath = ":/images/ShipSK.png";
break;
case DragWidgetType::AirportNK:
imgPath = ":/images/AirportNK.png";
break;
case DragWidgetType::AirportSK:
imgPath = ":/images/AirportSK.png";
break;
case DragWidgetType::HelicopterCarNK:
imgPath = ":/images/HelicopterCarNK";
break;
case DragWidgetType::HelicopterCarSK:
imgPath = ":/images/HelicopterCarSK.png";
break;
}
type = dragType;
setPixmap(QPixmap(imgPath));
move(0, 0);
setAttribute(Qt::WA_DeleteOnClose);
}
void DragWidget::mousePressEvent(QMouseEvent *event)
{
QPixmap pixmap = *this->pixmap();;
QMimeData *mimeData = new QMimeData;
switch (type) {
case DragWidgetType::ShipNK:
mimeData->setText("ShipNK");
break;
case DragWidgetType::ShipSK:
mimeData->setText("ShipSK");
break;
case DragWidgetType::AirportNK:
mimeData->setText("AirportNK");
break;
case DragWidgetType::AirportSK:
mimeData->setText("AirportSK");
break;
case DragWidgetType::HelicopterCarNK:
mimeData->setText("HelicopterCarNK");
break;
case DragWidgetType::HelicopterCarSK:
mimeData->setText("HelicopterCarSK");
break;
}
QDrag *drag = new QDrag(this);
drag->setMimeData(mimeData);
drag->setPixmap(pixmap);
drag->setHotSpot(event->pos());
QPixmap tempPixmap = pixmap;
QPainter painter;
painter.begin(&tempPixmap);
painter.fillRect(pixmap.rect(), QColor(127, 127, 127, 127));
painter.end();
setPixmap(tempPixmap);
if (drag->exec(Qt::CopyAction | Qt::MoveAction, Qt::CopyAction) == Qt::MoveAction) {
close();
} else {
show();
setPixmap(pixmap);
}
}
DragWidgetType DragWidget::getType()
{
return type;
}
|
// This file is part of Notepad++ project
// Copyright (C)2017 Don HO <don.h@free.fr>
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// Note that the GPL places important restrictions on "derived works", yet
// it does not provide a detailed definition of that term. To avoid
// misunderstandings, we consider an application to constitute a
// "derivative work" for the purpose of this license if it does any of the
// following:
// 1. Integrates source code from Notepad++.
// 2. Integrates/includes/aggregates Notepad++ into a proprietary executable
// installer, such as those produced by InstallShield.
// 3. Links to a library or executes a program that does any of the above.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#include <algorithm>
#include <string>
#include <cctype>
#include <shlobj.h>
#include <shlwapi.h>
#include <uxtheme.h>
#include "pluginsAdmin.h"
#include "ScintillaEditView.h"
#include "localization.h"
#include "PluginsManager.h"
#include "md5.h"
using namespace std;
void Version::setVersionFrom(generic_string filePath)
{
if (not filePath.empty() && ::PathFileExists(filePath.c_str()))
{
DWORD handle;
DWORD bufferSize = ::GetFileVersionInfoSize(filePath.c_str(), &handle);
if (bufferSize <= 0)
return;
unsigned char* buffer = new unsigned char[bufferSize];
::GetFileVersionInfo(filePath.c_str(), handle, bufferSize, buffer);
VS_FIXEDFILEINFO* lpFileInfo;
UINT cbFileInfo = 0;
VerQueryValue(buffer, TEXT("\\"), (LPVOID*)&lpFileInfo, &cbFileInfo);
if (cbFileInfo)
{
_major = (lpFileInfo->dwFileVersionMS & 0xFFFF0000) >> 16;
_minor = lpFileInfo->dwFileVersionMS & 0x0000FFFF;
_patch = (lpFileInfo->dwFileVersionLS & 0xFFFF0000) >> 16;
_build = lpFileInfo->dwFileVersionLS & 0x0000FFFF;
}
}
}
generic_string Version::toString()
{
std::wstring v = std::to_wstring(_major);
v += TEXT(".");
v += std::to_wstring(_minor);
v += TEXT(".");
v += std::to_wstring(_patch);
v += TEXT(".");
v += std::to_wstring(_build);
return v;
}
generic_string PluginUpdateInfo::describe()
{
generic_string desc;
const TCHAR *EOL = TEXT("\r\n");
if (not description.empty())
{
desc = description;
desc += EOL;
}
if (not author.empty())
{
desc += TEXT("Author: ");
desc += author;
desc += EOL;
}
if (not homepage.empty())
{
desc += TEXT("Homepage: ");
desc += homepage;
desc += EOL;
}
return desc;
}
/// Try to find in the Haystack the Needle - ignore case
bool findStrNoCase(const generic_string & strHaystack, const generic_string & strNeedle)
{
auto it = std::search(
strHaystack.begin(), strHaystack.end(),
strNeedle.begin(), strNeedle.end(),
[](char ch1, char ch2){return std::toupper(ch1) == std::toupper(ch2); }
);
return (it != strHaystack.end());
}
LoadedPluginInfo::LoadedPluginInfo(const generic_string & fullFilePath, const generic_string & filename)
{
if (not::PathFileExists(fullFilePath.c_str()))
return;
_fullFilePath = fullFilePath;
_name = filename;
WcharMbcsConvertor *wmc = WcharMbcsConvertor::getInstance();
const char *path = wmc->wchar2char(fullFilePath.c_str(), CP_ACP);
MD5 md5;
_id = wmc->char2wchar(md5.digestFile(path), CP_ACP);
_version.setVersionFrom(fullFilePath);
}
long PluginsAdminDlg::searchFromCurrentSel(generic_string str2search, bool inWhichPart, bool isNextMode) const
{
// search from curent selected item or from the beginning
long currentIndex = _availableListView.getSelectedIndex();
int nbItem = static_cast<int>(_availableListView.nbItem());
if (currentIndex == -1)
{
// no selection, let's search from 0 to the end
for (int i = 0; i < nbItem; ++i)
{
size_t j = _availableListView.getLParamFromIndex(i);
generic_string searchIn;
if (inWhichPart == inNames)
searchIn = _availablePluginList[j].name;
else //(inWhichPart == inDescs)
searchIn = _availablePluginList[j].description;
if (findStrNoCase(searchIn, str2search))
return i;
}
}
else
{
// with selection, let's search from currentIndex
// from current position to the end
for (int i = currentIndex + (isNextMode ? 1 : 0); i < nbItem; ++i)
{
size_t j = _availableListView.getLParamFromIndex(i);
generic_string searchIn;
if (inWhichPart == inNames)
searchIn = _availablePluginList[j].name;
else //(inWhichPart == inDescs)
searchIn = _availablePluginList[j].description;
if (findStrNoCase(searchIn, str2search))
return i;
}
// from to begining to current position
for (int i = 0; i < currentIndex + (isNextMode ? 1 : 0); ++i)
{
size_t j = _availableListView.getLParamFromIndex(i);
generic_string searchIn;
if (inWhichPart == inNames)
searchIn = _availablePluginList[j].name;
else //(inWhichPart == inDescs)
searchIn = _availablePluginList[j].description;
if (findStrNoCase(searchIn, str2search))
return i;
}
}
return -1;
}
void PluginsAdminDlg::create(int dialogID, bool isRTL)
{
// get plugin installation path and launch mode (Admin or normal)
collectNppCurrentStatusInfos();
StaticDialog::create(dialogID, isRTL);
RECT rect;
getClientRect(rect);
_tab.init(_hInst, _hSelf, false, true);
int tabDpiDynamicalHeight = NppParameters::getInstance()->_dpiManager.scaleY(13);
_tab.setFont(TEXT("Tahoma"), tabDpiDynamicalHeight);
const TCHAR *available = TEXT("Available");
const TCHAR *updates = TEXT("Updates");
const TCHAR *installed = TEXT("Installed");
_tab.insertAtEnd(available);
_tab.insertAtEnd(updates);
_tab.insertAtEnd(installed);
rect.bottom -= 100;;
_tab.reSizeTo(rect);
_tab.display();
const long marge = 10;
const int topMarge = 42;
HWND hResearchLabel = ::GetDlgItem(_hSelf, IDC_PLUGINADM_RESEARCH_STATIC);
RECT researchLabelRect;
::GetClientRect(hResearchLabel, &researchLabelRect);
researchLabelRect.left = rect.left;
researchLabelRect.top = topMarge + 2;
::MoveWindow(hResearchLabel, researchLabelRect.left, researchLabelRect.top, researchLabelRect.right, researchLabelRect.bottom, TRUE);
::InvalidateRect(hResearchLabel, nullptr, TRUE);
HWND hResearchEdit = ::GetDlgItem(_hSelf, IDC_PLUGINADM_RESEARCH_EDIT);
RECT researchEditRect;
::GetClientRect(hResearchEdit, &researchEditRect);
researchEditRect.left = researchLabelRect.right + marge;
researchEditRect.top = topMarge;
::MoveWindow(hResearchEdit, researchEditRect.left, researchEditRect.top, researchEditRect.right, researchEditRect.bottom, TRUE);
::InvalidateRect(hResearchEdit, nullptr, TRUE);
HWND hNextButton = ::GetDlgItem(_hSelf, IDC_PLUGINADM_RESEARCH_NEXT);
RECT researchNextRect;
::GetClientRect(hNextButton, &researchNextRect);
researchNextRect.left = researchEditRect.left + researchEditRect.right + marge;
researchNextRect.top = topMarge;
::MoveWindow(hNextButton, researchNextRect.left, researchNextRect.top, researchNextRect.right, researchNextRect.bottom, TRUE);
::InvalidateRect(hNextButton, nullptr, TRUE);
HWND hActionButton = ::GetDlgItem(_hSelf, IDC_PLUGINADM_INSTALL);
RECT actionRect;
::GetClientRect(hActionButton, &actionRect);
long w = actionRect.right - actionRect.left;
actionRect.left = rect.right - w - marge;
actionRect.top = topMarge;
::MoveWindow(hActionButton, actionRect.left, actionRect.top, actionRect.right, actionRect.bottom, TRUE);
::InvalidateRect(hActionButton, nullptr, TRUE);
hActionButton = ::GetDlgItem(_hSelf, IDC_PLUGINADM_UPDATE);
::MoveWindow(hActionButton, actionRect.left, actionRect.top, actionRect.right, actionRect.bottom, TRUE);
::InvalidateRect(hActionButton, nullptr, TRUE);
hActionButton = ::GetDlgItem(_hSelf, IDC_PLUGINADM_REMOVE);
::MoveWindow(hActionButton, actionRect.left, actionRect.top, actionRect.right, actionRect.bottom, TRUE);
::InvalidateRect(hActionButton, nullptr, TRUE);
long actionZoneHeight = 50;
rect.top += actionZoneHeight;
rect.bottom -= actionZoneHeight;
RECT listRect = rect;
RECT descRect = rect;
long descHeight = rect.bottom / 3 - marge * 2;
long listHeight = (rect.bottom / 3) * 2 - marge * 3;
listRect.top += marge;
listRect.bottom = listHeight;
listRect.left += marge;
listRect.right -= marge * 2;
descRect.top += listHeight + marge * 3;
descRect.bottom = descHeight;
descRect.left += marge;
descRect.right -= marge * 2;
NppParameters *nppParam = NppParameters::getInstance();
NativeLangSpeaker *pNativeSpeaker = nppParam->getNativeLangSpeaker();
generic_string pluginStr = pNativeSpeaker->getAttrNameStr(TEXT("Plugin"), "PluginAdmin", "Plugin");
generic_string vesionStr = pNativeSpeaker->getAttrNameStr(TEXT("Version"), "PluginAdmin", "Version");
generic_string stabilityStr = pNativeSpeaker->getAttrNameStr(TEXT("Stability"), "PluginAdmin", "Stability");
_availableListView.addColumn(columnInfo(pluginStr, nppParam->_dpiManager.scaleX(200)));
_availableListView.addColumn(columnInfo(vesionStr, nppParam->_dpiManager.scaleX(100)));
_availableListView.addColumn(columnInfo(stabilityStr, nppParam->_dpiManager.scaleX(70)));
_availableListView.setStyleOption(LVS_EX_CHECKBOXES);
_availableListView.init(_hInst, _hSelf);
_availableListView.reSizeTo(listRect);
//_availableListView.display();
_updateListView.addColumn(columnInfo(pluginStr, nppParam->_dpiManager.scaleX(200)));
_updateListView.addColumn(columnInfo(vesionStr, nppParam->_dpiManager.scaleX(100)));
_updateListView.addColumn(columnInfo(stabilityStr, nppParam->_dpiManager.scaleX(70)));
_updateListView.setStyleOption(LVS_EX_CHECKBOXES);
_updateListView.init(_hInst, _hSelf);
_updateListView.reSizeTo(listRect);
//_updateListView.display(false);
_installedListView.addColumn(columnInfo(pluginStr, nppParam->_dpiManager.scaleX(200)));
_installedListView.addColumn(columnInfo(vesionStr, nppParam->_dpiManager.scaleX(100)));
_installedListView.addColumn(columnInfo(stabilityStr, nppParam->_dpiManager.scaleX(70)));
_installedListView.setStyleOption(LVS_EX_CHECKBOXES);
_installedListView.init(_hInst, _hSelf);
_installedListView.reSizeTo(listRect);
//_installedListView.display(false);
HWND hDesc = ::GetDlgItem(_hSelf, IDC_PLUGINADM_EDIT);
::MoveWindow(hDesc, descRect.left, descRect.top, descRect.right, descRect.bottom, TRUE);
::InvalidateRect(hDesc, nullptr, TRUE);
switchDialog(0);
ETDTProc enableDlgTheme = (ETDTProc)::SendMessage(_hParent, NPPM_GETENABLETHEMETEXTUREFUNC, 0, 0);
if (enableDlgTheme)
enableDlgTheme(_hSelf, ETDT_ENABLETAB);
goToCenter();
}
void PluginsAdminDlg::collectNppCurrentStatusInfos()
{
NppParameters *pNppParam = NppParameters::getInstance();
_nppCurrentStatus._nppInstallPath = pNppParam->getNppPath();
_nppCurrentStatus._isAppDataPluginsAllowed = ::SendMessage(_hParent, NPPM_GETAPPDATAPLUGINSALLOWED, 0, 0) == TRUE;
_nppCurrentStatus._appdataPath = pNppParam->getAppDataNppDir();
generic_string programFilesPath = NppParameters::getSpecialFolderLocation(CSIDL_PROGRAM_FILES);
_nppCurrentStatus._isInProgramFiles = (_nppCurrentStatus._nppInstallPath.find(programFilesPath) == 0);
}
bool PluginsAdminDlg::installPlugins()
{
return true;
}
bool PluginsAdminDlg::updatePlugins()
{
return true;
}
bool PluginsAdminDlg::removePlugins()
{
return true;
}
bool PluginsAdminDlg::downloadPluginList()
{
// check on default location : %APPDATA%\Notepad++\plugins\config\pl\pl.json or NPP_INST_DIR\plugins\config\pl\pl.json
// if absent then download it
// check the update ofpl.json
// download update if present
// check integrity of pl.json
// load pl.json
generic_string pluginListXmlPath(TEXT("c:\\tmp\\pl.xml"));
_pPluginsXmlDoc = new TiXmlDocument(pluginListXmlPath);
if (not _pPluginsXmlDoc->LoadFile())
return false;
return true;
}
bool PluginsAdminDlg::readFromXml()
{
TiXmlNode *root = _pPluginsXmlDoc->FirstChild(TEXT("NotepadPlus"));
if (not root)
return false;
_availablePluginList.clear();
for (TiXmlNode *childNode = root->FirstChildElement(TEXT("plugin"));
childNode;
childNode = childNode->NextSibling(TEXT("plugin")))
{
PluginUpdateInfo pui;
const TCHAR *name = (childNode->ToElement())->Attribute(TEXT("name"));
if (name)
{
pui.name = name;
}
else
{
continue;
}
const TCHAR *version = (childNode->ToElement())->Attribute(TEXT("version"));
if (version)
{
pui.version = version;
}
else
{
continue;
}
const TCHAR *homepage = (childNode->ToElement())->Attribute(TEXT("homepage"));
if (homepage)
{
pui.homepage = homepage;
}
const TCHAR *sourceUrl = (childNode->ToElement())->Attribute(TEXT("sourceUrl"));
if (sourceUrl)
{
pui.sourceUrl = sourceUrl;
}
const TCHAR *description = (childNode->ToElement())->Attribute(TEXT("description"));
if (description)
{
pui.description = description;
}
const TCHAR *author = (childNode->ToElement())->Attribute(TEXT("author"));
if (author)
{
pui.author = author;
}
else
{
continue;
}
const TCHAR *md5 = (childNode->ToElement())->Attribute(TEXT("md5"));
if (md5)
{
pui.md5 = md5;
}
else
{
continue;
}
const TCHAR *alias = (childNode->ToElement())->Attribute(TEXT("alias"));
if (alias)
{
pui.alias = alias;
}
const TCHAR *download = (childNode->ToElement())->Attribute(TEXT("download"));
if (download)
{
pui.download = download;
}
else
{
continue;
}
_availablePluginList.push_back(pui);
}
return true;
}
bool PluginsAdminDlg::loadFomList()
{
if (not _pPluginsXmlDoc)
return false;
if (not readFromXml())
return false;
size_t i = 0;
// all - installed = available
for (auto it = _availablePluginList.begin(); it != _availablePluginList.end(); ++it)
{
vector<generic_string> values2Add;
values2Add.push_back(it->name);
values2Add.push_back(it->version);
values2Add.push_back(TEXT("Yes"));
_availableListView.addLine(values2Add, i++);
}
getLoadedPluginInfos();
return true;
}
bool PluginsAdminDlg::getLoadedPluginInfos()
{
if (not _pPluginsManager)
return false;
for (auto it = _pPluginsManager->_loadedDlls.begin(); it != _pPluginsManager->_loadedDlls.end(); ++it)
{
LoadedPluginInfo lpi(it->_fullFilePath, it->_fileName);
_loadedPluginInfos.push_back(lpi);
}
return true;
}
// begin insentive-case search from the second key-in character
bool PluginsAdminDlg::searchInPlugins(bool isNextMode) const
{
const int maxLen = 256;
TCHAR txt2search[maxLen];
::GetDlgItemText(_hSelf, IDC_PLUGINADM_RESEARCH_EDIT, txt2search, maxLen);
if (lstrlen(txt2search) < 2)
return false;
long foundIndex = searchInNamesFromCurrentSel(txt2search, isNextMode);
if (foundIndex == -1)
foundIndex = searchInDescsFromCurrentSel(txt2search, isNextMode);
if (foundIndex == -1)
return false;
_availableListView.setSelection(foundIndex);
return true;
}
void PluginsAdminDlg::switchDialog(int indexToSwitch)
{
bool showAvailable, showUpdate, showInstalled;
switch (indexToSwitch)
{
case 0: // available plugins
showAvailable = true;
showUpdate = false;
showInstalled = false;
break;
case 1: // to be updated plugins
showAvailable = false;
showUpdate = true;
showInstalled = false;
break;
case 2: // installed plugin
showAvailable = false;
showUpdate = false;
showInstalled = true;
break;
default:
return;
}
HWND hInstallButton = ::GetDlgItem(_hSelf, IDC_PLUGINADM_INSTALL);
HWND hUpdateButton = ::GetDlgItem(_hSelf, IDC_PLUGINADM_UPDATE);
HWND hRemoveButton = ::GetDlgItem(_hSelf, IDC_PLUGINADM_REMOVE);
::ShowWindow(hInstallButton, showAvailable ? SW_SHOW : SW_HIDE);
::EnableWindow(hInstallButton, showAvailable);
::ShowWindow(hUpdateButton, showUpdate ? SW_SHOW : SW_HIDE);
::EnableWindow(hUpdateButton, showUpdate);
::ShowWindow(hRemoveButton, showInstalled ? SW_SHOW : SW_HIDE);
::EnableWindow(hRemoveButton, showInstalled);
_availableListView.display(showAvailable);
_updateListView.display(showUpdate);
_installedListView.display(showInstalled);
}
INT_PTR CALLBACK PluginsAdminDlg::run_dlgProc(UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG :
{
return TRUE;
}
case WM_COMMAND :
{
if (HIWORD(wParam) == EN_CHANGE)
{
switch (LOWORD(wParam))
{
case IDC_PLUGINADM_RESEARCH_EDIT:
{
searchInPlugins(false);
return TRUE;
}
}
}
switch (wParam)
{
case IDCANCEL :
case IDOK :
display(false);
return TRUE;
case IDC_PLUGINADM_RESEARCH_NEXT:
searchInPlugins(true);
return true;
case IDC_PLUGINADM_INSTALL:
installPlugins();
return true;
case IDC_PLUGINADM_UPDATE:
updatePlugins();
return true;
case IDC_PLUGINADM_REMOVE:
removePlugins();
return true;
default :
break;
}
return FALSE;
}
case WM_NOTIFY :
{
LPNMHDR pnmh = reinterpret_cast<LPNMHDR>(lParam);
if (pnmh->code == TCN_SELCHANGE)
{
HWND tabHandle = _tab.getHSelf();
if (pnmh->hwndFrom == tabHandle)
{
int indexClicked = int(::SendMessage(tabHandle, TCM_GETCURSEL, 0, 0));
switchDialog(indexClicked);
}
}
else if (pnmh->hwndFrom == _availableListView.getHSelf() && pnmh->code == LVN_ITEMCHANGED)
{
LPNMLISTVIEW pnmv = (LPNMLISTVIEW)lParam;
if (pnmv->uChanged & LVIF_STATE)
{
if (pnmv->uNewState & LVIS_SELECTED)
{
size_t infoIndex = _availableListView.getLParamFromIndex(pnmv->iItem);
generic_string desc = _availablePluginList[infoIndex].describe();
::SetDlgItemText(_hSelf, IDC_PLUGINADM_EDIT, desc.c_str());
}
}
}
return TRUE;
}
case WM_DESTROY :
{
return TRUE;
}
}
return FALSE;
}
|
// SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) 2021 Scipp contributors (https://github.com/scipp)
#include <gtest/gtest.h>
#include "scipp/core/element/comparison.h"
#include "scipp/units/unit.h"
#include "fix_typed_test_suite_warnings.h"
#include "test_macros.h"
using namespace scipp;
using namespace scipp::core::element;
template <typename T> class ElementLessTest : public ::testing::Test {};
template <typename T> class ElementGreaterTest : public ::testing::Test {};
template <typename T> class ElementLessEqualTest : public ::testing::Test {};
template <typename T> class ElementGreaterEqualTest : public ::testing::Test {};
template <typename T> class ElementEqualTest : public ::testing::Test {};
template <typename T> class ElementNotEqualTest : public ::testing::Test {};
using ElementLessTestTypes = ::testing::Types<double, float, int64_t, int32_t>;
TYPED_TEST_SUITE(ElementLessTest, ElementLessTestTypes);
TYPED_TEST_SUITE(ElementGreaterTest, ElementLessTestTypes);
TYPED_TEST_SUITE(ElementLessEqualTest, ElementLessTestTypes);
TYPED_TEST_SUITE(ElementGreaterEqualTest, ElementLessTestTypes);
TYPED_TEST_SUITE(ElementEqualTest, ElementLessTestTypes);
TYPED_TEST_SUITE(ElementNotEqualTest, ElementLessTestTypes);
TEST(ElementComparisonTest, unit) {
const units::Unit m(units::m);
EXPECT_EQ(comparison(m, m), units::dimensionless);
const units::Unit rad(units::rad);
EXPECT_THROW(comparison(rad, m), except::UnitError);
}
TYPED_TEST(ElementLessTest, value) {
using T = TypeParam;
T y = 1;
T x = 2;
EXPECT_EQ(less(y, x), true);
x = -1;
EXPECT_EQ(less(y, x), false);
x = 1;
EXPECT_EQ(less(y, x), false);
}
TYPED_TEST(ElementGreaterTest, value) {
using T = TypeParam;
T y = 1;
T x = 2;
EXPECT_EQ(greater(y, x), false);
x = -1;
EXPECT_EQ(greater(y, x), true);
x = 1;
EXPECT_EQ(greater(y, x), false);
}
TYPED_TEST(ElementLessEqualTest, value) {
using T = TypeParam;
T y = 1;
T x = 2;
EXPECT_EQ(less_equal(y, x), true);
x = 1;
EXPECT_EQ(less_equal(y, x), true);
x = -1;
EXPECT_EQ(less_equal(y, x), false);
}
TYPED_TEST(ElementGreaterEqualTest, value) {
using T = TypeParam;
T y = 1;
T x = 2;
EXPECT_EQ(greater_equal(y, x), false);
x = 1;
EXPECT_EQ(greater_equal(y, x), true);
x = -1;
EXPECT_EQ(greater_equal(y, x), true);
}
TYPED_TEST(ElementEqualTest, value) {
using T = TypeParam;
T y = 1;
T x = 2;
EXPECT_EQ(equal(y, x), false);
x = 1;
EXPECT_EQ(equal(y, x), true);
x = -1;
EXPECT_EQ(equal(y, x), false);
}
TYPED_TEST(ElementNotEqualTest, value) {
using T = TypeParam;
T y = 1;
T x = 2;
EXPECT_EQ(not_equal(y, x), true);
x = 1;
EXPECT_EQ(not_equal(y, x), false);
x = -1;
EXPECT_EQ(not_equal(y, x), true);
}
template <typename T> class ElementNanMinTest : public ::testing::Test {};
template <typename T> class ElementNanMaxTest : public ::testing::Test {};
using ElementNanMinTestTypes = ::testing::Types<double, float>;
TYPED_TEST_SUITE(ElementNanMinTest, ElementNanMinTestTypes);
TYPED_TEST_SUITE(ElementNanMaxTest, ElementNanMinTestTypes);
TYPED_TEST(ElementNanMinTest, value) {
using T = TypeParam;
T y = 1;
T x = 2;
nanmin_equals(y, x);
EXPECT_EQ(y, 1);
}
TYPED_TEST(ElementNanMinTest, value_nan) {
using T = TypeParam;
T y = NAN;
T x = 2;
nanmin_equals(y, x);
EXPECT_EQ(y, 2);
}
TYPED_TEST(ElementNanMaxTest, value) {
using T = TypeParam;
T y = 1;
T x = 2;
nanmax_equals(y, x);
EXPECT_EQ(y, 2);
}
TYPED_TEST(ElementNanMaxTest, value_nan) {
using T = TypeParam;
T y = 1;
T x = NAN;
nanmax_equals(y, x);
EXPECT_EQ(y, 1);
}
template <typename T> class IsCloseTest : public ::testing::Test {};
using IsCloseTestTypes = ::testing::Types<double, ValueAndVariance<double>>;
TYPED_TEST_SUITE(IsCloseTest, IsCloseTestTypes);
TYPED_TEST(IsCloseTest, value) {
TypeParam a = 1.0;
TypeParam b = 2.1;
EXPECT_TRUE(isclose(a, b, 1.2));
EXPECT_TRUE(isclose(a, b, 1.1));
EXPECT_FALSE(isclose(a, b, 1.0));
}
TYPED_TEST(IsCloseTest, value_not_equal_nans) {
EXPECT_FALSE(isclose(TypeParam(NAN), TypeParam(NAN), 1.e9));
EXPECT_FALSE(isclose(TypeParam(NAN), TypeParam(1.0), 1.e9));
EXPECT_FALSE(isclose(TypeParam(1.0), TypeParam(NAN), 1.e9));
EXPECT_FALSE(isclose(TypeParam(INFINITY), TypeParam(INFINITY), 1.e9));
EXPECT_FALSE(isclose(TypeParam(1.0), TypeParam(INFINITY), 1.e9));
EXPECT_FALSE(isclose(TypeParam(INFINITY), TypeParam(1.0), 1.e9));
EXPECT_FALSE(isclose(-TypeParam(INFINITY), -TypeParam(INFINITY), 1.e9));
EXPECT_FALSE(isclose(-TypeParam(1.0), -TypeParam(INFINITY), 1.e9));
EXPECT_FALSE(isclose(-TypeParam(INFINITY), -TypeParam(1.0), 1.e9));
}
TYPED_TEST(IsCloseTest, value_equal_nans) {
EXPECT_TRUE(isclose_equal_nan(TypeParam(NAN), TypeParam(NAN), 1.e9));
EXPECT_FALSE(isclose_equal_nan(TypeParam(NAN), TypeParam(1.0), 1.e9));
EXPECT_FALSE(isclose_equal_nan(TypeParam(1.0), TypeParam(NAN), 1.e9));
}
TYPED_TEST(IsCloseTest, value_equal_pos_infs) {
EXPECT_TRUE(
isclose_equal_nan(TypeParam(INFINITY), TypeParam(INFINITY), 1.e9));
EXPECT_FALSE(isclose_equal_nan(TypeParam(1.0), TypeParam(INFINITY), 1.e9));
EXPECT_FALSE(isclose_equal_nan(TypeParam(INFINITY), TypeParam(1.0), 1.e9));
}
TYPED_TEST(IsCloseTest, value_equal_neg_infs) {
EXPECT_TRUE(
isclose_equal_nan(-TypeParam(INFINITY), -TypeParam(INFINITY), 1.e9));
EXPECT_FALSE(isclose_equal_nan(-TypeParam(1.0), -TypeParam(INFINITY), 1.e9));
EXPECT_FALSE(isclose_equal_nan(-TypeParam(INFINITY), -TypeParam(1.0), 1.e9));
}
TYPED_TEST(IsCloseTest, value_equal_infs_signbit) {
EXPECT_FALSE(
isclose_equal_nan(-TypeParam(INFINITY), TypeParam(INFINITY), 1.e9));
EXPECT_FALSE(
isclose_equal_nan(TypeParam(INFINITY), -TypeParam(INFINITY), 1.e9));
}
template <class Op> void do_isclose_units_test(Op op) {
EXPECT_EQ(units::dimensionless, op(units::m, units::m, units::m));
EXPECT_THROW_DISCARD(op(units::m, units::m, units::s), except::UnitError);
EXPECT_THROW_DISCARD(op(units::m, units::s, units::m), except::UnitError);
EXPECT_THROW_DISCARD(op(units::s, units::m, units::m), except::UnitError);
}
TEST(IsCloseTest, units) {
do_isclose_units_test(isclose);
do_isclose_units_test(isclose_equal_nan);
}
constexpr auto check_inplace = [](auto op, auto a, auto b, auto expected) {
op(a, b);
EXPECT_EQ(a, expected);
};
TEST(ComparisonTest, min_max_support_time_point) {
static_cast<void>(std::get<core::time_point>(decltype(max_equals)::types{}));
static_cast<void>(std::get<core::time_point>(decltype(min_equals)::types{}));
static_cast<void>(
std::get<core::time_point>(decltype(nanmax_equals)::types{}));
static_cast<void>(
std::get<core::time_point>(decltype(nanmin_equals)::types{}));
}
TEST(ComparisonTest, max_equals) {
check_inplace(max_equals, 1, 2, 2);
check_inplace(max_equals, 2, 1, 2);
check_inplace(max_equals, 1.2, 1.3, 1.3);
check_inplace(max_equals, 1.3, 1.2, 1.3);
check_inplace(max_equals, core::time_point(23), core::time_point(13),
core::time_point(23));
}
TEST(ComparisonTest, min_equals) {
check_inplace(min_equals, 1, 2, 1);
check_inplace(min_equals, 2, 1, 1);
check_inplace(min_equals, 1.2, 1.3, 1.2);
check_inplace(min_equals, 1.3, 1.2, 1.2);
check_inplace(min_equals, core::time_point(23), core::time_point(13),
core::time_point(13));
}
|
#include "core/precomp.h"
#include "core/ecs/entity.hpp"
#include "core/ecs/world.hpp"
#include "core/ecs/component.hpp"
namespace Khan
{
Entity::Entity(entt::entity handle, World* world)
: m_EntityHandle(handle)
, m_World(world)
{
}
void Entity::AddChild(Entity* child)
{
m_Children.insert(child);
child->SetParent(this);
}
void Entity::RemoveChild(Entity* child)
{
m_Children.erase(child);
if (child->GetParent() == this)
{
child->SetParent(nullptr);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
#ifndef ONLINE_JUDGE
freopen("files/input.txt", "r", stdin);
freopen("files/output.txt", "w", stdout);
#endif
int n, k;
cin >> n >> k;
string s; cin >> s;
map<char, int> freq;
for (int i = 0; i < k; ++i)
freq['A' + i] = 0;
for ( auto ch: s ) freq[ch]++;
auto min = min_element(freq.begin(), freq.end(), [](auto a, auto b) {
return a.second < b.second;
});
cout << min->second * k << endl;
return 0;
}
|
/***********************************************************************
created: 20th February 2010
author: Lukas E Meindl
purpose: Implementation of ColourPickerControls base class
*************************************************************************/
/***************************************************************************
* Copyright (C) 2004 - 2011 Paul D Turner & The CEGUI Development Team
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
***************************************************************************/
#include "CEGUI/widgets/PushButton.h"
#include "CEGUI/widgets/Editbox.h"
#include "CEGUI/widgets/RadioButton.h"
#include "CEGUI/widgets/Titlebar.h"
#include "CEGUI/widgets/Slider.h"
#include "CEGUI/widgets/Thumb.h"
#include "CEGUI/System.h"
#include "CEGUI/Renderer.h"
#include "CEGUI/Cursor.h"
#include "CEGUI/WindowManager.h"
#include "CEGUI/Exceptions.h"
#include "CEGUI/ImageManager.h"
#include "CEGUI/BitmapImage.h"
#include "CEGUI/CoordConverter.h"
#include "CEGUI/Logger.h"
#include "CEGUI/CommonDialogs/ColourPicker/ColourPicker.h"
#include "CEGUI/CommonDialogs/ColourPicker/Controls.h"
#include "CEGUI/CommonDialogs/ColourPicker/Conversions.h"
#include "CEGUI/TextureTarget.h"
#include "CEGUI/Texture.h"
#include "CEGUI/PropertyHelper.h"
#if defined(CEGUI_REGEX_MATCHER_PCRE)
# include "CEGUI/PCRERegexMatcher.h"
#elif defined(CEGUI_REGEX_MATCHER_STD)
# include "CEGUI/StdRegexMatcher.h"
#endif
#include <sstream>
#include <algorithm>
#include <math.h>
namespace CEGUI
{
//----------------------------------------------------------------------------//
const String ColourPickerControls::EventNamespace("ColourPickerControls");
const String ColourPickerControls::WidgetTypeName("CEGUI/ColourPickerControls");
const String ColourPickerControls::EventColourAccepted("ColourAccepted");
const String ColourPickerControls::EventClosed("Closed");
const String ColourPickerControls::ColourRectPropertyName("Colour");
//----------------------------------------------------------------------------//
const String ColourPickerControls::ColourPickerControlsPickingTextureImageName("ColourPickingTexture");
const String ColourPickerControls::ColourPickerControlsColourSliderTextureImageName("ColourSliderTexture");
const String ColourPickerControls::ColourPickerControlsAlphaSliderTextureImageName("AlphaSliderTexture");
//----------------------------------------------------------------------------//
const float ColourPickerControls::LAB_L_MIN(0.0f);
const float ColourPickerControls::LAB_L_MAX(100.0f);
const float ColourPickerControls::LAB_L_DIFF(LAB_L_MAX - LAB_L_MIN);
const float ColourPickerControls::LAB_A_MIN(-130.0f);
const float ColourPickerControls::LAB_A_MAX(130.0f);
const float ColourPickerControls::LAB_A_DIFF(LAB_A_MAX - LAB_A_MIN);
const float ColourPickerControls::LAB_B_MIN(-130.0f);
const float ColourPickerControls::LAB_B_MAX(130.0f);
const float ColourPickerControls::LAB_B_DIFF(LAB_B_MAX - LAB_B_MIN);
//----------------------------------------------------------------------------//
// Child Widget name constants
const String ColourPickerControls::CancelButtonName("__auto_cancelbutton__");
const String ColourPickerControls::AcceptButtonName("__auto_acceptbutton__");
const String ColourPickerControls::HexaDecimalDescriptionName("__auto_hexadecimalstatictext__");
const String ColourPickerControls::HexaDecimalEditBoxName("__auto_hexadecimaleditbox__");
const String ColourPickerControls::TitleBarName("__auto_titlebar__");
const String ColourPickerControls::ColourPickerStaticImageName("__auto_colourpickerstaticimage__");
const String ColourPickerControls::ColourPickerImageSliderName("__auto_colourpickerimageslider__");
const String ColourPickerControls::ColourPickerAlphaSliderName("__auto_colourpickeralphaslider__");
const String ColourPickerControls::NewColourDescriptionName("__auto_newcolourdescription__");
const String ColourPickerControls::OldColourDescriptionName("__auto_oldcolourdescription__");
const String ColourPickerControls::NewColourRectName("__auto_newcolourrect__");
const String ColourPickerControls::OldColourRectName("__auto_oldcolourrect__");
const String ColourPickerControls::ColourEditBoxRDescriptionName("__auto_coloureditboxRdescription__");
const String ColourPickerControls::ColourEditBoxRName("__auto_coloureditboxR__");
const String ColourPickerControls::ColourEditBoxGDescriptionName("__auto_coloureditboxGdescription__");
const String ColourPickerControls::ColourEditBoxGName("__auto_coloureditboxG__");
const String ColourPickerControls::ColourEditBoxBDescriptionName("__auto_coloureditboxBdescription__");
const String ColourPickerControls::ColourEditBoxBName("__auto_coloureditboxB__");
const String ColourPickerControls::HSVRadioButtonHName("__auto_HSVradiobuttonH__");
const String ColourPickerControls::HSVEditBoxHName("__auto_HSVeditboxH__");
const String ColourPickerControls::HSVRadioButtonSName("__auto_HSVradiobuttonS__");
const String ColourPickerControls::HSVEditBoxSName("__auto_HSVeditboxS__");
const String ColourPickerControls::HSVRadioButtonVName("__auto_HSVradiobuttonV__");
const String ColourPickerControls::HSVEditBoxVName("__auto_HSVeditboxV__");
const String ColourPickerControls::LabRadioButtonLName("__auto_LabradiobuttonL__");
const String ColourPickerControls::LabEditBoxLName("__auto_LabeditboxL__");
const String ColourPickerControls::LabRadioButtonAName("__auto_Labradiobuttona__");
const String ColourPickerControls::LabEditBoxAName("__auto_Labeditboxa__");
const String ColourPickerControls::LabRadioButtonBName("__auto_Labradiobuttonb__");
const String ColourPickerControls::LabEditBoxBName("__auto_Labeditboxb__");
const String ColourPickerControls::AlphaEditBoxName("__auto_alphaeditbox__");
const String ColourPickerControls::ColourPickerCursorName("__colourpickercursor__");
//----------------------------------------------------------------------------//
static RegexMatcher* createRegexMatcher()
{
#if defined(CEGUI_REGEX_MATCHER_PCRE)
return new PCRERegexMatcher();
#elif defined(CEGUI_REGEX_MATCHER_STD)
return new StdRegexMatcher();
#else
return nullptr;
#endif
}
//----------------------------------------------------------------------------//
ColourPickerControls::ColourPickerControls(const String& type, const String& name) :
Window(type, name),
d_callingColourPicker(nullptr),
d_colourPickerIndicator(nullptr),
d_sliderMode(SliderMode::LAB_L),
d_selectedColour(0.75f, 0.75f, 0.75f),
d_colourPickerControlsTextureTarget(nullptr),
d_colourPickerImageOffset(2),
d_colourPickerPickingImageHeight(260),
d_colourPickerPickingImageWidth(260),
d_colourPickerColourSliderImageWidth(1),
d_colourPickerColourSliderImageHeight(260),
d_colourPickerAlphaSliderImageWidth(260),
d_colourPickerAlphaSliderImageHeight(60),
d_colourPickerControlsTextureSize(512),
d_draggingColourPickerIndicator(false),
d_colourPickingTexture(new RGB_Colour[d_colourPickerControlsTextureSize *
d_colourPickerControlsTextureSize]),
d_ignoreEvents(false),
d_regexMatcher(*createRegexMatcher())
{
}
//----------------------------------------------------------------------------//
ColourPickerControls::~ColourPickerControls()
{
}
//----------------------------------------------------------------------------//
Lab_Colour ColourPickerControls::getColourPickingPositionColourLAB(float xAbs,
float yAbs)
{
float L = 0.0f;
float a = 0.0f;
float b = 0.0f;
float xRel = xAbs / static_cast<float>(d_colourPickerPickingImageWidth - 1);
float yRel = yAbs / static_cast<float>(d_colourPickerPickingImageHeight - 1);
if (d_sliderMode != LAB_L)
{
L = LAB_L_MAX - LAB_L_DIFF * yRel ;
if (d_sliderMode != LAB_A)
{
b = d_selectedColourLAB.b;
a = LAB_A_MAX - LAB_A_DIFF * xRel;
}
else
{
a = d_selectedColourLAB.a;
b = LAB_B_MAX - LAB_B_DIFF * xRel;
}
}
else
{
L = d_selectedColourLAB.L;
a = LAB_A_MAX - LAB_A_DIFF * xRel;
b = LAB_B_MAX - LAB_B_DIFF * yRel;
}
return Lab_Colour(L, a, b);
}
//----------------------------------------------------------------------------//
HSV_Colour ColourPickerControls::getColourPickingPositionColourHSV(float xAbs,
float yAbs)
{
HSV_Colour colour;
float xRel = xAbs / static_cast<float>(d_colourPickerPickingImageWidth - 1);
float yRel = yAbs / static_cast<float>(d_colourPickerPickingImageHeight - 1);
if (d_sliderMode != SliderMode::HSV_H)
{
float xCoord = (xRel - 0.5f) * 2.0f;
float yCoord = (yRel - 0.5f) * 2.0f;
float angle = std::atan2(yCoord, xCoord);
if (angle < 0.0f)
angle += 2.0f * 3.1415926535897932384626433832795f;
angle /= 2.0f * 3.1415926535897932384626433832795f;
colour.H = angle;
float length = std::sqrt(xCoord * xCoord + yCoord * yCoord);
float value = std::min(length, 1.0f);
if (d_sliderMode != SliderMode::HSV_S)
{
colour.V = d_selectedColourHSV.V;
colour.S = value;
}
else
{
colour.S = d_selectedColourHSV.S;
colour.V = value;
}
}
else
{
colour.H = d_selectedColourHSV.H;
colour.S = xRel;
colour.V = 1.0f - yRel;
}
return colour;
}
//----------------------------------------------------------------------------//
glm::vec2 ColourPickerControls::getColourPickingColourPosition()
{
float x = 0.0f;
float y = 0.0f;
switch (d_sliderMode)
{
case LAB_L:
x = 1.0f - (d_selectedColourLAB.a - LAB_A_MIN) / LAB_A_DIFF;
y = 1.0f - (d_selectedColourLAB.b - LAB_B_MIN) / LAB_B_DIFF;
break;
case LAB_A:
x = 1.0f - (d_selectedColourLAB.b - LAB_B_MIN) / LAB_B_DIFF;
y = 1.0f - (d_selectedColourLAB.L - LAB_L_MIN) / LAB_L_DIFF;
break;
case SliderMode::LAB_B:
x = 1.0f - (d_selectedColourLAB.a - LAB_A_MIN) / LAB_A_DIFF;
y = 1.0f - (d_selectedColourLAB.L - LAB_L_MIN) / LAB_L_DIFF;
break;
case SliderMode::HSV_H:
x = d_selectedColourHSV.S;
y = 1.0f - d_selectedColourHSV.V;
break;
case SliderMode::HSV_S:
getColourPickingColourPositionHSV(x, y);
break;
case SliderMode::HSV_V:
getColourPickingColourPositionHSV(x, y);
break;
default:
break;
}
return glm::vec2(x, y);
}
//----------------------------------------------------------------------------//
void ColourPickerControls::getColourPickingColourPositionHSV(float& x, float& y)
{
float radius;
switch (d_sliderMode)
{
case SliderMode::HSV_S:
radius = d_selectedColourHSV.V;
break;
case SliderMode::HSV_V:
radius = d_selectedColourHSV.S;
break;
default:
radius = 0.0f; //This shouldn't happen. (PDT: Why is it here, then?)
break;
}
float angle = d_selectedColourHSV.H;
angle *= 2.0f * 3.1415926535897932384626433832795f;
x = radius * cos(angle) * 0.5f + 0.5f;
y = radius * sin(angle) * 0.5f + 0.5f;
}
//----------------------------------------------------------------------------//
Lab_Colour ColourPickerControls::getColourSliderPositionColourLAB(float value)
{
Lab_Colour colour = d_selectedColourLAB;
switch (d_sliderMode)
{
case LAB_L:
colour.L = LAB_L_MAX - LAB_L_DIFF * value;
break;
case LAB_A:
colour.a = LAB_A_MAX - LAB_A_DIFF * value;
break;
case SliderMode::LAB_B:
colour.b = LAB_B_MAX - LAB_B_DIFF * value;
break;
default:
break;
}
return colour;
}
//----------------------------------------------------------------------------//
HSV_Colour ColourPickerControls::getColourSliderPositionColourHSV(float value)
{
HSV_Colour colour = d_selectedColourHSV;
switch (d_sliderMode)
{
case SliderMode::HSV_H:
colour.H = 1.0f - value;
break;
case SliderMode::HSV_S:
colour.S = 1.0f - value;
break;
case SliderMode::HSV_V:
colour.V = 1.0f - value;
break;
default:
break;
}
return colour;
}
//----------------------------------------------------------------------------//
void ColourPickerControls::initColourPickerControlsImageSet()
{
d_colourPickerControlsTextureTarget =
System::getSingleton().getRenderer()->createTextureTarget(false);
const String baseName(
d_colourPickerControlsTextureTarget->getTexture().getName());
BitmapImage* image = static_cast<BitmapImage*>(
&ImageManager::getSingleton().create("BitmapImage", baseName + '/' +
ColourPickerControlsPickingTextureImageName));
image->setTexture(&d_colourPickerControlsTextureTarget->getTexture());
image->setImageArea(
Rectf(glm::vec2(0.0f, 0.0f),
Sizef(static_cast<float>(d_colourPickerPickingImageWidth),
static_cast<float>(d_colourPickerPickingImageHeight))));
image = static_cast<BitmapImage*>(
&ImageManager::getSingleton().create("BitmapImage", baseName + '/' +
ColourPickerControlsColourSliderTextureImageName));
image->setTexture(&d_colourPickerControlsTextureTarget->getTexture());
image->setImageArea(
Rectf(glm::vec2(static_cast<float>(d_colourPickerPickingImageWidth + d_colourPickerImageOffset), 0.0f),
Sizef(static_cast<float>(d_colourPickerColourSliderImageWidth),
static_cast<float>(d_colourPickerColourSliderImageHeight))));
image = static_cast<BitmapImage*>(
&ImageManager::getSingleton().create("BitmapImage", baseName + '/' +
ColourPickerControlsAlphaSliderTextureImageName));
image->setTexture(&d_colourPickerControlsTextureTarget->getTexture());
image->setImageArea(
Rectf(glm::vec2(0.0f, static_cast<float>(d_colourPickerPickingImageHeight + d_colourPickerImageOffset)),
Sizef(static_cast<float>(d_colourPickerAlphaSliderImageWidth),
static_cast<float>(d_colourPickerAlphaSliderImageHeight))));
getColourPickerStaticImage()->setProperty(
"Image", baseName + '/' + ColourPickerControlsPickingTextureImageName);
getColourPickerImageSlider()->setProperty(
"ScrollImage", baseName + '/' + ColourPickerControlsColourSliderTextureImageName);
getColourPickerAlphaSlider()->setProperty(
"ScrollImage", baseName + '/' + ColourPickerControlsAlphaSliderTextureImageName);
refreshColourPickerControlsTextures();
}
//----------------------------------------------------------------------------//
void ColourPickerControls::deinitColourPickerControlsTexture()
{
if (d_colourPickerControlsTextureTarget)
{
ImageManager::getSingleton().destroyImageCollection(
d_colourPickerControlsTextureTarget->getTexture().getName(), false);
System::getSingleton().getRenderer()->
destroyTextureTarget(d_colourPickerControlsTextureTarget);
}
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshColourPickerControlsTextures()
{
Logger::getSingleton().logEvent(
"[ColourPicker] Refreshing ColourPickerTexture");
refreshColourPickingImage();
refreshColourSliderImage();
refreshAlphaSliderImage();
reloadColourPickerControlsTexture();
}
//----------------------------------------------------------------------------//
void ColourPickerControls::reloadColourPickerControlsTexture()
{
d_colourPickerControlsTextureTarget->getTexture().loadFromMemory(
d_colourPickingTexture,
Sizef(static_cast<float>(d_colourPickerControlsTextureSize),
static_cast<float>(d_colourPickerControlsTextureSize)),
Texture::PixelFormat::Rgb);
getColourPickerImageSlider()->invalidate();
getColourPickerAlphaSlider()->invalidate();
getColourPickerStaticImage()->invalidate();
}
//----------------------------------------------------------------------------//
void ColourPickerControls::initialiseComponents()
{
getCancelButton()->subscribeEvent(
PushButton::EventClicked,
Event::Subscriber(&ColourPickerControls::handleCancelButtonClicked, this));
getAcceptButton()->subscribeEvent(
PushButton::EventClicked,
Event::Subscriber(&ColourPickerControls::handleAcceptButtonClicked, this));
getHexadecimalEditbox()->subscribeEvent(
Editbox::EventDeactivated,
Event::Subscriber(&ColourPickerControls::handleEditboxDeactivated, this));
getColourEditBoxR()->subscribeEvent(
Editbox::EventDeactivated,
Event::Subscriber(&ColourPickerControls::handleEditboxDeactivated, this));
getColourEditBoxG()->subscribeEvent(
Editbox::EventDeactivated,
Event::Subscriber(&ColourPickerControls::handleEditboxDeactivated, this));
getColourEditBoxB()->subscribeEvent(
Editbox::EventDeactivated,
Event::Subscriber(&ColourPickerControls::handleEditboxDeactivated, this));
getHSVEditBoxH()->subscribeEvent(
Editbox::EventDeactivated,
Event::Subscriber(&ColourPickerControls::handleEditboxDeactivated, this));
getHSVEditBoxS()->subscribeEvent(
Editbox::EventDeactivated,
Event::Subscriber(&ColourPickerControls::handleEditboxDeactivated, this));
getHSVEditBoxV()->subscribeEvent(
Editbox::EventDeactivated,
Event::Subscriber(&ColourPickerControls::handleEditboxDeactivated, this));
getLabEditBoxL()->subscribeEvent(
Editbox::EventDeactivated,
Event::Subscriber(&ColourPickerControls::handleEditboxDeactivated, this));
getLabEditBoxA()->subscribeEvent(
Editbox::EventDeactivated,
Event::Subscriber(&ColourPickerControls::handleEditboxDeactivated, this));
getLabEditBoxB()->subscribeEvent(
Editbox::EventDeactivated,
Event::Subscriber(&ColourPickerControls::handleEditboxDeactivated, this));
getAlphaEditBox()->subscribeEvent(
Editbox::EventDeactivated,
Event::Subscriber(&ColourPickerControls::handleEditboxDeactivated, this));
getHSVRadioButtonH()->subscribeEvent(
RadioButton::EventSelectStateChanged,
Event::Subscriber(&ColourPickerControls::handleRadioButtonModeSelection, this));
getHSVRadioButtonS()->subscribeEvent(
RadioButton::EventSelectStateChanged,
Event::Subscriber(&ColourPickerControls::handleRadioButtonModeSelection, this));
getHSVRadioButtonV()->subscribeEvent(
RadioButton::EventSelectStateChanged,
Event::Subscriber(&ColourPickerControls::handleRadioButtonModeSelection, this));
getLabRadioButtonL()->subscribeEvent(
RadioButton::EventSelectStateChanged,
Event::Subscriber(&ColourPickerControls::handleRadioButtonModeSelection, this));
getLabRadioButtonA()->subscribeEvent(
RadioButton::EventSelectStateChanged,
Event::Subscriber(&ColourPickerControls::handleRadioButtonModeSelection, this));
getLabRadioButtonB()->subscribeEvent(
RadioButton::EventSelectStateChanged,
Event::Subscriber(&ColourPickerControls::handleRadioButtonModeSelection, this));
getHexadecimalEditbox()->subscribeEvent(
Editbox::EventTextChanged,
Event::Subscriber(&ColourPickerControls::handleHexadecimalEditboxTextChanged, this));
getColourEditBoxR()->subscribeEvent(
Editbox::EventTextChanged,
Event::Subscriber(&ColourPickerControls::handleRGBEditboxTextChanged, this));
getColourEditBoxG()->subscribeEvent(
Editbox::EventTextChanged,
Event::Subscriber(&ColourPickerControls::handleRGBEditboxTextChanged, this));
getColourEditBoxB()->subscribeEvent(
Editbox::EventTextChanged,
Event::Subscriber(&ColourPickerControls::handleRGBEditboxTextChanged, this));
getLabEditBoxL()->subscribeEvent(
Editbox::EventTextChanged,
Event::Subscriber(&ColourPickerControls::handleLABEditboxTextChanged, this));
getLabEditBoxA()->subscribeEvent(
Editbox::EventTextChanged,
Event::Subscriber(&ColourPickerControls::handleLABEditboxTextChanged, this));
getLabEditBoxB()->subscribeEvent(
Editbox::EventTextChanged,
Event::Subscriber(&ColourPickerControls::handleLABEditboxTextChanged, this));
getHSVEditBoxH()->subscribeEvent(
Editbox::EventTextChanged,
Event::Subscriber(&ColourPickerControls::handleHSVEditboxTextChanged, this));
getHSVEditBoxS()->subscribeEvent(
Editbox::EventTextChanged,
Event::Subscriber(&ColourPickerControls::handleHSVEditboxTextChanged, this));
getHSVEditBoxV()->subscribeEvent(
Editbox::EventTextChanged,
Event::Subscriber(&ColourPickerControls::handleHSVEditboxTextChanged, this));
getAlphaEditBox()->subscribeEvent(
Editbox::EventTextChanged,
Event::Subscriber(&ColourPickerControls::handleAlphaEditboxTextChanged, this));
getColourPickerImageSlider()->subscribeEvent(
Slider::EventValueChanged,
Event::Subscriber(&ColourPickerControls::handleColourPickerSliderValueChanged, this));
getColourPickerAlphaSlider()->subscribeEvent(
Slider::EventValueChanged,
Event::Subscriber(&ColourPickerControls::handleAlphaSliderValueChanged, this));
getColourPickerStaticImage()->subscribeEvent(
Window::EventCursorLeavesSurface,
Event::Subscriber(&ColourPickerControls::handleColourPickerStaticImagePointerLeaves, this));
getColourPickerStaticImage()->subscribeEvent(
Window::EventCursorActivate,
Event::Subscriber(&ColourPickerControls::handleColourPickerStaticImagePointerActivate, this));
getColourPickerStaticImage()->subscribeEvent(
Window::EventCursorPressHold,
Event::Subscriber(&ColourPickerControls::handleColourPickerStaticImagePointerPressHold, this));
getColourPickerStaticImage()->subscribeEvent(
Window::EventCursorMove,
Event::Subscriber(&ColourPickerControls::handleColourPickerStaticImagePointerMove, this));
initColourPicker();
Window::initialiseComponents();
}
void ColourPickerControls::destroy()
{
deinitColourPickerControlsTexture();
if (d_colourPickerIndicator)
{
WindowManager::getSingleton().destroyWindow(d_colourPickerIndicator);
d_colourPickerIndicator = nullptr;
}
delete[] d_colourPickingTexture;
d_colourPickingTexture = nullptr;
delete &d_regexMatcher;
Window::destroy();
}
//----------------------------------------------------------------------------//
void ColourPickerControls::setPreviousColour(const Colour& previousColour)
{
d_previouslySelectedColour = previousColour;
}
//----------------------------------------------------------------------------//
void ColourPickerControls::setColours(const Colour& newColour)
{
d_selectedColourRGB = RGB_Colour(newColour);
d_selectedColourLAB = Lab_Colour(d_selectedColourRGB);
d_selectedColourHSV = HSV_Colour(d_selectedColourRGB);
d_selectedColour = newColour;
}
//----------------------------------------------------------------------------//
void ColourPickerControls::setColours(const Lab_Colour& newColourLAB)
{
d_selectedColourLAB = newColourLAB;
d_selectedColourRGB = RGB_Colour(newColourLAB);
d_selectedColourHSV = HSV_Colour(d_selectedColourRGB);
float alpha = d_selectedColour.getAlpha();
d_selectedColour = ColourPickerConversions::toCeguiColour(d_selectedColourRGB);
d_selectedColour.setAlpha(alpha);
}
//----------------------------------------------------------------------------//
void ColourPickerControls::setColours(const RGB_Colour& newColourRGB)
{
d_selectedColourLAB = Lab_Colour(newColourRGB);
d_selectedColourRGB = newColourRGB;
d_selectedColourHSV = HSV_Colour(newColourRGB);
float alpha = d_selectedColour.getAlpha();
d_selectedColour = ColourPickerConversions::toCeguiColour(d_selectedColourRGB);
d_selectedColour.setAlpha(alpha);
}
//----------------------------------------------------------------------------//
void ColourPickerControls::setColours(const HSV_Colour& newColourHSV)
{
d_selectedColourRGB = RGB_Colour(newColourHSV);
d_selectedColourLAB = Lab_Colour(d_selectedColourRGB);
d_selectedColourHSV = newColourHSV;
float alpha = d_selectedColour.getAlpha();
d_selectedColour = ColourPickerConversions::toCeguiColour(d_selectedColourRGB);
d_selectedColour.setAlpha(alpha);
}
//----------------------------------------------------------------------------//
void ColourPickerControls::setCallingColourPicker(ColourPicker* colourPicker)
{
d_callingColourPicker = colourPicker;
}
//----------------------------------------------------------------------------//
PushButton* ColourPickerControls::getCancelButton()
{
return static_cast<PushButton*>(getChild(CancelButtonName));
}
//----------------------------------------------------------------------------//
PushButton* ColourPickerControls::getAcceptButton()
{
return static_cast<PushButton*>(getChild(AcceptButtonName));
}
//----------------------------------------------------------------------------//
Window* ColourPickerControls::getHexadecimalDescription()
{
return getChild(HexaDecimalDescriptionName);
}
//----------------------------------------------------------------------------//
Editbox* ColourPickerControls::getHexadecimalEditbox()
{
return static_cast<Editbox*>(getChild(HexaDecimalEditBoxName));
}
//----------------------------------------------------------------------------//
Titlebar* ColourPickerControls::getTitleBar()
{
return static_cast<Titlebar*>(getChild(TitleBarName));
}
//----------------------------------------------------------------------------//
Window* ColourPickerControls::getColourPickerStaticImage()
{
return getChild(ColourPickerStaticImageName);
}
//----------------------------------------------------------------------------//
Slider* ColourPickerControls::getColourPickerImageSlider()
{
return static_cast<Slider*>(getChild(ColourPickerImageSliderName));
}
//----------------------------------------------------------------------------//
Slider* ColourPickerControls::getColourPickerAlphaSlider()
{
return static_cast<Slider*>(getChild(ColourPickerAlphaSliderName));
}
//----------------------------------------------------------------------------//
Window* ColourPickerControls::getNewColourDescription()
{
return getChild(NewColourDescriptionName);
}
//----------------------------------------------------------------------------//
Window* ColourPickerControls::getOldColourDescription()
{
return getChild(OldColourDescriptionName);
}
//----------------------------------------------------------------------------//
Window* ColourPickerControls::getNewColourRect()
{
return getChild(NewColourRectName);
}
//----------------------------------------------------------------------------//
Window* ColourPickerControls::getOldColourRect()
{
return getChild(OldColourRectName);
}
//----------------------------------------------------------------------------//
Window* ColourPickerControls::getColourEditBoxRDescription()
{
return getChild(ColourEditBoxRDescriptionName);
}
//----------------------------------------------------------------------------//
Window* ColourPickerControls::getColourEditBoxGDescription()
{
return getChild(ColourEditBoxGDescriptionName);
}
//----------------------------------------------------------------------------//
Window* ColourPickerControls::getColourEditBoxBDescription()
{
return getChild(ColourEditBoxBDescriptionName);
}
//----------------------------------------------------------------------------//
Editbox* ColourPickerControls::getColourEditBoxR()
{
return static_cast<Editbox*>(getChild(ColourEditBoxRName));
}
//----------------------------------------------------------------------------//
Editbox* ColourPickerControls::getColourEditBoxG()
{
return static_cast<Editbox*>(getChild(ColourEditBoxGName));
}
//----------------------------------------------------------------------------//
Editbox* ColourPickerControls::getColourEditBoxB()
{
return static_cast<Editbox*>(getChild(ColourEditBoxBName));
}
//----------------------------------------------------------------------------//
RadioButton* ColourPickerControls::getHSVRadioButtonH()
{
return static_cast<RadioButton*>(getChild(HSVRadioButtonHName));
}
//----------------------------------------------------------------------------//
RadioButton* ColourPickerControls::getHSVRadioButtonS()
{
return static_cast<RadioButton*>(getChild(HSVRadioButtonSName));
}
//----------------------------------------------------------------------------//
RadioButton* ColourPickerControls::getHSVRadioButtonV()
{
return static_cast<RadioButton*>(getChild(HSVRadioButtonVName));
}
//----------------------------------------------------------------------------//
Editbox* ColourPickerControls::getHSVEditBoxH()
{
return static_cast<Editbox*>(getChild(HSVEditBoxHName));
}
//----------------------------------------------------------------------------//
Editbox* ColourPickerControls::getHSVEditBoxS()
{
return static_cast<Editbox*>(getChild(HSVEditBoxSName));
}
//----------------------------------------------------------------------------//
Editbox* ColourPickerControls::getHSVEditBoxV()
{
return static_cast<Editbox*>(getChild(HSVEditBoxVName));
}
//----------------------------------------------------------------------------//
RadioButton* ColourPickerControls::getLabRadioButtonL()
{
return static_cast<RadioButton*>(getChild(LabRadioButtonLName));
}
//----------------------------------------------------------------------------//
RadioButton* ColourPickerControls::getLabRadioButtonA()
{
return static_cast<RadioButton*>(getChild(LabRadioButtonAName));
}
//----------------------------------------------------------------------------//
RadioButton* ColourPickerControls::getLabRadioButtonB()
{
return static_cast<RadioButton*>(getChild(LabRadioButtonBName));
}
//----------------------------------------------------------------------------//
Editbox* ColourPickerControls::getLabEditBoxL()
{
return static_cast<Editbox*>(getChild(LabEditBoxLName));
}
//----------------------------------------------------------------------------//
Editbox* ColourPickerControls::getLabEditBoxA()
{
return static_cast<Editbox*>(getChild(LabEditBoxAName));
}
//----------------------------------------------------------------------------//
Editbox* ColourPickerControls::getLabEditBoxB()
{
return static_cast<Editbox*>(getChild(LabEditBoxBName));
}
//----------------------------------------------------------------------------//
Editbox* ColourPickerControls::getAlphaEditBox()
{
return static_cast<Editbox*>(getChild(AlphaEditBoxName));
}
//----------------------------------------------------------------------------//
Window* ColourPickerControls::getColourPickerCursorStaticImage()
{
return d_colourPickerIndicator;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleCancelButtonClicked(const EventArgs&)
{
WindowEventArgs args(this);
onCancelButtonClicked(args);
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleEditboxDeactivated(const EventArgs& args)
{
Editbox* editbox = static_cast<Editbox*>(
static_cast<const WindowEventArgs&>(args).window);
editbox->setSelection(0, 0);
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleHexadecimalEditboxTextChanged(const EventArgs&)
{
if (d_ignoreEvents == true)
return true;
String hexaText = getHexadecimalEditbox()->getText();
if (hexaText.length() == 8)
{
Colour hexaColour = PropertyHelper<Colour>::fromString(hexaText);
setColours(hexaColour);
refreshAllElements();
}
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleRGBEditboxTextChanged(const EventArgs&)
{
if (d_ignoreEvents == true)
return true;
int colourR = PropertyHelper<std::int32_t>::fromString(
getColourEditBoxR()->getText());
int colourG = PropertyHelper<std::int32_t>::fromString(
getColourEditBoxG()->getText());
int colourB = PropertyHelper<std::int32_t>::fromString(
getColourEditBoxB()->getText());
RGB_Colour newColour(colourR, colourG, colourB);
setColours(newColour);
refreshAllElements();
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleLABEditboxTextChanged(const EventArgs&)
{
if (d_ignoreEvents == true)
return true;
static const String labRegEx = "[-+]?[0-9]*\\.?[0-9]+";
d_regexMatcher.setRegexString(labRegEx);
String LabLString = getLabEditBoxL()->getText();
String LabAString = getLabEditBoxA()->getText();
String LabBString = getLabEditBoxB()->getText();
bool matchingRegEx = true;
matchingRegEx &= d_regexMatcher.getMatchStateOfString(LabLString) == RegexMatchState::Valid;
matchingRegEx &= d_regexMatcher.getMatchStateOfString(LabAString) == RegexMatchState::Valid;
matchingRegEx &= d_regexMatcher.getMatchStateOfString(LabBString) == RegexMatchState::Valid;
if (!matchingRegEx)
return true;
float LabColourL = PropertyHelper<float>::fromString(LabLString);
float LabColourA = PropertyHelper<float>::fromString(LabAString);
float LabColourB = PropertyHelper<float>::fromString(LabBString);
LabColourL = std::min(std::max(LabColourL, LAB_L_MIN), LAB_L_MAX);
LabColourA = std::min(std::max(LabColourA, LAB_A_MIN), LAB_A_MAX);
LabColourB = std::min(std::max(LabColourB, LAB_B_MIN), LAB_B_MAX);
Lab_Colour newColour(LabColourL, LabColourA, LabColourB);
setColours(newColour);
refreshAllElements();
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleHSVEditboxTextChanged(const EventArgs&)
{
if (d_ignoreEvents == true)
return true;
static const String labRegEx = "[-+]?[0-9]*\\.?[0-9]+";
d_regexMatcher.setRegexString(labRegEx);
String HString = getHSVEditBoxH()->getText();
String SString = getHSVEditBoxS()->getText();
String VString = getHSVEditBoxV()->getText();
bool matchingRegEx = true;
matchingRegEx &= d_regexMatcher.getMatchStateOfString(HString) == RegexMatchState::Valid;
matchingRegEx &= d_regexMatcher.getMatchStateOfString(SString) == RegexMatchState::Valid;
matchingRegEx &= d_regexMatcher.getMatchStateOfString(VString) == RegexMatchState::Valid;
if (!matchingRegEx)
return true;
float Hue = PropertyHelper<float>::fromString(HString);
float Saturation = PropertyHelper<float>::fromString(SString);
float Value = PropertyHelper<float>::fromString(VString);
Hue = std::min(std::max(Hue, 0.0f), 1.0f);
Saturation = std::min(std::max(Saturation, 0.0f), 1.0f);
Value = std::min(std::max(Value, 0.0f), 1.0f);
HSV_Colour newColour(Hue, Saturation, Value);
setColours(newColour);
refreshAllElements();
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleAlphaEditboxTextChanged(const EventArgs&)
{
if (d_ignoreEvents == true)
return true;
static const String labRegEx = "[-+]?[0-9]*\\.?[0-9]+";
d_regexMatcher.setRegexString(labRegEx);
String ValueString = getAlphaEditBox()->getText();
bool matchingRegEx = d_regexMatcher.getMatchStateOfString(ValueString) == RegexMatchState::Valid;
if (!matchingRegEx)
return true;
float value = PropertyHelper<float>::fromString(ValueString);
value = std::max(std::min(value, 1.0f), 0.0f);
setColourAlpha(value);
refreshAllElements();
return true;
}
//----------------------------------------------------------------------------//
void ColourPickerControls::setColourAlpha(float alphaValue)
{
d_selectedColour.setAlpha(alphaValue);
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleAcceptButtonClicked(const EventArgs&)
{
WindowEventArgs args(this);
onAcceptButtonClicked(args);
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleRadioButtonModeSelection(const EventArgs& args)
{
RadioButton* radioButton = static_cast<RadioButton*>(
static_cast<const WindowEventArgs&>(args).window);
if (getLabRadioButtonL() == radioButton)
d_sliderMode = LAB_L;
else if (getLabRadioButtonA() == radioButton)
d_sliderMode = LAB_A;
else if (getLabRadioButtonB() == radioButton)
d_sliderMode = SliderMode::LAB_B;
else if (getHSVRadioButtonH() == radioButton)
d_sliderMode = SliderMode::HSV_H;
else if (getHSVRadioButtonS() == radioButton)
d_sliderMode = SliderMode::HSV_S;
else if (getHSVRadioButtonV() == radioButton)
d_sliderMode = SliderMode::HSV_V;
refreshColourPickerIndicatorPosition();
refreshColourSliderPosition();
refreshColourPickerControlsTextures();
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleColourPickerSliderValueChanged(
const EventArgs& args)
{
if (d_ignoreEvents == true)
return true;
Slider* imageSlider = static_cast<Slider*>(
static_cast<const WindowEventArgs&>(args).window);
const float sliderValue = static_cast<float>(imageSlider->getCurrentValue());
Lab_Colour colourLAB = d_selectedColourLAB;
HSV_Colour colourHSV = d_selectedColourHSV;
switch (d_sliderMode)
{
case LAB_L:
colourLAB.L = LAB_L_MIN + LAB_L_DIFF * sliderValue;
setColours(colourLAB);
break;
case LAB_A:
colourLAB.a = LAB_A_MIN + LAB_A_DIFF * sliderValue;
setColours(colourLAB);
break;
case SliderMode::LAB_B:
colourLAB.b = LAB_B_MIN + LAB_B_DIFF * sliderValue;
setColours(colourLAB);
break;
case SliderMode::HSV_H:
colourHSV.H = sliderValue;
setColours(colourHSV);
break;
case SliderMode::HSV_S:
colourHSV.S = sliderValue;
setColours(colourHSV);
break;
case SliderMode::HSV_V:
colourHSV.V = sliderValue;
setColours(colourHSV);
break;
default:
break;
}
onColourSliderChanged();
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleAlphaSliderValueChanged(const EventArgs& args)
{
if (d_ignoreEvents == true)
return true;
Slider* imageSlider = static_cast<Slider*>(
static_cast<const WindowEventArgs&>(args).window);
const float sliderValue = 1.0f - static_cast<float>(imageSlider->getCurrentValue());
setColourAlpha(sliderValue);
refreshAlpha();
refreshColourRects();
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleColourPickerStaticImagePointerActivate(
const EventArgs& args)
{
const CursorInputEventArgs& cursor_args = static_cast<const CursorInputEventArgs&>(args);
if (cursor_args.source == CursorInputSource::Left)
d_draggingColourPickerIndicator = false;
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleColourPickerStaticImagePointerPressHold(
const EventArgs& args)
{
const CursorInputEventArgs& cursor_args = static_cast<const CursorInputEventArgs&>(args);
if (cursor_args.source == CursorInputSource::Left)
{
d_draggingColourPickerIndicator = true;
refreshColourPickerIndicatorPosition(cursor_args);
}
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleColourPickerStaticImagePointerMove(
const EventArgs& args)
{
if (d_colourPickerIndicator && d_draggingColourPickerIndicator)
refreshColourPickerIndicatorPosition(
static_cast<const CursorInputEventArgs&>(args));
return true;
}
//----------------------------------------------------------------------------//
bool ColourPickerControls::handleColourPickerStaticImagePointerLeaves(
const EventArgs&)
{
if (d_colourPickerIndicator)
d_draggingColourPickerIndicator = false;
return true;
}
//----------------------------------------------------------------------------//
void ColourPickerControls::onCancelButtonClicked(WindowEventArgs& e)
{
if (this->getParent() != nullptr)
this->getParent()->removeChild(this);
fireEvent(EventClosed, e, EventNamespace);
}
//----------------------------------------------------------------------------//
void ColourPickerControls::onAcceptButtonClicked(WindowEventArgs& e)
{
d_callingColourPicker->setColour(d_selectedColour);
if (this->getParent() != nullptr)
this->getParent()->removeChild(this);
fireEvent(EventColourAccepted, e, EventNamespace);
fireEvent(EventClosed, e, EventNamespace);
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshColourPickingImage()
{
if (d_sliderMode &
(LAB_L | LAB_A | SliderMode::LAB_B))
{
for (int y = 0; y < d_colourPickerPickingImageHeight; ++y)
{
for (int x = 0; x < d_colourPickerPickingImageWidth; ++x)
{
int i = d_colourPickerControlsTextureSize * y + x;
Lab_Colour colour =
getColourPickingPositionColourLAB(static_cast<float>(x),
static_cast<float>(y));
d_colourPickingTexture[i] = RGB_Colour(colour);
}
}
}
else if (d_sliderMode &
(SliderMode::HSV_H | SliderMode::HSV_S | SliderMode::HSV_V))
{
for (int y = 0; y < d_colourPickerPickingImageHeight; ++y)
{
for (int x = 0; x < d_colourPickerPickingImageWidth; ++x)
{
int i = d_colourPickerControlsTextureSize * y + x;
HSV_Colour colour =
getColourPickingPositionColourHSV(static_cast<float>(x),
static_cast<float>(y));
d_colourPickingTexture[i] = RGB_Colour(colour);
}
}
}
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshColourSliderImage()
{
if (d_sliderMode &
(LAB_L | LAB_A | SliderMode::LAB_B))
{
for (int y = 0; y < d_colourPickerPickingImageHeight; ++y)
{
for (int x = 0; x < d_colourPickerColourSliderImageWidth; ++x)
{
int i = d_colourPickerControlsTextureSize * y +
(x + d_colourPickerPickingImageWidth + 2);
Lab_Colour colour = getColourSliderPositionColourLAB(
y / static_cast<float>(d_colourPickerPickingImageHeight - 1));
d_colourPickingTexture[i] = RGB_Colour(colour);
}
}
}
else if (d_sliderMode &
(SliderMode::HSV_H | SliderMode::HSV_S | SliderMode::HSV_V))
{
for (int y = 0; y < d_colourPickerPickingImageHeight; ++y)
{
for (int x = 0; x < d_colourPickerColourSliderImageWidth; ++x)
{
int i = d_colourPickerControlsTextureSize * y +
(x + d_colourPickerPickingImageWidth + 2);
HSV_Colour colour = getColourSliderPositionColourHSV(
y / static_cast<float>(d_colourPickerPickingImageHeight - 1));
d_colourPickingTexture[i] = RGB_Colour(colour);
}
}
}
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshAlphaSliderImage()
{
for (int y = 0; y < d_colourPickerAlphaSliderImageHeight; ++y)
{
for (int x = 0; x < d_colourPickerAlphaSliderImageWidth; ++x)
{
int i = x + d_colourPickerControlsTextureSize *
(y + d_colourPickerImageOffset + d_colourPickerPickingImageHeight);
RGB_Colour curColour = getAlphaSliderPositionColour(x, y);
d_colourPickingTexture[i] = curColour;
}
}
}
//----------------------------------------------------------------------------//
RGB_Colour ColourPickerControls::getAlphaSliderPositionColour(int x, int y)
{
static const RGB_Colour background1(255, 255, 255);
static const RGB_Colour background2(122, 122, 122);
float xRel = x / static_cast<float>(d_colourPickerAlphaSliderImageWidth - 1);
RGB_Colour final;
bool isBackground1;
if ((x % 30) >= 15)
isBackground1 = false;
else
isBackground1 = true;
if ((y % 30) >= 15)
isBackground1 = !isBackground1;
if (isBackground1)
final = d_selectedColourRGB * (1.0f - xRel) + background1 * xRel;
else
final = d_selectedColourRGB * (1.0f - xRel) + background2 * xRel;
return final;
}
//----------------------------------------------------------------------------//
void ColourPickerControls::initColourPicker()
{
initColourPickerControlsImageSet();
d_sliderMode = LAB_L;
getLabRadioButtonL()->setSelected(true);
d_colourPickerIndicator = WindowManager::getSingleton().createWindow(
getProperty("ColourPickerCursorStyle"),
getName() + ColourPickerCursorName);
d_colourPickerIndicator->setProperty(
"BackgroundEnabled",
PropertyHelper<bool>::toString(false));
d_colourPickerIndicator->setProperty(
"FrameEnabled",
PropertyHelper<bool>::toString(false));
d_colourPickerIndicator->setProperty(
"Image",
getProperty("ColourPickerCursorImage"));
d_colourPickerIndicator->setProperty(
"ImageColours",
PropertyHelper<ColourRect>::toString(
ColourRect(Colour(0.0f, 0.0f, 0.0f))));
d_colourPickerIndicator->setWidth(UDim(0.05f, 0));
d_colourPickerIndicator->setHeight(UDim(0.05f, 0));
d_colourPickerIndicator->setCursorPassThroughEnabled(true);
d_colourPickerIndicator->setClippedByParent(false);
getColourPickerImageSlider()->getThumb()->setHotTracked(false);
getColourPickerStaticImage()->addChild(d_colourPickerIndicator);
}
//----------------------------------------------------------------------------//
void ColourPickerControls::positionColourPickerIndicatorRelative(float x, float y)
{
if (d_colourPickerIndicator)
{
d_colourPickerIndicator->setXPosition(
UDim(d_colourPickerIndicator->getWidth().d_scale * -0.5f + x, 0.0f));
d_colourPickerIndicator->setYPosition(
UDim(d_colourPickerIndicator->getHeight().d_scale * -0.5f + y, 0.0f));
}
}
//----------------------------------------------------------------------------//
void ColourPickerControls::positionColourPickerIndicatorAbsolute(float x, float y)
{
if (d_colourPickerIndicator)
{
d_colourPickerIndicator->setXPosition(
UDim(d_colourPickerIndicator->getWidth().d_scale * -0.5f, x));
d_colourPickerIndicator->setYPosition(
UDim(d_colourPickerIndicator->getHeight().d_scale * -0.5f, y));
}
}
//----------------------------------------------------------------------------//
RGB_Colour ColourPickerControls::getSelectedColourRGB()
{
return d_selectedColourRGB;
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshColourPickerIndicatorPosition()
{
const glm::vec2 pos = getColourPickingColourPosition();
positionColourPickerIndicatorRelative(pos.x, pos.y);
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshColourPickerIndicatorPosition(
const CursorInputEventArgs& pointerEventArgs)
{
const glm::vec2 localPos = CoordConverter::screenToWindow(
*pointerEventArgs.window, pointerEventArgs.position);
positionColourPickerIndicatorAbsolute(localPos.x, localPos.y);
if (d_sliderMode &
(LAB_L | LAB_A | SliderMode::LAB_B))
{
Lab_Colour col = getColourPickingPositionColourLAB(localPos.x, localPos.y);
setColours(col);
}
else if (d_sliderMode &
(SliderMode::HSV_H | SliderMode::HSV_S | SliderMode::HSV_V))
{
HSV_Colour col = getColourPickingPositionColourHSV(localPos.x, localPos.y);
setColours(col);
}
onColourIndicatorPositionChanged();
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshColourSliderPosition()
{
String editboxText;
switch (d_sliderMode)
{
case LAB_L:
editboxText = getLabEditBoxL()->getText();
break;
case LAB_A:
editboxText = getLabEditBoxA()->getText();
break;
case SliderMode::LAB_B:
editboxText = getLabEditBoxB()->getText();
break;
case SliderMode::HSV_H:
editboxText = getHSVEditBoxH()->getText();
break;
case SliderMode::HSV_S:
editboxText = getHSVEditBoxS()->getText();
break;
case SliderMode::HSV_V:
editboxText = getHSVEditBoxV()->getText();
break;
default:
Logger::getSingleton().logEvent(
"[ColourPicker] Unknown slider mode - action not processed");
break;
}
float value = PropertyHelper<float>::fromString(editboxText);
float sliderValue = 0.0f;
switch (d_sliderMode)
{
case LAB_L:
sliderValue = 1.0f - (LAB_L_MAX - value) / LAB_L_DIFF;
break;
case LAB_A:
sliderValue = 1.0f - (LAB_A_MAX - value) / LAB_A_DIFF;
break;
case SliderMode::LAB_B:
sliderValue = 1.0f - (LAB_B_MAX - value) / LAB_B_DIFF;
break;
case SliderMode::HSV_H:
sliderValue = value;
break;
case SliderMode::HSV_S:
sliderValue = value;
break;
case SliderMode::HSV_V:
sliderValue = value;
break;
default:
Logger::getSingleton().logEvent(
"[ColourPicker] Unknown slider mode - action not processed");
break;
}
d_ignoreEvents = true;
getColourPickerImageSlider()->setCurrentValue(sliderValue);
d_ignoreEvents = false;
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshAlpha()
{
d_ignoreEvents = true;
getColourPickerAlphaSlider()->setCurrentValue(
1.0f - d_selectedColour.getAlpha());
std::stringstream floatStringStream;
floatStringStream.precision(4);
floatStringStream.setf(std::ios::fixed, std::ios::floatfield);
floatStringStream << d_selectedColour.getAlpha();
getAlphaEditBox()->setText(floatStringStream.str().c_str());
d_ignoreEvents = false;
}
//----------------------------------------------------------------------------//
void ColourPickerControls::onColourSliderChanged()
{
refreshEditboxesAndColourRects();
refreshColourPickerIndicatorPosition();
refreshColourPickerControlsTextures();
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshEditboxesAndColourRects()
{
refreshColourRects();
d_ignoreEvents = true;
getColourEditBoxR()->setText(
PropertyHelper<std::int32_t>::toString(d_selectedColourRGB.r));
getColourEditBoxG()->setText(
PropertyHelper<std::int32_t>::toString(d_selectedColourRGB.g));
getColourEditBoxB()->setText(
PropertyHelper<std::int32_t>::toString(d_selectedColourRGB.b));
std::stringstream floatStringStream;
floatStringStream.precision(3);
floatStringStream.setf(std::ios::fixed, std::ios::floatfield);
floatStringStream << d_selectedColourLAB.L;
getLabEditBoxL()->setText(floatStringStream.str().c_str());
floatStringStream.str("");
floatStringStream << d_selectedColourLAB.a;
getLabEditBoxA()->setText(floatStringStream.str().c_str());
floatStringStream.str("");
floatStringStream << d_selectedColourLAB.b;
getLabEditBoxB()->setText(floatStringStream.str().c_str());
floatStringStream.str("");
floatStringStream.precision(5);
floatStringStream << d_selectedColourHSV.H;
getHSVEditBoxH()->setText(floatStringStream.str().c_str());
floatStringStream.str("");
floatStringStream << d_selectedColourHSV.S;
getHSVEditBoxS()->setText(floatStringStream.str().c_str());
floatStringStream.str("");
floatStringStream << d_selectedColourHSV.V;
getHSVEditBoxV()->setText(floatStringStream.str().c_str());
floatStringStream.str("");
floatStringStream.precision(4);
floatStringStream << d_selectedColour.getAlpha();
getAlphaEditBox()->setText(floatStringStream.str().c_str());
floatStringStream.str("");
d_ignoreEvents = false;
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshAllElements()
{
refreshEditboxesAndColourRects();
refreshColourSliderPosition();
refreshColourPickerIndicatorPosition();
refreshAlpha();
refreshColourPickerControlsTextures();
}
//----------------------------------------------------------------------------//
void ColourPickerControls::onColourIndicatorPositionChanged()
{
refreshEditboxesAndColourRects();
refreshAlphaSliderImage();
refreshOnlyColourSliderImage();
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshOnlyColourSliderImage()
{
refreshColourSliderImage();
reloadColourPickerControlsTexture();
}
//----------------------------------------------------------------------------//
void ColourPickerControls::refreshColourRects()
{
d_ignoreEvents = true;
Colour newColourNoAlpha(d_selectedColour.getRed(),
d_selectedColour.getGreen(),
d_selectedColour.getBlue());
String newColourRectString =
PropertyHelper<ColourRect>::toString(ColourRect(newColourNoAlpha));
Colour previousColourNoAlpha(d_previouslySelectedColour.getRed(),
d_previouslySelectedColour.getGreen(),
d_previouslySelectedColour.getBlue());
String previousColourRectString =
PropertyHelper<ColourRect>::toString(ColourRect(previousColourNoAlpha));
getNewColourRect()->setProperty(
ColourRectPropertyName,
newColourRectString);
getOldColourRect()->setProperty(
ColourRectPropertyName,
previousColourRectString);
String colourString = PropertyHelper<Colour>::toString(d_selectedColour);
getHexadecimalEditbox()->setText(colourString);
d_ignoreEvents = false;
}
//----------------------------------------------------------------------------//
}
|
// Copyright 2020 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/ast/call_statement.h"
#include "src/ast/variable_decl_statement.h"
#include "src/writer/hlsl/test_helper.h"
namespace tint {
namespace writer {
namespace hlsl {
namespace {
using HlslGeneratorImplTest_Binary = TestHelper;
struct BinaryData {
const char* result;
ast::BinaryOp op;
};
inline std::ostream& operator<<(std::ostream& out, BinaryData data) {
out << data.op;
return out;
}
using HlslBinaryTest = TestParamHelper<BinaryData>;
TEST_P(HlslBinaryTest, Emit_f32) {
auto params = GetParam();
// Skip ops that are illegal for this type
if (params.op == ast::BinaryOp::kAnd || params.op == ast::BinaryOp::kOr ||
params.op == ast::BinaryOp::kXor ||
params.op == ast::BinaryOp::kShiftLeft ||
params.op == ast::BinaryOp::kShiftRight) {
return;
}
Global("left", ty.f32(), ast::StorageClass::kPrivate);
Global("right", ty.f32(), ast::StorageClass::kPrivate);
auto* left = Expr("left");
auto* right = Expr("right");
auto* expr = create<ast::BinaryExpression>(params.op, left, right);
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), params.result);
}
TEST_P(HlslBinaryTest, Emit_u32) {
auto params = GetParam();
Global("left", ty.u32(), ast::StorageClass::kPrivate);
Global("right", ty.u32(), ast::StorageClass::kPrivate);
auto* left = Expr("left");
auto* right = Expr("right");
auto* expr = create<ast::BinaryExpression>(params.op, left, right);
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), params.result);
}
TEST_P(HlslBinaryTest, Emit_i32) {
auto params = GetParam();
// Skip ops that are illegal for this type
if (params.op == ast::BinaryOp::kShiftLeft ||
params.op == ast::BinaryOp::kShiftRight) {
return;
}
Global("left", ty.i32(), ast::StorageClass::kPrivate);
Global("right", ty.i32(), ast::StorageClass::kPrivate);
auto* left = Expr("left");
auto* right = Expr("right");
auto* expr = create<ast::BinaryExpression>(params.op, left, right);
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), params.result);
}
INSTANTIATE_TEST_SUITE_P(
HlslGeneratorImplTest,
HlslBinaryTest,
testing::Values(
BinaryData{"(left & right)", ast::BinaryOp::kAnd},
BinaryData{"(left | right)", ast::BinaryOp::kOr},
BinaryData{"(left ^ right)", ast::BinaryOp::kXor},
BinaryData{"(left == right)", ast::BinaryOp::kEqual},
BinaryData{"(left != right)", ast::BinaryOp::kNotEqual},
BinaryData{"(left < right)", ast::BinaryOp::kLessThan},
BinaryData{"(left > right)", ast::BinaryOp::kGreaterThan},
BinaryData{"(left <= right)", ast::BinaryOp::kLessThanEqual},
BinaryData{"(left >= right)", ast::BinaryOp::kGreaterThanEqual},
BinaryData{"(left << right)", ast::BinaryOp::kShiftLeft},
BinaryData{"(left >> right)", ast::BinaryOp::kShiftRight},
BinaryData{"(left + right)", ast::BinaryOp::kAdd},
BinaryData{"(left - right)", ast::BinaryOp::kSubtract},
BinaryData{"(left * right)", ast::BinaryOp::kMultiply},
BinaryData{"(left / right)", ast::BinaryOp::kDivide},
BinaryData{"(left % right)", ast::BinaryOp::kModulo}));
TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorScalar) {
auto* lhs = vec3<f32>(1.f, 1.f, 1.f);
auto* rhs = Expr(1.f);
auto* expr =
create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(),
"(float3(1.0f, 1.0f, 1.0f) * "
"1.0f)");
}
TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarVector) {
auto* lhs = Expr(1.f);
auto* rhs = vec3<f32>(1.f, 1.f, 1.f);
auto* expr =
create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(),
"(1.0f * float3(1.0f, 1.0f, "
"1.0f))");
}
TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixScalar) {
Global("mat", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
auto* lhs = Expr("mat");
auto* rhs = Expr(1.f);
auto* expr =
create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), "(mat * 1.0f)");
}
TEST_F(HlslGeneratorImplTest_Binary, Multiply_ScalarMatrix) {
Global("mat", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
auto* lhs = Expr(1.f);
auto* rhs = Expr("mat");
auto* expr =
create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), "(1.0f * mat)");
}
TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixVector) {
Global("mat", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
auto* lhs = Expr("mat");
auto* rhs = vec3<f32>(1.f, 1.f, 1.f);
auto* expr =
create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), "mul(float3(1.0f, 1.0f, 1.0f), mat)");
}
TEST_F(HlslGeneratorImplTest_Binary, Multiply_VectorMatrix) {
Global("mat", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
auto* lhs = vec3<f32>(1.f, 1.f, 1.f);
auto* rhs = Expr("mat");
auto* expr =
create<ast::BinaryExpression>(ast::BinaryOp::kMultiply, lhs, rhs);
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), "mul(mat, float3(1.0f, 1.0f, 1.0f))");
}
TEST_F(HlslGeneratorImplTest_Binary, Multiply_MatrixMatrix) {
Global("lhs", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
Global("rhs", ty.mat3x3<f32>(), ast::StorageClass::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kMultiply,
Expr("lhs"), Expr("rhs"));
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
EXPECT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), "mul(rhs, lhs)");
}
TEST_F(HlslGeneratorImplTest_Binary, Logical_And) {
Global("a", ty.bool_(), ast::StorageClass::kPrivate);
Global("b", ty.bool_(), ast::StorageClass::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
Expr("a"), Expr("b"));
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), "(tint_tmp)");
EXPECT_EQ(gen.result(), R"(bool tint_tmp = a;
if (tint_tmp) {
tint_tmp = b;
}
)");
}
TEST_F(HlslGeneratorImplTest_Binary, Logical_Multi) {
// (a && b) || (c || d)
Global("a", ty.bool_(), ast::StorageClass::kPrivate);
Global("b", ty.bool_(), ast::StorageClass::kPrivate);
Global("c", ty.bool_(), ast::StorageClass::kPrivate);
Global("d", ty.bool_(), ast::StorageClass::kPrivate);
auto* expr = create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr,
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("a"),
Expr("b")),
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, Expr("c"),
Expr("d")));
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), "(tint_tmp)");
EXPECT_EQ(gen.result(), R"(bool tint_tmp_1 = a;
if (tint_tmp_1) {
tint_tmp_1 = b;
}
bool tint_tmp = (tint_tmp_1);
if (!tint_tmp) {
bool tint_tmp_2 = c;
if (!tint_tmp_2) {
tint_tmp_2 = d;
}
tint_tmp = (tint_tmp_2);
}
)");
}
TEST_F(HlslGeneratorImplTest_Binary, Logical_Or) {
Global("a", ty.bool_(), ast::StorageClass::kPrivate);
Global("b", ty.bool_(), ast::StorageClass::kPrivate);
auto* expr = create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
Expr("a"), Expr("b"));
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), "(tint_tmp)");
EXPECT_EQ(gen.result(), R"(bool tint_tmp = a;
if (!tint_tmp) {
tint_tmp = b;
}
)");
}
TEST_F(HlslGeneratorImplTest_Binary, If_WithLogical) {
// if (a && b) {
// return 1;
// } else if (b || c) {
// return 2;
// } else {
// return 3;
// }
Global("a", ty.bool_(), ast::StorageClass::kPrivate);
Global("b", ty.bool_(), ast::StorageClass::kPrivate);
Global("c", ty.bool_(), ast::StorageClass::kPrivate);
auto* body = Block(Return(3));
auto* else_stmt = create<ast::ElseStatement>(nullptr, body);
body = Block(Return(2));
auto* else_if_stmt = create<ast::ElseStatement>(
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, Expr("b"),
Expr("c")),
body);
body = Block(Return(1));
auto* expr = create<ast::IfStatement>(
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("a"),
Expr("b")),
body,
ast::ElseStatementList{
else_if_stmt,
else_stmt,
});
Func("func", {}, ty.i32(), {WrapInStatement(expr), Return(0)});
GeneratorImpl& gen = Build();
ASSERT_TRUE(gen.EmitStatement(expr)) << gen.error();
EXPECT_EQ(gen.result(), R"(bool tint_tmp = a;
if (tint_tmp) {
tint_tmp = b;
}
if ((tint_tmp)) {
return 1;
} else {
bool tint_tmp_1 = b;
if (!tint_tmp_1) {
tint_tmp_1 = c;
}
if ((tint_tmp_1)) {
return 2;
} else {
return 3;
}
}
)");
}
TEST_F(HlslGeneratorImplTest_Binary, Return_WithLogical) {
// return (a && b) || c;
Global("a", ty.bool_(), ast::StorageClass::kPrivate);
Global("b", ty.bool_(), ast::StorageClass::kPrivate);
Global("c", ty.bool_(), ast::StorageClass::kPrivate);
auto* expr = Return(create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr,
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd, Expr("a"),
Expr("b")),
Expr("c")));
Func("func", {}, ty.bool_(), {WrapInStatement(expr)});
GeneratorImpl& gen = Build();
ASSERT_TRUE(gen.EmitStatement(expr)) << gen.error();
EXPECT_EQ(gen.result(), R"(bool tint_tmp_1 = a;
if (tint_tmp_1) {
tint_tmp_1 = b;
}
bool tint_tmp = (tint_tmp_1);
if (!tint_tmp) {
tint_tmp = c;
}
return (tint_tmp);
)");
}
TEST_F(HlslGeneratorImplTest_Binary, Assign_WithLogical) {
// a = (b || c) && d;
Global("a", ty.bool_(), ast::StorageClass::kPrivate);
Global("b", ty.bool_(), ast::StorageClass::kPrivate);
Global("c", ty.bool_(), ast::StorageClass::kPrivate);
Global("d", ty.bool_(), ast::StorageClass::kPrivate);
auto* expr = Assign(
Expr("a"), create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalAnd,
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
Expr("b"), Expr("c")),
Expr("d")));
WrapInFunction(expr);
GeneratorImpl& gen = Build();
ASSERT_TRUE(gen.EmitStatement(expr)) << gen.error();
EXPECT_EQ(gen.result(), R"(bool tint_tmp_1 = b;
if (!tint_tmp_1) {
tint_tmp_1 = c;
}
bool tint_tmp = (tint_tmp_1);
if (tint_tmp) {
tint_tmp = d;
}
a = (tint_tmp);
)");
}
TEST_F(HlslGeneratorImplTest_Binary, Decl_WithLogical) {
// var a : bool = (b && c) || d;
Global("b", ty.bool_(), ast::StorageClass::kPrivate);
Global("c", ty.bool_(), ast::StorageClass::kPrivate);
Global("d", ty.bool_(), ast::StorageClass::kPrivate);
auto* var = Var("a", ty.bool_(), ast::StorageClass::kNone,
create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalOr,
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
Expr("b"), Expr("c")),
Expr("d")));
auto* decl = Decl(var);
WrapInFunction(decl);
GeneratorImpl& gen = Build();
ASSERT_TRUE(gen.EmitStatement(decl)) << gen.error();
EXPECT_EQ(gen.result(), R"(bool tint_tmp_1 = b;
if (tint_tmp_1) {
tint_tmp_1 = c;
}
bool tint_tmp = (tint_tmp_1);
if (!tint_tmp) {
tint_tmp = d;
}
bool a = (tint_tmp);
)");
}
TEST_F(HlslGeneratorImplTest_Binary, Bitcast_WithLogical) {
// as<i32>(a && (b || c))
Global("a", ty.bool_(), ast::StorageClass::kPrivate);
Global("b", ty.bool_(), ast::StorageClass::kPrivate);
Global("c", ty.bool_(), ast::StorageClass::kPrivate);
auto* expr = create<ast::BitcastExpression>(
ty.i32(), create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalAnd, Expr("a"),
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
Expr("b"), Expr("c"))));
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(gen.result(), R"(bool tint_tmp = a;
if (tint_tmp) {
bool tint_tmp_1 = b;
if (!tint_tmp_1) {
tint_tmp_1 = c;
}
tint_tmp = (tint_tmp_1);
}
)");
EXPECT_EQ(out.str(), R"(asint((tint_tmp)))");
}
TEST_F(HlslGeneratorImplTest_Binary, Call_WithLogical) {
// foo(a && b, c || d, (a || c) && (b || d))
Func("foo",
{
Param(Sym(), ty.bool_()),
Param(Sym(), ty.bool_()),
Param(Sym(), ty.bool_()),
},
ty.void_(), ast::StatementList{}, ast::DecorationList{});
Global("a", ty.bool_(), ast::StorageClass::kPrivate);
Global("b", ty.bool_(), ast::StorageClass::kPrivate);
Global("c", ty.bool_(), ast::StorageClass::kPrivate);
Global("d", ty.bool_(), ast::StorageClass::kPrivate);
ast::ExpressionList params;
params.push_back(create<ast::BinaryExpression>(ast::BinaryOp::kLogicalAnd,
Expr("a"), Expr("b")));
params.push_back(create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr,
Expr("c"), Expr("d")));
params.push_back(create<ast::BinaryExpression>(
ast::BinaryOp::kLogicalAnd,
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, Expr("a"),
Expr("c")),
create<ast::BinaryExpression>(ast::BinaryOp::kLogicalOr, Expr("b"),
Expr("d"))));
auto* expr = CallStmt(Call("foo", params));
WrapInFunction(expr);
GeneratorImpl& gen = Build();
ASSERT_TRUE(gen.EmitStatement(expr)) << gen.error();
EXPECT_EQ(gen.result(), R"(bool tint_tmp = a;
if (tint_tmp) {
tint_tmp = b;
}
bool tint_tmp_1 = c;
if (!tint_tmp_1) {
tint_tmp_1 = d;
}
bool tint_tmp_3 = a;
if (!tint_tmp_3) {
tint_tmp_3 = c;
}
bool tint_tmp_2 = (tint_tmp_3);
if (tint_tmp_2) {
bool tint_tmp_4 = b;
if (!tint_tmp_4) {
tint_tmp_4 = d;
}
tint_tmp_2 = (tint_tmp_4);
}
foo((tint_tmp), (tint_tmp_1), (tint_tmp_2));
)");
}
TEST_F(HlslGeneratorImplTest_Binary, DivideByLiteralZero_i32) {
Global("a", ty.i32(), ast::StorageClass::kPrivate);
auto* expr = Div("a", 0);
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), R"((a / 1))");
}
TEST_F(HlslGeneratorImplTest_Binary, DivideByLiteralZero_u32) {
Global("a", ty.u32(), ast::StorageClass::kPrivate);
auto* expr = Div("a", 0u);
WrapInFunction(expr);
GeneratorImpl& gen = Build();
std::stringstream out;
ASSERT_TRUE(gen.EmitExpression(out, expr)) << gen.error();
EXPECT_EQ(out.str(), R"((a / 1u))");
}
} // namespace
} // namespace hlsl
} // namespace writer
} // namespace tint
|
/*****************************************************************************
* McPAT/CACTI
* SOFTWARE LICENSE AGREEMENT
* Copyright 2012 Hewlett-Packard Development Company, L.P.
* Copyright (c) 2010-2013 Advanced Micro Devices, Inc.
* All Rights Reserved
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
***************************************************************************/
#include <iomanip>
#include <iostream>
#include <string>
#include "area.h"
#include "parameter.h"
using namespace std;
InputParameter * g_ip;
TechnologyParameter g_tp;
void TechnologyParameter::DeviceType::display(uint32_t indent) {
string indent_str(indent, ' ');
cout << indent_str << "C_g_ideal = " << setw(12) << C_g_ideal << " F/um" << endl;
cout << indent_str << "C_fringe = " << setw(12) << C_fringe << " F/um" << endl;
cout << indent_str << "C_overlap = " << setw(12) << C_overlap << " F/um" << endl;
cout << indent_str << "C_junc = " << setw(12) << C_junc << " F/um^2" << endl;
cout << indent_str << "l_phy = " << setw(12) << l_phy << " um" << endl;
cout << indent_str << "l_elec = " << setw(12) << l_elec << " um" << endl;
cout << indent_str << "R_nch_on = " << setw(12) << R_nch_on << " ohm-um" << endl;
cout << indent_str << "R_pch_on = " << setw(12) << R_pch_on << " ohm-um" << endl;
cout << indent_str << "Vdd = " << setw(12) << Vdd << " V" << endl;
cout << indent_str << "Vth = " << setw(12) << Vth << " V" << endl;
cout << indent_str << "I_on_n = " << setw(12) << I_on_n << " A/um" << endl;
cout << indent_str << "I_on_p = " << setw(12) << I_on_p << " A/um" << endl;
cout << indent_str << "I_off_n = " << setw(12) << I_off_n << " A/um" << endl;
cout << indent_str << "I_off_p = " << setw(12) << I_off_p << " A/um" << endl;
cout << indent_str << "C_ox = " << setw(12) << C_ox << " F/um^2" << endl;
cout << indent_str << "t_ox = " << setw(12) << t_ox << " um" << endl;
cout << indent_str << "n_to_p_eff_curr_drv_ratio = " << n_to_p_eff_curr_drv_ratio << endl;
}
void TechnologyParameter::InterconnectType::display(uint32_t indent) {
string indent_str(indent, ' ');
cout << indent_str << "pitch = " << setw(12) << pitch << " um" << endl;
cout << indent_str << "R_per_um = " << setw(12) << R_per_um << " ohm/um" << endl;
cout << indent_str << "C_per_um = " << setw(12) << C_per_um << " F/um" << endl;
}
void TechnologyParameter::ScalingFactor::display(uint32_t indent) {
string indent_str(indent, ' ');
cout << indent_str << "logic_scaling_co_eff = " << setw(12) << logic_scaling_co_eff << endl;
cout << indent_str << "curr_core_tx_density = " << setw(12) << core_tx_density << " # of tx/um^2" << endl;
}
void TechnologyParameter::MemoryType::display(uint32_t indent) {
string indent_str(indent, ' ');
cout << indent_str << "b_w = " << setw(12) << b_w << " um" << endl;
cout << indent_str << "b_h = " << setw(12) << b_h << " um" << endl;
cout << indent_str << "cell_a_w = " << setw(12) << cell_a_w << " um" << endl;
cout << indent_str << "cell_pmos_w = " << setw(12) << cell_pmos_w << " um" << endl;
cout << indent_str << "cell_nmos_w = " << setw(12) << cell_nmos_w << " um" << endl;
cout << indent_str << "Vbitpre = " << setw(12) << Vbitpre << " V" << endl;
}
void TechnologyParameter::display(uint32_t indent) {
string indent_str(indent, ' ');
cout << indent_str << "ram_wl_stitching_overhead_ = " << setw(12) << ram_wl_stitching_overhead_ << " um" << endl;
cout << indent_str << "min_w_nmos_ = " << setw(12) << min_w_nmos_ << " um" << endl;
cout << indent_str << "max_w_nmos_ = " << setw(12) << max_w_nmos_ << " um" << endl;
cout << indent_str << "unit_len_wire_del = " << setw(12) << unit_len_wire_del << " s/um^2" << endl;
cout << indent_str << "FO4 = " << setw(12) << FO4 << " s" << endl;
cout << indent_str << "kinv = " << setw(12) << kinv << " s" << endl;
cout << indent_str << "vpp = " << setw(12) << vpp << " V" << endl;
cout << indent_str << "w_sense_en = " << setw(12) << w_sense_en << " um" << endl;
cout << indent_str << "w_sense_n = " << setw(12) << w_sense_n << " um" << endl;
cout << indent_str << "w_sense_p = " << setw(12) << w_sense_p << " um" << endl;
cout << indent_str << "w_iso = " << setw(12) << w_iso << " um" << endl;
cout << indent_str << "w_poly_contact = " << setw(12) << w_poly_contact << " um" << endl;
cout << indent_str << "spacing_poly_to_poly = " << setw(12) << spacing_poly_to_poly << " um" << endl;
cout << indent_str << "spacing_poly_to_contact = " << setw(12) << spacing_poly_to_contact << " um" << endl;
cout << endl;
cout << indent_str << "w_comp_inv_p1 = " << setw(12) << w_comp_inv_p1 << " um" << endl;
cout << indent_str << "w_comp_inv_p2 = " << setw(12) << w_comp_inv_p2 << " um" << endl;
cout << indent_str << "w_comp_inv_p3 = " << setw(12) << w_comp_inv_p3 << " um" << endl;
cout << indent_str << "w_comp_inv_n1 = " << setw(12) << w_comp_inv_n1 << " um" << endl;
cout << indent_str << "w_comp_inv_n2 = " << setw(12) << w_comp_inv_n2 << " um" << endl;
cout << indent_str << "w_comp_inv_n3 = " << setw(12) << w_comp_inv_n3 << " um" << endl;
cout << indent_str << "w_eval_inv_p = " << setw(12) << w_eval_inv_p << " um" << endl;
cout << indent_str << "w_eval_inv_n = " << setw(12) << w_eval_inv_n << " um" << endl;
cout << indent_str << "w_comp_n = " << setw(12) << w_comp_n << " um" << endl;
cout << indent_str << "w_comp_p = " << setw(12) << w_comp_p << " um" << endl;
cout << endl;
cout << indent_str << "dram_cell_I_on = " << setw(12) << dram_cell_I_on << " A/um" << endl;
cout << indent_str << "dram_cell_Vdd = " << setw(12) << dram_cell_Vdd << " V" << endl;
cout << indent_str << "dram_cell_I_off_worst_case_len_temp = " << setw(12) << dram_cell_I_off_worst_case_len_temp << " A/um" << endl;
cout << indent_str << "dram_cell_C = " << setw(12) << dram_cell_C << " F" << endl;
cout << indent_str << "gm_sense_amp_latch = " << setw(12) << gm_sense_amp_latch << " F/s" << endl;
cout << endl;
cout << indent_str << "w_nmos_b_mux = " << setw(12) << w_nmos_b_mux << " um" << endl;
cout << indent_str << "w_nmos_sa_mux = " << setw(12) << w_nmos_sa_mux << " um" << endl;
cout << indent_str << "w_pmos_bl_precharge = " << setw(12) << w_pmos_bl_precharge << " um" << endl;
cout << indent_str << "w_pmos_bl_eq = " << setw(12) << w_pmos_bl_eq << " um" << endl;
cout << indent_str << "MIN_GAP_BET_P_AND_N_DIFFS = " << setw(12) << MIN_GAP_BET_P_AND_N_DIFFS << " um" << endl;
cout << indent_str << "HPOWERRAIL = " << setw(12) << HPOWERRAIL << " um" << endl;
cout << indent_str << "cell_h_def = " << setw(12) << cell_h_def << " um" << endl;
cout << endl;
cout << indent_str << "SRAM cell transistor: " << endl;
sram_cell.display(indent + 2);
cout << endl;
cout << indent_str << "DRAM access transistor: " << endl;
dram_acc.display(indent + 2);
cout << endl;
cout << indent_str << "DRAM wordline transistor: " << endl;
dram_wl.display(indent + 2);
cout << endl;
cout << indent_str << "peripheral global transistor: " << endl;
peri_global.display(indent + 2);
cout << endl;
cout << indent_str << "wire local" << endl;
wire_local.display(indent + 2);
cout << endl;
cout << indent_str << "wire inside mat" << endl;
wire_inside_mat.display(indent + 2);
cout << endl;
cout << indent_str << "wire outside mat" << endl;
wire_outside_mat.display(indent + 2);
cout << endl;
cout << indent_str << "SRAM" << endl;
sram.display(indent + 2);
cout << endl;
cout << indent_str << "DRAM" << endl;
dram.display(indent + 2);
}
DynamicParameter::DynamicParameter():
use_inp_params(0), cell(), is_valid(true) {
}
DynamicParameter::DynamicParameter(
bool is_tag_,
int pure_ram_,
int pure_cam_,
double Nspd_,
unsigned int Ndwl_,
unsigned int Ndbl_,
unsigned int Ndcm_,
unsigned int Ndsam_lev_1_,
unsigned int Ndsam_lev_2_,
bool is_main_mem_):
is_tag(is_tag_), pure_ram(pure_ram_), pure_cam(pure_cam_), tagbits(0),
Nspd(Nspd_), Ndwl(Ndwl_), Ndbl(Ndbl_), Ndcm(Ndcm_),
Ndsam_lev_1(Ndsam_lev_1_), Ndsam_lev_2(Ndsam_lev_2_),
number_way_select_signals_mat(0), V_b_sense(0), use_inp_params(0),
is_main_mem(is_main_mem_), cell(), is_valid(false) {
ram_cell_tech_type = (is_tag) ? g_ip->tag_arr_ram_cell_tech_type : g_ip->data_arr_ram_cell_tech_type;
is_dram = ((ram_cell_tech_type == lp_dram) || (ram_cell_tech_type == comm_dram));
unsigned int capacity_per_die = g_ip->cache_sz / NUMBER_STACKED_DIE_LAYERS; // capacity per stacked die layer
const TechnologyParameter::InterconnectType & wire_local = g_tp.wire_local;
fully_assoc = (g_ip->fully_assoc) ? true : false;
// fully-assocative cache -- ref: CACTi 2.0 report
if (fully_assoc || pure_cam) {
if (Ndwl != 1 || //Ndwl is fixed to 1 for FA
Ndcm != 1 || //Ndcm is fixed to 1 for FA
Nspd < 1 || Nspd > 1 || //Nspd is fixed to 1 for FA
Ndsam_lev_1 != 1 || //Ndsam_lev_1 is fixed to one
Ndsam_lev_2 != 1 || //Ndsam_lev_2 is fixed to one
Ndbl < 2) {
return;
}
}
if ((is_dram) && (!is_tag) && (Ndcm > 1)) {
return; // For a DRAM array, each bitline has its own sense-amp
}
// If it's not an FA tag/data array, Ndwl should be at least two and Ndbl should be
// at least two because an array is assumed to have at least one mat. And a mat
// is formed out of two horizontal subarrays and two vertical subarrays
if (fully_assoc == false && (Ndwl < 1 || Ndbl < 1)) {
return;
}
//***********compute row, col of an subarray
if (!(fully_assoc || pure_cam)) {
//Not fully_asso nor cam
// if data array, let tagbits = 0
if (is_tag) {
if (g_ip->specific_tag) {
tagbits = g_ip->tag_w;
} else {
tagbits = ADDRESS_BITS + EXTRA_TAG_BITS - _log2(capacity_per_die) +
_log2(g_ip->tag_assoc * 2 - 1) - _log2(g_ip->nbanks);
}
tagbits = (((tagbits + 3) >> 2) << 2);
num_r_subarray = (int)ceil(capacity_per_die / (g_ip->nbanks *
g_ip->block_sz * g_ip->tag_assoc * Ndbl * Nspd));// + EPSILON);
num_c_subarray = (int)ceil((tagbits * g_ip->tag_assoc * Nspd / Ndwl));// + EPSILON);
//burst_length = 1;
} else {
num_r_subarray = (int)ceil(capacity_per_die / (g_ip->nbanks *
g_ip->block_sz * g_ip->data_assoc * Ndbl * Nspd));// + EPSILON);
num_c_subarray = (int)ceil((8 * g_ip->block_sz * g_ip->data_assoc * Nspd / Ndwl));// + EPSILON); + EPSILON);
// burst_length = g_ip->block_sz * 8 / g_ip->out_w;
}
if (num_r_subarray < MINSUBARRAYROWS) return;
if (num_r_subarray == 0) return;
if (num_r_subarray > MAXSUBARRAYROWS) return;
if (num_c_subarray < MINSUBARRAYCOLS) return;
if (num_c_subarray > MAXSUBARRAYCOLS) return;
}
else {//either fully-asso or cam
if (pure_cam) {
if (g_ip->specific_tag) {
tagbits = int(ceil(g_ip->tag_w / 8.0) * 8);
} else {
tagbits = int(ceil((ADDRESS_BITS + EXTRA_TAG_BITS) / 8.0) * 8);
// cout<<"Pure CAM needs tag width to be specified"<<endl;
// exit(0);
}
//tagbits = (((tagbits + 3) >> 2) << 2);
//TODO: error check input of tagbits and blocksize
//TODO: for pure CAM, g_ip->block should be number of entries.
tag_num_r_subarray = (int)ceil(capacity_per_die /
(g_ip->nbanks * tagbits / 8.0 * Ndbl));
//tag_num_c_subarray = (int)(tagbits + EPSILON);
tag_num_c_subarray = tagbits;
if (tag_num_r_subarray == 0) return;
if (tag_num_r_subarray > MAXSUBARRAYROWS) return;
if (tag_num_c_subarray < MINSUBARRAYCOLS) return;
if (tag_num_c_subarray > MAXSUBARRAYCOLS) return;
num_r_subarray = tag_num_r_subarray;
} else { //fully associative
if (g_ip->specific_tag) {
tagbits = g_ip->tag_w;
} else {
tagbits = ADDRESS_BITS + EXTRA_TAG_BITS - _log2(g_ip->block_sz);//TODO: should be the page_offset=log2(page size), but this info is not avail with CACTI, for McPAT this is no problem.
}
tagbits = (((tagbits + 3) >> 2) << 2);
tag_num_r_subarray = (int)(capacity_per_die /
(g_ip->nbanks * g_ip->block_sz * Ndbl));
tag_num_c_subarray = (int)ceil((tagbits * Nspd / Ndwl));// + EPSILON);
if (tag_num_r_subarray == 0) return;
if (tag_num_r_subarray > MAXSUBARRAYROWS) return;
if (tag_num_c_subarray < MINSUBARRAYCOLS) return;
if (tag_num_c_subarray > MAXSUBARRAYCOLS) return;
data_num_r_subarray = tag_num_r_subarray;
data_num_c_subarray = 8 * g_ip->block_sz;
if (data_num_r_subarray == 0) return;
if (data_num_r_subarray > MAXSUBARRAYROWS) return;
if (data_num_c_subarray < MINSUBARRAYCOLS) return;
if (data_num_c_subarray > MAXSUBARRAYCOLS) return;
num_r_subarray = tag_num_r_subarray;
}
}
num_subarrays = Ndwl * Ndbl;
//****************end of computation of row, col of an subarray
// calculate wire parameters
if (fully_assoc || pure_cam) {
cam_cell.h = g_tp.cam.b_h + 2 * wire_local.pitch *
(g_ip->num_rw_ports - 1 + g_ip->num_rd_ports + g_ip->num_wr_ports)
+ 2 * wire_local.pitch * (g_ip->num_search_ports - 1) +
wire_local.pitch * g_ip->num_se_rd_ports;
cam_cell.w = g_tp.cam.b_w + 2 * wire_local.pitch *
(g_ip->num_rw_ports - 1 + g_ip->num_rd_ports + g_ip->num_wr_ports)
+ 2 * wire_local.pitch * (g_ip->num_search_ports - 1) +
wire_local.pitch * g_ip->num_se_rd_ports;
cell.h = g_tp.sram.b_h + 2 * wire_local.pitch *
(g_ip->num_wr_ports + g_ip->num_rw_ports - 1 + g_ip->num_rd_ports)
+ 2 * wire_local.pitch * (g_ip->num_search_ports - 1);
cell.w = g_tp.sram.b_w + 2 * wire_local.pitch *
(g_ip->num_rw_ports - 1 + (g_ip->num_rd_ports -
g_ip->num_se_rd_ports)
+ g_ip->num_wr_ports) + g_tp.wire_local.pitch *
g_ip->num_se_rd_ports + 2 * wire_local.pitch *
(g_ip->num_search_ports - 1);
} else {
if (is_tag) {
cell.h = g_tp.sram.b_h + 2 * wire_local.pitch * (g_ip->num_rw_ports - 1 + g_ip->num_rd_ports +
g_ip->num_wr_ports);
cell.w = g_tp.sram.b_w + 2 * wire_local.pitch * (g_ip->num_rw_ports - 1 + g_ip->num_wr_ports +
(g_ip->num_rd_ports - g_ip->num_se_rd_ports)) +
wire_local.pitch * g_ip->num_se_rd_ports;
} else {
if (is_dram) {
cell.h = g_tp.dram.b_h;
cell.w = g_tp.dram.b_w;
} else {
cell.h = g_tp.sram.b_h + 2 * wire_local.pitch * (g_ip->num_wr_ports +
g_ip->num_rw_ports - 1 + g_ip->num_rd_ports);
cell.w = g_tp.sram.b_w + 2 * wire_local.pitch * (g_ip->num_rw_ports - 1 +
(g_ip->num_rd_ports - g_ip->num_se_rd_ports) +
g_ip->num_wr_ports) + g_tp.wire_local.pitch * g_ip->num_se_rd_ports;
}
}
}
double c_b_metal = cell.h * wire_local.C_per_um;
double C_bl;
if (!(fully_assoc || pure_cam)) {
if (is_dram) {
deg_bl_muxing = 1;
if (ram_cell_tech_type == comm_dram) {
C_bl = num_r_subarray * c_b_metal;
V_b_sense = (g_tp.dram_cell_Vdd / 2) * g_tp.dram_cell_C /
(g_tp.dram_cell_C + C_bl);
if (V_b_sense < VBITSENSEMIN) {
return;
}
V_b_sense = VBITSENSEMIN; // in any case, we fix sense amp input signal to a constant value
dram_refresh_period = 64e-3;
} else {
double Cbitrow_drain_cap = drain_C_(g_tp.dram.cell_a_w, NCH, 1, 0, cell.w, true, true) / 2.0;
C_bl = num_r_subarray * (Cbitrow_drain_cap + c_b_metal);
V_b_sense = (g_tp.dram_cell_Vdd / 2) * g_tp.dram_cell_C /
(g_tp.dram_cell_C + C_bl);
if (V_b_sense < VBITSENSEMIN) {
return; //Sense amp input signal is smaller that minimum allowable sense amp input signal
}
V_b_sense = VBITSENSEMIN; // in any case, we fix sense amp input signal to a constant value
//v_storage_worst = g_tp.dram_cell_Vdd / 2 - VBITSENSEMIN * (g_tp.dram_cell_C + C_bl) / g_tp.dram_cell_C;
//dram_refresh_period = 1.1 * g_tp.dram_cell_C * v_storage_worst / g_tp.dram_cell_I_off_worst_case_len_temp;
dram_refresh_period = 0.9 * g_tp.dram_cell_C * VDD_STORAGE_LOSS_FRACTION_WORST * g_tp.dram_cell_Vdd / g_tp.dram_cell_I_off_worst_case_len_temp;
}
} else { //SRAM
V_b_sense = (0.05 * g_tp.sram_cell.Vdd > VBITSENSEMIN) ? 0.05 * g_tp.sram_cell.Vdd : VBITSENSEMIN;
deg_bl_muxing = Ndcm;
// "/ 2.0" below is due to the fact that two adjacent access transistors share drain
// contacts in a physical layout
double Cbitrow_drain_cap = drain_C_(g_tp.sram.cell_a_w, NCH, 1, 0, cell.w, false, true) / 2.0;
C_bl = num_r_subarray * (Cbitrow_drain_cap + c_b_metal);
dram_refresh_period = 0;
}
} else {
c_b_metal = cam_cell.h * wire_local.C_per_um;//IBM and SUN design, SRAM array uses dummy cells to fill the blank space due to mismatch on CAM-RAM
V_b_sense = (0.05 * g_tp.sram_cell.Vdd > VBITSENSEMIN) ? 0.05 * g_tp.sram_cell.Vdd : VBITSENSEMIN;
deg_bl_muxing = 1;//FA fix as 1
// "/ 2.0" below is due to the fact that two adjacent access transistors share drain
// contacts in a physical layout
double Cbitrow_drain_cap = drain_C_(g_tp.cam.cell_a_w, NCH, 1, 0, cam_cell.w, false, true) / 2.0;//TODO: comment out these two lines
C_bl = num_r_subarray * (Cbitrow_drain_cap + c_b_metal);
dram_refresh_period = 0;
}
// do/di: data in/out, for fully associative they are the data width for normal read and write
// so/si: search data in/out, for fully associative they are the data width for the search ops
// for CAM, si=di, but so = matching address. do = data out = di (for normal read/write)
// so/si needs broadcase while do/di do not
if (fully_assoc || pure_cam) {
switch (Ndbl) {
case (0):
cout << " Invalid Ndbl \n" << endl;
exit(0);
break;
case (1):
num_mats_h_dir = 1;//one subarray per mat
num_mats_v_dir = 1;
break;
case (2):
num_mats_h_dir = 1;//two subarrays per mat
num_mats_v_dir = 1;
break;
default:
num_mats_h_dir = int(floor(sqrt(Ndbl / 4.0)));//4 subbarrys per mat
num_mats_v_dir = int(Ndbl / 4.0 / num_mats_h_dir);
}
num_mats = num_mats_h_dir * num_mats_v_dir;
if (fully_assoc) {
num_so_b_mat = data_num_c_subarray;
num_do_b_mat = data_num_c_subarray + tagbits;
} else {
num_so_b_mat = int(ceil(log2(num_r_subarray)) + ceil(log2(num_subarrays)));//the address contains the matched data
num_do_b_mat = tagbits;
}
} else {
num_mats_h_dir = MAX(Ndwl / 2, 1);
num_mats_v_dir = MAX(Ndbl / 2, 1);
num_mats = num_mats_h_dir * num_mats_v_dir;
num_do_b_mat = MAX((num_subarrays / num_mats) * num_c_subarray /
(deg_bl_muxing * Ndsam_lev_1 * Ndsam_lev_2), 1);
}
if (!(fully_assoc || pure_cam) && (num_do_b_mat <
(num_subarrays / num_mats))) {
return;
}
int deg_sa_mux_l1_non_assoc;
//TODO:the i/o for subbank is not necessary and should be removed.
if (!(fully_assoc || pure_cam)) {
if (!is_tag) {
if (is_main_mem == true) {
num_do_b_subbank = g_ip->int_prefetch_w * g_ip->out_w;
deg_sa_mux_l1_non_assoc = Ndsam_lev_1;
} else {
if (g_ip->fast_access == true) {
num_do_b_subbank = g_ip->out_w * g_ip->data_assoc;
deg_sa_mux_l1_non_assoc = Ndsam_lev_1;
} else {
num_do_b_subbank = g_ip->out_w;
deg_sa_mux_l1_non_assoc = Ndsam_lev_1 / g_ip->data_assoc;
if (deg_sa_mux_l1_non_assoc < 1) {
return;
}
}
}
} else {
num_do_b_subbank = tagbits * g_ip->tag_assoc;
if (num_do_b_mat < tagbits) {
return;
}
deg_sa_mux_l1_non_assoc = Ndsam_lev_1;
//num_do_b_mat = g_ip->tag_assoc / num_mats_h_dir;
}
} else {
if (fully_assoc) {
num_so_b_subbank = 8 * g_ip->block_sz;//TODO:internal perfetch should be considered also for fa
num_do_b_subbank = num_so_b_subbank + tag_num_c_subarray;
} else {
num_so_b_subbank = int(ceil(log2(num_r_subarray)) + ceil(log2(num_subarrays)));//the address contains the matched data
num_do_b_subbank = tag_num_c_subarray;
}
deg_sa_mux_l1_non_assoc = 1;
}
deg_senseamp_muxing_non_associativity = deg_sa_mux_l1_non_assoc;
if (fully_assoc || pure_cam) {
num_act_mats_hor_dir = 1;
num_act_mats_hor_dir_sl = num_mats_h_dir;//TODO: this is unnecessary, since search op, num_mats is used
} else {
num_act_mats_hor_dir = num_do_b_subbank / num_do_b_mat;
if (num_act_mats_hor_dir == 0) {
return;
}
}
//compute num_do_mat for tag
if (is_tag) {
if (!(fully_assoc || pure_cam)) {
num_do_b_mat = g_ip->tag_assoc / num_act_mats_hor_dir;
num_do_b_subbank = num_act_mats_hor_dir * num_do_b_mat;
}
}
if ((g_ip->is_cache == false && is_main_mem == true) ||
(PAGE_MODE == 1 && is_dram)) {
if (num_act_mats_hor_dir * num_do_b_mat * Ndsam_lev_1 * Ndsam_lev_2 !=
(int)g_ip->page_sz_bits) {
return;
}
}
// if (is_tag == false && g_ip->is_cache == true && !fully_assoc && !pure_cam && //TODO: TODO burst transfer should also apply to RAM arrays
if (is_tag == false && g_ip->is_main_mem == true &&
num_act_mats_hor_dir*num_do_b_mat*Ndsam_lev_1*Ndsam_lev_2 <
((int) g_ip->out_w * (int) g_ip->burst_len * (int) g_ip->data_assoc)) {
return;
}
if (num_act_mats_hor_dir > num_mats_h_dir) {
return;
}
//compute di for mat subbank and bank
if (!(fully_assoc || pure_cam)) {
if (!is_tag) {
if (g_ip->fast_access == true) {
num_di_b_mat = num_do_b_mat / g_ip->data_assoc;
} else {
num_di_b_mat = num_do_b_mat;
}
} else {
num_di_b_mat = tagbits;
}
} else {
if (fully_assoc) {
num_di_b_mat = num_do_b_mat;
//*num_subarrays/num_mats; bits per mat of CAM/FA is as same as cache,
//but inside the mat wire tracks need to be reserved for search data bus
num_si_b_mat = tagbits;
} else {
num_di_b_mat = tagbits;
num_si_b_mat = tagbits;//*num_subarrays/num_mats;
}
}
num_di_b_subbank = num_di_b_mat * num_act_mats_hor_dir;//normal cache or normal r/w for FA
num_si_b_subbank = num_si_b_mat; //* num_act_mats_hor_dir_sl; inside the data is broadcast
int num_addr_b_row_dec = _log2(num_r_subarray);
if ((fully_assoc || pure_cam))
num_addr_b_row_dec += _log2(num_subarrays / num_mats);
int number_subbanks = num_mats / num_act_mats_hor_dir;
number_subbanks_decode = _log2(number_subbanks);//TODO: add log2(num_subarray_per_bank) to FA/CAM
num_rw_ports = g_ip->num_rw_ports;
num_rd_ports = g_ip->num_rd_ports;
num_wr_ports = g_ip->num_wr_ports;
num_se_rd_ports = g_ip->num_se_rd_ports;
num_search_ports = g_ip->num_search_ports;
if (is_dram && is_main_mem) {
number_addr_bits_mat = MAX((unsigned int) num_addr_b_row_dec,
_log2(deg_bl_muxing) + _log2(deg_sa_mux_l1_non_assoc) + _log2(Ndsam_lev_2));
} else {
number_addr_bits_mat = num_addr_b_row_dec + _log2(deg_bl_muxing) +
_log2(deg_sa_mux_l1_non_assoc) + _log2(Ndsam_lev_2);
}
if (!(fully_assoc || pure_cam)) {
if (is_tag) {
num_di_b_bank_per_port = tagbits;
num_do_b_bank_per_port = g_ip->data_assoc;
} else {
num_di_b_bank_per_port = g_ip->out_w + g_ip->data_assoc;
num_do_b_bank_per_port = g_ip->out_w;
}
} else {
if (fully_assoc) {
num_di_b_bank_per_port = g_ip->out_w + tagbits;//TODO: out_w or block_sz?
num_si_b_bank_per_port = tagbits;
num_do_b_bank_per_port = g_ip->out_w + tagbits;
num_so_b_bank_per_port = g_ip->out_w;
} else {
num_di_b_bank_per_port = tagbits;
num_si_b_bank_per_port = tagbits;
num_do_b_bank_per_port = tagbits;
num_so_b_bank_per_port = int(ceil(log2(num_r_subarray)) + ceil(log2(num_subarrays)));
}
}
if ((!is_tag) && (g_ip->data_assoc > 1) && (!g_ip->fast_access)) {
number_way_select_signals_mat = g_ip->data_assoc;
}
// add ECC adjustment to all data signals that traverse on H-trees.
if (g_ip->add_ecc_b_ == true) {
num_do_b_mat += (int) (ceil(num_do_b_mat / num_bits_per_ecc_b_));
num_di_b_mat += (int) (ceil(num_di_b_mat / num_bits_per_ecc_b_));
num_di_b_subbank += (int) (ceil(num_di_b_subbank / num_bits_per_ecc_b_));
num_do_b_subbank += (int) (ceil(num_do_b_subbank / num_bits_per_ecc_b_));
num_di_b_bank_per_port += (int) (ceil(num_di_b_bank_per_port / num_bits_per_ecc_b_));
num_do_b_bank_per_port += (int) (ceil(num_do_b_bank_per_port / num_bits_per_ecc_b_));
num_so_b_mat += (int) (ceil(num_so_b_mat / num_bits_per_ecc_b_));
num_si_b_mat += (int) (ceil(num_si_b_mat / num_bits_per_ecc_b_));
num_si_b_subbank += (int) (ceil(num_si_b_subbank / num_bits_per_ecc_b_));
num_so_b_subbank += (int) (ceil(num_so_b_subbank / num_bits_per_ecc_b_));
num_si_b_bank_per_port += (int) (ceil(num_si_b_bank_per_port / num_bits_per_ecc_b_));
num_so_b_bank_per_port += (int) (ceil(num_so_b_bank_per_port / num_bits_per_ecc_b_));
}
is_valid = true;
}
|
// Copyright (c) 2017-2019 The PIVX developers
// Copyright (c) 2019 The CryptoDev developers
// Copyright (c) 2019 The peony developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "libzerocoin/Denominations.h"
#include "amount.h"
#include "chainparams.h"
#include "main.h"
#include "txdb.h"
#include "zpny/deterministicmint.h"
#include "key.h"
#include "zpny/accumulatorcheckpoints.h"
#include "libzerocoin/bignum.h"
#include <boost/test/unit_test.hpp>
#include <iostream>
#include <zpny/accumulators.h>
#include "wallet/wallet.h"
#include "zpny/zpnywallet.h"
#include "zpnychain.h"
#include "test_pny.h"
extern bool DecodeHexTx(CTransaction& tx, const std::string& strHexTx);
BOOST_FIXTURE_TEST_SUITE(zerocoin_implementation_tests, TestingSetup)
BOOST_AUTO_TEST_CASE(zcparams_test)
{
std::cout << "Running zcparams_test...\n";
bool fPassed = true;
try{
SelectParams(CBaseChainParams::MAIN);
libzerocoin::ZerocoinParams *ZCParams = Params().Zerocoin_Params(false);
(void)ZCParams;
} catch(std::exception& e) {
fPassed = false;
std::cout << e.what() << "\n";
}
BOOST_CHECK(fPassed);
}
std::string zerocoinModulus = "25195908475657893494027183240048398571429282126204032027777137836043662020707595556264018525880784"
"4069182906412495150821892985591491761845028084891200728449926873928072877767359714183472702618963750149718246911"
"6507761337985909570009733045974880842840179742910064245869181719511874612151517265463228221686998754918242243363"
"7259085141865462043576798423387184774447920739934236584823824281198163815010674810451660377306056201619676256133"
"8441436038339044149526344321901146575444541784240209246165157233507787077498171257724679629263863563732899121548"
"31438167899885040445364023527381951378636564391212010397122822120720357";
//ZQ_ONE mints
std::string rawTx1 = "0100000001983d5fd91685bb726c0ebc3676f89101b16e663fd896fea53e19972b95054c49000000006a473044022010fbec3e78f9c46e58193d481caff715ceb984df44671d30a2c0bde95c54055f0220446a97d9340da690eaf2658e5b2bf6a0add06f1ae3f1b40f37614c7079ce450d012103cb666bd0f32b71cbf4f32e95fa58e05cd83869ac101435fcb8acee99123ccd1dffffffff0200e1f5050000000086c10280004c80c3a01f94e71662f2ae8bfcd88dfc5b5e717136facd6538829db0c7f01e5fd793cccae7aa1958564518e0223d6d9ce15b1e38e757583546e3b9a3f85bd14408120cd5192a901bb52152e8759fdd194df230d78477706d0e412a66398f330be38a23540d12ab147e9fb19224913f3fe552ae6a587fb30a68743e52577150ff73042c0f0d8f000000001976a914d6042025bd1fff4da5da5c432d85d82b3f26a01688ac00000000";
std::string rawTxpub1 = "473ff507157523e74680ab37f586aae52e53f3f912492b19f7e14ab120d54238ae30b338f39662a410e6d707784d730f24d19dd9f75e85221b51b902a19d50c120844d15bf8a3b9e346355857e7381e5be19c6d3d22e01845565819aae7cacc93d75f1ef0c7b09d823865cdfa3671715e5bfc8dd8fc8baef26216e7941fa0c3";
std::string rawTxRand1 = "9fc222b16be09eb88affbdfbcc02d1c8b28f5e843c72eb06c89dd7aff0c60838";
std::string rawTxSerial1 = "b87754b165892c0f9634e3d03780ede24824125249cb8dfd4ad2c0be055cbead";
std::string rawTx2 = "01000000018c52504b2822c39dd7f4bd93e30562dc9d246e0b0dd4ee401ec2c24e9378be12000000006b483045022100e2628dbcd284dd4858e2c2d8e2d2d31eb222773b3026d39c79c489f5daf4ae2302200e0b1cb9a6d534dc86ea33afb8153a5a4c7cd4fb497c889fb991fbac8bf86802012103836a4868020f52f2ab9e5ec3634d2cd38794677fab47ae7a7128ea8102972ae0ffffffff022c0f0d8f000000001976a914e2e8e36a1a35da051341775315b1168494921acd88ac00e1f5050000000086c10280004c809d49caa17c3f1fb8bc93eabf54462c8ad1717ab646c8130ca0863ca5613f34751445cd7bde8ef1dd833645c7c205dd9b36171dc25209f46b04a34b5e06caa655eea9bd95b46f7d03ae60a97961dd6632c1050090ec1b6748199f0721eeec0822dd288c663020dd88ecda7c8abf8a409fa5c500c4188e52bfbe2ca77ce7b2700700000000";
std::string rawTxpub2 = "770b2e77ca72cbebf528e18c400c5a59f408abf8a7cdaec88dd2030668c28dd2208ecee21079f1948671bec900005c13266dd6179a960ae037d6fb495bda9ee55a6ca065e4ba3046bf40952c21d17369bdd05c2c7453683ddf18ede7bcd436788343f61a53c86a00c13c846b67a71d18a2c4654bfea93bcb81f3f7ca1ca499d";
std::string rawTxRand2 = "23040b1d889ca4a41cf50b88a380f3f3acffac750e221a268fedf700f063a886";
std::string rawTxSerial2 = "37393797cb39e5f22bdc4fba8108edb5ea497ba0d22aba0781e58a8555df285c";
std::string rawTx3 = "01000000014651d7ed09c01d26679dd8ad1ee1f704f63167544ca48bdd3b4577444d540514010000006a47304402207995f8e30a87b74f36146d80ab02198319240a2eb3f93018c740e91b6812ff23022002677250aa9f9c7b6c1258647b0b0c03f89c7495b82b9c4dd2dcdb0ced82412801210236e3e30dbb1d62c8872413b2a771cd611b8042dfb5d06feb6805ba934ba534ffffffffff0200e1f5050000000086c10280004c803dac1997d38ee8650bb87fae490f4684a7b023744c95cd5ef025bc7f4d1414aff96947cebf342cfbfaf217ec0088e489d722d494409494a011a452af55a8cd4d2cef97f3b0307b66238623ab02b148a9e20f36782c8b7ea47c0c0b8226ddb91ee8f1f94c8c04df5c834993f27175b20b1da99d8338c674b1741a696c54def8012c0f0d8f000000001976a914c7f81b8e5650af548f5d56ef064da5c2d1ee09ae88ac00000000";
std::string rawTxpub3 = "1f8de546c691a74b174c638839da91d0bb27571f29349835cdf048c4cf9f1e81eb9dd26820b0c7ca47e8b2c78360fe2a948b102ab238623667b30b0f397ef2c4dcda855af52a411a094944094d422d789e48800ec17f2fafb2c34bfce4769f9af14144d7fbc25f05ecd954c7423b0a784460f49ae7fb80b65e88ed39719ac3d";
std::string rawTxRand3 = "1953c2919d658c3f654566400ace91563105ad5acc4e4151bca1e762c0877d7b";
std::string rawTxSerial3 = "3abf349844720512325d129c95402edbc85d86fff89632a05dc18970560047a5";
std::vector<std::pair<std::string, std::string> > vecRawMints = {std::make_pair(rawTx1, rawTxSerial1), std::make_pair(rawTx2, rawTxSerial2), std::make_pair(rawTx3, rawTxSerial3)};
//create a zerocoin mint from vecsend
BOOST_AUTO_TEST_CASE(checkzerocoinmint_test)
{
std::cout << "generating privkeys\n";
//generate a privkey
CKey key;
key.MakeNewKey(true);
CPrivKey privkey = key.GetPrivKey();
//generate pubkey hash/serial
CPubKey pubkey = key.GetPubKey();
uint256 nSerial = Hash(pubkey.begin(), pubkey.end());
CBigNum bnSerial(nSerial);
//make sure privkey import to new keypair makes the same serial
CKey key2;
key2.SetPrivKey(privkey, true);
CPubKey pubkey2 = key2.GetPubKey();
uint256 nSerial2 = Hash(pubkey2.begin(), pubkey2.end());
CBigNum bnSerial2(nSerial2);
BOOST_CHECK_MESSAGE(bnSerial == bnSerial2, "Serials do not match!");
std::cout << "Running check_zerocoinmint_test...\n";
CTransaction tx;
BOOST_CHECK(DecodeHexTx(tx, rawTx1));
CValidationState state;
bool fFoundMint = false;
for(unsigned int i = 0; i < tx.vout.size(); i++){
if(tx.vout[i].IsZerocoinMint()) {
BOOST_CHECK(CheckZerocoinMint(tx.GetHash(), tx.vout[i], state, true));
fFoundMint = true;
}
}
BOOST_CHECK(fFoundMint);
}
bool CheckZerocoinSpendNoDB(const CTransaction tx, std::string& strError)
{
//max needed non-mint outputs should be 2 - one for redemption address and a possible 2nd for change
if (tx.vout.size() > 2){
int outs = 0;
for (const CTxOut& out : tx.vout) {
if (out.IsZerocoinMint())
continue;
outs++;
}
if (outs > 2) {
strError = "CheckZerocoinSpend(): over two non-mint outputs in a zerocoinspend transaction";
return false;
}
}
//compute the txout hash that is used for the zerocoinspend signatures
CMutableTransaction txTemp;
for (const CTxOut& out : tx.vout) {
txTemp.vout.push_back(out);
}
// uint256 hashTxOut = txTemp.GetHash();
bool fValidated = false;
std::set<CBigNum> serials;
std::list<libzerocoin::CoinSpend> vSpends;
CAmount nTotalRedeemed = 0;
for (const CTxIn& txin : tx.vin) {
//only check txin that is a zcspend
if (!txin.IsZerocoinSpend())
continue;
// extract the CoinSpend from the txin
std::vector<char, zero_after_free_allocator<char> > dataTxIn;
dataTxIn.insert(dataTxIn.end(), txin.scriptSig.begin() + 4, txin.scriptSig.end());
CDataStream serializedCoinSpend(dataTxIn, SER_NETWORK, PROTOCOL_VERSION);
libzerocoin::ZerocoinParams* paramsAccumulator = Params().Zerocoin_Params(false);
libzerocoin::CoinSpend newSpend(Params().Zerocoin_Params(true), paramsAccumulator, serializedCoinSpend);
vSpends.push_back(newSpend);
//check that the denomination is valid
if (newSpend.getDenomination() == libzerocoin::ZQ_ERROR) {
strError = "Zerocoinspend does not have the correct denomination";
return false;
}
//check that denomination is what it claims to be in nSequence
if (newSpend.getDenomination() != txin.nSequence) {
strError = "Zerocoinspend nSequence denomination does not match CoinSpend";
}
//make sure the txout has not changed
// if (newSpend.getTxOutHash() != hashTxOut) {
// strError = "Zerocoinspend does not use the same txout that was used in the SoK";
// return false;
// }
// //see if we have record of the accumulator used in the spend tx
// CBigNum bnAccumulatorValue = 0;
// if (!GetAccumulatorValueFromChecksum(newSpend.getAccumulatorChecksum(), true, bnAccumulatorValue)) {
// strError = "Zerocoinspend could not find accumulator associated with checksum";
// return false;
// }
// libzerocoin::Accumulator accumulator(Params().Zerocoin_Params(true), newSpend.getDenomination(), bnAccumulatorValue);
// //Check that the coin is on the accumulator
// if (!newSpend.Verify(accumulator)) {
// strError = "CheckZerocoinSpend(): zerocoin spend did not verify";
// return false;
// }
if (serials.count(newSpend.getCoinSerialNumber())) {
strError = "Zerocoinspend serial is used twice in the same tx";
return false;
}
serials.insert(newSpend.getCoinSerialNumber());
//cannot check this without database
// if(!IsZerocoinSpendUnknown(newSpend, tx.GetHash(), state))
// return state.DoS(100, error("Zerocoinspend is already known"));
//make sure that there is no over redemption of coins
nTotalRedeemed += libzerocoin::ZerocoinDenominationToAmount(newSpend.getDenomination());
fValidated = true;
}
if (nTotalRedeemed < tx.GetValueOut()) {
strError = "Transaction spend more than was redeemed in zerocoins";
return false;
}
return fValidated;
}
BOOST_AUTO_TEST_CASE(checkzerocoinspend_test)
{
CBigNum bnTrustedModulus = 0;
if (!bnTrustedModulus)
bnTrustedModulus.SetDec(zerocoinModulus);
libzerocoin::ZerocoinParams zerocoinParams = libzerocoin::ZerocoinParams(bnTrustedModulus);
std::cout << "Running check_zerocoinspend_test...\n";
//load our serialized pubcoin
CBigNum bnpubcoin;
BOOST_CHECK_MESSAGE(bnpubcoin.SetHexBool(rawTxpub1), "Failed to set CBigNum from hex string");
libzerocoin::PublicCoin pubCoin(Params().Zerocoin_Params(true), bnpubcoin, libzerocoin::CoinDenomination::ZQ_ONE);
BOOST_CHECK_MESSAGE(pubCoin.validate(), "Failed to validate pubCoin created from hex string");
//initialize and Accumulator and AccumulatorWitness
libzerocoin::Accumulator accumulator(Params().Zerocoin_Params(false), libzerocoin::CoinDenomination::ZQ_ONE);
libzerocoin::AccumulatorWitness witness(Params().Zerocoin_Params(false), accumulator, pubCoin);
//populate the witness and accumulators
CValidationState state;
for(std::pair<std::string, std::string> raw : vecRawMints) {
CTransaction tx;
BOOST_CHECK_MESSAGE(DecodeHexTx(tx, raw.first), "Failed to deserialize hex transaction");
for(const CTxOut& out : tx.vout){
if(out.IsZerocoinMint()) {
libzerocoin::PublicCoin publicCoin(Params().Zerocoin_Params(true));
BOOST_CHECK_MESSAGE(TxOutToPublicCoin(out, publicCoin, state), "Failed to convert CTxOut " << out.ToString() << " to PublicCoin");
accumulator += publicCoin;
witness += publicCoin;
}
}
}
// Create a New Zerocoin with specific denomination given by pubCoin
libzerocoin::PrivateCoin privateCoin(Params().Zerocoin_Params(true), pubCoin.getDenomination());
privateCoin.setPublicCoin(pubCoin);
CBigNum bn = 0;
bn.SetHex(rawTxRand1);
privateCoin.setRandomness(bn);
CBigNum bn2 = 0;
bn2.SetHex(rawTxSerial1);
privateCoin.setSerialNumber(bn2);
privateCoin.setVersion(1);
//Get the checksum of the accumulator we use for the spend and also add it to our checksum map
uint32_t nChecksum = GetChecksum(accumulator.getValue());
//AddAccumulatorChecksum(nChecksum, accumulator.getValue(), true);
libzerocoin::CoinSpend coinSpend(Params().Zerocoin_Params(true), Params().Zerocoin_Params(false), privateCoin, accumulator, nChecksum, witness, 0, libzerocoin::SpendType::SPEND);
std::cout << coinSpend.ToString() << std::endl;
BOOST_CHECK_MESSAGE(coinSpend.Verify(accumulator), "Coinspend construction failed to create valid proof");
CBigNum serial = coinSpend.getCoinSerialNumber();
BOOST_CHECK_MESSAGE(serial, "Serial Number can't be 0");
libzerocoin::CoinDenomination denom = coinSpend.getDenomination();
BOOST_CHECK_MESSAGE(denom == pubCoin.getDenomination(), "Spend denomination must match original pubCoin");
BOOST_CHECK_MESSAGE(coinSpend.Verify(accumulator), "CoinSpend object failed to validate");
//serialize the spend
CDataStream serializedCoinSpend2(SER_NETWORK, PROTOCOL_VERSION);
bool fSerialize = true;
try {
serializedCoinSpend2 << coinSpend;
} catch (...) {
fSerialize = false;
}
BOOST_CHECK_MESSAGE(fSerialize, "failed to serialize coinspend object");
std::vector<unsigned char> data(serializedCoinSpend2.begin(), serializedCoinSpend2.end());
/** Check valid spend */
CTxIn newTxIn;
newTxIn.nSequence = 1;
newTxIn.scriptSig = CScript() << OP_ZEROCOINSPEND << data.size();
newTxIn.scriptSig.insert(newTxIn.scriptSig.end(), data.begin(), data.end());
newTxIn.prevout.SetNull();
// Deserialize the CoinSpend intro a fresh object
std::vector<char, zero_after_free_allocator<char> > dataTxIn;
dataTxIn.insert(dataTxIn.end(), newTxIn.scriptSig.begin() + 4, newTxIn.scriptSig.end());
CDataStream serializedCoinSpend(dataTxIn, SER_NETWORK, PROTOCOL_VERSION);
//old params for the V1 generated coin, new params for the accumulator. Emulates main-net transition.
libzerocoin::CoinSpend spend1(Params().Zerocoin_Params(true), Params().Zerocoin_Params(false), serializedCoinSpend);
BOOST_CHECK_MESSAGE(spend1.Verify(accumulator), "Failed deserialized check of CoinSpend");
CScript script;
CTxOut txOut(1 * COIN, script);
CTransaction txNew;
txNew.vin.push_back(newTxIn);
txNew.vout.push_back(txOut);
CTransaction txMintFrom;
BOOST_CHECK_MESSAGE(DecodeHexTx(txMintFrom, rawTx1), "Failed to deserialize hex transaction");
std::string strError = "";
if (!CheckZerocoinSpendNoDB(txNew, strError)) {
std::cout << state.GetRejectCode() << std::endl;
BOOST_CHECK_MESSAGE(false, strError);
}
/**check an overspend*/
CTxOut txOutOverSpend(100 * COIN, script);
CTransaction txOverSpend;
txOverSpend.vin.push_back(newTxIn);
txOverSpend.vout.push_back(txOutOverSpend);
strError = "";
CheckZerocoinSpendNoDB(txOverSpend, strError);
std::string str = "Failed to detect overspend. Error Message: " + strError;
BOOST_CHECK_MESSAGE(strError == "Transaction spend more than was redeemed in zerocoins", str);
std::cout << "checking v2 spend\n";
CMutableTransaction tx;
uint256 txHash = 0;
CTxIn in(txHash, 0);
tx.vin.emplace_back(in);
// Create a New Zerocoin with specific denomination given by pubCoin
libzerocoin::PrivateCoin privateCoin_v2(Params().Zerocoin_Params(false), libzerocoin::CoinDenomination::ZQ_ONE);
CKey key;
key.SetPrivKey(privateCoin.getPrivKey(), true);
BOOST_CHECK_MESSAGE(key.IsValid(), "Key is not valid");
libzerocoin::PublicCoin pubcoin_v2 = privateCoin_v2.getPublicCoin();
//initialize and Accumulator and AccumulatorWitness
libzerocoin::Accumulator accumulator_v2(Params().Zerocoin_Params(false), libzerocoin::CoinDenomination::ZQ_ONE);
libzerocoin::AccumulatorWitness witness_v2(Params().Zerocoin_Params(false), accumulator_v2, pubcoin_v2);
//populate the witness and accumulators - with old v1 params
int64_t nTimeStart = GetTimeMillis();
CValidationState state_v2;
for(int i = 0; i < 5; i++) {
libzerocoin::PrivateCoin privTemp(Params().Zerocoin_Params(true), libzerocoin::CoinDenomination::ZQ_ONE);
libzerocoin::PublicCoin pubTemp = privTemp.getPublicCoin();
accumulator_v2 += pubTemp;
witness_v2 += pubTemp;
}
std::cout << (GetTimeMillis() - nTimeStart)/5 << "ms per mint\n";
accumulator_v2 += pubcoin_v2;
//Get the checksum of the accumulator we use for the spend and also add it to our checksum map
uint32_t nChecksum_v2 = GetChecksum(accumulator_v2.getValue());
//AddAccumulatorChecksum(nChecksum_v2, accumulator_v2.getValue(), true);
uint256 ptxHash = CBigNum::randKBitBignum(256).getuint256();
libzerocoin::CoinSpend coinSpend_v2(Params().Zerocoin_Params(false), Params().Zerocoin_Params(false), privateCoin_v2, accumulator_v2, nChecksum_v2, witness_v2, ptxHash, libzerocoin::SpendType::SPEND);
BOOST_CHECK_MESSAGE(coinSpend_v2.HasValidSerial(Params().Zerocoin_Params(false)), "coinspend_v2 does not have a valid serial");
BOOST_CHECK_MESSAGE(coinSpend_v2.Verify(accumulator_v2), "coinspend_v2 failed to verify");
BOOST_CHECK_MESSAGE(coinSpend_v2.HasValidSignature(), "coinspend_v2 does not have valid signature");
BOOST_CHECK_MESSAGE(coinSpend_v2.getVersion() == 2, "coinspend_v2 version is wrong");
BOOST_CHECK_MESSAGE(coinSpend_v2.getPubKey() == privateCoin_v2.getPubKey(), "pub keys do not match");
}
BOOST_AUTO_TEST_CASE(setup_exceptions_test)
{
CBigNum bnTrustedModulus = 0;
if (!bnTrustedModulus)
bnTrustedModulus.SetDec(zerocoinModulus);
libzerocoin::ZerocoinParams zerocoinParams = libzerocoin::ZerocoinParams(bnTrustedModulus);
std::cout << "Running check_unitialized parameters,etc for setup exceptions...\n";
CBigNum bnpubcoin;
BOOST_CHECK(bnpubcoin.SetHexBool(rawTxpub1));
// Check Modulus > 1023 Exception
try {
libzerocoin::ZerocoinParams ZCParams(bnpubcoin);
BOOST_CHECK_MESSAGE(false, "Didn't catch exception: ZerocoinException: Modulus must be at least 1023 bit");
}
catch (...) {
BOOST_CHECK_MESSAGE(true, "Caught exception: ZerocoinException: Modulus must be at least 1023 bit");
}
// Check Security Level < 80 Exception
try {
libzerocoin::ZerocoinParams ZCParams(bnpubcoin,1);
BOOST_CHECK_MESSAGE(false, "Didn't catch exception: Security Level >= 80");
}
catch (...) {
BOOST_CHECK_MESSAGE(true, "Caught exception: ZerocoinException: Security Level >= 80");
}
// Check unitialized params Exception for PublicCoin
try {
zerocoinParams.initialized = false;
libzerocoin::PublicCoin pubCoin(&zerocoinParams);
BOOST_CHECK_MESSAGE(false, "Didn't catch exception checking for uninitialized Params");
}
catch (...) {
BOOST_CHECK_MESSAGE(true, "Caught exception checking for initalized Params");
}
// Check unitialized params Exception for PublicCoin (alternate constructor)
try {
zerocoinParams.initialized = false;
libzerocoin::PublicCoin pubCoin(&zerocoinParams);
BOOST_CHECK_MESSAGE(false, "Didn't catch exception checking for uninitialized Params");
}
catch (...) {
BOOST_CHECK_MESSAGE(true, "Caught exception checking for initalized Params");
}
// Check unitialized params Exception for PrivateCoin
try {
zerocoinParams.initialized = false;
libzerocoin::PrivateCoin privCoin(&zerocoinParams, libzerocoin::CoinDenomination::ZQ_ONE);
BOOST_CHECK_MESSAGE(false, "Didn't catch exception checking for uninitialized Params");
}
catch (...) {
BOOST_CHECK_MESSAGE(true, "Caught exception checking for initalized Params");
}
}
BOOST_AUTO_TEST_CASE(checksum_tests)
{
std::cout << "Running checksum_tests\n";
uint256 checksum;
uint32_t c1 = 0xa3219ef1;
uint32_t c2 = 0xabcdef00;
uint32_t c3 = 0x101029f3;
uint32_t c4 = 0xaaaaaeee;
uint32_t c5 = 0xffffffff;
uint32_t c6 = 0xbbbbbbbb;
uint32_t c7 = 0x11111111;
uint32_t c8 = 0xeeeeeeee;
std::vector<uint32_t> vChecksums {c1,c2,c3,c4,c5,c6,c7,c8};
for(uint32_t c : vChecksums)
checksum = checksum << 32 | c;
BOOST_CHECK_MESSAGE(checksum == uint256("a3219ef1abcdef00101029f3aaaaaeeeffffffffbbbbbbbb11111111eeeeeeee"), "checksum not properly concatenated");
int i = 0;
for (auto& denom : libzerocoin::zerocoinDenomList){
uint32_t checksumParsed = ParseChecksum(checksum, denom);
BOOST_CHECK_MESSAGE(checksumParsed == vChecksums[i], "checksum parse failed");
i++;
}
}
BOOST_AUTO_TEST_CASE(test_checkpoints)
{
BOOST_CHECK_MESSAGE(AccumulatorCheckpoints::LoadCheckpoints("main"), "failed to load checkpoints");
BOOST_CHECK_MESSAGE(AccumulatorCheckpoints::mapCheckpoints.at(1050020)
.at(libzerocoin::CoinDenomination::ZQ_FIVE_THOUSAND)
.GetHex() == "fad7cf992b67792695619224fbbe311c6e60bf80d5bc1680fd9e32b5b3f00f373c9305c72c82bfaf1ce56adb617dc71bb8ddaf61326858ae4b01c3acf443bc7d22d4d2c77704b44fbe4f4fd260f13e0e12e82c531c390e72770e1d444e0877844d35a76c1e45072ddf02e101cf9c0a05a125f19ac5205ee1216732f4040cc3e8a68528685f2f39325efb2b7ba4d681fe13aaabb80ef07d8de8ef883a07e0a4f9771e8c370924fe4959de3c2a6e6e7ad74b12dd7e666765d7d660febe4d4cab3f49cb33cb51e44f756eef609184d8eeeb1c4dfe13b123251166c877d8e992f60cefd568644918c3617aec4d5564a9fe008540add903b9739973838d667721f8d", "does not match");
}
BOOST_AUTO_TEST_CASE(deterministic_tests)
{
SelectParams(CBaseChainParams::UNITTEST);
std::cout << "Testing deterministic minting\n";
uint256 seedMaster("3a1947364362e2e7c073b386869c89c905c0cf462448ffd6c2021bd03ce689f6");
std::string strWalletFile = "unittestwallet.dat";
CWalletDB walletdb(strWalletFile, "cr+");
CWallet wallet(strWalletFile);
CzPNYWallet zWallet(wallet.strWalletFile);
zWallet.SetMasterSeed(seedMaster);
wallet.setZWallet(&zWallet);
int64_t nTimeStart = GetTimeMillis();
libzerocoin::CoinDenomination denom = libzerocoin::CoinDenomination::ZQ_FIFTY;
std::vector<libzerocoin::PrivateCoin> vCoins;
int nTests = 50;
for (int i = 0; i < nTests; i++) {
libzerocoin::PrivateCoin coin(Params().Zerocoin_Params(false), denom, false);
CDeterministicMint dMint;
zWallet.GenerateDeterministicZPNY(denom, coin, dMint);
vCoins.emplace_back(coin);
}
int64_t nTotalTime = GetTimeMillis() - nTimeStart;
std::cout << "Total time:" << nTotalTime << "ms. Per Deterministic Mint:" << (nTotalTime/nTests) << "ms" << std::endl;
std::cout << "Checking that mints are valid" << std::endl;
CDataStream ss(SER_GETHASH, 0);
for (libzerocoin::PrivateCoin& coin : vCoins) {
BOOST_CHECK_MESSAGE(coin.IsValid(), "Generated Mint is not valid");
ss << coin.getPublicCoin().getValue();
}
std::cout << "Checking that mints are deterministic: sha256 checksum=";
uint256 hash = Hash(ss.begin(), ss.end());
std::cout << hash.GetHex() << std::endl;
BOOST_CHECK_MESSAGE(hash == uint256("c90c225f2cbdee5ef053b1f9f70053dd83724c58126d0e1b8425b88091d1f73f"), "minting determinism isn't as expected");
}
BOOST_AUTO_TEST_SUITE_END()
|
/* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE415_Double_Free__new_delete_wchar_t_66b.cpp
Label Definition File: CWE415_Double_Free__new_delete.label.xml
Template File: sources-sinks-66b.tmpl.cpp
*/
/*
* @description
* CWE: 415 Double Free
* BadSource: Allocate data using new and Deallocae data using delete
* GoodSource: Allocate data using new
* Sinks:
* GoodSink: do nothing
* BadSink : Deallocate data using delete
* Flow Variant: 66 Data flow: data passed in an array from one function to another in different source files
*
* */
#include "std_testcase.h"
#include <wchar.h>
namespace CWE415_Double_Free__new_delete_wchar_t_66
{
#ifndef OMITBAD
void bad_sink(wchar_t * data_array[])
{
/* copy data out of data_array */
wchar_t * data = data_array[2];
/* POTENTIAL FLAW: Possibly deleting memory twice */
delete data;
}
#endif /* OMITBAD */
#ifndef OMITGOOD
/* goodG2B uses the GoodSource with the BadSink */
void goodG2B_sink(wchar_t * data_array[])
{
wchar_t * data = data_array[2];
/* POTENTIAL FLAW: Possibly deleting memory twice */
delete data;
}
/* goodB2G uses the BadSource with the GoodSink */
void goodB2G_sink(wchar_t * data_array[])
{
wchar_t * data = data_array[2];
/* do nothing */
/* FIX: Don't attempt to delete the memory */
; /* empty statement needed for some flow variants */
}
#endif /* OMITGOOD */
} // close namespace
|
/*----------------------------------------------------------------------
----------------------------------------------------------------------*/
#include "EmbeddedRootSource.h"
#include "InputFile.h"
#include "RunHelper.h"
#include "RootEmbeddedFileSequence.h"
#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
#include "FWCore/Sources/interface/VectorInputSourceDescription.h"
namespace edm {
class EventID;
class EventPrincipal;
EmbeddedRootSource::EmbeddedRootSource(ParameterSet const& pset, VectorInputSourceDescription const& desc)
: VectorInputSource(pset, desc),
rootServiceChecker_(),
nStreams_(desc.allocations_->numberOfStreams()),
// The default value provided as the second argument to the getUntrackedParameter function call
// is not used when the ParameterSet has been validated and the parameters are not optional
// in the description. This is currently true when PoolSource is the primary input source.
// The modules that use PoolSource as a SecSource have not defined their fillDescriptions function
// yet, so the ParameterSet does not get validated yet. As soon as all the modules with a SecSource
// have defined descriptions, the defaults in the getUntrackedParameterSet function calls can
// and should be deleted from the code.
//
skipBadFiles_(pset.getUntrackedParameter<bool>("skipBadFiles", false)),
bypassVersionCheck_(pset.getUntrackedParameter<bool>("bypassVersionCheck", false)),
treeMaxVirtualSize_(pset.getUntrackedParameter<int>("treeMaxVirtualSize", -1)),
productSelectorRules_(pset, "inputCommands", "InputSource"),
runHelper_(new DefaultRunHelper()),
catalog_(pset.getUntrackedParameter<std::vector<std::string> >("fileNames"),
pset.getUntrackedParameter<std::string>("overrideCatalog", std::string())),
// Note: fileSequence_ needs to be initialized last, because it uses data members
// initialized previously in its own initialization.
fileSequence_(new RootEmbeddedFileSequence(pset, *this, catalog_)) {}
EmbeddedRootSource::~EmbeddedRootSource() {}
void EmbeddedRootSource::beginJob() {}
void EmbeddedRootSource::endJob() {
fileSequence_->endJob();
InputFile::reportReadBranches();
}
void EmbeddedRootSource::closeFile_() { fileSequence_->closeFile(); }
bool EmbeddedRootSource::readOneEvent(EventPrincipal& cache,
size_t& fileNameHash,
CLHEP::HepRandomEngine* engine,
EventID const* id,
bool recycleFiles) {
return fileSequence_->readOneEvent(cache, fileNameHash, engine, id, recycleFiles);
}
void EmbeddedRootSource::readOneSpecified(EventPrincipal& cache,
size_t& fileNameHash,
SecondaryEventIDAndFileInfo const& id) {
fileSequence_->readOneSpecified(cache, fileNameHash, id);
}
void EmbeddedRootSource::dropUnwantedBranches_(std::vector<std::string> const& wantedBranches) {
std::vector<std::string> rules;
rules.reserve(wantedBranches.size() + 1);
rules.emplace_back("drop *");
for (std::string const& branch : wantedBranches) {
rules.push_back("keep " + branch + "_*");
}
ParameterSet pset;
pset.addUntrackedParameter("inputCommands", rules);
productSelectorRules_ = ProductSelectorRules(pset, "inputCommands", "InputSource");
}
void EmbeddedRootSource::fillDescriptions(ConfigurationDescriptions& descriptions) {
ParameterSetDescription desc;
std::vector<std::string> defaultStrings;
desc.setComment("Reads EDM/Root files for mixing.");
desc.addUntracked<std::vector<std::string> >("fileNames")->setComment("Names of files to be processed.");
desc.addUntracked<std::string>("overrideCatalog", std::string());
desc.addUntracked<bool>("skipBadFiles", false)
->setComment(
"True: Ignore any missing or unopenable input file.\n"
"False: Throw exception if missing or unopenable input file.");
desc.addUntracked<bool>("bypassVersionCheck", false)
->setComment(
"True: Bypass release version check.\n"
"False: Throw exception if reading file in a release prior to the release in which the file was written.");
desc.addUntracked<int>("treeMaxVirtualSize", -1)
->setComment("Size of ROOT TTree TBasket cache. Affects performance.");
ProductSelectorRules::fillDescription(desc, "inputCommands");
RootEmbeddedFileSequence::fillDescription(desc);
descriptions.add("source", desc);
}
} // namespace edm
|
// job.cpp : Implementation of DLL Exports.
// You will need the NT SUR Beta 2 SDK or VC 4.2 in order to build this
// project. This is because you will need MIDL 3.00.15 or higher and new
// headers and libs. If you have VC 4.2 installed, then everything should
// already be configured correctly.
// Note: Proxy/Stub Information
// To merge the proxy/stub code into the object DLL, add the file
// dlldatax.c to the project. Make sure precompiled headers
// are turned off for this file, and add _MERGE_PROXYSTUB to the
// defines for the project.
//
// Modify the custom build rule for job.idl by adding the following
// files to the Outputs. You can select all of the .IDL files by
// expanding each project and holding Ctrl while clicking on each of them.
// job_p.c
// dlldata.c
// To build a separate proxy/stub DLL,
// run nmake -f jobps.mak in the project directory.
#include "stdafx.h"
#include "resource.h"
#include "initguid.h"
#include "wsb.h"
#include "fsa.h"
#include "job.h"
#include "task.h"
#include "hsmcrit.h"
#include "hsmactn.h"
#include "hsmacrsc.h"
#include "hsmjob.h"
#include "hsmjobcx.h"
#include "hsmjobdf.h"
#include "hsmjobwi.h"
#include "hsmphase.h"
#include "hsmpolcy.h"
#include "hsmrule.h"
#include "hsmrlstk.h"
#include "hsmscan.h"
#include "hsmsess.h"
#include "hsmsesst.h"
#include "dlldatax.h"
#ifdef _MERGE_PROXYSTUB
extern "C" HINSTANCE hProxyDll;
#endif
CComModule _Module;
BEGIN_OBJECT_MAP(ObjectMap)
OBJECT_ENTRY(CLSID_CHsmActionCopy, CHsmActionCopy)
OBJECT_ENTRY(CLSID_CHsmActionDelete, CHsmActionDelete)
OBJECT_ENTRY(CLSID_CHsmActionManage, CHsmActionManage)
OBJECT_ENTRY(CLSID_CHsmActionMigrate, CHsmActionMigrate)
OBJECT_ENTRY(CLSID_CHsmActionMove, CHsmActionMove)
OBJECT_ENTRY(CLSID_CHsmActionOnResourcePreUnmanage, CHsmActionOnResourcePreUnmanage)
OBJECT_ENTRY(CLSID_CHsmActionOnResourcePostUnmanage, CHsmActionOnResourcePostUnmanage)
OBJECT_ENTRY(CLSID_CHsmActionOnResourcePreScanUnmanage, CHsmActionOnResourcePreScanUnmanage)
OBJECT_ENTRY(CLSID_CHsmActionOnResourcePostValidate, CHsmActionOnResourcePostValidate)
OBJECT_ENTRY(CLSID_CHsmActionOnResourcePreValidate, CHsmActionOnResourcePreValidate)
OBJECT_ENTRY(CLSID_CHsmActionRecall, CHsmActionRecall)
OBJECT_ENTRY(CLSID_CHsmActionRecycle, CHsmActionRecycle)
OBJECT_ENTRY(CLSID_CHsmActionTruncate, CHsmActionTruncate)
OBJECT_ENTRY(CLSID_CHsmActionUnmanage, CHsmActionUnmanage)
OBJECT_ENTRY(CLSID_CHsmActionValidate, CHsmActionValidate)
OBJECT_ENTRY(CLSID_CHsmCritAccessTime, CHsmCritAccessTime)
OBJECT_ENTRY(CLSID_CHsmCritAlways, CHsmCritAlways)
OBJECT_ENTRY(CLSID_CHsmCritCompressed, CHsmCritCompressed)
OBJECT_ENTRY(CLSID_CHsmCritLinked, CHsmCritLinked)
OBJECT_ENTRY(CLSID_CHsmCritMbit, CHsmCritMbit)
OBJECT_ENTRY(CLSID_CHsmCritManageable, CHsmCritManageable)
OBJECT_ENTRY(CLSID_CHsmCritMigrated, CHsmCritMigrated)
OBJECT_ENTRY(CLSID_CHsmCritPremigrated, CHsmCritPremigrated)
OBJECT_ENTRY(CLSID_CHsmCritGroup, CHsmCritGroup)
OBJECT_ENTRY(CLSID_CHsmCritLogicalSize, CHsmCritLogicalSize)
OBJECT_ENTRY(CLSID_CHsmCritModifyTime, CHsmCritModifyTime)
OBJECT_ENTRY(CLSID_CHsmCritOwner, CHsmCritOwner)
OBJECT_ENTRY(CLSID_CHsmCritPhysicalSize, CHsmCritPhysicalSize)
OBJECT_ENTRY(CLSID_CHsmJob, CHsmJob)
OBJECT_ENTRY(CLSID_CHsmJobContext, CHsmJobContext)
OBJECT_ENTRY(CLSID_CHsmJobDef, CHsmJobDef)
OBJECT_ENTRY(CLSID_CHsmJobWorkItem, CHsmJobWorkItem)
OBJECT_ENTRY(CLSID_CHsmPhase, CHsmPhase)
OBJECT_ENTRY(CLSID_CHsmPolicy, CHsmPolicy)
OBJECT_ENTRY(CLSID_CHsmRule, CHsmRule)
OBJECT_ENTRY(CLSID_CHsmRuleStack, CHsmRuleStack)
OBJECT_ENTRY(CLSID_CHsmScanner, CHsmScanner)
OBJECT_ENTRY(CLSID_CHsmSession, CHsmSession)
OBJECT_ENTRY(CLSID_CHsmSessionTotals, CHsmSessionTotals)
END_OBJECT_MAP()
/////////////////////////////////////////////////////////////////////////////
// DLL Entry Point
extern "C"
BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
{
lpReserved;
#ifdef _MERGE_PROXYSTUB
if (!PrxDllMain(hInstance, dwReason, lpReserved))
return FALSE;
#endif
if (dwReason == DLL_PROCESS_ATTACH)
{
_Module.Init(ObjectMap, hInstance);
DisableThreadLibraryCalls(hInstance);
}
else if (dwReason == DLL_PROCESS_DETACH)
_Module.Term();
return TRUE; // ok
}
/////////////////////////////////////////////////////////////////////////////
// Used to determine whether the DLL can be unloaded by OLE
STDAPI DllCanUnloadNow(void)
{
#ifdef _MERGE_PROXYSTUB
if (PrxDllCanUnloadNow() != S_OK)
return S_FALSE;
#endif
return (_Module.GetLockCount()==0) ? S_OK : S_FALSE;
}
/////////////////////////////////////////////////////////////////////////////
// Returns a class factory to create an object of the requested type
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
{
#ifdef _MERGE_PROXYSTUB
if (PrxDllGetClassObject(rclsid, riid, ppv) == S_OK)
return S_OK;
#endif
return _Module.GetClassObject(rclsid, riid, ppv);
}
/////////////////////////////////////////////////////////////////////////////
// DllRegisterServer - Adds entries to the system registry
STDAPI DllRegisterServer(void)
{
HRESULT hr;
#ifdef _MERGE_PROXYSTUB
HRESULT hRes = PrxDllRegisterServer();
if (FAILED(hRes))
return hRes;
#endif
// registers object, typelib and all interfaces in typelib
// Not registering the Type Library right now
hr = CoInitialize( 0 );
if (SUCCEEDED(hr)) {
hr = _Module.RegisterServer( FALSE );
CoUninitialize( );
}
return( hr );
}
/////////////////////////////////////////////////////////////////////////////
// DllUnregisterServer - Removes entries from the system registry
STDAPI DllUnregisterServer(void)
{
HRESULT hr;
#ifdef _MERGE_PROXYSTUB
PrxDllUnregisterServer();
#endif
hr = CoInitialize( 0 );
if (SUCCEEDED(hr)) {
_Module.UnregisterServer();
CoUninitialize( );
hr = S_OK;
}
return( hr );
}
|
#pragma once
#include <temperaturesensor.h>
#include <ventilator.h>
#include <demo.h>
#include <math.h>
#include <algorithm>
/** very simple oven simulation
* airflow == temperature
*/
#define NUMBERS_SIZE 10000
class Oven {
virtual void handle(const uint32_t millis) = 0;
virtual void lidOpen(bool lo) = 0;
virtual void airFlow(float flow) = 0;
virtual float temperature() = 0;
};
class briquette {
float s_maxBurnTime = 1800.0;
float m_potentialEnergy = s_maxBurnTime;
float m_burnRate = 0.0;
uint32_t m_time = 0;
float m_lastAirFlow = -1;
float m_lastAlpha = 0;
bool m_isBurning = true;
bool m_up = true;
float m_alphaAdjust = 1.0f;
public:
float handle(float airFlow) {
assert(airFlow >= 0.0f && airFlow <= 100.0f);
if (!m_isBurning) {
return 0.0f;
}
if (airFlow > m_lastAirFlow) {
m_up = true;
m_lastAlpha = 0.004 * m_alphaAdjust;
} else if (airFlow < m_lastAirFlow) {
m_up = false;
m_lastAlpha = 0.002 * m_alphaAdjust;
}
m_lastAirFlow = airFlow;
// maps airflow from 0..1
float af = fmap(airFlow, 0.0f, 100.0f, 0.0f, 1.0f);
// maps burn potential from 0..2 so we can put it in
// https://www.wolframalpha.com/input/?i=plot+-%28x-1%29%5E8%2B1+from+-0.1+to+2
// currentBurn is 0..1
float burnPotential = fmap(m_potentialEnergy, 0.0f, s_maxBurnTime, 0.1f, 1.9f);
float currentBurn = (-pow(burnPotential - 1, 4) + 1.0f) * af;
if (m_up) {
m_burnRate = (m_burnRate + (currentBurn - m_burnRate) * m_lastAlpha) * 1.0f;
} else {
m_burnRate = (m_burnRate + (0.0f - m_burnRate) * m_lastAlpha) * 1.0f;
}
// https://www.wolframalpha.com/input/?i=plot+1%2F%281+%2B+2%5E%28-x%29%29+from+-10+to10
// Reduce energy
if (m_burnRate >= 1.0f) {
m_burnRate = 1.0f;
}
if (m_burnRate < 0) {
m_burnRate = 0.0f;
}
m_potentialEnergy = m_potentialEnergy - m_burnRate;
if (m_potentialEnergy < 0) {
m_potentialEnergy = 0;
}
return m_burnRate;
}
void startBurn() {
m_isBurning = true;
}
void alphaAdjust(float aa) {
m_alphaAdjust = aa;
}
static float fmap(float value, float in_min, float in_max, float out_min, float out_max) {
return (value - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
};
class MockedOven : public Oven {
private:
std::vector<briquette> briqettes;
float m_AirFlow = 0.0;
float m_temperature;
bool m_lidOpen;
int m_totalBriqettes = 8;
int m_maxBriqettes = 15;
uint32_t lastTIme = 0;
public:
MockedOven() {
briqettes.resize(m_totalBriqettes);
}
void handle(const uint32_t millis) {
if (millis - lastTIme > 900 * 1000) {
lastTIme = millis;
m_totalBriqettes = m_totalBriqettes + 1;
if (m_totalBriqettes >= m_maxBriqettes) {
m_totalBriqettes = m_maxBriqettes;
} else {
briqettes.resize(m_totalBriqettes);
}
}
m_temperature = 0.0;
for (auto& value : briqettes) {
float flow = (rand() % 20) - 10.f + m_AirFlow;
if (flow < 0) {
flow = 0;
}
if (flow > 100) {
flow = 100;
}
m_temperature += value.handle(flow) * 1.8f;
}
// Temperure is now 0..m_totalBriqettes
// https://www.wolframalpha.com/input/?i=plot+1%2F%281+%2B+2%5E%28-x%29%29+from+-10+to10
float bMapped = briquette::fmap(m_totalBriqettes, 0.0f, m_maxBriqettes, -10.0f, 10.0f);
float maxTempTotalOvenCoef = 1.0f / (1.0f + pow(2.0f, -bMapped));
m_temperature = (250.0f / m_maxBriqettes) * m_temperature * maxTempTotalOvenCoef;
}
void lidOpen(bool lo) {
m_lidOpen = true;
}
void airFlow(float flow) {
m_AirFlow = flow;
}
float temperature() {
return m_temperature;
}
};
|
#include <catch/catch.hpp>
#include "utils.h"
#include <tcp/EchoServer.h>
#include <tcp/TCPClient.h>
using namespace tcp;
namespace tests {
TEST_CASE("Test send and receive on echo server", "[tcp]") {
cleanSystem();
// Use different ports to make sure there's no conflicts
int port;
std::string host = "127.0.0.1";
std::vector<uint8_t> requestBytes;
TCPMessage m;
m.type = 1;
SECTION("Some data") {
port = 8006;
requestBytes = {0, 1, 2, 3, 4};
m.len = requestBytes.size();
m.buffer = requestBytes.data();
}
SECTION("No data") {
port = 8007;
// Don't set other fields on message to check defaults
}
// Run an echo server in a thread
std::thread serverThread([port] {
util::getLogger()->debug("Starting echo server thread");
EchoServer server(port);
int nMsgs = 0;
while (nMsgs == 0) {
nMsgs += server.poll();
}
server.close();
});
// Let the server start
usleep(1000 * 100);
// Send request with client
TCPClient client(host, port);
client.sendMessage(&m);
// Receive response
TCPMessage *r = client.recvMessage();
std::vector<uint8_t> actualRecv(r->buffer, r->buffer + r->len);
REQUIRE(actualRecv == requestBytes);
// Let server thread finish
if (serverThread.joinable()) {
serverThread.join();
}
}
}
|
#pragma once
#include <type_traits>
namespace Ubpa::UECS {
class Entity;
class EntityLocator;
class World;
}
namespace Ubpa::UECS {
template<typename Cmpt> struct RemoveTag : IType<Cmpt> {}; // default
template<typename Cmpt> struct RemoveTag<const Cmpt*> : IType<Cmpt> {};
template<typename Cmpt> struct RemoveTag<Cmpt*> : IType<Cmpt> {};
template<typename Cmpt> struct RemoveTag<LastFrame<Cmpt>> : IType<Cmpt> {};
template<typename T> struct DecayTag : IType<T> {};
template<typename Cmpt> struct DecayTag<const Cmpt*> : IType<Cmpt*> {};
template<typename Cmpt> struct DecayTag<LastFrame<Cmpt>> : IType<Cmpt*> {};
template<typename T> struct DecayTag<const T> : IType<T> {};
template<typename TaggedCmpt> struct IsLastFrame : std::false_type {};
template<typename Cmpt> struct IsLastFrame<LastFrame<Cmpt>> : std::true_type {};
template<typename TaggedCmpt> struct IsWrite : std::false_type {};
template<typename Cmpt> struct IsWrite<const Cmpt*> : std::false_type {};
template<typename Cmpt> struct IsWrite<Cmpt*> : std::true_type {};
template<> struct IsWrite<World*> : std::false_type {};
template<typename TaggedCmpt> struct IsLatest : std::false_type {};
template<typename Cmpt> struct IsLatest<const Cmpt*> : std::true_type {};
template<> struct IsLatest<const World*> : std::false_type {};
template<typename TaggedCmpt> struct IsTimePoint :
IValue<bool, IsWrite_v<TaggedCmpt> || IsLastFrame_v<TaggedCmpt> || IsLatest_v<TaggedCmpt>> {};
}
|
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
#include "olap/schema_change.h"
#include <gtest/gtest.h>
#include "olap/byte_buffer.h"
#include "olap/field.h"
#include "olap/olap_common.h"
#include "olap/olap_define.h"
#include "olap/row_block.h"
#include "olap/row_cursor.h"
#include "olap/rowset/column_reader.h"
#include "olap/rowset/column_writer.h"
#include "olap/stream_name.h"
#include "runtime/mem_pool.h"
#include "runtime/vectorized_row_batch.h"
#include "util/logging.h"
using std::string;
namespace doris {
class TestColumn : public testing::Test {
public:
TestColumn() : _column_writer(nullptr), _column_reader(nullptr), _stream_factory(nullptr) {
_offsets.clear();
_map_in_streams.clear();
_present_buffers.clear();
_data_buffers.clear();
_second_buffers.clear();
_dictionary_buffers.clear();
_length_buffers.clear();
_mem_tracker.reset(new MemTracker(-1));
_mem_pool.reset(new MemPool(_mem_tracker.get()));
}
virtual ~TestColumn() {
SAFE_DELETE(_column_writer);
SAFE_DELETE(_column_reader);
SAFE_DELETE(_stream_factory);
}
virtual void SetUp() {
_offsets.push_back(0);
_stream_factory = new (std::nothrow)
OutStreamFactory(COMPRESS_LZ4, OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE);
ASSERT_TRUE(_stream_factory != nullptr);
config::column_dictionary_key_ratio_threshold = 30;
config::column_dictionary_key_size_threshold = 1000;
}
virtual void TearDown() {
SAFE_DELETE(_column_writer);
SAFE_DELETE(_column_reader);
SAFE_DELETE(_stream_factory);
SAFE_DELETE(_shared_buffer);
_offsets.clear();
for (auto in_stream : _map_in_streams) {
delete in_stream.second;
}
_map_in_streams.clear();
_present_buffers.clear();
_data_buffers.clear();
_second_buffers.clear();
_dictionary_buffers.clear();
_length_buffers.clear();
}
void create_column_writer(const TabletSchema& tablet_schema) {
_column_writer = ColumnWriter::create(0, tablet_schema, _stream_factory, 1024,
BLOOM_FILTER_DEFAULT_FPP);
ASSERT_TRUE(_column_writer != nullptr);
ASSERT_EQ(_column_writer->init(), OLAP_SUCCESS);
}
void create_column_reader(const TabletSchema& tablet_schema) {
UniqueIdEncodingMap encodings;
encodings[0] = ColumnEncodingMessage();
encodings[0].set_kind(ColumnEncodingMessage::DIRECT);
encodings[0].set_dictionary_size(1);
create_column_reader(tablet_schema, encodings);
}
void create_column_reader(const TabletSchema& tablet_schema, UniqueIdEncodingMap& encodings) {
UniqueIdToColumnIdMap included;
included[0] = 0;
UniqueIdToColumnIdMap segment_included;
segment_included[0] = 0;
SAFE_DELETE(_column_reader);
_column_reader =
ColumnReader::create(0, tablet_schema, included, segment_included, encodings);
ASSERT_TRUE(_column_reader != nullptr);
system("mkdir -p ./ut_dir");
system("rm ./ut_dir/tmp_file");
ASSERT_EQ(OLAP_SUCCESS,
helper.open_with_mode("./ut_dir/tmp_file", O_CREAT | O_EXCL | O_WRONLY,
S_IRUSR | S_IWUSR));
std::vector<int> off;
std::vector<int> length;
std::vector<int> buffer_size;
std::vector<StreamName> name;
std::map<StreamName, OutStream*>::const_iterator it = _stream_factory->streams().begin();
for (; it != _stream_factory->streams().end(); ++it) {
StreamName stream_name = it->first;
OutStream* out_stream = it->second;
std::vector<StorageByteBuffer*>* buffers = nullptr;
if (out_stream->is_suppressed()) {
continue;
}
if (stream_name.kind() == StreamInfoMessage::ROW_INDEX) {
continue;
} else if (stream_name.kind() == StreamInfoMessage::PRESENT) {
buffers = &_present_buffers;
} else if (stream_name.kind() == StreamInfoMessage::DATA) {
buffers = &_data_buffers;
} else if (stream_name.kind() == StreamInfoMessage::SECONDARY) {
buffers = &_second_buffers;
} else if (stream_name.kind() == StreamInfoMessage::DICTIONARY_DATA) {
buffers = &_dictionary_buffers;
} else if (stream_name.kind() == StreamInfoMessage::LENGTH) {
buffers = &_length_buffers;
} else {
ASSERT_TRUE(false);
}
ASSERT_TRUE(buffers != nullptr);
off.push_back(helper.tell());
out_stream->write_to_file(&helper, 0);
length.push_back(out_stream->get_stream_length());
buffer_size.push_back(out_stream->get_total_buffer_size());
name.push_back(stream_name);
}
helper.close();
ASSERT_EQ(OLAP_SUCCESS,
helper.open_with_mode("./ut_dir/tmp_file", O_RDONLY, S_IRUSR | S_IWUSR));
SAFE_DELETE(_shared_buffer);
_shared_buffer = StorageByteBuffer::create(OLAP_DEFAULT_COLUMN_STREAM_BUFFER_SIZE +
sizeof(StreamHead));
ASSERT_TRUE(_shared_buffer != nullptr);
for (auto in_stream : _map_in_streams) {
delete in_stream.second;
}
_map_in_streams.clear();
for (int i = 0; i < off.size(); ++i) {
ReadOnlyFileStream* in_stream = new (std::nothrow)
ReadOnlyFileStream(&helper, &_shared_buffer, off[i], length[i], lz4_decompress,
buffer_size[i], &_stats);
ASSERT_EQ(OLAP_SUCCESS, in_stream->init());
_map_in_streams[name[i]] = in_stream;
}
ASSERT_EQ(_column_reader->init(&_map_in_streams, 1024, _mem_pool.get(), &_stats),
OLAP_SUCCESS);
}
void set_tablet_schema(const std::string& name, const std::string& type,
const std::string& aggregation, uint32_t length, bool is_allow_null,
bool is_key, TabletSchema* tablet_schema) {
TabletSchemaPB tablet_schema_pb;
ColumnPB* column = tablet_schema_pb.add_column();
column->set_unique_id(0);
column->set_name(name);
column->set_type(type);
column->set_is_key(is_key);
column->set_is_nullable(is_allow_null);
column->set_length(length);
column->set_aggregation(aggregation);
tablet_schema->init_from_pb(tablet_schema_pb);
}
void create_and_save_last_position() {
ASSERT_EQ(_column_writer->create_row_index_entry(), OLAP_SUCCESS);
}
template <typename T>
void test_convert_to_varchar(const std::string& type_name, int type_size, T val,
const std::string& expected_val, OLAPStatus expected_st,
int varchar_len = 255) {
TabletSchema src_tablet_schema;
set_tablet_schema("ConvertColumn", type_name, "REPLACE", type_size, false, false,
&src_tablet_schema);
create_column_writer(src_tablet_schema);
RowCursor write_row;
write_row.init(src_tablet_schema);
RowBlock block(&src_tablet_schema);
RowBlockInfo block_info;
block_info.row_num = 10000;
block.init(block_info);
write_row.set_field_content(0, reinterpret_cast<char*>(&val), _mem_pool.get());
block.set_row(0, write_row);
block.finalize(1);
ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
helper.close();
TabletSchema dst_tablet_schema;
set_tablet_schema("VarcharColumn", "VARCHAR", "REPLACE", varchar_len, false, false,
&dst_tablet_schema);
create_column_reader(src_tablet_schema);
RowCursor read_row;
read_row.init(dst_tablet_schema);
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS);
char* data = reinterpret_cast<char*>(_col_vector->col_data());
auto st = read_row.convert_from(0, data, write_row.column_schema(0)->type_info().get(),
_mem_pool.get());
ASSERT_EQ(st, expected_st);
if (st == OLAP_SUCCESS) {
std::string dst_str = read_row.column_schema(0)->to_string(read_row.cell_ptr(0));
ASSERT_TRUE(dst_str.compare(0, expected_val.size(), expected_val) == 0);
}
auto tp = get_type_info(OLAP_FIELD_TYPE_HLL);
st = read_row.convert_from(0, read_row.cell_ptr(0), tp.get(), _mem_pool.get());
ASSERT_EQ(st, OLAP_ERR_INVALID_SCHEMA);
}
void test_convert_from_varchar(const std::string& type_name, int type_size,
const std::string& value, OLAPStatus expected_st) {
TabletSchema tablet_schema;
set_tablet_schema("VarcharColumn", "VARCHAR", "REPLACE", 255, false, false, &tablet_schema);
create_column_writer(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
RowBlock block(&tablet_schema);
RowBlockInfo block_info;
block_info.row_num = 10000;
block.init(block_info);
Slice normal_str(value);
write_row.set_field_content(0, reinterpret_cast<char*>(&normal_str), _mem_pool.get());
block.set_row(0, write_row);
block.finalize(1);
ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
helper.close();
TabletSchema converted_tablet_schema;
set_tablet_schema("ConvertColumn", type_name, "REPLACE", type_size, false, false,
&converted_tablet_schema);
create_column_reader(tablet_schema);
RowCursor read_row;
read_row.init(converted_tablet_schema);
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS);
char* data = reinterpret_cast<char*>(_col_vector->col_data());
auto st = read_row.convert_from(0, data, write_row.column_schema(0)->type_info().get(),
_mem_pool.get());
ASSERT_EQ(st, expected_st);
if (st == OLAP_SUCCESS) {
std::string dst_str = read_row.column_schema(0)->to_string(read_row.cell_ptr(0));
ASSERT_TRUE(dst_str.compare(0, value.size(), value) == 0);
}
auto tp = get_scalar_type_info(OLAP_FIELD_TYPE_HLL);
st = read_row.convert_from(0, read_row.cell_ptr(0), tp.get(), _mem_pool.get());
ASSERT_EQ(st, OLAP_ERR_INVALID_SCHEMA);
}
ColumnWriter* _column_writer;
ColumnReader* _column_reader;
std::shared_ptr<MemTracker> _mem_tracker;
std::unique_ptr<MemPool> _mem_pool;
std::unique_ptr<ColumnVector> _col_vector;
OutStreamFactory* _stream_factory;
std::vector<size_t> _offsets;
std::vector<StorageByteBuffer*> _present_buffers;
std::vector<StorageByteBuffer*> _data_buffers;
std::vector<StorageByteBuffer*> _second_buffers;
std::vector<StorageByteBuffer*> _dictionary_buffers;
std::vector<StorageByteBuffer*> _length_buffers;
StorageByteBuffer* _shared_buffer = nullptr;
std::map<StreamName, ReadOnlyFileStream*> _map_in_streams;
FileHandler helper;
OlapReaderStatistics _stats;
};
TEST_F(TestColumn, ConvertFloatToDouble) {
TabletSchema tablet_schema;
set_tablet_schema("FloatColumn", "FLOAT", "REPLACE", 4, false, false, &tablet_schema);
create_column_writer(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
RowBlock block(&tablet_schema);
RowBlockInfo block_info;
block_info.row_num = 10000;
block.init(block_info);
float value = 1.234;
write_row.set_field_content(0, reinterpret_cast<char*>(&value), _mem_pool.get());
block.set_row(0, write_row);
block.finalize(1);
ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS);
value = 3.234;
write_row.set_field_content(0, reinterpret_cast<char*>(&value), _mem_pool.get());
block.set_row(0, write_row);
block.finalize(1);
ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
TabletSchema convert_tablet_schema;
set_tablet_schema("DoubleColumn", "DOUBLE", "REPLACE", 4, false, false, &convert_tablet_schema);
create_column_reader(tablet_schema);
RowCursor read_row;
read_row.init(convert_tablet_schema);
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 2, _mem_pool.get()), OLAP_SUCCESS);
char* data = reinterpret_cast<char*>(_col_vector->col_data());
read_row.convert_from(0, data, write_row.column_schema(0)->type_info().get(), _mem_pool.get());
//float val1 = *reinterpret_cast<float*>(read_row.cell_ptr(0));
double val2 = *reinterpret_cast<double*>(read_row.cell_ptr(0));
char buf[64];
memset(buf, 0, sizeof(buf));
sprintf(buf, "%f", val2);
char* tg;
double v2 = strtod(buf, &tg);
ASSERT_EQ(v2, 1.234);
//test not support type
auto tp = get_scalar_type_info(OLAP_FIELD_TYPE_HLL);
OLAPStatus st = read_row.convert_from(0, data, tp.get(), _mem_pool.get());
ASSERT_TRUE(st == OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertDatetimeToDate) {
TabletSchema tablet_schema;
set_tablet_schema("DatetimeColumn", "DATETIME", "REPLACE", 8, false, false, &tablet_schema);
create_column_writer(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
RowBlock block(&tablet_schema);
RowBlockInfo block_info;
block_info.row_num = 10000;
block.init(block_info);
std::vector<std::string> val_string_array;
std::string origin_val = "2019-11-25 19:07:00";
val_string_array.emplace_back(origin_val);
OlapTuple tuple(val_string_array);
write_row.from_tuple(tuple);
block.set_row(0, write_row);
block.finalize(1);
ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// read data
TabletSchema convert_tablet_schema;
set_tablet_schema("DateColumn", "DATE", "REPLACE", 3, false, false, &convert_tablet_schema);
create_column_reader(tablet_schema);
RowCursor read_row;
read_row.init(convert_tablet_schema);
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS);
char* data = reinterpret_cast<char*>(_col_vector->col_data());
read_row.convert_from(0, data, write_row.column_schema(0)->type_info().get(), _mem_pool.get());
std::string dest_string = read_row.column_schema(0)->to_string(read_row.cell_ptr(0));
ASSERT_TRUE(strncmp(dest_string.c_str(), "2019-11-25", strlen("2019-11-25")) == 0);
//test not support type
auto tp = get_type_info(OLAP_FIELD_TYPE_HLL);
OLAPStatus st = read_row.convert_from(0, data, tp.get(), _mem_pool.get());
ASSERT_TRUE(st == OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertDateToDatetime) {
TabletSchema tablet_schema;
set_tablet_schema("DateColumn", "DATE", "REPLACE", 3, false, false, &tablet_schema);
create_column_writer(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
RowBlock block(&tablet_schema);
RowBlockInfo block_info;
block_info.row_num = 10000;
block.init(block_info);
std::vector<std::string> val_string_array;
std::string origin_val = "2019-12-04";
val_string_array.emplace_back(origin_val);
OlapTuple tuple(val_string_array);
write_row.from_tuple(tuple);
block.set_row(0, write_row);
block.finalize(1);
ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header_message;
ASSERT_EQ(_column_writer->finalize(&header_message), OLAP_SUCCESS);
TabletSchema convert_tablet_schema;
set_tablet_schema("DateTimeColumn", "DATETIME", "REPLACE", 8, false, false,
&convert_tablet_schema);
create_column_reader(tablet_schema);
RowCursor read_row;
read_row.init(convert_tablet_schema);
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS);
char* data = reinterpret_cast<char*>(_col_vector->col_data());
read_row.set_field_content(0, data, _mem_pool.get());
read_row.convert_from(0, data, write_row.column_schema(0)->type_info().get(), _mem_pool.get());
std::string dest_string = read_row.column_schema(0)->to_string(read_row.cell_ptr(0));
ASSERT_TRUE(dest_string.compare("2019-12-04 00:00:00") == 0);
//test not support type
auto tp = get_type_info(OLAP_FIELD_TYPE_HLL);
OLAPStatus st = read_row.convert_from(0, data, tp.get(), _mem_pool.get());
ASSERT_TRUE(st == OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertIntToDate) {
TabletSchema tablet_schema;
set_tablet_schema("IntColumn", "INT", "REPLACE", 4, false, false, &tablet_schema);
create_column_writer(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
RowBlock block(&tablet_schema);
RowBlockInfo block_info;
block_info.row_num = 10000;
block.init(block_info);
int time_val = 20191205;
write_row.set_field_content(0, reinterpret_cast<char*>(&time_val), _mem_pool.get());
block.set_row(0, write_row);
block.finalize(1);
ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
TabletSchema convert_tablet_schema;
set_tablet_schema("DateColumn", "DATE", "REPLACE", 3, false, false, &convert_tablet_schema);
create_column_reader(tablet_schema);
RowCursor read_row;
read_row.init(convert_tablet_schema);
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS);
char* data = reinterpret_cast<char*>(_col_vector->col_data());
read_row.convert_from(0, data, write_row.column_schema(0)->type_info().get(), _mem_pool.get());
std::string dest_string = read_row.column_schema(0)->to_string(read_row.cell_ptr(0));
ASSERT_TRUE(strncmp(dest_string.c_str(), "2019-12-05", strlen("2019-12-05")) == 0);
//test not support type
auto tp = get_type_info(OLAP_FIELD_TYPE_HLL);
OLAPStatus st = read_row.convert_from(0, read_row.cell_ptr(0), tp.get(), _mem_pool.get());
ASSERT_TRUE(st == OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertVarcharToDate) {
TabletSchema tablet_schema;
set_tablet_schema("VarcharColumn", "VARCHAR", "REPLACE", 255, false, false, &tablet_schema);
create_column_writer(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
RowBlock block(&tablet_schema);
RowBlockInfo block_info;
block_info.row_num = 10000;
block.init(block_info);
// test valid format convert
std::vector<Slice> valid_src_strs = {
"2019-12-17", "19-12-17", "20191217", "191217", "2019/12/17", "19/12/17",
};
std::string expected_val("2019-12-17");
for (auto src_str : valid_src_strs) {
write_row.set_field_content(0, reinterpret_cast<char*>(&src_str), _mem_pool.get());
block.set_row(0, write_row);
block.finalize(1);
ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
// because file_helper is reused in this case, we should close it.
helper.close();
TabletSchema convert_tablet_schema;
set_tablet_schema("DateColumn", "DATE", "REPLACE", 3, false, false, &convert_tablet_schema);
create_column_reader(tablet_schema);
RowCursor read_row;
read_row.init(convert_tablet_schema);
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS);
char* data = reinterpret_cast<char*>(_col_vector->col_data());
read_row.convert_from(0, data, write_row.column_schema(0)->type_info().get(), _mem_pool.get());
std::string dst_str = read_row.column_schema(0)->to_string(read_row.cell_ptr(0));
ASSERT_EQ(expected_val, dst_str);
}
helper.close();
TabletSchema convert_tablet_schema;
set_tablet_schema("DateColumn", "DATE", "REPLACE", 3, false, false, &convert_tablet_schema);
create_column_reader(tablet_schema);
RowCursor read_row;
read_row.init(convert_tablet_schema);
//test not support type
auto tp = get_type_info(OLAP_FIELD_TYPE_HLL);
OLAPStatus st = read_row.convert_from(0, read_row.cell_ptr(0), tp.get(), _mem_pool.get());
ASSERT_EQ(st, OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertVarcharToTinyInt1) {
test_convert_from_varchar("TINYINT", 1, "127", OLAP_SUCCESS);
}
TEST_F(TestColumn, ConvertVarcharToTinyInt2) {
test_convert_from_varchar("TINYINT", 1, "128", OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertVarcharToSmallInt1) {
test_convert_from_varchar("SMALLINT", 2, "32767", OLAP_SUCCESS);
}
TEST_F(TestColumn, ConvertVarcharToSmallInt2) {
test_convert_from_varchar("SMALLINT", 2, "32768", OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertVarcharToInt1) {
test_convert_from_varchar("INT", 4, "2147483647", OLAP_SUCCESS);
}
TEST_F(TestColumn, ConvertVarcharToInt2) {
test_convert_from_varchar("INT", 4, "2147483648", OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertVarcharToBigInt1) {
test_convert_from_varchar("BIGINT", 8, "9223372036854775807", OLAP_SUCCESS);
}
TEST_F(TestColumn, ConvertVarcharToBigInt2) {
test_convert_from_varchar("BIGINT", 8, "9223372036854775808", OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertVarcharToLargeInt1) {
test_convert_from_varchar("LARGEINT", 16, "170141183460469000000000000000000000000",
OLAP_SUCCESS);
}
TEST_F(TestColumn, ConvertVarcharToLargeInt2) {
test_convert_from_varchar("LARGEINT", 16, "1701411834604690000000000000000000000000",
OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertVarcharToFloat1) {
test_convert_from_varchar("FLOAT", 4, "3.40282e+38", OLAP_SUCCESS);
}
TEST_F(TestColumn, ConvertVarcharToFloat2) {
test_convert_from_varchar(
"FLOAT", 4,
"17976900000000000632303049213894264349303303643368533621541098328912643414890628994061"
"52996321966094455338163203127744334848599000464911410516510916727344709727599413825823"
"04802812882753059262973637182942535982636884444611376868582636745405553206881859340916"
"3400929532301499014067384276511218551077374242324480.999",
OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertVarcharToDouble1) {
test_convert_from_varchar("DOUBLE", 8, "123.456", OLAP_SUCCESS);
}
TEST_F(TestColumn, ConvertVarcharToDouble2) {
test_convert_from_varchar(
"DOUBLE", 8,
"17976900000000000632303049213894264349303303643368533621541098328912643414890628994061"
"52996321966094455338163203127744334848599000464911410516510916727344709727599413825823"
"04802812882753059262973637182942535982636884444611376868582636745405553206881859340916"
"3400929532301499014067384276511218551077374242324480.0000000000",
OLAP_ERR_INVALID_SCHEMA);
}
TEST_F(TestColumn, ConvertTinyIntToVarchar3) {
test_convert_to_varchar<int8_t>("TINYINT", 1, 127, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 3);
}
TEST_F(TestColumn, ConvertTinyIntToVarchar5) {
test_convert_to_varchar<int8_t>("TINYINT", 1, 127, "127", OLAP_SUCCESS, 3 + 2);
}
TEST_F(TestColumn, ConvertTinyIntToVarchar4) {
test_convert_to_varchar<int8_t>("TINYINT", 1, -127, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 4);
}
TEST_F(TestColumn, ConvertTinyIntToVarchar6) {
// 4: tinyint digit count + minus symbol, +2 for var len bytes
test_convert_to_varchar<int8_t>("TINYINT", 1, -127, "-127", OLAP_SUCCESS, 4 + 2);
}
TEST_F(TestColumn, ConvertSmallIntToVarchar5) {
test_convert_to_varchar<int16_t>("SMALLINT", 2, 32767, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 5);
}
TEST_F(TestColumn, ConvertSmallIntToVarchar7) {
test_convert_to_varchar<int16_t>("SMALLINT", 2, 32767, "32767", OLAP_SUCCESS, 7);
}
TEST_F(TestColumn, ConvertSmallIntToVarchar6) {
test_convert_to_varchar<int16_t>("SMALLINT", 2, -32767, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 6);
}
TEST_F(TestColumn, ConvertSmallIntToVarchar8) {
test_convert_to_varchar<int16_t>("SMALLINT", 2, -32767, "-32767", OLAP_SUCCESS, 8);
}
TEST_F(TestColumn, ConvertIntToVarchar10) {
test_convert_to_varchar<int32_t>("INT", 4, 2147483647, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 10);
}
TEST_F(TestColumn, ConvertIntToVarchar12) {
test_convert_to_varchar<int32_t>("INT", 4, 2147483647, "2147483647", OLAP_SUCCESS, 12);
}
TEST_F(TestColumn, ConvertIntToVarchar11) {
test_convert_to_varchar<int32_t>("INT", 4, -2147483647, "", OLAP_ERR_INPUT_PARAMETER_ERROR, 11);
}
TEST_F(TestColumn, ConvertIntToVarchar13) {
test_convert_to_varchar<int32_t>("INT", 4, -2147483647, "-2147483647", OLAP_SUCCESS, 13);
}
TEST_F(TestColumn, ConvertBigIntToVarchar19) {
test_convert_to_varchar<int64_t>("BIGINT", 8, 9223372036854775807, "",
OLAP_ERR_INPUT_PARAMETER_ERROR, 19);
}
TEST_F(TestColumn, ConvertBigIntToVarchar21) {
test_convert_to_varchar<int64_t>("BIGINT", 8, 9223372036854775807, "9223372036854775807",
OLAP_SUCCESS, 21);
}
TEST_F(TestColumn, ConvertBigIntToVarchar20) {
test_convert_to_varchar<int64_t>("BIGINT", 8, -9223372036854775807, "",
OLAP_ERR_INPUT_PARAMETER_ERROR, 20);
}
TEST_F(TestColumn, ConvertBigIntToVarchar22) {
test_convert_to_varchar<int64_t>("BIGINT", 8, -9223372036854775807, "-9223372036854775807",
OLAP_SUCCESS, 22);
}
TEST_F(TestColumn, ConvertLargeIntToVarchar39) {
std::string str_val("170141183460469231731687303715884105727");
StringParser::ParseResult result;
int128_t int128_val =
StringParser::string_to_int<int128_t>(str_val.c_str(), str_val.length(), &result);
DCHECK(result == StringParser::PARSE_SUCCESS);
test_convert_to_varchar<int128_t>("LARGEINT", 16, int128_val, "",
OLAP_ERR_INPUT_PARAMETER_ERROR, 39);
}
TEST_F(TestColumn, ConvertLargeIntToVarchar41) {
std::string str_val("170141183460469231731687303715884105727");
StringParser::ParseResult result;
int128_t int128_val =
StringParser::string_to_int<int128_t>(str_val.c_str(), str_val.length(), &result);
DCHECK(result == StringParser::PARSE_SUCCESS);
test_convert_to_varchar<int128_t>("LARGEINT", 16, int128_val, str_val, OLAP_SUCCESS, 41);
}
TEST_F(TestColumn, ConvertLargeIntToVarchar40) {
std::string str_val = "-170141183460469231731687303715884105727";
StringParser::ParseResult result;
int128_t int128_val =
StringParser::string_to_int<int128_t>(str_val.c_str(), str_val.length(), &result);
DCHECK(result == StringParser::PARSE_SUCCESS);
test_convert_to_varchar<int128_t>("LARGEINT", 16, int128_val, "",
OLAP_ERR_INPUT_PARAMETER_ERROR, 40);
}
TEST_F(TestColumn, ConvertLargeIntToVarchar46) {
std::string str_val = "-170141183460469231731687303715884105727";
StringParser::ParseResult result;
int128_t int128_val =
StringParser::string_to_int<int128_t>(str_val.c_str(), str_val.length(), &result);
DCHECK(result == StringParser::PARSE_SUCCESS);
test_convert_to_varchar<int128_t>("LARGEINT", 16, int128_val, str_val, OLAP_SUCCESS, 42);
}
TEST_F(TestColumn, ConvertFloatToVarchar11) {
test_convert_to_varchar<float>("FLOAT", 4, 3.40282e+38, "3.40282e+38",
OLAP_ERR_INPUT_PARAMETER_ERROR, 11);
}
TEST_F(TestColumn, ConvertFloatToVarchar13) {
test_convert_to_varchar<float>("FLOAT", 4, 3.40282e+38, "3.40282e+38", OLAP_SUCCESS, 13);
}
TEST_F(TestColumn, ConvertFloatToVarchar13_2) {
test_convert_to_varchar<float>("FLOAT", 4, 3402820000000000000.0, "3.40282e+18", OLAP_SUCCESS,
13);
}
TEST_F(TestColumn, ConvertFloatToVarchar12) {
test_convert_to_varchar<float>("FLOAT", 4, -3.40282e+38, "-3.40282e+38",
OLAP_ERR_INPUT_PARAMETER_ERROR, 12);
}
TEST_F(TestColumn, ConvertFloatToVarchar14) {
test_convert_to_varchar<float>("FLOAT", 4, -3.40282e+38, "-3.40282e+38", OLAP_SUCCESS, 14);
}
TEST_F(TestColumn, ConvertFloatToVarchar14_2) {
test_convert_to_varchar<float>("FLOAT", 4, -3402820000000000000.0, "-3.40282e+18", OLAP_SUCCESS,
14);
}
TEST_F(TestColumn, ConvertFloatToVarchar13_3) {
test_convert_to_varchar<float>("FLOAT", 4, 1.17549435082228750796873653722224568e-38F,
"1.1754944e-38", OLAP_ERR_INPUT_PARAMETER_ERROR, 13);
}
TEST_F(TestColumn, ConvertFloatToVarchar15) {
test_convert_to_varchar<float>("FLOAT", 4, 1.17549435082228750796873653722224568e-38F,
"1.1754944e-38", OLAP_SUCCESS, 15);
}
TEST_F(TestColumn, ConvertFloatToVarchar14_3) {
test_convert_to_varchar<float>("FLOAT", 4, -1.17549435082228750796873653722224568e-38F,
"-1.1754944e-38", OLAP_ERR_INPUT_PARAMETER_ERROR, 14);
}
TEST_F(TestColumn, ConvertFloatToVarchar16) {
test_convert_to_varchar<float>("FLOAT", 4, -1.17549435082228750796873653722224568e-38F,
"-1.1754944e-38", OLAP_SUCCESS, 16);
}
TEST_F(TestColumn, ConvertDoubleToVarchar7) {
test_convert_to_varchar<double>("DOUBLE", 8, 123.456, "123.456", OLAP_ERR_INPUT_PARAMETER_ERROR,
7);
}
TEST_F(TestColumn, ConvertDoubleToVarchar9) {
test_convert_to_varchar<double>("DOUBLE", 8, 123.456, "123.456", OLAP_SUCCESS, 9);
}
TEST_F(TestColumn, ConvertDoubleToVarchar23) {
test_convert_to_varchar<double>("DOUBLE", 8, 1.79769313486231570814527423731704357e+308,
"1.7976931348623157e+308", OLAP_ERR_INPUT_PARAMETER_ERROR, 23);
}
TEST_F(TestColumn, ConvertDoubleToVarchar25) {
test_convert_to_varchar<double>("DOUBLE", 8, 1.79769313486231570814527423731704357e+308,
"1.7976931348623157e+308", OLAP_SUCCESS, 25);
}
TEST_F(TestColumn, ConvertDoubleToVarchar22) {
test_convert_to_varchar<double>("DOUBLE", 8, 1797693134862315708.0, "1.7976931348623158e+18",
OLAP_ERR_INPUT_PARAMETER_ERROR, 22);
}
TEST_F(TestColumn, ConvertDoubleToVarchar24) {
test_convert_to_varchar<double>("DOUBLE", 8, 1797693134862315708.0, "1.7976931348623158e+18",
OLAP_SUCCESS, 24);
}
TEST_F(TestColumn, ConvertDoubleToVarchar23_2) {
test_convert_to_varchar<double>("DOUBLE", 8, -1797693134862315708.0, "-1.7976931348623158e+18",
OLAP_ERR_INPUT_PARAMETER_ERROR, 23);
}
TEST_F(TestColumn, ConvertDoubleToVarchar25_2) {
test_convert_to_varchar<double>("DOUBLE", 8, -1797693134862315708.0, "-1.7976931348623158e+18",
OLAP_SUCCESS, 25);
}
TEST_F(TestColumn, ConvertDoubleToVarchar23_3) {
test_convert_to_varchar<double>("DOUBLE", 8, 2.22507385850720138309023271733240406e-308,
"2.2250738585072014e-308", OLAP_ERR_INPUT_PARAMETER_ERROR, 23);
}
TEST_F(TestColumn, ConvertDoubleToVarchar25_3) {
test_convert_to_varchar<double>("DOUBLE", 8, 2.22507385850720138309023271733240406e-308,
"2.2250738585072014e-308", OLAP_SUCCESS, 25);
}
TEST_F(TestColumn, ConvertDoubleToVarchar24_2) {
test_convert_to_varchar<double>("DOUBLE", 8, -2.22507385850720138309023271733240406e-308,
"-2.2250738585072014e-308", OLAP_ERR_INPUT_PARAMETER_ERROR, 24);
}
TEST_F(TestColumn, ConvertDoubleToVarchar26) {
test_convert_to_varchar<double>("DOUBLE", 8, -2.22507385850720138309023271733240406e-308,
"-2.2250738585072014e-308", OLAP_SUCCESS, 26);
}
TEST_F(TestColumn, ConvertDecimalToVarchar13) {
decimal12_t val = {456, 789000000};
test_convert_to_varchar<decimal12_t>("Decimal", 12, val, "456.789000000",
OLAP_ERR_INPUT_PARAMETER_ERROR, 13);
}
TEST_F(TestColumn, ConvertDecimalToVarchar15) {
decimal12_t val = {456, 789000000};
test_convert_to_varchar<decimal12_t>("Decimal", 12, val, "456.789000000", OLAP_SUCCESS, 15);
}
TEST_F(TestColumn, ConvertDecimalToVarchar28) {
decimal12_t val = {999999999999999999, 999999999};
test_convert_to_varchar<decimal12_t>("Decimal", 12, val, "", OLAP_ERR_INPUT_PARAMETER_ERROR,
28);
}
TEST_F(TestColumn, ConvertDecimalToVarchar30) {
decimal12_t val = {999999999999999999, 999999999};
test_convert_to_varchar<decimal12_t>("Decimal", 12, val, "999999999999999999.999999999",
OLAP_SUCCESS, 30);
}
TEST_F(TestColumn, ConvertDecimalToVarchar29) {
decimal12_t val = {-999999999999999999, 999999999};
test_convert_to_varchar<decimal12_t>("Decimal", 12, val, "", OLAP_ERR_INPUT_PARAMETER_ERROR,
29);
}
TEST_F(TestColumn, ConvertDecimalToVarchar31) {
decimal12_t val = {-999999999999999999, 999999999};
test_convert_to_varchar<decimal12_t>("Decimal", 12, val, "-999999999999999999.999999999",
OLAP_SUCCESS, 31);
}
void CreateTabletSchema(TabletSchema& tablet_schema) {
TabletSchemaPB tablet_schema_pb;
tablet_schema_pb.set_keys_type(KeysType::AGG_KEYS);
tablet_schema_pb.set_num_short_key_columns(2);
tablet_schema_pb.set_num_rows_per_row_block(1024);
tablet_schema_pb.set_compress_kind(COMPRESS_NONE);
tablet_schema_pb.set_next_column_unique_id(4);
ColumnPB* column_1 = tablet_schema_pb.add_column();
column_1->set_unique_id(1);
column_1->set_name("k1");
column_1->set_type("INT");
column_1->set_is_key(true);
column_1->set_length(4);
column_1->set_index_length(4);
column_1->set_is_nullable(false);
column_1->set_is_bf_column(false);
ColumnPB* column_2 = tablet_schema_pb.add_column();
column_2->set_unique_id(2);
column_2->set_name("k2");
column_2->set_type("VARCHAR");
column_2->set_length(20);
column_2->set_index_length(20);
column_2->set_is_key(true);
column_2->set_is_nullable(false);
column_2->set_is_bf_column(false);
ColumnPB* column_3 = tablet_schema_pb.add_column();
column_3->set_unique_id(3);
column_3->set_name("k3");
column_3->set_type("INT");
column_3->set_is_key(true);
column_3->set_length(4);
column_3->set_index_length(4);
column_3->set_is_nullable(false);
column_3->set_is_bf_column(false);
ColumnPB* column_4 = tablet_schema_pb.add_column();
column_4->set_unique_id(4);
column_4->set_name("v1");
column_4->set_type("INT");
column_4->set_length(4);
column_4->set_is_key(false);
column_4->set_is_nullable(false);
column_4->set_is_bf_column(false);
column_4->set_aggregation("SUM");
tablet_schema.init_from_pb(tablet_schema_pb);
}
TEST_F(TestColumn, ConvertIntToBitmap) {
//Base Tablet
TabletSchema tablet_schema;
CreateTabletSchema(tablet_schema);
//Base row block
create_column_writer(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
write_row.allocate_memory_for_string_type(tablet_schema);
RowBlock block(&tablet_schema);
RowBlockInfo block_info;
block_info.row_num = 10000;
block.init(block_info);
std::vector<std::string> val_string_array;
val_string_array.emplace_back("5");
val_string_array.emplace_back("4");
val_string_array.emplace_back("2");
val_string_array.emplace_back("3");
OlapTuple tuple(val_string_array);
write_row.from_tuple(tuple);
block.set_row(0, write_row);
block.finalize(1);
ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
//Materialized View tablet schema
TabletSchemaPB mv_tablet_schema_pb;
mv_tablet_schema_pb.set_keys_type(KeysType::AGG_KEYS);
mv_tablet_schema_pb.set_num_short_key_columns(2);
mv_tablet_schema_pb.set_num_rows_per_row_block(1024);
mv_tablet_schema_pb.set_compress_kind(COMPRESS_NONE);
mv_tablet_schema_pb.set_next_column_unique_id(3);
ColumnPB* mv_column_1 = mv_tablet_schema_pb.add_column();
mv_column_1->set_unique_id(1);
mv_column_1->set_name("k1");
mv_column_1->set_type("INT");
mv_column_1->set_is_key(true);
mv_column_1->set_length(4);
mv_column_1->set_index_length(4);
mv_column_1->set_is_nullable(false);
mv_column_1->set_is_bf_column(false);
ColumnPB* mv_column_2 = mv_tablet_schema_pb.add_column();
mv_column_2->set_unique_id(2);
mv_column_2->set_name("v1");
mv_column_2->set_type("OBJECT");
mv_column_2->set_length(8);
mv_column_2->set_is_key(false);
mv_column_2->set_is_nullable(false);
mv_column_2->set_is_bf_column(false);
mv_column_2->set_aggregation("BITMAP_UNION");
TabletSchema mv_tablet_schema;
mv_tablet_schema.init_from_pb(mv_tablet_schema_pb);
RowBlockChanger row_block_changer(mv_tablet_schema);
ColumnMapping* column_mapping = row_block_changer.get_mutable_column_mapping(0);
column_mapping->ref_column = 0;
column_mapping = row_block_changer.get_mutable_column_mapping(1);
column_mapping->ref_column = 2;
column_mapping->materialized_function = "to_bitmap";
RowBlock mutable_block(&mv_tablet_schema);
mutable_block.init(block_info);
uint64_t filtered_rows = 0;
row_block_changer.change_row_block(&block, 0, &mutable_block, &filtered_rows);
RowCursor mv_row_cursor;
mv_row_cursor.init(mv_tablet_schema);
mutable_block.get_row(0, &mv_row_cursor);
auto dst_slice = reinterpret_cast<Slice*>(mv_row_cursor.cell_ptr(1));
BitmapValue bitmapValue(dst_slice->data);
ASSERT_EQ(bitmapValue.cardinality(), 1);
}
TEST_F(TestColumn, ConvertCharToHLL) {
//Base Tablet
TabletSchema tablet_schema;
CreateTabletSchema(tablet_schema);
//Base row block
create_column_writer(tablet_schema);
RowCursor write_row;
write_row.init(tablet_schema);
write_row.allocate_memory_for_string_type(tablet_schema);
RowBlock block(&tablet_schema);
RowBlockInfo block_info;
block_info.row_num = 10000;
block.init(block_info);
std::vector<std::string> val_string_array;
//std::string origin_val = "2019-11-25 19:07:00";
//val_string_array.emplace_back(origin_val);
val_string_array.emplace_back("1");
val_string_array.emplace_back("1");
val_string_array.emplace_back("2");
val_string_array.emplace_back("3");
OlapTuple tuple(val_string_array);
write_row.from_tuple(tuple);
block.set_row(0, write_row);
block.finalize(1);
ASSERT_EQ(_column_writer->write_batch(&block, &write_row), OLAP_SUCCESS);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
//Materialized View tablet schema
TabletSchemaPB mv_tablet_schema_pb;
mv_tablet_schema_pb.set_keys_type(KeysType::AGG_KEYS);
mv_tablet_schema_pb.set_num_short_key_columns(2);
mv_tablet_schema_pb.set_num_rows_per_row_block(1024);
mv_tablet_schema_pb.set_compress_kind(COMPRESS_NONE);
mv_tablet_schema_pb.set_next_column_unique_id(3);
ColumnPB* mv_column_1 = mv_tablet_schema_pb.add_column();
mv_column_1->set_unique_id(1);
mv_column_1->set_name("k1");
mv_column_1->set_type("INT");
mv_column_1->set_is_key(true);
mv_column_1->set_length(4);
mv_column_1->set_index_length(4);
mv_column_1->set_is_nullable(false);
mv_column_1->set_is_bf_column(false);
ColumnPB* mv_column_2 = mv_tablet_schema_pb.add_column();
mv_column_2->set_unique_id(2);
mv_column_2->set_name("v1");
mv_column_2->set_type("HLL");
mv_column_2->set_length(4);
mv_column_2->set_is_key(false);
mv_column_2->set_is_nullable(false);
mv_column_2->set_is_bf_column(false);
mv_column_2->set_aggregation("HLL_UNION");
TabletSchema mv_tablet_schema;
mv_tablet_schema.init_from_pb(mv_tablet_schema_pb);
RowBlockChanger row_block_changer(mv_tablet_schema);
ColumnMapping* column_mapping = row_block_changer.get_mutable_column_mapping(0);
column_mapping->ref_column = 0;
column_mapping = row_block_changer.get_mutable_column_mapping(1);
column_mapping->ref_column = 1;
column_mapping->materialized_function = "hll_hash";
RowBlock mutable_block(&mv_tablet_schema);
mutable_block.init(block_info);
uint64_t filtered_rows = 0;
row_block_changer.change_row_block(&block, 0, &mutable_block, &filtered_rows);
RowCursor mv_row_cursor;
mv_row_cursor.init(mv_tablet_schema);
mutable_block.get_row(0, &mv_row_cursor);
auto dst_slice = reinterpret_cast<Slice*>(mv_row_cursor.cell_ptr(1));
HyperLogLog hll(*dst_slice);
ASSERT_EQ(hll.estimate_cardinality(), 1);
}
TEST_F(TestColumn, ConvertCharToCount) {
//Base Tablet
TabletSchema tablet_schema;
CreateTabletSchema(tablet_schema);
//Base row block
create_column_writer(tablet_schema);
RowBlock block(&tablet_schema);
RowBlockInfo block_info;
block_info.row_num = 10000;
block.init(block_info);
RowCursor write_row;
write_row.init(tablet_schema);
write_row.allocate_memory_for_string_type(tablet_schema);
std::vector<std::string> val_string_array;
val_string_array.emplace_back("1");
val_string_array.emplace_back("1");
val_string_array.emplace_back("2");
val_string_array.emplace_back("3");
OlapTuple tuple(val_string_array);
write_row.from_tuple(tuple);
block.set_row(0, write_row);
block.finalize(1);
ColumnDataHeaderMessage header;
ASSERT_EQ(_column_writer->finalize(&header), OLAP_SUCCESS);
//Materialized View tablet schema
TabletSchemaPB mv_tablet_schema_pb;
mv_tablet_schema_pb.set_keys_type(KeysType::AGG_KEYS);
mv_tablet_schema_pb.set_num_short_key_columns(2);
mv_tablet_schema_pb.set_num_rows_per_row_block(1024);
mv_tablet_schema_pb.set_compress_kind(COMPRESS_NONE);
mv_tablet_schema_pb.set_next_column_unique_id(3);
ColumnPB* mv_column_1 = mv_tablet_schema_pb.add_column();
mv_column_1->set_unique_id(1);
mv_column_1->set_name("k1");
mv_column_1->set_type("INT");
mv_column_1->set_is_key(true);
mv_column_1->set_length(4);
mv_column_1->set_index_length(4);
mv_column_1->set_is_nullable(false);
mv_column_1->set_is_bf_column(false);
ColumnPB* mv_column_2 = mv_tablet_schema_pb.add_column();
mv_column_2->set_unique_id(2);
mv_column_2->set_name("v1");
mv_column_2->set_type("BIGINT");
mv_column_2->set_length(4);
mv_column_2->set_is_key(false);
mv_column_2->set_is_nullable(false);
mv_column_2->set_is_bf_column(false);
mv_column_2->set_aggregation("SUM");
TabletSchema mv_tablet_schema;
mv_tablet_schema.init_from_pb(mv_tablet_schema_pb);
RowBlockChanger row_block_changer(mv_tablet_schema);
ColumnMapping* column_mapping = row_block_changer.get_mutable_column_mapping(0);
column_mapping->ref_column = 0;
column_mapping = row_block_changer.get_mutable_column_mapping(1);
column_mapping->ref_column = 1;
column_mapping->materialized_function = "count_field";
RowBlock mutable_block(&mv_tablet_schema);
mutable_block.init(block_info);
uint64_t filtered_rows = 0;
row_block_changer.change_row_block(&block, 0, &mutable_block, &filtered_rows);
RowCursor mv_row_cursor;
mv_row_cursor.init(mv_tablet_schema);
mutable_block.get_row(0, &mv_row_cursor);
auto dst = mv_row_cursor.cell_ptr(1);
ASSERT_EQ(*(int64_t*)dst, 1);
}
} // namespace doris
int main(int argc, char** argv) {
std::string conf_file = std::string(getenv("DORIS_HOME")) + "/conf/be.conf";
if (!doris::config::init(conf_file.c_str(), false)) {
fprintf(stderr, "error read config file. \n");
return -1;
}
doris::init_glog("be-test");
doris::MemInfo::init();
int ret = doris::OLAP_SUCCESS;
testing::InitGoogleTest(&argc, argv);
ret = RUN_ALL_TESTS();
return ret;
}
|
#include <sstream>
#include "Tools/Exception/exception.hpp"
#include "Factory/Module/Puncturer/Puncturer.hpp"
#include "Codec_RSC.hpp"
using namespace aff3ct;
using namespace aff3ct::module;
template <typename B, typename Q>
Codec_RSC<B,Q>
::Codec_RSC(const factory::Encoder_RSC::parameters &enc_params,
const factory::Decoder_RSC::parameters &dec_params)
: Codec <B,Q>(enc_params.K, enc_params.N_cw, enc_params.N_cw, enc_params.tail_length, enc_params.n_frames),
Codec_SISO_SIHO<B,Q>(enc_params.K, enc_params.N_cw, enc_params.N_cw, enc_params.tail_length, enc_params.n_frames),
buffered_encoding(enc_params.buffered)
{
const std::string name = "Codec_RSC";
this->set_name(name);
// ----------------------------------------------------------------------------------------------------- exceptions
if (enc_params.K != dec_params.K)
{
std::stringstream message;
message << "'enc_params.K' has to be equal to 'dec_params.K' ('enc_params.K' = " << enc_params.K
<< ", 'dec_params.K' = " << dec_params.K << ").";
throw tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
}
if (enc_params.N_cw != dec_params.N_cw)
{
std::stringstream message;
message << "'enc_params.N_cw' has to be equal to 'dec_params.N_cw' ('enc_params.N_cw' = " << enc_params.N_cw
<< ", 'dec_params.N_cw' = " << dec_params.N_cw << ").";
throw tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
}
if (enc_params.n_frames != dec_params.n_frames)
{
std::stringstream message;
message << "'enc_params.n_frames' has to be equal to 'dec_params.n_frames' ('enc_params.n_frames' = "
<< enc_params.n_frames << ", 'dec_params.n_frames' = " << dec_params.n_frames << ").";
throw tools::invalid_argument(__FILE__, __LINE__, __func__, message.str());
}
// ---------------------------------------------------------------------------------------------------------- tools
auto enc_cpy = enc_params;
enc_cpy.type = "RSC";
auto encoder_RSC = factory::Encoder_RSC::build<B>(enc_cpy);
trellis = encoder_RSC->get_trellis();
delete encoder_RSC;
// ---------------------------------------------------------------------------------------------------- allocations
factory::Puncturer::parameters pct_params;
pct_params.type = "NO";
pct_params.K = enc_params.K;
pct_params.N = enc_params.N_cw;
pct_params.N_cw = enc_params.N_cw;
pct_params.n_frames = enc_params.n_frames;
this->set_puncturer(factory::Puncturer::build<B,Q>(pct_params));
try
{
this->set_encoder(factory::Encoder_RSC::build<B>(enc_params));
}
catch (tools::cannot_allocate const&)
{
this->set_encoder(factory::Encoder::build<B>(enc_params));
}
try
{
auto decoder_siso_siho = factory::Decoder_RSC::build_siso<B,Q>(dec_params, trellis, std::cout, 1, this->get_encoder());
this->set_decoder_siso(decoder_siso_siho);
this->set_decoder_siho(decoder_siso_siho);
}
catch (tools::cannot_allocate const&)
{
this->set_decoder_siho(factory::Decoder_RSC::build<B,Q>(dec_params, trellis, std::cout, 1, this->get_encoder()));
}
}
template <typename B, typename Q>
Codec_RSC<B,Q>
::~Codec_RSC()
{
}
template <typename B, typename Q>
void Codec_RSC<B,Q>
::_extract_sys_par(const Q* Y_N, Q* sys, Q* par, const int frame_id)
{
const auto tb_2 = this->tail_length / 2;
const auto K = this->K;
const auto N_cw = this->N_cw;
if (buffered_encoding)
{
std::copy(Y_N, Y_N + K + tb_2, sys);
std::copy(Y_N + K + tb_2, Y_N + N_cw, par);
}
else
{
for (auto i = 0; i < K + tb_2; i++)
{
sys[i] = Y_N[i*2 +0];
par[i] = Y_N[i*2 +1];
}
}
}
template <typename B, typename Q>
void Codec_RSC<B,Q>
::_extract_sys_llr(const Q* Y_N, Q* sys, const int frame_id)
{
if (buffered_encoding)
std::copy(Y_N, Y_N + this->K, sys);
else
for (auto i = 0; i < this->K; i++)
sys[i] = Y_N[i*2];
}
template <typename B, typename Q>
void Codec_RSC<B,Q>
::_add_sys_ext(const Q* ext, Q* Y_N, const int frame_id)
{
if (buffered_encoding)
for (auto i = 0; i < this->K; i++)
Y_N[i] += ext[i];
else
for (auto i = 0; i < this->K; i++)
Y_N[i*2] += ext[i];
}
template <typename B, typename Q>
void Codec_RSC<B,Q>
::_extract_sys_bit(const Q *Y_N, B *V_K, const int frame_id)
{
if (buffered_encoding)
for (auto i = 0; i < this->K; i++)
V_K[i] = Y_N[i] >= 0 ? (B)0 : (B)1;
else
for (auto i = 0; i < this->K; i++)
V_K[i] = Y_N[2*i] >= 0 ? (B)0 : (B)1;
}
// ==================================================================================== explicit template instantiation
#include "Tools/types.h"
#ifdef MULTI_PREC
template class aff3ct::module::Codec_RSC<B_8,Q_8>;
template class aff3ct::module::Codec_RSC<B_16,Q_16>;
template class aff3ct::module::Codec_RSC<B_32,Q_32>;
template class aff3ct::module::Codec_RSC<B_64,Q_64>;
#else
template class aff3ct::module::Codec_RSC<B,Q>;
#endif
// ==================================================================================== explicit template instantiation
|
// Generated code. Do not edit
// Create the model
Model createTestModel() {
const std::vector<Operand> operands = {
{
.type = OperandType::TENSOR_FLOAT32,
.dimensions = {1, 2, 2, 3},
.numberOfConsumers = 1,
.scale = 0.0f,
.zeroPoint = 0,
.lifetime = OperandLifeTime::MODEL_INPUT,
.location = {.poolIndex = 0, .offset = 0, .length = 0},
},
{
.type = OperandType::INT32,
.dimensions = {},
.numberOfConsumers = 1,
.scale = 0.0f,
.zeroPoint = 0,
.lifetime = OperandLifeTime::CONSTANT_COPY,
.location = {.poolIndex = 0, .offset = 0, .length = 4},
},
{
.type = OperandType::INT32,
.dimensions = {},
.numberOfConsumers = 1,
.scale = 0.0f,
.zeroPoint = 0,
.lifetime = OperandLifeTime::CONSTANT_COPY,
.location = {.poolIndex = 0, .offset = 4, .length = 4},
},
{
.type = OperandType::INT32,
.dimensions = {},
.numberOfConsumers = 1,
.scale = 0.0f,
.zeroPoint = 0,
.lifetime = OperandLifeTime::CONSTANT_COPY,
.location = {.poolIndex = 0, .offset = 8, .length = 4},
},
{
.type = OperandType::INT32,
.dimensions = {},
.numberOfConsumers = 1,
.scale = 0.0f,
.zeroPoint = 0,
.lifetime = OperandLifeTime::CONSTANT_COPY,
.location = {.poolIndex = 0, .offset = 12, .length = 4},
},
{
.type = OperandType::INT32,
.dimensions = {},
.numberOfConsumers = 4,
.scale = 0.0f,
.zeroPoint = 0,
.lifetime = OperandLifeTime::CONSTANT_COPY,
.location = {.poolIndex = 0, .offset = 16, .length = 4},
},
{
.type = OperandType::INT32,
.dimensions = {},
.numberOfConsumers = 1,
.scale = 0.0f,
.zeroPoint = 0,
.lifetime = OperandLifeTime::CONSTANT_COPY,
.location = {.poolIndex = 0, .offset = 20, .length = 4},
},
{
.type = OperandType::TENSOR_FLOAT32,
.dimensions = {1, 1, 1, 3},
.numberOfConsumers = 0,
.scale = 0.0f,
.zeroPoint = 0,
.lifetime = OperandLifeTime::MODEL_OUTPUT,
.location = {.poolIndex = 0, .offset = 0, .length = 0},
}
};
const std::vector<Operation> operations = {
{
.type = OperationType::L2_POOL_2D,
.inputs = {0, 5, 5, 5, 5, 3, 4, 1, 2, 6},
.outputs = {7},
}
};
const std::vector<uint32_t> inputIndexes = {0};
const std::vector<uint32_t> outputIndexes = {7};
std::vector<uint8_t> operandValues = {
2, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
const std::vector<hidl_memory> pools = {};
return {
.operands = operands,
.operations = operations,
.inputIndexes = inputIndexes,
.outputIndexes = outputIndexes,
.operandValues = operandValues,
.pools = pools,
};
}
bool is_ignored(int i) {
static std::set<int> ignore = {};
return ignore.find(i) != ignore.end();
}
|
// Autogenerated from CppHeaderCreator
// Created by Sc2ad
// =========================================================================
#pragma once
// Begin includes
#include "beatsaber-hook/shared/utils/typedefs.h"
#include "beatsaber-hook/shared/utils/byref.hpp"
// Including type: OVR.OpenVR.IVRChaperone
#include "OVR/OpenVR/IVRChaperone.hpp"
// Including type: System.MulticastDelegate
#include "System/MulticastDelegate.hpp"
#include "beatsaber-hook/shared/utils/il2cpp-utils-methods.hpp"
#include "beatsaber-hook/shared/utils/il2cpp-utils-properties.hpp"
#include "beatsaber-hook/shared/utils/il2cpp-utils-fields.hpp"
#include "beatsaber-hook/shared/utils/utils.h"
// Completed includes
// Begin forward declares
// Forward declaring namespace: System
namespace System {
// Forward declaring type: IAsyncResult
class IAsyncResult;
// Forward declaring type: AsyncCallback
class AsyncCallback;
}
// Completed forward declares
#include "beatsaber-hook/shared/utils/il2cpp-type-check.hpp"
NEED_NO_BOX(::OVR::OpenVR::IVRChaperone::_ReloadInfo);
DEFINE_IL2CPP_ARG_TYPE(::OVR::OpenVR::IVRChaperone::_ReloadInfo*, "OVR.OpenVR", "IVRChaperone/_ReloadInfo");
// Type namespace: OVR.OpenVR
namespace OVR::OpenVR {
// Size: 0x70
#pragma pack(push, 1)
// Autogenerated type: OVR.OpenVR.IVRChaperone/OVR.OpenVR._ReloadInfo
// [TokenAttribute] Offset: FFFFFFFF
// [UnmanagedFunctionPointerAttribute] Offset: 58A988
class IVRChaperone::_ReloadInfo : public ::System::MulticastDelegate {
public:
// public System.Void .ctor(System.Object object, System.IntPtr method)
// Offset: 0x6F8030
template<::il2cpp_utils::CreationType creationType = ::il2cpp_utils::CreationType::Temporary>
static IVRChaperone::_ReloadInfo* New_ctor(::Il2CppObject* object, ::System::IntPtr method) {
static auto ___internal__logger = ::Logger::get().WithContext("::OVR::OpenVR::IVRChaperone::_ReloadInfo::.ctor");
return THROW_UNLESS((::il2cpp_utils::New<IVRChaperone::_ReloadInfo*, creationType>(object, method)));
}
// public System.Void Invoke()
// Offset: 0x6F8040
void Invoke();
// public System.IAsyncResult BeginInvoke(System.AsyncCallback callback, System.Object object)
// Offset: 0x6F824C
::System::IAsyncResult* BeginInvoke(::System::AsyncCallback* callback, ::Il2CppObject* object);
// public System.Void EndInvoke(System.IAsyncResult result)
// Offset: 0x6F8278
void EndInvoke(::System::IAsyncResult* result);
}; // OVR.OpenVR.IVRChaperone/OVR.OpenVR._ReloadInfo
#pragma pack(pop)
}
#include "beatsaber-hook/shared/utils/il2cpp-utils-methods.hpp"
// Writing MetadataGetter for method: OVR::OpenVR::IVRChaperone::_ReloadInfo::New_ctor
// Il2CppName: .ctor
// Cannot get method pointer of value based method overload from template for constructor!
// Try using FindMethod instead!
// Writing MetadataGetter for method: OVR::OpenVR::IVRChaperone::_ReloadInfo::Invoke
// Il2CppName: Invoke
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<void (OVR::OpenVR::IVRChaperone::_ReloadInfo::*)()>(&OVR::OpenVR::IVRChaperone::_ReloadInfo::Invoke)> {
static const MethodInfo* get() {
return ::il2cpp_utils::FindMethod(classof(OVR::OpenVR::IVRChaperone::_ReloadInfo*), "Invoke", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{});
}
};
// Writing MetadataGetter for method: OVR::OpenVR::IVRChaperone::_ReloadInfo::BeginInvoke
// Il2CppName: BeginInvoke
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<::System::IAsyncResult* (OVR::OpenVR::IVRChaperone::_ReloadInfo::*)(::System::AsyncCallback*, ::Il2CppObject*)>(&OVR::OpenVR::IVRChaperone::_ReloadInfo::BeginInvoke)> {
static const MethodInfo* get() {
static auto* callback = &::il2cpp_utils::GetClassFromName("System", "AsyncCallback")->byval_arg;
static auto* object = &::il2cpp_utils::GetClassFromName("System", "Object")->byval_arg;
return ::il2cpp_utils::FindMethod(classof(OVR::OpenVR::IVRChaperone::_ReloadInfo*), "BeginInvoke", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{callback, object});
}
};
// Writing MetadataGetter for method: OVR::OpenVR::IVRChaperone::_ReloadInfo::EndInvoke
// Il2CppName: EndInvoke
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<void (OVR::OpenVR::IVRChaperone::_ReloadInfo::*)(::System::IAsyncResult*)>(&OVR::OpenVR::IVRChaperone::_ReloadInfo::EndInvoke)> {
static const MethodInfo* get() {
static auto* result = &::il2cpp_utils::GetClassFromName("System", "IAsyncResult")->byval_arg;
return ::il2cpp_utils::FindMethod(classof(OVR::OpenVR::IVRChaperone::_ReloadInfo*), "EndInvoke", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{result});
}
};
|
// This file is part of KWIVER, and is distributed under the
// OSI-approved BSD 3-Clause License. See top-level LICENSE file or
// https://github.com/Kitware/kwiver/blob/master/LICENSE for details.
#include "timestamp.h"
#include <sstream>
#include <string>
#include <cstring>
#include <ctime>
namespace kwiver {
namespace vital {
timestamp::timestamp()
: m_valid_time( false ),
m_valid_frame( false ),
m_time( 0 ),
m_frame( 0 ),
m_time_domain_index( 0 )
{ }
timestamp::timestamp( time_usec_t t, frame_id_t f )
: m_valid_time( true ),
m_valid_frame( true ),
m_time( t ),
m_frame( f ),
m_time_domain_index( 0 )
{ }
// ------------------------------------------------------------------
timestamp& timestamp
::set_time_usec( time_usec_t t )
{
m_time = t;
m_valid_time = true;
return *this;
}
// ------------------------------------------------------------------
timestamp& timestamp
::set_time_seconds( double t )
{
m_time = static_cast< time_usec_t >(t * 1e6); // Convert to usec
m_valid_time = true;
return *this;
}
// ------------------------------------------------------------------
timestamp& timestamp
::set_frame( frame_id_t f)
{
m_frame = f;
m_valid_frame = true;
return *this;
}
// ------------------------------------------------------------------
timestamp& timestamp
::set_invalid()
{
m_valid_time = false;
m_valid_frame = false;
return *this;
}
// ------------------------------------------------------------------
timestamp& timestamp
::set_time_domain_index( int dom )
{
m_time_domain_index = dom;
return *this;
}
// ------------------------------------------------------------------
double timestamp
::get_time_seconds() const
{
return static_cast< double > (m_time) * 1e-6; // convert from usec to sec
}
// ------------------------------------------------------------------
/**
Generic truth table for compares
There are some cases where the tow objects are incomparable. in these
cases the results are always false.
\code
times-valid | frames_valid | same_domain | time_condition | frame_condition | result
------------------------------------------------------------------------------------
- | - | F | - | - | F (incomparable)
F | F | T | - | - | F (incomparable)
| | | | |
T | T | T | T | T | T (meets condition)
| | | | |
T | T | T | F | - | F
T | T | T | - | F | F
| | | | |
T | F | T | F | - | F (time only compare)
T | F | T | T | - | T (time only compare)
F | T | T | - | F | F (frame only compare)
F | T | T | - | T | T (frame only compare)
\endcode
General implementation
( ! same_domain ) -> F
( ! time_valid ) & ( ! frame_valid ) -> F
( time_valid & ( ! time_condition ) -> F
( frame_valid & ( ! frame_condition ) -> F
-> T
*/
#define COMPARE(OP) \
bool timestamp \
::operator OP( timestamp const& rhs ) const \
{ \
if ( this->m_time_domain_index != rhs.m_time_domain_index ) \
{ \
return false; \
} \
\
const bool time_valid( this->has_valid_time() && rhs.has_valid_time() ); \
const bool frame_valid( this->has_valid_frame() && rhs.has_valid_frame() ); \
\
if ( (! time_valid) && (! frame_valid) ) \
{ \
return false; \
} \
\
if ( time_valid && !( this->get_time_usec() OP rhs.get_time_usec() ) ) \
{ \
return false; \
} \
\
if ( frame_valid && !( this->get_frame() OP rhs.get_frame() ) ) \
{ \
return false; \
} \
\
return true; \
}
// -----------------------------------
// Instantiate relational operators
//
COMPARE( == )
COMPARE( < )
COMPARE( > )
COMPARE( <= )
COMPARE( >= )
bool timestamp
::operator !=( timestamp const& rhs ) const
{
return !operator == (rhs);
}
// ------------------------------------------------------------------
std::string timestamp
::pretty_print() const
{
std::stringstream str;
std::string c_tim( "" );
std::time_t tt = static_cast< std::time_t > ( this->get_time_seconds() );
std::streamsize old_prec = str.precision();
str.precision(16);
str << "ts(f: ";
if ( this->has_valid_frame() )
{
str << this->get_frame();
}
else
{
str << "<inv>";
}
str << ", t: ";
if ( this->has_valid_time() )
{
char* p = ctime( &tt ); // this may return null if <tt> is out of range,
if ( p )
{
char buffer[128];
c_tim = " (";
buffer[0] = 0;
strncpy( buffer, p, sizeof buffer );
buffer[std::strlen( buffer ) - 1] = 0; // remove NL
c_tim = c_tim + buffer;
c_tim = c_tim + ")";
str << this->get_time_usec() << c_tim;
}
else
{
str << " (time " << tt << " out of bounds?)";
}
}
else
{
str << "<inv>";
}
str << ", d: " << this->get_time_domain_index() << ")";
str.precision( old_prec );
return str.str();
}
} } // end namespace
|
#ifndef AVA_WORKER_MANAGER_SERVICE_H_
#define AVA_WORKER_MANAGER_SERVICE_H_
#include <boost/asio.hpp>
#include <map>
#include <memory>
#include <string>
#include <thread>
#include <vector>
#include "manager_service.proto.h"
#include "signal_handler.h"
namespace ava_manager {
class ManagerServiceServerBase {
public:
/**
* @brief Start a manager service that will exec a worker when a connection is
* accepted
* @param worker_argv arguments to forward to exec
*/
ManagerServiceServerBase(uint32_t manager_port, uint32_t worker_port_base,
std::string worker_path,
std::vector<std::string>& worker_argv);
void RunServer() {
std::cerr << "Manager Service listening on ::" << manager_port_
<< std::endl;
io_service_.run();
}
void StopServer() {
std::cerr << "Stopping Manager service" << std::endl;
io_service_.stop();
}
private:
void AcceptConnection();
void HandleAccept(std::unique_ptr<boost::asio::ip::tcp::socket> socket,
std::unique_ptr<boost::asio::ip::tcp::endpoint> endpoint);
boost::asio::io_service io_service_;
std::unique_ptr<boost::asio::ip::tcp::acceptor> acceptor_;
std::unique_ptr<boost::asio::ip::tcp::socket> socket_;
std::unique_ptr<boost::asio::ip::tcp::endpoint> endpoint_;
virtual ava_proto::WorkerAssignReply HandleRequest(
const ava_proto::WorkerAssignRequest& request);
protected:
virtual pid_t SpawnWorker(const std::vector<std::string>& environments,
const std::vector<std::string>& parameters);
uint32_t manager_port_;
uint32_t worker_port_base_;
std::atomic<uint32_t> worker_id_;
std::string worker_path_;
std::vector<std::string> worker_argv_;
std::map<pid_t, std::shared_ptr<std::thread>> worker_monitor_map_;
};
} // namespace ava_manager
#endif // AVA_WORKER_MANAGER_SERVICE_H_
|
// Copyright (C) 2018-2020 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include <memory>
#include <utility>
#include <vector>
#include "ie_memcpy.h"
#include "inference_engine.hpp"
template <InferenceEngine::Precision::ePrecision precision>
class BlobFactory {
public:
using BlobType = typename InferenceEngine::PrecisionTrait<precision>::value_type;
static InferenceEngine::Blob::Ptr make(const InferenceEngine::TensorDesc& desc) {
return InferenceEngine::make_shared_blob<BlobType>(desc);
}
static InferenceEngine::Blob::Ptr make(const InferenceEngine::TensorDesc& desc, void* ptr) {
return InferenceEngine::make_shared_blob<BlobType>(desc, reinterpret_cast<BlobType*>(ptr));
}
static InferenceEngine::Blob::Ptr make(const InferenceEngine::TensorDesc& desc,
const std::shared_ptr<InferenceEngine::IAllocator>& alloc) {
return InferenceEngine::make_shared_blob<BlobType>(desc, alloc);
}
};
template <InferenceEngine::Precision::ePrecision precision, class... Args>
InferenceEngine::Blob::Ptr make_shared_blob2(Args&&... args) {
return BlobFactory<precision>::make(std::forward<Args>(args)...);
}
// TODO: customize make_shared_blob2
#define USE_FACTORY(precision) \
case InferenceEngine::Precision::precision: \
return make_shared_blob2<InferenceEngine::Precision::precision>(std::forward<Args>(args)...);
INFERENCE_ENGINE_API_CPP(InferenceEngine::Blob::Ptr) make_blob_with_precision(const InferenceEngine::TensorDesc& desc);
INFERENCE_ENGINE_API_CPP(InferenceEngine::Blob::Ptr)
make_blob_with_precision(const InferenceEngine::TensorDesc& desc, void* ptr);
INFERENCE_ENGINE_API_CPP(InferenceEngine::Blob::Ptr)
make_blob_with_precision(const InferenceEngine::TensorDesc& desc,
const std::shared_ptr<InferenceEngine::IAllocator>& alloc);
INFERENCE_ENGINE_API_CPP(InferenceEngine::Blob::Ptr)
make_plain_blob(InferenceEngine::Precision prec, const InferenceEngine::SizeVector dims);
template <class... Args>
InferenceEngine::Blob::Ptr make_blob_with_precision(InferenceEngine::Precision precision, Args&&... args) {
switch (precision) {
USE_FACTORY(FP32);
USE_FACTORY(FP16);
USE_FACTORY(Q78);
USE_FACTORY(I16);
USE_FACTORY(U8);
USE_FACTORY(I8);
USE_FACTORY(U16);
USE_FACTORY(I32);
USE_FACTORY(I64);
USE_FACTORY(BIN);
USE_FACTORY(BOOL);
default:
THROW_IE_EXCEPTION << "cannot locate blob for precision: " << precision;
}
}
#undef USE_FACTORY
/**
* Create blob with custom precision
* @tparam T - type off underlined elements
* @tparam Args
* @param args
* @return
*/
template <class T, class... Args>
InferenceEngine::Blob::Ptr make_custom_blob(Args&&... args) {
return InferenceEngine::make_shared_blob<T>(InferenceEngine::Precision::fromType<T>(), std::forward<Args>(args)...);
}
/**
* Create blob with custom precision
* @tparam T - type off underlined elements
* @param args
* @return
*/
template <class T>
InferenceEngine::Blob::Ptr make_custom_blob(InferenceEngine::Layout layout, InferenceEngine::SizeVector size) {
return InferenceEngine::make_shared_blob<T>(
InferenceEngine::TensorDesc(InferenceEngine::Precision::fromType<T>(), size, layout));
}
/**
* @brief Creates a TBlob<> object from a Data node
* @param Data reference to a smart pointer of the Data node
* @return Smart pointer to TBlob<> with the relevant C type to the precision of the data node
*/
INFERENCE_ENGINE_API_CPP(InferenceEngine::Blob::Ptr) CreateBlobFromData(const InferenceEngine::DataPtr& data);
/**
* Copy data from vector to Blob
* @tparam T type of data in vector
* @return
*/
template <typename T>
void CopyVectorToBlob(const InferenceEngine::Blob::Ptr outputBlob, const std::vector<T>& inputVector) {
if (outputBlob->size() != inputVector.size()) THROW_IE_EXCEPTION << "Size mismatch between dims and vector";
if (outputBlob->element_size() != sizeof(T)) THROW_IE_EXCEPTION << "Element size mismatch between blob and vector";
ie_memcpy(outputBlob->buffer().as<T*>(), outputBlob->byteSize(), &inputVector[0], inputVector.size() * sizeof(T));
}
|
#include <windows.h>
#include <stdio.h>
int popup_message1()
{
SYSTEMTIME SystemTime;
GetSystemTime(&SystemTime);
TCHAR pszDate[200];
GetDateFormatA( LOCALE_USER_DEFAULT, DATE_LONGDATE, &SystemTime, NULL, pszDate, 200 );
return MessageBoxA(NULL, pszDate, "Test Case 1", MB_OK);
}
int popup_message2()
{
return MessageBoxW(NULL, L"Checking wide strings", L"Test Case 1", MB_OK);
}
int main()
{
if (popup_message1() == 1337) {
if (popup_message2() == 1338) {
return MessageBoxW(NULL, L"Hooking test passed", L"Test Case 1", MB_OK);
}
}
printf("Test Case 4 finished\n");
return 0;
}
|
/*
* Copyright (c) 2013-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the LICENSE
* file in the root directory of this source tree.
*
*/
#include "AnsiColorCodeStream.h"
namespace facebook {
namespace memcache {
namespace {
static const char* colorCode(Color color) {
switch (color) {
case Color::BLACK:
return "\x1b[0;30m";
case Color::DARKGRAY:
return "\x1b[30;1m";
case Color::GRAY:
return "\x1b[0;37m";
case Color::WHITE:
return "\x1b[37;1m";
case Color::RED:
return "\x1b[31;1m";
case Color::GREEN:
return "\x1b[32;1m";
case Color::YELLOW:
return "\x1b[33;1m";
case Color::BLUE:
return "\x1b[34;1m";
case Color::MAGENTA:
return "\x1b[35;1m";
case Color::CYAN:
return "\x1b[36;1m";
case Color::DARKRED:
return "\x1b[0;31m";
case Color::DARKGREEN:
return "\x1b[0;32m";
case Color::DARKYELLOW:
return "\x1b[0;33m";
case Color::DARKBLUE:
return "\x1b[0;34m";
case Color::DARKMAGENTA:
return "\x1b[0;35m";
case Color::DARKCYAN:
return "\x1b[0;36m";
case Color::DEFAULT:
default:
return "\x1b[0m";
}
}
} // anonymous
AnsiColorCodeEncoder::AnsiColorCodeEncoder(std::ostream& out)
: out_(out), isReset_(true) {}
void AnsiColorCodeEncoder::write(const StyledString& str) {
auto text = str.text();
size_t b = 0;
while (b < text.size()) {
Color currentColor = str.fgColorAt(b);
out_ << colorCode(currentColor);
/* Output the maximal string of the same color
that does not include a newline */
size_t e = b;
while (e < text.size() && text[e] != '\n' &&
str.fgColorAt(e) == currentColor) {
++e;
}
out_.write(text.begin() + b, e - b);
/* We reset color before every newline to play nicely with 'less'
and similar */
if (e < text.size() && text[e] == '\n') {
++e;
reset();
out_ << '\n';
}
b = e;
}
isReset_ = false;
}
void AnsiColorCodeEncoder::flush() const {
out_.flush();
}
void AnsiColorCodeEncoder::reset() {
out_ << colorCode(Color::DEFAULT);
isReset_ = true;
}
}
} // facebook::memcache
|
//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2011-2012. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/interprocess for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTERPROCESS_WINDOWS_NAMED_CONDITION_HPP
#define BOOST_INTERPROCESS_WINDOWS_NAMED_CONDITION_HPP
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif
#include <boost/interprocess/detail/config_begin.hpp>
#include <boost/interprocess/detail/workaround.hpp>
#include <boost/interprocess/creation_tags.hpp>
#include <boost/interprocess/permissions.hpp>
#include <boost/interprocess/detail/interprocess_tester.hpp>
#include <boost/interprocess/detail/posix_time_types_wrk.hpp>
#include <boost/interprocess/sync/windows/named_sync.hpp>
#include <boost/interprocess/sync/windows/winapi_semaphore_wrapper.hpp>
#include <boost/interprocess/sync/detail/condition_algorithm_8a.hpp>
namespace boost {
namespace interprocess {
namespace ipcdetail {
class windows_named_condition
{
/// @cond
//Non-copyable
windows_named_condition();
windows_named_condition(const windows_named_condition &);
windows_named_condition &operator=(const windows_named_condition &);
/// @endcond
public:
windows_named_condition(create_only_t, const char *name, const permissions &perm = permissions());
windows_named_condition(open_or_create_t, const char *name, const permissions &perm = permissions());
windows_named_condition(open_only_t, const char *name);
~windows_named_condition();
//!If there is a thread waiting on *this, change that
//!thread's state to ready. Otherwise there is no effect.*/
void notify_one();
//!Change the state of all threads waiting on *this to ready.
//!If there are no waiting threads, notify_all() has no effect.
void notify_all();
//!Releases the lock on the named_mutex object associated with lock, blocks
//!the current thread of execution until readied by a call to
//!this->notify_one() or this->notify_all(), and then reacquires the lock.
template <typename L>
void wait(L& lock);
//!The same as:
//!while (!pred()) wait(lock)
template <typename L, typename Pr>
void wait(L& lock, Pr pred);
//!Releases the lock on the named_mutex object associated with lock, blocks
//!the current thread of execution until readied by a call to
//!this->notify_one() or this->notify_all(), or until time abs_time is reached,
//!and then reacquires the lock.
//!Returns: false if time abs_time is reached, otherwise true.
template <typename L>
bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time);
//!The same as: while (!pred()) {
//! if (!timed_wait(lock, abs_time)) return pred();
//! } return true;
template <typename L, typename Pr>
bool timed_wait(L& lock, const boost::posix_time::ptime &abs_time, Pr pred);
static bool remove(const char *name);
/// @cond
private:
friend class interprocess_tester;
void dont_close_on_destruction();
template <class InterprocessMutex>
void do_wait(InterprocessMutex& lock);
template <class InterprocessMutex>
bool do_timed_wait(const boost::posix_time::ptime &abs_time, InterprocessMutex& lock);
struct condition_data
{
typedef boost::int32_t integer_type;
typedef winapi_semaphore_wrapper semaphore_type;
typedef winapi_mutex_wrapper mutex_type;
integer_type &get_nwaiters_blocked()
{ return m_nwaiters_blocked; }
integer_type &get_nwaiters_gone()
{ return m_nwaiters_gone; }
integer_type &get_nwaiters_to_unblock()
{ return m_nwaiters_to_unblock; }
semaphore_type &get_sem_block_queue()
{ return m_sem_block_queue; }
semaphore_type &get_sem_block_lock()
{ return m_sem_block_lock; }
mutex_type &get_mtx_unblock_lock()
{ return m_mtx_unblock_lock; }
integer_type m_nwaiters_blocked;
integer_type m_nwaiters_gone;
integer_type m_nwaiters_to_unblock;
winapi_semaphore_wrapper m_sem_block_queue;
winapi_semaphore_wrapper m_sem_block_lock;
winapi_mutex_wrapper m_mtx_unblock_lock;
} m_condition_data;
typedef condition_algorithm_8a<condition_data> algorithm_type;
class named_cond_callbacks : public windows_named_sync_interface
{
typedef __int64 sem_count_t;
mutable sem_count_t sem_counts [2];
public:
named_cond_callbacks(condition_data &cond_data)
: m_condition_data(cond_data)
{}
virtual std::size_t get_data_size() const
{ return sizeof(sem_counts); }
virtual const void *buffer_with_final_data_to_file()
{
sem_counts[0] = m_condition_data.m_sem_block_queue.value();
sem_counts[1] = m_condition_data.m_sem_block_lock.value();
return &sem_counts;
}
virtual const void *buffer_with_init_data_to_file()
{
sem_counts[0] = 0;
sem_counts[1] = 1;
return &sem_counts;
}
virtual void *buffer_to_store_init_data_from_file()
{ return &sem_counts; }
virtual bool open(create_enum_t, const char *id_name)
{
m_condition_data.m_nwaiters_blocked = 0;
m_condition_data.m_nwaiters_gone = 0;
m_condition_data.m_nwaiters_to_unblock = 0;
//Now open semaphores and mutex.
//Use local variables + swap to guarantee consistent
//initialization and cleanup in case any opening fails
permissions perm;
perm.set_unrestricted();
std::string aux_str = "Global\\bipc.cond.";
aux_str += id_name;
std::size_t pos = aux_str.size();
//sem_block_queue
aux_str += "_bq";
winapi_semaphore_wrapper sem_block_queue;
if(!sem_block_queue.open_or_create(aux_str.c_str(), sem_counts[0], perm))
return false;
aux_str.erase(pos);
//sem_block_lock
aux_str += "_bl";
winapi_semaphore_wrapper sem_block_lock;
if(!sem_block_lock.open_or_create(aux_str.c_str(), sem_counts[1], perm))
return false;
aux_str.erase(pos);
//mtx_unblock_lock
aux_str += "_ul";
winapi_mutex_wrapper mtx_unblock_lock;
if(!mtx_unblock_lock.open_or_create(aux_str.c_str(), perm))
return false;
//All ok, commit data
m_condition_data.m_sem_block_queue.swap(sem_block_queue);
m_condition_data.m_sem_block_lock.swap(sem_block_lock);
m_condition_data.m_mtx_unblock_lock.swap(mtx_unblock_lock);
return true;
}
virtual void close()
{
m_condition_data.m_sem_block_queue.close();
m_condition_data.m_sem_block_lock.close();
m_condition_data.m_mtx_unblock_lock.close();
m_condition_data.m_nwaiters_blocked = 0;
m_condition_data.m_nwaiters_gone = 0;
m_condition_data.m_nwaiters_to_unblock = 0;
}
virtual ~named_cond_callbacks()
{}
private:
condition_data &m_condition_data;
};
windows_named_sync m_named_sync;
/// @endcond
};
inline windows_named_condition::~windows_named_condition()
{
named_cond_callbacks callbacks(m_condition_data);
m_named_sync.close(callbacks);
}
inline void windows_named_condition::dont_close_on_destruction()
{}
inline windows_named_condition::windows_named_condition
(create_only_t, const char *name, const permissions &perm)
: m_condition_data()
{
named_cond_callbacks callbacks(m_condition_data);
m_named_sync.open_or_create(DoCreate, name, perm, callbacks);
}
inline windows_named_condition::windows_named_condition
(open_or_create_t, const char *name, const permissions &perm)
: m_condition_data()
{
named_cond_callbacks callbacks(m_condition_data);
m_named_sync.open_or_create(DoOpenOrCreate, name, perm, callbacks);
}
inline windows_named_condition::windows_named_condition(open_only_t, const char *name)
: m_condition_data()
{
named_cond_callbacks callbacks(m_condition_data);
m_named_sync.open_or_create(DoOpen, name, permissions(), callbacks);
}
inline void windows_named_condition::notify_one()
{ algorithm_type::signal(m_condition_data, false); }
inline void windows_named_condition::notify_all()
{ algorithm_type::signal(m_condition_data, true); }
template<class InterprocessMutex>
inline void windows_named_condition::do_wait(InterprocessMutex &mut)
{ algorithm_type::wait(m_condition_data, false, boost::posix_time::ptime(), mut); }
template<class InterprocessMutex>
inline bool windows_named_condition::do_timed_wait
(const boost::posix_time::ptime &abs_time, InterprocessMutex &mut)
{ return algorithm_type::wait(m_condition_data, true, abs_time, mut); }
template <typename L>
inline void windows_named_condition::wait(L& lock)
{
if (!lock)
throw lock_exception();
this->do_wait(*lock.mutex());
}
template <typename L, typename Pr>
inline void windows_named_condition::wait(L& lock, Pr pred)
{
if (!lock)
throw lock_exception();
while (!pred())
this->do_wait(*lock.mutex());
}
template <typename L>
inline bool windows_named_condition::timed_wait
(L& lock, const boost::posix_time::ptime &abs_time)
{
if(abs_time == boost::posix_time::pos_infin){
this->wait(lock);
return true;
}
if (!lock)
throw lock_exception();
return this->do_timed_wait(abs_time, *lock.mutex());
}
template <typename L, typename Pr>
inline bool windows_named_condition::timed_wait
(L& lock, const boost::posix_time::ptime &abs_time, Pr pred)
{
if(abs_time == boost::posix_time::pos_infin){
this->wait(lock, pred);
return true;
}
if (!lock)
throw lock_exception();
while (!pred()){
if(!this->do_timed_wait(abs_time, *lock.mutex())){
return pred();
}
}
return true;
}
inline bool windows_named_condition::remove(const char *name)
{
return windows_named_sync::remove(name);
}
} //namespace ipcdetail {
} //namespace interprocess {
} //namespace boost {
#include <boost/interprocess/detail/config_end.hpp>
#endif //BOOST_INTERPROCESS_WINDOWS_NAMED_CONDITION_HPP
|
/**
Copyright (c) 2015-present, Facebook, Inc.
All rights reserved.
This source code is licensed under the BSD-style license found in the
LICENSE file in the root directory of this source tree. An additional grant
of patent rights can be found in the PATENTS file in the same directory.
*/
#include <acdriver/Compile/Asset.h>
#include <acdriver/Compile/AppIconSet.h>
#include <acdriver/Compile/BrandAssets.h>
#include <acdriver/Compile/ComplicationSet.h>
#include <acdriver/Compile/DataSet.h>
#include <acdriver/Compile/GCDashboardImage.h>
#include <acdriver/Compile/GCLeaderboard.h>
#include <acdriver/Compile/GCLeaderboardSet.h>
#include <acdriver/Compile/IconSet.h>
#include <acdriver/Compile/ImageSet.h>
#include <acdriver/Compile/ImageStack.h>
#include <acdriver/Compile/ImageStackLayer.h>
#include <acdriver/Compile/LaunchImage.h>
#include <acdriver/Compile/SpriteAtlas.h>
#include <acdriver/Compile/Output.h>
#include <acdriver/Result.h>
#include <xcassets/Asset/Catalog.h>
#include <xcassets/Asset/Group.h>
#include <libutil/Filesystem.h>
#include <libutil/FSUtil.h>
using acdriver::Compile::Asset;
using acdriver::Compile::AppIconSet;
using acdriver::Compile::BrandAssets;
using acdriver::Compile::ComplicationSet;
using acdriver::Compile::DataSet;
using acdriver::Compile::GCDashboardImage;
using acdriver::Compile::GCLeaderboard;
using acdriver::Compile::GCLeaderboardSet;
using acdriver::Compile::IconSet;
using acdriver::Compile::ImageSet;
using acdriver::Compile::ImageStack;
using acdriver::Compile::ImageStackLayer;
using acdriver::Compile::LaunchImage;
using acdriver::Compile::SpriteAtlas;
using acdriver::Compile::Output;
using acdriver::Result;
using libutil::Filesystem;
using libutil::FSUtil;
template<typename T>
static bool
CompileChildren(
std::vector<T> const &assets,
std::shared_ptr<xcassets::Asset::Asset> const &asset,
Filesystem *filesystem,
Output *compileOutput,
Result *result)
{
bool success = true;
for (auto const &asset : assets) {
if (!Asset::Compile(asset, filesystem, compileOutput, result)) {
success = false;
}
}
return success;
}
bool Asset::
Compile(
std::shared_ptr<xcassets::Asset::Asset> const &asset,
Filesystem *filesystem,
Output *compileOutput,
Result *result)
{
std::string filename = FSUtil::GetBaseName(asset->path());
std::string name = FSUtil::GetBaseNameWithoutExtension(filename);
switch (asset->type()) {
case xcassets::Asset::AssetType::AppIconSet: {
auto appIconSet = std::static_pointer_cast<xcassets::Asset::AppIconSet>(asset);
if (appIconSet->name().name() == compileOutput->appIcon()) {
Compile::AppIconSet::Compile(appIconSet, compileOutput, result);
}
break;
}
case xcassets::Asset::AssetType::BrandAssets: {
auto brandAssets = std::static_pointer_cast<xcassets::Asset::BrandAssets>(asset);
Compile::BrandAssets::Compile(brandAssets, filesystem, compileOutput, result);
CompileChildren(brandAssets->children(), asset, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::Catalog: {
auto catalog = std::static_pointer_cast<xcassets::Asset::Catalog>(asset);
CompileChildren(catalog->children(), asset, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::ComplicationSet: {
auto complicationSet = std::static_pointer_cast<xcassets::Asset::ComplicationSet>(asset);
Compile::ComplicationSet::Compile(complicationSet, filesystem, compileOutput, result);
CompileChildren(complicationSet->children(), asset, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::DataSet: {
auto dataSet = std::static_pointer_cast<xcassets::Asset::DataSet>(asset);
Compile::DataSet::Compile(dataSet, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::GCDashboardImage: {
auto dashboardImage = std::static_pointer_cast<xcassets::Asset::GCDashboardImage>(asset);
Compile::GCDashboardImage::Compile(dashboardImage, filesystem, compileOutput, result);
CompileChildren(dashboardImage->children(), asset, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::GCLeaderboard: {
auto leaderboard = std::static_pointer_cast<xcassets::Asset::GCLeaderboard>(asset);
Compile::GCLeaderboard::Compile(leaderboard, filesystem, compileOutput, result);
CompileChildren(leaderboard->children(), asset, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::GCLeaderboardSet: {
auto leaderboardSet = std::static_pointer_cast<xcassets::Asset::GCLeaderboardSet>(asset);
Compile::GCLeaderboardSet::Compile(leaderboardSet, filesystem, compileOutput, result);
CompileChildren(leaderboardSet->children(), asset, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::Group: {
auto group = std::static_pointer_cast<xcassets::Asset::Group>(asset);
CompileChildren(group->children(), asset, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::IconSet: {
auto iconSet = std::static_pointer_cast<xcassets::Asset::IconSet>(asset);
Compile::IconSet::Compile(iconSet, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::ImageSet: {
auto imageSet = std::static_pointer_cast<xcassets::Asset::ImageSet>(asset);
Compile::ImageSet::Compile(imageSet, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::ImageStack: {
auto imageStack = std::static_pointer_cast<xcassets::Asset::ImageStack>(asset);
Compile::ImageStack::Compile(imageStack, filesystem, compileOutput, result);
CompileChildren(imageStack->children(), asset, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::ImageStackLayer: {
auto imageStackLayer = std::static_pointer_cast<xcassets::Asset::ImageStackLayer>(asset);
Compile::ImageStackLayer::Compile(imageStackLayer, filesystem, compileOutput, result);
// TODO: CompileChildren(imageStackLayer->children(), asset, filesystem, compileOutput, result);
break;
}
case xcassets::Asset::AssetType::LaunchImage: {
auto launchImage = std::static_pointer_cast<xcassets::Asset::LaunchImage>(asset);
if (launchImage->name().name() == compileOutput->launchImage()) {
Compile::LaunchImage::Compile(launchImage, compileOutput, result);
}
break;
}
case xcassets::Asset::AssetType::SpriteAtlas: {
auto spriteAtlas = std::static_pointer_cast<xcassets::Asset::SpriteAtlas>(asset);
Compile::SpriteAtlas::Compile(spriteAtlas, filesystem, compileOutput, result);
CompileChildren(spriteAtlas->children(), asset, filesystem, compileOutput, result);
break;
}
}
return true;
}
|
/*
* Copyright (C) 2005 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define __STDC_LIMIT_MACROS
#include <stdint.h>
#include <utils/String8.h>
#include <utils/Compat.h>
#include <utils/Log.h>
#include <utils/String16.h>
#include <ctype.h>
#include "SharedBuffer.h"
/*
* Functions outside android is below the namespace android, since they use
* functions and constants in android namespace.
*/
// ---------------------------------------------------------------------------
namespace android {
// Separator used by resource paths. This is not platform dependent contrary
// to OS_PATH_SEPARATOR.
#define RES_PATH_SEPARATOR '/'
static SharedBuffer* gEmptyStringBuf = NULL;
static char* gEmptyString = NULL;
extern int gDarwinCantLoadAllObjects;
int gDarwinIsReallyAnnoying;
void initialize_string8();
static inline char* getEmptyString()
{
gEmptyStringBuf->acquire();
return gEmptyString;
}
void initialize_string8()
{
// HACK: This dummy dependency forces linking libutils Static.cpp,
// which is needed to initialize String8/String16 classes.
// These variables are named for Darwin, but are needed elsewhere too,
// including static linking on any platform.
gDarwinIsReallyAnnoying = gDarwinCantLoadAllObjects;
SharedBuffer* buf = SharedBuffer::alloc(1);
char* str = (char*)buf->data();
*str = 0;
gEmptyStringBuf = buf;
gEmptyString = str;
}
void terminate_string8()
{
SharedBuffer::bufferFromData(gEmptyString)->release();
gEmptyStringBuf = NULL;
gEmptyString = NULL;
}
// ---------------------------------------------------------------------------
static char* allocFromUTF8(const char* in, size_t len)
{
if (len > 0) {
if (len == SIZE_MAX) {
return NULL;
}
SharedBuffer* buf = SharedBuffer::alloc(len+1);
if (buf) {
char* str = (char*)buf->data();
memcpy(str, in, len);
str[len] = 0;
return str;
}
return NULL;
}
return getEmptyString();
}
static char* allocFromUTF16(const char16_t* in, size_t len)
{
if (len == 0) return getEmptyString();
// Allow for closing '\0'
const ssize_t resultStrLen = utf16_to_utf8_length(in, len) + 1;
if (resultStrLen < 1) {
return getEmptyString();
}
SharedBuffer* buf = SharedBuffer::alloc(resultStrLen);
if (!buf) {
return getEmptyString();
}
char* resultStr = (char*)buf->data();
utf16_to_utf8(in, len, resultStr, resultStrLen);
return resultStr;
}
static char* allocFromUTF32(const char32_t* in, size_t len)
{
if (len == 0) {
return getEmptyString();
}
const ssize_t resultStrLen = utf32_to_utf8_length(in, len) + 1;
if (resultStrLen < 1) {
return getEmptyString();
}
SharedBuffer* buf = SharedBuffer::alloc(resultStrLen);
if (!buf) {
return getEmptyString();
}
char* resultStr = (char*) buf->data();
utf32_to_utf8(in, len, resultStr, resultStrLen);
return resultStr;
}
// ---------------------------------------------------------------------------
String8::String8()
: mString(getEmptyString())
{
}
String8::String8(StaticLinkage)
: mString(0)
{
// this constructor is used when we can't rely on the static-initializers
// having run. In this case we always allocate an empty string. It's less
// efficient than using getEmptyString(), but we assume it's uncommon.
char* data = static_cast<char*>(
SharedBuffer::alloc(sizeof(char))->data());
data[0] = 0;
mString = data;
}
String8::String8(const String8& o)
: mString(o.mString)
{
SharedBuffer::bufferFromData(mString)->acquire();
}
String8::String8(const char* o)
: mString(allocFromUTF8(o, strlen(o)))
{
if (mString == NULL) {
mString = getEmptyString();
}
}
String8::String8(const char* o, size_t len)
: mString(allocFromUTF8(o, len))
{
if (mString == NULL) {
mString = getEmptyString();
}
}
String8::String8(const String16& o)
: mString(allocFromUTF16(o.string(), o.size()))
{
}
String8::String8(const char16_t* o)
: mString(allocFromUTF16(o, strlen16(o)))
{
}
String8::String8(const char16_t* o, size_t len)
: mString(allocFromUTF16(o, len))
{
}
String8::String8(const char32_t* o)
: mString(allocFromUTF32(o, strlen32(o)))
{
}
String8::String8(const char32_t* o, size_t len)
: mString(allocFromUTF32(o, len))
{
}
String8::~String8()
{
SharedBuffer::bufferFromData(mString)->release();
}
size_t String8::length() const
{
return SharedBuffer::sizeFromData(mString)-1;
}
String8 String8::format(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
String8 result(formatV(fmt, args));
va_end(args);
return result;
}
String8 String8::formatV(const char* fmt, va_list args)
{
String8 result;
result.appendFormatV(fmt, args);
return result;
}
void String8::clear() {
SharedBuffer::bufferFromData(mString)->release();
mString = getEmptyString();
}
void String8::setTo(const String8& other)
{
SharedBuffer::bufferFromData(other.mString)->acquire();
SharedBuffer::bufferFromData(mString)->release();
mString = other.mString;
}
status_t String8::setTo(const char* other)
{
const char *newString = allocFromUTF8(other, strlen(other));
SharedBuffer::bufferFromData(mString)->release();
mString = newString;
if (mString) return NO_ERROR;
mString = getEmptyString();
return NO_MEMORY;
}
status_t String8::setTo(const char* other, size_t len)
{
const char *newString = allocFromUTF8(other, len);
SharedBuffer::bufferFromData(mString)->release();
mString = newString;
if (mString) return NO_ERROR;
mString = getEmptyString();
return NO_MEMORY;
}
status_t String8::setTo(const char16_t* other, size_t len)
{
const char *newString = allocFromUTF16(other, len);
SharedBuffer::bufferFromData(mString)->release();
mString = newString;
if (mString) return NO_ERROR;
mString = getEmptyString();
return NO_MEMORY;
}
status_t String8::setTo(const char32_t* other, size_t len)
{
const char *newString = allocFromUTF32(other, len);
SharedBuffer::bufferFromData(mString)->release();
mString = newString;
if (mString) return NO_ERROR;
mString = getEmptyString();
return NO_MEMORY;
}
status_t String8::append(const String8& other)
{
const size_t otherLen = other.bytes();
if (bytes() == 0) {
setTo(other);
return NO_ERROR;
} else if (otherLen == 0) {
return NO_ERROR;
}
return real_append(other.string(), otherLen);
}
status_t String8::append(const char* other)
{
return append(other, strlen(other));
}
status_t String8::append(const char* other, size_t otherLen)
{
if (bytes() == 0) {
return setTo(other, otherLen);
} else if (otherLen == 0) {
return NO_ERROR;
}
return real_append(other, otherLen);
}
status_t String8::appendFormat(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
status_t result = appendFormatV(fmt, args);
va_end(args);
return result;
}
status_t String8::appendFormatV(const char* fmt, va_list args)
{
int n, result = NO_ERROR;
va_list tmp_args;
/* args is undefined after vsnprintf.
* So we need a copy here to avoid the
* second vsnprintf access undefined args.
*/
va_copy(tmp_args, args);
n = vsnprintf(NULL, 0, fmt, tmp_args);
va_end(tmp_args);
if (n != 0) {
size_t oldLength = length();
char* buf = lockBuffer(oldLength + n);
if (buf) {
vsnprintf(buf + oldLength, n + 1, fmt, args);
} else {
result = NO_MEMORY;
}
}
return result;
}
status_t String8::real_append(const char* other, size_t otherLen)
{
const size_t myLen = bytes();
SharedBuffer* buf = SharedBuffer::bufferFromData(mString)
->editResize(myLen+otherLen+1);
if (buf) {
char* str = (char*)buf->data();
mString = str;
str += myLen;
memcpy(str, other, otherLen);
str[otherLen] = '\0';
return NO_ERROR;
}
return NO_MEMORY;
}
char* String8::lockBuffer(size_t size)
{
SharedBuffer* buf = SharedBuffer::bufferFromData(mString)
->editResize(size+1);
if (buf) {
char* str = (char*)buf->data();
mString = str;
return str;
}
return NULL;
}
void String8::unlockBuffer()
{
unlockBuffer(strlen(mString));
}
status_t String8::unlockBuffer(size_t size)
{
if (size != this->size()) {
SharedBuffer* buf = SharedBuffer::bufferFromData(mString)
->editResize(size+1);
if (! buf) {
return NO_MEMORY;
}
char* str = (char*)buf->data();
str[size] = 0;
mString = str;
}
return NO_ERROR;
}
ssize_t String8::find(const char* other, size_t start) const
{
size_t len = size();
if (start >= len) {
return -1;
}
const char* s = mString+start;
const char* p = strstr(s, other);
return p ? p-mString : -1;
}
bool String8::removeAll(const char* other) {
ssize_t index = find(other);
if (index < 0) return false;
char* buf = lockBuffer(size());
if (!buf) return false; // out of memory
size_t skip = strlen(other);
size_t len = size();
size_t tail = index;
while (size_t(index) < len) {
ssize_t next = find(other, index + skip);
if (next < 0) {
next = len;
}
memmove(buf + tail, buf + index + skip, next - index - skip);
tail += next - index - skip;
index = next;
}
unlockBuffer(tail);
return true;
}
void String8::toLower()
{
toLower(0, size());
}
void String8::toLower(size_t start, size_t length)
{
const size_t len = size();
if (start >= len) {
return;
}
if (start+length > len) {
length = len-start;
}
char* buf = lockBuffer(len);
buf += start;
while (length > 0) {
*buf = tolower(*buf);
buf++;
length--;
}
unlockBuffer(len);
}
void String8::toUpper()
{
toUpper(0, size());
}
void String8::toUpper(size_t start, size_t length)
{
const size_t len = size();
if (start >= len) {
return;
}
if (start+length > len) {
length = len-start;
}
char* buf = lockBuffer(len);
buf += start;
while (length > 0) {
*buf = toupper(*buf);
buf++;
length--;
}
unlockBuffer(len);
}
size_t String8::getUtf32Length() const
{
return utf8_to_utf32_length(mString, length());
}
int32_t String8::getUtf32At(size_t index, size_t *next_index) const
{
return utf32_from_utf8_at(mString, length(), index, next_index);
}
void String8::getUtf32(char32_t* dst) const
{
utf8_to_utf32(mString, length(), dst);
}
// ---------------------------------------------------------------------------
// Path functions
void String8::setPathName(const char* name)
{
setPathName(name, strlen(name));
}
void String8::setPathName(const char* name, size_t len)
{
char* buf = lockBuffer(len);
memcpy(buf, name, len);
// remove trailing path separator, if present
if (len > 0 && buf[len-1] == OS_PATH_SEPARATOR)
len--;
buf[len] = '\0';
unlockBuffer(len);
}
String8 String8::getPathLeaf(void) const
{
const char* cp;
const char*const buf = mString;
cp = strrchr(buf, OS_PATH_SEPARATOR);
if (cp == NULL)
return String8(*this);
else
return String8(cp+1);
}
String8 String8::getPathDir(void) const
{
const char* cp;
const char*const str = mString;
cp = strrchr(str, OS_PATH_SEPARATOR);
if (cp == NULL)
return String8("");
else
return String8(str, cp - str);
}
String8 String8::walkPath(String8* outRemains) const
{
const char* cp;
const char*const str = mString;
const char* buf = str;
cp = strchr(buf, OS_PATH_SEPARATOR);
if (cp == buf) {
// don't include a leading '/'.
buf = buf+1;
cp = strchr(buf, OS_PATH_SEPARATOR);
}
if (cp == NULL) {
String8 res = buf != str ? String8(buf) : *this;
if (outRemains) *outRemains = String8("");
return res;
}
String8 res(buf, cp-buf);
if (outRemains) *outRemains = String8(cp+1);
return res;
}
/*
* Helper function for finding the start of an extension in a pathname.
*
* Returns a pointer inside mString, or NULL if no extension was found.
*/
char* String8::find_extension(void) const
{
const char* lastSlash;
const char* lastDot;
const char* const str = mString;
// only look at the filename
lastSlash = strrchr(str, OS_PATH_SEPARATOR);
if (lastSlash == NULL)
lastSlash = str;
else
lastSlash++;
// find the last dot
lastDot = strrchr(lastSlash, '.');
if (lastDot == NULL)
return NULL;
// looks good, ship it
return const_cast<char*>(lastDot);
}
String8 String8::getPathExtension(void) const
{
char* ext;
ext = find_extension();
if (ext != NULL)
return String8(ext);
else
return String8("");
}
String8 String8::getBasePath(void) const
{
char* ext;
const char* const str = mString;
ext = find_extension();
if (ext == NULL)
return String8(*this);
else
return String8(str, ext - str);
}
String8& String8::appendPath(const char* name)
{
// TODO: The test below will fail for Win32 paths. Fix later or ignore.
if (name[0] != OS_PATH_SEPARATOR) {
if (*name == '\0') {
// nothing to do
return *this;
}
size_t len = length();
if (len == 0) {
// no existing filename, just use the new one
setPathName(name);
return *this;
}
// make room for oldPath + '/' + newPath
int newlen = strlen(name);
char* buf = lockBuffer(len+1+newlen);
// insert a '/' if needed
if (buf[len-1] != OS_PATH_SEPARATOR)
buf[len++] = OS_PATH_SEPARATOR;
memcpy(buf+len, name, newlen+1);
len += newlen;
unlockBuffer(len);
return *this;
} else {
setPathName(name);
return *this;
}
}
String8& String8::convertToResPath()
{
#if OS_PATH_SEPARATOR != RES_PATH_SEPARATOR
size_t len = length();
if (len > 0) {
char * buf = lockBuffer(len);
for (char * end = buf + len; buf < end; ++buf) {
if (*buf == OS_PATH_SEPARATOR)
*buf = RES_PATH_SEPARATOR;
}
unlockBuffer(len);
}
#endif
return *this;
}
}; // namespace android
|
//
// EpVector3.cpp
// EpMath
//
// Created by Joshua Pacana on 6/3/16.
// Copyright © 2016 Pacana. All rights reserved.
//
#include "EpVector3.hpp"
#include <iostream>
#include <cmath>
EpVector3::EpVector3()
{
mElements[0] = 0.0;
mElements[1] = 0.0;
mElements[2] = 0.0;
}
EpVector3::EpVector3(float x, float y, float z)
{
mElements[0] = x;
mElements[1] = y;
mElements[2] = z;
}
void
EpVector3::print()
{
std::cout << mElements[0] << " " << mElements[1] << " " << mElements[2] << std::endl;
}
|
#ifndef QML_JULIA_PROPERTY_MAP_H
#define QML_JULIA_PROPERTY_MAP_H
#include "jlcxx/jlcxx.hpp"
#include <QQmlPropertyMap>
namespace qmlwrap
{
/// Multimedia display for Julia
class JuliaPropertyMap : public QQmlPropertyMap
{
public:
JuliaPropertyMap(QObject* parent = nullptr);
virtual ~JuliaPropertyMap();
jl_value_t* julia_value() { return m_julia_value; }
void set_julia_value(jl_value_t* val);
private:
// This corresponds to the Julia object, which itself holds this JuliaPropertyMap together with a Dict
jl_value_t* m_julia_value = nullptr;
};
} // namespace qmlwrap
#endif
|
// -----------------------------------------------------------------------------------------------
//
// This file is part of a free package distributed by Dr TS Kelso, tkelso@grove.net in his web site
// at http://www.grove.net/~tkelso/
//
// This system carries two-line orbital data (*.tle files with the master list being tle.new)
// and the following key programs:
//
//* spacetrk.zip (LaTeX documentation and FORTRAN source code for the NORAD
// orbital models needed for using the two-line element sets),
//* sat-db13.zip (a complete database of all payloads launched into orbit),
//* sgp4-pl2.zip (a library of Turbo Pascal units to implement SGP4/SDP4),
//* trakstr2.zip (an implementation of sgp4-pl2 to output satellite ECI
// position, subpoint, look angles, and right ascension/declination),
//* passupdt.zip (a package for quickly and easily updating two-line element
// sets), and
//* unzip (a Sun executable for unzipping these programs).
//
// More information on the first five files is available in the file master.dir.
//
//
//- Dr TS Kelso, tkelso@grove.net
// Adjunct Professor of Space Operations
// Air Force Institute of Technology
// SYSOP, Celestial WWW
// http://www.grove.net/~tkelso/
//
// -----------------------------------------------------------------------------------------------
#include <math.h>
#include "norad.h"
#include "norad_in.h"
#define x3thm1 params[0]
#define x1mth2 params[1]
#define c1 params[2]
#define c4 params[3]
#define xnodcf params[4]
#define t2cof params[5]
#define xlcof params[6]
#define aycof params[7]
#define x7thm1 params[8]
#define p_aodp params[9]
#define p_cosio params[10]
#define p_sinio params[11]
#define p_omgdot params[12]
#define p_xmdot params[13]
#define p_xnodot params[14]
#define p_xnodp params[15]
#define c5 params[16]
#define d2 params[17]
#define d3 params[18]
#define d4 params[19]
#define delmo params[20]
#define p_eta params[21]
#define omgcof params[22]
#define sinmo params[23]
#define t3cof params[24]
#define t4cof params[25]
#define t5cof params[26]
#define xmcof params[27]
#define simple_flag *((int *)( params + 28))
#define MINIMAL_E 1.e-9
void DLL_FUNC SGP4_init( double *params, const tle_t *tle)
{
deep_arg_t deep_arg;
init_t init;
double eeta, etasq;
sxpx_common_init( params, tle, &init, &deep_arg);
p_aodp = deep_arg.aodp;
p_cosio = deep_arg.cosio;
p_sinio = deep_arg.sinio;
p_omgdot = deep_arg.omgdot;
p_xmdot = deep_arg.xmdot;
p_xnodot = deep_arg.xnodot;
p_xnodp = deep_arg.xnodp;
p_eta = deep_arg.aodp*tle->eo*init.tsi;
// p_eta = init.eta;
eeta = tle->eo*p_eta;
/* For perigee less than 220 kilometers, the "simple" flag is set */
/* and the equations are truncated to linear variation in sqrt a */
/* and quadratic variation in mean anomaly. Also, the c3 term, */
/* the delta omega term, and the delta m term are dropped. */
if((p_aodp*(1-tle->eo)/ae) < (220/xkmper+ae))
simple_flag = 1;
else
{
const double c1sq = c1*c1;
double temp, c3;
simple_flag = 0;
delmo = 1. + p_eta * cos(tle->xmo);
delmo *= delmo * delmo;
d2 = 4*p_aodp*init.tsi*c1sq;
temp = d2*init.tsi*c1/3;
d3 = (17*p_aodp+init.s4)*temp;
d4 = 0.5*temp*p_aodp*init.tsi*(221*p_aodp+31*init.s4)*c1;
t3cof = d2+2*c1sq;
t4cof = 0.25*(3*d3+c1*(12*d2+10*c1sq));
t5cof = 0.2*(3*d4+12*c1*d3+6*d2*d2+15*c1sq*(2*d2+c1sq));
sinmo = sin(tle->xmo);
c3 = init.coef*init.tsi*init.a3ovk2*p_xnodp*ae*p_sinio;
if( tle->eo < MINIMAL_E)
{
eeta = MINIMAL_E * MINIMAL_E * p_aodp * init.tsi;
c3 /= MINIMAL_E;
}
else
c3 /= tle->eo;
xmcof = -two_thirds*init.coef*tle->bstar*ae / eeta;
/* 17 Aug 2002: added a check for zero eccentricity: */
omgcof = tle->bstar*c3*cos(tle->omegao);
} /* End of if (isFlagClear(SIMPLE_FLAG)) */
etasq = p_eta * p_eta;
c5 = 2*init.coef1*p_aodp * deep_arg.betao2*(1+2.75*(etasq+eeta)+eeta*etasq);
} /* End of SGP4() initialization */
void DLL_FUNC SGP4( const double tsince, const tle_t *tle, const double *params,
double *pos, double *vel)
{
double
a, e, omega, omgadf,
temp, tempa, tempe, templ, tsq,
xl, xmdf, xmp, xnoddf, xnode;
/* Update for secular gravity and atmospheric drag. */
xmdf = tle->xmo+p_xmdot*tsince;
omgadf = tle->omegao+p_omgdot*tsince;
xnoddf = tle->xnodeo+p_xnodot*tsince;
omega = omgadf;
xmp = xmdf;
tsq = tsince*tsince;
xnode = xnoddf+xnodcf*tsq;
tempa = 1-c1*tsince;
tempe = tle->bstar*c4*tsince;
templ = t2cof*tsq;
if( !simple_flag)
{
const double delomg = omgcof*tsince;
double delm = 1. + p_eta * cos(xmdf);
double tcube, tfour;
delm = xmcof * (delm * delm * delm - delmo);
temp = delomg+delm;
xmp = xmdf+temp;
omega = omgadf-temp;
tcube = tsq*tsince;
tfour = tsince*tcube;
tempa = tempa-d2*tsq-d3*tcube-d4*tfour;
tempe = tempe+tle->bstar*c5*(sin(xmp)-sinmo);
templ = templ+t3cof*tcube+tfour*(t4cof+tsince*t5cof);
}; /* End of if (isFlagClear(SIMPLE_FLAG)) */
a = p_aodp*tempa*tempa;
e = tle->eo-tempe;
xl = xmp+omega+xnode+p_xnodp*templ;
sxpx_posn_vel( xnode, a, e, params, p_cosio, p_sinio, tle->xincl,
omega, xl, pos, vel);
} /*SGP4*/
|
/*=========================================================================
Library: TubeTK
Copyright 2010 Kitware Inc. 28 Corporate Drive,
Clifton Park, NY, 12065, USA.
All rights reserved.
Licensed under the Apache License, Version 2.0 ( the "License" );
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
=========================================================================*/
#ifndef __itktubeVectorImageToListGenerator_hxx
#define __itktubeVectorImageToListGenerator_hxx
#include "itktubeVectorImageToListGenerator.h"
#include <itkImageRegionConstIterator.h>
namespace itk
{
namespace tube
{
namespace Statistics
{
template< class TImage, class TMaskImage >
VectorImageToListGenerator< TImage, TMaskImage >
::VectorImageToListGenerator( void )
{
m_UseSingleMaskValue = false;
m_MaskValue = 1;
this->SetNumberOfRequiredInputs( 1 );
this->SetNumberOfRequiredOutputs( 1 );
typename ListSampleOutputType::Pointer listSampleDecorator =
static_cast< ListSampleOutputType * >( this->MakeOutput( 0 ).GetPointer() );
this->ProcessObject::SetNthOutput( 0, listSampleDecorator.GetPointer() );
}
template< class TImage, class TMaskImage >
void
VectorImageToListGenerator< TImage, TMaskImage >
::PrintSelf( std::ostream& os, Indent indent ) const
{
Superclass::PrintSelf( os, indent );
os << indent << "MaskValue: "
<< static_cast<typename NumericTraits<MaskPixelType>::PrintType>(
m_MaskValue )
<< std::endl;
if( m_UseSingleMaskValue )
{
os << indent << "UseSingleMaskValue: True" << std::endl;
}
else
{
os << indent << "UseSingleMaskValue: False" << std::endl;
}
}
template< class TImage, class TMaskImage >
void
VectorImageToListGenerator< TImage, TMaskImage >
::SetInput( const ImageType* image )
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput( 0,
const_cast< ImageType* >( image ) );
}
template< class TImage, class TMaskImage >
void
VectorImageToListGenerator< TImage, TMaskImage >
::SetMaskImage( const MaskImageType* image )
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput( 1,
const_cast< MaskImageType* >( image ) );
}
template< class TImage, class TMaskImage >
void
VectorImageToListGenerator< TImage, TMaskImage >
::SetMaskValue( const MaskPixelType maskValue )
{
m_MaskValue = maskValue;
m_UseSingleMaskValue = true;
this->Modified();
}
template< class TImage, class TMaskImage >
const TImage*
VectorImageToListGenerator< TImage, TMaskImage >
::GetInput( void ) const
{
if( this->GetNumberOfInputs() < 1 )
{
return 0;
}
return static_cast<const ImageType * >
( this->ProcessObject::GetInput( 0 ) );
}
template< class TImage, class TMaskImage >
const TMaskImage*
VectorImageToListGenerator< TImage, TMaskImage >
::GetMaskImage( void ) const
{
if( this->GetNumberOfInputs() < 2 )
{
return 0;
}
return static_cast<const MaskImageType * >
( this->ProcessObject::GetInput( 1 ) );
}
template< class TImage, class TMaskImage >
typename VectorImageToListGenerator< TImage, TMaskImage >::DataObjectPointer
VectorImageToListGenerator< TImage, TMaskImage >
::MakeOutput( DataObjectPointerArraySizeType itkNotUsed( idx ) )
{
typename ListSampleOutputType::Pointer decoratedOutput =
ListSampleOutputType::New();
decoratedOutput->Set( ListSampleType::New() );
return static_cast< DataObject * >( decoratedOutput.GetPointer() );
}
template< class TImage, class TMaskImage >
void
VectorImageToListGenerator< TImage, TMaskImage >
::GenerateData( void )
{
ListSampleOutputType * decoratedOutput =
static_cast< ListSampleOutputType * >(
this->ProcessObject::GetOutput( 0 ) );
ListSampleType *output =
const_cast< ListSampleType * >( decoratedOutput->Get() );
const ImageType *input = this->GetInput();
MaskImageType *maskImage = NULL;
output->Clear();
if( this->GetNumberOfInputs() > 1 )
{
maskImage = const_cast< MaskImageType * >( this->GetMaskImage() );
}
typedef ImageRegionConstIterator< ImageType > IteratorType;
IteratorType it( input, input->GetBufferedRegion() );
it.GoToBegin();
if( maskImage ) // mask specified
{
if( m_UseSingleMaskValue )
{
typedef ImageRegionConstIterator< MaskImageType > MaskIteratorType;
MaskIteratorType mit( maskImage, maskImage->GetBufferedRegion() );
mit.GoToBegin();
while( !it.IsAtEnd() )
{
if( mit.Get() == this->m_MaskValue )
{
MeasurementVectorType m;
m = it.Get();
output->PushBack( m );
}
++mit;
++it;
}
}
else
{
typedef ImageRegionConstIterator< MaskImageType > MaskIteratorType;
MaskIteratorType mit( maskImage, maskImage->GetBufferedRegion() );
mit.GoToBegin();
while( !it.IsAtEnd() )
{
if( mit.Get() != 0 )
{
MeasurementVectorType m;
m = it.Get();
output->PushBack( m );
}
++mit;
++it;
}
}
}
else // no mask specified
{
while( !it.IsAtEnd() )
{
MeasurementVectorType m;
m = it.Get();
output->PushBack( m );
++it;
}
}
}
template< class TImage, class TMaskImage >
void
VectorImageToListGenerator< TImage, TMaskImage >
::GenerateOutputInformation( void )
{
Superclass::GenerateOutputInformation();
ListSampleOutputType * decoratedOutput =
static_cast< ListSampleOutputType * >(
this->ProcessObject::GetOutput( 0 ) );
ListSampleType *output =
const_cast< ListSampleType *>( decoratedOutput->Get() );
output->SetMeasurementVectorSize(
itkGetStaticConstMacro( MeasurementVectorSize ) );
}
template< class TImage, class TMaskImage >
void
VectorImageToListGenerator< TImage, TMaskImage >
::GenerateInputRequestedRegion() throw( InvalidRequestedRegionError )
{
// call the superclass' implementation of this method. this should
// copy the output requested region to the input requested region
Superclass::GenerateInputRequestedRegion();
// Make sure that the mask's requested region, if specified is at least
// as large as the input image's buffered region. If not funny things can
// happen such as the mask iterator going out of bounds etc..
//
// TODO: Why don't most other ITK filters that take multiple inputs check
// for this ?
//
if( this->GetNumberOfInputs() > 1 )
{
MaskImageType *maskImage = const_cast< MaskImageType * >(
this->GetMaskImage() );
ImageType *image = const_cast< ImageType * >(
this->GetInput() );
if( !image->GetBufferedRegion().IsInside(
maskImage->GetBufferedRegion() ) )
{
maskImage->SetRequestedRegion( image->GetBufferedRegion() );
}
}
}
template< class TImage, class TMaskImage >
const typename VectorImageToListGenerator< TImage, TMaskImage >
::ListSampleType *
VectorImageToListGenerator< TImage, TMaskImage >
::GetListSample( void ) const
{
const ListSampleOutputType * decoratedOutput =
static_cast< const ListSampleOutputType * >(
this->ProcessObject::GetOutput( 0 ) );
return decoratedOutput->Get();
}
} // End namespace Statistics
} // End namespace tube
} // End namespace itk
#endif // End !defined( __itktubeVectorImageToListGenerator_hxx )
|
/*
* Copyright (C) 2019-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_container/cmdcontainer.h"
#include "shared/test/common/fixtures/device_fixture.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/mocks/mock_graphics_allocation.h"
#include "shared/test/common/mocks/mock_memory_manager.h"
#include "test.h"
using namespace NEO;
constexpr uint32_t defaultNumIddsPerBlock = 64;
class CommandContainerTest : public DeviceFixture,
public ::testing::Test {
public:
void SetUp() override {
::testing::Test::SetUp();
DeviceFixture::SetUp();
}
void TearDown() override {
DeviceFixture::TearDown();
::testing::Test::TearDown();
}
};
struct CommandContainerHeapStateTests : public ::testing::Test {
class MyMockCommandContainer : public CommandContainer {
public:
using CommandContainer::dirtyHeaps;
};
MyMockCommandContainer myCommandContainer;
};
TEST_F(CommandContainerHeapStateTests, givenDirtyHeapsWhenSettingStateForAllThenValuesAreCorrect) {
EXPECT_EQ(std::numeric_limits<uint32_t>::max(), myCommandContainer.dirtyHeaps);
EXPECT_TRUE(myCommandContainer.isAnyHeapDirty());
myCommandContainer.setDirtyStateForAllHeaps(false);
EXPECT_EQ(0u, myCommandContainer.dirtyHeaps);
EXPECT_FALSE(myCommandContainer.isAnyHeapDirty());
for (uint32_t i = 0; i < HeapType::NUM_TYPES; i++) {
HeapType heapType = static_cast<HeapType>(i);
EXPECT_FALSE(myCommandContainer.isHeapDirty(heapType));
}
myCommandContainer.setDirtyStateForAllHeaps(true);
EXPECT_EQ(std::numeric_limits<uint32_t>::max(), myCommandContainer.dirtyHeaps);
for (uint32_t i = 0; i < HeapType::NUM_TYPES; i++) {
HeapType heapType = static_cast<HeapType>(i);
EXPECT_TRUE(myCommandContainer.isHeapDirty(heapType));
}
}
TEST_F(CommandContainerHeapStateTests, givenDirtyHeapsWhenSettingStateForSingleHeapThenValuesAreCorrect) {
myCommandContainer.dirtyHeaps = 0;
EXPECT_FALSE(myCommandContainer.isAnyHeapDirty());
uint32_t controlVariable = 0;
for (uint32_t i = 0; i < HeapType::NUM_TYPES; i++) {
HeapType heapType = static_cast<HeapType>(i);
EXPECT_FALSE(myCommandContainer.isHeapDirty(heapType));
myCommandContainer.setHeapDirty(heapType);
EXPECT_TRUE(myCommandContainer.isHeapDirty(heapType));
EXPECT_TRUE(myCommandContainer.isAnyHeapDirty());
controlVariable |= (1 << i);
EXPECT_EQ(controlVariable, myCommandContainer.dirtyHeaps);
}
for (uint32_t i = 0; i < HeapType::NUM_TYPES; i++) {
HeapType heapType = static_cast<HeapType>(i);
EXPECT_TRUE(myCommandContainer.isHeapDirty(heapType));
}
}
TEST_F(CommandContainerTest, givenCmdContainerWhenCreatingCommandBufferThenCorrectAllocationTypeIsSet) {
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice);
ASSERT_NE(0u, cmdContainer.getCmdBufferAllocations().size());
EXPECT_EQ(GraphicsAllocation::AllocationType::COMMAND_BUFFER, cmdContainer.getCmdBufferAllocations()[0]->getAllocationType());
cmdContainer.allocateNextCommandBuffer();
ASSERT_LE(2u, cmdContainer.getCmdBufferAllocations().size());
EXPECT_EQ(GraphicsAllocation::AllocationType::COMMAND_BUFFER, cmdContainer.getCmdBufferAllocations()[1]->getAllocationType());
}
TEST_F(CommandContainerTest, givenCmdContainerWhenAllocatingHeapsThenSetCorrectAllocationTypes) {
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice);
for (uint32_t i = 0; i < HeapType::NUM_TYPES; i++) {
HeapType heapType = static_cast<HeapType>(i);
auto heap = cmdContainer.getIndirectHeap(heapType);
if (HeapType::INDIRECT_OBJECT == heapType) {
EXPECT_EQ(GraphicsAllocation::AllocationType::INTERNAL_HEAP, heap->getGraphicsAllocation()->getAllocationType());
EXPECT_NE(0u, heap->getHeapGpuStartOffset());
} else {
EXPECT_EQ(GraphicsAllocation::AllocationType::LINEAR_STREAM, heap->getGraphicsAllocation()->getAllocationType());
EXPECT_EQ(0u, heap->getHeapGpuStartOffset());
}
}
}
TEST_F(CommandContainerTest, givenCommandContainerWhenInitializeThenEverythingIsInitialized) {
CommandContainer cmdContainer;
auto status = cmdContainer.initialize(pDevice);
EXPECT_EQ(ErrorCode::SUCCESS, status);
EXPECT_EQ(pDevice, cmdContainer.getDevice());
EXPECT_NE(cmdContainer.getHeapHelper(), nullptr);
EXPECT_EQ(cmdContainer.getCmdBufferAllocations().size(), 1u);
EXPECT_NE(cmdContainer.getCommandStream(), nullptr);
for (uint32_t i = 0; i < HeapType::NUM_TYPES; i++) {
auto indirectHeap = cmdContainer.getIndirectHeap(static_cast<HeapType>(i));
auto heapAllocation = cmdContainer.getIndirectHeapAllocation(static_cast<HeapType>(i));
EXPECT_EQ(indirectHeap->getGraphicsAllocation(), heapAllocation);
}
EXPECT_EQ(cmdContainer.getIddBlock(), nullptr);
EXPECT_EQ(cmdContainer.getNumIddPerBlock(), defaultNumIddsPerBlock);
auto &hwHelper = HwHelper::get(pDevice->getHardwareInfo().platform.eRenderCoreFamily);
EXPECT_EQ(cmdContainer.getInstructionHeapBaseAddress(),
pDevice->getMemoryManager()->getInternalHeapBaseAddress(0, !hwHelper.useSystemMemoryPlacementForISA(pDevice->getHardwareInfo())));
}
TEST_F(CommandContainerTest, givenEnabledLocalMemoryAndIsaInSystemMemoryWhenCmdContainerIsInitializedThenInstructionBaseAddressIsSetToInternalHeap) {
DebugManagerStateRestore dbgRestore;
DebugManager.flags.ForceSystemMemoryPlacement.set(1 << (static_cast<uint32_t>(GraphicsAllocation::AllocationType::KERNEL_ISA) - 1));
auto executionEnvironment = new NEO::ExecutionEnvironment();
const size_t numDevices = 1;
executionEnvironment->prepareRootDeviceEnvironments(numDevices);
executionEnvironment->rootDeviceEnvironments[0]->setHwInfo(defaultHwInfo.get());
auto hwInfo = executionEnvironment->rootDeviceEnvironments[0]->getMutableHardwareInfo();
hwInfo->featureTable.ftrLocalMemory = true;
auto device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0u));
auto instructionHeapBaseAddress = device->getMemoryManager()->getInternalHeapBaseAddress(0, false);
CommandContainer cmdContainer;
auto status = cmdContainer.initialize(device.get());
EXPECT_EQ(ErrorCode::SUCCESS, status);
EXPECT_EQ(instructionHeapBaseAddress, cmdContainer.getInstructionHeapBaseAddress());
}
TEST_F(CommandContainerTest, givenCommandContainerDuringInitWhenAllocateGfxMemoryFailsThenErrorIsReturned) {
CommandContainer cmdContainer;
pDevice->executionEnvironment->memoryManager.reset(new FailMemoryManager(0, *pDevice->executionEnvironment));
auto status = cmdContainer.initialize(pDevice);
EXPECT_EQ(ErrorCode::OUT_OF_DEVICE_MEMORY, status);
}
TEST_F(CommandContainerTest, givenCommandContainerDuringInitWhenAllocateHeapMemoryFailsThenErrorIsReturned) {
CommandContainer cmdContainer;
auto temp_memoryManager = pDevice->executionEnvironment->memoryManager.release();
pDevice->executionEnvironment->memoryManager.reset(new FailMemoryManager(1, *pDevice->executionEnvironment));
auto status = cmdContainer.initialize(pDevice);
EXPECT_EQ(ErrorCode::OUT_OF_DEVICE_MEMORY, status);
delete temp_memoryManager;
}
TEST_F(CommandContainerTest, givenCommandContainerWhenSettingIndirectHeapAllocationThenAllocationIsSet) {
CommandContainer cmdContainer;
MockGraphicsAllocation mockAllocation;
auto heapType = HeapType::DYNAMIC_STATE;
cmdContainer.setIndirectHeapAllocation(heapType, &mockAllocation);
EXPECT_EQ(cmdContainer.getIndirectHeapAllocation(heapType), &mockAllocation);
}
TEST_F(CommandContainerTest, givenHeapAllocationsWhenDestroyCommandContainerThenHeapAllocationsAreReused) {
std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
cmdContainer->initialize(pDevice);
auto heapAllocationsAddress = cmdContainer->getIndirectHeapAllocation(HeapType::DYNAMIC_STATE)->getUnderlyingBuffer();
cmdContainer.reset(new CommandContainer);
cmdContainer->initialize(pDevice);
bool status = false;
for (uint32_t i = 0; i < HeapType::NUM_TYPES && !status; i++) {
status = cmdContainer->getIndirectHeapAllocation(static_cast<HeapType>(i))->getUnderlyingBuffer() == heapAllocationsAddress;
}
EXPECT_TRUE(status);
}
TEST_F(CommandContainerTest, givenCommandContainerWhenResetThenStateIsReset) {
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice);
LinearStream stream;
uint32_t usedSize = 1;
cmdContainer.lastSentNumGrfRequired = 64;
cmdContainer.getCommandStream()->getSpace(usedSize);
EXPECT_EQ(usedSize, cmdContainer.getCommandStream()->getUsed());
cmdContainer.reset();
EXPECT_NE(usedSize, cmdContainer.getCommandStream()->getUsed());
EXPECT_EQ(0u, cmdContainer.getCommandStream()->getUsed());
EXPECT_EQ(0u, cmdContainer.lastSentNumGrfRequired);
EXPECT_EQ(cmdContainer.getIddBlock(), nullptr);
EXPECT_EQ(cmdContainer.getNumIddPerBlock(), defaultNumIddsPerBlock);
}
TEST_F(CommandContainerTest, givenCommandContainerWhenWantToAddNullPtrToResidencyContainerThenNothingIsAdded) {
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice);
auto size = cmdContainer.getResidencyContainer().size();
cmdContainer.addToResidencyContainer(nullptr);
EXPECT_EQ(cmdContainer.getResidencyContainer().size(), size);
}
TEST_F(CommandContainerTest, givenCommandContainerWhenWantToAddAlreadyAddedAllocationAndDuplicatesRemovedThenExpectedSizeIsReturned) {
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice);
MockGraphicsAllocation mockAllocation;
auto sizeBefore = cmdContainer.getResidencyContainer().size();
cmdContainer.addToResidencyContainer(&mockAllocation);
auto sizeAfterFirstAdd = cmdContainer.getResidencyContainer().size();
EXPECT_NE(sizeBefore, sizeAfterFirstAdd);
cmdContainer.addToResidencyContainer(&mockAllocation);
auto sizeAfterSecondAdd = cmdContainer.getResidencyContainer().size();
EXPECT_NE(sizeAfterFirstAdd, sizeAfterSecondAdd);
cmdContainer.removeDuplicatesFromResidencyContainer();
auto sizeAfterDuplicatesRemoved = cmdContainer.getResidencyContainer().size();
EXPECT_EQ(sizeAfterFirstAdd, sizeAfterDuplicatesRemoved);
}
HWTEST_F(CommandContainerTest, givenCmdContainerWhenInitializeCalledThenSSHHeapHasBindlessOffsetReserved) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
cmdContainer->setReservedSshSize(4 * MemoryConstants::pageSize);
cmdContainer->initialize(pDevice);
cmdContainer->setDirtyStateForAllHeaps(false);
auto heap = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE);
ASSERT_NE(nullptr, heap);
EXPECT_EQ(4 * MemoryConstants::pageSize, heap->getUsed());
}
HWTEST_F(CommandContainerTest, givenNotEnoughSpaceInSSHWhenGettingHeapWithRequiredSizeAndAlignmentThenSSHHeapHasBindlessOffsetReserved) {
using RENDER_SURFACE_STATE = typename FamilyType::RENDER_SURFACE_STATE;
std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
cmdContainer->setReservedSshSize(4 * MemoryConstants::pageSize);
cmdContainer->initialize(pDevice);
cmdContainer->setDirtyStateForAllHeaps(false);
auto heap = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE);
ASSERT_NE(nullptr, heap);
heap->getSpace(heap->getAvailableSpace());
cmdContainer->getHeapWithRequiredSizeAndAlignment(HeapType::SURFACE_STATE, sizeof(RENDER_SURFACE_STATE), 0);
EXPECT_EQ(4 * MemoryConstants::pageSize, heap->getUsed());
EXPECT_EQ(cmdContainer->sshAllocations.size(), 1u);
}
TEST_F(CommandContainerTest, givenAvailableSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenExistingAllocationIsReturned) {
std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
cmdContainer->initialize(pDevice);
cmdContainer->setDirtyStateForAllHeaps(false);
HeapType types[] = {HeapType::SURFACE_STATE,
HeapType::DYNAMIC_STATE};
for (auto type : types) {
auto heapAllocation = cmdContainer->getIndirectHeapAllocation(type);
auto heap = cmdContainer->getIndirectHeap(type);
const size_t sizeRequested = 32;
const size_t alignment = 32;
EXPECT_GE(heap->getAvailableSpace(), sizeRequested + alignment);
auto sizeBefore = heap->getUsed();
auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(type, sizeRequested, alignment);
auto newAllocation = heapRequested->getGraphicsAllocation();
EXPECT_EQ(heap, heapRequested);
EXPECT_EQ(heapAllocation, newAllocation);
EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (alignment - 1)) == 0);
EXPECT_FALSE(cmdContainer->isHeapDirty(type));
auto sizeAfter = heapRequested->getUsed();
EXPECT_EQ(sizeBefore, sizeAfter);
}
}
TEST_F(CommandContainerTest, givenUnalignedAvailableSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenHeapReturnedIsCorrectlyAligned) {
std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
cmdContainer->initialize(pDevice);
cmdContainer->setDirtyStateForAllHeaps(false);
auto heapAllocation = cmdContainer->getIndirectHeapAllocation(HeapType::SURFACE_STATE);
auto heap = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE);
const size_t sizeRequested = 32;
const size_t alignment = 32;
heap->getSpace(sizeRequested / 2);
EXPECT_GE(heap->getAvailableSpace(), sizeRequested + alignment);
auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(HeapType::SURFACE_STATE, sizeRequested, alignment);
auto newAllocation = heapRequested->getGraphicsAllocation();
EXPECT_EQ(heap, heapRequested);
EXPECT_EQ(heapAllocation, newAllocation);
EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (alignment - 1)) == 0);
EXPECT_FALSE(cmdContainer->isHeapDirty(HeapType::SURFACE_STATE));
}
TEST_F(CommandContainerTest, givenNoAlignmentAndAvailableSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenHeapReturnedIsNotAligned) {
std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
cmdContainer->initialize(pDevice);
cmdContainer->setDirtyStateForAllHeaps(false);
auto heapAllocation = cmdContainer->getIndirectHeapAllocation(HeapType::SURFACE_STATE);
auto heap = cmdContainer->getIndirectHeap(HeapType::SURFACE_STATE);
const size_t sizeRequested = 32;
const size_t alignment = 0;
heap->getSpace(sizeRequested / 2);
EXPECT_GE(heap->getAvailableSpace(), sizeRequested + alignment);
auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(HeapType::SURFACE_STATE, sizeRequested, alignment);
auto newAllocation = heapRequested->getGraphicsAllocation();
EXPECT_EQ(heap, heapRequested);
EXPECT_EQ(heapAllocation, newAllocation);
EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (sizeRequested / 2)) == sizeRequested / 2);
EXPECT_FALSE(cmdContainer->isHeapDirty(HeapType::SURFACE_STATE));
}
TEST_F(CommandContainerTest, givenNotEnoughSpaceWhenGetHeapWithRequiredSizeAndAlignmentCalledThenNewAllocationIsReturned) {
std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
cmdContainer->initialize(pDevice);
cmdContainer->setDirtyStateForAllHeaps(false);
HeapType types[] = {HeapType::SURFACE_STATE,
HeapType::DYNAMIC_STATE};
for (auto type : types) {
auto heapAllocation = cmdContainer->getIndirectHeapAllocation(type);
auto heap = cmdContainer->getIndirectHeap(type);
const size_t sizeRequested = 32;
const size_t alignment = 32;
size_t availableSize = heap->getAvailableSpace();
heap->getSpace(availableSize - sizeRequested / 2);
EXPECT_LT(heap->getAvailableSpace(), sizeRequested + alignment);
auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(type, sizeRequested, alignment);
auto newAllocation = heapRequested->getGraphicsAllocation();
EXPECT_EQ(heap, heapRequested);
EXPECT_NE(heapAllocation, newAllocation);
EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (alignment - 1)) == 0);
EXPECT_TRUE(cmdContainer->isHeapDirty(type));
}
for (auto deallocation : cmdContainer->getDeallocationContainer()) {
cmdContainer->getDevice()->getMemoryManager()->freeGraphicsMemory(deallocation);
}
cmdContainer->getDeallocationContainer().clear();
}
TEST_F(CommandContainerTest, givenNotEnoughSpaceWhenCreatedAlocationHaveDifferentBaseThenHeapIsDirty) {
std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
cmdContainer->initialize(pDevice);
cmdContainer->setDirtyStateForAllHeaps(false);
HeapType type = HeapType::INDIRECT_OBJECT;
auto heapAllocation = cmdContainer->getIndirectHeapAllocation(type);
auto heap = cmdContainer->getIndirectHeap(type);
const size_t sizeRequested = 32;
const size_t alignment = 32;
size_t availableSize = heap->getAvailableSpace();
heap->getSpace(availableSize - sizeRequested / 2);
EXPECT_LT(heap->getAvailableSpace(), sizeRequested + alignment);
auto heapRequested = cmdContainer->getHeapWithRequiredSizeAndAlignment(type, sizeRequested, alignment);
auto newAllocation = heapRequested->getGraphicsAllocation();
EXPECT_EQ(heap, heapRequested);
EXPECT_NE(heapAllocation, newAllocation);
EXPECT_TRUE((reinterpret_cast<size_t>(heapRequested->getSpace(0)) & (alignment - 1)) == 0);
EXPECT_FALSE(cmdContainer->isHeapDirty(type));
for (auto deallocation : cmdContainer->getDeallocationContainer()) {
cmdContainer->getDevice()->getMemoryManager()->freeGraphicsMemory(deallocation);
}
cmdContainer->getDeallocationContainer().clear();
}
TEST_F(CommandContainerTest, whenAllocateNextCmdBufferIsCalledThenNewAllocationIsCreatedAndCommandStreamReplaced) {
std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
cmdContainer->initialize(pDevice);
auto stream = cmdContainer->getCommandStream();
ASSERT_NE(nullptr, stream);
auto initialBuffer = stream->getSpace(0);
EXPECT_NE(nullptr, initialBuffer);
cmdContainer->allocateNextCommandBuffer();
auto nextBuffer = stream->getSpace(0);
auto sizeUsed = stream->getUsed();
auto availableSize = stream->getMaxAvailableSpace();
EXPECT_NE(nullptr, nextBuffer);
EXPECT_EQ(0u, sizeUsed);
EXPECT_NE(initialBuffer, nextBuffer);
const size_t cmdBufSize = CommandContainer::defaultListCmdBufferSize;
EXPECT_EQ(cmdBufSize, availableSize);
ASSERT_EQ(2u, cmdContainer->getCmdBufferAllocations().size());
EXPECT_EQ(cmdContainer->getCmdBufferAllocations()[1], cmdContainer->getCommandStream()->getGraphicsAllocation());
EXPECT_EQ(cmdContainer->getCmdBufferAllocations()[1], cmdContainer->getResidencyContainer().back());
}
TEST_F(CommandContainerTest, whenResettingCommandContainerThenStoredCmdBuffersAreFreedAndStreamIsReplacedWithInitialBuffer) {
std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer);
cmdContainer->initialize(pDevice);
cmdContainer->allocateNextCommandBuffer();
cmdContainer->allocateNextCommandBuffer();
EXPECT_EQ(3u, cmdContainer->getCmdBufferAllocations().size());
cmdContainer->reset();
ASSERT_EQ(1u, cmdContainer->getCmdBufferAllocations().size());
auto stream = cmdContainer->getCommandStream();
ASSERT_NE(nullptr, stream);
auto buffer = stream->getSpace(0);
const size_t cmdBufSize = CommandContainer::defaultListCmdBufferSize;
EXPECT_EQ(cmdContainer->getCmdBufferAllocations()[0]->getUnderlyingBuffer(), buffer);
EXPECT_EQ(cmdBufSize, stream->getMaxAvailableSpace());
}
class CommandContainerHeaps : public DeviceFixture,
public ::testing::TestWithParam<IndirectHeap::Type> {
public:
void SetUp() override {
DeviceFixture::SetUp();
}
void TearDown() override {
DeviceFixture::TearDown();
}
};
INSTANTIATE_TEST_CASE_P(
Device,
CommandContainerHeaps,
testing::Values(
IndirectHeap::DYNAMIC_STATE,
IndirectHeap::INDIRECT_OBJECT,
IndirectHeap::SURFACE_STATE));
TEST_P(CommandContainerHeaps, givenCommandContainerWhenGetAllowHeapGrowCalledThenHeapIsReturned) {
HeapType heap = GetParam();
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice);
auto usedSpaceBefore = cmdContainer.getIndirectHeap(heap)->getUsed();
size_t size = 5000;
void *ptr = cmdContainer.getHeapSpaceAllowGrow(heap, size);
ASSERT_NE(nullptr, ptr);
auto usedSpaceAfter = cmdContainer.getIndirectHeap(heap)->getUsed();
ASSERT_EQ(usedSpaceBefore + size, usedSpaceAfter);
}
TEST_P(CommandContainerHeaps, givenCommandContainerWhenGetingMoreThanAvailableSizeThenBiggerHeapIsReturned) {
HeapType heap = GetParam();
CommandContainer cmdContainer;
cmdContainer.initialize(pDevice);
cmdContainer.setDirtyStateForAllHeaps(false);
auto usedSpaceBefore = cmdContainer.getIndirectHeap(heap)->getUsed();
auto availableSizeBefore = cmdContainer.getIndirectHeap(heap)->getAvailableSpace();
void *ptr = cmdContainer.getHeapSpaceAllowGrow(heap, availableSizeBefore + 1);
ASSERT_NE(nullptr, ptr);
auto usedSpaceAfter = cmdContainer.getIndirectHeap(heap)->getUsed();
auto availableSizeAfter = cmdContainer.getIndirectHeap(heap)->getAvailableSpace();
EXPECT_GT(usedSpaceAfter + availableSizeAfter, usedSpaceBefore + availableSizeBefore);
EXPECT_EQ(!cmdContainer.isHeapDirty(heap), heap == IndirectHeap::INDIRECT_OBJECT);
}
TEST_P(CommandContainerHeaps, givenCommandContainerForDifferentRootDevicesThenHeapsAreCreatedWithCorrectRootDeviceIndex) {
HeapType heap = GetParam();
auto executionEnvironment = new NEO::ExecutionEnvironment();
const size_t numDevices = 2;
executionEnvironment->prepareRootDeviceEnvironments(numDevices);
for (auto i = 0u; i < numDevices; i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
}
auto device0 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0u));
auto device1 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 1u));
CommandContainer cmdContainer0;
cmdContainer0.initialize(device0.get());
uint32_t heapRootDeviceIndex0 = cmdContainer0.getIndirectHeap(heap)->getGraphicsAllocation()->getRootDeviceIndex();
EXPECT_EQ(device0->getRootDeviceIndex(), heapRootDeviceIndex0);
CommandContainer cmdContainer1;
cmdContainer1.initialize(device1.get());
uint32_t heapRootDeviceIndex1 = cmdContainer1.getIndirectHeap(heap)->getGraphicsAllocation()->getRootDeviceIndex();
EXPECT_EQ(device1->getRootDeviceIndex(), heapRootDeviceIndex1);
}
TEST_F(CommandContainerHeaps, givenCommandContainerForDifferentRootDevicesThenCmdBufferAllocationIsCreatedWithCorrectRootDeviceIndex) {
auto executionEnvironment = new NEO::ExecutionEnvironment();
const size_t numDevices = 2;
executionEnvironment->prepareRootDeviceEnvironments(numDevices);
for (auto i = 0u; i < numDevices; i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
}
auto device0 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0u));
auto device1 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 1u));
CommandContainer cmdContainer0;
cmdContainer0.initialize(device0.get());
EXPECT_EQ(1u, cmdContainer0.getCmdBufferAllocations().size());
uint32_t cmdBufferAllocationIndex0 = cmdContainer0.getCmdBufferAllocations().front()->getRootDeviceIndex();
EXPECT_EQ(device0->getRootDeviceIndex(), cmdBufferAllocationIndex0);
CommandContainer cmdContainer1;
cmdContainer1.initialize(device1.get());
EXPECT_EQ(1u, cmdContainer1.getCmdBufferAllocations().size());
uint32_t cmdBufferAllocationIndex1 = cmdContainer1.getCmdBufferAllocations().front()->getRootDeviceIndex();
EXPECT_EQ(device1->getRootDeviceIndex(), cmdBufferAllocationIndex1);
}
TEST_F(CommandContainerHeaps, givenCommandContainerForDifferentRootDevicesThenInternalHeapIsCreatedWithCorrectRootDeviceIndex) {
auto executionEnvironment = new NEO::ExecutionEnvironment();
const size_t numDevices = 2;
executionEnvironment->prepareRootDeviceEnvironments(numDevices);
for (auto i = 0u; i < numDevices; i++) {
executionEnvironment->rootDeviceEnvironments[i]->setHwInfo(defaultHwInfo.get());
}
auto device0 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 0u));
auto device1 = std::unique_ptr<MockDevice>(Device::create<MockDevice>(executionEnvironment, 1u));
auto &hwHelper0 = HwHelper::get(device0->getHardwareInfo().platform.eRenderCoreFamily);
auto &hwHelper1 = HwHelper::get(device1->getHardwareInfo().platform.eRenderCoreFamily);
CommandContainer cmdContainer0;
cmdContainer0.initialize(device0.get());
bool useLocalMemory0 = !hwHelper0.useSystemMemoryPlacementForISA(device0->getHardwareInfo());
uint64_t baseAddressHeapDevice0 = device0.get()->getMemoryManager()->getInternalHeapBaseAddress(device0->getRootDeviceIndex(), useLocalMemory0);
EXPECT_EQ(cmdContainer0.getInstructionHeapBaseAddress(), baseAddressHeapDevice0);
CommandContainer cmdContainer1;
cmdContainer1.initialize(device1.get());
bool useLocalMemory1 = !hwHelper1.useSystemMemoryPlacementForISA(device0->getHardwareInfo());
uint64_t baseAddressHeapDevice1 = device1.get()->getMemoryManager()->getInternalHeapBaseAddress(device1->getRootDeviceIndex(), useLocalMemory1);
EXPECT_EQ(cmdContainer1.getInstructionHeapBaseAddress(), baseAddressHeapDevice1);
}
TEST_F(CommandContainerTest, givenCommandContainerWhenDestructionThenNonHeapAllocationAreNotDestroyed) {
std::unique_ptr<CommandContainer> cmdContainer(new CommandContainer());
MockGraphicsAllocation alloc;
size_t size = 0x1000;
alloc.setSize(size);
cmdContainer->initialize(pDevice);
cmdContainer->getDeallocationContainer().push_back(&alloc);
cmdContainer.reset();
EXPECT_EQ(alloc.getUnderlyingBufferSize(), size);
}
TEST_F(CommandContainerTest, givenContainerAllocatesNextCommandBufferWhenResetingContainerThenExpectFirstCommandBufferAllocationIsReused) {
auto cmdContainer = std::make_unique<CommandContainer>();
cmdContainer->initialize(pDevice);
auto stream = cmdContainer->getCommandStream();
ASSERT_NE(nullptr, stream);
auto firstCmdBufferAllocation = stream->getGraphicsAllocation();
ASSERT_NE(nullptr, firstCmdBufferAllocation);
auto firstCmdBufferCpuPointer = stream->getSpace(0);
EXPECT_EQ(firstCmdBufferCpuPointer, firstCmdBufferAllocation->getUnderlyingBuffer());
cmdContainer->allocateNextCommandBuffer();
auto secondCmdBufferAllocation = stream->getGraphicsAllocation();
ASSERT_NE(nullptr, secondCmdBufferAllocation);
EXPECT_NE(firstCmdBufferAllocation, secondCmdBufferAllocation);
auto secondCmdBufferCpuPointer = stream->getSpace(0);
EXPECT_EQ(secondCmdBufferCpuPointer, secondCmdBufferAllocation->getUnderlyingBuffer());
EXPECT_NE(firstCmdBufferCpuPointer, secondCmdBufferCpuPointer);
cmdContainer->reset();
auto aferResetCmdBufferAllocation = stream->getGraphicsAllocation();
ASSERT_NE(nullptr, aferResetCmdBufferAllocation);
auto afterResetCmdBufferCpuPointer = stream->getSpace(0);
EXPECT_EQ(afterResetCmdBufferCpuPointer, aferResetCmdBufferAllocation->getUnderlyingBuffer());
EXPECT_EQ(firstCmdBufferAllocation, aferResetCmdBufferAllocation);
EXPECT_EQ(firstCmdBufferCpuPointer, afterResetCmdBufferCpuPointer);
bool firstAllocationFound = false;
auto &residencyContainer = cmdContainer->getResidencyContainer();
for (auto *allocation : residencyContainer) {
if (allocation == firstCmdBufferAllocation) {
firstAllocationFound = true;
break;
}
}
EXPECT_TRUE(firstAllocationFound);
}
|
class node{
private:
int data;
node* left;
node* right;
public:
node();
node(int i);
~node();
int getData();
node* getLeft();
node* getRight();
void setChilds(node* nleft, node* nright);
};
|
// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/storage/minfs/allocator_reservation.h"
#include <stdlib.h>
#include <utility>
#include "src/storage/minfs/allocator/allocator.h"
namespace minfs {
AllocatorReservation::AllocatorReservation(Allocator* allocator) : allocator_(*allocator) {}
AllocatorReservation::~AllocatorReservation() { Cancel(); }
zx_status_t AllocatorReservation::Reserve(PendingWork* transaction, size_t reserved) {
if (reserved_ != 0) {
return ZX_ERR_BAD_STATE;
}
zx_status_t status = allocator_.Reserve({}, transaction, reserved);
if (status == ZX_OK) {
reserved_ = reserved;
}
return status;
}
zx_status_t AllocatorReservation::ExtendReservation(PendingWork* transaction, size_t reserved) {
zx_status_t status = allocator_.Reserve({}, transaction, reserved);
if (status == ZX_OK) {
reserved_ += reserved;
}
return status;
}
size_t AllocatorReservation::Allocate() {
ZX_ASSERT(reserved_ > 0);
reserved_--;
return allocator_.Allocate({}, this);
}
void AllocatorReservation::Deallocate(size_t element) { allocator_.Free(this, element); }
#ifdef __Fuchsia__
size_t AllocatorReservation::Swap(size_t old_index) {
if (old_index > 0) {
allocator_.Free(this, old_index);
}
return Allocate();
}
#endif
void AllocatorReservation::Cancel() {
if (reserved_ > 0) {
allocator_.Unreserve({}, reserved_);
reserved_ = 0;
}
}
PendingAllocations& AllocatorReservation::GetPendingAllocations(Allocator* allocator) {
if (!allocations_) {
allocations_ = std::make_unique<PendingAllocations>(allocator);
}
return *allocations_;
}
PendingDeallocations& AllocatorReservation::GetPendingDeallocations(Allocator* allocator) {
if (!deallocations_) {
deallocations_ = std::make_unique<PendingDeallocations>(allocator);
}
return *deallocations_;
}
void AllocatorReservation::Commit(PendingWork* transaction) {
allocator_.Commit(transaction, this);
}
} // namespace minfs
|
#ifndef TrackerConditions_TrackerStatus_hh
#define TrackerConditions_TrackerStatus_hh
//
// Define status of the tracker, as the agregate of tracker element status
//
// Mu2e includes
#include "Offline/DataProducts/inc/StrawId.hh"
#include "Offline/DataProducts/inc/StrawIdMask.hh"
#include "Offline/DataProducts/inc/StrawStatus.hh"
#include "Offline/Mu2eInterfaces/inc/ProditionsEntity.hh"
#include "fhiclcpp/type_traits.h"
// C++ includes
#include <map>
#include <memory>
namespace mu2e {
class TrackerStatus : public ProditionsEntity {
public:
typedef std::shared_ptr<TrackerStatus> ptr_t;
typedef std::shared_ptr<const TrackerStatus> cptr_t;
typedef std::map<StrawId,StrawStatus> stat_t;
typedef std::map<StrawIdMask,stat_t> estat_t;
constexpr static const char* cxname = {"TrackerStatus"};
TrackerStatus(): ProditionsEntity(cxname){}
virtual ~TrackerStatus() {}
// add status for an element. This is cumulative
void addStatus(StrawId const& sid, StrawIdMask const& mask, StrawStatus const& status);
void print( std::ostream& ) const override;
// convenience operators for some common situations
bool noSignal(StrawId const& sid) const; // return 'true' if we expect no signal from this straw
bool suppress(StrawId const& sid) const; // This straw may produce a signal, but it should be suppressed as it is inaccurate
bool noMaterial(StrawId const& sid) const; // straw doesn't contribute to scattering or energy loss
// Net status of an individual Straw. If the straw is in a plane or panel with status, that will be aggregated
StrawStatus strawStatus(StrawId const& sid) const;
// same for panel, plane. Note; these will return only status that applies to the ENTIRE PANEL (or plane)
// It will NOT detect (say) a panel where every straw has had the same status individually set (that's not a good configuration)
StrawStatus panelStatus(StrawId const& sid) const;
StrawStatus planeStatus(StrawId const& sid) const;
private:
estat_t _status;
};
} // namespace mu2e
#endif /* TrackerConditions_TrackerStatus_hh */
|
#pragma once
#include <limits>
#include "../common.hh"
#include "./channel.hh"
#include "../utils/marshal.hh"
namespace rdmaio {
namespace bootstrap {
/*!
MultiMsg ecnodes multiple msgs into one, merged msg.
\note: MaxMsgSz supported is std::numeric_limits<u16>::max()
\note: MAx number of msg supported ius defiend in kMaxmultiMsg
---
Usage:
`
MultiMsg<1024> mss; // create a MultioMsg with total 1024-bytes capacity.
ByteBuffer one_msg = ...;
ByteBuffer another_msg = ...;
assert(mss.append(one_msg)); // false if there is no capacity
assert(mss.append(another_msg)); //
ByteBuffer &total_msg = mss.buf;
// do something about the total_msg;
`
*/
// max encoded msg per MultiMsg
const usize kMaxMultiMsg = 8;
struct __attribute__((packed)) MsgEntry {
u16 offset = 0;
u16 sz = 0;
static usize max_entry_sz() { return std::numeric_limits<u16>::max(); }
};
struct __attribute__((packed)) MsgsHeader {
u8 num = 0;
MsgEntry entries[kMaxMultiMsg];
bool has_free_entry() const { return num < kMaxMultiMsg; }
/*!
append one msg to the header, return its current offset
*/
bool append_one(u16 sz) {
if (!has_free_entry())
return false;
u16 off = sizeof(MsgsHeader);
if (num != 0) {
off = entries[num - 1].offset + entries[num - 1].sz;
} else {
// handles nothing, off should be zero
}
entries[num++] = {.offset = off, .sz = sz};
return true;
}
// sanity check that the header content is consistent
bool sanity_check(usize sz) const {
if (num > kMaxMultiMsg) {
return false;
}
u16 cur_off = sizeof(MsgsHeader);
for (uint i = 0; i < num; ++i) {
if (entries[i].offset != cur_off) {
return false;
}
cur_off += entries[i].sz;
}
return (static_cast<usize>(cur_off) <= sz);
}
};
/*!
MultiMsg encodes several ByteBuffer into one single one,
and we can decode these buffers separately.
Note that at most *kMaxMultiMsg* can be encoded.
*/
template <usize MAXSZ = kMaxMsgSz> struct MultiMsg {
MsgsHeader *header;
ByteBuffer *buf = nullptr;
// whether this msg alloc from the heap
bool alloc = false;
static_assert(MAXSZ > sizeof(MsgsHeader), "MultiMsg reserved sz too small");
explicit MultiMsg(const usize &reserve_sz = MAXSZ)
: buf(new ByteBuffer(::rdmaio::Marshal::dump_null<MsgsHeader>())) {
init(reserve_sz);
}
~MultiMsg() {
if (alloc)
delete buf;
}
/*!
Create from an existing MultiMsg
*/
static Option<MultiMsg<MAXSZ>> create_from(ByteBuffer &b) {
if (b.size() > MAXSZ) {
RDMA_LOG(2) << "size mis match";
return {};
}
auto res = MultiMsg<MAXSZ>(b);
// do sanity checks, if one failes, then return false
if (!res.header->sanity_check(res.buf->size())) {
return {};
}
return res;
}
/*!
Create a MultiMsg with exact payload (sz)
Failes if sz + sizeof(MsgsHeader) > MAXSZ
*/
static Option<MultiMsg<MAXSZ>> create_exact(const usize &sz) {
if (sz + sizeof(MsgsHeader) > MAXSZ)
return {};
return MultiMsg<MAXSZ>(sz + sizeof(MsgsHeader));
}
/*!
\ret:
- true: a msg has been appended to the MultiMsg
- false: this can because:
+ there is no free space for the msg (current msgs has occupied more
than MAXSZ sz)
+ there is no free entry for the msg (there already be kMaxMultimsg
emplaced)
*/
bool append(const ByteBuffer &msg) {
if (buf->size() + msg.size() > MAXSZ) {
return false;
}
if (!this->header->append_one(static_cast<u16>(msg.size())))
return false;
buf->append(msg);
return true;
}
// the following is the querier for the msg
usize num_msg() const { return static_cast<usize>(header->num); }
/*!
Get one msg from the multimsg
\note: performance may be bad
*/
Option<ByteBuffer> query_one(const usize &idx) const {
if (idx >= num_msg())
return {};
MsgEntry &entry = header->entries[idx];
return ByteBuffer(buf->data() + entry.offset, entry.sz);
}
private:
/*!
create a multimsg from a buffer
fill the header and the buf
*/
explicit MultiMsg(ByteBuffer &total_msg) : buf(&total_msg) {
//init(total_msg.size());
{ // unsafe code
this->header = (MsgsHeader *)(buf->data());
}
}
MultiMsg(const ByteBuffer &m, usize reserve_sz) : buf(&m) { init(reserve_sz); }
void init(const usize &reserve_sz) {
usize true_reserve_sz = std::min(
std::max(reserve_sz, static_cast<usize>(sizeof(MsgsHeader))), MAXSZ);
buf->reserve(true_reserve_sz);
{ // unsafe code
this->header = (MsgsHeader *)(buf->data());
}
}
};
} // namespace bootstrap
} // namespace rdmaio
|
#include <iostream>
using namespace std;
int main()
{
float r, area;
cout<< "Please Enter R:"<<endl;
cin >> r;
area = (r*r) * (22/7.0);
cout <<"The Area is:" << area << " Unit"<<endl;
}
|
// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "driver/amlogic_npu/engine.h"
#include <unistd.h>
#include <algorithm>
#include <vector>
#include "driver/amlogic_npu/converter/converter.h"
#include "driver/amlogic_npu/optimizer/transpose_op_dimensions.h"
#include "driver/amlogic_npu/optimizer/unpack_op_fusion.h"
#include "optimizer/fuse_matmul_add_into_fully_connected.h"
#include "optimizer/symm2asymm.h"
#include "utility/debug.h"
#include "utility/logging.h"
#include "utility/modeling.h"
#include "utility/string.h"
#include "utility/utility.h"
namespace nnadapter {
namespace amlogic_npu {
Context::Context(void* device, const char* properties) : device_(device) {
// TODO(hong19860320) create the raw context from amlnpu_ddk
}
Context::~Context() {}
Program::~Program() { Clear(); }
void Program::Clear() {
tensors_.clear();
input_types_.clear();
output_types_.clear();
dump_graph_path_ = "";
dump_graph_buffer_ = nullptr;
}
int Program::Build(hal::Model* model, hal::Cache* cache) {
Clear();
if (model && cache->dir && cache->token) {
dump_graph_path_ = string_format("%s/%s.dat", cache->dir, cache->token);
}
dump_graph_buffer_ = &cache->buffer;
return cache->buffer.empty() ? BuildFromModel(model) : BuildFromCache(cache);
}
int Program::BuildFromModel(hal::Model* model) {
// Convert the quantization parameters of the operands in the NNAdapter model
NNADAPTER_VLOG(5) << "Origin model:" << std::endl << Visualize(model);
FuseMatMulAddIntoFullyConnected(model);
UnpackOpFusion(model);
TransposeOpDimensions(model);
ConvertQuantizationSymmToAsymm(model);
NNADAPTER_VLOG(5) << "Optimized model:" << std::endl << Visualize(model);
// Convert a NNAdapter model to a amlnpu graph
graph_from_cache_ = false;
if (!dump_graph_path_.empty()) {
graph_ = std::make_shared<aml::nn::Graph>(
const_cast<char*>(dump_graph_path_.c_str()));
if (!graph_) {
return NNADAPTER_OUT_OF_MEMORY;
}
} else {
graph_ = std::make_shared<aml::nn::Graph>();
if (!graph_) {
return NNADAPTER_OUT_OF_MEMORY;
}
}
Converter converter(graph_.get(), &tensors_);
NNADAPTER_CHECK_EQ(converter.Apply(model), NNADAPTER_NO_ERROR);
// Indentify the inputs and outputs
auto input_count = model->input_operands.size();
NNADAPTER_VLOG(3) << "Model input count: " << input_count;
std::vector<std::shared_ptr<aml::nn::Tensor>> input_tensors;
if (input_count > 0) {
input_tensors.resize(input_count);
input_types_.resize(input_count);
for (size_t i = 0; i < input_count; i++) {
auto operand = model->input_operands[i];
const auto& type = operand->type;
NNADAPTER_CHECK(tensors_.find(operand) != tensors_.end());
input_tensors[i] = tensors_[operand].back();
NNADAPTER_CHECK(input_tensors[i]);
input_types_[i] = type;
}
}
auto output_count = model->output_operands.size();
NNADAPTER_VLOG(3) << "Model output count: " << output_count;
NNADAPTER_CHECK_GT(output_count, 0);
std::vector<std::shared_ptr<aml::nn::Tensor>> output_tensors(output_count);
output_types_.resize(output_count);
for (size_t i = 0; i < output_count; i++) {
auto operand = model->output_operands[i];
const auto& type = operand->type;
NNADAPTER_CHECK(tensors_.find(operand) != tensors_.end());
output_tensors[i] = tensors_[operand].back();
NNADAPTER_CHECK(output_tensors[i]);
output_types_[i] = type;
}
graph_->SetInputsOutputs(input_tensors, output_tensors);
// Create an execution to build the graph to the device-related program.
execution_ = std::make_shared<aml::nn::Exection>(graph_.get());
execution_->Build();
NNADAPTER_VLOG(3) << "Build success.";
return NNADAPTER_NO_ERROR;
}
int Program::BuildFromCache(hal::Cache* cache) {
graph_ = std::make_shared<aml::nn::Graph>();
if (!graph_) {
return NNADAPTER_OUT_OF_MEMORY;
}
// Load graph from cache buffer
if (graph_from_cache_ == false) {
if (graph_->LoadCache(reinterpret_cast<char*>(cache->buffer.data()),
cache->buffer.size()) != aml::nn::AML_SUCCESS) {
NNADAPTER_LOG(FATAL) << "Failed to load cache graph from buffer!";
return NNADAPTER_DEVICE_INTERNAL_ERROR;
} else {
NNADAPTER_VLOG(3) << "first time to Load cache !";
graph_from_cache_ = true;
}
}
NNADAPTER_VLOG(3) << "Load cache graph from buffer success.";
// Indentify the inputs and outputs
auto input_count = cache->input_types.size();
NNADAPTER_VLOG(3) << "Model input count: " << input_count;
std::vector<std::shared_ptr<aml::nn::Tensor>> input_tensors;
if (input_count > 0) {
input_tensors.resize(input_count);
input_types_ = cache->input_types;
for (size_t i = 0; i < input_count; i++) {
const auto& type = cache->input_types[i];
input_tensors[i] = CreateAmlTensor(
graph_.get(), string_format("model_input_%d", i), &type);
NNADAPTER_CHECK(input_tensors[i]);
}
}
auto output_count = cache->output_types.size();
NNADAPTER_VLOG(3) << "Model output count: " << output_count;
NNADAPTER_CHECK_GT(output_count, 0);
std::vector<std::shared_ptr<aml::nn::Tensor>> output_tensors(output_count);
output_types_ = cache->output_types;
for (size_t i = 0; i < output_count; i++) {
const auto& type = cache->output_types[i];
output_tensors[i] = CreateAmlTensor(
graph_.get(), string_format("model_output_%d", i), &type);
NNADAPTER_CHECK(output_tensors[i]);
}
// graph_->SetInputsOutputs(input_tensors, output_tensors);
// Create an execution to build the graph to the device-specific program.
execution_ = std::make_shared<aml::nn::Exection>(graph_.get());
// execution_->Build();
NNADAPTER_VLOG(3) << "Build success.";
return NNADAPTER_NO_ERROR;
}
int Program::Execute(uint32_t input_count,
hal::Argument* input_arguments,
uint32_t output_count,
hal::Argument* output_arguments) {
NNADAPTER_CHECK_EQ(input_types_.size(), input_count);
NNADAPTER_CHECK_EQ(output_types_.size(), output_count);
std::vector<aml::nn::InputInfo> input_info(input_count);
std::vector<aml::nn::OutputInfo> output_info(output_count);
for (uint32_t i = 0; i < input_count; i++) {
auto& arg = input_arguments[i];
NNADAPTER_CHECK_GE(arg.index, 0);
NNADAPTER_CHECK_LT(arg.index, input_count);
NNADAPTER_CHECK(arg.memory);
NNADAPTER_CHECK(arg.access);
auto type = &input_types_[arg.index];
auto buffer = arg.access(arg.memory, type);
NNADAPTER_CHECK(buffer);
auto length = GetOperandTypeBufferLength(*type);
if (IsUInt8AsymmPerLayerQuantType(type->precision)) {
Symm2AsymmData(reinterpret_cast<const int8_t*>(buffer),
length,
type->asymm_per_layer_params.zero_point,
reinterpret_cast<uint8_t*>(buffer));
}
// Initialize the input info for the execution
input_info[arg.index].index = arg.index;
input_info[arg.index].buf = buffer;
input_info[arg.index].size = length;
input_info[arg.index].pass_through = false;
input_info[arg.index].type =
static_cast<int>(ConvertToAmlPrecisionType(type->precision));
input_info[arg.index].layout =
static_cast<int>(ConvertToAmlDataLayoutType(type->layout));
if (graph_from_cache_ == true) {
execution_->SwapIObuffer(0, i, reinterpret_cast<char*>(buffer));
NNADAPTER_LOG(INFO) << "Input SwapIObuffer " << buffer;
}
}
for (uint32_t i = 0; i < output_count; i++) {
auto& arg = output_arguments[i];
NNADAPTER_CHECK_GE(arg.index, 0);
NNADAPTER_CHECK_LT(arg.index, output_count);
NNADAPTER_CHECK(arg.memory);
NNADAPTER_CHECK(arg.access);
auto type = &output_types_[arg.index];
// TODO(hong19860320) Get the dimensions of the outputs from amlnpu_ddk
// according to the dynamic dimensions of the inputs, fill them to 'type'
// and call the 'access' function to re-allocate the host output memory
auto buffer = arg.access(arg.memory, type);
NNADAPTER_CHECK(buffer);
auto length = GetOperandTypeBufferLength(*type);
// Initialize the output info for the execution
output_info[arg.index].index = arg.index;
output_info[arg.index].buf = buffer;
output_info[arg.index].size = length;
output_info[arg.index].want_float = false;
output_info[arg.index].type =
static_cast<int>(ConvertToAmlPrecisionType(type->precision));
output_info[arg.index].layout =
static_cast<int>(ConvertToAmlDataLayoutType(type->layout));
if (graph_from_cache_ == true) {
execution_->SwapIObuffer(1, i, reinterpret_cast<char*>(buffer));
NNADAPTER_LOG(INFO) << "Output SwapIObuffer " << buffer;
}
}
auto start_time = GetCurrentUS();
NNADAPTER_CHECK_EQ(execution_->SetInputs(input_info), aml::nn::AML_SUCCESS);
NNADAPTER_CHECK_EQ(execution_->Run(), aml::nn::AML_SUCCESS);
NNADAPTER_CHECK_EQ(execution_->GetOutputs(output_info), aml::nn::AML_SUCCESS);
NNADAPTER_VLOG(3) << "Process cost " << GetCurrentUS() - start_time << " us";
for (uint32_t i = 0; i < output_count; i++) {
auto type = &output_types_[i];
auto buffer = output_info[i].buf;
auto length = output_info[i].size;
if (IsUInt8AsymmPerLayerQuantType(type->precision)) {
Asymm2SymmData(reinterpret_cast<const uint8_t*>(buffer),
length,
type->asymm_per_layer_params.zero_point,
reinterpret_cast<int8_t*>(buffer));
}
}
// Read data from the dump graph file and fill to cache
if (!dump_graph_path_.empty()) {
if (ReadFile(dump_graph_path_, dump_graph_buffer_)) {
NNADAPTER_LOG(INFO) << "Read the dump graph file " << dump_graph_path_
<< " success.";
} else {
NNADAPTER_LOG(INFO) << "Failed to read the dump graph file "
<< dump_graph_path_ << "!";
}
dump_graph_path_ = "";
}
return NNADAPTER_NO_ERROR;
}
} // namespace amlogic_npu
} // namespace nnadapter
|
#include "Util.h"
float P(short size, short num, short draws)
{
float not = 1;
for (float i = size; i > size - draws; --i) not *= (i - num) / i;
return 1 - not;
}
|
/*=============================================================================
Copyright (c) 2011-2019 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/Sprout
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#ifndef SPROUT_RANGE_ALGORITHM_PARTITION_COPY_HPP
#define SPROUT_RANGE_ALGORITHM_PARTITION_COPY_HPP
#include <sprout/config.hpp>
#include <sprout/range/algorithm/fixed/partition_copy.hpp>
#include <sprout/range/algorithm/fit/partition_copy.hpp>
#include <sprout/range/algorithm/cxx14/partition_copy.hpp>
#endif // #ifndef SPROUT_RANGE_ALGORITHM_PARTITION_COPY_HPP
|
/**
* Google's Firebase QueueInfo class, QueueInfo.cpp version 1.0.3
*
* This library supports Espressif ESP8266 and ESP32
*
* Created January 18, 2022
*
* This work is a part of Firebase ESP Client library
* Copyright (c) 2022 K. Suwatchai (Mobizt)
*
* The MIT License (MIT)
* Copyright (c) 2022 K. Suwatchai (Mobizt)
*
*
* Permission is hereby granted, free of charge, to any person returning a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "FirebaseFS.h"
#ifdef ENABLE_RTDB
#ifndef FIREBASE_QUEUE_INFO_CPP
#define FIREBASE_QUEUE_INFO_CPP
#include "QueueInfo.h"
QueueInfo::QueueInfo()
{
}
QueueInfo::~QueueInfo()
{
clear();
}
uint8_t QueueInfo::totalQueues()
{
return _totalQueue;
}
uint32_t QueueInfo::currentQueueID()
{
return _currentQueueID;
}
bool QueueInfo::isQueueFull()
{
return _isQueueFull;
}
String QueueInfo::dataType()
{
return _dataType.c_str();
}
String QueueInfo::firebaseMethod()
{
return _method.c_str();
}
String QueueInfo::dataPath()
{
return _path.c_str();
}
void QueueInfo::clear()
{
_dataType.clear();
_method.clear();
_path.clear();
}
#endif
#endif //ENABLE
|
//=================================================================================================
/*!
// \file src/mathtest/svecdvecinner/VCbVHa.cpp
// \brief Source file for the VCbVHa sparse vector/dense vector inner product math test
//
// Copyright (C) 2012-2018 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or modify it under
// the terms of the New (Revised) BSD License. Redistribution and use in source and binary
// forms, with or without modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other materials
// provided with the distribution.
// 3. Neither the names of the Blaze development group nor the names of its contributors
// may be used to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
// SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
*/
//=================================================================================================
//*************************************************************************************************
// Includes
//*************************************************************************************************
#include <cstdlib>
#include <iostream>
#include <blaze/math/CompressedVector.h>
#include <blaze/math/HybridVector.h>
#include <blazetest/mathtest/Creator.h>
#include <blazetest/mathtest/svecdvecinner/OperationTest.h>
#include <blazetest/system/MathTest.h>
//=================================================================================================
//
// MAIN FUNCTION
//
//=================================================================================================
//*************************************************************************************************
int main()
{
std::cout << " Running 'VCbVHa'..." << std::endl;
using blazetest::mathtest::TypeA;
using blazetest::mathtest::TypeB;
try
{
// Vector type definitions
typedef blaze::CompressedVector<TypeB> VCb;
typedef blaze::HybridVector<TypeA,128UL> VHa;
// Creator type definitions
typedef blazetest::Creator<VCb> CVCb;
typedef blazetest::Creator<VHa> CVHa;
// Running tests with small vectors
for( size_t i=0UL; i<=6UL; ++i ) {
for( size_t j=0UL; j<=i; ++j ) {
RUN_SVECDVECINNER_OPERATION_TEST( CVCb( i, j ), CVHa( i ) );
}
}
// Running tests with large vectors
RUN_SVECDVECINNER_OPERATION_TEST( CVCb( 127UL, 13UL ), CVHa( 127UL ) );
RUN_SVECDVECINNER_OPERATION_TEST( CVCb( 128UL, 16UL ), CVHa( 128UL ) );
}
catch( std::exception& ex ) {
std::cerr << "\n\n ERROR DETECTED during sparse vector/dense vector inner product:\n"
<< ex.what() << "\n";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
//*************************************************************************************************
|
/*******************************<GINKGO LICENSE>******************************
Copyright (c) 2017-2020, the Ginkgo authors
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
******************************<GINKGO LICENSE>*******************************/
#include "core/components/absolute_array.hpp"
#include <memory>
#include <random>
#include <vector>
#include <gtest/gtest.h>
#include <ginkgo/core/base/array.hpp>
#include "core/test/utils/assertions.hpp"
namespace {
class AbsoluteArray : public ::testing::Test {
protected:
using value_type = double;
using complex_type = std::complex<double>;
AbsoluteArray()
: ref(gko::ReferenceExecutor::create()),
exec(gko::HipExecutor::create(0, ref)),
total_size(6344),
vals(ref, total_size),
dvals(exec, total_size),
complex_vals(ref, total_size),
dcomplex_vals(exec, total_size)
{
std::fill_n(vals.get_data(), total_size, -1234.0);
dvals = vals;
std::fill_n(complex_vals.get_data(), total_size, complex_type{3, 4});
dcomplex_vals = complex_vals;
}
std::shared_ptr<gko::ReferenceExecutor> ref;
std::shared_ptr<gko::HipExecutor> exec;
gko::size_type total_size;
gko::Array<value_type> vals;
gko::Array<value_type> dvals;
gko::Array<complex_type> complex_vals;
gko::Array<complex_type> dcomplex_vals;
};
TEST_F(AbsoluteArray, InplaceEqualsReference)
{
gko::kernels::hip::components::inplace_absolute_array(
exec, dvals.get_data(), total_size);
gko::kernels::reference::components::inplace_absolute_array(
ref, vals.get_data(), total_size);
GKO_ASSERT_ARRAY_EQ(vals, dvals);
}
TEST_F(AbsoluteArray, InplaceComplexEqualsReference)
{
gko::kernels::hip::components::inplace_absolute_array(
exec, dcomplex_vals.get_data(), total_size);
gko::kernels::reference::components::inplace_absolute_array(
ref, complex_vals.get_data(), total_size);
GKO_ASSERT_ARRAY_EQ(complex_vals, dcomplex_vals);
}
TEST_F(AbsoluteArray, OutplaceEqualsReference)
{
gko::Array<value_type> abs_vals(ref, total_size);
gko::Array<value_type> dabs_vals(exec, total_size);
gko::kernels::hip::components::outplace_absolute_array(
exec, dvals.get_const_data(), total_size, dabs_vals.get_data());
gko::kernels::reference::components::outplace_absolute_array(
ref, vals.get_const_data(), total_size, abs_vals.get_data());
GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
}
TEST_F(AbsoluteArray, OutplaceComplexEqualsReference)
{
gko::Array<value_type> abs_vals(ref, total_size);
gko::Array<value_type> dabs_vals(exec, total_size);
gko::kernels::hip::components::outplace_absolute_array(
exec, dcomplex_vals.get_const_data(), total_size, dabs_vals.get_data());
gko::kernels::reference::components::outplace_absolute_array(
ref, complex_vals.get_const_data(), total_size, abs_vals.get_data());
GKO_ASSERT_ARRAY_EQ(abs_vals, dabs_vals);
}
} // namespace
|
// The macro F_CPU specifies the CPU frequency to be considered by the delay macros.
#define F_CPU 1000000UL
// This header file includes the apropriate IO definitions for the device.
#include <avr/io.h>
// The functions in this header file are wrappers around the basic busy-wait functions from <util/delay_basic.h>.
#include <util/delay.h>
// The device library provides a set of default interrupt routines, which will get used if you don't define your own.
#include <avr/interrupt.h>
// Standard IO facilities.
#include <stdio.h>
#define LCD_DDR DDRA // Define LCD Data Port Direction.
#define LCD_PORT PORTA // Define LCD Data Port.
#define RS PA0 // Define Register Select Pin.
#define EN PA1 // Define Enable Signal Pin.
// Define Data Pins.
#define D0 PA4
#define D1 PA5
#define D2 PA6
#define D3 PA7
// Send for 4 bit initialization of LCD.
// Note that we can provide any command with lower nibble as 2 i.e. 0x32, 0x42 etc.
// Except 0x22 to initialize display in 4-bit mode.
#define LCD_4BIT_INIT 0x02
#define LCD_4BIT_1LINE 0x20 // Function Set: 4-bit, 1 Line, 5×7 Dots.
#define LCD_4BIT_2LINE 0x28 // Function Set: 4-bit, 2 Line, 5×7 Dots.
#define LCD_8BIT_1LINE 0x30 // Function Set: 8-bit, 1 Line, 5×7 Dots.
#define LCD_8BIT_2LINE 0x38 // Function Set: 8-bit, 2 Line, 5×7 Dots.
#define DISPLAY_OFF_CURSOR_OFF 0x08 // Clearing display without clearing DDRAM content.
#define DISPLAY_ON_CURSOR_ON 0x0e
#define DISPLAY_ON_CURSOR_OFF 0x0c
#define DISPLAY_ON_CURSOR_BLINKING 0x0f
// Shift the cursor right (e.g. data gets written in an incrementing order, left to right).
#define INCREMENT_CURSOR 0x06
#define SHIFT_DISPLAY_LEFT 0x18 // Shift entire display left.
#define SHIFT_DISPLAY_RIGHT 0x1c // Shift entire display right.
#define MOVE_CURSOR_LEFT 0x10 // Move cursor left by one character.
#define MOVE_CURSOR_RIGHT 0x14 // Move cursor right by one character.
#define CLEAR_DISPLAY 0x01 // Clear Display (also clear DDRAM content).
#define MOVE_CURSOR_1st_LINE 0x80 // Force the cursor to the beginning of the 1st line.
#define MOVE_CURSOR_2nd_LINE 0xc0 // Force the cursor to the beginning of the 2nd line.
void command(uint8_t cmd)
{
// Sending upper 4 bits.
LCD_PORT = (LCD_PORT & 0x0f) | (cmd & 0xf0);
// RS = 0, command register.
LCD_PORT &= ~ (1 << RS);
// Enable pulse.
LCD_PORT |= (1 << EN);
_delay_us(1);
// Disable pulse.
LCD_PORT &= ~ (1 << EN);
_delay_us(200);
// Sending lower 4 bits.
LCD_PORT = (LCD_PORT & 0x0f) | (cmd << 4);
// Enable pulse.
LCD_PORT |= (1 << EN);
_delay_us(1);
// Disable pulse.
LCD_PORT &= ~ (1 << EN);
_delay_ms(2);
}
// Write character on LCD.
void write_char(uint8_t data)
{
// Sending upper byte.
LCD_PORT = (LCD_PORT & 0x0f) | (data & 0xf0);
// RS = 1, data reg.
LCD_PORT |= (1 << RS);
// Enable pulse.
LCD_PORT |= (1 << EN);
_delay_us(1);
// Enable pulse.
LCD_PORT &= ~ (1 << EN);
_delay_us(200);
// Sending lower byte.
LCD_PORT = (LCD_PORT & 0x0f) | (data << 4);
LCD_PORT |= (1 << EN);
_delay_us(1);
// Disable pulse.
LCD_PORT &= ~ (1 << EN);
_delay_ms(2);
}
// Write string on LCD.
void write_str(char *str)
{
for (char *it = str; *it; it++)
write_char(*it);
}
void clear(void)
{
command(CLEAR_DISPLAY);
_delay_ms(3);
command(MOVE_CURSOR_1st_LINE);
}
// LCD Initialize function.
void init(void)
{
// Configure pins as output.
LCD_DDR = LCD_DDR
| (1 << RS)
| (1 << EN)
| (1 << D0)
| (1 << D1)
| (1 << D2)
| (1 << D3);
// Wait for LCD to become ready (docs say 15ms+).
_delay_ms(20);
command(LCD_4BIT_INIT);
command(LCD_4BIT_2LINE);
command(DISPLAY_ON_CURSOR_BLINKING);
_delay_ms(3);
}
struct digital_clock
{
char sec, min, hour;
} time;
// Timer 2 is an 8-bit timer/counter, and so it can count up to 2^8(256) such periods before it rolls over.
int clock_source = 65536;
// Number of counts.
int number_of_counts = 15;
// Counter reload number.
int counter_reload_number = clock_source - number_of_counts;
int time_count = 0;
bool set_hour = false;
bool set_min = false;
bool set_sec = false;
bool done = false;
ISR(TIMER1_OVF_vect)
{
TCNT1 = counter_reload_number;
while(!set_sec){};
time_count++;
if(time_count == 14)
{
// To display digital clock.
char str[8];
time_count = 0;
if(!done)
time.sec--;
if(time.hour == 0 && time.min == 0 && time.sec == 0)
{
if(!done)
{
done = true;
PINB = PINB
| (1 << PINB7);
command(CLEAR_DISPLAY);
// Create necessary string to display digital clock.
sprintf(str, "ALARM!!!");
// Write the string on LCD.
write_str(str);
command(MOVE_CURSOR_2nd_LINE);
// Create necessary string to display digital clock.
sprintf(str, "%02d:%02d:%02d", 0, 0, 0);
// Write the string on LCD.
write_str(str);
}
}
else if(!done)
{
if(time.sec == -1)
{
time.sec = 59;
time.min--;
}
if(time.min == -1)
{
time.min = 0;
time.hour--;
}
if(time.hour == -1)
{
time.hour = 0;
}
command(MOVE_CURSOR_2nd_LINE);
// Create necessary string to display digital clock.
sprintf(str, "%02d:%02d:%02d", time.hour, time.min, time.sec);
// Write the string on LCD.
write_str(str);
}
}
}
int main()
{
//Set last bit of port B for output.
DDRB = DDRB
| (1 << PINB7);
// Set timer 1 prescaler to system clock.
TCCR1B = TCCR1B
| (1 << CS10);
// Set timeout for timer 1.
TCNT1 = counter_reload_number;
// Enables interrupts by setting the global interrupt mask.
sei();
init();
// To display necessary strings.
char str[15];
// Write necessary string.
sprintf(str, "Set Alarm:");
// Write the string on LCD.
write_str(str);
command(MOVE_CURSOR_2nd_LINE);
// Create necessary string.
sprintf(str, "HOUR: %02d", time.hour);
// Write the string on LCD.
write_str(str);
while(true)
{
while(!set_hour)
{
if((PINB >> PINB0) & 1)
{
_delay_ms(500);
set_hour = true;
command(MOVE_CURSOR_2nd_LINE);
// Create necessary string.
sprintf(str, "MINUTE: %02d", time.min);
// Write the string on LCD.
write_str(str);
}
else if((PINB >> PINB1) & 1)
{
_delay_ms(300);
time.hour++;
if(time.hour == 24) time.hour = 0;
command(MOVE_CURSOR_2nd_LINE);
sprintf(str, "HOUR: %02d", time.hour);
write_str(str);
_delay_ms(3);
}
else if((PINB >> 2) & 1)
{
_delay_ms(300);
time.hour--;
if(time.hour == -1) time.hour = 23;
command(MOVE_CURSOR_2nd_LINE);
sprintf(str, "HOUR: %02d", time.hour);
write_str(str);
_delay_ms(3);
}
}
while(!set_min)
{
if((PINB >> PINB0) & 1)
{
_delay_ms(500);
set_min = true;
command(MOVE_CURSOR_2nd_LINE);
// Create necessary string.
sprintf(str, "SECOND: %02d", time.sec);
// Write the string on LCD.
write_str(str);
}
else if((PINB >> PINB1) & 1)
{
_delay_ms(300);
time.min++;
if(time.min == 60) time.min = 0;
command(MOVE_CURSOR_2nd_LINE);
sprintf(str, "MINUTE: %02d", time.min);
write_str(str);
_delay_ms(3);
}
else if((PINB >> 2) & 1)
{
_delay_ms(300);
time.min--;
if(time.min == -1) time.min = 59;
command(MOVE_CURSOR_2nd_LINE);
sprintf(str, "MINUTE: %02d", time.min);
write_str(str);
_delay_ms(3);
}
}
while(!set_sec)
{
if((PINB >> PINB0) & 1)
{
_delay_ms(500);
set_sec = true;
command(CLEAR_DISPLAY);
command(DISPLAY_ON_CURSOR_OFF);
// Write necessary string.
sprintf(str, "Remaining Time:");
// Write the string on LCD.
write_str(str);
command(MOVE_CURSOR_2nd_LINE);
// Create necessary string.
sprintf(str, "%02d:%02d:%02d", time.hour, time.min, time.sec);
// Write the string on LCD.
write_str(str);
// Enable Timer 1.
TIMSK = TIMSK
| (1 << TOIE1);
}
else if((PINB >> PINB1) & 1)
{
_delay_ms(300);
time.sec++;
if(time.sec == 60) time.sec = 0;
command(MOVE_CURSOR_2nd_LINE);
sprintf(str, "SECOND: %02d", time.sec);
write_str(str);
_delay_ms(3);
}
else if((PINB >> 2) & 1)
{
_delay_ms(300);
time.sec--;
if(time.sec == -1) time.sec = 59;
command(MOVE_CURSOR_2nd_LINE);
sprintf(str, "SECOND: %02d", time.sec);
write_str(str);
_delay_ms(3);
}
}
}
return 0;
}
|
#include <iostream>
using namespace std;
class Base
{
public:
int m_nValue;
Base(int nValue=0)
: m_nValue(nValue)
{
cout << "Base" << endl;
}
};
class Derived: public Base
{
public:
double m_dValue;
Derived(double dValue=0.0)
: m_dValue(dValue)
{
cout << "Derived" << endl;
}
};
int main()
{
cout << "Instantiating Base" << endl;
Base cBase;
cout << "Instantiating Derived" << endl;
Derived cDerived;
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int N, M, K, ans;
int g[111], b[111];
int main()
{
int i, j, k;
scanf("%d%d", &N, &M);
for (i = 0; i < N; ++i)
scanf("%d", g+i);
for (i = 0; i < M; ++i)
scanf("%d", b+i);
sort(g, g+N);
sort(b, b+M);
if (N < M)
{
reverse(g, g+N);
reverse(b, b+M);
int sumg = 0;
for (i = 0; i < N; ++i)
sumg += g[i];
int sumb = 0;
for (i = 0; i < M; ++i)
sumb += b[i];
ans = 0x3fffffff;
for (k = 0; k <= N; ++k)
{
ans = min(ans, sumg+k*sumb);
sumg -= g[k];
sumb -= b[k];
}
}
else
{
for (i = 0; i < N-M; ++i)
ans += g[i];
}
printf("%d\n", ans);
return 0;
}
|
/****************************************************************************
*
* Copyright (c) 2018 PX4 Development Team. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#include "counter_sub.h"
#include <px4_getopt.h>
#include <px4_log.h>
#include <px4_posix.h>
#include <uORB/topics/counter.h>
int counterSub::print_usage(const char *reason)
{
if (reason) {
PX4_WARN("%s\n", reason);
}
PRINT_MODULE_DESCRIPTION(
R"DESCR_STR(
### Description
Section that describes the provided module functionality.
This is an attempt to write a subscriber as a task in the background with start/stop/status functionality.
### Implementation
Section describing the high-level implementation of this module.
### Examples
CLI usage example:
$ counter_sub start
)DESCR_STR");
PRINT_MODULE_USAGE_NAME("counter_sub", "module");
PRINT_MODULE_USAGE_COMMAND("start");
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
return 0;
}
int counterSub::print_status()
{
PX4_INFO("Running");
// TODO: print additional runtime information about the state of the module
return 0;
}
int counterSub::custom_command(int argc, char *argv[])
{
/*
if (!is_running()) {
print_usage("not running");
return 1;
}
// additional custom commands can be handled like this:
if (!strcmp(argv[0], "do-something")) {
get_instance()->do_something();
return 0;
}
*/
return print_usage("unknown command");
}
int counterSub::task_spawn(int argc, char *argv[])
{
_task_id = px4_task_spawn_cmd("module",
SCHED_DEFAULT,
SCHED_PRIORITY_DEFAULT,
1024,
(px4_main_t)&run_trampoline,
(char *const *)argv);
if (_task_id < 0) {
_task_id = -1;
return -errno;
}
return 0;
}
counterSub *counterSub::instantiate(int argc, char *argv[])
{
bool error_flag = false;
int myoptind = 1;
int ch;
const char *myoptarg = nullptr;
// parse CLI arguments
while ((ch = px4_getopt(argc, argv,"", &myoptind, &myoptarg)) != EOF) {
switch (ch) {
case '?':
error_flag = true;
break;
default:
PX4_WARN("unrecognized flag");
error_flag = true;
break;
}
}
if (error_flag) {
return nullptr;
}
counterSub *instance = new counterSub();
if (instance == nullptr) {
PX4_ERR("alloc failed");
}
return instance;
}
counterSub::counterSub()
{
}
void counterSub::run()
{
// Example: run the loop synchronized to the sensor_combined topic publication
int counter_sub = orb_subscribe(ORB_ID(counter));
px4_pollfd_struct_t fds[1];
fds[0].fd = counter_sub;
fds[0].events = POLLIN;
while (!should_exit()) {
// wait for up to 1000ms for data
int pret = px4_poll(fds, (sizeof(fds) / sizeof(fds[0])), 1000);
if (pret == 0) {
// Timeout: let the loop run anyway, don't do `continue` here
} else if (pret < 0) {
// this is undesirable but not much we can do
PX4_ERR("poll error %d, %d", pret, errno);
usleep(50000);
continue;
} else if (fds[0].revents & POLLIN) {
struct counter_s counter;
orb_copy(ORB_ID(counter), counter_sub, &counter);
PX4_INFO("the value is %d", counter.value );
// TODO: do something with the data...
}
}
orb_unsubscribe(counter_sub);
}
int counter_sub_main(int argc, char *argv[])
{
return counterSub::main(argc, argv);
}
|
/*
* Copyright (C) 2011 STMicroelectronics. All rights reserved.
* Copyright (C) 2008 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#if ENABLE(ASSEMBLER) && CPU(SH4)
#include "MacroAssemblerSH4.h"
namespace JSC {
const Condition MacroAssemblerSH4::Equal = SH4Assembler::EQ;
const Condition MacroAssemblerSH4::NotEqual = SH4Assembler::NE;
const Condition MacroAssemblerSH4::GreaterThan = SH4Assembler::GT;
const Condition MacroAssemblerSH4::GreaterThanOrEqual = SH4Assembler::GE;
const Condition MacroAssemblerSH4::LessThan = SH4Assembler::LT;
const Condition MacroAssemblerSH4::LessThanOrEqual = SH4Assembler::LE;
const Condition MacroAssemblerSH4::UGreaterThan = SH4Assembler::HI;
const Condition MacroAssemblerSH4::UGreaterThanOrEqual = SH4Assembler::HS;
const Condition MacroAssemblerSH4::ULessThan = SH4Assembler::LI;
const Condition MacroAssemblerSH4::ULessThanOrEqual = SH4Assembler::LS;
const Condition MacroAssemblerSH4::Zero = SH4Assembler::EQ;
const Condition MacroAssemblerSH4::NonZero = SH4Assembler::NE;
const Condition MacroAssemblerSH4::Overflow = SH4Assembler::OF;
const Condition MacroAssemblerSH4::Above = SH4Assembler::HI;
const Condition MacroAssemblerSH4::AboveOrEqual = SH4Assembler::HS;
const Condition MacroAssemblerSH4::Below = SH4Assembler::LI;
const Condition MacroAssemblerSH4::BelowOrEqual = SH4Assembler::LS;
const Condition MacroAssemblerSH4::DoubleEqual = SH4Assembler::EQ;
const Condition MacroAssemblerSH4::DoubleNotEqual = SH4Assembler::NE;
const Condition MacroAssemblerSH4::DoubleGreaterThan = SH4Assembler::GT;
const Condition MacroAssemblerSH4::DoubleGreaterThanOrEqual = SH4Assembler::GE;
const Condition MacroAssemblerSH4::DoubleLessThan = SH4Assembler::LT;
const Condition MacroAssemblerSH4::DoubleLessThanOrEqual = SH4Assembler::LE;
const Condition MacroAssemblerSH4::DoubleEqualOrUnordered = SH4Assembler::EQU;
const Condition MacroAssemblerSH4::DoubleNotEqualOrUnordered = SH4Assembler::NEU;
const Condition MacroAssemblerSH4::DoubleGreaterThanOrUnordered = SH4Assembler::GTU;
const Condition MacroAssemblerSH4::DoubleGreaterThanOrEqualOrUnordered = SH4Assembler::GEU;
const Condition MacroAssemblerSH4::DoubleLessThanOrUnordered = SH4Assembler::LTU;
const Condition MacroAssemblerSH4::DoubleLessThanOrEqualOrUnordered = SH4Assembler::LEU;
const Condition MacroAssemblerSH4::Signed = SH4Assembler::SI;
void MacroAssemblerSH4::linkCall(void* code, Call call, FunctionPtr function)
{
SH4Assembler::linkCall(code, call.m_jmp, function.value());
}
void MacroAssemblerSH4::repatchCall(CodeLocationCall call, CodeLocationLabel destination)
{
SH4Assembler::relinkCall(call.dataLocation(), destination.executableAddress());
}
void MacroAssemblerSH4::repatchCall(CodeLocationCall call, FunctionPtr destination)
{
SH4Assembler::relinkCall(call.dataLocation(), destination.executableAddress());
}
} // namespace JSC
#endif // ENABLE(ASSEMBLER)
|
// Copyright (c) 2017-2018 The Bitcoin Core developers
// Copyright (c) 2018 The Deftchain developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <chainparams.h>
#include <index/base.h>
#include <shutdown.h>
#include <tinyformat.h>
#include <ui_interface.h>
#include <util.h>
#include <validation.h>
#include <warnings.h>
constexpr char DB_BEST_BLOCK = 'B';
constexpr int64_t SYNC_LOG_INTERVAL = 30; // seconds
constexpr int64_t SYNC_LOCATOR_WRITE_INTERVAL = 30; // seconds
template<typename... Args>
static void FatalError(const char* fmt, const Args&... args)
{
std::string strMessage = tfm::format(fmt, args...);
SetMiscWarning(strMessage);
LogPrintf("*** %s\n", strMessage);
uiInterface.ThreadSafeMessageBox(
"Error: A fatal internal error occurred, see debug.log for details",
"", CClientUIInterface::MSG_ERROR);
StartShutdown();
}
BaseIndex::DB::DB(const fs::path& path, size_t n_cache_size, bool f_memory, bool f_wipe, bool f_obfuscate) :
CDBWrapper(path, n_cache_size, f_memory, f_wipe, f_obfuscate)
{}
bool BaseIndex::DB::ReadBestBlock(CBlockLocator& locator) const
{
bool success = Read(DB_BEST_BLOCK, locator);
if (!success) {
locator.SetNull();
}
return success;
}
bool BaseIndex::DB::WriteBestBlock(const CBlockLocator& locator)
{
return Write(DB_BEST_BLOCK, locator);
}
BaseIndex::~BaseIndex()
{
Interrupt();
Stop();
}
bool BaseIndex::Init()
{
CBlockLocator locator;
if (!GetDB().ReadBestBlock(locator)) {
locator.SetNull();
}
LOCK(cs_main);
m_best_block_index = FindForkInGlobalIndex(chainActive, locator);
m_synced = m_best_block_index.load() == chainActive.Tip();
return true;
}
static const CBlockIndex* NextSyncBlock(const CBlockIndex* pindex_prev)
{
AssertLockHeld(cs_main);
if (!pindex_prev) {
return chainActive.Genesis();
}
const CBlockIndex* pindex = chainActive.Next(pindex_prev);
if (pindex) {
return pindex;
}
return chainActive.Next(chainActive.FindFork(pindex_prev));
}
void BaseIndex::ThreadSync()
{
const CBlockIndex* pindex = m_best_block_index.load();
if (!m_synced) {
auto& consensus_params = Params().GetConsensus();
int64_t last_log_time = 0;
int64_t last_locator_write_time = 0;
while (true) {
if (m_interrupt) {
WriteBestBlock(pindex);
return;
}
{
LOCK(cs_main);
const CBlockIndex* pindex_next = NextSyncBlock(pindex);
if (!pindex_next) {
WriteBestBlock(pindex);
m_best_block_index = pindex;
m_synced = true;
break;
}
pindex = pindex_next;
}
int64_t current_time = GetTime();
if (last_log_time + SYNC_LOG_INTERVAL < current_time) {
LogPrintf("Syncing %s with block chain from height %d\n",
GetName(), pindex->nHeight);
last_log_time = current_time;
}
if (last_locator_write_time + SYNC_LOCATOR_WRITE_INTERVAL < current_time) {
WriteBestBlock(pindex);
last_locator_write_time = current_time;
}
CBlock block;
if (!ReadBlockFromDisk(block, pindex, consensus_params)) {
FatalError("%s: Failed to read block %s from disk",
__func__, pindex->GetBlockHash().ToString());
return;
}
if (!WriteBlock(block, pindex)) {
FatalError("%s: Failed to write block %s to index database",
__func__, pindex->GetBlockHash().ToString());
return;
}
}
}
if (pindex) {
LogPrintf("%s is enabled at height %d\n", GetName(), pindex->nHeight);
} else {
LogPrintf("%s is enabled\n", GetName());
}
}
bool BaseIndex::WriteBestBlock(const CBlockIndex* block_index)
{
LOCK(cs_main);
if (!GetDB().WriteBestBlock(chainActive.GetLocator(block_index))) {
return error("%s: Failed to write locator to disk", __func__);
}
return true;
}
void BaseIndex::BlockConnected(const std::shared_ptr<const CBlock>& block, const CBlockIndex* pindex,
const std::vector<CTransactionRef>& txn_conflicted)
{
if (!m_synced) {
return;
}
const CBlockIndex* best_block_index = m_best_block_index.load();
if (!best_block_index) {
if (pindex->nHeight != 0) {
FatalError("%s: First block connected is not the genesis block (height=%d)",
__func__, pindex->nHeight);
return;
}
} else {
// Ensure block connects to an ancestor of the current best block. This should be the case
// most of the time, but may not be immediately after the sync thread catches up and sets
// m_synced. Consider the case where there is a reorg and the blocks on the stale branch are
// in the ValidationInterface queue backlog even after the sync thread has caught up to the
// new chain tip. In this unlikely event, log a warning and let the queue clear.
if (best_block_index->GetAncestor(pindex->nHeight - 1) != pindex->pprev) {
LogPrintf("%s: WARNING: Block %s does not connect to an ancestor of " /* Continued */
"known best chain (tip=%s); not updating index\n",
__func__, pindex->GetBlockHash().ToString(),
best_block_index->GetBlockHash().ToString());
return;
}
}
if (WriteBlock(*block, pindex)) {
m_best_block_index = pindex;
} else {
FatalError("%s: Failed to write block %s to index",
__func__, pindex->GetBlockHash().ToString());
return;
}
}
void BaseIndex::ChainStateFlushed(const CBlockLocator& locator)
{
if (!m_synced) {
return;
}
const uint256& locator_tip_hash = locator.vHave.front();
const CBlockIndex* locator_tip_index;
{
LOCK(cs_main);
locator_tip_index = LookupBlockIndex(locator_tip_hash);
}
if (!locator_tip_index) {
FatalError("%s: First block (hash=%s) in locator was not found",
__func__, locator_tip_hash.ToString());
return;
}
// This checks that ChainStateFlushed callbacks are received after BlockConnected. The check may fail
// immediately after the sync thread catches up and sets m_synced. Consider the case where
// there is a reorg and the blocks on the stale branch are in the ValidationInterface queue
// backlog even after the sync thread has caught up to the new chain tip. In this unlikely
// event, log a warning and let the queue clear.
const CBlockIndex* best_block_index = m_best_block_index.load();
if (best_block_index->GetAncestor(locator_tip_index->nHeight) != locator_tip_index) {
LogPrintf("%s: WARNING: Locator contains block (hash=%s) not on known best " /* Continued */
"chain (tip=%s); not writing index locator\n",
__func__, locator_tip_hash.ToString(),
best_block_index->GetBlockHash().ToString());
return;
}
if (!GetDB().WriteBestBlock(locator)) {
error("%s: Failed to write locator to disk", __func__);
}
}
bool BaseIndex::BlockUntilSyncedToCurrentChain()
{
AssertLockNotHeld(cs_main);
if (!m_synced) {
return false;
}
{
// Skip the queue-draining stuff if we know we're caught up with
// chainActive.Tip().
LOCK(cs_main);
const CBlockIndex* chain_tip = chainActive.Tip();
const CBlockIndex* best_block_index = m_best_block_index.load();
if (best_block_index->GetAncestor(chain_tip->nHeight) == chain_tip) {
return true;
}
}
LogPrintf("%s: %s is catching up on block notifications\n", __func__, GetName());
SyncWithValidationInterfaceQueue();
return true;
}
void BaseIndex::Interrupt()
{
m_interrupt();
}
void BaseIndex::Start()
{
// Need to register this ValidationInterface before running Init(), so that
// callbacks are not missed if Init sets m_synced to true.
RegisterValidationInterface(this);
if (!Init()) {
FatalError("%s: %s failed to initialize", __func__, GetName());
return;
}
m_thread_sync = std::thread(&TraceThread<std::function<void()>>, GetName(),
std::bind(&BaseIndex::ThreadSync, this));
}
void BaseIndex::Stop()
{
UnregisterValidationInterface(this);
if (m_thread_sync.joinable()) {
m_thread_sync.join();
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.