931 lines
61 KiB
C++
931 lines
61 KiB
C++
#include "filesystem.h"
|
|
#include <cstdlib>
|
|
#include <new>
|
|
#include <array>
|
|
#include <ArduinoJson.h>
|
|
static bool deny_json_allocation = false;
|
|
static unsigned json_allocations = 0;
|
|
static void* trackedMalloc(size_t size) {
|
|
if (deny_json_allocation) return nullptr;
|
|
void* result = std::malloc(size); if (result) ++json_allocations; return result;
|
|
}
|
|
static void trackedFree(void* ptr) {
|
|
if (ptr) { assert(json_allocations != 0); --json_allocations; } std::free(ptr);
|
|
}
|
|
static void* trackedRealloc(void* ptr, size_t size) {
|
|
if (deny_json_allocation) return nullptr;
|
|
return std::realloc(ptr, size);
|
|
}
|
|
#define malloc trackedMalloc
|
|
#define free trackedFree
|
|
#define realloc trackedRealloc
|
|
#include <helpers/RoomWebJson.h>
|
|
#undef malloc
|
|
#undef free
|
|
#undef realloc
|
|
#include <helpers/RoomBoardStore.h>
|
|
#include <helpers/RoomMailWeb.h>
|
|
#include <helpers/RoomHistoryStore.h>
|
|
#include <helpers/RoomAccessPolicy.h>
|
|
#include <helpers/RoomLoginAuthorization.h>
|
|
#include <helpers/ClientPathPersistence.h>
|
|
#include <helpers/ClientPathObservation.h>
|
|
#include <helpers/RoomClientPathCommand.h>
|
|
#include <helpers/LazyPersistence.h>
|
|
#include <helpers/RoomTopicStore.h>
|
|
#include <helpers/RoomCatchUp.h>
|
|
#define WITH_WEBCONFIG 1
|
|
#define PUB_KEY_SIZE 32
|
|
#define MAX_PATH_SIZE 64
|
|
#define MAX_HASH_SIZE 8
|
|
#define MESH_CLIENT_REPEATER_ONLY 0
|
|
#define MAX_POST_TEXT_LEN 151
|
|
#define MAX_UNSYNCED_POSTS 32
|
|
#define POST_SYNC_DELAY_SECS 2
|
|
#define PUSH_NOTIFY_DELAY_MILLIS 200
|
|
#define MESH_DEBUG_PRINTLN(...) ((void)0)
|
|
#include "roles.inc"
|
|
static uint32_t ticks = 100;
|
|
static uint32_t millis() { return ticks; }
|
|
static uint32_t futureMillis(uint32_t duration) { return millis() + duration; }
|
|
namespace mesh {
|
|
struct Packet { static bool isValidPathLen(uint8_t length); };
|
|
struct Identity {
|
|
uint8_t pub_key[32];
|
|
Identity() = default;
|
|
explicit Identity(const uint8_t* key) { memcpy(pub_key, key, PUB_KEY_SIZE); }
|
|
bool matches(const Identity& other) const { return memcmp(pub_key, other.pub_key, 32) == 0; }
|
|
};
|
|
struct LocalIdentity : Identity {
|
|
void calcSharedSecret(uint8_t* output, const uint8_t* key) const {
|
|
for (size_t i = 0; i < PUB_KEY_SIZE; ++i) output[i] = key[i] ^ pub_key[i];
|
|
}
|
|
};
|
|
struct Utils {
|
|
static bool isHexChar(char);
|
|
static bool fromHex(uint8_t*, int, const char*);
|
|
// Cryptography is a boundary mock: every fixture token has a distinct key.
|
|
static void sha256(uint8_t* out, size_t length, const uint8_t* token, size_t token_length,
|
|
const uint8_t* server, size_t server_length) {
|
|
assert(length == 32 && token_length == 32 && server_length == 32);
|
|
for (size_t i = 0; i < length; ++i) out[i] = token[i] ^ server[i] ^ 0x5a;
|
|
}
|
|
static void toHex(char* output, const uint8_t* key, size_t length) {
|
|
static const char digits[] = "0123456789abcdef";
|
|
for (size_t i = 0; i < length; ++i) { output[2 * i] = digits[key[i] >> 4]; output[2 * i + 1] = digits[key[i] & 15]; }
|
|
output[length * 2] = 0;
|
|
}
|
|
static void sha256(uint8_t* output, size_t size, const uint8_t* bytes, size_t length) {
|
|
memset(output, 0, size);
|
|
for (size_t i = 0; i < length; ++i) output[i % size] ^= bytes[i];
|
|
}
|
|
};
|
|
}
|
|
struct StrHelper {
|
|
static void strncpy(char* out, const char* text, size_t capacity) { std::snprintf(out, capacity, "%s", text); }
|
|
};
|
|
struct Preferences {
|
|
static bool value, fail_open, fail_write;
|
|
bool begin(const char* name, bool readonly) { assert(strcmp(name, "mesh-room") == 0 && !readonly); return !fail_open; }
|
|
size_t putBool(const char* key, bool next) { assert(strcmp(key, "web") == 0); if (fail_write) return 0; value = next; return sizeof(bool); }
|
|
bool getBool(const char* key, bool fallback) { (void)fallback; assert(strcmp(key, "web") == 0); return value; }
|
|
void end() {}
|
|
};
|
|
bool Preferences::value = false, Preferences::fail_open = false, Preferences::fail_write = false;
|
|
#include "client.inc"
|
|
struct ACL {
|
|
ClientInfo clients[8]{};
|
|
ClientInfo durable[8]{};
|
|
bool retained[8]{};
|
|
ClientInfo& radio_admin = clients[0];
|
|
unsigned lookups = 0, saves = 0;
|
|
int count = 1;
|
|
int& num_clients = count;
|
|
static constexpr int capacity = 8;
|
|
bool acl_load_complete = true, protect_explicit_permissions = true;
|
|
bool save_ok = true;
|
|
int getNumClients() const { return count; }
|
|
ClientInfo* getClientByIdx(int i) { assert(i >= 0 && i < count); return &clients[i]; }
|
|
ClientInfo* getClient(const uint8_t* key, int length) {
|
|
++lookups; assert(length == PUB_KEY_SIZE);
|
|
for (int i = 0; i < count; ++i) {
|
|
if (memcmp(clients[i].id.pub_key, key, PUB_KEY_SIZE) == 0) return &clients[i];
|
|
}
|
|
return nullptr;
|
|
}
|
|
bool save(MemoryFS* fs, bool (*filter)(ClientInfo*)) {
|
|
assert(fs && filter); ++saves;
|
|
if (!save_ok) return false;
|
|
for (int i = 0; i < count; ++i) {
|
|
retained[i] = (clients[i].permissions & PERM_ACL_ROLE_MASK) != PERM_ACL_GUEST && filter(&clients[i]);
|
|
if (retained[i]) durable[i] = clients[i];
|
|
}
|
|
return true;
|
|
}
|
|
ClientInfo* putClient(const mesh::Identity& id, uint8_t permissions);
|
|
bool applyPermissions(const mesh::LocalIdentity& self, const uint8_t* key, int length, uint8_t permissions);
|
|
};
|
|
struct Clock {
|
|
uint32_t now = 1000;
|
|
uint32_t getCurrentTime() const { return now; }
|
|
uint32_t getCurrentTimeUnique() { return now++; }
|
|
};
|
|
#include "post.inc"
|
|
struct MyMesh {
|
|
MemoryFS storage; MemoryFS* _fs = &storage;
|
|
mesh::RoomAccessPolicy room_access;
|
|
mesh::LocalIdentity self_id{};
|
|
struct { char password[65] = "admin-secret", guest_password[65] = "write-secret", node_name[64] = "Test room"; bool allow_read_only = true; } _prefs;
|
|
bool room_web_enabled = false;
|
|
bool room_web_request_authenticated = false;
|
|
uint32_t room_web_boot_id = 71;
|
|
#include "web_user.inc"
|
|
ACL acl;
|
|
Clock clock;
|
|
PostInfo posts[MAX_UNSYNCED_POSTS] = {};
|
|
int next_post_idx = 0;
|
|
uint32_t last_room_timestamp = 0, post_ready_at[MAX_UNSYNCED_POSTS] = {}, post_ready_mask = UINT32_MAX, next_push = 0;
|
|
uint16_t _num_posted = 0;
|
|
mesh::RoomHistoryState room_history_state;
|
|
bool room_history_enabled = false, room_history_available = true;
|
|
char room_topic[152] = "Topic <img src=x onerror=attack()>";
|
|
unsigned long dirty_contacts_expiry = 0;
|
|
uint8_t contacts_save_failures = 0;
|
|
uint32_t room_topic_revision = 0, room_topic_timestamp = 0, room_topic_ready_at = 0;
|
|
bool room_topic_ready = false;
|
|
struct { unsigned clears = 0; void clear() { ++clears; } } recent_room_posts;
|
|
unsigned retry_cancellations = 0;
|
|
uint32_t cancelled_retry_timestamp = 0;
|
|
MyMesh() {
|
|
self_id.pub_key[0] = 4; metadata_filesystem = &storage; assert(room_access.load(_fs));
|
|
acl.radio_admin.permissions = PERM_ACL_ADMIN;
|
|
for (auto& client : acl.clients) {
|
|
client.out_path_len = client.alt_path_len = client.observed_path_len = OUT_PATH_UNKNOWN;
|
|
client.out_path_is_persistable = true;
|
|
}
|
|
}
|
|
Clock* getRTCClock() { return &clock; }
|
|
bool handleRoomWebCommand(const char*, char*);
|
|
void processRoomRequest(const uint8_t*, uint32_t, char*, char*, size_t);
|
|
void serviceRoomQuotas();
|
|
bool storePost(const mesh::Identity&, const char*);
|
|
bool snapshotRoomHistory();
|
|
bool executeClientPathCommand(ClientInfo*, mesh::RoomClientPathCommand, const char*, char*);
|
|
bool setRoomClientPath(ClientInfo*, const char*, const char*, char*);
|
|
bool applyRoomCatchUpCommand(ClientInfo*, const char*, uint32_t, char*);
|
|
static bool saveFilter(ClientInfo*);
|
|
uint8_t getUnsyncedCount(ClientInfo*);
|
|
bool roomClientChatEnabled(ClientInfo*);
|
|
bool handleRoomHistoryCommand(const char*, char*);
|
|
bool handleRoomTopicCommand(const char*, char*);
|
|
void activateRoomTopic();
|
|
void writeRoomClientJson(mesh::RoomJsonWriter&, ClientInfo*, bool);
|
|
void cancelActiveMessageRetries(const uint8_t*, uint32_t timestamp) {
|
|
++retry_cancellations; cancelled_retry_timestamp = timestamp;
|
|
}
|
|
};
|
|
#include "production.inc"
|
|
|
|
static std::array<uint8_t, 32> token(uint8_t id = 1) { std::array<uint8_t, 32> value = {}; value[0] = id; return value; }
|
|
static std::string execute(MyMesh& m, const std::string& input, uint32_t sequence,
|
|
uint8_t owner = 1, size_t capacity = 2048) {
|
|
metadata_filesystem = &m.storage;
|
|
std::vector<char> request(input.begin(), input.end()); request.push_back(0);
|
|
std::vector<char> reply(capacity + 2, 0x7f);
|
|
const auto key = token(owner);
|
|
m.processRoomRequest(key.data(), sequence, request.data(), reply.data() + 1, capacity);
|
|
assert(reply.front() == 0x7f && reply.back() == 0x7f && json_allocations == 0);
|
|
if (!capacity) return "";
|
|
assert(memchr(reply.data() + 1, 0, capacity)); return reply.data() + 1;
|
|
}
|
|
static JsonDocument result(MyMesh& m, const std::string& input, uint32_t sequence, uint8_t owner = 1) {
|
|
const auto text = execute(m, input, sequence, owner);
|
|
JsonDocument json; assert(deserializeJson(json, text) == DeserializationError::Ok); return json;
|
|
}
|
|
static std::string request(const char* op, const char* password = "write-secret", const std::string& fields = "") {
|
|
return std::string("{\"op\":\"") + op + "\",\"password\":\"" + password + "\"" + fields + "}";
|
|
}
|
|
static void error(MyMesh& m, const std::string& input, uint32_t sequence, const char* fragment, uint8_t owner = 1) {
|
|
const auto json = result(m, input, sequence, owner); const char* text = json["error"];
|
|
if (!text || !strstr(text, fragment)) fprintf(stderr, "Expected %s, got %s for %.120s\n", fragment, text ? text : "no error", input.c_str());
|
|
assert(text && strstr(text, fragment));
|
|
}
|
|
static std::string encoded(const std::string& body) {
|
|
std::vector<char> out(4 * ((body.size() + 2) / 3) + 1);
|
|
mesh::roomEncodeBase64(reinterpret_cast<const uint8_t*>(body.data()), body.size(), out.data()); return out.data();
|
|
}
|
|
static std::string saveRequest(uint8_t id, uint32_t version, const std::string& title, const std::string& body, const char* password = "admin-secret") {
|
|
return request("board.save", password, ",\"boot\":71,\"id\":" + std::to_string(id) + ",\"version\":" + std::to_string(version)
|
|
+ ",\"title\":\"" + title + "\",\"body64\":\"" + encoded(body) + "\"");
|
|
}
|
|
static void enable(MyMesh& m) { char reply[160]; assert(m.handleRoomWebCommand("set room.web on", reply)); assert(m.room_web_enabled); }
|
|
static unsigned floors(const MyMesh& m) { unsigned total = 0; for (const auto& user : m.room_web_users) total += user.last_sequence; return total; }
|
|
static std::string clientKey(const ClientInfo& client) {
|
|
char key[65]; mesh::Utils::toHex(key, client.id.pub_key, PUB_KEY_SIZE); return key;
|
|
}
|
|
static void seedClients(MyMesh& m, unsigned count = 5) {
|
|
assert(count <= 8); m.acl.count = count;
|
|
for (unsigned i = 0; i < count; ++i) {
|
|
auto& client = m.acl.clients[i];
|
|
memset(client.id.pub_key, i + 1, PUB_KEY_SIZE);
|
|
client.permissions = i == 0 ? PERM_ACL_ADMIN : PERM_ACL_READ_WRITE;
|
|
client.permissions_are_explicit = i < 2;
|
|
client.last_activity = 900 + i;
|
|
client.out_path_len = 1; client.out_path[0] = 0xA1 + i;
|
|
client.out_path_is_persistable = true;
|
|
client.alt_path_len = OUT_PATH_UNKNOWN;
|
|
client.extra.room.sync_since = 100 + i;
|
|
}
|
|
}
|
|
static void adminAuthorizationCases() {
|
|
const char* operations[] = {"admin.users", "admin.user", "admin.route", "admin.catchup",
|
|
"admin.access", "admin.ban", "admin.settings", "admin.topic", "admin.history", "admin.rates",
|
|
"admin.mail.list", "admin.mail.settings", "admin.mail.policy", "admin.mail.delete"};
|
|
unsigned denied = 0;
|
|
for (const char* password : {"", "wrong-password", "write-secret"}) {
|
|
for (const char* operation : operations) {
|
|
MyMesh m; enable(m); seedClients(m);
|
|
const std::vector<ClientInfo> before(m.acl.clients, m.acl.clients + m.acl.count);
|
|
const unsigned writes = m.storage.write_opens;
|
|
const auto reply = result(m, request(operation, password,
|
|
",\"boot\":71,\"cursor\":0,\"key\":\"" + clientKey(m.acl.clients[1])
|
|
+ "\",\"which\":\"outpath\",\"value\":\"B1\",\"expected\":\"> A2\","
|
|
"\"mode\":\"keep\",\"count\":1,\"expected_sync\":101,"
|
|
"\"role\":3,\"expected_role\":2,\"banned\":true"), 999);
|
|
assert(reply["error"].is<const char*>() && strstr(reply["error"].as<const char*>(), "admin"));
|
|
assert(reply.as<JsonObjectConst>().size() == 1);
|
|
assert(floors(m) == 0 && m.acl.lookups == 0 && m.acl.saves == 0);
|
|
assert(m.storage.write_opens == writes && m.room_access.banCount() == 0);
|
|
assert(memcmp(before.data(), m.acl.clients, before.size() * sizeof(ClientInfo)) == 0);
|
|
assert(m._num_posted == 0 && m.last_room_timestamp == 0);
|
|
++denied;
|
|
}
|
|
}
|
|
MyMesh closed; enable(closed); closed._prefs.allow_read_only = false;
|
|
error(closed, request("admin.users", "wrong-password", ",\"cursor\":0"), 100, "incorrect");
|
|
assert(floors(closed) == 0 && !closed.room_web_request_authenticated && closed.acl.lookups == 0);
|
|
MyMesh empty; enable(empty); empty._prefs.password[0] = 0;
|
|
error(empty, request("admin.users", "admin-secret", ",\"cursor\":0"), 100, "admin");
|
|
assert(floors(empty) == 0 && empty.acl.lookups == 0);
|
|
printf("ADMIN_AUTH: %u rejected low-trust operations leave state and identity data unchanged\n", denied + 2);
|
|
}
|
|
static std::string adminClientRequest(const char* operation, const ClientInfo& client,
|
|
const std::string& fields = "", uint32_t boot = 71) {
|
|
return request(operation, "admin-secret", ",\"boot\":" + std::to_string(boot)
|
|
+ ",\"key\":\"" + clientKey(client) + "\"" + fields);
|
|
}
|
|
static std::string routeFields(const char* which, const char* value, const char* expected) {
|
|
if (strncmp(expected, "> ", 2) == 0) expected += 2;
|
|
return std::string(",\"which\":\"") + which + "\",\"value\":\"" + value
|
|
+ "\",\"expected\":\"" + expected + "\"";
|
|
}
|
|
static void adminRouteCases() {
|
|
MyMesh m; enable(m); seedClients(m);
|
|
auto& retained = m.acl.clients[1];
|
|
const ClientInfo other = m.acl.clients[0];
|
|
uint32_t sequence = 1;
|
|
error(m, adminClientRequest("admin.route", retained,
|
|
routeFields("outpath", "B1", "> A2"), 70), sequence++, "restarted");
|
|
assert(m.acl.saves == 0 && floors(m) == 0);
|
|
assert(result(m, adminClientRequest("admin.route", retained,
|
|
routeFields("outpath", "B1", "> A2")), sequence++)["ok"] == true);
|
|
assert(retained.out_path_len == 1 && retained.out_path[0] == 0xB1 && m.acl.saves == 1);
|
|
assert(m.acl.retained[1] && !m.acl.retained[2]);
|
|
assert(memcmp(&other, &m.acl.clients[0], sizeof(other)) == 0);
|
|
assert(retained.permissions == PERM_ACL_READ_WRITE && retained.permissions_are_explicit);
|
|
assert(result(m, adminClientRequest("admin.route", retained,
|
|
routeFields("outpath", "B1", "> B1")), sequence++)["ok"] == true);
|
|
assert(m.acl.saves == 1);
|
|
const ClientInfo selected = retained;
|
|
const auto stale = result(m, adminClientRequest("admin.route", retained,
|
|
routeFields("outpath", "C1", "> A2")), sequence++);
|
|
assert(stale["error"].is<const char*>() && m.acl.saves == 1);
|
|
assert(memcmp(&retained, &selected, sizeof(selected)) == 0);
|
|
for (const char* value : {"B1,", "B1,,B2", "B1,1234", "direct;erase", "get prv.key", "path"}) {
|
|
const auto invalid = result(m, adminClientRequest("admin.route", retained,
|
|
routeFields("outpath", value, "> B1")), sequence++);
|
|
assert(invalid["error"].is<const char*>());
|
|
assert(memcmp(&retained, &selected, sizeof(selected)) == 0 && m.acl.saves == 1);
|
|
}
|
|
auto& transient = m.acl.clients[2];
|
|
assert(result(m, adminClientRequest("admin.route", transient,
|
|
routeFields("altpath", "C1,C2", "> unknown")), sequence++)["ok"] == true);
|
|
assert(transient.alt_path_len == 2 && transient.alt_path[0] == 0xC1 && m.acl.saves == 1);
|
|
assert(transient.permissions == PERM_ACL_READ_WRITE && !transient.permissions_are_explicit);
|
|
m.acl.save_ok = false;
|
|
m.dirty_contacts_expiry = 50000; m.contacts_save_failures = 3;
|
|
error(m, adminClientRequest("admin.route", retained,
|
|
routeFields("altpath", "D1", "> unknown")), sequence++, "save failed");
|
|
assert(m.acl.saves == 2 && memcmp(&retained, &selected, sizeof(selected)) == 0);
|
|
assert(m.dirty_contacts_expiry == 50000 && m.contacts_save_failures == 3);
|
|
m.acl.save_ok = true;
|
|
const std::string key = clientKey(retained);
|
|
for (const std::string& invalid_key : {key.substr(0, 8), key.substr(0, 12), std::string(64, '0'), std::string(64, 'g')}) {
|
|
const auto denied = result(m, request("admin.route", "admin-secret",
|
|
",\"boot\":71,\"key\":\"" + invalid_key + "\"" + routeFields("outpath", "D1", "> B1")), sequence++);
|
|
assert(denied["error"].is<const char*>() && m.acl.saves == 2);
|
|
assert(memcmp(&retained, &selected, sizeof(selected)) == 0);
|
|
}
|
|
puts("ADMIN_ROUTES: exact identities, stale guards, filtered saves, no-op writes, transient roles and rollback passed");
|
|
}
|
|
static void unreadPosts(MyMesh& m, const ClientInfo& client) {
|
|
m.posts[0].post_timestamp = 150; m.posts[1].post_timestamp = 200;
|
|
m.posts[2].post_timestamp = 250; m.posts[3].post_timestamp = 300;
|
|
for (unsigned i = 0; i < 4; ++i) memset(m.posts[i].author.pub_key, 0x99, PUB_KEY_SIZE);
|
|
m.posts[4].post_timestamp = 1000; m.posts[4].author = client.id;
|
|
m.last_room_timestamp = 1000;
|
|
}
|
|
static void adminCatchUpCases() {
|
|
MyMesh m; enable(m); seedClients(m);
|
|
auto& client = m.acl.clients[1]; unreadPosts(m, client);
|
|
client.extra.room.pending_ack = 0x12345678;
|
|
client.extra.room.push_post_timestamp = 150;
|
|
client.extra.room.ack_timeout = 9999;
|
|
client.extra.room.push_failures = 2;
|
|
const ClientInfo other = m.acl.clients[0];
|
|
uint32_t sequence = 1;
|
|
assert(result(m, adminClientRequest("admin.catchup", client,
|
|
",\"mode\":\"keep\",\"count\":2,\"expected_sync\":101"), sequence++)["ok"] == true);
|
|
assert(client.extra.room.sync_since == 200 && client.extra.room.pending_ack == 0);
|
|
assert(client.extra.room.push_post_timestamp == 0 && client.extra.room.ack_timeout == 0);
|
|
assert(client.extra.room.push_failures == 0 && m.acl.saves == 1);
|
|
assert(m.retry_cancellations == 1 && m.cancelled_retry_timestamp == 150);
|
|
assert(memcmp(&other, &m.acl.clients[0], sizeof(other)) == 0);
|
|
const ClientInfo advanced = client;
|
|
const auto stale = result(m, adminClientRequest("admin.catchup", client,
|
|
",\"mode\":\"keep\",\"count\":0,\"expected_sync\":101"), sequence++);
|
|
assert(stale["error"].is<const char*>() && m.acl.saves == 1);
|
|
assert(memcmp(&client, &advanced, sizeof(advanced)) == 0);
|
|
assert(m.retry_cancellations == 1);
|
|
assert(result(m, adminClientRequest("admin.catchup", client,
|
|
",\"mode\":\"keep\",\"count\":99,\"expected_sync\":200"), sequence++)["ok"] == true);
|
|
assert(memcmp(&client, &advanced, sizeof(advanced)) == 0 && m.acl.saves == 1);
|
|
m.acl.save_ok = false;
|
|
const auto failed = result(m, adminClientRequest("admin.catchup", client,
|
|
",\"mode\":\"keep\",\"count\":0,\"expected_sync\":200"), sequence++);
|
|
assert(failed["error"].is<const char*>() && m.acl.saves == 2);
|
|
assert(memcmp(&client, &advanced, sizeof(advanced)) == 0);
|
|
m.acl.save_ok = true;
|
|
assert(result(m, adminClientRequest("admin.catchup", client,
|
|
",\"mode\":\"before\",\"before\":4294967295,\"expected_sync\":200"), sequence++)["ok"] == true);
|
|
assert(client.extra.room.sync_since == 300 && m.acl.saves == 3);
|
|
// A retained own-author post must not create a future catch-up cursor.
|
|
assert(client.extra.room.sync_since < m.posts[4].post_timestamp);
|
|
auto& transient = m.acl.clients[2]; unreadPosts(m, transient);
|
|
transient.extra.room.pending_ack = 0x87654321;
|
|
transient.extra.room.pending_topic_revision = 7;
|
|
transient.extra.room.push_post_timestamp = 150;
|
|
assert(result(m, adminClientRequest("admin.catchup", transient,
|
|
",\"mode\":\"keep\",\"count\":0,\"expected_sync\":102"), sequence++)["ok"] == true);
|
|
assert(transient.extra.room.sync_since == 300 && transient.extra.room.pending_ack == 0x87654321);
|
|
assert(transient.extra.room.pending_topic_revision == 7 && m.acl.saves == 3);
|
|
assert(!transient.permissions_are_explicit && transient.permissions == PERM_ACL_READ_WRITE);
|
|
puts("ADMIN_CATCHUP: newest counts, stale cursors, future dates, own posts, topic ACKs, rollback and transient policy passed");
|
|
}
|
|
static void adminListingCases() {
|
|
MyMesh m; enable(m); seedClients(m);
|
|
auto& selected = m.acl.clients[1]; unreadPosts(m, selected);
|
|
selected.extra.room.pending_ack = 1234;
|
|
selected.extra.room.push_post_timestamp = 150;
|
|
selected.extra.room.ack_timeout = ticks + 3000;
|
|
selected.observed_path_len = 0x41;
|
|
selected.observed_path[0] = 0x12; selected.observed_path[1] = 0x34;
|
|
m.acl.clients[2].last_activity = 0;
|
|
m.acl.clients[3].last_activity = m.clock.now + 1;
|
|
m.acl.clients[3].extra.room.push_failures = 3;
|
|
assert(m.room_access.addBan(m._fs, m.acl.clients[4].id.pub_key) == mesh::RoomAccessPolicy::BanResult::Saved);
|
|
uint32_t sequence = 1;
|
|
for (unsigned cursor : {0, 2, 4}) {
|
|
const std::string output = execute(m, request("admin.users", "admin-secret",
|
|
",\"cursor\":" + std::to_string(cursor)), sequence++);
|
|
assert(output.size() < 2048);
|
|
JsonDocument page; assert(deserializeJson(page, output) == DeserializationError::Ok);
|
|
assert(page["total"] == 5 && page["boot"] == 71);
|
|
assert(page["active"] == 3 && page["backlog"] == 24);
|
|
assert(page["pending"] == 1 && page["failed"] == 1);
|
|
const unsigned expected = cursor == 4 ? 1 : 2;
|
|
assert(page["users"].is<JsonArray>() && page["users"].size() == expected);
|
|
for (unsigned i = 0; i < expected; ++i) {
|
|
const auto user = page["users"][i];
|
|
assert(user["key"].as<std::string>() == clientKey(m.acl.clients[cursor + i]));
|
|
assert(user["shared_secret"].isUnbound() && user["last_timestamp"].isUnbound());
|
|
assert(user["outpath"].isUnbound() && user["altpath"].isUnbound());
|
|
}
|
|
if (cursor < 4) assert(page["next"] == cursor + 2);
|
|
else assert(page["next"].isNull());
|
|
}
|
|
const auto detail = result(m, adminClientRequest("admin.user", selected), sequence++);
|
|
assert(detail["boot"] == 71 && detail["user"]["key"].as<std::string>() == clientKey(selected));
|
|
assert(detail["user"]["outpath"] == "A2" && detail["user"]["altpath"] == "unknown");
|
|
assert(detail["user"]["observed"] == "1234" && detail["user"]["sync_since"] == 101);
|
|
assert(detail["user"]["delivery"] == "post" && detail["user"]["ack_wait_ms"] == 3000);
|
|
assert(detail["user"]["shared_secret"].isUnbound() && m.acl.saves == 0);
|
|
const auto inactive = result(m, adminClientRequest("admin.user", m.acl.clients[2]), sequence++);
|
|
assert(inactive["user"]["active"] == false && inactive["user"]["heard_ago"].isNull());
|
|
const auto future = result(m, adminClientRequest("admin.user", m.acl.clients[3]), sequence++);
|
|
assert(future["user"]["heard_ago"].isNull());
|
|
const auto banned = result(m, adminClientRequest("admin.user", m.acl.clients[4]), sequence++);
|
|
assert(banned["user"]["banned"] == true && banned["user"]["active"] == false);
|
|
selected.out_path_len = selected.alt_path_len = selected.observed_path_len = 0x60;
|
|
memset(selected.out_path, 0xA1, MAX_PATH_SIZE);
|
|
memset(selected.alt_path, 0xB2, MAX_PATH_SIZE);
|
|
memset(selected.observed_path, 0xC3, MAX_PATH_SIZE);
|
|
const std::string maximum = execute(m, adminClientRequest("admin.user", selected), sequence++);
|
|
JsonDocument complete; assert(deserializeJson(complete, maximum) == DeserializationError::Ok);
|
|
assert(complete["user"]["outpath"].as<std::string>().size() == 128 && maximum.size() < 2048);
|
|
for (size_t capacity = 0; capacity < 750; ++capacity) {
|
|
execute(m, adminClientRequest("admin.user", selected), sequence++, 1, capacity);
|
|
}
|
|
assert(m.acl.saves == 0);
|
|
puts("ADMIN_USERS: two-row pages, delivery detail, full routes, inactive/future/banned states and bounded JSON passed");
|
|
}
|
|
static void adminAccessAndSettingsCases() {
|
|
MyMesh m; enable(m); seedClients(m);
|
|
uint32_t sequence = 1;
|
|
auto& selected = m.acl.clients[1];
|
|
const std::string target_key = clientKey(selected);
|
|
const ClientInfo following = m.acl.clients[2];
|
|
const auto changed_access = result(m, adminClientRequest("admin.access", selected,
|
|
",\"role\":1,\"expected_role\":2"), sequence++);
|
|
assert(changed_access["ok"] == true && changed_access["pending_save"] == true);
|
|
assert(selected.permissions == PERM_ACL_READ_ONLY && selected.permissions_are_explicit);
|
|
assert(m.dirty_contacts_expiry != 0 && m.acl.saves == 0);
|
|
const auto stale = result(m, adminClientRequest("admin.access", selected,
|
|
",\"role\":3,\"expected_role\":2"), sequence++);
|
|
assert(stale["error"].is<const char*>() && selected.permissions == PERM_ACL_READ_ONLY);
|
|
assert(result(m, adminClientRequest("admin.access", selected,
|
|
",\"role\":0,\"expected_role\":1"), sequence++)["ok"] == true);
|
|
assert(m.acl.count == 4 && m.acl.getClient(following.id.pub_key, PUB_KEY_SIZE) != nullptr);
|
|
assert(clientKey(m.acl.clients[1]) == clientKey(following));
|
|
uint8_t removed[PUB_KEY_SIZE]; memset(removed, 2, sizeof(removed));
|
|
assert(m.acl.getClient(removed, PUB_KEY_SIZE) == nullptr);
|
|
const unsigned before_ban = m.storage.write_opens;
|
|
assert(result(m, request("admin.ban", "admin-secret", ",\"boot\":71,\"key\":\""
|
|
+ target_key + "\",\"banned\":true"), sequence++)["ok"] == true);
|
|
assert(m.room_access.isBanned(removed) && m.storage.write_opens > before_ban);
|
|
const unsigned after_ban = m.storage.write_opens;
|
|
assert(result(m, request("admin.ban", "admin-secret", ",\"boot\":71,\"key\":\""
|
|
+ target_key + "\",\"banned\":true"), sequence++)["ok"] == true);
|
|
assert(m.storage.write_opens == after_ban);
|
|
assert(result(m, request("admin.ban", "admin-secret", ",\"boot\":71,\"key\":\""
|
|
+ target_key + "\",\"banned\":false"), sequence++)["ok"] == true);
|
|
assert(!m.room_access.isBanned(removed));
|
|
const unsigned reads_only = m.storage.write_opens;
|
|
const auto settings = result(m, request("admin.settings", "admin-secret"), sequence++);
|
|
assert(settings["boot"] == 71 && settings["topic"] == m.room_topic);
|
|
assert(settings["persistent_history"] == false && settings["post_rate"] == 0 && settings["poll_rate"] == 0);
|
|
assert(m.storage.write_opens == reads_only);
|
|
const std::string old_topic = m.room_topic;
|
|
const auto topic = result(m, request("admin.topic", "admin-secret", ",\"boot\":71,\"value\":\"New topic\",\"expected\":\""
|
|
+ old_topic + "\""), sequence++);
|
|
assert(topic["ok"] == true && strcmp(m.room_topic, "New topic") == 0);
|
|
const uint32_t revision = m.room_topic_revision;
|
|
const auto stale_topic = result(m, request("admin.topic", "admin-secret", ",\"boot\":71,\"value\":\"Stale\",\"expected\":\""
|
|
+ old_topic + "\""), sequence++);
|
|
assert(stale_topic["error"].is<const char*>() && strcmp(m.room_topic, "New topic") == 0 && m.room_topic_revision == revision);
|
|
assert(result(m, request("admin.history", "admin-secret", ",\"boot\":71,\"enabled\":true,\"expected\":false"), sequence++)["ok"] == true);
|
|
assert(m.room_history_enabled);
|
|
const auto stale_history = result(m, request("admin.history", "admin-secret", ",\"boot\":71,\"enabled\":false,\"expected\":false"), sequence++);
|
|
assert(stale_history["error"].is<const char*>() && m.room_history_enabled);
|
|
assert(result(m, request("admin.rates", "admin-secret", ",\"boot\":71,\"post_rate\":12,\"poll_rate\":60"), sequence++)["ok"] == true);
|
|
assert(m.room_access.postRate() == 12 && m.room_access.pollRate() == 60);
|
|
const unsigned rate_writes = m.storage.write_opens;
|
|
assert(result(m, request("admin.rates", "admin-secret", ",\"boot\":71,\"post_rate\":12,\"poll_rate\":60"), sequence++)["ok"] == true);
|
|
assert(m.storage.write_opens == rate_writes);
|
|
ticks += 60000;
|
|
m.storage.capacity = 0;
|
|
const auto failed_topic = result(m, request("admin.topic", "admin-secret", ",\"boot\":71,\"value\":\"Not saved\",\"expected\":\"New topic\""), sequence++);
|
|
assert(failed_topic["error"].is<const char*>() && strcmp(m.room_topic, "New topic") == 0);
|
|
m.storage.reset(); m.storage.faults.insert("open:w:/room_hist_cfg.tmp");
|
|
const auto failed_history = result(m, request("admin.history", "admin-secret", ",\"boot\":71,\"enabled\":false,\"expected\":true"), sequence++);
|
|
assert(failed_history["error"].is<const char*>() && m.room_history_enabled);
|
|
m.storage.reset(); m.storage.capacity = 0;
|
|
const auto failed_rates = result(m, request("admin.rates", "admin-secret", ",\"boot\":71,\"post_rate\":13,\"poll_rate\":61"), sequence++);
|
|
assert(failed_rates["error"].is<const char*>() && m.room_access.postRate() == 12 && m.room_access.pollRate() == 60);
|
|
puts("ADMIN_SETTINGS: queued ACL semantics, role revocation, bans, topic/history/rates stale guards and storage failure passed");
|
|
}
|
|
static void adminInvalidAndSessionCases() {
|
|
struct Invalid { const char* operation; const char* fields; };
|
|
const Invalid invalid[] = {
|
|
{"admin.users", ""}, {"admin.users", ",\"cursor\":-1"},
|
|
{"admin.users", ",\"cursor\":\"0\""}, {"admin.users", ",\"cursor\":1.5"},
|
|
{"admin.users", ",\"cursor\":false"}, {"admin.users", ",\"cursor\":6"},
|
|
{"admin.user", ",\"key\":9"}, {"admin.user", ",\"key\":\"02020202\""},
|
|
{"admin.user", ",\"key\":\"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""},
|
|
{"admin.route", ",\"which\":\"secret\",\"value\":\"B1\",\"expected\":\"A2\""},
|
|
{"admin.route", ",\"which\":false,\"value\":\"B1\",\"expected\":\"A2\""},
|
|
{"admin.route", ",\"which\":\"outpath\",\"value\":[],\"expected\":\"A2\""},
|
|
{"admin.route", ",\"which\":\"outpath\",\"value\":\"B1\",\"expected\":2"},
|
|
{"admin.route", ",\"which\":\"outpath\",\"value\":\"B1\",\"expected\":\"A2\\u0000\""},
|
|
{"admin.catchup", ",\"mode\":\"skip\",\"count\":0,\"expected_sync\":101"},
|
|
{"admin.catchup", ",\"mode\":\"keep\",\"count\":-1,\"expected_sync\":101"},
|
|
{"admin.catchup", ",\"mode\":\"keep\",\"count\":65536,\"expected_sync\":101"},
|
|
{"admin.catchup", ",\"mode\":\"keep\",\"count\":\"0\",\"expected_sync\":101"},
|
|
{"admin.catchup", ",\"mode\":\"keep\",\"count\":1.5,\"expected_sync\":101"},
|
|
{"admin.catchup", ",\"mode\":\"keep\",\"count\":0,\"expected_sync\":\"101\""},
|
|
{"admin.catchup", ",\"mode\":\"before\",\"before\":-1,\"expected_sync\":101"},
|
|
{"admin.catchup", ",\"mode\":\"before\",\"before\":4294967296,\"expected_sync\":101"},
|
|
{"admin.access", ",\"role\":4,\"expected_role\":2"},
|
|
{"admin.access", ",\"role\":5,\"expected_role\":2"},
|
|
{"admin.access", ",\"role\":256,\"expected_role\":2"},
|
|
{"admin.access", ",\"role\":-1,\"expected_role\":2"},
|
|
{"admin.access", ",\"role\":2.5,\"expected_role\":2"},
|
|
{"admin.access", ",\"role\":\"3\",\"expected_role\":2"},
|
|
{"admin.access", ",\"role\":3,\"expected_role\":\"2\""},
|
|
{"admin.ban", ",\"banned\":\"true\""}, {"admin.ban", ",\"banned\":1"},
|
|
{"admin.history", ",\"enabled\":1,\"expected\":false"},
|
|
{"admin.history", ",\"enabled\":true,\"expected\":\"false\""},
|
|
{"admin.topic", ",\"value\":7,\"expected\":\"unchanged\""},
|
|
{"admin.topic", ",\"value\":\"New\\u0000topic\",\"expected\":\"unchanged\""},
|
|
{"admin.rates", ",\"post_rate\":-1,\"poll_rate\":60"},
|
|
{"admin.rates", ",\"post_rate\":65536,\"poll_rate\":60"},
|
|
{"admin.rates", ",\"post_rate\":1.5,\"poll_rate\":60"},
|
|
{"admin.rates", ",\"post_rate\":12,\"poll_rate\":\"60\""},
|
|
{"admin.cli", ",\"value\":\"erase\""}, {"admin.userdetail", ""},
|
|
{"admin.users\\u0000post", ",\"cursor\":0"},
|
|
};
|
|
for (const auto& entry : invalid) {
|
|
MyMesh m; enable(m); seedClients(m); strcpy(m.room_topic, "unchanged");
|
|
const std::vector<ClientInfo> clients(m.acl.clients, m.acl.clients + m.acl.count);
|
|
const unsigned writes = m.storage.write_opens;
|
|
const auto denied = result(m, adminClientRequest(entry.operation, m.acl.clients[1], entry.fields), 1);
|
|
assert(denied["error"].is<const char*>() && denied.as<JsonObjectConst>().size() == 1);
|
|
assert(m.acl.count == 5 && memcmp(clients.data(), m.acl.clients, clients.size() * sizeof(ClientInfo)) == 0);
|
|
assert(m.acl.saves == 0 && m.dirty_contacts_expiry == 0 && m.retry_cancellations == 0);
|
|
assert(m.storage.write_opens == writes && m.room_access.banCount() == 0);
|
|
assert(!m.room_history_enabled && strcmp(m.room_topic, "unchanged") == 0);
|
|
assert(m.room_access.postRate() == 0 && m.room_access.pollRate() == 0);
|
|
}
|
|
const char* writes[] = {"admin.route", "admin.catchup", "admin.access", "admin.ban",
|
|
"admin.topic", "admin.history", "admin.rates", "admin.mail.policy", "admin.mail.delete"};
|
|
for (const char* operation : writes) {
|
|
MyMesh m; enable(m); seedClients(m);
|
|
error(m, adminClientRequest(operation, m.acl.clients[1], "", 70), 99, "restarted");
|
|
error(m, request(operation, "admin-secret", ",\"boot\":\"71\""), 99, "restarted");
|
|
error(m, request(operation, "admin-secret"), 99, "restarted");
|
|
assert(floors(m) == 0 && m.acl.lookups == 0 && m.acl.saves == 0);
|
|
}
|
|
MyMesh m; enable(m); seedClients(m);
|
|
const auto mutation = adminClientRequest("admin.route", m.acl.clients[1], routeFields("outpath", "B1", "A2"));
|
|
assert(result(m, mutation, 1)["ok"] == true && m.acl.saves == 1);
|
|
error(m, mutation, 1, "completed"); assert(m.acl.saves == 1);
|
|
error(m, request("admin.users", "write-secret", ",\"cursor\":0"), 100, "admin");
|
|
assert(floors(m) == 1);
|
|
assert(result(m, request("admin.users", "admin-secret", ",\"cursor\":0"), 2)["users"].size() == 2);
|
|
MyMesh full; enable(full);
|
|
for (uint8_t owner = 1; owner <= 8; ++owner) {
|
|
assert(result(full, request("admin.settings", "admin-secret"), 1, owner)["boot"] == 71);
|
|
}
|
|
error(full, request("admin.settings", "admin-secret"), 1, "busy", 9);
|
|
assert(floors(full) == 8 && full.acl.lookups == 0);
|
|
MyMesh banned; enable(banned);
|
|
uint8_t author[PUB_KEY_SIZE]; const auto identity = token();
|
|
mesh::Utils::sha256(author, sizeof(author), identity.data(), identity.size(), banned.self_id.pub_key, PUB_KEY_SIZE);
|
|
assert(banned.room_access.addBan(banned._fs, author) == mesh::RoomAccessPolicy::BanResult::Saved);
|
|
error(banned, request("admin.settings", "admin-secret"), 1, "access denied");
|
|
assert(floors(banned) == 0 && banned.acl.lookups == 0 && !banned.room_web_request_authenticated);
|
|
printf("ADMIN_INVALID: %zu strict schemas, %zu boot guards, replay/auth floors, bounded sessions and banned browser passed\n", std::size(invalid), std::size(writes) * 3);
|
|
}
|
|
static std::string browserKey(const MyMesh& m, uint8_t owner) {
|
|
const auto identity = token(owner); uint8_t author[32]; char key[65];
|
|
mesh::Utils::sha256(author, sizeof(author), identity.data(), identity.size(), m.self_id.pub_key, PUB_KEY_SIZE);
|
|
mesh::Utils::toHex(key, author, sizeof(author)); return key;
|
|
}
|
|
static std::string quoted(const std::string& value) {
|
|
JsonDocument json; json.set(value); std::string output; serializeJson(json, output); return output;
|
|
}
|
|
static std::string mailPolicyFields(const char* mode, uint32_t revision, bool only = false,
|
|
const std::vector<std::string>& allowed = {}) {
|
|
std::string fields = ",\"boot\":71,\"mode\":" + quoted(mode) + ",\"expected_revision\":" + std::to_string(revision)
|
|
+ ",\"mailbox_only\":" + (only ? "true" : "false") + ",\"allowlist\":[";
|
|
for (size_t i = 0; i < allowed.size(); ++i) { if (i) fields += ','; fields += quoted(allowed[i]); }
|
|
return fields + ']';
|
|
}
|
|
static std::string mailSendRequest(const std::string& recipient, const std::string& text,
|
|
const char* password = "write-secret") {
|
|
return request("mail.send", password, ",\"boot\":71,\"recipient\":" + quoted(recipient) + ",\"text\":" + quoted(text));
|
|
}
|
|
static std::string mailListRequest(uint8_t cursor = 0, uint32_t revision = 0,
|
|
const char* password = "") {
|
|
return request("mail.list", password, ",\"cursor\":" + std::to_string(cursor) + ",\"revision\":" + std::to_string(revision));
|
|
}
|
|
static std::string mailOwnerRequest(const char* operation, const std::string& owner,
|
|
const std::string& fields = "") {
|
|
return request(operation, "admin-secret", ",\"owner\":" + quoted(owner) + fields);
|
|
}
|
|
static uint32_t mailRevision(MyMesh& m, uint32_t& sequence, uint8_t owner) {
|
|
auto settings = result(m, request("mail.settings", ""), sequence++, owner);
|
|
assert(!settings["error"] && settings["revision"].is<uint32_t>());
|
|
return settings["revision"].as<uint32_t>();
|
|
}
|
|
static void mailAuthorizationAndPolicyCases() {
|
|
MyMesh m; enable(m); uint32_t sequence = 1;
|
|
const auto first = result(m, request("mail.settings", ""), sequence++, 1);
|
|
const std::string owner = first["owner"].as<std::string>(), sender = browserKey(m, 2);
|
|
assert(owner == browserKey(m, 1) && owner != sender);
|
|
assert(first["mode"] == "closed" && first["revision"] == 0 && first["total"] == 0 && first["mailbox_only"] == false);
|
|
const auto impersonated = result(m, request("mail.settings", "", ",\"owner\":" + quoted(owner)
|
|
+ ",\"key\":" + quoted(clientKey(m.acl.radio_admin)) + ",\"permissions\":3"), sequence++, 2);
|
|
assert(impersonated["owner"] == sender && m.acl.lookups == 0);
|
|
auto policy = result(m, request("mail.policy", "", mailPolicyFields("public", 0, true)), sequence++, 1);
|
|
assert(policy["mode"] == "public" && policy["revision"].as<uint32_t>() > 0 && policy["mailbox_only"] == true);
|
|
const uint32_t initial_revision = policy["revision"];
|
|
error(m, request("mail.policy", "", mailPolicyFields("closed", 0)), sequence++, "changed", 1);
|
|
assert(result(m, request("mail.settings", ""), sequence++, 1)["mode"] == "public");
|
|
assert(result(m, request("status", ""), sequence++, 1)["mailbox_only"] == true);
|
|
assert(result(m, request("status", ""), sequence++, 2)["mailbox_only"] == false);
|
|
error(m, mailSendRequest(owner, "reader cannot send", ""), sequence++, "read-only", 2);
|
|
auto sent = result(m, mailSendRequest(owner, "public mail"), sequence++, 2);
|
|
assert(sent["ok"] == true && sent["id"].as<uint32_t>() > initial_revision);
|
|
const uint32_t id = sent["id"], revision = mailRevision(m, sequence, 1);
|
|
error(m, request("mail.read", "", ",\"owner\":" + quoted(owner) + ",\"id\":" + std::to_string(id) + ",\"offset\":0"), sequence++, "not found", 2);
|
|
error(m, request("mail.ack", "", ",\"boot\":71,\"owner\":" + quoted(owner) + ",\"id\":" + std::to_string(id)), sequence++, "not found", 2);
|
|
assert(result(m, request("mail.check", ""), sequence++, 1)["unread"] == 1);
|
|
policy = result(m, request("mail.policy", "", mailPolicyFields("private", revision, true, {sender})), sequence++, 1);
|
|
assert(policy["allowlist"].size() == 1 && policy["allowlist"][0] == sender);
|
|
error(m, mailSendRequest(owner, "unapproved mail"), sequence++, "not accepting", 3);
|
|
assert(result(m, mailSendRequest(owner, "approved mail"), sequence++, 2)["ok"] == true);
|
|
const uint32_t private_revision = mailRevision(m, sequence, 1);
|
|
policy = result(m, request("mail.policy", "", mailPolicyFields("closed", private_revision)), sequence++, 1);
|
|
assert(policy["mode"] == "closed");
|
|
error(m, mailSendRequest(owner, "closed mail"), sequence++, "not accepting", 2);
|
|
assert(result(m, request("mail.check", ""), sequence++, 1)["total"] == 2 && m._num_posted == 0);
|
|
assert(result(m, request("status", ""), sequence++, 1)["mailbox_only"] == false);
|
|
const auto before = m.storage.get(mesh::ROOM_MAIL_PRIMARY_PATH);
|
|
const uint32_t closed_revision = mailRevision(m, sequence, 1);
|
|
error(m, request("mail.policy", "", mailPolicyFields("private", closed_revision, false, {sender, sender})), sequence++, "invalid", 1);
|
|
std::vector<std::string> too_many(9, sender);
|
|
error(m, request("mail.policy", "", mailPolicyFields("private", closed_revision, false, too_many)), sequence++, "eight", 1);
|
|
assert(m.storage.get(mesh::ROOM_MAIL_PRIMARY_PATH) == before && m.acl.lookups == 0);
|
|
printf("MAIL_AUTH: browser token identity isolation, reader/writer gates, strict stale-zero policy, public/private/closed and sender limits passed\n");
|
|
}
|
|
static void mailDeliveryAndDurabilityCases() {
|
|
MyMesh m; enable(m); const std::string recipient = browserKey(m, 2);
|
|
assert(result(m, request("mail.policy", "", mailPolicyFields("public", 0, true)), 1, 2)["mode"] == "public");
|
|
std::string text; for (unsigned i = 0; i < 128; ++i) text += "\xF0\x9F\x93\xA1";
|
|
assert(text.size() == 512);
|
|
const auto submission = mailSendRequest(recipient, text); auto sent = result(m, submission, 200, 1);
|
|
assert(sent["ok"] == true); const uint32_t id = sent["id"];
|
|
error(m, submission, 200, "completed", 1);
|
|
error(m, mailSendRequest(recipient, text + "x"), 201, "1-512", 1);
|
|
error(m, request("mail.send", "write-secret", ",\"boot\":71,\"recipient\":" + quoted(recipient) + ",\"text\":\"before\\u0000after\""), 202, "1-512", 1);
|
|
error(m, mailSendRequest(recipient.substr(0, 12), "bad recipient"), 203, "complete", 1);
|
|
MyMesh restored; restored.storage.files = m.storage.files; enable(restored);
|
|
const auto duplicate = result(restored, submission, 200, 1);
|
|
assert(duplicate["ok"] == true && duplicate["id"] == id && restored.storage.write_opens == 0);
|
|
uint32_t sequence = 1;
|
|
auto page = result(restored, mailListRequest(), sequence++, 2);
|
|
assert(page["messages"].size() == 1 && page["messages"][0]["id"] == id && page["messages"][0]["sender"] == browserKey(restored, 1));
|
|
assert(page["messages"][0]["length"] == 512 && page["messages"][0]["acked"] == false && page["next"].isNull());
|
|
std::string assembled;
|
|
for (unsigned offset = 0; offset < 512;) {
|
|
auto chunk = result(restored, request("mail.read", "", ",\"id\":" + std::to_string(id) + ",\"offset\":" + std::to_string(offset)), sequence++, 2);
|
|
uint8_t bytes[128]; size_t length = 0;
|
|
assert(chunk["id"] == id && chunk["sender"] == browserKey(restored, 1) && chunk["length"] == 512 && chunk["created"] == 1000);
|
|
assert(chunk["offset"] == offset && chunk["acked"] == false && mesh::roomDecodeBase64(chunk["data64"], bytes, sizeof(bytes), length));
|
|
assert(length == 128 && chunk["count"] == length && chunk["next"] == offset + length);
|
|
assembled.append(reinterpret_cast<const char*>(bytes), length); offset += length;
|
|
}
|
|
assert(assembled == text);
|
|
auto count = result(restored, request("mail.check", ""), sequence++, 2);
|
|
assert(count["total"] == 1 && count["unread"] == 1 && count["mailbox_only"] == true);
|
|
const auto eof = result(restored, request("mail.read", "", ",\"id\":" + std::to_string(id) + ",\"offset\":512"), sequence++, 2);
|
|
assert(eof["count"] == 0 && eof["next"] == 512 && eof["data64"] == "");
|
|
assert(result(restored, request("mail.ack", "", ",\"boot\":71,\"id\":" + std::to_string(id)), sequence++, 2)["ok"] == true);
|
|
assert(result(restored, request("mail.check", ""), sequence++, 2)["unread"] == 0);
|
|
error(restored, request("mail.read", "", ",\"id\":" + std::to_string(id) + ",\"offset\":0"), sequence++, "not found", 2);
|
|
MyMesh after_ack; after_ack.storage.files = restored.storage.files; enable(after_ack);
|
|
const auto repeated = result(after_ack, submission, 200, 1);
|
|
assert(repeated["ok"] == true && repeated["id"] == id);
|
|
assert(result(after_ack, request("mail.check", ""), 1, 2)["total"] == 0);
|
|
assert(result(after_ack, request("mail.ack", "", ",\"boot\":71,\"id\":" + std::to_string(id)), 2, 2)["ok"] == true);
|
|
printf("MAIL_DELIVERY: 512-byte UTF-8, bounded chunks/EOF, read retains unread mail, explicit durable ACK and retry across reboot passed\n");
|
|
}
|
|
static void mailAdministratorCases() {
|
|
MyMesh m; enable(m); uint32_t sequence = 1; const std::string target = browserKey(m, 2), sender = browserKey(m, 1);
|
|
auto selected = result(m, mailOwnerRequest("admin.mail.settings", target), sequence++, 9);
|
|
assert(selected["owner"] == target && selected["revision"] == 0 && selected["blocked"] == false);
|
|
selected = result(m, mailOwnerRequest("admin.mail.policy", target, mailPolicyFields("private", 0, true, {sender})), sequence++, 9);
|
|
assert(selected["owner"] == target && selected["allowlist"][0] == sender && selected["mailbox_only"] == true);
|
|
const uint32_t revision = selected["revision"];
|
|
error(m, mailOwnerRequest("admin.mail.policy", target, mailPolicyFields("closed", 0)), sequence++, "changed", 9);
|
|
error(m, mailOwnerRequest("admin.mail.policy", target, mailPolicyFields("closed", revision - 1)), sequence++, "changed", 9);
|
|
const auto sent = result(m, mailSendRequest(target, "recipient-only content"), sequence++, 1); assert(sent["ok"] == true);
|
|
auto metadata = result(m, request("admin.mail.list", "admin-secret", ",\"cursor\":0,\"revision\":0"), sequence++, 9);
|
|
assert(metadata["mailboxes"].size() == 1 && metadata["mailboxes"][0]["owner"] == target && metadata["mailboxes"][0]["total"] == 1);
|
|
assert(!metadata["mailboxes"][0]["text"] && !metadata["mailboxes"][0]["data64"] && !metadata["mailboxes"][0]["allowlist"]);
|
|
error(m, mailOwnerRequest("admin.mail.read", target, ",\"id\":" + std::to_string(sent["id"].as<uint32_t>()) + ",\"offset\":0"), sequence++, "unknown", 9);
|
|
auto own = result(m, request("mail.list", "admin-secret", ",\"owner\":" + quoted(target) + ",\"cursor\":0,\"revision\":0"), sequence++, 9);
|
|
assert(own["messages"].size() == 0);
|
|
assert(result(m, request("admin.ban", "admin-secret", ",\"boot\":71,\"key\":" + quoted(target) + ",\"banned\":true"), sequence++, 9)["ok"] == true);
|
|
selected = result(m, mailOwnerRequest("admin.mail.settings", target), sequence++, 9);
|
|
assert(selected["blocked"] == true && selected["mode"] == "private" && selected["allowlist"][0] == sender);
|
|
error(m, mailSendRequest(target, "blocked recipient"), sequence++, "blocked", 1);
|
|
error(m, request("mail.check", ""), sequence++, "denied", 2);
|
|
assert(result(m, mailOwnerRequest("admin.mail.delete", target, ",\"boot\":71,\"id\":0"), sequence++, 9)["ok"] == true);
|
|
selected = result(m, mailOwnerRequest("admin.mail.settings", target), sequence++, 9);
|
|
assert(selected["total"] == 0 && selected["mode"] == "private" && selected["blocked"] == true);
|
|
assert(result(m, request("admin.ban", "admin-secret", ",\"boot\":71,\"key\":" + quoted(target) + ",\"banned\":false"), sequence++, 9)["ok"] == true);
|
|
error(m, request("mail.delete", "", ",\"boot\":71,\"id\":0"), sequence++, "identifier", 2);
|
|
printf("MAIL_ADMIN: selected full-key policies, metadata-only enumeration, blocked field/gates, owner-isolated admin reads and confirmed purge passed\n");
|
|
}
|
|
static void mailPagingAndStorageCases() {
|
|
MyMesh m; enable(m); uint32_t sequence = 1; const std::string target = browserKey(m, 2);
|
|
assert(result(m, request("mail.policy", "", mailPolicyFields("public", 0)), sequence++, 2)["mode"] == "public");
|
|
std::vector<uint32_t> ids;
|
|
for (unsigned i = 0; i < 3; ++i) { auto sent = result(m, mailSendRequest(target, "queued " + std::to_string(i)), sequence++, 1); assert(sent["ok"] == true); ids.push_back(sent["id"]); }
|
|
auto page = result(m, mailListRequest(), sequence++, 2); assert(page["messages"].size() == 2 && page["next"] == 2);
|
|
const uint32_t snapshot = page["revision"];
|
|
assert(result(m, mailSendRequest(target, "arrival between pages"), sequence++, 1)["ok"] == true);
|
|
error(m, mailListRequest(2, snapshot), sequence++, "changed", 2);
|
|
page = result(m, mailListRequest(), sequence++, 2);
|
|
const uint32_t newer = page["revision"];
|
|
assert(result(m, request("mail.delete", "", ",\"boot\":71,\"id\":" + std::to_string(ids[0])), sequence++, 2)["ok"] == true);
|
|
error(m, mailListRequest(2, newer), sequence++, "changed", 2);
|
|
error(m, mailListRequest(2, 0), sequence++, "revision", 2);
|
|
page = result(m, mailListRequest(), sequence++, 2);
|
|
auto last = result(m, mailListRequest(2, page["revision"]), sequence++, 2);
|
|
assert(last["messages"].size() == 1 && last["next"].isNull());
|
|
for (uint8_t owner = 3; owner <= 4; ++owner) assert(result(m, mailOwnerRequest("admin.mail.policy", browserKey(m, owner), mailPolicyFields("public", 0)), sequence++, 9)["mode"] == "public");
|
|
auto owners = result(m, request("admin.mail.list", "admin-secret", ",\"cursor\":0,\"revision\":0"), sequence++, 9);
|
|
assert(owners["mailboxes"].size() == 2 && owners["next"] == 2); const uint32_t owner_snapshot = owners["revision"];
|
|
assert(result(m, mailSendRequest(target, "admin snapshot mutation"), sequence++, 1)["ok"] == true);
|
|
error(m, request("admin.mail.list", "admin-secret", ",\"cursor\":2,\"revision\":" + std::to_string(owner_snapshot)), sequence++, "changed", 9);
|
|
owners = result(m, request("admin.mail.list", "admin-secret", ",\"cursor\":0,\"revision\":0"), sequence++, 9);
|
|
auto owners_last = result(m, request("admin.mail.list", "admin-secret", ",\"cursor\":2,\"revision\":" + std::to_string(owners["revision"].as<uint32_t>())), sequence++, 9);
|
|
assert(owners_last["mailboxes"].size() == 1 && owners_last["next"].isNull());
|
|
error(m, mailSendRequest(target, "owner queue is full"), sequence++, "full", 1);
|
|
const auto primary = m.storage.get(mesh::ROOM_MAIL_PRIMARY_PATH);
|
|
m.storage.capacity = 0;
|
|
error(m, request("mail.ack", "", ",\"boot\":71,\"id\":" + std::to_string(ids[1])), sequence++, "save failed", 2);
|
|
assert(m.storage.get(mesh::ROOM_MAIL_PRIMARY_PATH) == primary); m.storage.reset();
|
|
assert(result(m, request("mail.check", ""), sequence++, 2)["total"] == 4);
|
|
uint8_t key[32]; assert(mesh::roomMailWebKey(key, sizeof(key), target.c_str()));
|
|
mesh::room_mail_detail::Index index; mesh::room_mail_detail::Entry entry; mesh::room_mail_detail::Owner owner; bool found = false;
|
|
assert(mesh::room_mail_detail::load(m._fs, key, index, entry, owner, found, false) == mesh::RoomMailResult::Success && found);
|
|
char bank[24]; mesh::room_mail_detail::ownerPath(entry, bank);
|
|
auto corrupt = m.storage.get(bank); corrupt.back() ^= 1; m.storage.put(bank, corrupt);
|
|
auto denied = result(m, request("mail.read", "", ",\"id\":" + std::to_string(ids[1]) + ",\"offset\":0"), sequence++, 2);
|
|
assert(denied.as<JsonObjectConst>().size() == 1 && strstr(denied["error"].as<const char*>(), "storage unavailable"));
|
|
error(m, mailSendRequest(target, "preserve corrupt evidence"), sequence++, "storage unavailable", 1);
|
|
assert(m.storage.get(bank) == corrupt && m.storage.get(mesh::ROOM_MAIL_PRIMARY_PATH) == primary);
|
|
assert(result(m, request("status", ""), sequence++, 2)["mailbox_only"] == true);
|
|
printf("MAIL_PAGING: explicit revisions reject message arrivals/deletions between pages and changed admin snapshots passed\n");
|
|
printf("MAIL_STORAGE: full owner queue, failed ACK retention, corrupt-bank fail-closed reads/status and preserved evidence passed\n");
|
|
}
|
|
static void mailGlobalQueueCases() {
|
|
MyMesh m; enable(m); uint32_t sequence = 1;
|
|
for (uint8_t owner = 2; owner <= 6; ++owner) assert(result(m, mailOwnerRequest("admin.mail.policy", browserKey(m, owner), mailPolicyFields("public", 0)), sequence++, 9)["mode"] == "public");
|
|
for (uint8_t owner = 2; owner <= 5; ++owner) for (unsigned i = 0; i < 4; ++i) assert(result(m, mailSendRequest(browserKey(m, owner), "bounded global queue"), sequence++, 1)["ok"] == true);
|
|
error(m, mailSendRequest(browserKey(m, 6), "seventeenth message"), sequence++, "full", 1);
|
|
const auto owners = result(m, request("admin.mail.list", "admin-secret", ",\"cursor\":0,\"revision\":0"), sequence++, 9);
|
|
assert(owners["queued"] == 16);
|
|
assert(result(m, mailOwnerRequest("admin.mail.delete", browserKey(m, 2), ",\"boot\":71,\"id\":0"), sequence++, 9)["ok"] == true);
|
|
assert(result(m, mailSendRequest(browserKey(m, 6), "space released by purge"), sequence++, 1)["ok"] == true);
|
|
printf("MAIL_GLOBAL: bounded 16-message server queue rejects without acceptance and recovers capacity after explicit purge passed\n");
|
|
}
|
|
int main() {
|
|
unsigned scenarios = 0;
|
|
{
|
|
MyMesh m; assert(!m.room_web_enabled);
|
|
error(m, request("status"), 1, "disabled"); assert(floors(m) == 0);
|
|
char reply[160]; assert(m.handleRoomWebCommand("get room.web", reply) && strstr(reply, "off"));
|
|
Preferences::fail_write = true; assert(m.handleRoomWebCommand("set room.web on", reply) && !m.room_web_enabled);
|
|
Preferences::fail_write = false; enable(m);
|
|
assert(!m.handleRoomWebCommand("get room.webx", reply));
|
|
auto status = result(m, request("status"), 1); assert(status["role"] == PERM_ACL_READ_WRITE && status["boot"] == 71);
|
|
assert(strcmp(status["topic"], m.room_topic) == 0 && status["persistent_history"] == false);
|
|
status = result(m, request("status", "bad-password", ",\"key\":\"radio-admin\",\"permissions\":3"), 2);
|
|
assert(status["role"] == PERM_ACL_GUEST && m.acl.lookups == 0);
|
|
const std::string web_key = status["web_key"].as<std::string>(); assert(web_key.size() == 64);
|
|
error(m, request("post", "bad-password", ",\"boot\":71,\"name\":\"A\",\"text\":\"denied\""), 500, "read-only");
|
|
assert(floors(m) == 2 && m.last_room_timestamp == 0 && m._num_posted == 0);
|
|
assert(result(m, request("status", "admin-secret"), 3)["role"] == PERM_ACL_ADMIN); ++scenarios;
|
|
}
|
|
{
|
|
MyMesh m; enable(m); m._prefs.allow_read_only = false;
|
|
error(m, request("status", "wrong"), 100, "incorrect"); assert(floors(m) == 0 && !m.room_web_request_authenticated);
|
|
error(m, request("status"), 100, "invalid browser", 0); assert(floors(m) == 0 && !m.room_web_request_authenticated);
|
|
assert(result(m, request("status"), 1)["role"] == PERM_ACL_READ_WRITE);
|
|
error(m, request("post", "write-secret", ",\"boot\":70,\"name\":\"A\",\"text\":\"no\""), 200, "restarted");
|
|
assert(floors(m) == 1 && m._num_posted == 0);
|
|
error(m, saveRequest(1, 0, "Title", "body", "write-secret"), 300, "admin"); assert(floors(m) == 1);
|
|
const auto okay = result(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A\",\"text\":\"one\""), 2);
|
|
assert(okay["ok"] == true && m.last_room_timestamp == 1000 && m._num_posted == 1);
|
|
error(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A\",\"text\":\"one\""), 2, "completed");
|
|
assert(m._num_posted == 1 && m.acl.radio_admin.extra.room.last_post_timestamp == 0);
|
|
auto post = result(m, request("posts", "write-secret", ",\"after\":0"), 3);
|
|
assert(strcmp(post["post"]["text"], "A: one") == 0 && post["post"]["timestamp"] == 1000);
|
|
post = result(m, request("posts", "write-secret", ",\"after\":1000"), 4); assert(post["post"].isNull()); ++scenarios;
|
|
}
|
|
{
|
|
MyMesh m; enable(m); m.room_history_enabled = true;
|
|
const std::string text(148, 'x');
|
|
assert(result(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A\",\"text\":\"" + text + "\""), 1)["ok"] == true);
|
|
assert(strlen(m.posts[0].text) == 151 && m.room_history_state.count == 1);
|
|
error(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A\",\"text\":\"" + text + "x\""), 2, "151");
|
|
assert(m._num_posted == 1 && m.last_room_timestamp == 1000);
|
|
error(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A:B\",\"text\":\"x\""), 3, "display name");
|
|
m.storage.capacity = 0;
|
|
error(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A\",\"text\":\"retain\""), 4, "not retained");
|
|
assert(m._num_posted == 1 && m.last_room_timestamp == 1000 && m.room_history_state.count == 1);
|
|
m.storage.reset(); m.clock.now = 2;
|
|
assert(result(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A\",\"text\":\"retry with new sequence\""), 5)["timestamp"] == 1001);
|
|
assert(m._num_posted == 2 && m.room_history_state.count == 2); ++scenarios;
|
|
}
|
|
{
|
|
MyMesh m; enable(m); assert(m.room_access.setRates(m._fs, 1, 2));
|
|
assert(result(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A\",\"text\":\"one\""), 1)["ok"] == true);
|
|
error(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A\",\"text\":\"two\""), 2, "rate limit");
|
|
assert(m._num_posted == 1 && m.last_room_timestamp == 1000);
|
|
result(m, request("status"), 3); result(m, request("status"), 4); error(m, request("status"), 5, "rate limit");
|
|
ticks += 60000; result(m, request("status"), 6);
|
|
const auto key = token(); uint8_t author[32]; mesh::Utils::sha256(author, 32, key.data(), 32, m.self_id.pub_key, 32);
|
|
assert(m.room_access.addBan(m._fs, author) == mesh::RoomAccessPolicy::BanResult::Saved);
|
|
const unsigned floor = floors(m); error(m, request("status"), 1000, "denied"); assert(floors(m) == floor);
|
|
assert(m.room_access.removeBan(m._fs, author) == mesh::RoomAccessPolicy::BanResult::Saved);
|
|
result(m, request("status"), 7); ++scenarios;
|
|
}
|
|
{
|
|
MyMesh m; enable(m); const std::string title = u8"Café 地図 📡"; const std::string body(2048, 'b');
|
|
const auto saved = result(m, saveRequest(1, 0, title, body), 1);
|
|
if (saved["ok"] != true) fprintf(stderr, "Full board save error: %s\n", saved["error"].as<const char*>());
|
|
assert(saved["ok"] == true);
|
|
assert(saved["version"] == 1);
|
|
auto page = result(m, request("board.index", "", ",\"revision\":0,\"cursor\":0"), 2);
|
|
assert(page["revision"] == 1 && page["articles"].size() == 1 && page["next"] == 255);
|
|
assert(page["articles"][0]["length"] == 2048 && strcmp(page["articles"][0]["title"], title.c_str()) == 0);
|
|
std::string assembled;
|
|
for (unsigned offset = 0, sequence = 3; offset < 2048; ++sequence) {
|
|
auto chunk = result(m, request("board.read", "", ",\"id\":1,\"version\":1,\"offset\":" + std::to_string(offset)), sequence);
|
|
assert(chunk["version"] == 1 && chunk["offset"] == offset && chunk["total"] == 2048);
|
|
uint8_t bytes[128]; size_t length; assert(mesh::roomDecodeBase64(chunk["data64"], bytes, sizeof(bytes), length) && length > 0 && length <= 128);
|
|
assembled.append(reinterpret_cast<const char*>(bytes), length); offset += length; assert(chunk["next"] == offset);
|
|
}
|
|
assert(assembled == body);
|
|
const auto updated = result(m, saveRequest(1, 1, "Updated", "new body"), 30);
|
|
assert(updated["ok"] == true && updated["version"] == 2);
|
|
error(m, request("board.index", "", ",\"revision\":1,\"cursor\":0"), 31, "board changed");
|
|
error(m, request("board.read", "", ",\"id\":1,\"version\":1,\"offset\":128"), 32, "article changed");
|
|
error(m, saveRequest(1, 1, "Stale", "old"), 33, "article changed");
|
|
error(m, request("board.delete", "admin-secret", ",\"boot\":71,\"id\":1,\"version\":0"), 34, "current article version");
|
|
assert(result(m, request("board.delete", "admin-secret", ",\"boot\":71,\"id\":1,\"version\":2"), 35)["ok"] == true);
|
|
assert(result(m, saveRequest(1, 0, "Reused", "new"), 36)["ok"] == true);
|
|
error(m, request("board.read", "", ",\"id\":1,\"version\":2,\"offset\":0"), 37, "article changed"); ++scenarios;
|
|
}
|
|
{
|
|
MyMesh m; enable(m); uint32_t sequence = 1;
|
|
for (const std::string& input : {std::string("{"), std::string("[]"), std::string("null"), std::string("{\"op\":{\"a\":{\"b\":{\"c\":{\"d\":1}}}}}"),
|
|
std::string("{\"op\":\"status\",\"password\":\"write-secret\\u0000ignored\"}"), std::string("{\"op\":\"status\\u0000ignored\",\"password\":\"write-secret\"}"),
|
|
std::string("{\"op\":3,\"password\":[]}")}) {
|
|
const auto json = result(m, input, sequence++); assert(json["error"].is<const char*>() && floors(m) == 0);
|
|
}
|
|
error(m, std::string(4097, ' '), sequence++, "invalid request");
|
|
for (const std::string text : {"A===", "====", "Zg=A", "Zg==Zg==", "Zh==", "Zm9=", "*m9v", "Zg", "Zg== "}) {
|
|
error(m, request("board.save", "admin-secret", ",\"boot\":71,\"id\":1,\"version\":0,\"title\":\"T\",\"body64\":\"" + text + "\""), sequence++, "encoding");
|
|
}
|
|
error(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A\",\"text\":\"before\\u0000after\""), sequence++, "name and message");
|
|
error(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A\\u0000B\",\"text\":\"body\""), sequence++, "name and message");
|
|
error(m, request("board.save", "admin-secret", ",\"boot\":71,\"id\":1,\"version\":0,\"title\":\"T\\u0000X\",\"body64\":\"Zg==\""), sequence++, "article changed");
|
|
error(m, request("board.save", "admin-secret", ",\"boot\":71,\"id\":1,\"version\":0,\"title\":\"T\",\"body64\":\"Zg==\\u0000Zg==\""), sequence++, "article changed");
|
|
assert(m._num_posted == 0 && m.last_room_timestamp == 0);
|
|
error(m, saveRequest(1, 0, std::string(64, 't'), "body"), sequence++, "article changed");
|
|
error(m, saveRequest(1, 0, "Title", std::string(2049, 'b')), sequence++, "encoding");
|
|
assert(!m.storage.files.count(mesh::ROOM_BOARD_PRIMARY_PATH));
|
|
deny_json_allocation = true; error(m, request("status"), sequence++, "invalid JSON"); deny_json_allocation = false;
|
|
result(m, request("status"), sequence++);
|
|
// Excess unknown array members exhaust the actual bounded allocator.
|
|
std::string huge = "{\"op\":\"status\",\"password\":\"write-secret\",\"extra\":[";
|
|
for (unsigned i = 0; i < 1000; ++i) { if (i) huge += ','; huge += '0'; } huge += "]}";
|
|
error(m, huge, sequence++, "invalid JSON"); assert(json_allocations == 0); ++scenarios;
|
|
}
|
|
{
|
|
MyMesh m; enable(m);
|
|
for (uint8_t owner = 1; owner <= 8; ++owner) result(m, request("status"), 1, owner);
|
|
error(m, request("status"), 1, "busy", 9); ticks += 1200000;
|
|
result(m, request("status"), 1, 9);
|
|
// Every small response capacity stays within its provided buffer.
|
|
for (size_t capacity = 0; capacity < 200; ++capacity) execute(m, request("status"), uint32_t(capacity + 2), 9, capacity);
|
|
for (unsigned i = 0; i < 40; ++i) assert(result(m, request("post", "write-secret", ",\"boot\":71,\"name\":\"A\",\"text\":\"bounded ring\""), 300 + i, 9)["ok"] == true);
|
|
assert(m._num_posted == 40 && m.next_post_idx == 8 && m.last_room_timestamp == 1039); ++scenarios;
|
|
}
|
|
adminAuthorizationCases();
|
|
adminRouteCases();
|
|
adminCatchUpCases();
|
|
adminListingCases();
|
|
adminAccessAndSettingsCases();
|
|
adminInvalidAndSessionCases();
|
|
mailAuthorizationAndPolicyCases();
|
|
mailDeliveryAndDurabilityCases();
|
|
mailAdministratorCases();
|
|
mailPagingAndStorageCases();
|
|
mailGlobalQueueCases();
|
|
// Deliver concrete backend responses for the browser boundary fixture.
|
|
MyMesh boundary; enable(boundary);
|
|
printf("BOUNDARY_STATUS %s\n", execute(boundary, request("status"), 1).c_str());
|
|
assert(result(boundary, saveRequest(1, 0, "Instructions", "Read only this article"), 2)["ok"] == true);
|
|
printf("BOUNDARY_INDEX %s\n", execute(boundary, request("board.index", "write-secret", ",\"revision\":0,\"cursor\":0"), 3).c_str());
|
|
printf("BOUNDARY_READ %s\n", execute(boundary, request("board.read", "write-secret", ",\"id\":1,\"version\":1,\"offset\":0"), 4).c_str());
|
|
printf("PASS: %u base, 6 admin and 6 mail actual room web service authorization, storage, quota, JSON and boundary groups\n", scenarios);
|
|
}
|