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-2013, 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 "i18n.h"
  25 #include "packet.h"
  26 #include "m_desktop.h"
  27 #include "protocol.h"
  28 #include "protostructs.h"
  29 #include "data.h"
  30 #include "endian.h"
  31 #include "parser.h"
  32 #include "builder.h"
  33 #include "error.h"
  34 #include <string.h>
  35
  36 #define __DEBUG_MODE__
  37 #include "debug.h"
  38
  39
  40 namespace Barry {
  41
  42 //////////////////////////////////////////////////////////////////////////////
  43 // Packet base class
  44
  45 //
  46 // Command
  47 //
  48 /// Returns the command value of the receive packet.  If receive isn't
  49 /// large enough, throws Error.
  50 ///
  51 unsigned int Packet::Command() const
  52 {
  53         Protocol::CheckSize(*m_receive, SB_PACKET_HEADER_SIZE);
  54         MAKE_PACKET(rpack, *m_receive);
  55         return rpack->command;
  56 }
  57
  58
  59 //////////////////////////////////////////////////////////////////////////////
  60 // ZeroPacket class
  61
  62 ZeroPacket::ZeroPacket(Data &send, Data &receive)
  63         : Packet(send, receive)
  64 {
  65 }
  66
  67 ZeroPacket::~ZeroPacket()
  68 {
  69 }
  70
  71 //
  72 // GetAttribute
  73 //
  74 /// Builds a command packet for the initial socket-0 handshakes
  75 /// that fetch certain (some unknown) attributes.  The attributes
  76 /// appear to exist in an object/attribute sequence, so that's
  77 /// how we address them here.
  78 ///
  79 void ZeroPacket::GetAttribute(unsigned int object, unsigned int attribute)
  80 {
  81         size_t size = SB_SOCKET_PACKET_HEADER_SIZE + ATTRIBUTE_FETCH_COMMAND_SIZE;
  82         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(size));
  83         Protocol::Packet &packet = *cpack;
  84
  85         // socket class sets socket for us
  86         packet.size = htobs(size);
  87         packet.command = SB_COMMAND_FETCH_ATTRIBUTE;
  88         packet.u.socket.socket = htobs(0x00ff); // default non-socket request
  89         packet.u.socket.sequence = 0;           // filled in by Socket class
  90         packet.u.socket.u.fetch.object = htobs(object);
  91         packet.u.socket.u.fetch.attribute = htobs(attribute);
  92
  93         m_send.ReleaseBuffer(size);
  94 }
  95
  96 //
  97 // Echo
  98 //
  99 /// Builds command packet for sending echo request.  The parameter
 100 /// to this command is the number of microseconds elapsed since host
 101 /// computer startup.
 102 ///
 103 void ZeroPacket::Echo(uint64_t us_ticks)
 104 {
 105         size_t size = SB_SOCKET_PACKET_HEADER_SIZE + ECHO_COMMAND_SIZE;
 106         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(size));
 107         Protocol::Packet &packet = *cpack;
 108
 109         packet.size = htobs(size);
 110         packet.command = SB_COMMAND_ECHO;
 111         packet.u.socket.socket = htobs(0x00ff); // default non-socket request
 112         packet.u.socket.sequence = 0;           // filled in by Socket class
 113         packet.u.socket.u.echo.ticks = htobl(us_ticks);
 114
 115         m_send.ReleaseBuffer(size);
 116 }
 117
 118 void ZeroPacket::Reset()
 119 {
 120         size_t size = SB_SOCKET_PACKET_HEADER_SIZE;
 121         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(size));
 122         Protocol::Packet &packet = *cpack;
 123
 124         packet.size = htobs(size);
 125         packet.command = SB_COMMAND_RESET;
 126         packet.u.socket.socket = htobs(0x00ff); // default non-socket request
 127         packet.u.socket.sequence = 0;           // filled in by Socket class
 128
 129         m_send.ReleaseBuffer(size);
 130 }
 131
 132 unsigned int ZeroPacket::ObjectID() const
 133 {
 134         Protocol::CheckSize(*m_receive, SB_SOCKET_PACKET_HEADER_SIZE);
 135         MAKE_PACKET(rpack, *m_receive);
 136         return btohs(rpack->u.socket.u.fetch.object);
 137 }
 138
 139 unsigned int ZeroPacket::AttributeID() const
 140 {
 141         Protocol::CheckSize(*m_receive, SB_SOCKET_PACKET_HEADER_SIZE);
 142         MAKE_PACKET(rpack, *m_receive);
 143         return btohs(rpack->u.socket.u.fetch.attribute);
 144 }
 145
 146 uint32_t ZeroPacket::ChallengeSeed() const
 147 {
 148         Protocol::CheckSize(*m_receive, SB_SOCKET_PACKET_HEADER_SIZE +
 149                 PASSWORD_CHALLENGE_SEED_SIZE);
 150         MAKE_PACKET(rpack, *m_receive);
 151         return btohl(rpack->u.socket.u.password.u.seed);
 152 }
 153
 154 unsigned int ZeroPacket::RemainingTries() const
 155 {
 156         Protocol::CheckSize(*m_receive, SB_SOCKET_PACKET_HEADER_SIZE +
 157                 PASSWORD_CHALLENGE_HEADER_SIZE);
 158         MAKE_PACKET(rpack, *m_receive);
 159         // this is a byte, so no byte swapping needed
 160         return rpack->u.socket.u.password.remaining_tries;
 161 }
 162
 163 unsigned int ZeroPacket::SocketResponse() const
 164 {
 165         Protocol::CheckSize(*m_receive, SB_SOCKET_PACKET_HEADER_SIZE);
 166         MAKE_PACKET(rpack, *m_receive);
 167         return btohs(rpack->u.socket.socket);
 168 }
 169
 170 unsigned char ZeroPacket::SocketSequence() const
 171 {
 172         Protocol::CheckSize(*m_receive, SB_SOCKET_PACKET_HEADER_SIZE);
 173         MAKE_PACKET(rpack, *m_receive);
 174         return rpack->u.socket.sequence;        // sequence is a byte
 175 }
 176
 177 uint8_t ZeroPacket::CommandResponse() const
 178 {
 179         Protocol::CheckSize(*m_receive, SB_SOCKET_PACKET_HEADER_SIZE);
 180         MAKE_PACKET(rpack, *m_receive);
 181         return rpack->command;
 182 }
 183
 184
 185
 186 //////////////////////////////////////////////////////////////////////////////
 187 // DBPacket class
 188
 189 DBPacket::DBPacket(Mode::Desktop &con, Data &send, Data &receive)
 190         : Packet(send, receive)
 191         , m_con(con)
 192         , m_last_dbop(0)
 193 {
 194 }
 195
 196 DBPacket::~DBPacket()
 197 {
 198 }
 199
 200 //
 201 // ClearDatabase
 202 //
 203 /// Builds a command packet for the CLEAR_DATABASE command code, placing
 204 /// the data in the send buffer.
 205 ///
 206 void DBPacket::ClearDatabase(unsigned int dbId)
 207 {
 208         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(9));
 209         Protocol::Packet &packet = *cpack;
 210
 211         // socket class sets socket for us
 212         packet.size = htobs(9);
 213         packet.command = SB_COMMAND_DB_DATA;
 214         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 215         packet.u.db.u.command.operation = SB_DBOP_CLEAR_DATABASE;
 216         packet.u.db.u.command.databaseId = htobs(dbId);
 217
 218         m_send.ReleaseBuffer(9);
 219
 220         m_last_dbop = SB_DBOP_CLEAR_DATABASE;
 221 }
 222
 223 //
 224 // GetDBDB
 225 //
 226 /// Builds a command packet for the GET_DBDB command code, placing the
 227 /// data in m_send.
 228 ///
 229 void DBPacket::GetDBDB()
 230 {
 231         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(7));
 232         Protocol::Packet &packet = *cpack;
 233
 234         // socket class sets socket for us
 235         packet.size = htobs(7);
 236         packet.command = SB_COMMAND_DB_DATA;
 237         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 238 //      packet.u.db.u.command.operation = SB_DBOP_GET_DBDB;
 239         packet.u.db.u.command.operation = SB_DBOP_OLD_GET_DBDB;
 240
 241         m_send.ReleaseBuffer(7);
 242
 243         m_last_dbop = SB_DBOP_OLD_GET_DBDB;
 244 }
 245
 246 //
 247 // GetRecordStateTable
 248 //
 249 /// Builds a command packet in the send buffer for the
 250 /// GET_RECORD_STATE_TABLE command.
 251 ///
 252 void DBPacket::GetRecordStateTable(unsigned int dbId)
 253 {
 254         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(9));
 255         Protocol::Packet &packet = *cpack;
 256
 257         // socket class sets socket for us
 258         packet.size = htobs(9);
 259         packet.command = SB_COMMAND_DB_DATA;
 260         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 261         packet.u.db.u.command.operation = SB_DBOP_GET_RECORD_STATE_TABLE;
 262         packet.u.db.u.command.databaseId = htobs(dbId);
 263
 264         m_send.ReleaseBuffer(9);
 265
 266         m_last_dbop = SB_DBOP_GET_RECORD_STATE_TABLE;
 267 }
 268
 269 //
 270 // SetRecordFlags
 271 //
 272 /// Builds a command packet in the send buffer for the SET_RECORD_FLAGS
 273 /// command code.
 274 ///
 275 /// FIXME - this API call is incomplete, since there are unknown flags
 276 ///         in the SetRecordFlags protocol packet.  Currently it is only
 277 ///         used to set all flags to zero.
 278 ///
 279 void DBPacket::SetRecordFlags(unsigned int dbId, unsigned int stateTableIndex,
 280                             uint8_t flag1)
 281 {
 282         size_t size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_RECORD_FLAGS_SIZE;
 283         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(size));
 284         Protocol::Packet &packet = *cpack;
 285
 286         // socket class sets socket for us
 287         packet.size = htobs(size);
 288         packet.command = SB_COMMAND_DB_DATA;
 289         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 290         packet.u.db.u.command.operation = SB_DBOP_SET_RECORD_FLAGS;
 291         packet.u.db.u.command.databaseId = htobs(dbId);
 292         packet.u.db.u.command.u.flags.unknown = flag1;
 293         packet.u.db.u.command.u.flags.index = htobs(stateTableIndex);
 294         memset(packet.u.db.u.command.u.flags.unknown2, 0, sizeof(packet.u.db.u.command.u.flags.unknown2));
 295
 296         m_send.ReleaseBuffer(size);
 297
 298         m_last_dbop = SB_DBOP_SET_RECORD_FLAGS;
 299 }
 300
 301 //
 302 // DeleteRecordByIndex
 303 //
 304 /// Builds a command packet in the send buffer for the DELETE_RECORD_BY_INDEX
 305 /// command code.
 306 ///
 307 void DBPacket::DeleteRecordByIndex(unsigned int dbId, unsigned int stateTableIndex)
 308 {
 309         size_t size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_RECORD_HEADER_SIZE;
 310         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(size));
 311         Protocol::Packet &packet = *cpack;
 312
 313         // socket class sets socket for us
 314         packet.size = htobs(size);
 315         packet.command = SB_COMMAND_DB_DATA;
 316         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 317         packet.u.db.u.command.operation = SB_DBOP_DELETE_RECORD_BY_INDEX;
 318         packet.u.db.u.command.databaseId = htobs(dbId);
 319         packet.u.db.u.command.u.record.recordIndex = htobs(stateTableIndex);
 320
 321         m_send.ReleaseBuffer(size);
 322
 323         m_last_dbop = SB_DBOP_DELETE_RECORD_BY_INDEX;
 324 }
 325
 326 //
 327 // GetRecordByIndex
 328 //
 329 /// Builds a command packet in the send buffer for the GET_RECORD_BY_INDEX
 330 /// command code.
 331 ///
 332 void DBPacket::GetRecordByIndex(unsigned int dbId, unsigned int stateTableIndex)
 333 {
 334         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(11));
 335         Protocol::Packet &packet = *cpack;
 336
 337         // socket class sets socket for us
 338         packet.size = htobs(11);
 339         packet.command = SB_COMMAND_DB_DATA;
 340         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 341         packet.u.db.u.command.operation = SB_DBOP_GET_RECORD_BY_INDEX;
 342         packet.u.db.u.command.databaseId = htobs(dbId);
 343         packet.u.db.u.command.u.record.recordIndex = htobs(stateTableIndex);
 344
 345         m_send.ReleaseBuffer(11);
 346
 347         m_last_dbop = SB_DBOP_GET_RECORD_BY_INDEX;
 348 }
 349
 350 //
 351 // SetRecordByIndex
 352 //
 353 /// Builds a command packet in the m_send buffer for the SET_RECORD_BY_INDEX
 354 /// command code.
 355 ///
 356 /// \return     bool
 357 ///             - true means success
 358 ///             - false means no data available from Builder object
 359 ///
 360 bool DBPacket::SetRecordByIndex(unsigned int dbId, unsigned int stateTableIndex,
 361                               Builder &build, const IConverter *ic)
 362 {
 363         // build packet data
 364         DBData send(m_send, false);     // send is just a reference to m_send,
 365                                         // so it is safe to use m_send later
 366
 367         size_t header_size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_INDEXED_UPLOAD_HEADER_SIZE;
 368         if( !build.BuildRecord(send, header_size, ic) )
 369                 return false;           // no data available
 370         size_t total_size = m_send.GetSize();
 371
 372         // fill in the header values
 373         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(total_size));
 374         Protocol::Packet &packet = *cpack;
 375
 376         // socket class sets socket for us
 377         packet.size = htobs(total_size);
 378         packet.command = SB_COMMAND_DB_DATA;
 379         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 380         packet.u.db.u.command.operation = SB_DBOP_SET_RECORD_BY_INDEX;
 381         packet.u.db.u.command.databaseId = htobs(dbId);
 382         packet.u.db.u.command.u.index_upload.unknown = 0;
 383         packet.u.db.u.command.u.index_upload.index = htobs(stateTableIndex);
 384
 385         m_send.ReleaseBuffer(total_size);
 386
 387         m_last_dbop = SB_DBOP_SET_RECORD_BY_INDEX;
 388         return true;
 389 }
 390
 391 //
 392 // GetRecords
 393 //
 394 /// Builds a command packet in the send buffer for the GET_RECORDS
 395 /// command code.
 396 ///
 397 void DBPacket::GetRecords(unsigned int dbId)
 398 {
 399         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(9));
 400         Protocol::Packet &packet = *cpack;
 401
 402         // socket class sets socket for us
 403         packet.size = htobs(9);
 404         packet.command = SB_COMMAND_DB_DATA;
 405         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 406         packet.u.db.u.command.operation = SB_DBOP_OLD_GET_RECORDS;
 407         packet.u.db.u.command.databaseId = htobs(dbId);
 408
 409         m_send.ReleaseBuffer(9);
 410
 411         m_last_dbop = SB_DBOP_OLD_GET_RECORDS;
 412 }
 413
 414 //
 415 // AddRecord
 416 //
 417 /// Builds a command packet in the m_send buffer for the ADD_RECORD command
 418 /// code.
 419 ///
 420 /// \return     bool
 421 ///             - true means success
 422 ///             - false means no data available from Builder object
 423 ///
 424 bool DBPacket::AddRecord(unsigned int dbId, Builder &build, const IConverter *ic)
 425 {
 426         // build packet data
 427         DBData send(m_send, false);     // send is just a reference to m_send,
 428                                         // so it is safe to use m_send later
 429
 430         size_t header_size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_TAGGED_UPLOAD_HEADER_SIZE;
 431         if( !build.BuildRecord(send, header_size, ic) )
 432                 return false;           // no data available
 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_ADD_RECORD;
 444         packet.u.db.u.command.databaseId = htobs(dbId);
 445         packet.u.db.u.command.u.tag_upload.rectype = send.GetRecType();
 446         packet.u.db.u.command.u.tag_upload.uniqueId = htobl(send.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_ADD_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                 offset = SB_PACKET_RESPONSE_HEADER_SIZE + DBR_OLD_TAGGED_RECORD_HEADER_SIZE;
 504                 Protocol::CheckSize(*m_receive, offset);
 505
 506                 // FIXME - this may need adjustment for email records... they
 507                 // don't seem to have uniqueID's
 508                 {
 509                         DBData block(DBData::REC_VERSION_1, dbname,
 510                                 rpack->u.db.u.response.u.tagged.rectype,
 511                                 btohl(rpack->u.db.u.response.u.tagged.uniqueId),
 512                                 offset, *m_receive, false);
 513                         parser.ParseRecord(block, ic);
 514                 }
 515                 return true;
 516
 517         default:        // unknown command
 518                 return false;
 519         }
 520 }
 521
 522 //
 523 // ParseMeta
 524 //
 525 /// Fills DBData's meta data based on its data block, and the last dbop.
 526 ///
 527 bool DBPacket::ParseMeta(DBData &data)
 528 {
 529         size_t offset = 0;
 530         MAKE_PACKET(rpack, data.GetData());
 531
 532         switch( m_last_dbop )
 533         {
 534         case SB_DBOP_OLD_GET_RECORDS:
 535         case SB_DBOP_GET_RECORD_BY_INDEX:
 536                 data.SetVersion(DBData::REC_VERSION_1);
 537
 538                 offset = SB_PACKET_RESPONSE_HEADER_SIZE + DBR_OLD_TAGGED_RECORD_HEADER_SIZE;
 539                 Protocol::CheckSize(data.GetData(), offset);
 540                 data.SetOffset(offset);
 541
 542                 // FIXME - this may need adjustment for email records... they
 543                 // don't seem to have uniqueID's
 544                 data.SetIds(rpack->u.db.u.response.u.tagged.rectype,
 545                         btohl(rpack->u.db.u.response.u.tagged.uniqueId));
 546                 return true;
 547
 548         default:        // unknown command
 549                 return false;
 550         }
 551 }
 552
 553
 554
 555 //////////////////////////////////////////////////////////////////////////////
 556 // JLPacket class
 557
 558 JLPacket::JLPacket(Data &cmd, Data &send, Data &receive)
 559         : Packet(send, receive)
 560         , m_cmd(cmd)
 561         , m_data(send)
 562         , m_last_set_size(0)
 563 {
 564 }
 565
 566 JLPacket::~JLPacket()
 567 {
 568 }
 569
 570 unsigned int JLPacket::Size()
 571 {
 572         Protocol::CheckSize(*m_receive, SB_JLPACKET_HEADER_SIZE + SB_JLRESPONSE_HEADER_SIZE);
 573         MAKE_JLPACKET(rpack, *m_receive);
 574         return btohs(rpack->u.response.expect);
 575 }
 576
 577
 578 // returns 1 or 2 depending on whether cmd or cmd+send are available
 579 int JLPacket::SimpleCmd(uint8_t cmd, uint8_t unknown, uint16_t size)
 580 {
 581         MAKE_JLPACKETPTR_BUF(cpack, m_cmd.GetBuffer(8));
 582         Protocol::JLPacket &packet = *cpack;
 583
 584         // socket class sets socket for us
 585         packet.size = htobs(8);
 586         packet.u.command.command = cmd;
 587         packet.u.command.unknown = unknown;
 588         packet.u.command.size = htobs(size);
 589
 590         m_cmd.ReleaseBuffer(8);
 591
 592         return m_last_set_size = 1;
 593 }
 594
 595 int JLPacket::SimpleData(const void *data, uint16_t size)
 596 {
 597         uint16_t total = size + 4;
 598
 599         MAKE_JLPACKETPTR_BUF(dpack, m_data.GetBuffer(total));
 600
 601         // socket class sets socket for us
 602         dpack->size = htobs(total);
 603         memcpy(dpack->u.raw, data, size);
 604
 605         m_data.ReleaseBuffer(total);
 606
 607         return m_last_set_size = 2;
 608 }
 609
 610 int JLPacket::BigEndianData(uint16_t value)
 611 {
 612         value = be_htobs(value);
 613         return SimpleData(&value, sizeof(value));
 614 }
 615
 616 int JLPacket::BigEndianData(uint32_t value)
 617 {
 618         value = be_htobl(value);
 619         return SimpleData(&value, sizeof(value));
 620 }
 621
 622 int JLPacket::SetUnknown1()
 623 {
 624         SimpleCmd(SB_COMMAND_JL_SET_UNKNOWN1, 0, 1);
 625         uint8_t arg = 0;
 626         return SimpleData(&arg, 1);
 627 }
 628
 629 int JLPacket::SetCodFilename(const std::string &filename)
 630 {
 631         SimpleCmd(SB_COMMAND_JL_SET_COD_FILENAME, 0, filename.size());
 632         return SimpleData(filename.data(), filename.size());
 633 }
 634
 635 int JLPacket::SetCodSize(off_t size)
 636 {
 637         SimpleCmd(SB_COMMAND_JL_SET_COD_SIZE, 1, 4);
 638         return BigEndianData((uint32_t)size);
 639 }
 640
 641 int JLPacket::SetTime(time_t when)
 642 {
 643         SimpleCmd(SB_COMMAND_JL_SET_TIME, 0, 4);
 644         return BigEndianData((uint32_t)when);
 645 }
 646
 647 int JLPacket::GetSubDir(uint16_t id)
 648 {
 649         SimpleCmd(SB_COMMAND_JL_GET_SUBDIR, 0, 2);
 650         return BigEndianData(id);
 651 }
 652
 653 int JLPacket::GetDirEntry(uint8_t entry_cmd, uint16_t id)
 654 {
 655         SimpleCmd(entry_cmd, 0, 2);
 656         return BigEndianData(id);
 657 }
 658
 659 int JLPacket::GetScreenshot()
 660 {
 661         SimpleCmd(SB_COMMAND_JL_GET_SCREENSHOT, 0, 4);
 662         return BigEndianData((uint32_t) 0);
 663 }
 664
 665 int JLPacket::Erase(uint16_t cmd, uint16_t id)
 666 {
 667         SimpleCmd((uint8_t)cmd, 0, 2);
 668         return BigEndianData(id);
 669 }
 670
 671 int JLPacket::GetEventlogEntry(uint16_t entry_num)
 672 {
 673         SimpleCmd(SB_COMMAND_JL_GET_LOG_ENTRY, 0, 2);
 674         return BigEndianData(entry_num);
 675 }
 676
 677 int JLPacket::SaveModule(uint16_t id)
 678 {
 679         SimpleCmd(SB_COMMAND_JL_SAVE_MODULE, 0, 2);
 680         return BigEndianData(id);
 681 }
 682
 683 int JLPacket::PutData(const void *data, uint16_t size)
 684 {
 685         SimpleCmd(SB_COMMAND_JL_SEND_DATA, 0, size);
 686         return SimpleData(data, size);
 687 }
 688
 689
 690 //////////////////////////////////////////////////////////////////////////////
 691 // JVMPacket class
 692
 693 JVMPacket::JVMPacket(Data &send, Data &receive)
 694         : Packet(send, receive)
 695         , m_cmd(send)
 696 {
 697 }
 698
 699 JVMPacket::~JVMPacket()
 700 {
 701 }
 702
 703
 704 unsigned int JVMPacket::Size()
 705 {
 706         MAKE_JVMPACKET(rpack, *m_receive);
 707         Protocol::CheckSize(*m_receive, SB_JVMPACKET_HEADER_SIZE + sizeof(rpack->u.expect));
 708         return be_btohs(rpack->u.expect);
 709 }
 710
 711
 712 // Command format (param is optionnal) :
 713 // 00000000: 05 00 07 00 00 01 8a
 714 //                             ^^ : command
 715 //                       ^^^^^ : size of commd + param
 716 //                 ^^^^^ : packet size
 717 //           ^^^^^ : socket ID
 718 void JVMPacket::SimpleCmd(uint8_t cmd)
 719 {
 720         // 4 : socket id field + packet size field
 721         // 2 : size field
 722         // 1 : command field
 723         const uint16_t total = 4 + 2 + 1;
 724
 725         MAKE_JVMPACKETPTR_BUF(cpack, m_cmd.GetBuffer(total));
 726         Protocol::JVMPacket &packet = *cpack;
 727
 728         // socket class sets socket for us
 729         packet.size = htobs(total);
 730         packet.u.command.size = be_htobs(1);
 731         packet.u.command.command = cmd;
 732
 733         m_cmd.ReleaseBuffer(total);
 734 }
 735
 736 // Command with parameter format :
 737 // 00000000: 05 00 0b 00 00 05 8d 00 00 00 00
 738 //                                ^^^^^^^^^^^ : param
 739 //                             ^^ : command
 740 //                       ^^^^^ : size of commd + param
 741 //                 ^^^^^ : packet size
 742 //           ^^^^^ : socket ID
 743 void JVMPacket::ComplexCmd(uint8_t cmd, const void *param, uint16_t size)
 744 {
 745         // 4 : socket id field + packet size field
 746         // 2 : size field
 747         // 1 : command field
 748         uint16_t total = 4 + 2 + 1 + size;
 749
 750         MAKE_JVMPACKETPTR_BUF(cpack, m_cmd.GetBuffer(total));
 751         Protocol::JVMPacket &packet = *cpack;
 752
 753         // socket class sets socket for us
 754         packet.size = htobs(total);
 755         packet.u.command.size = be_htobs(1 + size);
 756         packet.u.command.command = cmd;
 757
 758         if ((size > 0) && (param != NULL))
 759                 memcpy(cpack->u.command.raw, param, size);
 760
 761         m_cmd.ReleaseBuffer(total);
 762 }
 763
 764
 765 void JVMPacket::Unknown01() {
 766         SimpleCmd(SB_COMMAND_JVM_UNKNOWN01);
 767 }
 768
 769
 770 void JVMPacket::Unknown02() {
 771         SimpleCmd(SB_COMMAND_JVM_UNKNOWN02);
 772 }
 773
 774
 775 void JVMPacket::Unknown03() {
 776         SimpleCmd(SB_COMMAND_JVM_UNKNOWN03);
 777 }
 778
 779
 780 void JVMPacket::Unknown04() {
 781         SimpleCmd(SB_COMMAND_JVM_UNKNOWN04);
 782 }
 783
 784
 785 void JVMPacket::Unknown05() {
 786         SimpleCmd(SB_COMMAND_JVM_UNKNOWN05);
 787 }
 788
 789
 790 void JVMPacket::Unknown06() {
 791         uint32_t param = 0;
 792
 793         ComplexCmd(SB_COMMAND_JVM_UNKNOWN06, &param, sizeof(param));
 794 }
 795
 796
 797 void JVMPacket::Unknown07() {
 798         uint32_t param = 0;
 799
 800         ComplexCmd(SB_COMMAND_JVM_UNKNOWN07, &param, sizeof(param));
 801 }
 802
 803
 804 void JVMPacket::Unknown08() {
 805         uint32_t param = 0;
 806
 807         ComplexCmd(SB_COMMAND_JVM_UNKNOWN08, &param, sizeof(param));
 808 }
 809
 810
 811 void JVMPacket::Unknown09() {
 812         uint32_t param = be_htobl(0x09);
 813
 814         ComplexCmd(SB_COMMAND_JVM_UNKNOWN09, &param, sizeof(param));
 815 }
 816
 817
 818 void JVMPacket::Unknown10() {
 819         uint32_t param = be_htobl(0x01);
 820
 821         ComplexCmd(SB_COMMAND_JVM_UNKNOWN10, &param, sizeof(param));
 822 }
 823
 824
 825 void JVMPacket::Unknown11(uint32_t id) {
 826         id = be_htobl(id);
 827
 828         ComplexCmd(SB_COMMAND_JVM_UNKNOWN11, &id, sizeof(id));
 829 }
 830
 831
 832 void JVMPacket::Unknown12(uint32_t id) {
 833         id = be_htobl(id);
 834
 835         ComplexCmd(SB_COMMAND_JVM_UNKNOWN12, &id, sizeof(id));
 836 }
 837
 838
 839 void JVMPacket::Unknown13(uint32_t id) {
 840         id = be_htobl(id);
 841
 842         ComplexCmd(SB_COMMAND_JVM_UNKNOWN13, &id, sizeof(id));
 843 }
 844
 845
 846 void JVMPacket::Unknown14(uint32_t id) {
 847         id = be_htobl(id);
 848
 849         ComplexCmd(SB_COMMAND_JVM_UNKNOWN14, &id, sizeof(id));
 850 }
 851
 852
 853 void JVMPacket::Unknown15(uint32_t id) {
 854         id = be_htobl(id);
 855
 856         ComplexCmd(SB_COMMAND_JVM_UNKNOWN15, &id, sizeof(id));
 857 }
 858
 859
 860 void JVMPacket::GetModulesList(uint32_t id) {
 861         id = be_htobl(id);
 862
 863         ComplexCmd(SB_COMMAND_JVM_GET_MODULES_LIST, &id, sizeof(id));
 864 }
 865
 866
 867 void JVMPacket::GetThreadsList() {
 868         SimpleCmd(SB_COMMAND_JVM_GET_THREADS_LIST);
 869 }
 870
 871
 872 void JVMPacket::GetConsoleMessage() {
 873         SimpleCmd(SB_COMMAND_JVM_GET_CONSOLE_MSG);
 874 }
 875
 876
 877 void JVMPacket::Go()
 878 {
 879         SimpleCmd(SB_COMMAND_JVM_GO);
 880 }
 881
 882
 883 void JVMPacket::Stop()
 884 {
 885         // 4 : socket id field + packet size field
 886         // 2 : value field
 887         const uint16_t total = 4 + 2;
 888
 889         MAKE_JVMPACKETPTR_BUF(cpack, m_cmd.GetBuffer(total));
 890         Protocol::JVMPacket &packet = *cpack;
 891
 892         // socket class sets socket for us
 893         packet.size = htobs(total);
 894         packet.u.value = be_htobs(SB_COMMAND_JVM_STOP);
 895
 896         m_cmd.ReleaseBuffer(total);
 897 }
 898
 899
 900 void JVMPacket::GetStatus()
 901 {
 902         SimpleCmd(SB_COMMAND_JVM_GET_STATUS);
 903 }
 904
 905 } // namespace Barry
 906