win32process.cpp

"More for C++" is a class library that provides some features that are usually common for object ori

//
//  This file is part of the "More for C++" library
//
//  Copyright (c) 1999-2003 by Thorsten Goertz ([e-mail])
//
//  The "More for C++" library is free software; you can redistribute it and/or
//  modify it under the terms of the license that comes with this package.
//
//  Read "license.txt" for more details.
//
//  THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
//  WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
//  OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

////////////////////////////////////////////////////////////////////////////////

#ifndef _WIN32
#define _WIN32
#endif

#ifndef _MT
#define _MT
#endif

#include <windows.h>
#include <process.h>
#include <more/create.hpp>
#include <more/synchronized.hpp>
#include <more/os/file.hpp>
#include "win32process.hpp"

using namespace more::os;
using namespace more::os::win32;
using namespace more::util;

////////////////////////////////////////////////////////////////////////////////

void Win32Process::setConsoleCtrlHandler
(
  const p<SignalHandler>& pSignalHandler
)
{
  CREATE ConsoleCtrlHandler( pSignalHandler );
  SetConsoleCtrlHandler( Win32Process::consoleCtrlHandler, TRUE );
}

////////////////////////////////////////////////////////////////////////////////

Win32Process::Win32Process
(
  const p<File>& pBinary
)
: m_pMutex( Mutex::create( ) ), m_pBinary( pBinary )
{
  m_processInfo.hProcess = INVALID_HANDLE_VALUE;
  m_processInfo.hThread = INVALID_HANDLE_VALUE;
}

////////////////////////////////////////////////////////////////////////////////

void Win32Process::finalize( )
{
  if( m_processInfo.hProcess != INVALID_HANDLE_VALUE )
  {
    CloseHandle( m_processInfo.hProcess );
  }

  if( m_processInfo.hThread != INVALID_HANDLE_VALUE )
  {
    CloseHandle( m_processInfo.hThread );
  }
}

////////////////////////////////////////////////////////////////////////////////

void Win32Process::execute
(
  const Array<String>& sArgV

) throw( more::io::IOException )
{
  synchronized( m_pMutex )
  {
    String        sBinary = m_pBinary -> getDescriptor( ) -> getFullName( );
    size_t        nPosOfSpace;
    String        sArgs;
    const char*   pcArgs;
    STARTUPINFO   startUpInfo;

    if( !m_pBinary -> exists( ) )
    {
      throw more::io::IOException( -1, "Binary \"" + sBinary + "\" does not exist" );
    }

    if( m_processInfo.hProcess != INVALID_HANDLE_VALUE )
    {
      throw more::io::IOException( -1, "Process already executing" );
    }

    if( sBinary.find( " ", 0, nPosOfSpace ) )
    {
      sArgs = "\"" + sBinary + "\"";
    }
    else
    {
      sArgs = sBinary;
    }

    for( size_t i = 0; i < sArgV.getLength( ); i++ )
    {
      if( sArgV[i].find( " ", 0, nPosOfSpace ) )
      {
        sArgs << " \"" << sArgV[i] << "\"";
      }
      else
      {
        sArgs << " " << sArgV[i];
      }
    }

    pcArgs = sArgs;

    memset( &startUpInfo, 0, sizeof( STARTUPINFO ) );
    startUpInfo.cb = sizeof( STARTUPINFO );

    if( CreateProcess( sBinary,
                       ( char* ) pcArgs,
                       NULL,
                       NULL,
                       FALSE,
                       0,
                       NULL,
                       NULL,
                       &startUpInfo,
                       &m_processInfo ) == FALSE
    )
    {
      throw more::io::IOException( -1, "CreateProcess( ... ) failed" );
    }

  } end_synchronized
}

////////////////////////////////////////////////////////////////////////////////

void Win32Process::terminate( )
{
  synchronized( m_pMutex )
  {
    if( m_processInfo.hProcess != INVALID_HANDLE_VALUE )
    {
      TerminateProcess( m_processInfo.hProcess, 0 );
    }

  } end_synchronized
}

////////////////////////////////////////////////////////////////////////////////

void Win32Process::join( )
{
  HANDLE hProcess = INVALID_HANDLE_VALUE;

  synchronized( m_pMutex )
  {
    hProcess = m_processInfo.hProcess;

  } end_synchronized

  if( hProcess != INVALID_HANDLE_VALUE )
  {
    WaitForSingleObject( hProcess, INFINITE );

    synchronized( m_pMutex )
    {
      CloseHandle( m_processInfo.hProcess );
      m_processInfo.hProcess = INVALID_HANDLE_VALUE;

    } end_synchronized
  }
}

////////////////////////////////////////////////////////////////////////////////

Win32Process::ConsoleCtrlHandler::ConsoleCtrlHandler
(
  const p<SignalHandler>& pSignalHandler
)
: m_pMutex( Mutex::create( ) ), m_pSignalHandler( pSignalHandler )
{
  Singleton<ConsoleCtrlHandler>::setInstance( this );
}

////////////////////////////////////////////////////////////////////////////////

void Win32Process::ConsoleCtrlHandler::handleSignal( )
{
  if( m_pSignalHandler != 0 )
  {
    synchronized( m_pMutex )
    {
      if( m_pSignalHandler != 0 )
      {
        try
        {
          m_pSignalHandler -> onSignal( );
        }
        catch( ... )
        {
        }
      }

    } end_synchronized
  }
}

////////////////////////////////////////////////////////////////////////////////

BOOL WINAPI Win32Process::consoleCtrlHandler
(
  DWORD nEvent
)
{
  static bool bHandled = false;

  if( !bHandled )
  {
    bHandled = true;

    Singleton<ConsoleCtrlHandler>::getInstance( ) -> handleSignal( );
  }

  return TRUE;
}

////////////////////////////////////////////////////////////////////////////////