tools/bfuse.cc

   1 ///
   2 /// \file       bfuse.cc
   3 ///             FUSE filesystem for Blackberry databases, using Barry.
   4 ///
   5
   6 /*
   7     Copyright (C) 2008-2010, 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 #define FUSE_USE_VERSION 25
  23 #include <fuse.h>
  24 #include <fuse_opt.h>
  25
  26 #include <barry/barry.h>
  27 #include <sstream>
  28 #include <getopt.h>
  29 #include <vector>
  30 #include <list>
  31 #include <string>
  32 #include <stdexcept>
  33 #include <memory>
  34 #include <tr1/memory>
  35 #include <errno.h>
  36 #include <sys/types.h>
  37 #include <fcntl.h>
  38 #include <string.h>
  39 #include "i18n.h"
  40
  41 using namespace std;
  42 using namespace std::tr1;
  43 using namespace Barry;
  44
  45 // Global filenames
  46 const char *error_log_filename = "error.log";
  47
  48 // Global command line args
  49 string cmdline_pin;
  50 string cmdline_password;
  51
  52 //
  53 // Data from the command line
  54 //
  55
  56 /////////////////////////////////////////////////////////////////////////////
  57 // Command line option handling, through fuse
  58
  59 //struct opt {
  60 //      char
  61 //};
  62
  63 void Blurb()
  64 {
  65    int major, minor;
  66    const char *Version = Barry::Version(major, minor);
  67
  68    cerr
  69    << "bfuse - FUSE filesystem for Blackberry databases\n"
  70    << "        Copyright 2008-2010, Net Direct Inc. (http://www.netdirect.ca/)\n"
  71    << "        Using: " << Version << "\n"
  72    << endl;
  73 }
  74
  75 void Usage()
  76 {
  77    cerr
  78    << "\n"
  79    << "Barry specific options:\n"
  80    << "   -p pin    PIN of device to talk with\n"
  81    << "             If only one device is plugged in, this flag is optional\n"
  82    << "   -P pass   Simplistic method to specify device password\n"
  83    << endl;
  84 /*
  85    << "   -d db     Specify which database to mount.  If no -d options exist\n"
  86    << "             then all databases will be mounted.\n"
  87    << "             Can be used multiple times to mount more than one DB\n"
  88    << "   -h        This help\n"
  89    << "   -n        Use null parser on all databases.\n"
  90 */
  91 }
  92
  93 /////////////////////////////////////////////////////////////////////////////
  94 // FUSE specific exception
  95
  96 class fuse_error : public std::runtime_error
  97 {
  98         int m_errno;
  99 public:
 100         fuse_error(int errno_, const std::string &msg)
 101                 : std::runtime_error(msg), m_errno(errno_)
 102         {}
 103
 104         int get_errno() const { return m_errno; }
 105 };
 106
 107
 108 /////////////////////////////////////////////////////////////////////////////
 109 // Barry record parsers
 110
 111 class DataDumpParser : public Barry::Parser
 112 {
 113         uint32_t m_id;
 114         std::ostream &m_os;
 115
 116 public:
 117         explicit DataDumpParser(std::ostream &os)
 118                 : m_os(os)
 119         {
 120         }
 121
 122         virtual void Clear() {}
 123
 124         virtual void SetIds(uint8_t RecType, uint32_t UniqueId)
 125         {
 126                 m_id = UniqueId;
 127         }
 128
 129         virtual void ParseHeader(const Barry::Data &, size_t &) {}
 130
 131         virtual void ParseFields(const Barry::Data &data, size_t &offset,
 132                                 const Barry::IConverter *ic)
 133         {
 134                 m_os << "Raw record dump for record: "
 135                         << std::hex << m_id << std::endl;
 136                 m_os << data << std::endl;
 137         }
 138
 139         virtual void Store() {}
 140 };
 141
 142 template <class Record>
 143 struct Store
 144 {
 145         std::ostream &m_os;
 146
 147         explicit Store(std::ostream &os)
 148                 : m_os(os)
 149         {
 150         }
 151
 152         // storage operator
 153         void operator()(const Record &rec)
 154         {
 155                 m_os << rec;
 156         }
 157 };
 158
 159 typedef std::auto_ptr<Barry::Parser>            ParserPtr;
 160
 161 ParserPtr GetParser(const string &name, std::ostream &os, bool null_parser)
 162 {
 163         if( null_parser ) {
 164                 // use null parser
 165                 return ParserPtr( new DataDumpParser(os) );
 166         }
 167         // check for recognized database names
 168         else if( name == Contact::GetDBName() ) {
 169                 return ParserPtr(
 170                         new RecordParser<Contact, Store<Contact> > (
 171                                 new Store<Contact>(os)));
 172         }
 173         else if( name == Message::GetDBName() ) {
 174                 return ParserPtr(
 175                         new RecordParser<Message, Store<Message> > (
 176                                 new Store<Message>(os)));
 177         }
 178         else if( name == Calendar::GetDBName() ) {
 179                 return ParserPtr(
 180                         new RecordParser<Calendar, Store<Calendar> > (
 181                                 new Store<Calendar>(os)));
 182         }
 183         else if( name == CalendarAll::GetDBName() ) {
 184                 return ParserPtr(
 185                         new RecordParser<CalendarAll, Store<CalendarAll> > (
 186                                 new Store<CalendarAll>(os)));
 187         }
 188         else if( name == ServiceBook::GetDBName() ) {
 189                 return ParserPtr(
 190                         new RecordParser<ServiceBook, Store<ServiceBook> > (
 191                                 new Store<ServiceBook>(os)));
 192         }
 193
 194         else if( name == Memo::GetDBName() ) {
 195                 return ParserPtr(
 196                         new RecordParser<Memo, Store<Memo> > (
 197                                 new Store<Memo>(os)));
 198         }
 199         else if( name == Task::GetDBName() ) {
 200                 return ParserPtr(
 201                         new RecordParser<Task, Store<Task> > (
 202                                 new Store<Task>(os)));
 203         }
 204         else if( name == PINMessage::GetDBName() ) {
 205                 return ParserPtr(
 206                         new RecordParser<PINMessage, Store<PINMessage> > (
 207                                 new Store<PINMessage>(os)));
 208         }
 209         else if( name == SavedMessage::GetDBName() ) {
 210                 return ParserPtr(
 211                         new RecordParser<SavedMessage, Store<SavedMessage> > (
 212                                 new Store<SavedMessage>(os)));
 213         }
 214         else if( name == Folder::GetDBName() ) {
 215                 return ParserPtr(
 216                         new RecordParser<Folder, Store<Folder> > (
 217                                 new Store<Folder>(os)));
 218         }
 219         else if( name == Timezone::GetDBName() ) {
 220                 return ParserPtr(
 221                         new RecordParser<Timezone, Store<Timezone> > (
 222                                 new Store<Timezone>(os)));
 223         }
 224         else {
 225                 // unknown database, use null parser
 226                 return ParserPtr( new DataDumpParser(os) );
 227         }
 228 }
 229
 230 /////////////////////////////////////////////////////////////////////////////
 231 // PathSplit class
 232
 233 class PathSplit
 234 {
 235         std::string m_pin, m_db, m_record, m_field, m_remainder;
 236
 237         int m_level;            // the number of slashes, minus the first
 238                                 // i.e. first level is 0
 239         bool m_is_root;
 240
 241 public:
 242         explicit PathSplit(const char *path)
 243                 : m_level(-1)
 244                 , m_is_root(false)
 245         {
 246                 if( *path != '/' )
 247                         return;         // return in a failed state
 248
 249                 if( *(path+1) == 0 ) {
 250                         m_is_root = true;
 251                         return;
 252                 }
 253
 254                 const char *s = path, *e = path;
 255                 while( *e ) {
 256                         while( *e && *e != '/' )
 257                                 e++;
 258
 259                         m_level++;
 260
 261                         if( s != e && (s+1) != e ) {
 262                                 string token(s+1, e);
 263
 264                                 switch( m_level )
 265                                 {
 266                                 case 0: // root level, should not have token here
 267                                         m_level = -1;
 268                                         return; // failed state
 269
 270                                 case 1: // have pin
 271                                         m_pin = token;
 272                                         break;
 273
 274                                 case 2: // have db
 275                                         m_db = token;
 276                                         break;
 277
 278                                 case 3: // have record
 279                                         m_record = token;
 280                                         break;
 281
 282                                 case 4: // have field
 283                                         m_field = token;
 284                                         break;
 285
 286                                 default:        // too many, store remainder and done
 287                                         m_remainder = s;        // keeps slash
 288                                         return;
 289                                 }
 290
 291                                 // next
 292                                 s = e;
 293                                 if( *e )
 294                                         e++;
 295                         }
 296                         else if( *e ) {
 297                                 // next
 298                                 e++;
 299                         }
 300                 }
 301         }
 302
 303         bool IsRoot() const { return m_is_root; }
 304         const std::string& Pin() const { return m_pin; }
 305         const std::string& DB() const { return m_db; }
 306         const std::string& Record() const { return m_record; }
 307         const std::string& Field() const { return m_field; }
 308         const std::string& Remainder() const { return m_remainder; }
 309         int Level() const { return m_level; }
 310 };
 311
 312
 313 /////////////////////////////////////////////////////////////////////////////
 314 // API classes
 315
 316 class Entry
 317 {
 318 public:
 319         virtual ~Entry() {}
 320 };
 321
 322 class Directory : public Entry
 323 {
 324 public:
 325         virtual int ReadDir(void *buf, fuse_fill_dir_t filler) = 0;
 326         virtual void FillDirStat(struct stat *st)
 327         {
 328                 st->st_mode = S_IFDIR | 0555;
 329                 st->st_nlink = 2;
 330         }
 331 };
 332
 333 class File : public Entry
 334 {
 335 public:
 336         virtual void FillFileStat(const char *path, struct stat *st) = 0;
 337         virtual bool AccessOk(int flags)
 338         {
 339                 // default to readonly files
 340                 return (flags & (O_RDONLY | O_WRONLY | O_RDWR)) == O_RDONLY;
 341         }
 342         virtual int ReadFile(const char *path, char *buf, size_t size, off_t offset) = 0;
 343 };
 344
 345 typedef Directory*                              DirectoryPtr;
 346 typedef File*                                   FilePtr;
 347 typedef std::string                             NameT;
 348 typedef std::map<NameT, DirectoryPtr>           DirMap;
 349 typedef std::map<NameT, FilePtr>                FileMap;
 350
 351 static DirMap g_dirmap;
 352 static FileMap g_filemap;
 353
 354 static Directory* FindDir(const NameT &name)
 355 {
 356         DirMap::iterator di = g_dirmap.find(name);
 357         return di == g_dirmap.end() ? 0 : di->second;
 358 }
 359
 360 static File* FindFile(const NameT &name)
 361 {
 362         FileMap::iterator fi = g_filemap.find(name);
 363         return fi == g_filemap.end() ? 0 : fi->second;
 364 }
 365
 366 /////////////////////////////////////////////////////////////////////////////
 367 // Context classes
 368
 369 class Database : public Directory, public File
 370 {
 371 public:
 372         Barry::Mode::Desktop &m_desk;
 373         std::string m_name;
 374         const Barry::DatabaseItem *m_pdb;
 375
 376 public:
 377         Database(Barry::Mode::Desktop &desktop,
 378                 const std::string &pin, const Barry::DatabaseItem *pdb)
 379                 : m_desk(desktop)
 380                 , m_pdb(pdb)
 381         {
 382                 m_name = string("/") + pin + "/" + m_pdb->Name;
 383
 384                 // add to directory list
 385                 g_dirmap[ m_name ] = this;
 386         }
 387
 388         ~Database()
 389         {
 390                 // remove any entries that point to us
 391                 FileMap::iterator b = g_filemap.begin(), e = g_filemap.end();
 392                 for( ; b != e; ++b ) {
 393                         if( b->second == this ) {
 394                                 g_filemap.erase(b);
 395                         }
 396                 }
 397
 398                 // erase ourselves from the directory list
 399                 g_dirmap.erase( m_name );
 400         }
 401
 402         void AddFile(const std::string &recordId)
 403         {
 404                 // FIXME - this is a hack to redirect all record files
 405                 // to this database class... next step is to possibly
 406                 // split out records into field files if we have a
 407                 // parser, or just dump the hex if we don't
 408                 string name = m_name + "/" + recordId;
 409                 g_filemap[ name ] = this;
 410         }
 411
 412         virtual int ReadDir(void *buf, fuse_fill_dir_t filler)
 413         {
 414                 filler(buf, ".", NULL, 0);
 415                 filler(buf, "..", NULL, 0);
 416
 417                 // list all records in database, by recordId
 418                 Barry::RecordStateTable rst;
 419                 m_desk.GetRecordStateTable(m_pdb->Number, rst);
 420
 421                 Barry::RecordStateTable::StateMapType::iterator
 422                         b = rst.StateMap.begin(),
 423                         e = rst.StateMap.end();
 424                 for( ; b != e; ++ b ) {
 425                         ostringstream oss;
 426                         oss << hex << b->second.RecordId;
 427                         filler(buf, oss.str().c_str(), NULL, 0);
 428
 429                         AddFile(oss.str());
 430                 }
 431                 return 0;
 432         }
 433
 434         virtual void FillFileStat(const char *path, struct stat *st)
 435         {
 436                 // use the path to find the proper record
 437                 PathSplit ps(path);
 438
 439                 string constructed = string("/") + ps.Pin() + "/" + ps.DB();
 440                 if( constructed != m_name ) {
 441                         // FIXME - this is shoddy error handling
 442                         throw std::logic_error("Constructed != name");
 443                 }
 444
 445                 string data = GetRecordData(ps.Record());
 446
 447                 st->st_mode = S_IFREG | 0444;
 448                 st->st_nlink = 1;
 449                 st->st_size = data.size();
 450         }
 451
 452         virtual int ReadFile(const char *path, char *buf, size_t size, off_t offset)
 453         {
 454                 // use the path to find the proper record
 455                 PathSplit ps(path);
 456
 457                 string constructed = string("/") + ps.Pin() + "/" + ps.DB();
 458                 if( constructed != m_name ) {
 459                         // FIXME - this is shoddy error handling
 460                         throw std::logic_error("Constructed != name");
 461                 }
 462
 463                 string data = GetRecordData(ps.Record());
 464
 465                 size_t len = data.size();
 466                 if( offset < len ) {
 467                         if( (offset + size) > len )
 468                                 size = len - offset;
 469                         memcpy(buf, data.data() + offset, size);
 470                 }
 471                 else {
 472                         size = 0;
 473                 }
 474                 return size;
 475         }
 476
 477         const std::string& GetDBName() const { return m_pdb->Name; }
 478
 479         std::string GetRecordData(const std::string &recordId)
 480         {
 481                 string data;
 482
 483                 Barry::RecordStateTable rst;
 484                 m_desk.GetRecordStateTable(m_pdb->Number, rst);
 485
 486                 uint32_t recid = strtoul(recordId.c_str(), NULL, 16);
 487                 RecordStateTable::IndexType index;
 488                 if( rst.GetIndex(recid, &index) ) {
 489                         ostringstream oss;
 490                         ParserPtr parser = GetParser(m_pdb->Name, oss, false);
 491                         m_desk.GetRecord(m_pdb->Number, index, *parser);
 492                         data = oss.str();
 493                 }
 494
 495                 return data;
 496         }
 497 };
 498
 499 class DesktopCon : public Directory
 500 {
 501 public:
 502         typedef std::tr1::shared_ptr<Database>                  DatabasePtr;
 503         typedef std::list<DatabasePtr>                          DBList;
 504 public:
 505         Barry::Controller m_con;
 506         Barry::Mode::Desktop m_desk;
 507         std::string m_pin;
 508         DBList m_dblist;
 509
 510         DesktopCon(const Barry::ProbeResult &result, const std::string &pin)
 511                 : m_con(result)
 512                 , m_desk(m_con)
 513                 , m_pin(pin)
 514         {
 515                 // add to directory list
 516                 g_dirmap[ string("/") + pin ] = this;
 517         }
 518
 519         ~DesktopCon()
 520         {
 521                 // remove from directory list
 522                 g_dirmap.erase( string("/") + m_pin );
 523         }
 524
 525         virtual int ReadDir(void *buf, fuse_fill_dir_t filler)
 526         {
 527                 filler(buf, ".", NULL, 0);
 528                 filler(buf, "..", NULL, 0);
 529
 530                 // list all databases in list
 531                 DBList::const_iterator b = m_dblist.begin(), e = m_dblist.end();
 532                 for( ; b != e; ++ b ) {
 533                         filler(buf, (*b)->GetDBName().c_str(), NULL, 0);
 534                 }
 535                 return 0;
 536         }
 537
 538         void Open(const char *password = 0)
 539         {
 540                 // open our device
 541                 m_desk.Open(password);
 542
 543                 // add all databases as directories
 544                 DatabaseDatabase::DatabaseArrayType::const_iterator
 545                         dbi = m_desk.GetDBDB().Databases.begin(),
 546                         dbe = m_desk.GetDBDB().Databases.end();
 547                 for( ; dbi != dbe; ++dbi ) {
 548                         DatabasePtr db = DatabasePtr(
 549                                 new Database(m_desk, m_pin, &(*dbi)) );
 550                         m_dblist.push_back(db);
 551                 }
 552         }
 553 };
 554
 555 class Context : public Directory, public File
 556 {
 557 public:
 558         typedef std::auto_ptr<Barry::Probe>                     ProbePtr;
 559         typedef std::tr1::shared_ptr<DesktopCon>                DesktopConPtr;
 560         typedef std::string                                     PinT;
 561         typedef std::map<PinT, DesktopConPtr>                   PinMap;
 562
 563         ProbePtr m_probe;
 564         PinMap m_pinmap;
 565
 566         string m_error_log;
 567
 568         string m_limit_pin;             // only mount device with this pin
 569         string m_password;              // use this password when connecting
 570
 571 public:
 572         Context(const string &limit_pin = "", const string &password = "")
 573                 : m_limit_pin(limit_pin)
 574                 , m_password(password)
 575         {
 576                 g_dirmap["/"] = this;
 577                 g_filemap[string("/") + error_log_filename] = this;
 578
 579                 m_error_log = "Hello FUSE world.  This is Barry.  Pleased to meet you.\n";
 580         }
 581
 582         ~Context()
 583         {
 584                 g_dirmap.erase("/");
 585                 g_filemap.erase(string("/") + error_log_filename);
 586         }
 587
 588         virtual int ReadDir(void *buf, fuse_fill_dir_t filler)
 589         {
 590                 filler(buf, ".", NULL, 0);
 591                 filler(buf, "..", NULL, 0);
 592                 filler(buf, error_log_filename, NULL, 0);
 593
 594                 // list all pins in map
 595                 PinMap::const_iterator b = m_pinmap.begin(), e = m_pinmap.end();
 596                 for( ; b != e; ++ b ) {
 597                         filler(buf, b->first.c_str(), NULL, 0);
 598                 }
 599                 return 0;
 600         }
 601
 602         virtual void FillFileStat(const char *path, struct stat *st)
 603         {
 604                 st->st_mode = S_IFREG | 0444;
 605                 st->st_nlink = 1;
 606                 st->st_size = m_error_log.size();
 607         }
 608
 609         virtual int ReadFile(const char *path, char *buf, size_t size, off_t offset)
 610         {
 611                 size_t len = m_error_log.size();
 612                 if( offset < len ) {
 613                         if( (offset + size) > len )
 614                                 size = len - offset;
 615                         memcpy(buf, m_error_log.data() + offset, size);
 616                 }
 617                 else {
 618                         size = 0;
 619                 }
 620                 return size;
 621         }
 622
 623         void Log(const std::string &msg)
 624         {
 625                 m_error_log += msg;
 626                 m_error_log += "\n";
 627         }
 628
 629         const std::string& GetLog() const { return m_error_log; }
 630
 631         void ProbeAll()
 632         {
 633                 // probe the USB bus for Blackberry devices
 634                 m_probe.reset( new Probe );
 635
 636                 // connect to all PINs found, and add them to our map
 637                 for( int i = 0; i < m_probe->GetCount(); i++ ) {
 638                         string curpin = m_probe->Get(i).m_pin.str();
 639
 640                         // don't add a blank or pre-existing pin
 641                         if( !curpin.size() || m_pinmap.find(curpin) != m_pinmap.end() ) {
 642                                 continue;
 643                         }
 644
 645                         // don't add non-PIN device if pin specified
 646                         if( m_limit_pin.size() && curpin != m_limit_pin ) {
 647                                 continue;
 648                         }
 649
 650                         DesktopConPtr dev = DesktopConPtr (
 651                                 new DesktopCon(m_probe->Get(i), curpin) );
 652                         dev->Open(m_password.c_str());
 653                         m_pinmap[ curpin ] = dev;
 654                 }
 655         }
 656
 657         DesktopCon* FindPin(PinT pin)
 658         {
 659                 PinMap::iterator pi = m_pinmap.find(pin);
 660                 return pi == m_pinmap.end() ? 0 : pi->second.get();
 661         }
 662 };
 663
 664
 665 /////////////////////////////////////////////////////////////////////////////
 666 // FUSE API hooks
 667
 668 static void* bfuse_init()
 669 {
 670         // Initialize the barry library.  Must be called before
 671         // anything else.
 672         Barry::Init(false);
 673
 674         Context *ctx = 0;
 675
 676         try {
 677                 ctx = new Context(cmdline_pin, cmdline_password);
 678                 ctx->ProbeAll();
 679         }
 680         catch( std::exception &e ) {
 681                 if( ctx ) {
 682                         ctx->Log(e.what());
 683                 }
 684         }
 685
 686         return ctx;
 687 }
 688
 689 static void bfuse_destroy(void *data)
 690 {
 691         if( data ) {
 692                 Context *ctx = (Context*) data;
 693                 delete ctx;
 694         }
 695 }
 696
 697 static int bfuse_getattr(const char *path, struct stat *st)
 698 {
 699         memset(st, 0, sizeof(*st));
 700
 701         if( Directory *dir = FindDir(path) ) {
 702                 dir->FillDirStat(st);
 703                 return 0;
 704         }
 705         else if( File *file = FindFile(path) ) {
 706                 file->FillFileStat(path, st);
 707                 return 0;
 708         }
 709         else
 710                 return -ENOENT;
 711 }
 712
 713 static int bfuse_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
 714                          off_t /*offset*/, struct fuse_file_info * /*fi*/)
 715 {
 716         Directory *dir = FindDir(path);
 717         if( !dir )
 718                 return -ENOENT;
 719         return dir->ReadDir(buf, filler);
 720 }
 721
 722 static int bfuse_open(const char *path, struct fuse_file_info *fi)
 723 {
 724         File *file = FindFile(path);
 725         if( !file )
 726                 return -ENOENT;
 727
 728         if( !file->AccessOk(fi->flags) )
 729                 return -EACCES;
 730
 731         return 0;
 732 }
 733
 734 static int bfuse_read(const char *path, char *buf, size_t size, off_t offset,
 735                       struct fuse_file_info *fi)
 736 {
 737         File *file = FindFile(path);
 738         if( !file )
 739                 return -ENOENT;
 740
 741         return file->ReadFile(path, buf, size, offset);
 742 }
 743
 744 // static struct here automatically zeros data
 745 static struct fuse_operations bfuse_oper;
 746
 747
 748 /////////////////////////////////////////////////////////////////////////////
 749 // main
 750
 751 int main(int argc, char *argv[])
 752 {
 753         INIT_I18N(PACKAGE);
 754
 755         cout.sync_with_stdio(true);     // leave this on, since libusb uses
 756                                         // stdio for debug messages
 757
 758         Blurb();
 759
 760         // initialize the operation hooks
 761         bfuse_oper.init         = bfuse_init;
 762         bfuse_oper.destroy      = bfuse_destroy;
 763         bfuse_oper.getattr      = bfuse_getattr;
 764         bfuse_oper.readdir      = bfuse_readdir;
 765         bfuse_oper.open         = bfuse_open;
 766         bfuse_oper.read         = bfuse_read;
 767
 768         // process command line options before FUSE does
 769         // FUSE does its own command line processing, and
 770         // doesn't seem to have a way to plug into it,
 771         // so do our own first
 772         int fuse_argc = 0;
 773         char **fuse_argv = new char*[argc];
 774
 775         for( int i = 0; i < argc; i++ ) {
 776                 if( argv[i][0] == '-' ) {
 777
 778                         switch( argv[i][1] )
 779                         {
 780 //                      case 'd':       // mount dbname
 781 //                              dbNames.push_back(string(optarg));
 782 //                              break;
 783
 784 //                      case 'n':       // use null parser
 785 //                              null_parser = true;
 786 //                              break;
 787
 788                         case 'p':       // Blackberry PIN
 789                                 if( i+1 < argc ) {
 790                                         cmdline_pin = argv[++i];
 791                                 }
 792                                 continue;
 793
 794                         case 'P':       // Device password
 795                                 if( i+1 < argc ) {
 796                                         cmdline_password = argv[++i];
 797                                 }
 798                                 continue;
 799
 800                         case 'h':       // help
 801                                 Usage();
 802                                 break;
 803                         }
 804                 }
 805
 806                 // if we get here, add this option to FUSE's
 807                 fuse_argv[fuse_argc] = argv[i];
 808                 fuse_argc++;
 809         }
 810
 811         int ret = fuse_main(fuse_argc, fuse_argv, &bfuse_oper);
 812         delete [] fuse_argv;
 813         return ret;
 814 }
 815