startup.c File Reference

#include <stdio.h>
#include <windows.h>

Include dependency graph for startup.c:

Go to the source code of this file.

Classes
struct	op_mask
	structure holding startup flags More...

Macros
#define	INVALID_RUNCMD_RETURN   -1
#define	DEFAULT   SESSION_START

Enumerations
enum	runkeys { RUNKEY_RUN , RUNKEY_RUNONCE , RUNKEY_RUNSERVICES , RUNKEY_RUNSERVICESONCE }

Functions
EXTERN_C HRESULT WINAPI	SHCreateSessionKey (REGSAM samDesired, PHKEY phKey)
static BOOL	wininit ()
static BOOL	pendingRename ()
static int	runCmd (LPWSTR cmdline, LPCWSTR dir, BOOL wait, BOOL minimized)
static BOOL	ProcessRunKeys (HKEY hkRoot, LPCWSTR szKeyName, BOOL bDelete, BOOL bSynchronous)
int	startup (int argc, const char *argv[])

Variables
const WCHAR	runkeys_names [][30]
static const struct op_mask	SESSION_START = {FALSE, FALSE, TRUE, TRUE, TRUE, TRUE}
static const struct op_mask	SETUP = {FALSE, FALSE, FALSE, TRUE, TRUE, TRUE}

Macro Definition Documentation

DEFAULT

#define DEFAULT   SESSION_START

Definition at line 428 of file startup.c.

INVALID_RUNCMD_RETURN

#define INVALID_RUNCMD_RETURN   -1

Definition at line 227 of file startup.c.

Enumeration Type Documentation

runkeys

enum runkeys

Enumerator
RUNKEY_RUN
RUNKEY_RUNONCE
RUNKEY_RUNSERVICES
RUNKEY_RUNSERVICESONCE

Definition at line 215 of file startup.c.

             {
    RUNKEY_RUN, RUNKEY_RUNONCE, RUNKEY_RUNSERVICES, RUNKEY_RUNSERVICESONCE
};

Function Documentation

pendingRename()

static BOOL pendingRename ( )

static

Definition at line 69 of file startup.c.

{
    static const WCHAR ValueName[] = {'P','e','n','d','i','n','g',
                                      'F','i','l','e','R','e','n','a','m','e',
                                      'O','p','e','r','a','t','i','o','n','s',0};
    static const WCHAR SessionW[] = { 'S','y','s','t','e','m','\\',
                                     'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
                                     'C','o','n','t','r','o','l','\\',
                                     'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r',0};
    WCHAR *buffer=NULL;
    const WCHAR *src=NULL, *dst=NULL;
    DWORD dataLength=0;
    HKEY hSession=NULL;
    DWORD res;
 
    printf("Entered\n");
 
    if ((res=RegOpenKeyExW(HKEY_LOCAL_MACHINE, SessionW, 0, KEY_ALL_ACCESS, &hSession))
            !=ERROR_SUCCESS)
    {
        if (res==ERROR_FILE_NOT_FOUND)
        {
            printf("The key was not found - skipping\n");
            res=TRUE;
        }
        else
        {
            printf("Couldn't open key, error %lu\n", res);
            res=FALSE;
        }
 
        goto end;
    }
 
    res=RegQueryValueExW(hSession, ValueName, NULL, NULL /* The value type does not really interest us, as it is not
                                                             truely a REG_MULTI_SZ anyways */,
            NULL, &dataLength);
    if (res==ERROR_FILE_NOT_FOUND)
    {
        /* No value - nothing to do. Great! */
        printf("Value not present - nothing to rename\n");
        res=TRUE;
        goto end;
    }
 
    if (res!=ERROR_SUCCESS)
    {
        printf("Couldn't query value's length (%lu)\n", res);
        res=FALSE;
        goto end;
    }
 
    buffer=malloc(dataLength);
    if (buffer==NULL)
    {
        printf("Couldn't allocate %lu bytes for the value\n", dataLength);
        res=FALSE;
        goto end;
    }
 
    res=RegQueryValueExW(hSession, ValueName, NULL, NULL, (LPBYTE)buffer, &dataLength);
    if (res!=ERROR_SUCCESS)
    {
        printf("Couldn't query value after successfully querying before (%lu),\n"
                "please report to wine-devel@winehq.org\n", res);
        res=FALSE;
        goto end;
    }
 
    /* Make sure that the data is long enough and ends with two NULLs. This
     * simplifies the code later on.
     */
    if (dataLength<2*sizeof(buffer[0]) ||
            buffer[dataLength/sizeof(buffer[0])-1]!='\0' ||
            buffer[dataLength/sizeof(buffer[0])-2]!='\0')
    {
        printf("Improper value format - doesn't end with NULL\n");
        res=FALSE;
        goto end;
    }
 
    for(src=buffer; (src-buffer)*sizeof(src[0])<dataLength && *src!='\0';
            src=dst+lstrlenW(dst)+1)
    {
        DWORD dwFlags=0;
 
        printf("processing next command\n");
 
        dst=src+lstrlenW(src)+1;
 
        /* We need to skip the \??\ header */
        if (src[0]=='\\' && src[1]=='?' && src[2]=='?' && src[3]=='\\')
            src+=4;
 
        if (dst[0]=='!')
        {
            dwFlags|=MOVEFILE_REPLACE_EXISTING;
            dst++;
        }
 
        if (dst[0]=='\\' && dst[1]=='?' && dst[2]=='?' && dst[3]=='\\')
            dst+=4;
 
        if (*dst!='\0')
        {
            /* Rename the file */
            MoveFileExW(src, dst, dwFlags);
        } else
        {
            /* Delete the file or directory */
            res = GetFileAttributesW (src);
            if (res != (DWORD)-1)
            {
                if ((res&FILE_ATTRIBUTE_DIRECTORY)==0)
                {
                    /* It's a file */
                    DeleteFileW(src);
                } else
                {
                    /* It's a directory */
                    RemoveDirectoryW(src);
                }
            } else
            {
                printf("couldn't get file attributes (%ld)\n", GetLastError());
            }
        }
    }
 
    if ((res=RegDeleteValueW(hSession, ValueName))!=ERROR_SUCCESS)
    {
        printf("Error deleting the value (%lu)\n", GetLastError());
        res=FALSE;
    } else
        res=TRUE;
 
end:
    if (buffer!=NULL)
        free(buffer);
 
    if (hSession!=NULL)
        RegCloseKey(hSession);
 
    return res;
}

