?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- opensync module work:
[barry.git] / src / record.cc
blobbce7dfdfaf227edf4cdf55dfac77633bfadd10eb
1 ///
2 /// \file record.cc
3 /// Blackberry database record classes. Help translate data
4 /// from data packets to useful structurs, and back.
5 ///
6
7 /*
8 Copyright (C) 2005-2007, 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 "record.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 <stdexcept>
34
35 #define __DEBUG_MODE__
36 #include "debug.h"
37
38 using namespace std;
39 using namespace Barry::Protocol;
40
41 namespace Barry {
42
43 std::ostream& operator<<(std::ostream &os, const Message::Address &msga) {
44 os << msga.Name.c_str() << " <" << msga.Email.c_str() << ">";
45 return os;
46 }
47
48
49
50 template <class Record>
51 const unsigned char* ParseCommonFields(Record &rec, const void *begin, const void *end)
52 {
53 const unsigned char *b = (const unsigned char*) begin;
54 const unsigned char *e = (const unsigned char*) end;
55
56 while( (b + COMMON_FIELD_HEADER_SIZE) < e )
57 b = rec.ParseField(b, e);
58 return b;
59 }
60
61 void BuildField1900(Data &data, size_t &size, uint8_t type, time_t t)
62 {
63 size_t timesize = COMMON_FIELD_MIN1900_SIZE;
64 size_t fieldsize = COMMON_FIELD_HEADER_SIZE + timesize;
65 unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
66 CommonField *field = (CommonField *) pd;
67
68 field->size = htobs(timesize);
69 field->type = type;
70 field->u.min1900 = time2min(t);
71
72 size += fieldsize;
73 }
74
75 void BuildField(Data &data, size_t &size, uint8_t type, char c)
76 {
77 size_t strsize = 1;
78 size_t fieldsize = COMMON_FIELD_HEADER_SIZE + strsize;
79 unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
80 CommonField *field = (CommonField *) pd;
81
82 field->size = htobs(strsize);
83 field->type = type;
84 memcpy(field->u.raw, &c, strsize);
85
86 size += fieldsize;
87 }
88
89 void BuildField(Data &data, size_t &size, uint8_t type, const std::string &str)
90 {
91 // include null terminator
92 size_t strsize = str.size() + 1;
93 size_t fieldsize = COMMON_FIELD_HEADER_SIZE + strsize;
94 unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
95 CommonField *field = (CommonField *) pd;
96
97 field->size = htobs(strsize);
98 field->type = type;
99 memcpy(field->u.raw, str.c_str(), strsize);
100
101 size += fieldsize;
102 }
103
104 void BuildField(Data &data, size_t &size, uint8_t type, const Barry::Protocol::GroupLink &link)
105 {
106 size_t linksize = sizeof(Barry::Protocol::GroupLink);
107 size_t fieldsize = COMMON_FIELD_HEADER_SIZE + linksize;
108 unsigned char *pd = data.GetBuffer(size + fieldsize) + size;
109 CommonField *field = (CommonField *) pd;
110
111 field->size = htobs(linksize);
112 field->type = type;
113 field->u.link = link;
114
115 size += fieldsize;
116 }
117
118
119 ///////////////////////////////////////////////////////////////////////////////
120 // CommandTable class
121
122
123 CommandTable::CommandTable()
124 {
125 }
126
127 CommandTable::~CommandTable()
128 {
129 }
130
131 const unsigned char* CommandTable::ParseField(const unsigned char *begin,
132 const unsigned char *end)
133 {
134 // check if there is enough data for a header
135 const unsigned char *headend = begin + sizeof(CommandTableField);
136 if( headend > end )
137 return headend;
138
139 const CommandTableField *field = (const CommandTableField *) begin;
140
141 // advance and check size
142 begin += COMMAND_FIELD_HEADER_SIZE + field->size; // size is byte
143 if( begin > end ) // if begin==end, we are ok
144 return begin;
145
146 if( !field->size ) // if field has no size, something's up
147 return begin;
148
149 Command command;
150 command.Code = field->code;
151 command.Name.assign((const char *)field->name, field->size);
152 Commands.push_back(command);
153 return begin;
154 }
155
156 void CommandTable::Parse(const Data &data, size_t offset)
157 {
158 if( offset >= data.GetSize() )
159 return;
160
161 const unsigned char *begin = data.GetData() + offset;
162 const unsigned char *end = data.GetData() + data.GetSize();
163
164 while( begin < end )
165 begin = ParseField(begin, end);
166 }
167
168 void CommandTable::Clear()
169 {
170 Commands.clear();
171 }
172
173 unsigned int CommandTable::GetCommand(const std::string &name) const
174 {
175 CommandArrayType::const_iterator b = Commands.begin();
176 for( ; b != Commands.end(); b++ )
177 if( b->Name == name )
178 return b->Code;
179 return 0;
180 }
181
182 void CommandTable::Dump(std::ostream &os) const
183 {
184 CommandArrayType::const_iterator b = Commands.begin();
185 os << "Command table:\n";
186 for( ; b != Commands.end(); b++ ) {
187 os << " Command: 0x" << setbase(16) << b->Code
188 << " '" << b->Name << "'\n";
189 }
190 }
191
192
193
194
195 ///////////////////////////////////////////////////////////////////////////////
196 // RecordStateTable class
197
198 RecordStateTable::RecordStateTable()
199 : m_LastNewRecordId(1)
200 {
201 }
202
203 RecordStateTable::~RecordStateTable()
204 {
205 }
206
207 const unsigned char* RecordStateTable::ParseField(const unsigned char *begin,
208 const unsigned char *end)
209 {
210 const RecordStateTableField *field = (const RecordStateTableField *) begin;
211
212 // advance and check size
213 begin += sizeof(RecordStateTableField);
214 if( begin > end ) // if begin==end, we are ok
215 return begin;
216
217 State state;
218 state.Index = btohs(field->index);
219 state.RecordId = btohl(field->uniqueId);
220 state.Dirty = (field->flags & BARRY_RSTF_DIRTY) != 0;
221 state.RecType = field->rectype;
222 state.Unknown2.assign((const char*)field->unknown2, sizeof(field->unknown2));
223 StateMap[state.Index] = state;
224
225 return begin;
226 }
227
228 void RecordStateTable::Parse(const Data &data)
229 {
230 size_t offset = 12; // skipping the unknown 2 bytes at start
231
232 if( offset >= data.GetSize() )
233 return;
234
235 const unsigned char *begin = data.GetData() + offset;
236 const unsigned char *end = data.GetData() + data.GetSize();
237
238 while( begin < end )
239 begin = ParseField(begin, end);
240 }
241
242 void RecordStateTable::Clear()
243 {
244 StateMap.clear();
245 m_LastNewRecordId = 1;
246 }
247
248 // Searches the StateMap table for RecordId, and returns the "index"
249 // in the map if found. Returns true if found, false if not.
250 // pFoundIndex can be null if only the existence of the index is desired
251 bool RecordStateTable::GetIndex(uint32_t RecordId, IndexType *pFoundIndex) const
252 {
253 StateMapType::const_iterator i = StateMap.begin();
254 for( ; i != StateMap.end(); ++i ) {
255 if( i->second.RecordId == RecordId ) {
256 if( pFoundIndex )
257 *pFoundIndex = i->first;
258 return true;
259 }
260 }
261 return false;
262 }
263
264 // Generate a new RecordId that is not in the state table.
265 // Starts at 1 and keeps incrementing until a free one is found.
266 uint32_t RecordStateTable::MakeNewRecordId() const
267 {
268 // start with next Id
269 m_LastNewRecordId++;
270
271 // make sure it doesn't already exist
272 StateMapType::const_iterator i = StateMap.begin();
273 while( i != StateMap.end() ) {
274 if( m_LastNewRecordId == i->second.RecordId ) {
275 m_LastNewRecordId++; // try again
276 i = StateMap.begin(); // start over
277 }
278 else {
279 ++i; // next State
280 }
281 }
282 return m_LastNewRecordId;
283 }
284
285 void RecordStateTable::Dump(std::ostream &os) const
286 {
287 ios::fmtflags oldflags = os.setf(ios::right);
288 char fill = os.fill(' ');
289 bool bPrintAscii = Data::PrintAscii();
290 Data::PrintAscii(false);
291
292 os << " Index RecordId Dirty RecType" << endl;
293 os << "------- ---------- ----- -------" << endl;
294
295 StateMapType::const_iterator b, e = StateMap.end();
296 for( b = StateMap.begin(); b != e ; ++b ) {
297 const State &state = b->second;
298
299 os.fill(' ');
300 os << setbase(10) << setw(7) << state.Index;
301 os << " 0x" << setbase(16) << setfill('0') << setw(8) << state.RecordId;
302 os << " " << setfill(' ') << setw(5) << (state.Dirty ? "yes" : "no");
303 os << " 0x" << setbase(16) << setfill('0') << setw(2) << state.RecType;
304 os << " " << Data(state.Unknown2.data(), state.Unknown2.size());
305 }
306
307 // cleanup the stream
308 os.flags(oldflags);
309 os.fill(fill);
310 Data::PrintAscii(bPrintAscii);
311 }
312
313
314 ///////////////////////////////////////////////////////////////////////////////
315 // DatabaseDatabase class
316
317 DatabaseDatabase::DatabaseDatabase()
318 {
319 }
320
321 DatabaseDatabase::~DatabaseDatabase()
322 {
323 }
324
325 template <class RecordType, class FieldType>
326 void DatabaseDatabase::ParseRec(const RecordType &rec, const unsigned char *end)
327 {
328 }
329
330 template <class SizeType>
331 SizeType ConvertHtoB(SizeType s)
332 {
333 throw Error("Not implemented.");
334 }
335
336 // specializations for specific sizes
337 template <> uint8_t ConvertHtoB<uint8_t>(uint8_t s) { return s; }
338 template <> uint16_t ConvertHtoB<uint16_t>(uint16_t s) { return htobs(s); }
339 template <> uint32_t ConvertHtoB<uint32_t>(uint32_t s) { return htobl(s); }
340 template <> uint64_t ConvertHtoB<uint64_t>(uint64_t s) { return htobll(s); }
341
342
343 template <class FieldType>
344 const unsigned char* DatabaseDatabase::ParseField(const unsigned char *begin,
345 const unsigned char *end)
346 {
347 // check if there is enough data for a header
348 const unsigned char *headend = begin + sizeof(FieldType);
349 if( headend > end )
350 return headend;
351
352 // get our header
353 const FieldType *field = (const FieldType *) begin;
354
355 // advance and check size
356 begin += sizeof(FieldType) - sizeof(field->name) + ConvertHtoB(field->nameSize);
357 if( begin > end ) // if begin==end, we are ok
358 return begin;
359
360 if( !ConvertHtoB(field->nameSize) ) // if field has no size, something's up
361 return begin;
362
363 Database db;
364 db.Number = ConvertHtoB(field->dbNumber);
365 db.RecordCount = ConvertHtoB(field->dbRecordCount);
366 db.Name.assign((const char *)field->name, ConvertHtoB(field->nameSize) - 1);
367 Databases.push_back(db);
368 return begin;
369 }
370
371 void DatabaseDatabase::Parse(const Data &data)
372 {
373 // check size to make sure we have up to the DBAccess operation byte
374 if( data.GetSize() < (SB_PACKET_DBACCESS_HEADER_SIZE + 1) )
375 return;
376
377 MAKE_PACKET(pack, data);
378 const unsigned char *begin = 0;
379 const unsigned char *end = data.GetData() + data.GetSize();
380
381 switch( pack->u.db.u.response.operation )
382 {
383 case SB_DBOP_GET_DBDB:
384 // using the new protocol
385 if( data.GetSize() > SB_PACKET_DBDB_HEADER_SIZE ) {
386 begin = (const unsigned char *)
387 &pack->u.db.u.response.u.dbdb.field[0];
388
389 // this while check is ok, since ParseField checks
390 // for header size
391 while( begin < end )
392 begin = ParseField<DBDBField>(begin, end);
393 }
394 else
395 dout("DatabaseDatabase: not enough data for parsing");
396 break;
397
398 case SB_DBOP_OLD_GET_DBDB:
399 // using the old protocol
400 if( data.GetSize() > SB_PACKET_OLD_DBDB_HEADER_SIZE ) {
401 begin = (const unsigned char *)
402 &pack->u.db.u.response.u.old_dbdb.field[0];
403
404 // this while check is ok, since ParseField checks
405 // for header size
406 while( begin < end )
407 begin = ParseField<OldDBDBField>(begin, end);
408 }
409 else
410 dout("DatabaseDatabase: not enough data for parsing");
411 break;
412
413 default:
414 // unknown protocol
415 dout("Unknown protocol");
416 break;
417 }
418
419
420 }
421
422 void DatabaseDatabase::Clear()
423 {
424 Databases.clear();
425 }
426
427 bool DatabaseDatabase::GetDBNumber(const std::string &name,
428 unsigned int &number) const
429 {
430 DatabaseArrayType::const_iterator b = Databases.begin();
431 for( ; b != Databases.end(); b++ )
432 if( b->Name == name ) {
433 number = b->Number;
434 return true;
435 }
436 return false;
437 }
438
439 bool DatabaseDatabase::GetDBName(unsigned int number,
440 std::string &name) const
441 {
442 DatabaseArrayType::const_iterator b = Databases.begin();
443 for( ; b != Databases.end(); b++ )
444 if( b->Number == number ) {
445 name = b->Name;
446 return true;
447 }
448 return false;
449 }
450
451 void DatabaseDatabase::Dump(std::ostream &os) const
452 {
453 DatabaseArrayType::const_iterator b = Databases.begin();
454 os << "Database database:\n";
455 for( ; b != Databases.end(); b++ ) {
456 os << " Database: 0x" << setbase(16) << b->Number
457 << " '" << b->Name << "' (records: "
458 << setbase(10) << b->RecordCount << ")\n";
459 }
460 }
461
462
463 std::ostream& operator<< (std::ostream &os, const std::vector<UnknownField> &unknowns)
464 {
465 std::vector<UnknownField>::const_iterator
466 ub = unknowns.begin(), ue = unknowns.end();
467 if( ub != ue )
468 os << " Unknowns:\n";
469 for( ; ub != ue; ub++ ) {
470 os << " Type: 0x" << setbase(16)
471 << (unsigned int) ub->type
472 << " Data:\n" << Data(ub->data.data(), ub->data.size());
473 }
474 return os;
475 }
476
477
478
479 ///////////////////////////////////////////////////////////////////////////////
480 // Contact class
481
482 // Contact field codes
483 #define CFC_EMAIL 1
484 #define CFC_PHONE 2
485 #define CFC_FAX 3
486 #define CFC_WORK_PHONE 6
487 #define CFC_HOME_PHONE 7
488 #define CFC_MOBILE_PHONE 8
489 #define CFC_PAGER 9
490 #define CFC_PIN 10
491 #define CFC_NAME 32 // used twice, in first/last name order
492 #define CFC_COMPANY 33
493 #define CFC_DEFAULT_COMM_METHOD 34
494 #define CFC_ADDRESS1 35
495 #define CFC_ADDRESS2 36
496 #define CFC_ADDRESS3 37
497 #define CFC_CITY 38
498 #define CFC_PROVINCE 39
499 #define CFC_POSTAL_CODE 40
500 #define CFC_COUNTRY 41
501 #define CFC_TITLE 42
502 #define CFC_PUBLIC_KEY 43
503 #define CFC_GROUP_FLAG 44
504 #define CFC_GROUP_LINK 52
505 #define CFC_NOTES 64
506 #define CFC_INVALID_FIELD 255
507
508 // Contact code to field table
509 template <class Record>
510 struct FieldLink
511 {
512 int type;
513 char *name;
514 char *ldif;
515 char *objectClass;
516 std::string Record::* strMember; // FIXME - find a more general
517 Message::Address Record::* addrMember; // way to do this...
518 time_t Record::* timeMember;
519 };
520
521 FieldLink<Contact> ContactFieldLinks[] = {
522 { CFC_EMAIL, "Email", "mail",0, &Contact::Email, 0, 0 },
523 { CFC_PHONE, "Phone", 0,0, &Contact::Phone, 0, 0 },
524 { CFC_FAX, "Fax", "facsimileTelephoneNumber",0, &Contact::Fax, 0, 0 },
525 { CFC_WORK_PHONE, "WorkPhone", "telephoneNumber",0, &Contact::WorkPhone, 0, 0 },
526 { CFC_HOME_PHONE, "HomePhone", "homePhone",0, &Contact::HomePhone, 0, 0 },
527 { CFC_MOBILE_PHONE, "MobilePhone","mobile",0, &Contact::MobilePhone, 0, 0 },
528 { CFC_PAGER, "Pager", "pager",0, &Contact::Pager, 0, 0 },
529 { CFC_PIN, "PIN", 0,0, &Contact::PIN, 0, 0 },
530 { CFC_COMPANY, "Company", "o",0, &Contact::Company, 0, 0 },
531 { CFC_DEFAULT_COMM_METHOD,"DefaultCommMethod",0,0, &Contact::DefaultCommunicationsMethod, 0, 0 },
532 { CFC_ADDRESS1, "Address1", 0,0, &Contact::Address1, 0, 0 },
533 { CFC_ADDRESS2, "Address2", 0,0, &Contact::Address2, 0, 0 },
534 { CFC_ADDRESS3, "Address3", 0,0, &Contact::Address3, 0, 0 },
535 { CFC_CITY, "City", "l",0, &Contact::City, 0, 0 },
536 { CFC_PROVINCE, "Province", "st",0, &Contact::Province, 0, 0 },
537 { CFC_POSTAL_CODE, "PostalCode", "postalCode",0, &Contact::PostalCode, 0, 0 },
538 { CFC_COUNTRY, "Country", "c", "country", &Contact::Country, 0, 0 },
539 { CFC_TITLE, "Title", "title",0, &Contact::Title, 0, 0 },
540 { CFC_PUBLIC_KEY, "PublicKey", 0,0, &Contact::PublicKey, 0, 0 },
541 { CFC_NOTES, "Notes", 0,0, &Contact::Notes, 0, 0 },
542 { CFC_INVALID_FIELD,"EndOfList", 0, 0, 0 }
543 };
544
545 Contact::Contact()
546 : RecType(0),
547 RecordId(0),
548 m_FirstNameSeen(false)
549 {
550 }
551
552 Contact::~Contact()
553 {
554 }
555
556 const unsigned char* Contact::ParseField(const unsigned char *begin,
557 const unsigned char *end)
558 {
559 const CommonField *field = (const CommonField *) begin;
560
561 // advance and check size
562 begin += COMMON_FIELD_HEADER_SIZE + btohs(field->size);
563 if( begin > end ) // if begin==end, we are ok
564 return begin;
565
566 if( !btohs(field->size) ) // if field has no size, something's up
567 return begin;
568
569 // cycle through the type table
570 for( FieldLink<Contact> *b = ContactFieldLinks;
571 b->type != CFC_INVALID_FIELD;
572 b++ )
573 {
574 if( b->type == field->type ) {
575 std::string &s = this->*(b->strMember);
576 s.assign((const char *)field->u.raw, btohs(field->size)-1);
577 return begin; // done!
578 }
579 }
580
581 // if not found in the type table, check for special handling
582 switch( field->type )
583 {
584 case CFC_NAME: {
585 // can be used multiple times, for first/last names
586 std::string *name;
587 if( FirstName.size() || m_FirstNameSeen ) {
588 // first name already filled, use last name
589 name = &LastName;
590 m_FirstNameSeen = false;
591 }
592 else {
593 name = &FirstName;
594 m_FirstNameSeen = true;
595 }
596
597 name->assign((const char*)field->u.raw, btohs(field->size)-1);
598 }
599 return begin;
600
601 case CFC_GROUP_LINK:
602 // just add the unique ID to the list
603 GroupLinks.push_back(
604 GroupLink(field->u.link.uniqueId,
605 field->u.link.unknown));
606 return begin;
607
608 case CFC_GROUP_FLAG:
609 // ignore the group flag... the presense of group link items
610 // behaves as the flag in this class
611 return begin;
612 }
613
614 // if still not handled, add to the Unknowns list
615 UnknownField uf;
616 uf.type = field->type;
617 uf.data.assign((const char*)field->u.raw, btohs(field->size));
618 Unknowns.push_back(uf);
619
620 // return new pointer for next field
621 return begin;
622 }
623
624 void Contact::ParseHeader(const Data &data, size_t &offset)
625 {
626 // no header to parse in Contact records
627 }
628
629 // this is called by the RecordParser<> class, which checks size for us
630 void Contact::ParseFields(const Data &data, size_t &offset)
631 {
632 const unsigned char *finish = ParseCommonFields(*this,
633 data.GetData() + offset, data.GetData() + data.GetSize());
634 offset += finish - (data.GetData() + offset);
635 }
636
637 void Contact::BuildHeader(Data &data, size_t &offset) const
638 {
639 // no header in Contact records
640 }
641
642 //
643 // BuildFields
644 //
645 /// Build fields part of record
646 ///
647 void Contact::BuildFields(Data &data, size_t &offset) const
648 {
649 data.Zap();
650
651 // check if this is a group link record, and if so, output
652 // the group flag
653 if( GroupLinks.size() )
654 BuildField(data, offset, CFC_GROUP_FLAG, 'G');
655
656 // special fields not in type table
657 if( FirstName.size() )
658 BuildField(data, offset, CFC_NAME, FirstName);
659 if( LastName.size() )
660 BuildField(data, offset, CFC_NAME, LastName);
661
662 // cycle through the type table
663 for( FieldLink<Contact> *b = ContactFieldLinks;
664 b->type != CFC_INVALID_FIELD;
665 b++ )
666 {
667 // print only fields with data
668 const std::string &field = this->*(b->strMember);
669 if( field.size() ) {
670 BuildField(data, offset, b->type, field);
671 }
672 }
673
674 // save any group links
675 GroupLinksType::const_iterator
676 gb = GroupLinks.begin(), ge = GroupLinks.end();
677 for( ; gb != ge; gb++ ) {
678 Barry::Protocol::GroupLink link;
679 link.uniqueId = htobl(gb->Link);
680 link.unknown = htobs(gb->Unknown);
681 BuildField(data, offset, CFC_GROUP_LINK, link);
682 }
683
684 // and finally save unknowns
685 UnknownsType::const_iterator
686 ub = Unknowns.begin(), ue = Unknowns.end();
687 for( ; ub != ue; ub++ ) {
688 BuildField(data, offset, ub->type, ub->data);
689 }
690
691 data.ReleaseBuffer(offset);
692 }
693
694 void Contact::Clear()
695 {
696 Email.clear();
697 Phone.clear();
698 Fax.clear();
699 WorkPhone.clear();
700 HomePhone.clear();
701 MobilePhone.clear();
702 Pager.clear();
703 PIN.clear();
704 FirstName.clear();
705 LastName.clear();
706 Company.clear();
707 DefaultCommunicationsMethod.clear();
708 Address1.clear();
709 Address2.clear();
710 Address3.clear();
711 City.clear();
712 Province.clear();
713 PostalCode.clear();
714 Country.clear();
715 Title.clear();
716 PublicKey.clear();
717 Notes.clear();
718
719 GroupLinks.clear();
720 Unknowns.clear();
721
722 m_FirstNameSeen = false;
723 }
724
725 //
726 // GetPostalAddress
727 //
728 /// Format a mailing address, handling missing fields.
729 ///
730 std::string Contact::GetPostalAddress() const
731 {
732 std::string address = Address1;
733 if( Address2.size() ) {
734 if( address.size() )
735 address += "\n";
736 address += Address2;
737 }
738 if( Address3.size() ) {
739 if( address.size() )
740 address += "\n";
741 address += Address3;
742 }
743 if( address.size() )
744 address += "\n";
745 if( City.size() )
746 address += City + " ";
747 if( Province.size() )
748 address += Province + " ";
749 if( Country.size() )
750 address += Country;
751 if( address.size() )
752 address += "\n";
753 if( PostalCode.size() )
754 address += PostalCode;
755
756 return address;
757 }
758
759 void Contact::Dump(std::ostream &os) const
760 {
761 ios::fmtflags oldflags = os.setf(ios::left);
762 char fill = os.fill(' ');
763
764 os << "Contact: 0x" << setbase(16) << GetID()
765 << " (" << (unsigned int)RecType << ")\n";
766
767 // special fields not in type table
768 os << " " << setw(20) << "FirstName";
769 os << ": " << FirstName << "\n";
770 os << " " << setw(20) << "LastName";
771 os << ": " << LastName << "\n";
772
773 // cycle through the type table
774 for( FieldLink<Contact> *b = ContactFieldLinks;
775 b->type != CFC_INVALID_FIELD;
776 b++ )
777 {
778 // print only fields with data
779 const std::string &field = this->*(b->strMember);
780 if( field.size() ) {
781 os << " " << setw(20) << b->name;
782 os << ": " << field << "\n";
783 }
784 }
785
786 // print any group links
787 GroupLinksType::const_iterator
788 gb = GroupLinks.begin(), ge = GroupLinks.end();
789 if( gb != ge )
790 os << " GroupLinks:\n";
791 for( ; gb != ge; gb++ ) {
792 os << " ID: 0x" << setbase(16) << gb->Link << "\n";
793 }
794
795 // and finally print unknowns
796 os << Unknowns;
797
798 // cleanup the stream
799 os.flags(oldflags);
800 os.fill(fill);
801 }
802
803 void Contact::SplitName(const std::string &full, std::string &first, std::string &last)
804 {
805 first.clear();
806 last.clear();
807
808 string::size_type pos = full.find_last_of(' ');
809 if( pos != string::npos ) {
810 // has space, assume last word is last name
811 last = full.c_str() + pos + 1;
812 first = full.substr(0, pos);
813 }
814 else {
815 // no space, assume only first name
816 first = full.substr(0);
817 }
818 }
819
820
821
822 ///////////////////////////////////////////////////////////////////////////////
823 // Message class
824
825
826 // Email / message field codes
827 #define MFC_TO 0x01 // can occur multiple times
828 #define MFC_FROM 0x05
829 #define MFC_SUBJECT 0x0b
830 #define MFC_BODY 0x0c
831 #define MFC_END 0xffff
832
833 FieldLink<Message> MessageFieldLinks[] = {
834 { MFC_TO, "To", 0, 0, 0, &Message::To, 0 },
835 { MFC_FROM, "From", 0, 0, 0, &Message::From, 0 },
836 { MFC_SUBJECT, "Subject", 0, 0, &Message::Subject, 0, 0 },
837 { MFC_BODY, "Body", 0, 0, &Message::Body, 0, 0 },
838 { MFC_END, "End of List",0, 0, 0, 0, 0 }
839 };
840
841 Message::Message()
842 {
843 }
844
845 Message::~Message()
846 {
847 }
848
849 const unsigned char* Message::ParseField(const unsigned char *begin,
850 const unsigned char *end)
851 {
852 const CommonField *field = (const CommonField *) begin;
853
854 // advance and check size
855 begin += COMMON_FIELD_HEADER_SIZE + btohs(field->size);
856 if( begin > end ) // if begin==end, we are ok
857 return begin;
858
859 if( !btohs(field->size) ) // if field has no size, something's up
860 return begin;
861
862 // cycle through the type table
863 for( FieldLink<Message> *b = MessageFieldLinks;
864 b->type != MFC_END;
865 b++ )
866 {
867 if( b->type == field->type ) {
868 if( b->strMember ) {
869 // parse regular string
870 std::string &s = this->*(b->strMember);
871 s.assign((const char *)field->u.raw, btohs(field->size)-1);
872 return begin; // done!
873 }
874 else if( b->addrMember ) {
875 // parse email address
876 // get dual name+addr string first
877 const char *fa = (const char*)field->u.addr.addr;
878 std::string dual(fa, btohs(field->size) - sizeof(field->u.addr.unknown));
879
880 // assign first string, using null terminator...letting std::string add it for us if it doesn't exist
881 Address &a = this->*(b->addrMember);
882 a.Name = dual.c_str();
883
884 // assign second string, using first size as starting point
885 a.Email = dual.c_str() + a.Name.size() + 1;
886 }
887 }
888 }
889
890 return begin;
891 }
892
893 uint8_t Message::GetRecType() const
894 {
895 throw std::logic_error("Message::GetRecType() called, and not supported by the USB protocol. Should never get called.");
896 }
897
898 // empty API, not required by protocol
899 uint32_t Message::GetUniqueId() const
900 {
901 throw std::logic_error("Message::GetUniqueId() called, and not supported by the USB protocol. Should never get called.");
902 }
903
904 // empty API, not required by protocol
905 void Message::SetIds(uint8_t Type, uint32_t Id)
906 {
907 // accept it without complaining, just do nothing
908 }
909
910 void Message::ParseHeader(const Data &data, size_t &offset)
911 {
912 // we skip the "header" since we don't know what to do with it yet
913 offset += MESSAGE_RECORD_HEADER_SIZE;
914 }
915
916 void Message::ParseFields(const Data &data, size_t &offset)
917 {
918 const unsigned char *finish = ParseCommonFields(*this,
919 data.GetData() + offset, data.GetData() + data.GetSize());
920 offset += finish - (data.GetData() + offset);
921 }
922
923 void Message::BuildHeader(Data &data, size_t &offset) const
924 {
925 throw std::logic_error("Message::BuildHeader not yet implemented");
926 }
927
928 void Message::BuildFields(Data &data, size_t &offset) const
929 {
930 throw std::logic_error("Message::BuildFields not yet implemented");
931 }
932
933 void Message::Clear()
934 {
935 From.Name.clear();
936 From.Email.clear();
937 To.Name.clear();
938 To.Email.clear();
939 Cc.Name.clear();
940 Cc.Email.clear();
941 Subject.clear();
942 Body.clear();
943 }
944
945 // dump message in mbox format
946 void Message::Dump(std::ostream &os) const
947 {
948 // FIXME - use current time until we figure out the date headers
949 time_t fixme = time(NULL);
950
951 os << "From " << (From.Email.size() ? From.Email.c_str() : "unknown")
952 << " " << ctime(&fixme);
953 os << "Date: " << ctime(&fixme);
954 os << "From: " << From << "\n";
955 if( To.Email.size() )
956 os << "To: " << To << "\n";
957 if( Cc.Email.size() )
958 os << "Cc: " << Cc << "\n";
959 if( Subject.size() )
960 os << "Subject: " << Subject << "\n";
961 os << "\n";
962 for( std::string::const_iterator i = Body.begin();
963 i != Body.end() && *i;
964 i++)
965 {
966 if( *i == '\r' )
967 os << '\n';
968 else
969 os << *i;
970 }
971 os << "\n\n";
972 }
973
974
975
976 ///////////////////////////////////////////////////////////////////////////////
977 // Calendar class
978
979 // calendar field codes
980 #define CALFC_APPT_TYPE_FLAG 0x01
981 #define CALFC_SUBJECT 0x02
982 #define CALFC_NOTES 0x03
983 #define CALFC_LOCATION 0x04
984 #define CALFC_NOTIFICATION_TIME 0x05
985 #define CALFC_START_TIME 0x06
986 #define CALFC_END_TIME 0x07
987 #define CALFC_RECURRENCE_DATA 0x0c
988 #define CALFC_VERSION_DATA 0x10
989 #define CALFC_NOTIFICATION_DATA 0x1a
990 #define CALFC_TIMEZONE_CODE 0x1e // only seems to show up if recurring
991 #define CALFC_ALLDAYEVENT_FLAG 0xff
992 #define CALFC_END 0xffff
993
994 FieldLink<Calendar> CalendarFieldLinks[] = {
995 { CALFC_SUBJECT, "Subject", 0, 0, &Calendar::Subject, 0, 0 },
996 { CALFC_NOTES, "Notes", 0, 0, &Calendar::Notes, 0, 0 },
997 { CALFC_LOCATION, "Location", 0, 0, &Calendar::Location, 0, 0 },
998 { CALFC_NOTIFICATION_TIME,"Notification Time",0,0, 0, 0, &Calendar::NotificationTime },
999 { CALFC_START_TIME, "Start Time", 0, 0, 0, 0, &Calendar::StartTime },
1000 { CALFC_END_TIME, "End Time", 0, 0, 0, 0, &Calendar::EndTime },
1001 { CALFC_END, "End of List",0, 0, 0, 0, 0 }
1002 };
1003
1004 Calendar::Calendar()
1005 {
1006 Clear();
1007 }
1008
1009 Calendar::~Calendar()
1010 {
1011 }
1012
1013 const unsigned char* Calendar::ParseField(const unsigned char *begin,
1014 const unsigned char *end)
1015 {
1016 const CommonField *field = (const CommonField *) begin;
1017
1018 // advance and check size
1019 begin += COMMON_FIELD_HEADER_SIZE + btohs(field->size);
1020 if( begin > end ) // if begin==end, we are ok
1021 return begin;
1022
1023 if( !btohs(field->size) ) // if field has no size, something's up
1024 return begin;
1025
1026 // cycle through the type table
1027 for( FieldLink<Calendar> *b = CalendarFieldLinks;
1028 b->type != CALFC_END;
1029 b++ )
1030 {
1031 if( b->type == field->type ) {
1032 if( b->strMember ) {
1033 std::string &s = this->*(b->strMember);
1034 s.assign((const char *)field->u.raw, btohs(field->size)-1);
1035 return begin; // done!
1036 }
1037 else if( b->timeMember && btohs(field->size) == 4 ) {
1038 time_t &t = this->*(b->timeMember);
1039 t = min2time(field->u.min1900);
1040 return begin;
1041 }
1042 }
1043 }
1044
1045 // handle special cases
1046 switch( field->type )
1047 {
1048 case CALFC_APPT_TYPE_FLAG:
1049 switch( field->u.raw[0] )
1050 {
1051 case 'a': // regular non-recurring appointment
1052 Recurring = false;
1053 return begin;
1054
1055 case '*': // recurring appointment
1056 Recurring = true;
1057 return begin;
1058
1059 default:
1060 throw Error("Calendar::ParseField: unknown appointment type");
1061 }
1062 break;
1063
1064 case CALFC_ALLDAYEVENT_FLAG:
1065 AllDayEvent = field->u.raw[0] == 1;
1066 return begin;
1067
1068 case CALFC_RECURRENCE_DATA:
1069 if( btohs(field->size) >= CALENDAR_RECURRENCE_DATA_FIELD_SIZE ) {
1070 // good data
1071 ParseRecurrenceData(&field->u.raw[0]);
1072 }
1073 else {
1074 // not enough data!
1075 throw Error("Calendar::ParseField: not enough data in recurrence data field");
1076 }
1077 return begin;
1078
1079 case CALFC_TIMEZONE_CODE:
1080 if( btohs(field->size) == 2 ) {
1081 // good data
1082 TimeZoneCode = btohs(field->u.code);
1083 }
1084 else {
1085 throw Error("Calendar::ParseField: not enough data in time zone code field");
1086 }
1087 return begin;
1088 }
1089
1090 // if still not handled, add to the Unknowns list
1091 UnknownField uf;
1092 uf.type = field->type;
1093 uf.data.assign((const char*)field->u.raw, btohs(field->size));
1094 Unknowns.push_back(uf);
1095
1096 // return new pointer for next field
1097 return begin;
1098 }
1099
1100 // this function assumes the size has already been checked
1101 void Calendar::ParseRecurrenceData(const void *data)
1102 {
1103 const CalendarRecurrenceDataField *rec =
1104 (const CalendarRecurrenceDataField*) data;
1105
1106 Interval = btohs(rec->interval);
1107 if( Interval < 1 )
1108 Interval = 1; // must always be >= 1
1109
1110 if( rec->endTime == 0xffffffff ) {
1111 Perpetual = true;
1112 }
1113 else {
1114 RecurringEndTime = min2time(rec->endTime);
1115 Perpetual = false;
1116 }
1117
1118 switch( rec->type )
1119 {
1120 case CRDF_TYPE_DAY:
1121 RecurringType = Day;
1122 // no extra data
1123 break;
1124
1125 case CRDF_TYPE_MONTH_BY_DATE:
1126 RecurringType = MonthByDate;
1127 DayOfMonth = rec->u.month_by_date.monthDay;
1128 break;
1129
1130 case CRDF_TYPE_MONTH_BY_DAY:
1131 RecurringType = MonthByDay;
1132 DayOfWeek = rec->u.month_by_day.weekDay;
1133 WeekOfMonth = rec->u.month_by_day.week;
1134 break;
1135
1136 case CRDF_TYPE_YEAR_BY_DATE:
1137 RecurringType = YearByDate;
1138 DayOfMonth = rec->u.year_by_date.monthDay;
1139 MonthOfYear = rec->u.year_by_date.month;
1140 break;
1141
1142 case CRDF_TYPE_YEAR_BY_DAY:
1143 RecurringType = YearByDay;
1144 DayOfWeek = rec->u.year_by_day.weekDay;
1145 WeekOfMonth = rec->u.year_by_day.week;
1146 MonthOfYear = rec->u.year_by_day.month;
1147 break;
1148
1149 case CRDF_TYPE_WEEK:
1150 RecurringType = Week;
1151
1152 // Note: this simple copy is only possible since
1153 // the CAL_WD_* constants are the same as CRDF_WD_* constants.
1154 // If this ever changes, this code will need to change.
1155 WeekDays = rec->u.week.days;
1156 break;
1157
1158 default:
1159 eout("Unknown recurrence data type: " << rec->type);
1160 throw Error("Unknown recurrence data type");
1161 }
1162 }
1163
1164 // this function assumes there is CALENDAR_RECURRENCE_DATA_FIELD_SIZE bytes
1165 // available in data
1166 void Calendar::BuildRecurrenceData(void *data)
1167 {
1168 if( !Recurring )
1169 throw Error("Calendar::BuildRecurrenceData: Attempting to build recurrence data on non-recurring record.");
1170
1171 CalendarRecurrenceDataField *rec = (CalendarRecurrenceDataField*) data;
1172
1173 // set all to zero
1174 memset(data, 0, CALENDAR_RECURRENCE_DATA_FIELD_SIZE);
1175
1176 rec->interval = htobs(Interval);
1177 rec->startTime = time2min(StartTime);
1178 if( Perpetual )
1179 rec->endTime = 0xffffffff;
1180 else
1181 rec->endTime = time2min(RecurringEndTime);
1182
1183 switch( RecurringType )
1184 {
1185 case Day:
1186 rec->type = CRDF_TYPE_DAY;
1187 // no extra data
1188 break;
1189
1190 case MonthByDate:
1191 rec->type = CRDF_TYPE_MONTH_BY_DATE;
1192 rec->u.month_by_date.monthDay = DayOfMonth;
1193 break;
1194
1195 case MonthByDay:
1196 rec->type = CRDF_TYPE_MONTH_BY_DAY;
1197 rec->u.month_by_day.weekDay = DayOfWeek;
1198 rec->u.month_by_day.week = WeekOfMonth;
1199 break;
1200
1201 case YearByDate:
1202 rec->type = CRDF_TYPE_YEAR_BY_DATE;
1203 rec->u.year_by_date.monthDay = DayOfMonth;
1204 rec->u.year_by_date.month = MonthOfYear;
1205 break;
1206
1207 case YearByDay:
1208 rec->type = CRDF_TYPE_YEAR_BY_DAY;
1209 rec->u.year_by_day.weekDay = DayOfWeek;
1210 rec->u.year_by_day.week = WeekOfMonth;
1211 rec->u.year_by_day.month = MonthOfYear;
1212 break;
1213
1214 case Week:
1215 rec->type = CRDF_TYPE_WEEK;
1216
1217 // Note: this simple copy is only possible since
1218 // the CAL_WD_* constants are the same as CRDF_WD_* constants.
1219 // If this ever changes, this code will need to change.
1220 rec->u.week.days = WeekDays;
1221 break;
1222
1223 default:
1224 eout("Calendar::BuildRecurrenceData: "
1225 "Unknown recurrence data type: " << rec->type);
1226 throw Error("Calendar::BuildRecurrenceData: Unknown recurrence data type");
1227 }
1228 }
1229
1230 void Calendar::ParseHeader(const Data &data, size_t &offset)
1231 {
1232 // no header in Calendar records
1233 }
1234
1235 void Calendar::ParseFields(const Data &data, size_t &offset)
1236 {
1237 const unsigned char *finish = ParseCommonFields(*this,
1238 data.GetData() + offset, data.GetData() + data.GetSize());
1239 offset += finish - (data.GetData() + offset);
1240 }
1241
1242 void Calendar::BuildHeader(Data &data, size_t &offset) const
1243 {
1244 // no header in Calendar records
1245 }
1246
1247 //
1248 // Build
1249 //
1250 /// Build fields part of record.
1251 ///
1252 void Calendar::BuildFields(Data &data, size_t &offset) const
1253 {
1254 data.Zap();
1255
1256 // output the type first
1257 BuildField(data, offset, CALFC_APPT_TYPE_FLAG, Recurring ? '*' : 'a');
1258
1259 // output all day event flag only if set
1260 if( AllDayEvent )
1261 BuildField(data, offset, CALFC_ALLDAYEVENT_FLAG, (char)1);
1262
1263 // cycle through the type table
1264 for( const FieldLink<Calendar> *b = CalendarFieldLinks;
1265 b->type != CALFC_END;
1266 b++ )
1267 {
1268 if( b->strMember ) {
1269 const std::string &s = this->*(b->strMember);
1270 if( s.size() )
1271 BuildField(data, offset, b->type, s);
1272 }
1273 else if( b->timeMember ) {
1274 time_t t = this->*(b->timeMember);
1275 if( t > 0 )
1276 BuildField1900(data, offset, b->type, t);
1277 }
1278 }
1279
1280 // and finally save unknowns
1281 UnknownsType::const_iterator
1282 ub = Unknowns.begin(), ue = Unknowns.end();
1283 for( ; ub != ue; ub++ ) {
1284 BuildField(data, offset, ub->type, ub->data);
1285 }
1286
1287 data.ReleaseBuffer(offset);
1288 }
1289
1290 void Calendar::Clear()
1291 {
1292 AllDayEvent = false;
1293 Subject.clear();
1294 Notes.clear();
1295 Location.clear();
1296 NotificationTime = StartTime = EndTime = 0;
1297
1298 Recurring = false;
1299 RecurringType = Calendar::Week;
1300 Interval = 1;
1301 RecurringEndTime = 0;
1302 Perpetual = false;
1303 TimeZoneCode = GetTimeZoneCode(0, 0); // default to GMT
1304 DayOfWeek = WeekOfMonth = DayOfMonth = MonthOfYear = 0;
1305 WeekDays = 0;
1306
1307 Unknowns.clear();
1308 }
1309
1310 void Calendar::Dump(std::ostream &os) const
1311 {
1312 static const char *DayNames[] = { "Sun", "Mon", "Tue", "Wed",
1313 "Thu", "Fri", "Sat" };
1314 static const char *MonthNames[] = { "Jan", "Feb", "Mar", "Apr",
1315 "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
1316
1317 // FIXME - need a "check all data" function that make sure that all
1318 // recurrence data is within range. Then call that before using
1319 // the data, such as in Build and in Dump.
1320
1321 os << "Calendar entry: 0x" << setbase(16) << RecordId
1322 << " (" << (unsigned int)RecType << ")\n";
1323 os << " All Day Event: " << (AllDayEvent ? "yes" : "no") << "\n";
1324
1325 // cycle through the type table
1326 for( const FieldLink<Calendar> *b = CalendarFieldLinks;
1327 b->type != CALFC_END;
1328 b++ )
1329 {
1330 if( b->strMember ) {
1331 const std::string &s = this->*(b->strMember);
1332 if( s.size() )
1333 os << " " << b->name << ": " << s << "\n";
1334 }
1335 else if( b->timeMember ) {
1336 time_t t = this->*(b->timeMember);
1337 if( t > 0 )
1338 os << " " << b->name << ": " << ctime(&t);
1339 }
1340 }
1341
1342 // print recurrence data if available
1343 os << " Recurring: " << (Recurring ? "yes" : "no") << "\n";
1344 if( Recurring ) {
1345 switch( RecurringType )
1346 {
1347 case Day:
1348 os << " Every day.\n";
1349 break;
1350
1351 case MonthByDate:
1352 os << " Every month on the "
1353 << DayOfMonth
1354 << (DayOfMonth == 1 ? "st" : "")
1355 << (DayOfMonth == 2 ? "nd" : "")
1356 << (DayOfMonth == 3 ? "rd" : "")
1357 << (DayOfMonth > 3 ? "th" : "")
1358 << "\n";
1359 break;
1360
1361 case MonthByDay:
1362 os << " Every month on the "
1363 << DayNames[DayOfWeek]
1364 << " of week "
1365 << WeekOfMonth
1366 << "\n";
1367 break;
1368
1369 case YearByDate:
1370 os << " Every year on "
1371 << MonthNames[MonthOfYear-1]
1372 << " " << DayOfMonth << "\n";
1373 break;
1374
1375 case YearByDay:
1376 os << " Every year in " << MonthNames[MonthOfYear-1]
1377 << " on "
1378 << DayNames[DayOfWeek]
1379 << " of week " << WeekOfMonth << "\n";
1380 break;
1381
1382 case Week:
1383 os << " Every week on: ";
1384 if( WeekDays & CAL_WD_SUN ) os << "Sun ";
1385 if( WeekDays & CAL_WD_MON ) os << "Mon ";
1386 if( WeekDays & CAL_WD_TUE ) os << "Tue ";
1387 if( WeekDays & CAL_WD_WED ) os << "Wed ";
1388 if( WeekDays & CAL_WD_THU ) os << "Thu ";
1389 if( WeekDays & CAL_WD_FRI ) os << "Fri ";
1390 if( WeekDays & CAL_WD_SAT ) os << "Sat ";
1391 os << "\n";
1392 break;
1393
1394 default:
1395 os << " Unknown recurrence type\n";
1396 break;
1397 }
1398
1399 os << " Interval: " << Interval << "\n";
1400
1401 if( Perpetual )
1402 os << " Ends: never\n";
1403 else
1404 os << " Ends: "
1405 << ctime(&RecurringEndTime);
1406 }
1407
1408 // print any unknowns
1409 os << Unknowns;
1410 }
1411
1412
1413 ///////////////////////////////////////////////////////////////////////////////
1414 // ServiceBookConfig class
1415
1416 // service book packed field codes
1417 #define SBFCC_END 0xffff
1418
1419 FieldLink<ServiceBookConfig> ServiceBookConfigFieldLinks[] = {
1420 // { SBFC_DSID, "DSID", 0, 0, &ServiceBook::DSID, 0, 0 },
1421 { SBFCC_END, "End of List",0, 0, 0, 0, 0 }
1422 };
1423
1424 ServiceBookConfig::ServiceBookConfig()
1425 : Format(0)
1426 {
1427 Clear();
1428 }
1429
1430 ServiceBookConfig::~ServiceBookConfig()
1431 {
1432 }
1433
1434 const unsigned char* ServiceBookConfig::ParseField(const unsigned char *begin,
1435 const unsigned char *end)
1436 {
1437 const void *raw;
1438 uint16_t size, type;
1439
1440 switch( Format )
1441 {
1442 case 0x02:
1443 {
1444 const PackedField_02 *field = (const PackedField_02 *) begin;
1445 raw = field->raw;
1446 size = field->size;
1447 type = field->type;
1448 begin += PACKED_FIELD_02_HEADER_SIZE + size;
1449 }
1450 break;
1451
1452 case 0x10:
1453 {
1454 const PackedField_10 *field = (const PackedField_10 *) begin;
1455 raw = field->raw;
1456 size = field->size;
1457 type = field->type;
1458 begin += PACKED_FIELD_10_HEADER_SIZE + size;
1459 }
1460 break;
1461
1462 default:
1463 eout("Unknown packed field format" << Format);
1464 return begin + 1;
1465 }
1466
1467
1468 // check size
1469 if( begin > end ) // if begin==end, we are ok
1470 return begin;
1471
1472 if( !size ) // if field has no size, something's up
1473 return begin;
1474
1475 // cycle through the type table
1476 for( FieldLink<ServiceBookConfig> *b = ServiceBookConfigFieldLinks;
1477 b->type != SBFCC_END;
1478 b++ )
1479 {
1480 if( b->type == type ) {
1481 if( b->strMember ) {
1482 std::string &s = this->*(b->strMember);
1483 s.assign((const char *)raw, size-1);
1484 return begin; // done!
1485 }
1486 }
1487 }
1488
1489 /*
1490 // handle special cases
1491 switch( type )
1492 {
1493 }
1494 */
1495
1496 // if still not handled, add to the Unknowns list
1497 UnknownField uf;
1498 uf.type = type;
1499 uf.data.assign((const char*)raw, size);
1500 Unknowns.push_back(uf);
1501
1502 // return new pointer for next field
1503 return begin;
1504 }
1505
1506 void ServiceBookConfig::ParseHeader(const Data &data, size_t &offset)
1507 {
1508 MAKE_RECORD(const Barry::Protocol::ServiceBookConfigField, sbc, data, offset);
1509 offset += SERVICE_BOOK_CONFIG_FIELD_HEADER_SIZE;
1510 if( data.GetSize() >= offset ) { // size check!
1511 Format = sbc->format;
1512 }
1513 }
1514
1515 void ServiceBookConfig::ParseFields(const Data &data, size_t &offset)
1516 {
1517 const unsigned char *finish = ParseCommonFields(*this,
1518 data.GetData() + offset, data.GetData() + data.GetSize());
1519 offset += finish - (data.GetData() + offset);
1520 }
1521
1522 void ServiceBookConfig::BuildHeader(Data &data, size_t &offset) const
1523 {
1524 // make sure there is enough space
1525 data.GetBuffer(offset + SERVICE_BOOK_CONFIG_FIELD_HEADER_SIZE);
1526
1527 MAKE_RECORD(Barry::Protocol::ServiceBookConfigField, sbc, data, offset);
1528 sbc->format = Format;
1529
1530 offset += SERVICE_BOOK_CONFIG_FIELD_HEADER_SIZE;
1531 }
1532
1533 //
1534 // BuildFields
1535 //
1536 /// Build fields part of record
1537 ///
1538 void ServiceBookConfig::BuildFields(Data &data, size_t &offset) const
1539 {
1540 throw std::logic_error("ServiceBookConfig::Build not yet implemented");
1541 }
1542
1543 void ServiceBookConfig::Clear()
1544 {
1545 Unknowns.clear();
1546 }
1547
1548 void ServiceBookConfig::Dump(std::ostream &os) const
1549 {
1550 os << " ServiceBookConfig Format: " << setbase(16) << (uint16_t)Format << "\n";
1551
1552 // cycle through the type table
1553 for( const FieldLink<ServiceBookConfig> *b = ServiceBookConfigFieldLinks;
1554 b->type != SBFCC_END;
1555 b++ )
1556 {
1557 if( b->strMember ) {
1558 const std::string &s = this->*(b->strMember);
1559 if( s.size() )
1560 os << " " << b->name << ": " << s << "\n";
1561 }
1562 else if( b->timeMember ) {
1563 time_t t = this->*(b->timeMember);
1564 if( t > 0 )
1565 os << " " << b->name << ": " << ctime(&t);
1566 }
1567 }
1568
1569 // print any unknowns
1570 os << Unknowns;
1571 os << " ------------------- End of Config Field\n";
1572 }
1573
1574
1575 ///////////////////////////////////////////////////////////////////////////////
1576 // ServiceBook class
1577
1578 // service book field codes
1579 #define SBFC_OLD_NAME 0x01
1580 #define SBFC_HIDDEN_NAME 0x02
1581 #define SBFC_NAME 0x03
1582 #define SBFC_OLD_UNIQUE_ID 0x06
1583 #define SBFC_UNIQUE_ID 0x07
1584 #define SBFC_CONTENT_ID 0x08
1585 #define SBFC_CONFIG 0x09
1586 #define SBFC_OLD_DESC 0x32
1587 #define SBFC_DESCRIPTION 0x0f
1588 #define SBFC_DSID 0xa1
1589 #define SBFC_BES_DOMAIN 0xa2
1590 #define SBFC_USER_ID 0xa3
1591 #define SBFC_END 0xffff
1592
1593 FieldLink<ServiceBook> ServiceBookFieldLinks[] = {
1594 { SBFC_HIDDEN_NAME, "Hidden Name",0, 0, &ServiceBook::HiddenName, 0, 0 },
1595 { SBFC_DSID, "DSID", 0, 0, &ServiceBook::DSID, 0, 0 },
1596 { SBFC_END, "End of List",0, 0, 0, 0, 0 }
1597 };
1598
1599 ServiceBook::ServiceBook()
1600 : NameType(SBFC_OLD_NAME),
1601 DescType(SBFC_OLD_DESC),
1602 UniqueIdType(SBFC_OLD_UNIQUE_ID),
1603 RecordId(0)
1604 {
1605 Clear();
1606 }
1607
1608 ServiceBook::~ServiceBook()
1609 {
1610 }
1611
1612 const unsigned char* ServiceBook::ParseField(const unsigned char *begin,
1613 const unsigned char *end)
1614 {
1615 const CommonField *field = (const CommonField *) begin;
1616
1617 // advance and check size
1618 begin += COMMON_FIELD_HEADER_SIZE + btohs(field->size);
1619 if( begin > end ) // if begin==end, we are ok
1620 return begin;
1621
1622 if( !btohs(field->size) ) // if field has no size, something's up
1623 return begin;
1624
1625 // cycle through the type table
1626 for( FieldLink<ServiceBook> *b = ServiceBookFieldLinks;
1627 b->type != SBFC_END;
1628 b++ )
1629 {
1630 if( b->type == field->type ) {
1631 if( b->strMember ) {
1632 std::string &s = this->*(b->strMember);
1633 s.assign((const char *)field->u.raw, btohs(field->size)-1);
1634 return begin; // done!
1635 }
1636 else if( b->timeMember && btohs(field->size) == 4 ) {
1637 time_t &t = this->*(b->timeMember);
1638 t = min2time(field->u.min1900);
1639 return begin;
1640 }
1641 }
1642 }
1643
1644 // handle special cases
1645 switch( field->type )
1646 {
1647 case SBFC_OLD_NAME: // strings with old/new type codes
1648 case SBFC_NAME:
1649 Name.assign((const char *)field->u.raw, btohs(field->size)-1);
1650 NameType = field->type;
1651 return begin;
1652
1653 case SBFC_OLD_DESC:
1654 case SBFC_DESCRIPTION:
1655 Description.assign((const char *)field->u.raw, btohs(field->size)-1);
1656 DescType = field->type;
1657 return begin;
1658
1659 case SBFC_OLD_UNIQUE_ID:
1660 case SBFC_UNIQUE_ID:
1661 UniqueId.assign((const char *)field->u.raw, btohs(field->size));
1662 UniqueIdType = field->type;
1663 return begin;
1664
1665 case SBFC_CONTENT_ID:
1666 ContentId.assign((const char *)field->u.raw, btohs(field->size));
1667 return begin;
1668
1669 case SBFC_BES_DOMAIN:
1670 BesDomain.assign((const char *)field->u.raw, btohs(field->size));
1671 return begin;
1672
1673 case SBFC_CONFIG:
1674 {
1675 Data config((const void *)field->u.raw, btohs(field->size));
1676 size_t offset = 0;
1677 Config.ParseHeader(config, offset);
1678 Config.ParseFields(config, offset);
1679 }
1680 break; // break here so raw packet is still visible in dump
1681 // return begin;
1682 }
1683
1684 // if still not handled, add to the Unknowns list
1685 UnknownField uf;
1686 uf.type = field->type;
1687 uf.data.assign((const char*)field->u.raw, btohs(field->size));
1688 Unknowns.push_back(uf);
1689
1690 // return new pointer for next field
1691 return begin;
1692 }
1693
1694 void ServiceBook::ParseHeader(const Data &data, size_t &offset)
1695 {
1696 // no header in this record (?)
1697 }
1698
1699 void ServiceBook::ParseFields(const Data &data, size_t &offset)
1700 {
1701 const unsigned char *finish = ParseCommonFields(*this,
1702 data.GetData() + offset, data.GetData() + data.GetSize());
1703 offset += finish - (data.GetData() + offset);
1704 }
1705
1706 void ServiceBook::BuildHeader(Data &data, size_t &offset) const
1707 {
1708 // no header in this record (?)
1709 }
1710
1711 //
1712 // BuildFields
1713 //
1714 /// Build fields part of record
1715 ///
1716 void ServiceBook::BuildFields(Data &data, size_t &offset) const
1717 {
1718 throw std::logic_error("ServiceBook::BuildFields not yet implemented");
1719 }
1720
1721 void ServiceBook::Clear()
1722 {
1723 Unknowns.clear();
1724 Config.Clear();
1725 }
1726
1727 void ServiceBook::Dump(std::ostream &os) const
1728 {
1729 os << "ServiceBook entry: 0x" << setbase(16) << RecordId
1730 << " (" << (unsigned int)RecType << ")\n";
1731
1732 // cycle through the type table
1733 for( const FieldLink<ServiceBook> *b = ServiceBookFieldLinks;
1734 b->type != SBFC_END;
1735 b++ )
1736 {
1737 if( b->strMember ) {
1738 const std::string &s = this->*(b->strMember);
1739 if( s.size() )
1740 os << " " << b->name << ": " << s << "\n";
1741 }
1742 else if( b->timeMember ) {
1743 time_t t = this->*(b->timeMember);
1744 if( t > 0 )
1745 os << " " << b->name << ": " << ctime(&t);
1746 }
1747 }
1748
1749 // special cases
1750 if( UniqueId.size() )
1751 os << " Unique ID: " << UniqueId << "\n";
1752 if( ContentId.size() )
1753 os << " Content ID: " << ContentId << "\n";
1754 if( BesDomain.size() )
1755 os << " (BES) Domain: " << BesDomain << "\n";
1756
1757 os << Config;
1758
1759 // print any unknowns
1760 os << Unknowns;
1761 }
1762
1763
1764 } // namespace Barry
1765
1766
1767 #ifdef __TEST_MODE__
1768
1769 #include <iostream>
1770
1771 int main(int argc, char *argv[])
1772 {
1773 if( argc < 2 ) {
1774 cerr << "Usage: test <datafile>" << endl;
1775 return 1;
1776 }
1777
1778 std::vector<Data> array;
1779 if( !LoadDataArray(argv[1], array) ) {
1780 cerr << "Unable to load file: " << argv[1] << endl;
1781 return 1;
1782 }
1783
1784 cout << "Loaded " << array.size() << " items" << endl;
1785
1786 for( std::vector<Data>::iterator b = array.begin(), e = array.end();
1787 b != e; b++ )
1788 {
1789 Data &d = *b;
1790 // cout << d << endl;
1791 if( d.GetSize() > 13 && d.GetData()[6] == 0x4f ) {
1792 Barry::Contact contact;
1793 size_t size = 13;
1794 contact.ParseFields(d, size);
1795 cout << contact << endl;
1796 contact.DumpLdif(cout, "ou=People,dc=example,dc=com");
1797 }
1798 else if( d.GetSize() > 13 && d.GetData()[6] == 0x44 ) {
1799 Barry::Calendar cal;
1800 size_t size = 13;
1801 cal.ParseFields(d, size);
1802 cout << cal << endl;
1803 }
1804 }
1805 }
1806
1807 #endif
1808
Interface software for the Blackberry handheld