sal/osl/unx/process_impl.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include "osl/process.h"
  31
  32 #ifndef INCLUDED_LIMITS_H
  33 #include <limits.h>
  34 #define INCLUDED_LIMITS_H
  35 #endif
  36
  37 #ifndef INCLUDED_PTHREAD_H
  38 #include <pthread.h>
  39 #define INCLUDED_PTHREAD_H
  40 #endif
  41
  42 #ifndef INCLUDED_STDLIB_H
  43 #include <stdlib.h>
  44 #define INCLUDED_STDLIB_H
  45 #endif
  46
  47 #ifndef INCLUDED_STRING_H
  48 #include <string.h>
  49 #define INCLUDED_STRING_H
  50 #endif
  51 #include "osl/diagnose.h"
  52 #include "osl/file.h"
  53 #include "osl/module.h"
  54 #include "osl/thread.h"
  55 #include "rtl/ustring.hxx"
  56 #include "rtl/strbuf.h"
  57
  58 #include "file_path_helper.h"
  59
  60 #include "uunxapi.h"
  61
  62 #ifdef ANDROID
  63 #include <osl/detail/android-bootstrap.h>
  64 #endif
  65
  66 /***************************************
  67   osl_bootstrap_getExecutableFile_Impl().
  68
  69   @internal
  70   @see rtl_bootstrap
  71   @see #i37371#
  72
  73  **************************************/
  74
  75 extern "C" oslProcessError SAL_CALL osl_bootstrap_getExecutableFile_Impl (
  76     rtl_uString ** ppFileURL
  77 ) SAL_THROW_EXTERN_C();
  78
  79
  80 #if defined(MACOSX) || defined(IOS)
  81 #include <mach-o/dyld.h>
  82
  83 oslProcessError SAL_CALL osl_bootstrap_getExecutableFile_Impl (
  84     rtl_uString ** ppFileURL
  85 ) SAL_THROW_EXTERN_C()
  86 {
  87     oslProcessError result = osl_Process_E_NotFound;
  88
  89     char   buffer[PATH_MAX];
  90     size_t buflen = sizeof(buffer);
  91
  92     if (_NSGetExecutablePath (buffer, (uint32_t*)&buflen) == 0)
  93     {
  94         /* Determine absolute path. */
  95         char abspath[PATH_MAX];
  96         if (realpath (buffer, abspath) != 0)
  97         {
  98             /* Convert from utf8 to unicode. */
  99             rtl_uString * pAbsPath = 0;
 100             rtl_string2UString (
 101                 &(pAbsPath),
 102                 abspath, rtl_str_getLength (abspath),
 103                 RTL_TEXTENCODING_UTF8,
 104                 OSTRING_TO_OUSTRING_CVTFLAGS);
 105
 106             if (pAbsPath)
 107             {
 108                 /* Convert from path to url. */
 109                 if (osl_getFileURLFromSystemPath (pAbsPath, ppFileURL) == osl_File_E_None)
 110                 {
 111                     /* Success. */
 112                     result = osl_Process_E_None;
 113                 }
 114                 rtl_uString_release (pAbsPath);
 115             }
 116         }
 117     }
 118
 119     return (result);
 120 }
 121
 122 #else
 123 #include <dlfcn.h>
 124
 125 oslProcessError SAL_CALL osl_bootstrap_getExecutableFile_Impl (
 126     rtl_uString ** ppFileURL
 127 ) SAL_THROW_EXTERN_C()
 128 {
 129     oslProcessError result = osl_Process_E_NotFound;
 130
 131 #ifdef ANDROID
 132     /* On Android we in theory want the address of the "lo_main()"
 133      * function, as that is what corresponds to "main()" in
 134      * LibreOffice programs on normal desktop OSes.
 135      *
 136      * But that is true only for apps with a "native activity", using
 137      * <sal/main.h> and the org.libreoffice.android.Bootstrap
 138      * mechanism. For more normal (?) Android apps that just use
 139      * LibreOffice libraries (components) where the main program is in
 140      * Java, that just use LibreOffice libraries, there is no
 141      * lo_main(). (Note that we don't know for sure yet how
 142      * complicated it might be to write such Android apps...)
 143      *
 144      * Maybe best to just pick some function in liblo-bootstrap.so
 145      * which also such Java apps *must* load as the very first
 146      * LibreOffice native library. We store all LibreOffice native
 147      * shared libraries an app uses in the same folder anyway, so it
 148      * doesn't really matter.
 149      */
 150     void * addr = (void *) &lo_dlopen;
 151 #else
 152     /* Determine address of "main()" function. */
 153     void * addr = dlsym (RTLD_DEFAULT, "main");
 154 #endif
 155     if (addr != 0)
 156     {
 157         /* Determine module URL. */
 158         if (osl_getModuleURLFromAddress (addr, ppFileURL))
 159         {
 160             /* Success. */
 161             result = osl_Process_E_None;
 162         }
 163     }
 164
 165     /* Fallback to ordinary osl_getExecutableFile(). */
 166     if (result == osl_Process_E_NotFound)
 167         result = osl_getExecutableFile (ppFileURL);
 168
 169     return (result);
 170 }
 171
 172 #endif
 173
 174 /***************************************
 175  CommandArgs_Impl.
 176  **************************************/
 177 struct CommandArgs_Impl
 178 {
 179     pthread_mutex_t m_mutex;
 180     sal_uInt32      m_nCount;
 181     rtl_uString **  m_ppArgs;
 182 };
 183
 184 static struct CommandArgs_Impl g_command_args =
 185 {
 186     PTHREAD_MUTEX_INITIALIZER,
 187     0,
 188     0
 189 };
 190
 191 /***************************************
 192   osl_getExecutableFile().
 193  **************************************/
 194 oslProcessError SAL_CALL osl_getExecutableFile (rtl_uString ** ppustrFile)
 195 {
 196     oslProcessError result = osl_Process_E_NotFound;
 197
 198     pthread_mutex_lock (&(g_command_args.m_mutex));
 199     OSL_ASSERT(g_command_args.m_nCount > 0);
 200     if (g_command_args.m_nCount > 0)
 201     {
 202         /* CommandArgs set. Obtain argv[0]. */
 203         rtl_uString_assign (ppustrFile, g_command_args.m_ppArgs[0]);
 204         result = osl_Process_E_None;
 205     }
 206     pthread_mutex_unlock (&(g_command_args.m_mutex));
 207
 208     return (result);
 209 }
 210
 211 /***************************************
 212  osl_getCommandArgCount().
 213  **************************************/
 214 sal_uInt32 SAL_CALL osl_getCommandArgCount (void)
 215 {
 216     sal_uInt32 result = 0;
 217
 218     pthread_mutex_lock (&(g_command_args.m_mutex));
 219     if (g_command_args.m_nCount == 0) {
 220         OSL_TRACE(
 221             OSL_LOG_PREFIX
 222             "osl_getCommandArgCount w/o prior call to osl_setCommandArgs");
 223     }
 224     if (g_command_args.m_nCount > 0)
 225         result = g_command_args.m_nCount - 1;
 226     pthread_mutex_unlock (&(g_command_args.m_mutex));
 227
 228     return (result);
 229 }
 230
 231 /***************************************
 232  osl_getCommandArg().
 233  **************************************/
 234 oslProcessError SAL_CALL osl_getCommandArg (sal_uInt32 nArg, rtl_uString ** strCommandArg)
 235 {
 236     oslProcessError result = osl_Process_E_NotFound;
 237
 238     pthread_mutex_lock (&(g_command_args.m_mutex));
 239     OSL_ASSERT(g_command_args.m_nCount > 0);
 240     if (g_command_args.m_nCount > (nArg + 1))
 241     {
 242         rtl_uString_assign (strCommandArg, g_command_args.m_ppArgs[nArg + 1]);
 243         result = osl_Process_E_None;
 244     }
 245     pthread_mutex_unlock (&(g_command_args.m_mutex));
 246
 247     return (result);
 248 }
 249
 250 /***************************************
 251  osl_setCommandArgs().
 252  **************************************/
 253 void SAL_CALL osl_setCommandArgs (int argc, char ** argv)
 254 {
 255     OSL_ASSERT(argc > 0);
 256     pthread_mutex_lock (&(g_command_args.m_mutex));
 257     OSL_ENSURE (g_command_args.m_nCount == 0, "osl_setCommandArgs(): CommandArgs already set.");
 258     if (g_command_args.m_nCount == 0)
 259     {
 260         rtl_uString** ppArgs = (rtl_uString**)rtl_allocateZeroMemory (argc * sizeof(rtl_uString*));
 261         if (ppArgs != 0)
 262         {
 263             rtl_TextEncoding encoding = osl_getThreadTextEncoding();
 264             for (int i = 0; i < argc; i++)
 265             {
 266                 rtl_string2UString (
 267                     &(ppArgs[i]),
 268                     argv[i], rtl_str_getLength (argv[i]), encoding,
 269                     OSTRING_TO_OUSTRING_CVTFLAGS);
 270             }
 271             if (ppArgs[0] != 0)
 272             {
 273 #if !defined(ANDROID) && !defined(IOS) // No use searching PATH on Android or iOS
 274                 /* see @ osl_getExecutableFile(). */
 275                 if (rtl_ustr_indexOfChar (rtl_uString_getStr(ppArgs[0]), sal_Unicode('/')) == -1)
 276                 {
 277                     const rtl::OUString PATH (RTL_CONSTASCII_USTRINGPARAM("PATH"));
 278
 279                     rtl_uString * pSearchPath = 0;
 280                     osl_getEnvironment (PATH.pData, &pSearchPath);
 281                     if (pSearchPath)
 282                     {
 283                         rtl_uString * pSearchResult = 0;
 284                         osl_searchPath (ppArgs[0], pSearchPath, &pSearchResult);
 285                         if (pSearchResult)
 286                         {
 287                             rtl_uString_assign (&(ppArgs[0]), pSearchResult);
 288                             rtl_uString_release (pSearchResult);
 289                         }
 290                         rtl_uString_release (pSearchPath);
 291                     }
 292                 }
 293 #endif
 294                 rtl_uString * pArg0 = 0;
 295                 if (realpath_u (ppArgs[0], &pArg0))
 296                 {
 297                     osl_getFileURLFromSystemPath (pArg0, &(ppArgs[0]));
 298                     rtl_uString_release (pArg0);
 299                 }
 300             }
 301             g_command_args.m_nCount = argc;
 302             g_command_args.m_ppArgs = ppArgs;
 303         }
 304     }
 305     pthread_mutex_unlock (&(g_command_args.m_mutex));
 306 }
 307
 308 /***************************************
 309  osl_getEnvironment().
 310  **************************************/
 311 oslProcessError SAL_CALL osl_getEnvironment(rtl_uString* pustrEnvVar, rtl_uString** ppustrValue)
 312 {
 313     oslProcessError  result   = osl_Process_E_NotFound;
 314     rtl_TextEncoding encoding = osl_getThreadTextEncoding();
 315     rtl_String* pstr_env_var  = 0;
 316
 317     OSL_PRECOND(pustrEnvVar, "osl_getEnvironment(): Invalid parameter");
 318     OSL_PRECOND(ppustrValue, "osl_getEnvironment(): Invalid parameter");
 319
 320     rtl_uString2String(
 321         &pstr_env_var,
 322         rtl_uString_getStr(pustrEnvVar), rtl_uString_getLength(pustrEnvVar), encoding,
 323         OUSTRING_TO_OSTRING_CVTFLAGS);
 324     if (pstr_env_var != 0)
 325     {
 326         const char* p_env_var = getenv (rtl_string_getStr (pstr_env_var));
 327         if (p_env_var != 0)
 328         {
 329             rtl_string2UString(
 330                 ppustrValue,
 331                 p_env_var, strlen(p_env_var), encoding,
 332                 OSTRING_TO_OUSTRING_CVTFLAGS);
 333             OSL_ASSERT(*ppustrValue != NULL);
 334
 335             result = osl_Process_E_None;
 336         }
 337         rtl_string_release(pstr_env_var);
 338     }
 339
 340     return (result);
 341 }
 342
 343 /***************************************
 344  osl_setEnvironment().
 345  **************************************/
 346 oslProcessError SAL_CALL osl_setEnvironment(rtl_uString* pustrEnvVar, rtl_uString* pustrValue)
 347 {
 348     oslProcessError  result   = osl_Process_E_Unknown;
 349     rtl_TextEncoding encoding = osl_getThreadTextEncoding();
 350     rtl_String* pstr_env_var  = 0;
 351     rtl_String* pstr_val  = 0;
 352
 353     OSL_PRECOND(pustrEnvVar, "osl_setEnvironment(): Invalid parameter");
 354     OSL_PRECOND(pustrValue, "osl_setEnvironment(): Invalid parameter");
 355
 356     rtl_uString2String(
 357         &pstr_env_var,
 358         rtl_uString_getStr(pustrEnvVar), rtl_uString_getLength(pustrEnvVar), encoding,
 359         OUSTRING_TO_OSTRING_CVTFLAGS);
 360
 361     rtl_uString2String(
 362         &pstr_val,
 363         rtl_uString_getStr(pustrValue), rtl_uString_getLength(pustrValue), encoding,
 364         OUSTRING_TO_OSTRING_CVTFLAGS);
 365
 366     if (pstr_env_var != 0 && pstr_val != 0)
 367     {
 368 #if defined (SOLARIS)
 369         rtl_String * pBuffer = NULL;
 370
 371         sal_Int32 nCapacity = rtl_stringbuffer_newFromStringBuffer( &pBuffer,
 372             rtl_string_getLength(pstr_env_var) + rtl_string_getLength(pstr_val) + 1,
 373             pstr_env_var );
 374         rtl_stringbuffer_insert( &pBuffer, &nCapacity, pBuffer->length, "=", 1);
 375         rtl_stringbuffer_insert( &pBuffer, &nCapacity, pBuffer->length,
 376             rtl_string_getStr(pstr_val), rtl_string_getLength(pstr_val) );
 377
 378         rtl_string_acquire(pBuffer); // argument to putenv must leak on success
 379
 380         if (putenv(rtl_string_getStr(pBuffer)) == 0)
 381             result = osl_Process_E_None;
 382         else
 383             rtl_string_release(pBuffer);
 384 #else
 385         if (setenv(rtl_string_getStr(pstr_env_var), rtl_string_getStr(pstr_val), 1) == 0)
 386             result = osl_Process_E_None;
 387 #endif
 388     }
 389
 390     if (pstr_val)
 391         rtl_string_release(pstr_val);
 392
 393     if (pstr_env_var != 0)
 394         rtl_string_release(pstr_env_var);
 395
 396     return (result);
 397 }
 398
 399 /***************************************
 400  osl_clearEnvironment().
 401  **************************************/
 402 oslProcessError SAL_CALL osl_clearEnvironment(rtl_uString* pustrEnvVar)
 403 {
 404     oslProcessError  result   = osl_Process_E_Unknown;
 405     rtl_TextEncoding encoding = osl_getThreadTextEncoding();
 406     rtl_String* pstr_env_var  = 0;
 407
 408     OSL_PRECOND(pustrEnvVar, "osl_setEnvironment(): Invalid parameter");
 409
 410     rtl_uString2String(
 411         &pstr_env_var,
 412         rtl_uString_getStr(pustrEnvVar), rtl_uString_getLength(pustrEnvVar), encoding,
 413         OUSTRING_TO_OSTRING_CVTFLAGS);
 414
 415     if (pstr_env_var)
 416     {
 417 #if defined (SOLARIS)
 418         rtl_String * pBuffer = NULL;
 419
 420         sal_Int32 nCapacity = rtl_stringbuffer_newFromStringBuffer( &pBuffer,
 421             rtl_string_getLength(pstr_env_var) + 1, pstr_env_var );
 422         rtl_stringbuffer_insert( &pBuffer, &nCapacity, pBuffer->length, "=", 1);
 423
 424         rtl_string_acquire(pBuffer); // argument to putenv must leak on success
 425
 426         if (putenv(rtl_string_getStr(pBuffer)) == 0)
 427             result = osl_Process_E_None;
 428         else
 429             rtl_string_release(pBuffer);
 430 #elif (defined(MACOSX) || defined(NETBSD) || defined(FREEBSD))
 431         //MacOSX baseline is 10.4, which has an old-school void return
 432         //for unsetenv.
 433                 //See: http://developer.apple.com/mac/library/documentation/Darwin/Reference/ManPages/10.4/man3/unsetenv.3.html?useVersion=10.4
 434         unsetenv(rtl_string_getStr(pstr_env_var));
 435         result = osl_Process_E_None;
 436 #else
 437         if (unsetenv(rtl_string_getStr(pstr_env_var)) == 0)
 438             result = osl_Process_E_None;
 439 #endif
 440         rtl_string_release(pstr_env_var);
 441     }
 442
 443     return (result);
 444 }
 445
 446
 447 /***************************************
 448  osl_getProcessWorkingDir().
 449  **************************************/
 450 oslProcessError SAL_CALL osl_getProcessWorkingDir(rtl_uString **ppustrWorkingDir)
 451 {
 452     oslProcessError result = osl_Process_E_Unknown;
 453     char buffer[PATH_MAX];
 454
 455     OSL_PRECOND(ppustrWorkingDir, "osl_getProcessWorkingDir(): Invalid parameter");
 456
 457     if (getcwd (buffer, sizeof(buffer)) != 0)
 458     {
 459         rtl_uString* ustrTmp = 0;
 460
 461         rtl_string2UString(
 462             &ustrTmp,
 463             buffer, strlen(buffer), osl_getThreadTextEncoding(),
 464             OSTRING_TO_OUSTRING_CVTFLAGS);
 465         if (ustrTmp != 0)
 466         {
 467             if (osl_getFileURLFromSystemPath (ustrTmp, ppustrWorkingDir) == osl_File_E_None)
 468                 result = osl_Process_E_None;
 469             rtl_uString_release (ustrTmp);
 470         }
 471     }
 472
 473     return (result);
 474 }
 475
 476 /******************************************************************************
 477  *
 478  *              new functions to set/return the current process locale
 479  *
 480  *****************************************************************************/
 481
 482 struct ProcessLocale_Impl
 483 {
 484     pthread_mutex_t m_mutex;
 485     rtl_Locale *    m_pLocale;
 486 };
 487
 488 static struct ProcessLocale_Impl g_process_locale =
 489 {
 490     PTHREAD_MUTEX_INITIALIZER,
 491     0
 492 };
 493
 494 extern "C" void _imp_getProcessLocale( rtl_Locale ** );
 495 extern "C" int  _imp_setProcessLocale( rtl_Locale * );
 496
 497 /**********************************************
 498  osl_getProcessLocale().
 499  *********************************************/
 500 oslProcessError SAL_CALL osl_getProcessLocale( rtl_Locale ** ppLocale )
 501 {
 502     oslProcessError result = osl_Process_E_Unknown;
 503     OSL_PRECOND(ppLocale, "osl_getProcessLocale(): Invalid parameter.");
 504     if (ppLocale)
 505     {
 506         pthread_mutex_lock(&(g_process_locale.m_mutex));
 507
 508         if (g_process_locale.m_pLocale == 0)
 509             _imp_getProcessLocale (&(g_process_locale.m_pLocale));
 510         *ppLocale = g_process_locale.m_pLocale;
 511         result = osl_Process_E_None;
 512
 513         pthread_mutex_unlock (&(g_process_locale.m_mutex));
 514     }
 515     return (result);
 516 }
 517
 518 /**********************************************
 519  osl_setProcessLocale().
 520  *********************************************/
 521 oslProcessError SAL_CALL osl_setProcessLocale( rtl_Locale * pLocale )
 522 {
 523     oslProcessError result = osl_Process_E_Unknown;
 524
 525     OSL_PRECOND(pLocale, "osl_setProcessLocale(): Invalid parameter.");
 526
 527     pthread_mutex_lock(&(g_process_locale.m_mutex));
 528     if (_imp_setProcessLocale (pLocale) == 0)
 529     {
 530         g_process_locale.m_pLocale = pLocale;
 531         result = osl_Process_E_None;
 532     }
 533     pthread_mutex_unlock (&(g_process_locale.m_mutex));
 534
 535     return (result);
 536 }
 537
 538 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */