vos/source/process.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: process.cxx,v $
  10  * $Revision: 1.14 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 #include <cstdarg>
  33 #include <vector>
  34 #include <rtl/ustring.hxx>
  35 #include <rtl/instance.hxx>
  36
  37 #include "vos/process.hxx"
  38 #include "vos/diagnose.hxx"
  39 #include <osl/file.hxx>
  40
  41 #define MAX_RESOURCES   100
  42 #define MAX_ARGS                100
  43 #define MAX_ENVIROMENTS 100
  44
  45 using namespace vos;
  46
  47 /////////////////////////////////////////////////////////////////////////////
  48 /// Argument
  49
  50 OArgumentList::OArgumentList() :
  51     n_Args(0),
  52     m_aVec(0)
  53 {
  54     // empty
  55 }
  56
  57 OArgumentList::OArgumentList( sal_uInt32 nArgs, const ::rtl::OUString* aArgument1, ... ) :
  58     n_Args( nArgs )
  59 {
  60     m_aVec = new rtl_uString* [nArgs];
  61     std::va_list pArgs;
  62     sal_uInt32 i = 0;
  63     const rtl::OUString* aArgument;
  64
  65     va_start ( pArgs, aArgument1 );
  66     aArgument = aArgument1;
  67
  68     while( true ) {
  69         m_aVec[i] = aArgument->pData;
  70         rtl_uString_acquire( m_aVec[i++] );
  71         if( i < n_Args )
  72             aArgument = va_arg( pArgs,rtl::OUString* );
  73         else
  74             break;
  75     }
  76     va_end( pArgs );
  77 }
  78
  79
  80 OArgumentList::OArgumentList( const rtl::OUString aArgumentList[], sal_uInt32 nArgs ) :
  81     n_Args( nArgs )
  82 {
  83     m_aVec = new rtl_uString* [n_Args];
  84     for( sal_uInt32 i = 0; i < n_Args; ++ i )  {
  85         m_aVec[i] = aArgumentList[i].pData;
  86         rtl_uString_acquire( m_aVec[i] );
  87     }
  88 }
  89
  90 OArgumentList::OArgumentList( const OArgumentList& rOther ) : n_Args( rOther.n_Args )
  91 {
  92     m_aVec = new rtl_uString* [n_Args];
  93
  94     sal_uInt32 i;
  95     for ( i = 0; i < n_Args; ++i )
  96     {
  97         m_aVec[i] = rOther.m_aVec[i];
  98         rtl_uString_acquire( m_aVec[i] );
  99     }
 100 }
 101
 102 OArgumentList& OArgumentList::operator=( const OArgumentList& rOther )
 103 {
 104     if ( this != &rOther )
 105     {
 106
 107         // delete the old one
 108         sal_uInt32 i;
 109         for ( i = 0; i < n_Args; ++i )
 110             rtl_uString_release( m_aVec[i] );
 111
 112         delete [] m_aVec;
 113
 114
 115         n_Args = rOther.n_Args;
 116         m_aVec = new rtl_uString* [n_Args];
 117         for( i = 0; i < n_Args; ++i )
 118         {
 119             m_aVec[i] = rOther.m_aVec[i];
 120             rtl_uString_acquire( m_aVec[i] );
 121         }
 122     }
 123
 124     return *this;
 125 }
 126
 127 OArgumentList::~OArgumentList( )
 128 {
 129     for( sal_uInt32 i = 0; i < n_Args; ++i ) rtl_uString_release( m_aVec[i] );
 130     delete[] m_aVec;
 131 }
 132
 133
 134 ////////////////////////////////////////////////////////////////////////////////
 135 /// Environment
 136
 137 OEnvironment::OEnvironment() :
 138     n_Vars( 0 ),
 139     m_aVec( 0 )
 140 {
 141 }
 142
 143 OEnvironment::OEnvironment( sal_Int32 nVars, const ::rtl::OUString* aArgument1, ... ) :
 144     n_Vars( nVars )
 145 {
 146     m_aVec = new rtl_uString* [nVars];
 147     std::va_list pArgs;
 148     sal_Int32 i = 0;
 149     const rtl::OUString* aArgument;
 150
 151     va_start ( pArgs, aArgument1 );
 152     aArgument = aArgument1;
 153
 154     while( true ) {
 155         m_aVec[i] = aArgument->pData;
 156         rtl_uString_acquire( m_aVec[i++] );
 157         if( i < n_Vars )
 158             aArgument = va_arg( pArgs,rtl::OUString* );
 159         else
 160             break;
 161     }
 162     va_end( pArgs );
 163 }
 164
 165
 166 OEnvironment::OEnvironment( const ::rtl::OUString aVariableList[], sal_Int32 nVars ) :
 167     n_Vars( nVars )
 168 {
 169     m_aVec = new rtl_uString* [n_Vars];
 170     for( sal_Int32 i = 0; i < n_Vars; ++ i )  {
 171         m_aVec[i] = aVariableList[i].pData;
 172         rtl_uString_acquire( m_aVec[i] );
 173     }
 174 }
 175
 176 OEnvironment::OEnvironment( const OEnvironment& rOther ) : n_Vars( rOther.n_Vars )
 177 {
 178     m_aVec = new rtl_uString* [n_Vars];
 179
 180     sal_Int32 i;
 181     for ( i = 0; i < n_Vars; ++i )
 182     {
 183         m_aVec[i] = rOther.m_aVec[i];
 184         rtl_uString_acquire( m_aVec[i] );
 185     }
 186 }
 187
 188 OEnvironment& OEnvironment::operator=( const OEnvironment& rOther )
 189 {
 190     if ( this != &rOther )
 191     {
 192         sal_Int32 i;
 193         for ( i = 0; i < n_Vars; ++i )
 194             rtl_uString_release( m_aVec[i] );
 195
 196         delete [] m_aVec;
 197
 198         n_Vars = rOther.n_Vars;
 199         m_aVec = new rtl_uString* [n_Vars];
 200         for ( i = 0; i < n_Vars; ++i )
 201         {
 202             m_aVec[i] = rOther.m_aVec[i];
 203             rtl_uString_acquire( m_aVec[i] );
 204         }
 205     }
 206
 207     return *this;
 208 }
 209
 210 OEnvironment::~OEnvironment()
 211 {
 212     for( sal_Int32 i = 0; i < n_Vars; ++i ) rtl_uString_release( m_aVec[i] );
 213     delete[] m_aVec;
 214 }
 215
 216 /////////////////////////////////////////////////////////////////////////////
 217 // Process
 218
 219
 220 VOS_IMPLEMENT_CLASSINFO(
 221     VOS_CLASSNAME(OProcess, vos),
 222     VOS_NAMESPACE(OProcess, vos),
 223     VOS_NAMESPACE(OObject, vos), 0);
 224
 225
 226 OProcess::OProcess( ) :
 227     m_strImageName( ),
 228     m_strDirectory(),
 229     m_Process(0)
 230 {
 231 }
 232
 233
 234 OProcess::OProcess( const rtl::OUString& strImageName ) :
 235     m_strImageName( strImageName ),
 236     m_strDirectory(),
 237     m_Process(0)
 238 {
 239     // empty
 240 }
 241
 242
 243 OProcess::OProcess(const rtl::OUString& strImageName, const rtl::OUString& strWorkingDirectory) :
 244     m_strImageName( strImageName ),
 245     m_strDirectory( strWorkingDirectory ),
 246     m_Process(0)
 247 {
 248     // empty
 249 }
 250
 251
 252 OProcess::~OProcess()
 253 {
 254     osl_freeProcessHandle(m_Process);
 255 }
 256
 257 OProcess* OProcess::getProcess(TProcessIdentifier Identifier)
 258 {
 259     oslProcess hProcess = osl_getProcess(Identifier);
 260
 261     if (hProcess)
 262     {
 263         OProcess* pProcess = new OProcess( );
 264
 265         pProcess->m_Process = hProcess;
 266
 267         return pProcess;
 268     }
 269
 270     return 0;
 271 }
 272
 273
 274 OProcess::TProcessError OProcess::execute(TProcessOption Options,
 275                                           const OArgumentList& aArgumentList,
 276                                           const OEnvironment&  aEnvironment )
 277 {
 278     return ((TProcessError)osl_executeProcess(m_strImageName.pData,
 279                                               aArgumentList.m_aVec,
 280                                               aArgumentList.n_Args,
 281                                               Options,
 282                                               0,
 283                                               m_strDirectory.pData,
 284                                               aEnvironment.m_aVec,
 285                                               aEnvironment.n_Vars,
 286                                               &m_Process));
 287 }
 288
 289
 290 OProcess::TProcessError OProcess::execute( TProcessOption Options,
 291                                            const OSecurity &Security,
 292                                            const OArgumentList& aArgumentList,
 293                                            const OEnvironment&  aEnvironment )
 294 {
 295     return ((TProcessError)osl_executeProcess(m_strImageName.pData,
 296                                               aArgumentList.m_aVec,
 297                                               aArgumentList.n_Args,
 298                                               Options,
 299                                               Security,
 300                                               m_strDirectory.pData,
 301                                               aEnvironment.m_aVec,
 302                                               aEnvironment.n_Vars,
 303                                               &m_Process));
 304 }
 305
 306
 307 OProcess::TProcessError OProcess::terminate()
 308 {
 309    return (TProcessError)osl_terminateProcess(m_Process);
 310 }
 311
 312 OProcess::TProcessError OProcess::getInfo(TProcessData Data, TProcessInfo* pInfo) const
 313 {
 314    return (TProcessError)osl_getProcessInfo(m_Process, Data, pInfo);
 315 }
 316
 317 OProcess::TProcessError OProcess::getCurrentInfo(TProcessData Data, TProcessInfo* pInfo)
 318 {
 319    return (TProcessError)osl_getProcessInfo(0, Data, pInfo);
 320 }
 321
 322 OProcess::TProcessError OProcess::join()
 323 {
 324     return (TProcessError)osl_joinProcess(m_Process);
 325 }
 326
 327
 328 /*
 329 OProcess::TProcessError OProcess::searchPath(const sal_Char* Name, sal_Char *Buffer, sal_uInt32 Max,
 330                                              const sal_Char* Path, sal_Char Separator)
 331 {
 332     return (TProcessError)osl_searchPath(Name, Path, Separator, Buffer, Max);
 333 }
 334 */
 335
 336 /////////////////////////////////////////////////////////////////////////////
 337 // StartupInfo
 338
 339 VOS_IMPLEMENT_CLASSINFO(
 340     VOS_CLASSNAME(OStartupInfo, vos),
 341     VOS_NAMESPACE(OStartupInfo, vos),
 342     VOS_NAMESPACE(OObject, vos), 0);
 343
 344 OStartupInfo::OStartupInfo()
 345 {
 346 }
 347
 348 OStartupInfo::~OStartupInfo()
 349 {
 350 }
 351
 352 OStartupInfo::TStartupError OStartupInfo::getExecutableFile(
 353     rtl::OUString& strImageName ) const
 354 {
 355     return (TStartupError) osl_getExecutableFile( &strImageName.pData );
 356 }
 357
 358
 359 OStartupInfo::TStartupError OStartupInfo::getCommandArg(sal_uInt32 nArg, rtl::OUString& strCommandArg)
 360 {
 361     return ( TStartupError ) osl_getCommandArg( nArg,&strCommandArg.pData );
 362 }
 363
 364 sal_uInt32 OStartupInfo::getCommandArgCount()
 365 {
 366     return osl_getCommandArgCount();
 367 }
 368
 369 OStartupInfo::TStartupError OStartupInfo::getEnvironment(const rtl::OUString& strVar,
 370                                                          rtl::OUString& strValue)
 371 {
 372     return ( TStartupError ) osl_getEnvironment( strVar.pData, &strValue.pData );
 373 }
 374
 375
 376
 377 /////////////////////////////////////////////////////////////////////////////
 378 //
 379 // OExtCommandLineImpl
 380 //
 381
 382 namespace vos
 383 {
 384
 385 class OExtCommandLineImpl
 386 {
 387     void init();
 388
 389     ::std::vector< ::rtl::OUString > aExtArgVector;
 390     sal_uInt32 m_nArgCount;
 391
 392 public:
 393
 394     OExtCommandLineImpl();
 395     ~OExtCommandLineImpl();
 396
 397     sal_uInt32 SAL_CALL getCommandArgCount();
 398
 399     sal_Bool SAL_CALL getCommandArg(sal_uInt32 nArg, ::rtl::OUString& strCommandArg);
 400 };
 401
 402 }
 403
 404 OExtCommandLineImpl::OExtCommandLineImpl()
 405     : m_nArgCount(0)
 406 {
 407     init();
 408 }
 409
 410 OExtCommandLineImpl::~OExtCommandLineImpl()
 411 {
 412
 413 }
 414
 415
 416 sal_uInt32 SAL_CALL OExtCommandLineImpl::getCommandArgCount()
 417 {
 418     return m_nArgCount;
 419 }
 420
 421
 422 sal_Bool SAL_CALL OExtCommandLineImpl::getCommandArg(sal_uInt32 nArg, ::rtl::OUString& strCommandArg)
 423 {
 424     if ( nArg >= m_nArgCount )
 425     {
 426         return sal_False;
 427     }
 428
 429     strCommandArg = aExtArgVector[nArg];
 430
 431     return sal_True;
 432 }
 433
 434
 435 void OExtCommandLineImpl::init()
 436 {
 437     OStartupInfo aStartInfo;
 438     sal_uInt32 nIndex=0;
 439     sal_uInt32 nArgs = aStartInfo.getCommandArgCount();
 440
 441     for ( nIndex = 0 ; nIndex < nArgs ; ++nIndex )
 442     {
 443         ::rtl::OUString aString;
 444         aStartInfo.getCommandArg(nIndex,aString);
 445
 446         if ( aString[0] == (sal_Unicode) '@' )
 447         {
 448             ::rtl::OUString aFileName = aString.copy(1);
 449             ::osl::File aFile(aFileName);
 450             ::rtl::ByteSequence aSeq;
 451
 452             ::osl::FileBase::RC aErr = aFile.open(OpenFlag_Read);
 453
 454             if ( aErr != ::osl::FileBase::E_None )
 455             {
 456                 break;
 457             }
 458
 459             do
 460             {
 461                 aErr = aFile.readLine(aSeq);
 462                 if ( aSeq.getLength() != 0 )
 463                 {
 464                     ::rtl::OUString newString((sal_Char*)aSeq.getArray(), aSeq.getLength(), RTL_TEXTENCODING_ASCII_US);
 465                     aExtArgVector.push_back( newString );
 466                     m_nArgCount++;
 467                 }
 468             }
 469             while ( aErr == ::osl::FileBase::E_None && aSeq.getLength() > 0 );
 470
 471             aFile.close();
 472             aFile.remove(aFileName);
 473         }
 474         else
 475         {
 476             aExtArgVector.push_back( aString );
 477             m_nArgCount++;
 478         }
 479     }
 480 }
 481
 482
 483
 484 /////////////////////////////////////////////////////////////////////////////
 485 //
 486 // OExtCommandLine
 487 //
 488
 489 namespace
 490 {
 491     struct lclMutex : public rtl::Static< NAMESPACE_VOS(OMutex), lclMutex > {};
 492 }
 493
 494 OExtCommandLineImpl* OExtCommandLine::pExtImpl=0;
 495
 496
 497 VOS_IMPLEMENT_CLASSINFO(
 498     VOS_CLASSNAME(OExtCommandLine, vos),
 499     VOS_NAMESPACE(OExtCommandLine, vos),
 500     VOS_NAMESPACE(OObject, vos), 0);
 501
 502 OExtCommandLine::OExtCommandLine()
 503 {
 504     OGuard Guard(lclMutex::get());
 505
 506     if ( pExtImpl == NULL )
 507     {
 508         pExtImpl = new OExtCommandLineImpl;
 509     }
 510 }
 511
 512 OExtCommandLine::~OExtCommandLine()
 513 {
 514
 515
 516 }
 517
 518 sal_uInt32 SAL_CALL OExtCommandLine::getCommandArgCount()
 519 {
 520     return pExtImpl->getCommandArgCount();
 521 }
 522
 523
 524 sal_Bool SAL_CALL OExtCommandLine::getCommandArg(sal_uInt32 nArg, ::rtl::OUString& strCommandArg)
 525 {
 526     return pExtImpl->getCommandArg(nArg,strCommandArg);
 527 }
 528