wbemprox_private.h File Reference

#include "wine/debug.h"
#include "wine/heap.h"
#include "wine/list.h"

Include dependency graph for wbemprox_private.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	complex_expr
struct	expr
struct	column
struct	table
struct	property
struct	array
struct	field
struct	record
struct	keyword
struct	view
struct	query
struct	path

Macros
#define	CIM_TYPE_MASK   0x00000fff
#define	COL_TYPE_MASK   0x0000ffff
#define	COL_FLAG_DYNAMIC   0x00010000
#define	COL_FLAG_KEY   0x00020000
#define	COL_FLAG_METHOD   0x00040000
#define	TABLE_FLAG_DYNAMIC   0x00000001

Typedefs
typedef HRESULT()	class_method(IWbemClassObject *, IWbemClassObject *, IWbemClassObject **)

Enumerations
enum	param_direction { PARAM_OUT = -1 , PARAM_INOUT = 0 , PARAM_IN = 1 }
enum	operator {   OP_EQ = 1 , OP_AND = 2 , OP_OR = 3 , OP_GT = 4 ,   OP_LT = 5 , OP_LE = 6 , OP_GE = 7 , OP_NE = 8 ,   OP_ISNULL = 9 , OP_NOTNULL = 10 , OP_LIKE = 11 , OP_NOT = 12 }
enum	expr_type {   EXPR_COMPLEX = 1 , EXPR_UNARY = 2 , EXPR_PROPVAL = 3 , EXPR_SVAL = 4 ,   EXPR_IVAL = 5 , EXPR_BVAL = 6 , EXPR_VOID , EXPR_NUM ,   EXPR_HEXNUM , EXPR_DOUBLE , EXPR_IDENTIFIER , EXPR_NEG ,   EXPR_NOT , EXPR_PPTR , EXPR_CAST , EXPR_SIZEOF ,   EXPR_SHL , EXPR_SHR , EXPR_MUL , EXPR_DIV ,   EXPR_ADD , EXPR_SUB , EXPR_AND , EXPR_OR ,   EXPR_COND , EXPR_TRUEFALSE , EXPR_ADDRESSOF , EXPR_MEMBER ,   EXPR_ARRAY , EXPR_MOD , EXPR_LOGOR , EXPR_LOGAND ,   EXPR_XOR , EXPR_EQUALITY , EXPR_INEQUALITY , EXPR_GTR ,   EXPR_LESS , EXPR_GTREQL , EXPR_LESSEQL , EXPR_LOGNOT ,   EXPR_POS , EXPR_STRLIT , EXPR_WSTRLIT , EXPR_CHARCONST }
enum	fill_status { FILL_STATUS_FAILED = -1 , FILL_STATUS_UNFILTERED , FILL_STATUS_FILTERED }
enum	view_type { VIEW_TYPE_SELECT , VIEW_TYPE_ASSOCIATORS }

Functions
HRESULT	parse_path (const WCHAR *, struct path **) DECLSPEC_HIDDEN
void	free_path (struct path *) DECLSPEC_HIDDEN
WCHAR *	query_from_path (const struct path *) DECLSPEC_HIDDEN
struct query *	create_query (void) DECLSPEC_HIDDEN
void	free_query (struct query *) DECLSPEC_HIDDEN
struct query *	addref_query (struct query *) DECLSPEC_HIDDEN
void	release_query (struct query *query) DECLSPEC_HIDDEN
HRESULT	exec_query (const WCHAR *, IEnumWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	parse_query (const WCHAR *, struct view **, struct list *) DECLSPEC_HIDDEN
HRESULT	create_view (enum view_type, const WCHAR *, const struct keyword *, const WCHAR *, const struct property *, const struct expr *, struct view **) DECLSPEC_HIDDEN
void	destroy_view (struct view *) DECLSPEC_HIDDEN
HRESULT	execute_view (struct view *) DECLSPEC_HIDDEN
struct table *	get_view_table (const struct view *, UINT) DECLSPEC_HIDDEN
void	init_table_list (void) DECLSPEC_HIDDEN
struct table *	grab_table (const WCHAR *) DECLSPEC_HIDDEN
struct table *	addref_table (struct table *) DECLSPEC_HIDDEN
void	release_table (struct table *) DECLSPEC_HIDDEN
struct table *	create_table (const WCHAR *, UINT, const struct column *, UINT, UINT, BYTE *, enum fill_status(*)(struct table *, const struct expr *)) DECLSPEC_HIDDEN
BOOL	add_table (struct table *) DECLSPEC_HIDDEN
void	free_columns (struct column *, UINT) DECLSPEC_HIDDEN
void	free_row_values (const struct table *, UINT) DECLSPEC_HIDDEN
void	clear_table (struct table *) DECLSPEC_HIDDEN
void	free_table (struct table *) DECLSPEC_HIDDEN
UINT	get_type_size (CIMTYPE) DECLSPEC_HIDDEN
HRESULT	eval_cond (const struct table *, UINT, const struct expr *, LONGLONG *, UINT *) DECLSPEC_HIDDEN
HRESULT	get_column_index (const struct table *, const WCHAR *, UINT *) DECLSPEC_HIDDEN
HRESULT	get_value (const struct table *, UINT, UINT, LONGLONG *) DECLSPEC_HIDDEN
BSTR	get_value_bstr (const struct table *, UINT, UINT) DECLSPEC_HIDDEN
HRESULT	set_value (const struct table *, UINT, UINT, LONGLONG, CIMTYPE) DECLSPEC_HIDDEN
BOOL	is_method (const struct table *, UINT) DECLSPEC_HIDDEN
HRESULT	get_method (const struct table *, const WCHAR *, class_method **) DECLSPEC_HIDDEN
HRESULT	get_propval (const struct view *, UINT, const WCHAR *, VARIANT *, CIMTYPE *, LONG *) DECLSPEC_HIDDEN
HRESULT	put_propval (const struct view *, UINT, const WCHAR *, VARIANT *, CIMTYPE) DECLSPEC_HIDDEN
HRESULT	to_longlong (VARIANT *, LONGLONG *, CIMTYPE *) DECLSPEC_HIDDEN
SAFEARRAY *	to_safearray (const struct array *, CIMTYPE) DECLSPEC_HIDDEN
VARTYPE	to_vartype (CIMTYPE) DECLSPEC_HIDDEN
void	destroy_array (struct array *, CIMTYPE) DECLSPEC_HIDDEN
BOOL	is_result_prop (const struct view *, const WCHAR *) DECLSPEC_HIDDEN
HRESULT	get_properties (const struct view *, UINT, LONG, SAFEARRAY **) DECLSPEC_HIDDEN
HRESULT	get_object (const WCHAR *, IWbemClassObject **) DECLSPEC_HIDDEN
BSTR	get_method_name (const WCHAR *, UINT) DECLSPEC_HIDDEN
void	set_variant (VARTYPE, LONGLONG, void *, VARIANT *) DECLSPEC_HIDDEN
HRESULT	create_signature (const WCHAR *, const WCHAR *, enum param_direction, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	WbemLocator_create (LPVOID *) DECLSPEC_HIDDEN
HRESULT	WbemServices_create (const WCHAR *, LPVOID *) DECLSPEC_HIDDEN
HRESULT	create_class_object (const WCHAR *, IEnumWbemClassObject *, UINT, struct record *, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	EnumWbemClassObject_create (struct query *, LPVOID *) DECLSPEC_HIDDEN
HRESULT	WbemQualifierSet_create (const WCHAR *, const WCHAR *, LPVOID *) DECLSPEC_HIDDEN
HRESULT	process_get_owner (IWbemClassObject *, IWbemClassObject *, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	reg_create_key (IWbemClassObject *, IWbemClassObject *, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	reg_enum_key (IWbemClassObject *, IWbemClassObject *, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	reg_enum_values (IWbemClassObject *, IWbemClassObject *, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	reg_get_stringvalue (IWbemClassObject *, IWbemClassObject *, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	service_pause_service (IWbemClassObject *, IWbemClassObject *, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	service_resume_service (IWbemClassObject *, IWbemClassObject *, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	service_start_service (IWbemClassObject *, IWbemClassObject *, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	service_stop_service (IWbemClassObject *, IWbemClassObject *, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	security_get_sd (IWbemClassObject *, IWbemClassObject *, IWbemClassObject **) DECLSPEC_HIDDEN
HRESULT	security_set_sd (IWbemClassObject *, IWbemClassObject *, IWbemClassObject **) DECLSPEC_HIDDEN
static WCHAR *	heap_strdupW (const WCHAR *src)
static WCHAR *	heap_strdupAW (const char *src)

Variables
IClientSecurity client_security	DECLSPEC_HIDDEN
static const WCHAR	class_processW [] = {'W','i','n','3','2','_','P','r','o','c','e','s','s',0}
static const WCHAR	class_serviceW [] = {'W','i','n','3','2','_','S','e','r','v','i','c','e',0}
static const WCHAR	class_stdregprovW [] = {'S','t','d','R','e','g','P','r','o','v',0}
static const WCHAR	class_systemsecurityW [] = {'_','_','S','y','s','t','e','m','S','e','c','u','r','i','t','y',0}
static const WCHAR	prop_nameW [] = {'N','a','m','e',0}
static const WCHAR	method_createkeyW [] = {'C','r','e','a','t','e','K','e','y',0}
static const WCHAR	method_enumkeyW [] = {'E','n','u','m','K','e','y',0}
static const WCHAR	method_enumvaluesW [] = {'E','n','u','m','V','a','l','u','e','s',0}
static const WCHAR	method_getownerW [] = {'G','e','t','O','w','n','e','r',0}
static const WCHAR	method_getsdW [] = {'G','e','t','S','D',0}
static const WCHAR	method_getstringvalueW [] = {'G','e','t','S','t','r','i','n','g','V','a','l','u','e',0}
static const WCHAR	method_pauseserviceW [] = {'P','a','u','s','e','S','e','r','v','i','c','e',0}
static const WCHAR	method_resumeserviceW [] = {'R','e','s','u','m','e','S','e','r','v','i','c','e',0}
static const WCHAR	method_setsdW [] = {'S','e','t','S','D',0}
static const WCHAR	method_startserviceW [] = {'S','t','a','r','t','S','e','r','v','i','c','e',0}
static const WCHAR	method_stopserviceW [] = {'S','t','o','p','S','e','r','v','i','c','e',0}
static const WCHAR	param_defkeyW [] = {'h','D','e','f','K','e','y',0}
static const WCHAR	param_domainW [] = {'D','o','m','a','i','n',0}
static const WCHAR	param_namesW [] = {'s','N','a','m','e','s',0}
static const WCHAR	param_returnvalueW [] = {'R','e','t','u','r','n','V','a','l','u','e',0}
static const WCHAR	param_sdW [] = {'S','D',0}
static const WCHAR	param_subkeynameW [] = {'s','S','u','b','K','e','y','N','a','m','e',0}
static const WCHAR	param_typesW [] = {'T','y','p','e','s',0}
static const WCHAR	param_userW [] = {'U','s','e','r',0}
static const WCHAR	param_valueW [] = {'s','V','a','l','u','e',0}
static const WCHAR	param_valuenameW [] = {'s','V','a','l','u','e','N','a','m','e',0}

Macro Definition Documentation

CIM_TYPE_MASK

#define CIM_TYPE_MASK   0x00000fff

Definition at line 38 of file wbemprox_private.h.

COL_FLAG_DYNAMIC

#define COL_FLAG_DYNAMIC   0x00010000

Definition at line 41 of file wbemprox_private.h.

COL_FLAG_KEY

#define COL_FLAG_KEY   0x00020000

Definition at line 42 of file wbemprox_private.h.

COL_FLAG_METHOD

#define COL_FLAG_METHOD   0x00040000

Definition at line 43 of file wbemprox_private.h.

COL_TYPE_MASK

#define COL_TYPE_MASK   0x0000ffff

Definition at line 40 of file wbemprox_private.h.

TABLE_FLAG_DYNAMIC

#define TABLE_FLAG_DYNAMIC   0x00000001

Definition at line 106 of file wbemprox_private.h.

Typedef Documentation

class_method

typedef HRESULT() class_method(IWbemClassObject *, IWbemClassObject *, IWbemClassObject **)

Definition at line 45 of file wbemprox_private.h.

Enumeration Type Documentation

expr_type

enum expr_type

Enumerator
EXPR_COMPLEX
EXPR_UNARY
EXPR_PROPVAL
EXPR_SVAL
EXPR_IVAL
EXPR_BVAL
EXPR_VOID
EXPR_NUM
EXPR_HEXNUM
EXPR_DOUBLE
EXPR_IDENTIFIER
EXPR_NEG
EXPR_NOT
EXPR_PPTR
EXPR_CAST
EXPR_SIZEOF
EXPR_SHL
EXPR_SHR
EXPR_MUL
EXPR_DIV
EXPR_ADD
EXPR_SUB
EXPR_AND
EXPR_OR
EXPR_COND
EXPR_TRUEFALSE
EXPR_ADDRESSOF
EXPR_MEMBER
EXPR_ARRAY
EXPR_MOD
EXPR_LOGOR
EXPR_LOGAND
EXPR_XOR
EXPR_EQUALITY
EXPR_INEQUALITY
EXPR_GTR
EXPR_LESS
EXPR_GTREQL
EXPR_LESSEQL
EXPR_LOGNOT
EXPR_POS
EXPR_STRLIT
EXPR_WSTRLIT
EXPR_CHARCONST

Definition at line 71 of file wbemprox_private.h.

{
    EXPR_COMPLEX = 1,
    EXPR_UNARY   = 2,
    EXPR_PROPVAL = 3,
    EXPR_SVAL    = 4,
    EXPR_IVAL    = 5,
    EXPR_BVAL    = 6
};

fill_status

enum fill_status

Enumerator
FILL_STATUS_FAILED
FILL_STATUS_UNFILTERED
FILL_STATUS_FILTERED

Definition at line 99 of file wbemprox_private.h.

{
    FILL_STATUS_FAILED = -1,
    FILL_STATUS_UNFILTERED,
    FILL_STATUS_FILTERED
};

operator

enum operator

Enumerator
OP_EQ
OP_AND
OP_OR
OP_GT
OP_LT
OP_LE
OP_GE
OP_NE
OP_ISNULL
OP_NOTNULL
OP_LIKE
OP_NOT

Definition at line 47 of file wbemprox_private.h.

{
    OP_EQ      = 1,
    OP_AND     = 2,
    OP_OR      = 3,
    OP_GT      = 4,
    OP_LT      = 5,
    OP_LE      = 6,
    OP_GE      = 7,
    OP_NE      = 8,
    OP_ISNULL  = 9,
    OP_NOTNULL = 10,
    OP_LIKE    = 11,
    OP_NOT     = 12
};

param_direction

enum param_direction

Enumerator
PARAM_OUT
PARAM_INOUT
PARAM_IN

Definition at line 31 of file wbemprox_private.h.

{
    PARAM_OUT   = -1,
    PARAM_INOUT = 0,
    PARAM_IN    = 1
};

view_type

enum view_type

Enumerator
VIEW_TYPE_SELECT
VIEW_TYPE_ASSOCIATORS

Definition at line 161 of file wbemprox_private.h.

{
    VIEW_TYPE_SELECT,
    VIEW_TYPE_ASSOCIATORS,
};

Function Documentation

add_table()

BOOL add_table

(

struct table *

table

)

Definition at line 400 of file table.c.

{
    struct table *iter;
 
    LIST_FOR_EACH_ENTRY( iter, table_list, struct table, entry )
    {
        if (!wcsicmp( iter->name, table->name ))
        {
            TRACE("table %s already exists\n", debugstr_w(table->name));
            return FALSE;
        }
    }
    list_add_tail( table_list, &table->entry );
    TRACE("added %p\n", table);
    return TRUE;
}

Referenced by create_signature_table().

addref_query()

struct query * addref_query

(

struct query *

query

)

Definition at line 775 of file query.c.

{
    InterlockedIncrement( &query->refs );
    return query;
}

Referenced by EnumWbemClassObject_create().

addref_table()

struct table * addref_table

(

struct table *

table

)

Definition at line 359 of file table.c.

{
    InterlockedIncrement( &table->refs );
    return table;
}

Referenced by create_record(), get_antecedent_table(), and grab_table().

clear_table()

void clear_table

(

struct table *

table

)

Definition at line 314 of file table.c.

{
    UINT i;
 
    if (!table->data) return;
 
    for (i = 0; i < table->num_rows; i++) free_row_values( table, i );
    if (table->fill)
    {
        table->num_rows = 0;
        table->num_rows_allocated = 0;
        heap_free( table->data );
        table->data = NULL;
    }
}

Referenced by exec_select_view(), and free_table().

create_class_object()

HRESULT create_class_object	(	const WCHAR *	name,
		IEnumWbemClassObject *	iter,
		UINT	index,
		struct record *	record,
		IWbemClassObject **	obj
	)

Definition at line 1021 of file class.c.

{
    struct class_object *co;
 
    TRACE("%s, %p\n", debugstr_w(name), obj);
 
    co = heap_alloc( sizeof(*co) );
    if (!co) return E_OUTOFMEMORY;
 
    co->IWbemClassObject_iface.lpVtbl = &class_object_vtbl;
    co->refs  = 1;
    if (!name) co->name = NULL;
    else if (!(co->name = heap_strdupW( name )))
    {
        heap_free( co );
        return E_OUTOFMEMORY;
    }
    co->iter           = iter;
    co->index          = index;
    co->index_method   = 0;
    co->index_property = 0;
    co->record         = record;
    if (iter) IEnumWbemClassObject_AddRef( iter );
 
    *obj = &co->IWbemClassObject_iface;
 
    TRACE("returning iface %p\n", *obj);
    return S_OK;
}

Referenced by class_object_SpawnInstance(), enum_class_object_Next(), get_object(), get_qualifier_value(), qualifier_set_GetNames(), wbem_services_ExecMethod(), and wbem_services_GetObject().

create_query()

struct query * create_query

(

void

)

Definition at line 755 of file query.c.

{
    struct query *query;
 
    if (!(query = heap_alloc( sizeof(*query) ))) return NULL;
    list_init( &query->mem );
    query->refs = 1;
    return query;
}

Referenced by do_query(), and exec_query().

create_signature()

HRESULT create_signature	(	const WCHAR *	class,
		const WCHAR *	method,
		enum	param_direction,
		IWbemClassObject **	sig
	)

Definition at line 819 of file class.c.

{
    static const WCHAR selectW[] =
        {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
         '_','_','P','A','R','A','M','E','T','E','R','S',' ','W','H','E','R','E',' ',
         'C','l','a','s','s','=','\'','%','s','\'',' ','A','N','D',' ',
         'M','e','t','h','o','d','=','\'','%','s','\'',' ','A','N','D',' ',
         'D','i','r','e','c','t','i','o','n','%','s',0};
    static const WCHAR geW[] = {'>','=','0',0};
    static const WCHAR leW[] = {'<','=','0',0};
    UINT len = ARRAY_SIZE(selectW) + ARRAY_SIZE(geW);
    IEnumWbemClassObject *iter;
    WCHAR *query, *name;
    HRESULT hr;
 
    len += lstrlenW( class ) + lstrlenW( method );
    if (!(query = heap_alloc( len * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
    swprintf( query, selectW, class, method, dir >= 0 ? geW : leW );
 
    hr = exec_query( query, &iter );
    heap_free( query );
    if (hr != S_OK) return hr;
 
    if (!count_instances( iter ))
    {
        *sig = NULL;
        IEnumWbemClassObject_Release( iter );
        return S_OK;
    }
 
    if (!(name = build_signature_table_name( class, method, dir )))
    {
        IEnumWbemClassObject_Release( iter );
        return E_OUTOFMEMORY;
    }
    hr = create_signature_table( iter, name );
    IEnumWbemClassObject_Release( iter );
    if (hr == S_OK)
        hr = get_object( name, sig );
 
    heap_free( name );
    return hr;
}

Referenced by class_object_GetMethod(), class_object_NextMethod(), process_get_owner(), reg_create_key(), reg_enum_key(), reg_enum_values(), reg_get_stringvalue(), security_get_sd(), security_set_sd(), service_pause_service(), service_resume_service(), service_start_service(), and service_stop_service().

create_table()

struct table * create_table	(	const WCHAR *	,
		UINT	,
		const struct column *	,
		UINT	,
		UINT	,
		BYTE *	,
		enum	fill_status*)(struct table *, const struct expr *
	)

create_view()

HRESULT create_view	(	enum	view_type,
		const WCHAR *	path,
		const struct keyword *	keywordlist,
		const WCHAR *	class,
		const struct property *	proplist,
		const struct expr *	cond,
		struct view **	ret
	)

Definition at line 44 of file query.c.

{
    struct view *view = heap_alloc_zero( sizeof(*view) );
 
    if (!view) return E_OUTOFMEMORY;
 
    switch (type)
    {
    case VIEW_TYPE_ASSOCIATORS:
        view->path        = path;
        view->keywordlist = keywordlist;
        break;
 
    case VIEW_TYPE_SELECT:
    {
        struct table *table = grab_table( class );
        HRESULT hr;
 
        if (table && (hr = append_table( view, table )) != S_OK)
        {
            heap_free( view );
            return hr;
        }
        view->proplist = proplist;
        view->cond     = cond;
        break;
    }
    default:
        ERR( "unhandled type %u\n", type );
        heap_free( view );
        return E_INVALIDARG;
    }
 
    view->type = type;
    *ret = view;
    return S_OK;
}

destroy_array()

void destroy_array	(	struct array *	array,
		CIMTYPE	type
	)

Definition at line 240 of file class.c.

{
    UINT i;
    if (!array) return;
    if (type == CIM_STRING || type == CIM_DATETIME || type == CIM_REFERENCE)
    {
        for (i = 0; i < array->count; i++) heap_free( *(WCHAR **)((char *)array->ptr + i * array->elem_size) );
    }
    heap_free( array->ptr );
    heap_free( array );
}

Referenced by destroy_record(), free_row_values(), and to_array().

destroy_view()

void destroy_view

(

struct view *

view

)

Definition at line 83 of file query.c.

{
    ULONG i;
    if (!view) return;
    for (i = 0; i < view->table_count; i++) release_table( view->table[i] );
    heap_free( view->table );
    heap_free( view->result );
    heap_free( view );
}

Referenced by free_query().

EnumWbemClassObject_create()

HRESULT EnumWbemClassObject_create	(	struct query *	query,
		LPVOID *	ppObj
	)

Definition at line 199 of file class.c.

{
    struct enum_class_object *ec;
 
    TRACE("%p\n", ppObj);
 
    ec = heap_alloc( sizeof(*ec) );
    if (!ec) return E_OUTOFMEMORY;
 
    ec->IEnumWbemClassObject_iface.lpVtbl = &enum_class_object_vtbl;
    ec->refs  = 1;
    ec->query = addref_query( query );
    ec->index = 0;
 
    *ppObj = &ec->IEnumWbemClassObject_iface;
 
    TRACE("returning iface %p\n", *ppObj);
    return S_OK;
}

Referenced by enum_class_object_Clone(), exec_query(), and wbem_services_ExecMethod().

eval_cond()

HRESULT eval_cond	(	const struct table *	table,
		UINT	row,
		const struct expr *	cond,
		LONGLONG *	val,
		UINT *	type
	)

Definition at line 440 of file query.c.

{
    if (!cond)
    {
        *val = 1;
        *type = CIM_UINT64;
        return S_OK;
    }
    switch (cond->type)
    {
    case EXPR_COMPLEX:
        return eval_binary( table, row, &cond->u.expr, val, type );
 
    case EXPR_UNARY:
        return eval_unary( table, row, &cond->u.expr, val, type );
 
    case EXPR_PROPVAL:
        return eval_propval( table, row, cond->u.propval, val, type );
 
    case EXPR_SVAL:
        *val = (INT_PTR)cond->u.sval;
        *type = CIM_STRING;
        return S_OK;
 
    case EXPR_IVAL:
        *val = cond->u.ival;
        *type = CIM_UINT64;
        return S_OK;
 
    case EXPR_BVAL:
        *val = cond->u.ival;
        *type = CIM_BOOLEAN;
        return S_OK;
 
    default:
        ERR("invalid expression type\n");
        break;
    }
    return WBEM_E_INVALID_QUERY;
}

Referenced by eval_binary(), eval_unary(), exec_select_view(), and match_row().

exec_query()

HRESULT exec_query	(	const WCHAR *	str,
		IEnumWbemClassObject **	result
	)

Definition at line 786 of file query.c.

{
    HRESULT hr;
    struct query *query;
 
    *result = NULL;
    if (!(query = create_query())) return E_OUTOFMEMORY;
    hr = parse_query( str, &query->view, &query->mem );
    if (hr != S_OK) goto done;
    hr = execute_view( query->view );
    if (hr != S_OK) goto done;
    hr = EnumWbemClassObject_create( query, (void **)result );
 
done:
    release_query( query );
    return hr;
}

Referenced by async_exec_query(), create_assoc_enum(), create_instance_enum(), create_qualifier_enum(), create_signature(), get_antecedent(), test_associators(), test_select(), and wbem_services_ExecQuery().

execute_view()

HRESULT execute_view

(

struct view *

view

)

Definition at line 739 of file query.c.

{
    switch (view->type)
    {
    case VIEW_TYPE_ASSOCIATORS:
        return exec_assoc_view( view );
 
    case VIEW_TYPE_SELECT:
        return exec_select_view( view );
 
    default:
        ERR( "unhandled type %u\n", view->type );
        return E_INVALIDARG;
    }
}

Referenced by do_query(), exec_query(), get_diskdrivetodiskpartition_pairs(), get_logicaldisktopartition_pairs(), and wbem_services_ExecMethod().

free_columns()

void free_columns	(	struct column *	columns,
		UINT	num_cols
	)

Definition at line 330 of file table.c.

{
    UINT i;
 
    for (i = 0; i < num_cols; i++) { heap_free( (WCHAR *)columns[i].name ); }
    heap_free( columns );
}

Referenced by create_signature_table(), and free_table().

free_path()

void free_path

(

struct path *

path

)

Definition at line 413 of file services.c.

{
    if (!path) return;
    heap_free( path->class );
    heap_free( path->filter );
    heap_free( path );
}

Referenced by get_object(), wbem_services_CreateInstanceEnum(), and wbem_services_ExecMethod().

free_query()

void free_query

(

struct query *

query

)

Definition at line 765 of file query.c.

{
    struct list *mem, *next;
 
    if (!query) return;
    destroy_view( query->view );
    LIST_FOR_EACH_SAFE( mem, next, &query->mem ) { heap_free( mem ); }
    heap_free( query );
}

Referenced by get_diskdrivetodiskpartition_pairs(), get_logicaldisktopartition_pairs(), release_query(), and wbem_services_ExecMethod().

free_row_values()

void free_row_values	(	const struct table *	table,
		UINT	row
	)

Definition at line 292 of file table.c.

{
    UINT i, type;
    LONGLONG val;
 
    for (i = 0; i < table->num_cols; i++)
    {
        if (!(table->columns[i].type & COL_FLAG_DYNAMIC)) continue;
 
        type = table->columns[i].type & COL_TYPE_MASK;
        if (type == CIM_STRING || type == CIM_DATETIME || type == CIM_REFERENCE)
        {
            if (get_value( table, row, i, &val ) == S_OK) heap_free( (void *)(INT_PTR)val );
        }
        else if (type & CIM_FLAG_ARRAY)
        {
            if (get_value( table, row, i, &val ) == S_OK)
                destroy_array( (void *)(INT_PTR)val, type & CIM_TYPE_MASK );
        }
    }
}

Referenced by clear_table(), fill_baseboard(), fill_bios(), fill_cdromdrive(), fill_compsys(), fill_compsysproduct(), fill_datafile(), fill_directory(), fill_diskdrive(), fill_diskdrivetodiskpartition(), fill_diskpartition(), fill_displaycontrollerconfig(), fill_ip4routetable(), fill_logicaldisk(), fill_logicaldisktopartition(), fill_networkadapter(), fill_networkadapterconfig(), fill_operatingsystem(), fill_physicalmemory(), fill_pnpentity(), fill_printer(), fill_process(), fill_processor(), fill_service(), fill_systemenclosure(), and fill_videocontroller().

free_table()

void free_table

(

struct table *

table

)

Definition at line 338 of file table.c.

{
    if (!table) return;
 
    clear_table( table );
    if (table->flags & TABLE_FLAG_DYNAMIC)
    {
        TRACE("destroying %p\n", table);
        heap_free( (WCHAR *)table->name );
        free_columns( (struct column *)table->columns, table->num_cols );
        heap_free( table->data );
        list_remove( &table->entry );
        heap_free( table );
    }
}

get_column_index()

HRESULT get_column_index	(	const struct table *	table,
		const WCHAR *	name,
		UINT *	column
	)

Definition at line 35 of file table.c.

{
    UINT i;
    for (i = 0; i < table->num_cols; i++)
    {
        if (!wcsicmp( table->columns[i].name, name ))
        {
            *column = i;
            return S_OK;
        }
    }
    return WBEM_E_INVALID_QUERY;
}

Referenced by class_object_Get(), class_object_Put(), eval_propval(), eval_unary(), get_propval(), and put_propval().

get_method()

HRESULT get_method	(	const struct table *	table,
		const WCHAR *	name,
		class_method **	func
	)

Definition at line 269 of file table.c.

{
    UINT i, j;
 
    for (i = 0; i < table->num_rows; i++)
    {
        for (j = 0; j < table->num_cols; j++)
        {
            if (table->columns[j].type & COL_FLAG_METHOD && !wcscmp( table->columns[j].name, name ))
            {
                HRESULT hr;
                LONGLONG val;
 
                if ((hr = get_value( table, i, j, &val )) != S_OK) return hr;
                *func = (class_method *)(INT_PTR)val;
                return S_OK;
            }
        }
    }
    return WBEM_E_INVALID_METHOD;
 
}

Referenced by wbem_services_ExecMethod().

get_method_name()

BSTR get_method_name	(	const WCHAR *	class,
		UINT	index
	)

Definition at line 417 of file table.c.

{
    struct table *table;
    UINT i, count = 0;
    BSTR ret;
 
    if (!(table = grab_table( class ))) return NULL;
 
    for (i = 0; i < table->num_cols; i++)
    {
        if (table->columns[i].type & COL_FLAG_METHOD)
        {
            if (index == count)
            {
                ret = SysAllocString( table->columns[i].name );
                release_table( table );
                return ret;
            }
            count++;
        }
    }
    release_table( table );
    return NULL;
}

Referenced by class_object_NextMethod().

get_object()

HRESULT get_object	(	const WCHAR *	object_path,
		IWbemClassObject **	obj
	)

Definition at line 458 of file services.c.

{
    IEnumWbemClassObject *iter;
    struct path *path;
    HRESULT hr;
 
    hr = parse_path( object_path, &path );
    if (hr != S_OK) return hr;
 
    hr = create_instance_enum( path, &iter );
    if (hr != S_OK)
    {
        free_path( path );
        return hr;
    }
    hr = create_class_object( path->class, iter, 0, NULL, obj );
    IEnumWbemClassObject_Release( iter );
    free_path( path );
    return hr;
}

Referenced by wbem_services_GetObject().

get_properties()

HRESULT get_properties	(	const struct view *	view,
		UINT	index,
		LONG	flags,
		SAFEARRAY **	props
	)

Definition at line 1401 of file query.c.

{
    SAFEARRAY *sa;
    BSTR str;
    UINT i, table_index, result_index, num_props;
    struct table *table;
    HRESULT hr;
    LONG j;
 
    if ((hr = map_view_index( view, index, &table_index, &result_index )) != S_OK) return hr;
 
    num_props = count_result_properties( view, table_index );
    if (!(sa = SafeArrayCreateVector( VT_BSTR, 0, num_props ))) return E_OUTOFMEMORY;
 
    table = view->table[table_index];
    for (i = 0, j = 0; i < table->num_cols; i++)
    {
        BOOL is_system;
 
        if (is_method( table, i )) continue;
        if (!is_result_prop( view, table->columns[i].name )) continue;
 
        is_system = is_system_prop( table->columns[i].name );
        if ((flags & WBEM_FLAG_NONSYSTEM_ONLY) && is_system) continue;
        else if ((flags & WBEM_FLAG_SYSTEM_ONLY) && !is_system) continue;
 
        str = SysAllocString( table->columns[i].name );
        if (!str || SafeArrayPutElement( sa, &j, str ) != S_OK)
        {
            SysFreeString( str );
            SafeArrayDestroy( sa );
            return E_OUTOFMEMORY;
        }
        SysFreeString( str );
        j++;
    }
    *props = sa;
    return S_OK;
}

Referenced by class_object_GetNames().

get_propval()

HRESULT get_propval	(	const struct view *	view,
		UINT	index,
		const WCHAR *	name,
		VARIANT *	ret,
		CIMTYPE *	type,
		LONG *	flavor
	)

Definition at line 1177 of file query.c.

{
    HRESULT hr;
    UINT column, row, table_index, result_index;
    struct table *table;
    VARTYPE vartype;
    void *val_ptr = NULL;
    LONGLONG val;
 
    if ((hr = map_view_index( view, index, &table_index, &result_index )) != S_OK) return hr;
 
    if (is_system_prop( name )) return get_system_propval( view, table_index, result_index, name, ret, type, flavor );
    if (!view->result_count || !is_result_prop( view, name )) return WBEM_E_NOT_FOUND;
 
    table = view->table[table_index];
    hr = get_column_index( table, name, &column );
    if (hr != S_OK || is_method( table, column )) return WBEM_E_NOT_FOUND;
 
    row = view->result[result_index];
    hr = get_value( table, row, column, &val );
    if (hr != S_OK) return hr;
 
    if (type) *type = table->columns[column].type & COL_TYPE_MASK;
    if (flavor) *flavor = 0;
 
    if (!ret) return S_OK;
 
    vartype = to_vartype( table->columns[column].type & CIM_TYPE_MASK );
    if (table->columns[column].type & CIM_FLAG_ARRAY)
    {
        CIMTYPE basetype = table->columns[column].type & CIM_TYPE_MASK;
 
        val_ptr = to_safearray( (const struct array *)(INT_PTR)val, basetype );
        if (!val_ptr) vartype = VT_NULL;
        else vartype |= VT_ARRAY;
        set_variant( vartype, val, val_ptr, ret );
        return S_OK;
    }
 
    switch (table->columns[column].type & COL_TYPE_MASK)
    {
    case CIM_STRING:
    case CIM_REFERENCE:
    case CIM_DATETIME:
        if (val)
        {
            vartype = VT_BSTR;
            val_ptr = SysAllocString( (const WCHAR *)(INT_PTR)val );
        }
        else
            vartype = VT_NULL;
        break;
    case CIM_SINT64:
        vartype = VT_BSTR;
        val_ptr = get_value_bstr( table, row, column );
        break;
    case CIM_UINT64:
        vartype = VT_BSTR;
        val_ptr = get_value_bstr( table, row, column );
        break;
    case CIM_BOOLEAN:
    case CIM_SINT8:
    case CIM_UINT8:
    case CIM_SINT16:
    case CIM_UINT16:
    case CIM_SINT32:
    case CIM_UINT32:
    case CIM_REAL32:
        break;
    default:
        ERR("unhandled column type %u\n", table->columns[column].type);
        return WBEM_E_FAILED;
    }
 
    set_variant( vartype, val, val_ptr, ret );
    return S_OK;
}

Referenced by class_object_Get(), class_object_Next(), get_diskdrivetodiskpartition_pairs(), and get_logicaldisktopartition_pairs().

get_type_size()

UINT get_type_size

(

CIMTYPE

type

)

Definition at line 49 of file table.c.

{
    if (type & CIM_FLAG_ARRAY) return sizeof(void *);
 
    switch (type)
    {
    case CIM_BOOLEAN:
        return sizeof(int);
    case CIM_SINT8:
    case CIM_UINT8:
        return sizeof(INT8);
    case CIM_SINT16:
    case CIM_UINT16:
        return sizeof(INT16);
    case CIM_SINT32:
    case CIM_UINT32:
        return sizeof(INT32);
    case CIM_SINT64:
    case CIM_UINT64:
        return sizeof(INT64);
    case CIM_DATETIME:
    case CIM_REFERENCE:
    case CIM_STRING:
        return sizeof(WCHAR *);
    case CIM_REAL32:
        return sizeof(FLOAT);
    default:
        ERR("unhandled type %u\n", type);
        break;
    }
    return sizeof(LONGLONG);
}

Referenced by get_column_size().

get_value()

HRESULT get_value	(	const struct table *	table,
		UINT	row,
		UINT	column,
		LONGLONG *	val
	)

Definition at line 99 of file table.c.

{
    UINT col_offset, row_size;
    const BYTE *ptr;
 
    col_offset = get_column_offset( table, column );
    row_size = get_row_size( table );
    ptr = table->data + row * row_size + col_offset;
 
    if (table->columns[column].type & CIM_FLAG_ARRAY)
    {
        *val = (INT_PTR)*(const void **)ptr;
        return S_OK;
    }
    switch (table->columns[column].type & COL_TYPE_MASK)
    {
    case CIM_BOOLEAN:
        *val = *(const int *)ptr;
        break;
    case CIM_DATETIME:
    case CIM_REFERENCE:
    case CIM_STRING:
        *val = (INT_PTR)*(const WCHAR **)ptr;
        break;
    case CIM_SINT8:
        *val = *(const INT8 *)ptr;
        break;
    case CIM_UINT8:
        *val = *(const UINT8 *)ptr;
        break;
    case CIM_SINT16:
        *val = *(const INT16 *)ptr;
        break;
    case CIM_UINT16:
        *val = *(const UINT16 *)ptr;
        break;
    case CIM_SINT32:
        *val = *(const INT32 *)ptr;
        break;
    case CIM_UINT32:
        *val = *(const UINT32 *)ptr;
        break;
    case CIM_SINT64:
        *val = *(const INT64 *)ptr;
        break;
    case CIM_UINT64:
        *val = *(const UINT64 *)ptr;
        break;
    case CIM_REAL32:
        memcpy( val, ptr, sizeof(FLOAT) );
        break;
    default:
        ERR("invalid column type %u\n", table->columns[column].type & COL_TYPE_MASK);
        *val = 0;
        break;
    }
    return S_OK;
}

Referenced by eval_propval(), eval_unary(), free_row_values(), get_method(), get_propval(), and get_value_bstr().

get_value_bstr()

BSTR get_value_bstr	(	const struct table *	table,
		UINT	row,
		UINT	column
	)

Definition at line 158 of file table.c.

{
    static const WCHAR fmt_signedW[] = {'%','d',0};
    static const WCHAR fmt_unsignedW[] = {'%','u',0};
    static const WCHAR fmt_signed64W[] = {'%','I','6','4','d',0};
    static const WCHAR fmt_unsigned64W[] = {'%','I','6','4','u',0};
    static const WCHAR fmt_strW[] = {'\"','%','s','\"',0};
    static const WCHAR trueW[] = {'T','R','U','E',0};
    static const WCHAR falseW[] = {'F','A','L','S','E',0};
    LONGLONG val;
    BSTR ret;
    WCHAR number[22];
    UINT len;
 
    if (table->columns[column].type & CIM_FLAG_ARRAY)
    {
        FIXME("array to string conversion not handled\n");
        return NULL;
    }
    if (get_value( table, row, column, &val ) != S_OK) return NULL;
 
    switch (table->columns[column].type & COL_TYPE_MASK)
    {
    case CIM_BOOLEAN:
        if (val) return SysAllocString( trueW );
        else return SysAllocString( falseW );
 
    case CIM_DATETIME:
    case CIM_REFERENCE:
    case CIM_STRING:
        if (!val) return NULL;
        len = lstrlenW( (const WCHAR *)(INT_PTR)val ) + 2;
        if (!(ret = SysAllocStringLen( NULL, len ))) return NULL;
        swprintf( ret, fmt_strW, (const WCHAR *)(INT_PTR)val );
        return ret;
 
    case CIM_SINT16:
    case CIM_SINT32:
        swprintf( number, fmt_signedW, val );
        return SysAllocString( number );
 
    case CIM_UINT16:
    case CIM_UINT32:
        swprintf( number, fmt_unsignedW, val );
        return SysAllocString( number );
 
    case CIM_SINT64:
        wsprintfW( number, fmt_signed64W, val );
        return SysAllocString( number );
 
    case CIM_UINT64:
        wsprintfW( number, fmt_unsigned64W, val );
        return SysAllocString( number );
 
    default:
        FIXME("unhandled column type %u\n", table->columns[column].type & COL_TYPE_MASK);
        break;
    }
    return NULL;
}

Referenced by build_proplist(), get_body_text(), and get_propval().

get_view_table()

struct table * get_view_table	(	const struct view *	view,
		UINT	index
	)

Definition at line 1161 of file query.c.

{
    switch (view->type)
    {
    case VIEW_TYPE_SELECT:
        return view->table[0];
 
    case VIEW_TYPE_ASSOCIATORS:
        return view->table[index];
 
    default:
        ERR( "unhandled view type %u\n", view->type );
        return NULL;
    }
}

Referenced by class_object_Next(), class_object_SpawnInstance(), enum_class_object_Next(), get_object_text(), and wbem_services_ExecMethod().

grab_table()

struct table * grab_table

(

const WCHAR *

name

)

Definition at line 365 of file table.c.

{
    struct table *table;
 
    LIST_FOR_EACH_ENTRY( table, table_list, struct table, entry )
    {
        if (name && !wcsicmp( table->name, name ))
        {
            TRACE("returning %p\n", table);
            return addref_table( table );
        }
    }
    return NULL;
}

Referenced by create_view(), and get_method_name().

heap_strdupAW()

static WCHAR * heap_strdupAW ( const char *  src )

inlinestatic

Definition at line 270 of file wbemprox_private.h.

{
    int len;
    WCHAR *dst;
    if (!src) return NULL;
    len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 );
    if ((dst = heap_alloc( len * sizeof(*dst) ))) MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len );
    return dst;
}

Referenced by get_smbios_string().

heap_strdupW()

static WCHAR * heap_strdupW ( const WCHAR *  src )

inlinestatic

Definition at line 262 of file wbemprox_private.h.

{
    WCHAR *dst;
    if (!src) return NULL;
    if ((dst = heap_alloc( (lstrlenW( src ) + 1) * sizeof(WCHAR) ))) lstrcpyW( dst, src );
    return dst;
}

init_table_list()

void init_table_list

(

void

)

Definition at line 4605 of file builtin.c.

{
    static struct list tables = LIST_INIT( tables );
    UINT i;
 
    for (i = 0; i < ARRAY_SIZE(builtin_classes); i++) list_add_tail( &tables, &builtin_classes[i].entry );
    table_list = &tables;
}

Referenced by DllMain().

is_method()

BOOL is_method	(	const struct table *	table,
		UINT	column
	)

Definition at line 917 of file query.c.

{
    return table->columns[column].type & COL_FLAG_METHOD;
}

Referenced by class_object_Next(), count_properties(), get_properties(), get_propval(), and put_propval().

is_result_prop()

BOOL is_result_prop	(	const struct view *	view,
		const WCHAR *	name
	)

Definition at line 804 of file query.c.

{
    const struct property *prop = view->proplist;
    if (!prop) return TRUE;
    while (prop)
    {
        if (!wcsicmp( prop->name, name )) return TRUE;
        prop = prop->next;
    }
    return FALSE;
}

Referenced by class_object_Next(), get_properties(), and get_propval().

parse_path()

HRESULT parse_path	(	const WCHAR *	str,
		struct path **	ret
	)

Definition at line 326 of file services.c.

{
    struct path *path;
    const WCHAR *p = str, *q;
    UINT len;
 
    if (!(path = heap_alloc_zero( sizeof(*path) ))) return E_OUTOFMEMORY;
 
    if (*p == '\\')
    {
        static const WCHAR cimv2W[] = {'R','O','O','T','\\','C','I','M','V','2',0};
        WCHAR server[MAX_COMPUTERNAME_LENGTH+1];
        DWORD server_len = ARRAY_SIZE(server);
 
        p++;
        if (*p != '\\')
        {
            heap_free( path );
            return WBEM_E_INVALID_OBJECT_PATH;
        }
        p++;
 
        q = p;
        while (*p && *p != '\\') p++;
        if (!*p)
        {
            heap_free( path );
            return WBEM_E_INVALID_OBJECT_PATH;
        }
 
        len = p - q;
        if (!GetComputerNameW( server, &server_len ) || server_len != len || _wcsnicmp( q, server, server_len ))
        {
            heap_free( path );
            return WBEM_E_NOT_SUPPORTED;
        }
 
        q = ++p;
        while (*p && *p != ':') p++;
        if (!*p)
        {
            heap_free( path );
            return WBEM_E_INVALID_OBJECT_PATH;
        }
 
        len = p - q;
        if (len != ARRAY_SIZE(cimv2W) - 1 || _wcsnicmp( q, cimv2W, ARRAY_SIZE(cimv2W) - 1 ))
        {
            heap_free( path );
            return WBEM_E_INVALID_NAMESPACE;
        }
        p++;
    }
 
    q = p;
    while (*p && *p != '.') p++;
 
    len = p - q;
    if (!(path->class = heap_alloc( (len + 1) * sizeof(WCHAR) )))
    {
        heap_free( path );
        return E_OUTOFMEMORY;
    }
    memcpy( path->class, q, len * sizeof(WCHAR) );
    path->class[len] = 0;
    path->class_len = len;
 
    if (p[0] == '.' && p[1])
    {
        q = ++p;
        while (*q) q++;
 
        len = q - p;
        if (!(path->filter = heap_alloc( (len + 1) * sizeof(WCHAR) )))
        {
            heap_free( path->class );
            heap_free( path );
            return E_OUTOFMEMORY;
        }
        memcpy( path->filter, p, len * sizeof(WCHAR) );
        path->filter[len] = 0;
        path->filter_len = len;
    }
    *ret = path;
    return S_OK;
}

Referenced by get_object(), wbem_services_CreateInstanceEnum(), and wbem_services_ExecMethod().

parse_query()

HRESULT parse_query	(	const WCHAR *	,
		struct view **	,
		struct list *
	)

process_get_owner()

HRESULT process_get_owner	(	IWbemClassObject *	obj,
		IWbemClassObject *	in,
		IWbemClassObject **	out
	)

Definition at line 65 of file process.c.

{
    VARIANT user, domain, retval;
    IWbemClassObject *sig, *out_params = NULL;
    HRESULT hr;
 
    TRACE("%p, %p, %p\n", obj, in, out);
 
    hr = create_signature( class_processW, method_getownerW, PARAM_OUT, &sig );
    if (hr != S_OK) return hr;
 
    if (out)
    {
        hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
        if (hr != S_OK)
        {
            IWbemClassObject_Release( sig );
            return hr;
        }
    }
    VariantInit( &user );
    VariantInit( &domain );
    hr = get_owner( &user, &domain, &retval );
    if (hr != S_OK) goto done;
    if (out_params)
    {
        if (!V_UI4( &retval ))
        {
            hr = IWbemClassObject_Put( out_params, param_userW, 0, &user, CIM_STRING );
            if (hr != S_OK) goto done;
            hr = IWbemClassObject_Put( out_params, param_domainW, 0, &domain, CIM_STRING );
            if (hr != S_OK) goto done;
        }
        hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
    }
 
done:
    VariantClear( &user );
    VariantClear( &domain );
    IWbemClassObject_Release( sig );
    if (hr == S_OK && out)
    {
        *out = out_params;
        IWbemClassObject_AddRef( out_params );
    }
    if (out_params) IWbemClassObject_Release( out_params );
    return hr;
}

Referenced by fill_process().

put_propval()

HRESULT put_propval	(	const struct view *	view,
		UINT	index,
		const WCHAR *	name,
		VARIANT *	var,
		CIMTYPE	type
	)

Definition at line 1375 of file query.c.

{
    HRESULT hr;
    UINT row, column, table_index, result_index;
    struct table *table;
    LONGLONG val;
 
    if ((hr = map_view_index( view, index, &table_index, &result_index )) != S_OK) return hr;
 
    table = view->table[table_index];
    hr = get_column_index( table, name, &column );
    if (hr != S_OK)
    {
        FIXME("no support for creating new properties\n");
        return WBEM_E_FAILED;
    }
    if (is_method( table, column ) || !(table->columns[column].type & COL_FLAG_DYNAMIC))
        return WBEM_E_FAILED;
 
    hr = to_longlong( var, &val, &type );
    if (hr != S_OK) return hr;
 
    row = view->result[result_index];
    return set_value( table, row, column, val, type );
}

Referenced by class_object_Put().

query_from_path()

WCHAR * query_from_path

(

const struct path *

path

)

Definition at line 421 of file services.c.

{
    static const WCHAR selectW[] =
        {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','%','s',' ',
         'W','H','E','R','E',' ','%','s',0};
    static const WCHAR select_allW[] =
        {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',0};
    WCHAR *query;
    UINT len;
 
    if (path->filter)
    {
        len = path->class_len + path->filter_len + ARRAY_SIZE(selectW);
        if (!(query = heap_alloc( len * sizeof(WCHAR) ))) return NULL;
        swprintf( query, selectW, path->class, path->filter );
    }
    else
    {
        len = path->class_len + ARRAY_SIZE(select_allW);
        if (!(query = heap_alloc( len * sizeof(WCHAR) ))) return NULL;
        lstrcpyW( query, select_allW );
        lstrcatW( query, path->class );
    }
    return query;
}

Referenced by create_instance_enum(), get_antecedent_table(), and wbem_services_ExecMethod().

reg_create_key()

HRESULT reg_create_key	(	IWbemClassObject *	obj,
		IWbemClassObject *	in,
		IWbemClassObject **	out
	)

Definition at line 99 of file reg.c.

{
    VARIANT defkey, subkey, retval;
    IWbemClassObject *sig, *out_params = NULL;
    HRESULT hr;
 
    TRACE("%p, %p\n", in, out);
 
    hr = IWbemClassObject_Get( in, param_defkeyW, 0, &defkey, NULL, NULL );
    if (hr != S_OK) return hr;
    hr = IWbemClassObject_Get( in, param_subkeynameW, 0, &subkey, NULL, NULL );
    if (hr != S_OK) return hr;
 
    hr = create_signature( class_stdregprovW, method_createkeyW, PARAM_OUT, &sig );
    if (hr != S_OK)
    {
        VariantClear( &subkey );
        return hr;
    }
    if (out)
    {
        hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
        if (hr != S_OK)
        {
            VariantClear( &subkey );
            IWbemClassObject_Release( sig );
            return hr;
        }
    }
    hr = create_key( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), &retval );
    if (hr == S_OK && out_params)
        hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
 
    VariantClear( &subkey );
    IWbemClassObject_Release( sig );
    if (hr == S_OK && out)
    {
        *out = out_params;
        IWbemClassObject_AddRef( out_params );
    }
    if (out_params) IWbemClassObject_Release( out_params );
    return hr;
}

reg_enum_key()

HRESULT reg_enum_key	(	IWbemClassObject *	obj,
		IWbemClassObject *	in,
		IWbemClassObject **	out
	)

Definition at line 198 of file reg.c.

{
    VARIANT defkey, subkey, names, retval;
    IWbemClassObject *sig, *out_params = NULL;
    HRESULT hr;
 
    TRACE("%p, %p\n", in, out);
 
    hr = IWbemClassObject_Get( in, param_defkeyW, 0, &defkey, NULL, NULL );
    if (hr != S_OK) return hr;
    hr = IWbemClassObject_Get( in, param_subkeynameW, 0, &subkey, NULL, NULL );
    if (hr != S_OK) return hr;
 
    hr = create_signature( class_stdregprovW, method_enumkeyW, PARAM_OUT, &sig );
    if (hr != S_OK)
    {
        VariantClear( &subkey );
        return hr;
    }
    if (out)
    {
        hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
        if (hr != S_OK)
        {
            VariantClear( &subkey );
            IWbemClassObject_Release( sig );
            return hr;
        }
    }
    VariantInit( &names );
    hr = enum_key( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), &names, &retval );
    if (hr != S_OK) goto done;
    if (out_params)
    {
        if (!V_UI4( &retval ))
        {
            hr = IWbemClassObject_Put( out_params, param_namesW, 0, &names, CIM_STRING|CIM_FLAG_ARRAY );
            if (hr != S_OK) goto done;
        }
        hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
    }
 
done:
    VariantClear( &names );
    VariantClear( &subkey );
    IWbemClassObject_Release( sig );
    if (hr == S_OK && out)
    {
        *out = out_params;
        IWbemClassObject_AddRef( out_params );
    }
    if (out_params) IWbemClassObject_Release( out_params );
    return hr;
}

reg_enum_values()

HRESULT reg_enum_values	(	IWbemClassObject *	obj,
		IWbemClassObject *	in,
		IWbemClassObject **	out
	)

Definition at line 308 of file reg.c.

{
    VARIANT defkey, subkey, names, types, retval;
    IWbemClassObject *sig, *out_params = NULL;
    HRESULT hr;
 
    TRACE("%p, %p\n", in, out);
 
    hr = IWbemClassObject_Get( in, param_defkeyW, 0, &defkey, NULL, NULL );
    if (hr != S_OK) return hr;
    hr = IWbemClassObject_Get( in, param_subkeynameW, 0, &subkey, NULL, NULL );
    if (hr != S_OK) return hr;
 
    hr = create_signature( class_stdregprovW, method_enumvaluesW, PARAM_OUT, &sig );
    if (hr != S_OK)
    {
        VariantClear( &subkey );
        return hr;
    }
    if (out)
    {
        hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
        if (hr != S_OK)
        {
            VariantClear( &subkey );
            IWbemClassObject_Release( sig );
            return hr;
        }
    }
    VariantInit( &names );
    VariantInit( &types );
    hr = enum_values( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), &names, &types, &retval );
    if (hr != S_OK) goto done;
    if (out_params)
    {
        if (!V_UI4( &retval ))
        {
            hr = IWbemClassObject_Put( out_params, param_namesW, 0, &names, CIM_STRING|CIM_FLAG_ARRAY );
            if (hr != S_OK) goto done;
            hr = IWbemClassObject_Put( out_params, param_typesW, 0, &types, CIM_SINT32|CIM_FLAG_ARRAY );
            if (hr != S_OK) goto done;
        }
        hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
    }
 
done:
    VariantClear( &types );
    VariantClear( &names );
    VariantClear( &subkey );
    IWbemClassObject_Release( sig );
    if (hr == S_OK && out)
    {
        *out = out_params;
        IWbemClassObject_AddRef( out_params );
    }
    if (out_params) IWbemClassObject_Release( out_params );
    return hr;
}

reg_get_stringvalue()

HRESULT reg_get_stringvalue	(	IWbemClassObject *	obj,
		IWbemClassObject *	in,
		IWbemClassObject **	out
	)

Definition at line 391 of file reg.c.

{
    VARIANT defkey, subkey, name, value, retval;
    IWbemClassObject *sig, *out_params = NULL;
    HRESULT hr;
 
    TRACE("%p, %p\n", in, out);
 
    hr = IWbemClassObject_Get( in, param_defkeyW, 0, &defkey, NULL, NULL );
    if (hr != S_OK) return hr;
    hr = IWbemClassObject_Get( in, param_subkeynameW, 0, &subkey, NULL, NULL );
    if (hr != S_OK) return hr;
    hr = IWbemClassObject_Get( in, param_valuenameW, 0, &name, NULL, NULL );
    if (hr != S_OK) return hr;
 
    hr = create_signature( class_stdregprovW, method_getstringvalueW, PARAM_OUT, &sig );
    if (hr != S_OK)
    {
        VariantClear( &name );
        VariantClear( &subkey );
        return hr;
    }
    if (out)
    {
        hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
        if (hr != S_OK)
        {
            VariantClear( &name );
            VariantClear( &subkey );
            IWbemClassObject_Release( sig );
            return hr;
        }
    }
    VariantInit( &value );
    hr = get_stringvalue( (HKEY)(INT_PTR)V_I4(&defkey), V_BSTR(&subkey), V_BSTR(&name), &value, &retval );
    if (hr != S_OK) goto done;
    if (out_params)
    {
        if (!V_UI4( &retval ))
        {
            hr = IWbemClassObject_Put( out_params, param_valueW, 0, &value, CIM_STRING );
            if (hr != S_OK) goto done;
        }
        hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
    }
 
done:
    VariantClear( &name );
    VariantClear( &subkey );
    IWbemClassObject_Release( sig );
    if (hr == S_OK && out)
    {
        *out = out_params;
        IWbemClassObject_AddRef( out_params );
    }
    if (out_params) IWbemClassObject_Release( out_params );
    return hr;
}

release_query()

void release_query

(

struct query *

query

)

Definition at line 781 of file query.c.

{
    if (!InterlockedDecrement( &query->refs )) free_query( query );
}

Referenced by do_query(), enum_class_object_Release(), exec_query(), and get_antecedent_table().

release_table()

void release_table

(

struct table *

table

)

Definition at line 354 of file table.c.

{
    if (!InterlockedDecrement( &table->refs )) free_table( table );
}

Referenced by destroy_record(), destroy_view(), exec_assoc_view(), and get_method_name().

security_get_sd()

HRESULT security_get_sd	(	IWbemClassObject *	obj,
		IWbemClassObject *	in,
		IWbemClassObject **	out
	)

Definition at line 132 of file security.c.

{
    VARIANT var_sd, retval;
    IWbemClassObject *sig, *out_params = NULL;
    HRESULT hr, ret;
    SECURITY_DESCRIPTOR *sd;
    DWORD sd_size;
 
    TRACE("%p, %p\n", in, out);
 
    hr = create_signature( class_systemsecurityW, method_getsdW, PARAM_OUT, &sig );
 
    if (SUCCEEDED(hr))
    {
        hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 
        IWbemClassObject_Release( sig );
    }
 
    if (SUCCEEDED(hr))
    {
        ret = get_sd( &sd, &sd_size );
 
        if (SUCCEEDED(ret))
        {
            VariantInit( &var_sd );
 
            hr = to_byte_array( sd, sd_size, &var_sd );
 
            if (SUCCEEDED(hr))
                hr = IWbemClassObject_Put( out_params, param_sdW, 0, &var_sd, CIM_UINT8|CIM_FLAG_ARRAY );
 
            HeapFree( GetProcessHeap(), 0, sd );
            VariantClear( &var_sd );
        }
 
        if (SUCCEEDED(hr))
        {
            set_variant( VT_UI4, ret, NULL, &retval );
            hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
        }
 
        if (SUCCEEDED(hr) && out)
        {
            *out = out_params;
            IWbemClassObject_AddRef( out_params );
        }
 
        IWbemClassObject_Release( out_params );
    }
 
    return hr;
}

security_set_sd()

HRESULT security_set_sd	(	IWbemClassObject *	obj,
		IWbemClassObject *	in,
		IWbemClassObject **	out
	)

Definition at line 187 of file security.c.

{
    VARIANT retval;
    IWbemClassObject *sig, *out_params = NULL;
    HRESULT hr;
 
    FIXME("stub\n");
 
    hr = create_signature( class_systemsecurityW, method_setsdW, PARAM_OUT, &sig );
 
    if (SUCCEEDED(hr))
    {
        hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
 
        IWbemClassObject_Release( sig );
    }
 
    if (SUCCEEDED(hr))
    {
        set_variant( VT_UI4, S_OK, NULL, &retval );
        hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
 
        if (SUCCEEDED(hr) && out)
        {
            *out = out_params;
            IWbemClassObject_AddRef( out_params );
        }
 
        IWbemClassObject_Release( out_params );
    }
 
    return hr;
}

service_pause_service()

HRESULT service_pause_service	(	IWbemClassObject *	obj,
		IWbemClassObject *	in,
		IWbemClassObject **	out
	)

Definition at line 79 of file service.c.

{
    VARIANT name, retval;
    IWbemClassObject *sig, *out_params = NULL;
    HRESULT hr;
 
    TRACE("%p, %p, %p\n", obj, in, out);
 
    hr = IWbemClassObject_Get( obj, prop_nameW, 0, &name, NULL, NULL );
    if (hr != S_OK) return hr;
 
    hr = create_signature( class_serviceW, method_pauseserviceW, PARAM_OUT, &sig );
    if (hr != S_OK)
    {
        VariantClear( &name );
        return hr;
    }
    if (out)
    {
        hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
        if (hr != S_OK)
        {
            VariantClear( &name );
            IWbemClassObject_Release( sig );
            return hr;
        }
    }
    hr = control_service( V_BSTR(&name), SERVICE_CONTROL_PAUSE, &retval );
    if (hr != S_OK) goto done;
 
    if (out_params)
        hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
 
done:
    VariantClear( &name );
    IWbemClassObject_Release( sig );
    if (hr == S_OK && out)
    {
        *out = out_params;
        IWbemClassObject_AddRef( out_params );
    }
    if (out_params) IWbemClassObject_Release( out_params );
    return hr;
}

Referenced by fill_service().

service_resume_service()

HRESULT service_resume_service	(	IWbemClassObject *	obj,
		IWbemClassObject *	in,
		IWbemClassObject **	out
	)

Definition at line 124 of file service.c.

{
    VARIANT name, retval;
    IWbemClassObject *sig, *out_params = NULL;
    HRESULT hr;
 
    TRACE("%p, %p, %p\n", obj, in, out);
 
    hr = IWbemClassObject_Get( obj, prop_nameW, 0, &name, NULL, NULL );
    if (hr != S_OK) return hr;
 
    hr = create_signature( class_serviceW, method_resumeserviceW, PARAM_OUT, &sig );
    if (hr != S_OK)
    {
        VariantClear( &name );
        return hr;
    }
    if (out)
    {
        hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
        if (hr != S_OK)
        {
            VariantClear( &name );
            IWbemClassObject_Release( sig );
            return hr;
        }
    }
    hr = control_service( V_BSTR(&name), SERVICE_CONTROL_CONTINUE, &retval );
    if (hr != S_OK) goto done;
 
    if (out_params)
        hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
 
done:
    VariantClear( &name );
    IWbemClassObject_Release( sig );
    if (hr == S_OK && out)
    {
        *out = out_params;
        IWbemClassObject_AddRef( out_params );
    }
    if (out_params) IWbemClassObject_Release( out_params );
    return hr;
}

Referenced by fill_service().

service_start_service()

HRESULT service_start_service	(	IWbemClassObject *	obj,
		IWbemClassObject *	in,
		IWbemClassObject **	out
	)

Definition at line 193 of file service.c.

{
    VARIANT name, retval;
    IWbemClassObject *sig, *out_params = NULL;
    HRESULT hr;
 
    TRACE("%p, %p, %p\n", obj, in, out);
 
    hr = IWbemClassObject_Get( obj, prop_nameW, 0, &name, NULL, NULL );
    if (hr != S_OK) return hr;
 
    hr = create_signature( class_serviceW, method_startserviceW, PARAM_OUT, &sig );
    if (hr != S_OK)
    {
        VariantClear( &name );
        return hr;
    }
    if (out)
    {
        hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
        if (hr != S_OK)
        {
            VariantClear( &name );
            IWbemClassObject_Release( sig );
            return hr;
        }
    }
    hr = start_service( V_BSTR(&name), &retval );
    if (hr != S_OK) goto done;
 
    if (out_params)
        hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
 
done:
    VariantClear( &name );
    IWbemClassObject_Release( sig );
    if (hr == S_OK && out)
    {
        *out = out_params;
        IWbemClassObject_AddRef( out_params );
    }
    if (out_params) IWbemClassObject_Release( out_params );
    return hr;
}

Referenced by fill_service().

service_stop_service()

HRESULT service_stop_service	(	IWbemClassObject *	obj,
		IWbemClassObject *	in,
		IWbemClassObject **	out
	)

Definition at line 238 of file service.c.

{
    VARIANT name, retval;
    IWbemClassObject *sig, *out_params = NULL;
    HRESULT hr;
 
    TRACE("%p, %p, %p\n", obj, in, out);
 
    hr = IWbemClassObject_Get( obj, prop_nameW, 0, &name, NULL, NULL );
    if (hr != S_OK) return hr;
 
    hr = create_signature( class_serviceW, method_stopserviceW, PARAM_OUT, &sig );
    if (hr != S_OK)
    {
        VariantClear( &name );
        return hr;
    }
    if (out)
    {
        hr = IWbemClassObject_SpawnInstance( sig, 0, &out_params );
        if (hr != S_OK)
        {
            VariantClear( &name );
            IWbemClassObject_Release( sig );
            return hr;
        }
    }
    hr = control_service( V_BSTR(&name), SERVICE_CONTROL_STOP, &retval );
    if (hr != S_OK) goto done;
 
    if (out_params)
        hr = IWbemClassObject_Put( out_params, param_returnvalueW, 0, &retval, CIM_UINT32 );
 
done:
    VariantClear( &name );
    IWbemClassObject_Release( sig );
    if (hr == S_OK && out)
    {
        *out = out_params;
        IWbemClassObject_AddRef( out_params );
    }
    if (out_params) IWbemClassObject_Release( out_params );
    return hr;
}

Referenced by fill_service().

set_value()

HRESULT set_value	(	const struct table *	table,
		UINT	row,
		UINT	column,
		LONGLONG	val,
		CIMTYPE	type
	)

Definition at line 219 of file table.c.

{
    UINT col_offset, row_size;
    BYTE *ptr;
 
    if ((table->columns[column].type & COL_TYPE_MASK) != type) return WBEM_E_TYPE_MISMATCH;
 
    col_offset = get_column_offset( table, column );
    row_size = get_row_size( table );
    ptr = table->data + row * row_size + col_offset;
 
    switch (table->columns[column].type & COL_TYPE_MASK)
    {
    case CIM_DATETIME:
    case CIM_REFERENCE:
    case CIM_STRING:
        *(WCHAR **)ptr = (WCHAR *)(INT_PTR)val;
        break;
    case CIM_SINT8:
        *(INT8 *)ptr = val;
        break;
    case CIM_UINT8:
        *(UINT8 *)ptr = val;
        break;
    case CIM_SINT16:
        *(INT16 *)ptr = val;
        break;
    case CIM_UINT16:
        *(UINT16 *)ptr = val;
        break;
    case CIM_SINT32:
        *(INT32 *)ptr = val;
        break;
    case CIM_UINT32:
        *(UINT32 *)ptr = val;
        break;
    case CIM_SINT64:
        *(INT64 *)ptr = val;
        break;
    case CIM_UINT64:
        *(UINT64 *)ptr = val;
        break;
    default:
        FIXME("unhandled column type %u\n", type);
        return WBEM_E_FAILED;
    }
    return S_OK;
}

set_variant()

void set_variant	(	VARTYPE	type,
		LONGLONG	val,
		void *	val_ptr,
		VARIANT *	ret
	)

Definition at line 1093 of file query.c.

{
    if (type & VT_ARRAY)
    {
        V_VT( ret ) = type;
        V_ARRAY( ret ) = val_ptr;
        return;
    }
    switch (type)
    {
    case VT_BOOL:
        V_BOOL( ret ) = val;
        break;
    case VT_BSTR:
        V_BSTR( ret ) = val_ptr;
        break;
    case VT_I1:
        V_I1( ret ) = val;
        break;
    case VT_UI1:
        V_UI1( ret ) = val;
        break;
    case VT_I2:
        V_I2( ret ) = val;
        break;
    case VT_UI2:
        V_UI2( ret ) = val;
        break;
    case VT_I4:
        V_I4( ret ) = val;
        break;
    case VT_UI4:
        V_UI4( ret ) = val;
        break;
    case VT_NULL:
        break;
    case VT_R4:
        V_R4( ret ) = *(FLOAT *)&val;
        break;
    default:
        ERR("unhandled variant type %u\n", type);
        return;
    }
    V_VT( ret ) = type;
}

Referenced by control_service(), create_key(), enum_key(), enum_values(), get_owner(), get_propval(), get_stringvalue(), security_get_sd(), security_set_sd(), start_service(), to_bstr_array(), to_byte_array(), and to_i4_array().

to_longlong()

HRESULT to_longlong	(	VARIANT *	var,
		LONGLONG *	val,
		CIMTYPE *	type
	)

Definition at line 1325 of file query.c.

{
    if (!var)
    {
        *val = 0;
        return S_OK;
    }
    if (V_VT( var ) & VT_ARRAY)
    {
        *val = (INT_PTR)to_array( var, type );
        if (!*val) return E_OUTOFMEMORY;
        return S_OK;
    }
    switch (V_VT( var ))
    {
    case VT_BOOL:
        *val = V_BOOL( var );
        *type = CIM_BOOLEAN;
        break;
    case VT_BSTR:
        *val = (INT_PTR)heap_strdupW( V_BSTR( var ) );
        if (!*val) return E_OUTOFMEMORY;
        *type = CIM_STRING;
        break;
    case VT_I2:
        *val = V_I2( var );
        *type = CIM_SINT16;
        break;
    case VT_UI2:
        *val = V_UI2( var );
        *type = CIM_UINT16;
        break;
    case VT_I4:
        *val = V_I4( var );
        *type = CIM_SINT32;
        break;
    case VT_UI4:
        *val = V_UI4( var );
        *type = CIM_UINT32;
        break;
    case VT_NULL:
        *val = 0;
        break;
    default:
        ERR("unhandled type %u\n", V_VT( var ));
        return WBEM_E_FAILED;
    }
    return S_OK;
}

Referenced by put_propval(), and record_set_value().

to_safearray()

SAFEARRAY * to_safearray	(	const struct array *	array,
		CIMTYPE	basetype
	)

Definition at line 1062 of file query.c.

{
    SAFEARRAY *ret;
    VARTYPE vartype = to_vartype( basetype );
    LONG i;
 
    if (!array || !(ret = SafeArrayCreateVector( vartype, 0, array->count ))) return NULL;
 
    for (i = 0; i < array->count; i++)
    {
        void *ptr = (char *)array->ptr + i * array->elem_size;
        if (vartype == VT_BSTR)
        {
            BSTR str = SysAllocString( *(const WCHAR **)ptr );
            if (!str || SafeArrayPutElement( ret, &i, str ) != S_OK)
            {
                SysFreeString( str );
                SafeArrayDestroy( ret );
                return NULL;
            }
            SysFreeString( str );
        }
        else if (SafeArrayPutElement( ret, &i, ptr ) != S_OK)
        {
            SafeArrayDestroy( ret );
            return NULL;
        }
    }
    return ret;
}

Referenced by get_propval(), and record_get_value().

to_vartype()

VARTYPE to_vartype

(

CIMTYPE

type

)

Definition at line 1032 of file query.c.

{
    switch (type)
    {
    case CIM_BOOLEAN:   return VT_BOOL;
 
    case CIM_STRING:
    case CIM_REFERENCE:
    case CIM_DATETIME:  return VT_BSTR;
 
    case CIM_SINT8:     return VT_I1;
    case CIM_UINT8:     return VT_UI1;
    case CIM_SINT16:    return VT_I2;
 
    case CIM_UINT16:
    case CIM_SINT32:
    case CIM_UINT32:    return VT_I4;
 
    case CIM_SINT64:    return VT_I8;
    case CIM_UINT64:    return VT_UI8;
 
    case CIM_REAL32:    return VT_R4;
 
    default:
        ERR("unhandled type %u\n", type);
        break;
    }
    return 0;
}

Referenced by get_propval(), record_get_value(), and to_safearray().

WbemLocator_create()

HRESULT WbemLocator_create

(

LPVOID *

ppObj

)

Definition at line 212 of file wbemlocator.c.

{
    wbem_locator *wl;
 
    TRACE("(%p)\n", ppObj);
 
    wl = heap_alloc( sizeof(*wl) );
    if (!wl) return E_OUTOFMEMORY;
 
    wl->IWbemLocator_iface.lpVtbl = &wbem_locator_vtbl;
    wl->refs = 1;
 
    *ppObj = &wl->IWbemLocator_iface;
 
    TRACE("returning iface %p\n", *ppObj);
    return S_OK;
}

WbemQualifierSet_create()

HRESULT WbemQualifierSet_create	(	const WCHAR *	class,
		const WCHAR *	member,
		LPVOID *	ppObj
	)

Definition at line 293 of file qualifier.c.

{
    struct qualifier_set *set;
 
    TRACE("%p\n", ppObj);
 
    if (!(set = heap_alloc( sizeof(*set) ))) return E_OUTOFMEMORY;
 
    set->IWbemQualifierSet_iface.lpVtbl = &qualifier_set_vtbl;
    if (!(set->class = heap_strdupW( class )))
    {
        heap_free( set );
        return E_OUTOFMEMORY;
    }
    if (!member) set->member = NULL;
    else if (!(set->member = heap_strdupW( member )))
    {
        heap_free( set->class );
        heap_free( set );
        return E_OUTOFMEMORY;
    }
    set->refs = 1;
 
    *ppObj = &set->IWbemQualifierSet_iface;
 
    TRACE("returning iface %p\n", *ppObj);
    return S_OK;
}

Referenced by class_object_GetPropertyQualifierSet(), and class_object_GetQualifierSet().

WbemServices_create()

HRESULT WbemServices_create	(	const WCHAR *	namespace,
		LPVOID *	ppObj
	)

Definition at line 925 of file services.c.

{
    struct wbem_services *ws;
 
    TRACE("(%p)\n", ppObj);
 
    ws = heap_alloc( sizeof(*ws) );
    if (!ws) return E_OUTOFMEMORY;
 
    ws->IWbemServices_iface.lpVtbl = &wbem_services_vtbl;
    ws->refs      = 1;
    ws->namespace = heap_strdupW( namespace );
    ws->async     = NULL;
    InitializeCriticalSection( &ws->cs );
    ws->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": wbemprox_services.cs");
 
    *ppObj = &ws->IWbemServices_iface;
 
    TRACE("returning iface %p\n", *ppObj);
    return S_OK;
}

Referenced by wbem_locator_ConnectServer(), and wbem_services_OpenNamespace().

Variable Documentation

class_processW

const WCHAR class_processW[] = {'W','i','n','3','2','_','P','r','o','c','e','s','s',0}

static

Definition at line 280 of file wbemprox_private.h.

Referenced by process_get_owner().

class_serviceW

const WCHAR class_serviceW[] = {'W','i','n','3','2','_','S','e','r','v','i','c','e',0}

static

Definition at line 281 of file wbemprox_private.h.

Referenced by service_pause_service(), service_resume_service(), service_start_service(), and service_stop_service().

class_stdregprovW

const WCHAR class_stdregprovW[] = {'S','t','d','R','e','g','P','r','o','v',0}

static

Definition at line 282 of file wbemprox_private.h.

Referenced by reg_create_key(), reg_enum_key(), reg_enum_values(), and reg_get_stringvalue().

class_systemsecurityW

const WCHAR class_systemsecurityW[] = {'_','_','S','y','s','t','e','m','S','e','c','u','r','i','t','y',0}

static

Definition at line 283 of file wbemprox_private.h.

Referenced by security_get_sd(), and security_set_sd().

DECLSPEC_HIDDEN

struct list* table_list DECLSPEC_HIDDEN

extern

Definition at line 29 of file wbemprox_private.h.

method_createkeyW

const WCHAR method_createkeyW[] = {'C','r','e','a','t','e','K','e','y',0}

static

Definition at line 287 of file wbemprox_private.h.

Referenced by reg_create_key().

method_enumkeyW

const WCHAR method_enumkeyW[] = {'E','n','u','m','K','e','y',0}

static

Definition at line 288 of file wbemprox_private.h.

Referenced by reg_enum_key().

method_enumvaluesW

const WCHAR method_enumvaluesW[] = {'E','n','u','m','V','a','l','u','e','s',0}

static

Definition at line 289 of file wbemprox_private.h.

Referenced by reg_enum_values().

method_getownerW

const WCHAR method_getownerW[] = {'G','e','t','O','w','n','e','r',0}

static

Definition at line 290 of file wbemprox_private.h.

Referenced by process_get_owner().

method_getsdW

const WCHAR method_getsdW[] = {'G','e','t','S','D',0}

static

Definition at line 291 of file wbemprox_private.h.

Referenced by security_get_sd().

method_getstringvalueW

const WCHAR method_getstringvalueW[] = {'G','e','t','S','t','r','i','n','g','V','a','l','u','e',0}

static

Definition at line 292 of file wbemprox_private.h.

Referenced by reg_get_stringvalue().

method_pauseserviceW

const WCHAR method_pauseserviceW[] = {'P','a','u','s','e','S','e','r','v','i','c','e',0}

static

Definition at line 293 of file wbemprox_private.h.

Referenced by service_pause_service().

method_resumeserviceW

const WCHAR method_resumeserviceW[] = {'R','e','s','u','m','e','S','e','r','v','i','c','e',0}

static

Definition at line 294 of file wbemprox_private.h.

Referenced by service_resume_service().

method_setsdW

const WCHAR method_setsdW[] = {'S','e','t','S','D',0}

static

Definition at line 295 of file wbemprox_private.h.

Referenced by security_set_sd().

method_startserviceW

const WCHAR method_startserviceW[] = {'S','t','a','r','t','S','e','r','v','i','c','e',0}

static

Definition at line 296 of file wbemprox_private.h.

Referenced by service_start_service().

method_stopserviceW

const WCHAR method_stopserviceW[] = {'S','t','o','p','S','e','r','v','i','c','e',0}

static

Definition at line 297 of file wbemprox_private.h.

Referenced by service_stop_service().

param_defkeyW

const WCHAR param_defkeyW[] = {'h','D','e','f','K','e','y',0}

static

Definition at line 299 of file wbemprox_private.h.

Referenced by reg_create_key(), reg_enum_key(), reg_enum_values(), and reg_get_stringvalue().

param_domainW

const WCHAR param_domainW[] = {'D','o','m','a','i','n',0}

static

Definition at line 300 of file wbemprox_private.h.

Referenced by process_get_owner().

param_namesW

const WCHAR param_namesW[] = {'s','N','a','m','e','s',0}

static

Definition at line 301 of file wbemprox_private.h.

Referenced by reg_enum_key(), and reg_enum_values().

param_returnvalueW

const WCHAR param_returnvalueW[] = {'R','e','t','u','r','n','V','a','l','u','e',0}

static

Definition at line 302 of file wbemprox_private.h.

Referenced by process_get_owner(), reg_create_key(), reg_enum_key(), reg_enum_values(), reg_get_stringvalue(), security_get_sd(), security_set_sd(), service_pause_service(), service_resume_service(), service_start_service(), and service_stop_service().

param_sdW

const WCHAR param_sdW[] = {'S','D',0}

static

Definition at line 303 of file wbemprox_private.h.

Referenced by security_get_sd().

param_subkeynameW

const WCHAR param_subkeynameW[] = {'s','S','u','b','K','e','y','N','a','m','e',0}

static

Definition at line 304 of file wbemprox_private.h.

Referenced by reg_create_key(), reg_enum_key(), reg_enum_values(), and reg_get_stringvalue().

param_typesW

const WCHAR param_typesW[] = {'T','y','p','e','s',0}

static

Definition at line 305 of file wbemprox_private.h.

Referenced by reg_enum_values().

param_userW

const WCHAR param_userW[] = {'U','s','e','r',0}

static

Definition at line 306 of file wbemprox_private.h.

Referenced by process_get_owner().

param_valuenameW

const WCHAR param_valuenameW[] = {'s','V','a','l','u','e','N','a','m','e',0}

static

Definition at line 308 of file wbemprox_private.h.

Referenced by reg_get_stringvalue().

param_valueW

const WCHAR param_valueW[] = {'s','V','a','l','u','e',0}

static

Definition at line 307 of file wbemprox_private.h.

Referenced by reg_get_stringvalue().

prop_nameW

const WCHAR prop_nameW[] = {'N','a','m','e',0}

static

Definition at line 285 of file wbemprox_private.h.

Referenced by seed_dirs(), service_pause_service(), service_resume_service(), service_start_service(), and service_stop_service().