Signed-off-by: Hans Leidekker <hans(a)codeweavers.com>
---
dlls/wbemprox/builtin.c | 680 ++++++++++++++++++++++++-------
dlls/wbemprox/wbemprox_private.h | 10 +
2 files changed, 538 insertions(+), 152 deletions(-)
diff --git a/dlls/wbemprox/builtin.c b/dlls/wbemprox/builtin.c
index 8c4ebe44b0..14f826f0e3 100644
--- a/dlls/wbemprox/builtin.c
+++ b/dlls/wbemprox/builtin.c
@@ -425,23 +425,23 @@ static const WCHAR prop_workingsetsizeW[] =
/* column definitions must be kept in sync with record structures below */
static const struct column col_baseboard[] =
{
- { prop_manufacturerW, CIM_STRING },
+ { prop_manufacturerW, CIM_STRING|COL_FLAG_DYNAMIC },
{ prop_modelW, CIM_STRING },
{ prop_nameW, CIM_STRING },
- { prop_productW, CIM_STRING },
- { prop_serialnumberW, CIM_STRING },
+ { prop_productW, CIM_STRING|COL_FLAG_DYNAMIC },
+ { prop_serialnumberW, CIM_STRING|COL_FLAG_DYNAMIC },
{ prop_tagW, CIM_STRING|COL_FLAG_KEY },
- { prop_versionW, CIM_STRING }
+ { prop_versionW, CIM_STRING|COL_FLAG_DYNAMIC }
};
static const struct column col_bios[] =
{
{ prop_descriptionW, CIM_STRING },
{ prop_identificationcodeW, CIM_STRING },
- { prop_manufacturerW, CIM_STRING },
+ { prop_manufacturerW, CIM_STRING|COL_FLAG_DYNAMIC },
{ prop_nameW, CIM_STRING },
- { prop_releasedateW, CIM_DATETIME },
+ { prop_releasedateW, CIM_DATETIME|COL_FLAG_DYNAMIC },
{ prop_serialnumberW, CIM_STRING },
- { prop_smbiosbiosversionW, CIM_STRING },
+ { prop_smbiosbiosversionW, CIM_STRING|COL_FLAG_DYNAMIC },
{ prop_smbiosmajorversionW, CIM_UINT16, VT_I4 },
{ prop_smbiosminorversionW, CIM_UINT16, VT_I4 },
{ prop_versionW, CIM_STRING|COL_FLAG_KEY }
@@ -469,12 +469,12 @@ static const struct column col_compsys[] =
};
static const struct column col_compsysproduct[] =
{
- { prop_identifyingnumberW, CIM_STRING|COL_FLAG_KEY },
- { prop_nameW, CIM_STRING|COL_FLAG_KEY },
+ { prop_identifyingnumberW, CIM_STRING|COL_FLAG_DYNAMIC|COL_FLAG_KEY },
+ { prop_nameW, CIM_STRING|COL_FLAG_DYNAMIC|COL_FLAG_KEY },
{ prop_skunumberW, CIM_STRING },
{ prop_uuidW, CIM_STRING|COL_FLAG_DYNAMIC },
- { prop_vendorW, CIM_STRING },
- { prop_versionW, CIM_STRING|COL_FLAG_KEY }
+ { prop_vendorW, CIM_STRING|COL_FLAG_DYNAMIC },
+ { prop_versionW, CIM_STRING|COL_FLAG_DYNAMIC|COL_FLAG_KEY }
};
static const struct column col_datafile[] =
{
@@ -716,10 +716,10 @@ static const struct column col_stdregprov[] =
static const struct column col_systemenclosure[] =
{
{ prop_captionW, CIM_STRING },
- { prop_chassistypesW, CIM_UINT16|CIM_FLAG_ARRAY, VT_I4|VT_ARRAY },
+ { prop_chassistypesW, CIM_UINT16|CIM_FLAG_ARRAY|COL_FLAG_DYNAMIC, VT_I4|VT_ARRAY },
{ prop_descriptionW, CIM_STRING },
{ prop_lockpresentW, CIM_BOOLEAN },
- { prop_manufacturerW, CIM_STRING },
+ { prop_manufacturerW, CIM_STRING|COL_FLAG_DYNAMIC },
{ prop_nameW, CIM_STRING },
{ prop_tagW, CIM_STRING },
};
@@ -766,8 +766,6 @@ static const WCHAR bios_descriptionW[] =
{'D','e','f','a','u','l','t',' ','S','y','s','t','e','m',' ','B','I','O','S',0};
static const WCHAR bios_manufacturerW[] =
{'T','h','e',' ','W','i','n','e',' ','P','r','o','j','e','c','t',0};
-static const WCHAR bios_nameW[] =
- {'W','I','N','E',' ','B','I','O','S',0};
static const WCHAR bios_releasedateW[] =
{'2','0','1','2','0','6','0','8','0','0','0','0','0','0','.','0','0','0','0','0','0','+','0','0','0',0};
static const WCHAR bios_serialnumberW[] =
@@ -1149,13 +1147,13 @@ struct record_systemsecurity
};
struct record_systemenclosure
{
- const WCHAR *caption;
+ const WCHAR *caption;
const struct array *chassistypes;
- const WCHAR *description;
- int lockpresent;
- const WCHAR *manufacturer;
- const WCHAR *name;
- const WCHAR *tag;
+ const WCHAR *description;
+ int lockpresent;
+ const WCHAR *manufacturer;
+ const WCHAR *name;
+ const WCHAR *tag;
};
struct record_videocontroller
{
@@ -1184,15 +1182,6 @@ struct record_videocontroller
};
#include "poppack.h"
-static const struct record_baseboard data_baseboard[] =
-{
- { baseboard_manufacturerW, baseboard_tagW, baseboard_tagW, baseboard_tagW, baseboard_serialnumberW, baseboard_versionW }
-};
-static const struct record_bios data_bios[] =
-{
- { bios_descriptionW, NULL, bios_manufacturerW, bios_nameW, bios_releasedateW, bios_serialnumberW,
- bios_smbiosbiosversionW, 1, 0, bios_versionW }
-};
static const struct record_param data_param[] =
{
{ class_processW, method_getownerW, -1, param_returnvalueW, CIM_UINT32, VT_I4 },
@@ -1255,18 +1244,6 @@ static const struct array systemenclosure_chassistypes_array =
ARRAY_SIZE(systemenclosure_chassistypes),
&systemenclosure_chassistypes
};
-static const struct record_systemenclosure data_systemenclosure[] =
-{
- {
- systemenclosure_systemenclosureW,
- &systemenclosure_chassistypes_array,
- systemenclosure_systemenclosureW,
- FALSE,
- systemenclosure_manufacturerW,
- systemenclosure_systemenclosureW,
- systemenclosure_tagW,
- }
-};
static const struct record_systemsecurity data_systemsecurity[] =
{
{ security_get_sd, security_set_sd }
@@ -1311,6 +1288,317 @@ static BOOL resize_table( struct table *table, UINT row_count, UINT row_size )
return TRUE;
}
+#include "pshpack1.h"
+struct smbios_prologue
+{
+ BYTE calling_method;
+ BYTE major_version;
+ BYTE minor_version;
+ BYTE revision;
+ DWORD length;
+};
+
+enum smbios_type
+{
+ SMBIOS_TYPE_BIOS,
+ SMBIOS_TYPE_SYSTEM,
+ SMBIOS_TYPE_BASEBOARD,
+ SMBIOS_TYPE_CHASSIS,
+};
+
+struct smbios_header
+{
+ BYTE type;
+ BYTE length;
+ WORD handle;
+};
+
+struct smbios_baseboard
+{
+ struct smbios_header hdr;
+ BYTE vendor;
+ BYTE product;
+ BYTE version;
+ BYTE serial;
+};
+
+struct smbios_bios
+{
+ struct smbios_header hdr;
+ BYTE vendor;
+ BYTE version;
+ WORD start;
+ BYTE date;
+ BYTE size;
+ UINT64 characteristics;
+};
+
+struct smbios_chassis
+{
+ struct smbios_header hdr;
+ BYTE vendor;
+ BYTE type;
+ BYTE version;
+ BYTE serial;
+ BYTE asset_tag;
+};
+
+struct smbios_system
+{
+ struct smbios_header hdr;
+ BYTE vendor;
+ BYTE product;
+ BYTE version;
+ BYTE serial;
+ BYTE uuid[16];
+};
+#include "poppack.h"
+
+#define RSMB (('R' << 24) | ('S' << 16) | ('M' << 8) | 'B')
+
+static const struct smbios_header *find_smbios_entry( enum smbios_type type, const char *buf, UINT len )
+{
+ const char *ptr, *start;
+ const struct smbios_prologue *prologue;
+ const struct smbios_header *hdr;
+
+ if (len < sizeof(struct smbios_prologue)) return NULL;
+ prologue = (const struct smbios_prologue *)buf;
+ if (prologue->length > len - sizeof(*prologue) || prologue->length < sizeof(*hdr)) return NULL;
+
+ start = (const char *)(prologue + 1);
+ hdr = (const struct smbios_header *)start;
+
+ for (;;)
+ {
+ if ((const char *)hdr - start >= prologue->length - sizeof(*hdr)) return NULL;
+
+ if (!hdr->length)
+ {
+ WARN( "invalid entry\n" );
+ return NULL;
+ }
+
+ if (hdr->type == type)
+ {
+ if ((const char *)hdr - start + hdr->length > prologue->length) return NULL;
+ break;
+ }
+ else /* skip other entries and their strings */
+ {
+ for (ptr = (const char *)hdr + hdr->length; ptr - buf < len && *ptr; ptr++)
+ {
+ for (; ptr - buf < len; ptr++) if (!*ptr) break;
+ }
+ if (ptr == (const char *)hdr + hdr->length) ptr++;
+ hdr = (const struct smbios_header *)(ptr + 1);
+ }
+ }
+
+ return hdr;
+}
+
+static WCHAR *get_smbios_string( BYTE id, const char *buf, UINT offset, UINT buflen )
+{
+ const char *ptr = buf + offset;
+ UINT i = 0;
+
+ if (!id || offset >= buflen) return NULL;
+ for (ptr = buf + offset; ptr - buf < buflen && *ptr; ptr++)
+ {
+ if (++i == id) return heap_strdupAW( ptr );
+ for (; ptr - buf < buflen; ptr++) if (!*ptr) break;
+ }
+ return NULL;
+}
+
+static WCHAR *get_baseboard_string( BYTE id, const char *buf, UINT len )
+{
+ const struct smbios_header *hdr;
+ const struct smbios_baseboard *baseboard;
+ UINT offset;
+
+ if (!(hdr = find_smbios_entry( SMBIOS_TYPE_BASEBOARD, buf, len ))) return NULL;
+
+ baseboard = (const struct smbios_baseboard *)hdr;
+ offset = (const char *)baseboard - buf + baseboard->hdr.length;
+ return get_smbios_string( id, buf, offset, len );
+}
+
+static WCHAR *get_baseboard_manufacturer( const char *buf, UINT len )
+{
+ WCHAR *ret = get_baseboard_string( 1, buf, len );
+ if (!ret) return heap_strdupW( baseboard_manufacturerW );
+ return ret;
+}
+
+static WCHAR *get_baseboard_product( const char *buf, UINT len )
+{
+ WCHAR *ret = get_baseboard_string( 2, buf, len );
+ if (!ret) return heap_strdupW( baseboard_tagW );
+ return ret;
+}
+
+static WCHAR *get_baseboard_serialnumber( const char *buf, UINT len )
+{
+ WCHAR *ret = get_baseboard_string( 4, buf, len );
+ if (!ret) return heap_strdupW( baseboard_serialnumberW );
+ return ret;
+}
+
+static WCHAR *get_baseboard_version( const char *buf, UINT len )
+{
+ WCHAR *ret = get_baseboard_string( 3, buf, len );
+ if (!ret) return heap_strdupW( baseboard_versionW );
+ return ret;
+}
+
+static enum fill_status fill_baseboard( struct table *table, const struct expr *cond )
+{
+ struct record_baseboard *rec;
+ enum fill_status status = FILL_STATUS_UNFILTERED;
+ UINT row = 0, len;
+ char *buf;
+
+ if (!resize_table( table, 1, sizeof(*rec) )) return FILL_STATUS_FAILED;
+
+ len = GetSystemFirmwareTable( RSMB, 0, NULL, 0 );
+ if (!(buf = heap_alloc( len ))) return FILL_STATUS_FAILED;
+ GetSystemFirmwareTable( RSMB, 0, buf, len );
+
+ rec = (struct record_baseboard *)table->data;
+ rec->manufacturer = get_baseboard_manufacturer( buf, len );
+ rec->model = baseboard_tagW;
+ rec->name = baseboard_tagW;
+ rec->product = get_baseboard_product( buf, len );
+ rec->serialnumber = get_baseboard_serialnumber( buf, len );;
+ rec->tag = baseboard_tagW;
+ rec->version = get_baseboard_version( buf, len );
+ if (!match_row( table, row, cond, &status )) free_row_values( table, row );
+ else row++;
+
+ heap_free( buf );
+
+ TRACE("created %u rows\n", row);
+ table->num_rows = row;
+ return status;
+}
+
+static UINT16 get_bios_smbiosmajorversion( const char *buf, UINT len )
+{
+ const struct smbios_prologue *prologue = (const struct smbios_prologue *)buf;
+ if (len < sizeof(*prologue)) return 2;
+ return prologue->major_version;
+}
+
+static UINT16 get_bios_smbiosminorversion( const char *buf, UINT len )
+{
+ const struct smbios_prologue *prologue = (const struct smbios_prologue *)buf;
+ if (len < sizeof(*prologue)) return 0;
+ return prologue->minor_version;
+}
+
+static WCHAR *get_bios_string( BYTE id, const char *buf, UINT len )
+{
+ const struct smbios_header *hdr;
+ const struct smbios_bios *bios;
+ UINT offset;
+
+ if (!(hdr = find_smbios_entry( SMBIOS_TYPE_BIOS, buf, len ))) return NULL;
+
+ bios = (const struct smbios_bios *)hdr;
+ offset = (const char *)bios - buf + bios->hdr.length;
+ return get_smbios_string( id, buf, offset, len );
+}
+
+static WCHAR *get_bios_manufacturer( const char *buf, UINT len )
+{
+ WCHAR *ret = get_bios_string( 1, buf, len );
+ if (!ret) return heap_strdupW( bios_manufacturerW );
+ return ret;
+}
+
+static WCHAR *convert_bios_date( const WCHAR *str )
+{
+ static const WCHAR fmtW[] =
+ {'%','0','4','u','%','0','2','u','%','0','2','u','0','0','0','0','0','0','.','0','0','0','0','0','0','+','0','0','0',0};
+ UINT year, month, day, len = lstrlenW( str );
+ const WCHAR *p = str, *q;
+ WCHAR *ret;
+
+ while (len && iswspace( *p )) { p++; len--; }
+ while (len && iswspace( p[len - 1] )) { len--; }
+
+ q = p;
+ while (len && iswdigit( *q )) { q++; len--; };
+ if (q - p != 2 || !len || *q != '/') return NULL;
+ month = (p[0] - '0') * 10 + p[1] - '0';
+
+ p = ++q; len--;
+ while (len && iswdigit( *q )) { q++; len--; };
+ if (q - p != 2 || !len || *q != '/') return NULL;
+ day = (p[0] - '0') * 10 + p[1] - '0';
+
+ p = ++q; len--;
+ while (len && iswdigit( *q )) { q++; len--; };
+ if (q - p == 4) year = (p[0] - '0') * 1000 + (p[1] - '0') * 100 + (p[2] - '0') * 10 + p[3] - '0';
+ else if (q - p == 2) year = 1900 + (p[0] - '0') * 10 + p[1] - '0';
+ else return NULL;
+
+ if (!(ret = heap_alloc( sizeof(fmtW) ))) return NULL;
+ swprintf( ret, ARRAY_SIZE(fmtW), fmtW, year, month, day );
+ return ret;
+}
+
+static WCHAR *get_bios_releasedate( const char *buf, UINT len )
+{
+ WCHAR *ret, *date = get_bios_string( 3, buf, len );
+ if (!date || !(ret = convert_bios_date( date ))) ret = heap_strdupW( bios_releasedateW );
+ heap_free( date );
+ return ret;
+}
+
+static WCHAR *get_bios_smbiosbiosversion( const char *buf, UINT len )
+{
+ WCHAR *ret = get_bios_string( 2, buf, len );
+ if (!ret) return heap_strdupW( bios_smbiosbiosversionW );
+ return ret;
+}
+
+static enum fill_status fill_bios( struct table *table, const struct expr *cond )
+{
+ struct record_bios *rec;
+ enum fill_status status = FILL_STATUS_UNFILTERED;
+ UINT row = 0, len;
+ char *buf;
+
+ if (!resize_table( table, 1, sizeof(*rec) )) return FILL_STATUS_FAILED;
+
+ len = GetSystemFirmwareTable( RSMB, 0, NULL, 0 );
+ if (!(buf = heap_alloc( len ))) return FILL_STATUS_FAILED;
+ GetSystemFirmwareTable( RSMB, 0, buf, len );
+
+ rec = (struct record_bios *)table->data;
+ rec->description = bios_descriptionW;
+ rec->identificationcode = NULL;
+ rec->manufacturer = get_bios_manufacturer( buf, len );
+ rec->name = bios_descriptionW;
+ rec->releasedate = get_bios_releasedate( buf, len );
+ rec->serialnumber = bios_serialnumberW;
+ rec->smbiosbiosversion = get_bios_smbiosbiosversion( buf, len );
+ rec->smbiosmajorversion = get_bios_smbiosmajorversion( buf, len );
+ rec->smbiosminorversion = get_bios_smbiosminorversion( buf, len );
+ rec->version = bios_versionW;
+ if (!match_row( table, row, cond, &status )) free_row_values( table, row );
+ else row++;
+
+ heap_free( buf );
+
+ TRACE("created %u rows\n", row);
+ table->num_rows = row;
+ return status;
+}
+
static enum fill_status fill_cdromdrive( struct table *table, const struct expr *cond )
{
static const WCHAR fmtW[] = {'%','c',':',0};
@@ -1476,114 +1764,97 @@ static enum fill_status fill_compsys( struct table *table, const struct expr *co
return status;
}
-#include "pshpack1.h"
-struct smbios_prologue
+static WCHAR *get_compsysproduct_string( BYTE id, const char *buf, UINT len )
{
- BYTE calling_method;
- BYTE major_version;
- BYTE minor_version;
- BYTE revision;
- DWORD length;
-};
+ const struct smbios_header *hdr;
+ const struct smbios_system *system;
+ UINT offset;
-struct smbios_header
-{
- BYTE type;
- BYTE length;
- WORD handle;
-};
+ if (!(hdr = find_smbios_entry( SMBIOS_TYPE_SYSTEM, buf, len ))) return NULL;
-struct smbios_system
+ system = (const struct smbios_system *)hdr;
+ offset = (const char *)system - buf + system->hdr.length;
+ return get_smbios_string( id, buf, offset, len );
+}
+
+static WCHAR *get_compsysproduct_identifyingnumber( const char *buf, UINT len )
{
- struct smbios_header hdr;
- BYTE vendor;
- BYTE product;
- BYTE version;
- BYTE serial;
- BYTE uuid[16];
-};
-#include "poppack.h"
+ WCHAR *ret = get_compsysproduct_string( 4, buf, len );
+ if (!ret) return heap_strdupW( compsysproduct_identifyingnumberW );
+ return ret;
+}
-#define RSMB (('R' << 24) | ('S' << 16) | ('M' << 8) | 'B')
+static WCHAR *get_compsysproduct_name( const char *buf, UINT len )
+{
+ WCHAR *ret = get_compsysproduct_string( 2, buf, len );
+ if (!ret) return heap_strdupW( compsysproduct_nameW );
+ return ret;
+}
-static WCHAR *get_compsysproduct_uuid(void)
+static WCHAR *get_compsysproduct_uuid( const char *buf, UINT len )
{
static const WCHAR fmtW[] =
{'%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','-',
'%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X',
'%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X',0};
static const BYTE none[] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
- ULONG len;
- char *buf = NULL;
- const char *ptr, *start;
- const struct smbios_prologue *prologue;
const struct smbios_header *hdr;
const struct smbios_system *system;
- const BYTE *uuid = NULL;
+ const BYTE *ptr;
WCHAR *ret = NULL;
- if ((len = GetSystemFirmwareTable( RSMB, 0, NULL, 0 )) < sizeof(*prologue) ) goto done;
- if (!(buf = heap_alloc( len ))) goto done;
- GetSystemFirmwareTable( RSMB, 0, buf, len );
+ if (!(hdr = find_smbios_entry( SMBIOS_TYPE_SYSTEM, buf, len )) || hdr->length < sizeof(*system)) goto done;
+ system = (const struct smbios_system *)hdr;
+ if (!memcmp( system->uuid, none, sizeof(none) ) || !(ret = heap_alloc( 37 * sizeof(WCHAR) ))) goto done;
- prologue = (const struct smbios_prologue *)buf;
- if (prologue->length < sizeof(*hdr)) goto done;
- start = (const char *)(prologue + 1);
- hdr = (const struct smbios_header *)start;
-
- for (;;)
- {
- if (uuid || (const char *)hdr - start >= prologue->length - sizeof(*hdr)) break;
- if (!hdr->length)
- {
- WARN( "invalid entry\n" );
- break;
- }
-
- switch (hdr->type)
- {
- case 1: /* system entry */
- if (hdr->length < sizeof(*system) || (const char *)hdr - start + hdr->length > prologue->length) break;
- system = (const struct smbios_system *)hdr;
- uuid = system->uuid;
- break;
-
- default: /* skip other entries */
- for (ptr = (const char *)hdr + hdr->length; *ptr; ptr += strlen(ptr) + 1) { /* nothing */ }
- if (ptr == (const char *)hdr + hdr->length) ptr++;
- hdr = (const struct smbios_header *)(ptr + 1);
- break;
- }
- }
- if (!uuid || !memcmp( uuid, none, sizeof(none) ) || !(ret = heap_alloc( 37 * sizeof(WCHAR) ))) goto done;
-
- swprintf( ret, 37, fmtW, uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5], uuid[6], uuid[7], uuid[8],
- uuid[9], uuid[10], uuid[11], uuid[12], uuid[13], uuid[14], uuid[15] );
+ ptr = system->uuid;
+ swprintf( ret, 37, fmtW, ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7], ptr[8], ptr[9],
+ ptr[10], ptr[11], ptr[12], ptr[13], ptr[14], ptr[15] );
done:
- heap_free( buf );
if (!ret) ret = heap_strdupW( compsysproduct_uuidW );
return ret;
}
+static WCHAR *get_compsysproduct_vendor( const char *buf, UINT len )
+{
+ WCHAR *ret = get_compsysproduct_string( 1, buf, len );
+ if (!ret) return heap_strdupW( compsysproduct_vendorW );
+ return ret;
+}
+
+static WCHAR *get_compsysproduct_version( const char *buf, UINT len )
+{
+ WCHAR *ret = get_compsysproduct_string( 3, buf, len );
+ if (!ret) return heap_strdupW( compsysproduct_versionW );
+ return ret;
+}
+
static enum fill_status fill_compsysproduct( struct table *table, const struct expr *cond )
{
struct record_computersystemproduct *rec;
enum fill_status status = FILL_STATUS_UNFILTERED;
- UINT row = 0;
+ UINT row = 0, len;
+ char *buf;
if (!resize_table( table, 1, sizeof(*rec) )) return FILL_STATUS_FAILED;
+ len = GetSystemFirmwareTable( RSMB, 0, NULL, 0 );
+ if (!(buf = heap_alloc( len ))) return FILL_STATUS_FAILED;
+ GetSystemFirmwareTable( RSMB, 0, buf, len );
+
rec = (struct record_computersystemproduct *)table->data;
- rec->identifyingnumber = compsysproduct_identifyingnumberW;
- rec->name = compsysproduct_nameW;
+ rec->identifyingnumber = get_compsysproduct_identifyingnumber( buf, len );
+ rec->name = get_compsysproduct_name( buf, len );
rec->skunumber = NULL;
- rec->uuid = get_compsysproduct_uuid();
- rec->vendor = compsysproduct_vendorW;
- rec->version = compsysproduct_versionW;
+ rec->uuid = get_compsysproduct_uuid( buf, len );
+ rec->vendor = get_compsysproduct_vendor( buf, len );
+ rec->version = get_compsysproduct_version( buf, len );
if (!match_row( table, row, cond, &status )) free_row_values( table, row );
else row++;
+ heap_free( buf );
+
TRACE("created %u rows\n", row);
table->num_rows = row;
return status;
@@ -2124,10 +2395,7 @@ static enum fill_status fill_diskdrive( struct table *table, const struct expr *
rec->index = index;
rec->interfacetype = diskdrive_interfacetypeW;
rec->manufacturer = diskdrive_manufacturerW;
- if (type == DRIVE_FIXED)
- rec->mediatype = diskdrive_mediatype_fixedW;
- else
- rec->mediatype = diskdrive_mediatype_removableW;
+ rec->mediatype = (type == DRIVE_FIXED) ? diskdrive_mediatype_fixedW : diskdrive_mediatype_removableW;
rec->model = diskdrive_modelW;
rec->pnpdevice_id = diskdrive_pnpdeviceidW;
rec->serialnumber = diskdrive_serialW;
@@ -3551,6 +3819,110 @@ static enum fill_status fill_sid( struct table *table, const struct expr *cond )
return FILL_STATUS_FILTERED;
}
+static WCHAR *get_systemenclosure_string( BYTE id, const char *buf, UINT len )
+{
+ const struct smbios_header *hdr;
+ const struct smbios_chassis *chassis;
+ UINT offset;
+
+ if (!(hdr = find_smbios_entry( SMBIOS_TYPE_CHASSIS, buf, len ))) return NULL;
+
+ chassis = (const struct smbios_chassis *)hdr;
+ offset = (const char *)chassis - buf + chassis->hdr.length;
+ return get_smbios_string( id, buf, offset, len );
+}
+
+static WCHAR *get_systemenclosure_manufacturer( const char *buf, UINT len )
+{
+ WCHAR *ret = get_systemenclosure_string( 1, buf, len );
+ if (!ret) return heap_strdupW( systemenclosure_manufacturerW );
+ return ret;
+}
+
+static int get_systemenclosure_lockpresent( const char *buf, UINT len )
+{
+ const struct smbios_header *hdr;
+ const struct smbios_chassis *chassis;
+
+ if (!(hdr = find_smbios_entry( SMBIOS_TYPE_CHASSIS, buf, len )) || hdr->length < sizeof(*chassis)) return 0;
+
+ chassis = (const struct smbios_chassis *)hdr;
+ return (chassis->type & 0x80) ? -1 : 0;
+}
+
+static struct array *dup_array( const struct array *src )
+{
+ struct array *dst;
+ if (!(dst = heap_alloc( sizeof(*dst) ))) return NULL;
+ if (!(dst->ptr = heap_alloc( src->count * src->elem_size )))
+ {
+ heap_free( dst );
+ return NULL;
+ }
+ memcpy( dst->ptr, src->ptr, src->count * src->elem_size );
+ dst->elem_size = src->elem_size;
+ dst->count = src->count;
+ return dst;
+}
+
+static struct array *get_systemenclosure_chassistypes( const char *buf, UINT len )
+{
+ const struct smbios_header *hdr;
+ const struct smbios_chassis *chassis;
+ struct array *ret = NULL;
+ UINT16 *types;
+
+ if (!(hdr = find_smbios_entry( SMBIOS_TYPE_CHASSIS, buf, len )) || hdr->length < sizeof(*chassis)) goto done;
+ chassis = (const struct smbios_chassis *)hdr;
+
+ if (!(ret = heap_alloc( sizeof(*ret) ))) goto done;
+ if (!(types = heap_alloc( sizeof(*types) )))
+ {
+ heap_free( ret );
+ goto done;
+ }
+ types[0] = chassis->type & ~0x80;
+
+ ret->elem_size = sizeof(*types);
+ ret->count = 1;
+ ret->ptr = types;
+
+done:
+ if (!ret) ret = dup_array( &systemenclosure_chassistypes_array );
+ return ret;
+}
+
+static enum fill_status fill_systemenclosure( struct table *table, const struct expr *cond )
+{
+ struct record_systemenclosure *rec;
+ enum fill_status status = FILL_STATUS_UNFILTERED;
+ UINT row = 0, len;
+ char *buf;
+
+ if (!resize_table( table, 1, sizeof(*rec) )) return FILL_STATUS_FAILED;
+
+ len = GetSystemFirmwareTable( RSMB, 0, NULL, 0 );
+ if (!(buf = heap_alloc( len ))) return FILL_STATUS_FAILED;
+ GetSystemFirmwareTable( RSMB, 0, buf, len );
+
+ rec = (struct record_systemenclosure *)table->data;
+ rec->caption = systemenclosure_systemenclosureW;
+ rec->chassistypes = get_systemenclosure_chassistypes( buf, len );
+ rec->description = systemenclosure_systemenclosureW;
+ rec->lockpresent = get_systemenclosure_lockpresent( buf, len );
+ rec->manufacturer = get_systemenclosure_manufacturer( buf, len );
+ rec->name = systemenclosure_systemenclosureW;
+ rec->tag = systemenclosure_tagW;
+ if (!match_row( table, row, cond, &status )) free_row_values( table, row );
+ else row++;
+
+ heap_free( buf );
+
+ TRACE("created %u rows\n", row);
+ table->num_rows = row;
+ return status;
+}
+
static UINT32 get_bits_per_pixel( UINT *hres, UINT *vres )
{
HDC hdc = GetDC( NULL );
@@ -3665,41 +4037,45 @@ done:
return status;
}
+#define C(c) sizeof(c)/sizeof(c[0]), c
+#define D(d) sizeof(d)/sizeof(d[0]), 0, (BYTE *)d
static struct table builtin_classes[] =
{
- { class_baseboardW, ARRAY_SIZE(col_baseboard), col_baseboard, ARRAY_SIZE(data_baseboard), 0, (BYTE *)data_baseboard },
- { class_biosW, ARRAY_SIZE(col_bios), col_bios, ARRAY_SIZE(data_bios), 0, (BYTE *)data_bios },
- { class_cdromdriveW, ARRAY_SIZE(col_cdromdrive), col_cdromdrive, 0, 0, NULL, fill_cdromdrive },
- { class_compsysW, ARRAY_SIZE(col_compsys), col_compsys, 0, 0, NULL, fill_compsys },
- { class_compsysproductW, ARRAY_SIZE(col_compsysproduct), col_compsysproduct, 0, 0, NULL, fill_compsysproduct },
- { class_datafileW, ARRAY_SIZE(col_datafile), col_datafile, 0, 0, NULL, fill_datafile },
- { class_desktopmonitorW, ARRAY_SIZE(col_desktopmonitor), col_desktopmonitor, 0, 0, NULL, fill_desktopmonitor },
- { class_directoryW, ARRAY_SIZE(col_directory), col_directory, 0, 0, NULL, fill_directory },
- { class_diskdriveW, ARRAY_SIZE(col_diskdrive), col_diskdrive, 0, 0, NULL, fill_diskdrive },
- { class_diskpartitionW, ARRAY_SIZE(col_diskpartition), col_diskpartition, 0, 0, NULL, fill_diskpartition },
- { class_ip4routetableW, ARRAY_SIZE(col_ip4routetable), col_ip4routetable, 0, 0, NULL, fill_ip4routetable },
- { class_logicaldiskW, ARRAY_SIZE(col_logicaldisk), col_logicaldisk, 0, 0, NULL, fill_logicaldisk },
- { class_logicaldisk2W, ARRAY_SIZE(col_logicaldisk), col_logicaldisk, 0, 0, NULL, fill_logicaldisk },
- { class_networkadapterW, ARRAY_SIZE(col_networkadapter), col_networkadapter, 0, 0, NULL, fill_networkadapter },
- { class_networkadapterconfigW, ARRAY_SIZE(col_networkadapterconfig), col_networkadapterconfig, 0, 0, NULL, fill_networkadapterconfig },
- { class_osW, ARRAY_SIZE(col_os), col_os, 0, 0, NULL, fill_os },
- { class_paramsW, ARRAY_SIZE(col_param), col_param, ARRAY_SIZE(data_param), 0, (BYTE *)data_param },
- { class_physicalmediaW, ARRAY_SIZE(col_physicalmedia), col_physicalmedia, ARRAY_SIZE(data_physicalmedia), 0, (BYTE *)data_physicalmedia },
- { class_physicalmemoryW, ARRAY_SIZE(col_physicalmemory), col_physicalmemory, 0, 0, NULL, fill_physicalmemory },
- { class_pnpentityW, ARRAY_SIZE(col_pnpentity), col_pnpentity, 0, 0, NULL, fill_pnpentity },
- { class_printerW, ARRAY_SIZE(col_printer), col_printer, 0, 0, NULL, fill_printer },
- { class_processW, ARRAY_SIZE(col_process), col_process, 0, 0, NULL, fill_process },
- { class_processorW, ARRAY_SIZE(col_processor), col_processor, 0, 0, NULL, fill_processor },
- { class_processor2W, ARRAY_SIZE(col_processor), col_processor, 0, 0, NULL, fill_processor },
- { class_qualifiersW, ARRAY_SIZE(col_qualifier), col_qualifier, ARRAY_SIZE(data_qualifier), 0, (BYTE *)data_qualifier },
- { class_serviceW, ARRAY_SIZE(col_service), col_service, 0, 0, NULL, fill_service },
- { class_sidW, ARRAY_SIZE(col_sid), col_sid, 0, 0, NULL, fill_sid },
- { class_sounddeviceW, ARRAY_SIZE(col_sounddevice), col_sounddevice, ARRAY_SIZE(data_sounddevice), 0, (BYTE *)data_sounddevice },
- { class_stdregprovW, ARRAY_SIZE(col_stdregprov), col_stdregprov, ARRAY_SIZE(data_stdregprov), 0, (BYTE *)data_stdregprov },
- { class_systemsecurityW, ARRAY_SIZE(col_systemsecurity), col_systemsecurity, ARRAY_SIZE(data_systemsecurity), 0, (BYTE *)data_systemsecurity },
- { class_systemenclosureW, ARRAY_SIZE(col_systemenclosure), col_systemenclosure, ARRAY_SIZE(data_systemenclosure), 0, (BYTE *)data_systemenclosure },
- { class_videocontrollerW, ARRAY_SIZE(col_videocontroller), col_videocontroller, 0, 0, NULL, fill_videocontroller }
-};
+ { class_baseboardW, C(col_baseboard), 0, 0, NULL, fill_baseboard },
+ { class_biosW, C(col_bios), 0, 0, NULL, fill_bios },
+ { class_cdromdriveW, C(col_cdromdrive), 0, 0, NULL, fill_cdromdrive },
+ { class_compsysW, C(col_compsys), 0, 0, NULL, fill_compsys },
+ { class_compsysproductW, C(col_compsysproduct), 0, 0, NULL, fill_compsysproduct },
+ { class_datafileW, C(col_datafile), 0, 0, NULL, fill_datafile },
+ { class_desktopmonitorW, C(col_desktopmonitor), 0, 0, NULL, fill_desktopmonitor },
+ { class_directoryW, C(col_directory), 0, 0, NULL, fill_directory },
+ { class_diskdriveW, C(col_diskdrive), 0, 0, NULL, fill_diskdrive },
+ { class_diskpartitionW, C(col_diskpartition), 0, 0, NULL, fill_diskpartition },
+ { class_ip4routetableW, C(col_ip4routetable), 0, 0, NULL, fill_ip4routetable },
+ { class_logicaldiskW, C(col_logicaldisk), 0, 0, NULL, fill_logicaldisk },
+ { class_logicaldisk2W, C(col_logicaldisk), 0, 0, NULL, fill_logicaldisk },
+ { class_networkadapterW, C(col_networkadapter), 0, 0, NULL, fill_networkadapter },
+ { class_networkadapterconfigW, C(col_networkadapterconfig), 0, 0, NULL, fill_networkadapterconfig },
+ { class_osW, C(col_os), 0, 0, NULL, fill_os },
+ { class_paramsW, C(col_param), D(data_param) },
+ { class_physicalmediaW, C(col_physicalmedia), D(data_physicalmedia) },
+ { class_physicalmemoryW, C(col_physicalmemory), 0, 0, NULL, fill_physicalmemory },
+ { class_pnpentityW, C(col_pnpentity), 0, 0, NULL, fill_pnpentity },
+ { class_printerW, C(col_printer), 0, 0, NULL, fill_printer },
+ { class_processW, C(col_process), 0, 0, NULL, fill_process },
+ { class_processorW, C(col_processor), 0, 0, NULL, fill_processor },
+ { class_processor2W, C(col_processor), 0, 0, NULL, fill_processor },
+ { class_qualifiersW, C(col_qualifier), D(data_qualifier) },
+ { class_serviceW, C(col_service), 0, 0, NULL, fill_service },
+ { class_sidW, C(col_sid), 0, 0, NULL, fill_sid },
+ { class_sounddeviceW, C(col_sounddevice), D(data_sounddevice) },
+ { class_stdregprovW, C(col_stdregprov), D(data_stdregprov) },
+ { class_systemsecurityW, C(col_systemsecurity), D(data_systemsecurity) },
+ { class_systemenclosureW, C(col_systemenclosure), 0, 0, NULL, fill_systemenclosure },
+ { class_videocontrollerW, C(col_videocontroller), 0, 0, NULL, fill_videocontroller }
+};
+#undef C
+#undef D
void init_table_list( void )
{
diff --git a/dlls/wbemprox/wbemprox_private.h b/dlls/wbemprox/wbemprox_private.h
index 799bc80050..c1b1ae8679 100644
--- a/dlls/wbemprox/wbemprox_private.h
+++ b/dlls/wbemprox/wbemprox_private.h
@@ -244,6 +244,16 @@ static inline WCHAR *heap_strdupW( const WCHAR *src )
return dst;
}
+static inline WCHAR *heap_strdupAW( const char *src )
+{
+ 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;
+}
+
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};
--
2.20.1
