3 /// Low level protocol packet builder class.
4 /// Has knowledge of specific protocol commands in order
5 /// to hide protocol details behind an API.
9 Copyright (C) 2005-2010, Net Direct Inc. (http://www.netdirect.ca/)
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
20 See the GNU General Public License in the COPYING file at the
21 root directory of this project for more details.
25 #include "m_desktop.h"
27 #include "protostructs.h"
35 #define __DEBUG_MODE__
41 //////////////////////////////////////////////////////////////////////////////
47 /// Returns the command value of the receive packet. If receive isn't
48 /// large enough, throws Error.
50 unsigned int Packet::Command() const
52 Protocol::CheckSize(m_receive
, SB_PACKET_HEADER_SIZE
);
53 MAKE_PACKET(rpack
, m_receive
);
54 return rpack
->command
;
58 //////////////////////////////////////////////////////////////////////////////
61 ZeroPacket::ZeroPacket(Data
&send
, Data
&receive
)
62 : Packet(send
, receive
)
66 ZeroPacket::~ZeroPacket()
73 /// Builds a command packet for the initial socket-0 handshakes
74 /// that fetch certain (some unknown) attributes. The attributes
75 /// appear to exist in an object/attribute sequence, so that's
76 /// how we address them here.
78 void ZeroPacket::GetAttribute(unsigned int object
, unsigned int attribute
)
80 size_t size
= SB_SOCKET_PACKET_HEADER_SIZE
+ ATTRIBUTE_FETCH_COMMAND_SIZE
;
81 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(size
));
82 Protocol::Packet
&packet
= *cpack
;
84 // socket class sets socket for us
85 packet
.size
= htobs(size
);
86 packet
.command
= SB_COMMAND_FETCH_ATTRIBUTE
;
87 packet
.u
.socket
.socket
= htobs(0x00ff); // default non-socket request
88 packet
.u
.socket
.sequence
= 0; // filled in by Socket class
89 packet
.u
.socket
.u
.fetch
.object
= htobs(object
);
90 packet
.u
.socket
.u
.fetch
.attribute
= htobs(attribute
);
92 m_send
.ReleaseBuffer(size
);
98 /// Builds command packet for sending echo request. The parameter
99 /// to this command is the number of microseconds elapsed since host
100 /// computer startup.
102 void ZeroPacket::Echo(uint64_t us_ticks
)
104 size_t size
= SB_SOCKET_PACKET_HEADER_SIZE
+ ECHO_COMMAND_SIZE
;
105 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(size
));
106 Protocol::Packet
&packet
= *cpack
;
108 packet
.size
= htobs(size
);
109 packet
.command
= SB_COMMAND_ECHO
;
110 packet
.u
.socket
.socket
= htobs(0x00ff); // default non-socket request
111 packet
.u
.socket
.sequence
= 0; // filled in by Socket class
112 packet
.u
.socket
.u
.echo
.ticks
= htobl(us_ticks
);
114 m_send
.ReleaseBuffer(size
);
117 void ZeroPacket::Reset()
119 size_t size
= SB_SOCKET_PACKET_HEADER_SIZE
;
120 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(size
));
121 Protocol::Packet
&packet
= *cpack
;
123 packet
.size
= htobs(size
);
124 packet
.command
= SB_COMMAND_RESET
;
125 packet
.u
.socket
.socket
= htobs(0x00ff); // default non-socket request
126 packet
.u
.socket
.sequence
= 0; // filled in by Socket class
128 m_send
.ReleaseBuffer(size
);
131 unsigned int ZeroPacket::ObjectID() const
133 Protocol::CheckSize(m_receive
, SB_SOCKET_PACKET_HEADER_SIZE
);
134 MAKE_PACKET(rpack
, m_receive
);
135 return btohs(rpack
->u
.socket
.u
.fetch
.object
);
138 unsigned int ZeroPacket::AttributeID() const
140 Protocol::CheckSize(m_receive
, SB_SOCKET_PACKET_HEADER_SIZE
);
141 MAKE_PACKET(rpack
, m_receive
);
142 return btohs(rpack
->u
.socket
.u
.fetch
.attribute
);
145 uint32_t ZeroPacket::ChallengeSeed() const
147 Protocol::CheckSize(m_receive
, SB_SOCKET_PACKET_HEADER_SIZE
+
148 PASSWORD_CHALLENGE_SEED_SIZE
);
149 MAKE_PACKET(rpack
, m_receive
);
150 return btohl(rpack
->u
.socket
.u
.password
.u
.seed
);
153 unsigned int ZeroPacket::RemainingTries() const
155 Protocol::CheckSize(m_receive
, SB_SOCKET_PACKET_HEADER_SIZE
+
156 PASSWORD_CHALLENGE_HEADER_SIZE
);
157 MAKE_PACKET(rpack
, m_receive
);
158 // this is a byte, so no byte swapping needed
159 return rpack
->u
.socket
.u
.password
.remaining_tries
;
162 unsigned int ZeroPacket::SocketResponse() const
164 Protocol::CheckSize(m_receive
, SB_SOCKET_PACKET_HEADER_SIZE
);
165 MAKE_PACKET(rpack
, m_receive
);
166 return btohs(rpack
->u
.socket
.socket
);
169 unsigned char ZeroPacket::SocketSequence() const
171 Protocol::CheckSize(m_receive
, SB_SOCKET_PACKET_HEADER_SIZE
);
172 MAKE_PACKET(rpack
, m_receive
);
173 return rpack
->u
.socket
.sequence
; // sequence is a byte
176 uint8_t ZeroPacket::CommandResponse() const
178 Protocol::CheckSize(m_receive
, SB_SOCKET_PACKET_HEADER_SIZE
);
179 MAKE_PACKET(rpack
, m_receive
);
180 return rpack
->command
;
185 //////////////////////////////////////////////////////////////////////////////
188 DBPacket::DBPacket(Mode::Desktop
&con
, Data
&send
, Data
&receive
)
189 : Packet(send
, receive
)
195 DBPacket::~DBPacket()
202 /// Builds a command packet for the CLEAR_DATABASE command code, placing
203 /// the data in the send buffer.
205 void DBPacket::ClearDatabase(unsigned int dbId
)
207 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(9));
208 Protocol::Packet
&packet
= *cpack
;
210 // socket class sets socket for us
211 packet
.size
= htobs(9);
212 packet
.command
= SB_COMMAND_DB_DATA
;
213 packet
.u
.db
.tableCmd
= m_con
.GetDBCommand(Mode::Desktop::DatabaseAccess
);
214 packet
.u
.db
.u
.command
.operation
= SB_DBOP_CLEAR_DATABASE
;
215 packet
.u
.db
.u
.command
.databaseId
= htobs(dbId
);
217 m_send
.ReleaseBuffer(9);
219 m_last_dbop
= SB_DBOP_CLEAR_DATABASE
;
225 /// Builds a command packet for the GET_DBDB command code, placing the
228 void DBPacket::GetDBDB()
230 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(7));
231 Protocol::Packet
&packet
= *cpack
;
233 // socket class sets socket for us
234 packet
.size
= htobs(7);
235 packet
.command
= SB_COMMAND_DB_DATA
;
236 packet
.u
.db
.tableCmd
= m_con
.GetDBCommand(Mode::Desktop::DatabaseAccess
);
237 // packet.u.db.u.command.operation = SB_DBOP_GET_DBDB;
238 packet
.u
.db
.u
.command
.operation
= SB_DBOP_OLD_GET_DBDB
;
240 m_send
.ReleaseBuffer(7);
242 m_last_dbop
= SB_DBOP_OLD_GET_DBDB
;
246 // GetRecordStateTable
248 /// Builds a command packet in the send buffer for the
249 /// GET_RECORD_STATE_TABLE command.
251 void DBPacket::GetRecordStateTable(unsigned int dbId
)
253 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(9));
254 Protocol::Packet
&packet
= *cpack
;
256 // socket class sets socket for us
257 packet
.size
= htobs(9);
258 packet
.command
= SB_COMMAND_DB_DATA
;
259 packet
.u
.db
.tableCmd
= m_con
.GetDBCommand(Mode::Desktop::DatabaseAccess
);
260 packet
.u
.db
.u
.command
.operation
= SB_DBOP_GET_RECORD_STATE_TABLE
;
261 packet
.u
.db
.u
.command
.databaseId
= htobs(dbId
);
263 m_send
.ReleaseBuffer(9);
265 m_last_dbop
= SB_DBOP_GET_RECORD_STATE_TABLE
;
271 /// Builds a command packet in the send buffer for the SET_RECORD_FLAGS
274 /// FIXME - this API call is incomplete, since there are unknown flags
275 /// in the SetRecordFlags protocol packet. Currently it is only
276 /// used to set all flags to zero.
278 void DBPacket::SetRecordFlags(unsigned int dbId
, unsigned int stateTableIndex
,
281 size_t size
= SB_PACKET_COMMAND_HEADER_SIZE
+ DBC_RECORD_FLAGS_SIZE
;
282 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(size
));
283 Protocol::Packet
&packet
= *cpack
;
285 // socket class sets socket for us
286 packet
.size
= htobs(size
);
287 packet
.command
= SB_COMMAND_DB_DATA
;
288 packet
.u
.db
.tableCmd
= m_con
.GetDBCommand(Mode::Desktop::DatabaseAccess
);
289 packet
.u
.db
.u
.command
.operation
= SB_DBOP_SET_RECORD_FLAGS
;
290 packet
.u
.db
.u
.command
.databaseId
= htobs(dbId
);
291 packet
.u
.db
.u
.command
.u
.flags
.unknown
= flag1
;
292 packet
.u
.db
.u
.command
.u
.flags
.index
= htobs(stateTableIndex
);
293 memset(packet
.u
.db
.u
.command
.u
.flags
.unknown2
, 0, sizeof(packet
.u
.db
.u
.command
.u
.flags
.unknown2
));
295 m_send
.ReleaseBuffer(size
);
297 m_last_dbop
= SB_DBOP_SET_RECORD_FLAGS
;
301 // DeleteRecordByIndex
303 /// Builds a command packet in the send buffer for the DELETE_RECORD_BY_INDEX
306 void DBPacket::DeleteRecordByIndex(unsigned int dbId
, unsigned int stateTableIndex
)
308 size_t size
= SB_PACKET_COMMAND_HEADER_SIZE
+ DBC_RECORD_HEADER_SIZE
;
309 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(size
));
310 Protocol::Packet
&packet
= *cpack
;
312 // socket class sets socket for us
313 packet
.size
= htobs(size
);
314 packet
.command
= SB_COMMAND_DB_DATA
;
315 packet
.u
.db
.tableCmd
= m_con
.GetDBCommand(Mode::Desktop::DatabaseAccess
);
316 packet
.u
.db
.u
.command
.operation
= SB_DBOP_DELETE_RECORD_BY_INDEX
;
317 packet
.u
.db
.u
.command
.databaseId
= htobs(dbId
);
318 packet
.u
.db
.u
.command
.u
.record
.recordIndex
= htobs(stateTableIndex
);
320 m_send
.ReleaseBuffer(size
);
322 m_last_dbop
= SB_DBOP_DELETE_RECORD_BY_INDEX
;
328 /// Builds a command packet in the send buffer for the GET_RECORD_BY_INDEX
331 void DBPacket::GetRecordByIndex(unsigned int dbId
, unsigned int stateTableIndex
)
333 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(11));
334 Protocol::Packet
&packet
= *cpack
;
336 // socket class sets socket for us
337 packet
.size
= htobs(11);
338 packet
.command
= SB_COMMAND_DB_DATA
;
339 packet
.u
.db
.tableCmd
= m_con
.GetDBCommand(Mode::Desktop::DatabaseAccess
);
340 packet
.u
.db
.u
.command
.operation
= SB_DBOP_GET_RECORD_BY_INDEX
;
341 packet
.u
.db
.u
.command
.databaseId
= htobs(dbId
);
342 packet
.u
.db
.u
.command
.u
.record
.recordIndex
= htobs(stateTableIndex
);
344 m_send
.ReleaseBuffer(11);
346 m_last_dbop
= SB_DBOP_GET_RECORD_BY_INDEX
;
352 /// Builds a command packet in the m_send buffer for the SET_RECORD_BY_INDEX
356 /// - true means success
357 /// - false means no data available from Builder object
359 bool DBPacket::SetRecordByIndex(unsigned int dbId
, unsigned int stateTableIndex
,
360 Builder
&build
, const IConverter
*ic
)
362 // get new data if available
363 if( !build
.Retrieve(dbId
) )
367 size_t header_size
= SB_PACKET_COMMAND_HEADER_SIZE
+ DBC_INDEXED_UPLOAD_HEADER_SIZE
;
368 build
.BuildFields(m_send
, header_size
, ic
);
369 size_t total_size
= m_send
.GetSize();
371 // fill in the header values
372 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(total_size
));
373 Protocol::Packet
&packet
= *cpack
;
375 // socket class sets socket for us
376 packet
.size
= htobs(total_size
);
377 packet
.command
= SB_COMMAND_DB_DATA
;
378 packet
.u
.db
.tableCmd
= m_con
.GetDBCommand(Mode::Desktop::DatabaseAccess
);
379 packet
.u
.db
.u
.command
.operation
= SB_DBOP_SET_RECORD_BY_INDEX
;
380 packet
.u
.db
.u
.command
.databaseId
= htobs(dbId
);
381 packet
.u
.db
.u
.command
.u
.index_upload
.unknown
= 0;
382 packet
.u
.db
.u
.command
.u
.index_upload
.index
= htobs(stateTableIndex
);
384 m_send
.ReleaseBuffer(total_size
);
386 m_last_dbop
= SB_DBOP_SET_RECORD_BY_INDEX
;
393 /// Builds a command packet in the send buffer for the GET_RECORDS
396 void DBPacket::GetRecords(unsigned int dbId
)
398 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(9));
399 Protocol::Packet
&packet
= *cpack
;
401 // socket class sets socket for us
402 packet
.size
= htobs(9);
403 packet
.command
= SB_COMMAND_DB_DATA
;
404 packet
.u
.db
.tableCmd
= m_con
.GetDBCommand(Mode::Desktop::DatabaseAccess
);
405 packet
.u
.db
.u
.command
.operation
= SB_DBOP_OLD_GET_RECORDS
;
406 packet
.u
.db
.u
.command
.databaseId
= htobs(dbId
);
408 m_send
.ReleaseBuffer(9);
410 m_last_dbop
= SB_DBOP_OLD_GET_RECORDS
;
416 /// Builds a command packet in the m_send buffer for the SET_RECORD command
420 /// - true means success
421 /// - false means no data available from Builder object
423 bool DBPacket::SetRecord(unsigned int dbId
, Builder
&build
, const IConverter
*ic
)
425 // get new data if available
426 if( !build
.Retrieve(dbId
) )
430 size_t header_size
= SB_PACKET_COMMAND_HEADER_SIZE
+ DBC_TAGGED_UPLOAD_HEADER_SIZE
;
431 build
.BuildHeader(m_send
, header_size
);
432 build
.BuildFields(m_send
, header_size
, ic
);
433 size_t total_size
= m_send
.GetSize();
435 // fill in the header values
436 MAKE_PACKETPTR_BUF(cpack
, m_send
.GetBuffer(total_size
));
437 Protocol::Packet
&packet
= *cpack
;
439 // socket class sets socket for us
440 packet
.size
= htobs(total_size
);
441 packet
.command
= SB_COMMAND_DB_DATA
;
442 packet
.u
.db
.tableCmd
= m_con
.GetDBCommand(Mode::Desktop::DatabaseAccess
);
443 packet
.u
.db
.u
.command
.operation
= SB_DBOP_SET_RECORD
;
444 packet
.u
.db
.u
.command
.databaseId
= htobs(dbId
);
445 packet
.u
.db
.u
.command
.u
.tag_upload
.rectype
= build
.GetRecType();
446 packet
.u
.db
.u
.command
.u
.tag_upload
.uniqueId
= htobl(build
.GetUniqueId());
447 packet
.u
.db
.u
.command
.u
.tag_upload
.unknown2
= 1; // unknown observed value
449 m_send
.ReleaseBuffer(total_size
);
451 m_last_dbop
= SB_DBOP_SET_RECORD
;
456 // throws FIXME if packet doesn't support it
457 unsigned int DBPacket::ReturnCode() const
459 if( Command() == SB_COMMAND_DB_DONE
) {
460 Protocol::CheckSize(m_receive
, SB_PACKET_DBACCESS_HEADER_SIZE
+ SB_DBACCESS_RETURN_CODE_SIZE
);
461 MAKE_PACKET(rpack
, m_receive
);
462 return rpack
->u
.db
.u
.return_code
;
465 throw Error("Attempting to extract a return code from the wrong response packet type");
472 /// Returns the database operation code from the receive packet, assuming
473 /// that receive contains a response packet. If receive isn't large
474 /// enough, throws Error.
476 unsigned int DBPacket::DBOperation() const
478 Protocol::CheckSize(m_receive
, SB_PACKET_RESPONSE_HEADER_SIZE
);
479 MAKE_PACKET(rpack
, m_receive
);
480 return rpack
->u
.db
.u
.response
.operation
;
486 /// Parses the data in the receive buffer, and attempts to be smart about it,
487 /// using the last send command as guidance for what to expect in the
490 /// \returns bool true - packet was recognized and parse was attempted
491 /// false - packet was not recognized
493 bool DBPacket::Parse(Parser
&parser
, const IConverter
*ic
)
496 MAKE_PACKET(rpack
, m_receive
);
498 switch( m_last_dbop
)
500 case SB_DBOP_OLD_GET_RECORDS
:
501 case SB_DBOP_GET_RECORD_BY_INDEX
:
504 offset
= SB_PACKET_RESPONSE_HEADER_SIZE
+ DBR_OLD_TAGGED_RECORD_HEADER_SIZE
;
505 Protocol::CheckSize(m_receive
, offset
);
506 // FIXME - this may need adjustment for email records... they
507 // don't seem to have uniqueID's
508 parser
.SetIds(rpack
->u
.db
.u
.response
.u
.tagged
.rectype
,
509 btohl(rpack
->u
.db
.u
.response
.u
.tagged
.uniqueId
));
511 parser
.ParseHeader(m_receive
, offset
);
512 parser
.ParseFields(m_receive
, offset
, ic
);
516 default: // unknown command
523 //////////////////////////////////////////////////////////////////////////////
526 JLPacket::JLPacket(Data
&cmd
, Data
&send
, Data
&receive
)
527 : Packet(send
, receive
)
534 JLPacket::~JLPacket()
538 unsigned int JLPacket::Size()
540 Protocol::CheckSize(m_receive
, SB_JLPACKET_HEADER_SIZE
+ SB_JLRESPONSE_HEADER_SIZE
);
541 MAKE_JLPACKET(rpack
, m_receive
);
542 return btohs(rpack
->u
.response
.expect
);
546 // returns 1 or 2 depending on whether cmd or cmd+send are available
547 int JLPacket::SimpleCmd(uint8_t cmd
, uint8_t unknown
, uint16_t size
)
549 MAKE_JLPACKETPTR_BUF(cpack
, m_cmd
.GetBuffer(8));
550 Protocol::JLPacket
&packet
= *cpack
;
552 // socket class sets socket for us
553 packet
.size
= htobs(8);
554 packet
.u
.command
.command
= cmd
;
555 packet
.u
.command
.unknown
= unknown
;
556 packet
.u
.command
.size
= htobs(size
);
558 m_cmd
.ReleaseBuffer(8);
560 return m_last_set_size
= 1;
563 int JLPacket::SimpleData(const void *data
, uint16_t size
)
565 uint16_t total
= size
+ 4;
567 MAKE_JLPACKETPTR_BUF(dpack
, m_data
.GetBuffer(total
));
569 // socket class sets socket for us
570 dpack
->size
= htobs(total
);
571 memcpy(dpack
->u
.raw
, data
, size
);
573 m_data
.ReleaseBuffer(total
);
575 return m_last_set_size
= 2;
578 int JLPacket::BigEndianData(uint16_t value
)
580 value
= be_htobs(value
);
581 return SimpleData(&value
, sizeof(value
));
584 int JLPacket::BigEndianData(uint32_t value
)
586 value
= be_htobl(value
);
587 return SimpleData(&value
, sizeof(value
));
590 int JLPacket::SetUnknown1()
592 SimpleCmd(SB_COMMAND_JL_SET_UNKNOWN1
, 0, 1);
594 return SimpleData(&arg
, 1);
597 int JLPacket::SetCodFilename(const std::string
&filename
)
599 SimpleCmd(SB_COMMAND_JL_SET_COD_FILENAME
, 0, filename
.size());
600 return SimpleData(filename
.data(), filename
.size());
603 int JLPacket::SetCodSize(off_t size
)
605 SimpleCmd(SB_COMMAND_JL_SET_COD_SIZE
, 1, 4);
606 return BigEndianData((uint32_t)size
);
609 int JLPacket::SetTime(time_t when
)
611 SimpleCmd(SB_COMMAND_JL_SET_TIME
, 0, 4);
612 return BigEndianData((uint32_t)when
);
615 int JLPacket::GetSubDir(uint16_t id
)
617 SimpleCmd(SB_COMMAND_JL_GET_SUBDIR
, 0, 2);
618 return BigEndianData(id
);
621 int JLPacket::GetDirEntry(uint8_t entry_cmd
, uint16_t id
)
623 SimpleCmd(entry_cmd
, 0, 2);
624 return BigEndianData(id
);
627 int JLPacket::GetScreenshot()
629 SimpleCmd(SB_COMMAND_JL_GET_SCREENSHOT
, 0, 4);
630 return BigEndianData((uint32_t) 0);
633 int JLPacket::Erase(uint16_t cmd
, uint16_t id
)
635 SimpleCmd(cmd
, 0, 2);
636 return BigEndianData(id
);
639 int JLPacket::GetEventlogEntry(uint16_t entry_num
)
641 SimpleCmd(SB_COMMAND_JL_GET_LOG_ENTRY
, 0, 2);
642 return BigEndianData(entry_num
);
645 int JLPacket::SaveModule(uint16_t id
)
647 SimpleCmd(SB_COMMAND_JL_SAVE_MODULE
, 0, 2);
648 return BigEndianData(id
);
651 int JLPacket::PutData(const void *data
, uint16_t size
)
653 SimpleCmd(SB_COMMAND_JL_SEND_DATA
, 0, size
);
654 return SimpleData(data
, size
);
658 //////////////////////////////////////////////////////////////////////////////
661 JVMPacket::JVMPacket(Data
&send
, Data
&receive
)
662 : Packet(send
, receive
)
667 JVMPacket::~JVMPacket()
672 unsigned int JVMPacket::Size()
674 MAKE_JVMPACKET(rpack
, m_receive
);
675 Protocol::CheckSize(m_receive
, SB_JVMPACKET_HEADER_SIZE
+ sizeof(rpack
->u
.expect
));
676 return be_btohs(rpack
->u
.expect
);
680 // Command format (param is optionnal) :
681 // 00000000: 05 00 07 00 00 01 8a
683 // ^^^^^ : size of commd + param
684 // ^^^^^ : packet size
686 void JVMPacket::SimpleCmd(uint8_t cmd
)
688 // 4 : socket id field + packet size field
691 const uint16_t total
= 4 + 2 + 1;
693 MAKE_JVMPACKETPTR_BUF(cpack
, m_cmd
.GetBuffer(total
));
694 Protocol::JVMPacket
&packet
= *cpack
;
696 // socket class sets socket for us
697 packet
.size
= htobs(total
);
698 packet
.u
.command
.size
= be_htobs(1);
699 packet
.u
.command
.command
= cmd
;
701 m_cmd
.ReleaseBuffer(total
);
704 // Command with parameter format :
705 // 00000000: 05 00 0b 00 00 05 8d 00 00 00 00
706 // ^^^^^^^^^^^ : param
708 // ^^^^^ : size of commd + param
709 // ^^^^^ : packet size
711 void JVMPacket::ComplexCmd(uint8_t cmd
, const void *param
, uint16_t size
)
713 // 4 : socket id field + packet size field
716 uint16_t total
= 4 + 2 + 1 + size
;
718 MAKE_JVMPACKETPTR_BUF(cpack
, m_cmd
.GetBuffer(total
));
719 Protocol::JVMPacket
&packet
= *cpack
;
721 // socket class sets socket for us
722 packet
.size
= htobs(total
);
723 packet
.u
.command
.size
= be_htobs(1 + size
);
724 packet
.u
.command
.command
= cmd
;
726 if ((size
> 0) && (param
!= NULL
))
727 memcpy(cpack
->u
.command
.raw
, param
, size
);
729 m_cmd
.ReleaseBuffer(total
);
733 void JVMPacket::Unknown01() {
734 SimpleCmd(SB_COMMAND_JVM_UNKNOWN01
);
738 void JVMPacket::Unknown02() {
739 SimpleCmd(SB_COMMAND_JVM_UNKNOWN02
);
743 void JVMPacket::Unknown03() {
744 SimpleCmd(SB_COMMAND_JVM_UNKNOWN03
);
748 void JVMPacket::Unknown04() {
749 SimpleCmd(SB_COMMAND_JVM_UNKNOWN04
);
753 void JVMPacket::Unknown05() {
754 SimpleCmd(SB_COMMAND_JVM_UNKNOWN05
);
758 void JVMPacket::Unknown06() {
761 ComplexCmd(SB_COMMAND_JVM_UNKNOWN06
, ¶m
, sizeof(param
));
765 void JVMPacket::Unknown07() {
768 ComplexCmd(SB_COMMAND_JVM_UNKNOWN07
, ¶m
, sizeof(param
));
772 void JVMPacket::Unknown08() {
775 ComplexCmd(SB_COMMAND_JVM_UNKNOWN08
, ¶m
, sizeof(param
));
779 void JVMPacket::Unknown09() {
780 uint32_t param
= be_htobl(0x09);
782 ComplexCmd(SB_COMMAND_JVM_UNKNOWN09
, ¶m
, sizeof(param
));
786 void JVMPacket::Unknown10() {
787 uint32_t param
= be_htobl(0x01);
789 ComplexCmd(SB_COMMAND_JVM_UNKNOWN10
, ¶m
, sizeof(param
));
793 void JVMPacket::Unknown11(uint32_t id
) {
796 ComplexCmd(SB_COMMAND_JVM_UNKNOWN11
, &id
, sizeof(id
));
800 void JVMPacket::Unknown12(uint32_t id
) {
803 ComplexCmd(SB_COMMAND_JVM_UNKNOWN12
, &id
, sizeof(id
));
807 void JVMPacket::Unknown13(uint32_t id
) {
810 ComplexCmd(SB_COMMAND_JVM_UNKNOWN13
, &id
, sizeof(id
));
814 void JVMPacket::Unknown14(uint32_t id
) {
817 ComplexCmd(SB_COMMAND_JVM_UNKNOWN14
, &id
, sizeof(id
));
821 void JVMPacket::Unknown15(uint32_t id
) {
824 ComplexCmd(SB_COMMAND_JVM_UNKNOWN15
, &id
, sizeof(id
));
828 void JVMPacket::GetModulesList(uint32_t id
) {
831 ComplexCmd(SB_COMMAND_JVM_GET_MODULES_LIST
, &id
, sizeof(id
));
835 void JVMPacket::GetThreadsList() {
836 SimpleCmd(SB_COMMAND_JVM_GET_THREADS_LIST
);
840 void JVMPacket::GetConsoleMessage() {
841 SimpleCmd(SB_COMMAND_JVM_GET_CONSOLE_MSG
);
847 SimpleCmd(SB_COMMAND_JVM_GO
);
851 void JVMPacket::Stop()
853 // 4 : socket id field + packet size field
855 const uint16_t total
= 4 + 2;
857 MAKE_JVMPACKETPTR_BUF(cpack
, m_cmd
.GetBuffer(total
));
858 Protocol::JVMPacket
&packet
= *cpack
;
860 // socket class sets socket for us
861 packet
.size
= htobs(total
);
862 packet
.u
.value
= be_htobs(SB_COMMAND_JVM_STOP
);
864 m_cmd
.ReleaseBuffer(total
);
868 void JVMPacket::GetStatus()
870 SimpleCmd(SB_COMMAND_JVM_GET_STATUS
);