sal/osl/w32/procimpl.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 #define UNICODE
  31 #define _UNICODE
  32
  33 #ifndef WIN32_LEAN_AND_MEAN
  34 #   define WIN32_LEAN_AND_MEAN
  35 # ifdef _MSC_VER
  36 #   pragma warning(push,1) /* disable warnings within system headers */
  37 # endif
  38 #   include <windows.h>
  39 # ifdef _MSC_VER
  40 #   pragma warning(pop)
  41 # endif
  42 #   include <tchar.h>
  43 #   undef WIN32_LEAN_AND_MEAN
  44 #endif
  45 #include "procimpl.h"
  46 #include <rtl/ustring.hxx>
  47 #include <rtl/ustrbuf.hxx>
  48 #include "secimpl.h"
  49 #include "rtl/allocator.hxx"
  50 #include <osl/file.hxx>
  51
  52 #include <list>
  53 #include <vector>
  54 #include <algorithm>
  55 #include <string>
  56
  57 //#################################################
  58 extern "C" oslFileHandle SAL_CALL osl_createFileHandleFromOSHandle( HANDLE hFile, sal_uInt32 uFlags );
  59
  60 //#################################################
  61 const sal_Unicode NAME_VALUE_SEPARATOR = TEXT('=');
  62 const sal_Char* SPACE = " ";
  63 const rtl::OUString ENV_COMSPEC ("COMSPEC");
  64 const rtl::OUString QUOTE("\"");
  65
  66 namespace /* private */
  67 {
  68     //#################################################
  69     typedef std::list<rtl::OUString> string_container_t;
  70     typedef string_container_t::iterator string_container_iterator_t;
  71     typedef string_container_t::const_iterator string_container_const_iterator_t;
  72     typedef std::pair<string_container_iterator_t, string_container_iterator_t> iterator_pair_t;
  73     typedef std::vector<sal_Unicode> environment_container_t;
  74
  75     //#################################################
  76     /* Function object that compares two strings that are
  77        expected to be environment variables in the form
  78        "name=value". Only the 'name' part will be compared.
  79        The comparison is in upper case and returns true
  80        if the first of both strings is less than the
  81        second one. */
  82     struct less_environment_variable :
  83         public std::binary_function<rtl::OUString, rtl::OUString, bool>
  84     {
  85         bool operator() (const rtl::OUString& lhs, const rtl::OUString& rhs) const
  86         {
  87             OSL_ENSURE((lhs.indexOf(NAME_VALUE_SEPARATOR) > -1) && \
  88                         (rhs.indexOf(NAME_VALUE_SEPARATOR) > -1), \
  89                         "Malformed environment variable");
  90
  91             // Windows compares environment variables uppercase
  92             // so we do it, too
  93             return (rtl_ustr_compare_WithLength(
  94                 lhs.toAsciiUpperCase().pData->buffer,
  95                 lhs.indexOf(NAME_VALUE_SEPARATOR),
  96                 rhs.toAsciiUpperCase().pData->buffer,
  97                 rhs.indexOf(NAME_VALUE_SEPARATOR)) < 0);
  98         }
  99     };
 100
 101     //#################################################
 102     /* Function object used by for_each algorithm to
 103        calculate the sum of the length of all strings
 104        in a string container. */
 105     class sum_of_string_lengths
 106     {
 107     public:
 108         //--------------------------------
 109         sum_of_string_lengths() : sum_(0) {}
 110
 111         //--------------------------------
 112         void operator() (const rtl::OUString& string)
 113         {
 114             OSL_ASSERT(string.getLength());
 115
 116             // always include the terminating '\0'
 117             if (string.getLength())
 118                 sum_ += string.getLength() + 1;
 119         }
 120
 121         //--------------------------------
 122         operator size_t () const
 123         {
 124             return sum_;
 125         }
 126     private:
 127         size_t sum_;
 128     };
 129
 130     //#################################################
 131     inline size_t calc_sum_of_string_lengths(const string_container_t& string_cont)
 132     {
 133         return std::for_each(
 134             string_cont.begin(), string_cont.end(), sum_of_string_lengths());
 135     }
 136
 137     //#################################################
 138     void read_environment(/*out*/ string_container_t* environment)
 139     {
 140         // GetEnvironmentStrings returns a sorted list, Windows
 141         // sorts environment variables upper case
 142         LPTSTR env = reinterpret_cast<LPTSTR>(GetEnvironmentStrings());
 143         LPTSTR p   = env;
 144
 145         while (size_t l = _tcslen(p))
 146         {
 147             environment->push_back(reinterpret_cast<const sal_Unicode*>(p));
 148             p += l + 1;
 149         }
 150         FreeEnvironmentStrings(env);
 151     }
 152
 153     //#################################################
 154     /* the environment list must be sorted, new values
 155     should either replace existing ones or should be
 156     added to the list, environment variables will
 157     be handled case-insensitive */
 158     bool create_merged_environment(
 159         rtl_uString* env_vars[],
 160         sal_uInt32 env_vars_count,
 161         /*in|out*/ string_container_t* merged_env)
 162     {
 163         OSL_ASSERT(env_vars && env_vars_count > 0 && merged_env);
 164
 165         read_environment(merged_env);
 166
 167         for (sal_uInt32 i = 0; i < env_vars_count; i++)
 168         {
 169             rtl::OUString env_var = rtl::OUString(env_vars[i]);
 170
 171             if (env_var.getLength() == 0)
 172                 return false;
 173
 174             iterator_pair_t iter_pair = std::equal_range(
 175                 merged_env->begin(),
 176                 merged_env->end(),
 177                 env_var,
 178                 less_environment_variable());
 179
 180             if (env_var.indexOf(NAME_VALUE_SEPARATOR) == -1)
 181             {
 182                 merged_env->erase(iter_pair.first, iter_pair.second);
 183             }
 184             else
 185             {
 186                 if (iter_pair.first != iter_pair.second) // found
 187                     *iter_pair.first = env_var;
 188                 else // not found
 189                     merged_env->insert(iter_pair.first, env_var);
 190             }
 191         }
 192         return true;
 193     }
 194
 195     //#################################################
 196     /* Create a merged environment */
 197     bool setup_process_environment(
 198         rtl_uString* environment_vars[],
 199         sal_uInt32 n_environment_vars,
 200         /*in|out*/ environment_container_t& environment)
 201     {
 202         string_container_t merged_env;
 203         if (!create_merged_environment(environment_vars, n_environment_vars, &merged_env))
 204             return false;
 205
 206         // allocate enough space for the '\0'-separated environment strings and
 207         // a final '\0'
 208         environment.resize(calc_sum_of_string_lengths(merged_env) + 1);
 209
 210         string_container_const_iterator_t iter = merged_env.begin();
 211         string_container_const_iterator_t iter_end = merged_env.end();
 212
 213         sal_uInt32 pos = 0;
 214         for (/**/; iter != iter_end; ++iter)
 215         {
 216             rtl::OUString envv = *iter;
 217
 218             OSL_ASSERT(envv.getLength());
 219
 220             sal_uInt32 n = envv.getLength() + 1; // copy the final '\0', too
 221             rtl_copyMemory(
 222                 reinterpret_cast<void*>(&environment[pos]),
 223                 reinterpret_cast<const void*>(envv.getStr()),
 224                 n * sizeof(sal_Unicode));
 225             pos += n;
 226         }
 227         environment[pos] = 0; // append a final '\0'
 228
 229         return true;
 230     }
 231
 232     //##########################################################
 233     /*  In contrast to the Win32 API function CreatePipe with
 234         this function the caller is able to determine separately
 235         which handle of the pipe is inheritable. */
 236     bool create_pipe(
 237         PHANDLE p_read_pipe,
 238         bool    b_read_pipe_inheritable,
 239         PHANDLE p_write_pipe,
 240         bool    b_write_pipe_inheritable,
 241         LPVOID  p_security_descriptor = NULL,
 242         DWORD   pipe_size = 0)
 243     {
 244         SECURITY_ATTRIBUTES sa;
 245         sa.nLength              = sizeof(SECURITY_ATTRIBUTES);
 246         sa.lpSecurityDescriptor = p_security_descriptor;
 247         sa.bInheritHandle       = b_read_pipe_inheritable || b_write_pipe_inheritable;
 248
 249         BOOL   bRet  = FALSE;
 250         HANDLE hTemp = NULL;
 251
 252         if (!b_read_pipe_inheritable && b_write_pipe_inheritable)
 253         {
 254             bRet = CreatePipe(&hTemp, p_write_pipe, &sa, pipe_size);
 255
 256             if (bRet && !DuplicateHandle(GetCurrentProcess(), hTemp,
 257                             GetCurrentProcess(), p_read_pipe, 0, FALSE,
 258                             DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS))
 259             {
 260                 CloseHandle(hTemp);
 261                 CloseHandle(*p_read_pipe);
 262                 return false;
 263             }
 264         }
 265         else if (b_read_pipe_inheritable && !b_write_pipe_inheritable)
 266         {
 267             bRet = CreatePipe(p_read_pipe, &hTemp, &sa, pipe_size);
 268
 269             if (bRet && !DuplicateHandle(GetCurrentProcess(), hTemp,
 270                             GetCurrentProcess(), p_write_pipe, 0, FALSE,
 271                             DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS))
 272             {
 273                 CloseHandle(hTemp);
 274                 CloseHandle(*p_write_pipe);
 275                 return false;
 276             }
 277         }
 278         else
 279         {
 280             bRet = CreatePipe(p_read_pipe, p_write_pipe, &sa, pipe_size);
 281         }
 282         return bRet;
 283     }
 284
 285     //#########################################################
 286     // Add a quote sign to the start and the end of a string
 287     // if not already present
 288     rtl::OUString quote_string(const rtl::OUString& string)
 289     {
 290         rtl::OUStringBuffer quoted;
 291         if (string.indexOf(QUOTE) != 0)
 292             quoted.append(QUOTE);
 293
 294         quoted.append(string);
 295
 296         if (string.lastIndexOf(QUOTE) != (string.getLength() - 1))
 297             quoted.append(QUOTE);
 298
 299         return quoted.makeStringAndClear();
 300     }
 301
 302     //The parameter path must be a system path. If it is longer than 260 characters
 303     //then it is shortened using the GetShortPathName function. This function only
 304     //works if the path exists. Because "path" can be the path to an executable, it
 305     //may not have the file extension ".exe". However, if the file on disk has the
 306     //".exe" extension, then the function will fail. In this case a second attempt
 307     //is started by adding the parameter "extension" to "path".
 308     rtl::OUString getShortPath(rtl::OUString const & path, rtl::OUString const & extension)
 309     {
 310         rtl::OUString ret(path);
 311         if (path.getLength() > 260)
 312         {
 313             std::vector<sal_Unicode> vec(path.getLength() + 1);
 314             //GetShortPathNameW only works if the file can be found!
 315             const DWORD len = GetShortPathNameW(
 316                 reinterpret_cast<LPCWSTR>(path.getStr()), reinterpret_cast<LPWSTR>(&vec[0]), path.getLength() + 1);
 317
 318             if (!len && GetLastError() == ERROR_FILE_NOT_FOUND
 319                 && extension.getLength())
 320             {
 321                 const rtl::OUString extPath(path + extension);
 322                 std::vector<sal_Unicode> vec2(
 323                     extPath.getLength() + 1);
 324                 const DWORD len2 = GetShortPathNameW(
 325                     reinterpret_cast<LPCWSTR>(extPath.getStr()), reinterpret_cast<LPWSTR>(&vec2[0]), extPath.getLength() + 1);
 326                 ret = rtl::OUString(&vec2[0], len2);
 327             }
 328             else
 329             {
 330                 ret = rtl::OUString(&vec[0], len);
 331             }
 332         }
 333         return ret;
 334     }
 335     //##########################################################
 336     // Returns the system path of the executable which can either
 337     // be provided via the strImageName parameter or as first
 338     // element of the strArguments list.
 339     // The returned path will be quoted if it contains spaces.
 340     rtl::OUString get_executable_path(
 341         rtl_uString* image_name,
 342         rtl_uString* cmdline_args[],
 343         sal_uInt32 n_cmdline_args,
 344         bool search_path)
 345     {
 346         rtl::OUString exe_name;
 347
 348         if (image_name)
 349             exe_name = image_name;
 350         else if (n_cmdline_args)
 351             exe_name = rtl::OUString(cmdline_args[0]);
 352
 353         rtl::OUString exe_url = exe_name;
 354         if (search_path)
 355             osl_searchFileURL(exe_name.pData, NULL, &exe_url.pData);
 356
 357         rtl::OUString exe_path;
 358         if (osl::FileBase::E_None != osl::FileBase::getSystemPathFromFileURL(exe_url, exe_path))
 359             return rtl::OUString();
 360
 361         exe_path = getShortPath(exe_path, rtl::OUString(".exe"));
 362
 363         if (exe_path.indexOf(' ') != -1)
 364             exe_path = quote_string(exe_path);
 365
 366         return exe_path;
 367     }
 368
 369     //##########################################################
 370     rtl::OUString get_file_extension(const rtl::OUString& file_name)
 371     {
 372         sal_Int32 index = file_name.lastIndexOf('.');
 373         if ((index != -1) && ((index + 1) < file_name.getLength()))
 374             return file_name.copy(index + 1);
 375
 376         return rtl::OUString();
 377     }
 378
 379     //##########################################################
 380     bool is_batch_file(const rtl::OUString& file_name)
 381     {
 382         rtl::OUString ext = get_file_extension(file_name);
 383         return (ext.equalsIgnoreAsciiCaseAsciiL(RTL_CONSTASCII_STRINGPARAM("bat")) ||
 384                 ext.equalsIgnoreAsciiCaseAsciiL(RTL_CONSTASCII_STRINGPARAM("cmd")) ||
 385                 ext.equalsIgnoreAsciiCaseAsciiL(RTL_CONSTASCII_STRINGPARAM("btm")));
 386     }
 387
 388     //##########################################################
 389     rtl::OUString get_batch_processor()
 390     {
 391         rtl::OUString comspec;
 392         osl_getEnvironment(ENV_COMSPEC.pData, &comspec.pData);
 393
 394         OSL_ASSERT(comspec.getLength());
 395
 396         /* check if comspec path contains blanks and quote it if any */
 397         if (comspec.indexOf(' ') != -1)
 398             comspec = quote_string(comspec);
 399
 400         return comspec;
 401     }
 402
 403 } // namespace private
 404
 405
 406 //#################################################
 407 oslProcessError SAL_CALL osl_executeProcess(
 408     rtl_uString *strImageName,
 409     rtl_uString *strArguments[],
 410     sal_uInt32   nArguments,
 411     oslProcessOption Options,
 412     oslSecurity Security,
 413     rtl_uString *strDirectory,
 414     rtl_uString *strEnvironmentVars[],
 415     sal_uInt32   nEnvironmentVars,
 416     oslProcess *pProcess
 417 )
 418 {
 419     return osl_executeProcess_WithRedirectedIO(
 420         strImageName,
 421         strArguments,
 422         nArguments,
 423         Options,
 424         Security,
 425         strDirectory,
 426         strEnvironmentVars,
 427         nEnvironmentVars,
 428         pProcess,
 429         NULL, NULL, NULL );
 430 }
 431
 432 //#################################################
 433 oslProcessError SAL_CALL osl_executeProcess_WithRedirectedIO(
 434     rtl_uString *ustrImageName,
 435     rtl_uString *ustrArguments[],
 436     sal_uInt32   nArguments,
 437     oslProcessOption Options,
 438     oslSecurity Security,
 439     rtl_uString *ustrDirectory,
 440     rtl_uString *ustrEnvironmentVars[],
 441     sal_uInt32 nEnvironmentVars,
 442     oslProcess *pProcess,
 443     oslFileHandle *pProcessInputWrite,
 444     oslFileHandle *pProcessOutputRead,
 445     oslFileHandle *pProcessErrorRead)
 446 {
 447     rtl::OUString exe_path = get_executable_path(
 448         ustrImageName, ustrArguments, nArguments, (Options & osl_Process_SEARCHPATH));
 449
 450     if (0 == exe_path.getLength())
 451         return osl_Process_E_NotFound;
 452
 453     if (pProcess == NULL)
 454         return osl_Process_E_InvalidError;
 455
 456     DWORD flags = NORMAL_PRIORITY_CLASS;
 457     rtl::OUStringBuffer command_line;
 458
 459     if (is_batch_file(exe_path))
 460     {
 461         rtl::OUString batch_processor = get_batch_processor();
 462
 463         if (batch_processor.getLength())
 464         {
 465             /* cmd.exe does not work without a console window */
 466             if (!(Options & osl_Process_WAIT) || (Options & osl_Process_DETACHED))
 467                 flags |= CREATE_NEW_CONSOLE;
 468
 469             command_line.append(batch_processor);
 470             command_line.appendAscii(" /c ");
 471         }
 472         else
 473             // should we return here in case of error?
 474             return osl_Process_E_Unknown;
 475     }
 476
 477     command_line.append(exe_path);
 478
 479     /* Add remaining arguments to command line. If ustrImageName is NULL
 480        the first parameter is the name of the executable so we have to
 481        start at 1 instead of 0 */
 482     for (sal_uInt32 n = (NULL != ustrImageName) ? 0 : 1; n < nArguments; n++)
 483     {
 484         command_line.appendAscii(SPACE);
 485
 486         /* Quote arguments containing blanks */
 487         if (rtl::OUString(ustrArguments[n]).indexOf(' ') != -1)
 488             command_line.append(quote_string(ustrArguments[n]));
 489         else
 490             command_line.append(ustrArguments[n]);
 491     }
 492
 493     environment_container_t environment;
 494     LPVOID p_environment = NULL;
 495
 496     if (nEnvironmentVars && ustrEnvironmentVars)
 497     {
 498         if (!setup_process_environment(
 499                 ustrEnvironmentVars, nEnvironmentVars, environment))
 500             return osl_Process_E_InvalidError;
 501
 502         flags |= CREATE_UNICODE_ENVIRONMENT;
 503         p_environment = &environment[0];
 504     }
 505
 506     rtl::OUString cwd;
 507     if (ustrDirectory && ustrDirectory->length && (osl::FileBase::E_None != osl::FileBase::getSystemPathFromFileURL(ustrDirectory, cwd)))
 508            return osl_Process_E_InvalidError;
 509
 510     LPCWSTR p_cwd = (cwd.getLength()) ? reinterpret_cast<LPCWSTR>(cwd.getStr()) : NULL;
 511
 512     if ((Options & osl_Process_DETACHED) && !(flags & CREATE_NEW_CONSOLE))
 513         flags |= DETACHED_PROCESS;
 514
 515     STARTUPINFO startup_info;
 516     memset(&startup_info, 0, sizeof(STARTUPINFO));
 517
 518     startup_info.cb        = sizeof(STARTUPINFO);
 519     startup_info.dwFlags   = STARTF_USESHOWWINDOW;
 520     startup_info.lpDesktop = const_cast<LPWSTR>(L"");
 521
 522     /* Create pipes for redirected IO */
 523     HANDLE hInputRead  = NULL;
 524     HANDLE hInputWrite = NULL;
 525     if (pProcessInputWrite && create_pipe(&hInputRead, true, &hInputWrite, false))
 526         startup_info.hStdInput = hInputRead;
 527
 528     HANDLE hOutputRead  = NULL;
 529     HANDLE hOutputWrite = NULL;
 530     if (pProcessOutputRead && create_pipe(&hOutputRead, false, &hOutputWrite, true))
 531         startup_info.hStdOutput = hOutputWrite;
 532
 533     HANDLE hErrorRead  = NULL;
 534     HANDLE hErrorWrite = NULL;
 535     if (pProcessErrorRead && create_pipe(&hErrorRead, false, &hErrorWrite, true))
 536         startup_info.hStdError = hErrorWrite;
 537
 538     bool b_inherit_handles = false;
 539     if (pProcessInputWrite || pProcessOutputRead || pProcessErrorRead)
 540     {
 541         startup_info.dwFlags |= STARTF_USESTDHANDLES;
 542         b_inherit_handles      = true;
 543     }
 544
 545     switch(Options & (osl_Process_NORMAL | osl_Process_HIDDEN | osl_Process_MINIMIZED | osl_Process_MAXIMIZED | osl_Process_FULLSCREEN))
 546     {
 547         case osl_Process_HIDDEN:
 548             startup_info.wShowWindow = SW_HIDE;
 549             flags |= CREATE_NO_WINDOW; // ignored for non-console
 550                                        // applications; ignored on
 551                                        // Win9x
 552             break;
 553
 554         case osl_Process_MINIMIZED:
 555             startup_info.wShowWindow = SW_MINIMIZE;
 556             break;
 557
 558         case osl_Process_MAXIMIZED:
 559         case osl_Process_FULLSCREEN:
 560             startup_info.wShowWindow = SW_MAXIMIZE;
 561             break;
 562
 563         default:
 564             startup_info.wShowWindow = SW_NORMAL;
 565     }
 566
 567     rtl::OUString cmdline = command_line.makeStringAndClear();
 568     PROCESS_INFORMATION process_info;
 569     BOOL bRet = FALSE;
 570
 571     if ((Security != NULL) && (((oslSecurityImpl*)Security)->m_hToken != NULL))
 572     {
 573         bRet = CreateProcessAsUser(
 574             ((oslSecurityImpl*)Security)->m_hToken,
 575             NULL, const_cast<LPTSTR>(reinterpret_cast<LPCTSTR>(cmdline.getStr())), NULL,  NULL,
 576             b_inherit_handles, flags, p_environment, p_cwd,
 577             &startup_info, &process_info);
 578     }
 579     else
 580     {
 581         bRet = CreateProcess(
 582             NULL, const_cast<LPTSTR>(reinterpret_cast<LPCTSTR>(cmdline.getStr())), NULL,  NULL,
 583             b_inherit_handles, flags, p_environment, p_cwd,
 584             &startup_info, &process_info);
 585     }
 586
 587     /* Now we can close the pipe ends that are used by the child process */
 588
 589     if (hInputRead)
 590         CloseHandle(hInputRead);
 591
 592     if (hOutputWrite)
 593         CloseHandle(hOutputWrite);
 594
 595     if (hErrorWrite)
 596         CloseHandle(hErrorWrite);
 597
 598     if (bRet)
 599     {
 600         CloseHandle(process_info.hThread);
 601
 602         oslProcessImpl* pProcImpl = reinterpret_cast<oslProcessImpl*>(
 603             rtl_allocateMemory(sizeof(oslProcessImpl)));
 604
 605         if (pProcImpl != NULL)
 606         {
 607             pProcImpl->m_hProcess  = process_info.hProcess;
 608             pProcImpl->m_IdProcess = process_info.dwProcessId;
 609
 610             *pProcess = (oslProcess)pProcImpl;
 611
 612             if (Options & osl_Process_WAIT)
 613                 WaitForSingleObject(pProcImpl->m_hProcess, INFINITE);
 614
 615             if (pProcessInputWrite)
 616                 *pProcessInputWrite = osl_createFileHandleFromOSHandle(hInputWrite, osl_File_OpenFlag_Write);
 617
 618             if (pProcessOutputRead)
 619                 *pProcessOutputRead = osl_createFileHandleFromOSHandle(hOutputRead, osl_File_OpenFlag_Read);
 620
 621             if (pProcessErrorRead)
 622                 *pProcessErrorRead = osl_createFileHandleFromOSHandle(hErrorRead, osl_File_OpenFlag_Read);
 623
 624             return osl_Process_E_None;
 625         }
 626     }
 627
 628     /* if an error occurred we have to close the server side pipe ends too */
 629
 630     if (hInputWrite)
 631         CloseHandle(hInputWrite);
 632
 633     if (hOutputRead)
 634         CloseHandle(hOutputRead);
 635
 636     if (hErrorRead)
 637         CloseHandle(hErrorRead);
 638
 639     return osl_Process_E_Unknown;
 640 }
 641
 642 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */