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