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-2009, 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 <sstream>
  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         BuildField(data, size, type, (uint8_t)c);
  69 }
  70
  71 void BuildField(Data &data, size_t &size, uint8_t type, uint8_t c)
  72 {
  73         size_t strsize = 1;
  74         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + strsize;
  75         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
  76         CommonField *field = (CommonField *) pd;
  77
  78         field->size = htobs(strsize);
  79         field->type = type;
  80         memcpy(field->u.raw, &c, strsize);
  81
  82         size += fieldsize;
  83 }
  84
  85 void BuildField(Data &data, size_t &size, uint8_t type, uint16_t value)
  86 {
  87         size_t strsize = 2;
  88         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + strsize;
  89         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
  90         CommonField *field = (CommonField *) pd;
  91
  92         field->size = htobs(strsize);
  93         field->type = type;
  94
  95         uint16_t store = htobs(value);
  96         memcpy(field->u.raw, &store, strsize);
  97
  98         size += fieldsize;
  99 }
 100
 101 void BuildField(Data &data, size_t &size, uint8_t type, uint32_t value)
 102 {
 103         size_t strsize = 4;
 104         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + strsize;
 105         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
 106         CommonField *field = (CommonField *) pd;
 107
 108         field->size = htobl(strsize);
 109         field->type = type;
 110
 111         uint32_t store = htobs(value);
 112         memcpy(field->u.raw, &store, strsize);
 113
 114         size += fieldsize;
 115 }
 116
 117 void BuildField(Data &data, size_t &size, uint8_t type, const std::string &str)
 118 {
 119         // include null terminator
 120         BuildField(data, size, type, str.c_str(), str.size() + 1);
 121 }
 122
 123 void BuildField(Data &data, size_t &size, uint8_t type,
 124                 const void *buf, size_t bufsize)
 125 {
 126         // include null terminator
 127         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + bufsize;
 128         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
 129         CommonField *field = (CommonField *) pd;
 130
 131         field->size = htobs(bufsize);
 132         field->type = type;
 133         memcpy(field->u.raw, buf, bufsize);
 134
 135         size += fieldsize;
 136 }
 137
 138 void BuildField(Data &data, size_t &size, const Barry::UnknownField &field)
 139 {
 140         BuildField(data, size, field.type,
 141                 field.data.raw_data.data(), field.data.raw_data.size());
 142 }
 143
 144 void BuildField(Data &data, size_t &size, uint8_t type, const Barry::Protocol::GroupLink &link)
 145 {
 146         size_t linksize = sizeof(Barry::Protocol::GroupLink);
 147         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + linksize;
 148         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
 149         CommonField *field = (CommonField *) pd;
 150
 151         field->size = htobs(linksize);
 152         field->type = type;
 153         field->u.link = link;
 154
 155         size += fieldsize;
 156 }
 157
 158 std::string ParseFieldString(const Barry::Protocol::CommonField *field)
 159 {
 160         // make no assumptions here, and pass the full size in as
 161         // the maxlen, even though 99% of the time, it will be a null...
 162         // this function can be used by non-null terminated strings as well
 163         return ParseFieldString(field->u.raw, btohs(field->size));
 164 }
 165
 166 std::string ParseFieldString(const void *data, uint16_t maxlen)
 167 {
 168         const char *str = (const char *)data;
 169
 170         // find last non-null character, since some fields
 171         // can have multiple null terminators
 172         while( maxlen && str[maxlen-1] == 0 )
 173                 maxlen--;
 174
 175         return std::string(str, maxlen);
 176 }
 177
 178
 179 ///////////////////////////////////////////////////////////////////////////////
 180 // CommandTable class
 181
 182 CommandTable::CommandTable()
 183 {
 184 }
 185
 186 CommandTable::~CommandTable()
 187 {
 188 }
 189
 190 const unsigned char* CommandTable::ParseField(const unsigned char *begin,
 191                                               const unsigned char *end)
 192 {
 193         // check if there is enough data for a header
 194         const unsigned char *headend = begin + sizeof(CommandTableField);
 195         if( headend > end )
 196                 return headend;
 197
 198         const CommandTableField *field = (const CommandTableField *) begin;
 199
 200         // advance and check size
 201         begin += COMMAND_FIELD_HEADER_SIZE + field->size;       // size is byte
 202         if( begin > end )               // if begin==end, we are ok
 203                 return begin;
 204
 205         if( !field->size )              // if field has no size, something's up
 206                 return begin;
 207
 208         Command command;
 209         command.Code = field->code;
 210         command.Name.assign((const char *)field->name, field->size);
 211         Commands.push_back(command);
 212         return begin;
 213 }
 214
 215 void CommandTable::Parse(const Data &data, size_t offset)
 216 {
 217         if( offset >= data.GetSize() )
 218                 return;
 219
 220         const unsigned char *begin = data.GetData() + offset;
 221         const unsigned char *end = data.GetData() + data.GetSize();
 222
 223         while( begin < end )
 224                 begin = ParseField(begin, end);
 225 }
 226
 227 void CommandTable::Clear()
 228 {
 229         Commands.clear();
 230 }
 231
 232 unsigned int CommandTable::GetCommand(const std::string &name) const
 233 {
 234         CommandArrayType::const_iterator b = Commands.begin();
 235         for( ; b != Commands.end(); b++ )
 236                 if( b->Name == name )
 237                         return b->Code;
 238         return 0;
 239 }
 240
 241 void CommandTable::Dump(std::ostream &os) const
 242 {
 243         CommandArrayType::const_iterator b = Commands.begin();
 244         os << "Command table:\n";
 245         for( ; b != Commands.end(); b++ ) {
 246                 os << "    Command: 0x" << setbase(16) << b->Code
 247                    << " '" << b->Name << "'\n";
 248         }
 249 }
 250
 251
 252
 253 ///////////////////////////////////////////////////////////////////////////////
 254 // RecordStateTable class
 255
 256 RecordStateTable::RecordStateTable()
 257         : m_LastNewRecordId(1)
 258 {
 259 }
 260
 261 RecordStateTable::~RecordStateTable()
 262 {
 263 }
 264
 265 const unsigned char* RecordStateTable::ParseField(const unsigned char *begin,
 266                                                   const unsigned char *end)
 267 {
 268         const RecordStateTableField *field = (const RecordStateTableField *) begin;
 269
 270         // advance and check size
 271         begin += sizeof(RecordStateTableField);
 272         if( begin > end )               // if begin==end, we are ok
 273                 return begin;
 274
 275         State state;
 276         state.Index = btohs(field->index);
 277         state.RecordId = btohl(field->uniqueId);
 278         state.Dirty = (field->flags & BARRY_RSTF_DIRTY) != 0;
 279         state.RecType = field->rectype;
 280         state.Unknown2.assign((const char*)field->unknown2, sizeof(field->unknown2));
 281         StateMap[state.Index] = state;
 282
 283         return begin;
 284 }
 285
 286 void RecordStateTable::Parse(const Data &data)
 287 {
 288         size_t offset = 12;     // skipping the unknown 2 bytes at start
 289
 290         if( offset >= data.GetSize() )
 291                 return;
 292
 293         const unsigned char *begin = data.GetData() + offset;
 294         const unsigned char *end = data.GetData() + data.GetSize();
 295
 296         while( begin < end )
 297                 begin = ParseField(begin, end);
 298 }
 299
 300 void RecordStateTable::Clear()
 301 {
 302         StateMap.clear();
 303         m_LastNewRecordId = 1;
 304 }
 305
 306 // Searches the StateMap table for RecordId, and returns the "index"
 307 // in the map if found.  Returns true if found, false if not.
 308 // pFoundIndex can be null if only the existence of the index is desired
 309 bool RecordStateTable::GetIndex(uint32_t RecordId, IndexType *pFoundIndex) const
 310 {
 311         StateMapType::const_iterator i = StateMap.begin();
 312         for( ; i != StateMap.end(); ++i ) {
 313                 if( i->second.RecordId == RecordId ) {
 314                         if( pFoundIndex )
 315                                 *pFoundIndex = i->first;
 316                         return true;
 317                 }
 318         }
 319         return false;
 320 }
 321
 322 // Generate a new RecordId that is not in the state table.
 323 // Starts at 1 and keeps incrementing until a free one is found.
 324 uint32_t RecordStateTable::MakeNewRecordId() const
 325 {
 326         // start with next Id
 327         m_LastNewRecordId++;
 328
 329         // make sure it doesn't already exist
 330         StateMapType::const_iterator i = StateMap.begin();
 331         while( i != StateMap.end() ) {
 332                 if( m_LastNewRecordId == i->second.RecordId ) {
 333                         m_LastNewRecordId++;            // try again
 334                         i = StateMap.begin();           // start over
 335                 }
 336                 else {
 337                         ++i;                            // next State
 338                 }
 339         }
 340         return m_LastNewRecordId;
 341 }
 342
 343 void RecordStateTable::Dump(std::ostream &os) const
 344 {
 345         ios::fmtflags oldflags = os.setf(ios::right);
 346         char fill = os.fill(' ');
 347         bool bPrintAscii = Data::PrintAscii();
 348         Data::PrintAscii(false);
 349
 350         os << "  Index  RecordId    Dirty  RecType" << endl;
 351         os << "-------  ----------  -----  -------" << endl;
 352
 353         StateMapType::const_iterator b, e = StateMap.end();
 354         for( b = StateMap.begin(); b != e ; ++b ) {
 355                 const State &state = b->second;
 356
 357                 os.fill(' ');
 358                 os << setbase(10) << setw(7) << state.Index;
 359                 os << "  0x" << setbase(16) << setfill('0') << setw(8) << state.RecordId;
 360                 os << "  " << setfill(' ') << setw(5) << (state.Dirty ? "yes" : "no");
 361                 os << "     0x" << setbase(16) << setfill('0') << setw(2) << state.RecType;
 362                 os << "   " << Data(state.Unknown2.data(), state.Unknown2.size());
 363         }
 364
 365         // cleanup the stream
 366         os.flags(oldflags);
 367         os.fill(fill);
 368         Data::PrintAscii(bPrintAscii);
 369 }
 370
 371
 372
 373 ///////////////////////////////////////////////////////////////////////////////
 374 // DatabaseDatabase class
 375
 376 DatabaseDatabase::DatabaseDatabase()
 377 {
 378 }
 379
 380 DatabaseDatabase::~DatabaseDatabase()
 381 {
 382 }
 383
 384 template <class RecordType, class FieldType>
 385 void DatabaseDatabase::ParseRec(const RecordType &rec, const unsigned char *end)
 386 {
 387 }
 388
 389 template <class FieldType>
 390 const unsigned char* DatabaseDatabase::ParseField(const unsigned char *begin,
 391                                                   const unsigned char *end)
 392 {
 393         // check if there is enough data for a header
 394         const unsigned char *headend = begin + sizeof(FieldType);
 395         if( headend > end )
 396                 return headend;
 397
 398         // get our header
 399         const FieldType *field = (const FieldType *) begin;
 400
 401         // advance and check size
 402         begin += sizeof(FieldType) - sizeof(field->name) + ConvertHtoB(field->nameSize);
 403         if( begin > end )               // if begin==end, we are ok
 404                 return begin;
 405
 406         if( !ConvertHtoB(field->nameSize) ) // if field has no size, something's up
 407                 return begin;
 408
 409         Database db;
 410         db.Number = ConvertHtoB(field->dbNumber);
 411         db.RecordCount = ConvertHtoB(field->dbRecordCount);
 412         db.Name.assign((const char *)field->name, ConvertHtoB(field->nameSize) - 1);
 413         Databases.push_back(db);
 414         return begin;
 415 }
 416
 417 void DatabaseDatabase::Parse(const Data &data)
 418 {
 419         // check size to make sure we have up to the DBAccess operation byte
 420         if( data.GetSize() < (SB_PACKET_DBACCESS_HEADER_SIZE + 1) )
 421                 return;
 422
 423         MAKE_PACKET(pack, data);
 424         const unsigned char *begin = 0;
 425         const unsigned char *end = data.GetData() + data.GetSize();
 426
 427         switch( pack->u.db.u.response.operation )
 428         {
 429         case SB_DBOP_GET_DBDB:
 430                 // using the new protocol
 431                 if( data.GetSize() > SB_PACKET_DBDB_HEADER_SIZE ) {
 432                         begin = (const unsigned char *)
 433                                 &pack->u.db.u.response.u.dbdb.field[0];
 434
 435                         // this while check is ok, since ParseField checks
 436                         // for header size
 437                         while( begin < end )
 438                                 begin = ParseField<DBDBField>(begin, end);
 439                 }
 440                 else
 441                         dout("DatabaseDatabase: not enough data for parsing");
 442                 break;
 443
 444         case SB_DBOP_OLD_GET_DBDB:
 445                 // using the old protocol
 446                 if( data.GetSize() > SB_PACKET_OLD_DBDB_HEADER_SIZE ) {
 447                         begin = (const unsigned char *)
 448                                 &pack->u.db.u.response.u.old_dbdb.field[0];
 449
 450                         // this while check is ok, since ParseField checks
 451                         // for header size
 452                         while( begin < end )
 453                                 begin = ParseField<OldDBDBField>(begin, end);
 454                 }
 455                 else
 456                         dout("DatabaseDatabase: not enough data for parsing");
 457                 break;
 458
 459         default:
 460                 // unknown protocol
 461                 dout("Unknown protocol");
 462                 break;
 463         }
 464
 465
 466 }
 467
 468 void DatabaseDatabase::Clear()
 469 {
 470         Databases.clear();
 471 }
 472
 473 bool DatabaseDatabase::GetDBNumber(const std::string &name,
 474                                    unsigned int &number) const
 475 {
 476         DatabaseArrayType::const_iterator b = Databases.begin();
 477         for( ; b != Databases.end(); b++ )
 478                 if( b->Name == name ) {
 479                         number = b->Number;
 480                         return true;
 481                 }
 482         return false;
 483 }
 484
 485 bool DatabaseDatabase::GetDBName(unsigned int number,
 486                                  std::string &name) const
 487 {
 488         DatabaseArrayType::const_iterator b = Databases.begin();
 489         for( ; b != Databases.end(); b++ )
 490                 if( b->Number == number ) {
 491                         name = b->Name;
 492                         return true;
 493                 }
 494         return false;
 495 }
 496
 497 void DatabaseDatabase::Dump(std::ostream &os) const
 498 {
 499         DatabaseArrayType::const_iterator b = Databases.begin();
 500         os << "Database database:\n";
 501         for( ; b != Databases.end(); b++ ) {
 502                 os << "    Database: 0x" << setbase(16) << b->Number
 503                    << " '" << b->Name << "' (records: "
 504                    << setbase(10) << b->RecordCount << ")\n";
 505         }
 506 }
 507
 508
 509 std::ostream& operator<< (std::ostream &os, const std::vector<UnknownField> &unknowns)
 510 {
 511         std::vector<UnknownField>::const_iterator
 512                 ub = unknowns.begin(), ue = unknowns.end();
 513         if( ub != ue )
 514                 os << "    Unknowns:\n";
 515         for( ; ub != ue; ub++ ) {
 516                 os << "        Type: 0x" << setbase(16)
 517                    << (unsigned int) ub->type
 518                    << " Data:\n" << Data(ub->data.data(), ub->data.size());
 519         }
 520         return os;
 521 }
 522
 523
 524
 525 ///////////////////////////////////////////////////////////////////////////////
 526 // EmailAddress class
 527
 528 std::ostream& operator<<(std::ostream &os, const EmailAddress &msga) {
 529         os << msga.Name << " <" << msga.Email << ">";
 530         return os;
 531 }
 532
 533 std::ostream& operator<<(std::ostream &os, const EmailAddressList &elist) {
 534         for( EmailAddressList::const_iterator i = elist.begin(); i != elist.end(); ++i ) {
 535                 if( i != elist.begin() )
 536                         os << ", ";
 537                 os << *i;
 538         }
 539         return os;
 540 }
 541
 542
 543 ///////////////////////////////////////////////////////////////////////////////
 544 // PostalAddress class
 545
 546 //
 547 // GetLabel
 548 //
 549 /// Format a mailing address into a single string, handling missing fields.
 550 ///
 551 std::string PostalAddress::GetLabel() const
 552 {
 553         std::string address = Address1;
 554         if( Address2.size() ) {
 555                 if( address.size() )
 556                         address += "\n";
 557                 address += Address2;
 558         }
 559         if( Address3.size() ) {
 560                 if( address.size() )
 561                         address += "\n";
 562                 address += Address3;
 563         }
 564         if( address.size() )
 565                 address += "\n";
 566         if( City.size() )
 567                 address += City + " ";
 568         if( Province.size() )
 569                 address += Province + " ";
 570         if( Country.size() )
 571                 address += Country;
 572         if( address.size() )
 573                 address += "\n";
 574         if( PostalCode.size() )
 575                 address += PostalCode;
 576
 577         return address;
 578 }
 579
 580 void PostalAddress::Clear()
 581 {
 582         Address1.clear();
 583         Address2.clear();
 584         Address3.clear();
 585         City.clear();
 586         Province.clear();
 587         PostalCode.clear();
 588         Country.clear();
 589 }
 590
 591 std::ostream& operator<<(std::ostream &os, const PostalAddress &post) {
 592         os << post.GetLabel();
 593         return os;
 594 }
 595
 596
 597
 598 ///////////////////////////////////////////////////////////////////////////////
 599 // Date class
 600
 601 Date::Date(const struct tm *timep)
 602 {
 603         FromTm(timep);
 604 }
 605
 606 void Date::Clear()
 607 {
 608         Month = Day = Year = 0;
 609 }
 610
 611 void Date::ToTm(struct tm *timep) const
 612 {
 613         memset(timep, 0, sizeof(tm));
 614         timep->tm_year = Year - 1900;
 615         timep->tm_mon = Month;
 616         timep->tm_mday = Day;
 617 }
 618
 619 std::string Date::ToYYYYMMDD() const
 620 {
 621         std::ostringstream oss;
 622         oss     << setw(4) << Year
 623                 << setw(2) << Month + 1
 624                 << setw(2) << Day;
 625         return oss.str();
 626 }
 627
 628 //
 629 // ToBBString
 630 //
 631 /// The Blackberry stores Birthday and Anniversary date fields
 632 /// with the format: DD/MM/YYYY
 633 ///
 634 std::string Date::ToBBString() const
 635 {
 636         std::ostringstream oss;
 637         oss     << setw(2) << Day
 638                 << Month + 1
 639                 << Year;
 640         return oss.str();
 641 }
 642
 643 bool Date::FromTm(const struct tm *timep)
 644 {
 645         Year = timep->tm_year + 1900;
 646         Month = timep->tm_mon;
 647         Day = timep->tm_mday;
 648         return true;
 649 }
 650
 651 bool Date::FromBBString(const std::string &str)
 652 {
 653         int m, d, y;
 654         if( 3 == sscanf(str.c_str(), "%d/%d/%d", &d, &m, &y) ) {
 655                 Year = y;
 656                 Month = m - 1;
 657                 Day = d;
 658                 return true;
 659         }
 660         return false;
 661 }
 662
 663 bool Date::FromYYYYMMDD(const std::string &str)
 664 {
 665         int m, d, y;
 666         if( 3 == sscanf(str.c_str(), "%4d%2d%2d", &y, &m, &d) ) {
 667                 Year = y;
 668                 Month = m - 1;
 669                 Day = d;
 670                 return true;
 671         }
 672         return false;
 673 }
 674
 675 std::ostream& operator<<(std::ostream &os, const Date &date)
 676 {
 677         os      << setw(4) << date.Year << '/'
 678                 << setw(2) << date.Month << '/'
 679                 << setw(2) << date.Day;
 680         return os;
 681 }
 682
 683
 684
 685 } // namespace Barry
 686
 687
 688 #ifdef __TEST_MODE__
 689
 690 #include <iostream>
 691
 692 int main(int argc, char *argv[])
 693 {
 694         if( argc < 2 ) {
 695                 cerr << "Usage: test <datafile>" << endl;
 696                 return 1;
 697         }
 698
 699         std::vector<Data> array;
 700         if( !LoadDataArray(argv[1], array) ) {
 701                 cerr << "Unable to load file: " << argv[1] << endl;
 702                 return 1;
 703         }
 704
 705         cout << "Loaded " << array.size() << " items" << endl;
 706
 707         for( std::vector<Data>::iterator b = array.begin(), e = array.end();
 708                 b != e; b++ )
 709         {
 710                 Data &d = *b;
 711 //              cout << d << endl;
 712                 if( d.GetSize() > 13 && d.GetData()[6] == 0x4f ) {
 713                         Barry::Contact contact;
 714                         size_t size = 13;
 715                         contact.ParseFields(d, size);
 716                         cout << contact << endl;
 717                         contact.DumpLdif(cout, "ou=People,dc=example,dc=com");
 718                 }
 719                 else if( d.GetSize() > 13 && d.GetData()[6] == 0x44 ) {
 720                         Barry::Calendar cal;
 721                         size_t size = 13;
 722                         cal.ParseFields(d, size);
 723                         cout << cal << endl;
 724                 }
 725         }
 726 }
 727
 728 #endif
 729