static HRESULT read_hlink_string(IStream *pStm, LPWSTR *out_str) { LPWSTR str; DWORD len; ULONG read; HRESULT hr; hr = IStream_Read(pStm, &len, sizeof(len), &read); if (FAILED(hr)) return hr; if (read != sizeof(len)) return STG_E_READFAULT; TRACE("read len %d\n", len); str = heap_alloc(len * sizeof(WCHAR)); if (!str) return E_OUTOFMEMORY; hr = IStream_Read(pStm, str, len * sizeof(WCHAR), &read); if (FAILED(hr)) { heap_free(str); return hr; } if (read != len * sizeof(WCHAR)) { heap_free(str); return STG_E_READFAULT; } TRACE("read string %s\n", debugstr_w(str)); *out_str = str; return S_OK; }
/****************************************************************************** * URLMoniker_Load * * NOTE * Writes a ULONG containing length of unicode string, followed * by that many unicode characters ******************************************************************************/ static HRESULT WINAPI URLMonikerImpl_Load(IMoniker* iface,IStream* pStm) { URLMonikerImpl *This = (URLMonikerImpl *)iface; HRESULT res; ULONG size; ULONG got; TRACE("(%p,%p)\n",This,pStm); if(!pStm) return E_INVALIDARG; res = IStream_Read(pStm, &size, sizeof(ULONG), &got); if(SUCCEEDED(res)) { if(got == sizeof(ULONG)) { heap_free(This->URLName); This->URLName = heap_alloc(size); if(!This->URLName) res = E_OUTOFMEMORY; else { res = IStream_Read(pStm, This->URLName, size, NULL); This->URLName[size/sizeof(WCHAR) - 1] = 0; } } else res = E_FAIL; } return res; }
static HRESULT WINAPI FTMarshalImpl_UnmarshalInterface (LPMARSHAL iface, IStream * pStm, REFIID riid, void **ppv) { DWORD mshlflags; IUnknown *object; DWORD constant; GUID unknown_guid; HRESULT hres; TRACE ("(%p, %s, %p)\n", pStm, debugstr_guid(riid), ppv); hres = IStream_Read (pStm, &mshlflags, sizeof (mshlflags), NULL); if (hres != S_OK) return STG_E_READFAULT; hres = IStream_Read (pStm, &object, sizeof (object), NULL); if (hres != S_OK) return STG_E_READFAULT; hres = IStream_Read (pStm, &constant, sizeof (constant), NULL); if (hres != S_OK) return STG_E_READFAULT; if (constant != 0) FIXME("constant is 0x%lx instead of 0\n", constant); hres = IStream_Read (pStm, &unknown_guid, sizeof (unknown_guid), NULL); if (hres != S_OK) return STG_E_READFAULT; hres = IUnknown_QueryInterface(object, riid, ppv); if (!(mshlflags & (MSHLFLAGS_TABLEWEAK|MSHLFLAGS_TABLESTRONG))) IUnknown_Release(object); return hres; }
static HRESULT WINAPI FTMarshalImpl_ReleaseMarshalData (LPMARSHAL iface, IStream * pStm) { DWORD mshlflags; IUnknown *object; DWORD constant; GUID unknown_guid; HRESULT hres; TRACE ("(%p)\n", pStm); hres = IStream_Read (pStm, &mshlflags, sizeof (mshlflags), NULL); if (hres != S_OK) return STG_E_READFAULT; hres = IStream_Read (pStm, &object, sizeof (object), NULL); if (hres != S_OK) return STG_E_READFAULT; hres = IStream_Read (pStm, &constant, sizeof (constant), NULL); if (hres != S_OK) return STG_E_READFAULT; if (constant != 0) FIXME("constant is 0x%lx instead of 0\n", constant); hres = IStream_Read (pStm, &unknown_guid, sizeof (unknown_guid), NULL); if (hres != S_OK) return STG_E_READFAULT; IUnknown_Release(object); return S_OK; }
static void test_URLOpenBlockingStreamW(void) { HRESULT hr; IStream *pStream = NULL; char buffer[256]; hr = URLOpenBlockingStreamW(NULL, NULL, &pStream, 0, &BindStatusCallback); ok(hr == E_INVALIDARG, "URLOpenBlockingStreamW should have failed with E_INVALIDARG instead of 0x%08x\n", hr); if (0) /* crashes on Win2k */ { hr = URLOpenBlockingStreamW(NULL, INDEX_HTML, NULL, 0, &BindStatusCallback); ok(hr == E_INVALIDARG, "URLOpenBlockingStreamW should have failed with E_INVALIDARG instead of 0x%08x\n", hr); } SET_EXPECT(GetBindInfo); SET_EXPECT(QueryInterface_IServiceProvider); SET_EXPECT(OnStartBinding); SET_EXPECT(OnProgress_SENDINGREQUEST); SET_EXPECT(OnProgress_MIMETYPEAVAILABLE); SET_EXPECT(OnProgress_BEGINDOWNLOADDATA); SET_EXPECT(OnProgress_ENDDOWNLOADDATA); SET_EXPECT(OnStopBinding); hr = URLOpenBlockingStreamW(NULL, INDEX_HTML, &pStream, 0, &BindStatusCallback); ok(hr == S_OK, "URLOpenBlockingStreamW failed with error 0x%08x\n", hr); CHECK_CALLED(GetBindInfo); todo_wine CHECK_CALLED(QueryInterface_IServiceProvider); CHECK_CALLED(OnStartBinding); CHECK_CALLED(OnProgress_SENDINGREQUEST); CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE); CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA); CHECK_CALLED(OnProgress_ENDDOWNLOADDATA); CHECK_CALLED(OnStopBinding); ok(pStream != NULL, "pStream is NULL\n"); if(pStream) { buffer[0] = 0; hr = IStream_Read(pStream, buffer, sizeof(buffer), NULL); ok(hr == S_OK, "IStream_Read failed with error 0x%08x\n", hr); ok(!memcmp(buffer, szHtmlDoc, sizeof(szHtmlDoc)-1), "read data differs from file\n"); IStream_Release(pStream); } hr = URLOpenBlockingStreamW(NULL, INDEX_HTML, &pStream, 0, NULL); ok(hr == S_OK, "URLOpenBlockingStreamW failed with error 0x%08x\n", hr); ok(pStream != NULL, "pStream is NULL\n"); if(pStream) { buffer[0] = 0; hr = IStream_Read(pStream, buffer, sizeof(buffer), NULL); ok(hr == S_OK, "IStream_Read failed with error 0x%08x\n", hr); ok(!memcmp(buffer, szHtmlDoc, sizeof(szHtmlDoc)-1), "read data differs from file\n"); IStream_Release(pStream); } }
static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegTrackList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) { /*ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, PersistStreamVtbl, iface);*/ HRESULT hr = E_FAIL; DMUS_PRIVATE_CHUNK Chunk; DWORD ListSize[3], ListCount[3]; LARGE_INTEGER liMove; /* used when skipping chunks */ if (pChunk->fccID != DMUS_FOURCC_SEGTRACK_LIST) { ERR_(dmfile)(": %s chunk should be a SEGTRACK list\n", debugstr_fourcc (pChunk->fccID)); return E_FAIL; } ListSize[0] = pChunk->dwSize - sizeof(FOURCC); ListCount[0] = 0; do { IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); switch (Chunk.fccID) { case DMUS_FOURCC_SEGTRACK_CHUNK: { TRACE_(dmfile)(": segment trigger track chunk\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } case FOURCC_LIST: { IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID)); ListSize[1] = Chunk.dwSize - sizeof(FOURCC); ListCount[1] = 0; switch (Chunk.fccID) { case DMUS_FOURCC_SEGMENTS_LIST: { TRACE_(dmfile)(": SEGMENTS list\n"); hr = IDirectMusicSegTriggerTrack_IPersistStream_ParseSegmentsList (iface, &Chunk, pStm); if (FAILED(hr)) return hr; break; } default: { TRACE_(dmfile)(": unknown (skipping)\n"); liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } break; } default: { TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]); } while (ListCount[0] < ListSize[0]); return S_OK; }
static HRESULT WINAPI PersistHistory_LoadHistory(IPersistHistory *iface, IStream *pStream, IBindCtx *pbc) { HTMLDocument *This = impl_from_IPersistHistory(iface); ULONG str_len, read; WCHAR *uri_str; IUri *uri; HRESULT hres; TRACE("(%p)->(%p %p)\n", This, pStream, pbc); if(!This->window) { FIXME("No current window\n"); return E_UNEXPECTED; } if(pbc) FIXME("pbc not supported\n"); if(This->doc_obj->client) { IOleCommandTarget *cmdtrg = NULL; hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget, (void**)&cmdtrg); if(SUCCEEDED(hres)) { IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 138, 0, NULL, NULL); IOleCommandTarget_Release(cmdtrg); } } hres = IStream_Read(pStream, &str_len, sizeof(str_len), &read); if(FAILED(hres)) return hres; if(read != sizeof(str_len)) return E_FAIL; uri_str = heap_alloc((str_len+1)*sizeof(WCHAR)); if(!uri_str) return E_OUTOFMEMORY; hres = IStream_Read(pStream, uri_str, str_len*sizeof(WCHAR), &read); if(SUCCEEDED(hres) && read != str_len*sizeof(WCHAR)) hres = E_FAIL; if(SUCCEEDED(hres)) { uri_str[str_len] = 0; hres = create_uri(uri_str, 0, &uri); } heap_free(uri_str); if(FAILED(hres)) return hres; hres = load_uri(This->window, uri, BINDING_FROMHIST); IUri_Release(uri); return hres; }
static HRESULT WINAPI URLMoniker_Load(IMoniker* iface,IStream* pStm) { URLMoniker *This = impl_from_IMoniker(iface); WCHAR *new_uri_str; IUri *new_uri; BSTR new_url; ULONG size; ULONG got; HRESULT hres; TRACE("(%p,%p)\n",This,pStm); if(!pStm) return E_INVALIDARG; /* * NOTE * Writes a ULONG containing length of unicode string, followed * by that many unicode characters */ hres = IStream_Read(pStm, &size, sizeof(ULONG), &got); if(FAILED(hres)) return hres; if(got != sizeof(ULONG)) return E_FAIL; new_uri_str = heap_alloc(size+sizeof(WCHAR)); if(!new_uri_str) return E_OUTOFMEMORY; hres = IStream_Read(pStm, new_uri_str, size, NULL); new_uri_str[size/sizeof(WCHAR)] = 0; if(SUCCEEDED(hres)) hres = CreateUri(new_uri_str, 0, 0, &new_uri); heap_free(new_uri_str); if(FAILED(hres)) return hres; hres = IUri_GetDisplayUri(new_uri, &new_url); if(FAILED(hres)) { IUri_Release(new_uri); return hres; } SysFreeString(This->URLName); if(This->uri) IUri_Release(This->uri); This->uri = new_uri; This->URLName = new_url; return S_OK; }
static HRESULT CALLBACK CB_Load(DPASTREAMINFO *pInfo, IStream *pStm, LPVOID lp) { HRESULT hRes; INT iOldPos; iOldPos = pInfo->iPos; ok(lp == (LPVOID)0xdeadbeef, "lp=%p\n", lp); hRes = IStream_Read(pStm, &pInfo->iPos, sizeof(INT), NULL); expect(S_OK, hRes); ok(pInfo->iPos == iOldPos, "iPos=%d iOldPos=%d\n", pInfo->iPos, iOldPos); hRes = IStream_Read(pStm, &pInfo->pvItem, sizeof(PVOID), NULL); expect(S_OK, hRes); return S_OK; }
static HRESULT CALLBACK CB_Load(LPITEMDATA pInfo, IStream *pStm, LPARAM lp) { HRESULT hRes; INT iOldPos; iOldPos = pInfo->iPos; ok(lp == 0xdeadbeef, "lp=%ld\n", lp); hRes = IStream_Read(pStm, &pInfo->iPos, sizeof(INT), NULL); ok(hRes == S_OK, "hRes=0x%x\n", hRes); ok(pInfo->iPos == iOldPos, "iPos=%d iOldPos=%d\n", pInfo->iPos, iOldPos); hRes = IStream_Read(pStm, &pInfo->pvData, sizeof(PVOID), NULL); ok(hRes == S_OK, "hRes=0x%x\n", hRes); return S_OK; }
HRESULT IStream_ReadToBuffer(IStream *pstm, UINT uMaxSize, BYTE **ppBytes, UINT *pcBytes) { *ppBytes = NULL; *pcBytes = 0; ULARGE_INTEGER uli; HRESULT hr = IStream_Size(pstm, &uli); if (SUCCEEDED(hr)) { const ULARGE_INTEGER c_uliMaxSize = { uMaxSize }; hr = (uli.QuadPart < c_uliMaxSize.QuadPart) ? S_OK : E_FAIL; if (SUCCEEDED(hr)) { BYTE *pdata = (BYTE*)LocalAlloc(LPTR, uli.LowPart); hr = pdata ? S_OK : E_OUTOFMEMORY; if (SUCCEEDED(hr)) { hr = IStream_Read(pstm, pdata, uli.LowPart); if (SUCCEEDED(hr)) { *ppBytes = pdata; *pcBytes = uli.LowPart; } else { LocalFree(pdata); } } } } return hr; }
/****************************************************************************** * ClassMoniker_Load ******************************************************************************/ static HRESULT WINAPI ClassMoniker_Load(IMoniker* iface,IStream* pStm) { ClassMoniker *This = impl_from_IMoniker(iface); HRESULT hr; DWORD zero; TRACE("(%p)\n", pStm); hr = IStream_Read(pStm, &This->clsid, sizeof(This->clsid), NULL); if (hr != S_OK) return STG_E_READFAULT; hr = IStream_Read(pStm, &zero, sizeof(zero), NULL); if ((hr != S_OK) || (zero != 0)) return STG_E_READFAULT; return S_OK; }
static HRESULT WINAPI XMLView_BindStatusCallback_OnDataAvailable( IBindStatusCallback *iface, DWORD grfBSCF, DWORD dwSize, FORMATETC *pformatetc, STGMEDIUM *pstgmed) { BindStatusCallback *This = impl_from_IBindStatusCallback(iface); char buf[1024]; DWORD size; HRESULT hres; TRACE("(%p)->(%x %d %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed); if(!This->stream) return E_FAIL; do { hres = IStream_Read(pstgmed->u.pstm, buf, sizeof(buf), &size); IStream_Write(This->stream, buf, size, &size); } while(hres==S_OK && size); if(FAILED(hres) && hres!=E_PENDING) return hres; if(hres != S_FALSE) return S_OK; return handle_xml_load(This); }
static BOOL stream_chr(stream_t *stream, strbuf_t *buf, char c) { BOOL b = TRUE; ULONG i; while(b) { for(i=stream->p; i<stream->size; i++) { if(stream->buf[i] == c) { b = FALSE; break; } } if(buf && i > stream->p) strbuf_append(buf, stream->buf+stream->p, i-stream->p); stream->p = i; if(stream->p == stream->size) { stream->p = 0; IStream_Read(stream->str, stream->buf, sizeof(stream->buf), &stream->size); if(!stream->size) break; } } return stream->size != 0; }
static HRESULT write_post_stream(Protocol *protocol) { BYTE buf[0x20000]; DWORD written; ULONG size; BOOL res; HRESULT hres; protocol->flags &= ~FLAG_REQUEST_COMPLETE; while(1) { size = 0; hres = IStream_Read(protocol->post_stream, buf, sizeof(buf), &size); if(FAILED(hres) || !size) break; res = InternetWriteFile(protocol->request, buf, size, &written); if(!res) { FIXME("InternetWriteFile failed: %u\n", GetLastError()); hres = E_FAIL; break; } } if(SUCCEEDED(hres)) { IStream_Release(protocol->post_stream); protocol->post_stream = NULL; hres = protocol->vtbl->end_request(protocol); } if(FAILED(hres)) return report_result(protocol, hres); return S_OK; }
static HRESULT WINAPI bsc_OnDataAvailable( IBindStatusCallback* iface, DWORD grfBSCF, DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed) { bsc_t *This = impl_from_IBindStatusCallback(iface); BYTE buf[4096]; DWORD read, written; HRESULT hr; TRACE("(%p)->(%x %d %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed); do { hr = IStream_Read(pstgmed->u.pstm, buf, sizeof(buf), &read); if(FAILED(hr)) break; hr = IStream_Write(This->memstream, buf, read, &written); } while(SUCCEEDED(hr) && written != 0 && read != 0); return S_OK; }
static void test_freed_hglobal(void) { static const char teststring[] = "this is a test string"; HRESULT hr; IStream *pStream; HGLOBAL hglobal; char *p; char buffer[sizeof(teststring) + 8]; ULARGE_INTEGER ull; ULONG read, written; hglobal = GlobalAlloc(GMEM_DDESHARE|GMEM_NODISCARD|GMEM_MOVEABLE, strlen(teststring) + 1); ok(hglobal != NULL, "GlobalAlloc failed with error %d\n", GetLastError()); p = GlobalLock(hglobal); strcpy(p, teststring); GlobalUnlock(hglobal); hr = CreateStreamOnHGlobal(hglobal, FALSE, &pStream); ok_ole_success(hr, "CreateStreamOnHGlobal"); hr = IStream_Read(pStream, buffer, sizeof(buffer), &read); ok_ole_success(hr, "IStream_Read"); ok(!strcmp(buffer, teststring), "buffer data %s differs\n", buffer); ok(read == sizeof(teststring) || broken(read == ((sizeof(teststring) + 3) & ~3)), /* win9x rounds the size */ "read should be sizeof(teststring) instead of %d\n", read); GlobalFree(hglobal); memset(buffer, 0, sizeof(buffer)); read = -1; hr = IStream_Read(pStream, buffer, sizeof(buffer), &read); ok_ole_success(hr, "IStream_Read"); ok(buffer[0] == 0, "buffer data should be untouched\n"); ok(read == 0, "read should be 0 instead of %d\n", read); ull.QuadPart = sizeof(buffer); hr = IStream_SetSize(pStream, ull); ok(hr == E_OUTOFMEMORY, "IStream_SetSize with invalid HGLOBAL should return E_OUTOFMEMORY instead of 0x%08x\n", hr); hr = IStream_Write(pStream, buffer, sizeof(buffer), &written); ok(hr == E_OUTOFMEMORY, "IStream_Write with invalid HGLOBAL should return E_OUTOFMEMORY instead of 0x%08x\n", hr); ok(written == 0, "written should be 0 instead of %d\n", written); IStream_Release(pStream); }
static gboolean gdip_save_bitmap_to_callback (GpBitmap *bitmap, const CLSID *format, const EncoderParameters *encoder_params, GdkPixbufSaveFunc save_func, gpointer user_data, GError **error) { HRESULT hr; IStream *streamOut = NULL; gboolean success = FALSE; guint64 zero = 0; GpStatus status; hr = CreateStreamOnHGlobal (NULL, TRUE, &streamOut); if (!SUCCEEDED (hr)) { gdip_set_error_from_hresult (error, GDK_PIXBUF_ERROR_FAILED, hr, _("Could not create stream: %s")); return FALSE; } status = GdipSaveImageToStream ((GpImage *)bitmap, streamOut, format, encoder_params); if (Ok != status) { gdip_set_error_from_gpstatus (error, GDK_PIXBUF_ERROR_FAILED, status); IStream_Release (streamOut); return FALSE; } /* seek back to the beginning of the stream */ hr = IStream_Seek (streamOut, *(LARGE_INTEGER *)&zero, STREAM_SEEK_SET, NULL); if (!SUCCEEDED (hr)) { gdip_set_error_from_hresult (error, GDK_PIXBUF_ERROR_FAILED, hr, _("Could not seek stream: %s")); IStream_Release (streamOut); return FALSE; } for (;;) { char buffer[LOAD_BUFFER_SIZE]; ULONG nread; hr = IStream_Read (streamOut, buffer, sizeof(buffer), &nread); if (!SUCCEEDED (hr)) { gdip_set_error_from_hresult (error, GDK_PIXBUF_ERROR_FAILED, hr, _("Could not read from stream: %s")); break; } else if (0 == nread) { success = TRUE; /* EOF */ break; } else if (!(*save_func) (buffer, nread, error, user_data)) break; } IStream_Release (streamOut); return success; }
UINT MSI_RecordReadStream(MSIRECORD *rec, UINT iField, char *buf, LPDWORD sz) { ULONG count; HRESULT r; IStream *stm; TRACE("%p %d %p %p\n", rec, iField, buf, sz); if( !sz ) return ERROR_INVALID_PARAMETER; if( iField > rec->count) return ERROR_INVALID_PARAMETER; if ( rec->fields[iField].type == MSIFIELD_NULL ) { *sz = 0; return ERROR_INVALID_DATA; } if( rec->fields[iField].type != MSIFIELD_STREAM ) return ERROR_INVALID_DATATYPE; stm = rec->fields[iField].u.stream; if( !stm ) return ERROR_INVALID_PARAMETER; /* if there's no buffer pointer, calculate the length to the end */ if( !buf ) { LARGE_INTEGER ofs; ULARGE_INTEGER end, cur; ofs.QuadPart = cur.QuadPart = 0; end.QuadPart = 0; IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur ); IStream_Seek( stm, ofs, STREAM_SEEK_END, &end ); ofs.QuadPart = cur.QuadPart; IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur ); *sz = end.QuadPart - cur.QuadPart; return ERROR_SUCCESS; } /* read the data */ count = 0; r = IStream_Read( stm, buf, *sz, &count ); if( FAILED( r ) ) { *sz = 0; return ERROR_FUNCTION_FAILED; } *sz = count; return ERROR_SUCCESS; }
static HRESULT WINAPI IWICStreamImpl_Read(IWICStream *iface, void *pv, ULONG cb, ULONG *pcbRead) { IWICStreamImpl *This = impl_from_IWICStream(iface); TRACE("(%p): relay\n", This); if (!This->pStream) return WINCODEC_ERR_NOTINITIALIZED; return IStream_Read(This->pStream, pv, cb, pcbRead); }
static HRESULT WINAPI IDirectMusicLoaderGenericStream_IStream_Read (LPSTREAM iface, void* pv, ULONG cb, ULONG* pcbRead) { ICOM_THIS_MULTI(IDirectMusicLoaderGenericStream, StreamVtbl, iface); TRACE_(dmfileraw)("(%p, %p, 0x%08lX, %p): redirecting to low-level stream\n", This, pv, cb, pcbRead); if (!This->pStream) return E_FAIL; return IStream_Read (This->pStream, pv, cb, pcbRead); }
static HRESULT WINAPI IDirectMusicSegTriggerTrack_IPersistStream_Load (LPPERSISTSTREAM iface, IStream* pStm) { ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, PersistStreamVtbl, iface); DMUS_PRIVATE_CHUNK Chunk; LARGE_INTEGER liMove; HRESULT hr; TRACE("(%p, %p): Loading\n", This, pStm); #if 1 IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); switch (Chunk.fccID) { case FOURCC_LIST: { IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); switch (Chunk.fccID) { case DMUS_FOURCC_SEGTRACK_LIST: { TRACE_(dmfile)(": segment trigger track list\n"); hr = IDirectMusicSegTriggerTrack_IPersistStream_ParseSegTrackList (iface, &Chunk, pStm); if (FAILED(hr)) return hr; break; } default: { TRACE_(dmfile)(": unexpected chunk; loading failed)\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); return E_FAIL; } } TRACE_(dmfile)(": reading finished\n"); break; } default: { TRACE_(dmfile)(": unexpected chunk; loading failed)\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */ return E_FAIL; } } #endif return S_OK; }
static HRESULT BmpFrameDecode_ReadUncompressed(BmpFrameDecode* This) { UINT bytesperrow; UINT width, height; UINT datasize; int bottomup; HRESULT hr; LARGE_INTEGER offbits; ULONG bytesread; if (This->bih.bV5Size == sizeof(BITMAPCOREHEADER)) { BITMAPCOREHEADER *bch = (BITMAPCOREHEADER*)&This->bih; width = bch->bcWidth; height = bch->bcHeight; bottomup = 1; } else { width = This->bih.bV5Width; height = abs(This->bih.bV5Height); bottomup = (This->bih.bV5Height > 0); } /* row sizes in BMP files must be divisible by 4 bytes */ bytesperrow = (((width * This->bitsperpixel)+31)/32)*4; datasize = bytesperrow * height; This->imagedata = HeapAlloc(GetProcessHeap(), 0, datasize); if (!This->imagedata) return E_OUTOFMEMORY; offbits.QuadPart = This->bfh.bfOffBits; hr = IStream_Seek(This->stream, offbits, STREAM_SEEK_SET, NULL); if (FAILED(hr)) goto fail; hr = IStream_Read(This->stream, This->imagedata, datasize, &bytesread); if (FAILED(hr) || bytesread != datasize) goto fail; if (bottomup) { This->imagedatastart = This->imagedata + (height-1) * bytesperrow; This->stride = -bytesperrow; } else { This->imagedatastart = This->imagedata; This->stride = bytesperrow; } return S_OK; fail: HeapFree(GetProcessHeap(), 0, This->imagedata); This->imagedata = NULL; if (SUCCEEDED(hr)) hr = E_FAIL; return hr; }
/*** * This method is part of the IStream interface. * * It will copy the 'cb' Bytes to 'pstm' IStream. * * See the documentation of IStream for more info. */ static HRESULT WINAPI HGLOBALStreamImpl_CopyTo( IStream* iface, IStream* pstm, /* [unique][in] */ ULARGE_INTEGER cb, /* [in] */ ULARGE_INTEGER* pcbRead, /* [out] */ ULARGE_INTEGER* pcbWritten) /* [out] */ { HRESULT hr = S_OK; BYTE tmpBuffer[128]; ULONG bytesRead, bytesWritten, copySize; ULARGE_INTEGER totalBytesRead; ULARGE_INTEGER totalBytesWritten; TRACE("(%p, %p, %d, %p, %p)\n", iface, pstm, cb.u.LowPart, pcbRead, pcbWritten); if ( pstm == 0 ) return STG_E_INVALIDPOINTER; totalBytesRead.QuadPart = 0; totalBytesWritten.QuadPart = 0; while ( cb.QuadPart > 0 ) { if ( cb.QuadPart >= sizeof(tmpBuffer) ) copySize = sizeof(tmpBuffer); else copySize = cb.u.LowPart; hr = IStream_Read(iface, tmpBuffer, copySize, &bytesRead); if (FAILED(hr)) break; totalBytesRead.QuadPart += bytesRead; if (bytesRead) { hr = IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten); if (FAILED(hr)) break; totalBytesWritten.QuadPart += bytesWritten; } if (bytesRead!=copySize) cb.QuadPart = 0; else cb.QuadPart -= bytesRead; } if (pcbRead) pcbRead->QuadPart = totalBytesRead.QuadPart; if (pcbWritten) pcbWritten->QuadPart = totalBytesWritten.QuadPart; return hr; }
static HRESULT WINAPI IDirectMusicBandImpl_IPersistStream_Load (LPPERSISTSTREAM iface, IStream* pStm) { ICOM_THIS_MULTI(IDirectMusicBandImpl, PersistStreamVtbl, iface); DMUS_PRIVATE_CHUNK Chunk; LARGE_INTEGER liMove; HRESULT hr; TRACE("(%p,%p): loading\n", This, pStm); IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); switch (Chunk.fccID) { case FOURCC_RIFF: { IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); switch (Chunk.fccID) { case DMUS_FOURCC_BAND_FORM: { TRACE_(dmfile)(": Band form\n"); hr = IDirectMusicBandImpl_IPersistStream_ParseBandForm (iface, &Chunk, pStm); if (FAILED(hr)) return hr; break; } default: { TRACE_(dmfile)(": unexpected chunk; loading failed)\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); return E_FAIL; } } TRACE_(dmfile)(": reading finished\n"); break; } default: { TRACE_(dmfile)(": unexpected chunk; loading failed)\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */ return E_FAIL; } } return S_OK; }
static void test_copyto(void) { IStream *pStream, *pStream2; HRESULT hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream); static const char szHello[] = "Hello"; ULARGE_INTEGER cb; static const char *methods_copyto[] = { "TestStream_Write", NULL }; ULONG written; ULARGE_INTEGER ullRead; ULARGE_INTEGER ullWritten; ULARGE_INTEGER libNewPosition; static const LARGE_INTEGER llZero; char buffer[15]; ok_ole_success(hr, "CreateStreamOnHGlobal"); expected_method_list = methods_copyto; hr = IStream_Write(pStream, szHello, sizeof(szHello), &written); ok_ole_success(hr, "IStream_Write"); ok(written == sizeof(szHello), "only %d bytes written\n", written); hr = IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL); ok_ole_success(hr, "IStream_Seek"); cb.QuadPart = sizeof(szHello); hr = IStream_CopyTo(pStream, &Test_Stream, cb, &ullRead, &ullWritten); ok(ullWritten.QuadPart == 5, "ullWritten was %d instead\n", (ULONG)ullWritten.QuadPart); ok(ullRead.QuadPart == sizeof(szHello), "only %d bytes read\n", (ULONG)ullRead.QuadPart); ok_ole_success(hr, "IStream_CopyTo"); ok(!*expected_method_list, "Method sequence starting from %s not called\n", *expected_method_list); hr = IStream_Clone(pStream, &pStream2); ok_ole_success(hr, "IStream_Clone"); hr = IStream_Seek(pStream2, llZero, STREAM_SEEK_CUR, &libNewPosition); ok_ole_success(hr, "IStream_Seek"); ok(libNewPosition.QuadPart == sizeof(szHello), "libNewPosition wasn't set correctly for the cloned stream\n"); hr = IStream_Seek(pStream2, llZero, STREAM_SEEK_SET, NULL); ok_ole_success(hr, "IStream_Seek"); hr = IStream_Read(pStream2, buffer, sizeof(buffer), NULL); ok_ole_success(hr, "IStream_Read"); ok(!strcmp(buffer, szHello), "read data \"%s\" didn't match originally written data\n", buffer); IStream_Release(pStream2); IStream_Release(pStream); }
static HRESULT WINAPI IPersistStream_fnLoad(IPersistStream* iface, IStream* pStm) { HRESULT r; DWORD hdr[2]; DWORD read; HlinkImpl *This = impl_from_IPersistStream(iface); r = IStream_Read(pStm, hdr, sizeof(hdr), &read); if (read != sizeof(hdr) || (hdr[0] != HLINK_SAVE_MAGIC)) { r = E_FAIL; goto end; } if (hdr[1] & ~HLINK_SAVE_ALL) FIXME("unknown flag(s) 0x%x\n", hdr[1] & ~HLINK_SAVE_ALL); if (hdr[1] & HLINK_SAVE_TARGET_FRAME_PRESENT) { TRACE("loading target frame name\n"); r = read_hlink_string(pStm, &This->TargetFrameName); if (FAILED(r)) goto end; } if (hdr[1] & HLINK_SAVE_FRIENDLY_PRESENT) { TRACE("loading target friendly name\n"); if (!(hdr[1] & 0x4)) FIXME("0x4 flag not present with friendly name flag - not sure what this means\n"); r = read_hlink_string(pStm, &This->FriendlyName); if (FAILED(r)) goto end; } if (hdr[1] & HLINK_SAVE_MONIKER_PRESENT) { TRACE("loading moniker\n"); r = OleLoadFromStream(pStm, &IID_IMoniker, (LPVOID*)&(This->Moniker)); if (FAILED(r)) goto end; This->absolute = (hdr[1] & HLINK_SAVE_MONIKER_IS_ABSOLUTE) != 0; } if (hdr[1] & HLINK_SAVE_LOCATION_PRESENT) { TRACE("loading location\n"); r = read_hlink_string(pStm, &This->Location); if (FAILED(r)) goto end; } end: TRACE("Load Result 0x%x (%p)\n", r, This->Moniker); return r; }
static HRESULT WINAPI xmldoc_IPersistStreamInit_Load( IPersistStreamInit *iface, LPSTREAM pStm) { xmldoc *This = impl_from_IPersistStreamInit(iface); HRESULT hr; HGLOBAL hglobal; DWORD read, written, len; BYTE buf[4096]; char *ptr; TRACE("(%p, %p)\n", iface, pStm); if (!pStm) return E_INVALIDARG; /* release previously allocated stream */ if (This->stream) IStream_Release(This->stream); hr = CreateStreamOnHGlobal(NULL, TRUE, &This->stream); if (FAILED(hr)) return hr; do { IStream_Read(pStm, buf, sizeof(buf), &read); hr = IStream_Write(This->stream, buf, read, &written); } while(SUCCEEDED(hr) && written != 0 && read != 0); if (FAILED(hr)) { ERR("Failed to copy stream\n"); return hr; } hr = GetHGlobalFromStream(This->stream, &hglobal); if (FAILED(hr)) return hr; len = GlobalSize(hglobal); ptr = GlobalLock(hglobal); if (len != 0) { xmlFreeDoc(This->xmldoc); This->xmldoc = parse_xml(ptr, len); } GlobalUnlock(hglobal); if (!This->xmldoc) { ERR("Failed to parse xml\n"); return E_FAIL; } return S_OK; }
static HRESULT WINAPI MkProtocol_Read(IInternetProtocolEx *iface, void *pv, ULONG cb, ULONG *pcbRead) { MkProtocol *This = impl_from_IInternetProtocolEx(iface); TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead); if(!This->stream) return E_FAIL; return IStream_Read(This->stream, pv, cb, pcbRead); }
static void user_read_data(png_structp png_ptr, png_bytep data, png_size_t length) { IStream *stream = ppng_get_io_ptr(png_ptr); HRESULT hr; ULONG bytesread; hr = IStream_Read(stream, data, length, &bytesread); if (FAILED(hr) || bytesread != length) { ppng_error(png_ptr, "failed reading data"); } }