Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp} Namespace Reference

Classes
class	InterProcessRefreshTokenLock

Functions
std::string	get_json_string_field (const json &j, const std::string &key)
long long	get_json_int64_field (const json &j, const std::string &key)
std::string	resolve_display_name (const std::string &display_name, const std::string &nickname, const std::string &full_name, const std::string &name, const std::string &username)
std::string	base64url_encode (const std::vector< unsigned char > &data)
bool	base64url_decode (const std::string &input, std::vector< unsigned char > &out)
std::vector< unsigned char >	random_bytes (size_t len)
std::string	generate_code_verifier ()
std::string	generate_state_token ()
std::string	sha256_base64url (const std::string &input)
std::string	os_machine_id ()
std::string	get_encryption_key ()
std::vector< unsigned char >	sha256_bytes (const std::string &input)
std::string	hmac_sha256_hex (const std::string &data, const std::vector< unsigned char > &key)
bool	is_port_available (int port)
int	choose_loopback_port ()
bool	aes256gcm_encrypt (const std::string &plaintext, const std::vector< unsigned char > &key, std::string &out_b64)
bool	aes256gcm_decrypt (const std::string &b64_payload, const std::vector< unsigned char > &key, std::string &plaintext)

Variables
constexpr const char *	ORCA_DEFAULT_API_URL = "https://api.orcaslicer.com"
constexpr const char *	ORCA_DEFAULT_AUTH_URL = "https://auth.orcaslicer.com"
constexpr const char *	ORCA_DEFAULT_CLOUD_URL = "https://cloud.orcaslicer.com"
constexpr const char *	ORCA_DEFAULT_PUB_KEY = "sb_publishable_lvVe_whOi80SU9BPSxM1kA_tbt9AbR_"
constexpr const char *	ORCA_HEALTH_PATH = "/api/v1/health"
constexpr const char *	ORCA_SYNC_PULL_PATH = "/api/v1/sync/pull"
constexpr const char *	ORCA_SYNC_PUSH_PATH = "/api/v1/sync/push"
constexpr const char *	ORCA_SYNC_FORCE_PUSH_PATH = "/api/v1/sync/force-push"
constexpr const char *	ORCA_SYNC_DELETE_PATH = "/api/v1/sync/delete"
constexpr const char *	ORCA_PROFILES_PATH = "/api/v1/sync/profiles"
constexpr const char *	ORCA_SUBSCRIPTIONS_PATH = "/api/v1/subscriptions"
constexpr const char *	ORCA_SYNC_STATE_FILE = "sync_state"
constexpr const char *	ORCA_SYNC_PROFILE_TABLE = "profiles"
constexpr size_t	ORCA_SYNC_MAX_PAYLOAD_SIZE = 1048576
constexpr const char *	ORCA_SUBSCRIBED_PLUGINS = "/api/v1/plugins/subscriptions"
constexpr const char *	ORCA_UNSUBSCRIBE_PLUGINS = "/api/v1/plugins/subscriptions"
constexpr const char *	ORCA_PLUGINS_MINE = "/api/v1/plugins/mine"
constexpr const char *	ORCA_PLUGINS_BASE = "/api/v1/plugins"
constexpr const char *	ORCA_PLUGIN_DOWNLOAD_URL = "/api/v1/plugins/download"
constexpr const char *	ORCA_CLOUD_PRINTER = "/api/v1/printers"
constexpr const char *	ORCA_CLOUD_LOGIN_PATH = "/orcaslicer-login"
constexpr const char *	ORCA_WEB_SESSION_HANDOFF_PATH = "/api/v1/account/web-session-handoff"
constexpr const char *	CONFIG_ORCA_API_URL = "orca_api_url"
constexpr const char *	CONFIG_ORCA_AUTH_URL = "orca_auth_url"
constexpr const char *	CONFIG_ORCA_CLOUD_URL = "orca_cloud_url"
constexpr const char *	CONFIG_ORCA_PUB_KEY = "orca_pub_key"
constexpr const char *	SECRET_STORE_SERVICE = "OrcaSlicer/Auth"
constexpr const char *	SECRET_STORE_USER = "orca_refresh_token"
constexpr std::chrono::seconds	TOKEN_REFRESH_SKEW {900}

Function Documentation

aes256gcm_decrypt()

bool Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::aes256gcm_decrypt	(	const std::string &	b64_payload,
		const std::vector< unsigned char > &	key,
		std::string &	plaintext )

{
    std::vector<unsigned char> payload;
    if (!base64url_decode(b64_payload, payload))
        return false;
    if (payload.size() < 12 + 16)
        return false;
 
    const size_t iv_len  = 12;
    const size_t tag_len = 16;
    std::vector<unsigned char> iv(payload.begin(), payload.begin() + iv_len);
    std::vector<unsigned char> tag(payload.begin() + iv_len, payload.begin() + iv_len + tag_len);
    std::vector<unsigned char> ciphertext(payload.begin() + iv_len + tag_len, payload.end());
 
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    if (!ctx)
        return false;
 
    bool ok = true;
    int len = 0;
    std::vector<unsigned char> plain(ciphertext.size());
 
    if (EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), nullptr, nullptr, nullptr) != 1)
        ok = false;
    if (ok && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, iv_len, nullptr) != 1)
        ok = false;
    if (ok && EVP_DecryptInit_ex(ctx, nullptr, nullptr, key.data(), iv.data()) != 1)
        ok = false;
    if (ok && EVP_DecryptUpdate(ctx, plain.data(), &len, ciphertext.data(), ciphertext.size()) != 1)
        ok = false;
    int plain_len = len;
    if (ok && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, tag.size(), tag.data()) != 1)
        ok = false;
    if (ok && EVP_DecryptFinal_ex(ctx, plain.data() + len, &len) != 1)
        ok = false;
    plain_len += len;
 
    EVP_CIPHER_CTX_free(ctx);
 
    if (!ok)
        return false;
    plain.resize(plain_len);
    plaintext.assign(reinterpret_cast<char*>(plain.data()), plain.size());
    return true;
}

References aes256gcm_decrypt(), and base64url_decode().

Referenced by aes256gcm_decrypt().

Here is the call graph for this function:

Here is the caller graph for this function:

aes256gcm_encrypt()

bool Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::aes256gcm_encrypt	(	const std::string &	plaintext,
		const std::vector< unsigned char > &	key,
		std::string &	out_b64 )

{
    const int iv_len = 12;
    auto iv          = random_bytes(iv_len);
 
    EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
    if (!ctx)
        return false;
 
    bool ok = true;
    int len = 0;
    std::vector<unsigned char> ciphertext(plaintext.size());
    std::vector<unsigned char> tag(16);
 
    if (EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), nullptr, nullptr, nullptr) != 1)
        ok = false;
    if (ok && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, iv_len, nullptr) != 1)
        ok = false;
    if (ok && EVP_EncryptInit_ex(ctx, nullptr, nullptr, key.data(), iv.data()) != 1)
        ok = false;
    if (ok &&
        EVP_EncryptUpdate(ctx, ciphertext.data(), &len, reinterpret_cast<const unsigned char*>(plaintext.data()), plaintext.size()) != 1)
        ok = false;
    int ciphertext_len = len;
    if (ok && EVP_EncryptFinal_ex(ctx, ciphertext.data() + len, &len) != 1)
        ok = false;
    ciphertext_len += len;
    if (ok && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, tag.size(), tag.data()) != 1)
        ok = false;
 
    EVP_CIPHER_CTX_free(ctx);
 
    if (!ok)
        return false;
    ciphertext.resize(ciphertext_len);
 
    std::vector<unsigned char> payload;
    payload.reserve(iv.size() + tag.size() + ciphertext.size());
    payload.insert(payload.end(), iv.begin(), iv.end());
    payload.insert(payload.end(), tag.begin(), tag.end());
    payload.insert(payload.end(), ciphertext.begin(), ciphertext.end());
 
    out_b64 = base64url_encode(payload);
    return true;
}

References aes256gcm_encrypt(), base64url_encode(), and random_bytes().

Referenced by aes256gcm_encrypt().

Here is the call graph for this function:

Here is the caller graph for this function:

base64url_decode()

bool Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::base64url_decode	(	const std::string &	input,
		std::vector< unsigned char > &	out )

{
    std::string padded = input;
    while (padded.size() % 4 != 0)
        padded.push_back('=');
    std::string normalized = padded;
    std::replace(normalized.begin(), normalized.end(), '-', '+');
    std::replace(normalized.begin(), normalized.end(), '_', '/');
 
    out.resize(boost::beast::detail::base64::decoded_size(normalized.size()));
    auto res = boost::beast::detail::base64::decode(out.data(), normalized.data(), normalized.size());
    if (!res.second)
        return false;
    out.resize(res.first);
    return true;
}

References base64url_decode().

Referenced by aes256gcm_decrypt(), and base64url_decode().

Here is the call graph for this function:

Here is the caller graph for this function:

base64url_encode()

std::string Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::base64url_encode

(

const std::vector< unsigned char > &

data

)

{
    std::string out;
    out.resize(boost::beast::detail::base64::encoded_size(data.size()));
    out.resize(boost::beast::detail::base64::encode(out.data(), data.data(), data.size()));
 
    std::replace(out.begin(), out.end(), '+', '-');
    std::replace(out.begin(), out.end(), '/', '_');
    out.erase(std::remove(out.begin(), out.end(), '='), out.end());
    return out;
}

References base64url_encode().

Referenced by aes256gcm_encrypt(), base64url_encode(), generate_code_verifier(), and sha256_base64url().

Here is the call graph for this function:

Here is the caller graph for this function:

choose_loopback_port()

int Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::choose_loopback_port

(

)

{
    int base_port = auth_constants::LOOPBACK_PORT;
 
    if (const char* env_port = std::getenv("ORCA_LOOPBACK_PORT")) {
        try {
            int parsed = std::stoi(env_port);
            if (parsed > 0 && parsed <= 65535) {
                base_port = parsed;
            }
        } catch (...) {
            BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: invalid ORCA_LOOPBACK_PORT value, falling back to default";
        }
    }
 
    std::vector<int> candidates = {base_port, base_port + 1, base_port + 2};
    for (int port : candidates) {
        if (is_port_available(port))
            return port;
    }
 
    return base_port;
}

References choose_loopback_port(), is_port_available(), and Slic3r::auth_constants::LOOPBACK_PORT.

Referenced by choose_loopback_port().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_code_verifier()

std::string Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::generate_code_verifier

(

)

{
    constexpr int PKCE_VERIFIER_BYTES = 32;
    auto bytes                        = random_bytes(PKCE_VERIFIER_BYTES);
    return base64url_encode(bytes);
}

References base64url_encode(), generate_code_verifier(), and random_bytes().

Referenced by generate_code_verifier().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_state_token()

std::string Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::generate_state_token

(

)

{
    auto bytes = random_bytes(16);
    std::stringstream ss;
    for (auto b : bytes) {
        ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(b);
    }
    return ss.str();
}

References generate_state_token(), and random_bytes().

Referenced by generate_state_token().

Here is the call graph for this function:

Here is the caller graph for this function:

get_encryption_key()

std::string Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::get_encryption_key

(

)

{
    // Bind the encryption key to both the machine and the OS user. A data_dir
    // copied to another machine changes the machine half; a data_dir shared
    // between OS users on the same machine changes the user half. Either
    // difference makes the stored token fail to decrypt and forces a sign-in.
    return os_machine_id() + ":" + wxGetUserId().ToStdString();
}

References get_encryption_key(), and os_machine_id().

Referenced by get_encryption_key().

Here is the call graph for this function:

Here is the caller graph for this function:

get_json_int64_field()

long long Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::get_json_int64_field	(	const json &	j,
		const std::string &	key )

{
    if (!j.contains(key))
        return 0;
 
    const auto& value = j[key];
    if (value.is_number_integer())
        return value.get<long long>();
    if (value.is_number_unsigned())
        return static_cast<long long>(value.get<unsigned long long>());
    return 0;
}

References get_json_int64_field().

Referenced by get_json_int64_field().

Here is the call graph for this function:

Here is the caller graph for this function:

get_json_string_field()

std::string Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::get_json_string_field	(	const json &	j,
		const std::string &	key )

{
    if (j.contains(key) && j[key].is_string()) {
        return j[key].get<std::string>();
    }
    return "";
}

References get_json_string_field().

Referenced by get_json_string_field().

Here is the call graph for this function:

Here is the caller graph for this function:

hmac_sha256_hex()

std::string Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::hmac_sha256_hex	(	const std::string &	data,
		const std::vector< unsigned char > &	key )

{
    unsigned int len = 0;
    unsigned char result[EVP_MAX_MD_SIZE];
    if (HMAC(EVP_sha256(), key.data(), static_cast<int>(key.size()), reinterpret_cast<const unsigned char*>(data.data()), data.size(),
             result, &len) == nullptr) {
        return {};
    }
 
    std::ostringstream oss;
    oss << std::hex << std::setfill('0');
    for (unsigned int i = 0; i < len; ++i) {
        oss << std::setw(2) << static_cast<int>(result[i]);
    }
    return oss.str();
}

References hmac_sha256_hex().

Referenced by hmac_sha256_hex().

Here is the call graph for this function:

Here is the caller graph for this function:

is_port_available()

bool Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::is_port_available

(

int

port

)

{
    if (port <= 0 || port > 65535)
        return false;
 
    using boost::asio::ip::tcp;
    boost::asio::io_context ctx;
    boost::system::error_code ec;
 
    tcp::acceptor acceptor(ctx);
    tcp::endpoint endpoint(tcp::v4(), static_cast<unsigned short>(port));
 
    acceptor.open(endpoint.protocol(), ec);
    if (ec)
        return false;
    acceptor.set_option(tcp::acceptor::reuse_address(true), ec);
    if (ec)
        return false;
    acceptor.bind(endpoint, ec);
    if (ec)
        return false;
    acceptor.close(ec);
    return true;
}

References is_port_available().

Referenced by choose_loopback_port(), and is_port_available().

Here is the call graph for this function:

Here is the caller graph for this function:

os_machine_id()

std::string Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::os_machine_id

(

)

{
    // Orca: OS-level identifiers that live outside data_dir, so a copied data_dir
    // on another machine yields a different key and the stored refresh
    // token silently fails to decrypt (forcing a normal sign-in).
#if defined(__linux__)
    std::ifstream f("/etc/machine-id");
    std::string id;
    if (f.good()) {
        std::getline(f, id);
    }
    if (!id.empty())
        return id;
#elif defined(_WIN32)
    // HKLM\SOFTWARE\Microsoft\Cryptography\MachineGuid is a per-install
    // identifier that isn't copied along with the user's data_dir.
    HKEY hkey = nullptr;
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Cryptography", 0, KEY_READ | KEY_WOW64_64KEY, &hkey) == ERROR_SUCCESS) {
        wchar_t buffer[128] = {0};
        DWORD buffer_bytes  = sizeof(buffer);
        DWORD type          = 0;
        LONG status         = RegQueryValueExW(hkey, L"MachineGuid", nullptr, &type, reinterpret_cast<LPBYTE>(buffer), &buffer_bytes);
        RegCloseKey(hkey);
        if (status == ERROR_SUCCESS && type == REG_SZ && buffer_bytes > sizeof(wchar_t)) {
            const size_t wlen = (buffer_bytes / sizeof(wchar_t)) - 1; // strip trailing NUL
            return wxString(buffer, wlen).ToStdString();
        }
    }
#elif defined(__APPLE__)
    // gethostuuid() returns the hardware-tied host UUID (same value as
    // "Hardware UUID" in System Information). It persists across OS
    // reinstalls and kernel updates. Do NOT use sysctl kern.uuid — that
    // is the running kernel image's build UUID (from kernel_uuid_string
    // in XNU), which rotates on every macOS/kernel update and would
    // sign users out on every OS update.
    uuid_t host_id;
    struct timespec wait = {0, 0};
    if (gethostuuid(host_id, &wait) == 0) {
        uuid_string_t str;
        uuid_unparse(host_id, str);
        return std::string(str);
    }
#endif
 
    // Last resort: OS hostname.
    return wxGetHostName().ToStdString();
}

References Slic3r::empty(), Slic3r::f(), L, and os_machine_id().

Referenced by get_encryption_key(), and os_machine_id().

Here is the call graph for this function:

Here is the caller graph for this function:

random_bytes()

std::vector< unsigned char > Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::random_bytes

(

size_t

len

)

{
    std::vector<unsigned char> bytes(len);
    if (RAND_bytes(bytes.data(), static_cast<int>(len)) != 1) {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<int> dist(0, 255);
        for (auto& b : bytes)
            b = static_cast<unsigned char>(dist(gen));
    }
    return bytes;
}

References Slic3r::Geometry::dist(), and random_bytes().

Referenced by aes256gcm_encrypt(), generate_code_verifier(), generate_state_token(), and random_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_display_name()

std::string Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::resolve_display_name	(	const std::string &	display_name,
		const std::string &	nickname,
		const std::string &	full_name,
		const std::string &	name,
		const std::string &	username )

{
    // Providers and payload shapes do not all use the same display-name field.
    // Fallback sequence: display_name -> nickname -> full_name -> name
    if (!display_name.empty())
        return display_name;
    if (!nickname.empty())
        return nickname;
    if (!full_name.empty())
        return full_name;
    if (!name.empty())
        return name;
    return username;
}

References resolve_display_name().

Referenced by resolve_display_name().

Here is the call graph for this function:

Here is the caller graph for this function:

sha256_base64url()

std::string Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::sha256_base64url

(

const std::string &

input

)

{
    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256(reinterpret_cast<const unsigned char*>(input.data()), input.size(), hash);
    std::vector<unsigned char> hash_vec(hash, hash + sizeof(hash));
    return base64url_encode(hash_vec);
}

References base64url_encode(), and sha256_base64url().

Referenced by sha256_base64url().

Here is the call graph for this function:

Here is the caller graph for this function:

sha256_bytes()

std::vector< unsigned char > Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::sha256_bytes

(

const std::string &

input

)

{
    std::vector<unsigned char> out(SHA256_DIGEST_LENGTH, 0);
    SHA256(reinterpret_cast<const unsigned char*>(input.data()), input.size(), out.data());
    return out;
}

References sha256_bytes().

Referenced by sha256_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

CONFIG_ORCA_API_URL

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::CONFIG_ORCA_API_URL = "orca_api_url"

constexpr

CONFIG_ORCA_AUTH_URL

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::CONFIG_ORCA_AUTH_URL = "orca_auth_url"

constexpr

CONFIG_ORCA_CLOUD_URL

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::CONFIG_ORCA_CLOUD_URL = "orca_cloud_url"

constexpr

CONFIG_ORCA_PUB_KEY

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::CONFIG_ORCA_PUB_KEY = "orca_pub_key"

constexpr

ORCA_CLOUD_LOGIN_PATH

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_CLOUD_LOGIN_PATH = "/orcaslicer-login"

constexpr

ORCA_CLOUD_PRINTER

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_CLOUD_PRINTER = "/api/v1/printers"

constexpr

ORCA_DEFAULT_API_URL

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_DEFAULT_API_URL = "https://api.orcaslicer.com"

constexpr

ORCA_DEFAULT_AUTH_URL

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_DEFAULT_AUTH_URL = "https://auth.orcaslicer.com"

constexpr

ORCA_DEFAULT_CLOUD_URL

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_DEFAULT_CLOUD_URL = "https://cloud.orcaslicer.com"

constexpr

ORCA_DEFAULT_PUB_KEY

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_DEFAULT_PUB_KEY = "sb_publishable_lvVe_whOi80SU9BPSxM1kA_tbt9AbR_"

constexpr

ORCA_HEALTH_PATH

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_HEALTH_PATH = "/api/v1/health"

constexpr

ORCA_PLUGIN_DOWNLOAD_URL

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_PLUGIN_DOWNLOAD_URL = "/api/v1/plugins/download"

constexpr

ORCA_PLUGINS_BASE

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_PLUGINS_BASE = "/api/v1/plugins"

constexpr

ORCA_PLUGINS_MINE

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_PLUGINS_MINE = "/api/v1/plugins/mine"

constexpr

ORCA_PROFILES_PATH

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_PROFILES_PATH = "/api/v1/sync/profiles"

constexpr

ORCA_SUBSCRIBED_PLUGINS

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_SUBSCRIBED_PLUGINS = "/api/v1/plugins/subscriptions"

constexpr

ORCA_SUBSCRIPTIONS_PATH

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_SUBSCRIPTIONS_PATH = "/api/v1/subscriptions"

constexpr

ORCA_SYNC_DELETE_PATH

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_SYNC_DELETE_PATH = "/api/v1/sync/delete"

constexpr

ORCA_SYNC_FORCE_PUSH_PATH

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_SYNC_FORCE_PUSH_PATH = "/api/v1/sync/force-push"

constexpr

ORCA_SYNC_MAX_PAYLOAD_SIZE

size_t Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_SYNC_MAX_PAYLOAD_SIZE = 1048576

constexpr

ORCA_SYNC_PROFILE_TABLE

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_SYNC_PROFILE_TABLE = "profiles"

constexpr

ORCA_SYNC_PULL_PATH

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_SYNC_PULL_PATH = "/api/v1/sync/pull"

constexpr

ORCA_SYNC_PUSH_PATH

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_SYNC_PUSH_PATH = "/api/v1/sync/push"

constexpr

ORCA_SYNC_STATE_FILE

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_SYNC_STATE_FILE = "sync_state"

constexpr

ORCA_UNSUBSCRIBE_PLUGINS

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_UNSUBSCRIBE_PLUGINS = "/api/v1/plugins/subscriptions"

constexpr

ORCA_WEB_SESSION_HANDOFF_PATH

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::ORCA_WEB_SESSION_HANDOFF_PATH = "/api/v1/account/web-session-handoff"

constexpr

SECRET_STORE_SERVICE

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::SECRET_STORE_SERVICE = "OrcaSlicer/Auth"

constexpr

SECRET_STORE_USER

const char* Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::SECRET_STORE_USER = "orca_refresh_token"

constexpr

TOKEN_REFRESH_SKEW

std::chrono::seconds Slic3r::anonymous_namespace{OrcaCloudServiceAgent.cpp}::TOKEN_REFRESH_SKEW {900}

constexpr

{900}; // 15 minutes