Free, open-source 3D sculpting for Linux, macOS and Windows: dense meshes, remeshing, painting, built-in AI (image/text to 3D), Send to Unreal, game-ready LODs, Gaussian splats and OpenUSD.
C++ 3d3d-sculptingcppdear-imguidigital-sculptingfbxgame-developmentgaussian-splattinggltfimage-to-3dmcpopenglopenusdsculptingtext-to-3dunreal-engine
// SculptForge - open source digital sculpting
// SPDX-License-Identifier: GPL-3.0-or-later
#include "core/MemberBuilds.h"
#include "core/Json.h"
#include "core/SelfUpdate.h"
#include <algorithm>
#include <cctype>
#include <cmath>
namespace sf::member {
namespace {
bool allDigits(const std::string& s) {
return !s.empty() && s.size() <= 20 && std::all_of(s.begin(), s.end(), [](char c) { return std::isdigit(static_cast<unsigned char>(c)); });
}
std::string formEncode(const std::string& s) {
static const char* hex = "0123456789ABCDEF";
std::string out;
for (unsigned char c : s) {
if (std::isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') out += char(c);
else out += '%', out += hex[c >> 4], out += hex[c & 15];
}
return out;
}
std::string str(const Json& j, const char* key) { return j[key].isString() ? j[key].asString() : std::string(); }
// Tokens are printable strings of at most kMaxTokenLength (GitHub's newer tokens are ~520); anything else is not a token.
bool tokenLike(const std::string& s) {
return !s.empty() && s.size() <= kMaxTokenLength &&
std::all_of(s.begin(), s.end(), [](char c) { return c > 32 && c < 127 && c != '"' && c != '\\'; });
}
} // namespace
bool isMemberAssetUrl(const std::string& url) {
const std::string prefix = kAssetUrlPrefix;
return url.size() > prefix.size() && url.compare(0, prefix.size(), prefix) == 0 && allDigits(url.substr(prefix.size()));
}
bool isMemberApiUrl(const std::string& url) { return url == kReleasesUrl || url == kUserUrl || isMemberAssetUrl(url); }
std::vector<std::string> headersFor(const std::string& url, const std::string& accessToken) {
if (!isMemberApiUrl(url) || accessToken.empty()) return {};
return {"Authorization: Bearer " + accessToken,
isMemberAssetUrl(url) ? "Accept: application/octet-stream" : "Accept: application/vnd.github+json",
"X-GitHub-Api-Version: 2022-11-28"};
}
bool parseDeviceCode(const std::string& json, int64_t now, DeviceCode& out, std::string& error) {
Json j;
if (!Json::parse(json, j, error) || !j.isObject()) {
if (error.empty()) error = "GitHub's answer isn't JSON";
return false;
}
if (j["error"].isString()) {
error = j["error"].asString() == "device_flow_disabled" ? "sign-in is switched off for the app"
: "GitHub refused: " + j["error"].asString().substr(0, 60);
return false;
}
out.deviceCode = str(j, "device_code");
out.userCode = str(j, "user_code");
out.interval = std::clamp(int(j["interval"].asNumber(5)), 1, 60);
out.expiresAt = now + int64_t(std::clamp(j["expires_in"].asNumber(900), 60.0, 3600.0));
// The page to open is ours to choose (kVerifyUrl), not the answer's: it is checked to be the same place.
const std::string uri = str(j, "verification_uri");
if (!tokenLike(out.deviceCode) || out.userCode.empty() || out.userCode.size() > 16 || uri != kVerifyUrl) {
error = "GitHub's sign-in answer is not what was expected";
return false;
}
return true;
}
TokenReply parseTokenReply(const std::string& json, int64_t now, Tokens& tokens, std::string& error) {
Json j;
std::string err;
if (!Json::parse(json, j, err) || !j.isObject()) {
error = "GitHub's answer isn't JSON";
return TokenReply::Error;
}
const std::string e = str(j, "error");
if (e == "authorization_pending") return TokenReply::Pending;
if (e == "slow_down") return TokenReply::SlowDown;
if (e == "expired_token" || e == "bad_refresh_token" || e == "token_expired") return TokenReply::Expired;
if (e == "access_denied") return TokenReply::Denied;
if (!e.empty()) {
error = "GitHub refused: " + e.substr(0, 60);
return TokenReply::Error;
}
Tokens t;
t.access = str(j, "access_token");
t.refresh = str(j, "refresh_token");
if (!tokenLike(t.access) || (!t.refresh.empty() && !tokenLike(t.refresh)) ||
(j["token_type"].isString() && j["token_type"].asString() != "bearer")) {
error = "GitHub's answer has no usable token";
return TokenReply::Error;
}
if (j["expires_in"].isNumber()) t.accessExpiresAt = now + int64_t(j["expires_in"].asNumber(0));
if (j["refresh_token_expires_in"].isNumber()) t.refreshExpiresAt = now + int64_t(j["refresh_token_expires_in"].asNumber(0));
tokens = std::move(t);
return TokenReply::Ok;
}
std::string deviceCodeBody() { return "client_id=" + formEncode(kClientId); }
std::string pollBody(const std::string& deviceCode) {
return "client_id=" + formEncode(kClientId) + "&device_code=" + formEncode(deviceCode) +
"&grant_type=" + formEncode("urn:ietf:params:oauth:grant-type:device_code");
}
std::string refreshBody(const std::string& refreshToken) {
return "client_id=" + formEncode(kClientId) + "&grant_type=refresh_token&refresh_token=" + formEncode(refreshToken);
}
std::string tokensToSecret(const Tokens& t) {
Json j = Json::object();
j.set("access", t.access);
j.set("refresh", t.refresh);
j.set("access_expires", double(t.accessExpiresAt));
j.set("refresh_expires", double(t.refreshExpiresAt));
return j.dump();
}
bool tokensFromSecret(const std::string& secret, Tokens& t) {
Json j;
std::string err;
if (!Json::parse(secret, j, err) || !j.isObject()) return false;
Tokens r;
r.access = str(j, "access");
r.refresh = str(j, "refresh");
r.accessExpiresAt = int64_t(j["access_expires"].asNumber(0));
r.refreshExpiresAt = int64_t(j["refresh_expires"].asNumber(0));
if (!tokenLike(r.access) || (!r.refresh.empty() && !tokenLike(r.refresh))) return false;
t = std::move(r);
return true;
}
bool parseMemberReleases(const std::string& json, UpdateInfo& out, std::string& error) {
Json j;
if (!Json::parse(json, j, error) || !j.isArray()) {
if (error.empty()) error = "the member release list isn't one";
return false;
}
bool found = false;
for (const Json& r : j.items()) {
if (!r.isObject() || r["draft"].asBool(false)) continue;
std::string tag = str(r, "tag_name");
if (tag.size() < 2 || tag[0] != 'v' || !update::safeVersion(tag.substr(1))) continue;
const std::string version = tag.substr(1);
if (found && compareVersions(version, out.version) <= 0) continue;
UpdateInfo info;
info.version = version;
info.member = true;
info.downloadUrl = "https://github.com/sculptforge/sculptforge-insiders/releases/tag/" + tag; // (built here, not read)
info.notesUrl = info.downloadUrl;
info.highlights.push_back("Member build (the next release, early)");
for (const Json& a : r["assets"].items()) {
const std::string name = str(a, "name");
const double id = a["id"].asNumber(-1);
if (name.empty() || name.size() > 128 || !(id >= 1) || id > 9e15 || std::floor(id) != id) continue;
info.files[name] = std::string(kAssetUrlPrefix) + std::to_string(int64_t(id));
}
out = std::move(info);
found = true;
}
if (!found) error = "no member build yet";
return found;
}
std::string parseLogin(const std::string& json) {
Json j;
std::string err;
if (!Json::parse(json, j, err) || !j.isObject()) return {};
const std::string login = str(j, "login");
const bool ok = !login.empty() && login.size() <= 39 &&
std::all_of(login.begin(), login.end(), [](char c) { return std::isalnum(static_cast<unsigned char>(c)) || c == '-'; });
return ok ? login : std::string();
}
} // namespace sf::member