sal/osl/unx/process_impl.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_features.h>
  21
  22 #include <osl/process.h>
  23
  24 #include <limits.h>
  25 #include <pthread.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include <osl/diagnose.h>
  30 #include <osl/file.hxx>
  31 #include <osl/module.h>
  32 #include <osl/thread.h>
  33 #include <rtl/alloc.h>
  34 #include <rtl/ustring.hxx>
  35 #include <rtl/strbuf.h>
  36 #include <sal/log.hxx>
  37
  38 #include "file_path_helper.hxx"
  39
  40 #include "uunxapi.hxx"
  41 #include "nlsupport.hxx"
  42
  43 #ifdef ANDROID
  44 #include <osl/detail/android-bootstrap.h>
  45 #endif
  46
  47 #if defined(MACOSX) || defined(IOS)
  48 #include <mach-o/dyld.h>
  49
  50 namespace {
  51
  52 oslProcessError bootstrap_getExecutableFile(rtl_uString ** ppFileURL)
  53 {
  54     oslProcessError result = osl_Process_E_NotFound;
  55
  56     char   buffer[PATH_MAX];
  57     uint32_t buflen = sizeof(buffer);
  58
  59     if (_NSGetExecutablePath (buffer, &buflen) == 0)
  60     {
  61         /* Determine absolute path. */
  62         char abspath[PATH_MAX];
  63         if (realpath (buffer, abspath) != nullptr)
  64         {
  65             /* Convert from utf8 to unicode. */
  66             rtl_uString * pAbsPath = nullptr;
  67             rtl_string2UString (
  68                 &pAbsPath,
  69                 abspath, rtl_str_getLength (abspath),
  70                 RTL_TEXTENCODING_UTF8,
  71                 OSTRING_TO_OUSTRING_CVTFLAGS);
  72
  73             if (pAbsPath)
  74             {
  75                 /* Convert from path to url. */
  76                 if (osl_getFileURLFromSystemPath (pAbsPath, ppFileURL) == osl_File_E_None)
  77                 {
  78                     /* Success. */
  79                     result = osl_Process_E_None;
  80                 }
  81                 rtl_uString_release (pAbsPath);
  82             }
  83         }
  84     }
  85
  86     return result;
  87 }
  88
  89 }
  90
  91 #else
  92 #include <dlfcn.h>
  93
  94 namespace {
  95
  96 oslProcessError bootstrap_getExecutableFile(rtl_uString ** ppFileURL)
  97 {
  98     oslProcessError result = osl_Process_E_NotFound;
  99
 100 #ifdef EMSCRIPTEN
 101     // Just return some dummy file: URL for now to see what happens
 102     OUString fileURL = "vnd.sun.star.pathname:/instdir/program/soffice";
 103     rtl_uString_acquire(fileURL.pData);
 104     *ppFileURL = fileURL.pData;
 105     return osl_Process_E_None;
 106 #else
 107 #ifdef ANDROID
 108     /* Now with just a single DSO, this one from lo-bootstrap.c is as good as
 109      * any */
 110     void * addr = dlsym (RTLD_DEFAULT, "JNI_OnLoad");
 111 #else
 112 #if defined __linux
 113     // The below code looking for "main" with dlsym() will typically
 114     // fail, as there is little reason for "main" to be exported, in
 115     // the dlsym() sense, from an executable. But Linux has
 116     // /proc/self/exe, try using that.
 117     char buf[PATH_MAX];
 118     int rc = readlink("/proc/self/exe", buf, sizeof(buf));
 119     if (rc > 0 && rc < PATH_MAX)
 120     {
 121         buf[rc] = '\0';
 122         OUString path = OUString::fromUtf8(buf);
 123         OUString fileURL;
 124         if (osl::File::getFileURLFromSystemPath(path, fileURL) == osl::File::E_None)
 125         {
 126             rtl_uString_acquire(fileURL.pData);
 127             *ppFileURL = fileURL.pData;
 128             return osl_Process_E_None;
 129         }
 130     }
 131 #endif
 132     /* Determine address of "main()" function. */
 133     void * addr = dlsym (RTLD_DEFAULT, "main");
 134 #endif
 135     if (addr != nullptr)
 136     {
 137         /* Determine module URL. */
 138         if (osl_getModuleURLFromAddress (addr, ppFileURL))
 139         {
 140             /* Success. */
 141             result = osl_Process_E_None;
 142         }
 143     }
 144
 145     return result;
 146 #endif
 147 }
 148
 149 }
 150
 151 #endif
 152
 153 namespace {
 154
 155 struct CommandArgs_Impl
 156 {
 157     pthread_mutex_t m_mutex;
 158     sal_uInt32      m_nCount;
 159     rtl_uString **  m_ppArgs;
 160 };
 161
 162 }
 163
 164 static struct CommandArgs_Impl g_command_args =
 165 {
 166     PTHREAD_MUTEX_INITIALIZER,
 167     0,
 168     nullptr
 169 };
 170
 171 oslProcessError SAL_CALL osl_getExecutableFile (rtl_uString ** ppustrFile)
 172 {
 173     pthread_mutex_lock (&(g_command_args.m_mutex));
 174     if (g_command_args.m_nCount == 0)
 175     {
 176         pthread_mutex_unlock (&(g_command_args.m_mutex));
 177         return bootstrap_getExecutableFile(ppustrFile);
 178     }
 179
 180     /* CommandArgs set. Obtain argv[0]. */
 181     rtl_uString_assign (ppustrFile, g_command_args.m_ppArgs[0]);
 182     pthread_mutex_unlock (&(g_command_args.m_mutex));
 183     return osl_Process_E_None;
 184 }
 185
 186 sal_uInt32 SAL_CALL osl_getCommandArgCount()
 187 {
 188     sal_uInt32 result = 0;
 189
 190     pthread_mutex_lock (&(g_command_args.m_mutex));
 191     SAL_INFO_IF(
 192         g_command_args.m_nCount == 0, "sal.osl",
 193         "osl_getCommandArgCount w/o prior call to osl_setCommandArgs");
 194     if (g_command_args.m_nCount > 0)
 195         result = g_command_args.m_nCount - 1;
 196     pthread_mutex_unlock (&(g_command_args.m_mutex));
 197
 198     return result;
 199 }
 200
 201 oslProcessError SAL_CALL osl_getCommandArg (sal_uInt32 nArg, rtl_uString ** strCommandArg)
 202 {
 203     oslProcessError result = osl_Process_E_NotFound;
 204
 205     pthread_mutex_lock (&(g_command_args.m_mutex));
 206     assert(g_command_args.m_nCount > 0);
 207     if (g_command_args.m_nCount > (nArg + 1))
 208     {
 209         rtl_uString_assign (strCommandArg, g_command_args.m_ppArgs[nArg + 1]);
 210         result = osl_Process_E_None;
 211     }
 212     pthread_mutex_unlock (&(g_command_args.m_mutex));
 213
 214     return result;
 215 }
 216
 217 void SAL_CALL osl_setCommandArgs (int argc, char ** argv)
 218 {
 219     assert(argc > 0);
 220     pthread_mutex_lock (&(g_command_args.m_mutex));
 221     SAL_WARN_IF(g_command_args.m_nCount != 0, "sal.osl", "args already set");
 222     if (g_command_args.m_nCount == 0)
 223     {
 224         rtl_uString** ppArgs = static_cast<rtl_uString**>(rtl_allocateZeroMemory (argc * sizeof(rtl_uString*)));
 225         if (ppArgs != nullptr)
 226         {
 227             rtl_TextEncoding encoding = osl_getThreadTextEncoding();
 228             for (int i = 0; i < argc; i++)
 229             {
 230                 rtl_string2UString (
 231                     &(ppArgs[i]),
 232                     argv[i], rtl_str_getLength (argv[i]), encoding,
 233                     OSTRING_TO_OUSTRING_CVTFLAGS);
 234             }
 235             if (ppArgs[0] != nullptr)
 236             {
 237 #if HAVE_FEATURE_MACOSX_SANDBOX
 238                 // If we are called with a relative path in argv[0] in a sandboxed process
 239                 // osl::realpath() fails. So just use bootstrap_getExecutableFile() instead.
 240                 // Somewhat silly to use argv[0] and tediously figure out the absolute path from it
 241                 // anyway.
 242                 bootstrap_getExecutableFile(&ppArgs[0]);
 243                 OUString pArg0(ppArgs[0]);
 244                 osl_getFileURLFromSystemPath (pArg0.pData, &(ppArgs[0]));
 245 #else
 246 #if !defined(ANDROID) && !defined(IOS) // No use searching PATH on Android or iOS
 247                 /* see @ osl_getExecutableFile(). */
 248                 if (rtl_ustr_indexOfChar (rtl_uString_getStr(ppArgs[0]), '/') == -1)
 249                 {
 250                     const OUString PATH ("PATH");
 251
 252                     rtl_uString * pSearchPath = nullptr;
 253                     osl_getEnvironment (PATH.pData, &pSearchPath);
 254                     if (pSearchPath)
 255                     {
 256                         rtl_uString * pSearchResult = nullptr;
 257                         osl_searchPath (ppArgs[0], pSearchPath, &pSearchResult);
 258                         if (pSearchResult)
 259                         {
 260                             rtl_uString_assign (&(ppArgs[0]), pSearchResult);
 261                             rtl_uString_release (pSearchResult);
 262                         }
 263                         rtl_uString_release (pSearchPath);
 264                     }
 265                 }
 266 #endif
 267                 OUString pArg0;
 268                 if (osl::realpath (OUString::unacquired(&ppArgs[0]), pArg0))
 269                 {
 270                     osl_getFileURLFromSystemPath (pArg0.pData, &(ppArgs[0]));
 271                 }
 272 #endif // !HAVE_FEATURE_MACOSX_SANDBOX
 273             }
 274             g_command_args.m_nCount = argc;
 275             g_command_args.m_ppArgs = ppArgs;
 276         }
 277     }
 278     pthread_mutex_unlock (&(g_command_args.m_mutex));
 279 }
 280
 281 oslProcessError SAL_CALL osl_getEnvironment(rtl_uString* pustrEnvVar, rtl_uString** ppustrValue)
 282 {
 283     oslProcessError  result   = osl_Process_E_NotFound;
 284     rtl_TextEncoding encoding = osl_getThreadTextEncoding();
 285     rtl_String* pstr_env_var  = nullptr;
 286
 287     OSL_PRECOND(pustrEnvVar, "osl_getEnvironment(): Invalid parameter");
 288     OSL_PRECOND(ppustrValue, "osl_getEnvironment(): Invalid parameter");
 289
 290     rtl_uString2String(
 291         &pstr_env_var,
 292         rtl_uString_getStr(pustrEnvVar), rtl_uString_getLength(pustrEnvVar), encoding,
 293         OUSTRING_TO_OSTRING_CVTFLAGS);
 294     if (pstr_env_var != nullptr)
 295     {
 296         const char* p_env_var = getenv (rtl_string_getStr (pstr_env_var));
 297         if (p_env_var != nullptr)
 298         {
 299             rtl_string2UString(
 300                 ppustrValue,
 301                 p_env_var, strlen(p_env_var), encoding,
 302                 OSTRING_TO_OUSTRING_CVTFLAGS);
 303             OSL_ASSERT(*ppustrValue != nullptr);
 304
 305             result = osl_Process_E_None;
 306         }
 307         rtl_string_release(pstr_env_var);
 308     }
 309
 310     return result;
 311 }
 312
 313 oslProcessError SAL_CALL osl_setEnvironment(rtl_uString* pustrEnvVar, rtl_uString* pustrValue)
 314 {
 315     oslProcessError  result   = osl_Process_E_Unknown;
 316     rtl_TextEncoding encoding = osl_getThreadTextEncoding();
 317     rtl_String* pstr_env_var  = nullptr;
 318     rtl_String* pstr_val  = nullptr;
 319
 320     OSL_PRECOND(pustrEnvVar, "osl_setEnvironment(): Invalid parameter");
 321     OSL_PRECOND(pustrValue, "osl_setEnvironment(): Invalid parameter");
 322
 323     rtl_uString2String(
 324         &pstr_env_var,
 325         rtl_uString_getStr(pustrEnvVar), rtl_uString_getLength(pustrEnvVar), encoding,
 326         OUSTRING_TO_OSTRING_CVTFLAGS);
 327
 328     rtl_uString2String(
 329         &pstr_val,
 330         rtl_uString_getStr(pustrValue), rtl_uString_getLength(pustrValue), encoding,
 331         OUSTRING_TO_OSTRING_CVTFLAGS);
 332
 333     if (pstr_env_var != nullptr && pstr_val != nullptr)
 334     {
 335 #if defined (__sun)
 336         rtl_String * pBuffer = NULL;
 337
 338         sal_Int32 nCapacity = rtl_stringbuffer_newFromStringBuffer( &pBuffer,
 339             rtl_string_getLength(pstr_env_var) + rtl_string_getLength(pstr_val) + 1,
 340             pstr_env_var );
 341         rtl_stringbuffer_insert( &pBuffer, &nCapacity, pBuffer->length, "=", 1);
 342         rtl_stringbuffer_insert( &pBuffer, &nCapacity, pBuffer->length,
 343             rtl_string_getStr(pstr_val), rtl_string_getLength(pstr_val) );
 344
 345         rtl_string_acquire(pBuffer); // argument to putenv must leak on success
 346
 347         if (putenv(rtl_string_getStr(pBuffer)) == 0)
 348             result = osl_Process_E_None;
 349         else
 350             rtl_string_release(pBuffer);
 351 #else
 352         if (setenv(rtl_string_getStr(pstr_env_var), rtl_string_getStr(pstr_val), 1) == 0)
 353             result = osl_Process_E_None;
 354 #endif
 355     }
 356
 357     if (pstr_val)
 358         rtl_string_release(pstr_val);
 359
 360     if (pstr_env_var != nullptr)
 361         rtl_string_release(pstr_env_var);
 362
 363     return result;
 364 }
 365
 366 oslProcessError SAL_CALL osl_clearEnvironment(rtl_uString* pustrEnvVar)
 367 {
 368     oslProcessError  result   = osl_Process_E_Unknown;
 369     rtl_TextEncoding encoding = osl_getThreadTextEncoding();
 370     rtl_String* pstr_env_var  = nullptr;
 371
 372     OSL_PRECOND(pustrEnvVar, "osl_setEnvironment(): Invalid parameter");
 373
 374     rtl_uString2String(
 375         &pstr_env_var,
 376         rtl_uString_getStr(pustrEnvVar), rtl_uString_getLength(pustrEnvVar), encoding,
 377         OUSTRING_TO_OSTRING_CVTFLAGS);
 378
 379     if (pstr_env_var)
 380     {
 381 #if defined (__sun)
 382         rtl_String * pBuffer = NULL;
 383
 384         sal_Int32 nCapacity = rtl_stringbuffer_newFromStringBuffer( &pBuffer,
 385             rtl_string_getLength(pstr_env_var) + 1, pstr_env_var );
 386         rtl_stringbuffer_insert( &pBuffer, &nCapacity, pBuffer->length, "=", 1);
 387
 388         rtl_string_acquire(pBuffer); // argument to putenv must leak on success
 389
 390         if (putenv(rtl_string_getStr(pBuffer)) == 0)
 391             result = osl_Process_E_None;
 392         else
 393             rtl_string_release(pBuffer);
 394 #elif (defined(MACOSX) || defined(NETBSD) || defined(FREEBSD))
 395         // MacOSX baseline is 10.4, which has an old-school void return
 396         // for unsetenv.
 397         // See: http://developer.apple.com/mac/library/documentation/Darwin/Reference/ManPages/10.4/man3/unsetenv.3.html?useVersion=10.4
 398         unsetenv(rtl_string_getStr(pstr_env_var));
 399         result = osl_Process_E_None;
 400 #else
 401         if (unsetenv(rtl_string_getStr(pstr_env_var)) == 0)
 402             result = osl_Process_E_None;
 403 #endif
 404         rtl_string_release(pstr_env_var);
 405     }
 406
 407     return result;
 408 }
 409
 410 oslProcessError SAL_CALL osl_getProcessWorkingDir(rtl_uString **ppustrWorkingDir)
 411 {
 412     oslProcessError result = osl_Process_E_Unknown;
 413     char buffer[PATH_MAX];
 414
 415     OSL_PRECOND(ppustrWorkingDir, "osl_getProcessWorkingDir(): Invalid parameter");
 416
 417     if (getcwd (buffer, sizeof(buffer)) != nullptr)
 418     {
 419         rtl_uString* ustrTmp = nullptr;
 420
 421         rtl_string2UString(
 422             &ustrTmp,
 423             buffer, strlen(buffer), osl_getThreadTextEncoding(),
 424             OSTRING_TO_OUSTRING_CVTFLAGS);
 425         if (ustrTmp != nullptr)
 426         {
 427             if (osl_getFileURLFromSystemPath (ustrTmp, ppustrWorkingDir) == osl_File_E_None)
 428                 result = osl_Process_E_None;
 429             rtl_uString_release (ustrTmp);
 430         }
 431     }
 432
 433     return result;
 434 }
 435
 436 namespace {
 437
 438 struct ProcessLocale_Impl
 439 {
 440     pthread_mutex_t m_mutex;
 441     rtl_Locale *    m_pLocale;
 442 };
 443
 444 }
 445
 446 static struct ProcessLocale_Impl g_process_locale =
 447 {
 448     PTHREAD_MUTEX_INITIALIZER,
 449     nullptr
 450 };
 451
 452 oslProcessError SAL_CALL osl_getProcessLocale( rtl_Locale ** ppLocale )
 453 {
 454     oslProcessError result = osl_Process_E_Unknown;
 455     OSL_PRECOND(ppLocale, "osl_getProcessLocale(): Invalid parameter.");
 456     if (ppLocale)
 457     {
 458         pthread_mutex_lock(&(g_process_locale.m_mutex));
 459
 460         if (g_process_locale.m_pLocale == nullptr)
 461             imp_getProcessLocale (&(g_process_locale.m_pLocale));
 462         *ppLocale = g_process_locale.m_pLocale;
 463         result = osl_Process_E_None;
 464
 465         pthread_mutex_unlock (&(g_process_locale.m_mutex));
 466     }
 467     return result;
 468 }
 469
 470 oslProcessError SAL_CALL osl_setProcessLocale( rtl_Locale * pLocale )
 471 {
 472     OSL_PRECOND(pLocale, "osl_setProcessLocale(): Invalid parameter.");
 473
 474     pthread_mutex_lock(&(g_process_locale.m_mutex));
 475     g_process_locale.m_pLocale = pLocale;
 476     pthread_mutex_unlock (&(g_process_locale.m_mutex));
 477
 478     return osl_Process_E_None;
 479 }
 480
 481 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */