startup.cpp File Reference

#include "precomp.h"

Include dependency graph for startup.cpp:

Go to the source code of this file.

Macros
#define	INVALID_RUNCMD_RETURN   -1

Functions
static int	runCmd (LPWSTR cmdline, LPCWSTR dir, BOOL wait, BOOL minimized)
static BOOL	ProcessRunKeys (HKEY hkRoot, LPCWSTR szKeyName, BOOL bDelete, BOOL bSynchronous)
static BOOL	ProcessRunOnceEx (HKEY hkRoot)
static BOOL	AutoStartupApplications (INT nCSIDL_Folder)
INT	ProcessStartupItems (BOOL bRunOnce)
VOID	ReleaseStartupMutex ()
static BOOL	InitializeStartupMutex ()
BOOL	DoStartStartupItems (ITrayWindow *Tray)
VOID	ProcessRunOnceItems ()

Variables
static HANDLE	s_hStartupMutex = NULL

Macro Definition Documentation

INVALID_RUNCMD_RETURN

#define INVALID_RUNCMD_RETURN   -1

Definition at line 48 of file startup.cpp.

Function Documentation

AutoStartupApplications()

static BOOL AutoStartupApplications ( INT  nCSIDL_Folder )

static

Definition at line 384 of file startup.cpp.

{
    WCHAR szPath[MAX_PATH] = { 0 };
    HRESULT hResult;
    HANDLE hFind;
    WIN32_FIND_DATAW FoundData;
    size_t cchPathLen;
 
    TRACE("(%d)\n", nCSIDL_Folder);
 
    // Get the special folder path
    hResult = SHGetFolderPathW(NULL, nCSIDL_Folder, NULL, SHGFP_TYPE_CURRENT, szPath);
    cchPathLen = wcslen(szPath);
    if (!SUCCEEDED(hResult) || cchPathLen == 0)
    {
        WARN("SHGetFolderPath() failed with error %lu\n", GetLastError());
        return FALSE;
    }
 
    // Build a path with wildcard
    StringCbCatW(szPath, sizeof(szPath), L"\\*");
 
    // Start enumeration of files
    hFind = FindFirstFileW(szPath, &FoundData);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        WARN("FindFirstFile(%s) failed with error %lu\n", debugstr_w(szPath), GetLastError());
        return FALSE;
    }
 
    // Enumerate the files
    do
    {
        // Ignore "." and ".."
        if (wcscmp(FoundData.cFileName, L".") == 0 ||
            wcscmp(FoundData.cFileName, L"..") == 0)
        {
            continue;
        }
 
        // Don't run hidden files
        if (FoundData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
            continue;
 
        // Build the path
        szPath[cchPathLen + 1] = UNICODE_NULL;
        StringCbCatW(szPath, sizeof(szPath), FoundData.cFileName);
 
        TRACE("Executing %s in directory %s\n", debugstr_w(FoundData.cFileName), debugstr_w(szPath));
 
        DWORD dwType;
        if (GetBinaryTypeW(szPath, &dwType))
        {
            runCmd(szPath, NULL, TRUE, FALSE);
        }
        else
        {
            SHELLEXECUTEINFOW ExecInfo;
            ZeroMemory(&ExecInfo, sizeof(ExecInfo));
            ExecInfo.cbSize = sizeof(ExecInfo);
            ExecInfo.lpFile = szPath;
            ShellExecuteExW(&ExecInfo);
        }
    } while (FindNextFileW(hFind, &FoundData));
 
    FindClose(hFind);
    return TRUE;
}

Referenced by ProcessStartupItems().

DoStartStartupItems()

BOOL DoStartStartupItems

(

ITrayWindow *

Tray

)

Definition at line 549 of file startup.cpp.

