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-2008, 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
  34 #define __DEBUG_MODE__
  35 #include "debug.h"
  36
  37
  38 namespace Barry {
  39
  40 //////////////////////////////////////////////////////////////////////////////
  41 // Packet base class
  42
  43 //
  44 // Command
  45 //
  46 /// Returns the command value of the receive packet.  If receive isn't
  47 /// large enough, throws Error.
  48 ///
  49 unsigned int Packet::Command() const
  50 {
  51         Protocol::CheckSize(m_receive);
  52         MAKE_PACKET(rpack, m_receive);
  53         return rpack->command;
  54 }
  55
  56
  57 //////////////////////////////////////////////////////////////////////////////
  58 // ZeroPacket class
  59
  60 ZeroPacket::ZeroPacket(Data &send, Data &receive)
  61         : Packet(send, receive)
  62 {
  63 }
  64
  65 ZeroPacket::~ZeroPacket()
  66 {
  67 }
  68
  69 //
  70 // GetAttribute
  71 //
  72 /// Builds a command packet for the initial socket-0 handshakes
  73 /// that fetch certain (some unknown) attributes.  The attributes
  74 /// appear to exist in an object/attribute sequence, so that's
  75 /// how we address them here.
  76 ///
  77 void ZeroPacket::GetAttribute(unsigned int object, unsigned int attribute)
  78 {
  79         size_t size = SB_SOCKET_PACKET_HEADER_SIZE + ATTRIBUTE_FETCH_COMMAND_SIZE;
  80         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(size));
  81         Protocol::Packet &packet = *cpack;
  82
  83         packet.socket = 0;
  84         packet.size = htobs(size);
  85         packet.command = SB_COMMAND_FETCH_ATTRIBUTE;
  86         packet.u.socket.socket = htobs(0x00ff); // default non-socket request
  87         packet.u.socket.sequence = 0;           // filled in by Socket class
  88         packet.u.socket.u.fetch.object = htobs(object);
  89         packet.u.socket.u.fetch.attribute = htobs(attribute);
  90
  91         m_send.ReleaseBuffer(size);
  92 }
  93
  94 unsigned int ZeroPacket::ObjectID() const
  95 {
  96         Protocol::CheckSize(m_receive, SB_SOCKET_PACKET_HEADER_SIZE);
  97         MAKE_PACKET(rpack, m_receive);
  98         return btohs(rpack->u.socket.u.fetch.object);
  99 }
 100
 101 unsigned int ZeroPacket::AttributeID() const
 102 {
 103         Protocol::CheckSize(m_receive, SB_SOCKET_PACKET_HEADER_SIZE);
 104         MAKE_PACKET(rpack, m_receive);
 105         return btohs(rpack->u.socket.u.fetch.attribute);
 106 }
 107
 108 uint32_t ZeroPacket::ChallengeSeed() const
 109 {
 110         Protocol::CheckSize(m_receive, SB_SOCKET_PACKET_HEADER_SIZE +
 111                 PASSWORD_CHALLENGE_SEED_SIZE);
 112         MAKE_PACKET(rpack, m_receive);
 113         return btohl(rpack->u.socket.u.password.u.seed);
 114 }
 115
 116 unsigned int ZeroPacket::RemainingTries() const
 117 {
 118         Protocol::CheckSize(m_receive, SB_SOCKET_PACKET_HEADER_SIZE +
 119                 PASSWORD_CHALLENGE_HEADER_SIZE);
 120         MAKE_PACKET(rpack, m_receive);
 121         // this is a byte, so no byte swapping needed
 122         return rpack->u.socket.u.password.remaining_tries;
 123 }
 124
 125 unsigned int ZeroPacket::SocketResponse() const
 126 {
 127         Protocol::CheckSize(m_receive, SB_SOCKET_PACKET_HEADER_SIZE);
 128         MAKE_PACKET(rpack, m_receive);
 129         return btohs(rpack->u.socket.socket);
 130 }
 131
 132 unsigned char ZeroPacket::SocketSequence() const
 133 {
 134         Protocol::CheckSize(m_receive, SB_SOCKET_PACKET_HEADER_SIZE);
 135         MAKE_PACKET(rpack, m_receive);
 136         return rpack->u.socket.sequence;        // sequence is a byte
 137 }
 138
 139
 140
 141 //////////////////////////////////////////////////////////////////////////////
 142 // DBPacket class
 143
 144 DBPacket::DBPacket(Mode::Desktop &con, Data &send, Data &receive)
 145         : Packet(send, receive)
 146         , m_con(con)
 147         , m_last_dbop(0)
 148 {
 149 }
 150
 151 DBPacket::~DBPacket()
 152 {
 153 }
 154
 155 //
 156 // ClearDatabase
 157 //
 158 /// Builds a command packet for the CLEAR_DATABASE command code, placing
 159 /// the data in the send buffer.
 160 ///
 161 void DBPacket::ClearDatabase(unsigned int dbId)
 162 {
 163         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(9));
 164         Protocol::Packet &packet = *cpack;
 165
 166         // socket class should override this for us
 167 //      packet.socket = htobs(m_con.m_socket->GetSocket());
 168         packet.size = htobs(9);
 169         packet.command = SB_COMMAND_DB_DATA;
 170         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 171         packet.u.db.u.command.operation = SB_DBOP_CLEAR_DATABASE;
 172         packet.u.db.u.command.databaseId = htobs(dbId);
 173
 174         m_send.ReleaseBuffer(9);
 175
 176         m_last_dbop = SB_DBOP_CLEAR_DATABASE;
 177 }
 178
 179 //
 180 // GetDBDB
 181 //
 182 /// Builds a command packet for the GET_DBDB command code, placing the
 183 /// data in m_send.
 184 ///
 185 void DBPacket::GetDBDB()
 186 {
 187         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(7));
 188         Protocol::Packet &packet = *cpack;
 189
 190         // socket class should override this for us
 191 //      packet.socket = htobs(m_con.m_socket->GetSocket());
 192         packet.size = htobs(7);
 193         packet.command = SB_COMMAND_DB_DATA;
 194         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 195 //      packet.u.db.u.command.operation = SB_DBOP_GET_DBDB;
 196         packet.u.db.u.command.operation = SB_DBOP_OLD_GET_DBDB;
 197
 198         m_send.ReleaseBuffer(7);
 199
 200         m_last_dbop = SB_DBOP_OLD_GET_DBDB;
 201 }
 202
 203 //
 204 // GetRecordStateTable
 205 //
 206 /// Builds a command packet in the send buffer for the
 207 /// GET_RECORD_STATE_TABLE command.
 208 ///
 209 void DBPacket::GetRecordStateTable(unsigned int dbId)
 210 {
 211         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(9));
 212         Protocol::Packet &packet = *cpack;
 213
 214         // socket class should override this for us
 215 //      packet.socket = htobs(m_con.m_socket->GetSocket());
 216         packet.size = htobs(9);
 217         packet.command = SB_COMMAND_DB_DATA;
 218         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 219         packet.u.db.u.command.operation = SB_DBOP_GET_RECORD_STATE_TABLE;
 220         packet.u.db.u.command.databaseId = htobs(dbId);
 221
 222         m_send.ReleaseBuffer(9);
 223
 224         m_last_dbop = SB_DBOP_GET_RECORD_STATE_TABLE;
 225 }
 226
 227 //
 228 // SetRecordFlags
 229 //
 230 /// Builds a command packet in the send buffer for the SET_RECORD_FLAGS
 231 /// command code.
 232 ///
 233 /// FIXME - this API call is incomplete, since there are unknown flags
 234 ///         in the SetRecordFlags protocol packet.  Currently it is only
 235 ///         used to set all flags to zero.
 236 ///
 237 void DBPacket::SetRecordFlags(unsigned int dbId, unsigned int stateTableIndex,
 238                             uint8_t flag1)
 239 {
 240         size_t size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_RECORD_FLAGS_SIZE;
 241         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(size));
 242         Protocol::Packet &packet = *cpack;
 243
 244         // socket class should override this for us
 245 //      packet.socket = htobs(m_con.m_socket->GetSocket());
 246         packet.size = htobs(size);
 247         packet.command = SB_COMMAND_DB_DATA;
 248         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 249         packet.u.db.u.command.operation = SB_DBOP_SET_RECORD_FLAGS;
 250         packet.u.db.u.command.databaseId = htobs(dbId);
 251         packet.u.db.u.command.u.flags.unknown = flag1;
 252         packet.u.db.u.command.u.flags.index = htobs(stateTableIndex);
 253         memset(packet.u.db.u.command.u.flags.unknown2, 0, sizeof(packet.u.db.u.command.u.flags.unknown2));
 254
 255         m_send.ReleaseBuffer(size);
 256
 257         m_last_dbop = SB_DBOP_SET_RECORD_FLAGS;
 258 }
 259
 260 //
 261 // DeleteRecordByIndex
 262 //
 263 /// Builds a command packet in the send buffer for the DELETE_RECORD_BY_INDEX
 264 /// command code.
 265 ///
 266 void DBPacket::DeleteRecordByIndex(unsigned int dbId, unsigned int stateTableIndex)
 267 {
 268         size_t size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_RECORD_HEADER_SIZE;
 269         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(size));
 270         Protocol::Packet &packet = *cpack;
 271
 272         // socket class should override this for us
 273 //      packet.socket = htobs(m_con.m_socket->GetSocket());
 274         packet.size = htobs(size);
 275         packet.command = SB_COMMAND_DB_DATA;
 276         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 277         packet.u.db.u.command.operation = SB_DBOP_DELETE_RECORD_BY_INDEX;
 278         packet.u.db.u.command.databaseId = htobs(dbId);
 279         packet.u.db.u.command.u.record.recordIndex = htobs(stateTableIndex);
 280
 281         m_send.ReleaseBuffer(size);
 282
 283         m_last_dbop = SB_DBOP_DELETE_RECORD_BY_INDEX;
 284 }
 285
 286 //
 287 // GetRecordByIndex
 288 //
 289 /// Builds a command packet in the send buffer for the GET_RECORD_BY_INDEX
 290 /// command code.
 291 ///
 292 void DBPacket::GetRecordByIndex(unsigned int dbId, unsigned int stateTableIndex)
 293 {
 294         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(11));
 295         Protocol::Packet &packet = *cpack;
 296
 297         // socket class should override this for us
 298 //      packet.socket = htobs(m_con.m_socket->GetSocket());
 299         packet.size = htobs(11);
 300         packet.command = SB_COMMAND_DB_DATA;
 301         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 302         packet.u.db.u.command.operation = SB_DBOP_GET_RECORD_BY_INDEX;
 303         packet.u.db.u.command.databaseId = htobs(dbId);
 304         packet.u.db.u.command.u.record.recordIndex = htobs(stateTableIndex);
 305
 306         m_send.ReleaseBuffer(11);
 307
 308         m_last_dbop = SB_DBOP_GET_RECORD_BY_INDEX;
 309 }
 310
 311 //
 312 // SetRecordByIndex
 313 //
 314 /// Builds a command packet in the m_send buffer for the SET_RECORD_BY_INDEX
 315 /// command code.
 316 ///
 317 /// \return     bool
 318 ///             - true means success
 319 ///             - false means no data available from Builder object
 320 ///
 321 bool DBPacket::SetRecordByIndex(unsigned int dbId, unsigned int stateTableIndex,
 322                               Builder &build)
 323 {
 324         // get new data if available
 325         if( !build.Retrieve(dbId) )
 326                 return false;
 327
 328         // build packet data
 329         size_t header_size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_INDEXED_UPLOAD_HEADER_SIZE;
 330         build.BuildFields(m_send, header_size);
 331         size_t total_size = m_send.GetSize();
 332
 333         // fill in the header values
 334         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(total_size));
 335         Protocol::Packet &packet = *cpack;
 336
 337         // socket class should override this for us
 338 //      packet.socket = htobs(m_con.m_socket->GetSocket());
 339         packet.size = htobs(total_size);
 340         packet.command = SB_COMMAND_DB_DATA;
 341         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 342         packet.u.db.u.command.operation = SB_DBOP_SET_RECORD_BY_INDEX;
 343         packet.u.db.u.command.databaseId = htobs(dbId);
 344         packet.u.db.u.command.u.index_upload.unknown = 0;
 345         packet.u.db.u.command.u.index_upload.index = htobs(stateTableIndex);
 346
 347         m_send.ReleaseBuffer(total_size);
 348
 349         m_last_dbop = SB_DBOP_SET_RECORD_BY_INDEX;
 350         return true;
 351 }
 352
 353 //
 354 // GetRecords
 355 //
 356 /// Builds a command packet in the send buffer for the GET_RECORDS
 357 /// command code.
 358 ///
 359 void DBPacket::GetRecords(unsigned int dbId)
 360 {
 361         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(9));
 362         Protocol::Packet &packet = *cpack;
 363
 364         // socket class should override this for us
 365 //      packet.socket = htobs(m_con.m_socket->GetSocket());
 366         packet.size = htobs(9);
 367         packet.command = SB_COMMAND_DB_DATA;
 368         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 369         packet.u.db.u.command.operation = SB_DBOP_OLD_GET_RECORDS;
 370         packet.u.db.u.command.databaseId = htobs(dbId);
 371
 372         m_send.ReleaseBuffer(9);
 373
 374         m_last_dbop = SB_DBOP_OLD_GET_RECORDS;
 375 }
 376
 377 //
 378 // SetRecord
 379 //
 380 /// Builds a command packet in the m_send buffer for the SET_RECORD command
 381 /// code.
 382 ///
 383 /// \return     bool
 384 ///             - true means success
 385 ///             - false means no data available from Builder object
 386 ///
 387 bool DBPacket::SetRecord(unsigned int dbId, Builder &build)
 388 {
 389         // get new data if available
 390         if( !build.Retrieve(dbId) )
 391                 return false;
 392
 393         // build packet data
 394         size_t header_size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_TAGGED_UPLOAD_HEADER_SIZE;
 395         build.BuildHeader(m_send, header_size);
 396         build.BuildFields(m_send, header_size);
 397         size_t total_size = m_send.GetSize();
 398
 399         // fill in the header values
 400         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(total_size));
 401         Protocol::Packet &packet = *cpack;
 402
 403         // socket class should override this for us
 404 //      packet.socket = htobs(m_con.m_socket->GetSocket());
 405         packet.size = htobs(total_size);
 406         packet.command = SB_COMMAND_DB_DATA;
 407         packet.u.db.tableCmd = m_con.GetDBCommand(Mode::Desktop::DatabaseAccess);
 408         packet.u.db.u.command.operation = SB_DBOP_SET_RECORD;
 409         packet.u.db.u.command.databaseId = htobs(dbId);
 410         packet.u.db.u.command.u.tag_upload.rectype = build.GetRecType();
 411         packet.u.db.u.command.u.tag_upload.uniqueId = htobl(build.GetUniqueId());
 412         packet.u.db.u.command.u.tag_upload.unknown2 = 1;        // unknown observed value
 413
 414         m_send.ReleaseBuffer(total_size);
 415
 416         m_last_dbop = SB_DBOP_SET_RECORD;
 417         return true;
 418 }
 419
 420
 421 // throws FIXME if packet doesn't support it
 422 unsigned int DBPacket::ReturnCode() const
 423 {
 424         if( Command() == SB_COMMAND_DB_DONE ) {
 425                 Protocol::CheckSize(m_receive, SB_PACKET_DBACCESS_HEADER_SIZE + SB_DBACCESS_RETURN_CODE_SIZE);
 426                 MAKE_PACKET(rpack, m_receive);
 427                 return rpack->u.db.u.return_code;
 428         }
 429         else {
 430                 throw Error("Attempting to extract a return code from the wrong response packet type");
 431         }
 432 }
 433
 434 //
 435 // DBOperation
 436 //
 437 /// Returns the database operation code from the receive packet, assuming
 438 /// that receive contains a response packet.  If receive isn't large
 439 /// enough, throws Error.
 440 ///
 441 unsigned int DBPacket::DBOperation() const
 442 {
 443         Protocol::CheckSize(m_receive, SB_PACKET_RESPONSE_HEADER_SIZE);
 444         MAKE_PACKET(rpack, m_receive);
 445         return rpack->u.db.u.response.operation;
 446 }
 447
 448 //
 449 // Parse
 450 //
 451 /// Parses the data in the receive buffer, and attempts to be smart about it,
 452 /// using the last send command as guidance for what to expect in the
 453 /// response.
 454 ///
 455 /// \returns    bool    true - packet was recognized and parse was attempted
 456 ///                     false - packet was not recognized
 457 ///
 458 bool DBPacket::Parse(Parser &parser)
 459 {
 460         size_t offset = 0;
 461         MAKE_PACKET(rpack, m_receive);
 462
 463         switch( m_last_dbop )
 464         {
 465         case SB_DBOP_OLD_GET_RECORDS:
 466         case SB_DBOP_GET_RECORD_BY_INDEX:
 467                 parser.Clear();
 468
 469                 offset = SB_PACKET_RESPONSE_HEADER_SIZE + DBR_OLD_TAGGED_RECORD_HEADER_SIZE;
 470                 Protocol::CheckSize(m_receive, offset);
 471                 // FIXME - this may need adjustment for email records... they
 472                 // don't seem to have uniqueID's
 473                 parser.SetIds(rpack->u.db.u.response.u.tagged.rectype,
 474                         btohl(rpack->u.db.u.response.u.tagged.uniqueId));
 475
 476                 parser.ParseHeader(m_receive, offset);
 477                 parser.ParseFields(m_receive, offset);
 478                 parser.Store();
 479                 return true;
 480
 481         default:        // unknown command
 482                 return false;
 483         }
 484 }
 485
 486 } // namespace Barry
 487