src/r_folder.cc

   1 ///
   2 /// \file       r_folder.cc
   3 ///             Record parsing class for the folders database.
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2012, Net Direct Inc. (http://www.netdirect.ca/)
   8     Copyright (C) 2007, Brian Edginton
   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 #include "r_folder.h"
  24 #include "record-internal.h"
  25 #include "protostructs.h"
  26 #include "data.h"
  27 #include "time.h"
  28 #include "debug.h"
  29 #include "iconv.h"
  30 #include <iostream>
  31 #include <sstream>
  32 #include <iomanip>
  33 #include "ios_state.h"
  34
  35 using namespace std;
  36 using namespace Barry::Protocol;
  37
  38 namespace Barry {
  39
  40
  41 ///////////////////////////////////////////////////////////////////////////////
  42 // Folder Class, static members
  43
  44 //
  45 // Note! These functions currently only pass the same values through.
  46 //       In actuality, these are technically two different values:
  47 //       one on the raw protocol side, and the other part of the
  48 //       guaranteed Barry API.  If the Blackberry ever changes the
  49 //       meanings for these codes, do the translation here.
  50 //
  51
  52 Folder::FolderType Folder::TypeProto2Rec(uint8_t t)
  53 {
  54         return (FolderType)t;
  55 }
  56
  57 uint8_t Folder::TypeRec2Proto(FolderType t)
  58 {
  59         return t;
  60 }
  61
  62
  63
  64 ///////////////////////////////////////////////////////////////////////////////
  65 // Folder Class
  66
  67 // Folder Field Codes
  68
  69 #define FFC_NUMBER      0x0a
  70 #define FFC_LEVEL       0x0b
  71 #define FFC_NAME        0x0c
  72 #define FFC_ADDRESS1    0x0d
  73 #define FFC_ADDRESS2    0x0e
  74 #define FFC_TYPE        0x0f
  75 #define FFC_END         0xffff
  76
  77 #define INVALID         -1
  78
  79 #define SEPARATOR       0x2f
  80 #define ROOT_SEPARATOR  0x3a
  81
  82 static FieldLink<Folder> FolderFieldLinks[] = {
  83     { FFC_NAME, "FolderName",  0, 0, &Folder::Name, 0, 0, 0, 0, true },
  84     { FFC_END,  "End of List", 0, 0, 0, 0, 0, 0, 0, false },
  85 };
  86
  87 Folder::Folder()
  88 {
  89         Clear();
  90 }
  91
  92
  93 Folder::~Folder()
  94 {
  95 }
  96
  97 const unsigned char* Folder::ParseField(const unsigned char *begin,
  98                                         const unsigned char *end,
  99                                         const IConverter *ic)
 100 {
 101         const CommonField *field = (const CommonField *) begin;
 102
 103         // advance and check size
 104         begin += COMMON_FIELD_HEADER_SIZE + btohs(field->size);
 105         if( begin > end )       // if begin==end, we are ok
 106                 return begin;
 107
 108         if( !btohs(field->size) )   // if field has no size, something's up
 109                 return begin;
 110
 111         // cycle through the type table
 112         for(    FieldLink<Folder> *b = FolderFieldLinks;
 113                 b->type != FFC_END;
 114                 b++ )
 115         {
 116                 if( b->type == field->type ) {
 117                         if( b->strMember ) {
 118                                 std::string &s = this->*(b->strMember);
 119                                 s = ParseFieldString(field);
 120                                 if( b->iconvNeeded && ic )
 121                                         s = ic->FromBB(s);
 122                                 return begin;   // done!
 123                         }
 124                         else if( b->timeMember && btohs(field->size) == 4 ) {
 125                                 TimeT &t = this->*(b->timeMember);
 126                                 t.Time= min2time(field->u.min1900);
 127                                 return begin;
 128                         }
 129                 }
 130         }
 131         // handle special cases
 132         switch( field->type )
 133         {
 134         case FFC_TYPE:
 135                 Type = TypeProto2Rec(field->u.raw[0]);
 136                 return begin;
 137         case FFC_NUMBER:
 138                 Number = field->u.raw[0];       // two's complement
 139                 return begin;
 140         case FFC_LEVEL:
 141                 Level = field->u.raw[0];
 142                 return begin;
 143         }
 144
 145         // if still not handled, add to the Unknowns list
 146         UnknownField uf;
 147         uf.type = field->type;
 148         uf.data.assign((const char*)field->u.raw, btohs(field->size));
 149         Unknowns.push_back(uf);
 150
 151         // return new pointer for next field
 152         return begin;
 153 }
 154
 155 void Folder::ParseHeader(const Data &data, size_t &offset)
 156 {
 157         // no header in Folder records
 158 }
 159
 160 void Folder::ParseFields(const Data &data, size_t &offset, const IConverter *ic)
 161 {
 162         const unsigned char *finish = ParseCommonFields(*this,
 163                 data.GetData() + offset, data.GetData() + data.GetSize(), ic);
 164         offset += finish - (data.GetData() + offset);
 165 }
 166
 167 void Folder::Validate() const
 168 {
 169 }
 170
 171 void Folder::BuildHeader(Data &data, size_t &offset) const
 172 {
 173         // not yet implemented
 174 }
 175
 176 void Folder::BuildFields(Data &data, size_t &offset, const IConverter *ic) const
 177 {
 178         // not yet implemented
 179 }
 180
 181 void Folder::Clear()
 182 {
 183         RecType = GetDefaultRecType();
 184         RecordId = 0;
 185
 186         Name.clear();
 187         Number = 0;
 188         Level = 0;
 189
 190         Type = FolderSubtree;
 191
 192         Unknowns.clear();
 193 }
 194
 195 const FieldHandle<Folder>::ListT& Folder::GetFieldHandles()
 196 {
 197         static FieldHandle<Folder>::ListT fhv;
 198
 199         if( fhv.size() )
 200                 return fhv;
 201
 202 #undef CONTAINER_OBJECT_NAME
 203 #define CONTAINER_OBJECT_NAME fhv
 204
 205 #undef RECORD_CLASS_NAME
 206 #define RECORD_CLASS_NAME Folder
 207
 208         FHP(RecType, "Record Type Code");
 209         FHP(RecordId, "Unique Record ID");
 210
 211         FHD(Name, "Folder Name", FFC_NAME, true);
 212         FHD(Number, "Order Number", FFC_NUMBER, false);
 213         FHD(Level, "Folder Level", FFC_LEVEL, false);
 214
 215         FHE(ft, FolderType, Type, "Folder Type");
 216         FHE_CONST(ft, FolderSubtree, "Subtree");
 217         FHE_CONST(ft, FolderDeleted, "Deleted");
 218         FHE_CONST(ft, FolderInbox, "Inbox");
 219         FHE_CONST(ft, FolderOutbox, "Outbox");
 220         FHE_CONST(ft, FolderSent, "Sent");
 221         FHE_CONST(ft, FolderOther, "Other");
 222         FHE_CONST(ft, FolderDraft, "Draft");
 223
 224 // Not yet implemented
 225 //      FHE(fst, FolderStatusType, ..., "Folder Status");
 226 //      FHE_CONST(fst, FolderOrphan, "Orphan");
 227 //      FHE_CONST(fst, FolderUnfiled, "Unfiled");
 228 //      FHE_CONST(fst, FolderFiled, "Filed");
 229
 230         FHP(Unknowns, "Unknown Fields");
 231
 232         return fhv;
 233 }
 234
 235 std::string Folder::GetDescription() const
 236 {
 237         ostringstream oss;
 238         oss << Name << " (" << Level << ")";
 239         return oss.str();
 240 }
 241
 242 void Folder::Dump(std::ostream &os) const
 243 {
 244         ios_format_state state(os);
 245
 246         static const char *FolderTypeString[] = { "Subtree", "Deleted", "Inbox", "Outbox", "Sent", "Other"};
 247 //      static const char *FolderStatusString[] = { "Orphan", "Unfiled", "Filed" };
 248
 249         os << "Folder Records\n\n";
 250         os << "Folder Name: " << Name << "\n";
 251         os << "Folder Type: ";
 252         if( Type < FolderDraft )
 253                 os << FolderTypeString[Type] << "\n";
 254         else if( Type == FolderDraft )
 255                 os << "Draft\n";
 256         else
 257                 os << "Unknown (" << std::hex << Type << ")\n";
 258         os << "Folder Number: " << std::dec << Number << "\n";
 259         os << "Folder Level: " << std::dec << Level << "\n";
 260         os << "\n";
 261         os << Unknowns;
 262         os << "\n\n";
 263 }
 264
 265 } // namespace Barry
 266