ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
BrowserSessionBinding Class Reference

Public Member Functions

 BrowserSessionBinding (bool server, int encryption, PeerBytes password, PeerBytes identity, PeerBytes expected)
 BrowserSessionBinding (const BrowserSessionBinding &)=delete
BrowserSessionBinding & operator= (const BrowserSessionBinding &)=delete
bool valid () const
bool ready () const
std::string error () const
void close ()
emscripten::val process (emscripten::val event)
emscripten::val processBatch (emscripten::val events)

Detailed Description

Definition at line 20 of file browser_session.cpp.

Constructor & Destructor Documentation

◆ BrowserSessionBinding() [1/2]

BrowserSessionBinding::BrowserSessionBinding ( bool server,
int encryption,
PeerBytes password,
PeerBytes identity,
PeerBytes expected )
inline

Definition at line 22 of file browser_session.cpp.

22 {
23 auto pass = binding_copy_input(password);
24 auto secret = binding_copy_input(identity);
25 auto key = binding_copy_input(expected);
26 if ((!secret.empty() && secret.size() != 64) || (!key.empty() && key.size() != 32)) {
27 SET_ERRNO(ERROR_INVALID_PARAM, "Invalid peer identity or verification key length");
28 construction_error_ = "Invalid peer identity or verification key length";
29 } else {
30 pass.push_back(0);
31 session_.reset(
32 browser_session_create(server, encryption, pass.size() > 1 ? reinterpret_cast<char *>(pass.data()) : nullptr, secret.empty() ? nullptr : secret.data(), key.empty() ? nullptr : key.data()));
33 }
34 if (!pass.empty())
35 sodium_memzero(pass.data(), pass.size());
36 if (!secret.empty())
37 sodium_memzero(secret.data(), secret.size());
38 if (!key.empty())
39 sodium_memzero(key.data(), key.size());
40 }
#define SET_ERRNO(code,...)
std::vector< uint8_t > binding_copy_input(emscripten::val bytes)
Definition byte_arrays.h:6
@ ERROR_INVALID_PARAM
browser_session_t * browser_session_create(bool server, int encryption, const char *password, const uint8_t *identity, const uint8_t *expected_key)

References binding_copy_input(), browser_session_create(), ERROR_INVALID_PARAM, and SET_ERRNO.

Referenced by BrowserSessionBinding(), and operator=().

◆ BrowserSessionBinding() [2/2]

BrowserSessionBinding::BrowserSessionBinding ( const BrowserSessionBinding & )
delete

Member Function Documentation

◆ close()

void BrowserSessionBinding::close ( )
inline

Definition at line 55 of file browser_session.cpp.

55 {
56 session_.reset();
57 }

Referenced by EMSCRIPTEN_BINDINGS().

◆ error()

std::string BrowserSessionBinding::error ( ) const
inline

Definition at line 50 of file browser_session.cpp.

50 {
51 if (!session_ && !construction_error_.empty())
52 return construction_error_;
53 return browser_session_error(session_.get());
54 }
const char * browser_session_error(browser_session_t *peer)

References browser_session_error().

Referenced by EMSCRIPTEN_BINDINGS(), and processBatch().

◆ operator=()

BrowserSessionBinding & BrowserSessionBinding::operator= ( const BrowserSessionBinding & )
delete

◆ process()

emscripten::val BrowserSessionBinding::process ( emscripten::val event)
inline

Definition at line 58 of file browser_session.cpp.

58 {
59 emscripten::val result = emscripten::val::object();
60 if (!session_) {
61 const int code = SET_ERRNO(ERROR_INVALID_STATE, "Browser session is not initialized");
62 result.set("code", code);
63 result.set("ok", false);
64 result.set("message", "Browser session is not initialized");
65 result.set("retryable", false);
66 result.set("outputs", emscripten::val::array());
67 result.set("received", emscripten::val::null());
68 result.set("queuedBytes", 0);
69 result.set("writable", false);
70 return result;
71 }
72 result.set("code", 0);
73 const std::string type = event["type"].as<std::string>();
74 if (type == "start") {
75 result.set("code", static_cast<int>(browser_session_start(session_.get())));
76 } else if (type == "connected" || type == "disconnected") {
77 browser_session_set_connected(session_.get(), type == "connected");
78 } else if (type == "send" || type == "receive") {
79 auto bytes = binding_copy_input(event["packet"]);
80 const int code = input_bytes(bytes, type == "receive");
81 result.set("code", code);
82 if (!bytes.empty())
83 sodium_memzero(bytes.data(), bytes.size());
84 } else if (type == "tick") {
85 result.set("code", static_cast<int>(browser_session_tick(session_.get())));
86 } else if (type == "quic-begin") {
87 result.set("code", static_cast<int>(browser_session_quic_begin(session_.get())));
88 } else if (type == "quic-event" && event["operation"].as<std::string>() == "init") {
89 result.set("code", static_cast<int>(browser_session_security_init(session_.get())));
90 } else if (type == "quic-event" && event["operation"].as<std::string>() == "tick") {
91 int code = static_cast<int>(browser_session_security_tick(session_.get()));
92 result.set("epoch", browser_session_security_epoch(session_.get()));
93 emscripten::val quic_outputs = emscripten::val::array();
94 for (unsigned i = 0; i < 16; ++i) {
95 uint8_t data[256];
96 size_t length = 0;
97 uint32_t flow = 0;
98 code = browser_session_security_output(session_.get(), data, sizeof(data), &length, &flow);
99 if (code || !length)
100 break;
101 emscripten::val output = emscripten::val::object();
102 output.set("code", code);
103 output.set("flow", flow);
104 output.set("packet", binding_copy_output(data, length));
105 quic_outputs.call<void>("push", output);
106 }
107 result.set("code", code);
108 result.set("quicOutputs", quic_outputs);
109 } else if (type == "quic-event" && event["operation"].as<std::string>() == "state") {
110 result.set("epoch", browser_session_security_epoch(session_.get()));
111 } else if (type == "quic-event" && (event["operation"].as<std::string>() == "seal" || event["operation"].as<std::string>() == "open")) {
112 auto packet = binding_copy_input(event["packet"]);
113 const bool seal = event["operation"].as<std::string>() == "seal";
114 std::vector<uint8_t> output(packet.size() + (seal ? 94 : 0));
115 size_t length = 0;
116 uint64_t sequence = 0;
117 const int code = browser_session_security_packet(session_.get(), seal, event["flow"].as<unsigned>(), event["delivery"].as<unsigned>(), packet.data(), packet.size(), output.data(), output.size(),
118 &length, &sequence);
119 result.set("code", code);
120 result.set("packet", binding_copy_output(output.data(), code ? 0 : length));
121 result.set("sequence", emscripten::val::global("BigInt")(std::to_string(sequence)));
122 if (!packet.empty())
123 sodium_memzero(packet.data(), packet.size());
124 if (!output.empty())
125 sodium_memzero(output.data(), output.size());
126 } else {
127 result.set("code", SET_ERRNO(ERROR_INVALID_PARAM, "Unknown browser session event"));
128 }
129 const int code = result["code"].as<int>();
130 if (code) {
131 asciichat_error_context_t context{};
132 const bool has_context = errno_has(&context);
133 result.set("message", has_context && context.context_message[0] ? std::string(context.context_message) : std::string(asciichat_error_string(static_cast<asciichat_error_t>(code))));
134 result.set("retryable", network_error_action(static_cast<asciichat_error_t>(code)) == NETWORK_ERROR_RETRY);
135 }
136 emscripten::val outputs = emscripten::val::array();
137 for (unsigned i = 0; i < 16; ++i) {
138 const void *data = browser_session_output_data(session_.get());
139 if (!data)
140 break;
141 outputs.call<void>("push", binding_copy_output(data, browser_session_output_size(session_.get())));
142 browser_session_output_pop(session_.get());
143 }
144 result.set("outputs", outputs);
145 const void *received = browser_session_received_data(session_.get());
146 const size_t received_size = browser_session_received_size(session_.get());
147 result.set("received", received && received_size ? binding_copy_output(received, received_size) : emscripten::val::null());
148 result.set("queuedBytes", browser_session_queued_bytes(session_.get()));
149 result.set("writable", browser_session_writable(session_.get(), 0));
150 result.set("ok", result["code"].as<int>() == 0);
151 return result;
152 }
bool errno_has(asciichat_error_context_t *context)
emscripten::val binding_copy_output(const void *data, size_t length)
Definition byte_arrays.h:18
unsigned int uint32_t
unsigned long long uint64_t
unsigned char uint8_t
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ERROR_INVALID_STATE
asciichat_error_t browser_session_security_tick(browser_session_t *peer)
double browser_session_security_epoch(browser_session_t *peer)
const void * browser_session_output_data(browser_session_t *peer)
void browser_session_output_pop(browser_session_t *peer)
size_t browser_session_queued_bytes(const browser_session_t *peer)
asciichat_error_t browser_session_security_packet(browser_session_t *peer, bool seal, uint32_t channel, uint32_t delivery, const uint8_t *packet, size_t length, uint8_t *output, size_t capacity, size_t *out_length, uint64_t *sequence)
asciichat_error_t browser_session_security_output(browser_session_t *peer, uint8_t *output, size_t capacity, size_t *length, uint32_t *channel)
size_t browser_session_received_size(browser_session_t *peer)
asciichat_error_t browser_session_tick(browser_session_t *peer)
asciichat_error_t browser_session_start(browser_session_t *peer)
bool browser_session_writable(const browser_session_t *peer, size_t additional_bytes)
size_t browser_session_output_size(browser_session_t *peer)
void browser_session_set_connected(browser_session_t *peer, bool connected)
asciichat_error_t browser_session_security_init(browser_session_t *peer)
const void * browser_session_received_data(browser_session_t *peer)
asciichat_error_t browser_session_quic_begin(browser_session_t *peer)
network_error_action_t network_error_action(asciichat_error_t code)

References binding_copy_input(), binding_copy_output(), browser_session_output_data(), browser_session_output_pop(), browser_session_output_size(), browser_session_queued_bytes(), browser_session_quic_begin(), browser_session_received_data(), browser_session_received_size(), browser_session_security_epoch(), browser_session_security_init(), browser_session_security_output(), browser_session_security_packet(), browser_session_security_tick(), browser_session_set_connected(), browser_session_start(), browser_session_tick(), browser_session_writable(), asciichat_error_context_t::context_message, errno_has(), ERROR_INVALID_PARAM, ERROR_INVALID_STATE, network_error_action(), NETWORK_ERROR_RETRY, and SET_ERRNO.

Referenced by EMSCRIPTEN_BINDINGS(), and processBatch().

◆ processBatch()

emscripten::val BrowserSessionBinding::processBatch ( emscripten::val events)
inline

Definition at line 154 of file browser_session.cpp.

154 {
155 emscripten::val batch = emscripten::val::array();
156 const unsigned count = events["length"].as<unsigned>();
157 if (count > 128) {
158 emscripten::val error = emscripten::val::object();
159 error.set("code", static_cast<int>(SET_ERRNO(ERROR_INVALID_PARAM, "Browser session event batch exceeds 128 events")));
160 error.set("ok", false);
161 error.set("message", "Browser session event batch exceeds 128 events");
162 error.set("retryable", false);
163 batch.call<void>("push", error);
164 return batch;
165 }
166 for (unsigned index = 0; index < count; ++index)
167 batch.call<void>("push", process(events[index]));
168 return batch;
169 }
emscripten::val process(emscripten::val event)
std::string error() const
static bool size_t index
Definition queries.h:8

References error(), ERROR_INVALID_PARAM, index, process(), and SET_ERRNO.

Referenced by EMSCRIPTEN_BINDINGS().

◆ ready()

bool BrowserSessionBinding::ready ( ) const
inline

Definition at line 47 of file browser_session.cpp.

47 {
48 return session_ && browser_session_ready(session_.get());
49 }
bool browser_session_ready(browser_session_t *peer)

References browser_session_ready().

Referenced by EMSCRIPTEN_BINDINGS().

◆ valid()

bool BrowserSessionBinding::valid ( ) const
inline

Definition at line 44 of file browser_session.cpp.

44 {
45 return static_cast<bool>(session_);
46 }

Referenced by EMSCRIPTEN_BINDINGS().


The documentation for this class was generated from the following file: