static HRESULT WINAPI IWICStreamImpl_InitializeFromFilename(IWICStream *iface,
LPCWSTR wzFileName, DWORD dwDesiredAccess)
{
IWICStreamImpl *This = impl_from_IWICStream(iface);
HRESULT hr;
DWORD dwMode;
IStream *stream;
TRACE("(%p, %s, %u)\n", iface, debugstr_w(wzFileName), dwDesiredAccess);
if (This->pStream) return WINCODEC_ERR_WRONGSTATE;
if(dwDesiredAccess & GENERIC_WRITE)
dwMode = STGM_SHARE_DENY_WRITE | STGM_WRITE | STGM_CREATE;
else if(dwDesiredAccess & GENERIC_READ)
dwMode = STGM_SHARE_DENY_WRITE | STGM_READ | STGM_FAILIFTHERE;
else
return E_INVALIDARG;
hr = SHCreateStreamOnFileW(wzFileName, dwMode, &stream);
if (SUCCEEDED(hr))
{
if (InterlockedCompareExchangePointer((void**)&This->pStream, stream, NULL))
{
/* Some other thread set the stream first. */
IStream_Release(stream);
hr = WINCODEC_ERR_WRONGSTATE;
}
}
return hr;
}
static UINT msi_dump_stream_to_file( IStream *stm, LPCWSTR name )
{
ULARGE_INTEGER size;
LARGE_INTEGER pos;
IStream *out;
DWORD stgm;
HRESULT r;
stgm = STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_FAILIFTHERE;
r = SHCreateStreamOnFileW( name, stgm, &out );
if( FAILED( r ) )
return ERROR_FUNCTION_FAILED;
pos.QuadPart = 0;
r = IStream_Seek( stm, pos, STREAM_SEEK_END, &size );
if( FAILED( r ) )
goto end;
pos.QuadPart = 0;
r = IStream_Seek( stm, pos, STREAM_SEEK_SET, NULL );
if( FAILED( r ) )
goto end;
r = IStream_CopyTo( stm, out, size, NULL, NULL );
end:
IStream_Release( out );
if( FAILED( r ) )
return ERROR_FUNCTION_FAILED;
return ERROR_SUCCESS;
}
/*************************************************************************
* SHCreateStreamOnFileA [SHLWAPI.@]
*
* Create a stream on a file.
*
* PARAMS
* lpszPath [I] Path of file to create stream on
* dwMode [I] Mode to create stream in
* lppStream [O] Destination for created IStream object
*
* RETURNS
* Success: S_OK. lppStream contains the new IStream object
* Failure: E_INVALIDARG if any parameter is invalid, or an HRESULT error code
*/
HRESULT WINAPI SHCreateStreamOnFileA(LPCSTR lpszPath, DWORD dwMode,
IStream **lppStream)
{
WCHAR szPath[MAX_PATH];
TRACE("(%s,%ld,%p)\n", debugstr_a(lpszPath), dwMode, lppStream);
if (!lpszPath)
return E_INVALIDARG;
MultiByteToWideChar(0, 0, lpszPath, -1, szPath, MAX_PATH);
return SHCreateStreamOnFileW(szPath, dwMode, lppStream);
}
/*************************************************************************
* SHCreateStreamOnFileA [SHLWAPI.@]
*
* Create a stream on a file.
*
* PARAMS
* lpszPath [I] Path of file to create stream on
* dwMode [I] Mode to create stream in
* lppStream [O] Destination for created IStream object
*
* RETURNS
* Success: S_OK. lppStream contains the new IStream object
* Failure: E_INVALIDARG if any parameter is invalid, or an HRESULT error code
*/
HRESULT WINAPI SHCreateStreamOnFileA(LPCSTR lpszPath, DWORD dwMode,
IStream **lppStream)
{
WCHAR szPath[MAX_PATH];
TRACE("(%s,%d,%p)\n", debugstr_a(lpszPath), dwMode, lppStream);
if (!lpszPath)
return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
MultiByteToWideChar(CP_ACP, 0, lpszPath, -1, szPath, MAX_PATH);
return SHCreateStreamOnFileW(szPath, dwMode, lppStream);
}
HRESULT CreateStreamWriter(LPCWSTR path, IXmlWriter **ppWriter, IStream **ppFileStream)
{
HRESULT hr = S_FALSE;
if(ppWriter != NULL && ppFileStream != NULL)
{
hr = CreateXmlWriter(IID_PPV_ARGS(ppWriter), NULL);
EXIT_NOT_S_OK(hr);
hr = SHCreateStreamOnFileW(path, STGM_WRITE | STGM_CREATE, ppFileStream);
EXIT_NOT_S_OK(hr);
hr = (*ppWriter)->SetOutput(*ppFileStream);
}
NOT_S_OK:
return hr;
}
HRESULT CreateStreamReader(LPCWSTR path, IXmlReader **ppReader, IStream **ppFileStream)
{
HRESULT hr = S_FALSE;
if(ppReader != NULL && ppFileStream != NULL)
{
hr = CreateXmlReader(IID_PPV_ARGS(ppReader), NULL);
EXIT_NOT_S_OK(hr);
hr = SHCreateStreamOnFileW(path, STGM_READ, ppFileStream);
EXIT_NOT_S_OK(hr);
hr = (*ppReader)->SetInput(*ppFileStream);
EXIT_NOT_S_OK(hr);
}
NOT_S_OK:
return hr;
}
static void test_SHCreateStreamOnFileW(DWORD mode, DWORD stgm)
{
IStream * stream;
HRESULT ret;
ULONG refcount;
WCHAR test_file[MAX_PATH];
CHAR test_fileA[MAX_PATH];
static const CHAR testW_txt[] = "\\testW.txt";
trace("SHCreateStreamOnFileW: testing mode %d, STGM flags %08x\n", mode, stgm);
/* Don't used a fixed path for the testW.txt file */
GetTempPathA(MAX_PATH, test_fileA);
lstrcatA(test_fileA, testW_txt);
MultiByteToWideChar(CP_ACP, 0, test_fileA, -1, test_file, MAX_PATH);
/* invalid arguments */
if (0)
{
/* Crashes on NT4 */
stream = NULL;
ret = SHCreateStreamOnFileW(NULL, mode | stgm, &stream);
ok(ret == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) || /* XP */
ret == E_INVALIDARG /* Vista */,
"SHCreateStreamOnFileW: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) or E_INVALIDARG, got 0x%08x\n", ret);
ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
}
if (0)
{
/* This test crashes on WinXP SP2 */
ret = SHCreateStreamOnFileW(test_file, mode | stgm, NULL);
ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
}
stream = NULL;
ret = SHCreateStreamOnFileW(test_file, mode | STGM_CONVERT | stgm, &stream);
ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
stream = NULL;
ret = SHCreateStreamOnFileW(test_file, mode | STGM_DELETEONRELEASE | stgm, &stream);
ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
stream = NULL;
ret = SHCreateStreamOnFileW(test_file, mode | STGM_TRANSACTED | stgm, &stream);
ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
/* file does not exist */
stream = NULL;
ret = SHCreateStreamOnFileW(test_file, mode | STGM_FAILIFTHERE | stgm, &stream);
if (ret == E_INVALIDARG) /* Win98 SE */ {
win_skip("Not supported\n");
return;
}
ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "SHCreateStreamOnFileW: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret);
ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
stream = NULL;
ret = SHCreateStreamOnFileW(test_file, mode | STGM_CREATE | stgm, &stream);
ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret);
ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
if (stream) {
test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream);
ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount);
}
/* NOTE: don't delete the file, as it will be used for the file exists tests. */
/* file exists */
stream = NULL;
ret = SHCreateStreamOnFileW(test_file, mode | STGM_FAILIFTHERE | stgm, &stream);
ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret);
ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
if (stream) {
test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream);
ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount);
}
stream = NULL;
ret = SHCreateStreamOnFileW(test_file, mode | STGM_CREATE | stgm, &stream);
ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret);
ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
if (stream) {
BOOL delret;
test_stream_read_write(stream, mode);
test_IStream_invalid_operations(stream, mode);
refcount = IStream_Release(stream);
ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount);
delret = DeleteFileA(test_fileA);
ok(delret, "SHCreateStreamOnFileW: could not delete the test file, got error %d\n",
GetLastError());
}
}
std::wstring load_text_file(const std::wstring &path, uint32_t codepage)
{
struct F {
static void release(IUnknown *x) { x->Release(); }
};
IStream *stream;
HRESULT hr = SHCreateStreamOnFileW(path.c_str(),
STGM_READ | STGM_SHARE_DENY_WRITE,
&stream);
if (FAILED(hr)) win32::throw_error(path, hr);
std::shared_ptr<IStream> streamPtr(stream, F::release);
LARGE_INTEGER li = { 0 };
ULARGE_INTEGER ui;
HR(stream->Seek(li, STREAM_SEEK_END, &ui));
if (ui.QuadPart > 0x100000) {
throw std::runtime_error(strutil::w2us(path + L": file too big"));
}
size_t fileSize = ui.LowPart;
HR(stream->Seek(li, STREAM_SEEK_SET, &ui));
IMultiLanguage2 *mlang;
HR(CoCreateInstance(CLSID_CMultiLanguage, 0, CLSCTX_INPROC_SERVER,
IID_IMultiLanguage2, (void**)(&mlang)));
std::shared_ptr<IMultiLanguage2> mlangPtr(mlang, F::release);
if (!codepage) {
DetectEncodingInfo encoding[5];
INT nscores = 5;
HR(mlang->DetectCodepageInIStream(0, GetACP(),
stream, encoding, &nscores));
/*
* Usually DetectCodepageInIStream() puts the most appropriate choice
* in the first place.
* However, it tends to pick 8bit locale charset for the first place,
* even if it is really an UTF-8 encoded file.
*/
codepage = encoding[0].nCodePage;
for (size_t i = 0; i < nscores; ++i)
if (encoding[i].nCodePage == 65001) {
codepage = 65001;
break;
}
HR(stream->Seek(li, STREAM_SEEK_SET, &ui));
}
std::vector<char> ibuf(fileSize);
ULONG nread;
HR(stream->Read(&ibuf[0], ibuf.size(), &nread));
DWORD ctx = 0;
UINT size = ibuf.size(), cnt;
HR(mlang->ConvertStringToUnicode(&ctx, codepage,
&ibuf[0], &size, 0, &cnt));
std::vector<wchar_t> obuf(cnt);
size = ibuf.size();
HR(mlang->ConvertStringToUnicode(&ctx, codepage,
&ibuf[0], &size, &obuf[0], &cnt));
obuf.push_back(0);
// chop off BOM
size_t bom = obuf.size() && obuf[0] == 0xfeff;
return strutil::normalize_crlf(&obuf[bom], L"\n");
}
JNIEXPORT jstring JNICALL Java_jmtp_PortableDeviceContentImplWin32_createObjectWithPropertiesAndData
(JNIEnv* env, jobject obj, jobject jobjValues, jobject jobjFile)
{
//variabelen
HRESULT hr;
IPortableDeviceContent* pDeviceContent;
IPortableDeviceValues* pDeviceObjectValues;
jobject jobjValuesReference;
jstring jsFileLocation;
LPWSTR wszFileLocation;
DWORD dwBufferSize;
CComPtr<IStream> pFileStream;
CComPtr<IStream> pDeviceStream;
CComPtr<IPortableDeviceDataStream> pDeviceDataStream;
STATSTG fileStats;
BYTE* pBuffer;
DWORD dwReadFromStream;
LPWSTR wszObjectID;
jstring jsObjectID;
jmethodID mid;
//Methode implementatie
pDeviceContent = GetPortableDeviceContent(env, obj);
jobjValuesReference = RetrieveCOMReferenceFromCOMReferenceable(env, jobjValues);
pDeviceObjectValues = (IPortableDeviceValues*)ConvertComReferenceToPointer(env, jobjValuesReference);
//COM stream object aanmaken
mid = env->GetMethodID(env->FindClass("java/io/File"), "getAbsolutePath", "()Ljava/lang/String;");
jsFileLocation = (jstring)env->CallObjectMethod(jobjFile, mid);
wszFileLocation = (WCHAR*)env->GetStringChars(jsFileLocation, NULL);
hr = SHCreateStreamOnFileW(wszFileLocation, STGM_READ, &pFileStream);
env->ReleaseStringChars(jsFileLocation, (jchar*)wszFileLocation); //string resources terug vrijgeven
if(SUCCEEDED(hr))
{
//groote van het bestand bepalen
//(door een beperking in java op het gebied van unsigned integers, moeten we het wel in c++ doen)
pFileStream->Stat(&fileStats, STATFLAG_NONAME);
pDeviceObjectValues->SetUnsignedLargeIntegerValue(WPD_OBJECT_SIZE, fileStats.cbSize.QuadPart);
hr = pDeviceContent->CreateObjectWithPropertiesAndData(pDeviceObjectValues,
&pDeviceStream, &dwBufferSize, NULL);
if(SUCCEEDED(hr))
{
pDeviceStream->QueryInterface(IID_IPortableDeviceDataStream, (void**)&pDeviceDataStream);
//data kopieren
pBuffer = new BYTE[dwBufferSize];
dwReadFromStream = 0;
do
{
pFileStream->Read(pBuffer, dwBufferSize, &dwReadFromStream);
pDeviceDataStream->Write(pBuffer, dwReadFromStream, NULL);
}
while(dwReadFromStream > 0);
delete[] pBuffer;
hr = pDeviceDataStream->Commit(STGC_DEFAULT);
if(SUCCEEDED(hr))
{
pDeviceDataStream->GetObjectID(&wszObjectID);
jsObjectID = (jstring)env->NewString((jchar*)wszObjectID, wcslen(wszObjectID));
CoTaskMemFree(wszObjectID);
return jsObjectID;
}
else
{
ThrowCOMException(env, L"Couldn't commit the data to the portable device", hr);
}
}
else
{
ThrowCOMException(env, L"Couldn't create a COM stream object to the portable device", hr);
}
}
else
{
ThrowCOMException(env, L"Couldn't create a COM stream object to the file", hr);
}
return NULL;
}
