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-2008, 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 <ostream>
  31 #include <iomanip>
  32 #include <time.h>
  33 #include <string.h>
  34 #include <stdexcept>
  35
  36 #define __DEBUG_MODE__
  37 #include "debug.h"
  38
  39 using namespace std;
  40 using namespace Barry::Protocol;
  41
  42 namespace Barry {
  43
  44
  45 ///////////////////////////////////////////////////////////////////////////////
  46 // Calendar class
  47
  48 // calendar field codes
  49 #define CALFC_APPT_TYPE_FLAG            0x01
  50 #define CALFC_SUBJECT                   0x02
  51 #define CALFC_NOTES                     0x03
  52 #define CALFC_LOCATION                  0x04
  53 #define CALFC_NOTIFICATION_TIME         0x05
  54 #define CALFC_START_TIME                0x06
  55 #define CALFC_END_TIME                  0x07
  56 #define CALFC_RECURRENCE_DATA           0x0c
  57 #define CALFC_VERSION_DATA              0x10
  58 #define CALFC_NOTIFICATION_DATA         0x1a
  59 #define CALFC_FREEBUSY_FLAG             0x1c
  60 #define CALFC_TIMEZONE_CODE             0x1e    // only seems to show up if recurring
  61 #define CALFC_CLASS_FLAG                0x28    // private flag from outlook
  62 #define CALFC_ALLDAYEVENT_FLAG          0xff
  63 #define CALFC_END                       0xffff
  64
  65 FieldLink<Calendar> CalendarFieldLinks[] = {
  66    { CALFC_SUBJECT,    "Subject",    0, 0,    &Calendar::Subject, 0, 0 },
  67    { CALFC_NOTES,      "Notes",      0, 0,    &Calendar::Notes, 0, 0 },
  68    { CALFC_LOCATION,   "Location",   0, 0,    &Calendar::Location, 0, 0 },
  69    { CALFC_NOTIFICATION_TIME,"Notification Time",0,0, 0, 0, &Calendar::NotificationTime },
  70    { CALFC_START_TIME, "Start Time", 0, 0,    0, 0, &Calendar::StartTime },
  71    { CALFC_END_TIME,   "End Time",   0, 0,    0, 0, &Calendar::EndTime },
  72    { CALFC_END,        "End of List",0, 0,    0, 0, 0 }
  73 };
  74
  75 Calendar::Calendar()
  76 {
  77         Clear();
  78 }
  79
  80 Calendar::~Calendar()
  81 {
  82 }
  83
  84 const unsigned char* Calendar::ParseField(const unsigned char *begin,
  85                                           const unsigned char *end)
  86 {
  87         const CommonField *field = (const CommonField *) begin;
  88
  89         // advance and check size
  90         begin += COMMON_FIELD_HEADER_SIZE + btohs(field->size);
  91         if( begin > end )               // if begin==end, we are ok
  92                 return begin;
  93
  94         if( !btohs(field->size) )       // if field has no size, something's up
  95                 return begin;
  96
  97         // cycle through the type table
  98         for(    FieldLink<Calendar> *b = CalendarFieldLinks;
  99                 b->type != CALFC_END;
 100                 b++ )
 101         {
 102                 if( b->type == field->type ) {
 103                         if( b->strMember ) {
 104                                 std::string &s = this->*(b->strMember);
 105                                 s = ParseFieldString(field);
 106                                 return begin;   // done!
 107                         }
 108                         else if( b->timeMember && btohs(field->size) == 4 ) {
 109                                 time_t &t = this->*(b->timeMember);
 110                                 dout("min1900: " << field->u.min1900);
 111                                 t = min2time(field->u.min1900);
 112                                 return begin;
 113                         }
 114                 }
 115         }
 116
 117         // handle special cases
 118         switch( field->type )
 119         {
 120         case CALFC_APPT_TYPE_FLAG:
 121                 switch( field->u.raw[0] )
 122                 {
 123                 case 'a':                       // regular non-recurring appointment
 124                         Recurring = false;
 125                         return begin;
 126
 127                 case '*':                       // recurring appointment
 128                         Recurring = true;
 129                         return begin;
 130
 131                 default:
 132                         throw Error("Calendar::ParseField: unknown appointment type");
 133                 }
 134                 break;
 135
 136         case CALFC_ALLDAYEVENT_FLAG:
 137                 AllDayEvent = field->u.raw[0] == 1;
 138                 return begin;
 139
 140         case CALFC_RECURRENCE_DATA:
 141                 if( btohs(field->size) >= CALENDAR_RECURRENCE_DATA_FIELD_SIZE ) {
 142                         // good data
 143                         ParseRecurrenceData(&field->u.raw[0]);
 144                 }
 145                 else {
 146                         // not enough data!
 147                         throw Error("Calendar::ParseField: not enough data in recurrence data field");
 148                 }
 149                 return begin;
 150
 151         case CALFC_TIMEZONE_CODE:
 152                 if( btohs(field->size) == 2 ) {
 153                         // good data
 154                         TimeZoneCode = btohs(field->u.code);
 155                 }
 156                 else {
 157                         throw Error("Calendar::ParseField: not enough data in time zone code field");
 158                 }
 159                 return begin;
 160
 161         case CALFC_FREEBUSY_FLAG:
 162                 FreeBusyFlag = (FreeBusyFlagType)field->u.raw[0];
 163                 if( FreeBusyFlag > OutOfOffice ) {
 164                         throw Error("Calendar::ParseField: FreeBusyFlag out of range" );
 165                 }
 166                 return begin;
 167
 168         case CALFC_CLASS_FLAG:
 169                 ClassFlag = (ClassFlagType)field->u.raw[0];
 170                 if( ClassFlag > Private ) {
 171                         throw Error("Calendar::ParseField: ClassFlag out of range" );
 172                 }
 173                 return begin;
 174         }
 175
 176         // if still not handled, add to the Unknowns list
 177         UnknownField uf;
 178         uf.type = field->type;
 179         uf.data.assign((const char*)field->u.raw, btohs(field->size));
 180         Unknowns.push_back(uf);
 181
 182         // return new pointer for next field
 183         return begin;
 184 }
 185
 186 // this function assumes the size has already been checked
 187 void Calendar::ParseRecurrenceData(const void *data)
 188 {
 189         const CalendarRecurrenceDataField *rec =
 190                 (const CalendarRecurrenceDataField*) data;
 191
 192         Interval = btohs(rec->interval);
 193         if( Interval < 1 )
 194                 Interval = 1;   // must always be >= 1
 195
 196         if( rec->endTime == 0xffffffff ) {
 197                 Perpetual = true;
 198         }
 199         else {
 200                 RecurringEndTime = min2time(rec->endTime);
 201                 Perpetual = false;
 202         }
 203
 204         switch( rec->type )
 205         {
 206         case CRDF_TYPE_DAY:
 207                 RecurringType = Day;
 208                 // no extra data
 209                 break;
 210
 211         case CRDF_TYPE_MONTH_BY_DATE:
 212                 RecurringType = MonthByDate;
 213                 DayOfMonth = rec->u.month_by_date.monthDay;
 214                 break;
 215
 216         case CRDF_TYPE_MONTH_BY_DAY:
 217                 RecurringType = MonthByDay;
 218                 DayOfWeek = rec->u.month_by_day.weekDay;
 219                 WeekOfMonth = rec->u.month_by_day.week;
 220                 break;
 221
 222         case CRDF_TYPE_YEAR_BY_DATE:
 223                 RecurringType = YearByDate;
 224                 DayOfMonth = rec->u.year_by_date.monthDay;
 225                 MonthOfYear = rec->u.year_by_date.month;
 226                 break;
 227
 228         case CRDF_TYPE_YEAR_BY_DAY:
 229                 RecurringType = YearByDay;
 230                 DayOfWeek = rec->u.year_by_day.weekDay;
 231                 WeekOfMonth = rec->u.year_by_day.week;
 232                 MonthOfYear = rec->u.year_by_day.month;
 233                 break;
 234
 235         case CRDF_TYPE_WEEK:
 236                 RecurringType = Week;
 237
 238                 // Note: this simple copy is only possible since
 239                 // the CAL_WD_* constants are the same as CRDF_WD_* constants.
 240                 // If this ever changes, this code will need to change.
 241                 WeekDays = rec->u.week.days;
 242                 break;
 243
 244         default:
 245                 eout("Unknown recurrence data type: " << rec->type);
 246                 throw Error("Unknown recurrence data type");
 247         }
 248 }
 249
 250 // this function assumes there is CALENDAR_RECURRENCE_DATA_FIELD_SIZE bytes
 251 // available in data
 252 void Calendar::BuildRecurrenceData(void *data) const
 253 {
 254         if( !Recurring )
 255                 throw Error("Calendar::BuildRecurrenceData: Attempting to build recurrence data on non-recurring record.");
 256
 257         CalendarRecurrenceDataField *rec = (CalendarRecurrenceDataField*) data;
 258
 259         // set all to zero
 260         memset(data, 0, CALENDAR_RECURRENCE_DATA_FIELD_SIZE);
 261
 262         rec->interval = htobs(Interval);
 263         rec->startTime = time2min(StartTime);
 264         if( Perpetual )
 265                 rec->endTime = 0xffffffff;
 266         else
 267                 rec->endTime = time2min(RecurringEndTime);
 268
 269         switch( RecurringType )
 270         {
 271         case Day:
 272                 rec->type = CRDF_TYPE_DAY;
 273                 // no extra data
 274                 break;
 275
 276         case MonthByDate:
 277                 rec->type = CRDF_TYPE_MONTH_BY_DATE;
 278                 rec->u.month_by_date.monthDay = DayOfMonth;
 279                 break;
 280
 281         case MonthByDay:
 282                 rec->type = CRDF_TYPE_MONTH_BY_DAY;
 283                 rec->u.month_by_day.weekDay = DayOfWeek;
 284                 rec->u.month_by_day.week = WeekOfMonth;
 285                 break;
 286
 287         case YearByDate:
 288                 rec->type = CRDF_TYPE_YEAR_BY_DATE;
 289                 rec->u.year_by_date.monthDay = DayOfMonth;
 290                 rec->u.year_by_date.month = MonthOfYear;
 291                 break;
 292
 293         case YearByDay:
 294                 rec->type = CRDF_TYPE_YEAR_BY_DAY;
 295                 rec->u.year_by_day.weekDay = DayOfWeek;
 296                 rec->u.year_by_day.week = WeekOfMonth;
 297                 rec->u.year_by_day.month = MonthOfYear;
 298                 break;
 299
 300         case Week:
 301                 rec->type = CRDF_TYPE_WEEK;
 302
 303                 // Note: this simple copy is only possible since
 304                 // the CAL_WD_* constants are the same as CRDF_WD_* constants.
 305                 // If this ever changes, this code will need to change.
 306                 rec->u.week.days = WeekDays;
 307                 break;
 308
 309         default:
 310                 eout("Calendar::BuildRecurrenceData: "
 311                         "Unknown recurrence data type: " << rec->type);
 312                 throw Error("Calendar::BuildRecurrenceData: Unknown recurrence data type");
 313         }
 314 }
 315
 316 void Calendar::ParseHeader(const Data &data, size_t &offset)
 317 {
 318         // no header in Calendar records
 319 }
 320
 321 void Calendar::ParseFields(const Data &data, size_t &offset)
 322 {
 323         const unsigned char *finish = ParseCommonFields(*this,
 324                 data.GetData() + offset, data.GetData() + data.GetSize());
 325         offset += finish - (data.GetData() + offset);
 326 }
 327
 328 void Calendar::BuildHeader(Data &data, size_t &offset) const
 329 {
 330         // no header in Calendar records
 331 }
 332
 333 //
 334 // Build
 335 //
 336 /// Build fields part of record.
 337 ///
 338 void Calendar::BuildFields(Data &data, size_t &offset) const
 339 {
 340         data.Zap();
 341
 342         // output the type first
 343         BuildField(data, offset, CALFC_APPT_TYPE_FLAG, Recurring ? '*' : 'a');
 344
 345         // output all day event flag only if set
 346         if( AllDayEvent )
 347                 BuildField(data, offset, CALFC_ALLDAYEVENT_FLAG, (char)1);
 348
 349         // cycle through the type table
 350         for(    const FieldLink<Calendar> *b = CalendarFieldLinks;
 351                 b->type != CALFC_END;
 352                 b++ )
 353         {
 354                 if( b->strMember ) {
 355                         const std::string &s = this->*(b->strMember);
 356                         if( s.size() )
 357                                 BuildField(data, offset, b->type, s);
 358                 }
 359                 else if( b->timeMember ) {
 360                         time_t t = this->*(b->timeMember);
 361                         if( t > 0 )
 362                                 BuildField1900(data, offset, b->type, t);
 363                 }
 364         }
 365
 366         // handle special cases
 367
 368         if( Recurring ) {
 369                 CalendarRecurrenceDataField recur;
 370                 BuildRecurrenceData(&recur);
 371                 BuildField(data, offset, CALFC_RECURRENCE_DATA,
 372                         &recur, CALENDAR_RECURRENCE_DATA_FIELD_SIZE);
 373         }
 374
 375         if( TimeZoneValid )
 376                 BuildField(data, offset, CALFC_TIMEZONE_CODE, TimeZoneCode);
 377
 378         BuildField(data, offset, CALFC_FREEBUSY_FLAG, (char)FreeBusyFlag);
 379         BuildField(data, offset, CALFC_CLASS_FLAG, (char)ClassFlag);
 380
 381         // and finally save unknowns
 382         UnknownsType::const_iterator
 383                 ub = Unknowns.begin(), ue = Unknowns.end();
 384         for( ; ub != ue; ub++ ) {
 385                 BuildField(data, offset, *ub);
 386         }
 387
 388         data.ReleaseBuffer(offset);
 389 }
 390
 391 void Calendar::Clear()
 392 {
 393         RecType = Calendar::GetDefaultRecType();
 394
 395         AllDayEvent = false;
 396         Subject.clear();
 397         Notes.clear();
 398         Location.clear();
 399         NotificationTime = StartTime = EndTime = 0;
 400
 401         FreeBusyFlag = Free;
 402         ClassFlag = Public;
 403
 404         Recurring = false;
 405         RecurringType = Calendar::Week;
 406         Interval = 1;
 407         RecurringEndTime = 0;
 408         Perpetual = false;
 409         TimeZoneCode = GetTimeZoneCode(0, 0);   // default to GMT
 410         TimeZoneValid = false;
 411         DayOfWeek = WeekOfMonth = DayOfMonth = MonthOfYear = 0;
 412         WeekDays = 0;
 413
 414         Unknowns.clear();
 415 }
 416
 417 void Calendar::Dump(std::ostream &os) const
 418 {
 419         static const char *DayNames[] = { "Sun", "Mon", "Tue", "Wed",
 420                 "Thu", "Fri", "Sat" };
 421         static const char *MonthNames[] = { "Jan", "Feb", "Mar", "Apr",
 422                 "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
 423         static const char *ClassTypes[] = { "Public", "Confidential", "Private" };
 424         static const char *FreeBusy[] = { "Free", "Tentative", "Busy", "Out of Office" };
 425
 426 // FIXME - need a "check all data" function that make sure that all
 427 // recurrence data is within range.  Then call that before using
 428 // the data, such as in Build and in Dump.
 429
 430         os << "Calendar entry: 0x" << setbase(16) << RecordId
 431                 << " (" << (unsigned int)RecType << ")\n";
 432         os << "   All Day Event: " << (AllDayEvent ? "yes" : "no") << "\n";
 433         os << "   Class: " << ClassTypes[ClassFlag] << "\n";
 434         os << "   Free/Busy: " << FreeBusy[FreeBusyFlag] << "\n";
 435         if( TimeZoneValid )
 436                 os << "   Time Zone: " << GetTimeZone(TimeZoneCode)->Name << "\n";
 437
 438         // cycle through the type table
 439         for(    const FieldLink<Calendar> *b = CalendarFieldLinks;
 440                 b->type != CALFC_END;
 441                 b++ )
 442         {
 443                 if( b->strMember ) {
 444                         const std::string &s = this->*(b->strMember);
 445                         if( s.size() )
 446                                 os << "   " << b->name << ": " << s << "\n";
 447                 }
 448                 else if( b->timeMember ) {
 449                         time_t t = this->*(b->timeMember);
 450                         if( t > 0 )
 451                                 os << "   " << b->name << ": " << ctime(&t);
 452                         else
 453                                 os << "   " << b->name << ": disabled\n";
 454                 }
 455         }
 456
 457         // print recurrence data if available
 458         os << "   Recurring: " << (Recurring ? "yes" : "no") << "\n";
 459         if( Recurring ) {
 460                 switch( RecurringType )
 461                 {
 462                 case Day:
 463                         os << "      Every day.\n";
 464                         break;
 465
 466                 case MonthByDate:
 467                         os << "      Every month on the "
 468                            << DayOfMonth
 469                            << (DayOfMonth == 1 ? "st" : "")
 470                            << (DayOfMonth == 2 ? "nd" : "")
 471                            << (DayOfMonth == 3 ? "rd" : "")
 472                            << (DayOfMonth > 3  ? "th" : "")
 473                            << "\n";
 474                         break;
 475
 476                 case MonthByDay:
 477                         os << "      Every month on the "
 478                            << DayNames[DayOfWeek]
 479                            << " of week "
 480                            << WeekOfMonth
 481                            << "\n";
 482                         break;
 483
 484                 case YearByDate:
 485                         os << "      Every year on "
 486                            << MonthNames[MonthOfYear-1]
 487                            << " " << DayOfMonth << "\n";
 488                         break;
 489
 490                 case YearByDay:
 491                         os << "      Every year in " << MonthNames[MonthOfYear-1]
 492                            << " on "
 493                            << DayNames[DayOfWeek]
 494                            << " of week " << WeekOfMonth << "\n";
 495                         break;
 496
 497                 case Week:
 498                         os << "      Every week on: ";
 499                         if( WeekDays & CAL_WD_SUN ) os << "Sun ";
 500                         if( WeekDays & CAL_WD_MON ) os << "Mon ";
 501                         if( WeekDays & CAL_WD_TUE ) os << "Tue ";
 502                         if( WeekDays & CAL_WD_WED ) os << "Wed ";
 503                         if( WeekDays & CAL_WD_THU ) os << "Thu ";
 504                         if( WeekDays & CAL_WD_FRI ) os << "Fri ";
 505                         if( WeekDays & CAL_WD_SAT ) os << "Sat ";
 506                         os << "\n";
 507                         break;
 508
 509                 default:
 510                         os << "      Unknown recurrence type\n";
 511                         break;
 512                 }
 513
 514                 os << "      Interval: " << Interval << "\n";
 515
 516                 if( Perpetual )
 517                         os << "      Ends: never\n";
 518                 else
 519                         os << "      Ends: "
 520                            << ctime(&RecurringEndTime);
 521         }
 522
 523         // print any unknowns
 524         os << Unknowns;
 525 }
 526
 527
 528 } // namespace Barry
 529