private static MemoryStream GetIStream(STGMEDIUM medium) { //marshal the returned pointer to a IStream object IStream iStream = (IStream)Marshal.GetObjectForIUnknown(medium.unionmember); Marshal.Release(medium.unionmember); //get the STATSTG of the IStream to determine how many bytes are in it var iStreamStat = new System.Runtime.InteropServices.ComTypes.STATSTG(); iStream.Stat(out iStreamStat, 0); int iStreamSize = (int)iStreamStat.cbSize; //prevent memoryexception if (iStreamSize > 100000000) { return(null); } //read the data from the IStream into a managed byte array byte[] iStreamContent = new byte[iStreamSize]; iStream.Read(iStreamContent, iStreamContent.Length, IntPtr.Zero); //wrapped the managed byte array into a memory stream return(new MemoryStream(iStreamContent)); }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG statStg, int grfFlags) { statStg = new System.Runtime.InteropServices.ComTypes.STATSTG { cbSize = m_stream.Length }; }
public void Stat(out STATSTG pstatstg, int grfStatFlag) { pstatstg = new STATSTG { type = STGTY_STREAM, cbSize = BaseStream.Length, grfMode = 0 }; if (BaseStream.CanRead && BaseStream.CanWrite) { pstatstg.grfMode |= STGM_READWRITE; } else if (BaseStream.CanRead) { pstatstg.grfMode |= STGM_READ; } else if (BaseStream.CanWrite) { pstatstg.grfMode |= STGM_WRITE; } else { throw new IOException("Stream is closed"); } }
public void Stat(out STATSTG pstatstg, int grfStatFlag) { pstatstg = new STATSTG() { cbSize = _stream.Length }; }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { const int STGTY_STREAM = 2; pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG(); pstatstg.type = STGTY_STREAM; pstatstg.cbSize = this._stream.Length; pstatstg.grfMode = 0; if (this._stream.CanRead && this._stream.CanWrite) { const int STGM_READWRITE = 0x00000002; pstatstg.grfMode |= STGM_READWRITE; return; } if (this._stream.CanRead) { const int STGM_READ = 0x00000000; pstatstg.grfMode |= STGM_READ; return; } if (this._stream.CanWrite) { const int STGM_WRITE = 0x00000001; pstatstg.grfMode |= STGM_WRITE; return; } throw new IOException(); }
//No problem cant be made worse with recursion! private List <string> OpenSubStorage(ole32.IStorage Is, string pwcsName, List <string> data) { ole32.IStorage ppstg; Is.OpenStorage(pwcsName, null, (uint)(ole32.STGM.READ | ole32.STGM.SHARE_EXCLUSIVE), IntPtr.Zero, 0, out ppstg); //set up to fetch one item on each call to next ole32.IEnumSTATSTG SSenum; ppstg.EnumElements(0, IntPtr.Zero, 0, out SSenum); var SSstruct = new System.Runtime.InteropServices.ComTypes.STATSTG[1]; //do the loop until not more items uint NumReturned; do { SSenum.Next(1, SSstruct, out NumReturned); if (NumReturned != 0) { if (SSstruct[0].type == 1) { OpenSubStorage(ppstg, SSstruct[0].pwcsName, data); } else if (SSstruct[0].type == 2 && SSstruct[0].pwcsName == "3") { data.Add(readStream(ref ppstg, SSstruct[0].pwcsName)); } } } while (NumReturned > 0); return(data); }
public IEnumerable <string> GetNotes(string path) { var data = new List <string>(); var isOLE = ole32.StgIsStorageFile(path); if (isOLE == 0) { //open the storage ole32.IStorage Is; int result = ole32.StgOpenStorage(path, null, ole32.STGM.READ | ole32.STGM.SHARE_DENY_WRITE, IntPtr.Zero, 0, out Is); //set up to fetch one item on each call to next ole32.IEnumSTATSTG SSenum; Is.EnumElements(0, IntPtr.Zero, 0, out SSenum); var SSstruct = new System.Runtime.InteropServices.ComTypes.STATSTG[1]; //do the loop until not more items uint NumReturned; do { SSenum.Next(1, SSstruct, out NumReturned); if (NumReturned != 0) { if (SSstruct[0].type == 1) { OpenSubStorage(Is, SSstruct[0].pwcsName, data); } } } while (NumReturned > 0); } return(data); }
public void Stat(out ComTypes.STATSTG pstatstg, STATFLAG grfStatFlag) { pstatstg = new ComTypes.STATSTG(); pstatstg.type = (int)STGTY.Stream; pstatstg.cbSize = this.stream.Length; pstatstg.grfLocksSupported = (int)LOCKTYPE.Exclusive; }
public void Stat(out com.STATSTG pstatstg, int grfStatFlag) { pstatstg = new com.STATSTG() { cbSize = this.source.Length }; }
public void Stat( out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG(); pstatstg.cbSize = base.Length; }
/// <summary> /// Returns details about the stream, including its length, type and name. /// </summary> /// <param name="pstatstg"></param> /// <param name="grfStatFlag"></param> public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG(); pstatstg.cbSize = mInner.Length; pstatstg.type = 2; // stream type pstatstg.pwcsName = (mInner is FileStream) ? ((FileStream)mInner).Name : String.Empty; }
/// <summary> /// Obtain stream stats. /// </summary> /// <remarks> /// STATSG has to be qualified because it is defined both in System.Runtime.InteropServices and /// System.Runtime.InteropServices.ComTypes. /// The STATSTG structure is shared by streams, storages and byte arrays. Members irrelevant to streams /// or not available from System.IO.Stream are not returned, which leaves only cbSize and grfMode as /// meaningful and available pieces of information. /// grfStatFlag is used to indicate whether the stream name should be returned and is ignored because /// this information is unavailable. /// </remarks> void IStream.Stat(out System.Runtime.InteropServices.ComTypes.STATSTG streamStats, int grfStatFlag) { streamStats = new System.Runtime.InteropServices.ComTypes.STATSTG(); streamStats.type = NativeMethods.STGTY_STREAM; streamStats.cbSize = _ioStream.Length; // Return access information in grfMode. streamStats.grfMode = 0; // default value for each flag will be false if (_ioStream.CanRead && _ioStream.CanWrite) { streamStats.grfMode |= NativeMethods.STGM_READWRITE; } else if (_ioStream.CanRead) { streamStats.grfMode |= NativeMethods.STGM_READ; } else if (_ioStream.CanWrite) { streamStats.grfMode |= NativeMethods.STGM_WRITE; } else { // A stream that is neither readable nor writable is a closed stream. // Note the use of an exception that is known to the interop marshaller // (unlike ObjectDisposedException). throw new IOException(SR.Get(SRID.StreamObjectDisposed)); } }
public void Stat(out com.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG() { cbSize = this.source.Length }; }
internal static SolidEdgeDocument FromIStorage(IStorage storage) { if (storage == null) { throw new ArgumentNullException("storage"); } SolidEdgeDocument document = null; System.Runtime.InteropServices.ComTypes.STATSTG statstg = statstg = storage.GetStatistics(); // For now there is a 1 - 1 mapping. Type[] types = System.Reflection.Assembly.GetExecutingAssembly().GetSolidEdgeDocumentTypes(statstg.clsid); if (types.Length == 0) { Marshal.ThrowExceptionForHR(HRESULT.CO_E_CANTDETERMINECLASS); } else if (types.Length == 1) { document = InvokeConstructor(types[0], storage, statstg); } else // Future possibility for multiple types. i.e Guid.Empty { Marshal.ThrowExceptionForHR(HRESULT.CO_E_CANTDETERMINECLASS); } return(document); }
HResult IStream.Stat(out comtypes.STATSTG pstatstg, int grfStatFlag) { const int STGM_READ = 0x00000000; const int STGM_WRITE = 0x00000001; const int STGM_READWRITE = 0x00000002; var tmp = new comtypes.STATSTG(); tmp.type = 2; //STGTY_STREAM tmp.cbSize = Length; if (CanWrite && CanRead) { tmp.grfMode = STGM_READWRITE; } else if (CanRead) { tmp.grfMode = STGM_READ; } else if (CanWrite) { tmp.grfMode = STGM_WRITE; } else { throw new ObjectDisposedException("Stream"); } pstatstg = tmp; return(HResult.S_OK); }
void IStream.Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { System.Runtime.InteropServices.ComTypes.STATSTG sTATSTG = new System.Runtime.InteropServices.ComTypes.STATSTG { type = 2, cbSize = this.Length, grfMode = 0 }; if (this.CanWrite && this.CanRead) { sTATSTG.grfMode |= 2; } else if (this.CanRead) { sTATSTG.grfMode |= 0; } else { if (!this.CanWrite) { throw new ObjectDisposedException("Stream"); } sTATSTG.grfMode |= 1; } pstatstg = sTATSTG; }
public IEnumerable <STATSTGWrapper> EnumElements(bool read_stream_data) { List <STATSTGWrapper> ret = new List <STATSTGWrapper>(); _stg.EnumElements(0, IntPtr.Zero, 0, out IEnumSTATSTG enum_stg); try { ComTypes.STATSTG[] stat = new ComTypes.STATSTG[1]; uint fetched; while (enum_stg.Next(1, stat, out fetched) == 0) { STGTY type = (STGTY)stat[0].type; byte[] bytes = new byte[0]; if (read_stream_data && type == STGTY.Stream) { bytes = ReadStream(stat[0].pwcsName); } ret.Add(new STATSTGWrapper(stat[0].pwcsName, stat[0], bytes)); } } finally { Marshal.ReleaseComObject(enum_stg); } return(ret); }
void IStream.Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { const int STGM_READ = 0x00000000; const int STGM_WRITE = 0x00000001; const int STGM_READWRITE = 0x00000002; var tmp = new System.Runtime.InteropServices.ComTypes.STATSTG { type = 2, cbSize = Length, grfMode = 0 }; if (CanWrite && CanRead) { tmp.grfMode |= STGM_READWRITE; } else if (CanRead) { tmp.grfMode |= STGM_READ; } else if (CanWrite) { tmp.grfMode |= STGM_WRITE; } else { throw new ObjectDisposedException("Stream"); } pstatstg = tmp; }
// Returns details about the stream, including its length, type and name. public void Stat(out STATSTG pstatstg, int grfStatFlag) { pstatstg = new STATSTG(); pstatstg.cbSize = m_inner.Length; pstatstg.type = 2; // stream type pstatstg.pwcsName = (m_inner is FileStream) ? ((FileStream)m_inner).Name : String.Empty; }
/// <summary> /// Obtain stream stats. /// </summary> /// <remarks> /// STATSG has to be qualified because it is defined both in System.Runtime.InteropServices and /// System.Runtime.InteropServices.ComTypes. /// The STATSTG structure is shared by streams, storages and byte arrays. Members irrelevant to streams /// or not available from System.IO.Stream are not returned, which leaves only cbSize and grfMode as /// meaningful and available pieces of information. /// grfStatFlag is used to indicate whether the stream name should be returned and is ignored because /// this information is unavailable. /// </remarks> void IStream.Stat(out STATSTG streamStats, int grfStatFlag) { streamStats = new STATSTG { type = STGTY_STREAM, cbSize = stream.Length, // Return access information in grfMode. grfMode = 0 // default value for each flag will be false }; if (stream.CanRead && stream.CanWrite) { streamStats.grfMode |= STGM_READWRITE; } else if (stream.CanRead) { streamStats.grfMode |= STGM_READ; } else if (stream.CanWrite) { streamStats.grfMode |= STGM_WRITE; } else { // A stream that is neither readable nor writable is a closed stream. // Note the use of an exception that is known to the interop marshaller // (unlike ObjectDisposedException). throw new IOException("Current stream object was closed and disposed. Cannot access a closed stream."); } }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG stat, int statFlag) { stat = new System.Runtime.InteropServices.ComTypes.STATSTG { cbSize = _base.Length }; }
void IUnsafeComStream.Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG() { cbSize = _length }; }
public void Stat(out STATSTG pstatstg, int grfStatFlag) { pstatstg = new STATSTG { cbSize = _stream.Length }; }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG streamStats, int grfStatFlag) { streamStats = new System.Runtime.InteropServices.ComTypes.STATSTG(); streamStats.type = 2; streamStats.cbSize = stream.Length; // Return access information in grfMode. streamStats.grfMode = 0; // default value for each flag will be false if (stream.CanRead && stream.CanWrite) { streamStats.grfMode |= 22; } else if (stream.CanRead) { streamStats.grfMode |= 0; } else if (stream.CanWrite) { streamStats.grfMode |= 1; } else { throw new IOException(); } }
void IUnsafeComStream.Stat(out STATSTG pstatstg, int grfStatFlag) { pstatstg = new STATSTG() { cbSize = _length }; }
private static void ReadIStorageIntoStream(IntPtr handle, Stream stream) { //To handle a IStorage it needs to be written into a second unmanaged memory mapped storage //and then the data can be read from memory into a managed byte and returned as a MemoryStream NativeMethods.ILockBytes iLockBytes = null; NativeMethods.IStorage iStorageNew = null; IntPtr ptrRead = IntPtr.Zero; try { //Marshal pointer to an IStorage object NativeMethods.IStorage iStorage = (NativeMethods.IStorage)Marshal.GetObjectForIUnknown(handle); //Create an ILockBytes object on a HGlobal, then create a IStorage object on top of the ILockBytes object iLockBytes = NativeMethods.CreateILockBytesOnHGlobal(IntPtr.Zero, true); iStorageNew = NativeMethods.StgCreateDocfileOnILockBytes(iLockBytes, 0x00001012, 0); //Copy the IStorage object into the new IStorage object iStorage.CopyTo(0, null, IntPtr.Zero, iStorageNew); iLockBytes.Flush(); iStorageNew.Commit(0); //Get length of ILockBytes byte array System.Runtime.InteropServices.ComTypes.STATSTG stat = new System.Runtime.InteropServices.ComTypes.STATSTG(); iLockBytes.Stat(out stat, 1); long length = stat.cbSize; //Read bytes into stream ptrRead = Marshal.AllocCoTaskMem(sizeof(int)); byte[] buffer = new byte[4096]; //4 KB buffer int offset = 0; int bytesRead; while (true) { iLockBytes.ReadAt(offset, buffer, buffer.Length, ptrRead); bytesRead = Marshal.ReadInt32(ptrRead); if (bytesRead == 0) { break; } stream.Write(buffer, 0, bytesRead); offset += bytesRead; } } finally { //Release all unmanaged objects Marshal.FreeCoTaskMem(ptrRead); if (iStorageNew != null) { Marshal.ReleaseComObject(iStorageNew); } if (iLockBytes != null) { Marshal.ReleaseComObject(iLockBytes); } } }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG { cbSize = this._stream.Length, grfLocksSupported = 0 }; }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { //IStreamWrapper wants the length var tempSTATSTG = new System.Runtime.InteropServices.ComTypes.STATSTG(); tempSTATSTG.cbSize = stream.Length; pstatstg = tempSTATSTG; }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = default(System.Runtime.InteropServices.ComTypes.STATSTG); pstatstg.type = 2; pstatstg.cbSize = this.managedStream.Length; pstatstg.grfMode = 2; pstatstg.grfLocksSupported = 2; }
int IStream.Stat(out STATSTG pstatstg, int grfStatFlag) { pstatstg = new STATSTG(); pstatstg.type = 2; pstatstg.cbSize = stream.Length; pstatstg.grfLocksSupported = 2; return(S_OK); }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG(); this._Validate(); pstatstg.type = 2; pstatstg.cbSize = this._source.Length; pstatstg.grfMode = 2; pstatstg.grfLocksSupported = 2; }
public ReadOnlyILockBytes(Stream stream) { _stream = stream; _statstg = new STATSTG() { grfLocksSupported = 0, cbSize = _stream.Length, type = (int)STGTY.LOCKBYTES }; }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG(); pstatstg.type = 2; pstatstg.cbSize = this.stream.Length; pstatstg.grfMode = 0; if (this.stream.CanRead && this.stream.CanWrite) { pstatstg.grfMode |= 2; } else if (!this.stream.CanRead) { if (this.stream.CanWrite) pstatstg.grfMode |= 1; } }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG streamStats, int grfStatFlag) { streamStats = new System.Runtime.InteropServices.ComTypes.STATSTG(); streamStats.type = 2; streamStats.cbSize = stream.Length; // Return access information in grfMode. streamStats.grfMode = 0; // default value for each flag will be false if (stream.CanRead && stream.CanWrite) streamStats.grfMode |= 22; else if (stream.CanRead) streamStats.grfMode |= 0; else if (stream.CanWrite) streamStats.grfMode |= 1; else throw new IOException(); }
// Get this clipboard format out of this data object public static byte[] GetData(IDataObject oData, string cfFormat) { // First, we try using the built-in functionality. Unfortunately, in the TYMED_ISTREAM case // they forget to seek the stream to zero, and so aren't successful. We'll take care of that // in a moment. // System.IO.Stream stm = (System.IO.Stream)oData.GetData(cfFormat, false); if (null != stm) { stm.Seek(0, System.IO.SeekOrigin.Begin); int cb = (int)stm.Length; byte[] rgb = new byte[cb]; int cbRead = stm.Read(rgb, 0, cb); if (cbRead == cb) { // The bug is that the data returned is entirely zero. Let's check. // for (int ib=0; ib < cb; ib++) { if (rgb[ib] != 0) return rgb; } } } // // Ok, try to see if we can get it on a stream ourselves // COMTypes.IDataObject ido = (COMTypes.IDataObject)oData; COMTypes.FORMATETC formatEtc = new COMTypes.FORMATETC(); COMTypes.STGMEDIUM medium = new COMTypes.STGMEDIUM(); formatEtc.cfFormat = (short)DataFormats.GetFormat(cfFormat).Id; formatEtc.dwAspect = COMTypes.DVASPECT.DVASPECT_CONTENT; formatEtc.lindex = -1; // REVIEW: is 0 better? formatEtc.tymed = COMTypes.TYMED.TYMED_ISTREAM; // ido.GetData(ref formatEtc, out medium); // if (medium.unionmember != IntPtr.Zero) { // Get at the IStream and release the ref in the medium COMTypes.IStream istm = (COMTypes.IStream)Marshal.GetObjectForIUnknown(medium.unionmember); Marshal.Release(medium.unionmember); // How big is the stream? COMTypes.STATSTG statstg = new COMTypes.STATSTG(); istm.Stat(out statstg, 1); int cb = (int)statstg.cbSize; byte[] rgb = new byte[cb]; // Seek the stream to the beginning and read the data IntPtr pcbRead = Marshal.AllocCoTaskMem(sizeof(int)); istm.Seek(0, 0, IntPtr.Zero); istm.Read(rgb, cb, pcbRead); int cbRead = Marshal.ReadInt32(pcbRead); Marshal.FreeCoTaskMem(pcbRead); if (cb==cbRead) return rgb; } // // Can't get the data // return null; }
private static int Stat(IntPtr @this, out STATSTG pstatstg, int grfStatFlag) { #if MAP_EX_TO_HR try { #endif GetObject(@this).managedInterface.Stat(out pstatstg, grfStatFlag); return S_OK; #if MAP_EX_TO_HR } catch (Exception e) { pstatstg = new STATSTG(); return GetHRForException(e); } #endif }
public void Stat(out STATSTG pstatstg, int grfStatFlag) { ThrowExceptionForHR(managedVtable.Stat(comInterface, out pstatstg, grfStatFlag)); }
public string GetSource(IWebBrowser2 thisBrowser) { if ((thisBrowser == null) || (thisBrowser.Document == null)) return string.Empty; //Declare vars int hr = Hresults.S_OK; IStream pStream = null; IPersistStreamInit pPersistStreamInit = null; // Query for IPersistStreamInit. pPersistStreamInit = thisBrowser.Document as IPersistStreamInit; if (pPersistStreamInit == null) return string.Empty; //Create stream, delete on release hr = WinApis.CreateStreamOnHGlobal(m_NullPointer, true, out pStream); if ((pStream == null) || (hr != Hresults.S_OK)) return string.Empty; //Save hr = pPersistStreamInit.Save(pStream, false); if (hr != Hresults.S_OK) return string.Empty; //Now read from stream.... //First get the size long ulSizeRequired = (long)0; //LARGE_INTEGER long liBeggining = (long)0; System.Runtime.InteropServices.ComTypes.STATSTG statstg = new System.Runtime.InteropServices.ComTypes.STATSTG(); pStream.Seek(liBeggining, (int)tagSTREAM_SEEK.STREAM_SEEK_SET, m_NullPointer); pStream.Stat(out statstg, (int)tagSTATFLAG.STATFLAG_NONAME); //Size ulSizeRequired = statstg.cbSize; if (ulSizeRequired == (long)0) return string.Empty; //Allocate buffer + read byte[] pSource = new byte[ulSizeRequired]; pStream.Read(pSource, (int)ulSizeRequired, m_NullPointer); //Added by schlaup to handle UTF8 and UNICODE pages //Convert //ASCIIEncoding asce = new ASCIIEncoding(); //return asce.GetString(pSource); Encoding enc = null; if (pSource.Length > 8) { // Check byte order mark if ((pSource[0] == 0xFF) && (pSource[1] == 0xFE)) // UTF16LE enc = Encoding.Unicode; if ((pSource[0] == 0xFE) && (pSource[1] == 0xFF)) // UTF16BE enc = Encoding.BigEndianUnicode; if ((pSource[0] == 0xEF) && (pSource[1] == 0xBB) && (pSource[2] == 0xBF)) //UTF8 enc = Encoding.UTF8; if (enc == null) { // Check for alternating zero bytes which might indicate Unicode if ((pSource[1] == 0) && (pSource[3] == 0) && (pSource[5] == 0) && (pSource[7] == 0)) enc = Encoding.Unicode; } } if (enc == null) enc = Encoding.Default; int bomLength = enc.GetPreamble().Length; return enc.GetString(pSource, bomLength, pSource.Length - bomLength); }
internal static unsafe int Stat(System.IntPtr pComThis, out ComTypes.STATSTG pstatstg, int grfStatFlag) { __com_IStream* pIStream = (__com_IStream*)pComThis; pstatstg = new ComTypes.STATSTG(); pstatstg.cbSize = pIStream->m_cbSize; return Interop.COM.S_OK; }
/// <summary> /// Processes sub streams and storages on the specified storage. /// </summary> /// <param name="storage">The storage to get sub streams and storages for.</param> protected virtual void LoadStorage(NativeMethods.IStorage storage) { this.storage = storage; //ensures memory is released ReferenceManager.AddItem(this.storage); NativeMethods.IEnumSTATSTG storageElementEnum = null; try { //enum all elements of the storage storage.EnumElements(0, IntPtr.Zero, 0, out storageElementEnum); //iterate elements while (true) { //get 1 element out of the com enumerator uint elementStatCount; ComTypes.STATSTG[] elementStats = new ComTypes.STATSTG[1]; storageElementEnum.Next(1, elementStats, out elementStatCount); //break loop if element not retrieved if (elementStatCount != 1) { break; } ComTypes.STATSTG elementStat = elementStats[0]; switch (elementStat.type) { case 1: //element is a storage. add its statistics object to the storage dictionary subStorageStatistics.Add(elementStat.pwcsName, elementStat); break; case 2: //element is a stream. add its statistics object to the stream dictionary streamStatistics.Add(elementStat.pwcsName, elementStat); break; } } } finally { //free memory if (storageElementEnum != null) { Marshal.ReleaseComObject(storageElementEnum); } } }
/// <summary> /// Returns details about the stream, including its length, type and name. /// </summary> /// <param name="pstatstg"></param> /// <param name="grfStatFlag"></param> public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG { cbSize = _inner.Length, type = 2, pwcsName = (_inner is FileStream) ? ((FileStream) _inner).Name : String.Empty }; // stream type }
internal byte[] Save() { ILockBytes lb; var iret = CreateILockBytesOnHGlobal(IntPtr.Zero, true, out lb); IStorage storage = null; byte[] ret = null; //Create the document in-memory if (StgCreateDocfileOnILockBytes(lb, STGM.CREATE | STGM.READWRITE | STGM.SHARE_EXCLUSIVE | STGM.TRANSACTED, 0, out storage)==0) { foreach(var store in this.Storage.SubStorage) { CreateStore(store.Key, store.Value, storage); } CreateStreams(this.Storage, storage); lb.Flush(); //Now copy the unmanaged stream to a byte array --> memory stream var statstg = new comTypes.STATSTG(); lb.Stat(out statstg, 0); int size = (int)statstg.cbSize; IntPtr buffer = Marshal.AllocHGlobal(size); UIntPtr readSize; ret=new byte[size]; lb.ReadAt(0, buffer, size, out readSize); Marshal.Copy(buffer, ret, 0, size); Marshal.FreeHGlobal(buffer); } Marshal.ReleaseComObject(storage); Marshal.ReleaseComObject(lb); return ret; }
/// <inheritdoc/> public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { var s = new System.Runtime.InteropServices.ComTypes.STATSTG(); // s.atime = ???; s.cbSize = stream.Length; s.clsid = Guid.Empty; // s.ctime = ???; s.grfLocksSupported = 0; s.grfMode = 2; s.grfStateBits = 0; // s.mtime = ???; if ((grfStatFlag & (int)STATFLAG.NONAME) == 0) s.pwcsName = name; s.reserved = 0; s.type = (int)STGTY.STREAM; pstatstg = s; }
public void Stat(out COMTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new COMTypes.STATSTG(); pstatstg.cbSize = this.stm.Length; }
/// <summary> /// Retrieves the data associated with the specified data format at the specified index. /// </summary> /// <param name="format">The format of the data to retrieve. See <see cref="T:System.Windows.Forms.DataFormats"></see> for predefined formats.</param> /// <param name="index">The index of the data to retrieve.</param> /// <returns> /// A <see cref="MemoryStream"/> containing the raw data for the specified data format at the specified index. /// </returns> public MemoryStream GetData(string format, int index) { //create a FORMATETC struct to request the data with FORMATETC formatetc = new FORMATETC(); formatetc.cfFormat = (short)DataFormats.GetFormat(format).Id; formatetc.dwAspect = DVASPECT.DVASPECT_CONTENT; formatetc.lindex = index; formatetc.ptd = new IntPtr(0); formatetc.tymed = TYMED.TYMED_ISTREAM | TYMED.TYMED_ISTORAGE | TYMED.TYMED_HGLOBAL; //create STGMEDIUM to output request results into STGMEDIUM medium = new STGMEDIUM(); //using the Com IDataObject interface get the data using the defined FORMATETC this.comUnderlyingDataObject.GetData(ref formatetc, out medium); //retrieve the data depending on the returned store type switch(medium.tymed) { case TYMED.TYMED_ISTORAGE: //to handle a IStorage it needs to be written into a second unmanaged //memory mapped storage and then the data can be read from memory into //a managed byte and returned as a MemoryStream NativeMethods.IStorage iStorage = null; NativeMethods.IStorage iStorage2 = null; NativeMethods.ILockBytes iLockBytes = null; System.Runtime.InteropServices.ComTypes.STATSTG iLockBytesStat; try { //marshal the returned pointer to a IStorage object iStorage = (NativeMethods.IStorage)Marshal.GetObjectForIUnknown(medium.unionmember); Marshal.Release(medium.unionmember); //create a ILockBytes (unmanaged byte array) and then create a IStorage using the byte array as a backing store iLockBytes = NativeMethods.CreateILockBytesOnHGlobal(IntPtr.Zero, true); iStorage2 = NativeMethods.StgCreateDocfileOnILockBytes(iLockBytes, 0x00001012, 0); //copy the returned IStorage into the new IStorage iStorage.CopyTo(0, null, IntPtr.Zero, iStorage2); iLockBytes.Flush(); iStorage2.Commit(0); //get the STATSTG of the ILockBytes to determine how many bytes were written to it iLockBytesStat = new System.Runtime.InteropServices.ComTypes.STATSTG(); iLockBytes.Stat(out iLockBytesStat, 1); int iLockBytesSize = (int)iLockBytesStat.cbSize; //read the data from the ILockBytes (unmanaged byte array) into a managed byte array byte[] iLockBytesContent = new byte[iLockBytesSize]; iLockBytes.ReadAt(0, iLockBytesContent, iLockBytesContent.Length, null); //wrapped the managed byte array into a memory stream and return it return new MemoryStream(iLockBytesContent); } finally { //release all unmanaged objects Marshal.ReleaseComObject(iStorage2); Marshal.ReleaseComObject(iLockBytes); Marshal.ReleaseComObject(iStorage); } case TYMED.TYMED_ISTREAM: //to handle a IStream it needs to be read into a managed byte and //returned as a MemoryStream IStream iStream = null; System.Runtime.InteropServices.ComTypes.STATSTG iStreamStat; try { //marshal the returned pointer to a IStream object iStream = (IStream)Marshal.GetObjectForIUnknown(medium.unionmember); Marshal.Release(medium.unionmember); //get the STATSTG of the IStream to determine how many bytes are in it iStreamStat = new System.Runtime.InteropServices.ComTypes.STATSTG(); iStream.Stat(out iStreamStat, 0); int iStreamSize = (int)iStreamStat.cbSize; //read the data from the IStream into a managed byte array byte[] iStreamContent = new byte[iStreamSize]; iStream.Read(iStreamContent, iStreamContent.Length, IntPtr.Zero); //wrapped the managed byte array into a memory stream and return it return new MemoryStream(iStreamContent); } finally { //release all unmanaged objects Marshal.ReleaseComObject(iStream); } case TYMED.TYMED_HGLOBAL: //to handle a HGlobal the exisitng "GetDataFromHGLOBLAL" method is invoked via //reflection return (MemoryStream)this.getDataFromHGLOBLALMethod.Invoke(this.oleUnderlyingDataObject, new object[] { DataFormats.GetFormat((short)formatetc.cfFormat).Name, medium.unionmember }); } return null; }
void IStream.Stat(out STATSTG pstatstg, int grfStatFlag) { pstatstg = new STATSTG { type = 2, cbSize = _stream.Length, }; if (_stream.CanRead && _stream.CanWrite) pstatstg.grfMode = Win32.STGM_READWRITE; else if (_stream.CanWrite) pstatstg.grfMode = Win32.STGM_WRITE; else if (_stream.CanRead) pstatstg.grfMode = Win32.STGM_READ; else throw new IOException(); }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG(); pstatstg.type = 2; // STGTY_STREAM pstatstg.cbSize = this._stream.Length; pstatstg.grfMode = 0; if (this._stream.CanRead && this._stream.CanWrite) { pstatstg.grfMode |= 2; } else if (this._stream.CanRead && !_stream.CanWrite) { pstatstg.grfMode |= 1; } else { throw new IOException(); } }
public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG(); pstatstg.cbSize = m_stream.Length; if ((grfStatFlag & 0x0001/* STATFLAG_NONAME */) != 0) return; pstatstg.pwcsName = m_stream.ToString(); }
HResult IStream.Stat(out comtypes.STATSTG pstatstg, int grfStatFlag) { const int STGM_READ = 0x00000000; const int STGM_WRITE = 0x00000001; const int STGM_READWRITE = 0x00000002; var tmp = new comtypes.STATSTG(); tmp.type = 2; //STGTY_STREAM tmp.cbSize = Length; if (CanWrite && CanRead) tmp.grfMode = STGM_READWRITE; else if (CanRead) tmp.grfMode = STGM_READ; else if (CanWrite) tmp.grfMode = STGM_WRITE; else throw new ObjectDisposedException("Stream"); pstatstg = tmp; return HResult.S_OK; }
/// <summary> /// Encrypts a package /// </summary> /// <param name="package">The package as a byte array</param> /// <param name="encryption">The encryption info from the workbook</param> /// <returns></returns> internal MemoryStream EncryptPackage(byte[] package, ExcelEncryption encryption) { byte[] encryptionKey; //Create the Encryption Info. This also returns the Encryptionkey var encryptionInfo = CreateEncryptionInfo(encryption.Password, encryption.Algorithm == EncryptionAlgorithm.AES128 ? AlgorithmID.AES128 : encryption.Algorithm == EncryptionAlgorithm.AES192 ? AlgorithmID.AES192 : AlgorithmID.AES256, out encryptionKey); ILockBytes lb; var iret = CreateILockBytesOnHGlobal(IntPtr.Zero, true, out lb); IStorage storage = null; MemoryStream ret = null; //Create the document in-memory if (StgCreateDocfileOnILockBytes(lb, STGM.CREATE | STGM.READWRITE | STGM.SHARE_EXCLUSIVE | STGM.TRANSACTED, 0, out storage)==0) { //First create the dataspace storage CreateDataSpaces(storage); //Create the Encryption info Stream comTypes.IStream stream; storage.CreateStream("EncryptionInfo", (uint)(STGM.CREATE | STGM.WRITE | STGM.DIRECT | STGM.SHARE_EXCLUSIVE), (uint)0, (uint)0, out stream); byte[] ei=encryptionInfo.WriteBinary(); stream.Write(ei, ei.Length, IntPtr.Zero); stream = null; //Encrypt the package byte[] encryptedPackage=EncryptData(encryptionKey, package, false); storage.CreateStream("EncryptedPackage", (uint)(STGM.CREATE | STGM.WRITE | STGM.DIRECT | STGM.SHARE_EXCLUSIVE), (uint)0, (uint)0, out stream); //Write Size here MemoryStream ms = new MemoryStream(); BinaryWriter bw = new BinaryWriter(ms); bw.Write((ulong)package.LongLength); bw.Flush(); byte[] length = ms.ToArray(); //Write Encrypted data length first as an unsigned long stream.Write(length, length.Length, IntPtr.Zero); //And now the Encrypted data stream.Write(encryptedPackage, encryptedPackage.Length, IntPtr.Zero); stream = null; storage.Commit(0); lb.Flush(); //Now copy the unmanaged stream to a byte array --> memory stream var statstg = new comTypes.STATSTG(); lb.Stat(out statstg, 0); int size = (int)statstg.cbSize; IntPtr buffer = Marshal.AllocHGlobal(size); UIntPtr readSize; byte[] pack=new byte[size]; lb.ReadAt(0, buffer, size, out readSize); Marshal.Copy(buffer, pack, 0, size); Marshal.FreeHGlobal(buffer); ret = new MemoryStream(); ret.Write(pack, 0, size); } Marshal.ReleaseComObject(storage); Marshal.ReleaseComObject(lb); return ret; }
void IStream.Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG { type = 2 }; }
/// <summary> /// Processes sub streams and storages on the specified storage. /// </summary> /// <param name="storage"> The storage to get sub streams and storages for. </param> protected virtual void LoadStorage(NativeMethods.IStorage storage) { if (storage == null) throw new ArgumentNullException("storage", "Storage can not be null"); _storage = storage; // Ensures memory is released ReferenceManager.AddItem(storage); NativeMethods.IEnumSTATSTG storageElementEnum = null; try { // Enum all elements of the storage storage.EnumElements(0, IntPtr.Zero, 0, out storageElementEnum); // Iterate elements while (true) { // Get 1 element out of the COM enumerator uint elementStatCount; var elementStats = new STATSTG[1]; storageElementEnum.Next(1, elementStats, out elementStatCount); // Break loop if element not retrieved if (elementStatCount != 1) break; var elementStat = elementStats[0]; switch (elementStat.type) { case 1: // Element is a storage, add its statistics object to the storage dictionary _subStorageStatistics.Add(elementStat.pwcsName, elementStat); break; case 2: // Element is a stream, add its statistics object to the stream dictionary _streamStatistics.Add(elementStat.pwcsName, elementStat); break; } } } finally { // Free memory if (storageElementEnum != null) Marshal.ReleaseComObject(storageElementEnum); } }
/// <summary> /// Get description of the stream. /// </summary> /// <param name="pstatstg">Here is result of method when done.</param> /// <param name="grfStatFlag">Not used, just a placeholder.</param> public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG(); pstatstg.grfLocksSupported = 0; pstatstg.cbSize = this.Length; }
/// <summary> /// Retrieves the STATSTG structure for this stream. /// </summary> /// <param name="pstatstg"> /// When this method returns, contains a STATSTG structure that describes this stream object. /// This parameter is passed uninitialized. /// </param> /// <param name="grfStatFlag"> /// Members in the STATSTG structure that this method does not return, thus saving some memory allocation operations. /// </param> public void Stat(out STATSTG pstatstg, int grfStatFlag) { pstatstg = default(STATSTG); _Validate(); pstatstg.type = STGTY_STREAM; pstatstg.cbSize = _source.Length; pstatstg.grfMode = STGM_READWRITE; pstatstg.grfLocksSupported = LOCK_EXCLUSIVE; }
/// <summary> /// Retrieves the STATSTG structure for this stream object. /// </summary> public void Stat(out STATSTG pstatstg, int grfStatFlag) { pstatstg = new STATSTG(); }
// Retrieves the STATSTG structure for this stream public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) { if (originalStream == null) throw new ObjectDisposedException("originalStream"); pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG(); pstatstg.type = 2; // STGTY_STREAM pstatstg.cbSize = originalStream.Length; pstatstg.grfMode = 2; // STGM_READWRITE; pstatstg.grfLocksSupported = 2; // LOCK_EXCLUSIVE }
public void Stat(out STATSTG pstatstg, int grfStatFlag) { pstatstg = new STATSTG(); pstatstg.cbSize = _stream.Length; if ((grfStatFlag & 1) == 0) { pstatstg.pwcsName = _stream.ToString(); } }