src/packet.cc

   1 ///
   2 /// \file       packet.cc
   3 ///             Low level protocol packet builder class.
   4 ///             Has knowledge of specific protocol commands in order
   5 ///             to hide protocol details behind an API.
   6 ///
   7
   8 /*
   9     Copyright (C) 2005-2010, Net Direct Inc. (http://www.netdirect.ca/)
  10
  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.
  15
  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.
  19
  20     See the GNU General Public License in the COPYING file at the
  21     root directory of this project for more details.
  22 */
  23
  24 #include "packet.h"
  25 #include "m_desktop.h"
  26 #include "protocol.h"
  27 #include "protostructs.h"
  28 #include "data.h"
  29 #include "endian.h"
  30 #include "parser.h"
  31 #include "builder.h"
  32 #include "error.h"
  33 #include <string.h>
  34
  35 #define __DEBUG_MODE__
  36 #include "debug.h"
  37
  38
  39 namespace Barry {
  40
  41 //////////////////////////////////////////////////////////////////////////////
  42 // Packet base class
  43
  44 //
  45 // Command
  46 //
  47 /// Returns the command value of the receive packet.  If receive isn't
  48 /// large enough, throws Error.
  49 ///
  50 unsigned int Packet::Command() const
  51 {
  52         Protocol::CheckSize(m_receive, SB_PACKET_HEADER_SIZE);
  53         MAKE_PACKET(rpack, m_receive);
  54         return rpack->command;
  55 }
  56
  57
  58 //////////////////////////////////////////////////////////////////////////////
  59 // ZeroPacket class
  60
  61 ZeroPacket::ZeroPacket(Data &send, Data &receive)
  62         : Packet(send, receive)
  63 {
  64 }
  65
  66 ZeroPacket::~ZeroPacket()
  67 {
  68 }
  69
  70 //
  71 // GetAttribute
  72 //
  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.
  77 ///
  78 void ZeroPacket::GetAttribute(unsigned int object, unsigned int attribute)
  79 {
  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;
  83
  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);
  91
  92         m_send.ReleaseBuffer(size);
  93 }
  94
  95 //
  96 // Echo
  97 //
  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.
 101 ///
 102 void ZeroPacket::Echo(uint64_t us_ticks)
 103 {
 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;
 107
 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);
 113
 114         m_send.ReleaseBuffer(size);
 115 }
 116
 117 void ZeroPacket::Reset()
 118 {
 119         size_t size = SB_SOCKET_PACKET_HEADER_SIZE;
 120         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(size));
 121         Protocol::Packet &packet = *cpack;
 122
 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
 127
 128         m_send.ReleaseBuffer(size);
 129 }
 130
 131 unsigned int ZeroPacket::ObjectID() const
 132 {
 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);
 136 }
 137
 138 unsigned int ZeroPacket::AttributeID() const
 139 {
 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);
 143 }
 144
 145 uint32_t ZeroPacket::ChallengeSeed() const
 146 {
 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);
 151 }
 152
 153 unsigned int ZeroPacket::RemainingTries() const
 154 {
 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;
 160 }
 161
 162 unsigned int ZeroPacket::SocketResponse() const
 163 {
 164         Protocol::CheckSize(m_receive, SB_SOCKET_PACKET_HEADER_SIZE);
 165         MAKE_PACKET(rpack, m_receive);
 166         return btohs(rpack->u.socket.socket);
 167 }
 168
 169 unsigned char ZeroPacket::SocketSequence() const
 170 {
 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
 174 }
 175
 176 uint8_t ZeroPacket::CommandResponse() const
 177 {
 178         Protocol::CheckSize(m_receive, SB_SOCKET_PACKET_HEADER_SIZE);
 179         MAKE_PACKET(rpack, m_receive);
 180         return rpack->command;
 181 }
 182
 183
 184
 185 //////////////////////////////////////////////////////////////////////////////
 186 // DBPacket class
 187
 188 DBPacket::DBPacket(Mode::Desktop &con, Data &send, Data &receive)
 189         : Packet(send, receive)
 190         , m_con(con)
 191         , m_last_dbop(0)
 192 {
 193 }
 194
 195 DBPacket::~DBPacket()
 196 {
 197 }
 198
 199 //
 200 // ClearDatabase
 201 //
 202 /// Builds a command packet for the CLEAR_DATABASE command code, placing
 203 /// the data in the send buffer.
 204 ///
 205 void DBPacket::ClearDatabase(unsigned int dbId)
 206 {
 207         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(9));
 208         Protocol::Packet &packet = *cpack;
 209
 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);
 216
 217         m_send.ReleaseBuffer(9);
 218
 219         m_last_dbop = SB_DBOP_CLEAR_DATABASE;
 220 }
 221
 222 //
 223 // GetDBDB
 224 //
 225 /// Builds a command packet for the GET_DBDB command code, placing the
 226 /// data in m_send.
 227 ///
 228 void DBPacket::GetDBDB()
 229 {
 230         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(7));
 231         Protocol::Packet &packet = *cpack;
 232
 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;
 239
 240         m_send.ReleaseBuffer(7);
 241
 242         m_last_dbop = SB_DBOP_OLD_GET_DBDB;
 243 }
 244
 245 //
 246 // GetRecordStateTable
 247 //
 248 /// Builds a command packet in the send buffer for the
 249 /// GET_RECORD_STATE_TABLE command.
 250 ///
 251 void DBPacket::GetRecordStateTable(unsigned int dbId)
 252 {
 253         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(9));
 254         Protocol::Packet &packet = *cpack;
 255
 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);
 262
 263         m_send.ReleaseBuffer(9);
 264
 265         m_last_dbop = SB_DBOP_GET_RECORD_STATE_TABLE;
 266 }
 267
 268 //
 269 // SetRecordFlags
 270 //
 271 /// Builds a command packet in the send buffer for the SET_RECORD_FLAGS
 272 /// command code.
 273 ///
 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.
 277 ///
 278 void DBPacket::SetRecordFlags(unsigned int dbId, unsigned int stateTableIndex,
 279                             uint8_t flag1)
 280 {
 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;
 284
 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));
 294
 295         m_send.ReleaseBuffer(size);
 296
 297         m_last_dbop = SB_DBOP_SET_RECORD_FLAGS;
 298 }
 299
 300 //
 301 // DeleteRecordByIndex
 302 //
 303 /// Builds a command packet in the send buffer for the DELETE_RECORD_BY_INDEX
 304 /// command code.
 305 ///
 306 void DBPacket::DeleteRecordByIndex(unsigned int dbId, unsigned int stateTableIndex)
 307 {
 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;
 311
 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);
 319
 320         m_send.ReleaseBuffer(size);
 321
 322         m_last_dbop = SB_DBOP_DELETE_RECORD_BY_INDEX;
 323 }
 324
 325 //
 326 // GetRecordByIndex
 327 //
 328 /// Builds a command packet in the send buffer for the GET_RECORD_BY_INDEX
 329 /// command code.
 330 ///
 331 void DBPacket::GetRecordByIndex(unsigned int dbId, unsigned int stateTableIndex)
 332 {
 333         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(11));
 334         Protocol::Packet &packet = *cpack;
 335
 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);
 343
 344         m_send.ReleaseBuffer(11);
 345
 346         m_last_dbop = SB_DBOP_GET_RECORD_BY_INDEX;
 347 }
 348
 349 //
 350 // SetRecordByIndex
 351 //
 352 /// Builds a command packet in the m_send buffer for the SET_RECORD_BY_INDEX
 353 /// command code.
 354 ///
 355 /// \return     bool
 356 ///             - true means success
 357 ///             - false means no data available from Builder object
 358 ///
 359 bool DBPacket::SetRecordByIndex(unsigned int dbId, unsigned int stateTableIndex,
 360                               Builder &build, const IConverter *ic)
 361 {
 362         // get new data if available
 363         if( !build.Retrieve() )
 364                 return false;
 365
 366         // build packet data
 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();
 370
 371         // fill in the header values
 372         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(total_size));
 373         Protocol::Packet &packet = *cpack;
 374
 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);
 383
 384         m_send.ReleaseBuffer(total_size);
 385
 386         m_last_dbop = SB_DBOP_SET_RECORD_BY_INDEX;
 387         return true;
 388 }
 389
 390 //
 391 // GetRecords
 392 //
 393 /// Builds a command packet in the send buffer for the GET_RECORDS
 394 /// command code.
 395 ///
 396 void DBPacket::GetRecords(unsigned int dbId)
 397 {
 398         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(9));
 399         Protocol::Packet &packet = *cpack;
 400
 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);
 407
 408         m_send.ReleaseBuffer(9);
 409
 410         m_last_dbop = SB_DBOP_OLD_GET_RECORDS;
 411 }
 412
 413 //
 414 // SetRecord
 415 //
 416 /// Builds a command packet in the m_send buffer for the SET_RECORD command
 417 /// code.
 418 ///
 419 /// \return     bool
 420 ///             - true means success
 421 ///             - false means no data available from Builder object
 422 ///
 423 bool DBPacket::SetRecord(unsigned int dbId, Builder &build, const IConverter *ic)
 424 {
 425         // get new data if available
 426         if( !build.Retrieve() )
 427                 return false;
 428
 429         // build packet data
 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();
 434
 435         // fill in the header values
 436         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(total_size));
 437         Protocol::Packet &packet = *cpack;
 438
 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
 448
 449         m_send.ReleaseBuffer(total_size);
 450
 451         m_last_dbop = SB_DBOP_SET_RECORD;
 452         return true;
 453 }
 454
 455
 456 // throws FIXME if packet doesn't support it
 457 unsigned int DBPacket::ReturnCode() const
 458 {
 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;
 463         }
 464         else {
 465                 throw Error("Attempting to extract a return code from the wrong response packet type");
 466         }
 467 }
 468
 469 //
 470 // DBOperation
 471 //
 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.
 475 ///
 476 unsigned int DBPacket::DBOperation() const
 477 {
 478         Protocol::CheckSize(m_receive, SB_PACKET_RESPONSE_HEADER_SIZE);
 479         MAKE_PACKET(rpack, m_receive);
 480         return rpack->u.db.u.response.operation;
 481 }
 482
 483 //
 484 // Parse
 485 //
 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
 488 /// response.
 489 ///
 490 /// \returns    bool    true - packet was recognized and parse was attempted
 491 ///                     false - packet was not recognized
 492 ///
 493 bool DBPacket::Parse(Parser &parser, const std::string &dbname,
 494                         const IConverter *ic)
 495 {
 496         size_t offset = 0;
 497         MAKE_PACKET(rpack, m_receive);
 498
 499         switch( m_last_dbop )
 500         {
 501         case SB_DBOP_OLD_GET_RECORDS:
 502         case SB_DBOP_GET_RECORD_BY_INDEX:
 503                 parser.Clear();
 504
 505                 offset = SB_PACKET_RESPONSE_HEADER_SIZE + DBR_OLD_TAGGED_RECORD_HEADER_SIZE;
 506                 Protocol::CheckSize(m_receive, offset);
 507                 // FIXME - this may need adjustment for email records... they
 508                 // don't seem to have uniqueID's
 509                 parser.SetIds(dbname,
 510                         rpack->u.db.u.response.u.tagged.rectype,
 511                         btohl(rpack->u.db.u.response.u.tagged.uniqueId));
 512
 513                 parser.ParseHeader(m_receive, offset);
 514                 parser.ParseFields(m_receive, offset, ic);
 515                 parser.Store();
 516                 return true;
 517
 518         default:        // unknown command
 519                 return false;
 520         }
 521 }
 522
 523
 524
 525 //////////////////////////////////////////////////////////////////////////////
 526 // JLPacket class
 527
 528 JLPacket::JLPacket(Data &cmd, Data &send, Data &receive)
 529         : Packet(send, receive)
 530         , m_cmd(cmd)
 531         , m_data(send)
 532         , m_last_set_size(0)
 533 {
 534 }
 535
 536 JLPacket::~JLPacket()
 537 {
 538 }
 539
 540 unsigned int JLPacket::Size()
 541 {
 542         Protocol::CheckSize(m_receive, SB_JLPACKET_HEADER_SIZE + SB_JLRESPONSE_HEADER_SIZE);
 543         MAKE_JLPACKET(rpack, m_receive);
 544         return btohs(rpack->u.response.expect);
 545 }
 546
 547
 548 // returns 1 or 2 depending on whether cmd or cmd+send are available
 549 int JLPacket::SimpleCmd(uint8_t cmd, uint8_t unknown, uint16_t size)
 550 {
 551         MAKE_JLPACKETPTR_BUF(cpack, m_cmd.GetBuffer(8));
 552         Protocol::JLPacket &packet = *cpack;
 553
 554         // socket class sets socket for us
 555         packet.size = htobs(8);
 556         packet.u.command.command = cmd;
 557         packet.u.command.unknown = unknown;
 558         packet.u.command.size = htobs(size);
 559
 560         m_cmd.ReleaseBuffer(8);
 561
 562         return m_last_set_size = 1;
 563 }
 564
 565 int JLPacket::SimpleData(const void *data, uint16_t size)
 566 {
 567         uint16_t total = size + 4;
 568
 569         MAKE_JLPACKETPTR_BUF(dpack, m_data.GetBuffer(total));
 570
 571         // socket class sets socket for us
 572         dpack->size = htobs(total);
 573         memcpy(dpack->u.raw, data, size);
 574
 575         m_data.ReleaseBuffer(total);
 576
 577         return m_last_set_size = 2;
 578 }
 579
 580 int JLPacket::BigEndianData(uint16_t value)
 581 {
 582         value = be_htobs(value);
 583         return SimpleData(&value, sizeof(value));
 584 }
 585
 586 int JLPacket::BigEndianData(uint32_t value)
 587 {
 588         value = be_htobl(value);
 589         return SimpleData(&value, sizeof(value));
 590 }
 591
 592 int JLPacket::SetUnknown1()
 593 {
 594         SimpleCmd(SB_COMMAND_JL_SET_UNKNOWN1, 0, 1);
 595         uint8_t arg = 0;
 596         return SimpleData(&arg, 1);
 597 }
 598
 599 int JLPacket::SetCodFilename(const std::string &filename)
 600 {
 601         SimpleCmd(SB_COMMAND_JL_SET_COD_FILENAME, 0, filename.size());
 602         return SimpleData(filename.data(), filename.size());
 603 }
 604
 605 int JLPacket::SetCodSize(off_t size)
 606 {
 607         SimpleCmd(SB_COMMAND_JL_SET_COD_SIZE, 1, 4);
 608         return BigEndianData((uint32_t)size);
 609 }
 610
 611 int JLPacket::SetTime(time_t when)
 612 {
 613         SimpleCmd(SB_COMMAND_JL_SET_TIME, 0, 4);
 614         return BigEndianData((uint32_t)when);
 615 }
 616
 617 int JLPacket::GetSubDir(uint16_t id)
 618 {
 619         SimpleCmd(SB_COMMAND_JL_GET_SUBDIR, 0, 2);
 620         return BigEndianData(id);
 621 }
 622
 623 int JLPacket::GetDirEntry(uint8_t entry_cmd, uint16_t id)
 624 {
 625         SimpleCmd(entry_cmd, 0, 2);
 626         return BigEndianData(id);
 627 }
 628
 629 int JLPacket::GetScreenshot()
 630 {
 631         SimpleCmd(SB_COMMAND_JL_GET_SCREENSHOT, 0, 4);
 632         return BigEndianData((uint32_t) 0);
 633 }
 634
 635 int JLPacket::Erase(uint16_t cmd, uint16_t id)
 636 {
 637         SimpleCmd(cmd, 0, 2);
 638         return BigEndianData(id);
 639 }
 640
 641 int JLPacket::GetEventlogEntry(uint16_t entry_num)
 642 {
 643         SimpleCmd(SB_COMMAND_JL_GET_LOG_ENTRY, 0, 2);
 644         return BigEndianData(entry_num);
 645 }
 646
 647 int JLPacket::SaveModule(uint16_t id)
 648 {
 649         SimpleCmd(SB_COMMAND_JL_SAVE_MODULE, 0, 2);
 650         return BigEndianData(id);
 651 }
 652
 653 int JLPacket::PutData(const void *data, uint16_t size)
 654 {
 655         SimpleCmd(SB_COMMAND_JL_SEND_DATA, 0, size);
 656         return SimpleData(data, size);
 657 }
 658
 659
 660 //////////////////////////////////////////////////////////////////////////////
 661 // JVMPacket class
 662
 663 JVMPacket::JVMPacket(Data &send, Data &receive)
 664         : Packet(send, receive)
 665         , m_cmd(send)
 666 {
 667 }
 668
 669 JVMPacket::~JVMPacket()
 670 {
 671 }
 672
 673
 674 unsigned int JVMPacket::Size()
 675 {
 676         MAKE_JVMPACKET(rpack, m_receive);
 677         Protocol::CheckSize(m_receive, SB_JVMPACKET_HEADER_SIZE + sizeof(rpack->u.expect));
 678         return be_btohs(rpack->u.expect);
 679 }
 680
 681
 682 // Command format (param is optionnal) :
 683 // 00000000: 05 00 07 00 00 01 8a
 684 //                             ^^ : command
 685 //                       ^^^^^ : size of commd + param
 686 //                 ^^^^^ : packet size
 687 //           ^^^^^ : socket ID
 688 void JVMPacket::SimpleCmd(uint8_t cmd)
 689 {
 690         // 4 : socket id field + packet size field
 691         // 2 : size field
 692         // 1 : command field
 693         const uint16_t total = 4 + 2 + 1;
 694
 695         MAKE_JVMPACKETPTR_BUF(cpack, m_cmd.GetBuffer(total));
 696         Protocol::JVMPacket &packet = *cpack;
 697
 698         // socket class sets socket for us
 699         packet.size = htobs(total);
 700         packet.u.command.size = be_htobs(1);
 701         packet.u.command.command = cmd;
 702
 703         m_cmd.ReleaseBuffer(total);
 704 }
 705
 706 // Command with parameter format :
 707 // 00000000: 05 00 0b 00 00 05 8d 00 00 00 00
 708 //                                ^^^^^^^^^^^ : param
 709 //                             ^^ : command
 710 //                       ^^^^^ : size of commd + param
 711 //                 ^^^^^ : packet size
 712 //           ^^^^^ : socket ID
 713 void JVMPacket::ComplexCmd(uint8_t cmd, const void *param, uint16_t size)
 714 {
 715         // 4 : socket id field + packet size field
 716         // 2 : size field
 717         // 1 : command field
 718         uint16_t total = 4 + 2 + 1 + size;
 719
 720         MAKE_JVMPACKETPTR_BUF(cpack, m_cmd.GetBuffer(total));
 721         Protocol::JVMPacket &packet = *cpack;
 722
 723         // socket class sets socket for us
 724         packet.size = htobs(total);
 725         packet.u.command.size = be_htobs(1 + size);
 726         packet.u.command.command = cmd;
 727
 728         if ((size > 0) && (param != NULL))
 729                 memcpy(cpack->u.command.raw, param, size);
 730
 731         m_cmd.ReleaseBuffer(total);
 732 }
 733
 734
 735 void JVMPacket::Unknown01() {
 736         SimpleCmd(SB_COMMAND_JVM_UNKNOWN01);
 737 }
 738
 739
 740 void JVMPacket::Unknown02() {
 741         SimpleCmd(SB_COMMAND_JVM_UNKNOWN02);
 742 }
 743
 744
 745 void JVMPacket::Unknown03() {
 746         SimpleCmd(SB_COMMAND_JVM_UNKNOWN03);
 747 }
 748
 749
 750 void JVMPacket::Unknown04() {
 751         SimpleCmd(SB_COMMAND_JVM_UNKNOWN04);
 752 }
 753
 754
 755 void JVMPacket::Unknown05() {
 756         SimpleCmd(SB_COMMAND_JVM_UNKNOWN05);
 757 }
 758
 759
 760 void JVMPacket::Unknown06() {
 761         uint32_t param = 0;
 762
 763         ComplexCmd(SB_COMMAND_JVM_UNKNOWN06, &param, sizeof(param));
 764 }
 765
 766
 767 void JVMPacket::Unknown07() {
 768         uint32_t param = 0;
 769
 770         ComplexCmd(SB_COMMAND_JVM_UNKNOWN07, &param, sizeof(param));
 771 }
 772
 773
 774 void JVMPacket::Unknown08() {
 775         uint32_t param = 0;
 776
 777         ComplexCmd(SB_COMMAND_JVM_UNKNOWN08, &param, sizeof(param));
 778 }
 779
 780
 781 void JVMPacket::Unknown09() {
 782         uint32_t param = be_htobl(0x09);
 783
 784         ComplexCmd(SB_COMMAND_JVM_UNKNOWN09, &param, sizeof(param));
 785 }
 786
 787
 788 void JVMPacket::Unknown10() {
 789         uint32_t param = be_htobl(0x01);
 790
 791         ComplexCmd(SB_COMMAND_JVM_UNKNOWN10, &param, sizeof(param));
 792 }
 793
 794
 795 void JVMPacket::Unknown11(uint32_t id) {
 796         id = be_htobl(id);
 797
 798         ComplexCmd(SB_COMMAND_JVM_UNKNOWN11, &id, sizeof(id));
 799 }
 800
 801
 802 void JVMPacket::Unknown12(uint32_t id) {
 803         id = be_htobl(id);
 804
 805         ComplexCmd(SB_COMMAND_JVM_UNKNOWN12, &id, sizeof(id));
 806 }
 807
 808
 809 void JVMPacket::Unknown13(uint32_t id) {
 810         id = be_htobl(id);
 811
 812         ComplexCmd(SB_COMMAND_JVM_UNKNOWN13, &id, sizeof(id));
 813 }
 814
 815
 816 void JVMPacket::Unknown14(uint32_t id) {
 817         id = be_htobl(id);
 818
 819         ComplexCmd(SB_COMMAND_JVM_UNKNOWN14, &id, sizeof(id));
 820 }
 821
 822
 823 void JVMPacket::Unknown15(uint32_t id) {
 824         id = be_htobl(id);
 825
 826         ComplexCmd(SB_COMMAND_JVM_UNKNOWN15, &id, sizeof(id));
 827 }
 828
 829
 830 void JVMPacket::GetModulesList(uint32_t id) {
 831         id = be_htobl(id);
 832
 833         ComplexCmd(SB_COMMAND_JVM_GET_MODULES_LIST, &id, sizeof(id));
 834 }
 835
 836
 837 void JVMPacket::GetThreadsList() {
 838         SimpleCmd(SB_COMMAND_JVM_GET_THREADS_LIST);
 839 }
 840
 841
 842 void JVMPacket::GetConsoleMessage() {
 843         SimpleCmd(SB_COMMAND_JVM_GET_CONSOLE_MSG);
 844 }
 845
 846
 847 void JVMPacket::Go()
 848 {
 849         SimpleCmd(SB_COMMAND_JVM_GO);
 850 }
 851
 852
 853 void JVMPacket::Stop()
 854 {
 855         // 4 : socket id field + packet size field
 856         // 2 : value field
 857         const uint16_t total = 4 + 2;
 858
 859         MAKE_JVMPACKETPTR_BUF(cpack, m_cmd.GetBuffer(total));
 860         Protocol::JVMPacket &packet = *cpack;
 861
 862         // socket class sets socket for us
 863         packet.size = htobs(total);
 864         packet.u.value = be_htobs(SB_COMMAND_JVM_STOP);
 865
 866         m_cmd.ReleaseBuffer(total);
 867 }
 868
 869
 870 void JVMPacket::GetStatus()
 871 {
 872         SimpleCmd(SB_COMMAND_JVM_GET_STATUS);
 873 }
 874
 875 } // namespace Barry
 876