uui/source/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 #include <comphelper/processfactory.hxx>
  21 #include <cppuhelper/factory.hxx>
  22 #include <cppuhelper/supportsservice.hxx>
  23 #include <osl/diagnose.h>
  24
  25 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  26 #include <com/sun/star/task/NoMasterException.hpp>
  27 #include <com/sun/star/task/PasswordContainer.hpp>
  28 #include <com/sun/star/task/XInteractionHandler2.hpp>
  29 #include <com/sun/star/ucb/AuthenticationRequest.hpp>
  30 #include <com/sun/star/ucb/URLAuthenticationRequest.hpp>
  31 #include <com/sun/star/ucb/XInteractionSupplyAuthentication.hpp>
  32 #include <com/sun/star/ucb/XInteractionSupplyAuthentication2.hpp>
  33
  34 #include "passwordcontainer.hxx"
  35
  36 using namespace com::sun::star;
  37
  38 namespace {
  39
  40
  41 bool fillContinuation(
  42     bool bUseSystemCredentials,
  43     const ucb::AuthenticationRequest & rRequest,
  44     const task::UrlRecord & aRec,
  45     const uno::Reference< ucb::XInteractionSupplyAuthentication > &
  46         xSupplyAuthentication,
  47     const uno::Reference< ucb::XInteractionSupplyAuthentication2 > &
  48         xSupplyAuthentication2,
  49     bool bCanUseSystemCredentials,
  50     bool bCheckForEqualPasswords )
  51 {
  52     if ( bUseSystemCredentials )
  53     {
  54         // "use system creds" record found.
  55         // Wants client that we use it?
  56         if ( xSupplyAuthentication2.is() && bCanUseSystemCredentials )
  57         {
  58             xSupplyAuthentication2->setUseSystemCredentials( sal_True );
  59             return true;
  60         }
  61         return false;
  62     }
  63     else if (aRec.UserList.getLength() != 0)
  64     {
  65         if (aRec.UserList[0].Passwords.getLength() == 0)
  66         {
  67             // Password sequence can be empty, for instance if master
  68             // password was not given (e.g. master pw dialog canceled)
  69             // pw container does not throw NoMasterException in this case.
  70             // bug???
  71             return false;
  72         }
  73
  74         // "user/pass" record found.
  75         if (!bCheckForEqualPasswords || !rRequest.HasPassword
  76             || rRequest.Password != aRec.UserList[0].Passwords[0]) // failed login attempt?
  77         {
  78             if (xSupplyAuthentication->canSetUserName())
  79                 xSupplyAuthentication->
  80                     setUserName(aRec.UserList[0].UserName.getStr());
  81
  82             if (xSupplyAuthentication->canSetPassword())
  83                 xSupplyAuthentication->
  84                     setPassword(aRec.UserList[0].Passwords[0].getStr());
  85             if (aRec.UserList[0].Passwords.getLength() > 1)
  86             {
  87                 if (rRequest.HasRealm)
  88                 {
  89                     if (xSupplyAuthentication->canSetRealm())
  90                         xSupplyAuthentication->
  91                             setRealm(aRec.UserList[0].Passwords[1].
  92                                 getStr());
  93                 }
  94                 else if (xSupplyAuthentication->canSetAccount())
  95                     xSupplyAuthentication->
  96                         setAccount(aRec.UserList[0].Passwords[1].
  97                             getStr());
  98             }
  99
 100             if ( xSupplyAuthentication2.is() && bCanUseSystemCredentials )
 101                 xSupplyAuthentication2->setUseSystemCredentials( sal_False );
 102
 103             return true;
 104         }
 105     }
 106     return false;
 107 }
 108
 109 } // namespace
 110
 111 namespace uui {
 112
 113
 114 PasswordContainerHelper::PasswordContainerHelper(
 115     uno::Reference< uno::XComponentContext > const & xContext ):
 116     m_xPasswordContainer(task::PasswordContainer::create(xContext))
 117 {}
 118
 119
 120 bool PasswordContainerHelper::handleAuthenticationRequest(
 121     ucb::AuthenticationRequest const & rRequest,
 122     uno::Reference< ucb::XInteractionSupplyAuthentication > const &
 123         xSupplyAuthentication,
 124     OUString const & rURL,
 125     uno::Reference< task::XInteractionHandler2 > const & xIH )
 126 {
 127     uno::Reference< task::XInteractionHandler > xIH1(xIH, uno::UNO_QUERY);
 128
 129     // Is continuation even a XInteractionSupplyAuthentication2, which
 130     // is derived from XInteractionSupplyAuthentication?
 131     uno::Reference< ucb::XInteractionSupplyAuthentication2 >
 132         xSupplyAuthentication2(xSupplyAuthentication, uno::UNO_QUERY);
 133
 134     bool bCanUseSystemCredentials = false;
 135     if (xSupplyAuthentication2.is())
 136     {
 137         sal_Bool bDefaultUseSystemCredentials;
 138         bCanUseSystemCredentials
 139             =  xSupplyAuthentication2->canUseSystemCredentials(
 140                 bDefaultUseSystemCredentials );
 141     }
 142
 143     if ( bCanUseSystemCredentials )
 144     {
 145         // Runtime / Persistent info avail for current auth request?
 146
 147         OUString aResult = m_xPasswordContainer->findUrl(
 148             rURL.isEmpty() ? rRequest.ServerName : rURL );
 149         if ( !aResult.isEmpty() )
 150         {
 151             if ( fillContinuation( true,
 152                                    rRequest,
 153                                    task::UrlRecord(),
 154                                    xSupplyAuthentication,
 155                                    xSupplyAuthentication2,
 156                                    bCanUseSystemCredentials,
 157                                    false ) )
 158             {
 159                 return true;
 160             }
 161         }
 162     }
 163
 164     // m_xPasswordContainer works with userName passwdSequences pairs:
 165     if (rRequest.HasUserName && rRequest.HasPassword)
 166     {
 167         try
 168         {
 169             if (rRequest.UserName.isEmpty())
 170             {
 171                 task::UrlRecord aRec;
 172                 if ( !rURL.isEmpty() )
 173                     aRec = m_xPasswordContainer->find(rURL, xIH1);
 174
 175                 if ( aRec.UserList.getLength() == 0 )
 176                 {
 177                     // compat: try server name.
 178                     aRec = m_xPasswordContainer->find(rRequest.ServerName, xIH1);
 179                 }
 180
 181                 if ( fillContinuation( false,
 182                                        rRequest,
 183                                        aRec,
 184                                        xSupplyAuthentication,
 185                                        xSupplyAuthentication2,
 186                                        bCanUseSystemCredentials,
 187                                        false ) )
 188                 {
 189                     return true;
 190                 }
 191             }
 192             else
 193             {
 194                 task::UrlRecord aRec;
 195                 if ( !rURL.isEmpty() )
 196                     aRec = m_xPasswordContainer->findForName(
 197                         rURL, rRequest.UserName, xIH1);
 198
 199                 if ( aRec.UserList.getLength() == 0 )
 200                 {
 201                     // compat: try server name.
 202                     aRec = m_xPasswordContainer->findForName(
 203                         rRequest.ServerName, rRequest.UserName, xIH1);
 204                 }
 205
 206                 if ( fillContinuation( false,
 207                                        rRequest,
 208                                        aRec,
 209                                        xSupplyAuthentication,
 210                                        xSupplyAuthentication2,
 211                                        bCanUseSystemCredentials,
 212                                        true ) )
 213                 {
 214                     return true;
 215                 }
 216             }
 217         }
 218         catch (task::NoMasterException const &)
 219         {} // user did not enter master password
 220     }
 221     return false;
 222 }
 223
 224
 225 bool PasswordContainerHelper::addRecord(
 226     OUString const & rURL,
 227     OUString const & rUsername,
 228     uno::Sequence< OUString > const & rPasswords,
 229     uno::Reference< task::XInteractionHandler2 > const & xIH,
 230     bool bPersist )
 231 {
 232     uno::Reference< task::XInteractionHandler > xIH1(xIH, uno::UNO_QUERY);
 233
 234     try
 235     {
 236         if ( !rUsername.isEmpty() )
 237         {
 238             OSL_ENSURE( m_xPasswordContainer.is(),
 239                         "Got no XPasswordContainer!" );
 240             if ( !m_xPasswordContainer.is() )
 241                 return false;
 242
 243             if ( bPersist )
 244             {
 245                 // If persistent storing of passwords is not yet
 246                 // allowed, enable it.
 247                 if ( !m_xPasswordContainer->isPersistentStoringAllowed() )
 248                     m_xPasswordContainer->allowPersistentStoring( sal_True );
 249
 250                 m_xPasswordContainer->addPersistent( rURL,
 251                                                      rUsername,
 252                                                      rPasswords,
 253                                                      xIH1 );
 254             }
 255             else
 256                 m_xPasswordContainer->add( rURL,
 257                                            rUsername,
 258                                            rPasswords,
 259                                            xIH1 );
 260         }
 261         else
 262         {
 263             m_xPasswordContainer->addUrl( rURL, bPersist );
 264         }
 265     }
 266     catch ( task::NoMasterException const & )
 267     {
 268         // user did not enter master password
 269         return false;
 270     }
 271     return true;
 272 }
 273
 274
 275
 276
 277
 278 PasswordContainerInteractionHandler::PasswordContainerInteractionHandler(
 279     const uno::Reference< uno::XComponentContext >& xContext )
 280 : m_aPwContainerHelper( xContext )
 281 {
 282 }
 283
 284
 285 // virtual
 286 PasswordContainerInteractionHandler::~PasswordContainerInteractionHandler()
 287 {
 288 }
 289
 290
 291
 292 // XServiceInfo methods.
 293
 294
 295
 296 // virtual
 297 OUString SAL_CALL
 298 PasswordContainerInteractionHandler::getImplementationName()
 299     throw ( uno::RuntimeException, std::exception )
 300 {
 301     return getImplementationName_Static();
 302 }
 303
 304
 305 // virtual
 306 sal_Bool SAL_CALL
 307 PasswordContainerInteractionHandler::supportsService(
 308         const OUString& ServiceName )
 309     throw ( uno::RuntimeException, std::exception )
 310 {
 311     return cppu::supportsService(this, ServiceName);
 312 }
 313
 314
 315 // virtual
 316 uno::Sequence< OUString > SAL_CALL
 317 PasswordContainerInteractionHandler::getSupportedServiceNames()
 318     throw ( uno::RuntimeException, std::exception )
 319 {
 320     return getSupportedServiceNames_Static();
 321 }
 322
 323
 324 // static
 325 OUString
 326 PasswordContainerInteractionHandler::getImplementationName_Static()
 327 {
 328     return OUString( "com.sun.star.comp.uui.PasswordContainerInteractionHandler" );
 329 }
 330
 331
 332 // static
 333 uno::Sequence< OUString >
 334 PasswordContainerInteractionHandler::getSupportedServiceNames_Static()
 335 {
 336     uno::Sequence< OUString > aSNS( 1 );
 337     aSNS.getArray()[ 0 ] =
 338                           "com.sun.star.task.PasswordContainerInteractionHandler";
 339     return aSNS;
 340 }
 341
 342
 343
 344 // XInteractionHandler2 methods.
 345
 346
 347
 348 // virtual
 349 void SAL_CALL
 350 PasswordContainerInteractionHandler::handle(
 351         const uno::Reference< task::XInteractionRequest >& rRequest )
 352     throw ( uno::RuntimeException, std::exception )
 353 {
 354     handleInteractionRequest( rRequest );
 355 }
 356
 357 // virtual
 358 sal_Bool SAL_CALL
 359 PasswordContainerInteractionHandler::handleInteractionRequest(
 360         const uno::Reference< task::XInteractionRequest >& rRequest )
 361     throw ( uno::RuntimeException, std::exception )
 362 {
 363     if ( !rRequest.is() )
 364         return false;
 365
 366     uno::Any aAnyRequest( rRequest->getRequest() );
 367
 368     ucb::AuthenticationRequest aAuthenticationRequest;
 369     if ( !( aAnyRequest >>= aAuthenticationRequest ) )
 370         return false;
 371
 372     OUString aURL;
 373     ucb::URLAuthenticationRequest aURLAuthenticationRequest;
 374     if ( aAnyRequest >>= aURLAuthenticationRequest )
 375         aURL = aURLAuthenticationRequest.URL;
 376
 377     uno::Sequence< uno::Reference< task::XInteractionContinuation > >
 378         rContinuations = rRequest->getContinuations();
 379
 380     uno::Reference< ucb::XInteractionSupplyAuthentication >
 381         xSupplyAuthentication;
 382
 383     for ( sal_Int32 i = 0; i < rContinuations.getLength(); ++i )
 384     {
 385         xSupplyAuthentication
 386             = uno::Reference< ucb::XInteractionSupplyAuthentication >(
 387                 rContinuations[i], uno::UNO_QUERY );
 388         if( xSupplyAuthentication.is() )
 389             break;
 390     }
 391
 392     if ( !xSupplyAuthentication.is() )
 393         return false;
 394
 395     // Try to obtain credentials from password container.
 396     if ( m_aPwContainerHelper.
 397              handleAuthenticationRequest( aAuthenticationRequest,
 398                                           xSupplyAuthentication,
 399                                           aURL,
 400                                           // @@@ FIXME: this not able to
 401                                           // handle master pw request!
 402                                           // master pw request is never
 403                                           // solvable without UI!
 404                                           this ) )
 405     {
 406         // successfully handled
 407         xSupplyAuthentication->select();
 408         return true;
 409     }
 410     return false;
 411 }
 412
 413
 414
 415 // Service factory implementation.
 416
 417
 418
 419 static uno::Reference< uno::XInterface > SAL_CALL
 420 PasswordContainerInteractionHandler_CreateInstance(
 421         const uno::Reference< lang::XMultiServiceFactory> & rSMgr )
 422     throw( uno::Exception )
 423 {
 424     lang::XServiceInfo * pX = static_cast< lang::XServiceInfo * >(
 425         new PasswordContainerInteractionHandler( comphelper::getComponentContext(rSMgr) ) );
 426     return uno::Reference< uno::XInterface >::query( pX );
 427 }
 428
 429
 430 // static
 431 uno::Reference< lang::XSingleServiceFactory >
 432 PasswordContainerInteractionHandler::createServiceFactory(
 433     const uno::Reference< lang::XMultiServiceFactory >& rxServiceMgr )
 434 {
 435     return uno::Reference< lang::XSingleServiceFactory >(
 436         cppu::createOneInstanceFactory(
 437             rxServiceMgr,
 438             PasswordContainerInteractionHandler::getImplementationName_Static(),
 439             PasswordContainerInteractionHandler_CreateInstance,
 440             PasswordContainerInteractionHandler::getSupportedServiceNames_Static() ) );
 441 }
 442
 443 } // namespace uui
 444
 445 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */