src/r_calendar.cc

   1 ///
   2 /// \file       r_calendar.cc
   3 ///             Blackberry database record parser class for calendar records.
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2009, Net Direct Inc. (http://www.netdirect.ca/)
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #include "r_calendar.h"
  23 #include "record-internal.h"
  24 #include "protocol.h"
  25 #include "protostructs.h"
  26 #include "data.h"
  27 #include "time.h"
  28 #include "error.h"
  29 #include "endian.h"
  30 #include "iconv.h"
  31 #include <ostream>
  32 #include <iomanip>
  33 #include <time.h>
  34 #include <string.h>
  35 #include <stdexcept>
  36
  37 #define __DEBUG_MODE__
  38 #include "debug.h"
  39
  40 using namespace std;
  41 using namespace Barry::Protocol;
  42
  43 namespace Barry {
  44
  45
  46 ///////////////////////////////////////////////////////////////////////////////
  47 // Calendar class, static members
  48
  49 //
  50 // Note! These functions currently only pass the same values through.
  51 //       In actuality, these are technically two different values:
  52 //       one on the raw protocol side, and the other part of the
  53 //       guaranteed Barry API.  If the Blackberry ever changes the
  54 //       meanings for these codes, do the translation here.
  55 //
  56
  57 Calendar::FreeBusyFlagType Calendar::FreeBusyFlagProto2Rec(uint8_t f)
  58 {
  59         return (FreeBusyFlagType)f;
  60 }
  61
  62 uint8_t Calendar::FreeBusyFlagRec2Proto(FreeBusyFlagType f)
  63 {
  64         return f;
  65 }
  66
  67 Calendar::ClassFlagType Calendar::ClassFlagProto2Rec(uint8_t f)
  68 {
  69         return (ClassFlagType)f;
  70 }
  71
  72 uint8_t Calendar::ClassFlagRec2Proto(ClassFlagType f)
  73 {
  74         return f;
  75 }
  76
  77
  78
  79 ///////////////////////////////////////////////////////////////////////////////
  80 // Calendar class
  81
  82 // calendar field codes
  83 #define CALFC_APPT_TYPE_FLAG            0x01
  84 #define CALFC_SUBJECT                   0x02
  85 #define CALFC_NOTES                     0x03
  86 #define CALFC_LOCATION                  0x04
  87 #define CALFC_NOTIFICATION_TIME         0x05
  88 #define CALFC_START_TIME                0x06
  89 #define CALFC_END_TIME                  0x07
  90 #define CALFC_ACCEPTED_BY               0x0b
  91 #define CALFC_VERSION_DATA              0x10
  92 #define CALFC_INVITED                   0x15
  93 #define CALFC_ORGANIZER                 0x16
  94 #define CALFC_NOTIFICATION_DATA         0x1a
  95 #define CALFC_FREEBUSY_FLAG             0x1c
  96 #define CALFC_TIMEZONE_CODE             0x1e    // only seems to show up if recurring
  97 #define CALFC_CLASS_FLAG                0x28    // private flag from outlook
  98 #define CALFC_ALLDAYEVENT_FLAG          0xff
  99 #define CALFC_END                       0xffff
 100
 101 static FieldLink<Calendar> CalendarFieldLinks[] = {
 102    { CALFC_SUBJECT,    "Subject",    0, 0,    &Calendar::Subject, 0, 0, 0, 0, true },
 103    { CALFC_NOTES,      "Notes",      0, 0,    &Calendar::Notes, 0, 0, 0, 0, true },
 104    { CALFC_LOCATION,   "Location",   0, 0,    &Calendar::Location, 0, 0, 0, 0, true },
 105    { CALFC_NOTIFICATION_TIME,"Notification Time",0,0, 0, 0, &Calendar::NotificationTime, 0, 0, false },
 106    { CALFC_START_TIME, "Start Time", 0, 0,    0, 0, &Calendar::StartTime, 0, 0, false },
 107    { CALFC_END_TIME,   "End Time",   0, 0,    0, 0, &Calendar::EndTime, 0, 0, false },
 108    { CALFC_ORGANIZER,  "Organizer",  0, 0,    0, &Calendar::Organizer, 0, 0, 0, true },
 109    { CALFC_ACCEPTED_BY,"Accepted By",0, 0,    0, &Calendar::AcceptedBy, 0, 0, 0, true },
 110    { CALFC_INVITED,    "Invited",    0, 0,    0, &Calendar::Invited, 0, 0, 0, true },
 111    { CALFC_END,        "End of List",0, 0,    0, 0, 0, 0, 0, false }
 112 };
 113
 114 Calendar::Calendar()
 115 {
 116         Clear();
 117 }
 118
 119 Calendar::~Calendar()
 120 {
 121 }
 122
 123 const unsigned char* Calendar::ParseField(const unsigned char *begin,
 124                                           const unsigned char *end,
 125                                           const IConverter *ic)
 126 {
 127         const CommonField *field = (const CommonField *) begin;
 128
 129         // advance and check size
 130         begin += COMMON_FIELD_HEADER_SIZE + btohs(field->size);
 131         if( begin > end )               // if begin==end, we are ok
 132                 return begin;
 133
 134         if( !btohs(field->size) )       // if field has no size, something's up
 135                 return begin;
 136
 137         // cycle through the type table
 138         for(    FieldLink<Calendar> *b = CalendarFieldLinks;
 139                 b->type != CALFC_END;
 140                 b++ )
 141         {
 142                 if( b->type == field->type ) {
 143                         if( b->strMember ) {
 144                                 std::string &s = this->*(b->strMember);
 145                                 s = ParseFieldString(field);
 146                                 if( b->iconvNeeded && ic )
 147                                         s = ic->FromBB(s);
 148                                 return begin;   // done!
 149                         }
 150                         else if( b->timeMember && btohs(field->size) == 4 ) {
 151                                 time_t &t = this->*(b->timeMember);
 152                                 dout("min1900: " << field->u.min1900);
 153                                 t = min2time(field->u.min1900);
 154                                 return begin;
 155                         }
 156                         else if( b->addrMember ) {
 157                                 //
 158                                 // parse email address
 159                                 // get dual addr+name string first
 160                                 // Note: this is a different format than
 161                                 // used in r_message*.cc
 162                                 //
 163                                 std::string dual((const char*)field->u.raw, btohs(field->size));
 164
 165                                 EmailAddress a;
 166
 167                                 // assign first string, using null terminator
 168                                 // letting std::string add it for us if it
 169                                 // doesn't exist
 170                                 a.Email = dual.c_str();
 171
 172                                 // assign second string, using first size
 173                                 // as starting point
 174                                 a.Name = dual.c_str() + a.Email.size() + 1;
 175
 176                                 // if the address is non-empty, add to list
 177                                 if( a.size() ) {
 178                                         // i18n convert if needed
 179                                         if( b->iconvNeeded && ic ) {
 180                                                 a.Name = ic->FromBB(a.Name);
 181                                                 a.Email = ic->FromBB(a.Email);
 182                                         }
 183
 184                                         EmailAddressList &al = this->*(b->addrMember);
 185                                         al.push_back(a);
 186                                 }
 187
 188                                 return begin;
 189                         }
 190                 }
 191         }
 192
 193         // handle special cases
 194         switch( field->type )
 195         {
 196         case CALFC_APPT_TYPE_FLAG:
 197                 switch( field->u.raw[0] )
 198                 {
 199                 case 'a':                       // regular non-recurring appointment
 200                         Recurring = false;
 201                         return begin;
 202
 203                 case '*':                       // recurring appointment
 204                         Recurring = true;
 205                         return begin;
 206
 207                 default:
 208                         throw Error("Calendar::ParseField: unknown appointment type");
 209                 }
 210                 break;
 211
 212         case CALFC_ALLDAYEVENT_FLAG:
 213                 AllDayEvent = field->u.raw[0] == 1;
 214                 return begin;
 215
 216         case CALFC_TIMEZONE_CODE:
 217                 if( btohs(field->size) == 2 ) {
 218                         // good data
 219                         TimeZoneCode = btohs(field->u.code);
 220                         TimeZoneValid = true;
 221                 }
 222                 else {
 223                         throw Error("Calendar::ParseField: not enough data in time zone code field");
 224                 }
 225                 return begin;
 226
 227         case CALFC_FREEBUSY_FLAG:
 228                 if( field->u.raw[0] > CR_FREEBUSY_RANGE_HIGH ) {
 229                         throw Error("Calendar::ParseField: FreeBusyFlag out of range" );
 230                 }
 231                 FreeBusyFlag = FreeBusyFlagProto2Rec(field->u.raw[0]);
 232                 return begin;
 233
 234         case CALFC_CLASS_FLAG:
 235                 if( field->u.raw[0] > CR_CLASS_RANGE_HIGH ) {
 236                         throw Error("Calendar::ParseField: ClassFlag out of range" );
 237                 }
 238                 ClassFlag = ClassFlagProto2Rec(field->u.raw[0]);
 239                 return begin;
 240         }
 241
 242         // base class handles recurring data
 243         if( RecurBase::ParseField(field->type, field->u.raw, btohs(field->size), ic) )
 244                 return begin;
 245
 246         // if still not handled, add to the Unknowns list
 247         UnknownField uf;
 248         uf.type = field->type;
 249         uf.data.assign((const char*)field->u.raw, btohs(field->size));
 250         Unknowns.push_back(uf);
 251
 252         // return new pointer for next field
 253         return begin;
 254 }
 255
 256 void Calendar::ParseHeader(const Data &data, size_t &offset)
 257 {
 258         // no header in Calendar records
 259 }
 260
 261 void Calendar::ParseFields(const Data &data, size_t &offset, const IConverter *ic)
 262 {
 263         const unsigned char *finish = ParseCommonFields(*this,
 264                 data.GetData() + offset, data.GetData() + data.GetSize(), ic);
 265         offset += finish - (data.GetData() + offset);
 266 }
 267
 268 void Calendar::BuildHeader(Data &data, size_t &offset) const
 269 {
 270         // no header in Calendar records
 271 }
 272
 273 //
 274 // Build
 275 //
 276 /// Build fields part of record.
 277 ///
 278 void Calendar::BuildFields(Data &data, size_t &offset, const IConverter *ic) const
 279 {
 280         data.Zap();
 281
 282         // output the type first
 283         BuildField(data, offset, CALFC_APPT_TYPE_FLAG, Recurring ? '*' : 'a');
 284
 285         // output all day event flag only if set
 286         if( AllDayEvent )
 287                 BuildField(data, offset, CALFC_ALLDAYEVENT_FLAG, (char)1);
 288
 289         // cycle through the type table
 290         for(    const FieldLink<Calendar> *b = CalendarFieldLinks;
 291                 b->type != CALFC_END;
 292                 b++ )
 293         {
 294                 if( b->strMember ) {
 295                         const std::string &s = this->*(b->strMember);
 296                         if( s.size() )
 297                                 BuildField(data, offset, b->type, (b->iconvNeeded && ic) ? ic->ToBB(s) : s);
 298                 }
 299                 else if( b->timeMember ) {
 300                         time_t t = this->*(b->timeMember);
 301                         if( t > 0 )
 302                                 BuildField1900(data, offset, b->type, t);
 303                 }
 304                 else if( b->addrMember ) {
 305                         const EmailAddressList &al = this->*(b->addrMember);
 306                         EmailAddressList::const_iterator lb = al.begin(), le = al.end();
 307
 308                         // add all entries in list
 309                         for( ; lb != le; ++lb ) {
 310
 311                                 // skip empty entries
 312                                 if( !lb->size() )
 313                                         continue;
 314
 315                                 std::string Name = lb->Name,
 316                                         Email = lb->Email;
 317
 318                                 // do i18n conversion only if needed
 319                                 if( b->iconvNeeded && ic ) {
 320                                         Name = ic->ToBB(Name);
 321                                         Email = ic->ToBB(Email);
 322                                 }
 323
 324                                 //
 325                                 // Build an addr+name field, each string
 326                                 // null terminated.
 327                                 // Note: this is a different format than
 328                                 // what is used in r_message*.cc
 329                                 //
 330                                 std::string field(lb->Email.c_str(), lb->Email.size() + 1);
 331                                 field.append(lb->Name.c_str(), lb->Name.size() + 1);
 332                                 BuildField(data, offset, b->type, field.data(), field.size());
 333                         }
 334                 }
 335         }
 336
 337         // handle special cases
 338         if( Recurring ) {
 339                 CalendarRecurrenceDataField recur;
 340                 BuildRecurrenceData(StartTime, &recur);
 341                 BuildField(data, offset, RecurBase::RecurringFieldType(),
 342                         &recur, CALENDAR_RECURRENCE_DATA_FIELD_SIZE);
 343         }
 344
 345         if( TimeZoneValid )
 346                 BuildField(data, offset, CALFC_TIMEZONE_CODE, TimeZoneCode);
 347
 348         BuildField(data, offset, CALFC_FREEBUSY_FLAG, FreeBusyFlagRec2Proto(FreeBusyFlag));
 349         BuildField(data, offset, CALFC_CLASS_FLAG, ClassFlagRec2Proto(ClassFlag));
 350
 351         // and finally save unknowns
 352         UnknownsType::const_iterator
 353                 ub = Unknowns.begin(), ue = Unknowns.end();
 354         for( ; ub != ue; ub++ ) {
 355                 BuildField(data, offset, *ub);
 356         }
 357
 358         data.ReleaseBuffer(offset);
 359 }
 360
 361 void Calendar::Clear()
 362 {
 363         RecurBase::Clear();
 364
 365         RecType = Calendar::GetDefaultRecType();
 366
 367         AllDayEvent = false;
 368         Subject.clear();
 369         Notes.clear();
 370         Location.clear();
 371         NotificationTime = StartTime = EndTime = 0;
 372
 373         FreeBusyFlag = Free;
 374         ClassFlag = Public;
 375
 376         TimeZoneCode = GetTimeZoneCode(0, 0);   // default to GMT
 377         TimeZoneValid = false;
 378
 379         Unknowns.clear();
 380 }
 381
 382 void Calendar::Dump(std::ostream &os) const
 383 {
 384         static const char *ClassTypes[] = { "Public", "Confidential", "Private" };
 385         static const char *FreeBusy[] = { "Free", "Tentative", "Busy", "Out of Office" };
 386
 387 // FIXME - need a "check all data" function that make sure that all
 388 // recurrence data is within range.  Then call that before using
 389 // the data, such as in Build and in Dump.
 390
 391         os << "Calendar entry: 0x" << setbase(16) << RecordId
 392                 << " (" << (unsigned int)RecType << ")\n";
 393         os << "   All Day Event: " << (AllDayEvent ? "yes" : "no") << "\n";
 394         os << "   Class: " << ClassTypes[ClassFlag] << "\n";
 395         os << "   Free/Busy: " << FreeBusy[FreeBusyFlag] << "\n";
 396         if( TimeZoneValid )
 397                 os << "   Time Zone: " << GetTimeZone(TimeZoneCode)->Name << "\n";
 398
 399         // cycle through the type table
 400         for(    const FieldLink<Calendar> *b = CalendarFieldLinks;
 401                 b->type != CALFC_END;
 402                 b++ )
 403         {
 404                 if( b->strMember ) {
 405                         const std::string &s = this->*(b->strMember);
 406                         if( s.size() )
 407                                 os << "   " << b->name << ": " << s << "\n";
 408                 }
 409                 else if( b->timeMember ) {
 410                         time_t t = this->*(b->timeMember);
 411                         if( t > 0 )
 412                                 os << "   " << b->name << ": " << ctime(&t);
 413                         else
 414                                 os << "   " << b->name << ": disabled\n";
 415                 }
 416                 else if( b->addrMember ) {
 417                         const EmailAddressList &al = this->*(b->addrMember);
 418                         EmailAddressList::const_iterator lb = al.begin(), le = al.end();
 419
 420                         for( ; lb != le; ++lb ) {
 421                                 if( !lb->size() )
 422                                         continue;
 423
 424                                 os << "   " << b->name << ": " << *lb << "\n";
 425                         }
 426                 }
 427         }
 428
 429         // print recurrence data if available
 430         RecurBase::Dump(os);
 431
 432         // print any unknowns
 433         os << Unknowns;
 434 }
 435
 436
 437 } // namespace Barry
 438