src/record.cc

   1 ///
   2 /// \file       record.cc
   3 ///             Blackberry database record classes.  Help translate data
   4 ///             from data packets to useful structurs, and back.
   5 ///             This header provides the common types and classes
   6 ///             used by the general record parser classes in the
   7 ///             r_*.h files.  Only application-safe API stuff goes in
   8 ///             here.  Internal library types go in record-internal.h
   9 ///
  10
  11 /*
  12     Copyright (C) 2005-2008, Net Direct Inc. (http://www.netdirect.ca/)
  13
  14     This program is free software; you can redistribute it and/or modify
  15     it under the terms of the GNU General Public License as published by
  16     the Free Software Foundation; either version 2 of the License, or
  17     (at your option) any later version.
  18
  19     This program is distributed in the hope that it will be useful,
  20     but WITHOUT ANY WARRANTY; without even the implied warranty of
  21     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  22
  23     See the GNU General Public License in the COPYING file at the
  24     root directory of this project for more details.
  25 */
  26
  27 #include "record.h"
  28 #include "record-internal.h"
  29 #include "protocol.h"
  30 #include "protostructs.h"
  31 #include "data.h"
  32 #include "time.h"
  33 #include "error.h"
  34 #include "endian.h"
  35 #include <ostream>
  36 #include <iomanip>
  37 #include <time.h>
  38 #include <string.h>
  39 #include <stdexcept>
  40
  41 #define __DEBUG_MODE__
  42 #include "debug.h"
  43
  44 using namespace std;
  45 using namespace Barry::Protocol;
  46
  47 namespace Barry {
  48
  49 //////////////////////////////////////////////////////////////////////////////
  50 // Field builder helper functions
  51
  52 void BuildField1900(Data &data, size_t &size, uint8_t type, time_t t)
  53 {
  54         size_t timesize = COMMON_FIELD_MIN1900_SIZE;
  55         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + timesize;
  56         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
  57         CommonField *field = (CommonField *) pd;
  58
  59         field->size = htobs(timesize);
  60         field->type = type;
  61         field->u.min1900 = time2min(t);
  62
  63         size += fieldsize;
  64 }
  65
  66 void BuildField(Data &data, size_t &size, uint8_t type, char c)
  67 {
  68         size_t strsize = 1;
  69         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + strsize;
  70         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
  71         CommonField *field = (CommonField *) pd;
  72
  73         field->size = htobs(strsize);
  74         field->type = type;
  75         memcpy(field->u.raw, &c, strsize);
  76
  77         size += fieldsize;
  78 }
  79
  80 void BuildField(Data &data, size_t &size, uint8_t type, uint16_t value)
  81 {
  82         size_t strsize = 2;
  83         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + strsize;
  84         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
  85         CommonField *field = (CommonField *) pd;
  86
  87         field->size = htobs(strsize);
  88         field->type = type;
  89
  90         uint16_t store = htobs(value);
  91         memcpy(field->u.raw, &store, strsize);
  92
  93         size += fieldsize;
  94 }
  95
  96 void BuildField(Data &data, size_t &size, uint8_t type, const std::string &str)
  97 {
  98         // include null terminator
  99         BuildField(data, size, type, str.c_str(), str.size() + 1);
 100 }
 101
 102 void BuildField(Data &data, size_t &size, uint8_t type,
 103                 const void *buf, size_t bufsize)
 104 {
 105         // include null terminator
 106         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + bufsize;
 107         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
 108         CommonField *field = (CommonField *) pd;
 109
 110         field->size = htobs(bufsize);
 111         field->type = type;
 112         memcpy(field->u.raw, buf, bufsize);
 113
 114         size += fieldsize;
 115 }
 116
 117 void BuildField(Data &data, size_t &size, const Barry::UnknownField &field)
 118 {
 119         BuildField(data, size, field.type,
 120                 field.data.raw_data.data(), field.data.raw_data.size());
 121 }
 122
 123 void BuildField(Data &data, size_t &size, uint8_t type, const Barry::Protocol::GroupLink &link)
 124 {
 125         size_t linksize = sizeof(Barry::Protocol::GroupLink);
 126         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + linksize;
 127         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
 128         CommonField *field = (CommonField *) pd;
 129
 130         field->size = htobs(linksize);
 131         field->type = type;
 132         field->u.link = link;
 133
 134         size += fieldsize;
 135 }
 136
 137 std::string ParseFieldString(const Barry::Protocol::CommonField *field)
 138 {
 139         // make no assumptions here, and pass the full size in as
 140         // the maxlen, even though 99% of the time, it will be a null...
 141         // this function can be used by non-null terminated strings as well
 142         return ParseFieldString(field->u.raw, btohs(field->size));
 143 }
 144
 145 std::string ParseFieldString(const void *data, uint16_t maxlen)
 146 {
 147         const char *str = (const char *)data;
 148
 149         // find last non-null character, since some fields
 150         // can have multiple null terminators
 151         while( maxlen && str[maxlen-1] == 0 )
 152                 maxlen--;
 153
 154         return std::string(str, maxlen);
 155 }
 156
 157
 158 ///////////////////////////////////////////////////////////////////////////////
 159 // CommandTable class
 160
 161 CommandTable::CommandTable()
 162 {
 163 }
 164
 165 CommandTable::~CommandTable()
 166 {
 167 }
 168
 169 const unsigned char* CommandTable::ParseField(const unsigned char *begin,
 170                                               const unsigned char *end)
 171 {
 172         // check if there is enough data for a header
 173         const unsigned char *headend = begin + sizeof(CommandTableField);
 174         if( headend > end )
 175                 return headend;
 176
 177         const CommandTableField *field = (const CommandTableField *) begin;
 178
 179         // advance and check size
 180         begin += COMMAND_FIELD_HEADER_SIZE + field->size;       // size is byte
 181         if( begin > end )               // if begin==end, we are ok
 182                 return begin;
 183
 184         if( !field->size )              // if field has no size, something's up
 185                 return begin;
 186
 187         Command command;
 188         command.Code = field->code;
 189         command.Name.assign((const char *)field->name, field->size);
 190         Commands.push_back(command);
 191         return begin;
 192 }
 193
 194 void CommandTable::Parse(const Data &data, size_t offset)
 195 {
 196         if( offset >= data.GetSize() )
 197                 return;
 198
 199         const unsigned char *begin = data.GetData() + offset;
 200         const unsigned char *end = data.GetData() + data.GetSize();
 201
 202         while( begin < end )
 203                 begin = ParseField(begin, end);
 204 }
 205
 206 void CommandTable::Clear()
 207 {
 208         Commands.clear();
 209 }
 210
 211 unsigned int CommandTable::GetCommand(const std::string &name) const
 212 {
 213         CommandArrayType::const_iterator b = Commands.begin();
 214         for( ; b != Commands.end(); b++ )
 215                 if( b->Name == name )
 216                         return b->Code;
 217         return 0;
 218 }
 219
 220 void CommandTable::Dump(std::ostream &os) const
 221 {
 222         CommandArrayType::const_iterator b = Commands.begin();
 223         os << "Command table:\n";
 224         for( ; b != Commands.end(); b++ ) {
 225                 os << "    Command: 0x" << setbase(16) << b->Code
 226                    << " '" << b->Name << "'\n";
 227         }
 228 }
 229
 230
 231
 232 ///////////////////////////////////////////////////////////////////////////////
 233 // RecordStateTable class
 234
 235 RecordStateTable::RecordStateTable()
 236         : m_LastNewRecordId(1)
 237 {
 238 }
 239
 240 RecordStateTable::~RecordStateTable()
 241 {
 242 }
 243
 244 const unsigned char* RecordStateTable::ParseField(const unsigned char *begin,
 245                                                   const unsigned char *end)
 246 {
 247         const RecordStateTableField *field = (const RecordStateTableField *) begin;
 248
 249         // advance and check size
 250         begin += sizeof(RecordStateTableField);
 251         if( begin > end )               // if begin==end, we are ok
 252                 return begin;
 253
 254         State state;
 255         state.Index = btohs(field->index);
 256         state.RecordId = btohl(field->uniqueId);
 257         state.Dirty = (field->flags & BARRY_RSTF_DIRTY) != 0;
 258         state.RecType = field->rectype;
 259         state.Unknown2.assign((const char*)field->unknown2, sizeof(field->unknown2));
 260         StateMap[state.Index] = state;
 261
 262         return begin;
 263 }
 264
 265 void RecordStateTable::Parse(const Data &data)
 266 {
 267         size_t offset = 12;     // skipping the unknown 2 bytes at start
 268
 269         if( offset >= data.GetSize() )
 270                 return;
 271
 272         const unsigned char *begin = data.GetData() + offset;
 273         const unsigned char *end = data.GetData() + data.GetSize();
 274
 275         while( begin < end )
 276                 begin = ParseField(begin, end);
 277 }
 278
 279 void RecordStateTable::Clear()
 280 {
 281         StateMap.clear();
 282         m_LastNewRecordId = 1;
 283 }
 284
 285 // Searches the StateMap table for RecordId, and returns the "index"
 286 // in the map if found.  Returns true if found, false if not.
 287 // pFoundIndex can be null if only the existence of the index is desired
 288 bool RecordStateTable::GetIndex(uint32_t RecordId, IndexType *pFoundIndex) const
 289 {
 290         StateMapType::const_iterator i = StateMap.begin();
 291         for( ; i != StateMap.end(); ++i ) {
 292                 if( i->second.RecordId == RecordId ) {
 293                         if( pFoundIndex )
 294                                 *pFoundIndex = i->first;
 295                         return true;
 296                 }
 297         }
 298         return false;
 299 }
 300
 301 // Generate a new RecordId that is not in the state table.
 302 // Starts at 1 and keeps incrementing until a free one is found.
 303 uint32_t RecordStateTable::MakeNewRecordId() const
 304 {
 305         // start with next Id
 306         m_LastNewRecordId++;
 307
 308         // make sure it doesn't already exist
 309         StateMapType::const_iterator i = StateMap.begin();
 310         while( i != StateMap.end() ) {
 311                 if( m_LastNewRecordId == i->second.RecordId ) {
 312                         m_LastNewRecordId++;            // try again
 313                         i = StateMap.begin();           // start over
 314                 }
 315                 else {
 316                         ++i;                            // next State
 317                 }
 318         }
 319         return m_LastNewRecordId;
 320 }
 321
 322 void RecordStateTable::Dump(std::ostream &os) const
 323 {
 324         ios::fmtflags oldflags = os.setf(ios::right);
 325         char fill = os.fill(' ');
 326         bool bPrintAscii = Data::PrintAscii();
 327         Data::PrintAscii(false);
 328
 329         os << "  Index  RecordId    Dirty  RecType" << endl;
 330         os << "-------  ----------  -----  -------" << endl;
 331
 332         StateMapType::const_iterator b, e = StateMap.end();
 333         for( b = StateMap.begin(); b != e ; ++b ) {
 334                 const State &state = b->second;
 335
 336                 os.fill(' ');
 337                 os << setbase(10) << setw(7) << state.Index;
 338                 os << "  0x" << setbase(16) << setfill('0') << setw(8) << state.RecordId;
 339                 os << "  " << setfill(' ') << setw(5) << (state.Dirty ? "yes" : "no");
 340                 os << "     0x" << setbase(16) << setfill('0') << setw(2) << state.RecType;
 341                 os << "   " << Data(state.Unknown2.data(), state.Unknown2.size());
 342         }
 343
 344         // cleanup the stream
 345         os.flags(oldflags);
 346         os.fill(fill);
 347         Data::PrintAscii(bPrintAscii);
 348 }
 349
 350
 351
 352 ///////////////////////////////////////////////////////////////////////////////
 353 // DatabaseDatabase class
 354
 355 DatabaseDatabase::DatabaseDatabase()
 356 {
 357 }
 358
 359 DatabaseDatabase::~DatabaseDatabase()
 360 {
 361 }
 362
 363 template <class RecordType, class FieldType>
 364 void DatabaseDatabase::ParseRec(const RecordType &rec, const unsigned char *end)
 365 {
 366 }
 367
 368 template <class FieldType>
 369 const unsigned char* DatabaseDatabase::ParseField(const unsigned char *begin,
 370                                                   const unsigned char *end)
 371 {
 372         // check if there is enough data for a header
 373         const unsigned char *headend = begin + sizeof(FieldType);
 374         if( headend > end )
 375                 return headend;
 376
 377         // get our header
 378         const FieldType *field = (const FieldType *) begin;
 379
 380         // advance and check size
 381         begin += sizeof(FieldType) - sizeof(field->name) + ConvertHtoB(field->nameSize);
 382         if( begin > end )               // if begin==end, we are ok
 383                 return begin;
 384
 385         if( !ConvertHtoB(field->nameSize) ) // if field has no size, something's up
 386                 return begin;
 387
 388         Database db;
 389         db.Number = ConvertHtoB(field->dbNumber);
 390         db.RecordCount = ConvertHtoB(field->dbRecordCount);
 391         db.Name.assign((const char *)field->name, ConvertHtoB(field->nameSize) - 1);
 392         Databases.push_back(db);
 393         return begin;
 394 }
 395
 396 void DatabaseDatabase::Parse(const Data &data)
 397 {
 398         // check size to make sure we have up to the DBAccess operation byte
 399         if( data.GetSize() < (SB_PACKET_DBACCESS_HEADER_SIZE + 1) )
 400                 return;
 401
 402         MAKE_PACKET(pack, data);
 403         const unsigned char *begin = 0;
 404         const unsigned char *end = data.GetData() + data.GetSize();
 405
 406         switch( pack->u.db.u.response.operation )
 407         {
 408         case SB_DBOP_GET_DBDB:
 409                 // using the new protocol
 410                 if( data.GetSize() > SB_PACKET_DBDB_HEADER_SIZE ) {
 411                         begin = (const unsigned char *)
 412                                 &pack->u.db.u.response.u.dbdb.field[0];
 413
 414                         // this while check is ok, since ParseField checks
 415                         // for header size
 416                         while( begin < end )
 417                                 begin = ParseField<DBDBField>(begin, end);
 418                 }
 419                 else
 420                         dout("DatabaseDatabase: not enough data for parsing");
 421                 break;
 422
 423         case SB_DBOP_OLD_GET_DBDB:
 424                 // using the old protocol
 425                 if( data.GetSize() > SB_PACKET_OLD_DBDB_HEADER_SIZE ) {
 426                         begin = (const unsigned char *)
 427                                 &pack->u.db.u.response.u.old_dbdb.field[0];
 428
 429                         // this while check is ok, since ParseField checks
 430                         // for header size
 431                         while( begin < end )
 432                                 begin = ParseField<OldDBDBField>(begin, end);
 433                 }
 434                 else
 435                         dout("DatabaseDatabase: not enough data for parsing");
 436                 break;
 437
 438         default:
 439                 // unknown protocol
 440                 dout("Unknown protocol");
 441                 break;
 442         }
 443
 444
 445 }
 446
 447 void DatabaseDatabase::Clear()
 448 {
 449         Databases.clear();
 450 }
 451
 452 bool DatabaseDatabase::GetDBNumber(const std::string &name,
 453                                    unsigned int &number) const
 454 {
 455         DatabaseArrayType::const_iterator b = Databases.begin();
 456         for( ; b != Databases.end(); b++ )
 457                 if( b->Name == name ) {
 458                         number = b->Number;
 459                         return true;
 460                 }
 461         return false;
 462 }
 463
 464 bool DatabaseDatabase::GetDBName(unsigned int number,
 465                                  std::string &name) const
 466 {
 467         DatabaseArrayType::const_iterator b = Databases.begin();
 468         for( ; b != Databases.end(); b++ )
 469                 if( b->Number == number ) {
 470                         name = b->Name;
 471                         return true;
 472                 }
 473         return false;
 474 }
 475
 476 void DatabaseDatabase::Dump(std::ostream &os) const
 477 {
 478         DatabaseArrayType::const_iterator b = Databases.begin();
 479         os << "Database database:\n";
 480         for( ; b != Databases.end(); b++ ) {
 481                 os << "    Database: 0x" << setbase(16) << b->Number
 482                    << " '" << b->Name << "' (records: "
 483                    << setbase(10) << b->RecordCount << ")\n";
 484         }
 485 }
 486
 487
 488 std::ostream& operator<< (std::ostream &os, const std::vector<UnknownField> &unknowns)
 489 {
 490         std::vector<UnknownField>::const_iterator
 491                 ub = unknowns.begin(), ue = unknowns.end();
 492         if( ub != ue )
 493                 os << "    Unknowns:\n";
 494         for( ; ub != ue; ub++ ) {
 495                 os << "        Type: 0x" << setbase(16)
 496                    << (unsigned int) ub->type
 497                    << " Data:\n" << Data(ub->data.data(), ub->data.size());
 498         }
 499         return os;
 500 }
 501
 502
 503
 504 ///////////////////////////////////////////////////////////////////////////////
 505 // EmailAddress class
 506
 507 std::ostream& operator<<(std::ostream &os, const EmailAddress &msga) {
 508         os << msga.Name.c_str() << " <" << msga.Email.c_str() << ">";
 509         return os;
 510 }
 511
 512
 513 ///////////////////////////////////////////////////////////////////////////////
 514 // PostalAddress class
 515
 516 //
 517 // GetLabel
 518 //
 519 /// Format a mailing address into a single string, handling missing fields.
 520 ///
 521 std::string PostalAddress::GetLabel() const
 522 {
 523         std::string address = Address1;
 524         if( Address2.size() ) {
 525                 if( address.size() )
 526                         address += "\n";
 527                 address += Address2;
 528         }
 529         if( Address3.size() ) {
 530                 if( address.size() )
 531                         address += "\n";
 532                 address += Address3;
 533         }
 534         if( address.size() )
 535                 address += "\n";
 536         if( City.size() )
 537                 address += City + " ";
 538         if( Province.size() )
 539                 address += Province + " ";
 540         if( Country.size() )
 541                 address += Country;
 542         if( address.size() )
 543                 address += "\n";
 544         if( PostalCode.size() )
 545                 address += PostalCode;
 546
 547         return address;
 548 }
 549
 550 void PostalAddress::Clear()
 551 {
 552         Address1.clear();
 553         Address2.clear();
 554         Address3.clear();
 555         City.clear();
 556         Province.clear();
 557         PostalCode.clear();
 558         Country.clear();
 559 }
 560
 561 std::ostream& operator<<(std::ostream &os, const PostalAddress &post) {
 562         os << post.GetLabel();
 563         return os;
 564 }
 565
 566
 567
 568 } // namespace Barry
 569
 570
 571 #ifdef __TEST_MODE__
 572
 573 #include <iostream>
 574
 575 int main(int argc, char *argv[])
 576 {
 577         if( argc < 2 ) {
 578                 cerr << "Usage: test <datafile>" << endl;
 579                 return 1;
 580         }
 581
 582         std::vector<Data> array;
 583         if( !LoadDataArray(argv[1], array) ) {
 584                 cerr << "Unable to load file: " << argv[1] << endl;
 585                 return 1;
 586         }
 587
 588         cout << "Loaded " << array.size() << " items" << endl;
 589
 590         for( std::vector<Data>::iterator b = array.begin(), e = array.end();
 591                 b != e; b++ )
 592         {
 593                 Data &d = *b;
 594 //              cout << d << endl;
 595                 if( d.GetSize() > 13 && d.GetData()[6] == 0x4f ) {
 596                         Barry::Contact contact;
 597                         size_t size = 13;
 598                         contact.ParseFields(d, size);
 599                         cout << contact << endl;
 600                         contact.DumpLdif(cout, "ou=People,dc=example,dc=com");
 601                 }
 602                 else if( d.GetSize() > 13 && d.GetData()[6] == 0x44 ) {
 603                         Barry::Calendar cal;
 604                         size_t size = 13;
 605                         cal.ParseFields(d, size);
 606                         cout << cal << endl;
 607                 }
 608         }
 609 }
 610
 611 #endif
 612