windows-xp/Source/XPSP1/NT/shell/osshell/themes/themesw/schedule.cpp

// File:        schedule.cpp
//
// Contents:    Functions needed to start, query, add, remove tasks
//              in Task Scheduler
//
// Microsoft Desktop Themes for Windows
// Copyright (c) 1998-1999 Microsoft Corporation.  All rights reserved.

#include <wchar.h>
#include <windows.h>
#include <mbctype.h>
#include <objbase.h>
#include <initguid.h>
#include <mstask.h>
#include <msterr.h>
#include "frost.h"

#define MSG_BOX_TSERR(hw,msg) MessageBox(hw, msg, szThemeName,\
                            MB_OK | MB_ICONERROR | MB_APPLMODAL)


#define SCHED_CLASS             TEXT("SAGEWINDOWCLASS")
#define SCHED_TITLE             TEXT("SYSTEM AGENT COM WINDOW")
#define SCHED_SERVICE_APP_NAME  TEXT("mstask.exe")
#define SCHED_SERVICE_NAME      TEXT("Schedule")
#define EVERY_MONTH (TASK_JANUARY | TASK_FEBRUARY | TASK_MARCH | TASK_APRIL |\
                     TASK_MAY | TASK_JUNE | TASK_JULY | TASK_AUGUST |\
                     TASK_SEPTEMBER | TASK_OCTOBER | TASK_NOVEMBER |\
                     TASK_DECEMBER)

//+--------------------------------------------------------------------------
// Global variables defined in GLOBAL.H for compat. with C sources
//---------------------------------------------------------------------------

extern "C" HWND hWndApp = NULL;
extern "C" HINSTANCE hInstApp = NULL;

//+--------------------------------------------------------------------------
// Global variables for use in SCHEDULE.CPP only
//---------------------------------------------------------------------------

ITaskScheduler *g_pITaskScheduler = NULL;
TCHAR szRunServices[] = TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunServices");
TCHAR szScheduler[] = TEXT("SchedulingAgent");
TCHAR szMSTask[] = TEXT("mstask.exe");
TCHAR szUserName[MAX_PATH];
TCHAR szPassword[MAX_PATH];

//+--------------------------------------------------------------------------
// Function Prototypes
//---------------------------------------------------------------------------

HRESULT Init(void);
void Cleanup(void);
extern "C" BOOL IsTaskSchedulerRunning();
extern "C" BOOL StartTaskScheduler(BOOL);
extern "C" BOOL IsThemesScheduled();
extern "C" BOOL AddThemesTask(LPTSTR, BOOL);
extern "C" BOOL DeleteThemesTask();
extern "C" BOOL HandDeleteThemesTask();
extern "C" BOOL IsPlatformNT();
extern "C" BOOL GetCurrentUser(LPTSTR, DWORD, LPTSTR, DWORD, LPTSTR, DWORD);
extern "C" BOOL GetTextualSid(PSID, LPTSTR, LPDWORD);
extern "C" VOID BuildNTJobName(LPTSTR);
extern "C" BOOL IsUserAdmin();

//+--------------------------------------------------------------------------
//
// Function:        PasswordDlgProc()
//
// Synopsis:        WINNT only -- prompts user for name and password.
//
// Arguments:       none (void)
//
//---------------------------------------------------------------------------

INT_PTR CALLBACK PasswordDlgProc(HWND hDlg,
                                 UINT uMsg,
                                 WPARAM wParam,
                                 LPARAM lParam)
{
    TCHAR szPWConfirm[MAX_PATH];
    TCHAR szErrMsg[MAX_PATH];
    TCHAR szThemeName[MAX_STRLEN];  // Used for msgbox title
    DWORD dwSize = 0;
    TCHAR szProfile[MAX_PATH];

    switch(uMsg)

    {

          case WM_INITDIALOG:

                 if (GetCurrentUser(szPassword, /* Actually user name   */
                                    ARRAYSIZE(szPassword),
                                    szUserName, /* Actually domain name */
                                    ARRAYSIZE(szUserName),
                                    szProfile,
                                    ARRAYSIZE(szProfile)))
                 {
                    // GetCurrentUser succeeded so build the domain\user
                    //
                    // Remember these variable names are bogus --
                    // szUserName is actually the domain name
                    // szPassword is actually the user name
                    //

                    if (szPassword[0]) lstrcat(szUserName, TEXT("\\"));
                    lstrcat(szUserName, szPassword);
                 }
                 else
                 {
                    // GetCurrentUser failed so do this as last resort
                    dwSize = ARRAYSIZE(szUserName);
                    GetUserName(szUserName, &dwSize);
                 }
                 *szPassword = 0;

                 SetDlgItemText(hDlg, EDIT_USER, szUserName);
                 SetFocus(GetDlgItem(hDlg, EDIT_PW));

                 return FALSE;  // Return false to keep focus on PW control
                 break;


           case WM_COMMAND:

                 switch (wParam)

                 {

                      case IDOK:
                           GetDlgItemText(hDlg, EDIT_USER, szUserName, MAX_PATH);
                           GetDlgItemText(hDlg, EDIT_PW, szPassword, MAX_PATH);
                           GetDlgItemText(hDlg, EDIT_PWCONFIRM, szPWConfirm, MAX_PATH);

                           if (lstrcmp(szPassword, szPWConfirm))
                           {
                              // PW and PWCONFIRM don't match

                              LoadString(hInstApp, STR_APPNAME, szThemeName, MAX_STRLEN);
                              LoadString(hInstApp, STR_PW_NOMATCH, szErrMsg, MAX_PATH);
                              MessageBox(hWndApp, szErrMsg, szThemeName,
                                         MB_OK | MB_ICONERROR | MB_APPLMODAL);
                              SetDlgItemText(hDlg, EDIT_PW, TEXT("\0"));
                              SetDlgItemText(hDlg, EDIT_PWCONFIRM, TEXT("\0"));
                              SetActiveWindow(GetDlgItem(hDlg, EDIT_PW));
                              SetFocus(GetDlgItem(hDlg, EDIT_PW));
                              break;
                           }

                           else

                           {
                              EndDialog(hDlg,1);
                              break;
                           }

                      case IDCANCEL:
                           szUserName[0] = TEXT('\0');
                           szPassword[0] = TEXT('\0');
                           EndDialog(hDlg, 0);
                           break;
                 }

                 break;

           default:
                 return FALSE;

    } // switch uMsg

    return TRUE;

} // PasswordDlgProc