{
    if (!bExplorerIsShell || !InitializeStartupMutex())
        return FALSE;
 
    const DWORD dwWaitTotal = 3000;     // in milliseconds
    DWORD dwTick = GetTickCount();
    while (GetShellWindow() == NULL && GetTickCount() - dwTick < dwWaitTotal)
    {
        TrayProcessMessages(Tray);
    }
 
    if (GetShellWindow() == NULL)
    {
        DoFinishStartupItems();
        return FALSE;
    }
 
    // Check the volatile "StartupHasBeenRun" key
    HKEY hSessionKey, hKey;
    HRESULT hr = SHCreateSessionKey(KEY_WRITE, &hSessionKey);
    if (SUCCEEDED(hr))
    {
        ASSERT(hSessionKey);
 
        DWORD dwDisp;
        LONG Error = RegCreateKeyExW(hSessionKey, L"StartupHasBeenRun", 0, NULL,
                                     REG_OPTION_VOLATILE, KEY_WRITE, NULL, &hKey, &dwDisp);
        RegCloseKey(hSessionKey);
        RegCloseKey(hKey);
        if (Error == ERROR_SUCCESS && dwDisp == REG_OPENED_EXISTING_KEY)
        {
            return FALSE;   // Startup programs has already been run
        }
    }
 
    return TRUE;
}

Referenced by StartWithDesktop().

InitializeStartupMutex()

static BOOL InitializeStartupMutex ( )

static

Definition at line 523 of file startup.cpp.

{
    if (!bExplorerIsShell)
        return FALSE;
 
    if (!s_hStartupMutex)
    {
        // Accidentally, there is possibility that the system starts multiple Explorers
        // before startup of shell. We use a mutex to match the timing of shell initialization.
        s_hStartupMutex = CreateMutexW(NULL, FALSE, L"ExplorerIsShellMutex");
        if (s_hStartupMutex == NULL)
            return FALSE;
    }
 
    DWORD dwWait = WaitForSingleObject(s_hStartupMutex, INFINITE);
    TRACE("dwWait: 0x%08lX\n", dwWait);
    if (dwWait != WAIT_OBJECT_0)
    {
        TRACE("LastError: %ld\n", GetLastError());
 
        ReleaseStartupMutex();
        return FALSE;
    }
    return TRUE;
}

Referenced by DoStartStartupItems(), and ProcessRunOnceItems().

ProcessRunKeys()

static BOOL ProcessRunKeys ( HKEY  hkRoot, LPCWSTR  szKeyName, BOOL  bDelete, BOOL  bSynchronous  )

static

Process a "Run" type registry key. hkRoot is the HKEY from which "Software\Microsoft\Windows\CurrentVersion" is opened. szKeyName is the key holding the actual entries. bDelete tells whether we should delete each value right before executing it. bSynchronous tells whether we should wait for the prog to complete before going on to the next prog.

Definition at line 136 of file startup.cpp.

