src/record.h

   1 ///
   2 /// \file       record.h
   3 ///             Blackberry database record classes.  Help translate data
   4 ///             from data packets to useful structurs, and back.
   5 ///
   6
   7 /*
   8     Copyright (C) 2005-2006, Net Direct Inc. (http://www.netdirect.ca/)
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18
  19     See the GNU General Public License in the COPYING file at the
  20     root directory of this project for more details.
  21 */
  22
  23 #ifndef __BARRY_RECORD_H__
  24 #define __BARRY_RECORD_H__
  25
  26 #include <iosfwd>
  27 #include <string>
  28 #include <vector>
  29 #include <stdint.h>
  30
  31 // forward declarations
  32 class Data;
  33
  34 namespace Barry {
  35
  36 //
  37 // NOTE:  All classes here must be container-safe!  Perhaps add sorting
  38 //        operators in the future.
  39 //
  40
  41
  42
  43 class CommandTable
  44 {
  45 public:
  46         struct Command
  47         {
  48                 unsigned int Code;
  49                 std::string Name;
  50         };
  51
  52         typedef std::vector<Command> CommandArrayType;
  53
  54         CommandArrayType Commands;
  55
  56 private:
  57         const unsigned char* ParseField(const unsigned char *begin,
  58                 const unsigned char *end);
  59 public:
  60         CommandTable();
  61         ~CommandTable();
  62
  63         void Parse(const Data &data, size_t offset);
  64         void Clear();
  65
  66         // returns 0 if unable to find command name, which is safe, since
  67         // 0 is a special command that shouldn't be in the table anyway
  68         unsigned int GetCommand(const std::string &name) const;
  69
  70         void Dump(std::ostream &os) const;
  71 };
  72
  73 inline std::ostream& operator<< (std::ostream &os, const CommandTable &command) {
  74         command.Dump(os);
  75         return os;
  76 }
  77
  78
  79
  80 class DatabaseDatabase
  81 {
  82 public:
  83         struct Database
  84         {
  85                 unsigned int Number;
  86                 unsigned int RecordCount;
  87                 std::string Name;
  88         };
  89
  90         typedef std::vector<Database> DatabaseArrayType;
  91
  92         DatabaseArrayType Databases;
  93
  94 private:
  95         template <class RecordType, class FieldType>
  96         void ParseRec(const RecordType &rec, const unsigned char *end);
  97
  98         template <class FieldType>
  99         const unsigned char* ParseField(const unsigned char *begin,
 100                 const unsigned char *end);
 101
 102 public:
 103         DatabaseDatabase();
 104         ~DatabaseDatabase();
 105
 106         void Parse(const Data &data);
 107         void Clear();
 108
 109         // returns true on success, and fills target
 110         bool GetDBNumber(const std::string &name, unsigned int &number) const;
 111         bool GetDBName(unsigned int number, std::string &name) const;
 112
 113         void Dump(std::ostream &os) const;
 114 };
 115
 116 inline std::ostream& operator<<(std::ostream &os, const DatabaseDatabase &dbdb) {
 117         dbdb.Dump(os);
 118         return os;
 119 }
 120
 121
 122
 123 struct UnknownField
 124 {
 125         uint8_t type;
 126         std::string data;
 127 };
 128 std::ostream& operator<< (std::ostream &os, const std::vector<UnknownField> &unknowns);
 129
 130
 131 /// \addtogroup RecordParserClasses
 132 ///             Parser and data storage classes.  These classes take a
 133 ///             Database Database record and convert them into C++ objects.
 134 ///             Each of these classes are safe to be used in standard
 135 ///             containers, and are meant to be used in conjunction with the
 136 ///             RecordParser<> template when calling Controller::LoadDatabase().
 137 /// @{
 138
 139 class Contact
 140 {
 141 public:
 142         struct GroupLink
 143         {
 144                 uint32_t Link;
 145                 uint16_t Unknown;
 146
 147                 GroupLink() : Link(0), Unknown(0) {}
 148                 GroupLink(uint32_t link, uint16_t unknown)
 149                         : Link(link), Unknown(unknown)
 150                 {}
 151         };
 152
 153         typedef std::vector<GroupLink>                  GroupLinksType;
 154         typedef std::vector<UnknownField>               UnknownsType;
 155
 156         // contact specific data
 157         uint32_t RecordId;
 158         std::string
 159                 Email,
 160                 Phone,
 161                 Fax,
 162                 WorkPhone,
 163                 HomePhone,
 164                 MobilePhone,
 165                 Pager,
 166                 PIN,
 167                 FirstName,
 168                 LastName,
 169                 Company,
 170                 DefaultCommunicationsMethod,
 171                 Address1,
 172                 Address2,
 173                 Address3,
 174                 City,
 175                 Province,
 176                 PostalCode,
 177                 Country,
 178                 Title,
 179                 PublicKey,
 180                 Notes;
 181
 182         GroupLinksType GroupLinks;
 183         UnknownsType Unknowns;
 184
 185
 186 //protected:
 187 public:
 188         const unsigned char* ParseField(const unsigned char *begin,
 189                 const unsigned char *end);
 190
 191 public:
 192         Contact();
 193         ~Contact();
 194
 195         uint64_t GetID() const { return RecordId; }
 196         std::string GetPostalAddress() const;
 197
 198         void Parse(const Data &data, size_t offset, unsigned int operation);
 199         void Build(Data &data, size_t offset) const;
 200         void Clear();                   // erase everything
 201
 202         void Dump(std::ostream &os) const;
 203         void DumpLdif(std::ostream &os, const std::string &baseDN) const;
 204
 205         // sorting - put group links at the end
 206         bool operator<(const Contact &other) const {
 207                 return GroupLinks.size() == 0 && other.GroupLinks.size() > 0;
 208 //              // testing - put group links at the top
 209 //              return GroupLinks.size() > 0 && other.GroupLinks.size() == 0;
 210         }
 211
 212         // protocol record sizes
 213         static size_t GetOldProtocolRecordSize();
 214         static size_t GetProtocolRecordSize();
 215
 216         // database name
 217         static const char * GetDBName() { return "Address Book"; }
 218 };
 219
 220 inline std::ostream& operator<< (std::ostream &os, const Contact &contact) {
 221         contact.Dump(os);
 222         return os;
 223 }
 224
 225 class Message
 226 {
 227 public:
 228         struct Address
 229         {
 230                 std::string Name;
 231                 std::string Email;
 232         };
 233
 234
 235         Address From;
 236         Address To;
 237         Address Cc;
 238         std::string Subject;
 239         std::string Body;
 240         std::vector<UnknownField> Unknowns;
 241
 242 public:
 243         Message();
 244         ~Message();
 245
 246         const unsigned char* ParseField(const unsigned char *begin,
 247                 const unsigned char *end);
 248         void Parse(const Data &data, size_t offset, unsigned int operation);
 249         void Clear();
 250
 251         void Dump(std::ostream &os) const;
 252
 253         // sorting
 254         bool operator<(const Message &other) const { return Subject < other.Subject; }
 255
 256         // protocol record sizes
 257         static size_t GetOldProtocolRecordSize();
 258         static size_t GetProtocolRecordSize();
 259
 260         // database name
 261         static const char * GetDBName() { return "Messages"; }
 262 };
 263
 264 inline std::ostream& operator<<(std::ostream &os, const Message &msg) {
 265         msg.Dump(os);
 266         return os;
 267 }
 268
 269 std::ostream& operator<<(std::ostream &os, const Message::Address &msga);
 270
 271
 272 class Calendar
 273 {
 274 public:
 275         typedef std::vector<UnknownField>               UnknownsType;
 276
 277         uint64_t RecordId;
 278         bool Recurring;
 279         bool AllDayEvent;
 280         std::string Subject;
 281         std::string Notes;
 282         std::string Location;
 283         time_t NotificationTime;
 284         time_t StartTime;
 285         time_t EndTime;
 286         UnknownsType Unknowns;
 287
 288 public:
 289         Calendar();
 290         ~Calendar();
 291
 292         const unsigned char* ParseField(const unsigned char *begin,
 293                 const unsigned char *end);
 294         void Parse(const Data &data, size_t offset, unsigned int operation);
 295         void Build(Data &data, size_t offset) const;
 296         void Clear();
 297
 298         void Dump(std::ostream &os) const;
 299
 300         // sorting
 301         bool operator<(const Calendar &other) const { return StartTime < other.StartTime; }
 302
 303         // protocol record sizes
 304         static size_t GetOldProtocolRecordSize();
 305         static size_t GetProtocolRecordSize();
 306
 307         // database name
 308         static const char * GetDBName() { return "Calendar"; }
 309 };
 310
 311 inline std::ostream& operator<<(std::ostream &os, const Calendar &msg) {
 312         msg.Dump(os);
 313         return os;
 314 }
 315
 316 /// @}
 317
 318 } // namespace Barry
 319
 320 #endif
 321