uui/source/iahndl-authentication.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 <com/sun/star/task/DocumentPasswordRequest.hpp>
  21 #include <com/sun/star/task/DocumentPasswordRequest2.hpp>
  22 #include <com/sun/star/task/DocumentMSPasswordRequest.hpp>
  23 #include <com/sun/star/task/DocumentMSPasswordRequest2.hpp>
  24 #include <com/sun/star/task/MasterPasswordRequest.hpp>
  25 #include <com/sun/star/task/XInteractionAbort.hpp>
  26 #include <com/sun/star/task/XInteractionPassword.hpp>
  27 #include <com/sun/star/task/XInteractionPassword2.hpp>
  28 #include <com/sun/star/task/XInteractionRetry.hpp>
  29 #include <com/sun/star/ucb/XInteractionAuthFallback.hpp>
  30 #include <com/sun/star/ucb/XInteractionSupplyAuthentication2.hpp>
  31 #include <com/sun/star/ucb/URLAuthenticationRequest.hpp>
  32
  33 #include <osl/diagnose.h>
  34 #include <rtl/digest.h>
  35 #include <unotools/resmgr.hxx>
  36 #include <vcl/errcode.hxx>
  37 #include <vcl/errinf.hxx>
  38 #include <vcl/abstdlg.hxx>
  39 #include <vcl/svapp.hxx>
  40
  41 #include "authfallbackdlg.hxx"
  42 #include <strings.hrc>
  43 #include "getcontinuations.hxx"
  44 #include "passwordcontainer.hxx"
  45 #include "loginerr.hxx"
  46 #include "logindlg.hxx"
  47 #include "masterpasscrtdlg.hxx"
  48 #include "masterpassworddlg.hxx"
  49 #include "passworddlg.hxx"
  50
  51 #include "iahndl.hxx"
  52
  53 #include <memory>
  54
  55 using namespace com::sun::star;
  56
  57 namespace {
  58
  59 void
  60 executeLoginDialog(
  61     weld::Window* pParent,
  62     LoginErrorInfo & rInfo,
  63     OUString const & rRealm)
  64 {
  65     SolarMutexGuard aGuard;
  66
  67     bool bAccount = (rInfo.GetFlags() & LOGINERROR_FLAG_MODIFY_ACCOUNT) != 0;
  68     bool bSavePassword   = rInfo.GetCanRememberPassword();
  69     bool bCanUseSysCreds = rInfo.GetCanUseSystemCredentials();
  70
  71     LoginFlags nFlags = LoginFlags::NONE;
  72     if (rInfo.GetErrorText().isEmpty())
  73         nFlags |= LoginFlags::NoErrorText;
  74     if (!bAccount)
  75         nFlags |= LoginFlags::NoAccount;
  76     if (!(rInfo.GetFlags() & LOGINERROR_FLAG_MODIFY_USER_NAME))
  77         nFlags |= LoginFlags::UsernameReadonly;
  78
  79     if (!bSavePassword)
  80         nFlags |= LoginFlags::NoSavePassword;
  81
  82     if (!bCanUseSysCreds)
  83         nFlags |= LoginFlags::NoUseSysCreds;
  84
  85     LoginDialog aDialog(pParent, nFlags, rInfo.GetServer(), rRealm);
  86     if (!rInfo.GetErrorText().isEmpty())
  87         aDialog.SetErrorText(rInfo.GetErrorText());
  88     aDialog.SetName(rInfo.GetUserName());
  89     if (bAccount)
  90         aDialog.ClearAccount();
  91     else
  92         aDialog.ClearPassword();
  93     aDialog.SetPassword(rInfo.GetPassword());
  94
  95     if (bSavePassword)
  96     {
  97         std::locale aLocale(Translate::Create("uui"));
  98         aDialog.SetSavePasswordText(
  99             Translate::get(rInfo.GetIsRememberPersistent()
 100                       ? RID_SAVE_PASSWORD
 101                       : RID_KEEP_PASSWORD,
 102                   aLocale));
 103
 104         aDialog.SetSavePassword(rInfo.GetIsRememberPassword());
 105     }
 106
 107     if ( bCanUseSysCreds )
 108         aDialog.SetUseSystemCredentials( rInfo.GetIsUseSystemCredentials() );
 109
 110     rInfo.SetResult(aDialog.run() == RET_OK ? DialogMask::ButtonsOk :
 111                                               DialogMask::ButtonsCancel);
 112     rInfo.SetUserName(aDialog.GetName());
 113     rInfo.SetPassword(aDialog.GetPassword());
 114     rInfo.SetAccount(aDialog.GetAccount());
 115     rInfo.SetIsRememberPassword(aDialog.IsSavePassword());
 116
 117     if ( bCanUseSysCreds )
 118       rInfo.SetIsUseSystemCredentials( aDialog.IsUseSystemCredentials() );
 119 }
 120
 121 void getRememberModes(
 122     uno::Sequence< ucb::RememberAuthentication > const & rRememberModes,
 123     ucb::RememberAuthentication & rPreferredMode,
 124     ucb::RememberAuthentication & rAlternateMode )
 125 {
 126     sal_Int32 nCount = rRememberModes.getLength();
 127     OSL_ENSURE( (nCount > 0) && (nCount < 4),
 128                 "ucb::RememberAuthentication sequence size mismatch!" );
 129     if ( nCount == 1 )
 130     {
 131         rPreferredMode = rAlternateMode = rRememberModes[ 0 ];
 132         return;
 133     }
 134     else
 135     {
 136         bool bHasRememberModeSession = false;
 137         bool bHasRememberModePersistent = false;
 138
 139         for (sal_Int32 i = 0; i < nCount; ++i)
 140         {
 141             switch ( rRememberModes[i] )
 142             {
 143             case ucb::RememberAuthentication_NO:
 144                 break;
 145             case ucb::RememberAuthentication_SESSION:
 146                 bHasRememberModeSession = true;
 147                 break;
 148             case ucb::RememberAuthentication_PERSISTENT:
 149                 bHasRememberModePersistent = true;
 150                 break;
 151             default:
 152                 SAL_WARN( "uui", "Unsupported RememberAuthentication value" << static_cast<sal_Int32>(rRememberModes[i]) );
 153                 break;
 154             }
 155         }
 156
 157         if (bHasRememberModePersistent)
 158         {
 159             rPreferredMode = ucb::RememberAuthentication_PERSISTENT;
 160             if (bHasRememberModeSession)
 161                 rAlternateMode = ucb::RememberAuthentication_SESSION;
 162             else
 163                 rAlternateMode = ucb::RememberAuthentication_NO;
 164         }
 165         else
 166         {
 167             rPreferredMode = ucb::RememberAuthentication_SESSION;
 168             rAlternateMode = ucb::RememberAuthentication_NO;
 169         }
 170     }
 171 }
 172
 173 void
 174 handleAuthenticationRequest_(
 175     weld::Window * pParent,
 176     uno::Reference< task::XInteractionHandler2 > const & xIH,
 177     uno::Reference< uno::XComponentContext > const & xContext,
 178     ucb::AuthenticationRequest const & rRequest,
 179     uno::Sequence< uno::Reference< task::XInteractionContinuation > > const &
 180         rContinuations,
 181     const OUString & rURL)
 182 {
 183     uno::Reference< task::XInteractionRetry > xRetry;
 184     uno::Reference< task::XInteractionAbort > xAbort;
 185     uno::Reference< ucb::XInteractionSupplyAuthentication >
 186         xSupplyAuthentication;
 187     uno::Reference< ucb::XInteractionSupplyAuthentication2 >
 188         xSupplyAuthentication2;
 189     getContinuations(rContinuations, &xRetry, &xAbort, &xSupplyAuthentication);
 190     if (xSupplyAuthentication.is())
 191         xSupplyAuthentication2.set(xSupplyAuthentication, uno::UNO_QUERY);
 192
 193
 194     // First, try to obtain credentials from password container service.
 195     uui::PasswordContainerHelper aPwContainerHelper(xContext);
 196     if (aPwContainerHelper.handleAuthenticationRequest(rRequest,
 197                                                        xSupplyAuthentication,
 198                                                        rURL,
 199                                                        xIH))
 200     {
 201         xSupplyAuthentication->select();
 202         return;
 203     }
 204
 205
 206     // Second, try to obtain credentials from user via password dialog.
 207     ucb::RememberAuthentication eDefaultRememberMode
 208         = ucb::RememberAuthentication_SESSION;
 209     ucb::RememberAuthentication ePreferredRememberMode
 210         = eDefaultRememberMode;
 211     ucb::RememberAuthentication eAlternateRememberMode
 212         = ucb::RememberAuthentication_NO;
 213
 214     if (xSupplyAuthentication.is())
 215     {
 216         getRememberModes(
 217             xSupplyAuthentication->getRememberPasswordModes(
 218                 eDefaultRememberMode),
 219             ePreferredRememberMode,
 220             eAlternateRememberMode);
 221     }
 222
 223     bool bCanUseSystemCredentials;
 224     sal_Bool bDefaultUseSystemCredentials;
 225     if (xSupplyAuthentication2.is())
 226     {
 227         bCanUseSystemCredentials
 228             = xSupplyAuthentication2->canUseSystemCredentials(
 229                 bDefaultUseSystemCredentials);
 230     }
 231     else
 232     {
 233         bCanUseSystemCredentials = false;
 234         bDefaultUseSystemCredentials = false;
 235     }
 236
 237     LoginErrorInfo aInfo;
 238     aInfo.SetTitle(rRequest.ServerName);
 239     aInfo.SetServer(rRequest.ServerName);
 240     if (rRequest.HasAccount)
 241         aInfo.SetAccount(rRequest.Account);
 242     if (rRequest.HasUserName)
 243         aInfo.SetUserName(rRequest.UserName);
 244     if (rRequest.HasPassword)
 245         aInfo.SetPassword(rRequest.Password);
 246     aInfo.SetErrorText(rRequest.Diagnostic);
 247
 248     aInfo.SetCanRememberPassword(
 249         ePreferredRememberMode != eAlternateRememberMode);
 250     aInfo.SetIsRememberPassword(
 251         ePreferredRememberMode == eDefaultRememberMode);
 252     aInfo.SetIsRememberPersistent(
 253         ePreferredRememberMode == ucb::RememberAuthentication_PERSISTENT);
 254
 255     aInfo.SetCanUseSystemCredentials(bCanUseSystemCredentials);
 256     aInfo.SetIsUseSystemCredentials( bDefaultUseSystemCredentials );
 257     aInfo.SetModifyAccount(rRequest.HasAccount
 258                            && xSupplyAuthentication.is()
 259                            && xSupplyAuthentication->canSetAccount());
 260     aInfo.SetModifyUserName(rRequest.HasUserName
 261                             && xSupplyAuthentication.is()
 262                             && xSupplyAuthentication->canSetUserName());
 263     executeLoginDialog(pParent,
 264                        aInfo,
 265                        rRequest.HasRealm ? rRequest.Realm : OUString());
 266     switch (aInfo.GetResult())
 267     {
 268     case DialogMask::ButtonsOk:
 269         if (xSupplyAuthentication.is())
 270         {
 271             if (xSupplyAuthentication->canSetUserName())
 272                 xSupplyAuthentication->setUserName(aInfo.GetUserName());
 273             if (xSupplyAuthentication->canSetPassword())
 274                 xSupplyAuthentication->setPassword(aInfo.GetPassword());
 275
 276             if (ePreferredRememberMode != eAlternateRememberMode)
 277             {
 278                 // user had the choice.
 279                 if (aInfo.GetIsRememberPassword())
 280                     xSupplyAuthentication->setRememberPassword(
 281                         ePreferredRememberMode);
 282                 else
 283                     xSupplyAuthentication->setRememberPassword(
 284                         eAlternateRememberMode);
 285             }
 286             else
 287             {
 288                 // user had no choice.
 289                 xSupplyAuthentication->setRememberPassword(
 290                     ePreferredRememberMode);
 291             }
 292
 293             if (rRequest.HasRealm)
 294             {
 295                 if (xSupplyAuthentication->canSetRealm())
 296                     xSupplyAuthentication->setRealm(aInfo.GetAccount());
 297             }
 298             else if (xSupplyAuthentication->canSetAccount())
 299                 xSupplyAuthentication->setAccount(aInfo.GetAccount());
 300
 301             if ( xSupplyAuthentication2.is() && bCanUseSystemCredentials )
 302                 xSupplyAuthentication2->setUseSystemCredentials(
 303                     aInfo.GetIsUseSystemCredentials() );
 304
 305             xSupplyAuthentication->select();
 306         }
 307
 308
 309         // Third, store credentials in password container.
 310
 311           if ( aInfo.GetIsUseSystemCredentials() )
 312           {
 313               if (aInfo.GetIsRememberPassword())
 314               {
 315                   if (!aPwContainerHelper.addRecord(
 316                           !rURL.isEmpty() ? rURL : rRequest.ServerName,
 317                           OUString(), // empty u/p -> sys creds
 318                           uno::Sequence< OUString >(),
 319                           xIH,
 320                           ePreferredRememberMode
 321                               == ucb::RememberAuthentication_PERSISTENT))
 322                   {
 323                       xSupplyAuthentication->setRememberPassword(
 324                           ucb::RememberAuthentication_NO);
 325                   }
 326               }
 327               else if (eAlternateRememberMode
 328                            == ucb::RememberAuthentication_SESSION)
 329               {
 330                   if (!aPwContainerHelper.addRecord(
 331                           !rURL.isEmpty() ? rURL : rRequest.ServerName,
 332                           OUString(), // empty u/p -> sys creds
 333                           uno::Sequence< OUString >(),
 334                           xIH,
 335                           false /* SESSION */))
 336                   {
 337                       xSupplyAuthentication->setRememberPassword(
 338                           ucb::RememberAuthentication_NO);
 339                   }
 340               }
 341           }
 342           // Empty user name can not be valid:
 343           else if (!aInfo.GetUserName().isEmpty())
 344           {
 345               uno::Sequence< OUString >
 346                   aPassList(aInfo.GetAccount().isEmpty() ? 1 : 2);
 347               aPassList[0] = aInfo.GetPassword();
 348               if (!aInfo.GetAccount().isEmpty())
 349                   aPassList[1] = aInfo.GetAccount();
 350
 351               if (aInfo.GetIsRememberPassword())
 352               {
 353                   if (!aPwContainerHelper.addRecord(
 354                           !rURL.isEmpty() ? rURL : rRequest.ServerName,
 355                           aInfo.GetUserName(),
 356                           aPassList,
 357                           xIH,
 358                           ePreferredRememberMode
 359                               == ucb::RememberAuthentication_PERSISTENT))
 360                   {
 361                       xSupplyAuthentication->setRememberPassword(
 362                           ucb::RememberAuthentication_NO);
 363                   }
 364               }
 365               else if (eAlternateRememberMode
 366                            == ucb::RememberAuthentication_SESSION)
 367               {
 368                   if (!aPwContainerHelper.addRecord(
 369                           !rURL.isEmpty() ? rURL : rRequest.ServerName,
 370                           aInfo.GetUserName(),
 371                           aPassList,
 372                           xIH,
 373                           false /* SESSION */))
 374                   {
 375                       xSupplyAuthentication->setRememberPassword(
 376                           ucb::RememberAuthentication_NO);
 377                   }
 378               }
 379           }
 380           break;
 381
 382     case DialogMask::ButtonsRetry:
 383         if (xRetry.is())
 384             xRetry->select();
 385         break;
 386
 387     default:
 388         if (xAbort.is())
 389             xAbort->select();
 390         break;
 391     }
 392 }
 393
 394 void
 395 executeMasterPasswordDialog(
 396     weld::Window* pParent,
 397     LoginErrorInfo & rInfo,
 398     task::PasswordRequestMode nMode)
 399 {
 400     OString aMaster;
 401     {
 402         SolarMutexGuard aGuard;
 403
 404         std::locale aResLocale(Translate::Create("uui"));
 405         if( nMode == task::PasswordRequestMode_PASSWORD_CREATE )
 406         {
 407             MasterPasswordCreateDialog aDialog(pParent, aResLocale);
 408             rInfo.SetResult(aDialog.run()
 409                 == RET_OK ? DialogMask::ButtonsOk : DialogMask::ButtonsCancel);
 410             aMaster = OUStringToOString(
 411                 aDialog.GetMasterPassword(), RTL_TEXTENCODING_UTF8);
 412         }
 413         else
 414         {
 415             MasterPasswordDialog aDialog(pParent, nMode, aResLocale);
 416             rInfo.SetResult(aDialog.run()
 417                 == RET_OK ? DialogMask::ButtonsOk : DialogMask::ButtonsCancel);
 418             aMaster = OUStringToOString(
 419                 aDialog.GetMasterPassword(), RTL_TEXTENCODING_UTF8);
 420         }
 421     }
 422
 423     sal_uInt8 aKey[RTL_DIGEST_LENGTH_MD5];
 424     // FIXME this is subject to the SHA1-bug tdf#114939 - but this
 425     // MasterPassword stuff is just stored in the UserInstallation,
 426     // so no interop concerns
 427     rtl_digest_PBKDF2(aKey,
 428                       RTL_DIGEST_LENGTH_MD5,
 429                       reinterpret_cast< sal_uInt8 const * >(aMaster.getStr()),
 430                       aMaster.getLength(),
 431                       reinterpret_cast< sal_uInt8 const * >(
 432                           "3B5509ABA6BC42D9A3A1F3DAD49E56A51"),
 433                       32,
 434                       1000);
 435
 436     OUStringBuffer aBuffer;
 437     for (sal_uInt8 i : aKey)
 438     {
 439         aBuffer.append(static_cast< sal_Unicode >('a' + (i >> 4)));
 440         aBuffer.append(static_cast< sal_Unicode >('a' + (i & 15)));
 441     }
 442     rInfo.SetPassword(aBuffer.makeStringAndClear());
 443 }
 444
 445 void
 446 handleMasterPasswordRequest_(
 447     weld::Window * pParent,
 448     task::PasswordRequestMode nMode,
 449     uno::Sequence< uno::Reference< task::XInteractionContinuation > > const &
 450         rContinuations)
 451 {
 452     uno::Reference< task::XInteractionRetry > xRetry;
 453     uno::Reference< task::XInteractionAbort > xAbort;
 454     uno::Reference< ucb::XInteractionSupplyAuthentication >
 455         xSupplyAuthentication;
 456     getContinuations(rContinuations, &xRetry, &xAbort, &xSupplyAuthentication);
 457     LoginErrorInfo aInfo;
 458
 459     // in case of master password a hash code is returned
 460     executeMasterPasswordDialog(pParent, aInfo, nMode);
 461
 462     switch (aInfo.GetResult())
 463     {
 464     case DialogMask::ButtonsOk:
 465         if (xSupplyAuthentication.is())
 466         {
 467             if (xSupplyAuthentication->canSetPassword())
 468                 xSupplyAuthentication->setPassword(aInfo.GetPassword());
 469             xSupplyAuthentication->select();
 470         }
 471         break;
 472
 473     case DialogMask::ButtonsRetry:
 474         if (xRetry.is())
 475             xRetry->select();
 476         break;
 477
 478     default:
 479         if (xAbort.is())
 480             xAbort->select();
 481         break;
 482     }
 483 }
 484
 485 void
 486 executePasswordDialog(
 487     weld::Window * pParent,
 488     LoginErrorInfo & rInfo,
 489     task::PasswordRequestMode nMode,
 490     const OUString& aDocName,
 491     bool bMSCryptoMode,
 492     bool bIsPasswordToModify,
 493     bool bIsSimplePasswordRequest )
 494 {
 495     SolarMutexGuard aGuard;
 496
 497     std::locale aResLocale(Translate::Create("uui"));
 498     if( nMode == task::PasswordRequestMode_PASSWORD_CREATE )
 499     {
 500         if (bIsSimplePasswordRequest)
 501         {
 502             std::unique_ptr<PasswordDialog> xDialog(new PasswordDialog(pParent, nMode,
 503                 aResLocale, aDocName, bIsPasswordToModify, bIsSimplePasswordRequest));
 504             xDialog->SetMinLen(0);
 505
 506             rInfo.SetResult(xDialog->run() == RET_OK ? DialogMask::ButtonsOk : DialogMask::ButtonsCancel);
 507             rInfo.SetPassword(xDialog->GetPassword());
 508         }
 509         else
 510         {
 511             const sal_uInt16 nMaxPasswdLen = bMSCryptoMode ? 15 : 0;   // 0 -> allow any length
 512
 513             VclAbstractDialogFactory * pFact = VclAbstractDialogFactory::Create();
 514             ScopedVclPtr<AbstractPasswordToOpenModifyDialog> const pDialog(
 515                 pFact->CreatePasswordToOpenModifyDialog(pParent, nMaxPasswdLen, bIsPasswordToModify));
 516
 517             rInfo.SetResult( pDialog->Execute() == RET_OK ? DialogMask::ButtonsOk : DialogMask::ButtonsCancel );
 518             rInfo.SetPassword( pDialog->GetPasswordToOpen() );
 519             rInfo.SetPasswordToModify( pDialog->GetPasswordToModify() );
 520             rInfo.SetRecommendToOpenReadonly( pDialog->IsRecommendToOpenReadonly() );
 521         }
 522     }
 523     else // enter password or reenter password
 524     {
 525         std::unique_ptr<PasswordDialog> xDialog(new PasswordDialog(pParent, nMode,
 526             aResLocale, aDocName, bIsPasswordToModify, bIsSimplePasswordRequest));
 527         xDialog->SetMinLen(0);
 528
 529         rInfo.SetResult(xDialog->run() == RET_OK ? DialogMask::ButtonsOk : DialogMask::ButtonsCancel);
 530         rInfo.SetPassword(bIsPasswordToModify ? OUString() : xDialog->GetPassword());
 531         rInfo.SetPasswordToModify(bIsPasswordToModify ? xDialog->GetPassword() : OUString());
 532     }
 533 }
 534
 535 void
 536 handlePasswordRequest_(
 537     weld::Window * pParent,
 538     task::PasswordRequestMode nMode,
 539     uno::Sequence< uno::Reference< task::XInteractionContinuation > > const &
 540         rContinuations,
 541     const OUString& aDocumentName,
 542     bool bMSCryptoMode,
 543     bool bIsPasswordToModify,
 544     bool bIsSimplePasswordRequest = false )
 545 {
 546     uno::Reference< task::XInteractionRetry > xRetry;
 547     uno::Reference< task::XInteractionAbort > xAbort;
 548     uno::Reference< task::XInteractionPassword > xPassword;
 549     uno::Reference< task::XInteractionPassword2 > xPassword2;
 550     getContinuations(rContinuations, &xRetry, &xAbort, &xPassword2, &xPassword);
 551
 552     if ( xPassword2.is() && !xPassword.is() )
 553         xPassword.set( xPassword2, uno::UNO_QUERY_THROW );
 554
 555     LoginErrorInfo aInfo;
 556
 557     executePasswordDialog( pParent, aInfo, nMode,
 558             aDocumentName, bMSCryptoMode, bIsPasswordToModify, bIsSimplePasswordRequest );
 559
 560     switch (aInfo.GetResult())
 561     {
 562     case DialogMask::ButtonsOk:
 563         OSL_ENSURE( !bIsPasswordToModify || xPassword2.is(), "PasswordToModify is requested, but there is no Interaction!" );
 564         if (xPassword.is())
 565         {
 566             if (xPassword2.is())
 567             {
 568                 xPassword2->setPasswordToModify( aInfo.GetPasswordToModify() );
 569                 xPassword2->setRecommendReadOnly( aInfo.IsRecommendToOpenReadonly() );
 570             }
 571
 572             xPassword->setPassword(aInfo.GetPassword());
 573             xPassword->select();
 574         }
 575         break;
 576
 577     case DialogMask::ButtonsRetry:
 578         if (xRetry.is())
 579             xRetry->select();
 580         break;
 581
 582     default:
 583         if (xAbort.is())
 584             xAbort->select();
 585         break;
 586     }
 587 }
 588
 589 } // namespace
 590
 591 bool
 592 UUIInteractionHelper::handleAuthenticationRequest(
 593     uno::Reference< task::XInteractionRequest > const & rRequest)
 594 {
 595     uno::Any aAnyRequest(rRequest->getRequest());
 596     uno::Reference<awt::XWindow> xParent = getParentXWindow();
 597
 598     ucb::URLAuthenticationRequest aURLAuthenticationRequest;
 599     if (aAnyRequest >>= aURLAuthenticationRequest)
 600     {
 601         handleAuthenticationRequest_(Application::GetFrameWeld(xParent),
 602                                      getInteractionHandler(),
 603                                      m_xContext,
 604                                      aURLAuthenticationRequest,
 605                                      rRequest->getContinuations(),
 606                                      aURLAuthenticationRequest.URL);
 607         return true;
 608     }
 609
 610     ucb::AuthenticationRequest aAuthenticationRequest;
 611     if (aAnyRequest >>= aAuthenticationRequest)
 612     {
 613         handleAuthenticationRequest_(Application::GetFrameWeld(xParent),
 614                                      getInteractionHandler(),
 615                                      m_xContext,
 616                                      aAuthenticationRequest,
 617                                      rRequest->getContinuations(),
 618                                      OUString());
 619         return true;
 620     }
 621     return false;
 622 }
 623
 624 bool
 625 UUIInteractionHelper::handleMasterPasswordRequest(
 626     uno::Reference< task::XInteractionRequest > const & rRequest)
 627 {
 628     uno::Any aAnyRequest(rRequest->getRequest());
 629
 630     task::MasterPasswordRequest aMasterPasswordRequest;
 631     if (aAnyRequest >>= aMasterPasswordRequest)
 632     {
 633         uno::Reference<awt::XWindow> xParent = getParentXWindow();
 634
 635         handleMasterPasswordRequest_(Application::GetFrameWeld(xParent),
 636                                      aMasterPasswordRequest.Mode,
 637                                      rRequest->getContinuations());
 638         return true;
 639     }
 640     return false;
 641 }
 642
 643 bool
 644 UUIInteractionHelper::handlePasswordRequest(
 645     uno::Reference< task::XInteractionRequest > const & rRequest)
 646 {
 647     // parameters to be filled for the call to handlePasswordRequest_
 648     uno::Reference<awt::XWindow> xParent = getParentXWindow();
 649     task::PasswordRequestMode nMode = task::PasswordRequestMode_PASSWORD_ENTER;
 650     uno::Sequence< uno::Reference< task::XInteractionContinuation > > const & rContinuations = rRequest->getContinuations();
 651     OUString aDocumentName;
 652     bool bMSCryptoMode          = false;
 653     bool bIsPasswordToModify    = false;
 654
 655     bool bDoHandleRequest = false;
 656
 657     uno::Any aAnyRequest(rRequest->getRequest());
 658
 659     task::DocumentPasswordRequest2 aDocumentPasswordRequest2;
 660     if (!bDoHandleRequest && (aAnyRequest >>= aDocumentPasswordRequest2))
 661     {
 662         nMode               = aDocumentPasswordRequest2.Mode;
 663         aDocumentName       = aDocumentPasswordRequest2.Name;
 664         OSL_ENSURE( !bMSCryptoMode, "bMSCryptoMode should be false" );
 665         bIsPasswordToModify = aDocumentPasswordRequest2.IsRequestPasswordToModify;
 666
 667         bDoHandleRequest = true;
 668     }
 669
 670     task::DocumentPasswordRequest aDocumentPasswordRequest;
 671     if (!bDoHandleRequest && (aAnyRequest >>= aDocumentPasswordRequest))
 672     {
 673         nMode               = aDocumentPasswordRequest.Mode;
 674         aDocumentName       = aDocumentPasswordRequest.Name;
 675         OSL_ENSURE( !bMSCryptoMode, "bMSCryptoMode should be false" );
 676         OSL_ENSURE( !bIsPasswordToModify, "bIsPasswordToModify should be false" );
 677
 678         bDoHandleRequest = true;
 679     }
 680
 681     task::DocumentMSPasswordRequest2 aDocumentMSPasswordRequest2;
 682     if (!bDoHandleRequest && (aAnyRequest >>= aDocumentMSPasswordRequest2))
 683     {
 684         nMode               = aDocumentMSPasswordRequest2.Mode;
 685         aDocumentName       = aDocumentMSPasswordRequest2.Name;
 686         bMSCryptoMode       = true;
 687         bIsPasswordToModify = aDocumentMSPasswordRequest2.IsRequestPasswordToModify;
 688
 689         bDoHandleRequest = true;
 690     }
 691
 692     task::DocumentMSPasswordRequest aDocumentMSPasswordRequest;
 693     if (!bDoHandleRequest && (aAnyRequest >>= aDocumentMSPasswordRequest))
 694     {
 695         nMode               = aDocumentMSPasswordRequest.Mode;
 696         aDocumentName       = aDocumentMSPasswordRequest.Name;
 697         bMSCryptoMode       = true;
 698         OSL_ENSURE( !bIsPasswordToModify, "bIsPasswordToModify should be false" );
 699
 700         bDoHandleRequest = true;
 701     }
 702
 703     if (bDoHandleRequest)
 704     {
 705         handlePasswordRequest_( Application::GetFrameWeld(xParent), nMode, rContinuations,
 706                 aDocumentName, bMSCryptoMode, bIsPasswordToModify );
 707         return true;
 708     }
 709
 710     task::PasswordRequest aPasswordRequest;
 711     if( aAnyRequest >>= aPasswordRequest )
 712     {
 713         handlePasswordRequest_(Application::GetFrameWeld(xParent),
 714                                aPasswordRequest.Mode,
 715                                rRequest->getContinuations(),
 716                                OUString(),
 717                                false /* bool bMSCryptoMode */,
 718                                false /* bool bIsPasswordToModify */,
 719                                true  /* bool bIsSimplePasswordRequest */ );
 720         return true;
 721     }
 722
 723     return false;
 724 }
 725
 726 bool
 727 UUIInteractionHelper::handleAuthFallbackRequest( OUString & instructions,
 728         OUString & url,
 729         uno::Sequence< uno::Reference< task::XInteractionContinuation > > const & rContinuations )
 730 {
 731     uno::Reference<awt::XWindow> xParent = getParentXWindow();
 732     AuthFallbackDlg dlg(Application::GetFrameWeld(xParent), instructions, url);
 733     int retCode = dlg.run();
 734     uno::Reference< task::XInteractionAbort > xAbort;
 735     uno::Reference< ucb::XInteractionAuthFallback > xAuthFallback;
 736     getContinuations(rContinuations, &xAbort, &xAuthFallback);
 737
 738     if( retCode == RET_OK && xAuthFallback.is( ) )
 739     {
 740         xAuthFallback->setCode(dlg.GetCode());
 741         xAuthFallback->select( );
 742     }
 743
 744     return true;
 745 }
 746
 747 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */