Merge pull request #43462 from sharwell/port-safe-handle

Use safe handles for SQLite interop

Author: sharwell

src/Workspaces/Core/Portable/Shared/Extensions/SafeHandleExtensions.cs

@@ -0,0 +1,49 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Runtime.InteropServices;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.Shared.Extensions
+{
+    internal static class SafeHandleExtensions
+    {
+        /// <summary>
+        /// Acquires a lease on a safe handle. The lease increments the reference count of the <see cref="SafeHandle"/>
+        /// to ensure the handle is not released prior to the lease being released.
+        /// </summary>
+        /// <remarks>
+        /// This method is intended to be used in the initializer of a <c>using</c> statement. Failing to release the
+        /// lease will permanently prevent the underlying <see cref="SafeHandle"/> from being released by the garbage
+        /// collector.
+        /// </remarks>
+        /// <param name="handle">The <see cref="SafeHandle"/> to lease.</param>
+        /// <returns>A <see cref="SafeHandleLease"/>, which must be disposed to release the resource.</returns>
+        /// <exception cref="ObjectDisposedException">If the lease could not be acquired.</exception>
+        public static SafeHandleLease Lease(this SafeHandle handle)
+        {
+            RoslynDebug.AssertNotNull(handle);
+
+            var success = false;
+            try
+            {
+                handle.DangerousAddRef(ref success);
+                if (!success)
+                    throw new ObjectDisposedException(handle.GetType().FullName);
+
+                return new SafeHandleLease(handle);
+            }
+            catch
+            {
+                if (success)
+                    handle.DangerousRelease();
+
+                throw;
+            }
+        }
+    }
+}

src/Workspaces/Core/Portable/Shared/Extensions/SafeHandleLease.cs

@@ -0,0 +1,30 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.CodeAnalysis.Shared.Extensions
+{
+    /// <summary>
+    /// Represents a lease of a <see cref="SafeHandle"/>.
+    /// </summary>
+    /// <seealso cref="SafeHandleExtensions.Lease"/>
+    internal readonly struct SafeHandleLease : IDisposable
+    {
+        private readonly SafeHandle? _handle;
+
+        internal SafeHandleLease(SafeHandle handle)
+            => _handle = handle;
+
+        /// <summary>
+        /// Releases the <see cref="SafeHandle"/> lease. The behavior of this method is unspecified if called more than
+        /// once.
+        /// </summary>
+        public void Dispose()
+            => _handle?.DangerousRelease();
+    }
+}

src/Workspaces/Core/Portable/Storage/SQLite/Interop/NativeMethods.cs

@@ -0,0 +1,172 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using SQLitePCL;
+
+namespace Microsoft.CodeAnalysis.SQLite.Interop
+{
+    [SuppressMessage("Style", "IDE1006:Naming Styles", Justification = "Name chosen to match SQLitePCL.raw")]
+    internal static class NativeMethods
+    {
+        public static SafeSqliteHandle sqlite3_open_v2(string filename, int flags, string vfs, out Result result)
+        {
+            result = (Result)raw.sqlite3_open_v2(filename, out var wrapper, flags, vfs);
+            if (result != Result.OK)
+            {
+                wrapper = null;
+            }
+
+            try
+            {
+                // Always return a non-null handle to match default P/Invoke marshaling behavior. SafeHandle.IsInvalid
+                // will be true when the handle is not usable, but the handle instance can be disposed either way.
+                return new SafeSqliteHandle(wrapper);
+            }
+            catch
+            {
+                raw.sqlite3_close(wrapper);
+                throw;
+            }
+        }
+
+        public static SafeSqliteStatementHandle sqlite3_prepare_v2(SafeSqliteHandle db, string sql, out Result result)
+        {
+            using var _ = db.Lease();
+
+            result = (Result)raw.sqlite3_prepare_v2(db.DangerousGetHandle(), sql, out var wrapper);
+            if (result != (int)Result.OK)
+            {
+                wrapper = null;
+            }
+
+            try
+            {
+                // Always return a non-null handle to match default P/Invoke marshaling behavior. SafeHandle.IsInvalid
+                // will be true when the handle is not usable, but the handle instance can be disposed either way.
+                return new SafeSqliteStatementHandle(db, wrapper);
+            }
+            catch
+            {
+                raw.sqlite3_finalize(wrapper);
+                throw;
+            }
+        }
+
+        public static SafeSqliteBlobHandle sqlite3_blob_open(SafeSqliteHandle db, string sdb, string table, string col, long rowid, int flags, out Result result)
+        {
+            using var _ = db.Lease();
+
+            result = (Result)raw.sqlite3_blob_open(db.DangerousGetHandle(), sdb, table, col, rowid, flags, out var wrapper);
+            if (result != (int)Result.OK)
+            {
+                wrapper = null;
+            }
+
+            try
+            {
+                // Always return a non-null handle to match default P/Invoke marshaling behavior. SafeHandle.IsInvalid
+                // will be true when the handle is not usable, but the handle instance can be disposed either way.
+                return new SafeSqliteBlobHandle(db, wrapper);
+            }
+            catch
+            {
+                raw.sqlite3_blob_close(wrapper);
+                throw;
+            }
+        }
+
+        public static string sqlite3_errmsg(SafeSqliteHandle db)
+        {
+            using var _ = db.Lease();
+            return raw.sqlite3_errmsg(db.DangerousGetHandle());
+        }
+
+        public static string sqlite3_errstr(int rc)
+        {
+            return raw.sqlite3_errstr(rc);
+        }
+
+        public static int sqlite3_extended_errcode(SafeSqliteHandle db)
+        {
+            using var _ = db.Lease();
+            return raw.sqlite3_extended_errcode(db.DangerousGetHandle());
+        }
+
+        public static Result sqlite3_busy_timeout(SafeSqliteHandle db, int ms)
+        {
+            using var _ = db.Lease();
+            return (Result)raw.sqlite3_busy_timeout(db.DangerousGetHandle(), ms);
+        }
+
+        public static long sqlite3_last_insert_rowid(SafeSqliteHandle db)
+        {
+            using var _ = db.Lease();
+            return raw.sqlite3_last_insert_rowid(db.DangerousGetHandle());
+        }
+
+        public static int sqlite3_blob_bytes(SafeSqliteBlobHandle blob)
+        {
+            using var _ = blob.Lease();
+            return raw.sqlite3_blob_bytes(blob.DangerousGetHandle());
+        }
+
+        public static Result sqlite3_blob_read(SafeSqliteBlobHandle blob, byte[] b, int n, int offset)
+        {
+            using var _ = blob.Lease();
+            return (Result)raw.sqlite3_blob_read(blob.DangerousGetHandle(), b, n, offset);
+        }
+
+        public static Result sqlite3_reset(SafeSqliteStatementHandle stmt)
+        {
+            using var _ = stmt.Lease();
+            return (Result)raw.sqlite3_reset(stmt.DangerousGetHandle());
+        }
+
+        public static Result sqlite3_step(SafeSqliteStatementHandle stmt)
+        {
+            using var _ = stmt.Lease();
+            return (Result)raw.sqlite3_step(stmt.DangerousGetHandle());
+        }
+
+        public static Result sqlite3_bind_text(SafeSqliteStatementHandle stmt, int index, string val)
+        {
+            using var _ = stmt.Lease();
+            return (Result)raw.sqlite3_bind_text(stmt.DangerousGetHandle(), index, val);
+        }
+
+        public static Result sqlite3_bind_int64(SafeSqliteStatementHandle stmt, int index, long val)
+        {
+            using var _ = stmt.Lease();
+            return (Result)raw.sqlite3_bind_int64(stmt.DangerousGetHandle(), index, val);
+        }
+
+        public static byte[] sqlite3_column_blob(SafeSqliteStatementHandle stmt, int index)
+        {
+            using var _ = stmt.Lease();
+            return raw.sqlite3_column_blob(stmt.DangerousGetHandle(), index);
+        }
+
+        public static int sqlite3_column_int(SafeSqliteStatementHandle stmt, int index)
+        {
+            using var _ = stmt.Lease();
+            return raw.sqlite3_column_int(stmt.DangerousGetHandle(), index);
+        }
+
+        public static long sqlite3_column_int64(SafeSqliteStatementHandle stmt, int index)
+        {
+            using var _ = stmt.Lease();
+            return raw.sqlite3_column_int64(stmt.DangerousGetHandle(), index);
+        }
+
+        public static string sqlite3_column_text(SafeSqliteStatementHandle stmt, int index)
+        {
+            using var _ = stmt.Lease();
+            return raw.sqlite3_column_text(stmt.DangerousGetHandle(), index);
+        }
+    }
+}