//+--------------------------------------------------------------------------
//
// Function:        IsPlatformNT()
//
// Synopsis:        Checks to see if the os is NT or not.
//
// Arguments:       none (void)
//
// Returns:         TRUE if NT, FALSE if not.
//
//---------------------------------------------------------------------------

extern "C" BOOL IsPlatformNT()
{
    OSVERSIONINFO        osver;

    osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

    // Determine what version of OS we are running on.
    GetVersionEx(&osver);

    if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT)
       return TRUE;
    else
       return FALSE;
}

//+--------------------------------------------------------------------------
//
// Function:        IsTaskSchedulerRunning()
//
// Synopsis:        Looks for TS window to determince TS is running.
//
// Arguments:       none (void)
//
// Returns:         TRUE if running, FALSE if not.
//
//---------------------------------------------------------------------------

extern "C" BOOL IsTaskSchedulerRunning()
{
   HWND hwnd = FindWindow(SCHED_CLASS, SCHED_TITLE);

   if (hwnd == NULL)
   {
      //MessageBox(hWndApp, TEXT("TS is not running"), TEXT("Desktop Themes"), MB_OK | MB_APPLMODAL);
      return FALSE;
   }
   else
   {
      //MessageBox(hWndApp, TEXT("TS is running"), TEXT("Desktop Themes"), MB_OK | MB_APPLMODAL);
      return TRUE;
   }
}

//---------------------------------------------------------------------------
//  Function:   StartTaskScheduler
//  Synopsis:   Start the task scheduler service if it isn't already running.
//  Arguments:  bPrompt -- TRUE == prompt user before starting.
//                         FALSE == just start it, don't prompt user.
//  Returns:    TRUE if successful, FALSE if not.
//  Notes:      This function works in Win9x only.
//              If the service is running but paused, does nothing.
//---------------------------------------------------------------------------

extern "C" BOOL StartTaskScheduler(BOOL bPrompt)
{
    STARTUPINFO          sui;
    PROCESS_INFORMATION  pi;
    TCHAR                szApp[MAX_PATH];
    LPTSTR               pszPath;
    DWORD                dwRet;
    BOOL                 fRet;
    TCHAR                szErrMsg[MAX_PATH];
    TCHAR                szThemeName[MAX_STRLEN]; // Used for msgbox title
    int                  MBChoice;  // User's reply to Yes/No dialog
    DWORD                dwDisposition;
    HKEY                 hKey;
    LONG                 lret;

    LoadString(hInstApp, STR_APPNAME, szThemeName, MAX_STRLEN);

    HWND hwnd = FindWindow(SCHED_CLASS, SCHED_TITLE);
    if (hwnd != NULL) {
       // It is already running.
       return TRUE;
    }

    // If specified, prompt user before attempting to start
    // Task Scheduler.

    if (bPrompt) {
       LoadString(hInstApp, STR_ERRTSNOTRUN, szErrMsg, MAX_PATH);
       MBChoice = MessageBox(hWndApp, szErrMsg, szThemeName,
                           MB_YESNO | MB_ICONQUESTION | MB_APPLMODAL);

       // Did user opt to NOT start task scheduler?
       if (IDYES != MBChoice) return FALSE;
    }

    if (!IsPlatformNT()) {

       // Start the Win9x version of TaskScheduler.
       //  Execute the task scheduler process.

       ZeroMemory(&sui, sizeof(sui));
       sui.cb = sizeof(STARTUPINFO);

       dwRet = SearchPath(NULL,
                          SCHED_SERVICE_APP_NAME,
                          NULL,
                          MAX_PATH,
                          szApp,
                          &pszPath);

       if (dwRet == 0) {
           LoadString(hInstApp, STR_ERRTSNOTFOUND, szErrMsg, MAX_PATH);
           MessageBox(hWndApp, szErrMsg, szThemeName,
                         MB_OK | MB_ICONERROR | MB_APPLMODAL);
           return FALSE;
       }

       fRet = CreateProcess(szApp,
                            NULL,
                            NULL,
                            NULL,
                            FALSE,
                            CREATE_NEW_CONSOLE | CREATE_NEW_PROCESS_GROUP,
                            NULL,
                            NULL,
                            &sui,
                            &pi);

       if (fRet == 0) {
           LoadString(hInstApp, STR_ERRTSNOSTART, szErrMsg, MAX_PATH);
           MessageBox(hWndApp, szErrMsg, szThemeName,
                             MB_OK | MB_ICONERROR | MB_APPLMODAL);
           return FALSE;
       }

       CloseHandle(pi.hProcess);
       CloseHandle(pi.hThread);

       // Assume that MSTASK.EXE was successfully started.  We need to
       // add mstask.exe to the RunServices branch of the registry.

       hKey = NULL;
       lret = RegCreateKeyEx(HKEY_LOCAL_MACHINE,
                             szRunServices,
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             KEY_WRITE,
                             NULL,
                             &hKey,
                             &dwDisposition);

       if (lret == ERROR_SUCCESS) {
          // RegDeleteValue(hKey, szScheduler);
          lret = RegSetValueEx(hKey,
                               szScheduler,
                               0,
                               REG_SZ,
                               (CONST BYTE *)szMSTask,
                               SZSIZEINBYTES(szMSTask));
       }

       if (hKey) RegCloseKey(hKey);

       return TRUE;
    }
    else
    {

       // If not Win9x then start the NT version as a TaskScheduler service.

       SC_HANDLE   hSC = NULL;
       SC_HANDLE   hSchSvc = NULL;

       // Does the user have administrative privileges?  If not, the
       // user can't start TS.

       if (!IsUserAdmin())
       {
          LoadString(hInstApp, STR_ERRTSNOTADMIN, szErrMsg, MAX_PATH);
          MessageBox(hWndApp, szErrMsg, szThemeName,
                             MB_OK | MB_ICONERROR | MB_APPLMODAL);
          return FALSE;
       }


       hSC = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);

       if (hSC == NULL)
       {

          return FALSE;
// NEED TO ADD ERROR DIALOG HERE
//        return GetLastError();
       }

       hSchSvc = OpenService(hSC,
                             SCHED_SERVICE_NAME,
                             SERVICE_START | SERVICE_QUERY_STATUS);

       CloseServiceHandle(hSC);

       if (hSchSvc == NULL)
       {
          LoadString(hInstApp, STR_ERRTSNOSTART, szErrMsg, MAX_PATH);
          MessageBox(hWndApp, szErrMsg, szThemeName,
                             MB_OK | MB_ICONERROR | MB_APPLMODAL);
          return FALSE;
       }

       SERVICE_STATUS SvcStatus;

       if (QueryServiceStatus(hSchSvc, &SvcStatus) == FALSE)
       {
          CloseServiceHandle(hSchSvc);
          LoadString(hInstApp, STR_ERRTSNOSTART, szErrMsg, MAX_PATH);
          MessageBox(hWndApp, szErrMsg, szThemeName,
                             MB_OK | MB_ICONERROR | MB_APPLMODAL);
          return FALSE;
       }

       if (SvcStatus.dwCurrentState == SERVICE_RUNNING)
       {
          // The service is already running.
          CloseServiceHandle(hSchSvc);
          return TRUE;
       }

       if (StartService(hSchSvc, 0, NULL) == FALSE)
       {
          CloseServiceHandle(hSchSvc);
          LoadString(hInstApp, STR_ERRTSNOSTART, szErrMsg, MAX_PATH);
          MessageBox(hWndApp, szErrMsg, szThemeName,
                             MB_OK | MB_ICONERROR | MB_APPLMODAL);
          return FALSE;
       }

       CloseServiceHandle(hSchSvc);

       return TRUE;
    }

}  // END StartTaskScheduler()

//+--------------------------------------------------------------------------
//
// Function:        Init()
//
// Synopsis:        Called to initialize and instantiate a task
//                  scheduler object.
//
// Arguments:       none (void)
//
// Returns:         HRESULT indicating success or failure.  S_OK on success.
//
// Side effect:     Sets global pointer g_pITaskScheduler, for use in other
//                  functions.
//
//---------------------------------------------------------------------------

HRESULT Init()
{
    HRESULT hr = S_OK;

    // Bring in the library

    hr = CoInitialize(NULL);
    if (FAILED(hr))
    {
        return hr;
    }

    // Create the pointer to Task Scheduler object
    // CLSID from the header file mstask.h

    hr = CoCreateInstance(
        CLSID_CTaskScheduler,
        NULL,
        CLSCTX_INPROC_SERVER,
        IID_ITaskScheduler,
        (void **) &g_pITaskScheduler);

    // Should we fail, unload the library

    if (FAILED(hr))
    {
        CoUninitialize();
    }

    return hr;
}


//+--------------------------------------------------------------------------
//
// Function:    Cleanup()
//
// Synopsis:    Called to clean up OLE, memory, etc. before termination
//
// Arguments:   none (void)
//
// Returns:     nothing (void)
//
// Side effect: Cancels the global pointer g_pITaskScheduler.
//
//---------------------------------------------------------------------------

void Cleanup()
{
    if (g_pITaskScheduler)
    {
        g_pITaskScheduler->Release();
        g_pITaskScheduler = NULL;
    }

    // Unload the library, now that our pointer is freed.

    CoUninitialize();
    return;
}


//+--------------------------------------------------------------------------
//
// Function:    IsThemesScheduled()
//
// Synopsis:    Enumerates tasks and returns TRUE if Themes.job exists.
//              Returns FALSE if it does not.
//
// Arguments:   none (void).  Requires g_pITaskScheduler.
//
// Returns:     TRUE if Themes.job exists, else FALSE
//
//---------------------------------------------------------------------------

extern "C" BOOL IsThemesScheduled()
{
    HRESULT hr = S_OK, hrLoop = S_OK;
    IEnumWorkItems *pIEnumWorkItems;
    IUnknown *pIU;
    ITask *pITask;
    ULONG ulTasksToGet = 1, ulActualTasksRetrieved = 0;
    LPWSTR *rgpwszNames;
    TCHAR szDefaultJobName[MAX_PATH];
    BOOL bResult;
    UINT uCodePage;
#ifndef UNICODE
    CHAR szJobNameA[MAX_PATH];
#endif

    // For protection

    g_pITaskScheduler = NULL;

    // String conversion initialization

    uCodePage = _getmbcp();

    // Attempt to initialize OLE and fill in the global g_pITaskScheduler

    hr = Init();
    if (FAILED(hr))
    {
         return FALSE;
    }

    // Get the default name for a Themes task

    LoadString(hInstApp, STR_JOB_NAME, szDefaultJobName, MAX_PATH);

    // If this is NT we need to append the user profile name onto the
    // end of this task.

    if (IsPlatformNT()) BuildNTJobName(szDefaultJobName);

    //
    // Get an enumeration pointer, using ITaskScheduler::Enum
    //

    hr = g_pITaskScheduler->Enum(&pIEnumWorkItems);
    if (FAILED(hr))
    {
        // LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
        // MSG_BOX_TSERR(hWndApp, szErrMsg);
        Cleanup();
        return FALSE;
    }

    bResult = FALSE;
    do
    {
        // Get a single work item, using IEnumWorkItems::Next

        hrLoop = pIEnumWorkItems->Next(ulTasksToGet, &rgpwszNames,
                                       &ulActualTasksRetrieved);
        if (hrLoop == S_FALSE)
        {
            // There are no more waiting tasks to look at
            break;
        }

        // Attach to the work item, using ITaskScheduler::Activate

        hr = g_pITaskScheduler->Activate(rgpwszNames[0], IID_ITask, &pIU);
        if (FAILED(hr))
        {
            // LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
            // MSG_BOX_TSERR(hWndApp, szErrMsg);
            bResult = FALSE;
            break;
        }

        // QI pIU for pITask

        hr = pIU->QueryInterface(IID_ITask, (void **) &pITask);
        pIU->Release();
        pIU = NULL;
        if (FAILED(hr))
        {
            // LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
            // MSG_BOX_TSERR(hWndApp, szErrMsg);
            bResult = FALSE;
            break;
        }

        // Compare task name

#ifndef UNICODE
        // No UNICODE so we need to convert the wide string returned
        // by ITask into an ANSI string.

        WideCharToMultiByte(uCodePage, 0, rgpwszNames[0], -1,
                            szJobNameA, MAX_PATH, NULL, NULL);
        // MessageBox(hWndApp, szJobNameA, szThemeName,
        //                               MB_OK | MB_APPLMODAL);
        if (!lstrcmp(szJobNameA, szDefaultJobName)) bResult = TRUE;
#else
        // We're living in a UNICODE world so no need to convert
        // the string from ITask.

        // MessageBox(hWndApp, rgpwszNames[0], szThemeName,
        //                               MB_OK | MB_APPLMODAL);
        if (!lstrcmp(rgpwszNames[0], szDefaultJobName)) bResult = TRUE;
#endif

        // Clean up each element in the array of job names, then
        // clean up the final array.

        CoTaskMemFree(rgpwszNames[0]);
        CoTaskMemFree(rgpwszNames);

        // Free the ITask pointer

        pITask->Release();

    } while(!bResult);

    // Release the enumeration pointer

    pITask = NULL;

    pIEnumWorkItems->Release();
    pIEnumWorkItems = NULL;

    Cleanup();
    return bResult; //
}

