/*
* call-seq:
* WIN32OLE_VARIANT[i,j,...] #=> element of OLE array.
*
* Returns the element of WIN32OLE_VARIANT object(OLE array).
* This method is available only when the variant type of
* WIN32OLE_VARIANT object is VT_ARRAY.
*
* REMARK:
* The all indices should be 0 or natural number and
* lower than or equal to max indices.
* (This point is different with Ruby Array indices.)
*
* obj = WIN32OLE_VARIANT.new([[1,2,3],[4,5,6]])
* p obj[0,0] # => 1
* p obj[1,0] # => 4
* p obj[2,0] # => WIN32OLERuntimeError
* p obj[0, -1] # => WIN32OLERuntimeError
*
*/
static VALUE
folevariant_ary_aref(int argc, VALUE *argv, VALUE self)
{
struct olevariantdata *pvar;
SAFEARRAY *psa;
VALUE val = Qnil;
VARIANT variant;
LONG *pid;
HRESULT hr;
TypedData_Get_Struct(self, struct olevariantdata, &olevariant_datatype, pvar);
if (!V_ISARRAY(&(pvar->var))) {
rb_raise(eWIN32OLERuntimeError,
"`[]' is not available for this variant type object");
}
psa = get_locked_safe_array(self);
if (psa == NULL) {
return val;
}
pid = ary2safe_array_index(argc, argv, psa);
VariantInit(&variant);
V_VT(&variant) = (V_VT(&(pvar->var)) & ~VT_ARRAY) | VT_BYREF;
hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
if (FAILED(hr)) {
ole_raise(hr, eWIN32OLERuntimeError, "failed to SafeArrayPtrOfIndex");
}
val = ole_variant2val(&variant);
unlock_safe_array(psa);
if (pid) free(pid);
return val;
}
/*************************************************************************
* SafeArrayPutElement (OLEAUT32.26)
*
* Put an item into a SafeArray.
*
* PARAMS
* psa [I] SafeArray to insert into
* rgIndices [I] Indices to insert at
* pvData [I] Data to insert
*
* RETURNS
* Success: S_OK. The item is inserted
* Failure: An HRESULT error code indicating the error.
*
* NOTES
* See SafeArray.
*/
HRESULT WINAPI SafeArrayPutElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
{
HRESULT hRet;
TRACE("(%p,%p,%p)\n", psa, rgIndices, pvData);
if (!psa || !rgIndices)
return E_INVALIDARG;
hRet = SafeArrayLock(psa);
if (SUCCEEDED(hRet))
{
PVOID lpvDest;
hRet = SafeArrayPtrOfIndex(psa, rgIndices, &lpvDest);
if (SUCCEEDED(hRet))
{
if (psa->fFeatures & FADF_VARIANT)
{
VARIANT* lpVariant = pvData;
VARIANT* lpDest = lpvDest;
hRet = VariantCopy(lpDest, lpVariant);
if (FAILED(hRet)) FIXME("VariantCopy failed with 0x%x\n", hRet);
}
else if (psa->fFeatures & FADF_BSTR)
{
BSTR lpBstr = (BSTR)pvData;
BSTR* lpDest = lpvDest;
SysFreeString(*lpDest);
*lpDest = SysAllocStringByteLen((char*)lpBstr, SysStringByteLen(lpBstr));
if (!*lpDest)
hRet = E_OUTOFMEMORY;
}
else if (psa->fFeatures & (FADF_UNKNOWN|FADF_DISPATCH))
{
IUnknown *lpUnknown = pvData;
IUnknown **lpDest = lpvDest;
if (lpUnknown)
IUnknown_AddRef(lpUnknown);
if (*lpDest)
IUnknown_Release(*lpDest);
*lpDest = lpUnknown;
}
else if (psa->fFeatures & FADF_RECORD)
{
IRecordInfo *record;
SafeArrayGetRecordInfo(psa, &record);
hRet = IRecordInfo_RecordCopy(record, pvData, lpvDest);
IRecordInfo_Release(record);
} else
/* Copy the data over */
memcpy(lpvDest, pvData, psa->cbElements);
}
SafeArrayUnlock(psa);
}
return hRet;
}
/*************************************************************************
* SafeArrayGetElement (OLEAUT32.25)
*
* Get an item from a SafeArray.
*
* PARAMS
* psa [I] SafeArray to get from
* rgIndices [I] Indices to get from
* pvData [O] Destination for data
*
* RETURNS
* Success: S_OK. The item data is returned in pvData.
* Failure: An HRESULT error code indicating the error.
*
* NOTES
* See SafeArray.
*/
HRESULT WINAPI SafeArrayGetElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
{
HRESULT hRet;
TRACE("(%p,%p,%p)\n", psa, rgIndices, pvData);
if (!psa || !rgIndices || !pvData)
return E_INVALIDARG;
hRet = SafeArrayLock(psa);
if (SUCCEEDED(hRet))
{
PVOID lpvSrc;
hRet = SafeArrayPtrOfIndex(psa, rgIndices, &lpvSrc);
if (SUCCEEDED(hRet))
{
if (psa->fFeatures & FADF_VARIANT)
{
VARIANT* lpVariant = lpvSrc;
VARIANT* lpDest = pvData;
/* The original content of pvData is ignored. */
V_VT(lpDest) = VT_EMPTY;
hRet = VariantCopy(lpDest, lpVariant);
if (FAILED(hRet)) FIXME("VariantCopy failed with 0x%x\n", hRet);
}
else if (psa->fFeatures & FADF_BSTR)
{
BSTR* lpBstr = lpvSrc;
BSTR* lpDest = pvData;
if (*lpBstr)
{
*lpDest = SysAllocStringByteLen((char*)*lpBstr, SysStringByteLen(*lpBstr));
if (!*lpBstr)
hRet = E_OUTOFMEMORY;
}
else
*lpDest = NULL;
}
else if (psa->fFeatures & (FADF_UNKNOWN|FADF_DISPATCH))
{
IUnknown **src_unk = lpvSrc;
IUnknown **dest_unk = pvData;
if (*src_unk)
IUnknown_AddRef(*src_unk);
*dest_unk = *src_unk;
}
else if (psa->fFeatures & FADF_RECORD)
{
IRecordInfo *record;
SafeArrayGetRecordInfo(psa, &record);
hRet = IRecordInfo_RecordCopy(record, lpvSrc, pvData);
IRecordInfo_Release(record);
}
else
/* Copy the data over */
memcpy(pvData, lpvSrc, psa->cbElements);
}
SafeArrayUnlock(psa);
}
return hRet;
}
/*!
* @brief Perform a WMI query.
* @param lpwRoot Name of the root object that is to be queried against.
* @param lpwQuery The filter to use when reading objects (LDAP style).
* @param response The response \c Packet to add the results to.
*/
DWORD wmi_query(LPCWSTR lpwRoot, LPWSTR lpwQuery, Packet* response)
{
HRESULT hResult;
dprintf("[WMI] Initialising COM");
if ((hResult = CoInitializeEx(NULL, COINIT_MULTITHREADED)) == S_OK)
{
dprintf("[WMI] COM initialised");
IWbemLocator* pLocator = NULL;
IWbemServices* pServices = NULL;
IEnumWbemClassObject* pEnumerator = NULL;
IWbemClassObject* pSuperClass = NULL;
IWbemClassObject* pObj = NULL;
Tlv* valueTlvs = NULL;
char* values = NULL;
VARIANT** fields = NULL;
do
{
if (FAILED(hResult = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, 0)))
{
dprintf("[WMI] Failed to initialize security: %x", hResult);
break;
}
dprintf("[WMI] Security initialised");
if (FAILED(hResult = CoCreateInstance(CLSID_WbemLocator, NULL, CLSCTX_ALL, IID_PPV_ARGS(&pLocator))))
{
dprintf("[WMI] Failed to create WbemLocator: %x", hResult);
break;
}
dprintf("[WMI] WbemLocator created.");
if (FAILED(hResult = pLocator->ConnectServer(_bstr_t(lpwRoot), NULL, NULL, NULL, WBEM_FLAG_CONNECT_USE_MAX_WAIT, NULL, NULL, &pServices)))
{
dprintf("[WMI] Failed to create WbemServices at %S: %x", lpwRoot, hResult);
break;
}
dprintf("[WMI] WbemServices created.");
if (FAILED(hResult = pServices->ExecQuery(L"WQL", lpwQuery, WBEM_FLAG_FORWARD_ONLY, NULL, &pEnumerator)))
{
dprintf("[WMI] Failed to create Enumerator for query %S: %x", lpwQuery, hResult);
break;
}
dprintf("[WMI] Enumerated created.");
ULONG numFound;
if (FAILED(hResult = pEnumerator->Next(ENUM_TIMEOUT, 1, &pObj, &numFound)))
{
dprintf("[WMI] Failed to get the first query element: %x", lpwQuery, hResult);
break;
}
dprintf("[WMI] First result read. hr=%x p=%p", hResult, pObj);
if (hResult == WBEM_S_FALSE)
{
// this is not an error
dprintf("[WMI] No results found!");
break;
}
// get the names of the fields out of the first object before doing anything else.
LPSAFEARRAY pFieldArray = NULL;
if (FAILED(hResult = pObj->GetNames(NULL, WBEM_FLAG_ALWAYS, NULL, &pFieldArray)))
{
dprintf("[WMI] Failed to get field names: %x", hResult);
break;
}
dprintf("[WMI] Field Names extracted. hr=%x p=%p", hResult, pFieldArray);
// lock the array
if (FAILED(hResult = SafeArrayLock(pFieldArray)))
{
dprintf("[WMI] Failed to get array dimension: %x", hResult);
break;
}
dprintf("[WMI] Field name array locked.");
do
{
dprintf("[WMI] Array dimensions: %u", SafeArrayGetDim(pFieldArray));
// this array is just one dimension, let's get the bounds of the first dimension
LONG lBound, uBound;
if (FAILED(hResult = SafeArrayGetLBound(pFieldArray, 1, &lBound))
|| FAILED(hResult = SafeArrayGetUBound(pFieldArray, 1, &uBound)))
{
dprintf("[WMI] Failed to get array dimensions: %x", hResult);
break;
}
dprintf("[WMI] Bounds: %u to %u", lBound, uBound);
LONG fieldCount = uBound - lBound - SYSTEM_FIELD_COUNT - 1;
dprintf("[WMI] Query results in %u fields", fieldCount);
fields = (VARIANT**)malloc(fieldCount * sizeof(VARIANT**));
valueTlvs = (Tlv*)malloc(fieldCount * sizeof(Tlv));
values = (char*)malloc(fieldCount * FIELD_SIZE);
memset(fields, 0, fieldCount * sizeof(VARIANT**));
memset(valueTlvs, 0, fieldCount * sizeof(Tlv));
memset(values, 0, fieldCount * FIELD_SIZE);
for (LONG i = 0; i < fieldCount; ++i)
{
LONG indices[1] = { i + SYSTEM_FIELD_COUNT };
char* fieldName = values + (i * FIELD_SIZE);
SafeArrayPtrOfIndex(pFieldArray, indices, (void**)&fields[i]);
_bstr_t bstr(fields[i]->bstrVal);
strncpy_s(fieldName, FIELD_SIZE, (const char*)bstr, FIELD_SIZE - 1);
valueTlvs[i].header.type = TLV_TYPE_EXT_WMI_FIELD;
valueTlvs[i].header.length = (UINT)strlen(fieldName) + 1;
valueTlvs[i].buffer = (PUCHAR)fieldName;
dprintf("[WMI] Added header field: %s", fieldName);
}
dprintf("[WMI] added all field headers");
// add the field names to the packet
packet_add_tlv_group(response, TLV_TYPE_EXT_WMI_FIELDS, valueTlvs, fieldCount);
dprintf("[WMI] processing values...");
// with that horrible pain out of the way, let's actually grab the data
do
{
if (FAILED(hResult))
{
dprintf("[WMI] Loop exited via %x", hResult);
break;
}
memset(valueTlvs, 0, fieldCount * sizeof(Tlv));
memset(values, 0, fieldCount * FIELD_SIZE);
for (LONG i = 0; i < fieldCount; ++i)
{
char* value = values + (i * FIELD_SIZE);
valueTlvs[i].header.type = TLV_TYPE_EXT_WMI_VALUE;
valueTlvs[i].buffer = (PUCHAR)value;
VARIANT varValue;
VariantInit(&varValue);
_bstr_t field(fields[i]->bstrVal);
dprintf("[WMI] Extracting value for %s", (char*)field);
if (SUCCEEDED(pObj->Get(field, 0, &varValue, NULL, NULL)))
{
variant_to_string(_variant_t(varValue), value, FIELD_SIZE);
}
valueTlvs[i].header.length = (UINT)strlen(value) + 1;
dprintf("[WMI] Added value for %s: %s", (char*)_bstr_t(fields[i]->bstrVal), value);
}
// add the field values to the packet
packet_add_tlv_group(response, TLV_TYPE_EXT_WMI_VALUES, valueTlvs, fieldCount);
pObj->Release();
pObj = NULL;
} while ((hResult = pEnumerator->Next(ENUM_TIMEOUT, 1, &pObj, &numFound)) != WBEM_S_FALSE);
} while (0);
SafeArrayUnlock(pFieldArray);
} while (0);
if (fields)
{
free(fields);
}
if (values)
{
free(values);
}
if (valueTlvs)
{
free(valueTlvs);
}
if (pObj)
{
pObj->Release();
}
if (pEnumerator)
{
pEnumerator->Release();
}
if (pServices)
{
pServices->Release();
}
if (pLocator)
{
pLocator->Release();
}
CoUninitialize();
if (SUCCEEDED(hResult))
{
hResult = S_OK;
dprintf("[WMI] Things appeard to go well!");
}
}
else
{
dprintf("[WMI] Failed to initialize COM");
}
if (FAILED(hResult))
{
// if we failed, we're going to convert the error to a string, add it and still return success, but we'll
// also include the hresult.
char errorMessage[1024];
memset(errorMessage, 0, 1024);
_com_error comError(hResult);
_snprintf_s(errorMessage, 1024, 1023, "%s (0x%x)", comError.ErrorMessage(), hResult);
dprintf("[WMI] returning error -> %s", errorMessage);
packet_add_tlv_string(response, TLV_TYPE_EXT_WMI_ERROR, errorMessage);
hResult = S_OK;
}
return (DWORD)hResult;
}
