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-2007, 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 "controller.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(Controller &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         packet.socket = htobs(m_con.m_socket.GetSocket());
 167         packet.size = htobs(9);
 168         packet.command = SB_COMMAND_DB_DATA;
 169         packet.u.db.tableCmd = m_con.GetCommand(Controller::DatabaseAccess);
 170         packet.u.db.u.command.operation = SB_DBOP_CLEAR_DATABASE;
 171         packet.u.db.u.command.databaseId = htobs(dbId);
 172
 173         m_send.ReleaseBuffer(9);
 174
 175         m_last_dbop = SB_DBOP_CLEAR_DATABASE;
 176 }
 177
 178 //
 179 // GetDBDB
 180 //
 181 /// Builds a command packet for the GET_DBDB command code, placing the
 182 /// data in m_send.
 183 ///
 184 void DBPacket::GetDBDB()
 185 {
 186         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(7));
 187         Protocol::Packet &packet = *cpack;
 188
 189         packet.socket = htobs(m_con.m_socket.GetSocket());
 190         packet.size = htobs(7);
 191         packet.command = SB_COMMAND_DB_DATA;
 192         packet.u.db.tableCmd = m_con.GetCommand(Controller::DatabaseAccess);
 193 //      packet.u.db.u.command.operation = SB_DBOP_GET_DBDB;
 194         packet.u.db.u.command.operation = SB_DBOP_OLD_GET_DBDB;
 195
 196         m_send.ReleaseBuffer(7);
 197
 198         m_last_dbop = SB_DBOP_OLD_GET_DBDB;
 199 }
 200
 201 //
 202 // GetRecordStateTable
 203 //
 204 /// Builds a command packet in the send buffer for the
 205 /// GET_RECORD_STATE_TABLE command.
 206 ///
 207 void DBPacket::GetRecordStateTable(unsigned int dbId)
 208 {
 209         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(9));
 210         Protocol::Packet &packet = *cpack;
 211
 212         packet.socket = htobs(m_con.m_socket.GetSocket());
 213         packet.size = htobs(9);
 214         packet.command = SB_COMMAND_DB_DATA;
 215         packet.u.db.tableCmd = m_con.GetCommand(Controller::DatabaseAccess);
 216         packet.u.db.u.command.operation = SB_DBOP_GET_RECORD_STATE_TABLE;
 217         packet.u.db.u.command.databaseId = htobs(dbId);
 218
 219         m_send.ReleaseBuffer(9);
 220
 221         m_last_dbop = SB_DBOP_GET_RECORD_STATE_TABLE;
 222 }
 223
 224 //
 225 // SetRecordFlags
 226 //
 227 /// Builds a command packet in the send buffer for the SET_RECORD_FLAGS
 228 /// command code.
 229 ///
 230 /// FIXME - this API call is incomplete, since there are unknown flags
 231 ///         in the SetRecordFlags protocol packet.  Currently it is only
 232 ///         used to set all flags to zero.
 233 ///
 234 void DBPacket::SetRecordFlags(unsigned int dbId, unsigned int stateTableIndex,
 235                             uint8_t flag1)
 236 {
 237         size_t size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_RECORD_FLAGS_SIZE;
 238         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(size));
 239         Protocol::Packet &packet = *cpack;
 240
 241         packet.socket = htobs(m_con.m_socket.GetSocket());
 242         packet.size = htobs(size);
 243         packet.command = SB_COMMAND_DB_DATA;
 244         packet.u.db.tableCmd = m_con.GetCommand(Controller::DatabaseAccess);
 245         packet.u.db.u.command.operation = SB_DBOP_SET_RECORD_FLAGS;
 246         packet.u.db.u.command.databaseId = htobs(dbId);
 247         packet.u.db.u.command.u.flags.unknown = flag1;
 248         packet.u.db.u.command.u.flags.index = htobs(stateTableIndex);
 249         memset(packet.u.db.u.command.u.flags.unknown2, 0, sizeof(packet.u.db.u.command.u.flags.unknown2));
 250
 251         m_send.ReleaseBuffer(size);
 252
 253         m_last_dbop = SB_DBOP_SET_RECORD_FLAGS;
 254 }
 255
 256 //
 257 // DeleteRecordByIndex
 258 //
 259 /// Builds a command packet in the send buffer for the DELETE_RECORD_BY_INDEX
 260 /// command code.
 261 ///
 262 void DBPacket::DeleteRecordByIndex(unsigned int dbId, unsigned int stateTableIndex)
 263 {
 264         size_t size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_RECORD_HEADER_SIZE;
 265         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(size));
 266         Protocol::Packet &packet = *cpack;
 267
 268         packet.socket = htobs(m_con.m_socket.GetSocket());
 269         packet.size = htobs(size);
 270         packet.command = SB_COMMAND_DB_DATA;
 271         packet.u.db.tableCmd = m_con.GetCommand(Controller::DatabaseAccess);
 272         packet.u.db.u.command.operation = SB_DBOP_DELETE_RECORD_BY_INDEX;
 273         packet.u.db.u.command.databaseId = htobs(dbId);
 274         packet.u.db.u.command.u.record.recordIndex = htobs(stateTableIndex);
 275
 276         m_send.ReleaseBuffer(size);
 277
 278         m_last_dbop = SB_DBOP_DELETE_RECORD_BY_INDEX;
 279 }
 280
 281 //
 282 // GetRecordByIndex
 283 //
 284 /// Builds a command packet in the send buffer for the GET_RECORD_BY_INDEX
 285 /// command code.
 286 ///
 287 void DBPacket::GetRecordByIndex(unsigned int dbId, unsigned int stateTableIndex)
 288 {
 289         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(11));
 290         Protocol::Packet &packet = *cpack;
 291
 292         packet.socket = htobs(m_con.m_socket.GetSocket());
 293         packet.size = htobs(11);
 294         packet.command = SB_COMMAND_DB_DATA;
 295         packet.u.db.tableCmd = m_con.GetCommand(Controller::DatabaseAccess);
 296         packet.u.db.u.command.operation = SB_DBOP_GET_RECORD_BY_INDEX;
 297         packet.u.db.u.command.databaseId = htobs(dbId);
 298         packet.u.db.u.command.u.record.recordIndex = htobs(stateTableIndex);
 299
 300         m_send.ReleaseBuffer(11);
 301
 302         m_last_dbop = SB_DBOP_GET_RECORD_BY_INDEX;
 303 }
 304
 305 //
 306 // SetRecordByIndex
 307 //
 308 /// Builds a command packet in the m_send buffer for the SET_RECORD_BY_INDEX
 309 /// command code.
 310 ///
 311 /// \return     bool
 312 ///             - true means success
 313 ///             - false means no data available from Builder object
 314 ///
 315 bool DBPacket::SetRecordByIndex(unsigned int dbId, unsigned int stateTableIndex,
 316                               Builder &build)
 317 {
 318         // get new data if available
 319         if( !build.Retrieve(dbId) )
 320                 return false;
 321
 322         // build packet data
 323         size_t header_size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_INDEXED_UPLOAD_HEADER_SIZE;
 324         build.BuildFields(m_send, header_size);
 325         size_t total_size = m_send.GetSize();
 326
 327         // fill in the header values
 328         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(total_size));
 329         Protocol::Packet &packet = *cpack;
 330
 331         packet.socket = htobs(m_con.m_socket.GetSocket());
 332         packet.size = htobs(total_size);
 333         packet.command = SB_COMMAND_DB_DATA;
 334         packet.u.db.tableCmd = m_con.GetCommand(Controller::DatabaseAccess);
 335         packet.u.db.u.command.operation = SB_DBOP_SET_RECORD_BY_INDEX;
 336         packet.u.db.u.command.databaseId = htobs(dbId);
 337         packet.u.db.u.command.u.index_upload.unknown = 0;
 338         packet.u.db.u.command.u.index_upload.index = htobs(stateTableIndex);
 339
 340         m_send.ReleaseBuffer(total_size);
 341
 342         m_last_dbop = SB_DBOP_SET_RECORD_BY_INDEX;
 343         return true;
 344 }
 345
 346 //
 347 // GetRecords
 348 //
 349 /// Builds a command packet in the send buffer for the GET_RECORDS
 350 /// command code.
 351 ///
 352 void DBPacket::GetRecords(unsigned int dbId)
 353 {
 354         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(9));
 355         Protocol::Packet &packet = *cpack;
 356
 357         packet.socket = htobs(m_con.m_socket.GetSocket());
 358         packet.size = htobs(9);
 359         packet.command = SB_COMMAND_DB_DATA;
 360         packet.u.db.tableCmd = m_con.GetCommand(Controller::DatabaseAccess);
 361         packet.u.db.u.command.operation = SB_DBOP_OLD_GET_RECORDS;
 362         packet.u.db.u.command.databaseId = htobs(dbId);
 363
 364         m_send.ReleaseBuffer(9);
 365
 366         m_last_dbop = SB_DBOP_OLD_GET_RECORDS;
 367 }
 368
 369 //
 370 // SetRecord
 371 //
 372 /// Builds a command packet in the m_send buffer for the SET_RECORD command
 373 /// code.
 374 ///
 375 /// \return     bool
 376 ///             - true means success
 377 ///             - false means no data available from Builder object
 378 ///
 379 bool DBPacket::SetRecord(unsigned int dbId, Builder &build)
 380 {
 381         // get new data if available
 382         if( !build.Retrieve(dbId) )
 383                 return false;
 384
 385         // build packet data
 386         size_t header_size = SB_PACKET_COMMAND_HEADER_SIZE + DBC_TAGGED_UPLOAD_HEADER_SIZE;
 387         build.BuildHeader(m_send, header_size);
 388         build.BuildFields(m_send, header_size);
 389         size_t total_size = m_send.GetSize();
 390
 391         // fill in the header values
 392         MAKE_PACKETPTR_BUF(cpack, m_send.GetBuffer(total_size));
 393         Protocol::Packet &packet = *cpack;
 394
 395         packet.socket = htobs(m_con.m_socket.GetSocket());
 396         packet.size = htobs(total_size);
 397         packet.command = SB_COMMAND_DB_DATA;
 398         packet.u.db.tableCmd = m_con.GetCommand(Controller::DatabaseAccess);
 399         packet.u.db.u.command.operation = SB_DBOP_SET_RECORD;
 400         packet.u.db.u.command.databaseId = htobs(dbId);
 401         packet.u.db.u.command.u.tag_upload.rectype = build.GetRecType();
 402         packet.u.db.u.command.u.tag_upload.uniqueId = htobl(build.GetUniqueId());
 403         packet.u.db.u.command.u.tag_upload.unknown2 = 1;        // unknown observed value
 404
 405         m_send.ReleaseBuffer(total_size);
 406
 407         m_last_dbop = SB_DBOP_SET_RECORD;
 408         return true;
 409 }
 410
 411
 412 // throws FIXME if packet doesn't support it
 413 unsigned int DBPacket::ReturnCode() const
 414 {
 415         if( Command() == SB_COMMAND_DB_DONE ) {
 416                 Protocol::CheckSize(m_receive, SB_PACKET_DBACCESS_HEADER_SIZE + SB_DBACCESS_RETURN_CODE_SIZE);
 417                 MAKE_PACKET(rpack, m_receive);
 418                 return rpack->u.db.u.return_code;
 419         }
 420         else {
 421                 throw Error("Attempting to extract a return code from the wrong response packet type");
 422         }
 423 }
 424
 425 //
 426 // DBOperation
 427 //
 428 /// Returns the database operation code from the receive packet, assuming
 429 /// that receive contains a response packet.  If receive isn't large
 430 /// enough, throws Error.
 431 ///
 432 unsigned int DBPacket::DBOperation() const
 433 {
 434         Protocol::CheckSize(m_receive, SB_PACKET_RESPONSE_HEADER_SIZE);
 435         MAKE_PACKET(rpack, m_receive);
 436         return rpack->u.db.u.response.operation;
 437 }
 438
 439 //
 440 // Parse
 441 //
 442 /// Parses the data in the receive buffer, and attempts to be smart about it,
 443 /// using the last send command as guidance for what to expect in the
 444 /// response.
 445 ///
 446 /// \returns    bool    true - packet was recognized and parse was attempted
 447 ///                     false - packet was not recognized
 448 ///
 449 bool DBPacket::Parse(Parser &parser)
 450 {
 451         size_t offset = 0;
 452         MAKE_PACKET(rpack, m_receive);
 453
 454         switch( m_last_dbop )
 455         {
 456         case SB_DBOP_OLD_GET_RECORDS:
 457         case SB_DBOP_GET_RECORD_BY_INDEX:
 458                 parser.Clear();
 459
 460                 offset = SB_PACKET_RESPONSE_HEADER_SIZE + DBR_OLD_TAGGED_RECORD_HEADER_SIZE;
 461                 Protocol::CheckSize(m_receive, offset);
 462                 // FIXME - this may need adjustment for email records... they
 463                 // don't seem to have uniqueID's
 464                 parser.SetIds(rpack->u.db.u.response.u.tagged.rectype,
 465                         btohl(rpack->u.db.u.response.u.tagged.uniqueId));
 466
 467                 parser.ParseHeader(m_receive, offset);
 468                 parser.ParseFields(m_receive, offset);
 469                 parser.Store();
 470                 return true;
 471
 472         default:        // unknown command
 473                 return false;
 474         }
 475 }
 476
 477 } // namespace Barry
 478