//+--------------------------------------------------------------------------
//
// Function:        DeleteThemesTask()
//
// Synopsis:        Deletes Themes task from Task Scheduler.
//
// Returns:         TRUE if OK, FALSE if FAIL.
//
//---------------------------------------------------------------------------

extern "C" BOOL DeleteThemesTask()
{
    HRESULT hr = S_OK;
    UINT uCodePage;
    TCHAR szDefaultJobName[MAX_PATH];
#ifndef UNICODE
    WCHAR szJobNameW[MAX_PATH];
#endif

    // String conversion initialization

    uCodePage = _getmbcp();

    // For protection

    g_pITaskScheduler = NULL;

    // Attempt to initialize OLE and fill in the global g_pITaskScheduler

    hr = Init();
    if (FAILED(hr))
    {
         // LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
         // MSG_BOX_TSERR(hWndApp, szErrMsg);
         return FALSE;
    }

    // Get the default name for a Themes task

    LoadString(hInstApp, STR_JOB_NAME, szDefaultJobName, MAX_PATH);

    // If this is NT we need to append the user profile name onto the
    // end of this task.

    if (IsPlatformNT()) BuildNTJobName(szDefaultJobName);

#ifndef UNICODE
    // No UNICODE so convert the string to WCHAR format to
    // please the TS interface

    MultiByteToWideChar(uCodePage, 0, szDefaultJobName, -1,
                                             szJobNameW, MAX_PATH);

    // Delete it
    hr = g_pITaskScheduler->Delete(szJobNameW);
#else // UNICODE
    // We're UNICODE so we don't need to convert the string before
    // calling TS
    hr = g_pITaskScheduler->Delete(szDefaultJobName);
#endif

    Cleanup();

    return TRUE; // Returns TRUE regardless of hr value.
}

//+--------------------------------------------------------------------------
//
// Function:        AddThemesTask()
//
// Synopsis:        Adds a new work item to the Scheduled Tasks folder.
//
// Arguments:       lpwszThemesExe - fully qualified path to Themes.exe.
//                  bShowErrors - if TRUE, ATT shows error dialogs else
//                                it fails silently.
//
// Returns:         TRUE if successful, FALSE if not.
//
//---------------------------------------------------------------------------

extern "C" BOOL AddThemesTask(LPTSTR lpszThemesExe, BOOL bShowErrors)

{
    HRESULT hr = S_OK;
    IUnknown *pIU;
    IPersistFile *pIPF;
    ITask *pITask;
    ITaskTrigger *pITaskTrig;
    DWORD dwTaskFlags, dwTrigFlags;
    WORD wTrigNumber;
    TASK_TRIGGER TaskTrig;
    UINT uCodePage;

    //TCHAR szUserName[MAX_PATH];
    //TCHAR szPassword[MAX_PATH];
    WCHAR szRotateCommandW[] = L"/r";
    TCHAR szDefaultJobName[MAX_PATH];
    TCHAR szJobComment[MAX_PATH];
#ifndef UNICODE
    WCHAR szUserNameW[MAX_PATH];
    WCHAR szPasswordW[MAX_PATH];
    WCHAR szThemesExeW[MAX_PATH];
    WCHAR szJobNameW[MAX_PATH];
    WCHAR szJobCommentW[MAX_PATH];
#endif
    SYSTEMTIME LocalTime;
    TCHAR szErrMsg[MAX_PATH];
    TCHAR szThemeName[MAX_STRLEN];  // msg box title
    HKEY hKey;
    DWORD dwDisposition;
    LONG lret;
    INT_PTR iResult;

    LoadString(hInstApp, STR_APPNAME, szThemeName, MAX_STRLEN);
    LoadString(hInstApp, STR_JOB_NAME, szDefaultJobName, MAX_PATH);
    LoadString(hInstApp, STR_JOB_COMMENT, szJobComment, MAX_PATH);

    // If this is NT we need to append the user profile name onto the
    // end of this task.

    if (IsPlatformNT()) BuildNTJobName(szDefaultJobName);

    // String conversion initialization

    uCodePage = _getmbcp();


    // For protection

    g_pITaskScheduler = NULL;

    // Attempt to initialize OLE and fill in the global g_pITaskScheduler

    hr = Init();
    if (FAILED(hr))
    {
         if (bShowErrors) {
            LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
            MSG_BOX_TSERR(hWndApp, szErrMsg);
         }
         return FALSE;
    }

    // Add the task.  Most likely failure is that work item already exists.
    // Uses ITaskScheduler::NewWorkItem


#ifndef UNICODE
    // No UNICODE so convert string to wide before adding task

    MultiByteToWideChar(uCodePage, 0, szDefaultJobName, -1,
                                             szJobNameW, MAX_PATH);

    hr = g_pITaskScheduler->NewWorkItem(szJobNameW,
                                        CLSID_CTask,
                                        IID_ITask,
                                        &pIU);
#else
    // UNICODE, so no need to convert string to WIDE before adding task

    hr = g_pITaskScheduler->NewWorkItem(szDefaultJobName,
                                        CLSID_CTask,
                                        IID_ITask,
                                        &pIU);
#endif

    if (FAILED(hr))
    {
        if (bShowErrors) {
           LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
           MSG_BOX_TSERR(hWndApp, szErrMsg);
        }
        Cleanup();
        return FALSE;
    }

    // We now have an IUnknown pointer.  This is queried for an ITask
    // pointer on the work item we just added.

    hr = pIU->QueryInterface(IID_ITask, (void **) &pITask);
    if (FAILED(hr))
    {
        if (bShowErrors) {
           LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
           MSG_BOX_TSERR(hWndApp, szErrMsg);
        }
        pIU->Release();
        Cleanup();
        return FALSE;
    }

    // Cleanup pIUnknown, as we are done with it.

    pIU->Release();
    pIU = NULL;

    //
    // If this is for NT we need to get and set the user account
    // information.   ITask::SetAccountInformation
    //

    if (IsPlatformNT())
    {

        szUserName[0] = TEXT('\0');    // global user name string
        szPassword[0] = TEXT('\0');    // global password string

        // Prompt for the user name and password
        //
        // Password dialog returns:
        //      -1 if DialogBox() fails
        //       0 if user cancels
        //       1 if PW entered OK

        iResult = 0;
        iResult = DialogBox(hInstApp,
                            MAKEINTRESOURCE(DLG_PASSWORD),
                            hWndApp,
                            PasswordDlgProc);

        if (iResult < 1)
        {
           // Either the password dialog failed or the user Canceled
           // it so bail out.
           pITask->Release();
           Cleanup();
           return FALSE;
        }

#ifndef UNICODE

        // No UNICODE so we need to convert from ANSI to WCHAR before
        // calling SetAccountInformation

        MultiByteToWideChar(uCodePage, 0, szUserName, -1,
                                             szUserNameW, MAX_PATH);

        MultiByteToWideChar(uCodePage, 0, szPassword, -1,
                                             szPasswordW, MAX_PATH);

        hr = pITask->SetAccountInformation(szUserNameW, szPasswordW);

#else
        // UNICODE so no need to convert strings

        hr = pITask->SetAccountInformation(szUserName, szPassword);

#endif  // UNICODE

        if (FAILED(hr))
        {
           if (bShowErrors) {
              LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
              MSG_BOX_TSERR(hWndApp, szErrMsg);
           }
           pITask->Release();
           Cleanup();
           return FALSE;
        }

    }  // IsPlatformNT


    // Set command name with ITask::SetApplicationName

#ifndef UNICODE
    // No UNICODE so need to convert string to WIDE

    MultiByteToWideChar(uCodePage, 0, lpszThemesExe, -1,
                                             szThemesExeW, MAX_PATH);

    hr = pITask->SetApplicationName(szThemesExeW);
#else
    // UNICODE so no need to convert string

    hr = pITask->SetApplicationName(lpszThemesExe);
#endif

    if (FAILED(hr))
    {
        if (bShowErrors) {
           LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
           MSG_BOX_TSERR(hWndApp, szErrMsg);
        }
        pITask->Release();
        Cleanup();
        return FALSE;
    }

    // Set task parameters with ITask::SetParameters

    hr = pITask->SetParameters(szRotateCommandW);
    if (FAILED(hr))
    {
        if (bShowErrors) {
           LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
           MSG_BOX_TSERR(hWndApp, szErrMsg);
        }
        pITask->Release();
        Cleanup();
        return FALSE;
    }

    // Set the comment, so we know how this job got there
    // Uses ITask::SetComment

#ifndef UNICODE
    // No UNICODE so convert to WIDE

    MultiByteToWideChar(uCodePage, 0, szJobComment, -1,
                                             szJobCommentW, MAX_PATH);


    hr = pITask->SetComment(szJobCommentW);
#else
    // UNICODE so no need to convert string

    hr = pITask->SetComment(szJobComment);
#endif

    if (FAILED(hr))
    {
        if (bShowErrors) {
           LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
           MSG_BOX_TSERR(hWndApp, szErrMsg);
        }
        pITask->Release();
        Cleanup();
        return FALSE;
    }

    // Set the flags on the task object
    // Use ITask::SetFlags

    dwTaskFlags = NULL;
    hr = pITask->SetFlags(dwTaskFlags);
    if (FAILED(hr))
    {
        if (bShowErrors) {
           LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
           MSG_BOX_TSERR(hWndApp, szErrMsg);
        }
        pITask->Release();
        Cleanup();
        return FALSE;
    }

    // Now, create a trigger to run the task at our specified time.
    // Uses ITask::CreateTrigger()

    hr = pITask->CreateTrigger(&wTrigNumber, &pITaskTrig);
    if (FAILED(hr))
    {
        if (bShowErrors) {
           LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
           MSG_BOX_TSERR(hWndApp, szErrMsg);
        }
        pITask->Release();
        Cleanup();
        return FALSE;
    }

    // Now, fill in the trigger as necessary.

    GetLocalTime(&LocalTime);

    if (12 == LocalTime.wMonth) {
        LocalTime.wMonth = 1;
        LocalTime.wYear++;
    }
    else LocalTime.wMonth++;

    dwTrigFlags = 0;

    TaskTrig.cbTriggerSize = sizeof(TASK_TRIGGER);
    TaskTrig.Reserved1 = 0;
    TaskTrig.wBeginYear = LocalTime.wYear;
    TaskTrig.wBeginMonth = LocalTime.wMonth;
    TaskTrig.wBeginDay = 1;
    TaskTrig.wEndYear = 0;
    TaskTrig.wEndMonth = 0;
    TaskTrig.wEndDay = 0;
    TaskTrig.wStartHour = 14;
    TaskTrig.wStartMinute = 0;
    TaskTrig.MinutesDuration = 0;
    TaskTrig.MinutesInterval = 0;
    TaskTrig.rgFlags = dwTrigFlags;
    TaskTrig.TriggerType = TASK_TIME_TRIGGER_MONTHLYDATE;
    TaskTrig.Type.MonthlyDate.rgfDays = 1;
    TaskTrig.Type.MonthlyDate.rgfMonths = EVERY_MONTH;
    TaskTrig.wRandomMinutesInterval = 0;
    TaskTrig.Reserved2 = 0;

    // Add this trigger to the task using ITaskTrigger::SetTrigger

    hr = pITaskTrig->SetTrigger(&TaskTrig);
    if (FAILED(hr))
    {
        if (bShowErrors) {
           LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
           MSG_BOX_TSERR(hWndApp, szErrMsg);
        }
        pITaskTrig->Release();
        pITask->Release();
        Cleanup();
        return FALSE;
    }

    // Make the changes permanent
    // Requires using IPersistFile::Save()

    hr = pITask->QueryInterface(IID_IPersistFile, (void **) &pIPF);
    if (FAILED(hr))
    {
        if (bShowErrors) {
           LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
           MSG_BOX_TSERR(hWndApp, szErrMsg);
        }
        pITaskTrig->Release();
        pITask->Release();
        Cleanup();
        return FALSE;
    }

    hr = pIPF->Save(NULL, FALSE);
    if (FAILED(hr))
    {
        if (bShowErrors) {
           LoadString(hInstApp, STR_ERRTS, szErrMsg, MAX_PATH);
           MSG_BOX_TSERR(hWndApp, szErrMsg);
        }
        pITaskTrig->Release();
        pITask->Release();
        pIPF->Release();
        Cleanup();
        return FALSE;
    }

    // We no longer need ITask

    pITask->Release();
    pITask = NULL;

    // Done with ITaskTrigger pointer

    pITaskTrig->Release();
    pITaskTrig = NULL;

    // Done with IPersistFile

    pIPF->Release();
    pIPF = NULL;
    Cleanup();

    // Finally -- we have successfully added the task but we need to
    // make sure that Task Scheduler is in the RunServices branch of
    // the registry so it will start every time.
    hKey = NULL;
    lret = RegCreateKeyEx(HKEY_LOCAL_MACHINE,
                          szRunServices,
                          0,
                          NULL,
                          REG_OPTION_NON_VOLATILE,
                          KEY_WRITE,
                          NULL,
                          &hKey,
                          &dwDisposition);

    if (lret == ERROR_SUCCESS) {
       // RegDeleteValue(hKey, szScheduler);
       lret = RegSetValueEx(hKey,
                            szScheduler,
                            0,
                            REG_SZ,
                            (CONST BYTE *)szMSTask,
                            (SZSIZEINBYTES(szMSTask) + 1));
    }

    if (hKey) RegCloseKey(hKey);

    return TRUE;
}

extern "C" BOOL HandDeleteThemesTask()
{
    TCHAR szJobFile[MAX_PATH];  // Full path to %windir%\Tasks\Themes.job
    TCHAR szDefaultJobName[MAX_PATH];

    if (!GetWindowsDirectory(szJobFile, MAX_PATH)) return FALSE;
    lstrcat(szJobFile, TEXT("\\Tasks\\\0"));
    LoadString(hInstApp, STR_JOB_NAME, szDefaultJobName, MAX_PATH);
    // If this is NT we need to append the user profile name onto the
    // end of this task.

    if (IsPlatformNT()) BuildNTJobName(szDefaultJobName);
    lstrcat(szJobFile, szDefaultJobName);
    DeleteFile(szJobFile);
    return TRUE;
}

//---------------------------------------------------------------------------
//  GetUserToken - Gets the current process's user token and returns
//                        it. It can later be free'd with LocalFree.
//---------------------------------------------------------------------------
PTOKEN_USER GetUserToken(HANDLE hUser)
{
    PTOKEN_USER pUser;
    DWORD dwSize = 64;
    HANDLE hToClose = NULL;

    if (hUser == NULL)
    {
        OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hUser);
        hToClose = hUser;
    }

    pUser = (PTOKEN_USER)LocalAlloc(LPTR, dwSize);
    if (pUser)
    {
        DWORD dwNewSize;
        BOOL fOk = GetTokenInformation(hUser, TokenUser, pUser, dwSize, &dwNewSize);
        if (!fOk && (GetLastError() == ERROR_INSUFFICIENT_BUFFER))
        {
            LocalFree((HLOCAL)pUser);

            pUser = (PTOKEN_USER)LocalAlloc(LPTR, dwNewSize);
            if (pUser)
            {
                fOk = GetTokenInformation( hUser, TokenUser, pUser, dwNewSize, &dwNewSize);
            }
        }
        if (!fOk)
        {
            LocalFree((HLOCAL)pUser);
            pUser = NULL;
        }
    }

    if (hToClose)
        CloseHandle(hToClose);

    return pUser;
}

//----------------------------------------------------------------------------
//  GetCurrentUser - Fills in a buffer with the unique name that we are using
//                   for the currently logged on user.  On NT, this name is
//                   used for the name of the profile directory and for the
//                   name of the per-user recycle bin directory on a security
//                   aware drive.
//
//  Parameters:
//                   lpAccountName -- buffer to receive user account name
//                   lpDomainName -- buffer to receive domain name
//                   lpProfilePath -- receives fully qualified path to user's
//                                    profile directory.  If the caller does
//                                    not want the profile path NULL may be
//                                    passed in for this parameter.
//----------------------------------------------------------------------------
extern "C" BOOL GetCurrentUser(LPTSTR lpAccountName, DWORD cchAcctSize,
                               LPTSTR lpDomainName, DWORD cchDomSize,
                               LPTSTR lpProfilePath, DWORD cchProfSize)
{
    PTOKEN_USER     pUser;
    LPTSTR          pTextSid = 0;
    DWORD           cbBytes;
    SID_NAME_USE    SNU;
    HANDLE          hUser;

    // Take the easy outs -- no NULL parms for first four.
    if (!lpAccountName || !lpDomainName || !&cchAcctSize || !&cchDomSize) return FALSE;

    // Initialize these strings to NULL.
    *lpAccountName = 0;
    *lpDomainName = 0;

    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hUser))
    {
       return FALSE;
    }

    pUser = GetUserToken(hUser);

    CloseHandle(hUser);

    if (!pUser)
       return FALSE;

    if (!IsValidSid(pUser->User.Sid))
    {
       LocalFree(pUser);
       return FALSE;
    }

    if (!LookupAccountSid(NULL,
                         pUser->User.Sid,
                         lpAccountName,
                         &cchAcctSize,
                         lpDomainName,
                         &cchDomSize,
                         &SNU))
    {
       // LookupAccountSid failed
       LocalFree(pUser);
       return FALSE;
    }

    // Does the caller want the profile path?

    if (!lpProfilePath)
    {
       // No, so cleanup and hit the road.
       LocalFree(pUser);
       return TRUE;
    }

    // Have the Account and Domain Name.  Next we need to get
    // a text based SID so we can lookup the profile path in
    // the registry.

    // First let's find out how big a buffer we need for the
    // text Sid.

    *lpProfilePath = 0;
    cbBytes = 0;
    if ((!GetTextualSid(pUser->User.Sid, pTextSid, &cbBytes)) &&
        (ERROR_INSUFFICIENT_BUFFER == GetLastError()))
    {
       pTextSid = (LPTSTR)LocalAlloc(LPTR, cbBytes);
       if (!pTextSid)
       {
          LocalFree(pUser);
          return FALSE;
       }

       if (!GetTextualSid(pUser->User.Sid, pTextSid, &cbBytes))
       {
          LocalFree(pUser);
          return FALSE;
       }
    }
    else
    {
       // Failed to get a text SID so we're outta here.
       LocalFree((HLOCAL)pUser);
       return FALSE;
    }

    // OK, now we should have a text-based SID.  Used this to find
    // the profilepath in the registry.

    if (pTextSid)
    {
       HKEY hkeyProfileList;

       // Open the registry and find the appropriate name

       LONG lStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList"), 0,
                                   KEY_READ, &hkeyProfileList);

       if (lStatus == ERROR_SUCCESS)
       {
          HKEY hkeyUser;
          lStatus = RegOpenKeyEx(hkeyProfileList, pTextSid, 0, KEY_READ, &hkeyUser);
          if (lStatus == ERROR_SUCCESS)
          {
             DWORD dwType;
             cbBytes = (cchProfSize * sizeof(TCHAR));

             // First check for a "ProfileName" key

             lStatus = RegQueryValueEx(hkeyUser, TEXT("ProfileName"), NULL, &dwType,
                                       (LPBYTE)lpProfilePath, &cbBytes);

             if (lStatus == ERROR_SUCCESS && (dwType == REG_SZ || dwType == REG_EXPAND_SZ))
             {
                // We're good to go.
                LocalFree(pUser);
                LocalFree(pTextSid);
                RegCloseKey(hkeyProfileList);
                RegCloseKey(hkeyUser);
                return TRUE;
             }
             else
             {
                // Otherwise, grab the "ProfilePath" and get the last part of the name
                cbBytes = (cchProfSize * sizeof(TCHAR));

                lStatus = RegQueryValueEx(hkeyUser,TEXT("ProfileImagePath"), NULL, &dwType,
                                          (LPBYTE)lpProfilePath, &cbBytes);

                if (lStatus == ERROR_SUCCESS && (dwType == REG_SZ || dwType == REG_EXPAND_SZ))
                {
                   // Return just the directory name portion of the profile path
                   //lstrcpyn(lpBuff, PathFindFileName(lpProfilePath), iSize);

                   LocalFree(pUser);
                   LocalFree(pTextSid);
                   RegCloseKey(hkeyProfileList);
                   RegCloseKey(hkeyUser);
                   return TRUE;
                }
                else
                {
                   // Have exhausted our resources -- can't get the
                   // profile path.
                   LocalFree(pUser);
                   LocalFree(pTextSid);
                   RegCloseKey(hkeyProfileList);
                   RegCloseKey(hkeyUser);
                   return FALSE;
                }
             }
          }
          else
          {
             // Couldn't open reg key so we're hosed
             LocalFree(pUser);
             LocalFree(pTextSid);
             RegCloseKey(hkeyProfileList);
             return FALSE;
          }
       }

       LocalFree(pUser);
       LocalFree(pTextSid);

    }
    else
    {
       // For some completely unknown reason we have a NULL Sid string
       // so we're doomed.
       LocalFree(pTextSid);
       return FALSE;
    }

    // We should never fall through to this point but if we do...
    return FALSE;
}

//+--------------------------------------------------------------------------
//
// Function:        GetTextualSid()
//
// Synopsis:        WINNT only -- converts a SID to text.
//
// Returns:         TRUE if successful, FALSE if not.
//                  Sets LastError on failure.
//
// Taken from the January 1998 MSDN reference.
//
//---------------------------------------------------------------------------


BOOL GetTextualSid( PSID pSid,             // binary Sid
                    LPTSTR TextualSid,     // buffer for Textual representation of Sid
                    LPDWORD lpdwBufferLen) // required/provided TextualSid buffersize
{
    PSID_IDENTIFIER_AUTHORITY psia;
    DWORD dwSubAuthorities;
    DWORD dwSidRev=SID_REVISION;
    DWORD dwCounter;
    DWORD dwSidSize;

    // Validate the binary SID.
    if(!IsValidSid(pSid))
    {
       SetLastError(ERROR_INVALID_PARAMETER);
       return FALSE;
    }

    // Get the identifier authority value from the SID.
    psia = GetSidIdentifierAuthority(pSid);

    // Get the number of subauthorities in the SID.
    dwSubAuthorities = *GetSidSubAuthorityCount(pSid);

    // Compute the buffer length.
    // S-SID_REVISION- + IdentifierAuthority- + subauthorities- + NULL
    dwSidSize=(15 + 12 + (12 * dwSubAuthorities) + 1) * sizeof(TCHAR);

    // Check input buffer length.
    // If too small, indicate the proper size and set last error.
    if (*lpdwBufferLen < dwSidSize)
    {
       *lpdwBufferLen = dwSidSize;
       SetLastError(ERROR_INSUFFICIENT_BUFFER);
       return FALSE;
    }

    // Add 'S' prefix and revision number to the string.
    dwSidSize=wsprintf(TextualSid, TEXT("S-%lu-"), dwSidRev );

    // Add SID identifier authority to the string.
    if ( (psia->Value[0] != 0) || (psia->Value[1] != 0) )
    {
       dwSidSize+=wsprintf(TextualSid + lstrlen(TextualSid),
                   TEXT("0x%02hx%02hx%02hx%02hx%02hx%02hx"),
                   (USHORT)psia->Value[0],
                   (USHORT)psia->Value[1],
                   (USHORT)psia->Value[2],
                   (USHORT)psia->Value[3],
                   (USHORT)psia->Value[4],
                   (USHORT)psia->Value[5]);
    }
    else
    {
       dwSidSize+=wsprintf(TextualSid + lstrlen(TextualSid),
                   TEXT("%lu"),
                   (ULONG)(psia->Value[5]      )   +
                   (ULONG)(psia->Value[4] <<  8)   +
                   (ULONG)(psia->Value[3] << 16)   +
                   (ULONG)(psia->Value[2] << 24)   );
    }

    // Add SID subauthorities to the string.
    //

    for (dwCounter=0 ; dwCounter < dwSubAuthorities ; dwCounter++)
    {
       dwSidSize+=wsprintf(TextualSid + dwSidSize, TEXT("-%lu"),
       *GetSidSubAuthority(pSid, dwCounter) );
    }

    SetLastError(ERROR_INSUFFICIENT_BUFFER);
    return TRUE;
}

extern "C" VOID BuildNTJobName(LPTSTR lpJobName)
{
  TCHAR szUser[MAX_PATH];
  TCHAR szDomain[MAX_PATH];
  TCHAR szProfile[MAX_PATH];
  LPTSTR Current;
  LPTSTR Dot;

  if (!lpJobName) return;  // Null pointers not allowed.

  if (!GetCurrentUser(szUser, ARRAYSIZE(szUser),
                      szDomain, ARRAYSIZE(szDomain),
                      szProfile, ARRAYSIZE(szProfile)))
  {
     // GetCurrentUser failed so bail out.
     return;
  }
  // Walk to the end of the lpJobName string
  Dot = lpJobName;
  while (*Dot) Dot = CharNext(Dot);

  // Dot now points to the end of the lpJobName string.  Backup until
  // we get to the "dot" in the extension.

  Dot = CharPrev(lpJobName, Dot);
  while ((Dot > lpJobName) && (*Dot != TEXT('.'))) Dot = CharPrev(lpJobName, Dot);

  // Ok truncate the extension by putting a NULL on the "dot".
  *Dot = TEXT('\0');

  // Walk to the end of the szProfile string
  Current = szProfile;
  while (*Current) Current = CharNext(Current);

  // Current now points to the end of szProfile.  Backup until we get
  // to the first "\".

  Current = CharPrev(szProfile, Current);
  while ((Current > szProfile) && (*Current != TEXT('\\'))) Current = CharPrev(szProfile, Current);

  *Current = TEXT('(');

  lstrcat(lpJobName, TEXT(" "));
  lstrcat(lpJobName, Current);
  lstrcat(lpJobName, TEXT(").JOB"));
}


extern "C" BOOL IsUserAdmin(VOID)

/*++

Routine Description:

    This routine returns TRUE if the caller's process is a
    member of the Administrators local group.

    Caller is NOT expected to be impersonating anyone and IS
    expected to be able to open their own process and process
    token.

Arguments:

    None.

Return Value:

    TRUE - Caller has Administrators local group.

    FALSE - Caller does not have Administrators local group.

--*/

{
    HANDLE Token;
    DWORD BytesRequired;
    PTOKEN_GROUPS Groups;
    BOOL b;
    DWORD i;
    SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
    PSID AdministratorsGroup;

    //
    // On non-NT platforms the user is administrator.
    //
    if(!IsPlatformNT()) {
        return(TRUE);
    }

    //
    // Open the process token.
    //
    if(!OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY,&Token)) {
        return(FALSE);
    }

    b = FALSE;
    Groups = NULL;

    //
    // Get group information.
    //
    if (!GetTokenInformation(Token,TokenGroups,NULL,0,&BytesRequired)
        && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
        && (Groups = (PTOKEN_GROUPS)LocalAlloc(LPTR,BytesRequired))
        && GetTokenInformation(Token,TokenGroups,Groups,BytesRequired,&BytesRequired))
    {

        b = AllocateAndInitializeSid(
                &NtAuthority,
                2,
                SECURITY_BUILTIN_DOMAIN_RID,
                DOMAIN_ALIAS_RID_ADMINS,
                0, 0, 0, 0, 0, 0,
                &AdministratorsGroup
                );

        if (b) {

            //
            // See if the user has the administrator group.
            //
            b = FALSE;
            for(i=0; i<Groups->GroupCount; i++) {
                if(EqualSid(Groups->Groups[i].Sid,AdministratorsGroup)) {
                    b = TRUE;
                    break;
                }
            }

            FreeSid(AdministratorsGroup);
        }
    }

    //
    // Clean up and return.
    //

    if(Groups) {
        LocalFree((HLOCAL)Groups);
    }

    CloseHandle(Token);

    return(b);
}