Sample Code
Windows Driver Samples/ WPD WUDF sample driver/ C++/ FakeContent.h/
#include "FakeContent.h.tmh"
class FakeContent
{
public:
FakeContent() :
MarkedForDeletion(FALSE),
CanDelete(TRUE),
IsHidden(FALSE),
IsSystem(FALSE),
NonConsumable(FALSE)
{
ContentType = WPD_CONTENT_TYPE_UNSPECIFIED;
}
FakeContent(const FakeContent& src) :
MarkedForDeletion(FALSE),
CanDelete(TRUE),
IsHidden(FALSE),
IsSystem(FALSE),
NonConsumable(FALSE)
{
*this = src;
}
virtual ~FakeContent()
{
}
virtual FakeContent& operator= (const FakeContent& src)
{
ObjectID = src.ObjectID;
PersistentUniqueID = src.PersistentUniqueID;
ParentID = src.ParentID;
Name = src.Name;
FileName = src.FileName;
ContentType = src.ContentType;
MarkedForDeletion = src.MarkedForDeletion;
CanDelete = src.CanDelete;
IsHidden = src.IsHidden;
IsSystem = src.IsSystem;
NonConsumable = src.NonConsumable;
return *this;
}
virtual HRESULT GetSupportedProperties(_COM_Outptr_ IPortableDeviceKeyCollection** ppKeys)
{
HRESULT hr = S_OK;
if(ppKeys == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL collection parameter");
return hr;
}
hr = AddSupportedProperties(GetObjectFormat(), ppKeys);
CHECK_HR(hr, ("Failed to add supported proeprties for FakeContent"));
return hr;
}
virtual HRESULT GetAllValues(_In_ IPortableDeviceValues* pStore)
{
HRESULT hr = S_OK;
HRESULT hrSetValue = S_OK;
PropVariantWrapper pvValue;
if(pStore == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL parameter");
return hr;
}
// Add WPD_OBJECT_ID
pvValue = ObjectID;
hrSetValue = pStore->SetValue(WPD_OBJECT_ID, &pvValue);
if (hrSetValue != S_OK)
{
CHECK_HR(hrSetValue, ("Failed to set WPD_OBJECT_ID"));
return hrSetValue;
}
// Add WPD_OBJECT_PERSISTENT_UNIQUE_ID
pvValue = this->PersistentUniqueID;
hrSetValue = pStore->SetValue(WPD_OBJECT_PERSISTENT_UNIQUE_ID, &pvValue);
if (hrSetValue != S_OK)
{
CHECK_HR(hrSetValue, ("Failed to set WPD_OBJECT_PERSISTENT_UNIQUE_ID"));
return hrSetValue;
}
// Add WPD_OBJECT_PARENT_ID
pvValue = ParentID;
hrSetValue = pStore->SetValue(WPD_OBJECT_PARENT_ID, &pvValue);
if (hrSetValue != S_OK)
{
CHECK_HR(hrSetValue, ("Failed to set WPD_OBJECT_PARENT_ID"));
return hrSetValue;
}
// Add WPD_OBJECT_NAME
pvValue = Name;
hrSetValue = pStore->SetValue(WPD_OBJECT_NAME, &pvValue);
if (hrSetValue != S_OK)
{
CHECK_HR(hrSetValue, ("Failed to set WPD_OBJECT_NAME"));
return hrSetValue;
}
// Add WPD_OBJECT_CONTENT_TYPE
hrSetValue = pStore->SetGuidValue(WPD_OBJECT_CONTENT_TYPE, ContentType);
if (hrSetValue != S_OK)
{
CHECK_HR(hrSetValue, ("Failed to set WPD_OBJECT_CONTENT_TYPE"));
return hrSetValue;
}
// Add WPD_OBJECT_FORMAT
hrSetValue = pStore->SetGuidValue(WPD_OBJECT_FORMAT, GetObjectFormat());
if (hrSetValue != S_OK)
{
CHECK_HR(hrSetValue, ("Failed to set WPD_OBJECT_FORMAT"));
return hrSetValue;
}
// Add WPD_OBJECT_CAN_DELETE
hrSetValue = pStore->SetBoolValue(WPD_OBJECT_CAN_DELETE, CanDelete);
if (hrSetValue != S_OK)
{
CHECK_HR(hrSetValue, ("Failed to set WPD_OBJECT_CAN_DELETE"));
return hrSetValue;
}
// Add WPD_OBJECT_ISHIDDEN
hrSetValue = pStore->SetBoolValue(WPD_OBJECT_ISHIDDEN, IsHidden);
if (hrSetValue != S_OK)
{
CHECK_HR(hrSetValue, ("Failed to set WPD_OBJECT_ISHIDDEN"));
return hrSetValue;
}
// Add WPD_OBJECT_ISSYSTEM
hrSetValue = pStore->SetBoolValue(WPD_OBJECT_ISSYSTEM, IsSystem);
if (hrSetValue != S_OK)
{
CHECK_HR(hrSetValue, ("Failed to set WPD_OBJECT_ISSYSTEM"));
return hrSetValue;
}
// Add WPD_OBJECT_NON_CONSUMABLE
hrSetValue = pStore->SetBoolValue(WPD_OBJECT_NON_CONSUMABLE, NonConsumable);
if (hrSetValue != S_OK)
{
CHECK_HR(hrSetValue, ("Failed to set WPD_OBJECT_NON_CONSUMABLE"));
return hrSetValue;
}
// Add WPD_FOLDER_CONTENT_TYPES_ALLOWED if necessary
if(!RestrictToContentTypes.IsEmpty())
{
CComPtr<IPortableDevicePropVariantCollection> pContentTypes;
hrSetValue = CoCreateInstance(CLSID_PortableDevicePropVariantCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDevicePropVariantCollection,
(VOID**) &pContentTypes);
CHECK_HR(hrSetValue, "Failed to CoCreate CLSID_PortableDevicePropVariantCollection");
if (hrSetValue == S_OK)
{
PROPVARIANT pvContentType = {0};
PropVariantInit(&pvContentType);
pvContentType.vt = VT_CLSID; // Don't PropVariantClear this since we won't allocate memory for it
size_t numElems = RestrictToContentTypes.GetCount();
for(size_t typeIndex = 0; hrSetValue == S_OK && typeIndex < numElems; typeIndex++)
{
pvContentType.puuid = &RestrictToContentTypes[typeIndex];
hrSetValue = pContentTypes->Add(&pvContentType);
CHECK_HR(hrSetValue, "Failed to add content type");
}
if (hrSetValue == S_OK)
{
hrSetValue = pStore->SetIPortableDevicePropVariantCollectionValue(WPD_FOLDER_CONTENT_TYPES_ALLOWED, pContentTypes);
CHECK_HR(hrSetValue, "Failed to set WPD_FOLDER_CONTENT_TYPES_ALLOWED");
}
if (FAILED(hrSetValue))
{
hr = hrSetValue;
}
}
}
return hr;
}
virtual HRESULT WriteValue(
_In_ REFPROPERTYKEY key,
_In_ REFPROPVARIANT Value)
{
HRESULT hr = S_OK;
PropVariantWrapper pvValue;
if(IsEqualPropertyKey(key, WPD_OBJECT_NAME))
{
if(Value.vt == VT_LPWSTR)
{
if (Value.pwszVal != NULL && Value.pwszVal[0] != L'\0')
{
Name = Value.pwszVal;
}
else
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Failed to set WPD_OBJECT_NAME because value was an empty string");
}
}
else
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Failed to set WPD_OBJECT_NAME because type was not VT_LPWSTR");
}
}
else if (IsEqualPropertyKey(key, WPD_OBJECT_NON_CONSUMABLE))
{
if(Value.vt == VT_BOOL)
{
NonConsumable = Value.boolVal;
}
else
{
hr = E_INVALIDARG;
CHECK_HR(hr, "Failed to set WPD_OBJECT_NON_CONSUMABLE because type was not VT_BOOL");
}
}
else
{
hr = E_ACCESSDENIED;
CHECK_HR(hr, "Property %ws.%d on [%ws] does not support set value operation", CComBSTR(key.fmtid), key.pid, ObjectID);
}
return hr;
}
virtual HRESULT GetAttributes(
_In_ REFPROPERTYKEY Key,
_COM_Outptr_ IPortableDeviceValues** ppAttributes)
{
HRESULT hr = S_OK;
CComPtr<IPortableDeviceValues> pAttributes;
if(ppAttributes == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL attributes parameter");
return hr;
}
*ppAttributes = NULL;
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_PortableDeviceValues,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceValues,
(VOID**) &pAttributes);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceValues");
}
if (SUCCEEDED(hr))
{
hr = AddFixedPropertyAttributes(GetObjectFormat(), Key, pAttributes);
CHECK_HR(hr, "Failed to add fixed property attributes for %ws.%d on FakeContent", CComBSTR(Key.fmtid), Key.pid);
}
// Some of our properties have extra attributes on top of the ones that are common to all
if(IsEqualPropertyKey(Key, WPD_OBJECT_NAME))
{
CAtlStringW strDefaultName;
strDefaultName.Format(L"%ws%ws", L"Name", ObjectID.GetString());
hr = pAttributes->SetStringValue(WPD_PROPERTY_ATTRIBUTE_DEFAULT_VALUE, strDefaultName.GetString());;
CHECK_HR(hr, "Failed to set WPD_PROPERTY_ATTRIBUTE_DEFAULT_VALUE");
}
// Return the property attributes
if (SUCCEEDED(hr))
{
hr = pAttributes->QueryInterface(IID_IPortableDeviceValues, (VOID**) ppAttributes);
CHECK_HR(hr, "Failed to QI for IPortableDeviceValues on Wpd IPortableDeviceValues");
}
return hr;
}
virtual HRESULT GetSupportedResources(_COM_Outptr_ IPortableDeviceKeyCollection** ppKeys)
{
HRESULT hr = S_OK;
CComPtr<IPortableDeviceKeyCollection> pKeys;
if(ppKeys == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL collection parameter");
return hr;
}
*ppKeys = NULL;
if (SUCCEEDED(hr))
{
hr = CoCreateInstance(CLSID_PortableDeviceKeyCollection,
NULL,
CLSCTX_INPROC_SERVER,
IID_IPortableDeviceKeyCollection,
(VOID**) &pKeys);
CHECK_HR(hr, "Failed to CoCreate CLSID_PortableDeviceKeyCollection");
}
// This object has no resources so return the empty collection
if (SUCCEEDED(hr))
{
hr = pKeys->QueryInterface(IID_IPortableDeviceKeyCollection, (VOID**) ppKeys);
CHECK_HR(hr, "Failed to QI for IPortableDeviceKeyCollection on IPortableDeviceKeyCollection");
}
return hr;
}
virtual HRESULT GetResourceAttributes(
_In_ REFPROPERTYKEY Key,
_COM_Outptr_ IPortableDeviceValues** ppAttributes)
{
UNREFERENCED_PARAMETER(Key);
*ppAttributes = NULL;
// This object has no resources therefore has no attributes to return.
return E_NOTIMPL;
}
virtual HRESULT ReadData(
_In_ REFPROPERTYKEY ResourceKey,
DWORD dwStartByte,
_Out_writes_to_(dwNumBytesToRead, *pdwNumBytesRead) BYTE* pBuffer,
DWORD dwNumBytesToRead,
_Out_ DWORD* pdwNumBytesRead)
{
HRESULT hr = S_OK;
DWORD dwBytesToTransfer = 0;
if((pBuffer == NULL) ||
(pdwNumBytesRead == NULL))
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL parameter");
return hr;
}
*pdwNumBytesRead = 0;
UNREFERENCED_PARAMETER(ResourceKey);
// Calculate how many bytes to transfer
if (hr == S_OK)
{
if (dwStartByte < FAKE_DATA_SIZE)
{
dwBytesToTransfer = (FAKE_DATA_SIZE - dwStartByte);
if (dwBytesToTransfer > dwNumBytesToRead)
{
dwBytesToTransfer = dwNumBytesToRead;
}
}
}
// This sample driver does not have any real data content,
// so we generate fake data content.
// The content we generate is made up of the Name string repeated
// in the data buffer.
if ((hr == S_OK) && (dwBytesToTransfer > 0))
{
DWORD dwOffset = 0;
DWORD dwSourceStringSizeInBytes = (Name.GetLength() * sizeof(WCHAR)) + sizeof(L'\0');
for (DWORD counter = 0; counter < (dwBytesToTransfer / dwSourceStringSizeInBytes); counter++)
{
_Analysis_assume_((dwOffset + dwSourceStringSizeInBytes) <= dwNumBytesToRead);
memcpy(pBuffer + dwOffset, Name.GetString(), dwSourceStringSizeInBytes);
dwOffset += dwSourceStringSizeInBytes;
}
memset(pBuffer + dwOffset, 0, dwBytesToTransfer % dwSourceStringSizeInBytes);
}
if (hr == S_OK)
{
*pdwNumBytesRead = dwBytesToTransfer;
}
return hr;
}
virtual HRESULT WriteData(
_In_ REFPROPERTYKEY ResourceKey,
DWORD dwStartByte,
_In_reads_(dwNumBytesToWrite) BYTE* pBuffer,
DWORD dwNumBytesToWrite,
_Out_ DWORD* pdwNumBytesWritten)
{
HRESULT hr = S_OK;
if((pBuffer == NULL) ||
(pdwNumBytesWritten == NULL))
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL parameter");
return hr;
}
*pdwNumBytesWritten = 0;
UNREFERENCED_PARAMETER(ResourceKey);
UNREFERENCED_PARAMETER(dwStartByte);
// This fake driver does nothing with the data. The write method is simply
// a dummy one.
// Normally, a driver would copy the contents from the buffer to the device.
if (hr == S_OK)
{
*pdwNumBytesWritten = dwNumBytesToWrite;
}
return hr;
}
virtual GUID GetObjectFormat()
{
return FakeContent_Format;
}
virtual HRESULT EnableResource(
_In_ REFPROPERTYKEY ResourceKey)
{
UNREFERENCED_PARAMETER(ResourceKey);
return E_NOTIMPL;
}
CAtlStringW ObjectID;
CAtlStringW PersistentUniqueID;
CAtlStringW ParentID;
CAtlStringW Name;
CAtlStringW FileName;
GUID ContentType;
BOOL MarkedForDeletion;
BOOL CanDelete;
BOOL IsHidden;
BOOL IsSystem;
BOOL NonConsumable;
CAtlArray<GUID> RestrictToContentTypes;
};
class FakeGenericFileContent : public FakeContent
{
public:
virtual HRESULT GetAllValues(
_In_ IPortableDeviceValues* pStore)
{
HRESULT hr = S_OK;
PropVariantWrapper pvValue;
if(pStore == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL parameter");
return hr;
}
// Call the base class to fill in the standard properties
hr = FakeContent::GetAllValues(pStore);
if (FAILED(hr))
{
CHECK_HR(hr, "Failed to get basic property set");
return hr;
}
// Add WPD_OBJECT_ORIGINAL_FILE_NAME
pvValue = FileName;
hr = pStore->SetValue(WPD_OBJECT_ORIGINAL_FILE_NAME, &pvValue);
if (hr != S_OK)
{
CHECK_HR(hr, ("Failed to set WPD_OBJECT_ORIGINAL_FILE_NAME"));
return hr;
}
return hr;
}
virtual HRESULT GetSupportedResources(_COM_Outptr_ IPortableDeviceKeyCollection** ppKeys)
{
HRESULT hr = S_OK;
CComPtr<IPortableDeviceKeyCollection> pKeys;
if(ppKeys == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL collection parameter");
return hr;
}
*ppKeys = NULL;
if (SUCCEEDED(hr))
{
// Call the base class to fill in the standard resources if any
hr = FakeContent::GetSupportedResources(&pKeys);
CHECK_HR(hr, "Failed to get basic supported resources");
}
if (SUCCEEDED(hr))
{
// Add WPD_RESOURCE_DEFAULT
hr = pKeys->Add(WPD_RESOURCE_DEFAULT);
CHECK_HR(hr, "Failed to add WPD_RESOURCE_DEFAULT to collection");
}
if (SUCCEEDED(hr))
{
hr = pKeys->QueryInterface(IID_IPortableDeviceKeyCollection, (VOID**) ppKeys);
CHECK_HR(hr, "Failed to QI for IPortableDeviceKeyCollection on IPortableDeviceKeyCollection");
}
return hr;
}
virtual HRESULT GetResourceAttributes(
_In_ REFPROPERTYKEY Key,
_COM_Outptr_ IPortableDeviceValues** ppAttributes)
{
HRESULT hr = S_OK;
CComPtr<IPortableDeviceValues> pAttributes;
if(ppAttributes == NULL)
{
hr = E_POINTER;
CHECK_HR(hr, "Cannot have NULL attributes parameter");
return hr;
}
*ppAttributes = NULL;
if (SUCCEEDED(hr))
{
// Fill in the common resource attributes
hr = GetCommonResourceAttributes(&pAttributes);
CHECK_HR(hr, "Failed to get common resource attributes set");
}
// Override the necessary attributes for this resource.
if ((hr == S_OK) && (IsEqualPropertyKey(Key, WPD_RESOURCE_DEFAULT)))
{
hr = pAttributes->SetBoolValue(WPD_RESOURCE_ATTRIBUTE_CAN_WRITE, TRUE);
CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_CAN_WRITE");
}
// Return the resource attributes
if (SUCCEEDED(hr))
{
hr = pAttributes->QueryInterface(IID_IPortableDeviceValues, (VOID**) ppAttributes);
CHECK_HR(hr, "Failed to QI for IPortableDeviceValues on Wpd IPortableDeviceValues");
}
return hr;
}
};
Our Services
-
What our customers say about us?
Read our customer testimonials to find out why our clients keep returning for their projects.
View Testimonials
