extensions/source/update/check/updatecheck.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 <sal/config.h>
  21
  22 #include <string_view>
  23
  24 #include <comphelper/scopeguard.hxx>
  25 #include <config_folders.h>
  26
  27 #include "updatecheck.hxx"
  28
  29 #include <cppuhelper/implbase.hxx>
  30 #include <com/sun/star/beans/XFastPropertySet.hpp>
  31 #include <com/sun/star/deployment/UpdateInformationProvider.hpp>
  32 #include <com/sun/star/frame/Desktop.hpp>
  33 #include <com/sun/star/office/Quickstart.hpp>
  34 #include <com/sun/star/system/SystemShellExecute.hpp>
  35 #include <com/sun/star/system/SystemShellExecuteException.hpp>
  36 #include <com/sun/star/system/SystemShellExecuteFlags.hpp>
  37 #include <com/sun/star/task/XJob.hpp>
  38 #include <com/sun/star/task/XJobExecutor.hpp>
  39
  40 #include <rtl/bootstrap.hxx>
  41 #include <osl/process.h>
  42 #include <osl/file.hxx>
  43 #include <sal/macros.h>
  44 #include <sal/log.hxx>
  45 #include <comphelper/diagnose_ex.hxx>
  46
  47 #ifdef _WIN32
  48 #include <o3tl/safeCoInitUninit.hxx>
  49 #include <objbase.h>
  50 #endif
  51
  52 #include "onlinecheck.hxx"
  53 #include "updateprotocol.hxx"
  54 #include "updatecheckconfig.hxx"
  55
  56 namespace beans = css::beans ;
  57 namespace deployment = css::deployment ;
  58 namespace lang = css::lang ;
  59 namespace c3s = css::system ;
  60 namespace task = css::task ;
  61 namespace uno = css::uno ;
  62
  63 constexpr OUStringLiteral PROPERTY_TITLE = u"BubbleHeading";
  64 constexpr OUStringLiteral PROPERTY_TEXT = u"BubbleText";
  65 constexpr OUStringLiteral PROPERTY_SHOW_BUBBLE = u"BubbleVisible";
  66 constexpr OUStringLiteral PROPERTY_CLICK_HDL = u"MenuClickHDL";
  67 constexpr OUString PROPERTY_SHOW_MENUICON = u"MenuIconVisible"_ustr;
  68
  69 // Returns the URL of the release note for the given position
  70 OUString getReleaseNote(const UpdateInfo& rInfo, sal_uInt8 pos, bool autoDownloadEnabled)
  71 {
  72     for (auto const& elem : rInfo.ReleaseNotes)
  73     {
  74         if( pos == elem.Pos )
  75         {
  76             if( (pos > 2) || !autoDownloadEnabled || elem.URL2.isEmpty() )
  77                 return elem.URL;
  78         }
  79         else if( (pos == elem.Pos2) && ((1 == elem.Pos) || (2 == elem.Pos)) && autoDownloadEnabled )
  80             return elem.URL2;
  81     }
  82
  83     return OUString();
  84 }
  85
  86
  87 namespace
  88 {
  89
  90 OUString getBuildId()
  91 {
  92     OUString aPathVal(u"${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("version") ":buildid}"_ustr);
  93     rtl::Bootstrap::expandMacros(aPathVal);
  94     return aPathVal;
  95 }
  96
  97
  98 bool isObsoleteUpdateInfo(std::u16string_view rBuildId)
  99 {
 100     return rBuildId != getBuildId() && !rBuildId.empty();
 101 }
 102
 103
 104 OUString getImageFromFileName(const OUString& aFile)
 105 {
 106 #ifndef _WIN32
 107     OUString aUnpackPath;
 108     if( osl_getExecutableFile(&aUnpackPath.pData) == osl_Process_E_None )
 109     {
 110         sal_uInt32 lastIndex = aUnpackPath.lastIndexOf('/');
 111         if ( lastIndex > 0 )
 112         {
 113             aUnpackPath = OUString::Concat(aUnpackPath.subView( 0, lastIndex+1 )) +
 114                 "unpack_update";
 115         }
 116
 117         oslFileHandle hOut = nullptr;
 118         oslProcess hProcess = nullptr;
 119
 120         OUString aSystemPath;
 121         osl::File::getSystemPathFromFileURL(aFile, aSystemPath);
 122
 123         oslProcessError rc = osl_executeProcess_WithRedirectedIO(
 124             aUnpackPath.pData,                                  // [in] Image name
 125             &aSystemPath.pData, 1,                              // [in] Arguments
 126             osl_Process_WAIT | osl_Process_NORMAL,              // [in] Options
 127             nullptr,                                               // [in] Security
 128             nullptr,                                               // [in] Working directory
 129             nullptr, 0,                                            // [in] Environment variables
 130             &hProcess,                                          // [out] Process handle
 131             nullptr, &hOut, nullptr                                   // [out] File handles for redirected I/O
 132         );
 133
 134         if( osl_Process_E_None == rc )
 135         {
 136             // Create a guard to ensure correct cleanup in its dtor in any case
 137             comphelper::ScopeGuard g([hOut, hProcess] () {
 138                 osl_closeFile(hOut);
 139                 osl_freeProcessHandle(hProcess);
 140             });
 141
 142             oslProcessInfo aInfo;
 143             aInfo.Size = sizeof(oslProcessInfo);
 144
 145             if( osl_Process_E_None == osl_getProcessInfo(hProcess, osl_Process_EXITCODE, &aInfo) )
 146             {
 147                 if( 0 == aInfo.Code )
 148                 {
 149                     char       szBuffer[4096];
 150                     sal_uInt64 nBytesRead = 0;
 151                     const sal_uInt64 nBytesToRead = sizeof(szBuffer) - 1;
 152
 153                     OUString aImageName;
 154                     while( osl_File_E_None == osl_readFile(hOut, szBuffer, nBytesToRead, &nBytesRead) )
 155                     {
 156                         char *pc = szBuffer + nBytesRead;
 157                         do
 158                         {
 159                             *pc = '\0'; --pc;
 160                         }
 161                         while( ('\n' == *pc) || ('\r' == *pc) );
 162
 163                         aImageName += OUString(szBuffer, pc - szBuffer + 1, osl_getThreadTextEncoding());
 164
 165                         if( nBytesRead < nBytesToRead )
 166                             break;
 167                     }
 168
 169                     if( osl::FileBase::E_None == osl::FileBase::getFileURLFromSystemPath(aImageName, aImageName) )
 170                         return aImageName;
 171                 }
 172             }
 173         }
 174     }
 175 #endif
 176
 177     return aFile;
 178 }
 179
 180
 181 uno::Reference< beans::XPropertySet > createMenuBarUI(
 182     const uno::Reference< uno::XComponentContext >& xContext,
 183     const uno::Reference< task::XJob >& xJob)
 184 {
 185     if( !xContext.is() )
 186         throw uno::RuntimeException(
 187             u"UpdateCheckJob: empty component context"_ustr, uno::Reference< uno::XInterface > () );
 188
 189     uno::Reference< lang::XMultiComponentFactory > xServiceManager(xContext->getServiceManager());
 190     if( !xServiceManager.is() )
 191         throw uno::RuntimeException(
 192             u"UpdateCheckJob: unable to obtain service manager from component context"_ustr, uno::Reference< uno::XInterface > () );
 193
 194     uno::Reference< beans::XPropertySet > xMenuBarUI(
 195             xServiceManager->createInstanceWithContext( u"com.sun.star.setup.UpdateCheckUI"_ustr, xContext ),
 196             uno::UNO_QUERY_THROW);
 197
 198     xMenuBarUI->setPropertyValue( PROPERTY_CLICK_HDL, uno::Any( xJob ) );
 199
 200     return xMenuBarUI;
 201 }
 202
 203
 204 typedef sal_Bool (* OnlineCheckFunc) ();
 205
 206 class UpdateCheckThread : public WorkerThread
 207 {
 208
 209 public:
 210     UpdateCheckThread( osl::Condition& rCondition,
 211         const uno::Reference<uno::XComponentContext>& xContext,
 212         rtl::Reference<UpdateCheck> const & controller );
 213
 214     virtual void SAL_CALL join() override;
 215     virtual void SAL_CALL terminate() override;
 216     virtual void cancel() override;
 217
 218     void cancelAsSoonAsPossible();
 219
 220 protected:
 221     virtual ~UpdateCheckThread() override;
 222
 223     virtual void SAL_CALL run() override;
 224     virtual void SAL_CALL onTerminated() override;
 225
 226     /* Wrapper around checkForUpdates */
 227     bool runCheck( bool & rbExtensionsChecked );
 228
 229 private:
 230
 231     /* Used to avoid dialup login windows (on platforms we know how to double this) */
 232     static bool hasInternetConnection()
 233     {
 234 #ifdef _WIN32
 235         return WNT_hasInternetConnection();
 236 #else
 237         return true;
 238 #endif
 239     }
 240
 241     /* Creates a new instance of UpdateInformationProvider and returns this instance */
 242     uno::Reference<deployment::XUpdateInformationProvider> createProvider()
 243     {
 244         osl::MutexGuard aGuard(m_aMutex);
 245         m_xProvider = deployment::UpdateInformationProvider::create(m_xContext);
 246         return m_xProvider;
 247     };
 248
 249     /* Returns the remembered instance of UpdateInformationProvider if any */
 250     uno::Reference<deployment::XUpdateInformationProvider> getProvider()
 251         { osl::MutexGuard aGuard(m_aMutex); return m_xProvider; };
 252
 253     /* Releases the remembered instance of UpdateInformationProvider if any */
 254     void clearProvider()
 255         { osl::MutexGuard aGuard(m_aMutex); m_xProvider.clear(); };
 256
 257     osl::Mutex      m_aMutex;
 258
 259 protected:
 260     osl::Condition& m_aCondition;
 261
 262 private:
 263     const uno::Reference<uno::XComponentContext> m_xContext;
 264     uno::Reference<deployment::XUpdateInformationProvider> m_xProvider;
 265     rtl::Reference<UpdateCheck> m_controller;
 266     bool m_cancelAsSoonAsPossible;
 267 };
 268
 269
 270 class ManualUpdateCheckThread : public UpdateCheckThread
 271 {
 272 public:
 273     ManualUpdateCheckThread( osl::Condition& rCondition, const uno::Reference<uno::XComponentContext>& xContext ) :
 274         UpdateCheckThread(rCondition, xContext, {}) {};
 275
 276     virtual void SAL_CALL run() override;
 277 };
 278
 279
 280 class MenuBarButtonJob : public ::cppu::WeakImplHelper< task::XJob >
 281 {
 282 public:
 283     explicit MenuBarButtonJob(const rtl::Reference< UpdateCheck >& rUpdateCheck);
 284
 285     // XJob
 286     virtual uno::Any SAL_CALL execute(const uno::Sequence<beans::NamedValue>&) override;
 287
 288 private:
 289     rtl::Reference< UpdateCheck > m_aUpdateCheck;
 290 };
 291
 292 class DownloadThread :  public WorkerThread
 293 {
 294 public:
 295     DownloadThread(
 296         osl::Condition& rCondition,
 297         const uno::Reference<uno::XComponentContext>& xContext,
 298         const rtl::Reference< DownloadInteractionHandler >& rHandler,
 299         const OUString& rURL );
 300
 301     virtual void SAL_CALL run() override;
 302     virtual void cancel() override;
 303     virtual void SAL_CALL suspend() override;
 304     virtual void SAL_CALL onTerminated() override;
 305
 306 protected:
 307     virtual ~DownloadThread() override;
 308
 309 private:
 310     osl::Condition& m_aCondition;
 311     const uno::Reference<uno::XComponentContext> m_xContext;
 312     const OUString m_aURL;
 313     Download m_aDownload;
 314 };
 315
 316
 317
 318 UpdateCheckThread::UpdateCheckThread( osl::Condition& rCondition,
 319                                       const uno::Reference<uno::XComponentContext>& xContext,
 320                                       rtl::Reference<UpdateCheck> const & controller ) :
 321     m_aCondition(rCondition),
 322     m_xContext(xContext),
 323     m_controller(controller),
 324     m_cancelAsSoonAsPossible(false)
 325 {
 326     createSuspended();
 327
 328     // actually run the thread
 329     resume();
 330 }
 331
 332
 333 UpdateCheckThread::~UpdateCheckThread()
 334 {
 335 }
 336
 337
 338 void SAL_CALL
 339 UpdateCheckThread::terminate()
 340 {
 341     // Cancel potentially hanging http request ..
 342     cancel();
 343     // .. before terminating
 344     osl::Thread::terminate();
 345 }
 346
 347
 348 void SAL_CALL
 349 UpdateCheckThread::join()
 350 {
 351     uno::Reference< deployment::XUpdateInformationProvider > xProvider(getProvider());
 352
 353     // do not join during an update check until #i73893# is fixed
 354     if( ! xProvider.is() )
 355     {
 356         osl::Thread::join();
 357     }
 358 }
 359
 360
 361 void
 362 UpdateCheckThread::cancel()
 363 {
 364     uno::Reference< deployment::XUpdateInformationProvider > xProvider(getProvider());
 365
 366     if( xProvider.is() )
 367         xProvider->cancel();
 368 }
 369
 370 void UpdateCheckThread::cancelAsSoonAsPossible() {
 371     {
 372         osl::MutexGuard g(m_aMutex);
 373         m_cancelAsSoonAsPossible = true;
 374     }
 375     m_aCondition.set();
 376 }
 377
 378 bool
 379 UpdateCheckThread::runCheck( bool & rbExtensionsChecked )
 380 {
 381     bool ret = false;
 382     UpdateState eUIState = UPDATESTATE_NO_UPDATE_AVAIL;
 383
 384     UpdateInfo aInfo;
 385     rtl::Reference< UpdateCheck > aController(UpdateCheck::get());
 386
 387     if( checkForUpdates(aInfo, m_xContext, aController->getInteractionHandler(), createProvider()) )
 388     {
 389         aController->setUpdateInfo(aInfo);
 390         eUIState = UpdateCheck::getUIState(aInfo);
 391         ret = true;
 392     }
 393     else
 394         aController->setCheckFailedState();
 395
 396     // We will only look for extension updates, when there is no 'check for office updates' dialog open
 397     // and when there was no office update found
 398     if ( ( eUIState != UPDATESTATE_UPDATE_AVAIL ) &&
 399          ( eUIState != UPDATESTATE_UPDATE_NO_DOWNLOAD ) &&
 400          !aController->isDialogShowing() &&
 401          !rbExtensionsChecked )
 402     {
 403         bool bHasExtensionUpdates = checkForExtensionUpdates( m_xContext );
 404         aController->setHasExtensionUpdates( bHasExtensionUpdates );
 405         if ( bHasExtensionUpdates )
 406             aController->setUIState( UPDATESTATE_EXT_UPD_AVAIL );
 407         rbExtensionsChecked = true;
 408     }
 409
 410     // joining with this thread is safe again
 411     clearProvider();
 412     return ret;
 413 }
 414
 415
 416 void SAL_CALL
 417 UpdateCheckThread::onTerminated()
 418 {
 419     delete this;
 420 }
 421
 422
 423 void SAL_CALL
 424 UpdateCheckThread::run()
 425 {
 426     osl_setThreadName("UpdateCheckThread");
 427
 428     TimeValue systime;
 429     TimeValue nExtCheckTime;
 430     osl_getSystemTime( &nExtCheckTime );
 431
 432     osl::Condition::Result aResult = osl::Condition::result_timeout;
 433     TimeValue tv = { 10, 0 };
 434
 435     // Initial wait to avoid doing further time consuming tasks during start-up
 436     aResult = m_aCondition.wait(&tv);
 437     {
 438         osl::MutexGuard g(m_aMutex);
 439         if (m_cancelAsSoonAsPossible) {
 440             goto done;
 441         }
 442     }
 443
 444     try {
 445         bool bExtensionsChecked = false;
 446
 447         while( schedule() )
 448         {
 449             /* Use cases:
 450              *  a) manual check requested from auto check thread - "last check" should not be checked (one time)
 451              *     a1) manual check was requested in the middle of a running auto check,
 452              *         condition is set
 453              *     a2) manual check was requested while waiting for a retry,
 454              *         condition is set
 455              *     a3) manual check was requested while waiting for time to next
 456              *         scheduled check elapsing, condition is set
 457              *     a4) manual check was requested during initial wait, condition is set
 458              *  b) check interval got changed, condition may be set - same sub-cases as a),
 459              *     but "last check" should be honored
 460              *  c) normal auto check mode, condition not set - "last check" should be honored
 461              */
 462
 463             // Accessing const members without synchronization
 464             rtl::Reference< UpdateCheck > aController(UpdateCheck::get());
 465             rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext, *aController);
 466
 467             // FIXME: remember last & offset ?
 468             sal_Int64 last   = rModel->getLastChecked();
 469             sal_Int64 offset = rModel->getCheckInterval();
 470
 471             rModel.clear();
 472
 473             // last == 0 means check immediately
 474             bool checkNow = last <= 0;
 475
 476             // Reset the condition to avoid busy loops
 477             if( osl::Condition::result_ok == aResult )
 478             {
 479                 m_aCondition.reset();
 480                 aResult = osl::Condition::result_timeout;
 481                 checkNow = aController->isDialogShowing();
 482             }
 483
 484             if( ! checkNow )
 485             {
 486                 osl_getSystemTime(&systime);
 487
 488                 // Go back to sleep until time has elapsed
 489                 sal_Int64 next = last + offset;
 490                 if( last + offset > systime.Seconds )
 491                 {
 492                     // This can not be > 32 Bit for now ..
 493                     tv.Seconds = static_cast< sal_Int32 > (next - systime.Seconds);
 494                     aResult = m_aCondition.wait(&tv);
 495                     {
 496                         osl::MutexGuard g(m_aMutex);
 497                         if (m_cancelAsSoonAsPossible) {
 498                             goto done;
 499                         }
 500                     }
 501                     continue;
 502                 }
 503             }
 504
 505             static sal_uInt8 n = 0;
 506
 507             if( ! hasInternetConnection() || ! runCheck( bExtensionsChecked ) )
 508             {
 509                 // the extension update check should be independent from the office update check
 510
 511                 osl_getSystemTime( &systime );
 512                 if ( nExtCheckTime.Seconds + offset < systime.Seconds )
 513                     bExtensionsChecked = false;
 514
 515                 // Increase next by 15, 60, .. minutes
 516                 static const sal_Int32 nRetryInterval[] = { 900, 3600, 14400, 86400 };
 517
 518                 if( n < std::size(nRetryInterval) )
 519                     ++n;
 520
 521                 tv.Seconds = nRetryInterval[n-1];
 522                 aResult = m_aCondition.wait(&tv);
 523                 {
 524                     osl::MutexGuard g(m_aMutex);
 525                     if (m_cancelAsSoonAsPossible) {
 526                         goto done;
 527                     }
 528                 }
 529             }
 530             else // reset retry counter
 531             {
 532                 n = 0;
 533                 bExtensionsChecked = false;
 534             }
 535         }
 536     }
 537
 538     catch(const uno::Exception&) {
 539         // Silently catch all errors
 540         TOOLS_WARN_EXCEPTION("extensions.update", "Caught exception, thread terminated" );
 541     }
 542
 543 done:
 544     if (m_controller.is()) {
 545         m_controller->notifyUpdateCheckFinished();
 546     }
 547 }
 548
 549
 550 void SAL_CALL
 551 ManualUpdateCheckThread::run()
 552 {
 553     try {
 554         bool bExtensionsChecked = false;
 555         runCheck( bExtensionsChecked );
 556         m_aCondition.reset();
 557     }
 558     catch(const uno::Exception&) {
 559         // Silently catch all errors
 560         TOOLS_WARN_EXCEPTION("extensions.update", "Caught exception, thread terminated" );
 561     }
 562 }
 563
 564
 565 MenuBarButtonJob::MenuBarButtonJob(const rtl::Reference< UpdateCheck >& rUpdateCheck) :
 566     m_aUpdateCheck(rUpdateCheck)
 567 {
 568 };
 569
 570
 571 uno::Any SAL_CALL
 572 MenuBarButtonJob::execute(const uno::Sequence<beans::NamedValue>& )
 573 {
 574     if ( m_aUpdateCheck->shouldShowExtUpdDlg() )
 575         m_aUpdateCheck->showExtensionDialog();
 576     else
 577         m_aUpdateCheck->showDialog();
 578
 579     return uno::Any();
 580 }
 581
 582
 583 DownloadThread::DownloadThread(osl::Condition& rCondition,
 584                                const uno::Reference<uno::XComponentContext>& xContext,
 585                                const rtl::Reference< DownloadInteractionHandler >& rHandler,
 586                                const OUString& rURL) :
 587     m_aCondition(rCondition),
 588     m_xContext(xContext),
 589     m_aURL(rURL),
 590     m_aDownload(xContext, rHandler)
 591 {
 592     createSuspended();
 593 }
 594
 595
 596 DownloadThread::~DownloadThread()
 597 {
 598 }
 599
 600
 601 void SAL_CALL
 602 DownloadThread::run()
 603 {
 604     osl_setThreadName("DownloadThread");
 605
 606 #ifdef _WIN32
 607     int nNbCallCoInitializeExForReinit = 0;
 608     // for SystemShellExecute
 609     o3tl::safeCoInitializeEx(COINIT_APARTMENTTHREADED, nNbCallCoInitializeExForReinit);
 610 #endif
 611
 612     while( schedule() )
 613     {
 614         rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext);
 615
 616         OUString aLocalFile = rModel->getLocalFileName();
 617         OUString aDownloadDest = rModel->getDownloadDestination();
 618
 619         // release config class for now
 620         rModel.clear();
 621
 622         static sal_uInt8 n = 0;
 623         if( ! m_aDownload.start(m_aURL, aLocalFile, aDownloadDest ) )
 624         {
 625             // retry every 15s unless the dialog is not visible
 626             TimeValue tv(15, 0);
 627
 628             if( ! UpdateCheck::get()->isDialogShowing() )
 629             {
 630                 // Increase next by 1, 5, 15, 60, .. minutes
 631                 static const sal_Int16 nRetryInterval[] = { 60, 300, 900, 3600 };
 632
 633                 if( n < std::size(nRetryInterval) )
 634                     ++n;
 635
 636                 tv.Seconds = nRetryInterval[n-1];
 637             }
 638             m_aCondition.wait(&tv);
 639         }
 640         else
 641         {
 642             // reset wait period after successful download
 643             n=0;
 644         }
 645     }
 646 #ifdef _WIN32
 647     o3tl::safeCoUninitializeReinit(COINIT_MULTITHREADED, nNbCallCoInitializeExForReinit);
 648 #endif
 649 }
 650
 651
 652 void DownloadThread::cancel()
 653 {
 654     m_aDownload.stop();
 655     resume();
 656
 657     rtl::Reference< UpdateCheck > aController(UpdateCheck::get());
 658     aController->cancelDownload();
 659 }
 660
 661
 662 void SAL_CALL DownloadThread::suspend()
 663 {
 664     osl::Thread::suspend();
 665     m_aDownload.stop();
 666 }
 667
 668
 669 void SAL_CALL DownloadThread::onTerminated()
 670 {
 671     delete this;
 672 }
 673
 674
 675 } // anonymous namespace
 676
 677 UpdateCheck::UpdateCheck()
 678     : m_eState(NOT_INITIALIZED)
 679     , m_eUpdateState(UPDATESTATES_COUNT)
 680     , m_pThread(nullptr)
 681     , m_bHasExtensionUpdate(false)
 682     , m_bShowExtUpdDlg(false)
 683     , m_updateCheckRunning(false)
 684 {
 685 }
 686
 687 UpdateCheck::~UpdateCheck() {}
 688
 689 void
 690 UpdateCheck::initialize(const uno::Sequence< beans::NamedValue >& rValues,
 691                         const uno::Reference<uno::XComponentContext>& xContext)
 692 {
 693     std::scoped_lock aGuard(m_aMutex);
 694
 695     if( NOT_INITIALIZED == m_eState )
 696     {
 697         NamedValueByNameAccess aNameAccess(rValues);
 698         UpdateCheckROModel aModel( aNameAccess );
 699         m_xContext = xContext;
 700
 701         OUString aUpdateEntryVersion = aModel.getUpdateEntryVersion();
 702
 703         aModel.getUpdateEntry(m_aUpdateInfo);
 704
 705         bool obsoleteUpdateInfo = isObsoleteUpdateInfo(aUpdateEntryVersion);
 706         bool bContinueDownload = false;
 707         bool bDownloadAvailable = false;
 708
 709         m_bHasExtensionUpdate = checkForPendingUpdates( xContext );
 710         m_bShowExtUpdDlg = false;
 711
 712         OUString aLocalFileName = aModel.getLocalFileName();
 713
 714         if( !aLocalFileName.isEmpty() )
 715         {
 716             bContinueDownload = true;
 717
 718             // Try to get the number of bytes already on disk
 719             osl::DirectoryItem aDirectoryItem;
 720             if( osl::DirectoryItem::E_None == osl::DirectoryItem::get(aLocalFileName, aDirectoryItem) )
 721             {
 722                 osl::FileStatus aFileStatus(osl_FileStatus_Mask_FileSize);
 723                 if( osl::DirectoryItem::E_None == aDirectoryItem.getFileStatus(aFileStatus) )
 724                 {
 725                     sal_Int64 nDownloadSize = aModel.getDownloadSize();
 726                     sal_Int64 nFileSize = aFileStatus.getFileSize();
 727
 728                     if( nDownloadSize > 0 )
 729                     {
 730                         if ( nDownloadSize <= nFileSize ) // we have already downloaded everything
 731                         {
 732                             bContinueDownload = false;
 733                             bDownloadAvailable = true;
 734                             m_aImageName = getImageFromFileName( aLocalFileName );
 735                         }
 736                         else // Calculate initial percent value.
 737                         {
 738                             sal_Int32 nPercent = static_cast<sal_Int32>(100 * nFileSize / nDownloadSize);
 739                             getUpdateHandler()->setProgress( nPercent );
 740                         }
 741                     }
 742                 }
 743             }
 744
 745             if ( bContinueDownload )
 746             {
 747                 bool downloadPaused = aModel.isDownloadPaused();
 748
 749                 enableDownload(true, downloadPaused);
 750                 // coverity[lock_order : FALSE] - incorrect report of lock order error with std::recursive_mutex
 751                 setUIState(downloadPaused ? UPDATESTATE_DOWNLOAD_PAUSED : UPDATESTATE_DOWNLOADING);
 752             }
 753
 754         }
 755         if ( !bContinueDownload )
 756         {
 757             // We do this intentionally only if no download is in progress ..
 758             if( obsoleteUpdateInfo )
 759             {
 760                 // Bring-up release note for position 5 ..
 761                 const OUString aURL(getReleaseNote(m_aUpdateInfo, 5));
 762                 if( !aURL.isEmpty() )
 763                     showReleaseNote(aURL);
 764
 765                 // Data is outdated, probably due to installed update
 766                 rtl::Reference< UpdateCheckConfig > aConfig = UpdateCheckConfig::get( xContext, *this );
 767                 aConfig->clearUpdateFound();
 768                 aConfig->clearLocalFileName();
 769
 770
 771                 m_aUpdateInfo = UpdateInfo();
 772                 // Remove outdated release notes
 773                 storeReleaseNote( 1, OUString() );
 774                 storeReleaseNote( 2, OUString() );
 775             }
 776             else
 777             {
 778                 enableAutoCheck(aModel.isAutoCheckEnabled());
 779                 if ( bDownloadAvailable )
 780                     setUIState( UPDATESTATE_DOWNLOAD_AVAIL );
 781                 else
 782                 {
 783                     // coverity[lock_order : FALSE] - incorrect report of lock order error with std::recursive_mutex
 784                     setUIState(getUIState(m_aUpdateInfo));
 785                 }
 786             }
 787         }
 788     }
 789 }
 790
 791
 792 void
 793 UpdateCheck::cancel()
 794 {
 795     std::unique_lock aGuard(m_aMutex);
 796
 797     WorkerThread *pThread = m_pThread;
 798     UpdateState eUIState = getUIState(m_aUpdateInfo);
 799
 800     aGuard.unlock();
 801
 802     if( nullptr != pThread )
 803         pThread->cancel();
 804
 805     setUIState(eUIState);
 806 }
 807
 808
 809 void
 810 UpdateCheck::download()
 811 {
 812     std::unique_lock aGuard(m_aMutex);
 813     UpdateInfo aInfo(m_aUpdateInfo);
 814     State eState = m_eState;
 815     aGuard.unlock();
 816
 817     if (aInfo.Sources.empty())
 818     {
 819         SAL_WARN("extensions.update", "download called without source");
 820         return;
 821     }
 822
 823     if( aInfo.Sources[0].IsDirect )
 824     {
 825         // Ignore second click of a double click
 826         if( DOWNLOADING != eState )
 827         {
 828             shutdownThread(true);
 829
 830             {
 831                 std::scoped_lock aGuard2(m_aMutex);
 832                 enableDownload(true);
 833             }
 834             setUIState(UPDATESTATE_DOWNLOADING);
 835         }
 836     }
 837     else
 838     {
 839         showReleaseNote(aInfo.Sources[0].URL); // Display in browser
 840     }
 841 }
 842
 843
 844 void
 845 UpdateCheck::pause()
 846 {
 847     std::unique_lock aGuard(m_aMutex);
 848
 849     if( nullptr != m_pThread )
 850         m_pThread->suspend();
 851
 852     rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext);
 853     aGuard.unlock();
 854
 855     rModel->storeDownloadPaused(true);
 856     setUIState(UPDATESTATE_DOWNLOAD_PAUSED);
 857 }
 858
 859
 860 void
 861 UpdateCheck::resume()
 862 {
 863     std::unique_lock aGuard(m_aMutex);
 864
 865     if( nullptr != m_pThread )
 866         m_pThread->resume();
 867
 868     rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext);
 869     aGuard.unlock();
 870
 871     rModel->storeDownloadPaused(false);
 872     setUIState(UPDATESTATE_DOWNLOADING);
 873 }
 874
 875
 876 void
 877 UpdateCheck::closeAfterFailure()
 878 {
 879     std::unique_lock aGuard(m_aMutex);
 880
 881     if ( ( m_eState == DISABLED ) || ( m_eState == CHECK_SCHEDULED ) )
 882     {
 883         const UpdateState eUIState = getUIState( m_aUpdateInfo );
 884         aGuard.unlock();
 885         setUIState( eUIState, true );
 886     }
 887 }
 888
 889 void UpdateCheck::notifyUpdateCheckFinished() {
 890     std::scoped_lock l(m_aMutex);
 891     m_updateCheckRunning = false;
 892     m_updateCheckFinished.notify_all();
 893 }
 894
 895 void UpdateCheck::waitForUpdateCheckFinished() {
 896     UpdateCheckThread * thread;
 897     {
 898         std::scoped_lock l(m_aMutex);
 899         thread = dynamic_cast<UpdateCheckThread *>(m_pThread);
 900     }
 901     if (thread != nullptr) {
 902         thread->cancelAsSoonAsPossible();
 903     }
 904     for (;;) {
 905         std::unique_lock lock(m_aMutex);
 906         if (!m_updateCheckRunning) {
 907             return;
 908         }
 909         m_updateCheckFinished.wait(lock);
 910     }
 911 }
 912
 913 void
 914 UpdateCheck::shutdownThread(bool join)
 915 {
 916     std::unique_lock aGuard(m_aMutex);
 917
 918     // copy thread object pointer to stack
 919     osl::Thread *pThread = m_pThread;
 920     m_pThread = nullptr;
 921     aGuard.unlock();
 922
 923     if( nullptr != pThread )
 924     {
 925         pThread->terminate();
 926         if( join )
 927         {
 928             m_aCondition.set();
 929             pThread->join();
 930             m_aCondition.reset();
 931         }
 932     }
 933 }
 934
 935
 936 void
 937 UpdateCheck::enableAutoCheck(bool enable)
 938 {
 939     if( enable )
 940     {
 941         m_updateCheckRunning = true;
 942         m_pThread = new UpdateCheckThread(m_aCondition, m_xContext, this);
 943     }
 944
 945     m_eState = enable ? CHECK_SCHEDULED : DISABLED;
 946 }
 947
 948
 949 void
 950 UpdateCheck::enableDownload(bool enable, bool paused)
 951 {
 952     OSL_ASSERT(nullptr == m_pThread);
 953
 954     if( enable )
 955     {
 956         m_pThread = new DownloadThread(m_aCondition, m_xContext, this, m_aUpdateInfo.Sources[0].URL );
 957         State eState = DISABLED;
 958         if( !paused )
 959         {
 960             eState = DOWNLOADING;
 961             m_pThread->resume();
 962         }
 963         else
 964             eState = DOWNLOAD_PAUSED;
 965
 966         m_eState = eState;
 967     }
 968     else {
 969         enableAutoCheck(UpdateCheckConfig::get(m_xContext)->isAutoCheckEnabled());
 970     }
 971
 972 }
 973
 974
 975 bool
 976 UpdateCheck::downloadTargetExists(const OUString& rFileName)
 977 {
 978     std::unique_lock aGuard(m_aMutex);
 979
 980     rtl::Reference< UpdateHandler > aUpdateHandler(getUpdateHandler());
 981     UpdateState eUIState = UPDATESTATE_DOWNLOADING;
 982
 983     bool cont = false;
 984
 985     if( aUpdateHandler->isVisible() )
 986     {
 987         cont = aUpdateHandler->showOverwriteWarning();
 988         if( cont )
 989         {
 990             if( osl_File_E_None != osl_removeFile(rFileName.pData) )
 991             {
 992                 // FIXME: error message
 993                 cont = false;
 994             }
 995         }
 996         else
 997             eUIState = getUIState(m_aUpdateInfo);
 998     }
 999     else
1000     {
1001         m_aImageName = getImageFromFileName(rFileName);
1002         eUIState = UPDATESTATE_DOWNLOAD_AVAIL;
1003     }
1004
1005     if( !cont )
1006     {
1007         shutdownThread(false);
1008         enableDownload(false);
1009
1010         aGuard.unlock();
1011         setUIState(eUIState);
1012     }
1013
1014     return cont;
1015 }
1016
1017
1018 bool UpdateCheck::checkDownloadDestination( const OUString& rFileName )
1019 {
1020     std::scoped_lock aGuard(m_aMutex);
1021
1022     rtl::Reference< UpdateHandler > aUpdateHandler( getUpdateHandler() );
1023
1024     bool bReload = false;
1025
1026     if( aUpdateHandler->isVisible() )
1027     {
1028         bReload = aUpdateHandler->showOverwriteWarning( rFileName );
1029     }
1030
1031     return bReload;
1032 }
1033
1034
1035 void
1036 UpdateCheck::downloadStalled(const OUString& rErrorMessage)
1037 {
1038     std::unique_lock aGuard(m_aMutex);
1039     rtl::Reference< UpdateHandler > aUpdateHandler(getUpdateHandler());
1040     aGuard.unlock();
1041
1042     aUpdateHandler->setErrorMessage(rErrorMessage);
1043     setUIState(UPDATESTATE_ERROR_DOWNLOADING);
1044 }
1045
1046
1047 void
1048 UpdateCheck::downloadProgressAt(sal_Int8 nPercent)
1049 {
1050     std::unique_lock aGuard(m_aMutex);
1051     rtl::Reference< UpdateHandler > aUpdateHandler(getUpdateHandler());
1052     aGuard.unlock();
1053
1054     aUpdateHandler->setProgress(nPercent);
1055     setUIState(UPDATESTATE_DOWNLOADING);
1056 }
1057
1058
1059 void
1060 UpdateCheck::downloadStarted(const OUString& rLocalFileName, sal_Int64 nFileSize)
1061 {
1062     if ( nFileSize > 0 )
1063     {
1064         std::scoped_lock aGuard(m_aMutex);
1065
1066         rtl::Reference< UpdateCheckConfig > aModel(UpdateCheckConfig::get(m_xContext));
1067         aModel->storeLocalFileName(rLocalFileName, nFileSize);
1068
1069         // Bring-up release note for position 1 ..
1070         const OUString aURL(getReleaseNote(m_aUpdateInfo, 1, aModel->isAutoDownloadEnabled()));
1071         if( !aURL.isEmpty() )
1072             showReleaseNote(aURL);
1073     }
1074 }
1075
1076
1077 void
1078 UpdateCheck::downloadFinished(const OUString& rLocalFileName)
1079 {
1080     std::unique_lock aGuard(m_aMutex);
1081
1082     // no more retries
1083     m_pThread->terminate();
1084
1085     m_aImageName = getImageFromFileName(rLocalFileName);
1086     UpdateInfo aUpdateInfo(m_aUpdateInfo);
1087
1088     aGuard.unlock();
1089     setUIState(UPDATESTATE_DOWNLOAD_AVAIL);
1090
1091     // Bring-up release note for position 2 ..
1092     rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get( m_xContext );
1093     const OUString aURL(getReleaseNote(aUpdateInfo, 2, rModel->isAutoDownloadEnabled()));
1094     if( !aURL.isEmpty() )
1095         showReleaseNote(aURL);
1096 }
1097
1098
1099 void
1100 UpdateCheck::cancelDownload()
1101 {
1102     shutdownThread(true);
1103
1104     std::scoped_lock aGuard(m_aMutex);
1105     enableDownload(false);
1106
1107     rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext);
1108
1109     OUString aLocalFile(rModel->getLocalFileName());
1110     rModel->clearLocalFileName();
1111     rModel->storeDownloadPaused(false);
1112
1113     if( isObsoleteUpdateInfo(rModel->getUpdateEntryVersion()) )
1114     {
1115         rModel->clearUpdateFound(); // This wasn't done during init yet ..
1116         m_aUpdateInfo = UpdateInfo();
1117     }
1118
1119     /*oslFileError rc =*/ osl_removeFile(aLocalFile.pData);
1120     // FIXME: error handling ..
1121
1122 }
1123
1124
1125 void
1126 UpdateCheck::showDialog(bool forceCheck)
1127 {
1128     std::unique_lock aGuard(m_aMutex);
1129
1130     bool update_found = !m_aUpdateInfo.BuildId.isEmpty();
1131     bool bSetUIState = ! m_aUpdateHandler.is();
1132
1133     UpdateState eDialogState = UPDATESTATES_COUNT;
1134
1135     switch( m_eState )
1136     {
1137     case DISABLED:
1138     case CHECK_SCHEDULED:
1139         if( forceCheck || ! update_found ) // Run check when forced or if we did not find an update yet
1140         {
1141             eDialogState = UPDATESTATE_CHECKING;
1142             bSetUIState = true;
1143         }
1144         else if(m_aUpdateInfo.Sources[0].IsDirect)
1145             eDialogState = UPDATESTATE_UPDATE_AVAIL;
1146         else
1147             eDialogState = UPDATESTATE_UPDATE_NO_DOWNLOAD;
1148         break;
1149
1150     case DOWNLOADING:
1151         eDialogState = UPDATESTATE_DOWNLOADING;
1152         break;
1153
1154     case DOWNLOAD_PAUSED:
1155         eDialogState = UPDATESTATE_DOWNLOAD_PAUSED;
1156         break;
1157
1158     case NOT_INITIALIZED:
1159         OSL_ASSERT( false );
1160         break;
1161     }
1162
1163     if( bSetUIState )
1164     {
1165         aGuard.unlock();
1166         setUIState(eDialogState, true); // suppress bubble as Dialog will be visible soon
1167         aGuard.lock();
1168     }
1169
1170     getUpdateHandler()->setVisible();
1171
1172     // Run check in separate thread ..
1173     if( UPDATESTATE_CHECKING == eDialogState )
1174     {
1175         if( DISABLED == m_eState )
1176         {
1177             // destructs itself when done, not cancellable for now ..
1178             new ManualUpdateCheckThread(m_aCondition, m_xContext);
1179         }
1180
1181         m_aCondition.set();
1182     }
1183 }
1184
1185 void
1186 UpdateCheck::setUpdateInfo(const UpdateInfo& aInfo)
1187 {
1188     std::unique_lock aGuard(m_aMutex);
1189
1190     bool bSuppressBubble = aInfo.BuildId == m_aUpdateInfo.BuildId;
1191     m_aUpdateInfo = aInfo;
1192
1193     OSL_ASSERT(DISABLED == m_eState || CHECK_SCHEDULED == m_eState);
1194
1195     // Ignore leading non direct download if we get direct ones
1196     std::vector< DownloadSource >::iterator iter = std::find_if(m_aUpdateInfo.Sources.begin(), m_aUpdateInfo.Sources.end(),
1197         [](const DownloadSource& rSource) { return rSource.IsDirect; });
1198
1199     if( (iter != m_aUpdateInfo.Sources.begin()) &&
1200         (iter != m_aUpdateInfo.Sources.end()) &&
1201         iter->IsDirect )
1202     {
1203         m_aUpdateInfo.Sources.erase(m_aUpdateInfo.Sources.begin(), --iter);
1204     }
1205
1206     rtl::Reference< UpdateCheckConfig > rModel = UpdateCheckConfig::get(m_xContext, *this);
1207     OSL_ASSERT( rModel.is() );
1208
1209     // Decide whether to use alternate release note pos ..
1210     bool autoDownloadEnabled = rModel->isAutoDownloadEnabled();
1211
1212     for (auto & elem : m_aUpdateInfo.ReleaseNotes)
1213     {
1214         if( ((1 == elem.Pos) || (2 == elem.Pos)) && autoDownloadEnabled && !elem.URL2.isEmpty())
1215         {
1216             elem.URL = elem.URL2;
1217             elem.URL2.clear();
1218             elem.Pos = elem.Pos2;
1219             elem.Pos2 = 0;
1220         }
1221     }
1222
1223     // do not move below store/clear ..
1224     rModel->updateLastChecked();
1225
1226     UpdateState eUIState;
1227     if( !m_aUpdateInfo.Sources.empty() )
1228     {
1229         rModel->storeUpdateFound(aInfo, getBuildId());
1230
1231         if( m_aUpdateInfo.Sources[0].IsDirect )
1232         {
1233             eUIState = UPDATESTATE_UPDATE_AVAIL;
1234
1235             if( rModel->isAutoDownloadEnabled() )
1236             {
1237                 shutdownThread(false);
1238                 eUIState = UPDATESTATE_DOWNLOADING;
1239                 enableDownload(true);
1240             }
1241         }
1242         else
1243             eUIState = UPDATESTATE_UPDATE_NO_DOWNLOAD;
1244     }
1245     else
1246     {
1247         eUIState = UPDATESTATE_NO_UPDATE_AVAIL;
1248         rModel->clearUpdateFound();
1249     }
1250
1251     aGuard.unlock();
1252     setUIState(eUIState, bSuppressBubble);
1253 }
1254
1255 bool UpdateCheck::hasOfficeUpdate() const
1256 {
1257     std::unique_lock aGuard(m_aMutex);
1258     return m_aUpdateInfo.BuildId.getLength() > 0;
1259 }
1260
1261 void
1262 UpdateCheck::setCheckFailedState()
1263 {
1264     setUIState(UPDATESTATE_ERROR_CHECKING);
1265 }
1266
1267
1268 void UpdateCheck::handleMenuBarUI( const rtl::Reference< UpdateHandler >& rUpdateHandler,
1269                                    UpdateState& eState,
1270                                    bool suppressBubble )
1271 {
1272     uno::Reference<beans::XPropertySet> xMenuBarUI( m_xMenuBarUI );
1273
1274     if ( ( UPDATESTATE_NO_UPDATE_AVAIL == eState ) && m_bHasExtensionUpdate )
1275         eState = UPDATESTATE_EXT_UPD_AVAIL;
1276
1277     if ( UPDATESTATE_EXT_UPD_AVAIL == eState )
1278         m_bShowExtUpdDlg = true;
1279     else
1280         m_bShowExtUpdDlg = false;
1281
1282     if( xMenuBarUI.is() )
1283     {
1284         if( UPDATESTATE_NO_UPDATE_AVAIL == eState )
1285         {
1286             xMenuBarUI->setPropertyValue( PROPERTY_SHOW_MENUICON, uno::Any(false) );
1287         }
1288         else
1289         {
1290             xMenuBarUI->setPropertyValue( PROPERTY_TITLE, uno::Any(rUpdateHandler->getBubbleTitle(eState)) );
1291             xMenuBarUI->setPropertyValue( PROPERTY_TEXT, uno::Any(rUpdateHandler->getBubbleText(eState)) );
1292
1293             if( ! suppressBubble && ( ! rUpdateHandler->isVisible() || rUpdateHandler->isMinimized() ) )
1294                 xMenuBarUI->setPropertyValue( PROPERTY_SHOW_BUBBLE, uno::Any( true ) );
1295
1296             if( UPDATESTATE_CHECKING != eState )
1297                 xMenuBarUI->setPropertyValue( PROPERTY_SHOW_MENUICON, uno::Any(true) );
1298         }
1299     }
1300 }
1301
1302
1303 void UpdateCheck::setUIState(UpdateState eState, bool suppressBubble)
1304 {
1305     std::unique_lock aGuard(m_aMutex);
1306
1307     if( ! m_xMenuBarUI.is() &&
1308         (DISABLED != m_eState) &&
1309         ( m_bHasExtensionUpdate || (UPDATESTATE_NO_UPDATE_AVAIL != eState)) &&
1310         (UPDATESTATE_CHECKING != eState) &&
1311         (UPDATESTATE_ERROR_CHECKING != eState)
1312     )
1313     {
1314         m_xMenuBarUI = createMenuBarUI(m_xContext, new MenuBarButtonJob(this));
1315     }
1316
1317     // Show bubble only when the status has changed
1318     if ( eState == m_eUpdateState )
1319         suppressBubble = true;
1320     else
1321         m_eUpdateState = eState;
1322
1323     rtl::Reference<UpdateHandler> aUpdateHandler(getUpdateHandler());
1324     OSL_ASSERT( aUpdateHandler.is() );
1325
1326     UpdateInfo aUpdateInfo(m_aUpdateInfo);
1327     OUString aImageName(m_aImageName);
1328
1329     aGuard.unlock();
1330
1331     handleMenuBarUI( aUpdateHandler, eState, suppressBubble );
1332
1333     if( (UPDATESTATE_UPDATE_AVAIL == eState)
1334      || (UPDATESTATE_DOWNLOAD_PAUSED == eState)
1335      || (UPDATESTATE_DOWNLOADING == eState) )
1336     {
1337         uno::Reference< uno::XComponentContext > xContext(m_xContext);
1338
1339         OUString aDownloadDestination =
1340             UpdateCheckConfig::get(xContext, this)->getDownloadDestination();
1341
1342         osl_getSystemPathFromFileURL(aDownloadDestination.pData, &aDownloadDestination.pData);
1343
1344         aUpdateHandler->setDownloadPath(aDownloadDestination);
1345     }
1346     else if( UPDATESTATE_DOWNLOAD_AVAIL == eState )
1347     {
1348         aUpdateHandler->setDownloadFile(aImageName);
1349     }
1350
1351     aUpdateHandler->setDescription(aUpdateInfo.Description);
1352     aUpdateHandler->setNextVersion(aUpdateInfo.Version);
1353     aUpdateHandler->setState(eState);
1354 }
1355
1356
1357 UpdateState
1358 UpdateCheck::getUIState(const UpdateInfo& rInfo)
1359 {
1360     UpdateState eUIState = UPDATESTATE_NO_UPDATE_AVAIL;
1361
1362     if( !rInfo.BuildId.isEmpty() )
1363     {
1364         if( rInfo.Sources[0].IsDirect )
1365             eUIState = UPDATESTATE_UPDATE_AVAIL;
1366         else
1367             eUIState = UPDATESTATE_UPDATE_NO_DOWNLOAD;
1368     }
1369
1370     return eUIState;
1371 }
1372
1373
1374 void
1375 UpdateCheck::showReleaseNote(const OUString& rURL) const
1376 {
1377     const uno::Reference< c3s::XSystemShellExecute > xShellExecute(
1378         c3s::SystemShellExecute::create( m_xContext ) );
1379
1380     try {
1381         xShellExecute->execute(rURL, OUString(), c3s::SystemShellExecuteFlags::URIS_ONLY);
1382     } catch(const c3s::SystemShellExecuteException&) {
1383     }
1384 }
1385
1386
1387 bool
1388 UpdateCheck::storeReleaseNote(sal_Int8 nNum, const OUString &rURL)
1389 {
1390     osl::FileBase::RC rc;
1391     OUString aTargetDir( UpdateCheckConfig::getAllUsersDirectory() + "/sun" );
1392
1393     osl::Directory::createPath( aTargetDir );
1394
1395     OUString aFileName = "releasenote" +
1396                               OUString::number( nNum ) +
1397                               ".url";
1398
1399     OUString aFilePath;
1400     rc = osl::FileBase::getAbsoluteFileURL( aTargetDir, aFileName, aFilePath );
1401     if ( rc != osl::FileBase::E_None ) return false;
1402
1403     osl::File::remove( aFilePath );
1404
1405     // don't store empty release notes, but delete old ones
1406     if ( rURL.isEmpty() )
1407         return true;
1408
1409     osl::File aFile( aFilePath );
1410     rc = aFile.open( osl_File_OpenFlag_Write | osl_File_OpenFlag_Create );
1411     if ( rc != osl::FileBase::E_None ) return false;
1412
1413     OString aLineBuf("[InternetShortcut]\r\n"_ostr);
1414     sal_uInt64 nWritten = 0;
1415
1416     OUString aURL( rURL );
1417 #ifdef _WIN32
1418     rc = aFile.write( aLineBuf.getStr(), aLineBuf.getLength(), nWritten );
1419     if ( rc != osl::FileBase::E_None ) return false;
1420     aURL = "URL=" + rURL;
1421 #endif
1422     aLineBuf = OUStringToOString( aURL, RTL_TEXTENCODING_UTF8 );
1423     rc = aFile.write( aLineBuf.getStr(), aLineBuf.getLength(), nWritten );
1424     if ( rc != osl::FileBase::E_None ) return false;
1425
1426     aFile.close();
1427     return true;
1428 }
1429
1430
1431 void UpdateCheck::showExtensionDialog()
1432 {
1433     uno::Reference< uno::XInterface > xService;
1434
1435     if( ! m_xContext.is() )
1436         throw uno::RuntimeException(
1437             u"UpdateCheck::showExtensionDialog(): empty component context"_ustr, uno::Reference< uno::XInterface > () );
1438
1439     uno::Reference< lang::XMultiComponentFactory > xServiceManager( m_xContext->getServiceManager() );
1440     if( !xServiceManager.is() )
1441         throw uno::RuntimeException(
1442             u"UpdateCheck::showExtensionDialog(): unable to obtain service manager from component context"_ustr, uno::Reference< uno::XInterface > () );
1443
1444     xService = xServiceManager->createInstanceWithContext( u"com.sun.star.deployment.ui.PackageManagerDialog"_ustr, m_xContext );
1445     uno::Reference< task::XJobExecutor > xExecutable( xService, uno::UNO_QUERY );
1446     if ( xExecutable.is() )
1447         xExecutable->trigger( u"SHOW_UPDATE_DIALOG"_ustr );
1448 }
1449
1450
1451 rtl::Reference<UpdateHandler>
1452 UpdateCheck::getUpdateHandler()
1453 {
1454     std::scoped_lock aGuard(m_aMutex);
1455
1456     if( ! m_aUpdateHandler.is() )
1457         m_aUpdateHandler = new UpdateHandler(m_xContext, this);
1458
1459     return m_aUpdateHandler;
1460 }
1461
1462
1463 uno::Reference< task::XInteractionHandler >
1464 UpdateCheck::getInteractionHandler() const
1465 {
1466     std::scoped_lock aGuard(m_aMutex);
1467
1468     uno::Reference< task::XInteractionHandler > xHandler;
1469
1470     if( m_aUpdateHandler.is() && m_aUpdateHandler->isVisible() )
1471         xHandler = m_aUpdateHandler.get();
1472
1473     return xHandler;
1474 }
1475
1476
1477 bool
1478 UpdateCheck::isDialogShowing() const
1479 {
1480     std::scoped_lock aGuard(m_aMutex);
1481     return m_aUpdateHandler.is() && m_aUpdateHandler->isVisible();
1482 };
1483
1484
1485 void
1486 UpdateCheck::autoCheckStatusChanged(bool enabled)
1487 {
1488     std::unique_lock aGuard(m_aMutex);
1489
1490     if( (CHECK_SCHEDULED == m_eState) && !enabled )
1491         shutdownThread(false);
1492
1493     if( (DISABLED == m_eState) || (CHECK_SCHEDULED == m_eState) )
1494     {
1495         enableAutoCheck(enabled);
1496         UpdateState eState = getUIState(m_aUpdateInfo);
1497         aGuard.unlock();
1498         setUIState(eState);
1499     }
1500 };
1501
1502
1503 void
1504 UpdateCheck::autoCheckIntervalChanged()
1505 {
1506     // just wake-up
1507     m_aCondition.set();
1508 };
1509
1510 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */