Skip to content

Commit 59cd37f

Browse files
MysticialMysticial
authored
Sync with FW fix + RSC protocol change. (#1256)
* Sync with FW fix + RSC protocol change. * Update PABotBase2_PacketSender.cpp
1 parent 04e37c5 commit 59cd37f

14 files changed

Lines changed: 146 additions & 145 deletions

‎Common/Cpp/Concurrency/Mutex.h‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -26,4 +26,11 @@ namespace PokemonAutomation{
2626

2727
#endif
2828

29+
30+
namespace PokemonAutomation{
31+
template <typename LockType>
32+
using LockGuard = std::lock_guard<LockType>;
33+
}
34+
35+
2936
#endif

‎Common/Cpp/StreamConnections/PollingStreamConnections.h‎

Lines changed: 18 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,14 @@ class UnreliableStreamConnectionPolling : public UnreliableStreamSender{
2727

2828
class ReliableStreamConnectionPolling{
2929
public:
30+
virtual void lock() noexcept = 0;
31+
virtual void unlock() noexcept = 0;
32+
33+
//
34+
// These 3 functions are not thread/IRQ safe with anything else.
35+
// If needed call these under the lock above.
36+
//
37+
3038
// Enqueue the specified data into the uncommitted stream.
3139
// On success, returns true.
3240
// On fail, return false and aborts all uncommitted sends.
@@ -38,12 +46,16 @@ class ReliableStreamConnectionPolling{
3846
// Commits all uncommitted sends to stream.
3947
virtual void commit_uncommitted_reliable_sends() noexcept = 0;
4048

49+
50+
public:
4151
virtual bool reliable_send_all_or_nothing(const void* data, size_t bytes) noexcept{
42-
if (!enqueue_uncommitted_reliable_sends(data, bytes)){
43-
return false;
52+
lock();
53+
bool success = enqueue_uncommitted_reliable_sends(data, bytes);
54+
if (success){
55+
commit_uncommitted_reliable_sends();
4456
}
45-
commit_uncommitted_reliable_sends();
46-
return true;
57+
unlock();
58+
return success;
4759
}
4860

4961

@@ -53,10 +65,10 @@ class ReliableStreamConnectionPolling{
5365
virtual bool reset_flag_set() const{ return false; }
5466
virtual void clear_reset_flag(){}
5567

56-
virtual bool run_send_events(const WallDuration& timeout){
68+
virtual bool run_send_events(const WallDuration& timeout) noexcept{
5769
return false;
5870
}
59-
virtual bool run_recv_events(const WallDuration& timeout){
71+
virtual bool run_recv_events(const WallDuration& timeout) noexcept{
6072
return false;
6173
}
6274
};

‎Common/PABotBase2/PABotBase2CC_MessageDumper.cpp‎

Lines changed: 3 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ std::string tostr(const PacketHeader* header){
5151
case PABB2_CONNECTION_OPCODE_RET_PACKET_SIZE:
5252
str += "PABB2_CONNECTION_OPCODE_RET_PACKET_SIZE: seqnum = ";
5353
str += std::to_string(header->seqnum);
54-
str += ", bytes = " + std::to_string(((const PacketHeader_u16*)header)->data);
54+
str += ", bytes = " + std::to_string(((const PacketHeader_u32*)header)->data);
5555
return str;
5656

5757
case PABB2_CONNECTION_OPCODE_ASK_BUFFER_SLOTS:
@@ -61,7 +61,7 @@ std::string tostr(const PacketHeader* header){
6161
case PABB2_CONNECTION_OPCODE_RET_BUFFER_SLOTS:
6262
str += "PABB2_CONNECTION_OPCODE_RET_BUFFER_SLOTS: seqnum = ";
6363
str += std::to_string(header->seqnum);
64-
str += ", slots = " + std::to_string(((const PacketHeader_u8*)header)->data);
64+
str += ", slots = " + std::to_string(((const PacketHeader_u32*)header)->data);
6565
return str;
6666

6767
case PABB2_CONNECTION_OPCODE_ASK_BUFFER_BYTES:
@@ -71,7 +71,7 @@ std::string tostr(const PacketHeader* header){
7171
case PABB2_CONNECTION_OPCODE_RET_BUFFER_BYTES:
7272
str += "PABB2_CONNECTION_OPCODE_RET_BUFFER_BYTES: seqnum = ";
7373
str += std::to_string(header->seqnum);
74-
str += ", bytes = " + std::to_string(((const PacketHeader_u16*)header)->data);
74+
str += ", bytes = " + std::to_string(((const PacketHeader_u32*)header)->data);
7575
return str;
7676

7777
case PABB2_CONNECTION_OPCODE_ASK_STREAM_DATA:
@@ -112,16 +112,6 @@ std::string tostr(const PacketHeader* header){
112112
str += "PABB2_CONNECTION_OPCODE_INFO: seqnum = ";
113113
str += std::to_string(header->seqnum);
114114
return str;
115-
case PABB2_CONNECTION_OPCODE_INFO_U8:
116-
str += "PABB2_CONNECTION_OPCODE_INFO_U8: seqnum = ";
117-
str += std::to_string(header->seqnum);
118-
str += ", data = " + std::to_string(((const PacketHeader_u8*)header)->data);
119-
return str;
120-
case PABB2_CONNECTION_OPCODE_INFO_U16:
121-
str += "PABB2_CONNECTION_OPCODE_INFO_U16: seqnum = ";
122-
str += std::to_string(header->seqnum);
123-
str += ", data = " + std::to_string(((const PacketHeader_u16*)header)->data);
124-
return str;
125115
case PABB2_CONNECTION_OPCODE_INFO_H32:
126116
str += "PABB2_CONNECTION_OPCODE_INFO_H32: seqnum = ";
127117
str += std::to_string(header->seqnum);

‎Common/PABotBase2/PABotBase2_MessageProtocol.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@ namespace PABotBase2{
2323

2424

2525

26-
#define PABB2_MESSAGE_PROTOCOL_VERSION 2026050905
26+
#define PABB2_MESSAGE_PROTOCOL_VERSION 2026052100
2727

2828

2929
struct PABB_PACK MessageHeader{

‎Common/PABotBase2/ReliableConnectionLayer/PABotBase2CC_ReliableStreamConnection.cpp‎

Lines changed: 14 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -201,12 +201,10 @@ void ReliableStreamConnection::on_cancellable_cancel(
201201
// Send Path
202202
//
203203

204-
bool ReliableStreamConnection::reset(bool random_session_id, WallDuration timeout){
204+
bool ReliableStreamConnection::reset(WallDuration timeout){
205205
{
206206
std::lock_guard<Mutex> lg(m_lock);
207-
if (!random_session_id){
208-
m_reliable_sender.reset(0xffffffff);
209-
}else if (m_reliable_sender.session_id() == 0xffffffff){
207+
if (m_reliable_sender.session_id() == 0xffffffff){
210208
m_reliable_sender.reset(random_u32());
211209
}else{
212210
m_reliable_sender.reset(m_reliable_sender.session_id() + 1);
@@ -215,11 +213,7 @@ bool ReliableStreamConnection::reset(bool random_session_id, WallDuration timeou
215213
m_parser.reset();
216214
m_stream_coalescer.reset();
217215
throw_if_cancelled();
218-
if (random_session_id){
219-
m_reliable_sender.send_reset();
220-
}else{
221-
m_reliable_sender.send_packet(PABB2_CONNECTION_OPCODE_ASK_RESET, 0, nullptr);
222-
}
216+
m_reliable_sender.send_reset();
223217
}
224218
m_cv.notify_all();
225219
return wait_for_pending(timeout);
@@ -267,10 +261,10 @@ void ReliableStreamConnection::send_ack(uint8_t seqnum, uint8_t opcode){
267261
pabb_crc32_write_to_message(m_reliable_sender.session_id(), &packet, sizeof(packet));
268262
unreliable_send(&packet, sizeof(packet));
269263
}
270-
void ReliableStreamConnection::send_ack_u16(uint8_t seqnum, uint8_t opcode, uint16_t data){
264+
void ReliableStreamConnection::send_ack_u32(uint8_t seqnum, uint8_t opcode, uint32_t data){
271265
// Must call inside lock.
272266
struct{
273-
PacketHeader_u16 header;
267+
PacketHeader_u32 header;
274268
uint8_t crc[sizeof(uint32_t)];
275269
} packet;
276270
packet.header.magic_number = PABB2_CONNECTION_MAGIC_NUMBER;
@@ -414,8 +408,6 @@ void ReliableStreamConnection::on_packet(const PacketHeader* packet){
414408
case PABB2_CONNECTION_OPCODE_INFO_STREAM_SEND_FULL:
415409
case PABB2_CONNECTION_OPCODE_INFO_STREAM_RECV_FULL:
416410
case PABB2_CONNECTION_OPCODE_INFO:
417-
case PABB2_CONNECTION_OPCODE_INFO_U8:
418-
case PABB2_CONNECTION_OPCODE_INFO_U16:
419411
case PABB2_CONNECTION_OPCODE_INFO_H32:
420412
case PABB2_CONNECTION_OPCODE_INFO_U32:
421413
case PABB2_CONNECTION_OPCODE_INFO_I32:
@@ -440,13 +432,13 @@ void ReliableStreamConnection::on_packet(const PacketHeader* packet){
440432
}
441433
void ReliableStreamConnection::process_UNKNOWN_OPCODE(const PacketHeader* packet){
442434
std::lock_guard<Mutex> lg(m_lock);
443-
if (packet->packet_bytes < sizeof(PacketHeader_u8) + sizeof(uint32_t)){
435+
if (packet->packet_bytes < sizeof(PacketHeader_u32) + sizeof(uint32_t)){
444436
m_error = "Unknown opcode packet is too small: " + std::to_string(packet->packet_bytes);
445437
m_logger.log("[RSC]: " + m_error, COLOR_RED);
446438
return;
447439
}
448440

449-
const PacketHeader_u8* message = (const PacketHeader_u8*)packet;
441+
const PacketHeader_u32* message = (const PacketHeader_u32*)packet;
450442
m_logger.log(
451443
"[RSC]: PABB2_CONNECTION_OPCODE_INVALID_OPCODE: Device reported an invalid opcode: " +
452444
std::to_string(message->data),
@@ -493,14 +485,14 @@ void ReliableStreamConnection::process_RET_VERSION(const PacketHeader* packet){
493485
m_cv.notify_all();
494486
}
495487
void ReliableStreamConnection::process_RET_PACKET_SIZE(const PacketHeader* packet){
496-
if (packet->packet_bytes < sizeof(PacketHeader_u16) + sizeof(uint32_t)){
488+
if (packet->packet_bytes < sizeof(PacketHeader_u32) + sizeof(uint32_t)){
497489
m_logger.log(
498490
"[RSC]: Packet size response is too small: " + std::to_string(packet->packet_bytes),
499491
COLOR_RED
500492
);
501493
return;
502494
}
503-
const PacketHeader_u16* message = (const PacketHeader_u16*)packet;
495+
const PacketHeader_u32* message = (const PacketHeader_u32*)packet;
504496
m_logger.log(
505497
"[RSC]: Setting Packet Size: " + std::to_string(message->data) + " bytes",
506498
COLOR_BLUE
@@ -513,14 +505,14 @@ void ReliableStreamConnection::process_RET_PACKET_SIZE(const PacketHeader* packe
513505
m_cv.notify_all();
514506
}
515507
void ReliableStreamConnection::process_RET_BUFFER_SLOTS(const PacketHeader* packet){
516-
if (packet->packet_bytes < sizeof(PacketHeader_u8) + sizeof(uint32_t)){
508+
if (packet->packet_bytes < sizeof(PacketHeader_u32) + sizeof(uint32_t)){
517509
m_logger.log(
518510
"[RSC]: Buffer slot response is too small: " + std::to_string(packet->packet_bytes),
519511
COLOR_RED
520512
);
521513
return;
522514
}
523-
const PacketHeader_u8* message = (const PacketHeader_u8*)packet;
515+
const PacketHeader_u32* message = (const PacketHeader_u32*)packet;
524516
{
525517
std::lock_guard<Mutex> lg(m_lock);
526518
m_reliable_sender.remove(packet->seqnum);
@@ -533,14 +525,14 @@ void ReliableStreamConnection::process_RET_BUFFER_SLOTS(const PacketHeader* pack
533525
m_cv.notify_all();
534526
}
535527
void ReliableStreamConnection::process_RET_BUFFER_BYTES(const PacketHeader* packet){
536-
if (packet->packet_bytes < sizeof(PacketHeader_u16) + sizeof(uint32_t)){
528+
if (packet->packet_bytes < sizeof(PacketHeader_u32) + sizeof(uint32_t)){
537529
m_logger.log(
538530
"[RSC]: Buffer slot response is too small: " + std::to_string(packet->packet_bytes),
539531
COLOR_RED
540532
);
541533
return;
542534
}
543-
const PacketHeader_u16* message = (const PacketHeader_u16*)packet;
535+
const PacketHeader_u32* message = (const PacketHeader_u32*)packet;
544536
{
545537
std::lock_guard<Mutex> lg(m_lock);
546538
m_reliable_sender.remove(packet->seqnum);
@@ -570,7 +562,7 @@ void ReliableStreamConnection::process_ASK_STREAM_DATA(const PacketHeader* packe
570562
// cout << "Calling: send_ack_u16()" << endl;
571563
{
572564
std::lock_guard<Mutex> lg(m_lock);
573-
send_ack_u16(
565+
send_ack_u32(
574566
packet->seqnum,
575567
PABB2_CONNECTION_OPCODE_RET_STREAM_DATA,
576568
m_stream_coalescer.free_bytes()

‎Common/PABotBase2/ReliableConnectionLayer/PABotBase2CC_ReliableStreamConnection.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,7 @@ class ReliableStreamConnection final
4848
}
4949
virtual bool cancel(std::exception_ptr exception) noexcept override;
5050

51-
bool reset(bool random_session_id, WallDuration timeout = WallDuration::max());
51+
bool reset(WallDuration timeout = WallDuration::max());
5252

5353
bool remote_protocol_is_compatible() const{
5454
return m_remote_protocol_compatible;
@@ -89,7 +89,7 @@ class ReliableStreamConnection final
8989
// Send
9090

9191
void send_ack(uint8_t seqnum, uint8_t opcode);
92-
void send_ack_u16(uint8_t seqnum, uint8_t opcode, uint16_t data);
92+
void send_ack_u32(uint8_t seqnum, uint8_t opcode, uint32_t data);
9393

9494
void retransmit_thread();
9595

0 commit comments

Comments
 (0)