svtools/source/passwordcontainer/passwordcontainer.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: passwordcontainer.cxx,v $
  10  * $Revision: 1.17 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33
  34 #include "passwordcontainer.hxx"
  35
  36 #include <svtools/pathoptions.hxx>
  37 #include "cppuhelper/factory.hxx"
  38 #include <com/sun/star/registry/XSimpleRegistry.hpp>
  39 #include <com/sun/star/beans/PropertyValue.hpp>
  40 #include <com/sun/star/task/MasterPasswordRequest.hpp>
  41 #include <com/sun/star/task/NoMasterException.hpp>
  42
  43 #include <rtl/cipher.h>
  44 #include <rtl/digest.h>
  45 #include <rtl/byteseq.hxx>
  46
  47 #ifndef _TOOLS_INETSTRM_HXX
  48 // @@@ #include <inetstrm.hxx>
  49 #endif
  50
  51 using namespace std;
  52 using namespace osl;
  53 using namespace utl;
  54 using namespace com::sun::star;
  55 using namespace com::sun::star::uno;
  56 using namespace com::sun::star::registry;
  57 using namespace com::sun::star::lang;
  58 using namespace com::sun::star::task;
  59 using namespace com::sun::star::ucb;
  60
  61 //-------------------------------------------------------------------------
  62 //-------------------------------------------------------------------------
  63
  64 static ::rtl::OUString createIndex( vector< ::rtl::OUString > lines )
  65 {
  66     ::rtl::OString aResult;
  67     const sal_Char* pLine;
  68
  69     for( unsigned int i = 0; i < lines.size(); i++ )
  70     {
  71         if( i )
  72             aResult += ::rtl::OString( "__" );
  73         ::rtl::OString line = ::rtl::OUStringToOString( lines[i], RTL_TEXTENCODING_UTF8 );
  74         pLine = line.getStr();
  75
  76         while( *pLine )
  77         {
  78             if( ( *pLine >= 'A' && *pLine <= 'Z' )
  79                 || ( *pLine >= 'a' && *pLine <= 'z' )
  80                 || ( *pLine >= '0' && *pLine <= '9' ) )
  81             {
  82                 aResult += ::rtl::OString::valueOf( *pLine );
  83             }
  84             else
  85             {
  86                 aResult += ::rtl::OString("_");
  87                 aResult += ::rtl::OString::valueOf( (sal_Int32) *pLine, 16 );
  88             }
  89
  90             pLine++;
  91         }
  92     }
  93
  94     return ::rtl::OUString::createFromAscii( aResult.getStr() );
  95 }
  96
  97 //-------------------------------------------------------------------------
  98
  99 static vector< ::rtl::OUString > getInfoFromInd( ::rtl::OUString aInd )
 100 {
 101     vector< ::rtl::OUString > aResult;
 102     sal_Bool aStart = sal_True;
 103
 104     ::rtl::OString line = ::rtl::OUStringToOString( aInd, RTL_TEXTENCODING_ASCII_US );
 105     const sal_Char* pLine = line.getStr();
 106     do
 107     {
 108         ::rtl::OUString newItem;
 109         if( !aStart )
 110             pLine += 2;
 111         else
 112             aStart = sal_False;
 113
 114         while( *pLine && !( pLine[0] == '_' && pLine[1] == '_' ))
 115             if( *pLine != '_' )
 116             {
 117                 newItem += ::rtl::OUString::valueOf( (sal_Unicode) *pLine );
 118                 pLine++;
 119             }
 120             else
 121             {
 122                 ::rtl::OUString aNum;
 123                 for( int i = 1; i < 3; i++ )
 124                 {
 125                     if( !pLine[i]
 126                       ||  ( ( pLine[i] < '0' || pLine[i] > '9' )
 127                          && ( pLine[i] < 'a' || pLine[i] > 'f' )
 128                          && ( pLine[i] < 'A' || pLine[i] > 'F' ) ) )
 129                     {
 130                         OSL_ENSURE( sal_False, "Wrong index syntax!\n" );
 131                         return aResult;
 132                     }
 133
 134                     aNum += ::rtl::OUString::valueOf( (sal_Unicode) pLine[i] );
 135                 }
 136
 137                 newItem += ::rtl::OUString::valueOf( (sal_Unicode) aNum.toInt32( 16 ) );
 138                 pLine += 3;
 139             }
 140
 141         aResult.push_back( newItem );
 142     } while( pLine[0] == '_' && pLine[1] == '_' );
 143
 144     if( *pLine )
 145         OSL_ENSURE( sal_False, "Wrong index syntax!\n" );
 146
 147     return aResult;
 148 }
 149
 150 //-------------------------------------------------------------------------
 151
 152 static sal_Bool shorterUrl( ::rtl::OUString& aURL )
 153 {
 154     sal_Int32 aInd = aURL.lastIndexOf( sal_Unicode( '/' ) );
 155
 156     if( aInd > 0  )
 157     {
 158         sal_Int32 aPrevInd = aURL.lastIndexOf( sal_Unicode( '/' ), aInd );
 159         if ( aURL.indexOf( ::rtl::OUString::createFromAscii( "://" ) )
 160                 != aPrevInd - 2 ||
 161              aInd != aURL.getLength() - 1 )
 162         {
 163             aURL = aURL.copy( 0, aInd );
 164             return sal_True;
 165         }
 166     }
 167
 168     return sal_False;
 169 }
 170
 171 //-------------------------------------------------------------------------
 172
 173 static ::rtl::OUString getAsciiLine( const ::rtl::ByteSequence& buf )
 174 {
 175     ::rtl::OUString aResult;
 176
 177     ::rtl::ByteSequence outbuf( buf.getLength()*2+1 );
 178
 179     for( int ind = 0; ind < buf.getLength(); ind++ )
 180     {
 181         outbuf[ind*2]   = ( ((sal_uInt8)buf[ind]) >> 4 ) + 'a';
 182         outbuf[ind*2+1] = ( ((sal_uInt8)buf[ind]) & 0x0f ) + 'a';
 183     }
 184     outbuf[buf.getLength()*2] = '\0';
 185
 186     aResult = ::rtl::OUString::createFromAscii( (sal_Char*)outbuf.getArray() );
 187
 188     return aResult;
 189 }
 190
 191 //-------------------------------------------------------------------------
 192
 193 static ::rtl::ByteSequence getBufFromAsciiLine( ::rtl::OUString line )
 194 {
 195     OSL_ENSURE( line.getLength() % 2 == 0, "Wrong syntax!\n" );
 196     ::rtl::OString tmpLine = ::rtl::OUStringToOString( line, RTL_TEXTENCODING_ASCII_US );
 197     ::rtl::ByteSequence aResult(line.getLength()/2);
 198
 199     for( int ind = 0; ind < tmpLine.getLength()/2; ind++ )
 200     {
 201         aResult[ind] = ( (sal_uInt8)( tmpLine.getStr()[ind*2] - 'a' ) << 4 ) | (sal_uInt8)( tmpLine.getStr()[ind*2+1] - 'a' );
 202     }
 203
 204     return aResult;
 205 }
 206
 207 //-------------------------------------------------------------------------
 208
 209 static Sequence< ::rtl::OUString > copyVectorToSequence( const vector< ::rtl::OUString >& original )
 210 {
 211     Sequence< ::rtl::OUString > newOne ( original.size() );
 212     for( unsigned int i = 0; i < original.size() ; i++ )
 213         newOne[i] = original[i];
 214
 215     return newOne;
 216 }
 217
 218 static vector< ::rtl::OUString > copySequenceToVector( const Sequence< ::rtl::OUString >& original )
 219 {
 220     vector< ::rtl::OUString > newOne ( original.getLength() );
 221     for( int i = 0; i < original.getLength() ; i++ )
 222         newOne[i] = original[i];
 223
 224     return newOne;
 225 }
 226
 227 //-------------------------------------------------------------------------
 228 //-------------------------------------------------------------------------
 229
 230 PassMap StorageItem::getInfo()
 231 {
 232     PassMap aResult;
 233
 234     Sequence< ::rtl::OUString > aNodeNames     = ConfigItem::GetNodeNames( ::rtl::OUString::createFromAscii("Store") );
 235     sal_Int32 aNodeCount = aNodeNames.getLength();
 236     Sequence< ::rtl::OUString > aPropNames( aNodeCount );
 237     sal_Int32 aNodeInd;
 238
 239     for( aNodeInd = 0; aNodeInd < aNodeCount; ++aNodeInd )
 240     {
 241         aPropNames[aNodeInd]  = ::rtl::OUString::createFromAscii( "Store/Passwordstorage['" );
 242         aPropNames[aNodeInd] += aNodeNames[aNodeInd];
 243         aPropNames[aNodeInd] += ::rtl::OUString::createFromAscii( "']/Password" );
 244     }
 245
 246     Sequence< Any > aPropertyValues = ConfigItem::GetProperties( aPropNames );
 247
 248     if( aPropertyValues.getLength() != aNodeNames.getLength() )
 249     {
 250         OSL_ENSURE( aPropertyValues.getLength() == aNodeNames.getLength(), "Problems during reading\n" );
 251         return aResult;
 252     }
 253
 254     for( aNodeInd = 0; aNodeInd < aNodeCount; ++aNodeInd )
 255     {
 256         vector< ::rtl::OUString > aUrlUsr = getInfoFromInd( aNodeNames[aNodeInd] );
 257
 258         if( aUrlUsr.size() == 2 )
 259         {
 260             ::rtl::OUString aUrl  = aUrlUsr[0];
 261             ::rtl::OUString aName = aUrlUsr[1];
 262
 263             ::rtl::OUString aEPasswd;
 264             aPropertyValues[aNodeInd] >>= aEPasswd;
 265
 266             PassMap::iterator aIter = aResult.find( aUrl );
 267             if( aIter != aResult.end() )
 268                 aIter->second.push_back( NamePassRecord( aName, aEPasswd ) );
 269             else
 270             {
 271                 NamePassRecord aNewRecord( aName, aEPasswd );
 272                 list< NamePassRecord > listToAdd( 1, aNewRecord );
 273
 274                 aResult.insert( PairUrlRecord( aUrl, listToAdd ) );
 275             }
 276         }
 277         else
 278             OSL_ENSURE( sal_False, "Wrong index sintax!\n" );
 279     }
 280
 281     return aResult;
 282 }
 283
 284 //-------------------------------------------------------------------------
 285
 286 void StorageItem::setUseStorage( sal_Bool bUse )
 287 {
 288     Sequence< ::rtl::OUString > sendNames(1);
 289     Sequence< uno::Any > sendVals(1);
 290
 291     sendNames[0] = ::rtl::OUString::createFromAscii( "UseStorage" );
 292
 293     sendVals[0] <<= bUse;
 294
 295     ConfigItem::SetModified();
 296     ConfigItem::PutProperties( sendNames, sendVals );
 297 }
 298
 299 //-------------------------------------------------------------------------
 300
 301 sal_Bool StorageItem::useStorage()
 302 {
 303     Sequence< ::rtl::OUString > aNodeNames( 1 );
 304     aNodeNames[0] = ::rtl::OUString::createFromAscii( "UseStorage" );
 305
 306     Sequence< Any > aPropertyValues = ConfigItem::GetProperties( aNodeNames );
 307
 308     if( aPropertyValues.getLength() != aNodeNames.getLength() )
 309     {
 310         OSL_ENSURE( aPropertyValues.getLength() == aNodeNames.getLength(), "Problems during reading\n" );
 311         return sal_False;
 312     }
 313
 314     sal_Bool aResult = false;
 315     aPropertyValues[0] >>= aResult;
 316
 317     return aResult;
 318 }
 319
 320 //-------------------------------------------------------------------------
 321
 322 sal_Bool StorageItem::getEncodedMP( ::rtl::OUString& aResult )
 323 {
 324     if( hasEncoded )
 325     {
 326         aResult = mEncoded;
 327         return sal_True;
 328     }
 329
 330     Sequence< ::rtl::OUString > aNodeNames( 2 );
 331     aNodeNames[0] = ::rtl::OUString::createFromAscii( "HasMaster" );
 332     aNodeNames[1] = ::rtl::OUString::createFromAscii( "Master" );
 333
 334     Sequence< Any > aPropertyValues = ConfigItem::GetProperties( aNodeNames );
 335
 336     if( aPropertyValues.getLength() != aNodeNames.getLength() )
 337     {
 338         OSL_ENSURE( aPropertyValues.getLength() == aNodeNames.getLength(), "Problems during reading\n" );
 339         return sal_False;
 340     }
 341
 342     aPropertyValues[0] >>= hasEncoded;
 343     aPropertyValues[1] >>= mEncoded;
 344
 345     aResult = mEncoded;
 346
 347     return hasEncoded;
 348 }
 349
 350 //-------------------------------------------------------------------------
 351
 352 void StorageItem::setEncodedMP( const ::rtl::OUString& aEncoded, sal_Bool bAcceptEmpty )
 353 {
 354     Sequence< ::rtl::OUString > sendNames(2);
 355     Sequence< uno::Any > sendVals(2);
 356
 357     sendNames[0] = ::rtl::OUString::createFromAscii( "HasMaster" );
 358     sendNames[1] = ::rtl::OUString::createFromAscii( "Master" );
 359
 360     sal_Bool bHasMaster = ( aEncoded.getLength() > 0 || bAcceptEmpty );
 361     sendVals[0] <<= bHasMaster;
 362     sendVals[1] <<= aEncoded;
 363
 364     ConfigItem::SetModified();
 365     ConfigItem::PutProperties( sendNames, sendVals );
 366
 367     hasEncoded = bHasMaster;
 368     mEncoded = aEncoded;
 369 }
 370
 371 //-------------------------------------------------------------------------
 372
 373 void StorageItem::remove( const ::rtl::OUString& aURL, const ::rtl::OUString& aName )
 374 {
 375     vector < ::rtl::OUString > forIndex;
 376     forIndex.push_back( aURL );
 377     forIndex.push_back( aName );
 378
 379     Sequence< ::rtl::OUString > sendSeq(1);
 380
 381     sendSeq[0] = createIndex( forIndex );
 382     // sendSeq[0]  = ::rtl::OUString::createFromAscii( "Store/Passwordstorage['" );
 383     // sendSeq[0] += createIndex( forIndex );
 384     // sendSeq[0] += ::rtl::OUString::createFromAscii( "']" );
 385
 386     ConfigItem::ClearNodeElements( ::rtl::OUString::createFromAscii( "Store" ), sendSeq );
 387 }
 388
 389 //-------------------------------------------------------------------------
 390
 391 void StorageItem::clear()
 392 {
 393     Sequence< ::rtl::OUString > sendSeq(1);
 394
 395     ConfigItem::ClearNodeSet( ::rtl::OUString::createFromAscii( "Store" ) );
 396 }
 397
 398 //-------------------------------------------------------------------------
 399
 400 void StorageItem::update( const ::rtl::OUString& aURL, const NamePassRecord& aRecord )
 401 {
 402     if ( !aRecord.HasPasswords( PERSISTENT_RECORD ) )
 403     {
 404         OSL_ASSERT( "Unexpected storing of a record!" );
 405         return;
 406     }
 407
 408     vector < ::rtl::OUString > forIndex;
 409     forIndex.push_back( aURL );
 410     forIndex.push_back( aRecord.GetUserName() );
 411
 412     Sequence< beans::PropertyValue > sendSeq(1);
 413
 414     sendSeq[0].Name  = ::rtl::OUString::createFromAscii( "Store/Passwordstorage['" );
 415     sendSeq[0].Name += createIndex( forIndex );
 416     sendSeq[0].Name += ::rtl::OUString::createFromAscii( "']/Password" );
 417
 418     sendSeq[0].Value <<= aRecord.GetPersPasswords();
 419
 420     ConfigItem::SetModified();
 421     ConfigItem::SetSetProperties( ::rtl::OUString::createFromAscii( "Store" ), sendSeq );
 422 }
 423
 424 //-------------------------------------------------------------------------
 425
 426 void StorageItem::Notify( const Sequence< ::rtl::OUString >& )
 427 {
 428     // this feature still should not be used
 429     if( mainCont )
 430         mainCont->Notify();
 431 }
 432
 433 //-------------------------------------------------------------------------
 434
 435 void StorageItem::Commit()
 436 {
 437     // Do nothing, we stored everything we want already
 438 }
 439
 440 //-------------------------------------------------------------------------
 441 //-------------------------------------------------------------------------
 442
 443 PasswordContainer::PasswordContainer( const Reference<XMultiServiceFactory>& xServiceFactory ):
 444     m_pStorageFile( NULL )
 445 {
 446     // m_pStorageFile->Notify() can be called
 447     ::osl::MutexGuard aGuard( mMutex );
 448
 449     mComponent = Reference< XComponent >( xServiceFactory, UNO_QUERY );
 450     mComponent->addEventListener( this );
 451
 452     m_pStorageFile = new StorageItem( this, ::rtl::OUString::createFromAscii( "Office.Common/Passwords" ) );
 453     if( m_pStorageFile )
 454         if( m_pStorageFile->useStorage() )
 455             m_aContainer = m_pStorageFile->getInfo();
 456 }
 457
 458 //-------------------------------------------------------------------------
 459
 460 PasswordContainer::~PasswordContainer()
 461 {
 462     ::osl::MutexGuard aGuard( mMutex );
 463
 464     if( m_pStorageFile )
 465     {
 466         delete m_pStorageFile;
 467         m_pStorageFile = NULL;
 468     }
 469
 470     if( mComponent.is() )
 471     {
 472         mComponent->removeEventListener(this);
 473         mComponent = Reference< XComponent >();
 474     }
 475 }
 476
 477 //-------------------------------------------------------------------------
 478
 479 void SAL_CALL PasswordContainer::disposing( const EventObject& ) throw(RuntimeException)
 480 {
 481     ::osl::MutexGuard aGuard( mMutex );
 482
 483     if( m_pStorageFile )
 484     {
 485         delete m_pStorageFile;
 486         m_pStorageFile = NULL;
 487     }
 488
 489     if( mComponent.is() )
 490     {
 491         //mComponent->removeEventListener(this);
 492         mComponent = Reference< XComponent >();
 493     }
 494 }
 495
 496 //-------------------------------------------------------------------------
 497
 498 vector< ::rtl::OUString > PasswordContainer::DecodePasswords( const ::rtl::OUString& aLine, const ::rtl::OUString& aMasterPasswd ) throw(RuntimeException)
 499 {
 500     if( aMasterPasswd.getLength() )
 501     {
 502         rtlCipher aDecoder = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeStream );
 503         OSL_ENSURE( aDecoder, "Can't create decoder\n" );
 504
 505         if( aDecoder )
 506         {
 507             OSL_ENSURE( aMasterPasswd.getLength() == RTL_DIGEST_LENGTH_MD5 * 2, "Wrong master password format!\n" );
 508
 509             unsigned char code[RTL_DIGEST_LENGTH_MD5];
 510             for( int ind = 0; ind < RTL_DIGEST_LENGTH_MD5; ind++ )
 511                 code[ ind ] = (char)(aMasterPasswd.copy( ind*2, 2 ).toInt32(16));
 512
 513             rtlCipherError result = rtl_cipher_init (
 514                     aDecoder, rtl_Cipher_DirectionDecode,
 515                     code, RTL_DIGEST_LENGTH_MD5, NULL, 0 );
 516
 517             if( result == rtl_Cipher_E_None )
 518             {
 519                 ::rtl::ByteSequence aSeq = getBufFromAsciiLine( aLine );
 520
 521                 ::rtl::ByteSequence resSeq( aSeq.getLength() );
 522
 523                 result = rtl_cipher_decode ( aDecoder, (sal_uInt8*)aSeq.getArray(), aSeq.getLength(),
 524                                                         (sal_uInt8*)resSeq.getArray(), resSeq.getLength() );
 525
 526                 ::rtl::OUString aPasswd( ( sal_Char* )resSeq.getArray(), resSeq.getLength(), RTL_TEXTENCODING_UTF8 );
 527
 528                 rtl_cipher_destroy (aDecoder);
 529
 530                 return getInfoFromInd( aPasswd );
 531             }
 532
 533             rtl_cipher_destroy (aDecoder);
 534         }
 535     }
 536     else
 537     {
 538         OSL_ENSURE( sal_False, "No master password provided!\n" );
 539         // throw special exception
 540     }
 541
 542     // problems with decoding
 543     OSL_ENSURE( sal_False, "Problem with decoding\n" );
 544     throw RuntimeException( ::rtl::OUString::createFromAscii( "Can't decode!" ), Reference< XInterface >() );
 545 }
 546
 547
 548 //-------------------------------------------------------------------------
 549
 550 ::rtl::OUString PasswordContainer::EncodePasswords( vector< ::rtl::OUString > lines, const ::rtl::OUString& aMasterPasswd ) throw(RuntimeException)
 551 {
 552     if( aMasterPasswd.getLength() )
 553     {
 554         ::rtl::OString aSeq = ::rtl::OUStringToOString( createIndex( lines ), RTL_TEXTENCODING_UTF8 );
 555
 556         rtlCipher aEncoder = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeStream );
 557         OSL_ENSURE( aEncoder, "Can't create encoder\n" );
 558
 559         if( aEncoder )
 560         {
 561             OSL_ENSURE( aMasterPasswd.getLength() == RTL_DIGEST_LENGTH_MD5 * 2, "Wrong master password format!\n" );
 562
 563             unsigned char code[RTL_DIGEST_LENGTH_MD5];
 564             for( int ind = 0; ind < RTL_DIGEST_LENGTH_MD5; ind++ )
 565                 code[ ind ] = (char)(aMasterPasswd.copy( ind*2, 2 ).toInt32(16));
 566
 567             rtlCipherError result = rtl_cipher_init (
 568                     aEncoder, rtl_Cipher_DirectionEncode,
 569                     code, RTL_DIGEST_LENGTH_MD5, NULL, 0 );
 570
 571             if( result == rtl_Cipher_E_None )
 572             {
 573                 ::rtl::ByteSequence resSeq(aSeq.getLength()+1);
 574
 575                 result = rtl_cipher_encode ( aEncoder, (sal_uInt8*)aSeq.getStr(), aSeq.getLength()+1,
 576                                                         (sal_uInt8*)resSeq.getArray(), resSeq.getLength() );
 577
 578 /*
 579                 //test
 580                 rtlCipherError result = rtl_cipher_init (
 581                     aEncoder, rtl_Cipher_DirectionDecode,
 582                     code, RTL_DIGEST_LENGTH_MD5, NULL, 0 );
 583
 584
 585                 if( result == rtl_Cipher_E_None )
 586                 {
 587                     ::rtl::OUString testOU = getAsciiLine( resSeq );
 588                     ::rtl::ByteSequence aSeq1 = getBufFromAsciiLine( testOU );
 589
 590                     ::rtl::ByteSequence resSeq1( aSeq1.getLength() );
 591
 592                     if( resSeq.getLength() == aSeq1.getLength() )
 593                     {
 594                         for( int ind = 0; ind < aSeq1.getLength(); ind++ )
 595                             if( resSeq[ind] != aSeq1[ind] )
 596                                 testOU = ::rtl::OUString();
 597                     }
 598
 599                     result = rtl_cipher_decode ( aEncoder, (sal_uInt8*)aSeq1.getArray(), aSeq1.getLength(),
 600                                                         (sal_uInt8*)resSeq1.getArray(), resSeq1.getLength() );
 601
 602                     ::rtl::OUString aPasswd( ( sal_Char* )resSeq1.getArray(), resSeq1.getLength(), RTL_TEXTENCODING_UTF8 );
 603                 }
 604 */
 605
 606                 rtl_cipher_destroy (aEncoder);
 607
 608                 if( result == rtl_Cipher_E_None )
 609                     return getAsciiLine( resSeq );
 610
 611             }
 612
 613             rtl_cipher_destroy (aEncoder);
 614         }
 615     }
 616     else
 617     {
 618         OSL_ENSURE( sal_False, "No master password provided!\n" );
 619         // throw special exception
 620     }
 621
 622     // problems with encoding
 623     OSL_ENSURE( sal_False, "Problem with encoding\n" );
 624     throw RuntimeException( ::rtl::OUString::createFromAscii( "Can't encode!" ), Reference< XInterface >() );
 625 }
 626
 627 //-------------------------------------------------------------------------
 628
 629 void PasswordContainer::UpdateVector( const ::rtl::OUString& aURL, list< NamePassRecord >& toUpdate, NamePassRecord& aRecord, sal_Bool writeFile ) throw(RuntimeException)
 630 {
 631     for( list< NamePassRecord >::iterator aNPIter = toUpdate.begin(); aNPIter != toUpdate.end(); aNPIter++ )
 632         if( aNPIter->GetUserName().equals( aRecord.GetUserName() ) )
 633         {
 634             if( aRecord.HasPasswords( MEMORY_RECORD ) )
 635                 aNPIter->SetMemPasswords( aRecord.GetMemPasswords() );
 636
 637             if( aRecord.HasPasswords( PERSISTENT_RECORD ) )
 638             {
 639                 aNPIter->SetPersPasswords( aRecord.GetPersPasswords() );
 640
 641                 if( writeFile )
 642                 {
 643                     // the password must be already encoded
 644                     m_pStorageFile->update( aURL, aRecord ); // change existing ( aURL, aName ) record in the configfile
 645                 }
 646             }
 647
 648             return;
 649         }
 650
 651
 652     if( aRecord.HasPasswords( PERSISTENT_RECORD ) && writeFile )
 653     {
 654         // the password must be already encoded
 655         m_pStorageFile->update( aURL, aRecord ); // add new aName to the existing url
 656     }
 657
 658     toUpdate.insert( toUpdate.begin(), aRecord );
 659 }
 660
 661 //-------------------------------------------------------------------------
 662
 663 UserRecord PasswordContainer::CopyToUserRecord( const NamePassRecord& aRecord, sal_Bool& io_bTryToDecode, const Reference< XInteractionHandler >& aHandler )
 664 {
 665     ::std::vector< ::rtl::OUString > aPasswords;
 666     if( aRecord.HasPasswords( MEMORY_RECORD ) )
 667         aPasswords = aRecord.GetMemPasswords();
 668
 669     if( io_bTryToDecode && aRecord.HasPasswords( PERSISTENT_RECORD ) )
 670     {
 671         try
 672         {
 673             ::std::vector< ::rtl::OUString > aDecodedPasswords = DecodePasswords( aRecord.GetPersPasswords(), GetMasterPassword( aHandler ) );
 674             aPasswords.insert( aPasswords.end(), aDecodedPasswords.begin(), aDecodedPasswords.end() );
 675         }
 676         catch( NoMasterException& )
 677         {
 678             // if master password could not be detected the entry will be just ignored
 679             io_bTryToDecode = sal_False;
 680         }
 681     }
 682
 683     return UserRecord( aRecord.GetUserName(), copyVectorToSequence( aPasswords ) );
 684 }
 685
 686 //-------------------------------------------------------------------------
 687
 688 Sequence< UserRecord > PasswordContainer::CopyToUserRecordSequence( const list< NamePassRecord >& original, const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
 689 {
 690     Sequence< UserRecord >     aResult( original.size() );
 691     sal_uInt32 nInd = 0;
 692     sal_Bool bTryToDecode = sal_True;
 693
 694     for( list< NamePassRecord >::const_iterator aNPIter = original.begin();
 695          aNPIter != original.end();
 696          aNPIter++, nInd++ )
 697     {
 698         aResult[nInd] = CopyToUserRecord( *aNPIter, bTryToDecode, aHandler );
 699     }
 700
 701     return aResult;
 702 }
 703
 704 //-------------------------------------------------------------------------
 705
 706 void SAL_CALL PasswordContainer::add( const ::rtl::OUString& Url, const ::rtl::OUString& UserName, const Sequence< ::rtl::OUString >& Passwords, const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
 707 {
 708     ::osl::MutexGuard aGuard( mMutex );
 709
 710     PrivateAdd( Url, UserName, Passwords, MEMORY_RECORD, aHandler );
 711 }
 712
 713 //-------------------------------------------------------------------------
 714
 715 void SAL_CALL PasswordContainer::addPersistent( const ::rtl::OUString& Url, const ::rtl::OUString& UserName, const Sequence< ::rtl::OUString >& Passwords, const Reference< XInteractionHandler >& aHandler  ) throw(RuntimeException)
 716 {
 717     ::osl::MutexGuard aGuard( mMutex );
 718
 719     PrivateAdd( Url, UserName, Passwords, PERSISTENT_RECORD, aHandler );
 720 }
 721
 722 //-------------------------------------------------------------------------
 723
 724 void PasswordContainer::PrivateAdd( const ::rtl::OUString& Url, const ::rtl::OUString& UserName, const Sequence< ::rtl::OUString >& Passwords, char Mode, const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
 725 {
 726     NamePassRecord aRecord( UserName );
 727     ::std::vector< ::rtl::OUString > aStorePass = copySequenceToVector( Passwords );
 728
 729     if( Mode == PERSISTENT_RECORD )
 730         aRecord.SetPersPasswords( EncodePasswords( aStorePass, GetMasterPassword( aHandler ) ) );
 731     else if( Mode == MEMORY_RECORD )
 732         aRecord.SetMemPasswords( aStorePass );
 733     else
 734     {
 735         OSL_ASSERT( "Unexpected persistence status!" );
 736         return;
 737     }
 738
 739     if( !m_aContainer.empty() )
 740     {
 741         PassMap::iterator aIter = m_aContainer.find( Url );
 742
 743         if( aIter != m_aContainer.end() )
 744         {
 745             UpdateVector( aIter->first, aIter->second, aRecord, sal_True );
 746             return;
 747         }
 748     }
 749
 750     list< NamePassRecord > listToAdd( 1, aRecord );
 751     m_aContainer.insert( PairUrlRecord( Url, listToAdd ) );
 752
 753     if( Mode == PERSISTENT_RECORD && m_pStorageFile && m_pStorageFile->useStorage() )
 754         m_pStorageFile->update( Url, aRecord );
 755
 756 }
 757
 758 //-------------------------------------------------------------------------
 759
 760
 761 UrlRecord SAL_CALL PasswordContainer::find( const ::rtl::OUString& aURL, const Reference< XInteractionHandler >& aHandler  ) throw(RuntimeException)
 762 {
 763     return find( aURL, rtl::OUString(), false, aHandler );
 764 }
 765
 766 //-------------------------------------------------------------------------
 767
 768 UrlRecord SAL_CALL PasswordContainer::findForName( const ::rtl::OUString& aURL, const ::rtl::OUString& aName, const Reference< XInteractionHandler >& aHandler  ) throw(RuntimeException)
 769 {
 770     return find( aURL, aName, true, aHandler );
 771 }
 772
 773 //-------------------------------------------------------------------------
 774
 775 Sequence< UserRecord > PasswordContainer::FindUsr( const list< NamePassRecord >& userlist, const ::rtl::OUString& aName, const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
 776 {
 777     sal_uInt32 nInd = 0;
 778     for( list< NamePassRecord >::const_iterator aNPIter = userlist.begin();
 779          aNPIter != userlist.end();
 780          aNPIter++, nInd++ )
 781     {
 782         if( aNPIter->GetUserName().equals( aName ) )
 783         {
 784             Sequence< UserRecord > aResult(1);
 785             sal_Bool bTryToDecode = sal_True;
 786             aResult[0] = CopyToUserRecord( *aNPIter, bTryToDecode, aHandler );
 787
 788             return aResult;
 789         }
 790     }
 791
 792     return Sequence< UserRecord >();
 793 }
 794
 795 //-------------------------------------------------------------------------
 796
 797 bool PasswordContainer::createUrlRecord(
 798     const PassMap::iterator & rIter,
 799     bool bName,
 800     const ::rtl::OUString & aName,
 801     const Reference< XInteractionHandler >& aHandler,
 802     UrlRecord & rRec )
 803         throw( RuntimeException )
 804 {
 805     if ( bName )
 806     {
 807         Sequence< UserRecord > aUsrRec
 808             = FindUsr( rIter->second, aName, aHandler );
 809         if( aUsrRec.getLength() )
 810         {
 811             rRec = UrlRecord( rIter->first, aUsrRec );
 812             return true;
 813         }
 814     }
 815     else
 816     {
 817         rRec = UrlRecord(
 818             rIter->first,
 819             CopyToUserRecordSequence( rIter->second, aHandler ) );
 820         return true;
 821     }
 822     return false;
 823 }
 824
 825 //-------------------------------------------------------------------------
 826
 827 UrlRecord PasswordContainer::find(
 828     const ::rtl::OUString& aURL,
 829     const ::rtl::OUString& aName,
 830     bool bName, // only needed to support empty user names
 831     const Reference< XInteractionHandler >& aHandler  ) throw(RuntimeException)
 832 {
 833     ::osl::MutexGuard aGuard( mMutex );
 834
 835     if( !m_aContainer.empty() && aURL.getLength() )
 836     {
 837         ::rtl::OUString aUrl( aURL );
 838
 839         // each iteration remove last '/...' section from the aUrl
 840         // while it's possible, up to the most left '://'
 841         do
 842         {
 843             // first look for <url>/somename and then look for <url>/somename/...
 844             PassMap::iterator aIter = m_aContainer.find( aUrl );
 845             if( aIter != m_aContainer.end() )
 846             {
 847                 UrlRecord aRec;
 848                 if ( createUrlRecord( aIter, bName, aName, aHandler, aRec ) )
 849                   return aRec;
 850             }
 851             else
 852             {
 853                 ::rtl::OUString tmpUrl( aUrl );
 854                 if ( tmpUrl.getStr()[tmpUrl.getLength() - 1] != (sal_Unicode)'/' )
 855                     tmpUrl += ::rtl::OUString::createFromAscii( "/" );
 856
 857                 aIter = m_aContainer.lower_bound( tmpUrl );
 858                 if( aIter != m_aContainer.end() && aIter->first.match( tmpUrl ) )
 859                 {
 860                     UrlRecord aRec;
 861                     if ( createUrlRecord( aIter, bName, aName, aHandler, aRec ) )
 862                       return aRec;
 863                 }
 864             }
 865         }
 866         while( shorterUrl( aUrl ) && aUrl.getLength() );
 867     }
 868
 869     return UrlRecord();
 870 }
 871
 872 //-------------------------------------------------------------------------
 873 ::rtl::OUString PasswordContainer::GetDefaultMasterPassword()
 874 {
 875     ::rtl::OUString aResult;
 876     for ( sal_Int32 nInd = 0; nInd < RTL_DIGEST_LENGTH_MD5; nInd++ )
 877         aResult += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "aa" ) );
 878
 879     return aResult;
 880 }
 881
 882 //-------------------------------------------------------------------------
 883 ::rtl::OUString PasswordContainer::RequestPasswordFromUser( PasswordRequestMode aRMode, const uno::Reference< task::XInteractionHandler >& xHandler )
 884 {
 885     // empty string means that the call was cancelled or just failed
 886     ::rtl::OUString aResult;
 887
 888     if ( xHandler.is() )
 889     {
 890         ::rtl::Reference< MasterPasswordRequest_Impl > xRequest = new MasterPasswordRequest_Impl( aRMode );
 891
 892         xHandler->handle( xRequest.get() );
 893
 894         ::rtl::Reference< ucbhelper::InteractionContinuation > xSelection = xRequest->getSelection();
 895
 896         if ( xSelection.is() )
 897         {
 898             Reference< XInteractionAbort > xAbort( xSelection.get(), UNO_QUERY );
 899             if ( !xAbort.is() )
 900             {
 901                 const ::rtl::Reference< ucbhelper::InteractionSupplyAuthentication > & xSupp
 902                             = xRequest->getAuthenticationSupplier();
 903
 904                 aResult = xSupp->getPassword();
 905             }
 906         }
 907     }
 908
 909     return aResult;
 910 }
 911
 912 //-------------------------------------------------------------------------
 913
 914 ::rtl::OUString PasswordContainer::GetMasterPassword( const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
 915 {
 916     PasswordRequestMode aRMode = PasswordRequestMode_PASSWORD_ENTER;
 917     if( !m_pStorageFile || !m_pStorageFile->useStorage() )
 918         throw NoMasterException( ::rtl::OUString::createFromAscii( "Password storing is not active!" ), Reference< XInterface >(), aRMode );
 919
 920     if( !m_aMasterPasswd.getLength() && aHandler.is() )
 921     {
 922         ::rtl::OUString aEncodedMP;
 923         sal_Bool bAskAgain = sal_False;
 924         sal_Bool bDefaultPassword = sal_False;
 925
 926         if( !m_pStorageFile->getEncodedMP( aEncodedMP ) )
 927             aRMode = PasswordRequestMode_PASSWORD_CREATE;
 928         else if ( !aEncodedMP.getLength() )
 929         {
 930             m_aMasterPasswd = GetDefaultMasterPassword();
 931             bDefaultPassword = sal_True;
 932         }
 933
 934         if ( !bDefaultPassword )
 935         {
 936             do {
 937                 bAskAgain = sal_False;
 938
 939                 ::rtl::OUString aPass = RequestPasswordFromUser( aRMode, aHandler );
 940                 if ( aPass.getLength() )
 941                 {
 942                     if( aRMode == PasswordRequestMode_PASSWORD_CREATE )
 943                     {
 944                         m_aMasterPasswd = aPass;
 945                         vector< ::rtl::OUString > aMaster( 1, m_aMasterPasswd );
 946
 947                         m_pStorageFile->setEncodedMP( EncodePasswords( aMaster, m_aMasterPasswd ) );
 948                     }
 949                     else
 950                     {
 951                         vector< ::rtl::OUString > aRM( DecodePasswords( aEncodedMP, aPass ) );
 952                         if( !aRM.size() || !aPass.equals( aRM[0] ) )
 953                         {
 954                             bAskAgain = sal_True;
 955                             aRMode = PasswordRequestMode_PASSWORD_REENTER;
 956                         }
 957                         else
 958                             m_aMasterPasswd = aPass;
 959                     }
 960                 }
 961
 962             } while( bAskAgain );
 963         }
 964     }
 965
 966     if ( !m_aMasterPasswd.getLength() )
 967         throw NoMasterException( ::rtl::OUString::createFromAscii( "No master password!" ), Reference< XInterface >(), aRMode );
 968
 969     return m_aMasterPasswd;
 970 }
 971
 972 //-------------------------------------------------------------------------
 973
 974 void SAL_CALL PasswordContainer::remove( const ::rtl::OUString& aURL, const ::rtl::OUString& aName ) throw(RuntimeException)
 975 {
 976     ::osl::MutexGuard aGuard( mMutex );
 977
 978     ::rtl::OUString aUrl( aURL );
 979     if( !m_aContainer.empty() )
 980     {
 981         PassMap::iterator aIter = m_aContainer.find( aUrl );
 982
 983         if( aIter == m_aContainer.end() )
 984         {
 985             sal_Int32 aInd = aUrl.lastIndexOf( sal_Unicode( '/' ) );
 986             if( aInd > 0 && aUrl.getLength()-1 == aInd )
 987                 aUrl = aUrl.copy( 0, aUrl.getLength() - 1 );
 988             else
 989                 aUrl += ::rtl::OUString::createFromAscii( "/" );
 990
 991             aIter = m_aContainer.find( aUrl );
 992         }
 993
 994         if( aIter != m_aContainer.end() )
 995         {
 996             for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); aNPIter++ )
 997                 if( aNPIter->GetUserName().equals( aName ) )
 998                 {
 999                     if( aNPIter->HasPasswords( PERSISTENT_RECORD ) && m_pStorageFile )
1000                         m_pStorageFile->remove( aURL, aName ); // remove record ( aURL, aName )
1001
1002                     // the iterator will not be used any more so it can be removed directly
1003                     aIter->second.erase( aNPIter );
1004
1005                     if( aIter->second.begin() == aIter->second.end() )
1006                         m_aContainer.erase( aIter );
1007
1008                     return;
1009                 }
1010         }
1011     }
1012 }
1013
1014 //-------------------------------------------------------------------------
1015
1016 void SAL_CALL PasswordContainer::removePersistent( const ::rtl::OUString& aURL, const ::rtl::OUString& aName ) throw(RuntimeException)
1017 {
1018     ::osl::MutexGuard aGuard( mMutex );
1019
1020     ::rtl::OUString aUrl( aURL );
1021     if( !m_aContainer.empty() )
1022     {
1023         PassMap::iterator aIter = m_aContainer.find( aUrl );
1024
1025         if( aIter == m_aContainer.end() )
1026         {
1027             sal_Int32 aInd = aUrl.lastIndexOf( sal_Unicode( '/' ) );
1028             if( aInd > 0 && aUrl.getLength()-1 == aInd )
1029                 aUrl = aUrl.copy( 0, aUrl.getLength() - 1 );
1030             else
1031                 aUrl += ::rtl::OUString::createFromAscii( "/" );
1032
1033             aIter = m_aContainer.find( aUrl );
1034         }
1035
1036         if( aIter != m_aContainer.end() )
1037         {
1038             for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); aNPIter++ )
1039                 if( aNPIter->GetUserName().equals( aName ) )
1040                 {
1041                     if( aNPIter->HasPasswords( PERSISTENT_RECORD ) )
1042                     {
1043                         // TODO/LATER: should the password be converted to MemoryPassword?
1044                         aNPIter->RemovePasswords( PERSISTENT_RECORD );
1045
1046                         if ( m_pStorageFile )
1047                             m_pStorageFile->remove( aURL, aName ); // remove record ( aURL, aName )
1048                     }
1049
1050                     if( !aNPIter->HasPasswords( MEMORY_RECORD ) )
1051                         aIter->second.erase( aNPIter );
1052
1053                     if( aIter->second.begin() == aIter->second.end() )
1054                         m_aContainer.erase( aIter );
1055
1056                     return;
1057                 }
1058         }
1059     }
1060 }
1061 //-------------------------------------------------------------------------
1062
1063 void SAL_CALL PasswordContainer::removeAllPersistent() throw(RuntimeException)
1064 {
1065     ::osl::MutexGuard aGuard( mMutex );
1066
1067     if( m_pStorageFile )
1068         m_pStorageFile->clear();
1069
1070     for( PassMap::iterator aIter = m_aContainer.begin(); aIter != m_aContainer.end(); )
1071     {
1072         for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); )
1073         {
1074             if( aNPIter->HasPasswords( PERSISTENT_RECORD ) )
1075             {
1076                 // TODO/LATER: should the password be converted to MemoryPassword?
1077                 aNPIter->RemovePasswords( PERSISTENT_RECORD );
1078
1079                 if ( m_pStorageFile )
1080                     m_pStorageFile->remove( aIter->first, aNPIter->GetUserName() ); // remove record ( aURL, aName )
1081             }
1082
1083             if( !aNPIter->HasPasswords( MEMORY_RECORD ) )
1084             {
1085                 list< NamePassRecord >::iterator aIterToDelete( aNPIter );
1086                 aNPIter++;
1087                 aIter->second.erase( aIterToDelete );
1088             }
1089             else
1090                 aNPIter++;
1091         }
1092
1093         if( aIter->second.begin() == aIter->second.end() )
1094         {
1095             PassMap::iterator aIterToDelete( aIter );
1096             aIter++;
1097             m_aContainer.erase( aIterToDelete );
1098         }
1099         else
1100             aIter++;
1101     }
1102 }
1103 //-------------------------------------------------------------------------
1104
1105 Sequence< UrlRecord > SAL_CALL PasswordContainer::getAllPersistent( const Reference< XInteractionHandler >& xHandler ) throw(RuntimeException)
1106 {
1107     Sequence< UrlRecord > aResult;
1108
1109     ::osl::MutexGuard aGuard( mMutex );
1110     for( PassMap::iterator aIter = m_aContainer.begin(); aIter != m_aContainer.end(); aIter++ )
1111     {
1112         Sequence< UserRecord > aUsers;
1113         for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); aNPIter++ )
1114             if( aNPIter->HasPasswords( PERSISTENT_RECORD ) )
1115             {
1116                 sal_Int32 oldLen = aUsers.getLength();
1117                 aUsers.realloc( oldLen + 1 );
1118                 aUsers[ oldLen ] = UserRecord( aNPIter->GetUserName(), copyVectorToSequence( DecodePasswords( aNPIter->GetPersPasswords(), GetMasterPassword( xHandler ) ) ) );
1119             }
1120
1121         if( aUsers.getLength() )
1122         {
1123             sal_Int32 oldLen = aResult.getLength();
1124             aResult.realloc( oldLen + 1 );
1125             aResult[ oldLen ] = UrlRecord( aIter->first, aUsers );
1126         }
1127     }
1128
1129     return aResult;
1130 }
1131
1132 //-------------------------------------------------------------------------
1133 sal_Bool SAL_CALL PasswordContainer::authorizateWithMasterPassword( const uno::Reference< task::XInteractionHandler >& xHandler )
1134     throw (uno::RuntimeException)
1135 {
1136     sal_Bool bResult = sal_False;
1137     ::rtl::OUString aEncodedMP;
1138     uno::Reference< task::XInteractionHandler > xTmpHandler = xHandler;
1139     ::osl::MutexGuard aGuard( mMutex );
1140
1141     // the method should fail if there is no master password
1142     if( m_pStorageFile && m_pStorageFile->useStorage() && m_pStorageFile->getEncodedMP( aEncodedMP ) )
1143     {
1144         if ( !aEncodedMP.getLength() )
1145         {
1146             // this is a default master password
1147             // no UI is necessary
1148             bResult = sal_True;
1149         }
1150         else
1151         {
1152             if ( !xTmpHandler.is() )
1153             {
1154                 uno::Reference< lang::XMultiServiceFactory > xFactory( mComponent, uno::UNO_QUERY_THROW );
1155                 xTmpHandler.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.task.InteractionHandler" ) ) ), uno::UNO_QUERY_THROW );
1156             }
1157
1158             if ( m_aMasterPasswd.getLength() )
1159             {
1160                 // there is a password, it should be just rechecked
1161                 PasswordRequestMode aRMode = PasswordRequestMode_PASSWORD_ENTER;
1162                 ::rtl::OUString aPass;
1163
1164                 do {
1165                     aPass = RequestPasswordFromUser( aRMode, xTmpHandler );
1166                     bResult = ( aPass.getLength() && aPass.equals( m_aMasterPasswd ) );
1167                     aRMode = PasswordRequestMode_PASSWORD_REENTER; // further questions with error notification
1168                 } while( !bResult && aPass.getLength() );
1169             }
1170             else
1171             {
1172                 try
1173                 {
1174                     // ask for the password, if user provide no correct password an exception will be thrown
1175                     bResult = ( GetMasterPassword( xTmpHandler ).getLength() > 0 );
1176                 }
1177                 catch( uno::Exception& )
1178                 {}
1179             }
1180         }
1181     }
1182
1183     return bResult;
1184 }
1185
1186 //-------------------------------------------------------------------------
1187 sal_Bool SAL_CALL PasswordContainer::changeMasterPassword( const uno::Reference< task::XInteractionHandler >& xHandler )
1188     throw (uno::RuntimeException)
1189 {
1190     sal_Bool bResult = sal_False;
1191     uno::Reference< task::XInteractionHandler > xTmpHandler = xHandler;
1192     ::osl::MutexGuard aGuard( mMutex );
1193
1194     if ( m_pStorageFile && m_pStorageFile->useStorage() )
1195     {
1196         if ( !xTmpHandler.is() )
1197         {
1198             uno::Reference< lang::XMultiServiceFactory > xFactory( mComponent, uno::UNO_QUERY_THROW );
1199             xTmpHandler.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.task.InteractionHandler" ) ) ), uno::UNO_QUERY_THROW );
1200         }
1201
1202         sal_Bool bCanChangePassword = sal_True;
1203         // if there is already a stored master password it should be entered by the user before the change happen
1204         ::rtl::OUString aEncodedMP;
1205         if( m_aMasterPasswd.getLength() || m_pStorageFile->getEncodedMP( aEncodedMP ) )
1206             bCanChangePassword = authorizateWithMasterPassword( xTmpHandler );
1207
1208         if ( bCanChangePassword )
1209         {
1210             // ask for the new password, but do not set it
1211             PasswordRequestMode aRMode = PasswordRequestMode_PASSWORD_CREATE;
1212             ::rtl::OUString aPass = RequestPasswordFromUser( aRMode, xTmpHandler );
1213
1214             if ( aPass.getLength() )
1215             {
1216                 // get all the persistent entries if it is possible
1217                 Sequence< UrlRecord > aPersistent = getAllPersistent( uno::Reference< task::XInteractionHandler >() );
1218
1219                 // remove the master password and the entries persistence
1220                 removeMasterPassword();
1221
1222                 // store the new master password
1223                 m_aMasterPasswd = aPass;
1224                 vector< ::rtl::OUString > aMaster( 1, m_aMasterPasswd );
1225                 m_pStorageFile->setEncodedMP( EncodePasswords( aMaster, m_aMasterPasswd ) );
1226
1227                 // store all the entries with the new password
1228                 for ( int nURLInd = 0; nURLInd < aPersistent.getLength(); nURLInd++ )
1229                     for ( int nNameInd = 0; nNameInd< aPersistent[nURLInd].UserList.getLength(); nNameInd++ )
1230                         addPersistent( aPersistent[nURLInd].Url,
1231                                        aPersistent[nURLInd].UserList[nNameInd].UserName,
1232                                        aPersistent[nURLInd].UserList[nNameInd].Passwords,
1233                                        uno::Reference< task::XInteractionHandler >() );
1234
1235                 bResult = sal_True;
1236             }
1237         }
1238     }
1239
1240     return bResult;
1241 }
1242
1243 //-------------------------------------------------------------------------
1244 void SAL_CALL PasswordContainer::removeMasterPassword()
1245     throw (uno::RuntimeException)
1246 {
1247     // remove all the stored passwords and the master password
1248     removeAllPersistent();
1249
1250     ::osl::MutexGuard aGuard( mMutex );
1251     if ( m_pStorageFile )
1252     {
1253         m_aMasterPasswd = ::rtl::OUString();
1254         m_pStorageFile->setEncodedMP( ::rtl::OUString() ); // let the master password be removed from configuration
1255     }
1256 }
1257
1258 //-------------------------------------------------------------------------
1259 ::sal_Bool SAL_CALL PasswordContainer::hasMasterPassword(  )
1260     throw (::com::sun::star::uno::RuntimeException)
1261 {
1262     ::osl::MutexGuard aGuard( mMutex );
1263
1264     if ( !m_pStorageFile )
1265         throw uno::RuntimeException();
1266
1267     ::rtl::OUString aEncodedMP;
1268     return ( m_pStorageFile->useStorage() && m_pStorageFile->getEncodedMP( aEncodedMP ) );
1269 }
1270
1271 //-------------------------------------------------------------------------
1272 ::sal_Bool SAL_CALL PasswordContainer::allowPersistentStoring( ::sal_Bool bAllow )
1273     throw (::com::sun::star::uno::RuntimeException)
1274 {
1275     ::osl::MutexGuard aGuard( mMutex );
1276
1277     if ( !m_pStorageFile )
1278         throw uno::RuntimeException();
1279
1280     if ( !bAllow )
1281         removeMasterPassword();
1282
1283     if ( m_pStorageFile->useStorage() == bAllow )
1284         return bAllow;
1285
1286     m_pStorageFile->setUseStorage( bAllow );
1287     return !bAllow;
1288 }
1289
1290 //-------------------------------------------------------------------------
1291 ::sal_Bool SAL_CALL PasswordContainer::isPersistentStoringAllowed()
1292     throw (::com::sun::star::uno::RuntimeException)
1293 {
1294     ::osl::MutexGuard aGuard( mMutex );
1295
1296     if ( !m_pStorageFile )
1297         throw uno::RuntimeException();
1298
1299     return m_pStorageFile->useStorage();
1300 }
1301
1302 //-------------------------------------------------------------------------
1303 ::sal_Bool SAL_CALL PasswordContainer::useDefaultMasterPassword( const uno::Reference< task::XInteractionHandler >& xHandler )
1304     throw ( uno::RuntimeException )
1305 {
1306     sal_Bool bResult = sal_False;
1307     uno::Reference< task::XInteractionHandler > xTmpHandler = xHandler;
1308     ::osl::MutexGuard aGuard( mMutex );
1309
1310     if ( m_pStorageFile && m_pStorageFile->useStorage() )
1311     {
1312         if ( !xTmpHandler.is() )
1313         {
1314             uno::Reference< lang::XMultiServiceFactory > xFactory( mComponent, uno::UNO_QUERY_THROW );
1315             xTmpHandler.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.task.InteractionHandler" ) ) ), uno::UNO_QUERY_THROW );
1316         }
1317
1318         sal_Bool bCanChangePassword = sal_True;
1319         // if there is already a stored nondefault master password it should be entered by the user before the change happen
1320         ::rtl::OUString aEncodedMP;
1321         if( m_pStorageFile->getEncodedMP( aEncodedMP ) && aEncodedMP.getLength() )
1322             bCanChangePassword = authorizateWithMasterPassword( xTmpHandler );
1323
1324         if ( bCanChangePassword )
1325         {
1326             // generate the default password
1327             ::rtl::OUString aPass = GetDefaultMasterPassword();
1328             if ( aPass.getLength() )
1329             {
1330                 // get all the persistent entries if it is possible
1331                 Sequence< UrlRecord > aPersistent = getAllPersistent( uno::Reference< task::XInteractionHandler >() );
1332
1333                 // remove the master password and the entries persistence
1334                 removeMasterPassword();
1335
1336                 // store the empty string to flag the default master password
1337                 m_aMasterPasswd = aPass;
1338                 m_pStorageFile->setEncodedMP( ::rtl::OUString(), sal_True );
1339
1340                 // store all the entries with the new password
1341                 for ( int nURLInd = 0; nURLInd < aPersistent.getLength(); nURLInd++ )
1342                     for ( int nNameInd = 0; nNameInd< aPersistent[nURLInd].UserList.getLength(); nNameInd++ )
1343                         addPersistent( aPersistent[nURLInd].Url,
1344                                        aPersistent[nURLInd].UserList[nNameInd].UserName,
1345                                        aPersistent[nURLInd].UserList[nNameInd].Passwords,
1346                                        uno::Reference< task::XInteractionHandler >() );
1347
1348                 bResult = sal_True;
1349             }
1350         }
1351     }
1352
1353     return bResult;
1354
1355 }
1356
1357 //-------------------------------------------------------------------------
1358 ::sal_Bool SAL_CALL PasswordContainer::isDefaultMasterPasswordUsed()
1359     throw ( uno::RuntimeException )
1360 {
1361     ::osl::MutexGuard aGuard( mMutex );
1362
1363     if ( !m_pStorageFile )
1364         throw uno::RuntimeException();
1365
1366     ::rtl::OUString aEncodedMP;
1367     return ( m_pStorageFile->useStorage() && m_pStorageFile->getEncodedMP( aEncodedMP ) && !aEncodedMP.getLength() );
1368 }
1369
1370
1371 //-------------------------------------------------------------------------
1372 void SAL_CALL PasswordContainer::addUrl( const ::rtl::OUString& Url, ::sal_Bool MakePersistent )
1373     throw (uno::RuntimeException)
1374 {
1375     mUrlContainer.add( Url, MakePersistent );
1376 }
1377
1378 //-------------------------------------------------------------------------
1379 ::rtl::OUString SAL_CALL PasswordContainer::findUrl( const ::rtl::OUString& Url )
1380     throw (uno::RuntimeException)
1381 {
1382     return mUrlContainer.find( Url );
1383 }
1384
1385 //-------------------------------------------------------------------------
1386 void SAL_CALL PasswordContainer::removeUrl( const ::rtl::OUString& Url )
1387     throw (uno::RuntimeException)
1388 {
1389     mUrlContainer.remove( Url );
1390 }
1391
1392 //-------------------------------------------------------------------------
1393 uno::Sequence< ::rtl::OUString > SAL_CALL PasswordContainer::getUrls( ::sal_Bool OnlyPersistent )
1394     throw (uno::RuntimeException)
1395 {
1396     return mUrlContainer.list( OnlyPersistent );
1397 }
1398
1399 //-------------------------------------------------------------------------
1400
1401 void PasswordContainer::Notify()
1402 {
1403     ::osl::MutexGuard aGuard( mMutex );
1404
1405     PassMap::iterator aIter;
1406
1407     // remove the cached persistent values in the memory
1408     for( aIter = m_aContainer.begin(); aIter != m_aContainer.end(); aIter++ )
1409     {
1410         for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); )
1411         {
1412             if( aNPIter->HasPasswords( PERSISTENT_RECORD ) )
1413             {
1414                 aNPIter->RemovePasswords( PERSISTENT_RECORD );
1415
1416                 if ( m_pStorageFile )
1417                     m_pStorageFile->remove( aIter->first, aNPIter->GetUserName() ); // remove record ( aURL, aName )
1418             }
1419
1420             if( !aNPIter->HasPasswords( MEMORY_RECORD ) )
1421             {
1422                 list< NamePassRecord >::iterator aIterToDelete( aNPIter );
1423                 aNPIter++;
1424                 aIter->second.erase( aIterToDelete );
1425             }
1426             else
1427                 aNPIter++;
1428         }
1429     }
1430
1431     PassMap addon;
1432     if( m_pStorageFile )
1433         addon = m_pStorageFile->getInfo();
1434
1435     for( aIter = addon.begin(); aIter != addon.end(); aIter++ )
1436     {
1437         PassMap::iterator aSearchIter = m_aContainer.find( aIter->first );
1438         if( aSearchIter != m_aContainer.end() )
1439             for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); aNPIter++ )
1440                 UpdateVector( aSearchIter->first, aSearchIter->second, *aNPIter, sal_False );
1441         else
1442             m_aContainer.insert( PairUrlRecord( aIter->first, aIter->second ) );
1443     }
1444 }
1445
1446 //-------------------------------------------------------------------------
1447
1448 ::rtl::OUString SAL_CALL PasswordContainer::getImplementationName(  ) throw(uno::RuntimeException)
1449 {
1450     return impl_getStaticImplementationName();
1451 }
1452
1453 //-------------------------------------------------------------------------
1454
1455 sal_Bool SAL_CALL PasswordContainer::supportsService( const ::rtl::OUString& ServiceName ) throw(uno::RuntimeException)
1456 {
1457     if ( ServiceName.compareToAscii("com.sun.star.task.PasswordContainer") == 0 )
1458         return sal_True;
1459     else
1460         return sal_False;
1461 }
1462
1463 //-------------------------------------------------------------------------
1464
1465 Sequence< ::rtl::OUString > SAL_CALL PasswordContainer::getSupportedServiceNames(  ) throw(uno::RuntimeException)
1466 {
1467     return impl_getStaticSupportedServiceNames();
1468 }
1469
1470 //-------------------------------------------------------------------------
1471
1472 Sequence< ::rtl::OUString > SAL_CALL PasswordContainer::impl_getStaticSupportedServiceNames(  ) throw(uno::RuntimeException)
1473 {
1474     Sequence< ::rtl::OUString > aRet(1);
1475     *aRet.getArray() = ::rtl::OUString::createFromAscii("com.sun.star.task.PasswordContainer");
1476     return aRet;
1477 }
1478
1479 //-------------------------------------------------------------------------
1480
1481 ::rtl::OUString SAL_CALL PasswordContainer::impl_getStaticImplementationName() throw(uno::RuntimeException)
1482 {
1483     return ::rtl::OUString::createFromAscii("stardiv.svtools.PasswordContainer");
1484 }
1485
1486 //-------------------------------------------------------------------------
1487
1488 Reference< XInterface > SAL_CALL PasswordContainer::impl_createInstance( const Reference< XMultiServiceFactory >& xServiceManager ) throw( RuntimeException )
1489 {
1490     return Reference< XInterface >( *new PasswordContainer( xServiceManager ) );
1491 }
1492
1493 //-------------------------------------------------------------------------
1494
1495 Reference< XSingleServiceFactory > SAL_CALL PasswordContainer::impl_createFactory( const Reference< XMultiServiceFactory >& ServiceManager ) throw(RuntimeException)
1496 {
1497     Reference< XSingleServiceFactory > xReturn( ::cppu::createOneInstanceFactory( ServiceManager,
1498                                                         PasswordContainer::impl_getStaticImplementationName(),
1499                                                         PasswordContainer::impl_createInstance,
1500                                                         PasswordContainer::impl_getStaticSupportedServiceNames()));
1501     return xReturn ;
1502
1503 }
1504
1505 //-------------------------------------------------------------------------
1506 //-------------------------------------------------------------------------
1507
1508 MasterPasswordRequest_Impl::MasterPasswordRequest_Impl( PasswordRequestMode Mode )
1509 {
1510     MasterPasswordRequest aRequest;
1511
1512     aRequest.Classification = InteractionClassification_ERROR;
1513     aRequest.Mode = Mode;
1514
1515     setRequest( makeAny( aRequest ) );
1516
1517     // Fill continuations...
1518     Sequence< RememberAuthentication > aRememberModes( 1 );
1519     aRememberModes[ 0 ] = RememberAuthentication_NO;
1520
1521     m_xAuthSupplier
1522         = new ::ucbhelper::InteractionSupplyAuthentication(
1523                 this,
1524                 sal_False, // bCanSetRealm
1525                 sal_False,  // bCanSetUserName
1526                 sal_True,  // bCanSetPassword
1527                 sal_False, // bCanSetAccount
1528                 aRememberModes, // rRememberPasswordModes
1529                 RememberAuthentication_NO, // eDefaultRememberPasswordMode
1530                 aRememberModes, // rRememberAccountModes
1531                 RememberAuthentication_NO, // eDefaultRememberAccountMode
1532                 sal_False, // bCanUseSystemCredentials
1533                 sal_False  // bDefaultUseSystemCredentials
1534             );
1535
1536     Sequence<
1537         Reference< XInteractionContinuation > > aContinuations( 3 );
1538     aContinuations[ 0 ] = new ::ucbhelper::InteractionAbort( this );
1539     aContinuations[ 1 ] = new ::ucbhelper::InteractionRetry( this );
1540     aContinuations[ 2 ] = m_xAuthSupplier.get();
1541
1542     setContinuations( aContinuations );
1543 }
1544
1545 //-------------------------------------------------------------------------
1546 //-------------------------------------------------------------------------
1547
1548 extern "C"
1549 {
1550 SAL_DLLPUBLIC_EXPORT void SAL_CALL component_getImplementationEnvironment (
1551     const sal_Char ** ppEnvTypeName, uno_Environment ** /* ppEnv */)
1552 {
1553     *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
1554 }
1555
1556 SAL_DLLPUBLIC_EXPORT sal_Bool SAL_CALL component_writeInfo (
1557     void * /* pServiceManager */, void * pRegistryKey)
1558 {
1559     if (pRegistryKey)
1560     {
1561         Reference< XRegistryKey > xRegistryKey (
1562             reinterpret_cast< XRegistryKey* >( pRegistryKey ));
1563         Reference< XRegistryKey > xNewKey;
1564
1565         xNewKey = xRegistryKey->createKey(
1566             ::rtl::OUString::createFromAscii( "/stardiv.svtools.PasswordContainer/UNO/SERVICES" ));
1567         xNewKey->createKey( ::rtl::OUString::createFromAscii("com.sun.star.task.PasswordContainer"));
1568
1569         return sal_True;
1570     }
1571     return sal_False;
1572 }
1573
1574 SAL_DLLPUBLIC_EXPORT void * SAL_CALL component_getFactory (
1575     const sal_Char * pImplementationName, void * pServiceManager, void * /* pRegistryKey */)
1576 {
1577     void * pResult = 0;
1578     if (pServiceManager)
1579     {
1580         Reference< XSingleServiceFactory > xFactory;
1581         if (PasswordContainer::impl_getStaticImplementationName().compareToAscii (pImplementationName) == 0)
1582         {
1583             xFactory = PasswordContainer::impl_createFactory (
1584                 reinterpret_cast< XMultiServiceFactory* >(pServiceManager));
1585         }
1586         if (xFactory.is())
1587         {
1588             xFactory->acquire();
1589             pResult = xFactory.get();
1590         }
1591     }
1592     return pResult;
1593 }
1594
1595 } // extern "C"