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 // ParseMeta
 525 //
 526 /// Fills DBData's meta data based on its data block, and the last dbop.
 527 ///
 528 bool DBPacket::ParseMeta(DBData &data)
 529 {
 530         size_t offset = 0;
 531         MAKE_PACKET(rpack, data.GetData());
 532
 533         switch( m_last_dbop )
 534         {
 535         case SB_DBOP_OLD_GET_RECORDS:
 536         case SB_DBOP_GET_RECORD_BY_INDEX:
 537                 data.SetVersion(DBData::REC_VERSION_1);
 538
 539                 offset = SB_PACKET_RESPONSE_HEADER_SIZE + DBR_OLD_TAGGED_RECORD_HEADER_SIZE;
 540                 Protocol::CheckSize(data.GetData(), offset);
 541                 data.SetOffset(offset);
 542
 543                 // FIXME - this may need adjustment for email records... they
 544                 // don't seem to have uniqueID's
 545                 data.SetIds(rpack->u.db.u.response.u.tagged.rectype,
 546                         btohl(rpack->u.db.u.response.u.tagged.uniqueId));
 547                 return true;
 548
 549         default:        // unknown command
 550                 return false;
 551         }
 552 }
 553
 554
 555
 556 //////////////////////////////////////////////////////////////////////////////
 557 // JLPacket class
 558
 559 JLPacket::JLPacket(Data &cmd, Data &send, Data &receive)
 560         : Packet(send, receive)
 561         , m_cmd(cmd)
 562         , m_data(send)
 563         , m_last_set_size(0)
 564 {
 565 }
 566
 567 JLPacket::~JLPacket()
 568 {
 569 }
 570
 571 unsigned int JLPacket::Size()
 572 {
 573         Protocol::CheckSize(m_receive, SB_JLPACKET_HEADER_SIZE + SB_JLRESPONSE_HEADER_SIZE);
 574         MAKE_JLPACKET(rpack, m_receive);
 575         return btohs(rpack->u.response.expect);
 576 }
 577
 578
 579 // returns 1 or 2 depending on whether cmd or cmd+send are available
 580 int JLPacket::SimpleCmd(uint8_t cmd, uint8_t unknown, uint16_t size)
 581 {
 582         MAKE_JLPACKETPTR_BUF(cpack, m_cmd.GetBuffer(8));
 583         Protocol::JLPacket &packet = *cpack;
 584
 585         // socket class sets socket for us
 586         packet.size = htobs(8);
 587         packet.u.command.command = cmd;
 588         packet.u.command.unknown = unknown;
 589         packet.u.command.size = htobs(size);
 590
 591         m_cmd.ReleaseBuffer(8);
 592
 593         return m_last_set_size = 1;
 594 }
 595
 596 int JLPacket::SimpleData(const void *data, uint16_t size)
 597 {
 598         uint16_t total = size + 4;
 599
 600         MAKE_JLPACKETPTR_BUF(dpack, m_data.GetBuffer(total));
 601
 602         // socket class sets socket for us
 603         dpack->size = htobs(total);
 604         memcpy(dpack->u.raw, data, size);
 605
 606         m_data.ReleaseBuffer(total);
 607
 608         return m_last_set_size = 2;
 609 }
 610
 611 int JLPacket::BigEndianData(uint16_t value)
 612 {
 613         value = be_htobs(value);
 614         return SimpleData(&value, sizeof(value));
 615 }
 616
 617 int JLPacket::BigEndianData(uint32_t value)
 618 {
 619         value = be_htobl(value);
 620         return SimpleData(&value, sizeof(value));
 621 }
 622
 623 int JLPacket::SetUnknown1()
 624 {
 625         SimpleCmd(SB_COMMAND_JL_SET_UNKNOWN1, 0, 1);
 626         uint8_t arg = 0;
 627         return SimpleData(&arg, 1);
 628 }
 629
 630 int JLPacket::SetCodFilename(const std::string &filename)
 631 {
 632         SimpleCmd(SB_COMMAND_JL_SET_COD_FILENAME, 0, filename.size());
 633         return SimpleData(filename.data(), filename.size());
 634 }
 635
 636 int JLPacket::SetCodSize(off_t size)
 637 {
 638         SimpleCmd(SB_COMMAND_JL_SET_COD_SIZE, 1, 4);
 639         return BigEndianData((uint32_t)size);
 640 }
 641
 642 int JLPacket::SetTime(time_t when)
 643 {
 644         SimpleCmd(SB_COMMAND_JL_SET_TIME, 0, 4);
 645         return BigEndianData((uint32_t)when);
 646 }
 647
 648 int JLPacket::GetSubDir(uint16_t id)
 649 {
 650         SimpleCmd(SB_COMMAND_JL_GET_SUBDIR, 0, 2);
 651         return BigEndianData(id);
 652 }
 653
 654 int JLPacket::GetDirEntry(uint8_t entry_cmd, uint16_t id)
 655 {
 656         SimpleCmd(entry_cmd, 0, 2);
 657         return BigEndianData(id);
 658 }
 659
 660 int JLPacket::GetScreenshot()
 661 {
 662         SimpleCmd(SB_COMMAND_JL_GET_SCREENSHOT, 0, 4);
 663         return BigEndianData((uint32_t) 0);
 664 }
 665
 666 int JLPacket::Erase(uint16_t cmd, uint16_t id)
 667 {
 668         SimpleCmd(cmd, 0, 2);
 669         return BigEndianData(id);
 670 }
 671
 672 int JLPacket::GetEventlogEntry(uint16_t entry_num)
 673 {
 674         SimpleCmd(SB_COMMAND_JL_GET_LOG_ENTRY, 0, 2);
 675         return BigEndianData(entry_num);
 676 }
 677
 678 int JLPacket::SaveModule(uint16_t id)
 679 {
 680         SimpleCmd(SB_COMMAND_JL_SAVE_MODULE, 0, 2);
 681         return BigEndianData(id);
 682 }
 683
 684 int JLPacket::PutData(const void *data, uint16_t size)
 685 {
 686         SimpleCmd(SB_COMMAND_JL_SEND_DATA, 0, size);
 687         return SimpleData(data, size);
 688 }
 689
 690
 691 //////////////////////////////////////////////////////////////////////////////
 692 // JVMPacket class
 693
 694 JVMPacket::JVMPacket(Data &send, Data &receive)
 695         : Packet(send, receive)
 696         , m_cmd(send)
 697 {
 698 }
 699
 700 JVMPacket::~JVMPacket()
 701 {
 702 }
 703
 704
 705 unsigned int JVMPacket::Size()
 706 {
 707         MAKE_JVMPACKET(rpack, m_receive);
 708         Protocol::CheckSize(m_receive, SB_JVMPACKET_HEADER_SIZE + sizeof(rpack->u.expect));
 709         return be_btohs(rpack->u.expect);
 710 }
 711
 712
 713 // Command format (param is optionnal) :
 714 // 00000000: 05 00 07 00 00 01 8a
 715 //                             ^^ : command
 716 //                       ^^^^^ : size of commd + param
 717 //                 ^^^^^ : packet size
 718 //           ^^^^^ : socket ID
 719 void JVMPacket::SimpleCmd(uint8_t cmd)
 720 {
 721         // 4 : socket id field + packet size field
 722         // 2 : size field
 723         // 1 : command field
 724         const uint16_t total = 4 + 2 + 1;
 725
 726         MAKE_JVMPACKETPTR_BUF(cpack, m_cmd.GetBuffer(total));
 727         Protocol::JVMPacket &packet = *cpack;
 728
 729         // socket class sets socket for us
 730         packet.size = htobs(total);
 731         packet.u.command.size = be_htobs(1);
 732         packet.u.command.command = cmd;
 733
 734         m_cmd.ReleaseBuffer(total);
 735 }
 736
 737 // Command with parameter format :
 738 // 00000000: 05 00 0b 00 00 05 8d 00 00 00 00
 739 //                                ^^^^^^^^^^^ : param
 740 //                             ^^ : command
 741 //                       ^^^^^ : size of commd + param
 742 //                 ^^^^^ : packet size
 743 //           ^^^^^ : socket ID
 744 void JVMPacket::ComplexCmd(uint8_t cmd, const void *param, uint16_t size)
 745 {
 746         // 4 : socket id field + packet size field
 747         // 2 : size field
 748         // 1 : command field
 749         uint16_t total = 4 + 2 + 1 + size;
 750
 751         MAKE_JVMPACKETPTR_BUF(cpack, m_cmd.GetBuffer(total));
 752         Protocol::JVMPacket &packet = *cpack;
 753
 754         // socket class sets socket for us
 755         packet.size = htobs(total);
 756         packet.u.command.size = be_htobs(1 + size);
 757         packet.u.command.command = cmd;
 758
 759         if ((size > 0) && (param != NULL))
 760                 memcpy(cpack->u.command.raw, param, size);
 761
 762         m_cmd.ReleaseBuffer(total);
 763 }
 764
 765
 766 void JVMPacket::Unknown01() {
 767         SimpleCmd(SB_COMMAND_JVM_UNKNOWN01);
 768 }
 769
 770
 771 void JVMPacket::Unknown02() {
 772         SimpleCmd(SB_COMMAND_JVM_UNKNOWN02);
 773 }
 774
 775
 776 void JVMPacket::Unknown03() {
 777         SimpleCmd(SB_COMMAND_JVM_UNKNOWN03);
 778 }
 779
 780
 781 void JVMPacket::Unknown04() {
 782         SimpleCmd(SB_COMMAND_JVM_UNKNOWN04);
 783 }
 784
 785
 786 void JVMPacket::Unknown05() {
 787         SimpleCmd(SB_COMMAND_JVM_UNKNOWN05);
 788 }
 789
 790
 791 void JVMPacket::Unknown06() {
 792         uint32_t param = 0;
 793
 794         ComplexCmd(SB_COMMAND_JVM_UNKNOWN06, &param, sizeof(param));
 795 }
 796
 797
 798 void JVMPacket::Unknown07() {
 799         uint32_t param = 0;
 800
 801         ComplexCmd(SB_COMMAND_JVM_UNKNOWN07, &param, sizeof(param));
 802 }
 803
 804
 805 void JVMPacket::Unknown08() {
 806         uint32_t param = 0;
 807
 808         ComplexCmd(SB_COMMAND_JVM_UNKNOWN08, &param, sizeof(param));
 809 }
 810
 811
 812 void JVMPacket::Unknown09() {
 813         uint32_t param = be_htobl(0x09);
 814
 815         ComplexCmd(SB_COMMAND_JVM_UNKNOWN09, &param, sizeof(param));
 816 }
 817
 818
 819 void JVMPacket::Unknown10() {
 820         uint32_t param = be_htobl(0x01);
 821
 822         ComplexCmd(SB_COMMAND_JVM_UNKNOWN10, &param, sizeof(param));
 823 }
 824
 825
 826 void JVMPacket::Unknown11(uint32_t id) {
 827         id = be_htobl(id);
 828
 829         ComplexCmd(SB_COMMAND_JVM_UNKNOWN11, &id, sizeof(id));
 830 }
 831
 832
 833 void JVMPacket::Unknown12(uint32_t id) {
 834         id = be_htobl(id);
 835
 836         ComplexCmd(SB_COMMAND_JVM_UNKNOWN12, &id, sizeof(id));
 837 }
 838
 839
 840 void JVMPacket::Unknown13(uint32_t id) {
 841         id = be_htobl(id);
 842
 843         ComplexCmd(SB_COMMAND_JVM_UNKNOWN13, &id, sizeof(id));
 844 }
 845
 846
 847 void JVMPacket::Unknown14(uint32_t id) {
 848         id = be_htobl(id);
 849
 850         ComplexCmd(SB_COMMAND_JVM_UNKNOWN14, &id, sizeof(id));
 851 }
 852
 853
 854 void JVMPacket::Unknown15(uint32_t id) {
 855         id = be_htobl(id);
 856
 857         ComplexCmd(SB_COMMAND_JVM_UNKNOWN15, &id, sizeof(id));
 858 }
 859
 860
 861 void JVMPacket::GetModulesList(uint32_t id) {
 862         id = be_htobl(id);
 863
 864         ComplexCmd(SB_COMMAND_JVM_GET_MODULES_LIST, &id, sizeof(id));
 865 }
 866
 867
 868 void JVMPacket::GetThreadsList() {
 869         SimpleCmd(SB_COMMAND_JVM_GET_THREADS_LIST);
 870 }
 871
 872
 873 void JVMPacket::GetConsoleMessage() {
 874         SimpleCmd(SB_COMMAND_JVM_GET_CONSOLE_MSG);
 875 }
 876
 877
 878 void JVMPacket::Go()
 879 {
 880         SimpleCmd(SB_COMMAND_JVM_GO);
 881 }
 882
 883
 884 void JVMPacket::Stop()
 885 {
 886         // 4 : socket id field + packet size field
 887         // 2 : value field
 888         const uint16_t total = 4 + 2;
 889
 890         MAKE_JVMPACKETPTR_BUF(cpack, m_cmd.GetBuffer(total));
 891         Protocol::JVMPacket &packet = *cpack;
 892
 893         // socket class sets socket for us
 894         packet.size = htobs(total);
 895         packet.u.value = be_htobs(SB_COMMAND_JVM_STOP);
 896
 897         m_cmd.ReleaseBuffer(total);
 898 }
 899
 900
 901 void JVMPacket::GetStatus()
 902 {
 903         SimpleCmd(SB_COMMAND_JVM_GET_STATUS);
 904 }
 905
 906 } // namespace Barry
 907