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; }