svl/source/passwordcontainer/passwordcontainer.cxx

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