desktop/source/pkgchk/unopkg/unopkg_misc.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 <config_folders.h>
  21
  22 #include "deployment.hrc"
  23 #include "unopkg_shared.h"
  24 #include "dp_identifier.hxx"
  25 #include "../../deployment/gui/dp_gui.hrc"
  26 #include "lockfile.hxx"
  27 #include <vcl/svapp.hxx>
  28 #include <vcl/msgbox.hxx>
  29 #include <rtl/bootstrap.hxx>
  30 #include <rtl/strbuf.hxx>
  31 #include <rtl/ustrbuf.hxx>
  32 #include <osl/process.h>
  33 #include <osl/file.hxx>
  34 #include <osl/thread.hxx>
  35 #include <tools/getprocessworkingdir.hxx>
  36 #include <comphelper/processfactory.hxx>
  37 #include <unotools/configmgr.hxx>
  38 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  39 #include <com/sun/star/ucb/UniversalContentBroker.hpp>
  40 #include <cppuhelper/bootstrap.hxx>
  41 #include <comphelper/sequence.hxx>
  42 #include <stdio.h>
  43
  44 using namespace ::com::sun::star;
  45 using namespace ::com::sun::star::uno;
  46 using namespace ::com::sun::star::ucb;
  47
  48 namespace unopkg {
  49
  50 OUString toString( OptionInfo const * info )
  51 {
  52     assert(info != 0);
  53     OUStringBuffer buf;
  54     buf.appendAscii("--");
  55     buf.appendAscii(info->m_name);
  56     if (info->m_short_option != '\0')
  57     {
  58         buf.appendAscii(" (short -" );
  59         buf.append(info->m_short_option );
  60         buf.appendAscii(")");
  61     }
  62     if (info->m_has_argument)
  63         buf.appendAscii(" <argument>" );
  64     return buf.makeStringAndClear();
  65 }
  66
  67
  68 OptionInfo const * getOptionInfo(
  69     OptionInfo const * list,
  70     OUString const & opt, sal_Unicode copt )
  71 {
  72     for ( ; list->m_name != 0; ++list )
  73     {
  74         OptionInfo const & option_info = *list;
  75         if (!opt.isEmpty())
  76         {
  77             if (opt.equalsAsciiL(
  78                     option_info.m_name, option_info.m_name_length ) &&
  79                 (copt == '\0' || copt == option_info.m_short_option))
  80             {
  81                 return &option_info;
  82             }
  83         }
  84         else
  85         {
  86             OSL_ASSERT( copt != '\0' );
  87             if (copt == option_info.m_short_option)
  88             {
  89                 return &option_info;
  90             }
  91         }
  92     }
  93     OSL_FAIL( OUStringToOString(
  94                     opt, osl_getThreadTextEncoding() ).getStr() );
  95     return 0;
  96 }
  97
  98
  99 bool isOption( OptionInfo const * option_info, sal_uInt32 * pIndex )
 100 {
 101     assert(option_info != 0);
 102     if (osl_getCommandArgCount() <= *pIndex)
 103         return false;
 104
 105     OUString arg;
 106     osl_getCommandArg( *pIndex, &arg.pData );
 107     sal_Int32 len = arg.getLength();
 108
 109     if (len < 2 || arg[ 0 ] != '-')
 110         return false;
 111
 112     if (len == 2 && arg[ 1 ] == option_info->m_short_option)
 113     {
 114         ++(*pIndex);
 115         dp_misc::TRACE(__FILE__ ": identified option \'\'"
 116             + OUString( option_info->m_short_option ) + "\n");
 117         return true;
 118     }
 119     if (arg[ 1 ] == '-' && rtl_ustr_ascii_compare(
 120             arg.pData->buffer + 2, option_info->m_name ) == 0)
 121     {
 122         ++(*pIndex);
 123         dp_misc::TRACE(__FILE__ ": identified option \'"
 124             + OUString::createFromAscii(option_info->m_name) + "\'\n");
 125         return true;
 126     }
 127     return false;
 128 }
 129
 130
 131 bool isBootstrapVariable(sal_uInt32 * pIndex)
 132 {
 133     OSL_ASSERT(osl_getCommandArgCount() >=  *pIndex);
 134
 135     OUString arg;
 136     osl_getCommandArg(*pIndex, &arg.pData);
 137     if (arg.match("-env:"))
 138     {
 139         ++(*pIndex);
 140         return true;
 141     }
 142     return false;
 143 }
 144
 145
 146 bool readArgument(
 147     OUString * pValue, OptionInfo const * option_info, sal_uInt32 * pIndex )
 148 {
 149     if (isOption( option_info, pIndex ))
 150     {
 151         if (*pIndex < osl_getCommandArgCount())
 152         {
 153             OSL_ASSERT( pValue != 0 );
 154             osl_getCommandArg( *pIndex, &pValue->pData );
 155             dp_misc::TRACE(__FILE__ ": argument value: "
 156                 + *pValue + "\n");
 157             ++(*pIndex);
 158             return true;
 159         }
 160         --(*pIndex);
 161     }
 162     return false;
 163 }
 164
 165
 166 namespace {
 167 struct ExecutableDir : public rtl::StaticWithInit<
 168     OUString, ExecutableDir> {
 169     const OUString operator () () {
 170         OUString path;
 171         if (osl_getExecutableFile( &path.pData ) != osl_Process_E_None) {
 172             throw RuntimeException("cannot locate executable directory!",0);
 173         }
 174         return path.copy( 0, path.lastIndexOf( '/' ) );
 175     }
 176 };
 177 struct ProcessWorkingDir : public rtl::StaticWithInit<
 178     OUString, ProcessWorkingDir> {
 179     const OUString operator () () {
 180         OUString workingDir;
 181         tools::getProcessWorkingDir(workingDir);
 182         return workingDir;
 183     }
 184 };
 185 } // anon namespace
 186
 187
 188 OUString const & getExecutableDir()
 189 {
 190     return ExecutableDir::get();
 191 }
 192
 193
 194 OUString const & getProcessWorkingDir()
 195 {
 196     return ProcessWorkingDir::get();
 197 }
 198
 199
 200 OUString makeAbsoluteFileUrl(
 201     OUString const & sys_path, OUString const & base_url, bool throw_exc )
 202 {
 203     // system path to file url
 204     OUString file_url;
 205     oslFileError rc = osl_getFileURLFromSystemPath( sys_path.pData, &file_url.pData );
 206     if ( rc != osl_File_E_None) {
 207         OUString tempPath;
 208         if ( osl_getSystemPathFromFileURL( sys_path.pData, &tempPath.pData) == osl_File_E_None )
 209         {
 210             file_url = sys_path;
 211         }
 212         else if (throw_exc)
 213         {
 214             throw RuntimeException("cannot get file url from system path: " +
 215                 sys_path );
 216         }
 217     }
 218
 219     OUString abs;
 220     if (osl_getAbsoluteFileURL(
 221             base_url.pData, file_url.pData, &abs.pData ) != osl_File_E_None)
 222     {
 223         if (throw_exc) {
 224             OUStringBuffer buf;
 225             buf.appendAscii( "making absolute file url failed: \"" );
 226             buf.append( base_url );
 227             buf.appendAscii( "\" (base-url) and \"" );
 228             buf.append( file_url );
 229             buf.appendAscii( "\" (file-url)!" );
 230             throw RuntimeException( buf.makeStringAndClear() );
 231         }
 232         return OUString();
 233     }
 234     return abs[ abs.getLength() -1 ] == '/'
 235         ? abs.copy( 0, abs.getLength() -1 ) : abs;
 236 }
 237
 238
 239 namespace {
 240
 241
 242 inline void printf_space( sal_Int32 space )
 243 {
 244     while (space--)
 245         dp_misc::writeConsole("  ");
 246 }
 247
 248
 249 void printf_line(
 250     OUString const & name, OUString const & value, sal_Int32 level )
 251 {
 252    printf_space( level );
 253     dp_misc::writeConsole(name + ": " + value + "\n");
 254 }
 255
 256
 257 void printf_package(
 258     Reference<deployment::XPackage> const & xPackage,
 259     Reference<XCommandEnvironment> const & xCmdEnv, sal_Int32 level )
 260 {
 261     beans::Optional< OUString > id(
 262         level == 0
 263         ? beans::Optional< OUString >(
 264             true, dp_misc::getIdentifier( xPackage ) )
 265         : xPackage->getIdentifier() );
 266     if (id.IsPresent)
 267         printf_line( "Identifier", id.Value, level );
 268     OUString version(xPackage->getVersion());
 269     if (!version.isEmpty())
 270         printf_line( "Version", version, level + 1 );
 271     printf_line( "URL", xPackage->getURL(), level + 1 );
 272
 273     beans::Optional< beans::Ambiguous<sal_Bool> > option(
 274         xPackage->isRegistered( Reference<task::XAbortChannel>(), xCmdEnv ) );
 275     OUString value;
 276     if (option.IsPresent) {
 277         beans::Ambiguous<sal_Bool> const & reg = option.Value;
 278         if (reg.IsAmbiguous)
 279             value = "unknown";
 280         else
 281             value = reg.Value ? OUString("yes") : OUString("no");
 282     }
 283     else
 284         value = "n/a";
 285     printf_line( "is registered", value, level + 1 );
 286
 287     const Reference<deployment::XPackageTypeInfo> xPackageType(
 288         xPackage->getPackageType() );
 289     OSL_ASSERT( xPackageType.is() );
 290     if (xPackageType.is()) {
 291         printf_line( "Media-Type", xPackageType->getMediaType(), level + 1 );
 292     }
 293     printf_line( "Description", xPackage->getDescription(), level + 1 );
 294     if (xPackage->isBundle()) {
 295         Sequence< Reference<deployment::XPackage> > seq(
 296             xPackage->getBundle( Reference<task::XAbortChannel>(), xCmdEnv ) );
 297         printf_space( level + 1 );
 298         dp_misc::writeConsole("bundled Packages: {\n");
 299         ::std::vector<Reference<deployment::XPackage> >vec_bundle;
 300         ::comphelper::sequenceToContainer(vec_bundle, seq);
 301         printf_packages( vec_bundle, ::std::vector<bool>(vec_bundle.size()),
 302                          xCmdEnv, level + 2 );
 303         printf_space( level + 1 );
 304         dp_misc::writeConsole("}\n");
 305     }
 306 }
 307
 308 } // anon namespace
 309
 310 void printf_unaccepted_licenses(
 311     Reference<deployment::XPackage> const & ext)
 312 {
 313         OUString id(
 314             dp_misc::getIdentifier(ext) );
 315         printf_line( "Identifier", id, 0 );
 316         printf_space(1);
 317         dp_misc::writeConsole("License not accepted\n\n");
 318 }
 319
 320
 321 void printf_packages(
 322     ::std::vector< Reference<deployment::XPackage> > const & allExtensions,
 323     ::std::vector<bool> const & vecUnaccepted,
 324     Reference<XCommandEnvironment> const & xCmdEnv, sal_Int32 level )
 325 {
 326     OSL_ASSERT(allExtensions.size() == vecUnaccepted.size());
 327
 328     if (allExtensions.empty())
 329     {
 330         printf_space( level );
 331         dp_misc::writeConsole("<none>\n");
 332     }
 333     else
 334     {
 335         typedef ::std::vector< Reference<deployment::XPackage> >::const_iterator I_EXT;
 336         int index = 0;
 337         for (I_EXT i = allExtensions.begin(); i != allExtensions.end(); ++i, ++index)
 338         {
 339             if (vecUnaccepted[index])
 340                 printf_unaccepted_licenses(*i);
 341             else
 342                 printf_package( *i, xCmdEnv, level );
 343             dp_misc::writeConsole("\n");
 344         }
 345     }
 346 }
 347
 348
 349
 350 namespace {
 351
 352
 353 Reference<XComponentContext> bootstrapStandAlone()
 354 {
 355     Reference<XComponentContext> xContext =
 356         ::cppu::defaultBootstrap_InitialComponentContext();
 357
 358     Reference<lang::XMultiServiceFactory> xServiceManager(
 359         xContext->getServiceManager(), UNO_QUERY_THROW );
 360     // set global process service factory used by unotools config helpers
 361     ::comphelper::setProcessServiceFactory( xServiceManager );
 362
 363     // Initialize the UCB (for backwards compatibility, in case some code still
 364     // uses plain createInstance w/o args directly to obtain an instance):
 365     UniversalContentBroker::create( xContext );
 366
 367     return xContext;
 368 }
 369
 370
 371 Reference<XComponentContext> connectToOffice(
 372     Reference<XComponentContext> const & xLocalComponentContext,
 373     bool verbose )
 374 {
 375     Sequence<OUString> args( 3 );
 376     args[ 0 ] = "--nologo";
 377     args[ 1 ] = "--nodefault";
 378
 379     OUString pipeId( ::dp_misc::generateRandomPipeId() );
 380     OUStringBuffer buf;
 381     buf.appendAscii( "--accept=pipe,name=" );
 382     buf.append( pipeId );
 383     buf.appendAscii( ";urp;" );
 384     args[ 2 ] = buf.makeStringAndClear();
 385     OUString appURL( getExecutableDir() + "/soffice" );
 386
 387     if (verbose)
 388     {
 389         dp_misc::writeConsole(
 390             "Raising process: " + appURL +
 391             "\nArguments: --nologo --nodefault " + args[2] +
 392             "\n");
 393     }
 394
 395     ::dp_misc::raiseProcess( appURL, args );
 396
 397     if (verbose)
 398         dp_misc::writeConsole("OK.  Connecting...");
 399
 400     OSL_ASSERT( buf.isEmpty() );
 401     buf.appendAscii( "uno:pipe,name=" );
 402     buf.append( pipeId );
 403     buf.appendAscii( ";urp;StarOffice.ComponentContext" );
 404     Reference<XComponentContext> xRet(
 405         ::dp_misc::resolveUnoURL(
 406             buf.makeStringAndClear(), xLocalComponentContext ),
 407         UNO_QUERY_THROW );
 408     if (verbose)
 409         dp_misc::writeConsole("OK.\n");
 410
 411     return xRet;
 412 }
 413
 414 } // anon namespace
 415
 416 /** returns the path to the lock file used by unopkg.
 417     @return the path. An empty string signifies an error.
 418 */
 419 OUString getLockFilePath()
 420 {
 421     OUString ret;
 422     OUString sBootstrap("${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap") ":UserInstallation}");
 423     rtl::Bootstrap::expandMacros(sBootstrap);
 424     OUString sAbs;
 425     if (::osl::File::E_None ==  ::osl::File::getAbsoluteFileURL(
 426         sBootstrap, ".lock", sAbs))
 427     {
 428         if (::osl::File::E_None ==
 429             ::osl::File::getSystemPathFromFileURL(sAbs, sBootstrap))
 430         {
 431             ret = sBootstrap;
 432         }
 433     }
 434
 435     return ret;
 436 }
 437
 438 Reference<XComponentContext> getUNO(
 439     bool verbose, bool shared, bool bGui,
 440     Reference<XComponentContext> & out_localContext)
 441 {
 442     // do not create any user data (for the root user) in --shared mode:
 443     if (shared) {
 444         rtl::Bootstrap::set(
 445             OUString("CFG_CacheUrl"),
 446             OUString());
 447     }
 448
 449     // hold lock during process runtime:
 450     static ::desktop::Lockfile s_lockfile( false /* no IPC server */ );
 451     Reference<XComponentContext> xComponentContext( bootstrapStandAlone() );
 452     out_localContext = xComponentContext;
 453     if (::dp_misc::office_is_running()) {
 454         xComponentContext.set(
 455             connectToOffice( xComponentContext, verbose ) );
 456     }
 457     else
 458     {
 459         if (! s_lockfile.check( 0 ))
 460         {
 461             OUString sMsg(ResId(RID_STR_CONCURRENTINSTANCE, *DeploymentResMgr::get()));
 462             //Create this string before we call DeInitVCL, because this will kill
 463             //the ResMgr
 464             OUString sError(ResId(RID_STR_UNOPKG_ERROR, *DeploymentResMgr::get()));
 465
 466             sMsg += "\n" + getLockFilePath();
 467
 468             if (bGui)
 469             {
 470                 //We show a message box or print to the console that there
 471                 //is another instance already running
 472                 if ( ! InitVCL() )
 473                     throw RuntimeException( "Cannot initialize VCL!" );
 474                 {
 475                     ScopedVclPtrInstance< WarningBox > warn(nullptr, WB_OK | WB_DEF_OK, sMsg);
 476                     warn->SetText(utl::ConfigManager::getProductName());
 477                     warn->SetIcon(0);
 478                     warn->Execute();
 479                 }
 480                 DeInitVCL();
 481             }
 482
 483             throw LockFileException(sError + sMsg);
 484         }
 485     }
 486
 487     return xComponentContext;
 488 }
 489
 490 }
 491
 492 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */