/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svl.hxx"
#include "passwordcontainer.hxx"
#include <unotools/pathoptions.hxx>
#include "cppuhelper/factory.hxx"
#include <com/sun/star/registry/XSimpleRegistry.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/task/MasterPasswordRequest.hpp>
#include <com/sun/star/task/NoMasterException.hpp>
#include <rtl/cipher.h>
#include <rtl/digest.h>
#include <rtl/byteseq.hxx>
#ifndef _TOOLS_INETSTRM_HXX
// @@@ #include <inetstrm.hxx>
#endif
using namespace std;
using namespace osl;
using namespace utl;
using namespace com::sun::star;
using namespace com::sun::star::uno;
using namespace com::sun::star::registry;
using namespace com::sun::star::lang;
using namespace com::sun::star::task;
using namespace com::sun::star::ucb;
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
static ::rtl::OUString createIndex( vector< ::rtl::OUString > lines )
{
::rtl::OString aResult;
const sal_Char* pLine;
for( unsigned int i = 0; i < lines.size(); i++ )
{
if( i )
aResult += ::rtl::OString( "__" );
::rtl::OString line = ::rtl::OUStringToOString( lines[i], RTL_TEXTENCODING_UTF8 );
pLine = line.getStr();
while( *pLine )
{
if( ( *pLine >= 'A' && *pLine <= 'Z' )
|| ( *pLine >= 'a' && *pLine <= 'z' )
|| ( *pLine >= '0' && *pLine <= '9' ) )
{
aResult += ::rtl::OString::valueOf( *pLine );
}
else
{
aResult += ::rtl::OString("_");
aResult += ::rtl::OString::valueOf( (sal_Int32) *pLine, 16 );
}
pLine++;
}
}
return ::rtl::OUString::createFromAscii( aResult.getStr() );
}
//-------------------------------------------------------------------------
static vector< ::rtl::OUString > getInfoFromInd( ::rtl::OUString aInd )
{
vector< ::rtl::OUString > aResult;
sal_Bool aStart = sal_True;
::rtl::OString line = ::rtl::OUStringToOString( aInd, RTL_TEXTENCODING_ASCII_US );
const sal_Char* pLine = line.getStr();
do
{
::rtl::OUString newItem;
if( !aStart )
pLine += 2;
else
aStart = sal_False;
while( *pLine && !( pLine[0] == '_' && pLine[1] == '_' ))
if( *pLine != '_' )
{
newItem += ::rtl::OUString::valueOf( (sal_Unicode) *pLine );
pLine++;
}
else
{
::rtl::OUString aNum;
for( int i = 1; i < 3; i++ )
{
if( !pLine[i]
|| ( ( pLine[i] < '0' || pLine[i] > '9' )
&& ( pLine[i] < 'a' || pLine[i] > 'f' )
&& ( pLine[i] < 'A' || pLine[i] > 'F' ) ) )
{
OSL_ENSURE( sal_False, "Wrong index syntax!\n" );
return aResult;
}
aNum += ::rtl::OUString::valueOf( (sal_Unicode) pLine[i] );
}
newItem += ::rtl::OUString::valueOf( (sal_Unicode) aNum.toInt32( 16 ) );
pLine += 3;
}
aResult.push_back( newItem );
} while( pLine[0] == '_' && pLine[1] == '_' );
if( *pLine )
OSL_ENSURE( sal_False, "Wrong index syntax!\n" );
return aResult;
}
//-------------------------------------------------------------------------
static sal_Bool shorterUrl( ::rtl::OUString& aURL )
{
sal_Int32 aInd = aURL.lastIndexOf( sal_Unicode( '/' ) );
if( aInd > 0 && aURL.indexOf( ::rtl::OUString::createFromAscii( "://" ) ) != aInd-2 )
{
aURL = aURL.copy( 0, aInd );
return sal_True;
}
return sal_False;
}
//-------------------------------------------------------------------------
static ::rtl::OUString getAsciiLine( const ::rtl::ByteSequence& buf )
{
::rtl::OUString aResult;
::rtl::ByteSequence outbuf( buf.getLength()*2+1 );
for( int ind = 0; ind < buf.getLength(); ind++ )
{
outbuf[ind*2] = ( ((sal_uInt8)buf[ind]) >> 4 ) + 'a';
outbuf[ind*2+1] = ( ((sal_uInt8)buf[ind]) & 0x0f ) + 'a';
}
outbuf[buf.getLength()*2] = '\0';
aResult = ::rtl::OUString::createFromAscii( (sal_Char*)outbuf.getArray() );
return aResult;
}
//-------------------------------------------------------------------------
static ::rtl::ByteSequence getBufFromAsciiLine( ::rtl::OUString line )
{
OSL_ENSURE( line.getLength() % 2 == 0, "Wrong syntax!\n" );
::rtl::OString tmpLine = ::rtl::OUStringToOString( line, RTL_TEXTENCODING_ASCII_US );
::rtl::ByteSequence aResult(line.getLength()/2);
for( int ind = 0; ind < tmpLine.getLength()/2; ind++ )
{
aResult[ind] = ( (sal_uInt8)( tmpLine.getStr()[ind*2] - 'a' ) << 4 ) | (sal_uInt8)( tmpLine.getStr()[ind*2+1] - 'a' );
}
return aResult;
}
//-------------------------------------------------------------------------
static Sequence< ::rtl::OUString > copyVectorToSequence( const vector< ::rtl::OUString >& original )
{
Sequence< ::rtl::OUString > newOne ( original.size() );
for( unsigned int i = 0; i < original.size() ; i++ )
newOne[i] = original[i];
return newOne;
}
static vector< ::rtl::OUString > copySequenceToVector( const Sequence< ::rtl::OUString >& original )
{
vector< ::rtl::OUString > newOne ( original.getLength() );
for( int i = 0; i < original.getLength() ; i++ )
newOne[i] = original[i];
return newOne;
}
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
PassMap StorageItem::getInfo()
{
PassMap aResult;
Sequence< ::rtl::OUString > aNodeNames = ConfigItem::GetNodeNames( ::rtl::OUString::createFromAscii("Store") );
sal_Int32 aNodeCount = aNodeNames.getLength();
Sequence< ::rtl::OUString > aPropNames( aNodeCount );
sal_Int32 aNodeInd;
for( aNodeInd = 0; aNodeInd < aNodeCount; ++aNodeInd )
{
aPropNames[aNodeInd] = ::rtl::OUString::createFromAscii( "Store/Passwordstorage['" );
aPropNames[aNodeInd] += aNodeNames[aNodeInd];
aPropNames[aNodeInd] += ::rtl::OUString::createFromAscii( "']/Password" );
}
Sequence< Any > aPropertyValues = ConfigItem::GetProperties( aPropNames );
if( aPropertyValues.getLength() != aNodeNames.getLength() )
{
OSL_ENSURE( aPropertyValues.getLength() == aNodeNames.getLength(), "Problems during reading\n" );
return aResult;
}
for( aNodeInd = 0; aNodeInd < aNodeCount; ++aNodeInd )
{
vector< ::rtl::OUString > aUrlUsr = getInfoFromInd( aNodeNames[aNodeInd] );
if( aUrlUsr.size() == 2 )
{
::rtl::OUString aUrl = aUrlUsr[0];
::rtl::OUString aName = aUrlUsr[1];
::rtl::OUString aEPasswd;
aPropertyValues[aNodeInd] >>= aEPasswd;
PassMap::iterator aIter = aResult.find( aUrl );
if( aIter != aResult.end() )
aIter->second.push_back( NamePassRecord( aName, aEPasswd ) );
else
{
NamePassRecord aNewRecord( aName, aEPasswd );
list< NamePassRecord > listToAdd( 1, aNewRecord );
aResult.insert( PairUrlRecord( aUrl, listToAdd ) );
}
}
else
OSL_ENSURE( sal_False, "Wrong index sintax!\n" );
}
return aResult;
}
//-------------------------------------------------------------------------
void StorageItem::setUseStorage( sal_Bool bUse )
{
Sequence< ::rtl::OUString > sendNames(1);
Sequence< uno::Any > sendVals(1);
sendNames[0] = ::rtl::OUString::createFromAscii( "UseStorage" );
sendVals[0] <<= bUse;
ConfigItem::SetModified();
ConfigItem::PutProperties( sendNames, sendVals );
}
//-------------------------------------------------------------------------
sal_Bool StorageItem::useStorage()
{
Sequence< ::rtl::OUString > aNodeNames( 1 );
aNodeNames[0] = ::rtl::OUString::createFromAscii( "UseStorage" );
Sequence< Any > aPropertyValues = ConfigItem::GetProperties( aNodeNames );
if( aPropertyValues.getLength() != aNodeNames.getLength() )
{
OSL_ENSURE( aPropertyValues.getLength() == aNodeNames.getLength(), "Problems during reading\n" );
return sal_False;
}
sal_Bool aResult = false;
aPropertyValues[0] >>= aResult;
return aResult;
}
//-------------------------------------------------------------------------
sal_Bool StorageItem::getEncodedMP( ::rtl::OUString& aResult )
{
if( hasEncoded )
{
aResult = mEncoded;
return sal_True;
}
Sequence< ::rtl::OUString > aNodeNames( 2 );
aNodeNames[0] = ::rtl::OUString::createFromAscii( "HasMaster" );
aNodeNames[1] = ::rtl::OUString::createFromAscii( "Master" );
Sequence< Any > aPropertyValues = ConfigItem::GetProperties( aNodeNames );
if( aPropertyValues.getLength() != aNodeNames.getLength() )
{
OSL_ENSURE( aPropertyValues.getLength() == aNodeNames.getLength(), "Problems during reading\n" );
return sal_False;
}
aPropertyValues[0] >>= hasEncoded;
aPropertyValues[1] >>= mEncoded;
aResult = mEncoded;
return hasEncoded;
}
//-------------------------------------------------------------------------
void StorageItem::setEncodedMP( const ::rtl::OUString& aEncoded, sal_Bool bAcceptEmpty )
{
Sequence< ::rtl::OUString > sendNames(2);
Sequence< uno::Any > sendVals(2);
sendNames[0] = ::rtl::OUString::createFromAscii( "HasMaster" );
sendNames[1] = ::rtl::OUString::createFromAscii( "Master" );
sal_Bool bHasMaster = ( aEncoded.getLength() > 0 || bAcceptEmpty );
sendVals[0] <<= bHasMaster;
sendVals[1] <<= aEncoded;
ConfigItem::SetModified();
ConfigItem::PutProperties( sendNames, sendVals );
hasEncoded = bHasMaster;
mEncoded = aEncoded;
}
//-------------------------------------------------------------------------
void StorageItem::remove( const ::rtl::OUString& aURL, const ::rtl::OUString& aName )
{
vector < ::rtl::OUString > forIndex;
forIndex.push_back( aURL );
forIndex.push_back( aName );
Sequence< ::rtl::OUString > sendSeq(1);
sendSeq[0] = createIndex( forIndex );
// sendSeq[0] = ::rtl::OUString::createFromAscii( "Store/Passwordstorage['" );
// sendSeq[0] += createIndex( forIndex );
// sendSeq[0] += ::rtl::OUString::createFromAscii( "']" );
ConfigItem::ClearNodeElements( ::rtl::OUString::createFromAscii( "Store" ), sendSeq );
}
//-------------------------------------------------------------------------
void StorageItem::clear()
{
Sequence< ::rtl::OUString > sendSeq(1);
ConfigItem::ClearNodeSet( ::rtl::OUString::createFromAscii( "Store" ) );
}
//-------------------------------------------------------------------------
void StorageItem::update( const ::rtl::OUString& aURL, const NamePassRecord& aRecord )
{
if ( !aRecord.HasPasswords( PERSISTENT_RECORD ) )
{
OSL_ASSERT( "Unexpected storing of a record!" );
return;
}
vector < ::rtl::OUString > forIndex;
forIndex.push_back( aURL );
forIndex.push_back( aRecord.GetUserName() );
Sequence< beans::PropertyValue > sendSeq(1);
sendSeq[0].Name = ::rtl::OUString::createFromAscii( "Store/Passwordstorage['" );
sendSeq[0].Name += createIndex( forIndex );
sendSeq[0].Name += ::rtl::OUString::createFromAscii( "']/Password" );
sendSeq[0].Value <<= aRecord.GetPersPasswords();
ConfigItem::SetModified();
ConfigItem::SetSetProperties( ::rtl::OUString::createFromAscii( "Store" ), sendSeq );
}
//-------------------------------------------------------------------------
void StorageItem::Notify( const Sequence< ::rtl::OUString >& )
{
// this feature still should not be used
if( mainCont )
mainCont->Notify();
}
//-------------------------------------------------------------------------
void StorageItem::Commit()
{
// Do nothing, we stored everything we want already
}
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
PasswordContainer::PasswordContainer( const Reference<XMultiServiceFactory>& xServiceFactory ):
m_pStorageFile( NULL )
{
// m_pStorageFile->Notify() can be called
::osl::MutexGuard aGuard( mMutex );
mComponent = Reference< XComponent >( xServiceFactory, UNO_QUERY );
mComponent->addEventListener( this );
m_pStorageFile = new StorageItem( this, ::rtl::OUString::createFromAscii( "Office.Common/Passwords" ) );
if( m_pStorageFile )
if( m_pStorageFile->useStorage() )
m_aContainer = m_pStorageFile->getInfo();
}
//-------------------------------------------------------------------------
PasswordContainer::~PasswordContainer()
{
::osl::MutexGuard aGuard( mMutex );
if( m_pStorageFile )
{
delete m_pStorageFile;
m_pStorageFile = NULL;
}
if( mComponent.is() )
{
mComponent->removeEventListener(this);
mComponent = Reference< XComponent >();
}
}
//-------------------------------------------------------------------------
void SAL_CALL PasswordContainer::disposing( const EventObject& ) throw(RuntimeException)
{
::osl::MutexGuard aGuard( mMutex );
if( m_pStorageFile )
{
delete m_pStorageFile;
m_pStorageFile = NULL;
}
if( mComponent.is() )
{
//mComponent->removeEventListener(this);
mComponent = Reference< XComponent >();
}
}
//-------------------------------------------------------------------------
vector< ::rtl::OUString > PasswordContainer::DecodePasswords( const ::rtl::OUString& aLine, const ::rtl::OUString& aMasterPasswd ) throw(RuntimeException)
{
if( aMasterPasswd.getLength() )
{
rtlCipher aDecoder = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeStream );
OSL_ENSURE( aDecoder, "Can't create decoder\n" );
if( aDecoder )
{
OSL_ENSURE( aMasterPasswd.getLength() == RTL_DIGEST_LENGTH_MD5 * 2, "Wrong master password format!\n" );
unsigned char code[RTL_DIGEST_LENGTH_MD5];
for( int ind = 0; ind < RTL_DIGEST_LENGTH_MD5; ind++ )
code[ ind ] = (char)(aMasterPasswd.copy( ind*2, 2 ).toInt32(16));
rtlCipherError result = rtl_cipher_init (
aDecoder, rtl_Cipher_DirectionDecode,
code, RTL_DIGEST_LENGTH_MD5, NULL, 0 );
if( result == rtl_Cipher_E_None )
{
::rtl::ByteSequence aSeq = getBufFromAsciiLine( aLine );
::rtl::ByteSequence resSeq( aSeq.getLength() );
result = rtl_cipher_decode ( aDecoder, (sal_uInt8*)aSeq.getArray(), aSeq.getLength(),
(sal_uInt8*)resSeq.getArray(), resSeq.getLength() );
::rtl::OUString aPasswd( ( sal_Char* )resSeq.getArray(), resSeq.getLength(), RTL_TEXTENCODING_UTF8 );
rtl_cipher_destroy (aDecoder);
return getInfoFromInd( aPasswd );
}
rtl_cipher_destroy (aDecoder);
}
}
else
{
OSL_ENSURE( sal_False, "No master password provided!\n" );
// throw special exception
}
// problems with decoding
OSL_ENSURE( sal_False, "Problem with decoding\n" );
throw RuntimeException( ::rtl::OUString::createFromAscii( "Can't decode!" ), Reference< XInterface >() );
}
//-------------------------------------------------------------------------
::rtl::OUString PasswordContainer::EncodePasswords( vector< ::rtl::OUString > lines, const ::rtl::OUString& aMasterPasswd ) throw(RuntimeException)
{
if( aMasterPasswd.getLength() )
{
::rtl::OString aSeq = ::rtl::OUStringToOString( createIndex( lines ), RTL_TEXTENCODING_UTF8 );
rtlCipher aEncoder = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeStream );
OSL_ENSURE( aEncoder, "Can't create encoder\n" );
if( aEncoder )
{
OSL_ENSURE( aMasterPasswd.getLength() == RTL_DIGEST_LENGTH_MD5 * 2, "Wrong master password format!\n" );
unsigned char code[RTL_DIGEST_LENGTH_MD5];
for( int ind = 0; ind < RTL_DIGEST_LENGTH_MD5; ind++ )
code[ ind ] = (char)(aMasterPasswd.copy( ind*2, 2 ).toInt32(16));
rtlCipherError result = rtl_cipher_init (
aEncoder, rtl_Cipher_DirectionEncode,
code, RTL_DIGEST_LENGTH_MD5, NULL, 0 );
if( result == rtl_Cipher_E_None )
{
::rtl::ByteSequence resSeq(aSeq.getLength()+1);
result = rtl_cipher_encode ( aEncoder, (sal_uInt8*)aSeq.getStr(), aSeq.getLength()+1,
(sal_uInt8*)resSeq.getArray(), resSeq.getLength() );
/*
//test
rtlCipherError result = rtl_cipher_init (
aEncoder, rtl_Cipher_DirectionDecode,
code, RTL_DIGEST_LENGTH_MD5, NULL, 0 );
if( result == rtl_Cipher_E_None )
{
::rtl::OUString testOU = getAsciiLine( resSeq );
::rtl::ByteSequence aSeq1 = getBufFromAsciiLine( testOU );
::rtl::ByteSequence resSeq1( aSeq1.getLength() );
if( resSeq.getLength() == aSeq1.getLength() )
{
for( int ind = 0; ind < aSeq1.getLength(); ind++ )
if( resSeq[ind] != aSeq1[ind] )
testOU = ::rtl::OUString();
}
result = rtl_cipher_decode ( aEncoder, (sal_uInt8*)aSeq1.getArray(), aSeq1.getLength(),
(sal_uInt8*)resSeq1.getArray(), resSeq1.getLength() );
::rtl::OUString aPasswd( ( sal_Char* )resSeq1.getArray(), resSeq1.getLength(), RTL_TEXTENCODING_UTF8 );
}
*/
rtl_cipher_destroy (aEncoder);
if( result == rtl_Cipher_E_None )
return getAsciiLine( resSeq );
}
rtl_cipher_destroy (aEncoder);
}
}
else
{
OSL_ENSURE( sal_False, "No master password provided!\n" );
// throw special exception
}
// problems with encoding
OSL_ENSURE( sal_False, "Problem with encoding\n" );
throw RuntimeException( ::rtl::OUString::createFromAscii( "Can't encode!" ), Reference< XInterface >() );
}
//-------------------------------------------------------------------------
void PasswordContainer::UpdateVector( const ::rtl::OUString& aURL, list< NamePassRecord >& toUpdate, NamePassRecord& aRecord, sal_Bool writeFile ) throw(RuntimeException)
{
for( list< NamePassRecord >::iterator aNPIter = toUpdate.begin(); aNPIter != toUpdate.end(); aNPIter++ )
if( aNPIter->GetUserName().equals( aRecord.GetUserName() ) )
{
if( aRecord.HasPasswords( MEMORY_RECORD ) )
aNPIter->SetMemPasswords( aRecord.GetMemPasswords() );
if( aRecord.HasPasswords( PERSISTENT_RECORD ) )
{
aNPIter->SetPersPasswords( aRecord.GetPersPasswords() );
if( writeFile )
{
// the password must be already encoded
m_pStorageFile->update( aURL, aRecord ); // change existing ( aURL, aName ) record in the configfile
}
}
return;
}
if( aRecord.HasPasswords( PERSISTENT_RECORD ) && writeFile )
{
// the password must be already encoded
m_pStorageFile->update( aURL, aRecord ); // add new aName to the existing url
}
toUpdate.insert( toUpdate.begin(), aRecord );
}
//-------------------------------------------------------------------------
UserRecord PasswordContainer::CopyToUserRecord( const NamePassRecord& aRecord, sal_Bool& io_bTryToDecode, const Reference< XInteractionHandler >& aHandler )
{
::std::vector< ::rtl::OUString > aPasswords;
if( aRecord.HasPasswords( MEMORY_RECORD ) )
aPasswords = aRecord.GetMemPasswords();
if( io_bTryToDecode && aRecord.HasPasswords( PERSISTENT_RECORD ) )
{
try
{
::std::vector< ::rtl::OUString > aDecodedPasswords = DecodePasswords( aRecord.GetPersPasswords(), GetMasterPassword( aHandler ) );
aPasswords.insert( aPasswords.end(), aDecodedPasswords.begin(), aDecodedPasswords.end() );
}
catch( NoMasterException& )
{
// if master password could not be detected the entry will be just ignored
io_bTryToDecode = sal_False;
}
}
return UserRecord( aRecord.GetUserName(), copyVectorToSequence( aPasswords ) );
}
//-------------------------------------------------------------------------
Sequence< UserRecord > PasswordContainer::CopyToUserRecordSequence( const list< NamePassRecord >& original, const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
{
Sequence< UserRecord > aResult( original.size() );
sal_uInt32 nInd = 0;
sal_Bool bTryToDecode = sal_True;
for( list< NamePassRecord >::const_iterator aNPIter = original.begin();
aNPIter != original.end();
aNPIter++, nInd++ )
{
aResult[nInd] = CopyToUserRecord( *aNPIter, bTryToDecode, aHandler );
}
return aResult;
}
//-------------------------------------------------------------------------
void SAL_CALL PasswordContainer::add( const ::rtl::OUString& Url, const ::rtl::OUString& UserName, const Sequence< ::rtl::OUString >& Passwords, const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
{
::osl::MutexGuard aGuard( mMutex );
PrivateAdd( Url, UserName, Passwords, MEMORY_RECORD, aHandler );
}
//-------------------------------------------------------------------------
void SAL_CALL PasswordContainer::addPersistent( const ::rtl::OUString& Url, const ::rtl::OUString& UserName, const Sequence< ::rtl::OUString >& Passwords, const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
{
::osl::MutexGuard aGuard( mMutex );
PrivateAdd( Url, UserName, Passwords, PERSISTENT_RECORD, aHandler );
}
//-------------------------------------------------------------------------
void PasswordContainer::PrivateAdd( const ::rtl::OUString& Url, const ::rtl::OUString& UserName, const Sequence< ::rtl::OUString >& Passwords, char Mode, const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
{
NamePassRecord aRecord( UserName );
::std::vector< ::rtl::OUString > aStorePass = copySequenceToVector( Passwords );
if( Mode == PERSISTENT_RECORD )
aRecord.SetPersPasswords( EncodePasswords( aStorePass, GetMasterPassword( aHandler ) ) );
else if( Mode == MEMORY_RECORD )
aRecord.SetMemPasswords( aStorePass );
else
{
OSL_ASSERT( "Unexpected persistence status!" );
return;
}
if( !m_aContainer.empty() )
{
PassMap::iterator aIter = m_aContainer.find( Url );
if( aIter != m_aContainer.end() )
{
UpdateVector( aIter->first, aIter->second, aRecord, sal_True );
return;
}
}
list< NamePassRecord > listToAdd( 1, aRecord );
m_aContainer.insert( PairUrlRecord( Url, listToAdd ) );
if( Mode == PERSISTENT_RECORD && m_pStorageFile && m_pStorageFile->useStorage() )
m_pStorageFile->update( Url, aRecord );
}
//-------------------------------------------------------------------------
UrlRecord SAL_CALL PasswordContainer::find( const ::rtl::OUString& aURL, const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
{
return find( aURL, rtl::OUString(), false, aHandler );
}
//-------------------------------------------------------------------------
UrlRecord SAL_CALL PasswordContainer::findForName( const ::rtl::OUString& aURL, const ::rtl::OUString& aName, const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
{
return find( aURL, aName, true, aHandler );
}
//-------------------------------------------------------------------------
Sequence< UserRecord > PasswordContainer::FindUsr( const list< NamePassRecord >& userlist, const ::rtl::OUString& aName, const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
{
sal_uInt32 nInd = 0;
for( list< NamePassRecord >::const_iterator aNPIter = userlist.begin();
aNPIter != userlist.end();
aNPIter++, nInd++ )
{
if( aNPIter->GetUserName().equals( aName ) )
{
Sequence< UserRecord > aResult(1);
sal_Bool bTryToDecode = sal_True;
aResult[0] = CopyToUserRecord( *aNPIter, bTryToDecode, aHandler );
return aResult;
}
}
return Sequence< UserRecord >();
}
//-------------------------------------------------------------------------
bool PasswordContainer::createUrlRecord(
const PassMap::iterator & rIter,
bool bName,
const ::rtl::OUString & aName,
const Reference< XInteractionHandler >& aHandler,
UrlRecord & rRec )
throw( RuntimeException )
{
if ( bName )
{
Sequence< UserRecord > aUsrRec
= FindUsr( rIter->second, aName, aHandler );
if( aUsrRec.getLength() )
{
rRec = UrlRecord( rIter->first, aUsrRec );
return true;
}
}
else
{
rRec = UrlRecord(
rIter->first,
CopyToUserRecordSequence( rIter->second, aHandler ) );
return true;
}
return false;
}
//-------------------------------------------------------------------------
UrlRecord PasswordContainer::find(
const ::rtl::OUString& aURL,
const ::rtl::OUString& aName,
bool bName, // only needed to support empty user names
const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
{
::osl::MutexGuard aGuard( mMutex );
if( !m_aContainer.empty() && aURL.getLength() )
{
::rtl::OUString aUrl( aURL );
// each iteration remove last '/...' section from the aUrl
// while it's possible, up to the most left '://'
do
{
// first look for <url>/somename and then look for <url>/somename/...
PassMap::iterator aIter = m_aContainer.find( aUrl );
if( aIter != m_aContainer.end() )
{
UrlRecord aRec;
if ( createUrlRecord( aIter, bName, aName, aHandler, aRec ) )
return aRec;
}
else
{
::rtl::OUString tmpUrl( aUrl );
if ( tmpUrl.getStr()[tmpUrl.getLength() - 1] != (sal_Unicode)'/' )
tmpUrl += ::rtl::OUString::createFromAscii( "/" );
aIter = m_aContainer.lower_bound( tmpUrl );
if( aIter != m_aContainer.end() && aIter->first.match( tmpUrl ) )
{
UrlRecord aRec;
if ( createUrlRecord( aIter, bName, aName, aHandler, aRec ) )
return aRec;
}
}
}
while( shorterUrl( aUrl ) && aUrl.getLength() );
}
return UrlRecord();
}
//-------------------------------------------------------------------------
::rtl::OUString PasswordContainer::GetDefaultMasterPassword()
{
::rtl::OUString aResult;
for ( sal_Int32 nInd = 0; nInd < RTL_DIGEST_LENGTH_MD5; nInd++ )
aResult += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "aa" ) );
return aResult;
}
//-------------------------------------------------------------------------
::rtl::OUString PasswordContainer::RequestPasswordFromUser( PasswordRequestMode aRMode, const uno::Reference< task::XInteractionHandler >& xHandler )
{
// empty string means that the call was cancelled or just failed
::rtl::OUString aResult;
if ( xHandler.is() )
{
::rtl::Reference< MasterPasswordRequest_Impl > xRequest = new MasterPasswordRequest_Impl( aRMode );
xHandler->handle( xRequest.get() );
::rtl::Reference< ucbhelper::InteractionContinuation > xSelection = xRequest->getSelection();
if ( xSelection.is() )
{
Reference< XInteractionAbort > xAbort( xSelection.get(), UNO_QUERY );
if ( !xAbort.is() )
{
const ::rtl::Reference< ucbhelper::InteractionSupplyAuthentication > & xSupp
= xRequest->getAuthenticationSupplier();
aResult = xSupp->getPassword();
}
}
}
return aResult;
}
//-------------------------------------------------------------------------
::rtl::OUString PasswordContainer::GetMasterPassword( const Reference< XInteractionHandler >& aHandler ) throw(RuntimeException)
{
PasswordRequestMode aRMode = PasswordRequestMode_PASSWORD_ENTER;
if( !m_pStorageFile || !m_pStorageFile->useStorage() )
throw NoMasterException( ::rtl::OUString::createFromAscii( "Password storing is not active!" ), Reference< XInterface >(), aRMode );
if( !m_aMasterPasswd.getLength() && aHandler.is() )
{
::rtl::OUString aEncodedMP;
sal_Bool bAskAgain = sal_False;
sal_Bool bDefaultPassword = sal_False;
if( !m_pStorageFile->getEncodedMP( aEncodedMP ) )
aRMode = PasswordRequestMode_PASSWORD_CREATE;
else if ( !aEncodedMP.getLength() )
{
m_aMasterPasswd = GetDefaultMasterPassword();
bDefaultPassword = sal_True;
}
if ( !bDefaultPassword )
{
do {
bAskAgain = sal_False;
::rtl::OUString aPass = RequestPasswordFromUser( aRMode, aHandler );
if ( aPass.getLength() )
{
if( aRMode == PasswordRequestMode_PASSWORD_CREATE )
{
m_aMasterPasswd = aPass;
vector< ::rtl::OUString > aMaster( 1, m_aMasterPasswd );
m_pStorageFile->setEncodedMP( EncodePasswords( aMaster, m_aMasterPasswd ) );
}
else
{
vector< ::rtl::OUString > aRM( DecodePasswords( aEncodedMP, aPass ) );
if( !aRM.size() || !aPass.equals( aRM[0] ) )
{
bAskAgain = sal_True;
aRMode = PasswordRequestMode_PASSWORD_REENTER;
}
else
m_aMasterPasswd = aPass;
}
}
} while( bAskAgain );
}
}
if ( !m_aMasterPasswd.getLength() )
throw NoMasterException( ::rtl::OUString::createFromAscii( "No master password!" ), Reference< XInterface >(), aRMode );
return m_aMasterPasswd;
}
//-------------------------------------------------------------------------
void SAL_CALL PasswordContainer::remove( const ::rtl::OUString& aURL, const ::rtl::OUString& aName ) throw(RuntimeException)
{
::osl::MutexGuard aGuard( mMutex );
::rtl::OUString aUrl( aURL );
if( !m_aContainer.empty() )
{
PassMap::iterator aIter = m_aContainer.find( aUrl );
if( aIter == m_aContainer.end() )
{
sal_Int32 aInd = aUrl.lastIndexOf( sal_Unicode( '/' ) );
if( aInd > 0 && aUrl.getLength()-1 == aInd )
aUrl = aUrl.copy( 0, aUrl.getLength() - 1 );
else
aUrl += ::rtl::OUString::createFromAscii( "/" );
aIter = m_aContainer.find( aUrl );
}
if( aIter != m_aContainer.end() )
{
for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); aNPIter++ )
if( aNPIter->GetUserName().equals( aName ) )
{
if( aNPIter->HasPasswords( PERSISTENT_RECORD ) && m_pStorageFile )
m_pStorageFile->remove( aURL, aName ); // remove record ( aURL, aName )
// the iterator will not be used any more so it can be removed directly
aIter->second.erase( aNPIter );
if( aIter->second.begin() == aIter->second.end() )
m_aContainer.erase( aIter );
return;
}
}
}
}
//-------------------------------------------------------------------------
void SAL_CALL PasswordContainer::removePersistent( const ::rtl::OUString& aURL, const ::rtl::OUString& aName ) throw(RuntimeException)
{
::osl::MutexGuard aGuard( mMutex );
::rtl::OUString aUrl( aURL );
if( !m_aContainer.empty() )
{
PassMap::iterator aIter = m_aContainer.find( aUrl );
if( aIter == m_aContainer.end() )
{
sal_Int32 aInd = aUrl.lastIndexOf( sal_Unicode( '/' ) );
if( aInd > 0 && aUrl.getLength()-1 == aInd )
aUrl = aUrl.copy( 0, aUrl.getLength() - 1 );
else
aUrl += ::rtl::OUString::createFromAscii( "/" );
aIter = m_aContainer.find( aUrl );
}
if( aIter != m_aContainer.end() )
{
for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); aNPIter++ )
if( aNPIter->GetUserName().equals( aName ) )
{
if( aNPIter->HasPasswords( PERSISTENT_RECORD ) )
{
// TODO/LATER: should the password be converted to MemoryPassword?
aNPIter->RemovePasswords( PERSISTENT_RECORD );
if ( m_pStorageFile )
m_pStorageFile->remove( aURL, aName ); // remove record ( aURL, aName )
}
if( !aNPIter->HasPasswords( MEMORY_RECORD ) )
aIter->second.erase( aNPIter );
if( aIter->second.begin() == aIter->second.end() )
m_aContainer.erase( aIter );
return;
}
}
}
}
//-------------------------------------------------------------------------
void SAL_CALL PasswordContainer::removeAllPersistent() throw(RuntimeException)
{
::osl::MutexGuard aGuard( mMutex );
if( m_pStorageFile )
m_pStorageFile->clear();
for( PassMap::iterator aIter = m_aContainer.begin(); aIter != m_aContainer.end(); )
{
for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); )
{
if( aNPIter->HasPasswords( PERSISTENT_RECORD ) )
{
// TODO/LATER: should the password be converted to MemoryPassword?
aNPIter->RemovePasswords( PERSISTENT_RECORD );
if ( m_pStorageFile )
m_pStorageFile->remove( aIter->first, aNPIter->GetUserName() ); // remove record ( aURL, aName )
}
if( !aNPIter->HasPasswords( MEMORY_RECORD ) )
{
list< NamePassRecord >::iterator aIterToDelete( aNPIter );
aNPIter++;
aIter->second.erase( aIterToDelete );
}
else
aNPIter++;
}
if( aIter->second.begin() == aIter->second.end() )
{
PassMap::iterator aIterToDelete( aIter );
aIter++;
m_aContainer.erase( aIterToDelete );
}
else
aIter++;
}
}
//-------------------------------------------------------------------------
Sequence< UrlRecord > SAL_CALL PasswordContainer::getAllPersistent( const Reference< XInteractionHandler >& xHandler ) throw(RuntimeException)
{
Sequence< UrlRecord > aResult;
::osl::MutexGuard aGuard( mMutex );
for( PassMap::iterator aIter = m_aContainer.begin(); aIter != m_aContainer.end(); aIter++ )
{
Sequence< UserRecord > aUsers;
for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); aNPIter++ )
if( aNPIter->HasPasswords( PERSISTENT_RECORD ) )
{
sal_Int32 oldLen = aUsers.getLength();
aUsers.realloc( oldLen + 1 );
aUsers[ oldLen ] = UserRecord( aNPIter->GetUserName(), copyVectorToSequence( DecodePasswords( aNPIter->GetPersPasswords(), GetMasterPassword( xHandler ) ) ) );
}
if( aUsers.getLength() )
{
sal_Int32 oldLen = aResult.getLength();
aResult.realloc( oldLen + 1 );
aResult[ oldLen ] = UrlRecord( aIter->first, aUsers );
}
}
return aResult;
}
//-------------------------------------------------------------------------
sal_Bool SAL_CALL PasswordContainer::authorizateWithMasterPassword( const uno::Reference< task::XInteractionHandler >& xHandler )
throw (uno::RuntimeException)
{
sal_Bool bResult = sal_False;
::rtl::OUString aEncodedMP;
uno::Reference< task::XInteractionHandler > xTmpHandler = xHandler;
::osl::MutexGuard aGuard( mMutex );
// the method should fail if there is no master password
if( m_pStorageFile && m_pStorageFile->useStorage() && m_pStorageFile->getEncodedMP( aEncodedMP ) )
{
if ( !aEncodedMP.getLength() )
{
// this is a default master password
// no UI is necessary
bResult = sal_True;
}
else
{
if ( !xTmpHandler.is() )
{
uno::Reference< lang::XMultiServiceFactory > xFactory( mComponent, uno::UNO_QUERY_THROW );
xTmpHandler.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.task.InteractionHandler" ) ) ), uno::UNO_QUERY_THROW );
}
if ( m_aMasterPasswd.getLength() )
{
// there is a password, it should be just rechecked
PasswordRequestMode aRMode = PasswordRequestMode_PASSWORD_ENTER;
::rtl::OUString aPass;
do {
aPass = RequestPasswordFromUser( aRMode, xTmpHandler );
bResult = ( aPass.getLength() && aPass.equals( m_aMasterPasswd ) );
aRMode = PasswordRequestMode_PASSWORD_REENTER; // further questions with error notification
} while( !bResult && aPass.getLength() );
}
else
{
try
{
// ask for the password, if user provide no correct password an exception will be thrown
bResult = ( GetMasterPassword( xTmpHandler ).getLength() > 0 );
}
catch( uno::Exception& )
{}
}
}
}
return bResult;
}
//-------------------------------------------------------------------------
sal_Bool SAL_CALL PasswordContainer::changeMasterPassword( const uno::Reference< task::XInteractionHandler >& xHandler )
throw (uno::RuntimeException)
{
sal_Bool bResult = sal_False;
uno::Reference< task::XInteractionHandler > xTmpHandler = xHandler;
::osl::MutexGuard aGuard( mMutex );
if ( m_pStorageFile && m_pStorageFile->useStorage() )
{
if ( !xTmpHandler.is() )
{
uno::Reference< lang::XMultiServiceFactory > xFactory( mComponent, uno::UNO_QUERY_THROW );
xTmpHandler.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.task.InteractionHandler" ) ) ), uno::UNO_QUERY_THROW );
}
sal_Bool bCanChangePassword = sal_True;
// if there is already a stored master password it should be entered by the user before the change happen
::rtl::OUString aEncodedMP;
if( m_aMasterPasswd.getLength() || m_pStorageFile->getEncodedMP( aEncodedMP ) )
bCanChangePassword = authorizateWithMasterPassword( xTmpHandler );
if ( bCanChangePassword )
{
// ask for the new password, but do not set it
PasswordRequestMode aRMode = PasswordRequestMode_PASSWORD_CREATE;
::rtl::OUString aPass = RequestPasswordFromUser( aRMode, xTmpHandler );
if ( aPass.getLength() )
{
// get all the persistent entries if it is possible
Sequence< UrlRecord > aPersistent = getAllPersistent( uno::Reference< task::XInteractionHandler >() );
// remove the master password and the entries persistence
removeMasterPassword();
// store the new master password
m_aMasterPasswd = aPass;
vector< ::rtl::OUString > aMaster( 1, m_aMasterPasswd );
m_pStorageFile->setEncodedMP( EncodePasswords( aMaster, m_aMasterPasswd ) );
// store all the entries with the new password
for ( int nURLInd = 0; nURLInd < aPersistent.getLength(); nURLInd++ )
for ( int nNameInd = 0; nNameInd< aPersistent[nURLInd].UserList.getLength(); nNameInd++ )
addPersistent( aPersistent[nURLInd].Url,
aPersistent[nURLInd].UserList[nNameInd].UserName,
aPersistent[nURLInd].UserList[nNameInd].Passwords,
uno::Reference< task::XInteractionHandler >() );
bResult = sal_True;
}
}
}
return bResult;
}
//-------------------------------------------------------------------------
void SAL_CALL PasswordContainer::removeMasterPassword()
throw (uno::RuntimeException)
{
// remove all the stored passwords and the master password
removeAllPersistent();
::osl::MutexGuard aGuard( mMutex );
if ( m_pStorageFile )
{
m_aMasterPasswd = ::rtl::OUString();
m_pStorageFile->setEncodedMP( ::rtl::OUString() ); // let the master password be removed from configuration
}
}
//-------------------------------------------------------------------------
::sal_Bool SAL_CALL PasswordContainer::hasMasterPassword( )
throw (::com::sun::star::uno::RuntimeException)
{
::osl::MutexGuard aGuard( mMutex );
if ( !m_pStorageFile )
throw uno::RuntimeException();
::rtl::OUString aEncodedMP;
return ( m_pStorageFile->useStorage() && m_pStorageFile->getEncodedMP( aEncodedMP ) );
}
//-------------------------------------------------------------------------
::sal_Bool SAL_CALL PasswordContainer::allowPersistentStoring( ::sal_Bool bAllow )
throw (::com::sun::star::uno::RuntimeException)
{
::osl::MutexGuard aGuard( mMutex );
if ( !m_pStorageFile )
throw uno::RuntimeException();
if ( !bAllow )
removeMasterPassword();
if ( m_pStorageFile->useStorage() == bAllow )
return bAllow;
m_pStorageFile->setUseStorage( bAllow );
return !bAllow;
}
//-------------------------------------------------------------------------
::sal_Bool SAL_CALL PasswordContainer::isPersistentStoringAllowed()
throw (::com::sun::star::uno::RuntimeException)
{
::osl::MutexGuard aGuard( mMutex );
if ( !m_pStorageFile )
throw uno::RuntimeException();
return m_pStorageFile->useStorage();
}
//-------------------------------------------------------------------------
::sal_Bool SAL_CALL PasswordContainer::useDefaultMasterPassword( const uno::Reference< task::XInteractionHandler >& xHandler )
throw ( uno::RuntimeException )
{
sal_Bool bResult = sal_False;
uno::Reference< task::XInteractionHandler > xTmpHandler = xHandler;
::osl::MutexGuard aGuard( mMutex );
if ( m_pStorageFile && m_pStorageFile->useStorage() )
{
if ( !xTmpHandler.is() )
{
uno::Reference< lang::XMultiServiceFactory > xFactory( mComponent, uno::UNO_QUERY_THROW );
xTmpHandler.set( xFactory->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.task.InteractionHandler" ) ) ), uno::UNO_QUERY_THROW );
}
sal_Bool bCanChangePassword = sal_True;
// if there is already a stored nondefault master password it should be entered by the user before the change happen
::rtl::OUString aEncodedMP;
if( m_pStorageFile->getEncodedMP( aEncodedMP ) && aEncodedMP.getLength() )
bCanChangePassword = authorizateWithMasterPassword( xTmpHandler );
if ( bCanChangePassword )
{
// generate the default password
::rtl::OUString aPass = GetDefaultMasterPassword();
if ( aPass.getLength() )
{
// get all the persistent entries if it is possible
Sequence< UrlRecord > aPersistent = getAllPersistent( uno::Reference< task::XInteractionHandler >() );
// remove the master password and the entries persistence
removeMasterPassword();
// store the empty string to flag the default master password
m_aMasterPasswd = aPass;
m_pStorageFile->setEncodedMP( ::rtl::OUString(), sal_True );
// store all the entries with the new password
for ( int nURLInd = 0; nURLInd < aPersistent.getLength(); nURLInd++ )
for ( int nNameInd = 0; nNameInd< aPersistent[nURLInd].UserList.getLength(); nNameInd++ )
addPersistent( aPersistent[nURLInd].Url,
aPersistent[nURLInd].UserList[nNameInd].UserName,
aPersistent[nURLInd].UserList[nNameInd].Passwords,
uno::Reference< task::XInteractionHandler >() );
bResult = sal_True;
}
}
}
return bResult;
}
//-------------------------------------------------------------------------
::sal_Bool SAL_CALL PasswordContainer::isDefaultMasterPasswordUsed()
throw ( uno::RuntimeException )
{
::osl::MutexGuard aGuard( mMutex );
if ( !m_pStorageFile )
throw uno::RuntimeException();
::rtl::OUString aEncodedMP;
return ( m_pStorageFile->useStorage() && m_pStorageFile->getEncodedMP( aEncodedMP ) && !aEncodedMP.getLength() );
}
//-------------------------------------------------------------------------
void SAL_CALL PasswordContainer::addUrl( const ::rtl::OUString& Url, ::sal_Bool MakePersistent )
throw (uno::RuntimeException)
{
mUrlContainer.add( Url, MakePersistent );
}
//-------------------------------------------------------------------------
::rtl::OUString SAL_CALL PasswordContainer::findUrl( const ::rtl::OUString& Url )
throw (uno::RuntimeException)
{
return mUrlContainer.find( Url );
}
//-------------------------------------------------------------------------
void SAL_CALL PasswordContainer::removeUrl( const ::rtl::OUString& Url )
throw (uno::RuntimeException)
{
mUrlContainer.remove( Url );
}
//-------------------------------------------------------------------------
uno::Sequence< ::rtl::OUString > SAL_CALL PasswordContainer::getUrls( ::sal_Bool OnlyPersistent )
throw (uno::RuntimeException)
{
return mUrlContainer.list( OnlyPersistent );
}
//-------------------------------------------------------------------------
void PasswordContainer::Notify()
{
::osl::MutexGuard aGuard( mMutex );
PassMap::iterator aIter;
// remove the cached persistent values in the memory
for( aIter = m_aContainer.begin(); aIter != m_aContainer.end(); aIter++ )
{
for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); )
{
if( aNPIter->HasPasswords( PERSISTENT_RECORD ) )
{
aNPIter->RemovePasswords( PERSISTENT_RECORD );
if ( m_pStorageFile )
m_pStorageFile->remove( aIter->first, aNPIter->GetUserName() ); // remove record ( aURL, aName )
}
if( !aNPIter->HasPasswords( MEMORY_RECORD ) )
{
list< NamePassRecord >::iterator aIterToDelete( aNPIter );
aNPIter++;
aIter->second.erase( aIterToDelete );
}
else
aNPIter++;
}
}
PassMap addon;
if( m_pStorageFile )
addon = m_pStorageFile->getInfo();
for( aIter = addon.begin(); aIter != addon.end(); aIter++ )
{
PassMap::iterator aSearchIter = m_aContainer.find( aIter->first );
if( aSearchIter != m_aContainer.end() )
for( list< NamePassRecord >::iterator aNPIter = aIter->second.begin(); aNPIter != aIter->second.end(); aNPIter++ )
UpdateVector( aSearchIter->first, aSearchIter->second, *aNPIter, sal_False );
else
m_aContainer.insert( PairUrlRecord( aIter->first, aIter->second ) );
}
}
//-------------------------------------------------------------------------
::rtl::OUString SAL_CALL PasswordContainer::getImplementationName( ) throw(uno::RuntimeException)
{
return impl_getStaticImplementationName();
}
//-------------------------------------------------------------------------
sal_Bool SAL_CALL PasswordContainer::supportsService( const ::rtl::OUString& ServiceName ) throw(uno::RuntimeException)
{
if ( ServiceName.compareToAscii("com.sun.star.task.PasswordContainer") == 0 )
return sal_True;
else
return sal_False;
}
//-------------------------------------------------------------------------
Sequence< ::rtl::OUString > SAL_CALL PasswordContainer::getSupportedServiceNames( ) throw(uno::RuntimeException)
{
return impl_getStaticSupportedServiceNames();
}
//-------------------------------------------------------------------------
Sequence< ::rtl::OUString > SAL_CALL PasswordContainer::impl_getStaticSupportedServiceNames( ) throw(uno::RuntimeException)
{
Sequence< ::rtl::OUString > aRet(1);
*aRet.getArray() = ::rtl::OUString::createFromAscii("com.sun.star.task.PasswordContainer");
return aRet;
}
//-------------------------------------------------------------------------
::rtl::OUString SAL_CALL PasswordContainer::impl_getStaticImplementationName() throw(uno::RuntimeException)
{
return ::rtl::OUString::createFromAscii("stardiv.svl.PasswordContainer");
}
//-------------------------------------------------------------------------
Reference< XInterface > SAL_CALL PasswordContainer::impl_createInstance( const Reference< XMultiServiceFactory >& xServiceManager ) throw( RuntimeException )
{
return Reference< XInterface >( *new PasswordContainer( xServiceManager ) );
}
//-------------------------------------------------------------------------
Reference< XSingleServiceFactory > SAL_CALL PasswordContainer::impl_createFactory( const Reference< XMultiServiceFactory >& ServiceManager ) throw(RuntimeException)
{
Reference< XSingleServiceFactory > xReturn( ::cppu::createOneInstanceFactory( ServiceManager,
PasswordContainer::impl_getStaticImplementationName(),
PasswordContainer::impl_createInstance,
PasswordContainer::impl_getStaticSupportedServiceNames()));
return xReturn ;
}
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
MasterPasswordRequest_Impl::MasterPasswordRequest_Impl( PasswordRequestMode Mode )
{
MasterPasswordRequest aRequest;
aRequest.Classification = InteractionClassification_ERROR;
aRequest.Mode = Mode;
setRequest( makeAny( aRequest ) );
// Fill continuations...
Sequence< RememberAuthentication > aRememberModes( 1 );
aRememberModes[ 0 ] = RememberAuthentication_NO;
m_xAuthSupplier
= new ::ucbhelper::InteractionSupplyAuthentication(
this,
sal_False, // bCanSetRealm
sal_False, // bCanSetUserName
sal_True, // bCanSetPassword
sal_False, // bCanSetAccount
aRememberModes, // rRememberPasswordModes
RememberAuthentication_NO, // eDefaultRememberPasswordMode
aRememberModes, // rRememberAccountModes
RememberAuthentication_NO, // eDefaultRememberAccountMode
sal_False, // bCanUseSystemCredentials
sal_False // bDefaultUseSystemCredentials
);
Sequence<
Reference< XInteractionContinuation > > aContinuations( 3 );
aContinuations[ 0 ] = new ::ucbhelper::InteractionAbort( this );
aContinuations[ 1 ] = new ::ucbhelper::InteractionRetry( this );
aContinuations[ 2 ] = m_xAuthSupplier.get();
setContinuations( aContinuations );
}
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
extern "C"
{
SAL_DLLPUBLIC_EXPORT void SAL_CALL component_getImplementationEnvironment (
const sal_Char ** ppEnvTypeName, uno_Environment ** /* ppEnv */)
{
*ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME;
}
SAL_DLLPUBLIC_EXPORT void * SAL_CALL component_getFactory (
const sal_Char * pImplementationName, void * pServiceManager, void * /* pRegistryKey */)
{
void * pResult = 0;
if (pServiceManager)
{
Reference< XSingleServiceFactory > xFactory;
if (PasswordContainer::impl_getStaticImplementationName().compareToAscii (pImplementationName) == 0)
{
xFactory = PasswordContainer::impl_createFactory (
reinterpret_cast< XMultiServiceFactory* >(pServiceManager));
}
if (xFactory.is())
{
xFactory->acquire();
pResult = xFactory.get();
}
}
return pResult;
}
} // extern "C"