src/Workspaces/Core/Portable/Storage/SQLite/Interop/Result.cs

@@ -10,7 +10,7 @@ namespace Microsoft.CodeAnalysis.SQLite.Interop
     internal enum Result
     {
         OK = 0,                /* Successful result */
-        // ERROR = 1,          /* SQL error or missing database */
+        ERROR = 1,             /* SQL error or missing database */
         // INTERNAL = 2,       /* Internal logic error in SQLite */
         // PERM = 3,           /* Access permission denied */
         // ABORT = 4,          /* Callback routine requested an abort */

src/Workspaces/Core/Portable/Storage/SQLite/Interop/SafeSqliteBlobHandle.cs

@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Runtime.InteropServices;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using SQLitePCL;
+
+namespace Microsoft.CodeAnalysis.SQLite.Interop
+{
+    internal sealed class SafeSqliteBlobHandle : SafeHandle
+    {
+        private readonly sqlite3_blob? _wrapper;
+        private readonly SafeHandleLease _lease;
+
+        public SafeSqliteBlobHandle(SafeSqliteHandle sqliteHandle, sqlite3_blob? wrapper)
+            : base(invalidHandleValue: IntPtr.Zero, ownsHandle: true)
+        {
+            _wrapper = wrapper;
+            SetHandle(wrapper?.ptr ?? IntPtr.Zero);
+            _lease = sqliteHandle.Lease();
+        }
+
+        public override bool IsInvalid => handle == IntPtr.Zero;
+
+        public new sqlite3_blob DangerousGetHandle()
+            => _wrapper!;
+
+        protected override bool ReleaseHandle()
+        {
+            using var _ = _lease;
+            var result = (Result)raw.sqlite3_blob_close(_wrapper);
+            return result == Result.OK;
+        }
+    }
+}

src/Workspaces/Core/Portable/Storage/SQLite/Interop/SafeSqliteHandle.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Runtime.InteropServices;
+using SQLitePCL;
+
+namespace Microsoft.CodeAnalysis.SQLite.Interop
+{
+    internal sealed class SafeSqliteHandle : SafeHandle
+    {
+        private readonly sqlite3? _wrapper;
+
+        public SafeSqliteHandle(sqlite3? wrapper)
+            : base(invalidHandleValue: IntPtr.Zero, ownsHandle: true)
+        {
+            _wrapper = wrapper;
+            SetHandle(wrapper?.ptr ?? IntPtr.Zero);
+        }
+
+        public override bool IsInvalid => handle == IntPtr.Zero;
+
+        public new sqlite3 DangerousGetHandle()
+            => _wrapper!;
+
+        protected override bool ReleaseHandle()
+        {
+            var result = (Result)raw.sqlite3_close(_wrapper);
+            return result == Result.OK;
+        }
+    }
+}

src/Workspaces/Core/Portable/Storage/SQLite/Interop/SafeSqliteStatementHandle.cs

@@ -0,0 +1,39 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable enable
+
+using System;
+using System.Runtime.InteropServices;
+using Microsoft.CodeAnalysis.Shared.Extensions;
+using SQLitePCL;
+
+namespace Microsoft.CodeAnalysis.SQLite.Interop
+{
+    internal sealed class SafeSqliteStatementHandle : SafeHandle
+    {
+        private readonly sqlite3_stmt? _wrapper;
+        private readonly SafeHandleLease _lease;
+
+        public SafeSqliteStatementHandle(SafeSqliteHandle sqliteHandle, sqlite3_stmt? wrapper)
+            : base(invalidHandleValue: IntPtr.Zero, ownsHandle: true)
+        {
+            _wrapper = wrapper;
+            SetHandle(wrapper?.ptr ?? IntPtr.Zero);
+            _lease = sqliteHandle.Lease();
+        }
+
+        public override bool IsInvalid => handle == IntPtr.Zero;
+
+        public new sqlite3_stmt DangerousGetHandle()
+            => _wrapper!;
+
+        protected override bool ReleaseHandle()
+        {
+            using var _ = _lease;
+            var result = (Result)raw.sqlite3_finalize(_wrapper);
+            return result == Result.OK;
+        }
+    }
+}