Referenced by startup().

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 289 of file startup.c.

{
    static const WCHAR WINKEY_NAME[]={'S','o','f','t','w','a','r','e','\\',
        'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
        'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
    HKEY hkWin=NULL, hkRun=NULL;
    LONG res=ERROR_SUCCESS;
    DWORD i, nMaxCmdLine=0, nMaxValue=0;
    WCHAR *szCmdLine=NULL;
    WCHAR *szValue=NULL;
 
    if (hkRoot==HKEY_LOCAL_MACHINE)
        wprintf(L"processing %s entries under HKLM\n", szKeyName);
    else
        wprintf(L"processing %s entries under HKCU\n", szKeyName);
 
    if ((res=RegOpenKeyExW(hkRoot, WINKEY_NAME, 0, KEY_READ, &hkWin))!=ERROR_SUCCESS)
    {
        printf("RegOpenKey failed on Software\\Microsoft\\Windows\\CurrentVersion (%ld)\n",
                res);
 
        goto end;
    }
 
    if ((res=RegOpenKeyExW(hkWin, szKeyName, 0, bDelete?KEY_ALL_ACCESS:KEY_READ, &hkRun))!=
            ERROR_SUCCESS)
    {
        if (res==ERROR_FILE_NOT_FOUND)
        {
            printf("Key doesn't exist - nothing to be done\n");
 
            res=ERROR_SUCCESS;
        }
        else
            printf("RegOpenKey failed on run key (%ld)\n", res);
 
        goto end;
    }
 
    if ((res=RegQueryInfoKeyW(hkRun, NULL, NULL, NULL, NULL, NULL, NULL, &i, &nMaxValue,
                    &nMaxCmdLine, NULL, NULL))!=ERROR_SUCCESS)
    {
        printf("Couldn't query key info (%ld)\n", res);
 
        goto end;
    }
 
    if (i==0)
    {
        printf("No commands to execute.\n");
 
        res=ERROR_SUCCESS;
        goto end;
    }
 
    if ((szCmdLine=malloc(nMaxCmdLine))==NULL)
    {
        printf("Couldn't allocate memory for the commands to be executed\n");
 
        res=ERROR_NOT_ENOUGH_MEMORY;
        goto end;
    }
 
    if ((szValue=malloc((++nMaxValue)*sizeof(*szValue)))==NULL)
    {
        printf("Couldn't allocate memory for the value names\n");
 
        free(szCmdLine);
        res=ERROR_NOT_ENOUGH_MEMORY;
        goto end;
    }
 
    while(i>0)
    {
        DWORD nValLength=nMaxValue, nDataLength=nMaxCmdLine;
        DWORD type;
 
        --i;
 
        if ((res=RegEnumValueW(hkRun, i, szValue, &nValLength, 0, &type,
                        (LPBYTE)szCmdLine, &nDataLength))!=ERROR_SUCCESS)
        {
            printf("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)
        {
            printf("Couldn't delete value - %lu, %ld. Running command anyways.\n", i, res);
        }
 
        if (type!=REG_SZ)
        {
            printf("Incorrect type of value #%lu (%lu)\n", i, type);
 
            continue;
        }
 
        if ((res=runCmd(szCmdLine, NULL, bSynchronous, FALSE))==INVALID_RUNCMD_RETURN)
        {
            printf("Error running cmd #%lu (%ld)\n", i, GetLastError());
        }
 
        printf("Done processing cmd #%lu\n", i);
    }
 
    free(szValue);
    free(szCmdLine);
    res=ERROR_SUCCESS;
 
end:
    if (hkRun!=NULL)
        RegCloseKey(hkRun);
    if (hkWin!=NULL)
        RegCloseKey(hkWin);
 
    printf("done\n");
 
    return res==ERROR_SUCCESS?TRUE:FALSE;
}

Referenced by startup().

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 240 of file startup.c.

{
    STARTUPINFOW si;
    PROCESS_INFORMATION info;
    DWORD exit_code=0;
    WCHAR szCmdLineExp[MAX_PATH+1]= L"\0";
 
    ExpandEnvironmentStringsW(cmdline, szCmdLineExp, sizeof(szCmdLineExp) / sizeof(WCHAR));
 
    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, szCmdLineExp, NULL, NULL, FALSE, 0, NULL, dir, &si, &info))
    {
        printf("Failed to run command (%ld)\n", GetLastError());
 
        return INVALID_RUNCMD_RETURN;
    }
 
    printf("Successfully ran command\n"); //%s - Created process handle %p\n",
               //wine_dbgstr_w(szCmdLineExp), info.hProcess);
 
    if (wait)
    {   /* wait for the process to exit */
        WaitForSingleObject(info.hProcess, INFINITE);
        GetExitCodeProcess(info.hProcess, &exit_code);
    }
 
    CloseHandle(info.hThread);
    CloseHandle(info.hProcess);
 
    return exit_code;
}

Referenced by ProcessRunKeys().

SHCreateSessionKey()

EXTERN_C HRESULT WINAPI SHCreateSessionKey	(	REGSAM	samDesired,
		PHKEY	phKey
	)

Definition at line 147 of file shellreg.c.

{
    HRESULT hr = S_OK;
    static WCHAR wszSessionKey[256];
    LONG Error;
 
    if (!wszSessionKey[0]) // FIXME: Critical Section
    {
        HANDLE hToken;
 
        if (OpenProcessToken(GetCurrentProcess(), TOKEN_READ, &hToken))
        {
            TOKEN_STATISTICS Stats;
            DWORD ReturnLength;
 
            if (GetTokenInformation(hToken, TokenStatistics, &Stats, sizeof(Stats), &ReturnLength))
            {
                swprintf(wszSessionKey,
                         L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\SessionInfo\\%08x%08x",
                         Stats.AuthenticationId.HighPart, Stats.AuthenticationId.LowPart);
            }
            else
                hr = HRESULT_FROM_WIN32(GetLastError());
 
            CloseHandle(hToken);
        }
        else
            hr = HRESULT_FROM_WIN32(GetLastError());
    }
 
    if(SUCCEEDED(hr))
    {
        Error = RegCreateKeyExW(HKEY_LOCAL_MACHINE, wszSessionKey, 0, NULL,
                                REG_OPTION_VOLATILE, samDesired, NULL, phKey, NULL);
        if (Error != ERROR_SUCCESS)
            hr = HRESULT_FROM_WIN32(Error);
    }
 
    return hr;
}

Referenced by startup().

startup()

int startup	(	int	argc,
		const char *	argv[]
	)

Definition at line 430 of file startup.c.

{
    struct op_mask ops; /* Which of the ops do we want to perform? */
    /* First, set the current directory to SystemRoot */
    TCHAR gen_path[MAX_PATH];
    DWORD res;
    HKEY hSessionKey, hKey;
    HRESULT hr;
 
    res = GetWindowsDirectory(gen_path, sizeof(gen_path));
 
    if (res==0)
    {
        printf("Couldn't get the windows directory - error %ld\n",
            GetLastError());
 
        return 100;
    }
 
    if (!SetCurrentDirectory(gen_path))
    {
        wprintf(L"Cannot set the dir to %s (%ld)\n", gen_path, GetLastError());
 
        return 100;
    }
 
    hr = SHCreateSessionKey(KEY_WRITE, &hSessionKey);
    if (SUCCEEDED(hr))
    {
        LONG Error;
        DWORD dwDisp;
 
        Error = RegCreateKeyEx(hSessionKey, L"StartupHasBeenRun", 0, NULL, REG_OPTION_VOLATILE, KEY_WRITE, NULL, &hKey, &dwDisp);
        RegCloseKey(hSessionKey);
        if (Error == ERROR_SUCCESS)
        {
            RegCloseKey(hKey);
            if (dwDisp == REG_OPENED_EXISTING_KEY)
            {
                /* Startup programs has already been run */
                return 0;
            }
        }
    }
 
    if (argc > 1)
    {
        switch(argv[1][0])
        {
        case 'r': /* Restart */
            ops = SETUP;
            break;
        case 's': /* Full start */
            ops = SESSION_START;
            break;
        default:
            ops = DEFAULT;
            break;
        }
    } else
        ops = DEFAULT;
 
    /* do not run certain items in Safe Mode */
    if(GetSystemMetrics(SM_CLEANBOOT)) ops.startup = FALSE;
 
    /* Perform the ops by order, stopping if one fails, skipping if necessary */
    /* Shachar: Sorry for the perl syntax */
    res = TRUE;
    if (res && !ops.ntonly && ops.preboot)
         res = wininit();
    if (res && !ops.w9xonly && ops.preboot)
         res = pendingRename();
    if (res && !ops.ntonly && ops.prelogin)
         res = ProcessRunKeys(HKEY_LOCAL_MACHINE, runkeys_names[RUNKEY_RUNSERVICESONCE], TRUE, FALSE);
    if (res && !ops.ntonly && ops.prelogin && ops.startup)
         res = ProcessRunKeys(HKEY_LOCAL_MACHINE, runkeys_names[RUNKEY_RUNSERVICES], FALSE, FALSE);
    if (res && ops.postlogin)
         res = ProcessRunKeys(HKEY_LOCAL_MACHINE, runkeys_names[RUNKEY_RUNONCE], TRUE, TRUE);
    if (res && ops.postlogin && ops.startup)
         res = ProcessRunKeys(HKEY_LOCAL_MACHINE, runkeys_names[RUNKEY_RUN], FALSE, FALSE);
    if (res && ops.postlogin && ops.startup)
         res = ProcessRunKeys(HKEY_CURRENT_USER, runkeys_names[RUNKEY_RUN], FALSE, FALSE);
    if (res && ops.postlogin && ops.startup)
         res = ProcessRunKeys(HKEY_CURRENT_USER, runkeys_names[RUNKEY_RUNONCE], TRUE, FALSE);
 
    printf("Operation done\n");
 
    return res ? 0 : 101;
}

wininit()

static BOOL wininit ( )

static

Performs the rename operations dictated in SystemRoot%\Wininit.ini. Returns FALSE if there was an error, or otherwise if all is ok.

Definition at line 64 of file startup.c.

{
    return TRUE;
}

Referenced by startup().

Variable Documentation

runkeys_names

const WCHAR runkeys_names[][30]

Initial value:

=
{
    {'R','u','n',0},
    {'R','u','n','O','n','c','e',0},
    {'R','u','n','S','e','r','v','i','c','e','s',0},
    {'R','u','n','S','e','r','v','i','c','e','s','O','n','c','e',0}
}

Definition at line 219 of file startup.c.

Referenced by startup().

SESSION_START

const struct op_mask SESSION_START = {FALSE, FALSE, TRUE, TRUE, TRUE, TRUE}

static

Definition at line 426 of file startup.c.

Referenced by startup().

SETUP

const struct op_mask SETUP = {FALSE, FALSE, FALSE, TRUE, TRUE, TRUE}

static

Definition at line 427 of file startup.c.

Referenced by startup().