main.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "initguid.h"
#include "ocidl.h"
#include "featurestagingapi.h"
#include "shellscalingapi.h"
#include "shcore.h"
#include "shlwapi.h"
#include "wine/debug.h"

Include dependency graph for main.c:

Go to the source code of this file.

Classes
struct	shstream
struct	threadref
struct	thread_data

Macros
#define	COBJMACROS
#define	WINSHLWAPI
#define	ISOS_RETURN(x)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shcore)
BOOL WINAPI	DllMain (HINSTANCE instance, DWORD reason, void *reserved)
HRESULT WINAPI	GetProcessDpiAwareness (HANDLE process, PROCESS_DPI_AWARENESS *value)
HRESULT WINAPI	SetProcessDpiAwareness (PROCESS_DPI_AWARENESS value)
HRESULT WINAPI	GetDpiForMonitor (HMONITOR monitor, MONITOR_DPI_TYPE type, UINT *x, UINT *y)
HRESULT WINAPI	GetScaleFactorForMonitor (HMONITOR monitor, DEVICE_SCALE_FACTOR *scale)
DEVICE_SCALE_FACTOR WINAPI	GetScaleFactorForDevice (DISPLAY_DEVICE_TYPE device_type)
HRESULT WINAPI	_IStream_Read (IStream *stream, void *dest, ULONG size)
HRESULT WINAPI	IStream_Reset (IStream *stream)
HRESULT WINAPI	IStream_Size (IStream *stream, ULARGE_INTEGER *size)
HRESULT WINAPI	_IStream_Write (IStream *stream, const void *src, ULONG size)
void WINAPI	IUnknown_AtomicRelease (IUnknown **obj)
HRESULT WINAPI	IUnknown_GetSite (IUnknown *unk, REFIID iid, void **site)
HRESULT WINAPI	IUnknown_QueryService (IUnknown *obj, REFGUID sid, REFIID iid, void **out)
void WINAPI	IUnknown_Set (IUnknown **dest, IUnknown *src)
HRESULT WINAPI	IUnknown_SetSite (IUnknown *obj, IUnknown *site)
HRESULT WINAPI	SetCurrentProcessExplicitAppUserModelID (const WCHAR *appid)
HRESULT WINAPI	GetCurrentProcessExplicitAppUserModelID (const WCHAR **appid)
WCHAR **WINAPI	CommandLineToArgvW (const WCHAR *cmdline, int *numargs)
static struct shstream *	impl_from_IStream (IStream *iface)
static HRESULT WINAPI	shstream_QueryInterface (IStream *iface, REFIID riid, void **out)
static ULONG WINAPI	shstream_AddRef (IStream *iface)
static ULONG WINAPI	memstream_Release (IStream *iface)
static HRESULT WINAPI	memstream_Read (IStream *iface, void *buff, ULONG buff_size, ULONG *read_len)
static HRESULT WINAPI	memstream_Write (IStream *iface, const void *buff, ULONG buff_size, ULONG *written)
static HRESULT WINAPI	memstream_Seek (IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *new_pos)
static HRESULT WINAPI	memstream_SetSize (IStream *iface, ULARGE_INTEGER new_size)
static HRESULT WINAPI	shstream_CopyTo (IStream *iface, IStream *dest, ULARGE_INTEGER size, ULARGE_INTEGER *read_len, ULARGE_INTEGER *written)
static HRESULT WINAPI	shstream_Commit (IStream *iface, DWORD flags)
static HRESULT WINAPI	shstream_Revert (IStream *iface)
static HRESULT WINAPI	shstream_LockRegion (IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER size, DWORD lock_type)
static HRESULT WINAPI	shstream_UnlockRegion (IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER size, DWORD lock_type)
static HRESULT WINAPI	memstream_Stat (IStream *iface, STATSTG *statstg, DWORD flags)
static HRESULT WINAPI	shstream_Clone (IStream *iface, IStream **dest)
static struct shstream *	shstream_create (const IStreamVtbl *vtbl, const BYTE *data, UINT data_len)
IStream *WINAPI	SHCreateMemStream (const BYTE *data, UINT data_len)
static ULONG WINAPI	filestream_Release (IStream *iface)
static HRESULT WINAPI	filestream_Read (IStream *iface, void *buff, ULONG size, ULONG *read_len)
static HRESULT WINAPI	filestream_Write (IStream *iface, const void *buff, ULONG size, ULONG *written)
static HRESULT WINAPI	filestream_Seek (IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *new_pos)
static HRESULT WINAPI	filestream_SetSize (IStream *iface, ULARGE_INTEGER size)
static HRESULT WINAPI	filestream_CopyTo (IStream *iface, IStream *dest, ULARGE_INTEGER size, ULARGE_INTEGER *read_len, ULARGE_INTEGER *written)
static HRESULT WINAPI	filestream_Commit (IStream *iface, DWORD flags)
static HRESULT WINAPI	filestream_Stat (IStream *iface, STATSTG *statstg, DWORD flags)
HRESULT WINAPI	SHCreateStreamOnFileEx (const WCHAR *path, DWORD mode, DWORD attributes, BOOL create, IStream *template, IStream **ret)
HRESULT WINAPI	SHCreateStreamOnFileW (const WCHAR *path, DWORD mode, IStream **stream)
HRESULT WINAPI	SHCreateStreamOnFileA (const char *path, DWORD mode, IStream **stream)
static ULONG WINAPI	regstream_Release (IStream *iface)
IStream *WINAPI	SHOpenRegStream2W (HKEY hKey, const WCHAR *subkey, const WCHAR *value, DWORD mode)
IStream *WINAPI	SHOpenRegStream2A (HKEY hKey, const char *subkey, const char *value, DWORD mode)
IStream *WINAPI	SHOpenRegStreamA (HKEY hkey, const char *subkey, const char *value, DWORD mode)
static ULONG WINAPI	dummystream_AddRef (IStream *iface)
static ULONG WINAPI	dummystream_Release (IStream *iface)
static HRESULT WINAPI	dummystream_Read (IStream *iface, void *buff, ULONG buff_size, ULONG *read_len)
IStream *WINAPI	SHOpenRegStreamW (HKEY hkey, const WCHAR *subkey, const WCHAR *value, DWORD mode)
static struct threadref *	threadref_impl_from_IUnknown (IUnknown *iface)
static HRESULT WINAPI	threadref_QueryInterface (IUnknown *iface, REFIID riid, void **out)
static ULONG WINAPI	threadref_AddRef (IUnknown *iface)
static ULONG WINAPI	threadref_Release (IUnknown *iface)
HRESULT WINAPI	SHCreateThreadRef (LONG *refcount, IUnknown **out)
HRESULT WINAPI	SHGetThreadRef (IUnknown **out)
HRESULT WINAPI	SHSetThreadRef (IUnknown *obj)
HRESULT WINAPI	SHReleaseThreadRef (void)
HRESULT WINAPI	GetProcessReference (IUnknown **obj)
void WINAPI	SetProcessReference (IUnknown *obj)
static DWORD WINAPI	shcore_thread_wrapper (void *data)
BOOL WINAPI	SHCreateThread (LPTHREAD_START_ROUTINE thread_proc, void *data, DWORD flags, LPTHREAD_START_ROUTINE callback)
HRESULT WINAPI	SHStrDupW (const WCHAR *src, WCHAR **dest)
HRESULT WINAPI	SHStrDupA (const char *src, WCHAR **dest)
DWORD WINAPI	SHAnsiToAnsi (const char *src, char *dest, int dest_len)
DWORD WINAPI	SHUnicodeToAnsi (const WCHAR *src, char *dest, int dest_len)
DWORD WINAPI	SHUnicodeToUnicode (const WCHAR *src, WCHAR *dest, int dest_len)
DWORD WINAPI	SHAnsiToUnicode (const char *src, WCHAR *dest, int dest_len)
HKEY WINAPI	SHRegDuplicateHKey (HKEY hKey)
DWORD WINAPI	SHDeleteEmptyKeyW (HKEY hkey, const WCHAR *subkey)
DWORD WINAPI	SHDeleteEmptyKeyA (HKEY hkey, const char *subkey)
DWORD WINAPI	SHDeleteKeyW (HKEY hkey, const WCHAR *subkey)
DWORD WINAPI	SHDeleteKeyA (HKEY hkey, const char *subkey)
DWORD WINAPI	SHDeleteValueW (HKEY hkey, const WCHAR *subkey, const WCHAR *value)
DWORD WINAPI	SHDeleteValueA (HKEY hkey, const char *subkey, const char *value)
DWORD WINAPI	SHCopyKeyA (HKEY hkey_src, const char *subkey, HKEY hkey_dst, DWORD reserved)
DWORD WINAPI	SHCopyKeyW (HKEY hkey_src, const WCHAR *subkey, HKEY hkey_dst, DWORD reserved)
LONG WINAPI	SHEnumKeyExA (HKEY hkey, DWORD index, char *subkey, DWORD *length)
LONG WINAPI	SHEnumKeyExW (HKEY hkey, DWORD index, WCHAR *subkey, DWORD *length)
LONG WINAPI	SHEnumValueA (HKEY hkey, DWORD index, char *value, DWORD *length, DWORD *type, void *data, DWORD *data_len)
LONG WINAPI	SHEnumValueW (HKEY hkey, DWORD index, WCHAR *value, DWORD *length, DWORD *type, void *data, DWORD *data_len)
DWORD WINAPI	SHQueryValueExW (HKEY hkey, const WCHAR *name, DWORD *reserved, DWORD *type, void *buff, DWORD *buff_len)
DWORD WINAPI	SHQueryValueExA (HKEY hkey, const char *name, DWORD *reserved, DWORD *type, void *buff, DWORD *buff_len)
DWORD WINAPI	SHGetValueA (HKEY hkey, const char *subkey, const char *value, DWORD *type, void *data, DWORD *data_len)
DWORD WINAPI	SHGetValueW (HKEY hkey, const WCHAR *subkey, const WCHAR *value, DWORD *type, void *data, DWORD *data_len)
int WINAPI	SHRegGetIntW (HKEY hkey, const WCHAR *value, int default_value)
DWORD WINAPI	SHRegGetPathA (HKEY hkey, const char *subkey, const char *value, char *path, DWORD flags)
DWORD WINAPI	SHRegGetPathW (HKEY hkey, const WCHAR *subkey, const WCHAR *value, WCHAR *path, DWORD flags)
DWORD WINAPI	SHSetValueW (HKEY hkey, const WCHAR *subkey, const WCHAR *value, DWORD type, const void *data, DWORD data_len)
DWORD WINAPI	SHSetValueA (HKEY hkey, const char *subkey, const char *value, DWORD type, const void *data, DWORD data_len)
DWORD WINAPI	SHRegSetPathA (HKEY hkey, const char *subkey, const char *value, const char *path, DWORD flags)
DWORD WINAPI	SHRegSetPathW (HKEY hkey, const WCHAR *subkey, const WCHAR *value, const WCHAR *path, DWORD flags)
LONG WINAPI	SHQueryInfoKeyA (HKEY hkey, DWORD *subkeys, DWORD *subkey_max, DWORD *values, DWORD *value_max)
LONG WINAPI	SHQueryInfoKeyW (HKEY hkey, DWORD *subkeys, DWORD *subkey_max, DWORD *values, DWORD *value_max)
BOOL WINAPI	IsOS (DWORD feature)
void WINAPI	SubscribeFeatureStateChangeNotification (FEATURE_STATE_CHANGE_SUBSCRIPTION *subscription, FEATURE_STATE_CHANGE_CALLBACK *callback, void *context)
FEATURE_ENABLED_STATE WINAPI	GetFeatureEnabledState (UINT32 feature, FEATURE_CHANGE_TIME change_time)
HRESULT WINAPI	RegisterScaleChangeEvent (HANDLE handle, DWORD_PTR *cookie)
HRESULT WINAPI	RegisterScaleChangeNotifications (DISPLAY_DEVICE_TYPE display_device, HWND hwnd, UINT msg, DWORD *cookie)
HRESULT WINAPI	CreateRandomAccessStreamOverStream (IStream *stream, BSOS_OPTIONS options, REFIID riid, void **ppv)

Variables
static DWORD	shcore_tls
static IUnknown *	process_ref
static const IStreamVtbl	memstreamvtbl
static const IStreamVtbl	filestreamvtbl
static const IStreamVtbl	regstreamvtbl
static const IStreamVtbl	dummystreamvtbl
static struct shstream	dummyregstream = { { &dummystreamvtbl } }
static const IUnknownVtbl	threadrefvtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 22 of file main.c.

ISOS_RETURN

#define ISOS_RETURN

(

x

)

Value:

    TRACE("(%#lx) ret %d\n",feature,(x)); \
    return (x)

WINSHLWAPI

#define WINSHLWAPI

Definition at line 33 of file main.c.

Function Documentation

_IStream_Read()

HRESULT WINAPI _IStream_Read	(	IStream *	stream,
		void *	dest,
		ULONG	size
	)

Definition at line 98 of file main.c.

{
    ULONG read;
    HRESULT hr;
 
    TRACE("%p, %p, %lu.\n", stream, dest, size);
 
    hr = IStream_Read(stream, dest, size, &read);
    if (SUCCEEDED(hr) && read != size)
        hr = E_FAIL;
    return hr;
}

_IStream_Write()

HRESULT WINAPI _IStream_Write	(	IStream *	stream,
		const void *	src,
		ULONG	size
	)

Definition at line 136 of file main.c.

{
    ULONG written;
    HRESULT hr;
 
    TRACE("%p, %p, %lu.\n", stream, src, size);
 
    hr = IStream_Write(stream, src, size, &written);
    if (SUCCEEDED(hr) && written != size)
        hr = E_FAIL;
 
    return hr;
}

CommandLineToArgvW()

WCHAR **WINAPI CommandLineToArgvW	(	const WCHAR *	cmdline,
		int *	numargs
	)

Definition at line 294 of file main.c.

{
    int qcount, bcount;
    const WCHAR *s;
    WCHAR **argv;
    DWORD argc;
    WCHAR *d;
 
    if (!numargs)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    if (*cmdline == 0)
    {
        /* Return the path to the executable */
        DWORD len, deslen = MAX_PATH, size;
 
        size = sizeof(WCHAR *) * 2 + deslen * sizeof(WCHAR);
        for (;;)
        {
            if (!(argv = LocalAlloc(LMEM_FIXED, size))) return NULL;
            len = GetModuleFileNameW(0, (WCHAR *)(argv + 2), deslen);
            if (!len)
            {
                LocalFree(argv);
                return NULL;
            }
            if (len < deslen) break;
            deslen *= 2;
            size = sizeof(WCHAR *) * 2 + deslen * sizeof(WCHAR);
            LocalFree(argv);
        }
        argv[0] = (WCHAR *)(argv + 2);
        argv[1] = NULL;
        *numargs = 1;
 
        return argv;
    }
 
    /* --- First count the arguments */
    argc = 1;
    s = cmdline;
    /* The first argument, the executable path, follows special rules */
    if (*s == '"')
    {
        /* The executable path ends at the next quote, no matter what */
        s++;
        while (*s)
            if (*s++ == '"')
                break;
    }
    else
    {
        /* The executable path ends at the next space, no matter what */
        while (*s && *s != ' ' && *s != '\t')
            s++;
    }
    /* skip to the first argument, if any */
    while (*s == ' ' || *s == '\t')
        s++;
    if (*s)
        argc++;
 
    /* Analyze the remaining arguments */
    qcount = bcount = 0;
    while (*s)
    {
        if ((*s == ' ' || *s == '\t') && qcount == 0)
        {
            /* skip to the next argument and count it if any */
            while (*s == ' ' || *s == '\t')
                s++;
            if (*s)
                argc++;
            bcount = 0;
        }
        else if (*s == '\\')
        {
            /* '\', count them */
            bcount++;
            s++;
        }
        else if (*s == '"')
        {
            /* '"' */
            if ((bcount & 1) == 0)
                qcount++; /* unescaped '"' */
            s++;
            bcount = 0;
            /* consecutive quotes, see comment in copying code below */
            while (*s == '"')
            {
                qcount++;
                s++;
            }
            qcount = qcount % 3;
            if (qcount == 2)
                qcount = 0;
        }
        else
        {
            /* a regular character */
            bcount = 0;
            s++;
        }
    }
 
    /* Allocate in a single lump, the string array, and the strings that go
     * with it. This way the caller can make a single LocalFree() call to free
     * both, as per MSDN.
     */
    argv = LocalAlloc(LMEM_FIXED, (argc + 1) * sizeof(WCHAR *) + (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
    if (!argv)
        return NULL;
 
    /* --- Then split and copy the arguments */
    argv[0] = d = lstrcpyW((WCHAR *)(argv + argc + 1), cmdline);
    argc = 1;
    /* The first argument, the executable path, follows special rules */
    if (*d == '"')
    {
        /* The executable path ends at the next quote, no matter what */
        s = d + 1;
        while (*s)
        {
            if (*s == '"')
            {
                s++;
                break;
            }
            *d++ = *s++;
        }
    }
    else
    {
        /* The executable path ends at the next space, no matter what */
        while (*d && *d != ' ' && *d != '\t')
            d++;
        s = d;
        if (*s)
            s++;
    }
    /* close the executable path */
    *d++ = 0;
    /* skip to the first argument and initialize it if any */
    while (*s == ' ' || *s == '\t')
        s++;
    if (!*s)
    {
        /* There are no parameters so we are all done */
        argv[argc] = NULL;
        *numargs = argc;
        return argv;
    }
 
    /* Split and copy the remaining arguments */
    argv[argc++] = d;
    qcount = bcount = 0;
    while (*s)
    {
        if ((*s == ' ' || *s == '\t') && qcount == 0)
        {
            /* close the argument */
            *d++ = 0;
            bcount = 0;
 
            /* skip to the next one and initialize it if any */
            do {
                s++;
            } while (*s == ' ' || *s == '\t');
            if (*s)
                argv[argc++] = d;
        }
        else if (*s=='\\')
        {
            *d++ = *s++;
            bcount++;
        }
        else if (*s == '"')
        {
            if ((bcount & 1) == 0)
            {
                /* Preceded by an even number of '\', this is half that
                 * number of '\', plus a quote which we erase.
                 */
                d -= bcount / 2;
                qcount++;
            }
            else
            {
                /* Preceded by an odd number of '\', this is half that
                 * number of '\' followed by a '"'
                 */
                d = d - bcount / 2 - 1;
                *d++ = '"';
            }
            s++;
            bcount = 0;
            /* Now count the number of consecutive quotes. Note that qcount
             * already takes into account the opening quote if any, as well as
             * the quote that lead us here.
             */
            while (*s == '"')
            {
                if (++qcount == 3)
                {
                    *d++ = '"';
                    qcount = 0;
                }
                s++;
            }
            if (qcount == 2)
                qcount = 0;
        }
        else
        {
            /* a regular character */
            *d++ = *s++;
            bcount = 0;
        }
    }
    *d = '\0';
    argv[argc] = NULL;
    *numargs = argc;
 
    return argv;
}

Referenced by _tmain(), CmdDebugService(), command_line_to_args(), DisplayApplet(), DoEntry(), get_utf8_args(), main(), ParseCmdAndExecute(), CCleanMgrModule::ParseCommandLine(), PrintUIEntryW(), ProcessCmdLine(), ProcessCommandLine(), test_commandline2argv(), test_one_cmdline(), and wWinMain().

CreateRandomAccessStreamOverStream()

HRESULT WINAPI CreateRandomAccessStreamOverStream	(	IStream *	stream,
		BSOS_OPTIONS	options,
		REFIID	riid,
		void **	ppv
	)

Definition at line 2593 of file main.c.

{
    FIXME("(%p, %d, %s, %p) stub\n", stream, options, debugstr_guid(riid), ppv);
    return E_NOTIMPL;
}

DllMain()

BOOL WINAPI DllMain	(	HINSTANCE	instance,
		DWORD	reason,
		void *	reserved
	)

Definition at line 43 of file main.c.

{
    TRACE("%p, %lu, %p.\n", instance, reason, reserved);
 
    switch (reason)
    {
        case DLL_PROCESS_ATTACH:
            DisableThreadLibraryCalls(instance);
            shcore_tls = TlsAlloc();
            break;
        case DLL_PROCESS_DETACH:
            if (reserved) break;
            if (shcore_tls != TLS_OUT_OF_INDEXES)
                TlsFree(shcore_tls);
            break;
    }
 
    return TRUE;
}

dummystream_AddRef()

static ULONG WINAPI dummystream_AddRef ( IStream *  iface )

static

Definition at line 1361 of file main.c.

{
    TRACE("()\n");
    return 2;
}

dummystream_Read()

static HRESULT WINAPI dummystream_Read ( IStream *  iface, void *  buff, ULONG  buff_size, ULONG *  read_len  )

static

Definition at line 1373 of file main.c.

{
    if (read_len)
        *read_len = 0;
 
    return E_NOTIMPL;
}

dummystream_Release()

static ULONG WINAPI dummystream_Release ( IStream *  iface )

static

Definition at line 1367 of file main.c.

{
    TRACE("()\n");
    return 1;
}

filestream_Commit()

static HRESULT WINAPI filestream_Commit ( IStream *  iface, DWORD  flags  )

static

Definition at line 1033 of file main.c.

{
    TRACE("%p, %#lx.\n", iface, flags);
 
    return S_OK;
}

filestream_CopyTo()

static HRESULT WINAPI filestream_CopyTo ( IStream *  iface, IStream *  dest, ULARGE_INTEGER  size, ULARGE_INTEGER *  read_len, ULARGE_INTEGER *  written  )

static

Definition at line 990 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    HRESULT hr = S_OK;
    char buff[1024];
 
    TRACE("(%p, %p, %s, %p, %p)\n", stream, dest, wine_dbgstr_longlong(size.QuadPart), read_len, written);
 
    if (read_len)
        read_len->QuadPart = 0;
    if (written)
        written->QuadPart = 0;
 
    if (!dest)
        return S_OK;
 
    while (size.QuadPart)
    {
        ULONG left, read_chunk, written_chunk;
 
        left = size.QuadPart > sizeof(buff) ? sizeof(buff) : size.QuadPart;
 
        /* Read */
        hr = IStream_Read(iface, buff, left, &read_chunk);
        if (FAILED(hr) || read_chunk == 0)
            break;
        if (read_len)
            read_len->QuadPart += read_chunk;
 
        /* Write */
        hr = IStream_Write(dest, buff, read_chunk, &written_chunk);
        if (written)
            written->QuadPart += written_chunk;
        if (FAILED(hr) || written_chunk != left)
            break;
 
        size.QuadPart -= left;
    }
 
    return hr;
}

filestream_Read()

static HRESULT WINAPI filestream_Read ( IStream *  iface, void *  buff, ULONG  size, ULONG *  read_len  )

static

Definition at line 900 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    DWORD read = 0;
 
    TRACE("%p, %p, %lu, %p.\n", iface, buff, size, read_len);
 
    if (!ReadFile(stream->u.file.handle, buff, size, &read, NULL))
    {
        WARN("error %ld reading file\n", GetLastError());
        return S_FALSE;
    }
 
    if (read_len)
        *read_len = read;
 
    return read == size ? S_OK : S_FALSE;
}

filestream_Release()

static ULONG WINAPI filestream_Release ( IStream *  iface )

static

Definition at line 883 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    ULONG refcount = InterlockedDecrement(&stream->refcount);
 
    TRACE("%p, refcount %lu.\n", iface, refcount);
 
    if (!refcount)
    {
        CloseHandle(stream->u.file.handle);
        free(stream->u.file.path);
        free(stream);
    }
 
    return refcount;
}

filestream_Seek()

static HRESULT WINAPI filestream_Seek ( IStream *  iface, LARGE_INTEGER  move, DWORD  origin, ULARGE_INTEGER *  new_pos  )

static

Definition at line 944 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    DWORD position;
 
    TRACE("%p, %s, %ld, %p.\n", iface, wine_dbgstr_longlong(move.QuadPart), origin, new_pos);
 
    position = SetFilePointer(stream->u.file.handle, move.u.LowPart, NULL, origin);
    if (position == INVALID_SET_FILE_POINTER)
        return HRESULT_FROM_WIN32(GetLastError());
 
    if (new_pos)
    {
        new_pos->u.HighPart = 0;
        new_pos->u.LowPart = position;
    }
 
    return S_OK;
}

filestream_SetSize()

static HRESULT WINAPI filestream_SetSize ( IStream *  iface, ULARGE_INTEGER  size  )

static

Definition at line 964 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    LARGE_INTEGER origin, move;
 
    TRACE("(%p, %s)\n", stream, wine_dbgstr_longlong(size.QuadPart));
 
    move.QuadPart = 0;
    if (!SetFilePointerEx(stream->u.file.handle, move, &origin, FILE_CURRENT))
        return E_FAIL;
 
    move.QuadPart = size.QuadPart;
    if (!SetFilePointerEx(stream->u.file.handle, move, NULL, FILE_BEGIN))
        return E_FAIL;
 
    if (stream->u.file.mode != STGM_READ)
    {
        if (!SetEndOfFile(stream->u.file.handle))
            return E_FAIL;
        if (!SetFilePointerEx(stream->u.file.handle, origin, NULL, FILE_BEGIN))
            return E_FAIL;
    }
 
    return S_OK;
}

filestream_Stat()

static HRESULT WINAPI filestream_Stat ( IStream *  iface, STATSTG *  statstg, DWORD  flags  )

static

Definition at line 1040 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    BY_HANDLE_FILE_INFORMATION fi;
 
    TRACE("%p, %p, %#lx.\n", iface, statstg, flags);
 
    if (!statstg)
        return STG_E_INVALIDPOINTER;
 
    memset(&fi, 0, sizeof(fi));
    GetFileInformationByHandle(stream->u.file.handle, &fi);
 
    if (flags & STATFLAG_NONAME)
        statstg->pwcsName = NULL;
    else
    {
        int len = lstrlenW(stream->u.file.path);
        if ((statstg->pwcsName = CoTaskMemAlloc((len + 1) * sizeof(WCHAR))))
            memcpy(statstg->pwcsName, stream->u.file.path, (len + 1) * sizeof(WCHAR));
    }
    statstg->type = 0;
    statstg->cbSize.u.LowPart = fi.nFileSizeLow;
    statstg->cbSize.u.HighPart = fi.nFileSizeHigh;
    statstg->mtime = fi.ftLastWriteTime;
    statstg->ctime = fi.ftCreationTime;
    statstg->atime = fi.ftLastAccessTime;
    statstg->grfMode = stream->u.file.mode;
    statstg->grfLocksSupported = 0;
    memcpy(&statstg->clsid, &IID_IStream, sizeof(CLSID));
    statstg->grfStateBits = 0;
    statstg->reserved = 0;
 
    return S_OK;
}

filestream_Write()

static HRESULT WINAPI filestream_Write ( IStream *  iface, const void *  buff, ULONG  size, ULONG *  written  )

static

Definition at line 919 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    DWORD written_len = 0;
 
    TRACE("%p, %p, %lu, %p.\n", iface, buff, size, written);
 
    switch (stream->u.file.mode & 0xf)
    {
        case STGM_WRITE:
        case STGM_READWRITE:
            break;
        default:
            return STG_E_ACCESSDENIED;
    }
 
    if (!WriteFile(stream->u.file.handle, buff, size, &written_len, NULL))
        return HRESULT_FROM_WIN32(GetLastError());
 
    if (written)
        *written = written_len;
 
    return S_OK;
}

GetCurrentProcessExplicitAppUserModelID()

HRESULT WINAPI GetCurrentProcessExplicitAppUserModelID

(

const WCHAR **

appid

)

Definition at line 260 of file main.c.

{
    FIXME("%p: stub\n", appid);
    *appid = NULL;
    return E_NOTIMPL;
}

GetDpiForMonitor()

HRESULT WINAPI GetDpiForMonitor	(	HMONITOR	monitor,
		MONITOR_DPI_TYPE	type,
		UINT *	x,
		UINT *	y
	)

Definition at line 76 of file main.c.

{
    if (GetDpiForMonitorInternal( monitor, type, x, y )) return S_OK;
    return HRESULT_FROM_WIN32( GetLastError() );
}

GetFeatureEnabledState()

FEATURE_ENABLED_STATE WINAPI GetFeatureEnabledState	(	UINT32	feature,
		FEATURE_CHANGE_TIME	change_time
	)

Definition at line 2563 of file main.c.

{
    FIXME("(%u, %u) stub\n", feature, change_time);
    return FEATURE_ENABLED_STATE_DEFAULT;
}

GetProcessDpiAwareness()

HRESULT WINAPI GetProcessDpiAwareness	(	HANDLE	process,
		PROCESS_DPI_AWARENESS *	value
	)

Definition at line 64 of file main.c.

{
    if (GetProcessDpiAwarenessInternal( process, (DPI_AWARENESS *)value )) return S_OK;
    return HRESULT_FROM_WIN32( GetLastError() );
}

GetProcessReference()

HRESULT WINAPI GetProcessReference

(

IUnknown **

obj

)

Definition at line 1546 of file main.c.

{
    TRACE("(%p)\n", obj);
 
    *obj = process_ref;
 
    if (!process_ref)
        return E_FAIL;
 
    if (*obj)
        IUnknown_AddRef(*obj);
 
    return S_OK;
}

Referenced by init(), and SHCreateThread().

GetScaleFactorForDevice()

DEVICE_SCALE_FACTOR WINAPI GetScaleFactorForDevice

(

DISPLAY_DEVICE_TYPE

device_type

)

Definition at line 91 of file main.c.

{
    FIXME("%d\n", device_type);
 
    return SCALE_100_PERCENT;
}

GetScaleFactorForMonitor()

HRESULT WINAPI GetScaleFactorForMonitor	(	HMONITOR	monitor,
		DEVICE_SCALE_FACTOR *	scale
	)

Definition at line 83 of file main.c.

{
    FIXME("(%p %p): stub\n", monitor, scale);
 
    *scale = SCALE_100_PERCENT;
    return S_OK;
}

impl_from_IStream()

static struct shstream * impl_from_IStream ( IStream *  iface )

inlinestatic

Definition at line 549 of file main.c.

{
    return CONTAINING_RECORD(iface, struct shstream, IStream_iface);
}

Referenced by filestream_CopyTo(), filestream_Read(), filestream_Release(), filestream_Seek(), filestream_SetSize(), filestream_Stat(), filestream_Write(), memstream_Read(), memstream_Release(), memstream_Seek(), memstream_SetSize(), memstream_Stat(), memstream_Write(), regstream_Release(), shstream_AddRef(), shstream_Clone(), shstream_CopyTo(), shstream_LockRegion(), shstream_QueryInterface(), shstream_Revert(), and shstream_UnlockRegion().

IsOS()

BOOL WINAPI IsOS

(

DWORD

feature

)

Definition at line 2392 of file main.c.

{
    DWORD platform, majorv, minorv;
#ifdef __REACTOS__
    OSVERSIONINFOEXA osvi;
 
    osvi.dwOSVersionInfoSize = sizeof(osvi);
    if (!GetVersionExA((OSVERSIONINFOA*)&osvi))
    {
        osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
        if (!GetVersionExA((OSVERSIONINFOA*)&osvi))
        {
            ERR("GetVersionEx failed\n");
            return FALSE;
        }
        osvi.wProductType = VER_NT_WORKSTATION;
        osvi.wSuiteMask = 0;
    }
#else
    OSVERSIONINFOA osvi;
 
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
    if (!GetVersionExA(&osvi))
        return FALSE;
#endif
 
    majorv = osvi.dwMajorVersion;
    minorv = osvi.dwMinorVersion;
    platform = osvi.dwPlatformId;
 
#define ISOS_RETURN(x) \
    TRACE("(%#lx) ret %d\n",feature,(x)); \
    return (x)
 
    switch(feature)  {
    case OS_WIN32SORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32s
                 || platform == VER_PLATFORM_WIN32_WINDOWS);
    case OS_NT:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
    case OS_WIN95ORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS);
    case OS_NT4ORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 4);
    case OS_WIN2000ORGREATER_ALT:
    case OS_WIN2000ORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5);
    case OS_WIN98ORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 10);
    case OS_WIN98_GOLD:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 10);
    case OS_WIN2000PRO:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5);
    case OS_WIN2000SERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1));
    case OS_WIN2000ADVSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1));
    case OS_WIN2000DATACENTER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1));
    case OS_WIN2000TERMINAL:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1));
    case OS_EMBEDDED:
        FIXME("(OS_EMBEDDED) What should we return here?\n");
        return FALSE;
    case OS_TERMINALCLIENT:
        FIXME("(OS_TERMINALCLIENT) What should we return here?\n");
        return FALSE;
    case OS_TERMINALREMOTEADMIN:
        FIXME("(OS_TERMINALREMOTEADMIN) What should we return here?\n");
        return FALSE;
    case OS_WIN95_GOLD:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 0);
    case OS_MEORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 90);
    case OS_XPORGREATER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1);
    case OS_HOME:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1);
    case OS_PROFESSIONAL:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
    case OS_DATACENTER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
    case OS_ADVSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5);
    case OS_SERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
    case OS_TERMINALSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
    case OS_PERSONALTERMINALSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && minorv >= 1 && majorv >= 5);
    case OS_FASTUSERSWITCHING:
        FIXME("(OS_FASTUSERSWITCHING) What should we return here?\n");
        return TRUE;
    case OS_WELCOMELOGONUI:
        FIXME("(OS_WELCOMELOGONUI) What should we return here?\n");
        return FALSE;
    case OS_DOMAINMEMBER:
        FIXME("(OS_DOMAINMEMBER) What should we return here?\n");
        return TRUE;
    case OS_ANYSERVER:
#ifdef __REACTOS__
        ISOS_RETURN(osvi.wProductType > VER_NT_WORKSTATION);
#else
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
#endif
    case OS_WOW6432:
        {
            BOOL is_wow64;
            IsWow64Process(GetCurrentProcess(), &is_wow64);
            return is_wow64;
        }
    case OS_WEBSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
    case OS_SMALLBUSINESSSERVER:
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT);
    case OS_TABLETPC:
        FIXME("(OS_TABLETPC) What should we return here?\n");
        return FALSE;
    case OS_SERVERADMINUI:
#ifdef __REACTOS__
        {
            DWORD value = FALSE, size = sizeof(value);
            HKEY hKey = NULL;
 
            RegOpenKeyExW(
                HKEY_CURRENT_USER,
                L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
                0,
                MAXIMUM_ALLOWED,
                &hKey);
 
            if (hKey)
            {
                SHQueryValueExW(hKey, L"ServerAdminUI", NULL, NULL, &value, &size);
                RegCloseKey(hKey);
            }
            ISOS_RETURN(value);
        }
#else
        FIXME("(OS_SERVERADMINUI) What should we return here?\n");
        return FALSE;
#endif
    case OS_MEDIACENTER:
        FIXME("(OS_MEDIACENTER) What should we return here?\n");
        return FALSE;
    case OS_APPLIANCE:
        FIXME("(OS_APPLIANCE) What should we return here?\n");
        return FALSE;
    case 0x25: /*OS_VISTAORGREATER*/
        ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 6);
    }
 
#undef ISOS_RETURN
 
    WARN("(%#lx) unknown parameter\n", feature);
 
    return FALSE;
}

Referenced by CDefView::GetDefaultViewMode(), CShellDispatch::GetSetting(), CShellDispatch::GetSystemInformation(), InitializeServerAdminUI(), IsSystem64Bit(), and CControlPanelFolder::MessageSFVCB().

IStream_Reset()

HRESULT WINAPI IStream_Reset

(

IStream *

stream

)

Definition at line 111 of file main.c.

{
    static const LARGE_INTEGER zero;
 
    TRACE("(%p)\n", stream);
 
    return IStream_Seek(stream, zero, 0, NULL);
}

Referenced by Open().

IStream_Size()

HRESULT WINAPI IStream_Size	(	IStream *	stream,
		ULARGE_INTEGER *	size
	)

Definition at line 120 of file main.c.

{
    STATSTG statstg;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", stream, size);
 
    memset(&statstg, 0, sizeof(statstg));
 
    hr = IStream_Stat(stream, &statstg, STATFLAG_NONAME);
 
    if (SUCCEEDED(hr) && size)
        *size = statstg.cbSize;
    return hr;
}

Referenced by CDesktopUpgradePropertyBag::_GetOldDesktopViewStream(), CRegPropertyBag::_GetStreamSize(), CDesktopUpgradePropertyBag::_NewStreamFromOld(), and init().

IUnknown_AtomicRelease()

void WINAPI IUnknown_AtomicRelease

(

IUnknown **

obj

)

Definition at line 150 of file main.c.

{
    TRACE("(%p)\n", obj);
 
    if (!obj || !*obj)
        return;
 
    IUnknown_Release(*obj);
    *obj = NULL;
}

Referenced by IUnknown_Set().

IUnknown_GetSite()

HRESULT WINAPI IUnknown_GetSite	(	IUnknown *	unk,
		REFIID	iid,
		void **	site
	)

Definition at line 161 of file main.c.

{
    IObjectWithSite *obj = NULL;
    HRESULT hr = E_INVALIDARG;
 
    TRACE("(%p, %s, %p)\n", unk, debugstr_guid(iid), site);
 
    if (unk && iid && site)
    {
        hr = IUnknown_QueryInterface(unk, &IID_IObjectWithSite, (void **)&obj);
        if (SUCCEEDED(hr) && obj)
        {
            hr = IObjectWithSite_GetSite(obj, iid, site);
            IObjectWithSite_Release(obj);
        }
    }
 
    return hr;
}

Referenced by CMenuDeskBar::_IsSubMenuParent(), CShellMenuCallback::OnInitMenu(), and CMenuFocusManager::UpdateFocus().

IUnknown_QueryService()

HRESULT WINAPI IUnknown_QueryService	(	IUnknown *	obj,
		REFGUID	sid,
		REFIID	iid,
		void **	out
	)

Definition at line 181 of file main.c.

{
    IServiceProvider *provider = NULL;
    HRESULT hr;
 
    if (!out)
        return E_FAIL;
 
    *out = NULL;
 
    if (!obj)
        return E_FAIL;
 
    hr = IUnknown_QueryInterface(obj, &IID_IServiceProvider, (void **)&provider);
    if (hr == S_OK && provider)
    {
        TRACE("Using provider %p.\n", provider);
 
        hr = IServiceProvider_QueryService(provider, sid, iid, out);
 
        TRACE("Provider %p returned %p.\n", provider, *out);
 
        IServiceProvider_Release(provider);
    }
 
    return hr;
}

Referenced by CDefViewBckgrndMenu::_bIsDesktopBrowserMenu(), CExplorerBand::_CreateTreeView(), CExplorerBand::_DestroyTreeView(), CDefView::_MergeToolbar(), CMenuDeskBar::_OnActivate(), CDefaultContextMenu::BrowserFlagsFromVerb(), CDefaultContextMenu::DoCopyOrCut(), CDefaultContextMenu::DoCreateNewFolder(), CDefaultContextMenu::DoRename(), CFSDropTarget::Drop(), CMenuDeskBar::Exec(), CAddressEditBox::Execute(), CBandProxy::FindBrowserWindow(), CAddressEditBox::GetAbsolutePidl(), CShellBrowser::GetMenuBand(), CSearchBar::GetSearchResultsFolder(), CRegTreeOptions::GetSetState(), CFolderOptions::HandleDefFolderSettings(), CAddressEditBox::Init(), CDefViewBckgrndMenu::InvokeCommand(), CNetConUiObject::InvokeCommand(), CAddressBand::IsGoButtonVisible(), CMenuFocusManager::IsTrackedWindowOrParent(), IUnknown_QueryServiceForWebBrowserApp(), IUnknown_QueryServicePropertyBag(), CFindFolder::MessageSFVCB(), CSearchBar::OnInitDialog(), CInternetToolbar::OnMenuDropDown(), CSearchBar::OnSearchButtonClicked(), CInternetToolbar::OnTravelBack(), CInternetToolbar::OnTravelForward(), CAddressEditBox::ParseNow(), CMenuDeskBar::Popup(), QueryActiveShellView(), CInternetToolbar::QueryService(), CDefView::QueryService(), CMenuDeskBar::QueryService(), CMenuSite::QueryService(), CDefaultContextMenu::QueryService(), CNewMenu::SelectNewItem(), CAddressEditBox::SetOwner(), CInternetToolbar::SetSite(), CMenuBand::SetSite(), CMenuDeskBar::SetSite(), SHShouldShowWizards(), CDefaultContextMenu::TryToBrowse(), and CMenuBand::UIActivateIO().

IUnknown_Set()

void WINAPI IUnknown_Set	(	IUnknown **	dest,
		IUnknown *	src
	)

Definition at line 209 of file main.c.

{
    TRACE("(%p, %p)\n", dest, src);
 
    IUnknown_AtomicRelease(dest);
 
    if (src)
    {
        IUnknown_AddRef(src);
        *dest = src;
    }
}

Referenced by Free(), and CFindFolderContextMenu::SetSite().

IUnknown_SetSite()

HRESULT WINAPI IUnknown_SetSite	(	IUnknown *	obj,
		IUnknown *	site
	)

Definition at line 222 of file main.c.

{
    IInternetSecurityManager *sec_manager;
    IObjectWithSite *objwithsite;
    HRESULT hr;
 
    if (!obj)
        return E_FAIL;
 
    hr = IUnknown_QueryInterface(obj, &IID_IObjectWithSite, (void **)&objwithsite);
    TRACE("ObjectWithSite %p, hr %#lx.\n", objwithsite, hr);
    if (SUCCEEDED(hr))
    {
        hr = IObjectWithSite_SetSite(objwithsite, site);
        TRACE("SetSite() hr %#lx.\n", hr);
        IObjectWithSite_Release(objwithsite);
    }
    else
    {
        hr = IUnknown_QueryInterface(obj, &IID_IInternetSecurityManager, (void **)&sec_manager);
        TRACE("InternetSecurityManager %p, hr %#lx.\n", sec_manager, hr);
        if (FAILED(hr))
            return hr;
 
        hr = IInternetSecurityManager_SetSecuritySite(sec_manager, (IInternetSecurityMgrSite *)site);
        TRACE("SetSecuritySite() hr %#lx.\n", hr);
        IInternetSecurityManager_Release(sec_manager);
    }
 
    return hr;
}

Referenced by CMenuBand::_OnPopupSubMenu(), CMenuSite::AddBand(), CShellBrowser::BrowseToPath(), CreateStartMenu(), DCMA_DestroyEntry(), DCMA_InsertMenuItems(), CShellBrowser::DoFolderOptions(), CDefView::drag_notify_subitem(), CDefView::FillFileMenu(), CShellBrowser::GetBaseBar(), CDefView::GetItemObject(), CShellBrowser::Initialize(), CDockSite::Initialize(), CDefView::InvokeContextMenuCommand(), CDefaultContextMenu::LoadDynamicContextMenuHandler(), CDefView::OnDestroy(), CMenuBand::SetClient(), CMenuSite::SetDeskBarSite(), CFindFolderContextMenu::SetSite(), CDefViewBckgrndMenu::SetSite(), SHInvokeCommandOnContextMenuInternal(), SHInvokeCommandsOnContextMenu(), CDefaultContextMenu::~CDefaultContextMenu(), and MenuCleanup::~MenuCleanup().

memstream_Read()

static HRESULT WINAPI memstream_Read ( IStream *  iface, void *  buff, ULONG  buff_size, ULONG *  read_len  )

static

Definition at line 600 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    DWORD length;
 
    TRACE("%p, %p, %lu, %p.\n", iface, buff, buff_size, read_len);
 
    if (stream->u.mem.position >= stream->u.mem.length)
    {
        if (read_len)
            *read_len = 0;
        return S_FALSE;
    }
 
    length = stream->u.mem.length - stream->u.mem.position;
    if (buff_size < length)
        length = buff_size;
 
    memmove(buff, stream->u.mem.buffer + stream->u.mem.position, length);
    stream->u.mem.position += length;
 
    if (read_len)
        *read_len = length;
 
    return S_OK;
}

memstream_Release()

static ULONG WINAPI memstream_Release ( IStream *  iface )

static

Definition at line 584 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    ULONG refcount = InterlockedDecrement(&stream->refcount);
 
    TRACE("%p, refcount %lu.\n", iface, refcount);
 
    if (!refcount)
    {
        free(stream->u.mem.buffer);
        free(stream);
    }
 
    return refcount;
}

memstream_Seek()

static HRESULT WINAPI memstream_Seek ( IStream *  iface, LARGE_INTEGER  move, DWORD  origin, ULARGE_INTEGER *  new_pos  )

static

Definition at line 655 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    LARGE_INTEGER tmp;
 
    TRACE("%p, %s, %ld, %p.\n", iface, wine_dbgstr_longlong(move.QuadPart), origin, new_pos);
 
    if (origin == STREAM_SEEK_SET)
        tmp = move;
    else if (origin == STREAM_SEEK_CUR)
        tmp.QuadPart = stream->u.mem.position + move.QuadPart;
    else if (origin == STREAM_SEEK_END)
        tmp.QuadPart = stream->u.mem.length + move.QuadPart;
    else
        return STG_E_INVALIDPARAMETER;
 
    if (tmp.QuadPart < 0)
        return STG_E_INVALIDFUNCTION;
 
    /* we cut off the high part here */
    stream->u.mem.position = tmp.u.LowPart;
 
    if (new_pos)
        new_pos->QuadPart = stream->u.mem.position;
    return S_OK;
}

memstream_SetSize()

static HRESULT WINAPI memstream_SetSize ( IStream *  iface, ULARGE_INTEGER  new_size  )

static

Definition at line 682 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    DWORD length;
    BYTE *buffer;
 
    TRACE("(%p, %s)\n", stream, wine_dbgstr_longlong(new_size.QuadPart));
 
    /* we cut off the high part here */
    length = new_size.u.LowPart;
    buffer = _recalloc(stream->u.mem.buffer, 1, length);
    if (!buffer)
        return STG_E_INSUFFICIENTMEMORY;
 
    stream->u.mem.buffer = buffer;
    stream->u.mem.length = length;
 
    return S_OK;
}

memstream_Stat()

static HRESULT WINAPI memstream_Stat ( IStream *  iface, STATSTG *  statstg, DWORD  flags  )

static

Definition at line 790 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
 
    TRACE("%p, %p, %#lx.\n", iface, statstg, flags);
 
    memset(statstg, 0, sizeof(*statstg));
    statstg->type = STGTY_STREAM;
    statstg->cbSize.QuadPart = stream->u.mem.length;
    statstg->grfMode = STGM_READWRITE;
 
    return S_OK;
}

memstream_Write()

static HRESULT WINAPI memstream_Write ( IStream *  iface, const void *  buff, ULONG  buff_size, ULONG *  written  )

static

Definition at line 627 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    DWORD length = stream->u.mem.position + buff_size;
 
    TRACE("%p, %p, %lu, %p.\n", iface, buff, buff_size, written);
 
    if (length < stream->u.mem.position) /* overflow */
        return STG_E_INSUFFICIENTMEMORY;
 
    if (length > stream->u.mem.length)
    {
        BYTE *buffer = _recalloc(stream->u.mem.buffer, 1, length);
        if (!buffer)
            return STG_E_INSUFFICIENTMEMORY;
 
        stream->u.mem.length = length;
        stream->u.mem.buffer = buffer;
    }
    memmove(stream->u.mem.buffer + stream->u.mem.position, buff, buff_size);
    stream->u.mem.position += buff_size; /* adjust pointer */
 
    if (written)
        *written = buff_size;
 
    return S_OK;
}

RegisterScaleChangeEvent()

HRESULT WINAPI RegisterScaleChangeEvent	(	HANDLE	handle,
		DWORD_PTR *	cookie
	)

Definition at line 2572 of file main.c.

{
    FIXME("(%p, %p) stub\n", handle, cookie);
    return E_NOTIMPL;
}

RegisterScaleChangeNotifications()

HRESULT WINAPI RegisterScaleChangeNotifications	(	DISPLAY_DEVICE_TYPE	display_device,
		HWND	hwnd,
		UINT	msg,
		DWORD *	cookie
	)

Definition at line 2581 of file main.c.

{
    FIXME("(%d, %p, %u, %p) stub\n", display_device, hwnd, msg, cookie);
 
    if (cookie) *cookie = 0;
 
    return E_NOTIMPL;
}

regstream_Release()

static ULONG WINAPI regstream_Release ( IStream *  iface )

static

Definition at line 1219 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    ULONG refcount = InterlockedDecrement(&stream->refcount);
 
    TRACE("%p, refcount %lu.\n", iface, refcount);
 
    if (!refcount)
    {
        if (stream->u.mem.hkey)
        {
            if (stream->u.mem.length)
                RegSetValueExW(stream->u.mem.hkey, stream->u.mem.valuename, 0, REG_BINARY,
                        (const BYTE *)stream->u.mem.buffer, stream->u.mem.length);
            else
                RegDeleteValueW(stream->u.mem.hkey, stream->u.mem.valuename);
            RegCloseKey(stream->u.mem.hkey);
        }
        CoTaskMemFree(stream->u.mem.valuename);
        free(stream->u.mem.buffer);
        free(stream);
    }
 
    return refcount;
}

SetCurrentProcessExplicitAppUserModelID()

HRESULT WINAPI SetCurrentProcessExplicitAppUserModelID

(

const WCHAR *

appid

)

Definition at line 254 of file main.c.

{
    FIXME("%s: stub\n", debugstr_w(appid));
    return S_OK;
}

SetProcessDpiAwareness()

HRESULT WINAPI SetProcessDpiAwareness

(

PROCESS_DPI_AWARENESS

value

)

Definition at line 70 of file main.c.

{
    if (SetProcessDpiAwarenessInternal( (DPI_AWARENESS)value )) return S_OK;
    return HRESULT_FROM_WIN32( GetLastError() );
}

Referenced by set_dpi_aware().

SetProcessReference()

void WINAPI SetProcessReference

(

IUnknown *

obj

)

Definition at line 1564 of file main.c.

{
    TRACE("(%p)\n", obj);
 
    process_ref = obj;
}

Referenced by init().

SHAnsiToAnsi()

DWORD WINAPI SHAnsiToAnsi	(	const char *	src,
		char *	dest,
		int	dest_len
	)

Definition at line 1738 of file main.c.

{
    DWORD ret;
 
    TRACE("(%s, %p, %d)\n", debugstr_a(src), dest, dest_len);
 
    if (!src || !dest || dest_len <= 0)
        return 0;
 
    lstrcpynA(dest, src, dest_len);
    ret = strlen(dest);
 
    return src[ret] ? 0 : ret + 1;
}

Referenced by init().

SHAnsiToUnicode()

DWORD WINAPI SHAnsiToUnicode	(	const char *	src,
		WCHAR *	dest,
		int	dest_len
	)

Definition at line 1801 of file main.c.

{
    int ret = 1;
 
    TRACE("(%s, %p, %d)\n", debugstr_a(src), dest, dest_len);
 
    if (!dest || !dest_len)
        return 0;
 
    if (src)
    {
        ret = MultiByteToWideChar(CP_ACP, 0, src, -1, dest, dest_len);
        if (!ret)
        {
            dest[dest_len - 1] = 0;
            ret = dest_len;
        }
    }
    else
        dest[0] = 0;
 
    return ret;
}

Referenced by CDefaultContextMenu::_DoInvokeCommandCallback(), CheckEscapesA(), CShellLink::DoOpen(), CCopyMoveToMenu::GetCommandString(), CDefaultContextMenu::GetCommandString(), init(), CRegTreeOptions::InitTree(), CStartMenuBtnCtxMenu::InvokeCommand(), CDefView::InvokeContextMenuCommand(), IsLFNDriveA(), MakeShellURLFromPathA(), CDefaultContextMenu::MapVerbToCmdId(), PathIsTemporaryA(), PathQualifyA(), PathResolveA(), SHChangeNotify(), SHELL_GetCommandStringImpl(), SHGetFileDescriptionA(), SHInvokeCommandOnContextMenuInternal(), SHUpdateImageA(), ZoneCheckPathA(), ZoneCheckUrlA(), ZoneCheckUrlExA(), and ZoneCheckUrlExCacheA().

SHCopyKeyA()

DWORD WINAPI SHCopyKeyA	(	HKEY	hkey_src,
		const char *	subkey,
		HKEY	hkey_dst,
		DWORD	reserved
	)

Definition at line 1950 of file main.c.

{
    WCHAR *subkeyW = NULL;
    DWORD ret;
 
    TRACE("%p, %s, %p, %ld.\n", hkey_src, debugstr_a(subkey), hkey_dst, reserved);
 
    if (subkey && FAILED(SHStrDupA(subkey, &subkeyW)))
        return 0;
 
    ret = SHCopyKeyW(hkey_src, subkeyW, hkey_dst, reserved);
    CoTaskMemFree(subkeyW);
    return ret;
}

Referenced by init().

SHCopyKeyW()

DWORD WINAPI SHCopyKeyW	(	HKEY	hkey_src,
		const WCHAR *	subkey,
		HKEY	hkey_dst,
		DWORD	reserved
	)

Definition at line 1968 of file main.c.

{
    DWORD key_count = 0, value_count = 0, max_key_len = 0;
    WCHAR name[MAX_PATH], *ptr_name = name;
    BYTE buff[1024], *ptr = buff;
    DWORD max_data_len = 0, i;
    DWORD ret = 0;
 
    TRACE("%p, %s, %p, %ld.\n", hkey_src, debugstr_w(subkey), hkey_dst, reserved);
 
    if (!hkey_dst || !hkey_src)
        return ERROR_INVALID_PARAMETER;
 
    if (subkey)
        ret = RegOpenKeyExW(hkey_src, subkey, 0, KEY_ALL_ACCESS, &hkey_src);
 
    if (ret)
        hkey_src = NULL; /* Don't close this key since we didn't open it */
    else
    {
        DWORD max_value_len;
 
        ret = RegQueryInfoKeyW(hkey_src, NULL, NULL, NULL, &key_count, &max_key_len,
                NULL, &value_count, &max_value_len, &max_data_len, NULL, NULL);
        if (!ret)
        {
            /* Get max size for key/value names */
            max_key_len = max(max_key_len, max_value_len);
 
            if (max_key_len++ > MAX_PATH - 1)
                ptr_name = malloc(max_key_len * sizeof(WCHAR));
 
            if (max_data_len > sizeof(buff))
                ptr = malloc(max_data_len);
 
            if (!ptr_name || !ptr)
                ret = ERROR_NOT_ENOUGH_MEMORY;
        }
    }
 
    for (i = 0; i < key_count && !ret; i++)
    {
        HKEY hsubkey_src, hsubkey_dst;
        DWORD length = max_key_len;
 
        ret = RegEnumKeyExW(hkey_src, i, ptr_name, &length, NULL, NULL, NULL, NULL);
        if (!ret)
        {
            ret = RegOpenKeyExW(hkey_src, ptr_name, 0, KEY_READ, &hsubkey_src);
            if (!ret)
            {
                /* Create destination sub key */
                ret = RegCreateKeyW(hkey_dst, ptr_name, &hsubkey_dst);
                if (!ret)
                {
                    /* Recursively copy keys and values from the sub key */
                    ret = SHCopyKeyW(hsubkey_src, NULL, hsubkey_dst, 0);
                    RegCloseKey(hsubkey_dst);
                }
            }
            RegCloseKey(hsubkey_src);
        }
    }
 
    /* Copy all the values in this key */
    for (i = 0; i < value_count && !ret; i++)
    {
        DWORD length = max_key_len, type, data_len = max_data_len;
 
        ret = RegEnumValueW(hkey_src, i, ptr_name, &length, NULL, &type, ptr, &data_len);
        if (!ret) {
            ret = SHSetValueW(hkey_dst, NULL, ptr_name, type, ptr, data_len);
        }
    }
 
    /* Free buffers if allocated */
    if (ptr_name != name)
        free(ptr_name);
    if (ptr != buff)
        free(ptr);
 
    if (subkey && hkey_src)
        RegCloseKey(hkey_src);
 
    return ret;
}

Referenced by COpenWithList::SetDefaultHandler(), SHCopyKeyA(), and SHCopyKeyW().

shcore_thread_wrapper()

static DWORD WINAPI shcore_thread_wrapper ( void *  data )

static

Definition at line 1582 of file main.c.

{
    struct thread_data thread_data;
    HRESULT hr = E_FAIL;
    DWORD retval;
 
    TRACE("(%p)\n", data);
 
    /* We are now executing in the context of the newly created thread.
     * So we copy the data passed to us (it is on the stack of the function
     * that called us, which is waiting for us to signal an event before
     * returning). */
    thread_data = *(struct thread_data *)data;
 
    if (thread_data.flags & CTF_COINIT)
    {
        hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
        if (FAILED(hr))
            hr = CoInitializeEx(NULL, COINIT_DISABLE_OLE1DDE);
    }
 
    if (thread_data.callback)
        thread_data.callback(thread_data.data);
 
    /* Signal the thread that created us; it can return now. */
    SetEvent(thread_data.hEvent);
 
    /* Execute the callers start code. */
    retval = thread_data.thread_proc(thread_data.data);
 
    /* Release thread and process references. */
    if (thread_data.thread_ref)
        IUnknown_Release(thread_data.thread_ref);
 
    if (thread_data.process_ref)
        IUnknown_Release(thread_data.process_ref);
 
    if (SUCCEEDED(hr))
        CoUninitialize();
 
    return retval;
}

Referenced by SHCreateThread().

SHCreateMemStream()

IStream *WINAPI SHCreateMemStream	(	const BYTE *	data,
		UINT	data_len
	)

Definition at line 873 of file main.c.

{
    struct shstream *stream;
 
    TRACE("(%p, %u)\n", data, data_len);
 
    stream = shstream_create(&memstreamvtbl, data, data_len);
    return stream ? &stream->IStream_iface : NULL;
}

Referenced by CDesktopUpgradePropertyBag::_NewStreamFromOld(), CRegPropertyBag::_ReadStream(), create_decoder(), MSSTYLES_TryLoadPng(), CDefView::SaveViewState(), SHPropertyBag_OnRegKey(), test_load(), test_persiststream(), Test_Read_EmptyStream(), Test_Read_MissingTerminator(), Test_Read_OutputNullOnFailure(), Test_Read_TooSmallCbSize(), Test_Read_TruncatedData(), Test_RoundTrip_EmptyPidl(), Test_RoundTrip_MultiItemPidl(), Test_RoundTrip_SimplePidl(), test_SHCreateMemStream(), test_transformNodeToObject(), and Test_Write_StreamPosition().

SHCreateStreamOnFileA()

HRESULT WINAPI SHCreateStreamOnFileA	(	const char *	path,
		DWORD	mode,
		IStream **	stream
	)

Definition at line 1196 of file main.c.

{
    WCHAR *pathW;
    HRESULT hr;
    DWORD len;
 
    TRACE("%s, %#lx, %p.\n", debugstr_a(path), mode, stream);
 
    if (!path)
        return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
 
    len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
    pathW = malloc(len * sizeof(WCHAR));
    if (!pathW)
        return E_OUTOFMEMORY;
 
    MultiByteToWideChar(CP_ACP, 0, path, -1, pathW, len);
    hr = SHCreateStreamOnFileW(pathW, mode, stream);
    free(pathW);
 
    return hr;
}

Referenced by init(), and test_SHCreateStreamOnFileA().

SHCreateStreamOnFileEx()

HRESULT WINAPI SHCreateStreamOnFileEx	(	const WCHAR *	path,
		DWORD	mode,
		DWORD	attributes,
		BOOL	create,
		IStream *	template,
		IStream **	ret
	)

Definition at line 1097 of file main.c.

{
    DWORD access, share, creation_disposition, len;
    struct shstream *stream;
    HANDLE hFile;
 
    TRACE("%s, %ld, %#lx, %d, %p, %p)\n", debugstr_w(path), mode, attributes,
        create, template, ret);
 
    if (!path || !ret || template)
        return E_INVALIDARG;
 
    *ret = NULL;
 
    /* Access */
    switch (mode & 0xf)
    {
        case STGM_WRITE:
        case STGM_READWRITE:
            access = GENERIC_READ | GENERIC_WRITE;
            break;
        case STGM_READ:
            access = GENERIC_READ;
            break;
        default:
            return E_INVALIDARG;
    }
 
    /* Sharing */
    switch (mode & 0xf0)
    {
        case 0:
        case STGM_SHARE_DENY_NONE:
            share = FILE_SHARE_READ | FILE_SHARE_WRITE;
            break;
        case STGM_SHARE_DENY_READ:
            share = FILE_SHARE_WRITE;
            break;
        case STGM_SHARE_DENY_WRITE:
            share = FILE_SHARE_READ;
            break;
        case STGM_SHARE_EXCLUSIVE:
            share = 0;
            break;
        default:
            return E_INVALIDARG;
    }
 
    switch (mode & 0xf000)
    {
        case STGM_FAILIFTHERE:
            creation_disposition = create ? CREATE_NEW : OPEN_EXISTING;
            break;
        case STGM_CREATE:
            creation_disposition = CREATE_ALWAYS;
            break;
        default:
            return E_INVALIDARG;
    }
 
    hFile = CreateFileW(path, access, share, NULL, creation_disposition, attributes, 0);
    if (hFile == INVALID_HANDLE_VALUE)
        return HRESULT_FROM_WIN32(GetLastError());
 
    stream = malloc(sizeof(*stream));
    stream->IStream_iface.lpVtbl = &filestreamvtbl;
    stream->refcount = 1;
    stream->u.file.handle = hFile;
    stream->u.file.mode = mode;
 
    len = lstrlenW(path);
    stream->u.file.path = malloc((len + 1) * sizeof(WCHAR));
    memcpy(stream->u.file.path, path, (len + 1) * sizeof(WCHAR));
 
    *ret = &stream->IStream_iface;
 
    return S_OK;
}

Referenced by DoLoadPicture(), OpenStreamOnFile(), SHCreateStreamOnFileW(), test_SHCreateStreamOnFileEx(), and test_SHCreateStreamOnFileEx_CopyTo().

SHCreateStreamOnFileW()

HRESULT WINAPI SHCreateStreamOnFileW	(	const WCHAR *	path,
		DWORD	mode,
		IStream **	stream
	)

Definition at line 1180 of file main.c.

{
    TRACE("%s, %#lx, %p.\n", debugstr_w(path), mode, stream);
 
    if (!path || !stream)
        return E_INVALIDARG;
 
    if ((mode & (STGM_CONVERT | STGM_DELETEONRELEASE | STGM_TRANSACTED)) != 0)
        return E_INVALIDARG;
 
    return SHCreateStreamOnFileEx(path, mode, 0, FALSE, NULL, stream);
}

Referenced by dump_stream_to_file(), GdipCreateStreamOnFile(), IWICStreamImpl_InitializeFromFilename(), CShellLink::Load(), Open(), CShellLink::Save(), SHCreateStreamOnFileA(), and test_SHCreateStreamOnFileW().

SHCreateThread()

BOOL WINAPI SHCreateThread	(	LPTHREAD_START_ROUTINE	thread_proc,
		void *	data,
		DWORD	flags,
		LPTHREAD_START_ROUTINE	callback
	)

Definition at line 1628 of file main.c.

{
    struct thread_data thread_data;
    BOOL called = FALSE;
 
    TRACE("%p, %p, %#lx, %p.\n", thread_proc, data, flags, callback);
 
    thread_data.thread_proc = thread_proc;
    thread_data.callback = callback;
    thread_data.data = data;
    thread_data.flags = flags;
    thread_data.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
 
    if (flags & CTF_THREAD_REF)
        SHGetThreadRef(&thread_data.thread_ref);
    else
        thread_data.thread_ref = NULL;
 
    if (flags & CTF_PROCESS_REF)
        GetProcessReference(&thread_data.process_ref);
    else
        thread_data.process_ref = NULL;
 
    /* Create the thread */
    if (thread_data.hEvent)
    {
        HANDLE hThread;
        DWORD retval;
 
        hThread = CreateThread(NULL, 0, shcore_thread_wrapper, &thread_data, 0, &retval);
        if (hThread)
        {
            /* Wait for the thread to signal us to continue */
            WaitForSingleObject(thread_data.hEvent, INFINITE);
            CloseHandle(hThread);
            called = TRUE;
        }
        CloseHandle(thread_data.hEvent);
    }
 
    if (!called)
    {
        if (!thread_data.callback && flags & CTF_INSIST)
        {
            /* Couldn't call, call synchronously */
            thread_data.thread_proc(data);
            called = TRUE;
        }
        else
        {
            if (thread_data.thread_ref)
                IUnknown_Release(thread_data.thread_ref);
 
            if (thread_data.process_ref)
                IUnknown_Release(thread_data.process_ref);
        }
    }
 
    return called;
}

Referenced by CRecyclerDropTarget::_DoDeleteAsync(), DoFormatDriveAsync(), CFSDropTarget::Drop(), EnableCommandIfVerbExists(), CCabFolder::ExtractFilesUI(), FormatDriveDlg(), CTrayWindow::HandleCommand(), CFileDefExt::InitFileAttr(), CFileDefExt::InitMultifilePage(), InstallDlgProc(), ShellPropSheetDialog::ShowAsync(), ShowFolderOptionsDialog(), CFindFolder::StartSearch(), and UIDlgProc().

SHCreateThreadRef()

HRESULT WINAPI SHCreateThreadRef	(	LONG *	refcount,
		IUnknown **	out
	)

Definition at line 1478 of file main.c.

{
    struct threadref *threadref;
 
    TRACE("(%p, %p)\n", refcount, out);
 
    if (!refcount || !out)
        return E_INVALIDARG;
 
    *out = NULL;
 
    threadref = malloc(sizeof(*threadref));
    if (!threadref)
        return E_OUTOFMEMORY;
    threadref->IUnknown_iface.lpVtbl = &threadrefvtbl;
    threadref->refcount = refcount;
 
    *refcount = 1;
    *out = &threadref->IUnknown_iface;
 
    TRACE("Created %p.\n", threadref);
    return S_OK;
}

Referenced by SHCreateFromDesktop().

SHDeleteEmptyKeyA()

DWORD WINAPI SHDeleteEmptyKeyA	(	HKEY	hkey,
		const char *	subkey
	)

Definition at line 1868 of file main.c.

{
    WCHAR *subkeyW = NULL;
    DWORD ret;
 
    TRACE("(%p, %s)\n", hkey, debugstr_a(subkey));
 
    if (subkey && FAILED(SHStrDupA(subkey, &subkeyW)))
        return ERROR_OUTOFMEMORY;
 
    ret = SHDeleteEmptyKeyW(hkey, subkeyW);
    CoTaskMemFree(subkeyW);
    return ret;
}

SHDeleteEmptyKeyW()

DWORD WINAPI SHDeleteEmptyKeyW	(	HKEY	hkey,
		const WCHAR *	subkey
	)

Definition at line 1840 of file main.c.

{
    DWORD ret, count = 0;
    HKEY hsubkey = 0;
 
    TRACE("(%p, %s)\n", hkey, debugstr_w(subkey));
 
    ret = RegOpenKeyExW(hkey, subkey, 0, KEY_READ, &hsubkey);
    if (!ret)
    {
        ret = RegQueryInfoKeyW(hsubkey, NULL, NULL, NULL, &count,
                             NULL, NULL, NULL, NULL, NULL, NULL, NULL);
        RegCloseKey(hsubkey);
        if (!ret)
        {
            if (count)
                ret = ERROR_KEY_HAS_CHILDREN;
            else
                ret = RegDeleteKeyW(hkey, subkey);
        }
    }
 
    return ret;
}

Referenced by SHDeleteEmptyKeyA().

SHDeleteKeyA()

DWORD WINAPI SHDeleteKeyA	(	HKEY	hkey,
		const char *	subkey
	)

Definition at line 1896 of file main.c.

{
    TRACE("(%p, %s)\n", hkey, debugstr_a(subkey));
 
    return RegDeleteTreeA(hkey, subkey);
}

Referenced by delete_key(), init(), test_getstring_no_extra(), test_SHCopyKey(), test_SHDeleteKey(), and testRegStore().

SHDeleteKeyW()

DWORD WINAPI SHDeleteKeyW	(	HKEY	hkey,
		const WCHAR *	subkey
	)

Definition at line 1886 of file main.c.

{
    TRACE("(%p, %s)\n", hkey, debugstr_w(subkey));
 
    return RegDeleteTreeW(hkey, subkey);
}

Referenced by CMruNode::_DeleteValue(), CleanupRegistry(), DeleteExt(), EditTypeDlg_WriteClass(), HandleMruData(), MRUList_DataList(), MRUList_PidlList(), PNP_DeleteClassKey(), and SHAddToRecentDocs().

SHDeleteValueA()

DWORD WINAPI SHDeleteValueA	(	HKEY	hkey,
		const char *	subkey,
		const char *	value
	)

Definition at line 1926 of file main.c.

{
    WCHAR *subkeyW = NULL, *valueW = NULL;
    DWORD ret;
 
    TRACE("(%p, %s, %s)\n", hkey, debugstr_a(subkey), debugstr_a(value));
 
    if (subkey && FAILED(SHStrDupA(subkey, &subkeyW)))
        return ERROR_OUTOFMEMORY;
    if (value && FAILED(SHStrDupA(value, &valueW)))
    {
        CoTaskMemFree(subkeyW);
        return ERROR_OUTOFMEMORY;
    }
 
    ret = SHDeleteValueW(hkey, subkeyW, valueW);
    CoTaskMemFree(subkeyW);
    CoTaskMemFree(valueW);
    return ret;
}

Referenced by test_objecttag(), UnregisterExtensionForMIMETypeA(), and UnregisterMIMETypeForExtensionA().

SHDeleteValueW()

DWORD WINAPI SHDeleteValueW	(	HKEY	hkey,
		const WCHAR *	subkey,
		const WCHAR *	value
	)

Definition at line 1906 of file main.c.

{
    HKEY hsubkey;
    DWORD ret;
 
    TRACE("(%p, %s, %s)\n", hkey, debugstr_w(subkey), debugstr_w(value));
 
    ret = RegOpenKeyExW(hkey, subkey, 0, KEY_SET_VALUE, &hsubkey);
    if (!ret)
    {
        ret = RegDeleteValueW(hsubkey, value);
        RegCloseKey(hsubkey);
    }
 
    return ret;
}

Referenced by CMruBase::_DeleteValue(), CMruLongList::_ImportShortList(), MRUList_DataList(), CGlobalFolderSettings::Save(), CRegFolder::SetNameOf(), SHDeleteValueA(), UnregisterExtensionForMIMETypeW(), UnregisterMIMETypeForExtensionW(), and CRegPropertyBag::Write().

SHEnumKeyExA()

LONG WINAPI SHEnumKeyExA	(	HKEY	hkey,
		DWORD	index,
		char *	subkey,
		DWORD *	length
	)

Definition at line 2059 of file main.c.

{
    TRACE("%p, %ld, %s, %p.\n", hkey, index, debugstr_a(subkey), length);
 
    return RegEnumKeyExA(hkey, index, subkey, length, NULL, NULL, NULL, NULL);
}

SHEnumKeyExW()

LONG WINAPI SHEnumKeyExW	(	HKEY	hkey,
		DWORD	index,
		WCHAR *	subkey,
		DWORD *	length
	)

Definition at line 2069 of file main.c.

{
    TRACE("%p, %ld, %s, %p.\n", hkey, index, debugstr_w(subkey), length);
 
    return RegEnumKeyExW(hkey, index, subkey, length, NULL, NULL, NULL, NULL);
}

SHEnumValueA()

LONG WINAPI SHEnumValueA	(	HKEY	hkey,
		DWORD	index,
		char *	value,
		DWORD *	length,
		DWORD *	type,
		void *	data,
		DWORD *	data_len
	)

Definition at line 2079 of file main.c.

{
    TRACE("%p, %ld, %s, %p, %p, %p, %p.\n", hkey, index, debugstr_a(value), length, type, data, data_len);
 
    return RegEnumValueA(hkey, index, value, length, NULL, type, data, data_len);
}

SHEnumValueW()

LONG WINAPI SHEnumValueW	(	HKEY	hkey,
		DWORD	index,
		WCHAR *	value,
		DWORD *	length,
		DWORD *	type,
		void *	data,
		DWORD *	data_len
	)

Definition at line 2090 of file main.c.

{
    TRACE("%p, %ld, %s, %p, %p, %p, %p.\n", hkey, index, debugstr_w(value), length, type, data, data_len);
 
    return RegEnumValueW(hkey, index, value, length, NULL, type, data, data_len);
}

SHGetThreadRef()

HRESULT WINAPI SHGetThreadRef

(

IUnknown **

out

)

Definition at line 1505 of file main.c.

{
    TRACE("(%p)\n", out);
 
    if (shcore_tls == TLS_OUT_OF_INDEXES)
        return E_NOINTERFACE;
 
    *out = TlsGetValue(shcore_tls);
    if (!*out)
        return E_NOINTERFACE;
 
    IUnknown_AddRef(*out);
    return S_OK;
}

Referenced by SHCreateThread().

SHGetValueA()

DWORD WINAPI SHGetValueA	(	HKEY	hkey,
		const char *	subkey,
		const char *	value,
		DWORD *	type,
		void *	data,
		DWORD *	data_len
	)

Definition at line 2197 of file main.c.

{
    HKEY hsubkey = 0;
    DWORD ret = 0;
 
    TRACE("(%p, %s, %s, %p, %p, %p)\n", hkey, debugstr_a(subkey), debugstr_a(value),
            type, data, data_len);
 
    if (subkey)
        ret = RegOpenKeyExA(hkey, subkey, 0, KEY_QUERY_VALUE, &hsubkey);
 
    if (!ret)
    {
        ret = SHQueryValueExA(hsubkey ? hsubkey : hkey, value, 0, type, data, data_len);
        if (subkey)
            RegCloseKey(hsubkey);
    }
 
    return ret;
}

Referenced by getregdw(), init(), MIME_GetExtensionA(), PathIsContentTypeA(), SHGetValueGoodBootA(), SHLWAPI_GetMappedFlags(), SHLWAPI_GetRegistryCompatFlags(), SHLWAPI_UseSystemForSystemFolders(), SHRegGetPathA(), and test_SHGetValue().

SHGetValueW()

DWORD WINAPI SHGetValueW	(	HKEY	hkey,
		const WCHAR *	subkey,
		const WCHAR *	value,
		DWORD *	type,
		void *	data,
		DWORD *	data_len
	)

Definition at line 2222 of file main.c.

{
    HKEY hsubkey = 0;
    DWORD ret = 0;
 
    TRACE("(%p, %s, %s, %p, %p, %p)\n", hkey, debugstr_w(subkey), debugstr_w(value),
            type, data, data_len);
 
    if (subkey)
        ret = RegOpenKeyExW(hkey, subkey, 0, KEY_QUERY_VALUE, &hsubkey);
 
    if (!ret)
    {
        ret = SHQueryValueExW(hsubkey ? hsubkey : hkey, value, 0, type, data, data_len);
        if (subkey)
            RegCloseKey(hsubkey);
    }
 
    return ret;
}

Referenced by _AllocValueString(), CDesktopUpgradePropertyBag::_AlreadyUpgraded(), CBandSiteMenu::_CreateMenuPart(), CViewStatePropertyBag::_GetMRUSize(), CMruShortList::_InitSlots(), CMruLongList::_InitSlots(), CMruBase::_LoadItem(), CMruPidlList::_LoadNodeSlots(), CRegPropertyBag::_ReadBinary(), CRegPropertyBag::_ReadDword(), CDesktopUpgradePropertyBag::_ReadFlags(), CRegPropertyBag::_ReadString(), Candidate_SHGetRestriction(), CTrayWindow::DoExitWindows(), GetAssocClass(), CRegFolder::GetDisplayNameOf(), CMruNode::GetNodeSlot(), GetZipCodePage(), HCR_GetExecuteCommandW(), InitializeServerAdminUI(), TaskbarSettings::Load(), MIME_GetExtensionW(), MRUList_Check(), MRUList_DataList(), MRUList_PidlList_0(), PathIsContentTypeW(), CRegistrySource::QueryValueDword(), CRegistrySource::QueryValueExists(), CRegistrySource::QueryValueString(), CRegPropertyBag::Read(), SHAboutInfoW(), SHCreatePropSheetExtArrayEx(), SHELL32_ReadRegShellState(), SHELL_GetCachedComputerDescription(), SHGetRestriction(), SHGetValueGoodBootW(), SHRegGetPathW(), SIC_GetMetricsValue(), and CDefView::UpdateListColors().

SHOpenRegStream2A()

IStream *WINAPI SHOpenRegStream2A	(	HKEY	hKey,
		const char *	subkey,
		const char *	value,
		DWORD	mode
	)

Definition at line 1316 of file main.c.

{
    WCHAR *subkeyW = NULL, *valueW = NULL;
    IStream *stream;
 
    TRACE("%p, %s, %s, %#lx.\n", hKey, debugstr_a(subkey), debugstr_a(value), mode);
 
    if (subkey && FAILED(SHStrDupA(subkey, &subkeyW)))
        return NULL;
    if (value && FAILED(SHStrDupA(value, &valueW)))
    {
        CoTaskMemFree(subkeyW);
        return NULL;
    }
 
    stream = SHOpenRegStream2W(hKey, subkeyW, valueW, mode);
    CoTaskMemFree(subkeyW);
    CoTaskMemFree(valueW);
    return stream;
}

SHOpenRegStream2W()

IStream *WINAPI SHOpenRegStream2W	(	HKEY	hKey,
		const WCHAR *	subkey,
		const WCHAR *	value,
		DWORD	mode
	)

Definition at line 1266 of file main.c.

{
    struct shstream *stream;
    HKEY hStrKey = NULL;
    BYTE *buff = NULL;
    DWORD length = 0;
    LONG ret;
 
    TRACE("%p, %s, %s, %#lx.\n", hKey, debugstr_w(subkey), debugstr_w(value), mode);
 
    if (mode == STGM_READ)
        ret = RegOpenKeyExW(hKey, subkey, 0, KEY_READ, &hStrKey);
    else /* in write mode we make sure the subkey exits */
        ret = RegCreateKeyExW(hKey, subkey, 0, NULL, 0, KEY_READ | KEY_WRITE, NULL, &hStrKey, NULL);
 
    if (ret == ERROR_SUCCESS)
    {
        if (mode == STGM_READ || mode == STGM_READWRITE)
        {
            /* read initial data */
            ret = RegQueryValueExW(hStrKey, value, 0, 0, 0, &length);
            if (ret == ERROR_SUCCESS && length)
            {
                buff = malloc(length);
                RegQueryValueExW(hStrKey, value, 0, 0, buff, &length);
            }
        }
 
        if (!length)
            buff = malloc(length);
 
        stream = shstream_create(&regstreamvtbl, buff, length);
        free(buff);
        if (stream)
        {
            stream->u.mem.hkey = hStrKey;
            SHStrDupW(value, &stream->u.mem.valuename);
            return &stream->IStream_iface;
        }
    }
 
    if (hStrKey)
        RegCloseKey(hStrKey);
 
    return NULL;
}

Referenced by CDesktopUpgradePropertyBag::_GetOldDesktopViewStream(), CDefView::GetDefaultViewStream(), CInternetToolbar::GetStream(), SHOpenRegStream2A(), and SHOpenRegStreamW().

SHOpenRegStreamA()

IStream *WINAPI SHOpenRegStreamA	(	HKEY	hkey,
		const char *	subkey,
		const char *	value,
		DWORD	mode
	)

Definition at line 1340 of file main.c.

{
    WCHAR *subkeyW = NULL, *valueW = NULL;
    IStream *stream;
 
    TRACE("%p, %s, %s, %#lx.\n", hkey, debugstr_a(subkey), debugstr_a(value), mode);
 
    if (subkey && FAILED(SHStrDupA(subkey, &subkeyW)))
        return NULL;
    if (value && FAILED(SHStrDupA(value, &valueW)))
    {
        CoTaskMemFree(subkeyW);
        return NULL;
    }
 
    stream = SHOpenRegStreamW(hkey, subkeyW, valueW, mode);
    CoTaskMemFree(subkeyW);
    CoTaskMemFree(valueW);
    return stream;
}

SHOpenRegStreamW()

IStream *WINAPI SHOpenRegStreamW	(	HKEY	hkey,
		const WCHAR *	subkey,
		const WCHAR *	value,
		DWORD	mode
	)

Definition at line 1404 of file main.c.

{
    IStream *stream;
 
    TRACE("%p, %s, %s, %#lx.\n", hkey, debugstr_w(subkey), debugstr_w(value), mode);
    stream = SHOpenRegStream2W(hkey, subkey, value, mode);
    return stream ? stream : &dummyregstream.IStream_iface;
}

Referenced by CTrayBandSite::GetDefaultBandsStream(), CTrayBandSite::GetUserBandsStream(), and SHOpenRegStreamA().

SHQueryInfoKeyA()

LONG WINAPI SHQueryInfoKeyA	(	HKEY	hkey,
		DWORD *	subkeys,
		DWORD *	subkey_max,
		DWORD *	values,
		DWORD *	value_max
	)

Definition at line 2372 of file main.c.

{
    TRACE("(%p, %p, %p, %p, %p)\n", hkey, subkeys, subkey_max, values, value_max);
 
    return RegQueryInfoKeyA(hkey, NULL, NULL, NULL, subkeys, subkey_max, NULL, values, value_max, NULL, NULL, NULL);
}

SHQueryInfoKeyW()

LONG WINAPI SHQueryInfoKeyW	(	HKEY	hkey,
		DWORD *	subkeys,
		DWORD *	subkey_max,
		DWORD *	values,
		DWORD *	value_max
	)

Definition at line 2382 of file main.c.

{
    TRACE("(%p, %p, %p, %p, %p)\n", hkey, subkeys, subkey_max, values, value_max);
 
    return RegQueryInfoKeyW(hkey, NULL, NULL, NULL, subkeys, subkey_max, NULL, values, value_max, NULL, NULL, NULL);
}

SHQueryValueExA()

DWORD WINAPI SHQueryValueExA	(	HKEY	hkey,
		const char *	name,
		DWORD *	reserved,
		DWORD *	type,
		void *	buff,
		DWORD *	buff_len
	)

Definition at line 2149 of file main.c.

{
    DWORD ret, value_type, data_len = 0;
 
    TRACE("(%p, %s, %p, %p, %p, %p)\n", hkey, debugstr_a(name), reserved, type, buff, buff_len);
 
    if (buff_len)
        data_len = *buff_len;
 
    ret = RegQueryValueExA(hkey, name, reserved, &value_type, buff, &data_len);
    if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA)
        return ret;
 
    if (buff_len && value_type == REG_EXPAND_SZ)
    {
        DWORD length;
        char *value;
 
        if (!buff || ret == ERROR_MORE_DATA)
        {
            length = data_len;
            value = malloc(length);
            RegQueryValueExA(hkey, name, reserved, NULL, (BYTE *)value, &length);
            length = ExpandEnvironmentStringsA(value, NULL, 0);
        }
        else
        {
            length = strlen(buff) + 1;
            value = malloc(length);
            memcpy(value, buff, length);
            length = ExpandEnvironmentStringsA(value, buff, *buff_len);
            if (length > *buff_len) ret = ERROR_MORE_DATA;
        }
        data_len = max(data_len, length);
        free(value);
    }
 
    if (type)
        *type = value_type == REG_EXPAND_SZ ? REG_SZ : value_type;
    if (buff_len)
        *buff_len = data_len;
    return ret;
}

Referenced by init(), SHADD_get_policy(), SHGetValueA(), SHRegQueryValueExA(), test_SHCopyKey(), and test_SHQueryValueEx().

SHQueryValueExW()

DWORD WINAPI SHQueryValueExW	(	HKEY	hkey,
		const WCHAR *	name,
		DWORD *	reserved,
		DWORD *	type,
		void *	buff,
		DWORD *	buff_len
	)

Definition at line 2101 of file main.c.

{
    DWORD ret, value_type, data_len = 0;
 
    TRACE("(%p, %s, %p, %p, %p, %p)\n", hkey, debugstr_w(name), reserved, type, buff, buff_len);
 
    if (buff_len)
        data_len = *buff_len;
 
    ret = RegQueryValueExW(hkey, name, reserved, &value_type, buff, &data_len);
    if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA)
        return ret;
 
    if (buff_len && value_type == REG_EXPAND_SZ)
    {
        DWORD length;
        WCHAR *value;
 
        if (!buff || ret == ERROR_MORE_DATA)
        {
            length = data_len;
            value = malloc(length);
            RegQueryValueExW(hkey, name, reserved, NULL, (BYTE *)value, &length);
            length = ExpandEnvironmentStringsW(value, NULL, 0);
        }
        else
        {
            length = (lstrlenW(buff) + 1) * sizeof(WCHAR);
            value = malloc(length);
            memcpy(value, buff, length);
            length = ExpandEnvironmentStringsW(value, buff, *buff_len / sizeof(WCHAR));
            if (length > *buff_len) ret = ERROR_MORE_DATA;
        }
        data_len = max(data_len, length);
        free(value);
    }
 
    if (type)
        *type = value_type == REG_EXPAND_SZ ? REG_SZ : value_type;
    if (buff_len)
        *buff_len = data_len;
    return ret;
}

Referenced by CFSExtractIcon_CreateInstance(), CQueryAssociations::GetValue(), IsOS(), read_advanced_key(), SH32_CoCreateInstance(), SHELL_ReadSingleUnreadMailCount(), SHGetValueW(), SHRegGetIntW(), SHRegQueryValueExW(), SKAllocValueW(), and SKGetValueW().

SHRegDuplicateHKey()

HKEY WINAPI SHRegDuplicateHKey

(

HKEY

hKey

)

Definition at line 1828 of file main.c.

{
    HKEY newKey = 0;
 
    RegOpenKeyExW(hKey, 0, 0, MAXIMUM_ALLOWED, &newKey);
    TRACE("new key is %p\n", newKey);
    return newKey;
}

Referenced by CRegistrySource::GetKey(), init(), CMruBase::InitData(), CDefaultContextMenu::Initialize(), CRegistrySource::SetKey(), SHRegCreateUSKeyW(), and SHRegOpenUSKeyW().

SHRegGetIntW()

int WINAPI SHRegGetIntW	(	HKEY	hkey,
		const WCHAR *	value,
		int	default_value
	)

Definition at line 2247 of file main.c.

{
    WCHAR buff[32];
    DWORD buff_len;
 
    TRACE("(%p, %s, %d)\n", hkey, debugstr_w(value), default_value);
 
    buff[0] = 0;
    buff_len = sizeof(buff);
    if (SHQueryValueExW(hkey, value, 0, 0, buff, &buff_len))
        return default_value;
 
    if (*buff >= '0' && *buff <= '9')
        return wcstol(buff, NULL, 10);
 
    return default_value;
}

Referenced by LoadCurrentScheme(), and LoadSchemeFromReg().

SHRegGetPathA()

DWORD WINAPI SHRegGetPathA	(	HKEY	hkey,
		const char *	subkey,
		const char *	value,
		char *	path,
		DWORD	flags
	)

Definition at line 2268 of file main.c.

{
    DWORD length = MAX_PATH;
 
    TRACE("%p, %s, %s, %p, %#lx.\n", hkey, debugstr_a(subkey), debugstr_a(value), path, flags);
 
    return SHGetValueA(hkey, subkey, value, 0, path, &length);
}

Referenced by init().

SHRegGetPathW()

DWORD WINAPI SHRegGetPathW	(	HKEY	hkey,
		const WCHAR *	subkey,
		const WCHAR *	value,
		WCHAR *	path,
		DWORD	flags
	)

Definition at line 2280 of file main.c.

{
    DWORD length = MAX_PATH;
 
    TRACE("%p, %s, %s, %p, %#lx.\n", hkey, debugstr_w(subkey), debugstr_w(value), path, flags);
 
    return SHGetValueW(hkey, subkey, value, 0, path, &length);
}

SHRegSetPathA()

DWORD WINAPI SHRegSetPathA	(	HKEY	hkey,
		const char *	subkey,
		const char *	value,
		const char *	path,
		DWORD	flags
	)

Definition at line 2346 of file main.c.

{
    FIXME("%p, %s, %s, %s, %#lx - semi-stub\n", hkey, debugstr_a(subkey),
            debugstr_a(value), debugstr_a(path), flags);
 
    /* FIXME: PathUnExpandEnvStringsA() */
 
    return SHSetValueA(hkey, subkey, value, REG_SZ, path, lstrlenA(path));
}

SHRegSetPathW()

DWORD WINAPI SHRegSetPathW	(	HKEY	hkey,
		const WCHAR *	subkey,
		const WCHAR *	value,
		const WCHAR *	path,
		DWORD	flags
	)

Definition at line 2359 of file main.c.

{
    FIXME("%p, %s, %s, %s, %#lx semi-stub\n", hkey, debugstr_w(subkey),
            debugstr_w(value), debugstr_w(path), flags);
 
    /* FIXME: PathUnExpandEnvStringsW(); */
 
    return SHSetValueW(hkey, subkey, value, REG_SZ, path, lstrlenW(path));
}

SHReleaseThreadRef()

HRESULT WINAPI SHReleaseThreadRef

(

void

)

Definition at line 1537 of file main.c.

{
    FIXME("() - stub!\n");
    return S_OK;
}

SHSetThreadRef()

HRESULT WINAPI SHSetThreadRef

(

IUnknown *

obj

)

Definition at line 1523 of file main.c.

{
    TRACE("(%p)\n", obj);
 
    if (shcore_tls == TLS_OUT_OF_INDEXES)
        return E_NOINTERFACE;
 
    TlsSetValue(shcore_tls, obj);
    return S_OK;
}

SHSetValueA()

DWORD WINAPI SHSetValueA	(	HKEY	hkey,
		const char *	subkey,
		const char *	value,
		DWORD	type,
		const void *	data,
		DWORD	data_len
	)

Definition at line 2319 of file main.c.

{
    DWORD ret = ERROR_SUCCESS, dummy;
    HKEY hsubkey;
 
    TRACE("%p, %s, %s, %ld, %p, %ld.\n", hkey, debugstr_a(subkey), debugstr_a(value),
            type, data, data_len);
 
    if (subkey && *subkey)
        ret = RegCreateKeyExA(hkey, subkey, 0, NULL, 0, KEY_SET_VALUE, NULL, &hsubkey, &dummy);
    else
        hsubkey = hkey;
 
    if (!ret)
    {
        ret = RegSetValueExA(hsubkey, value, 0, type, data, data_len);
        if (hsubkey != hkey)
            RegCloseKey(hsubkey);
    }
 
    return ret;
}

Referenced by RegisterExtensionForMIMETypeA(), RegisterMIMETypeForExtensionA(), and SHRegSetPathA().

SHSetValueW()

DWORD WINAPI SHSetValueW	(	HKEY	hkey,
		const WCHAR *	subkey,
		const WCHAR *	value,
		DWORD	type,
		const void *	data,
		DWORD	data_len
	)

Definition at line 2292 of file main.c.

{
    DWORD ret = ERROR_SUCCESS, dummy;
    HKEY hsubkey;
 
    TRACE("%p, %s, %s, %ld, %p, %ld.\n", hkey, debugstr_w(subkey), debugstr_w(value),
            type, data, data_len);
 
    if (subkey && *subkey)
        ret = RegCreateKeyExW(hkey, subkey, 0, NULL, 0, KEY_SET_VALUE, NULL, &hsubkey, &dummy);
    else
        hsubkey = hkey;
 
    if (!ret)
    {
        ret = RegSetValueExW(hsubkey, value, 0, type, data, data_len);
        if (hsubkey != hkey)
            RegCloseKey(hsubkey);
    }
 
    return ret;
}

Referenced by CMruBase::_AddItem(), CDesktopUpgradePropertyBag::_MarkAsUpgraded(), CMruPidlList::_SaveNodeSlots(), CMruShortList::_SaveSlots(), CMruLongList::_SaveSlots(), CRegPropertyBag::_WriteStream(), ApplyScheme(), CRegTreeOptions::GetSetState(), InitializeServerAdminUI(), MRUList_DataList(), RegisterExtensionForMIMETypeW(), RegisterMIMETypeForExtensionW(), TaskbarSettings::Save(), CGlobalFolderSettings::Save(), CRegFolder::SetNameOf(), CMruNode::SetNodeSlot(), SetUnreadMailInfo(), CRegistrySource::SetValueDirect(), SHCopyKeyW(), SHELL32_WriteRegShellState(), SHELL_CacheComputerDescription(), SHGetSetSettings(), SHRegSetPathW(), and CRegPropertyBag::Write().

SHStrDupA()

HRESULT WINAPI SHStrDupA	(	const char *	src,
		WCHAR **	dest
	)

Definition at line 1716 of file main.c.

{
    DWORD len;
 
    *dest = NULL;
 
    if (!src)
        return E_INVALIDARG;
 
    len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
    *dest = CoTaskMemAlloc(len * sizeof(WCHAR));
    if (!*dest)
        return E_OUTOFMEMORY;
 
    MultiByteToWideChar(CP_ACP, 0, src, -1, *dest, len);
 
    return S_OK;
}

Referenced by SHCopyKeyA(), SHDeleteEmptyKeyA(), SHDeleteValueA(), SHOpenRegStream2A(), SHOpenRegStreamA(), and TestFilenameA().

SHStrDupW()

HRESULT WINAPI SHStrDupW	(	const WCHAR *	src,
		WCHAR **	dest
	)

Definition at line 1692 of file main.c.

{
    size_t len;
 
    TRACE("(%s, %p)\n", debugstr_w(src), dest);
 
    *dest = NULL;
 
    if (!src)
        return E_INVALIDARG;
 
    len = (lstrlenW(src) + 1) * sizeof(WCHAR);
    *dest = CoTaskMemAlloc(len);
    if (!*dest)
        return E_OUTOFMEMORY;
 
    memcpy(*dest, src, len);
 
    return S_OK;
}

Referenced by CRegistryEnumBase::_Next(), AssocGetPerceivedType(), DoSanitizeClipboard(), GetDisplayNameOf(), CRecycleBin::GetDisplayNameOf(), CAutoComplete::GetDropDownStatus(), GetItemOriginalFolder(), CACListISF::GetPaths(), CShellFolder::GetValidCharacters(), CDesktopFolder::GetValidCharacters(), CFSFolder::GetValidCharacters(), CMyDocsFolder::GetValidCharacters(), CMergedFolder::GetValidCharacters(), CCleanupHandler::Initialize(), CFSDropTarget::Initialize(), CFSFolder::Initialize(), CFSFolder::InitializeEx(), load_APE_metadata(), load_GCE_metadata(), load_GifComment_metadata(), load_IMD_metadata(), load_LSD_metadata(), LoadChrmMetadata(), LoadGamaMetadata(), LoadHistMetadata(), LoadTimeMetadata(), CEnumString::Next(), CRecycleBinCleaner::OutputResourceString(), CAddressEditBox::ParseNow(), CRegistrySource::QueryValueString(), CCleanupHandler::ReadProperty(), RecursiveFind(), CFindFolder::SearchThreadProc(), SHExplorerParseCmdLine(), SHOpenRegStream2W(), ShellPropSheetDialog::ShowAsync(), START_TEST(), and TEST_StrRet().

shstream_AddRef()

static ULONG WINAPI shstream_AddRef ( IStream *  iface )

static

Definition at line 574 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    ULONG refcount = InterlockedIncrement(&stream->refcount);
 
    TRACE("%p, refcount %lu.\n", iface, refcount);
 
    return refcount;
}

shstream_Clone()

static HRESULT WINAPI shstream_Clone ( IStream *  iface, IStream **  dest  )

static

Definition at line 804 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
 
    TRACE("(%p, %p)\n", stream, dest);
 
    *dest = NULL;
 
    /* clone not supported by this stream */
    return E_NOTIMPL;
}

shstream_Commit()

static HRESULT WINAPI shstream_Commit ( IStream *  iface, DWORD  flags  )

static

Definition at line 752 of file main.c.

{
    TRACE("%p, %#lx.\n", iface, flags);
 
    /* Commit is not supported by this stream */
    return E_NOTIMPL;
}

shstream_CopyTo()

static HRESULT WINAPI shstream_CopyTo ( IStream *  iface, IStream *  dest, ULARGE_INTEGER  size, ULARGE_INTEGER *  read_len, ULARGE_INTEGER *  written  )

static

Definition at line 702 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
    ULARGE_INTEGER total_read, total_written;
    HRESULT hr = S_OK;
    BYTE buffer[0x400];
 
    TRACE("(%p, %p, %s, %p, %p)\n", stream, dest, wine_dbgstr_longlong(size.QuadPart), read_len, written);
 
    if (!dest)
        return E_POINTER;
 
    total_read.QuadPart = 0;
    total_written.QuadPart = 0;
 
    while (size.QuadPart > 0)
    {
        ULONG chunk_size = size.QuadPart >= sizeof(buffer) ? sizeof(buffer) : size.u.LowPart;
        ULONG chunk_read, chunk_written;
 
        hr = IStream_Read(iface, buffer, chunk_size, &chunk_read);
        if (FAILED(hr))
            break;
 
        total_read.QuadPart += chunk_read;
 
        if (chunk_read)
        {
            hr = IStream_Write(dest, buffer, chunk_read, &chunk_written);
            if (FAILED(hr))
                break;
 
            total_written.QuadPart += chunk_written;
        }
 
        if (chunk_read != chunk_size)
            size.QuadPart = 0;
        else
            size.QuadPart -= chunk_read;
    }
 
    if (read_len)
        read_len->QuadPart = total_read.QuadPart;
    if (written)
        written->QuadPart = total_written.QuadPart;
 
    return hr;
}

shstream_create()

static struct shstream * shstream_create ( const IStreamVtbl *  vtbl, const BYTE *  data, UINT  data_len  )

static

Definition at line 834 of file main.c.

{
    struct shstream *stream;
 
    if (!data)
        data_len = 0;
 
    stream = malloc(sizeof(*stream));
    stream->IStream_iface.lpVtbl = vtbl;
    stream->refcount = 1;
    stream->u.mem.buffer = malloc(data_len);
    if (!stream->u.mem.buffer)
    {
        free(stream);
        return NULL;
    }
    memcpy(stream->u.mem.buffer, data, data_len);
    stream->u.mem.length = data_len;
    stream->u.mem.position = 0;
 
    return stream;
}

Referenced by SHCreateMemStream(), and SHOpenRegStream2W().

shstream_LockRegion()

static HRESULT WINAPI shstream_LockRegion ( IStream *  iface, ULARGE_INTEGER  offset, ULARGE_INTEGER  size, DWORD  lock_type  )

static

Definition at line 770 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
 
    TRACE("(%p)\n", stream);
 
    /* lock/unlock not supported by this stream */
    return E_NOTIMPL;
}

shstream_QueryInterface()

static HRESULT WINAPI shstream_QueryInterface ( IStream *  iface, REFIID  riid, void **  out  )

static

Definition at line 554 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
 
    TRACE("(%p)->(%s, %p)\n", stream, debugstr_guid(riid), out);
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IStream) ||
        IsEqualIID(riid, &IID_ISequentialStream))
    {
        *out = iface;
        IStream_AddRef(iface);
        return S_OK;
    }
 
    *out = NULL;
    WARN("Unsupported interface %s.\n", debugstr_guid(riid));
    return E_NOINTERFACE;
}

shstream_Revert()

static HRESULT WINAPI shstream_Revert ( IStream *  iface )

static

Definition at line 760 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
 
    TRACE("(%p)\n", stream);
 
    /* revert not supported by this stream */
    return E_NOTIMPL;
}

shstream_UnlockRegion()

static HRESULT WINAPI shstream_UnlockRegion ( IStream *  iface, ULARGE_INTEGER  offset, ULARGE_INTEGER  size, DWORD  lock_type  )

static

Definition at line 780 of file main.c.

{
    struct shstream *stream = impl_from_IStream(iface);
 
    TRACE("(%p)\n", stream);
 
    /* lock/unlock not supported by this stream */
    return E_NOTIMPL;
}

SHUnicodeToAnsi()

DWORD WINAPI SHUnicodeToAnsi	(	const WCHAR *	src,
		char *	dest,
		int	dest_len
	)

Definition at line 1756 of file main.c.

{
    int ret = 1;
 
    TRACE("(%s, %p, %d)\n", debugstr_w(src), dest, dest_len);
 
    if (!dest || !dest_len)
        return 0;
 
    if (src)
    {
        ret = WideCharToMultiByte(CP_ACP, 0, src, -1, dest, dest_len, NULL, NULL);
        if (!ret)
        {
            dest[dest_len - 1] = 0;
            ret = dest_len;
        }
    }
    else
        dest[0] = 0;
 
    return ret;
}

Referenced by CheckEscapesA(), CDefaultContextMenu::GetCommandString(), GetCommandStringA(), init(), CStartMenuBtnCtxMenu::InvokeCommand(), CDefView::InvokeContextMenuCommand(), MakeShellURLFromPathA(), CAutoComplete::OnNotify(), PathQualifyA(), PathResolveA(), SHBrowseForFolderA(), SHELL_IsVerb(), SHELL_MapContextMenuVerbToCmdId(), SHGetFileDescriptionA(), SHInvokeCommandOnContextMenuInternal(), and ViewDlg_OnInitDialog().

SHUnicodeToUnicode()

DWORD WINAPI SHUnicodeToUnicode	(	const WCHAR *	src,
		WCHAR *	dest,
		int	dest_len
	)

Definition at line 1783 of file main.c.

{
    DWORD ret;
 
    TRACE("(%s, %p, %d)\n", debugstr_w(src), dest, dest_len);
 
    if (!src || !dest || dest_len <= 0)
        return 0;
 
    lstrcpynW(dest, src, dest_len);
    ret = lstrlenW(dest);
 
    return src[ret] ? 0 : ret + 1;
}

Referenced by init().

SubscribeFeatureStateChangeNotification()

void WINAPI SubscribeFeatureStateChangeNotification	(	FEATURE_STATE_CHANGE_SUBSCRIPTION *	subscription,
		FEATURE_STATE_CHANGE_CALLBACK *	callback,
		void *	context
	)

Definition at line 2554 of file main.c.

{
    FIXME("(%p, %p, %p) stub\n", subscription, callback, context);
}

threadref_AddRef()

static ULONG WINAPI threadref_AddRef ( IUnknown *  iface )

static

Definition at line 1445 of file main.c.

{
    struct threadref *threadref = threadref_impl_from_IUnknown(iface);
    LONG refcount = InterlockedIncrement(threadref->refcount);
 
    TRACE("%p, refcount %ld.\n", threadref, refcount);
 
    return refcount;
}

threadref_impl_from_IUnknown()

static struct threadref * threadref_impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 1419 of file main.c.

{
    return CONTAINING_RECORD(iface, struct threadref, IUnknown_iface);
}

Referenced by threadref_AddRef(), threadref_QueryInterface(), and threadref_Release().

threadref_QueryInterface()

static HRESULT WINAPI threadref_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  out  )

static

Definition at line 1424 of file main.c.

{
    struct threadref *threadref = threadref_impl_from_IUnknown(iface);
 
    TRACE("(%p, %s, %p)\n", threadref, debugstr_guid(riid), out);
 
    if (out == NULL)
        return E_POINTER;
 
    if (IsEqualGUID(&IID_IUnknown, riid))
    {
        *out = iface;
        IUnknown_AddRef(iface);
        return S_OK;
    }
 
    *out = NULL;
    WARN("Interface %s not supported.\n", debugstr_guid(riid));
    return E_NOINTERFACE;
}

threadref_Release()

static ULONG WINAPI threadref_Release ( IUnknown *  iface )

static

Definition at line 1455 of file main.c.

{
    struct threadref *threadref = threadref_impl_from_IUnknown(iface);
    LONG refcount = InterlockedDecrement(threadref->refcount);
 
    TRACE("%p, refcount %ld.\n", threadref, refcount);
 
    if (!refcount)
        free(threadref);
 
    return refcount;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shcore

)

Variable Documentation

dummyregstream

struct shstream dummyregstream = { { &dummystreamvtbl } }

static

Definition at line 1399 of file main.c.

Referenced by SHOpenRegStreamW().

dummystreamvtbl

const IStreamVtbl dummystreamvtbl

static

Initial value:

=
{
    shstream_QueryInterface,
    dummystream_AddRef,
    dummystream_Release,
    dummystream_Read,
    memstream_Write,
    memstream_Seek,
    memstream_SetSize,
    shstream_CopyTo,
    shstream_Commit,
    shstream_Revert,
    shstream_LockRegion,
    shstream_UnlockRegion,
    memstream_Stat,
    shstream_Clone,
}

Definition at line 1381 of file main.c.

filestreamvtbl

const IStreamVtbl filestreamvtbl

static

Initial value:

=
{
    shstream_QueryInterface,
    shstream_AddRef,
    filestream_Release,
    filestream_Read,
    filestream_Write,
    filestream_Seek,
    filestream_SetSize,
    filestream_CopyTo,
    filestream_Commit,
    shstream_Revert,
    shstream_LockRegion,
    shstream_UnlockRegion,
    filestream_Stat,
    shstream_Clone,
}

Definition at line 1076 of file main.c.

Referenced by SHCreateStreamOnFileEx().

memstreamvtbl

const IStreamVtbl memstreamvtbl

static

Initial value:

=
{
    shstream_QueryInterface,
    shstream_AddRef,
    memstream_Release,
    memstream_Read,
    memstream_Write,
    memstream_Seek,
    memstream_SetSize,
    shstream_CopyTo,
    shstream_Commit,
    shstream_Revert,
    shstream_LockRegion,
    shstream_UnlockRegion,
    memstream_Stat,
    shstream_Clone,
}

Definition at line 816 of file main.c.

Referenced by SHCreateMemStream().

process_ref

IUnknown* process_ref

static

Definition at line 41 of file main.c.

Referenced by GetProcessReference(), and SetProcessReference().

regstreamvtbl

const IStreamVtbl regstreamvtbl

static

Initial value:

=
{
    shstream_QueryInterface,
    shstream_AddRef,
    regstream_Release,
    memstream_Read,
    memstream_Write,
    memstream_Seek,
    memstream_SetSize,
    shstream_CopyTo,
    shstream_Commit,
    shstream_Revert,
    shstream_LockRegion,
    shstream_UnlockRegion,
    memstream_Stat,
    shstream_Clone,
}

Definition at line 1245 of file main.c.

Referenced by SHOpenRegStream2W().

shcore_tls

DWORD shcore_tls

static

Definition at line 40 of file main.c.

Referenced by DllMain(), SHGetThreadRef(), and SHSetThreadRef().

threadrefvtbl

const IUnknownVtbl threadrefvtbl

static

Initial value:

=
{
    threadref_QueryInterface,
    threadref_AddRef,
    threadref_Release,
}

Definition at line 1468 of file main.c.

Referenced by SHCreateThreadRef().