{
    HKEY hkWin = NULL, hkRun = NULL;
    LONG res = ERROR_SUCCESS;
    DWORD i, cbMaxCmdLine = 0, cchMaxValue = 0;
    WCHAR *szCmdLine = NULL;
    WCHAR *szValue = NULL;
 
    if (hkRoot == HKEY_LOCAL_MACHINE)
        TRACE("processing %ls entries under HKLM\n", szKeyName);
    else
        TRACE("processing %ls entries under HKCU\n", szKeyName);
 
    res = RegOpenKeyExW(hkRoot,
                        L"Software\\Microsoft\\Windows\\CurrentVersion",
                        0,
                        KEY_READ,
                        &hkWin);
    if (res != ERROR_SUCCESS)
    {
        TRACE("RegOpenKeyW failed on Software\\Microsoft\\Windows\\CurrentVersion (%ld)\n", res);
 
        goto end;
    }
 
    res = RegOpenKeyExW(hkWin,
                        szKeyName,
                        0,
                        bDelete ? KEY_ALL_ACCESS : KEY_READ,
                        &hkRun);
    if (res != ERROR_SUCCESS)
    {
        if (res == ERROR_FILE_NOT_FOUND)
        {
            TRACE("Key doesn't exist - nothing to be done\n");
 
            res = ERROR_SUCCESS;
        }
        else
            TRACE("RegOpenKeyExW failed on run key (%ld)\n", res);
 
        goto end;
    }
 
    res = RegQueryInfoKeyW(hkRun,
                           NULL,
                           NULL,
                           NULL,
                           NULL,
                           NULL,
                           NULL,
                           &i,
                           &cchMaxValue,
                           &cbMaxCmdLine,
                           NULL,
                           NULL);
    if (res != ERROR_SUCCESS)
    {
        TRACE("Couldn't query key info (%ld)\n", res);
 
        goto end;
    }
 
    if (i == 0)
    {
        TRACE("No commands to execute.\n");
 
        res = ERROR_SUCCESS;
        goto end;
    }
 
    szCmdLine = (WCHAR*)HeapAlloc(hProcessHeap,
                          0,
                          cbMaxCmdLine);
    if (szCmdLine == NULL)
    {
        TRACE("Couldn't allocate memory for the commands to be executed\n");
 
        res = ERROR_NOT_ENOUGH_MEMORY;
        goto end;
    }
 
    ++cchMaxValue;
    szValue = (WCHAR*)HeapAlloc(hProcessHeap,
                        0,
                        cchMaxValue * sizeof(*szValue));
    if (szValue == NULL)
    {
        TRACE("Couldn't allocate memory for the value names\n");
 
        res = ERROR_NOT_ENOUGH_MEMORY;
        goto end;
    }
 
    while (i > 0)
    {
        WCHAR *szCmdLineExp = NULL;
        DWORD cchValLength = cchMaxValue, cbDataLength = cbMaxCmdLine;
        DWORD type;
 
        --i;
 
        res = RegEnumValueW(hkRun,
                            i,
                            szValue,
                            &cchValLength,
                            0,
                            &type,
                            (PBYTE)szCmdLine,
                            &cbDataLength);
        if (res != ERROR_SUCCESS)
        {
            TRACE("Couldn't read in value %lu - %ld\n", i, res);
 
            continue;
        }
 
        /* safe mode - force to run if prefixed with asterisk */
        if (GetSystemMetrics(SM_CLEANBOOT) && (szValue[0] != L'*')) continue;
 
        if (bDelete && (res = RegDeleteValueW(hkRun, szValue)) != ERROR_SUCCESS)
        {
            TRACE("Couldn't delete value - %lu, %ld. Running command anyways.\n", i, res);
        }
 
        if (type != REG_SZ && type != REG_EXPAND_SZ)
        {
            TRACE("Incorrect type of value #%lu (%lu)\n", i, type);
 
            continue;
        }
 
        if (type == REG_EXPAND_SZ)
        {
            DWORD dwNumOfChars;
 
            dwNumOfChars = ExpandEnvironmentStringsW(szCmdLine, NULL, 0);
            if (dwNumOfChars)
            {
                szCmdLineExp = (WCHAR *)HeapAlloc(hProcessHeap, 0, dwNumOfChars * sizeof(*szCmdLineExp));
 
                if (szCmdLineExp == NULL)
                {
                    TRACE("Couldn't allocate memory for the commands to be executed\n");
 
                    res = ERROR_NOT_ENOUGH_MEMORY;
                    goto end;
                }
 
                ExpandEnvironmentStringsW(szCmdLine, szCmdLineExp, dwNumOfChars);
            }
        }
 
        res = runCmd(szCmdLineExp ? szCmdLineExp : szCmdLine, NULL, bSynchronous, FALSE);
        if (res == INVALID_RUNCMD_RETURN)
        {
            TRACE("Error running cmd #%lu (%lu)\n", i, GetLastError());
        }
 
        if (szCmdLineExp != NULL)
        {
            HeapFree(hProcessHeap, 0, szCmdLineExp);
            szCmdLineExp = NULL;
        }
 
        TRACE("Done processing cmd #%lu\n", i);
    }
 
    res = ERROR_SUCCESS;
end:
    if (szValue != NULL)
        HeapFree(hProcessHeap, 0, szValue);
    if (szCmdLine != NULL)
        HeapFree(hProcessHeap, 0, szCmdLine);
    if (hkRun != NULL)
        RegCloseKey(hkRun);
    if (hkWin != NULL)
        RegCloseKey(hkWin);
 
    TRACE("done\n");
 
    return res == ERROR_SUCCESS ? TRUE : FALSE;
}

Referenced by ProcessStartupItems().

ProcessRunOnceEx()

static BOOL ProcessRunOnceEx ( HKEY  hkRoot )

static

Process "RunOnceEx" type registry key. rundll32.exe will be invoked if the corresponding key has items inside, and wait for it. hkRoot is the HKEY from which "Software\Microsoft\Windows\CurrentVersion\RunOnceEx" is opened.

Definition at line 328 of file startup.cpp.

{
    HKEY hkRunOnceEx = NULL;
    LONG res = ERROR_SUCCESS;
    WCHAR cmdLine[] = L"rundll32 iernonce.dll RunOnceExProcess";
    DWORD dwSubKeyCnt;
 
    res = RegOpenKeyExW(hkRoot,
                        L"Software\\Microsoft\\Windows\\CurrentVersion\\RunOnceEx",
                        0,
                        KEY_READ,
                        &hkRunOnceEx);
    if (res != ERROR_SUCCESS)
    {
        TRACE("RegOpenKeyW failed on Software\\Microsoft\\Windows\\CurrentVersion\\RunOnceEx (%ld)\n", res);
        goto end;
    }
 
    res = RegQueryInfoKeyW(hkRunOnceEx,
                           NULL,
                           NULL,
                           NULL,
                           &dwSubKeyCnt,
                           NULL,
                           NULL,
                           NULL,
                           NULL,
                           NULL,
                           NULL,
                           NULL);
 
    if (res != ERROR_SUCCESS)
    {
        TRACE("RegQueryInfoKeyW failed on Software\\Microsoft\\Windows\\CurrentVersion\\RunOnceEx (%ld)\n", res);
        goto end;
    }
 
    if (dwSubKeyCnt != 0)
    {
        if (runCmd(cmdLine, NULL, TRUE, TRUE) == INVALID_RUNCMD_RETURN)
        {
            TRACE("runCmd failed (%ld)\n", res = GetLastError());
            goto end;
        }
    }
 
end:
    if (hkRunOnceEx != NULL)
        RegCloseKey(hkRunOnceEx);
 
    TRACE("done\n");
 
    return res == ERROR_SUCCESS ? TRUE : FALSE;
}

Referenced by ProcessStartupItems().

ProcessRunOnceItems()

VOID ProcessRunOnceItems

(

)

Definition at line 588 of file startup.cpp.

{
    if (bExplorerIsShell && IsUserAnAdmin() && InitializeStartupMutex())
        ProcessStartupItems(TRUE);
}

Referenced by StartWithDesktop().

ProcessStartupItems()

INT ProcessStartupItems

(

BOOL

bRunOnce

)

Definition at line 453 of file startup.cpp.

{
    /* TODO: ProcessRunKeys already checks SM_CLEANBOOT -- items prefixed with * should probably run even in safe mode */
    BOOL bNormalBoot = GetSystemMetrics(SM_CLEANBOOT) == 0; /* Perform the operations that are performed every boot */
    /* First, set the current directory to SystemRoot */
    WCHAR gen_path[MAX_PATH];
    DWORD res;
 
    res = GetWindowsDirectoryW(gen_path, _countof(gen_path));
    if (res == 0)
    {
        TRACE("Couldn't get the windows directory - error %lu\n", GetLastError());
 
        return 100;
    }
 
    if (!SetCurrentDirectoryW(gen_path))
    {
        TRACE("Cannot set the dir to %ls (%lu)\n", gen_path, GetLastError());
 
        return 100;
    }
 
    /* Perform the operations by order checking if policy allows it, checking if this is not Safe Mode,
     * stopping if one fails, skipping if necessary.
     */
    res = TRUE;
 
    if (bRunOnce)
    {
        if (res && bNormalBoot)
            ProcessRunOnceEx(HKEY_LOCAL_MACHINE);
 
        if (res && (SHRestricted(REST_NOLOCALMACHINERUNONCE) == 0))
            res = ProcessRunKeys(HKEY_LOCAL_MACHINE, L"RunOnce", TRUE, TRUE);
 
        return !res;
    }
 
    if (res && bNormalBoot && (SHRestricted(REST_NOLOCALMACHINERUN) == 0))
        res = ProcessRunKeys(HKEY_LOCAL_MACHINE, L"Run", FALSE, FALSE);
 
    if (res && bNormalBoot && (SHRestricted(REST_NOCURRENTUSERRUNONCE) == 0))
        res = ProcessRunKeys(HKEY_CURRENT_USER, L"Run", FALSE, FALSE);
 
    /* All users Startup folder */
    AutoStartupApplications(CSIDL_COMMON_STARTUP);
 
    /* Current user Startup folder */
    AutoStartupApplications(CSIDL_STARTUP);
 
    /* TODO: HKCU\RunOnce runs even if StartupHasBeenRun exists */
    if (res && bNormalBoot && (SHRestricted(REST_NOCURRENTUSERRUNONCE) == 0))
        res = ProcessRunKeys(HKEY_CURRENT_USER, L"RunOnce", TRUE, FALSE);
 
    TRACE("Operation done\n");
 
    return res ? 0 : 101;
}

