src/record.cc

   1 ///
   2 /// \file       record.cc
   3 ///             Misc. Blackberry database record helper classes and functions.
   4 ///             Helps translate data from data packets to useful structures,
   5 ///             and back.
   6 ///
   7
   8 /*
   9     Copyright (C) 2005-2010, Net Direct Inc. (http://www.netdirect.ca/)
  10
  11     This program is free software; you can redistribute it and/or modify
  12     it under the terms of the GNU General Public License as published by
  13     the Free Software Foundation; either version 2 of the License, or
  14     (at your option) any later version.
  15
  16     This program is distributed in the hope that it will be useful,
  17     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  19
  20     See the GNU General Public License in the COPYING file at the
  21     root directory of this project for more details.
  22 */
  23
  24 #include "record.h"
  25 #include "record-internal.h"
  26 #include "protocol.h"
  27 #include "protostructs.h"
  28 #include "data.h"
  29 #include "time.h"
  30 #include "error.h"
  31 #include "endian.h"
  32 #include <sstream>
  33 #include <iomanip>
  34 #include <time.h>
  35 #include <string.h>
  36 #include <stdio.h>                      // for sscanf()
  37 #include <stdexcept>
  38
  39 #define __DEBUG_MODE__
  40 #include "debug.h"
  41
  42 using namespace std;
  43 using namespace Barry::Protocol;
  44
  45 namespace Barry {
  46
  47 BXEXPORT std::ostream& operator<< (std::ostream &os, const Cr2LfWrapper &str)
  48 {
  49         for(    std::string::const_iterator i = str.m_str.begin();
  50                 i != str.m_str.end() && *i;
  51                 i++)
  52         {
  53                 if( *i == '\r' )
  54                         os << '\n';
  55                 else
  56                         os << *i;
  57         }
  58         return os;
  59 }
  60
  61 //////////////////////////////////////////////////////////////////////////////
  62 // Field builder helper functions
  63
  64 void BuildField1900(Data &data, size_t &size, uint8_t type, time_t t)
  65 {
  66         size_t timesize = COMMON_FIELD_MIN1900_SIZE;
  67         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + timesize;
  68         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
  69         CommonField *field = (CommonField *) pd;
  70
  71         field->size = htobs(timesize);
  72         field->type = type;
  73         field->u.min1900 = time2min(t);
  74
  75         size += fieldsize;
  76 }
  77
  78 void BuildField(Data &data, size_t &size, uint8_t type, char c)
  79 {
  80         BuildField(data, size, type, (uint8_t)c);
  81 }
  82
  83 void BuildField(Data &data, size_t &size, uint8_t type, uint8_t c)
  84 {
  85         size_t strsize = 1;
  86         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + strsize;
  87         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
  88         CommonField *field = (CommonField *) pd;
  89
  90         field->size = htobs(strsize);
  91         field->type = type;
  92         memcpy(field->u.raw, &c, strsize);
  93
  94         size += fieldsize;
  95 }
  96
  97 void BuildField(Data &data, size_t &size, uint8_t type, uint16_t value)
  98 {
  99         size_t strsize = 2;
 100         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + strsize;
 101         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
 102         CommonField *field = (CommonField *) pd;
 103
 104         field->size = htobs(strsize);
 105         field->type = type;
 106
 107         uint16_t store = htobs(value);
 108         memcpy(field->u.raw, &store, strsize);
 109
 110         size += fieldsize;
 111 }
 112
 113 void BuildField(Data &data, size_t &size, uint8_t type, uint32_t value)
 114 {
 115         size_t strsize = 4;
 116         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + strsize;
 117         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
 118         CommonField *field = (CommonField *) pd;
 119
 120         field->size = htobl(strsize);
 121         field->type = type;
 122
 123         uint32_t store = htobl(value);
 124         memcpy(field->u.raw, &store, strsize);
 125
 126         size += fieldsize;
 127 }
 128
 129 void BuildField(Data &data, size_t &size, uint8_t type, uint64_t value)
 130 {
 131         size_t strsize = 8;
 132         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + strsize;
 133         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
 134         CommonField *field = (CommonField *) pd;
 135
 136         field->size = htobl(strsize);
 137         field->type = type;
 138
 139         uint64_t store = htobll(value);
 140         memcpy(field->u.raw, &store, strsize);
 141
 142         size += fieldsize;
 143 }
 144
 145 void BuildField(Data &data, size_t &size, uint8_t type, const std::string &str)
 146 {
 147         // include null terminator
 148         BuildField(data, size, type, str.c_str(), str.size() + 1);
 149 }
 150
 151 void BuildField(Data &data, size_t &size, uint8_t type,
 152                 const void *buf, size_t bufsize)
 153 {
 154         // include null terminator
 155         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + bufsize;
 156         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
 157         CommonField *field = (CommonField *) pd;
 158
 159         field->size = htobs(bufsize);
 160         field->type = type;
 161         memcpy(field->u.raw, buf, bufsize);
 162
 163         size += fieldsize;
 164 }
 165
 166 void BuildField(Data &data, size_t &size, const Barry::UnknownField &field)
 167 {
 168         BuildField(data, size, field.type,
 169                 field.data.raw_data.data(), field.data.raw_data.size());
 170 }
 171
 172 void BuildField(Data &data, size_t &size, uint8_t type, const Barry::Protocol::GroupLink &link)
 173 {
 174         size_t linksize = sizeof(Barry::Protocol::GroupLink);
 175         size_t fieldsize = COMMON_FIELD_HEADER_SIZE + linksize;
 176         unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
 177         CommonField *field = (CommonField *) pd;
 178
 179         field->size = htobs(linksize);
 180         field->type = type;
 181         field->u.link = link;
 182
 183         size += fieldsize;
 184 }
 185
 186 std::string ParseFieldString(const Barry::Protocol::CommonField *field)
 187 {
 188         // make no assumptions here, and pass the full size in as
 189         // the maxlen, even though 99% of the time, it will be a null...
 190         // this function can be used by non-null terminated strings as well
 191         return ParseFieldString(field->u.raw, btohs(field->size));
 192 }
 193
 194 std::string ParseFieldString(const void *data, uint16_t maxlen)
 195 {
 196         const char *str = (const char *)data;
 197
 198         // find last non-null character, since some fields
 199         // can have multiple null terminators
 200         while( maxlen && str[maxlen-1] == 0 )
 201                 maxlen--;
 202
 203         return std::string(str, maxlen);
 204 }
 205
 206
 207 ///////////////////////////////////////////////////////////////////////////////
 208 // UnknownField
 209
 210 std::ostream& operator<< (std::ostream &os, const std::vector<UnknownField> &unknowns)
 211 {
 212         std::vector<UnknownField>::const_iterator
 213                 ub = unknowns.begin(), ue = unknowns.end();
 214         if( ub != ue )
 215                 os << "    Unknowns:\n";
 216         for( ; ub != ue; ub++ ) {
 217                 os << "        Type: 0x" << setbase(16)
 218                    << (unsigned int) ub->type
 219                    << " Data:\n" << Data(ub->data.data(), ub->data.size());
 220         }
 221         return os;
 222 }
 223
 224
 225 ///////////////////////////////////////////////////////////////////////////////
 226 // EmailAddress class
 227
 228 std::ostream& operator<<(std::ostream &os, const EmailAddress &msga) {
 229         os << msga.Name << " <" << msga.Email << ">";
 230         return os;
 231 }
 232
 233 std::ostream& operator<<(std::ostream &os, const EmailAddressList &elist) {
 234         for( EmailAddressList::const_iterator i = elist.begin(); i != elist.end(); ++i ) {
 235                 if( i != elist.begin() )
 236                         os << ", ";
 237                 os << *i;
 238         }
 239         return os;
 240 }
 241
 242
 243 ///////////////////////////////////////////////////////////////////////////////
 244 // PostalAddress class
 245
 246 //
 247 // GetLabel
 248 //
 249 /// Format a mailing address into a single string, handling missing fields.
 250 ///
 251 std::string PostalAddress::GetLabel() const
 252 {
 253         std::string address = Address1;
 254         if( Address2.size() ) {
 255                 if( address.size() )
 256                         address += "\n";
 257                 address += Address2;
 258         }
 259         if( Address3.size() ) {
 260                 if( address.size() )
 261                         address += "\n";
 262                 address += Address3;
 263         }
 264         if( address.size() )
 265                 address += "\n";
 266         if( City.size() )
 267                 address += City + " ";
 268         if( Province.size() )
 269                 address += Province + " ";
 270         if( Country.size() )
 271                 address += Country;
 272         if( address.size() )
 273                 address += "\n";
 274         if( PostalCode.size() )
 275                 address += PostalCode;
 276
 277         return address;
 278 }
 279
 280 void PostalAddress::Clear()
 281 {
 282         Address1.clear();
 283         Address2.clear();
 284         Address3.clear();
 285         City.clear();
 286         Province.clear();
 287         PostalCode.clear();
 288         Country.clear();
 289 }
 290
 291 std::ostream& operator<<(std::ostream &os, const PostalAddress &post) {
 292         os << post.GetLabel();
 293         return os;
 294 }
 295
 296
 297
 298 ///////////////////////////////////////////////////////////////////////////////
 299 // Date class
 300
 301 Date::Date(const struct tm *timep)
 302 {
 303         FromTm(timep);
 304 }
 305
 306 void Date::Clear()
 307 {
 308         Month = Day = Year = 0;
 309 }
 310
 311 void Date::ToTm(struct tm *timep) const
 312 {
 313         memset(timep, 0, sizeof(tm));
 314         timep->tm_year = Year - 1900;
 315         timep->tm_mon = Month;
 316         timep->tm_mday = Day;
 317 }
 318
 319 std::string Date::ToYYYYMMDD() const
 320 {
 321         std::ostringstream oss;
 322         // setfill and setw not sticky.
 323         oss     << setw(4) << setfill('0') << Year
 324                 << setw(2) << setfill('0') << (Month + 1)
 325                 << setw(2) << setfill('0') << Day;
 326         return oss.str();
 327 }
 328
 329 //
 330 // ToBBString
 331 //
 332 /// The Blackberry stores Birthday and Anniversary date fields
 333 /// with the format: DD/MM/YYYY
 334 ///
 335 std::string Date::ToBBString() const
 336 {
 337         std::ostringstream oss;
 338         // setw() ain't 'sticky'!
 339         oss     << setw(2) << setfill('0') << Day << '/'
 340                 << setw(2) << setfill('0') << (Month + 1) << '/'
 341                 << setw(2) << setfill('0') << Year;
 342         return oss.str();
 343 }
 344
 345 bool Date::FromTm(const struct tm *timep)
 346 {
 347         if( !timep )
 348                 throw std::logic_error("NULL time pointer passed to Date::FromTm");
 349
 350         Year = timep->tm_year + 1900;
 351         Month = timep->tm_mon;
 352         Day = timep->tm_mday;
 353         return true;
 354 }
 355
 356 bool Date::FromBBString(const std::string &str)
 357 {
 358         int m, d, y;
 359         if( 3 == sscanf(str.c_str(), "%d/%d/%d", &d, &m, &y) ) {
 360                 Year = y;
 361                 Month = m - 1;
 362                 Day = d;
 363                 return true;
 364         }
 365         return false;
 366 }
 367
 368 bool Date::FromYYYYMMDD(const std::string &str)
 369 {
 370         int m, d, y;
 371         if( 3 == sscanf(str.c_str(), "%4d%2d%2d", &y, &m, &d) ) {
 372                 Year = y;
 373                 Month = m - 1;
 374                 Day = d;
 375                 return true;
 376         }
 377         return false;
 378 }
 379
 380 std::ostream& operator<<(std::ostream &os, const Date &date)
 381 {
 382         os      << setw(4) << dec << date.Year << '/'
 383                 << setw(2) << dec << (date.Month + 1) << '/'
 384                 << setw(2) << dec << date.Day;
 385         return os;
 386 }
 387
 388
 389 ///////////////////////////////////////////////////////////////////////////////
 390 // CategoryList class
 391
 392 /// Parses the given comma delimited category string into
 393 /// this CategoryList object, appending each token to the vector.
 394 /// Will clear vector beforehand.
 395 void CategoryList::CategoryStr2List(const std::string &str)
 396 {
 397         // start fresh
 398         clear();
 399
 400         if( !str.size() )
 401                 return;
 402
 403         // parse the comma-delimited string to a list, stripping away
 404         // any white space around each category name
 405         string::size_type start = 0, end = 0, delim = str.find(',', start);
 406         while( start != string::npos ) {
 407                 if( delim == string::npos )
 408                         end = str.size() - 1;
 409                 else
 410                         end = delim - 1;
 411
 412                 // strip surrounding whitespace
 413                 while( str[start] == ' ' )
 414                         start++;
 415                 while( end && str[end] == ' ' )
 416                         end--;
 417
 418                 if( start <= end ) {
 419                         string token = str.substr(start, end-start+1);
 420                         push_back(token);
 421                 }
 422
 423                 // next
 424                 start = delim;
 425                 if( start != string::npos )
 426                         start++;
 427                 delim = str.find(',', start);
 428         }
 429 }
 430
 431 /// Turns the current vectory into a comma delimited category
 432 /// string suitable for use in Calendar, Task, and Memo protocol values.
 433 void CategoryList::CategoryList2Str(std::string &str) const
 434 {
 435         str.clear();
 436
 437         Barry::CategoryList::const_iterator i = begin();
 438         for( ; i != end(); ++i ) {
 439                 if( str.size() )
 440                         str += ", ";
 441                 str += *i;
 442         }
 443 }
 444
 445
 446 } // namespace Barry
 447
 448
 449 #ifdef __TEST_MODE__
 450
 451 #include <iostream>
 452
 453 int main(int argc, char *argv[])
 454 {
 455         if( argc < 2 ) {
 456                 cerr << "Usage: test <datafile>" << endl;
 457                 return 1;
 458         }
 459
 460         std::vector<Data> array;
 461         if( !LoadDataArray(argv[1], array) ) {
 462                 cerr << "Unable to load file: " << argv[1] << endl;
 463                 return 1;
 464         }
 465
 466         cout << "Loaded " << array.size() << " items" << endl;
 467
 468         for( std::vector<Data>::iterator b = array.begin(), e = array.end();
 469                 b != e; b++ )
 470         {
 471                 Data &d = *b;
 472 //              cout << d << endl;
 473                 if( d.GetSize() > 13 && d.GetData()[6] == 0x4f ) {
 474                         Barry::Contact contact;
 475                         size_t size = 13;
 476                         contact.ParseFields(d, size);
 477                         cout << contact << endl;
 478                         contact.DumpLdif(cout, "ou=People,dc=example,dc=com");
 479                 }
 480                 else if( d.GetSize() > 13 && d.GetData()[6] == 0x44 ) {
 481                         Barry::Calendar cal;
 482                         size_t size = 13;
 483                         cal.ParseFields(d, size);
 484                         cout << cal << endl;
 485                 }
 486         }
 487 }
 488
 489 #endif
 490