ScheduledTask.cpp

Go to the documentation of this file.

/* 
 * Confdump-Agent - Dump static and runtime system configuration
 * Copyright (C) 2009-2012  Straton IT, SAS
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <windows.h>
#include <initguid.h>
#include <ole2.h>
#include <mstask.h>
#include <msterr.h>

#include "QVariant"

#include "boost/shared_ptr.hpp"
#include "boost/shared_array.hpp"
#include "boost/foreach.hpp"
#include "boost/function.hpp"
#include "Confdump/System/WMI/errors.hpp"
#include "Confdump/System/Win32/ScheduledTask.hpp"

using boost::shared_ptr;
using boost::shared_array;
using Confdump::System::Wmi::ComContext;
using Confdump::System::Wmi::throwOnComError;
using Confdump::System::Wmi::guardComObject;

namespace Confdump
{

namespace System
{

namespace Win32
{

namespace
{

void freeFetchedTasks1( LPWSTR *tasks )
{
        if ( tasks )
        {
                CoTaskMemFree( tasks[0] );
                CoTaskMemFree( tasks );
    }
}

shared_ptr<ITaskScheduler> getTaskScheduler()
{
    ITaskScheduler *rawScheduler = 0;
    HRESULT hr = CoCreateInstance(
        CLSID_CTaskScheduler,
        0,
        CLSCTX_INPROC_SERVER,
        IID_ITaskScheduler,
        reinterpret_cast<void**>( &rawScheduler ) );
    throwOnComError( hr, "contact the Windows task scheduler" );
    shared_ptr<ITaskScheduler> scheduler = guardComObject( rawScheduler );

        return scheduler;
}

QStringList allTaskNames( shared_ptr<ITaskScheduler> scheduler )
{
    QStringList taskNames;

    IEnumWorkItems *rawEnumWI;
    HRESULT hr = scheduler->Enum( &rawEnumWI );
    throwOnComError( hr, "enumerate the Windows scheduled tasks" );
    shared_ptr<IEnumWorkItems> enumWI = guardComObject( rawEnumWI );

    for ( ;; )
    {
        LPWSTR *rawNames = 0;
        hr = enumWI->Next( 1, &rawNames, 0 );
        throwOnComError( hr, "enumerate the next Windows scheduled task" );
        shared_array<LPWSTR> names( rawNames, freeFetchedTasks1 );
        if ( hr != S_OK )
            break;
        taskNames << QString::fromWCharArray( names[0] );
    };

    return taskNames;
}

typedef boost::function< HRESULT( ITask*, LPWSTR *) > TaskStringGetter;

QString getStringProperty( shared_ptr<ITask> task, TaskStringGetter getter )
{
    LPWSTR rawString = 0;
    HRESULT hr = getter( task.get(), &rawString );
    // Scheduled tasks easily become corrupted, do not throw on error
    if ( SUCCEEDED( hr ) )
    {
                shared_array<wchar_t> str( rawString, CoTaskMemFree );
                return QString::fromWCharArray( str.get() );
        }
        else
        {
                return QString();
        }
}

QString getStatusString( shared_ptr<ITask> task )
{    
    HRESULT status = 0;
    HRESULT hr = task->GetStatus( &status );
    throwOnComError( hr, "get the status of a Windows Scheduled Task" );
    
    // Comments from http://msdn.microsoft.com/en-us/library/windows/desktop/aa381263%28v=VS.85%29.aspx
    switch ( status )
    {
    // The work item is ready to run at its next scheduled time.
    case SCHED_S_TASK_READY:             return "READY";
    // The work item is currently running.
    case SCHED_S_TASK_RUNNING:               return "RUNNING";
    // One or more of the properties that are needed to run this task on a schedule have not been set.
        case SCHED_S_TASK_NOT_SCHEDULED:     return "NOT_SCHEDULED";
        // The task has not been run. This value is returned whenever the task has not been run,
        // even if the task is ready to be run at the next scheduled time or the task is a recurring task.
        case SCHED_S_TASK_HAS_NOT_RUN:       return "HAS_NOT_RUN";
        // The task will not run at the scheduled times because it has been disabled.
        case SCHED_S_TASK_DISABLED:          return "DISABLED";
        // There are no more runs scheduled for this task.
        case SCHED_S_TASK_NO_MORE_RUNS:      return "NO_MORE_RUNS";
        // Either the task has no triggers or the existing triggers are disabled or not set.
        case SCHED_S_TASK_NO_VALID_TRIGGERS: return "NO_VALID_TRIGGERS";
        default:                             return QString();
    }
}

} // ns


Result ScheduledTask::allSystemInstances( Wmi::ComContext::Guard com )
{
        Result allTasks;

        shared_ptr<ITaskScheduler> scheduler = getTaskScheduler();
        
        QStringList allNames = allTaskNames( scheduler );
        BOOST_FOREACH( QString name, allNames )
        {
                Result::Row task( new ScheduledTask( com, name, scheduler ) );
                allTasks.push_back( task );
        }
        
        return allTasks;
}

ScheduledTask::ScheduledTask( Wmi::ComContext::Guard com, QString name, boost::shared_ptr<ITaskScheduler> scheduler )
{
        if ( !scheduler )
                scheduler = getTaskScheduler();

        ITask *rawTask;
        HRESULT hr = scheduler->Activate(
                name.toStdWString().c_str(),
        IID_ITask, reinterpret_cast<IUnknown**>( &rawTask ) );
        throwOnComError( hr, "acquire a task from the Windows Scheduler" );
        shared_ptr<ITask> task = guardComObject( rawTask );
  
    setProperty( "name", name );
    setProperty( "applicationName",    getStringProperty( task, &ITask::GetApplicationName ) );
    setProperty( "parameters",         getStringProperty( task, &ITask::GetParameters ) );
    setProperty( "workingDirectory",   getStringProperty( task, &ITask::GetWorkingDirectory ) );
    setProperty( "accountInformation", getStringProperty( task, &ITask::GetAccountInformation ) );
    setProperty( "comment",            getStringProperty( task, &ITask::GetComment ) );
    setProperty( "creator",            getStringProperty( task, &ITask::GetCreator ) );
    setProperty( "status",             getStatusString( task ) );
}

ScheduledTask::~ScheduledTask()
{
}

}
}
}