src/r_calllog.cc

   1 ///
   2 /// \file       r_calllog.cc
   3 ///             Record parsing class for the phone call logs database.
   4 ///
   5
   6 /*
   7     Copyright (C) 2008-2009, Nicolas VIVIEN
   8     Copyright (C) 2005-2012, 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 #include "r_calllog.h"
  24 #include "record-internal.h"
  25 #include "protostructs.h"
  26 #include "data.h"
  27 #include "time.h"
  28 #include "iconv.h"
  29 #include <ostream>
  30 #include <iomanip>
  31 #include "ios_state.h"
  32
  33 using namespace std;
  34 using namespace Barry::Protocol;
  35
  36 namespace Barry {
  37
  38 #define MILLISECONDS_IN_A_SECOND 1000
  39
  40 time_t CallLog::GetTime() const
  41 {
  42         return (time_t)(Timestamp / MILLISECONDS_IN_A_SECOND);
  43 }
  44
  45 CallLog::DirectionFlagType CallLog::DirectionProto2Rec(uint8_t s)
  46 {
  47         return (DirectionFlagType)s;
  48 }
  49
  50 uint8_t CallLog::DirectionRec2Proto(DirectionFlagType s)
  51 {
  52         return s;
  53 }
  54
  55 CallLog::PhoneTypeFlagType CallLog::PhoneTypeProto2Rec(uint8_t s)
  56 {
  57         return (PhoneTypeFlagType)s;
  58 }
  59
  60 uint8_t CallLog::PhoneTypeRec2Proto(PhoneTypeFlagType s)
  61 {
  62         return s;
  63 }
  64
  65
  66 ///////////////////////////////////////////////////////////////////////////////
  67 // CallLog Class
  68
  69 // CallLog Field Codes
  70 #define CLLFC_CALLLOG_TYPE              0x01
  71 #define CLLFC_DIRECTION                 0x02
  72 #define CLLFC_DURATION                  0x03
  73 #define CLLFC_TIMESTAMP                 0x04
  74 #define CLLFC_STATUS                    0x06
  75 #define CLLFC_UNIQUEID                  0x07
  76 #define CLLFC_PHONE_TYPE                0x0b
  77 #define CLLFC_PHONE_NUMBER              0x0c
  78 #define CLLFC_PHONE_INFO                0x0d
  79 #define CLLFC_CONTACT_NAME              0x1f
  80 #define CLLFC_END                       0xffff
  81
  82 static FieldLink<CallLog> CallLogFieldLinks[] = {
  83     { CLLFC_PHONE_NUMBER,       "Phone number",  0, 0, &CallLog::PhoneNumber, 0, 0, 0, 0, true },
  84     { CLLFC_CONTACT_NAME,       "Contact name",  0, 0, &CallLog::ContactName, 0, 0, 0, 0, true },
  85     { CLLFC_END,                "End of List",   0, 0, 0, 0, 0, 0, 0, false }
  86 };
  87
  88 CallLog::CallLog()
  89 {
  90         Clear();
  91 }
  92
  93 CallLog::~CallLog()
  94 {
  95 }
  96
  97 const unsigned char* CallLog::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         if( field->type == CLLFC_CALLLOG_TYPE ) {
 112                 if( field->u.raw[0] != 'p' ) {
 113                         throw Error( "CallLog::ParseField: CallLogType is not 'p'" );
 114                 }
 115                 return begin;
 116         }
 117
 118         // this is always the same as the RecordID from the lower level
 119         // protocol, so we throw this away for now
 120         if( field->type == CLLFC_UNIQUEID)
 121                 return begin;
 122
 123         // cycle through the type table
 124         for(    FieldLink<CallLog> *b = CallLogFieldLinks;
 125                 b->type != CLLFC_END;
 126                 b++ )
 127         {
 128                 if( b->type == field->type ) {
 129                         if( b->strMember ) {
 130                                 std::string &s = this->*(b->strMember);
 131                                 s = ParseFieldString(field);
 132                                 if( b->iconvNeeded && ic )
 133                                         s = ic->FromBB(s);
 134                                 return begin;   // done!
 135                         }
 136                         else if( b->timeMember && btohs(field->size) == 4 ) {
 137                                 TimeT &t = this->*(b->timeMember);
 138                                 t.Time = min2time(field->u.min1900);
 139                                 return begin;
 140                         }
 141                 }
 142         }
 143
 144         // handle special cases
 145         switch( field->type )
 146         {
 147         case CLLFC_STATUS:
 148                 // single byte... size check above checks for non-zero already
 149                 switch (field->u.raw[0]) {
 150                 case 0x00:
 151                         StatusFlag = Barry::CallLog::OK;
 152                         break;
 153                 case 0x01:
 154                         StatusFlag = Barry::CallLog::Busy;
 155                         break;
 156                 case 0x09:
 157                         StatusFlag = Barry::CallLog::NetError;
 158                         break;
 159                 default:
 160                         StatusFlag = Barry::CallLog::Unknown;
 161                 }
 162                 return begin;
 163
 164         case CLLFC_DIRECTION:
 165                 if( field->u.raw[0] > CLL_DIRECTION_RANGE_HIGH ) {
 166                         throw Error( "CallLog::ParseField: direction field out of bounds" );
 167                 }
 168                 else {
 169                         DirectionFlag = DirectionProto2Rec(field->u.raw[0]);
 170                 }
 171                 return begin;
 172
 173         case CLLFC_PHONE_TYPE:
 174                 if( field->u.raw[0] > CLL_PHONETYPE_RANGE_HIGH ) {
 175                         PhoneTypeFlag = Barry::CallLog::TypeUnknown;
 176                 }
 177                 else {
 178                         PhoneTypeFlag = PhoneTypeProto2Rec(field->u.raw[0]);
 179                 }
 180                 return begin;
 181
 182         case CLLFC_PHONE_INFO:
 183                 switch (field->u.raw[0]) {
 184                 case 0x03:
 185                         PhoneInfoFlag = Barry::CallLog::InfoKnown;
 186                         break;
 187                 case 0x80:
 188                         PhoneInfoFlag = Barry::CallLog::InfoUnknown;
 189                         break;
 190                 case 0x40:
 191                         PhoneInfoFlag = Barry::CallLog::InfoPrivate;
 192                         break;
 193                 default:
 194                         PhoneInfoFlag = Barry::CallLog::InfoUndefined;
 195                 }
 196                 return begin;
 197
 198         case CLLFC_DURATION:
 199                 if( btohs(field->size) >= sizeof(field->u.uint32) ) {
 200                         Duration = btohl(field->u.uint32);
 201                         return begin;
 202                 }
 203                 break;
 204
 205         case CLLFC_TIMESTAMP:
 206                 if( btohs(field->size) >= sizeof(field->u.timestamp) ) {
 207                         Timestamp = btohll(field->u.timestamp);
 208                         return begin;
 209                 }
 210                 break;
 211         }
 212
 213         // if still not handled, add to the Unknowns list
 214         UnknownField uf;
 215         uf.type = field->type;
 216         uf.data.assign((const char*)field->u.raw, btohs(field->size));
 217         Unknowns.push_back(uf);
 218
 219         // return new pointer for next field
 220         return begin;
 221 }
 222
 223 void CallLog::ParseHeader(const Data &data, size_t &offset)
 224 {
 225         // no header in CallLog records
 226 }
 227
 228 void CallLog::ParseFields(const Data &data, size_t &offset, const IConverter *ic)
 229 {
 230         const unsigned char *finish = ParseCommonFields(*this,
 231                 data.GetData() + offset, data.GetData() + data.GetSize(), ic);
 232         offset += finish - (data.GetData() + offset);
 233 }
 234
 235 void CallLog::Validate() const
 236 {
 237 }
 238
 239 void CallLog::BuildHeader(Data &data, size_t &offset) const
 240 {
 241         // not yet implemented
 242 }
 243
 244 void CallLog::BuildFields(Data &data, size_t &offset, const IConverter *ic) const
 245 {
 246         // not yet implemented
 247 }
 248
 249 void CallLog::Dump(std::ostream &os) const
 250 {
 251         ios_format_state state(os);
 252
 253         uint32_t timestamp = Duration;
 254         int32_t days, hours, minutes, secondes;
 255
 256         static const char *DirectionName[] = { "Received", "Sent", "Call Missing (Messagerie)", "Call Missing" };
 257         static const char *StatusName[] = { "OK", "Busy", "Error", "Not supported by Barry" };
 258         static const char *PhoneInfoName[] = { "Undefined", "Known phone number", "Unknown phone number", "Private phone number" };
 259         static const char *PhoneTypeName[] = { "Unknown", "Office", "Home", "Mobile", "Not supported by Barry" };
 260
 261         os << "CallLog entry: 0x" << setbase(16) << RecordId
 262            << " (" << (unsigned int)RecType << ")\n";
 263
 264         time_t t = GetTime();
 265         os << "   Timestamp: " << ctime(&t);
 266         os << "   Direction: " << DirectionName[DirectionFlag] << "\n";
 267         os << "   Status: " << StatusName[StatusFlag] << "\n";
 268         os << "   Phone info: " << PhoneInfoName[PhoneInfoFlag] << "\n";
 269         os << "   Phone type: " << PhoneTypeName[PhoneTypeFlag] << "\n";
 270
 271         os << "   Duration: ";
 272
 273         // Days :
 274         days = (int) (timestamp / (60 * 60 * 24));
 275         timestamp = timestamp - (days * (60 * 60 * 24));
 276         // Hours :
 277         hours = (int) (timestamp / (60 * 60));
 278         timestamp = timestamp - (hours * (60 * 60));
 279         // Minutes :
 280         minutes = (int) (timestamp / 60);
 281         timestamp = timestamp - (minutes * 60);
 282         // Secondes :
 283         secondes = timestamp;
 284
 285         if (days > 1)
 286                 os << setbase(10) << days << " days ";
 287         else if (days > 0)
 288                 os << setbase(10) << days << " day ";
 289
 290         os << setfill ('0') << setw(2) << setbase(10) << hours;
 291         os << ":";
 292         os << setfill ('0') << setw(2) << setbase(10) << minutes;
 293         os << ":";
 294         os << setfill ('0') << setw(2) << setbase(10) << secondes;
 295         os << "\n";
 296
 297         // cycle through the type table
 298         for(    const FieldLink<CallLog> *b = CallLogFieldLinks;
 299                 b->type != CLLFC_END;
 300                 b++ )
 301         {
 302                 if( b->strMember ) {
 303                         const std::string &s = this->*(b->strMember);
 304                         if( s.size() )
 305                                 os << "   " << b->name << ": " << s << "\n";
 306                 }
 307                 else if( b->timeMember ) {
 308                         TimeT t = this->*(b->timeMember);
 309                         if( t.Time > 0 )
 310                                 os << "   " << b->name << ": " << t << "\n";
 311                         else
 312                                 os << "   " << b->name << ": unknown\n";
 313                 }
 314         }
 315
 316
 317         os << Unknowns;
 318         os << "\n\n";
 319 }
 320
 321 void CallLog::Clear()
 322 {
 323         RecType = GetDefaultRecType();
 324         RecordId = 0;
 325
 326         Duration = 0;
 327         Timestamp = 0;
 328
 329         ContactName.clear();
 330         PhoneNumber.clear();
 331
 332         DirectionFlag = Barry::CallLog::Receiver;
 333         StatusFlag = Barry::CallLog::Unknown;
 334         PhoneTypeFlag = Barry::CallLog::TypeUnknown;
 335         PhoneInfoFlag = Barry::CallLog::InfoUndefined;
 336
 337         Unknowns.clear();
 338 }
 339
 340 const FieldHandle<CallLog>::ListT& CallLog::GetFieldHandles()
 341 {
 342         static FieldHandle<CallLog>::ListT fhv;
 343
 344         if( fhv.size() )
 345                 return fhv;
 346
 347 #undef CONTAINER_OBJECT_NAME
 348 #define CONTAINER_OBJECT_NAME fhv
 349
 350 #undef RECORD_CLASS_NAME
 351 #define RECORD_CLASS_NAME CallLog
 352
 353         FHP(RecType, "Record Type Code");
 354         FHP(RecordId, "Unique Record ID");
 355
 356         FHD(Duration, "Duration of Call in Seconds", CLLFC_DURATION, false);
 357         FHD(Timestamp, "Timestamp of Call in Milliseconds", CLLFC_TIMESTAMP, false);
 358         FHD(ContactName, "Contact Name", CLLFC_CONTACT_NAME, true);
 359         FHD(PhoneNumber, "Phone Number", CLLFC_PHONE_NUMBER, true);
 360
 361         FHE(dft, DirectionFlagType, DirectionFlag, "Direction of Call");
 362         FHE_CONST(dft, Receiver, "Received Call");
 363         FHE_CONST(dft, Emitter, "Placed the Call");
 364         FHE_CONST(dft, Failed, "Failed Call");
 365         FHE_CONST(dft, Missing, "Missed Call");
 366
 367         FHE(sft, StatusFlagType, StatusFlag, "Status of Call");
 368         FHE_CONST(sft, OK, "OK");
 369         FHE_CONST(sft, Busy, "Busy");
 370         FHE_CONST(sft, NetError, "Network Error");
 371         FHE_CONST(sft, Unknown, "Unsupported Status");
 372
 373         FHE(ptf, PhoneTypeFlagType, PhoneTypeFlag, "Phone Type");
 374         FHE_CONST(ptf, TypeUndefined, "Undefined");
 375         FHE_CONST(ptf, TypeOffice, "Office");
 376         FHE_CONST(ptf, TypeHome, "Home");
 377         FHE_CONST(ptf, TypeMobile, "Mobile");
 378         FHE_CONST(ptf, TypeUnknown, "Unknown");
 379
 380         FHE(pif, PhoneInfoFlagType, PhoneInfoFlag, "Phone Info");
 381         FHE_CONST(pif, InfoUndefined, "Undefined");
 382         FHE_CONST(pif, InfoKnown, "Phone Number is Set");
 383         FHE_CONST(pif, InfoUnknown, "Phone Number Not Set");
 384         FHE_CONST(pif, InfoPrivate, "Phone Number is Private");
 385
 386         FHP(Unknowns, "Unknown Fields");
 387
 388         return fhv;
 389 }
 390
 391 std::string CallLog::GetDescription() const
 392 {
 393         return ContactName;
 394 }
 395
 396 } // namespace Barry
 397