src/ldif.cc

   1 ///
   2 /// \file       ldif.cc
   3 ///             Routines for reading and writing LDAP LDIF data.
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2011, 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 "ldif.h"
  23 #include "record.h"
  24 #include "r_contact.h"
  25 #include "base64.h"
  26 #include <stdexcept>
  27 #include <iostream>
  28 #include <iomanip>
  29 #include <string.h>
  30 #include "ios_state.h"
  31
  32 #define __DEBUG_MODE__
  33 #include "debug.h"
  34
  35 namespace Barry {
  36
  37 const ContactLdif::NameToFunc ContactLdif::FieldMap[] = {
  38         { "Email", "Email address",
  39                 &ContactLdif::Email, &ContactLdif::SetEmail },
  40         { "Phone", "Phone number",
  41                 &ContactLdif::Phone, &ContactLdif::SetPhone },
  42         { "Fax", "Fax number",
  43                 &ContactLdif::Fax, &ContactLdif::SetFax },
  44         { "WorkPhone", "Work phone number",
  45                 &ContactLdif::WorkPhone, &ContactLdif::SetWorkPhone },
  46         { "HomePhone", "Home phone number",
  47                 &ContactLdif::HomePhone, &ContactLdif::SetHomePhone },
  48         { "MobilePhone", "Mobile phone number",
  49                 &ContactLdif::MobilePhone, &ContactLdif::SetMobilePhone },
  50         { "Pager", "Pager number",
  51                 &ContactLdif::Pager, &ContactLdif::SetPager },
  52         { "PIN", "PIN",
  53                 &ContactLdif::PIN, &ContactLdif::SetPIN },
  54         { "FirstName", "First name",
  55                 &ContactLdif::FirstName, &ContactLdif::SetFirstName },
  56         { "LastName", "Last name",
  57                 &ContactLdif::LastName, &ContactLdif::SetLastName },
  58         { "Company", "Company name",
  59                 &ContactLdif::Company, &ContactLdif::SetCompany },
  60         { "DefaultCommunicationsMethod", "Default communications method",
  61                 &ContactLdif::DefaultCommunicationsMethod, &ContactLdif::SetDefaultCommunicationsMethod },
  62         { "WorkAddress1", "Work Address, line 1",
  63                 &ContactLdif::WorkAddress1, &ContactLdif::SetWorkAddress1 },
  64         { "WorkAddress2", "Work Address, line 2",
  65                 &ContactLdif::WorkAddress2, &ContactLdif::SetWorkAddress2 },
  66         { "WorkAddress3", "Work Address, line 3",
  67                 &ContactLdif::WorkAddress3, &ContactLdif::SetWorkAddress3 },
  68         { "WorkCity", "WorkCity",
  69                 &ContactLdif::WorkCity, &ContactLdif::SetWorkCity },
  70         { "WorkProvince", "WorkProvince / State",
  71                 &ContactLdif::WorkProvince, &ContactLdif::SetWorkProvince },
  72         { "WorkPostalCode", "Work Postal / ZIP code",
  73                 &ContactLdif::WorkPostalCode, &ContactLdif::SetWorkPostalCode },
  74         { "WorkCountry", "WorkCountry",
  75                 &ContactLdif::WorkCountry, &ContactLdif::SetWorkCountry },
  76         { "JobTitle", "Job Title",
  77                 &ContactLdif::JobTitle, &ContactLdif::SetJobTitle },
  78         { "PublicKey", "Public key",
  79                 &ContactLdif::PublicKey, &ContactLdif::SetPublicKey },
  80         { "Notes", "Notes",
  81                 &ContactLdif::Notes, &ContactLdif::SetNotes },
  82         { "Image", "Contact photo",
  83                 &ContactLdif::Image, &ContactLdif::SetImage },
  84         { "WorkPostalAddress", "Mailing Work address (includes address lines, city, province, country, and postal code)",
  85                 &ContactLdif::WorkPostalAddress, &ContactLdif::SetWorkPostalAddress },
  86         { "HomePostalAddress", "Mailing home address (includes address lines, city, province, country, and postal code)",
  87                 &ContactLdif::HomePostalAddress, &ContactLdif::SetHomePostalAddress },
  88         { "FullName", "First + Last names",
  89                 &ContactLdif::FullName, &ContactLdif::SetFullName },
  90         { "FQDN", "Fully qualified domain name",
  91                 &ContactLdif::FQDN, &ContactLdif::SetFQDN },
  92         { 0, 0, 0 }
  93 };
  94
  95
  96 bool ContactLdif::LdifAttribute::operator<(const LdifAttribute &other) const
  97 {
  98         // the dn attribute always comes first in LDIF output
  99         if( name == "dn" ) {
 100                 if( other.name == "dn" )
 101                         return false;   // both dn, so equal
 102                 return true;
 103         }
 104         else if( other.name == "dn" )
 105                 return false;
 106
 107         return (order < other.order && name != other.name) ||
 108                 (order == other.order && name < other.name);
 109 }
 110
 111 bool ContactLdif::LdifAttribute::operator==(const LdifAttribute &other) const
 112 {
 113         return name == other.name;
 114 }
 115
 116
 117 ///////////////////////////////////////////////////////////////////////////////
 118 // ContactLdif class
 119
 120 ContactLdif::ContactLdif(const std::string &baseDN)
 121         : m_baseDN(baseDN)
 122 {
 123         // setup some sane defaults
 124         Map("mail", &ContactLdif::Email, &ContactLdif::SetEmail);
 125         Map("facsimileTelephoneNumber", &ContactLdif::Fax, &ContactLdif::SetFax);
 126         Map("telephoneNumber", &ContactLdif::WorkPhone, &ContactLdif::SetWorkPhone);
 127         Map("homePhone", &ContactLdif::HomePhone, &ContactLdif::SetHomePhone);
 128         Map("mobile", &ContactLdif::MobilePhone, &ContactLdif::SetMobilePhone);
 129         Map("pager", &ContactLdif::Pager, &ContactLdif::SetPager);
 130         Map("l", &ContactLdif::WorkCity, &ContactLdif::SetWorkCity);
 131         Map("st", &ContactLdif::WorkProvince, &ContactLdif::SetWorkProvince);
 132         Map("postalCode", &ContactLdif::WorkPostalCode, &ContactLdif::SetWorkPostalCode);
 133         Map("o", &ContactLdif::Company, &ContactLdif::SetCompany);
 134         Map("c", &ContactLdif::WorkCountry, &ContactLdif::SetWorkCountry);
 135         SetObjectClass("c", "country");
 136
 137         Map("title", &ContactLdif::JobTitle, &ContactLdif::SetJobTitle);
 138         Map("dn", &ContactLdif::FQDN, &ContactLdif::SetFQDN);
 139         Map("displayName", &ContactLdif::FullName, &ContactLdif::SetFullName);
 140         Map("cn", &ContactLdif::FullName, &ContactLdif::SetFullName);
 141         Map("sn", &ContactLdif::LastName, &ContactLdif::SetLastName);
 142         Map("givenName", &ContactLdif::FirstName, &ContactLdif::SetFirstName);
 143         Map("street", &ContactLdif::WorkAddress1, &ContactLdif::SetWorkAddress1);
 144         Map("postalAddress", &ContactLdif::WorkPostalAddress, &ContactLdif::SetWorkPostalAddress);
 145         Map("homePostalAddress", &ContactLdif::HomePostalAddress, &ContactLdif::SetHomePostalAddress);
 146         Map("note", &ContactLdif::Notes, &ContactLdif::SetNotes);
 147         // FIXME - jpegPhoto looks like the only LDIF field for photo
 148         // images... it is unknown which format will come from the
 149         // BlackBerry in the Image field, so we can't guarantee
 150         // that Image will be in JPG.  This mapping can be done manually
 151         // from the btool command line with "-m jpegPhoto,Image,Image"
 152         // Reading photos from LDIF should be fine, since the BlackBerry
 153         // seems to handle most formats.
 154 //      Map("jpegPhoto", &ContactLdif::Image, &ContactLdif::SetImage);
 155
 156         // add heuristics hooks
 157         Hook("cn", &m_cn);
 158         Hook("displayName", &m_displayName);
 159         Hook("sn", &m_sn);
 160         Hook("givenName", &m_givenName);
 161
 162         // set default DN attribute
 163         SetDNAttr("cn");
 164 }
 165
 166 ContactLdif::~ContactLdif()
 167 {
 168 }
 169
 170 void ContactLdif::DoWrite(Barry::Contact &con,
 171                           const std::string &attr,
 172                           const std::string &data)
 173 {
 174         // valid?
 175         if( attr.size() == 0 || data.size() == 0 )
 176                 return;
 177
 178         // now have attr/data pair, check hooks:
 179         HookMapType::iterator hook = m_hookMap.find(attr);
 180         if( hook != m_hookMap.end() ) {
 181                 *(hook->second) = data;
 182         }
 183
 184         // run according to map
 185         AccessMapType::iterator acc = m_map.find(attr);
 186         if( acc != m_map.end() ) {
 187                 (this->*(acc->second.write))(con, data);
 188         }
 189 }
 190
 191 void ContactLdif::Hook(const std::string &ldifname, std::string *var)
 192 {
 193         m_hookMap[ldifname] = var;
 194 }
 195
 196 const ContactLdif::NameToFunc*
 197 ContactLdif::GetField(const std::string &fieldname) const
 198 {
 199         for( const NameToFunc *n = FieldMap; n->name; n++ ) {
 200                 if( fieldname == n->name )
 201                         return n;
 202         }
 203         return 0;
 204 }
 205
 206 std::string ContactLdif::GetFieldReadName(GetFunctionType read) const
 207 {
 208         for( const NameToFunc *n = FieldMap; n->name; n++ ) {
 209                 if( read == n->read )
 210                         return n->name;
 211         }
 212         return "<unknown>";
 213 }
 214
 215 std::string ContactLdif::GetFieldWriteName(SetFunctionType write) const
 216 {
 217         for( const NameToFunc *n = FieldMap; n->name; n++ ) {
 218                 if( write == n->write )
 219                         return n->name;
 220         }
 221         return "<unknown>";
 222 }
 223
 224 bool ContactLdif::Map(const LdifAttribute &ldifname,
 225                       const std::string &readField,
 226                       const std::string &writeField)
 227 {
 228         const NameToFunc *read = GetField(readField);
 229         const NameToFunc *write = GetField(writeField);
 230         if( !read || !write )
 231                 return false;
 232         Map(ldifname, read->read, write->write);
 233         return true;
 234 }
 235
 236 void ContactLdif::Map(const LdifAttribute &ldifname,
 237                       GetFunctionType read,
 238                       SetFunctionType write)
 239 {
 240         m_map[ldifname] = AccessPair(read, write);
 241 }
 242
 243 void ContactLdif::Unmap(const LdifAttribute &ldifname)
 244 {
 245         m_map.erase(ldifname);
 246 }
 247
 248 //
 249 // SetDNAttr
 250 //
 251 /// Sets the LDIF attribute name to use when constructing the FQDN.
 252 /// The FQDN field will take this name, and combine it with the
 253 /// baseDN from the constructor to produce a FQDN for the record.
 254 ///
 255 bool ContactLdif::SetDNAttr(const LdifAttribute &name)
 256 {
 257         // try to find the attribute in the map
 258         AccessMapType::iterator i = m_map.find(name);
 259         if( i == m_map.end() )
 260                 return false;
 261
 262         m_dnAttr = name;
 263         return true;
 264 }
 265
 266 bool ContactLdif::SetObjectClass(const LdifAttribute &name,
 267                                  const std::string &objectClass)
 268 {
 269         AccessMapType::iterator i = m_map.find(name);
 270         if( i == m_map.end() )
 271                 return false;
 272
 273         LdifAttribute key = i->first;
 274         AccessPair pair = i->second;
 275         m_map.erase(key);
 276         key.objectClass = objectClass;
 277         m_map[key] = pair;
 278         return true;
 279 }
 280
 281 bool ContactLdif::SetObjectOrder(const LdifAttribute &name, int order)
 282 {
 283         AccessMapType::iterator i = m_map.find(name);
 284         if( i == m_map.end() )
 285                 return false;
 286
 287         LdifAttribute key = i->first;
 288         AccessPair pair = i->second;
 289         m_map.erase(key);
 290         key.order = order;
 291         m_map[key] = pair;
 292         return true;
 293 }
 294
 295
 296 std::string ContactLdif::Email(const Barry::Contact &con) const
 297 {
 298         return con.GetEmail(m_emailIndex++);
 299 }
 300
 301 std::string ContactLdif::Phone(const Barry::Contact &con) const
 302 {
 303         return con.Phone;
 304 }
 305
 306 std::string ContactLdif::Fax(const Barry::Contact &con) const
 307 {
 308         return con.Fax;
 309 }
 310
 311 std::string ContactLdif::WorkPhone(const Barry::Contact &con) const
 312 {
 313         return con.WorkPhone;
 314 }
 315
 316 std::string ContactLdif::HomePhone(const Barry::Contact &con) const
 317 {
 318         return con.HomePhone;
 319 }
 320
 321 std::string ContactLdif::MobilePhone(const Barry::Contact &con) const
 322 {
 323         return con.MobilePhone;
 324 }
 325
 326 std::string ContactLdif::Pager(const Barry::Contact &con) const
 327 {
 328         return con.Pager;
 329 }
 330
 331 std::string ContactLdif::PIN(const Barry::Contact &con) const
 332 {
 333         return con.PIN;
 334 }
 335
 336 std::string ContactLdif::FirstName(const Barry::Contact &con) const
 337 {
 338         return con.FirstName;
 339 }
 340
 341 std::string ContactLdif::LastName(const Barry::Contact &con) const
 342 {
 343         return con.LastName;
 344 }
 345
 346 std::string ContactLdif::Company(const Barry::Contact &con) const
 347 {
 348         return con.Company;
 349 }
 350
 351 std::string ContactLdif::DefaultCommunicationsMethod(const Barry::Contact &con) const
 352 {
 353         return con.DefaultCommunicationsMethod;
 354 }
 355
 356 std::string ContactLdif::WorkAddress1(const Barry::Contact &con) const
 357 {
 358         return con.WorkAddress.Address1;
 359 }
 360
 361 std::string ContactLdif::WorkAddress2(const Barry::Contact &con) const
 362 {
 363         return con.WorkAddress.Address2;
 364 }
 365
 366 std::string ContactLdif::WorkAddress3(const Barry::Contact &con) const
 367 {
 368         return con.WorkAddress.Address3;
 369 }
 370
 371 std::string ContactLdif::WorkCity(const Barry::Contact &con) const
 372 {
 373         return con.WorkAddress.City;
 374 }
 375
 376 std::string ContactLdif::WorkProvince(const Barry::Contact &con) const
 377 {
 378         return con.WorkAddress.Province;
 379 }
 380
 381 std::string ContactLdif::WorkPostalCode(const Barry::Contact &con) const
 382 {
 383         return con.WorkAddress.PostalCode;
 384 }
 385
 386 std::string ContactLdif::WorkCountry(const Barry::Contact &con) const
 387 {
 388         return con.WorkAddress.Country;
 389 }
 390
 391 std::string ContactLdif::JobTitle(const Barry::Contact &con) const
 392 {
 393         return con.JobTitle;
 394 }
 395
 396 std::string ContactLdif::PublicKey(const Barry::Contact &con) const
 397 {
 398         return con.PublicKey;
 399 }
 400
 401 std::string ContactLdif::Notes(const Barry::Contact &con) const
 402 {
 403         return con.Notes;
 404 }
 405
 406 std::string ContactLdif::Image(const Barry::Contact &con) const
 407 {
 408         return con.Image;
 409 }
 410
 411 std::string ContactLdif::WorkPostalAddress(const Barry::Contact &con) const
 412 {
 413         return con.WorkAddress.GetLabel();
 414 }
 415
 416 std::string ContactLdif::HomePostalAddress(const Barry::Contact &con) const
 417 {
 418         return con.HomeAddress.GetLabel();
 419 }
 420
 421 std::string ContactLdif::FullName(const Barry::Contact &con) const
 422 {
 423         return con.GetFullName();
 424 }
 425
 426 std::string ContactLdif::FQDN(const Barry::Contact &con) const
 427 {
 428         std::string FQDN = m_dnAttr.name;
 429         FQDN += "=";
 430
 431         AccessMapType::const_iterator i = m_map.find(m_dnAttr);
 432         if( i != m_map.end() ) {
 433                 FQDN += (this->*(i->second.read))(con);
 434         }
 435         else {
 436                 FQDN += "unknown";
 437         }
 438
 439         FQDN += ",";
 440         FQDN += m_baseDN;
 441         return FQDN;
 442 }
 443
 444 bool ContactLdif::IsArrayFunc(GetFunctionType getf) const
 445 {
 446         // Currently, only the Email getter has array data
 447         if( getf == &ContactLdif::Email )
 448                 return true;
 449         return false;
 450 }
 451
 452 void ContactLdif::ClearArrayState() const
 453 {
 454         m_emailIndex = 0;
 455 }
 456
 457 void ContactLdif::SetEmail(Barry::Contact &con, const std::string &val) const
 458 {
 459         con.EmailAddresses.push_back(val);
 460 }
 461
 462 void ContactLdif::SetPhone(Barry::Contact &con, const std::string &val) const
 463 {
 464         con.Phone = val;
 465 }
 466
 467 void ContactLdif::SetFax(Barry::Contact &con, const std::string &val) const
 468 {
 469         con.Fax = val;
 470 }
 471
 472 void ContactLdif::SetWorkPhone(Barry::Contact &con, const std::string &val) const
 473 {
 474         con.WorkPhone = val;
 475 }
 476
 477 void ContactLdif::SetHomePhone(Barry::Contact &con, const std::string &val) const
 478 {
 479         con.HomePhone = val;
 480 }
 481
 482 void ContactLdif::SetMobilePhone(Barry::Contact &con, const std::string &val) const
 483 {
 484         con.MobilePhone = val;
 485 }
 486
 487 void ContactLdif::SetPager(Barry::Contact &con, const std::string &val) const
 488 {
 489         con.Pager = val;
 490 }
 491
 492 void ContactLdif::SetPIN(Barry::Contact &con, const std::string &val) const
 493 {
 494         con.PIN = val;
 495 }
 496
 497 void ContactLdif::SetFirstName(Barry::Contact &con, const std::string &val) const
 498 {
 499         con.FirstName = val;
 500 }
 501
 502 void ContactLdif::SetLastName(Barry::Contact &con, const std::string &val) const
 503 {
 504         con.LastName = val;
 505 }
 506
 507 void ContactLdif::SetCompany(Barry::Contact &con, const std::string &val) const
 508 {
 509         con.Company = val;
 510 }
 511
 512 void ContactLdif::SetDefaultCommunicationsMethod(Barry::Contact &con, const std::string &val) const
 513 {
 514         con.DefaultCommunicationsMethod = val;
 515 }
 516
 517 void ContactLdif::SetWorkAddress1(Barry::Contact &con, const std::string &val) const
 518 {
 519         con.WorkAddress.Address1 = val;
 520 }
 521
 522 void ContactLdif::SetWorkAddress2(Barry::Contact &con, const std::string &val) const
 523 {
 524         con.WorkAddress.Address2 = val;
 525 }
 526
 527 void ContactLdif::SetWorkAddress3(Barry::Contact &con, const std::string &val) const
 528 {
 529         con.WorkAddress.Address3 = val;
 530 }
 531
 532 void ContactLdif::SetWorkCity(Barry::Contact &con, const std::string &val) const
 533 {
 534         con.WorkAddress.City = val;
 535 }
 536
 537 void ContactLdif::SetWorkProvince(Barry::Contact &con, const std::string &val) const
 538 {
 539         con.WorkAddress.Province = val;
 540 }
 541
 542 void ContactLdif::SetWorkPostalCode(Barry::Contact &con, const std::string &val) const
 543 {
 544         con.WorkAddress.PostalCode = val;
 545 }
 546
 547 void ContactLdif::SetWorkCountry(Barry::Contact &con, const std::string &val) const
 548 {
 549         con.WorkAddress.Country = val;
 550 }
 551
 552 void ContactLdif::SetJobTitle(Barry::Contact &con, const std::string &val) const
 553 {
 554         con.JobTitle = val;
 555 }
 556
 557 void ContactLdif::SetPublicKey(Barry::Contact &con, const std::string &val) const
 558 {
 559         con.PublicKey = val;
 560 }
 561
 562 void ContactLdif::SetNotes(Barry::Contact &con, const std::string &val) const
 563 {
 564         con.Notes = val;
 565 }
 566
 567 void ContactLdif::SetImage(Barry::Contact &con, const std::string &val) const
 568 {
 569         con.Image = val;
 570 }
 571
 572 void ContactLdif::SetWorkPostalAddress(Barry::Contact &con, const std::string &val) const
 573 {
 574         // FIXME;
 575 //      throw std::runtime_error("SetWorkPostalAddress() not implemented");
 576 //      std::cout << "SetWorkPostalAddress() not implemented: " << val << std::endl;
 577 }
 578
 579 void ContactLdif::SetHomePostalAddress(Barry::Contact &con, const std::string &val) const
 580 {
 581         // FIXME;
 582 //      throw std::runtime_error("SetHomePostalAddress() not implemented");
 583 //      std::cout << "SetHomePostalAddress() not implemented: " << val << std::endl;
 584 }
 585
 586 void ContactLdif::SetFullName(Barry::Contact &con, const std::string &val) const
 587 {
 588         std::string first, last;
 589         Contact::SplitName(val, first, last);
 590         con.FirstName = first;
 591         con.LastName = last;
 592 }
 593
 594 void ContactLdif::SetFQDN(Barry::Contact &con, const std::string &val) const
 595 {
 596         throw std::runtime_error("not implemented");
 597 }
 598
 599
 600 void ContactLdif::ClearHeuristics()
 601 {
 602         m_cn.clear();
 603         m_displayName.clear();
 604         m_sn.clear();
 605         m_givenName.clear();
 606 }
 607
 608 bool ContactLdif::RunHeuristics(Barry::Contact &con)
 609 {
 610         // start fresh
 611         con.LastName.clear();
 612         con.FirstName.clear();
 613
 614         // find the best match for name... prefer sn/givenName if available
 615         if( m_sn.size() ) {
 616                 con.LastName = m_sn;
 617         }
 618         if( m_givenName.size() ) {
 619                 con.FirstName = m_givenName;
 620         }
 621
 622         if( !con.LastName.size() || !con.FirstName.size() ) {
 623                 std::string first, last;
 624
 625                 // still don't have a complete name, check cn first
 626                 if( m_cn.size() ) {
 627                         Contact::SplitName(m_cn, first, last);
 628                         if( !con.LastName.size() && last.size() )
 629                                 con.LastName = last;
 630                         if( !con.FirstName.size() && first.size() )
 631                                 con.FirstName = first;
 632                 }
 633
 634                 // displayName is last chance
 635                 if( m_displayName.size() ) {
 636                         Contact::SplitName(m_displayName, first, last);
 637                         if( !con.LastName.size() && last.size() )
 638                                 con.LastName = last;
 639                         if( !con.FirstName.size() && first.size() )
 640                                 con.FirstName = first;
 641                 }
 642         }
 643
 644         return con.LastName.size() && con.FirstName.size();
 645 }
 646
 647
 648 //
 649 // DumpLdif
 650 //
 651 /// Output contact data to os in LDAP LDIF format.
 652 ///
 653 void ContactLdif::DumpLdif(std::ostream &os,
 654                        const Barry::Contact &con) const
 655 {
 656         ios_format_state state(os);
 657
 658         // start fresh
 659         ClearArrayState();
 660
 661         // setup stream state
 662         os.setf(std::ios::left);
 663         os.fill(' ');
 664
 665         if( FirstName(con).size() == 0 && LastName(con).size() == 0 )
 666                 return;                 // nothing to do
 667
 668         os << "# Contact 0x" << std::hex << con.GetID() << ", "
 669                 << FullName(con) << "\n";
 670
 671         // cycle through the map
 672         for(    AccessMapType::const_iterator b = m_map.begin();
 673                 b != m_map.end();
 674                 ++b )
 675         {
 676                 // print only fields with data
 677                 std::string field;
 678
 679                 do {
 680                         field = (this->*(b->second.read))(con);
 681                         if( field.size() ) {
 682                                 os << b->first.name << MakeLdifData(field) << "\n";
 683                                 if( b->first.objectClass.size() )
 684                                         os << "objectClass: " << b->first.objectClass << "\n";
 685                         }
 686                 } while( IsArrayFunc(b->second.read) && field.size() );
 687         }
 688
 689         os << "objectClass: inetOrgPerson\n";
 690
 691         // last line must be empty
 692         os << "\n";
 693 }
 694
 695 bool ContactLdif::ReadLdif(std::istream &is, Barry::Contact &con)
 696 {
 697         std::string line;
 698
 699         // start fresh
 700         con.Clear();
 701         ClearHeuristics();
 702
 703         // search for beginning dn: line
 704         bool found = false;
 705         while( std::getline(is, line) ) {
 706                 if( strncmp(line.c_str(), "dn: ", 4) == 0 ) {
 707                         found = true;
 708                         break;
 709                 }
 710         }
 711         if( !found )
 712                 return false;
 713
 714         // storage for various name styles
 715         std::string coded, decode, attr, data;
 716         bool b64field = false;
 717
 718         // read ldif lines until empty line is found
 719         while( getline(is, line) && line.size() ) {
 720
 721                 if( b64field ) {
 722                         // processing a base64 encoded field
 723                         if( line[0] == ' ' ) {
 724                                 coded += "\n";
 725                                 coded += line;
 726                                 continue;
 727                         }
 728                         else {
 729                                 // end of base64 block... ignore errors,
 730                                 // and attempt to save everything decodable...
 731                                 // the LDAP server sometimes returns incomplete
 732                                 // base64 encoding, but otherwise the data is fine
 733                                 base64_decode(coded, decode);
 734                                 DoWrite(con, attr, decode);
 735                                 coded.clear();
 736                                 b64field = false;
 737                         }
 738                         // fall through to process new line
 739                 }
 740
 741
 742                 // split into attribute / data
 743                 std::string::size_type delim = line.find(':'), dstart;
 744                 if( delim == std::string::npos )
 745                         continue;
 746
 747                 attr.assign(line, 0, delim);
 748                 dstart = delim + 1;
 749                 while( line[dstart] == ' ' || line[dstart] == ':' )
 750                         dstart++;
 751                 data = line.substr(dstart);
 752
 753                 // is this data base64 encoded?
 754                 if( line[delim + 1] == ':' ) {
 755                         coded = data;
 756                         b64field = true;
 757                         continue;
 758                 }
 759
 760                 DoWrite(con, attr, data);
 761         }
 762
 763         if( b64field ) {
 764                 // clean up base64 decoding... ignore errors, see above comment
 765                 base64_decode(coded, decode);
 766                 DoWrite(con, attr, decode);
 767                 coded.clear();
 768                 b64field = false;
 769         }
 770
 771         return RunHeuristics(con);
 772 }
 773
 774 void ContactLdif::DumpMap(std::ostream &os) const
 775 {
 776         ios_format_state state(os);
 777
 778         os.setf(std::ios::left);
 779         os.fill(' ');
 780
 781         os << "ContactLdif Mapping:\n";
 782
 783         // cycle through the map
 784         for(    AccessMapType::const_iterator b = m_map.begin();
 785                 b != m_map.end();
 786                 ++b )
 787         {
 788                 os << "   " << std::left << std::setw(20) << b->first.name
 789                    << "->  " << GetFieldReadName(b->second.read)
 790                    << " / " << GetFieldWriteName(b->second.write) << "\n";
 791
 792                 // find read/write names
 793
 794                 if( b->first.objectClass.size() ) {
 795                         os << "   " << std::setw(20) << " "
 796                            << "objectClass: " << b->first.objectClass << "\n";
 797                 }
 798         }
 799
 800         os << "   >>> DN attribute: " << m_dnAttr.name << "\n";
 801 }
 802
 803 std::string ContactLdif::MakeLdifData(const std::string &str)
 804 {
 805         std::string data = ":";
 806
 807         if( NeedsEncoding(str) ) {
 808                 std::string b64;
 809                 base64_encode(str, b64);
 810
 811                 data += ": ";
 812                 data += b64;
 813         }
 814         else {
 815                 data += " ";
 816                 data += str;
 817         }
 818
 819         return data;
 820 }
 821
 822 //
 823 // RFC 2849
 824 //
 825 // Must not contain:
 826 //      0x00 (NUL), 0x0a (LF), 0x0d (CR), or anything greater than 0x7f
 827 //
 828 // First char must meet above criteria, plus must not be:
 829 //      0x20 (SPACE), 0x3a (colon), 0x3c ('<')
 830 //
 831 bool ContactLdif::NeedsEncoding(const std::string &str)
 832 {
 833         for( std::string::size_type i = 0; i < str.size(); i++ ) {
 834                 unsigned char c = str[i];
 835
 836                 switch( c )
 837                 {
 838                 case 0x00:
 839                 case 0x0a:
 840                 case 0x0d:
 841                         return true;
 842
 843                 case 0x20:
 844                 case 0x3a:
 845                 case 0x3c:
 846                         if( i == 0 )
 847                                 return true;
 848                 }
 849
 850                 if( c > 0x7f )
 851                         return true;
 852         }
 853         return false;
 854 }
 855
 856 } // namespace Barry
 857