summaryrefslogtreecommitdiff
path: root/source4/lib/wmi
diff options
context:
space:
mode:
Diffstat (limited to 'source4/lib/wmi')
-rw-r--r--source4/lib/wmi/config.mk81
-rw-r--r--source4/lib/wmi/pywmi.i371
-rw-r--r--source4/lib/wmi/tools/wmic.c234
-rw-r--r--source4/lib/wmi/tools/wmis.c229
-rw-r--r--source4/lib/wmi/wbemdata.c692
-rw-r--r--source4/lib/wmi/wmicore.c225
6 files changed, 1832 insertions, 0 deletions
diff --git a/source4/lib/wmi/config.mk b/source4/lib/wmi/config.mk
new file mode 100644
index 0000000000..1899822ff0
--- /dev/null
+++ b/source4/lib/wmi/config.mk
@@ -0,0 +1,81 @@
+#################################
+# Start BINARY wmic
+[BINARY::wmic]
+PRIVATE_PROTO_HEADER = proto.h
+INSTALLDIR = BINDIR
+OBJ_FILES = \
+ wmic.o \
+ wmicore.o \
+ wbemdata.o \
+ ../librpc/gen_ndr/dcom_p.o
+PRIVATE_DEPENDENCIES = \
+ POPT_SAMBA \
+ POPT_CREDENTIALS \
+ LIBPOPT \
+ RPC_NDR_OXIDRESOLVER \
+ NDR_DCOM \
+ RPC_NDR_REMACT \
+ NDR_TABLE \
+ DCOM_PROXY_DCOM \
+ dcom
+# End BINARY wmic
+#################################
+
+#################################
+# Start BINARY wmis
+[BINARY::wmis]
+INSTALLDIR = BINDIR
+OBJ_FILES = \
+ wmis.o \
+ wmicore.o \
+ wbemdata.o \
+ ../librpc/gen_ndr/dcom_p.o
+PRIVATE_DEPENDENCIES = \
+ POPT_SAMBA \
+ POPT_CREDENTIALS \
+ LIBPOPT \
+ RPC_NDR_OXIDRESOLVER \
+ NDR_DCOM \
+ RPC_NDR_REMACT \
+ NDR_TABLE \
+ DCOM_PROXY_DCOM \
+ dcom
+# End BINARY wmis
+#################################
+
+librpc/gen_ndr/dcom_p.c: idl
+
+#######################
+# Start LIBRARY swig_dcerpc
+[LIBRARY::pywmi]
+LIBRARY_REALNAME = _pywmi.$(SHLIBEXT)
+PUBLIC_DEPENDENCIES = LIBCLI_SMB NDR_MISC LIBSAMBA-UTIL LIBSAMBA-CONFIG RPC_NDR_SAMR RPC_NDR_LSA DYNCONFIG \
+ RPC_NDR_OXIDRESOLVER \
+ NDR_DCOM \
+ RPC_NDR_REMACT \
+ NDR_TABLE \
+ DCOM_PROXY_DCOM \
+ dcom \
+ RPC_NDR_WINREG
+OBJ_FILES = wbemdata.o \
+ wmicore.o \
+ ../librpc/gen_ndr/dcom_p.o \
+ pywmi_wrap.o
+# End LIBRARY swig_dcerpc
+#######################
+
+#################################
+# Start BINARY pdhc
+#[BINARY::pdhc]
+#INSTALLDIR = BINDIR
+#OBJ_FILES = \
+# pdhc.o
+#PRIVATE_DEPENDENCIES = \
+# POPT_SAMBA \
+# POPT_CREDENTIALS \
+# LIBPOPT \
+# NDR_TABLE \
+# RPC_NDR_WINREG
+# End BINARY pdhc
+#################################
+
diff --git a/source4/lib/wmi/pywmi.i b/source4/lib/wmi/pywmi.i
new file mode 100644
index 0000000000..1361ab0040
--- /dev/null
+++ b/source4/lib/wmi/pywmi.i
@@ -0,0 +1,371 @@
+%module pywmi
+
+%include "typemaps.i"
+%include "scripting/swig/samba.i"
+//%include "librpc/gen_ndr/winreg.i"
+
+%runtime %{
+void push_object(PyObject **stack, PyObject *o)
+{
+ if ((!*stack) || (*stack == Py_None)) {
+ *stack = o;
+ } else {
+ PyObject *o2, *o3;
+ if (!PyTuple_Check(*stack)) {
+ o2 = *stack;
+ *stack = PyTuple_New(1);
+ PyTuple_SetItem(*stack,0,o2);
+ }
+ o3 = PyTuple_New(1);
+ PyTuple_SetItem(o3,0,o);
+ o2 = *stack;
+ *stack = PySequence_Concat(o2,o3);
+ Py_DECREF(o2);
+ Py_DECREF(o3);
+ }
+}
+%}
+
+%{
+#include "includes.h"
+#include "librpc/gen_ndr/misc.h"
+#include "librpc/rpc/dcerpc.h"
+#include "librpc/rpc/dcerpc_table.h"
+#include "libcli/util/nt_status.h"
+#include "lib/com/dcom/dcom.h"
+#include "librpc/gen_ndr/com_dcom.h"
+#include "wmi/proto.h"
+
+
+WERROR WBEM_ConnectServer(struct com_context *ctx, const char *server, const char *nspace, const char *user, const char *password,
+ const char *locale, uint32_t flags, const char *authority, struct IWbemContext* wbem_ctx, struct IWbemServices** services);
+WERROR IEnumWbemClassObject_SmartNext(struct IEnumWbemClassObject *d, TALLOC_CTX *mem_ctx, int32_t lTimeout,uint32_t uCount,
+ struct WbemClassObject **apObjects, uint32_t *puReturned);
+
+static PyObject *PyErr_SetFromWERROR(WERROR w);
+static PyObject *PyObject_FromCVAR(uint32_t cimtype, union CIMVAR *cvar);
+static PyObject *PySWbemObject_FromWbemClassObject(struct WbemClassObject *wco);
+
+static struct com_context *com_ctx;
+static PyObject *ComError;
+static PyObject *mod_win32_client;
+static PyObject *mod_pywintypes;
+%}
+
+%apply uint32_t { int32_t };
+
+extern int DEBUGLEVEL;
+
+%wrapper %{
+static PyObject *PyErr_SetFromWERROR(WERROR w)
+{
+ PyObject *v;
+
+ v = Py_BuildValue("(is)", W_ERROR_V(w), wmi_errstr(w));
+ if (v != NULL) {
+ PyErr_SetObject(ComError, v);
+ Py_DECREF(v);
+ }
+ return NULL;
+}
+
+#define RETURN_CVAR_ARRAY(fmt, arr) {\
+ PyObject *l, *o;\
+ uint32_t i;\
+\
+ if (!arr) {\
+ Py_INCREF(Py_None);\
+ return Py_None;\
+ }\
+ l = PyList_New(arr->count);\
+ if (!l) return NULL;\
+ for (i = 0; i < arr->count; ++i) {\
+ o = _Py_BuildValue(fmt, arr->item[i]);\
+ if (!o) {\
+ Py_DECREF(l);\
+ return NULL;\
+ }\
+ PyList_SET_ITEM(l, i, o);\
+ }\
+ return l;\
+}
+
+static PyObject *_Py_BuildValue(char *str, ...)
+{
+ PyObject * result = NULL;
+ va_list lst;
+ va_start(lst, str);
+ if (str && *str == 'I') {
+ uint32_t value = va_arg(lst, uint32_t);
+ if (value & 0x80000000) {
+ result = Py_BuildValue("L", (long)value);
+ } else {
+ result = Py_BuildValue("i", value);
+ }
+ } else {
+ result = Py_VaBuildValue(str, lst);
+ }
+ va_end(lst);
+ return result;
+}
+
+
+static PyObject *PyObject_FromCVAR(uint32_t cimtype, union CIMVAR *cvar)
+{
+ switch (cimtype) {
+ case CIM_SINT8: return Py_BuildValue("b", cvar->v_sint8);
+ case CIM_UINT8: return Py_BuildValue("B", cvar->v_uint8);
+ case CIM_SINT16: return Py_BuildValue("h", cvar->v_sint16);
+ case CIM_UINT16: return Py_BuildValue("H", cvar->v_uint16);
+ case CIM_SINT32: return Py_BuildValue("i", cvar->v_sint32);
+ case CIM_UINT32: return _Py_BuildValue("I", cvar->v_uint32);
+ case CIM_SINT64: return Py_BuildValue("L", cvar->v_sint64);
+ case CIM_UINT64: return Py_BuildValue("K", cvar->v_uint64);
+ case CIM_REAL32: return Py_BuildValue("f", cvar->v_real32);
+ case CIM_REAL64: return Py_BuildValue("d", cvar->v_real64);
+ case CIM_BOOLEAN: return Py_BuildValue("h", cvar->v_boolean);
+ case CIM_STRING: return Py_BuildValue("s", cvar->v_string);
+ case CIM_DATETIME: return Py_BuildValue("s", cvar->v_datetime);
+ case CIM_REFERENCE: return Py_BuildValue("s", cvar->v_reference);
+ case CIM_OBJECT: return PySWbemObject_FromWbemClassObject(cvar->v_object);
+ case CIM_ARR_SINT8: RETURN_CVAR_ARRAY("b", cvar->a_sint8);
+ case CIM_ARR_UINT8: RETURN_CVAR_ARRAY("B", cvar->a_uint8);
+ case CIM_ARR_SINT16: RETURN_CVAR_ARRAY("h", cvar->a_sint16);
+ case CIM_ARR_UINT16: RETURN_CVAR_ARRAY("H", cvar->a_uint16);
+ case CIM_ARR_SINT32: RETURN_CVAR_ARRAY("i", cvar->a_sint32);
+ case CIM_ARR_UINT32: RETURN_CVAR_ARRAY("I", cvar->a_uint32);
+ case CIM_ARR_SINT64: RETURN_CVAR_ARRAY("L", cvar->a_sint64);
+ case CIM_ARR_UINT64: RETURN_CVAR_ARRAY("K", cvar->a_uint64);
+ case CIM_ARR_REAL32: RETURN_CVAR_ARRAY("f", cvar->a_real32);
+ case CIM_ARR_REAL64: RETURN_CVAR_ARRAY("d", cvar->a_real64);
+ case CIM_ARR_BOOLEAN: RETURN_CVAR_ARRAY("h", cvar->a_boolean);
+ case CIM_ARR_STRING: RETURN_CVAR_ARRAY("s", cvar->a_string);
+ case CIM_ARR_DATETIME: RETURN_CVAR_ARRAY("s", cvar->a_datetime);
+ case CIM_ARR_REFERENCE: RETURN_CVAR_ARRAY("s", cvar->a_reference);
+ default:
+ {
+ char *str;
+ str = talloc_asprintf(NULL, "Unsupported CIMTYPE(0x%04X)", cimtype);
+ PyErr_SetString(PyExc_RuntimeError, str);
+ talloc_free(str);
+ return NULL;
+ }
+ }
+}
+
+#undef RETURN_CVAR_ARRAY
+
+PyObject *PySWbemObject_InitProperites(PyObject *o, struct WbemClassObject *wco)
+{
+ PyObject *properties;
+ PyObject *addProp;
+ uint32_t i;
+ int32_t r;
+ PyObject *result;
+
+ result = NULL;
+ properties = PyObject_GetAttrString(o, "Properties_");
+ if (!properties) return NULL;
+ addProp = PyObject_GetAttrString(properties, "Add");
+ if (!addProp) {
+ Py_DECREF(properties);
+ return NULL;
+ }
+
+ for (i = 0; i < wco->obj_class->__PROPERTY_COUNT; ++i) {
+ PyObject *args, *property;
+
+ args = Py_BuildValue("(si)", wco->obj_class->properties[i].name, wco->obj_class->properties[i].desc->cimtype & CIM_TYPEMASK);
+ if (!args) goto finish;
+ property = PyObject_CallObject(addProp, args);
+ Py_DECREF(args);
+ if (!property) goto finish;
+ if (wco->flags & WCF_INSTANCE) {
+ PyObject *value;
+
+ if (wco->instance->default_flags[i] & 1) {
+ value = Py_None;
+ Py_INCREF(Py_None);
+ } else
+ value = PyObject_FromCVAR(wco->obj_class->properties[i].desc->cimtype & CIM_TYPEMASK, &wco->instance->data[i]);
+ if (!value) {
+ Py_DECREF(property);
+ goto finish;
+ }
+ r = PyObject_SetAttrString(property, "Value", value);
+ Py_DECREF(value);
+ if (r == -1) {
+ PyErr_SetString(PyExc_RuntimeError, "Error setting value of property");
+ goto finish;
+ }
+ }
+ Py_DECREF(property);
+ }
+
+ Py_INCREF(Py_None);
+ result = Py_None;
+finish:
+ Py_DECREF(addProp);
+ Py_DECREF(properties);
+ return result;
+}
+
+static PyObject *PySWbemObject_FromWbemClassObject(struct WbemClassObject *wco)
+{
+ PyObject *swo_class, *swo, *args, *result;
+
+ swo_class = PyObject_GetAttrString(mod_win32_client, "SWbemObject");
+ if (!swo_class) return NULL;
+ args = PyTuple_New(0);
+ if (!args) {
+ Py_DECREF(swo_class);
+ return NULL;
+ }
+ swo = PyObject_CallObject(swo_class, args);
+ Py_DECREF(args);
+ Py_DECREF(swo_class);
+ if (!swo) return NULL;
+
+ result = PySWbemObject_InitProperites(swo, wco);
+ if (!result) {
+ Py_DECREF(swo);
+ return NULL;
+ }
+ Py_DECREF(result);
+
+ return swo;
+}
+
+%}
+
+%typemap(out) WERROR {
+ if (!W_ERROR_IS_OK($1)) {
+ PyErr_SetFromWERROR($1);
+ return NULL;
+ }
+ $result = Py_None;
+ Py_INCREF(Py_None);
+}
+
+%typemap(in, numinputs=0) struct com_context *ctx {
+ $1 = com_ctx;
+}
+
+%typemap(in, numinputs=0) TALLOC_CTX *mem_ctx {
+ $1 = NULL;
+}
+
+%typemap(in, numinputs=0) struct IWbemServices **services (struct IWbemServices *temp) {
+ $1 = &temp;
+}
+
+%typemap(argout) struct IWbemServices **services {
+ PyObject *o;
+ o = SWIG_NewPointerObj(*$1, SWIGTYPE_p_IWbemServices, 0);
+ push_object(&$result, o);
+}
+
+WERROR WBEM_ConnectServer(struct com_context *ctx, const char *server, const char *nspace, const char *user, const char *password,
+ const char *locale, uint32_t flags, const char *authority, struct IWbemContext* wbem_ctx, struct IWbemServices** services);
+
+%typemap(in, numinputs=0) struct IEnumWbemClassObject **ppEnum (struct IEnumWbemClassObject *temp) {
+ $1 = &temp;
+}
+
+%typemap(argout) struct IEnumWbemClassObject **ppEnum {
+ PyObject *o;
+ o = SWIG_NewPointerObj(*$1, SWIGTYPE_p_IEnumWbemClassObject, 0);
+ push_object(&$result, o);
+}
+
+
+uint32_t IUnknown_Release(void *d, TALLOC_CTX *mem_ctx);
+
+WERROR IWbemServices_ExecQuery(struct IWbemServices *d, TALLOC_CTX *mem_ctx, const char *strQueryLanguage, const char *strQuery,
+ int32_t lFlags, struct IWbemContext *pCtx, struct IEnumWbemClassObject **ppEnum);
+
+WERROR IWbemServices_ExecNotificationQuery(struct IWbemServices *d, TALLOC_CTX *mem_ctx, const char *strQueryLanguage, const char *strQuery,
+ int32_t lFlags, struct IWbemContext *pCtx, struct IEnumWbemClassObject **ppEnum);
+
+WERROR IWbemServices_CreateInstanceEnum(struct IWbemServices *d, TALLOC_CTX *mem_ctx, const char *strClass,
+ int32_t lFlags, struct IWbemContext *pCtx, struct IEnumWbemClassObject **ppEnum);
+
+WERROR IEnumWbemClassObject_Reset(struct IEnumWbemClassObject *d, TALLOC_CTX *mem_ctx);
+
+%typemap(in, numinputs=1) (uint32_t uCount, struct WbemClassObject **apObjects, uint32_t *puReturned) (uint32_t uReturned) {
+ if (PyLong_Check($input))
+ $1 = PyLong_AsUnsignedLong($input);
+ else if (PyInt_Check($input))
+ $1 = PyInt_AsLong($input);
+ else {
+ PyErr_SetString(PyExc_TypeError,"Expected a long or an int");
+ return NULL;
+ }
+ $2 = talloc_array(NULL, struct WbemClassObject *, $1);
+ $3 = &uReturned;
+}
+
+%typemap(argout) (struct WbemClassObject **apObjects, uint32_t *puReturned) {
+ uint32_t i;
+ PyObject *o;
+ int32_t error;
+
+ error = 0;
+
+ $result = PyTuple_New(*$2);
+ for (i = 0; i < *$2; ++i) {
+ if (!error) {
+ o = PySWbemObject_FromWbemClassObject($1[i]);
+ if (!o)
+ --error;
+ else
+ error = PyTuple_SetItem($result, i, o);
+ }
+ talloc_free($1[i]);
+ }
+ talloc_free($1);
+ if (error) return NULL;
+}
+
+%typemap(out) WERROR {
+ if (!W_ERROR_IS_OK($1)) {
+ PyErr_SetFromWERROR($1);
+ talloc_free(arg5); // FIXME:avg make it properly(how???)
+ return NULL;
+ }
+}
+
+WERROR IEnumWbemClassObject_SmartNext(struct IEnumWbemClassObject *d, TALLOC_CTX *mem_ctx, int32_t lTimeout, uint32_t uCount,
+ struct WbemClassObject **apObjects, uint32_t *puReturned);
+
+%init %{
+
+ mod_win32_client = PyImport_ImportModule("win32com.client");
+ mod_pywintypes = PyImport_ImportModule("pywintypes");
+ ComError = PyObject_GetAttrString(mod_pywintypes, "com_error");
+
+ DEBUGLEVEL = 0;
+// talloc_enable_leak_report_full();
+
+ lp_load();
+ dcerpc_init();
+ dcerpc_table_init();
+
+ dcom_proxy_IUnknown_init();
+ dcom_proxy_IWbemLevel1Login_init();
+ dcom_proxy_IWbemServices_init();
+ dcom_proxy_IEnumWbemClassObject_init();
+ dcom_proxy_IRemUnknown_init();
+ dcom_proxy_IWbemFetchSmartEnum_init();
+ dcom_proxy_IWbemWCOSmartEnum_init();
+ dcom_proxy_IWbemClassObject_init();
+
+ com_init_ctx(&com_ctx, NULL);
+ dcom_client_init(com_ctx, NULL);
+
+ {
+ PyObject *pModule;
+
+ pModule = PyImport_ImportModule( "win32com.client" );
+ }
+%}
diff --git a/source4/lib/wmi/tools/wmic.c b/source4/lib/wmi/tools/wmic.c
new file mode 100644
index 0000000000..0e52b5905a
--- /dev/null
+++ b/source4/lib/wmi/tools/wmic.c
@@ -0,0 +1,234 @@
+/*
+ WMI Sample client
+ Copyright (C) 2006 Andrzej Hajda <andrzej.hajda@wp.pl>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+#include "lib/cmdline/popt_common.h"
+#include "librpc/rpc/dcerpc.h"
+#include "librpc/gen_ndr/ndr_oxidresolver.h"
+#include "librpc/gen_ndr/ndr_oxidresolver_c.h"
+#include "librpc/gen_ndr/ndr_dcom.h"
+#include "librpc/gen_ndr/ndr_dcom_c.h"
+#include "librpc/gen_ndr/ndr_remact_c.h"
+#include "librpc/gen_ndr/ndr_epmapper_c.h"
+#include "librpc/gen_ndr/com_dcom.h"
+#include "librpc/rpc/dcerpc_table.h"
+
+#include "lib/com/dcom/dcom.h"
+#include "lib/com/proto.h"
+#include "lib/com/dcom/proto.h"
+
+struct WBEMCLASS;
+struct WBEMOBJECT;
+
+#include "wmi/proto.h"
+
+struct program_args {
+ char *hostname;
+ char *query;
+ char *ns;
+};
+
+static void parse_args(int argc, char *argv[], struct program_args *pmyargs)
+{
+ poptContext pc;
+ int opt, i;
+
+ int argc_new;
+ char **argv_new;
+
+ struct poptOption long_options[] = {
+ POPT_AUTOHELP
+ POPT_COMMON_SAMBA
+ POPT_COMMON_CONNECTION
+ POPT_COMMON_CREDENTIALS
+ POPT_COMMON_VERSION
+ {"namespace", 0, POPT_ARG_STRING, &pmyargs->ns, 0,
+ "WMI namespace, default to root\\cimv2", 0},
+ POPT_TABLEEND
+ };
+
+ pc = poptGetContext("wmi", argc, (const char **) argv,
+ long_options, POPT_CONTEXT_KEEP_FIRST);
+
+ poptSetOtherOptionHelp(pc, "//host query\n\nExample: wmic -U [domain/]adminuser%password //host \"select * from Win32_ComputerSystem\"");
+
+ while ((opt = poptGetNextOpt(pc)) != -1) {
+ poptPrintUsage(pc, stdout, 0);
+ poptFreeContext(pc);
+ exit(1);
+ }
+
+ argv_new = discard_const_p(char *, poptGetArgs(pc));
+
+ argc_new = argc;
+ for (i = 0; i < argc; i++) {
+ if (argv_new[i] == NULL) {
+ argc_new = i;
+ break;
+ }
+ }
+
+ if (argc_new != 3 || argv_new[1][0] != '/'
+ || argv_new[1][1] != '/') {
+ poptPrintUsage(pc, stdout, 0);
+ poptFreeContext(pc);
+ exit(1);
+ }
+
+ pmyargs->hostname = argv_new[1] + 2;
+ pmyargs->query = argv_new[2];
+ poptFreeContext(pc);
+}
+
+#define WERR_CHECK(msg) if (!W_ERROR_IS_OK(result)) { \
+ DEBUG(0, ("ERROR: %s\n", msg)); \
+ goto error; \
+ } else { \
+ DEBUG(1, ("OK : %s\n", msg)); \
+ }
+
+#define RETURN_CVAR_ARRAY_STR(fmt, arr) {\
+ uint32_t i;\
+ char *r;\
+\
+ if (!arr) {\
+ return talloc_strdup(mem_ctx, "NULL");\
+ }\
+ r = talloc_strdup(mem_ctx, "(");\
+ for (i = 0; i < arr->count; ++i) {\
+ r = talloc_asprintf_append(r, fmt "%s", arr->item[i], (i+1 == arr->count)?"":",");\
+ }\
+ return talloc_asprintf_append(r, ")");\
+}
+
+char *string_CIMVAR(TALLOC_CTX *mem_ctx, union CIMVAR *v, enum CIMTYPE_ENUMERATION cimtype)
+{
+ switch (cimtype) {
+ case CIM_SINT8: return talloc_asprintf(mem_ctx, "%d", v->v_sint8);
+ case CIM_UINT8: return talloc_asprintf(mem_ctx, "%u", v->v_uint8);
+ case CIM_SINT16: return talloc_asprintf(mem_ctx, "%d", v->v_sint16);
+ case CIM_UINT16: return talloc_asprintf(mem_ctx, "%u", v->v_uint16);
+ case CIM_SINT32: return talloc_asprintf(mem_ctx, "%d", v->v_sint32);
+ case CIM_UINT32: return talloc_asprintf(mem_ctx, "%u", v->v_uint32);
+ case CIM_SINT64: return talloc_asprintf(mem_ctx, "%lld", v->v_sint64);
+ case CIM_UINT64: return talloc_asprintf(mem_ctx, "%llu", v->v_sint64);
+ case CIM_REAL32: return talloc_asprintf(mem_ctx, "%f", (double)v->v_uint32);
+ case CIM_REAL64: return talloc_asprintf(mem_ctx, "%f", (double)v->v_uint64);
+ case CIM_BOOLEAN: return talloc_asprintf(mem_ctx, "%s", v->v_boolean?"True":"False");
+ case CIM_STRING:
+ case CIM_DATETIME:
+ case CIM_REFERENCE: return talloc_asprintf(mem_ctx, "%s", v->v_string);
+ case CIM_CHAR16: return talloc_asprintf(mem_ctx, "Unsupported");
+ case CIM_OBJECT: return talloc_asprintf(mem_ctx, "Unsupported");
+ case CIM_ARR_SINT8: RETURN_CVAR_ARRAY_STR("%d", v->a_sint8);
+ case CIM_ARR_UINT8: RETURN_CVAR_ARRAY_STR("%u", v->a_uint8);
+ case CIM_ARR_SINT16: RETURN_CVAR_ARRAY_STR("%d", v->a_sint16);
+ case CIM_ARR_UINT16: RETURN_CVAR_ARRAY_STR("%u", v->a_uint16);
+ case CIM_ARR_SINT32: RETURN_CVAR_ARRAY_STR("%d", v->a_sint32);
+ case CIM_ARR_UINT32: RETURN_CVAR_ARRAY_STR("%u", v->a_uint32);
+ case CIM_ARR_SINT64: RETURN_CVAR_ARRAY_STR("%lld", v->a_sint64);
+ case CIM_ARR_UINT64: RETURN_CVAR_ARRAY_STR("%llu", v->a_uint64);
+ case CIM_ARR_REAL32: RETURN_CVAR_ARRAY_STR("%f", v->a_real32);
+ case CIM_ARR_REAL64: RETURN_CVAR_ARRAY_STR("%f", v->a_real64);
+ case CIM_ARR_BOOLEAN: RETURN_CVAR_ARRAY_STR("%d", v->a_boolean);
+ case CIM_ARR_STRING: RETURN_CVAR_ARRAY_STR("%s", v->a_string);
+ case CIM_ARR_DATETIME: RETURN_CVAR_ARRAY_STR("%s", v->a_datetime);
+ case CIM_ARR_REFERENCE: RETURN_CVAR_ARRAY_STR("%s", v->a_reference);
+ default: return talloc_asprintf(mem_ctx, "Unsupported");
+ }
+}
+
+#undef RETURN_CVAR_ARRAY_STR
+
+int main(int argc, char **argv)
+{
+ struct program_args args = {};
+ uint32_t cnt = 5, ret;
+ char *class_name = NULL;
+ WERROR result;
+ NTSTATUS status;
+ struct IWbemServices *pWS = NULL;
+
+ parse_args(argc, argv, &args);
+
+ dcerpc_init();
+ dcerpc_table_init();
+
+ dcom_proxy_IUnknown_init();
+ dcom_proxy_IWbemLevel1Login_init();
+ dcom_proxy_IWbemServices_init();
+ dcom_proxy_IEnumWbemClassObject_init();
+ dcom_proxy_IRemUnknown_init();
+ dcom_proxy_IWbemFetchSmartEnum_init();
+ dcom_proxy_IWbemWCOSmartEnum_init();
+
+ struct com_context *ctx = NULL;
+ com_init_ctx(&ctx, NULL);
+ dcom_client_init(ctx, cmdline_credentials);
+
+ if (!args.ns)
+ args.ns = "root\\cimv2";
+ result = WBEM_ConnectServer(ctx, args.hostname, args.ns, 0, 0, 0, 0, 0, 0, &pWS);
+ WERR_CHECK("Login to remote object.");
+
+ struct IEnumWbemClassObject *pEnum = NULL;
+ result = IWbemServices_ExecQuery(pWS, ctx, "WQL", args.query, WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_ENSURE_LOCATABLE, NULL, &pEnum);
+ WERR_CHECK("WMI query execute.");
+
+ IEnumWbemClassObject_Reset(pEnum, ctx);
+ WERR_CHECK("Reset result of WMI query.");
+
+ do {
+ uint32_t i, j;
+ struct WbemClassObject *co[cnt];
+
+ result = IEnumWbemClassObject_SmartNext(pEnum, ctx, 0xFFFFFFFF, cnt, co, &ret);
+ /* WERR_BADFUNC is OK, it means only that there is less returned objects than requested */
+ if (!W_ERROR_EQUAL(result, WERR_BADFUNC)) {
+ WERR_CHECK("Retrieve result data.");
+ } else {
+ DEBUG(1, ("OK : Retrieved less objects than requested (it is normal).\n"));
+ }
+ if (!ret) break;
+
+ for (i = 0; i < ret; ++i) {
+ if (!class_name || strcmp(co[i]->obj_class->__CLASS, class_name)) {
+ if (class_name) talloc_free(class_name);
+ class_name = talloc_strdup(ctx, co[i]->obj_class->__CLASS);
+ printf("CLASS: %s\n", class_name);
+ for (j = 0; j < co[i]->obj_class->__PROPERTY_COUNT; ++j)
+ printf("%s%s", j?"|":"", co[i]->obj_class->properties[j].name);
+ printf("\n");
+ }
+ for (j = 0; j < co[i]->obj_class->__PROPERTY_COUNT; ++j) {
+ char *s;
+ s = string_CIMVAR(ctx, &co[i]->instance->data[j], co[i]->obj_class->properties[j].desc->cimtype & CIM_TYPEMASK);
+ printf("%s%s", j?"|":"", s);
+ }
+ printf("\n");
+ }
+ } while (ret == cnt);
+ talloc_free(ctx);
+ return 0;
+error:
+ status = werror_to_ntstatus(result);
+ fprintf(stderr, "NTSTATUS: %s - %s\n", nt_errstr(status), get_friendly_nt_error_msg(status));
+ talloc_free(ctx);
+ return 1;
+}
diff --git a/source4/lib/wmi/tools/wmis.c b/source4/lib/wmi/tools/wmis.c
new file mode 100644
index 0000000000..85063ecdb9
--- /dev/null
+++ b/source4/lib/wmi/tools/wmis.c
@@ -0,0 +1,229 @@
+/*
+ WMI Sample client
+ Copyright (C) 2006 Andrzej Hajda <andrzej.hajda@wp.pl>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+#include "lib/cmdline/popt_common.h"
+#include "auth/credentials/credentials.h"
+#include "librpc/rpc/dcerpc.h"
+#include "librpc/gen_ndr/ndr_oxidresolver.h"
+#include "librpc/gen_ndr/ndr_oxidresolver_c.h"
+#include "librpc/gen_ndr/dcom.h"
+#include "librpc/gen_ndr/ndr_dcom.h"
+#include "librpc/gen_ndr/ndr_dcom_c.h"
+#include "librpc/gen_ndr/ndr_remact_c.h"
+#include "librpc/gen_ndr/ndr_epmapper_c.h"
+#include "librpc/gen_ndr/com_dcom.h"
+#include "librpc/rpc/dcerpc_table.h"
+
+#include "lib/com/dcom/dcom.h"
+#include "lib/com/proto.h"
+#include "lib/com/dcom/proto.h"
+
+struct WBEMCLASS;
+struct WBEMOBJECT;
+enum CIMTYPE_ENUMERATION;
+NTSTATUS dcom_proxy_IWbemClassObject_init();
+
+#include "wmi/proto.h"
+
+struct program_args {
+ char *hostname;
+ char *query;
+};
+
+static void parse_args(int argc, char *argv[], struct program_args *pmyargs)
+{
+ poptContext pc;
+ int opt, i;
+
+ int argc_new;
+ char **argv_new;
+
+ struct poptOption long_options[] = {
+ POPT_AUTOHELP
+ POPT_COMMON_SAMBA
+ POPT_COMMON_CONNECTION
+ POPT_COMMON_CREDENTIALS
+ POPT_COMMON_VERSION
+ POPT_TABLEEND
+ };
+
+ pc = poptGetContext("wmi", argc, (const char **) argv,
+ long_options, POPT_CONTEXT_KEEP_FIRST);
+
+ poptSetOtherOptionHelp(pc, "//host\n\nExample: wmis -U [domain/]adminuser%password //host");
+
+ while ((opt = poptGetNextOpt(pc)) != -1) {
+ poptPrintUsage(pc, stdout, 0);
+ poptFreeContext(pc);
+ exit(1);
+ }
+
+ argv_new = discard_const_p(char *, poptGetArgs(pc));
+
+ argc_new = argc;
+ for (i = 0; i < argc; i++) {
+ if (argv_new[i] == NULL) {
+ argc_new = i;
+ break;
+ }
+ }
+
+ if (argc_new < 2 || argv_new[1][0] != '/'
+ || argv_new[1][1] != '/') {
+ poptPrintUsage(pc, stdout, 0);
+ poptFreeContext(pc);
+ exit(1);
+ }
+
+ pmyargs->hostname = argv_new[1] + 2;
+ poptFreeContext(pc);
+}
+
+#define WERR_CHECK(msg) if (!W_ERROR_IS_OK(result)) { \
+ DEBUG(0, ("ERROR: %s\n", msg)); \
+ goto error; \
+ } else { \
+ DEBUG(1, ("OK : %s\n", msg)); \
+ }
+/*
+WERROR WBEM_ConnectServer(struct com_context *ctx, const char *server, const char *nspace, const char *user, const char *password, const char *locale, uint32_t flags, const char *authority, struct IWbemContext* wbem_ctx, struct IWbemServices** services)
+{
+ struct GUID clsid;
+ struct GUID iid;
+ WERROR result, coresult;
+ struct IUnknown **mqi;
+ struct IWbemLevel1Login *pL;
+
+ if (user) {
+ char *cred;
+ struct cli_credentials *cc;
+
+ cred = talloc_asprintf(NULL, "%s%%%s", user, password);
+ cc = cli_credentials_init(ctx);
+ cli_credentials_set_conf(cc);
+ cli_credentials_parse_string(cc, cred, CRED_SPECIFIED);
+ dcom_set_server_credentials(ctx, server, cc);
+ talloc_free(cred);
+ }
+
+ GUID_from_string(CLSID_WBEMLEVEL1LOGIN, &clsid);
+ GUID_from_string(COM_IWBEMLEVEL1LOGIN_UUID, &iid);
+ result = dcom_create_object(ctx, &clsid, server, 1, &iid, &mqi, &coresult);
+ WERR_CHECK("dcom_create_object.");
+ result = coresult;
+ WERR_CHECK("Create remote WMI object.");
+ pL = (struct IWbemLevel1Login *)mqi[0];
+ talloc_free(mqi);
+
+ result = IWbemLevel1Login_NTLMLogin(pL, ctx, nspace, locale, flags, wbem_ctx, services);
+ WERR_CHECK("Login to remote object.");
+error:
+ return result;
+}
+*/
+WERROR WBEM_RemoteExecute(struct IWbemServices *pWS, const char *cmdline, uint32_t *ret_code)
+{
+ struct IWbemClassObject *wco = NULL;
+ struct IWbemClassObject *inc, *outc, *in;
+ struct IWbemClassObject *out = NULL;
+ WERROR result;
+ union CIMVAR v;
+ TALLOC_CTX *ctx;
+
+ ctx = talloc_new(0);
+
+ result = IWbemServices_GetObject(pWS, ctx, "Win32_Process", WBEM_FLAG_RETURN_WBEM_COMPLETE, NULL, &wco, NULL);
+ WERR_CHECK("GetObject.");
+
+ result = IWbemClassObject_GetMethod(wco, ctx, "Create", 0, &inc, &outc);
+ WERR_CHECK("IWbemClassObject_GetMethod.");
+
+ result = IWbemClassObject_SpawnInstance(inc, ctx, 0, &in);
+ WERR_CHECK("IWbemClassObject_SpawnInstance.");
+
+ v.v_string = cmdline;
+ result = IWbemClassObject_Put(in, ctx, "CommandLine", 0, &v, 0);
+ WERR_CHECK("IWbemClassObject_Put(CommandLine).");
+
+ result = IWbemServices_ExecMethod(pWS, ctx, "Win32_Process", "Create", 0, NULL, in, &out, NULL);
+ WERR_CHECK("IWbemServices_ExecMethod.");
+
+ if (ret_code) {
+ result = WbemClassObject_Get(out->object_data, ctx, "ReturnValue", 0, &v, 0, 0);
+ WERR_CHECK("IWbemClassObject_Put(CommandLine).");
+ *ret_code = v.v_uint32;
+ }
+error:
+ talloc_free(ctx);
+ return result;
+}
+
+int main(int argc, char **argv)
+{
+ struct program_args args = {};
+ struct com_context *ctx = NULL;
+ WERROR result;
+ NTSTATUS status;
+ struct IWbemServices *pWS = NULL;
+ struct IEnumWbemClassObject *pEnum = NULL;
+ uint32_t cnt;
+
+ parse_args(argc, argv, &args);
+
+ dcerpc_init();
+ dcerpc_table_init();
+
+ dcom_proxy_IUnknown_init();
+ dcom_proxy_IWbemLevel1Login_init();
+ dcom_proxy_IWbemServices_init();
+ dcom_proxy_IEnumWbemClassObject_init();
+ dcom_proxy_IRemUnknown_init();
+ dcom_proxy_IWbemFetchSmartEnum_init();
+ dcom_proxy_IWbemWCOSmartEnum_init();
+ dcom_proxy_IWbemClassObject_init();
+
+ com_init_ctx(&ctx, NULL);
+ dcom_client_init(ctx, cmdline_credentials);
+
+ result = WBEM_ConnectServer(ctx, args.hostname, "root\\cimv2", 0, 0, 0, 0, 0, 0, &pWS);
+ WERR_CHECK("WBEM_ConnectServer.");
+
+ DEBUG(0, ("1: Creating directory C:\\wmi_test_dir_tmp using method Win32_Process.Create\n"));
+ WBEM_RemoteExecute(pWS, "cmd.exe /C mkdir C:\\wmi_test_dir_tmp", &cnt);
+ WERR_CHECK("WBEM_RemoteExecute.");
+ DEBUG(0, ("2: ReturnCode: %d\n", cnt));
+
+ DEBUG(0, ("3: Monitoring directory C:\\wmi_test_dir_tmp. Please create/delete files in that directory to see notifications, after 4 events program quits.\n"));
+ result = IWbemServices_ExecNotificationQuery(pWS, ctx, "WQL", "SELECT * FROM __InstanceOperationEvent WITHIN 1 WHERE Targetinstance ISA 'CIM_DirectoryContainsFile' and TargetInstance.GroupComponent= 'Win32_Directory.Name=\"C:\\\\\\\\wmi_test_dir_tmp\"'", WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pEnum);
+ WERR_CHECK("WMI query execute.");
+ for (cnt = 0; cnt < 4; ++cnt) {
+ struct WbemClassObject *co;
+ uint32_t ret;
+ result = IEnumWbemClassObject_SmartNext(pEnum, ctx, 0xFFFFFFFF, 1, &co, &ret);
+ WERR_CHECK("IEnumWbemClassObject_Next.");
+ printf("%s\n", co->obj_class->__CLASS);
+ }
+
+error:
+ status = werror_to_ntstatus(result);
+ fprintf(stderr, "NTSTATUS: %s - %s\n", nt_errstr(status), get_friendly_nt_error_msg(status));
+ talloc_free(ctx);
+ return 1;
+}
diff --git a/source4/lib/wmi/wbemdata.c b/source4/lib/wmi/wbemdata.c
new file mode 100644
index 0000000000..02eed3dbc5
--- /dev/null
+++ b/source4/lib/wmi/wbemdata.c
@@ -0,0 +1,692 @@
+/*
+ WMI Implementation
+ Copyright (C) 2006 Andrzej Hajda <andrzej.hajda@wp.pl>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+#include "librpc/gen_ndr/dcom.h"
+#include "librpc/gen_ndr/com_dcom.h"
+#include "librpc/ndr/libndr.h"
+#include "librpc/ndr/libndr_proto.h"
+#include "lib/com/com.h"
+#include "lib/com/dcom/dcom.h"
+#include "lib/util/dlinklist.h"
+#include "librpc/ndr/libndr.h"
+#include "librpc/gen_ndr/ndr_dcom.h"
+#include "librpc/rpc/dcerpc.h"
+#include "librpc/gen_ndr/ndr_misc.h"
+#include "lib/talloc/talloc.h"
+#include "libcli/composite/composite.h"
+#include "wmi/proto.h"
+
+NTSTATUS ndr_pull_WbemClassObject_Object(struct ndr_pull *ndr, int ndr_flags, struct WbemClassObject *r);
+void duplicate_CIMVAR(TALLOC_CTX *mem_ctx, const union CIMVAR *src, union CIMVAR *dst, enum CIMTYPE_ENUMERATION cimtype);
+void duplicate_WbemClassObject(TALLOC_CTX *mem_ctx, const struct WbemClassObject *src, struct WbemClassObject *dst);
+
+#define NDR_CHECK_LEN(n) do { if (p + (n) > pend) { \
+ DEBUG(0, ("%s(%d): WBEMDATA_ERR(0x%08X): Buffer too small(0x%04X)\n", __FILE__, __LINE__, ndr->offset, p + (n) - pend)); \
+ status = NT_STATUS_UNSUCCESSFUL; \
+ goto end; \
+ } \
+ } while(0)
+
+#define NDR_CHECK_EXPR(expr) do { if (!(expr)) {\
+ DEBUG(0, ("%s(%d): WBEMDATA_ERR(0x%08X): Error parsing(%s)\n", __FILE__, __LINE__, ndr->offset, #expr)); \
+ status = NT_STATUS_UNSUCCESSFUL; \
+ goto end; \
+ } \
+ } while(0)
+
+#define NDR_CHECK_CONST(val, exp) NDR_CHECK_EXPR((val) == (exp))
+#define NDR_CHECK_RSTRING(rstring) NDR_CHECK_EXPR((rstring) >= 0)
+
+#define NTERR_CHECK(call) status = call; if (!NT_STATUS_IS_OK(status)) goto end;
+
+enum {
+ DATATYPE_CLASSOBJECT = 2,
+ DATATYPE_OBJECT = 3,
+
+ COFLAG_IS_CLASS = 4,
+};
+
+static NTSTATUS marshal(struct IUnknown *pv, struct OBJREF *o)
+{
+ struct ndr_push *ndr;
+ NTSTATUS status;
+ struct WbemClassObject *wco;
+ TALLOC_CTX *mem_ctx;
+ struct MInterfacePointer *mp;
+
+ mp = (struct MInterfacePointer *)((char *)o - offsetof(struct MInterfacePointer, obj)); // FIXME:high remove this Mumbo Jumbo
+ wco = pv->object_data;
+ mem_ctx = talloc_new(0);
+ ndr = talloc_zero(mem_ctx, struct ndr_push);
+ ndr->flags = 0;
+ ndr->alloc_size = 1024;
+ ndr->data = talloc_array(mp, uint8_t, ndr->alloc_size);
+
+ if (wco) {
+ uint32_t ofs;
+ NTERR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x12345678));
+ NTERR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
+ NTERR_CHECK(ndr_push_WbemClassObject(ndr, NDR_SCALARS | NDR_BUFFERS, wco));
+ ofs = ndr->offset;
+ ndr->offset = 4;
+ NTERR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ofs - 8));
+ ndr->offset = ofs;
+ } else {
+ NTERR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
+ }
+ o->u_objref.u_custom.pData = talloc_realloc(mp, ndr->data, uint8_t, ndr->offset);
+ o->u_objref.u_custom.size = ndr->offset;
+ mp->size = sizeof(struct OBJREF) - sizeof(union OBJREF_Types) + sizeof(struct u_custom) + o->u_objref.u_custom.size - 4;
+ if (DEBUGLVL(9)) {
+ NDR_PRINT_DEBUG(WbemClassObject, wco);
+ }
+end:
+ talloc_free(mem_ctx);
+ return status;
+}
+
+static NTSTATUS unmarshal(struct OBJREF *o, struct IUnknown **pv)
+{
+ struct ndr_pull *ndr;
+ TALLOC_CTX *mem_ctx;
+ struct WbemClassObject *wco;
+ NTSTATUS status;
+ uint32_t u;
+
+ mem_ctx = talloc_new(0);
+ ndr = talloc_zero(mem_ctx, struct ndr_pull);
+ ndr->current_mem_ctx = mem_ctx;
+ ndr->data = o->u_objref.u_custom.pData;
+ ndr->data_size = o->u_objref.u_custom.size;
+
+ NTERR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ if (!u) {
+ talloc_free(*pv);
+ *pv = NULL;
+ status = NT_STATUS_OK;
+ goto end;
+ }
+ NTERR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ if (u + 8 > ndr->data_size) {
+ DEBUG(1, ("unmarshall_IWbemClassObject: Incorrect data_size"));
+ status = NT_STATUS_BUFFER_TOO_SMALL;
+ goto end;
+ }
+ wco = talloc_zero(*pv, struct WbemClassObject);
+ ndr->current_mem_ctx = wco;
+ status = ndr_pull_WbemClassObject(ndr, NDR_SCALARS | NDR_BUFFERS, wco);
+
+ if (NT_STATUS_IS_OK(status) && (DEBUGLVL(9))) {
+ NDR_PRINT_DEBUG(WbemClassObject, wco);
+ }
+
+ if (NT_STATUS_IS_OK(status)) {
+ (*pv)->object_data = wco;
+ } else {
+ talloc_free(wco);
+ }
+end:
+ talloc_free(mem_ctx);
+ return status;
+}
+
+WERROR dcom_IWbemClassObject_from_WbemClassObject(struct com_context *ctx, struct IWbemClassObject **_p, struct WbemClassObject *wco)
+{
+ struct IWbemClassObject *p;
+
+
+ p = talloc_zero(ctx, struct IWbemClassObject);
+ p->ctx = ctx;
+ p->obj.signature = 0x574f454d;
+ p->obj.flags = OBJREF_CUSTOM;
+ GUID_from_string("dc12a681-737f-11cf-884d-00aa004b2e24", &p->obj.iid);
+ GUID_from_string("4590f812-1d3a-11d0-891f-00aa004b2e24", &p->obj.u_objref.u_custom.clsid);
+ p->object_data = (void *)wco;
+ talloc_steal(p, p->object_data);
+ *_p = p;
+ return WERR_OK;
+}
+
+WERROR IWbemClassObject_GetMethod(struct IWbemClassObject *d, TALLOC_CTX *mem_ctx, const char *name, uint32_t flags, struct IWbemClassObject **in, struct IWbemClassObject **out)
+{
+ uint32_t i;
+ struct WbemClassObject *wco;
+
+ wco = (struct WbemClassObject *)d->object_data;
+ for (i = 0; i < wco->obj_methods->count; ++i)
+ if (!strcmp(wco->obj_methods->method[i].name, name)) {
+ if (in) dcom_IWbemClassObject_from_WbemClassObject(d->ctx, in, wco->obj_methods->method[i].in);
+ if (out) dcom_IWbemClassObject_from_WbemClassObject(d->ctx, out, wco->obj_methods->method[i].out);
+ return WERR_OK;
+ }
+ return WERR_NOT_FOUND;
+}
+
+void WbemClassObject_CreateInstance(struct WbemClassObject *wco)
+{
+ uint32_t i;
+
+ wco->instance = talloc_zero(wco, struct WbemInstance);
+ wco->instance->default_flags = talloc_array(wco->instance, uint8_t, wco->obj_class->__PROPERTY_COUNT);
+ wco->instance->data = talloc_array(wco->instance, union CIMVAR, wco->obj_class->__PROPERTY_COUNT);
+ memset(wco->instance->data, 0, sizeof(union CIMVAR) * wco->obj_class->__PROPERTY_COUNT);
+ for (i = 0; i < wco->obj_class->__PROPERTY_COUNT; ++i) {
+ wco->instance->default_flags[i] = 1; // FIXME:high resolve this magic
+ }
+ wco->instance->__CLASS = wco->obj_class->__CLASS;
+ wco->instance->u2_4 = 4;
+ wco->instance->u3_1 = 1;
+}
+
+WERROR IWbemClassObject_Clone(struct IWbemClassObject *d, TALLOC_CTX *mem_ctx, struct IWbemClassObject **copy)
+{
+ return WERR_NOT_SUPPORTED;
+}
+
+WERROR IWbemClassObject_SpawnInstance(struct IWbemClassObject *d, TALLOC_CTX *mem_ctx, uint32_t flags, struct IWbemClassObject **instance)
+{
+ struct WbemClassObject *wco, *nwco;
+
+ wco = (struct WbemClassObject *)d->object_data;
+ nwco = talloc_zero(mem_ctx, struct WbemClassObject);
+ nwco->flags = WCF_INSTANCE;
+ nwco->obj_class = wco->obj_class;
+ WbemClassObject_CreateInstance(nwco);
+ dcom_IWbemClassObject_from_WbemClassObject(d->ctx, instance, nwco);
+ return WERR_OK;
+}
+
+void duplicate_WbemQualifier(TALLOC_CTX *mem_ctx, const struct WbemQualifier *src, struct WbemQualifier *dst)
+{
+ dst->name = src->name;
+ if (src->name) dst->name = talloc_strdup(mem_ctx, src->name);
+
+ dst->flavors = src->flavors;
+
+ dst->cimtype = src->cimtype;
+
+ duplicate_CIMVAR(mem_ctx, &src->value, &dst->value, src->cimtype);
+}
+
+void duplicate_CIMSTRINGS(TALLOC_CTX *mem_ctx, const struct CIMSTRINGS *src, struct CIMSTRINGS *dst)
+{
+ uint32_t i;
+
+ dst->count = src->count;
+ for (i = 0; i < src->count; ++i)
+ dst->item[i] = talloc_strdup(mem_ctx, src->item[i]);
+}
+
+void duplicate_WbemQualifiers(TALLOC_CTX *mem_ctx, const struct WbemQualifiers *src, struct WbemQualifiers *dst)
+{
+ uint32_t i;
+
+ dst->count = src->count;
+ for (i = 0; i < src->count; ++i) {
+ dst->item[i] = talloc_zero(mem_ctx, struct WbemQualifier);
+ duplicate_WbemQualifier(dst->item[i], src->item[i], dst->item[i]);
+ }
+}
+
+void duplicate_WbemClass(TALLOC_CTX *mem_ctx, const struct WbemClass *src, struct WbemClass *dst)
+{
+ uint32_t i;
+
+ dst->u_0 = src->u_0;
+
+ dst->__CLASS = src->__CLASS;
+ if (src->__CLASS) dst->__CLASS = talloc_strdup(mem_ctx, src->__CLASS);
+
+ duplicate_CIMSTRINGS(mem_ctx, &src->__DERIVATION, &dst->__DERIVATION);
+ duplicate_WbemQualifiers(mem_ctx, &src->qualifiers, &dst->qualifiers);
+
+ dst->__PROPERTY_COUNT = src->__PROPERTY_COUNT;
+
+ dst->properties = talloc_array(mem_ctx, struct WbemProperty, src->__PROPERTY_COUNT);
+ for (i = 0; i < src->__PROPERTY_COUNT; ++i) {
+ dst->properties[i].name = talloc_strdup(dst->properties, src->properties[i].name);
+ dst->properties[i].desc = talloc_memdup(dst->properties, src->properties[i].desc, sizeof(*src->properties[i].desc));
+ duplicate_WbemQualifiers(dst->properties[i].desc, &src->properties[i].desc->qualifiers, &dst->properties[i].desc->qualifiers);
+ }
+
+ dst->default_flags = talloc_array(mem_ctx, uint8_t, src->__PROPERTY_COUNT);
+ dst->default_values = talloc_array(mem_ctx, union CIMVAR, src->__PROPERTY_COUNT);
+ for (i = 0; i < src->__PROPERTY_COUNT; ++i) {
+ dst->default_flags[i] = src->default_flags[i];
+ duplicate_CIMVAR(dst->default_values, &src->default_values[i], &dst->default_values[i], src->properties[i].desc->cimtype);
+ }
+}
+
+void duplicate_WbemMethod(TALLOC_CTX *mem_ctx, const struct WbemMethod *src, struct WbemMethod *dst)
+{
+ dst->name = src->name;
+ if (src->name) dst->name = talloc_strdup(mem_ctx, src->name);
+
+ dst->u0 = src->u0;
+ dst->u1 = src->u1;
+
+ dst->qualifiers = talloc_zero(mem_ctx, struct WbemQualifiers);
+ duplicate_WbemQualifiers(dst->qualifiers, src->qualifiers, dst->qualifiers);
+
+ dst->in = src->in;
+ if (src->in) {
+ dst->in = talloc_zero(mem_ctx, struct WbemClassObject);
+ duplicate_WbemClassObject(dst->in, src->in, dst->in);
+ }
+
+ dst->out = src->out;
+ if (src->out) {
+ dst->out = talloc_zero(mem_ctx, struct WbemClassObject);
+ duplicate_WbemClassObject(dst->out, src->out, dst->out);
+ }
+}
+
+void duplicate_WbemMethods(TALLOC_CTX *mem_ctx, const struct WbemMethods *src, struct WbemMethods *dst)
+{
+ uint32_t i;
+
+ dst->count = src->count;
+ dst->u0 = src->u0;
+ for (i = 0; i < src->count; ++i)
+ duplicate_WbemMethod(mem_ctx, &src->method[i], &dst->method[i]);
+}
+
+void duplicate_WbemInstance(TALLOC_CTX *mem_ctx, const struct WbemInstance *src, struct WbemInstance *dst, const struct WbemClass *cls)
+{
+ uint32_t i;
+
+ dst->u1_0 = src->u1_0;
+
+ dst->__CLASS = src->__CLASS;
+ if (src->__CLASS) dst->__CLASS = talloc_strdup(mem_ctx, src->__CLASS);
+
+ dst->default_flags = talloc_array(mem_ctx, uint8_t, cls->__PROPERTY_COUNT);
+ dst->data = talloc_array(mem_ctx, union CIMVAR, cls->__PROPERTY_COUNT);
+ for (i = 0; i < cls->__PROPERTY_COUNT; ++i) {
+ dst->default_flags[i] = src->default_flags[i];
+ duplicate_CIMVAR(dst->data, &src->data[i], &dst->data[i], cls->properties[i].desc->cimtype);
+ }
+
+ dst->u2_4 = src->u2_4;
+ dst->u3_1 = src->u3_1;
+}
+
+void duplicate_WbemClassObject(TALLOC_CTX *mem_ctx, const struct WbemClassObject *src, struct WbemClassObject *dst)
+{
+ dst->flags = src->flags;
+ if (src->flags & WCF_CLASS) {
+ dst->__SERVER = talloc_strdup(mem_ctx, src->__SERVER);
+ dst->__NAMESPACE = talloc_strdup(mem_ctx, src->__NAMESPACE);
+ }
+ if (src->flags & WCF_DECORATIONS) {
+ dst->sup_class = talloc_zero(mem_ctx, struct WbemClass);
+ duplicate_WbemClass(dst->sup_class, src->sup_class, dst->sup_class);
+
+ dst->sup_methods = talloc_zero(mem_ctx, struct WbemMethods);
+ duplicate_WbemMethods(dst->sup_methods, src->sup_methods, dst->sup_methods);
+
+ dst->obj_methods = talloc_zero(mem_ctx, struct WbemMethods);
+ duplicate_WbemMethods(dst->obj_methods, src->obj_methods, dst->obj_methods);
+ }
+ if (src->flags & (WCF_CLASS | WCF_INSTANCE)) {
+ dst->obj_class = talloc_zero(mem_ctx, struct WbemClass);
+ duplicate_WbemClass(dst->obj_class, src->obj_class, dst->obj_class);
+ }
+ if (src->flags & WCF_INSTANCE) {
+ dst->instance = talloc_zero(mem_ctx, struct WbemInstance);
+ duplicate_WbemInstance(dst->instance, src->instance, dst->instance, src->obj_class);
+ }
+}
+
+void duplicate_CIMVAR(TALLOC_CTX *mem_ctx, const union CIMVAR *src, union CIMVAR *dst, enum CIMTYPE_ENUMERATION cimtype)
+{
+ uint32_t i;
+
+ switch (cimtype & CIM_TYPEMASK) {
+ case CIM_SINT8:
+ case CIM_UINT8:
+ case CIM_SINT16:
+ case CIM_UINT16:
+ case CIM_SINT32:
+ case CIM_UINT32:
+ case CIM_SINT64:
+ case CIM_UINT64:
+ case CIM_REAL32:
+ case CIM_REAL64:
+ case CIM_BOOLEAN:
+ *dst = *src;
+ break;
+ case CIM_STRING:
+ case CIM_DATETIME:
+ case CIM_REFERENCE:
+ dst->v_string = talloc_strdup(mem_ctx, src->v_string);
+ break;
+ case CIM_OBJECT:
+ dst->v_object = talloc_zero(mem_ctx, struct WbemClassObject);
+ duplicate_WbemClassObject(dst->v_object, src->v_object, dst->v_object);
+ break;
+ case CIM_ARR_SINT8:
+ case CIM_ARR_UINT8:
+ dst->a_uint8 = talloc_memdup(mem_ctx, src->a_uint8, sizeof(struct arr_uint8));
+ dst->a_uint8->item = talloc_memdup(dst->a_uint8, src->a_uint8->item, src->a_uint8->count);
+ break;
+ case CIM_ARR_SINT16:
+ case CIM_ARR_UINT16:
+ case CIM_ARR_BOOLEAN:
+ dst->a_uint8 = talloc_memdup(mem_ctx, src->a_uint8, sizeof(struct arr_uint8));
+ dst->a_uint8->item = talloc_memdup(dst->a_uint8, src->a_uint8->item, 2*src->a_uint8->count);
+ break;
+ case CIM_ARR_SINT32:
+ case CIM_ARR_UINT32:
+ case CIM_ARR_REAL32:
+ dst->a_uint8 = talloc_memdup(mem_ctx, src->a_uint8, sizeof(struct arr_uint8));
+ dst->a_uint8->item = talloc_memdup(dst->a_uint8, src->a_uint8->item, 4*src->a_uint8->count);
+ break;
+ case CIM_ARR_SINT64:
+ case CIM_ARR_UINT64:
+ case CIM_ARR_REAL64:
+ dst->a_uint8 = talloc_memdup(mem_ctx, src->a_uint8, sizeof(struct arr_uint8));
+ dst->a_uint8->item = talloc_memdup(dst->a_uint8, src->a_uint8->item, 8*src->a_uint8->count);
+ break;
+ case CIM_ARR_STRING:
+ case CIM_ARR_DATETIME:
+ case CIM_ARR_REFERENCE:
+ dst->a_uint8 = talloc_memdup(mem_ctx, src->a_uint8, sizeof(struct arr_uint8));
+ dst->a_uint8->item = talloc_memdup(dst->a_uint8, src->a_uint8->item, 4*src->a_uint8->count);
+ for (i = 0; i < src->a_uint8->count; ++i)
+ dst->a_string->item[i] = talloc_strdup(dst->a_uint8->item, src->a_string->item[i]);
+ break;
+ default:
+ DEBUG(0, ("duplicate_CIMVAR: cimtype 0x%04X not supported\n", cimtype & CIM_TYPEMASK));
+ break;
+ }
+}
+
+WERROR WbemClassObject_Get(struct WbemClassObject *d, TALLOC_CTX *mem_ctx, const char *name, uint32_t flags, union CIMVAR *val, enum CIMTYPE_ENUMERATION *cimtype, uint32_t *flavor)
+{
+ uint32_t i;
+ for (i = 0; i < d->obj_class->__PROPERTY_COUNT; ++i) {
+ if (!strcmp(d->obj_class->properties[i].name, name)) {
+ duplicate_CIMVAR(mem_ctx, &d->instance->data[i], val, d->obj_class->properties[i].desc->cimtype);
+ if (cimtype) *cimtype = d->obj_class->properties[i].desc->cimtype;
+ if (flavor) *flavor = 0; // FIXME:avg implement flavor
+ return WERR_OK;
+ }
+ }
+ return WERR_NOT_FOUND;
+}
+
+WERROR IWbemClassObject_Put(struct IWbemClassObject *d, TALLOC_CTX *mem_ctx, const char *name, uint32_t flags, union CIMVAR *val, enum CIMTYPE_ENUMERATION cimtype)
+{
+ struct WbemClassObject *wco;
+ uint32_t i;
+
+ wco = (struct WbemClassObject *)d->object_data;
+ for (i = 0; i < wco->obj_class->__PROPERTY_COUNT; ++i) {
+ if (!strcmp(wco->obj_class->properties[i].name, name)) {
+ if (cimtype && cimtype != wco->obj_class->properties[i].desc->cimtype) return WERR_INVALID_PARAM;
+ wco->instance->default_flags[i] = 0;
+ duplicate_CIMVAR(wco->instance, val, &wco->instance->data[i], wco->obj_class->properties[i].desc->cimtype);
+ return WERR_OK;
+ }
+ }
+ return WERR_NOT_FOUND;
+}
+
+#define WERR_CHECK(msg) if (!W_ERROR_IS_OK(result)) { \
+ DEBUG(1, ("ERROR: %s - %s\n", msg, wmi_errstr(result))); \
+ goto end; \
+ } else { \
+ DEBUG(1, ("OK : %s\n", msg)); \
+ }
+
+struct pair_guid_ptr {
+ struct GUID guid;
+ void *ptr;
+ struct pair_guid_ptr *next, *prev;
+};
+
+static void *get_ptr_by_guid(struct pair_guid_ptr *list, struct GUID *uuid)
+{
+ for (; list; list = list->next) {
+ if (GUID_equal(&list->guid, uuid))
+ return list->ptr;
+ }
+ return NULL;
+}
+
+static void add_pair_guid_ptr(TALLOC_CTX *mem_ctx, struct pair_guid_ptr **list, struct GUID *uuid, void *ptr)
+{
+ struct pair_guid_ptr *e;
+
+ e = talloc(mem_ctx, struct pair_guid_ptr);
+ e->guid = *uuid;
+ e->ptr = ptr;
+ talloc_steal(e, ptr);
+ DLIST_ADD(*list, e);
+}
+
+struct IEnumWbemClassObject_data {
+ struct GUID guid;
+ struct IWbemFetchSmartEnum *pFSE;
+ struct IWbemWCOSmartEnum *pSE;
+ struct pair_guid_ptr *cache;
+};
+
+static NTSTATUS WBEMDATA_Parse(uint8_t *data, uint32_t size, struct IEnumWbemClassObject *d, uint32_t uCount, struct WbemClassObject **apObjects)
+{
+ struct ndr_pull *ndr;
+ TALLOC_CTX *mem_ctx;
+ uint32_t u, i, ofs_next;
+ uint8_t u8, datatype;
+ NTSTATUS status;
+ struct GUID guid;
+ struct IEnumWbemClassObject_data *ecod;
+
+ if (!uCount) return NT_STATUS_NOT_IMPLEMENTED;
+
+ ecod = d->object_data;
+ mem_ctx = talloc_new(0);
+
+ ndr = talloc_zero(mem_ctx, struct ndr_pull);
+ ndr->current_mem_ctx = d->ctx;
+ ndr->data = data;
+ ndr->data_size = size;
+ ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NOALIGN);
+
+ NDR_CHECK_set_shift(0x18);
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_CHECK_CONST(u, 0x0);
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_CHECK_CONST(u, *(const uint32_t *)"WBEM");
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_CHECK_CONST(u, *(const uint32_t *)"DATA");
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_CHECK_CONST(u, 0x1A); /* Length of header */
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_PULL_NEED_BYTES(ndr, u + 6);
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_CHECK_CONST(u, 0x0);
+ NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &u8));
+ NDR_CHECK_CONST(u8, 0x01); /* Major Version */
+ NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &u8));
+ NDR_CHECK_EXPR(u8 <= 1); /* Minor Version 0 - Win2000, 1 - XP/2003 */
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_CHECK_CONST(u, 0x8); /* Length of header */
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_PULL_NEED_BYTES(ndr, u);
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_CHECK_CONST(u, 0xC); /* Length of header */
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_PULL_NEED_BYTES(ndr, u + 4);
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_CHECK_CONST(u, uCount);
+ for (i = 0; i < uCount; ++i) {
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_CHECK_CONST(u, 0x9); /* Length of header */
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_PULL_NEED_BYTES(ndr, u + 1);
+ NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &datatype));
+ ofs_next = ndr->offset + u;
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_CHECK_CONST(u, 0x18); /* Length of header */
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &u));
+ NDR_PULL_NEED_BYTES(ndr, u + 16);
+ NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &guid));
+ switch (datatype) {
+ case DATATYPE_CLASSOBJECT:
+ apObjects[i] = talloc_zero(d->ctx, struct WbemClassObject);
+ ndr->current_mem_ctx = apObjects[i];
+ NDR_CHECK(ndr_pull_WbemClassObject(ndr, NDR_SCALARS|NDR_BUFFERS, apObjects[i]));
+ ndr->current_mem_ctx = d->ctx;
+ add_pair_guid_ptr(ecod, &ecod->cache, &guid, apObjects[i]->obj_class);
+ break;
+ case DATATYPE_OBJECT:
+ apObjects[i] = talloc_zero(d->ctx, struct WbemClassObject);
+ apObjects[i]->obj_class = get_ptr_by_guid(ecod->cache, &guid);
+ (void)talloc_reference(apObjects[i], apObjects[i]->obj_class);
+ ndr->current_mem_ctx = apObjects[i];
+ NDR_CHECK(ndr_pull_WbemClassObject_Object(ndr, NDR_SCALARS|NDR_BUFFERS, apObjects[i]));
+ ndr->current_mem_ctx = d->ctx;
+ break;
+ default:
+ DEBUG(0, ("WBEMDATA_Parse: Data type %d not supported\n", datatype));
+ status = NT_STATUS_NOT_SUPPORTED;
+ goto end;
+ }
+ ndr->offset = ofs_next;
+ if (DEBUGLVL(9)) {
+ NDR_PRINT_DEBUG(WbemClassObject, apObjects[i]);
+ }
+ }
+ status = NT_STATUS_OK;
+end:
+ talloc_free(mem_ctx);
+ return status;
+}
+
+struct composite_context *dcom_proxy_IEnumWbemClassObject_Release_send(struct IUnknown *d, TALLOC_CTX *mem_ctx);
+
+WERROR IEnumWbemClassObject_SmartNext(struct IEnumWbemClassObject *d, TALLOC_CTX *mem_ctx, int32_t lTimeout, uint32_t uCount, struct WbemClassObject **apObjects, uint32_t *puReturned)
+{
+ WERROR result;
+ NTSTATUS status;
+ struct IEnumWbemClassObject_data *ecod;
+ TALLOC_CTX *loc_ctx;
+ uint32_t size;
+ uint8_t *data;
+
+ loc_ctx = talloc_new(0);
+ ecod = d->object_data;
+ if (!ecod) {
+ struct GUID iid;
+ WERROR coresult;
+
+ d->object_data = ecod = talloc_zero(d, struct IEnumWbemClassObject_data);
+ GUID_from_string(COM_IWBEMFETCHSMARTENUM_UUID, &iid);
+ result = dcom_query_interface((struct IUnknown *)d, 5, 1, &iid, (struct IUnknown **)&ecod->pFSE, &coresult);
+ WERR_CHECK("dcom_query_interface.");
+ result = coresult;
+ WERR_CHECK("Retrieve enumerator of result(IWbemFetchSmartEnum).");
+
+ result = IWbemFetchSmartEnum_Fetch(ecod->pFSE, mem_ctx, &ecod->pSE);
+ WERR_CHECK("Retrieve enumerator of result(IWbemWCOSmartEnum).");
+
+ ecod->guid = GUID_random();
+ d->vtable->Release_send = dcom_proxy_IEnumWbemClassObject_Release_send;
+ }
+
+ result = IWbemWCOSmartEnum_Next(ecod->pSE, loc_ctx, &ecod->guid, lTimeout, uCount, puReturned, &size, &data);
+ if (!W_ERROR_EQUAL(result, WERR_BADFUNC)) {
+ WERR_CHECK("IWbemWCOSmartEnum_Next.");
+ }
+
+ if (data) {
+ status = WBEMDATA_Parse(data, size, d, *puReturned, apObjects);
+ result = ntstatus_to_werror(status);
+ WERR_CHECK("WBEMDATA_Parse.");
+ }
+end:
+ if (!W_ERROR_IS_OK(result)) {
+ status = werror_to_ntstatus(result);
+ DEBUG(9, ("dcom_proxy_IEnumWbemClassObject_Next: %s - %s\n", nt_errstr(status), get_friendly_nt_error_msg(status)));
+ }
+ talloc_free(loc_ctx);
+ return result;
+}
+
+struct composite_context *dcom_proxy_IEnumWbemClassObject_Release_send(struct IUnknown *d, TALLOC_CTX *mem_ctx)
+{
+ struct composite_context *c, *cr;
+ struct REMINTERFACEREF iref[3];
+ struct dcom_object_exporter *ox;
+ struct IEnumWbemClassObject_data *ecod;
+ int n;
+
+ c = composite_create(d->ctx, d->ctx->event_ctx);
+ if (c == NULL) return NULL;
+ c->private_data = d;
+
+ ox = object_exporter_by_ip(d->ctx, d);
+ iref[0].ipid = IUnknown_ipid(d);
+ iref[0].cPublicRefs = 5;
+ iref[0].cPrivateRefs = 0;
+ n = 1;
+
+ ecod = d->object_data;
+ if (ecod) {
+ if (ecod->pFSE) {
+ talloc_steal(d, ecod->pFSE);
+ iref[n].ipid = IUnknown_ipid(ecod->pFSE);
+ iref[n].cPublicRefs = 5;
+ iref[n].cPrivateRefs = 0;
+ ++n;
+ }
+ if (ecod->pSE) {
+ talloc_steal(d, ecod->pSE);
+ iref[n].ipid = IUnknown_ipid(ecod->pSE);
+ iref[n].cPublicRefs = 5;
+ iref[n].cPrivateRefs = 0;
+ ++n;
+ }
+ }
+ cr = IRemUnknown_RemRelease_send(ox->rem_unknown, mem_ctx, n, iref);
+
+ composite_continue(c, cr, dcom_release_continue, c);
+ return c;
+}
+
+NTSTATUS dcom_proxy_IWbemClassObject_init()
+{
+ struct GUID clsid;
+ GUID_from_string("4590f812-1d3a-11d0-891f-00aa004b2e24", &clsid);
+ dcom_register_marshal(&clsid, marshal, unmarshal);
+
+#if 0
+ struct IEnumWbemClassObject_vtable *proxy_vtable;
+ proxy_vtable = (struct IEnumWbemClassObject_vtable *)dcom_proxy_vtable_by_iid((struct GUID *)&dcerpc_table_IEnumWbemClassObject.syntax_id.uuid);
+ if (proxy_vtable)
+ proxy_vtable->Release_send = dcom_proxy_IEnumWbemClassObject_Release_send;
+ else
+ DEBUG(0, ("WARNING: IEnumWbemClassObject should be initialized before IWbemClassObject."));
+#endif
+
+ return NT_STATUS_OK;
+}
diff --git a/source4/lib/wmi/wmicore.c b/source4/lib/wmi/wmicore.c
new file mode 100644
index 0000000000..cb896f4a5d
--- /dev/null
+++ b/source4/lib/wmi/wmicore.c
@@ -0,0 +1,225 @@
+#include "includes.h"
+#include "auth/credentials/credentials.h"
+#include "librpc/gen_ndr/com_dcom.h"
+#include "lib/com/dcom/dcom.h"
+
+struct IWbemServices;
+struct IWbemContext;
+
+#define WERR_CHECK(msg) if (!W_ERROR_IS_OK(result)) { \
+ DEBUG(0, ("ERROR: %s\n", msg)); \
+ goto end; \
+ } else { \
+ DEBUG(1, ("OK : %s\n", msg)); \
+ }
+
+WERROR WBEM_ConnectServer(struct com_context *ctx, const char *server, const char *nspace, const char *user, const char *password,
+ const char *locale, uint32_t flags, const char *authority, struct IWbemContext* wbem_ctx, struct IWbemServices** services)
+{
+ struct GUID clsid;
+ struct GUID iid;
+ WERROR result, coresult;
+ struct IUnknown **mqi;
+ struct IWbemLevel1Login *pL;
+
+ if (user) {
+ char *cred;
+ struct cli_credentials *cc;
+
+ cred = talloc_asprintf(NULL, "%s%%%s", user, password);
+ cc = cli_credentials_init(cred);
+ cli_credentials_set_conf(cc);
+ cli_credentials_parse_string(cc, cred, CRED_SPECIFIED);
+ dcom_set_server_credentials(ctx, server, cc);
+ talloc_free(cred);
+ }
+
+ GUID_from_string(CLSID_WBEMLEVEL1LOGIN, &clsid);
+ GUID_from_string(COM_IWBEMLEVEL1LOGIN_UUID, &iid);
+ result = dcom_create_object(ctx, &clsid, server, 1, &iid, &mqi, &coresult);
+ WERR_CHECK("dcom_create_object.");
+ result = coresult;
+ WERR_CHECK("Create remote WMI object.");
+ pL = (struct IWbemLevel1Login *)mqi[0];
+ talloc_free(mqi);
+
+ result = IWbemLevel1Login_NTLMLogin(pL, ctx, nspace, locale, flags, wbem_ctx, services);
+ WERR_CHECK("Login to remote object.");
+
+ IUnknown_Release((struct IUnknown *)pL, ctx);
+end:
+ return result;
+}
+
+struct werror_code_struct {
+ const char *dos_errstr;
+ WERROR werror;
+};
+
+static const struct werror_code_struct wmi_errs[] =
+{
+ { "RPC_S_CALL_FAILED", W_ERROR(RPC_S_CALL_FAILED) },
+
+ { "WBEM_NO_ERROR", W_ERROR(WBEM_NO_ERROR) },
+ { "WBEM_S_NO_ERROR", W_ERROR(WBEM_S_NO_ERROR) },
+ { "WBEM_S_SAME", W_ERROR(WBEM_S_SAME) },
+ { "WBEM_S_FALSE", W_ERROR(WBEM_S_FALSE) },
+ { "WBEM_S_ALREADY_EXISTS", W_ERROR(WBEM_S_ALREADY_EXISTS) },
+ { "WBEM_S_RESET_TO_DEFAULT", W_ERROR(WBEM_S_RESET_TO_DEFAULT) },
+ { "WBEM_S_DIFFERENT", W_ERROR(WBEM_S_DIFFERENT) },
+ { "WBEM_S_TIMEDOUT", W_ERROR(WBEM_S_TIMEDOUT) },
+ { "WBEM_S_NO_MORE_DATA", W_ERROR(WBEM_S_NO_MORE_DATA) },
+ { "WBEM_S_OPERATION_CANCELLED", W_ERROR(WBEM_S_OPERATION_CANCELLED) },
+ { "WBEM_S_PENDING", W_ERROR(WBEM_S_PENDING) },
+ { "WBEM_S_DUPLICATE_OBJECTS", W_ERROR(WBEM_S_DUPLICATE_OBJECTS) },
+ { "WBEM_S_ACCESS_DENIED", W_ERROR(WBEM_S_ACCESS_DENIED) },
+ { "WBEM_S_PARTIAL_RESULTS", W_ERROR(WBEM_S_PARTIAL_RESULTS) },
+ { "WBEM_S_NO_POSTHOOK", W_ERROR(WBEM_S_NO_POSTHOOK) },
+ { "WBEM_S_POSTHOOK_WITH_BOTH", W_ERROR(WBEM_S_POSTHOOK_WITH_BOTH) },
+ { "WBEM_S_POSTHOOK_WITH_NEW", W_ERROR(WBEM_S_POSTHOOK_WITH_NEW) },
+ { "WBEM_S_POSTHOOK_WITH_STATUS", W_ERROR(WBEM_S_POSTHOOK_WITH_STATUS) },
+ { "WBEM_S_POSTHOOK_WITH_OLD", W_ERROR(WBEM_S_POSTHOOK_WITH_OLD) },
+ { "WBEM_S_REDO_PREHOOK_WITH_ORIGINAL_OBJECT", W_ERROR(WBEM_S_REDO_PREHOOK_WITH_ORIGINAL_OBJECT) },
+ { "WBEM_S_SOURCE_NOT_AVAILABLE", W_ERROR(WBEM_S_SOURCE_NOT_AVAILABLE) },
+ { "WBEM_E_FAILED", W_ERROR(WBEM_E_FAILED) },
+ { "WBEM_E_NOT_FOUND", W_ERROR(WBEM_E_NOT_FOUND) },
+ { "WBEM_E_ACCESS_DENIED", W_ERROR(WBEM_E_ACCESS_DENIED) },
+ { "WBEM_E_PROVIDER_FAILURE", W_ERROR(WBEM_E_PROVIDER_FAILURE) },
+ { "WBEM_E_TYPE_MISMATCH", W_ERROR(WBEM_E_TYPE_MISMATCH) },
+ { "WBEM_E_OUT_OF_MEMORY", W_ERROR(WBEM_E_OUT_OF_MEMORY) },
+ { "WBEM_E_INVALID_CONTEXT", W_ERROR(WBEM_E_INVALID_CONTEXT) },
+ { "WBEM_E_INVALID_PARAMETER", W_ERROR(WBEM_E_INVALID_PARAMETER) },
+ { "WBEM_E_NOT_AVAILABLE", W_ERROR(WBEM_E_NOT_AVAILABLE) },
+ { "WBEM_E_CRITICAL_ERROR", W_ERROR(WBEM_E_CRITICAL_ERROR) },
+ { "WBEM_E_INVALID_STREAM", W_ERROR(WBEM_E_INVALID_STREAM) },
+ { "WBEM_E_NOT_SUPPORTED", W_ERROR(WBEM_E_NOT_SUPPORTED) },
+ { "WBEM_E_INVALID_SUPERCLASS", W_ERROR(WBEM_E_INVALID_SUPERCLASS) },
+ { "WBEM_E_INVALID_NAMESPACE", W_ERROR(WBEM_E_INVALID_NAMESPACE) },
+ { "WBEM_E_INVALID_OBJECT", W_ERROR(WBEM_E_INVALID_OBJECT) },
+ { "WBEM_E_INVALID_CLASS", W_ERROR(WBEM_E_INVALID_CLASS) },
+ { "WBEM_E_PROVIDER_NOT_FOUND", W_ERROR(WBEM_E_PROVIDER_NOT_FOUND) },
+ { "WBEM_E_INVALID_PROVIDER_REGISTRATION", W_ERROR(WBEM_E_INVALID_PROVIDER_REGISTRATION) },
+ { "WBEM_E_PROVIDER_LOAD_FAILURE", W_ERROR(WBEM_E_PROVIDER_LOAD_FAILURE) },
+ { "WBEM_E_INITIALIZATION_FAILURE", W_ERROR(WBEM_E_INITIALIZATION_FAILURE) },
+ { "WBEM_E_TRANSPORT_FAILURE", W_ERROR(WBEM_E_TRANSPORT_FAILURE) },
+ { "WBEM_E_INVALID_OPERATION", W_ERROR(WBEM_E_INVALID_OPERATION) },
+ { "WBEM_E_INVALID_QUERY", W_ERROR(WBEM_E_INVALID_QUERY) },
+ { "WBEM_E_INVALID_QUERY_TYPE", W_ERROR(WBEM_E_INVALID_QUERY_TYPE) },
+ { "WBEM_E_ALREADY_EXISTS", W_ERROR(WBEM_E_ALREADY_EXISTS) },
+ { "WBEM_E_OVERRIDE_NOT_ALLOWED", W_ERROR(WBEM_E_OVERRIDE_NOT_ALLOWED) },
+ { "WBEM_E_PROPAGATED_QUALIFIER", W_ERROR(WBEM_E_PROPAGATED_QUALIFIER) },
+ { "WBEM_E_PROPAGATED_PROPERTY", W_ERROR(WBEM_E_PROPAGATED_PROPERTY) },
+ { "WBEM_E_UNEXPECTED", W_ERROR(WBEM_E_UNEXPECTED) },
+ { "WBEM_E_ILLEGAL_OPERATION", W_ERROR(WBEM_E_ILLEGAL_OPERATION) },
+ { "WBEM_E_CANNOT_BE_KEY", W_ERROR(WBEM_E_CANNOT_BE_KEY) },
+ { "WBEM_E_INCOMPLETE_CLASS", W_ERROR(WBEM_E_INCOMPLETE_CLASS) },
+ { "WBEM_E_INVALID_SYNTAX", W_ERROR(WBEM_E_INVALID_SYNTAX) },
+ { "WBEM_E_NONDECORATED_OBJECT", W_ERROR(WBEM_E_NONDECORATED_OBJECT) },
+ { "WBEM_E_READ_ONLY", W_ERROR(WBEM_E_READ_ONLY) },
+ { "WBEM_E_PROVIDER_NOT_CAPABLE", W_ERROR(WBEM_E_PROVIDER_NOT_CAPABLE) },
+ { "WBEM_E_CLASS_HAS_CHILDREN", W_ERROR(WBEM_E_CLASS_HAS_CHILDREN) },
+ { "WBEM_E_CLASS_HAS_INSTANCES", W_ERROR(WBEM_E_CLASS_HAS_INSTANCES) },
+ { "WBEM_E_QUERY_NOT_IMPLEMENTED", W_ERROR(WBEM_E_QUERY_NOT_IMPLEMENTED) },
+ { "WBEM_E_ILLEGAL_NULL", W_ERROR(WBEM_E_ILLEGAL_NULL) },
+ { "WBEM_E_INVALID_QUALIFIER_TYPE", W_ERROR(WBEM_E_INVALID_QUALIFIER_TYPE) },
+ { "WBEM_E_INVALID_PROPERTY_TYPE", W_ERROR(WBEM_E_INVALID_PROPERTY_TYPE) },
+ { "WBEM_E_VALUE_OUT_OF_RANGE", W_ERROR(WBEM_E_VALUE_OUT_OF_RANGE) },
+ { "WBEM_E_CANNOT_BE_SINGLETON", W_ERROR(WBEM_E_CANNOT_BE_SINGLETON) },
+ { "WBEM_E_INVALID_CIM_TYPE", W_ERROR(WBEM_E_INVALID_CIM_TYPE) },
+ { "WBEM_E_INVALID_METHOD", W_ERROR(WBEM_E_INVALID_METHOD) },
+ { "WBEM_E_INVALID_METHOD_PARAMETERS", W_ERROR(WBEM_E_INVALID_METHOD_PARAMETERS) },
+ { "WBEM_E_SYSTEM_PROPERTY", W_ERROR(WBEM_E_SYSTEM_PROPERTY) },
+ { "WBEM_E_INVALID_PROPERTY", W_ERROR(WBEM_E_INVALID_PROPERTY) },
+ { "WBEM_E_CALL_CANCELLED", W_ERROR(WBEM_E_CALL_CANCELLED) },
+ { "WBEM_E_SHUTTING_DOWN", W_ERROR(WBEM_E_SHUTTING_DOWN) },
+ { "WBEM_E_PROPAGATED_METHOD", W_ERROR(WBEM_E_PROPAGATED_METHOD) },
+ { "WBEM_E_UNSUPPORTED_PARAMETER", W_ERROR(WBEM_E_UNSUPPORTED_PARAMETER) },
+ { "WBEM_E_MISSING_PARAMETER_ID", W_ERROR(WBEM_E_MISSING_PARAMETER_ID) },
+ { "WBEM_E_INVALID_PARAMETER_ID", W_ERROR(WBEM_E_INVALID_PARAMETER_ID) },
+ { "WBEM_E_NONCONSECUTIVE_PARAMETER_IDS", W_ERROR(WBEM_E_NONCONSECUTIVE_PARAMETER_IDS) },
+ { "WBEM_E_PARAMETER_ID_ON_RETVAL", W_ERROR(WBEM_E_PARAMETER_ID_ON_RETVAL) },
+ { "WBEM_E_INVALID_OBJECT_PATH", W_ERROR(WBEM_E_INVALID_OBJECT_PATH) },
+ { "WBEM_E_OUT_OF_DISK_SPACE", W_ERROR(WBEM_E_OUT_OF_DISK_SPACE) },
+ { "WBEM_E_BUFFER_TOO_SMALL", W_ERROR(WBEM_E_BUFFER_TOO_SMALL) },
+ { "WBEM_E_UNSUPPORTED_PUT_EXTENSION", W_ERROR(WBEM_E_UNSUPPORTED_PUT_EXTENSION) },
+ { "WBEM_E_UNKNOWN_OBJECT_TYPE", W_ERROR(WBEM_E_UNKNOWN_OBJECT_TYPE) },
+ { "WBEM_E_UNKNOWN_PACKET_TYPE", W_ERROR(WBEM_E_UNKNOWN_PACKET_TYPE) },
+ { "WBEM_E_MARSHAL_VERSION_MISMATCH", W_ERROR(WBEM_E_MARSHAL_VERSION_MISMATCH) },
+ { "WBEM_E_MARSHAL_INVALID_SIGNATURE", W_ERROR(WBEM_E_MARSHAL_INVALID_SIGNATURE) },
+ { "WBEM_E_INVALID_QUALIFIER", W_ERROR(WBEM_E_INVALID_QUALIFIER) },
+ { "WBEM_E_INVALID_DUPLICATE_PARAMETER", W_ERROR(WBEM_E_INVALID_DUPLICATE_PARAMETER) },
+ { "WBEM_E_TOO_MUCH_DATA", W_ERROR(WBEM_E_TOO_MUCH_DATA) },
+ { "WBEM_E_SERVER_TOO_BUSY", W_ERROR(WBEM_E_SERVER_TOO_BUSY) },
+ { "WBEM_E_INVALID_FLAVOR", W_ERROR(WBEM_E_INVALID_FLAVOR) },
+ { "WBEM_E_CIRCULAR_REFERENCE", W_ERROR(WBEM_E_CIRCULAR_REFERENCE) },
+ { "WBEM_E_UNSUPPORTED_CLASS_UPDATE", W_ERROR(WBEM_E_UNSUPPORTED_CLASS_UPDATE) },
+ { "WBEM_E_CANNOT_CHANGE_KEY_INHERITANCE", W_ERROR(WBEM_E_CANNOT_CHANGE_KEY_INHERITANCE) },
+ { "WBEM_E_CANNOT_CHANGE_INDEX_INHERITANCE", W_ERROR(WBEM_E_CANNOT_CHANGE_INDEX_INHERITANCE) },
+ { "WBEM_E_TOO_MANY_PROPERTIES", W_ERROR(WBEM_E_TOO_MANY_PROPERTIES) },
+ { "WBEM_E_UPDATE_TYPE_MISMATCH", W_ERROR(WBEM_E_UPDATE_TYPE_MISMATCH) },
+ { "WBEM_E_UPDATE_OVERRIDE_NOT_ALLOWED", W_ERROR(WBEM_E_UPDATE_OVERRIDE_NOT_ALLOWED) },
+ { "WBEM_E_UPDATE_PROPAGATED_METHOD", W_ERROR(WBEM_E_UPDATE_PROPAGATED_METHOD) },
+ { "WBEM_E_METHOD_NOT_IMPLEMENTED", W_ERROR(WBEM_E_METHOD_NOT_IMPLEMENTED) },
+ { "WBEM_E_METHOD_DISABLED", W_ERROR(WBEM_E_METHOD_DISABLED) },
+ { "WBEM_E_REFRESHER_BUSY", W_ERROR(WBEM_E_REFRESHER_BUSY) },
+ { "WBEM_E_UNPARSABLE_QUERY", W_ERROR(WBEM_E_UNPARSABLE_QUERY) },
+ { "WBEM_E_NOT_EVENT_CLASS", W_ERROR(WBEM_E_NOT_EVENT_CLASS) },
+ { "WBEM_E_MISSING_GROUP_WITHIN", W_ERROR(WBEM_E_MISSING_GROUP_WITHIN) },
+ { "WBEM_E_MISSING_AGGREGATION_LIST", W_ERROR(WBEM_E_MISSING_AGGREGATION_LIST) },
+ { "WBEM_E_PROPERTY_NOT_AN_OBJECT", W_ERROR(WBEM_E_PROPERTY_NOT_AN_OBJECT) },
+ { "WBEM_E_AGGREGATING_BY_OBJECT", W_ERROR(WBEM_E_AGGREGATING_BY_OBJECT) },
+ { "WBEM_E_UNINTERPRETABLE_PROVIDER_QUERY", W_ERROR(WBEM_E_UNINTERPRETABLE_PROVIDER_QUERY) },
+ { "WBEM_E_BACKUP_RESTORE_WINMGMT_RUNNING", W_ERROR(WBEM_E_BACKUP_RESTORE_WINMGMT_RUNNING) },
+ { "WBEM_E_QUEUE_OVERFLOW", W_ERROR(WBEM_E_QUEUE_OVERFLOW) },
+ { "WBEM_E_PRIVILEGE_NOT_HELD", W_ERROR(WBEM_E_PRIVILEGE_NOT_HELD) },
+ { "WBEM_E_INVALID_OPERATOR", W_ERROR(WBEM_E_INVALID_OPERATOR) },
+ { "WBEM_E_LOCAL_CREDENTIALS", W_ERROR(WBEM_E_LOCAL_CREDENTIALS) },
+ { "WBEM_E_CANNOT_BE_ABSTRACT", W_ERROR(WBEM_E_CANNOT_BE_ABSTRACT) },
+ { "WBEM_E_AMENDED_OBJECT", W_ERROR(WBEM_E_AMENDED_OBJECT) },
+ { "WBEM_E_CLIENT_TOO_SLOW", W_ERROR(WBEM_E_CLIENT_TOO_SLOW) },
+ { "WBEM_E_NULL_SECURITY_DESCRIPTOR", W_ERROR(WBEM_E_NULL_SECURITY_DESCRIPTOR) },
+ { "WBEM_E_TIMED_OUT", W_ERROR(WBEM_E_TIMED_OUT) },
+ { "WBEM_E_INVALID_ASSOCIATION", W_ERROR(WBEM_E_INVALID_ASSOCIATION) },
+ { "WBEM_E_AMBIGUOUS_OPERATION", W_ERROR(WBEM_E_AMBIGUOUS_OPERATION) },
+ { "WBEM_E_QUOTA_VIOLATION", W_ERROR(WBEM_E_QUOTA_VIOLATION) },
+ { "WBEM_E_RESERVED_001", W_ERROR(WBEM_E_RESERVED_001) },
+ { "WBEM_E_RESERVED_002", W_ERROR(WBEM_E_RESERVED_002) },
+ { "WBEM_E_UNSUPPORTED_LOCALE", W_ERROR(WBEM_E_UNSUPPORTED_LOCALE) },
+ { "WBEM_E_HANDLE_OUT_OF_DATE", W_ERROR(WBEM_E_HANDLE_OUT_OF_DATE) },
+ { "WBEM_E_CONNECTION_FAILED", W_ERROR(WBEM_E_CONNECTION_FAILED) },
+ { "WBEM_E_INVALID_HANDLE_REQUEST", W_ERROR(WBEM_E_INVALID_HANDLE_REQUEST) },
+ { "WBEM_E_PROPERTY_NAME_TOO_WIDE", W_ERROR(WBEM_E_PROPERTY_NAME_TOO_WIDE) },
+ { "WBEM_E_CLASS_NAME_TOO_WIDE", W_ERROR(WBEM_E_CLASS_NAME_TOO_WIDE) },
+ { "WBEM_E_METHOD_NAME_TOO_WIDE", W_ERROR(WBEM_E_METHOD_NAME_TOO_WIDE) },
+ { "WBEM_E_QUALIFIER_NAME_TOO_WIDE", W_ERROR(WBEM_E_QUALIFIER_NAME_TOO_WIDE) },
+ { "WBEM_E_RERUN_COMMAND", W_ERROR(WBEM_E_RERUN_COMMAND) },
+ { "WBEM_E_DATABASE_VER_MISMATCH", W_ERROR(WBEM_E_DATABASE_VER_MISMATCH) },
+ { "WBEM_E_VETO_DELETE", W_ERROR(WBEM_E_VETO_DELETE) },
+ { "WBEM_E_VETO_PUT", W_ERROR(WBEM_E_VETO_PUT) },
+ { "WBEM_E_INVALID_LOCALE", W_ERROR(WBEM_E_INVALID_LOCALE) },
+ { "WBEM_E_PROVIDER_SUSPENDED", W_ERROR(WBEM_E_PROVIDER_SUSPENDED) },
+ { "WBEM_E_SYNCHRONIZATION_REQUIRED", W_ERROR(WBEM_E_SYNCHRONIZATION_REQUIRED) },
+ { "WBEM_E_NO_SCHEMA", W_ERROR(WBEM_E_NO_SCHEMA) },
+ { "WBEM_E_PROVIDER_ALREADY_REGISTERED", W_ERROR(WBEM_E_PROVIDER_ALREADY_REGISTERED) },
+ { "WBEM_E_PROVIDER_NOT_REGISTERED", W_ERROR(WBEM_E_PROVIDER_NOT_REGISTERED) },
+ { "WBEM_E_FATAL_TRANSPORT_ERROR", W_ERROR(WBEM_E_FATAL_TRANSPORT_ERROR) },
+ { "WBEM_E_ENCRYPTED_CONNECTION_REQUIRED", W_ERROR(WBEM_E_ENCRYPTED_CONNECTION_REQUIRED) },
+ { "WBEM_E_PROVIDER_TIMED_OUT", W_ERROR(WBEM_E_PROVIDER_TIMED_OUT) },
+ { "WBEM_E_NO_KEY", W_ERROR(WBEM_E_NO_KEY) },
+ { "WBEM_E_PROVIDER_DISABLED", W_ERROR(WBEM_E_PROVIDER_DISABLED) },
+ { NULL, W_ERROR(0) }
+};
+
+const char *wmi_errstr(WERROR werror)
+{
+ int idx = 0;
+
+ while (wmi_errs[idx].dos_errstr != NULL) {
+ if (W_ERROR_V(wmi_errs[idx].werror) ==
+ W_ERROR_V(werror))
+ return wmi_errs[idx].dos_errstr;
+ idx++;
+ }
+
+ return win_errstr(werror);
+}
generated by cgit (git 2.34.1) at 2024-12-26 20:50:56 +0000