tools/bio.cc

   1 ///
   2 /// \file       bio.cc
   3 ///             Barry Input / Output
   4 ///
   5
   6 /*
   7     Copyright (C) 2010-2012, 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 <barry/barry.h>
  23 #include <barry/barrysync.h>
  24 #include <barry/barrybackup.h>
  25
  26 #include "brecsum.h"
  27 #include "util.h"
  28
  29 #include <iomanip>
  30 #include <iostream>
  31 #include <sstream>
  32 #include <fstream>
  33 #include <string>
  34 #include <vector>
  35 #include <algorithm>
  36 #include <stdexcept>
  37 #include <tr1/memory>
  38 #include <strings.h>
  39 #include <unistd.h>
  40
  41 #include "barrygetopt.h"
  42
  43 using namespace std;
  44 using namespace std::tr1;
  45 using namespace Barry;
  46
  47 // keeping a record of all the -i device / -o device pin numbers, so
  48 // we can warn the poor user appropriately
  49 std::vector<Barry::Pin> m_device_pins;
  50
  51 bool IsPinUsed(const Barry::Pin &pin)
  52 {
  53         for( std::vector<Barry::Pin>::const_iterator b = m_device_pins.begin();
  54                         b != m_device_pins.end(); ++b )
  55         {
  56                 if( *b == pin )
  57                         return true;
  58         }
  59         return false;
  60 }
  61
  62 void Usage()
  63 {
  64    int logical, major, minor;
  65    const char *Version = Barry::Version(logical, major, minor);
  66
  67    cerr
  68    << "bio - Barry Input / Output\n"
  69    << "      Copyright 2010-2012, Net Direct Inc. (http://www.netdirect.ca/)\n"
  70    << "      Using: " << Version << "\n"
  71    << "      Compiled "
  72 #ifdef __BARRY_BOOST_MODE__
  73    << "with"
  74 #else
  75    << "without"
  76 #endif
  77    << " Boost support\n"
  78    << "\n"
  79    << " Usage:  bio -i <type> [options...]   -o <type> [options...]\n"
  80    << "\n"
  81    << "   -i type   The input type (Builder) to use for producing records\n"
  82    << "             Can be one of: device, tar"
  83 #ifdef __BARRY_BOOST_MODE__
  84    << ", boost"
  85 #endif
  86    << ", ldif, mime\n"
  87    << "   -o type   The output type (Parser) to use for processing records.\n"
  88    << "             Multiple outputs are allowed, as long as they don't\n"
  89    << "             conflict (such as two outputs writing to the same file\n"
  90    << "             or device).\n"
  91    << "             Can be one of: device, tar"
  92 #ifdef __BARRY_BOOST_MODE__
  93    << ", boost"
  94 #endif
  95    << ", ldif, mime, dump, sha1, cstore\n"
  96    << "\n"
  97    << " Options to use for 'device' type:\n"
  98    << "   -d db     Name of input database. Can be used multiple times.\n"
  99    << "   -A        Add all available device databases, instead of specifying\n"
 100    << "             them manually via -d\n"
 101    << "   -p pin    PIN of device to talk to\n"
 102    << "             If only one device is plugged in, this flag is optional\n"
 103    << "   -P pass   Simplistic method to specify device password\n"
 104    << "   -w mode   Set write mode when using 'device' for output.  Must be\n"
 105    << "             specified, or will not write anything.\n"
 106    << "             Can be one of: erase, overwrite, addonly, addnew\n"
 107    << "\n"
 108    << " Options to use for 'tar' backup type:\n"
 109    << "   -d db     Name of input database. Can be used multiple times.\n"
 110    << "             Not available in output mode.  Note that by default,\n"
 111    << "             all databases in the backup are selected, when reading,\n"
 112    << "             unless at least one -d is specified.\n"
 113    << "   -D db     Name of input database to skip.  If no -d options are used,\n"
 114    << "             then all databases are automatically selected.  Using -D\n"
 115    << "             allows a filtering selection.  If -d and -D are used for\n"
 116    << "             the same database, -D takes precedence.\n"
 117    << "   -f file   Tar backup file to read from or write to\n"
 118 #ifdef __BARRY_BOOST_MODE__
 119    << "\n"
 120    << " Options to use for 'boost' type:\n"
 121    << "   -f file   Boost serialization filename to read from or write to\n"
 122    << "             Can use - to specify stdin/stdout\n"
 123 #endif
 124    << "\n"
 125    << " Options to use for 'ldif' type:\n"
 126    << "   -c dn     Convert address book database to LDIF format, using the\n"
 127    << "             specified baseDN\n"
 128    << "   -C dnattr LDIF attribute name to use when building the FQDN\n"
 129    << "             Defaults to 'cn'\n"
 130 /*
 131 LDIF options?
 132
 133    << "   -L        List Contact field names\n"
 134    << "   -m        Map LDIF name to Contact field / Unmap LDIF name\n"
 135    << "                Map: ldif,read,write - maps ldif to read/write Contact fields\n"
 136    << "                Unmap: ldif name alone\n"
 137    << "   -M        List current LDIF mapping\n"
 138 */
 139    << "\n"
 140    << " Options to use for 'mime' type:\n"
 141    << "   -f file   Filename to read from or write to.  Use - to explicitly\n"
 142    << "             specify stdin/stdout, which is default.\n"
 143    << "\n"
 144    << " Options to use for 'dump' to stdout output type:\n"
 145    << "   -n        Use hex dump parser on all databases.\n"
 146    << "\n"
 147    << " Options to use for 'sha1' sum stdout output type:\n"
 148    << "   -t        Include DB Name, Type, and Unique record IDs in the checksums\n"
 149    << "\n"
 150    << " Options to use for 'cstore' output type:\n"
 151    << "   -l        List filenames only\n"
 152    << "   -f file   Filename from the above list, including path.\n"
 153    << "             If found, the file will be written to the current\n"
 154    << "             directory, using the base filename from the device.\n"
 155    << "\n"
 156    << " Standalone options:\n"
 157    << "   -h        This help\n"
 158    << "   -I cs     International charset for string conversions\n"
 159    << "             Valid values here are available with 'iconv --list'\n"
 160    << "   -S        Show list of supported database parsers and builders.\n"
 161    << "             Use twice to show field names as well.\n"
 162    << "   -v        Dump protocol data during operation\n"
 163    << "\n"
 164    << endl;
 165 }
 166
 167 class ModeBase
 168 {
 169 public:
 170         virtual ~ModeBase() {}
 171
 172         virtual bool ProbeNeeded() const { return false; }
 173
 174         virtual void SetFilename(const std::string &name)
 175         {
 176                 throw runtime_error("Filename not applicable for this mode");
 177         }
 178
 179         virtual void AddDB(const std::string &dbname)
 180         {
 181                 throw runtime_error("DB not applicable for this mode");
 182         }
 183
 184         virtual void AddSkipDB(const std::string &dbname)
 185         {
 186                 throw runtime_error("DB skipping not applicable for this mode");
 187         }
 188
 189         virtual void AddAllDBs()
 190         {
 191                 throw runtime_error("DBs not applicable for this mode");
 192         }
 193
 194         virtual void SetPIN(const std::string &pin)
 195         {
 196                 throw runtime_error("PIN not applicable for this mode");
 197         }
 198
 199         virtual void SetPassword(const std::string &password)
 200         {
 201                 throw runtime_error("Password not applicable for this mode");
 202         }
 203
 204         virtual void SetWriteMode(DeviceParser::WriteMode mode)
 205         {
 206                 throw runtime_error("Device write behaviour not applicable for this mode");
 207         }
 208
 209         virtual void SetDN(const std::string &dn)
 210         {
 211                 throw runtime_error("DN not applicable for this mode");
 212         }
 213
 214         virtual void SetAttribute(const std::string &attr)
 215         {
 216                 throw runtime_error("Attribute not applicable for this mode");
 217         }
 218
 219         virtual void SetHexDump()
 220         {
 221                 throw runtime_error("No hex dump option in this mode");
 222         }
 223
 224         virtual void IncludeIDs()
 225         {
 226                 throw runtime_error("Including record IDs in the SHA1 sum is not applicable in this mode");
 227         }
 228
 229         virtual void SetList()
 230         {
 231                 throw runtime_error("List option not applicable for this mode");
 232         }
 233 };
 234
 235 class DeviceBase : public virtual ModeBase
 236 {
 237 protected:
 238         Barry::Pin m_pin;
 239         std::string m_password;
 240
 241 public:
 242         bool ProbeNeeded() const { return true; }
 243
 244         void SetPIN(const std::string &pin)
 245         {
 246                 istringstream iss(pin);
 247                 iss >> m_pin;
 248                 if( !m_pin.Valid() )
 249                         throw runtime_error("Invalid PIN: " + pin);
 250         }
 251
 252         void SetPassword(const std::string &password)
 253         {
 254                 m_password = password;
 255         }
 256 };
 257
 258 //////////////////////////////////////////////////////////////////////////////
 259 // Base class for Input Mode
 260
 261 class InputBase : public virtual ModeBase
 262 {
 263 public:
 264         virtual Builder& GetBuilder(Barry::Probe *probe, IConverter &ic) = 0;
 265 };
 266
 267 class DeviceInputBase : public DeviceBase, public InputBase
 268 {
 269 };
 270
 271 //////////////////////////////////////////////////////////////////////////////
 272 // Mode: Input, Type: device
 273
 274 class DeviceInput : public DeviceInputBase
 275 {
 276         auto_ptr<Controller> m_con;
 277         auto_ptr<Mode::Desktop> m_desktop;
 278         auto_ptr<DeviceBuilder> m_builder;
 279         vector<string> m_dbnames;
 280         bool m_add_all;
 281
 282 public:
 283         DeviceInput()
 284                 : m_add_all(false)
 285         {
 286         }
 287
 288         void AddDB(const std::string &dbname)
 289         {
 290                 m_dbnames.push_back(dbname);
 291         }
 292
 293         void AddAllDBs()
 294         {
 295                 m_add_all = true;
 296         }
 297
 298         Builder& GetBuilder(Barry::Probe *probe, IConverter &ic)
 299         {
 300                 int i = probe->FindActive(m_pin);
 301                 if( i == -1 ) {
 302                         if( m_pin.Valid() )
 303                                 throw runtime_error("PIN not found: " + m_pin.Str());
 304                         else
 305                                 throw runtime_error("PIN not specified, and more than one device exists.");
 306                 }
 307
 308                 if( IsPinUsed(probe->Get(i).m_pin) ) {
 309                         throw runtime_error("It seems you are trying to use the same device for multiple input or outputs.");
 310                 }
 311                 m_device_pins.push_back(probe->Get(i).m_pin);
 312
 313                 m_con.reset( new Controller(probe->Get(i)) );
 314                 m_desktop.reset( new Mode::Desktop(*m_con, ic) );
 315                 m_desktop->Open(m_password.c_str());
 316                 m_builder.reset( new DeviceBuilder(*m_desktop) );
 317
 318                 if( m_add_all ) {
 319                         m_builder->Add(m_desktop->GetDBDB());
 320                 }
 321                 else {
 322                         for( size_t i = 0; i < m_dbnames.size(); i++ ) {
 323                                 if( !m_builder->Add(m_dbnames[i]) )
 324                                         throw runtime_error("Database not found: " + m_dbnames[i]);
 325                         }
 326                 }
 327
 328                 return *m_builder;
 329         }
 330 };
 331
 332 //////////////////////////////////////////////////////////////////////////////
 333 // Mode: Input, Type: tar
 334
 335 class TarInput : public InputBase
 336 {
 337         auto_ptr<Restore> m_restore;
 338         string m_tarpath;
 339         vector<string> m_dbnames, m_dbskips;
 340
 341 public:
 342         void SetFilename(const std::string &name)
 343         {
 344                 m_tarpath = name;
 345                 if( name == "-" )
 346                         throw runtime_error("Cannot use stdin as tar source file, sorry.");
 347         }
 348
 349         void AddDB(const std::string &dbname)
 350         {
 351                 m_dbnames.push_back(dbname);
 352         }
 353
 354         void AddSkipDB(const std::string &dbname)
 355         {
 356                 m_dbskips.push_back(dbname);
 357         }
 358
 359         Builder& GetBuilder(Barry::Probe *probe, IConverter &ic)
 360         {
 361                 m_restore.reset( new Restore(m_tarpath, true) );
 362                 for( size_t i = 0; i < m_dbnames.size(); i++ ) {
 363                         m_restore->AddDB(m_dbnames[i]);
 364                 }
 365                 for( size_t i = 0; i < m_dbskips.size(); i++ ) {
 366                         m_restore->AddSkipDB(m_dbskips[i]);
 367                 }
 368
 369                 return *m_restore;
 370         }
 371 };
 372
 373 //////////////////////////////////////////////////////////////////////////////
 374 // Mode: Input, Type: boost
 375
 376 #ifdef __BARRY_BOOST_MODE__
 377 class BoostInput : public InputBase
 378 {
 379         auto_ptr<BoostBuilder> m_builder;
 380         string m_filename;
 381
 382 public:
 383         BoostInput()
 384                 : m_filename("-")       // default to stdin/stdout
 385         {
 386         }
 387
 388         void SetFilename(const std::string &name)
 389         {
 390                 m_filename = name;
 391         }
 392
 393         Builder& GetBuilder(Barry::Probe *probe, IConverter &ic)
 394         {
 395                 if( m_filename == "-" ) {
 396                         // use stdin
 397                         m_builder.reset( new BoostBuilder(cin) );
 398                 }
 399                 else {
 400                         m_builder.reset( new BoostBuilder(m_filename) );
 401                 }
 402                 return *m_builder;
 403         }
 404
 405 };
 406 #endif
 407
 408 //////////////////////////////////////////////////////////////////////////////
 409 // Mode: Input, Type: ldif
 410
 411 class LdifInput : public InputBase
 412 {
 413         auto_ptr<Builder> m_builder;
 414         string m_filename;
 415
 416 public:
 417         LdifInput()
 418                 : m_filename("-")
 419         {
 420         }
 421
 422         void SetFilename(const std::string &name)
 423         {
 424                 m_filename = name;
 425         }
 426
 427         Builder& GetBuilder(Barry::Probe *probe, IConverter &ic)
 428         {
 429                 if( m_filename == "-" ) {
 430                         // use stdin
 431                         m_builder.reset(
 432                                 new RecordBuilder<Contact, LdifStore>(
 433                                         new LdifStore(cin)) );
 434                 }
 435                 else {
 436                         m_builder.reset(
 437                                 new RecordBuilder<Contact, LdifStore>(
 438                                         new LdifStore(m_filename)) );
 439                 }
 440                 return *m_builder;
 441         }
 442
 443 };
 444
 445
 446 //////////////////////////////////////////////////////////////////////////////
 447 // Mode: Input, Type: mime
 448
 449 class MimeInput : public InputBase
 450 {
 451         auto_ptr<MimeBuilder> m_builder;
 452         string m_filename;
 453
 454 public:
 455         MimeInput()
 456                 : m_filename("-")
 457         {
 458         }
 459
 460         void SetFilename(const std::string &name)
 461         {
 462                 m_filename = name;
 463         }
 464
 465         Builder& GetBuilder(Barry::Probe *probe, IConverter &ic)
 466         {
 467                 if( m_filename == "-" ) {
 468                         // use stdin
 469                         m_builder.reset( new MimeBuilder(cin) );
 470                 }
 471                 else {
 472                         m_builder.reset( new MimeBuilder(m_filename) );
 473                 }
 474                 return *m_builder;
 475         }
 476
 477 };
 478
 479 //////////////////////////////////////////////////////////////////////////////
 480 // Base class for Output Mode
 481
 482 class OutputBase : public virtual ModeBase
 483 {
 484 public:
 485         virtual Parser& GetParser(Barry::Probe *probe, IConverter &ic) = 0;
 486 };
 487
 488 class DeviceOutputBase : public DeviceBase, public OutputBase
 489 {
 490 };
 491
 492 //////////////////////////////////////////////////////////////////////////////
 493 // Mode: Output, Type: device
 494
 495 class DeviceOutput : public DeviceOutputBase
 496 {
 497         auto_ptr<Controller> m_con;
 498         auto_ptr<Mode::Desktop> m_desktop;
 499         auto_ptr<DeviceParser> m_parser;
 500         DeviceParser::WriteMode m_mode;
 501
 502 public:
 503         DeviceOutput()
 504                 : m_mode(DeviceParser::DROP_RECORD)
 505         {
 506         }
 507
 508         void SetWriteMode(DeviceParser::WriteMode mode)
 509         {
 510                 m_mode = mode;
 511         }
 512
 513         Parser& GetParser(Barry::Probe *probe, IConverter &ic)
 514         {
 515                 if( m_mode == DeviceParser::DROP_RECORD ) {
 516                         cerr << "Warning: the -w switch was not specified: no data will be written to the device." << endl;
 517                 }
 518
 519                 int i = probe->FindActive(m_pin);
 520                 if( i == -1 ) {
 521                         if( m_pin.Valid() )
 522                                 throw runtime_error("PIN not found: " + m_pin.Str());
 523                         else
 524                                 throw runtime_error("PIN not specified, and more than one device exists.");
 525                 }
 526
 527                 if( IsPinUsed(probe->Get(i).m_pin) ) {
 528                         throw runtime_error("It seems you are trying to use the same device for multiple input or outputs.");
 529                 }
 530                 m_device_pins.push_back(probe->Get(i).m_pin);
 531
 532                 m_con.reset( new Controller(probe->Get(i)) );
 533                 m_desktop.reset( new Mode::Desktop(*m_con, ic) );
 534                 m_desktop->Open(m_password.c_str());
 535                 m_parser.reset( new DeviceParser(*m_desktop, m_mode) );
 536
 537                 return *m_parser;
 538         }
 539 };
 540
 541 //////////////////////////////////////////////////////////////////////////////
 542 // Mode: Output, Type: tar
 543
 544 class TarOutput : public OutputBase
 545 {
 546         auto_ptr<Backup> m_backup;
 547         string m_tarpath;
 548
 549 public:
 550         void SetFilename(const std::string &name)
 551         {
 552                 m_tarpath = name;
 553                 if( name == "-" )
 554                         throw runtime_error("Cannot use stdout as tar backup file, sorry.");
 555         }
 556
 557         Parser& GetParser(Barry::Probe *probe, IConverter &ic)
 558         {
 559                 m_backup.reset( new Backup(m_tarpath) );
 560                 return *m_backup;
 561         }
 562 };
 563
 564 //////////////////////////////////////////////////////////////////////////////
 565 // Mode: Output, Type: boost
 566
 567 #ifdef __BARRY_BOOST_MODE__
 568 class BoostOutput : public OutputBase
 569 {
 570         auto_ptr<BoostParser> m_parser;
 571         string m_filename;
 572
 573 public:
 574         void SetFilename(const std::string &name)
 575         {
 576                 m_filename = name;
 577         }
 578
 579         Parser& GetParser(Barry::Probe *probe, IConverter &ic)
 580         {
 581                 if( !m_filename.size() )
 582                         throw runtime_error("Boost output requires a specific output file (-f switch)");
 583
 584                 if( m_filename == "-" ) {
 585                         // use stdout
 586                         m_parser.reset( new BoostParser(cout) );
 587                 }
 588                 else {
 589                         m_parser.reset( new BoostParser(m_filename) );
 590                 }
 591                 return *m_parser;
 592         }
 593
 594 };
 595 #endif
 596
 597 //////////////////////////////////////////////////////////////////////////////
 598 // Mode: Output, Type: ldif
 599
 600 class LdifOutput : public OutputBase
 601 {
 602         auto_ptr<Parser> m_parser;
 603         string m_filename;
 604         string m_baseDN;
 605         string m_dnattr;
 606
 607 public:
 608         LdifOutput()
 609                 : m_filename("-")
 610         {
 611         }
 612
 613         void SetFilename(const std::string &name)
 614         {
 615                 m_filename = name;
 616         }
 617
 618         void SetDN(const std::string &dn)
 619         {
 620                 m_baseDN = dn;
 621         }
 622
 623         void SetAttribute(const std::string &attr)
 624         {
 625                 m_dnattr = attr;
 626         }
 627
 628         Parser& GetParser(Barry::Probe *probe, IConverter &ic)
 629         {
 630                 if( m_filename == "-" ) {
 631                         // use stdin
 632                         m_parser.reset(
 633                                 new RecordParser<Contact, LdifStore>(
 634                                         new LdifStore(cout, m_baseDN,
 635                                                 m_dnattr)) );
 636                 }
 637                 else {
 638                         m_parser.reset(
 639                                 new RecordParser<Contact, LdifStore>(
 640                                         new LdifStore(m_filename, m_baseDN,
 641                                                 m_dnattr)) );
 642                 }
 643                 return *m_parser;
 644         }
 645 };
 646
 647 //////////////////////////////////////////////////////////////////////////////
 648 // Mode: Output, Type: mime
 649
 650 class MimeStore : public AllRecordStore
 651 {
 652         std::ostream &m_os;
 653
 654 public:
 655         MimeStore(std::ostream &os)
 656                 : m_os(os)
 657         {
 658         }
 659
 660 #undef HANDLE_PARSER
 661 #define HANDLE_PARSER(tname) \
 662         void operator() (const Barry::tname &r) \
 663         { \
 664                 MimeDump<tname>::Dump(m_os, r); \
 665         }
 666
 667         ALL_KNOWN_PARSER_TYPES
 668 };
 669
 670 class MimeOutput : public OutputBase
 671 {
 672         auto_ptr<std::ofstream> m_file;
 673         auto_ptr<Parser> m_parser;
 674         std::string m_filename;
 675
 676 public:
 677         MimeOutput()
 678                 : m_filename("-")       // default to stdout
 679         {
 680         }
 681
 682         void SetFilename(const std::string &name)
 683         {
 684                 m_filename = name;
 685         }
 686
 687         Parser& GetParser(Barry::Probe *probe, IConverter &ic)
 688         {
 689                 if( m_filename == "-" ) {
 690                         m_parser.reset( new AllRecordParser(cout,
 691                                 new HexDumpParser(cout),
 692                                 new MimeStore(cout)) );
 693                 }
 694                 else {
 695                         m_file.reset( new std::ofstream(m_filename.c_str()) );
 696                         m_parser.reset( new AllRecordParser(*m_file,
 697                                 new HexDumpParser(*m_file),
 698                                 new MimeStore(*m_file)) );
 699                 }
 700                 return *m_parser;
 701         }
 702 };
 703
 704 //////////////////////////////////////////////////////////////////////////////
 705 // Mode: Output, Type: dump
 706
 707 class DumpOutput : public OutputBase
 708 {
 709         auto_ptr<Parser> m_parser;
 710         bool m_hex_only;
 711
 712 public:
 713         DumpOutput()
 714                 : m_hex_only(false)
 715         {
 716         }
 717
 718         void SetHexDump()
 719         {
 720                 m_hex_only = true;
 721         }
 722
 723         Parser& GetParser(Barry::Probe *probe, IConverter &ic)
 724         {
 725                 if( m_hex_only ) {
 726                         m_parser.reset( new HexDumpParser(cout) );
 727                 }
 728                 else {
 729                         m_parser.reset( new AllRecordParser(cout,
 730                                 new HexDumpParser(cout),
 731                                 new AllRecordDumpStore(cout)) );
 732                 }
 733                 return *m_parser;
 734         }
 735 };
 736
 737 //////////////////////////////////////////////////////////////////////////////
 738 // Mode: Output, Type: sha1
 739
 740 class Sha1Output : public OutputBase
 741 {
 742         auto_ptr<Parser> m_parser;
 743         bool m_include_ids;
 744
 745 public:
 746         Sha1Output()
 747                 : m_include_ids(false)
 748         {
 749         }
 750
 751         void IncludeIDs()
 752         {
 753                 m_include_ids = true;
 754         }
 755
 756         Parser& GetParser(Barry::Probe *probe, IConverter &ic)
 757         {
 758                 m_parser.reset( new ChecksumParser(m_include_ids) );
 759                 return *m_parser;
 760         }
 761 };
 762
 763 //////////////////////////////////////////////////////////////////////////////
 764 // Mode: Output, Type: cstore
 765
 766 class ContentStoreOutput : public OutputBase
 767 {
 768         auto_ptr<Parser> m_parser;
 769         bool m_list_only;
 770         vector<string> m_filenames;
 771
 772 public:
 773         ContentStoreOutput()
 774                 : m_list_only(false)
 775         {
 776         }
 777
 778         void SetFilename(const std::string &name)
 779         {
 780                 m_filenames.push_back(name);
 781         }
 782
 783         void SetList()
 784         {
 785                 m_list_only = true;
 786         }
 787
 788         Parser& GetParser(Barry::Probe *probe, IConverter &ic)
 789         {
 790                 m_parser.reset( new RecordParser<ContentStore, ContentStoreOutput>(*this) );
 791                 return *m_parser;
 792         }
 793
 794         // storage operator
 795         void operator() (const ContentStore &rec)
 796         {
 797                 if( m_list_only ) {
 798                         cout << rec.Filename;
 799                         if( rec.FolderFlag ) {
 800                                 cout << " (folder)";
 801                         }
 802                         cout << endl;
 803                 }
 804                 else {
 805                         // check if this record matches one of the filenames
 806                         // in the list
 807                         vector<string>::iterator i = find(m_filenames.begin(),
 808                                 m_filenames.end(), rec.Filename);
 809                         if( i != m_filenames.end() ) {
 810                                 SaveFile(rec);
 811                         }
 812                 }
 813         }
 814
 815         void SaveFile(const ContentStore &rec)
 816         {
 817                 size_t slash = rec.Filename.rfind('/');
 818                 string filename;
 819                 if( slash == string::npos )
 820                         filename = rec.Filename;
 821                 else
 822                         filename = rec.Filename.substr(slash + 1);
 823
 824                 // modify filename until we find one that doesn't
 825                 // already exist
 826                 string freshname = filename;
 827                 int count = 0;
 828                 while( access(freshname.c_str(), F_OK) == 0 ) {
 829                         ostringstream oss;
 830                         oss << filename << count++;
 831                         freshname = oss.str();
 832                 }
 833
 834                 // open and write!
 835                 cout << "Saving: " << rec.Filename
 836                         << " as " << freshname << endl;
 837                 ofstream ofs(freshname.c_str());
 838                 ofs << rec.FileContent;
 839                 ofs.flush();
 840                 if( !ofs ) {
 841                         cout << "Error during write!" << endl;
 842                 }
 843         }
 844 };
 845
 846
 847
 848 //////////////////////////////////////////////////////////////////////////////
 849 // Main application class
 850
 851 class App
 852 {
 853 public:
 854         typedef shared_ptr<OutputBase> OutputPtr;
 855         typedef vector<OutputPtr> OutputsType;
 856
 857 private:
 858         auto_ptr<InputBase> Input;
 859         OutputsType Outputs;
 860
 861 public:
 862
 863         bool ParseInMode(const string &mode);
 864         bool ParseOutMode(const string &mode);
 865         DeviceParser::WriteMode ParseWriteMode(const std::string &mode);
 866         // returns true if any of the items in Outputs needs a probe
 867         bool OutputsProbeNeeded();
 868         int main(int argc, char *argv[]);
 869 };
 870
 871 bool App::ParseInMode(const string &mode)
 872 {
 873         if( mode == "device" ) {
 874                 Input.reset( new DeviceInput );
 875                 return true;
 876         }
 877         else if( mode == "tar" ) {
 878                 Input.reset( new TarInput );
 879                 return true;
 880         }
 881 #ifdef __BARRY_BOOST_MODE__
 882         else if( mode == "boost" ) {
 883                 Input.reset( new BoostInput );
 884                 return true;
 885         }
 886 #endif
 887         else if( mode == "ldif" ) {
 888                 Input.reset( new LdifInput );
 889                 return true;
 890         }
 891         else if( mode == "mime" ) {
 892                 Input.reset( new MimeInput );
 893                 return true;
 894         }
 895         else
 896                 return false;
 897 }
 898
 899 bool App::ParseOutMode(const string &mode)
 900 {
 901         if( mode == "device" ) {
 902                 Outputs.push_back( OutputPtr(new DeviceOutput) );
 903                 return true;
 904         }
 905         else if( mode == "tar" ) {
 906                 Outputs.push_back( OutputPtr(new TarOutput) );
 907                 return true;
 908         }
 909 #ifdef __BARRY_BOOST_MODE__
 910         else if( mode == "boost" ) {
 911                 Outputs.push_back( OutputPtr(new BoostOutput) );
 912                 return true;
 913         }
 914 #endif
 915         else if( mode == "ldif" ) {
 916                 Outputs.push_back( OutputPtr(new LdifOutput) );
 917                 return true;
 918         }
 919         else if( mode == "mime" ) {
 920                 Outputs.push_back( OutputPtr(new MimeOutput) );
 921                 return true;
 922         }
 923         else if( mode == "dump" ) {
 924                 Outputs.push_back( OutputPtr(new DumpOutput) );
 925                 return true;
 926         }
 927         else if( mode == "sha1" ) {
 928                 Outputs.push_back( OutputPtr(new Sha1Output) );
 929                 return true;
 930         }
 931         else if( mode == "cstore" ) {
 932                 Outputs.push_back( OutputPtr(new ContentStoreOutput) );
 933                 return true;
 934         }
 935         else
 936                 return false;
 937 }
 938
 939 DeviceParser::WriteMode App::ParseWriteMode(const std::string &mode)
 940 {
 941         if( mode == "erase" )
 942                 return DeviceParser::ERASE_ALL_WRITE_ALL;
 943         else if( mode == "overwrite" )
 944                 return DeviceParser::INDIVIDUAL_OVERWRITE;
 945         else if( mode == "addonly" )
 946                 return DeviceParser::ADD_BUT_NO_OVERWRITE;
 947         else if( mode == "addnew" )
 948                 return DeviceParser::ADD_WITH_NEW_ID;
 949         else
 950                 throw runtime_error("Unknown device output mode. Must be one of: erase, overwrite, addonly, addnew");
 951 }
 952
 953 bool App::OutputsProbeNeeded()
 954 {
 955         for( OutputsType::iterator i = Outputs.begin();
 956                 i != Outputs.end();
 957                 ++i )
 958         {
 959                 if( (*i)->ProbeNeeded() )
 960                         return true;
 961         }
 962         return false;
 963 }
 964
 965 int App::main(int argc, char *argv[])
 966 {
 967         bool verbose = false;
 968         bool show_parsers = false, show_fields = false;
 969         string iconvCharset;
 970
 971         // process command line options
 972         ModeBase *current = 0;
 973         for(;;) {
 974                 int cmd = getopt(argc, argv, "hi:o:nvI:f:p:P:d:D:c:C:ASw:tl");
 975                 if( cmd == -1 )
 976                         break;
 977
 978                 // first option must be in or out, or a global option
 979                 if( !current ) {
 980                         if( cmd != 'i' && \
 981                             cmd != 'o' && \
 982                             cmd != 'S' && \
 983                             cmd != 'I' && \
 984                             cmd != 'v' )
 985                         {
 986                                 Usage();
 987                                 return 1;
 988                         }
 989                 }
 990
 991                 switch( cmd )
 992                 {
 993                 case 'i':       // set input mode
 994                         // must be first time used
 995                         if( Input.get() || !ParseInMode(optarg) ) {
 996                                 Usage();
 997                                 return 1;
 998                         }
 999                         current = Input.get();
1000                         break;
1001
1002                 case 'o':       // set output mode
1003                         // can be used multiple times
1004                         if( !ParseOutMode(optarg) ) {
1005                                 Usage();
1006                                 return 1;
1007                         }
1008                         current = Outputs[Outputs.size() - 1].get();
1009                         break;
1010
1011
1012                 case 'c':       // set ldif dn
1013                         current->SetDN(optarg);
1014                         break;
1015
1016                 case 'C':       // set ldif attr
1017                         current->SetAttribute(optarg);
1018                         break;
1019
1020                 case 'd':       // database name
1021                         current->AddDB(optarg);
1022                         break;
1023
1024                 case 'D':       // database name to skip
1025                         current->AddSkipDB(optarg);
1026                         break;
1027
1028                 case 'f':       // filename
1029                         current->SetFilename(optarg);
1030                         break;
1031
1032                 case 'p':       // device PIN
1033                         current->SetPIN(optarg);
1034                         break;
1035
1036                 case 'P':       // password
1037                         current->SetPassword(optarg);
1038                         break;
1039
1040                 case 'w':       // device write mode
1041                         current->SetWriteMode(ParseWriteMode(optarg));
1042                         break;
1043
1044                 case 'A':       // add all DB names to the device builder
1045                         current->AddAllDBs();
1046                         break;
1047
1048                 case 't':       // include type and IDs in sha1 mode
1049                         current->IncludeIDs();
1050                         break;
1051
1052                 case 'l':       // list only
1053                         current->SetList();
1054                         break;
1055
1056                 case 'S':       // show parsers and builders
1057                         if( show_parsers )
1058                                 show_fields = true;
1059                         else
1060                                 show_parsers = true;
1061                         break;
1062
1063                 case 'I':       // international charset (iconv)
1064                         iconvCharset = optarg;
1065                         break;
1066
1067                 case 'n':       // use null hex dump parser only
1068                         current->SetHexDump();
1069                         break;
1070
1071                 case 'v':       // verbose
1072                         verbose = true;
1073                         break;
1074
1075                 case 'h':       // help
1076                 default:
1077                         Usage();
1078                         return 0;
1079                 }
1080         }
1081
1082         if( show_parsers ) {
1083                 ShowParsers(show_fields, true);
1084                 ShowBuilders();
1085                 return 0;
1086         }
1087
1088         if( !Input.get() || !Outputs.size() ) {
1089                 Usage();
1090                 return 0;
1091         }
1092
1093         // Initialize the Barry library
1094         Barry::Init(verbose);
1095
1096         // Create an IConverter object if needed
1097         auto_ptr<IConverter> ic;
1098         if( iconvCharset.size() ) {
1099                 ic.reset( new IConverter(iconvCharset.c_str(), true) );
1100         }
1101
1102         // Probe for devices only if needed
1103         auto_ptr<Probe> probe;
1104         if( Input->ProbeNeeded() || OutputsProbeNeeded() ) {
1105                 // Probe for available devices
1106                 probe.reset( new Probe );
1107         }
1108
1109         // Setup the input first (builder)
1110         Builder &builder = Input->GetBuilder(probe.get(), *ic);
1111
1112         // Setup a TeeParser with all Outputs
1113         TeeParser tee;
1114         for( OutputsType::iterator i = Outputs.begin(); i != Outputs.end(); ++i ) {
1115                 Parser &parser = (*i)->GetParser(probe.get(), *ic);
1116                 tee.Add(parser);
1117         }
1118
1119         // Setup the pipe
1120         Pipe pipe(builder);
1121         pipe.PumpFile(tee, ic.get());
1122
1123         return 0;
1124 }
1125
1126 int main(int argc, char *argv[])
1127 {
1128         try {
1129                 App app;
1130                 return app.main(argc, argv);
1131         }
1132         catch( std::exception &e ) {
1133                 cerr << "Exception: " << e.what() << endl;
1134                 return 1;
1135         }
1136 }
1137