ReleaseStartupMutex()

VOID ReleaseStartupMutex

(

)

Definition at line 513 of file startup.cpp.

{
    if (s_hStartupMutex)
    {
        ReleaseMutex(s_hStartupMutex);
        CloseHandle(s_hStartupMutex);
        s_hStartupMutex = NULL;
    }
}

Referenced by DoFinishStartupItems(), InitializeStartupMutex(), and StartWithDesktop().

runCmd()

static int runCmd ( LPWSTR  cmdline, LPCWSTR  dir, BOOL  wait, BOOL  minimized  )

static

This function runs the specified command in the specified dir. [in,out] cmdline - the command line to run. The function may change the passed buffer. [in] dir - the dir to run the command in. If it is NULL, then the current dir is used. [in] wait - whether to wait for the run program to finish before returning. [in] minimized - Whether to ask the program to run minimized.

Returns: If running the process failed, returns INVALID_RUNCMD_RETURN. Use GetLastError to get the error code. If wait is FALSE - returns 0 if successful. If wait is TRUE - returns the program's return value.

Definition at line 61 of file startup.cpp.

{
    STARTUPINFOW si;
    PROCESS_INFORMATION info;
    DWORD exit_code = 0;
 
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);
    if (minimized)
    {
        si.dwFlags = STARTF_USESHOWWINDOW;
        si.wShowWindow = SW_MINIMIZE;
    }
    memset(&info, 0, sizeof(info));
 
    if (!CreateProcessW(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, dir, &si, &info))
    {
        TRACE("Failed to run command (%lu)\n", GetLastError());
 
        return INVALID_RUNCMD_RETURN;
    }
 
    TRACE("Successfully ran command\n");
 
    if (wait)
    {
        HANDLE Handles[] = { info.hProcess };
        DWORD nCount = _countof(Handles);
        DWORD dwWait;
        MSG msg;
 
        /* wait for the process to exit */
        for (;;)
        {
            /* We need to keep processing messages,
               otherwise we will hang anything that is trying to send a message to us */
            dwWait = MsgWaitForMultipleObjects(nCount, Handles, FALSE, INFINITE, QS_ALLINPUT);
 
            /* WAIT_OBJECT_0 + nCount signals an event in the message queue,
               so anything other than that means we are done. */
            if (dwWait != WAIT_OBJECT_0 + nCount)
            {
                if (dwWait >= WAIT_OBJECT_0 && dwWait < WAIT_OBJECT_0 + nCount)
                    TRACE("Event %u signaled\n", dwWait - WAIT_OBJECT_0);
                else
                    WARN("Return code: %u\n", dwWait);
                break;
            }
 
            while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
            {
                TranslateMessage(&msg);
                DispatchMessageW(&msg);
            }
        }
 
        GetExitCodeProcess(info.hProcess, &exit_code);
    }
 
    CloseHandle(info.hThread);
    CloseHandle(info.hProcess);
 
    return exit_code;
}

Referenced by AutoStartupApplications(), ProcessRunKeys(), and ProcessRunOnceEx().

Variable Documentation

s_hStartupMutex

HANDLE s_hStartupMutex = NULL

static

Definition at line 46 of file startup.cpp.

Referenced by InitializeStartupMutex(), and ReleaseStartupMutex().