sal/osl/unx/process_impl.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_impl.cxx,v $
  10  * $Revision: 1.12 $
  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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sal.hxx"
  33
  34 #include "osl/process.h"
  35
  36 #ifndef INCLUDED_LIMITS_H
  37 #include <limits.h>
  38 #define INCLUDED_LIMITS_H
  39 #endif
  40
  41 #ifndef INCLUDED_PTHREAD_H
  42 #include <pthread.h>
  43 #define INCLUDED_PTHREAD_H
  44 #endif
  45
  46 #ifndef INCLUDED_STDLIB_H
  47 #include <stdlib.h>
  48 #define INCLUDED_STDLIB_H
  49 #endif
  50
  51 #ifndef INCLUDED_STRING_H
  52 #include <string.h>
  53 #define INCLUDED_STRING_H
  54 #endif
  55 #include "osl/diagnose.h"
  56 #include <osl/file.h>
  57 #include "osl/module.h"
  58 #include "osl/thread.h"
  59 #include "rtl/ustring.hxx"
  60
  61 #ifndef _OSL_FILE_PATH_HELPER_H_
  62 #include "file_path_helper.h"
  63 #endif
  64
  65 #ifndef _OSL_UUNXAPI_H_
  66 #include "uunxapi.h"
  67 #endif
  68
  69 /***************************************
  70   osl_bootstrap_getExecutableFile_Impl().
  71
  72   @internal
  73   @see rtl_bootstrap
  74   @see #i37371#
  75
  76  **************************************/
  77
  78 extern "C" oslProcessError SAL_CALL osl_bootstrap_getExecutableFile_Impl (
  79     rtl_uString ** ppFileURL
  80 ) SAL_THROW_EXTERN_C();
  81
  82
  83 #if defined(MACOSX)
  84 #include <mach-o/dyld.h>
  85
  86 oslProcessError SAL_CALL osl_bootstrap_getExecutableFile_Impl (
  87     rtl_uString ** ppFileURL
  88 ) SAL_THROW_EXTERN_C()
  89 {
  90     oslProcessError result = osl_Process_E_NotFound;
  91
  92     char   buffer[PATH_MAX];
  93     size_t buflen = sizeof(buffer);
  94
  95 #if __GNUC__ >= 4 && defined(MACOSX)
  96     if (_NSGetExecutablePath (buffer, (uint32_t*)&buflen) == 0)
  97 #else
  98     if (_NSGetExecutablePath (buffer, &buflen) == 0)
  99 #endif
 100     {
 101         /* Determine absolute path. */
 102         char abspath[PATH_MAX];
 103         if (realpath (buffer, abspath) != 0)
 104         {
 105             /* Convert from utf8 to unicode. */
 106             rtl_uString * pAbsPath = 0;
 107             rtl_string2UString (
 108                 &(pAbsPath),
 109                 abspath, rtl_str_getLength (abspath),
 110                 RTL_TEXTENCODING_UTF8,
 111                 OSTRING_TO_OUSTRING_CVTFLAGS);
 112
 113             if (pAbsPath)
 114             {
 115                 /* Convert from path to url. */
 116                 if (osl_getFileURLFromSystemPath (pAbsPath, ppFileURL) == osl_File_E_None)
 117                 {
 118                     /* Success. */
 119                     result = osl_Process_E_None;
 120                 }
 121                 rtl_uString_release (pAbsPath);
 122             }
 123         }
 124     }
 125
 126     return (result);
 127 }
 128
 129 #elif !defined(NO_DL_FUNCTIONS)
 130 #include <dlfcn.h>
 131
 132 oslProcessError SAL_CALL osl_bootstrap_getExecutableFile_Impl (
 133     rtl_uString ** ppFileURL
 134 ) SAL_THROW_EXTERN_C()
 135 {
 136     oslProcessError result = osl_Process_E_NotFound;
 137
 138     /* Determine address of "main()" function. */
 139     void * addr = dlsym (RTLD_DEFAULT, "main");
 140     if (addr != 0)
 141     {
 142         /* Determine module URL. */
 143         if (osl_getModuleURLFromAddress (addr, ppFileURL))
 144         {
 145             /* Success. */
 146             result = osl_Process_E_None;
 147         }
 148     }
 149
 150     return (result);
 151 }
 152
 153 #else  /* NO_DL_FUNCTIONS */
 154
 155 oslProcessError SAL_CALL osl_bootstrap_getExecutableFile_Impl (
 156     rtl_uString ** ppFileURL
 157 ) SAL_THROW_EXTERN_C()
 158 {
 159     /* Fallback to ordinary osl_getExecutableFile(). */
 160     return osl_getExecutableFile (ppFileURL);
 161 }
 162
 163 #endif /* NO_DL_FUNCTIONS */
 164
 165 /***************************************
 166  CommandArgs_Impl.
 167  **************************************/
 168 struct CommandArgs_Impl
 169 {
 170     pthread_mutex_t m_mutex;
 171     sal_uInt32      m_nCount;
 172     rtl_uString **  m_ppArgs;
 173 };
 174
 175 static struct CommandArgs_Impl g_command_args =
 176 {
 177     PTHREAD_MUTEX_INITIALIZER,
 178     0,
 179     0
 180 };
 181
 182 /***************************************
 183   osl_getExecutableFile().
 184  **************************************/
 185 oslProcessError SAL_CALL osl_getExecutableFile (rtl_uString ** ppustrFile)
 186 {
 187     oslProcessError result = osl_Process_E_NotFound;
 188
 189     pthread_mutex_lock (&(g_command_args.m_mutex));
 190     if (g_command_args.m_nCount > 0)
 191     {
 192         /* CommandArgs set. Obtain argv[0]. */
 193         rtl_uString_assign (ppustrFile, g_command_args.m_ppArgs[0]);
 194         result = osl_Process_E_None;
 195     }
 196     pthread_mutex_unlock (&(g_command_args.m_mutex));
 197
 198     return (result);
 199 }
 200
 201 /***************************************
 202  osl_getCommandArgCount().
 203  **************************************/
 204 sal_uInt32 SAL_CALL osl_getCommandArgCount (void)
 205 {
 206     sal_uInt32 result = 0;
 207
 208     pthread_mutex_lock (&(g_command_args.m_mutex));
 209     if (g_command_args.m_nCount > 0)
 210         result = g_command_args.m_nCount - 1;
 211     pthread_mutex_unlock (&(g_command_args.m_mutex));
 212
 213     return (result);
 214 }
 215
 216 /***************************************
 217  osl_getCommandArg().
 218  **************************************/
 219 oslProcessError SAL_CALL osl_getCommandArg (sal_uInt32 nArg, rtl_uString ** strCommandArg)
 220 {
 221     oslProcessError result = osl_Process_E_NotFound;
 222
 223     pthread_mutex_lock (&(g_command_args.m_mutex));
 224     if (g_command_args.m_nCount > (nArg + 1))
 225     {
 226         rtl_uString_assign (strCommandArg, g_command_args.m_ppArgs[nArg + 1]);
 227         result = osl_Process_E_None;
 228     }
 229     pthread_mutex_unlock (&(g_command_args.m_mutex));
 230
 231     return (result);
 232 }
 233
 234 /***************************************
 235  osl_setCommandArgs().
 236  **************************************/
 237 void SAL_CALL osl_setCommandArgs (int argc, char ** argv)
 238 {
 239     pthread_mutex_lock (&(g_command_args.m_mutex));
 240     OSL_ENSURE (g_command_args.m_nCount == 0, "osl_setCommandArgs(): CommandArgs already set.");
 241     if (g_command_args.m_nCount == 0)
 242     {
 243         rtl_uString** ppArgs = (rtl_uString**)rtl_allocateZeroMemory (argc * sizeof(rtl_uString*));
 244         if (ppArgs != 0)
 245         {
 246             rtl_TextEncoding encoding = osl_getThreadTextEncoding();
 247             for (int i = 0; i < argc; i++)
 248             {
 249                 rtl_string2UString (
 250                     &(ppArgs[i]),
 251                     argv[i], rtl_str_getLength (argv[i]), encoding,
 252                     OSTRING_TO_OUSTRING_CVTFLAGS);
 253             }
 254             if (ppArgs[0] != 0)
 255             {
 256                 /* see @ osl_getExecutableFile(). */
 257                 if (rtl_ustr_indexOfChar (rtl_uString_getStr(ppArgs[0]), sal_Unicode('/')) == -1)
 258                 {
 259                     const rtl::OUString PATH (RTL_CONSTASCII_USTRINGPARAM("PATH"));
 260
 261                     rtl_uString * pSearchPath = 0;
 262                     osl_getEnvironment (PATH.pData, &pSearchPath);
 263                     if (pSearchPath)
 264                     {
 265                         rtl_uString * pSearchResult = 0;
 266                         osl_searchPath (ppArgs[0], pSearchPath, &pSearchResult);
 267                         if (pSearchResult)
 268                         {
 269                             rtl_uString_assign (&(ppArgs[0]), pSearchResult);
 270                             rtl_uString_release (pSearchResult);
 271                         }
 272                         rtl_uString_release (pSearchPath);
 273                     }
 274                 }
 275
 276                 rtl_uString * pArg0 = 0;
 277                 if (realpath_u (ppArgs[0], &pArg0))
 278                 {
 279                     osl_getFileURLFromSystemPath (pArg0, &(ppArgs[0]));
 280                     rtl_uString_release (pArg0);
 281                 }
 282             }
 283             g_command_args.m_nCount = argc;
 284             g_command_args.m_ppArgs = ppArgs;
 285         }
 286     }
 287     pthread_mutex_unlock (&(g_command_args.m_mutex));
 288 }
 289
 290 /***************************************
 291  osl_getEnvironment().
 292  **************************************/
 293 oslProcessError SAL_CALL osl_getEnvironment(rtl_uString* pustrEnvVar, rtl_uString** ppustrValue)
 294 {
 295     oslProcessError  result   = osl_Process_E_NotFound;
 296     rtl_TextEncoding encoding = osl_getThreadTextEncoding();
 297     rtl_String* pstr_env_var  = 0;
 298
 299     OSL_PRECOND(pustrEnvVar, "osl_getEnvironment(): Invalid parameter");
 300     OSL_PRECOND(ppustrValue, "osl_getEnvironment(): Invalid parameter");
 301
 302     rtl_uString2String(
 303         &pstr_env_var,
 304         rtl_uString_getStr(pustrEnvVar), rtl_uString_getLength(pustrEnvVar), encoding,
 305         OUSTRING_TO_OSTRING_CVTFLAGS);
 306     if (pstr_env_var != 0)
 307     {
 308         const char* p_env_var = getenv (rtl_string_getStr (pstr_env_var));
 309         if (p_env_var != 0)
 310         {
 311             rtl_string2UString(
 312                 ppustrValue,
 313                 p_env_var, strlen(p_env_var), encoding,
 314                 OSTRING_TO_OUSTRING_CVTFLAGS);
 315             OSL_ASSERT(*ppustrValue != NULL);
 316
 317             result = osl_Process_E_None;
 318         }
 319         rtl_string_release(pstr_env_var);
 320     }
 321
 322     return (result);
 323 }
 324
 325 /***************************************
 326  osl_getProcessWorkingDir().
 327  **************************************/
 328 oslProcessError SAL_CALL osl_getProcessWorkingDir(rtl_uString **ppustrWorkingDir)
 329 {
 330     oslProcessError result = osl_Process_E_Unknown;
 331     char buffer[PATH_MAX];
 332
 333     OSL_PRECOND(ppustrWorkingDir, "osl_getProcessWorkingDir(): Invalid parameter");
 334
 335     if (getcwd (buffer, sizeof(buffer)) != 0)
 336     {
 337         rtl_uString* ustrTmp = 0;
 338
 339         rtl_string2UString(
 340             &ustrTmp,
 341             buffer, strlen(buffer), osl_getThreadTextEncoding(),
 342             OSTRING_TO_OUSTRING_CVTFLAGS);
 343         if (ustrTmp != 0)
 344         {
 345             if (osl_getFileURLFromSystemPath (ustrTmp, ppustrWorkingDir) == osl_File_E_None)
 346                 result = osl_Process_E_None;
 347             rtl_uString_release (ustrTmp);
 348         }
 349     }
 350
 351     return (result);
 352 }
 353
 354 /******************************************************************************
 355  *
 356  *              new functions to set/return the current process locale
 357  *
 358  *****************************************************************************/
 359
 360 struct ProcessLocale_Impl
 361 {
 362     pthread_mutex_t m_mutex;
 363     rtl_Locale *    m_pLocale;
 364 };
 365
 366 static struct ProcessLocale_Impl g_process_locale =
 367 {
 368     PTHREAD_MUTEX_INITIALIZER,
 369     0
 370 };
 371
 372 extern "C" void _imp_getProcessLocale( rtl_Locale ** );
 373 extern "C" int  _imp_setProcessLocale( rtl_Locale * );
 374
 375 /**********************************************
 376  osl_getProcessLocale().
 377  *********************************************/
 378 oslProcessError SAL_CALL osl_getProcessLocale( rtl_Locale ** ppLocale )
 379 {
 380     OSL_PRECOND(ppLocale, "osl_getProcessLocale(): Invalid parameter.");
 381
 382     pthread_mutex_lock(&(g_process_locale.m_mutex));
 383
 384     if (g_process_locale.m_pLocale == 0)
 385         _imp_getProcessLocale (&(g_process_locale.m_pLocale));
 386     *ppLocale = g_process_locale.m_pLocale;
 387
 388     pthread_mutex_unlock (&(g_process_locale.m_mutex));
 389
 390     return (osl_Process_E_None);
 391 }
 392
 393 /**********************************************
 394  osl_setProcessLocale().
 395  *********************************************/
 396 oslProcessError SAL_CALL osl_setProcessLocale( rtl_Locale * pLocale )
 397 {
 398     oslProcessError result = osl_Process_E_Unknown;
 399
 400     OSL_PRECOND(pLocale, "osl_setProcessLocale(): Invalid parameter.");
 401
 402     pthread_mutex_lock(&(g_process_locale.m_mutex));
 403     if (_imp_setProcessLocale (pLocale) == 0)
 404     {
 405         g_process_locale.m_pLocale = pLocale;
 406         result = osl_Process_E_None;
 407     }
 408     pthread_mutex_unlock (&(g_process_locale.m_mutex));
 409
 410     return (result);
 411 }