svl/source/passwordcontainer/syscreds.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 #include "syscreds.hxx"
  21 #include <com/sun/star/beans/PropertyValue.hpp>
  22 #include <osl/diagnose.h>
  23 #include <comphelper/sequence.hxx>
  24
  25 using namespace com::sun::star;
  26
  27 SysCredentialsConfigItem::SysCredentialsConfigItem(
  28     SysCredentialsConfig * pOwner )
  29 : utl::ConfigItem( "Office.Common/Passwords", ConfigItemMode::NONE ),
  30   m_bInited( false ),
  31   m_pOwner( pOwner )
  32 {
  33     uno::Sequence<OUString> aNode { "Office.Common/Passwords/AuthenticateUsingSystemCredentials" };
  34     EnableNotification( aNode );
  35 }
  36
  37 //virtual
  38 void SysCredentialsConfigItem::Notify(
  39     const uno::Sequence< OUString > & /*seqPropertyNames*/ )
  40 {
  41     {
  42         ::osl::MutexGuard aGuard( m_aMutex );
  43         m_bInited = false;
  44         // rebuild m_seqURLs
  45         getSystemCredentialsURLs();
  46     }
  47     m_pOwner->persistentConfigChanged();
  48 }
  49
  50 void SysCredentialsConfigItem::ImplCommit()
  51 {
  52     // does nothing
  53 }
  54
  55 uno::Sequence< OUString >
  56 SysCredentialsConfigItem::getSystemCredentialsURLs()
  57 {
  58     ::osl::MutexGuard aGuard( m_aMutex );
  59     if ( !m_bInited )
  60     {
  61         // read config item
  62         uno::Sequence<OUString> aPropNames { "AuthenticateUsingSystemCredentials" };
  63         uno::Sequence< uno::Any > aAnyValues(
  64             utl::ConfigItem::GetProperties( aPropNames ) );
  65
  66         OSL_ENSURE(
  67             aAnyValues.getLength() == 1,
  68             "SysCredentialsConfigItem::getSystemCredentialsURLs: "
  69             "Error reading config item!" );
  70
  71         uno::Sequence< OUString > aValues;
  72         if ( ( aAnyValues[ 0 ] >>= aValues ) ||
  73              ( !aAnyValues[ 0 ].hasValue() ) )
  74         {
  75             m_seqURLs = aValues;
  76             m_bInited = true;
  77         }
  78     }
  79     return m_seqURLs;
  80 }
  81
  82 void SysCredentialsConfigItem::setSystemCredentialsURLs(
  83     const uno::Sequence< OUString > & seqURLList )
  84 {
  85     ::osl::MutexGuard aGuard( m_aMutex );
  86
  87     // write config item.
  88     uno::Sequence< OUString > aPropNames( 1 );
  89     uno::Sequence< uno::Any > aPropValues( 1 );
  90     aPropNames[ 0 ] = "AuthenticateUsingSystemCredentials";
  91     aPropValues[ 0 ] <<= seqURLList;
  92
  93     utl::ConfigItem::SetModified();
  94     utl::ConfigItem::PutProperties( aPropNames, aPropValues );
  95
  96     m_seqURLs = seqURLList;
  97     m_bInited = true;
  98 }
  99
 100
 101 namespace
 102 {
 103     // TODO: This code is actually copied from svl/source/passwordcontainer.cxx
 104     bool removeLastSegment( OUString & aURL )
 105     {
 106         sal_Int32 aInd = aURL.lastIndexOf( '/' );
 107
 108         if( aInd > 0  )
 109         {
 110             sal_Int32 aPrevInd = aURL.lastIndexOf( '/', aInd );
 111             if ( aURL.indexOf( "://" ) != aPrevInd - 2 ||
 112                  aInd != aURL.getLength() - 1 )
 113             {
 114                 aURL = aURL.copy( 0, aInd );
 115                 return true;
 116             }
 117         }
 118
 119         return false;
 120     }
 121
 122     bool findURL( StringSet const & rContainer, OUString const & aURL, OUString & aResult )
 123     {
 124         // TODO: This code is actually copied from svl/source/passwordcontainer.cxx
 125         if( !rContainer.empty() && !aURL.isEmpty() )
 126         {
 127             OUString aUrl( aURL );
 128
 129             // each iteration remove last '/...' section from the aUrl
 130             // while it's possible, up to the most left '://'
 131             do
 132             {
 133                 // first look for <url>/somename and then look for <url>/somename/...
 134                 StringSet::const_iterator aIter = rContainer.find( aUrl );
 135                 if( aIter != rContainer.end() )
 136                 {
 137                     aResult = *aIter;
 138                     return true;
 139                 }
 140                 else
 141                 {
 142                     OUString tmpUrl( aUrl );
 143                     if ( !tmpUrl.endsWith("/") )
 144                       tmpUrl += "/";
 145
 146                     aIter = rContainer.lower_bound( tmpUrl );
 147                     if( aIter != rContainer.end() && aIter->match( tmpUrl ) )
 148                     {
 149                         aResult = *aIter;
 150                         return true;
 151                     }
 152                 }
 153             }
 154             while( removeLastSegment( aUrl ) && !aUrl.isEmpty() );
 155         }
 156         aResult.clear();
 157         return false;
 158     }
 159
 160 } // namespace
 161
 162 SysCredentialsConfig::SysCredentialsConfig()
 163 : m_aConfigItem( this ),
 164   m_bCfgInited( false )
 165 {
 166 }
 167
 168 void SysCredentialsConfig::initCfg()
 169 {
 170     osl::MutexGuard aGuard( m_aMutex );
 171     if ( !m_bCfgInited )
 172     {
 173         uno::Sequence< OUString > aURLs(
 174             m_aConfigItem.getSystemCredentialsURLs() );
 175         for ( sal_Int32 n = 0; n < aURLs.getLength(); ++n )
 176             m_aCfgContainer.insert( aURLs[ n ] );
 177
 178         m_bCfgInited = true;
 179     }
 180 }
 181
 182 void SysCredentialsConfig::writeCfg()
 183 {
 184     osl::MutexGuard aGuard( m_aMutex );
 185
 186     OSL_ENSURE( m_bCfgInited, "SysCredentialsConfig::writeCfg : not initialized!" );
 187
 188     m_aConfigItem.setSystemCredentialsURLs( comphelper::containerToSequence(m_aCfgContainer) );
 189 }
 190
 191 OUString SysCredentialsConfig::find( OUString const & aURL )
 192 {
 193     osl::MutexGuard aGuard( m_aMutex );
 194     OUString aResult;
 195     if ( findURL( m_aMemContainer, aURL, aResult ) )
 196         return aResult;
 197
 198     initCfg();
 199     if ( findURL( m_aCfgContainer, aURL, aResult ) )
 200         return aResult;
 201
 202     return OUString();
 203 }
 204
 205 void SysCredentialsConfig::add( OUString const & rURL, bool bPersistent )
 206 {
 207     ::osl::MutexGuard aGuard( m_aMutex );
 208
 209     if ( bPersistent )
 210     {
 211         m_aMemContainer.erase( rURL );
 212
 213         initCfg();
 214         m_aCfgContainer.insert( rURL );
 215         writeCfg();
 216     }
 217     else
 218     {
 219         initCfg();
 220         if ( m_aCfgContainer.erase( rURL ) > 0 )
 221             writeCfg();
 222
 223         m_aMemContainer.insert( rURL );
 224     }
 225 }
 226
 227 void SysCredentialsConfig::remove( OUString const & rURL )
 228 {
 229     m_aMemContainer.erase( rURL );
 230
 231     initCfg();
 232     if ( m_aCfgContainer.erase( rURL ) > 0 )
 233         writeCfg();
 234 }
 235
 236 uno::Sequence< OUString > SysCredentialsConfig::list( bool bOnlyPersistent )
 237 {
 238     initCfg();
 239     sal_Int32 nCount = m_aCfgContainer.size()
 240                      + ( bOnlyPersistent ? 0 : m_aMemContainer.size() );
 241     uno::Sequence< OUString > aResult( nCount );
 242
 243     sal_Int32 n = 0;
 244
 245     for ( const auto& rItem : m_aCfgContainer )
 246     {
 247         aResult[ n ] = rItem;
 248         ++n;
 249     }
 250
 251     if ( !bOnlyPersistent )
 252     {
 253         for ( const auto& rItem : m_aMemContainer )
 254         {
 255             aResult[ n ] = rItem;
 256             ++n;
 257         }
 258     }
 259     return aResult;
 260 }
 261
 262 void SysCredentialsConfig::persistentConfigChanged()
 263 {
 264     ::osl::MutexGuard aGuard( m_aMutex );
 265     m_bCfgInited = false; // re-init on demand.
 266 }
 267
 268 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */