Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Data/System/Data/OleDb/DBPropSet.cs

@@ -0,0 +1,250 @@
+//------------------------------------------------------------------------------
+// <copyright file="DBPropSet.cs" company="Microsoft">
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+// <owner current="true" primary="true">[....]</owner>
+// <owner current="true" primary="false">[....]</owner>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Data;
+using System.Data.Common;
+using System.Diagnostics;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Security.Permissions;
+using System.Threading;
+using System.Runtime.ConstrainedExecution;
+
+namespace System.Data.OleDb {
+
+    sealed internal class DBPropSet : SafeHandle {
+
+        private readonly Int32 propertySetCount;
+
+        // VSDD 621427: stores the exception with last error.HRESULT from IDBProperties.GetProperties
+        private Exception lastErrorFromProvider;
+
+        private DBPropSet() : base(IntPtr.Zero, true) {
+            propertySetCount = 0;
+        }
+
+        internal DBPropSet(int propertysetCount) : this() {
+            this.propertySetCount = propertysetCount;
+            IntPtr countOfBytes = (IntPtr)(propertysetCount * ODB.SizeOf_tagDBPROPSET);
+            RuntimeHelpers.PrepareConstrainedRegions();
+            try {} finally {
+                base.handle = SafeNativeMethods.CoTaskMemAlloc(countOfBytes);
+                if (ADP.PtrZero != base.handle) {
+                    SafeNativeMethods.ZeroMemory(base.handle, countOfBytes);
+                }
+            }
+            if (ADP.PtrZero == base.handle) {
+                throw new OutOfMemoryException();
+            }
+        }
+
+        internal DBPropSet(UnsafeNativeMethods.IDBProperties properties, PropertyIDSet propidset, out OleDbHResult hr) : this() {
+            Debug.Assert(null != properties, "null IDBProperties");
+
+            int propidsetcount = 0;
+            if (null != propidset) {
+                propidsetcount = propidset.Count;
+            }
+            Bid.Trace("<oledb.IDBProperties.GetProperties|API|OLEDB>\n");
+            hr = properties.GetProperties(propidsetcount, propidset, out this.propertySetCount, out base.handle);
+            Bid.Trace("<oledb.IDBProperties.GetProperties|API|OLEDB|RET> %08X{HRESULT}\n", hr);
+
+            if (hr < 0) {
+                // VSDD 621427: remember the last HRESULT. Note we do not want to raise exception now to avoid breaking change from Orcas RTM/SP1
+                SetLastErrorInfo(hr);
+            }
+        }
+
+        internal DBPropSet(UnsafeNativeMethods.IRowsetInfo properties, PropertyIDSet propidset, out OleDbHResult hr) : this() {
+            Debug.Assert(null != properties, "null IRowsetInfo");
+
+            int propidsetcount = 0;
+            if (null != propidset) {
+                propidsetcount = propidset.Count;
+            }
+            Bid.Trace("<oledb.IRowsetInfo.GetProperties|API|OLEDB>\n");
+            hr = properties.GetProperties(propidsetcount, propidset, out this.propertySetCount, out base.handle);
+            Bid.Trace("<oledb.IRowsetInfo.GetProperties|API|OLEDB|RET> %08X{HRESULT}\n", hr);
+
+            if (hr < 0) {
+                // VSDD 621427: remember the last HRESULT. Note we do not want to raise exception now to avoid breaking change from Orcas RTM/SP1
+                SetLastErrorInfo(hr);
+            }
+        }
+
+        internal DBPropSet(UnsafeNativeMethods.ICommandProperties properties, PropertyIDSet propidset, out OleDbHResult hr) : this() {
+            Debug.Assert(null != properties, "null ICommandProperties");
+
+            int propidsetcount = 0;
+            if (null != propidset) {
+                propidsetcount = propidset.Count;
+            }
+            Bid.Trace("<oledb.ICommandProperties.GetProperties|API|OLEDB>\n");
+            hr = properties.GetProperties(propidsetcount, propidset, out this.propertySetCount, out base.handle);
+            Bid.Trace("<oledb.ICommandProperties.GetProperties|API|OLEDB|RET> %08X{HRESULT}\n", hr);
+
+            if (hr < 0) {
+                // VSDD 621427: remember the last HRESULT. Note we do not want to raise exception now to avoid breaking change from Orcas RTM/SP1
+                SetLastErrorInfo(hr);
+            }
+        }
+
+        private void SetLastErrorInfo(OleDbHResult lastErrorHr) {
+            // note: OleDbHResult is actually a simple wrapper over HRESULT with OLEDB-specific codes
+            UnsafeNativeMethods.IErrorInfo errorInfo = null;
+            string message = String.Empty;
+
+            OleDbHResult errorInfoHr = UnsafeNativeMethods.GetErrorInfo(0, out errorInfo);  // 0 - IErrorInfo exists, 1 - no IErrorInfo
+            if ((errorInfoHr == OleDbHResult.S_OK) && (errorInfo != null)) {
+                ODB.GetErrorDescription(errorInfo, lastErrorHr, out message);
+                // note that either GetErrorInfo or GetErrorDescription might fail in which case we will have only the HRESULT value in exception message
+            }
+            lastErrorFromProvider = new COMException(message, (int)lastErrorHr);
+        }
+
+        public override bool IsInvalid {
+            get {
+                return (IntPtr.Zero == base.handle);
+            }
+        }
+
+         override protected bool ReleaseHandle() {
+            // NOTE: The SafeHandle class guarantees this will be called exactly once and is non-interrutible.
+            IntPtr ptr = base.handle;
+            base.handle = IntPtr.Zero;
+            if (ADP.PtrZero != ptr) {
+
+                int count = this.propertySetCount;
+                for (int i = 0, offset = 0; i < count; ++i, offset += ODB.SizeOf_tagDBPROPSET) {
+
+                    IntPtr rgProperties = Marshal.ReadIntPtr(ptr, offset);
+                    if(ADP.PtrZero != rgProperties) {
+                        int cProperties = Marshal.ReadInt32(ptr, offset + ADP.PtrSize);
+
+                        IntPtr vptr = ADP.IntPtrOffset(rgProperties, ODB.OffsetOf_tagDBPROP_Value);
+                        for (int k = 0; k < cProperties; ++k, vptr = ADP.IntPtrOffset(vptr, ODB.SizeOf_tagDBPROP)) {
+                            SafeNativeMethods.VariantClear(vptr);
+                        }
+                        SafeNativeMethods.CoTaskMemFree(rgProperties);
+                    }
+                }
+                SafeNativeMethods.CoTaskMemFree(ptr);
+            }
+            return true;
+        }
+
+        internal int PropertySetCount {
+            get {
+                return this.propertySetCount;
+            }
+        }
+
+        internal tagDBPROP[] GetPropertySet(int index, out Guid propertyset) {
+            if ((index < 0) || (PropertySetCount <= index)) {
+                if (lastErrorFromProvider != null)
+                {
+                    // VSDD 621427: add extra error information for CSS/stress troubleshooting.
+                    // We need to keep same exception type to avoid breaking change with Orcas RTM/SP1.
+                    throw ADP.InternalError(ADP.InternalErrorCode.InvalidBuffer, lastErrorFromProvider);
+                }
+                else {
+                    throw ADP.InternalError(ADP.InternalErrorCode.InvalidBuffer);
+                }
+            }
+
+            tagDBPROPSET propset = new tagDBPROPSET();
+            tagDBPROP[] properties = null;
+
+            bool mustRelease = false;
+            RuntimeHelpers.PrepareConstrainedRegions();
+            try {
+                DangerousAddRef(ref mustRelease);
+                IntPtr propertySetPtr = ADP.IntPtrOffset(DangerousGetHandle(), index * ODB.SizeOf_tagDBPROPSET);
+                Marshal.PtrToStructure(propertySetPtr, propset);
+                propertyset = propset.guidPropertySet;
+
+                properties = new tagDBPROP[propset.cProperties];
+                for(int i = 0; i < properties.Length; ++i) {
+                    properties[i] = new tagDBPROP();
+                    IntPtr ptr = ADP.IntPtrOffset(propset.rgProperties, i * ODB.SizeOf_tagDBPROP);
+                    Marshal.PtrToStructure(ptr, properties[i]);
+                }
+            }
+            finally {
+                if (mustRelease) {
+                    DangerousRelease();
+                }
+            }
+            return properties;
+        }
+
+        internal void SetPropertySet(int index, Guid propertySet, tagDBPROP[] properties) {
+            if ((index < 0) || (PropertySetCount <= index)) {
+                if (lastErrorFromProvider != null) {
+                    // VSDD 621427: add extra error information for CSS/stress troubleshooting.
+                    // We need to keep same exception type to avoid breaking change with Orcas RTM/SP1.
+                    throw ADP.InternalError(ADP.InternalErrorCode.InvalidBuffer, lastErrorFromProvider);
+                }
+                else {
+                    throw ADP.InternalError(ADP.InternalErrorCode.InvalidBuffer);
+                }
+            }
+            Debug.Assert(Guid.Empty != propertySet, "invalid propertySet");
+            Debug.Assert((null != properties) && (0 < properties.Length), "invalid properties");
+
+            IntPtr countOfBytes = (IntPtr)(properties.Length * ODB.SizeOf_tagDBPROP);
+            tagDBPROPSET propset = new tagDBPROPSET(properties.Length, propertySet);
+
+            bool mustRelease = false;
+            RuntimeHelpers.PrepareConstrainedRegions();
+            try {
+                DangerousAddRef(ref mustRelease);
+
+                IntPtr propsetPtr = ADP.IntPtrOffset(DangerousGetHandle(), index * ODB.SizeOf_tagDBPROPSET);
+
+                RuntimeHelpers.PrepareConstrainedRegions();
+                try {} finally {
+                    // must allocate and clear the memory without interruption
+                    propset.rgProperties = SafeNativeMethods.CoTaskMemAlloc(countOfBytes);
+                    if (ADP.PtrZero != propset.rgProperties) {
+                        // clearing is important so that we don't treat existing
+                        // garbage as important information during releaseHandle
+                        SafeNativeMethods.ZeroMemory(propset.rgProperties, countOfBytes);
+                        
+                        // writing the structure to native memory so that it knows to free the referenced pointers
+                        Marshal.StructureToPtr(propset, propsetPtr, false/*deleteold*/);
+                    }
+                }
+                if (ADP.PtrZero == propset.rgProperties) {
+                    throw new OutOfMemoryException();
+                }
+
+                for(int i = 0; i < properties.Length; ++i) {
+                    Debug.Assert(null != properties[i], "null tagDBPROP " + i.ToString(CultureInfo.InvariantCulture));
+                    IntPtr propertyPtr = ADP.IntPtrOffset(propset.rgProperties, i * ODB.SizeOf_tagDBPROP);
+                    Marshal.StructureToPtr(properties[i], propertyPtr, false/*deleteold*/);
+                }
+            }
+            finally {
+                if (mustRelease) {
+                    DangerousRelease();
+                }
+            }
+        }
+
+        static internal DBPropSet CreateProperty(Guid propertySet, int propertyId, bool required, object value) {
+            tagDBPROP dbprop = new tagDBPROP(propertyId, required, value);
+            DBPropSet propertyset = new DBPropSet(1);
+            propertyset.SetPropertySet(0, propertySet, new tagDBPROP[1] { dbprop });
+            return propertyset;
+        }
+    }
+}