NativeMethods.cs

using System;
using System.Globalization;
using System.IO;
using System.Runtime.CompilerServices;
#if NET40
using System.Runtime.ConstrainedExecution;
#endif
using System.Runtime.InteropServices;
using System.Threading;
using LibGit2Sharp.Core.Handles;

// ReSharper disable InconsistentNaming
namespace LibGit2Sharp.Core
{
    [OfferFriendlyInteropOverloads]
    internal static partial class NativeMethods
    {
        public const uint GIT_PATH_MAX = 4096;
        private const string libgit2 = NativeDllName.Name;
        // This is here to keep the pointer alive
#pragma warning disable 0414
        private static readonly LibraryLifetimeObject lifetimeObject;
#pragma warning restore 0414
        private static int handlesCount;

        /// <summary>
        /// Internal hack to ensure that the call to git_threads_shutdown is called after all handle finalizers
        /// have run to completion ensuring that no dangling git-related finalizer runs after git_threads_shutdown.
        /// There should never be more than one instance of this object per AppDomain.
        /// </summary>
        private sealed class LibraryLifetimeObject
#if NET40
            : CriticalFinalizerObject
#endif
        {
            // Ensure mono can JIT the .cctor and adjust the PATH before trying to load the native library.
            // See https://github.com/libgit2/libgit2sharp/pull/190
            [MethodImpl(MethodImplOptions.NoInlining)]
            public LibraryLifetimeObject()
            {
                int res = git_libgit2_init();
                Ensure.Int32Result(res);
                if (res == 1)
                {
                    // Ignore the error that this propagates. Call it in case openssl is being used.
                    git_openssl_set_locking();
                }
                AddHandle();
            }

            ~LibraryLifetimeObject()
            {
                RemoveHandle();
            }
        }

#if NET40
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
#endif
        internal static void AddHandle()
        {
            Interlocked.Increment(ref handlesCount);
        }

#if NET40
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
#endif
        internal static void RemoveHandle()
        {
            int count = Interlocked.Decrement(ref handlesCount);
            if (count == 0)
            {
                git_libgit2_shutdown();
            }
        }

        static NativeMethods()
        {
            if (Platform.OperatingSystem == OperatingSystemType.Windows)
            {
                string nativeLibraryPath = GlobalSettings.GetAndLockNativeLibraryPath();

                string path = Path.Combine(nativeLibraryPath, Platform.ProcessorArchitecture);

                const string pathEnvVariable = "PATH";
                Environment.SetEnvironmentVariable(pathEnvVariable,
                    String.Format(CultureInfo.InvariantCulture, "{0}{1}{2}", path, Path.PathSeparator, Environment.GetEnvironmentVariable(pathEnvVariable)));
            }

            // See LibraryLifetimeObject description.
            lifetimeObject = new LibraryLifetimeObject();
        }

        [DllImport(libgit2)]
        internal static extern unsafe GitError* giterr_last();

        [DllImport(libgit2)]
        private static unsafe extern void giterr_set_str(
            GitErrorCategory error_class,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* errorString);

        [DllImport(libgit2)]
        internal static extern void giterr_set_oom();

        [DllImport(libgit2)]
        internal static extern unsafe UInt32 git_blame_get_hunk_count(git_blame* blame);

        [DllImport(libgit2)]
        internal static extern unsafe git_blame_hunk* git_blame_get_hunk_byindex(
            git_blame* blame, UInt32 index);

        [DllImport(libgit2)]
        private static extern unsafe int git_blame_file(
            out git_blame* blame,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* path,
            git_blame_options options);

        [DllImport(libgit2)]
        internal static extern unsafe void git_blame_free(git_blame* blame);

        [DllImport(libgit2)]
        private static extern unsafe int git_blob_create_fromdisk(
            ref GitOid id,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* path);

        [DllImport(libgit2)]
        private static extern unsafe int git_blob_create_fromworkdir(
            ref GitOid id,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* relative_path);

        internal delegate int source_callback(
            IntPtr content,
            int max_length,
            IntPtr data);

        [DllImport(libgit2)]
        private static extern unsafe int git_blob_create_fromstream(
            out IntPtr stream,
            git_repository* repositoryPtr,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* hintpath);

        [DllImport(libgit2)]
        internal static extern unsafe int git_blob_create_fromstream_commit(
            ref GitOid oid,
            IntPtr stream);

        [DllImport(libgit2)]
        private static extern unsafe int git_blob_create_fromchunks(
            ref GitOid oid,
            git_repository* repositoryPtr,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* hintpath,
            source_callback fileCallback,
            IntPtr data);

        [DllImport(libgit2)]
        private static extern unsafe int git_blob_filtered_content(
            GitBuf buf,
            git_object* blob,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* as_path,
            [MarshalAs(UnmanagedType.Bool)] bool check_for_binary_data);

        [DllImport(libgit2)]
        internal static extern unsafe IntPtr git_blob_rawcontent(git_object* blob);

        [DllImport(libgit2)]
        internal static extern unsafe Int64 git_blob_rawsize(git_object* blob);

        [DllImport(libgit2)]
        private static extern unsafe int git_branch_create_from_annotated(
            out git_reference* ref_out,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* branch_name,
            git_annotated_commit* target,
            [MarshalAs(UnmanagedType.Bool)] bool force);

        [DllImport(libgit2)]
        internal static extern unsafe int git_branch_delete(
            git_reference* reference);

        internal delegate int branch_foreach_callback(
            IntPtr branch_name,
            GitBranchType branch_type,
            IntPtr payload);

        [DllImport(libgit2)]
        internal static extern void git_branch_iterator_free(
            IntPtr iterator);

        [DllImport(libgit2)]
        internal static extern int git_branch_iterator_new(
            out IntPtr iter_out,
            IntPtr repo,
            GitBranchType branch_type);

        [DllImport(libgit2)]
        private static extern unsafe int git_branch_move(
            out git_reference* ref_out,
            git_reference* reference,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* new_branch_name,
            [MarshalAs(UnmanagedType.Bool)] bool force);

        [DllImport(libgit2)]
        internal static extern int git_branch_next(
            out IntPtr ref_out,
            out GitBranchType type_out,
            IntPtr iter);

        [DllImport(libgit2)]
        private static extern unsafe int git_branch_remote_name(
            GitBuf buf,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* canonical_branch_name);

        [DllImport(libgit2)]
        internal static extern unsafe int git_rebase_init(
            out git_rebase* rebase,
            git_repository* repo,
            git_annotated_commit* branch,
            git_annotated_commit* upstream,
            git_annotated_commit* onto,
            GitRebaseOptions options);

        [DllImport(libgit2)]
        internal static extern unsafe int git_rebase_open(
            out git_rebase* rebase,
            git_repository* repo,
            GitRebaseOptions options);

        [DllImport(libgit2)]
        internal static extern unsafe UIntPtr git_rebase_operation_entrycount(
            git_rebase* rebase);

        [DllImport(libgit2)]
        internal static extern unsafe UIntPtr git_rebase_operation_current(
            git_rebase* rebase);

        [DllImport(libgit2)]
        internal static extern unsafe git_rebase_operation* git_rebase_operation_byindex(
            git_rebase* rebase,
            UIntPtr index);

        [DllImport(libgit2)]
        internal static extern unsafe int git_rebase_next(
            out git_rebase_operation* operation,
            git_rebase* rebase);

        [DllImport(libgit2)]
        internal static extern unsafe int git_rebase_commit(
            ref GitOid id,
            git_rebase* rebase,
            git_signature* author,
            git_signature* committer,
            IntPtr message_encoding,
            IntPtr message);

        [DllImport(libgit2)]
        internal static extern unsafe int git_rebase_abort(
            git_rebase* rebase);

        [DllImport(libgit2)]
        internal static extern unsafe int git_rebase_finish(
            git_rebase* repo,
            git_signature* signature);

        [DllImport(libgit2)]
        internal static extern unsafe void git_rebase_free(git_rebase* rebase);

        [DllImport(libgit2)]
        private static extern unsafe int git_remote_rename(
            ref GitStrArray problems,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* old_name,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* new_name);

        private unsafe delegate int git_remote_rename_problem_cb(
            [CustomMarshaler(typeof(LaxUtf8NoCleanupMarshaler), typeof(string))] byte* problematic_refspec,
            IntPtr payload);

        [DllImport(libgit2)]
        private static extern unsafe int git_branch_upstream_name(
            GitBuf buf,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* referenceName);

        [DllImport(libgit2)]
        internal static extern void git_buf_free(GitBuf buf);

        [DllImport(libgit2)]
        internal static extern unsafe int git_checkout_tree(
            git_repository* repo,
            git_object* treeish,
            ref GitCheckoutOpts opts);

        [DllImport(libgit2)]
        internal static extern unsafe int git_checkout_index(
            git_repository* repo,
            git_object* treeish,
            ref GitCheckoutOpts opts);

        [DllImport(libgit2)]
        private static extern unsafe int git_clone(
            out git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* origin_url,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* workdir_path,
            ref GitCloneOptions opts);

        [DllImport(libgit2)]
        internal static extern unsafe git_signature* git_commit_author(git_object* commit);

        [DllImport(libgit2)]
        internal static extern unsafe git_signature* git_commit_committer(git_object* commit);

        [DllImport(libgit2)]
        private static extern unsafe int git_commit_create_from_ids(
            out GitOid id,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* updateRef,
            git_signature* author,
            git_signature* committer,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* encoding,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* message,
            ref GitOid tree,
            UIntPtr parentCount,
            [MarshalAs(UnmanagedType.LPArray)] [In] IntPtr[] parents);

        [DllImport(libgit2)]
        private static extern unsafe int git_commit_create_buffer(
            GitBuf res,
            git_repository* repo,
            git_signature* author,
            git_signature* committer,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* encoding,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* message,
            git_object* tree,
            UIntPtr parent_count,
            IntPtr* parents /* git_commit** originally */);

        [DllImport(libgit2)]
        private static extern unsafe int git_commit_create_with_signature(
            out GitOid id,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* commit_content,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* signature,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* signature_field);

        [DllImport(libgit2, EntryPoint = "git_commit_message")]
        [return: CustomMarshaler(typeof(LaxUtf8NoCleanupMarshaler), typeof(string))]
        private static extern unsafe byte* git_commit_message_(git_object* commit);

        [DllImport(libgit2, EntryPoint = "git_commit_summary")]
        [return: CustomMarshaler(typeof(LaxUtf8NoCleanupMarshaler), typeof(string))]
        private static extern unsafe byte* git_commit_summary_(git_object* commit);

        [DllImport(libgit2, EntryPoint = "git_commit_message_encoding")]
        [return: CustomMarshaler(typeof(LaxUtf8NoCleanupMarshaler), typeof(string))]
        private static extern unsafe byte* git_commit_message_encoding_(git_object* commit);

        [DllImport(libgit2)]
        internal static extern unsafe git_oid* git_commit_parent_id(git_object* commit, uint n);

        [DllImport(libgit2)]
        internal static extern unsafe uint git_commit_parentcount(git_object* commit);

        [DllImport(libgit2)]
        internal static extern unsafe git_oid* git_commit_tree_id(git_object* commit);

        [DllImport(libgit2)]
        private static extern unsafe int git_commit_extract_signature(
            GitBuf signature,
            GitBuf signed_data,
            git_repository* repo,
            ref GitOid commit_id,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* field);

        [DllImport(libgit2)]
        private static extern unsafe int git_config_delete_entry(
            git_config* cfg,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* name);

        [DllImport(libgit2)]
        internal static extern unsafe int git_config_lock(out IntPtr txn, git_config* config);

        [DllImport(libgit2)]
        private static extern unsafe int git_config_delete_multivar(
            git_config* cfg,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* name,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* regexp);

        [DllImport(libgit2)]
        internal static extern int git_config_find_global(GitBuf global_config_path);

        [DllImport(libgit2)]
        internal static extern int git_config_find_system(GitBuf system_config_path);

        [DllImport(libgit2)]
        internal static extern int git_config_find_xdg(GitBuf xdg_config_path);

        [DllImport(libgit2)]
        internal static extern int git_config_find_programdata(GitBuf programdata_config_path);

        [DllImport(libgit2)]
        internal static extern unsafe void git_config_free(git_config* cfg);

        [DllImport(libgit2)]
        internal static extern unsafe void git_config_entry_free(GitConfigEntry* entry);

        [DllImport(libgit2)]
        private static extern unsafe int git_config_get_entry(
            out GitConfigEntry* entry,
            git_config* cfg,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* name);

        [DllImport(libgit2)]
        private static extern unsafe int git_config_add_file_ondisk(
            git_config* cfg,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* path,
            uint level,
            [MarshalAs(UnmanagedType.Bool)] bool force);

        [DllImport(libgit2)]
        internal static extern unsafe int git_config_new(out git_config* cfg);

        [DllImport(libgit2)]
        internal static extern unsafe int git_config_open_level(
            out git_config* cfg,
            git_config* parent,
            uint level);

        [DllImport(libgit2)]
        private static unsafe extern int git_config_parse_bool(
            [MarshalAs(UnmanagedType.Bool)] out bool value,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* valueToParse);

        [DllImport(libgit2)]
        private static unsafe extern int git_config_parse_int32(
            [MarshalAs(UnmanagedType.I4)] out int value,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* valueToParse);

        [DllImport(libgit2)]
        private static unsafe extern int git_config_parse_int64(
            [MarshalAs(UnmanagedType.I8)] out long value,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* valueToParse);

        [DllImport(libgit2)]
        private static extern unsafe int git_config_set_bool(
            git_config* cfg,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* name,
            [MarshalAs(UnmanagedType.Bool)] bool value);

        [DllImport(libgit2)]
        private static extern unsafe int git_config_set_int32(
            git_config* cfg,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* name,
            int value);

        [DllImport(libgit2)]
        private static extern unsafe int git_config_set_int64(
            git_config* cfg,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* name,
            long value);

        [DllImport(libgit2)]
        private static extern unsafe int git_config_set_string(
            git_config* cfg,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* name,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* value);

        internal delegate int config_foreach_callback(
            IntPtr entry,
            IntPtr payload);

        [DllImport(libgit2)]
        internal static extern unsafe int git_config_foreach(
            git_config* cfg,
            config_foreach_callback callback,
            IntPtr payload);

        [DllImport(libgit2)]
        private static extern unsafe int git_config_iterator_glob_new(
            out IntPtr iter,
            IntPtr cfg,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* regexp);

        [DllImport(libgit2)]
        internal static extern int git_config_next(
            out IntPtr entry,
            IntPtr iter);

        [DllImport(libgit2)]
        internal static extern void git_config_iterator_free(IntPtr iter);

        [DllImport(libgit2)]
        internal static extern unsafe int git_config_snapshot(out git_config* @out, git_config* config);

        // Ordinarily we would decorate the `url` parameter with the StrictUtf8Marshaler like we do everywhere
        // else, but apparently doing a native->managed callback with the 64-bit version of CLR 2.0 can
        // sometimes vomit when using a custom IMarshaler.  So yeah, don't do that.  If you need the url,
        // call StrictUtf8Marshaler.FromNative manually.  See the discussion here:
        // http://social.msdn.microsoft.com/Forums/en-US/netfx64bit/thread/1eb746c6-d695-4632-8a9e-16c4fa98d481
        internal delegate int git_cred_acquire_cb(
            out IntPtr cred,
            IntPtr url,
            IntPtr username_from_url,
            GitCredentialType allowed_types,
            IntPtr payload);

        [DllImport(libgit2)]
        internal static extern int git_cred_default_new(out IntPtr cred);

        [DllImport(libgit2)]
        private static unsafe extern int git_cred_userpass_plaintext_new(
            out IntPtr cred,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* username,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* password);

        [DllImport(libgit2)]
        internal static extern void git_cred_free(IntPtr cred);

        [DllImport(libgit2)]
        internal static extern unsafe int git_describe_commit(
            out git_describe_result* describe,
            git_object* committish,
            ref GitDescribeOptions options);

        [DllImport(libgit2)]
        internal static extern unsafe int git_describe_format(
            GitBuf buf,
            git_describe_result* describe,
            ref GitDescribeFormatOptions options);

        [DllImport(libgit2)]
        internal static extern unsafe void git_describe_result_free(git_describe_result* describe);

        [DllImport(libgit2)]
        internal static extern unsafe void git_diff_free(git_diff* diff);

        [DllImport(libgit2)]
        internal static extern unsafe int git_diff_tree_to_tree(
            out git_diff* diff,
            git_repository* repo,
            git_object* oldTree,
            git_object* newTree,
            GitDiffOptions options);

        [DllImport(libgit2)]
        internal static extern unsafe int git_diff_tree_to_index(
            out git_diff* diff,
            git_repository* repo,
            git_object* oldTree,
            git_index* index,
            GitDiffOptions options);

        [DllImport(libgit2)]
        internal static extern unsafe int git_diff_merge(
            git_diff* onto,
            git_diff* from);

        [DllImport(libgit2)]
        internal static extern unsafe int git_diff_index_to_workdir(
            out git_diff* diff,
            git_repository* repo,
            git_index* index,
            GitDiffOptions options);

        [DllImport(libgit2)]
        internal static extern unsafe int git_diff_tree_to_workdir(
            out git_diff* diff,
            git_repository* repo,
            git_object* oldTree,
            GitDiffOptions options);

        internal unsafe delegate int git_diff_file_cb(
            [In] git_diff_delta* delta,
            float progress,
            IntPtr payload);

        internal unsafe delegate int git_diff_hunk_cb(
            [In] git_diff_delta* delta,
            [In] GitDiffHunk hunk,
            IntPtr payload);

        internal unsafe delegate int git_diff_line_cb(
            [In] git_diff_delta* delta,
            [In] GitDiffHunk hunk,
            [In] GitDiffLine line,
            IntPtr payload);

        internal unsafe delegate int git_diff_binary_cb(
            [In] git_diff_delta* delta,
            [In] GitDiffBinary binary,
            IntPtr payload);

        [DllImport(libgit2)]
        private static extern unsafe int git_diff_blobs(
            git_object* oldBlob,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* old_as_path,
            git_object* newBlob,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* new_as_path,
            GitDiffOptions options,
            git_diff_file_cb fileCallback,
            git_diff_binary_cb binaryCallback,
            git_diff_hunk_cb hunkCallback,
            git_diff_line_cb lineCallback,
            IntPtr payload);

        [DllImport(libgit2)]
        internal static extern unsafe int git_diff_foreach(
            git_diff* diff,
            git_diff_file_cb fileCallback,
            git_diff_binary_cb binaryCallback,
            git_diff_hunk_cb hunkCallback,
            git_diff_line_cb lineCallback,
            IntPtr payload);

        [DllImport(libgit2)]
        internal static extern unsafe int git_diff_find_similar(
            git_diff* diff,
            GitDiffFindOptions options);

        [DllImport(libgit2)]
        internal static extern unsafe UIntPtr git_diff_num_deltas(git_diff* diff);

        [DllImport(libgit2)]
        internal static extern unsafe git_diff_delta* git_diff_get_delta(git_diff* diff, UIntPtr idx);

        [DllImport(libgit2)]
        private static unsafe extern int git_filter_register(
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* name,
            IntPtr gitFilter, int priority);

        [DllImport(libgit2)]
        private static extern unsafe int git_filter_unregister(
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* name);

        [DllImport(libgit2)]
        internal static extern unsafe int git_filter_source_mode(git_filter_source* source);

        [DllImport(libgit2)]
        internal static extern int git_libgit2_features();

        #region git_libgit2_opts

        // Bindings for git_libgit2_opts(int option, ...):
        // Currently only GIT_OPT_GET_SEARCH_PATH and GIT_OPT_SET_SEARCH_PATH are supported,
        // but other overloads could be added using a similar pattern.
        // CallingConvention.Cdecl is used to allow binding the the C varargs signature, and each possible call signature must be enumerated.
        // __argslist was an option, but is an undocumented feature that should likely not be used here.

        // git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, int level, git_buf *buf)
        [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
        internal static extern int git_libgit2_opts(int option, uint level, GitBuf buf);

        // git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, int level, const char *path)
        [DllImport(libgit2, CallingConvention = CallingConvention.Cdecl)]
        private static unsafe extern int git_libgit2_opts(int option, uint level,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* path);

        #endregion

        [DllImport(libgit2)]
        internal static extern unsafe int git_graph_ahead_behind(out UIntPtr ahead, out UIntPtr behind, git_repository* repo, ref GitOid one, ref GitOid two);

        [DllImport(libgit2)]
        internal static extern unsafe int git_graph_descendant_of(
            git_repository* repo,
            ref GitOid commit,
            ref GitOid ancestor);

        [DllImport(libgit2)]
        private static extern unsafe int git_ignore_add_rule(
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* rules);

        [DllImport(libgit2)]
        internal static extern unsafe int git_ignore_clear_internal_rules(git_repository* repo);

        [DllImport(libgit2)]
        private static extern unsafe int git_ignore_path_is_ignored(
            out int ignored,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* path);

        [DllImport(libgit2)]
        private static extern unsafe int git_index_add_bypath(
            git_index* index,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* path);

        [DllImport(libgit2)]
        internal static extern unsafe int git_index_add(
            git_index* index,
            git_index_entry* entry);

        [DllImport(libgit2)]
        private static extern unsafe int git_index_conflict_get(
            out git_index_entry* ancestor,
            out git_index_entry* ours,
            out git_index_entry* theirs,
            git_index* index,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* path);

        [DllImport(libgit2)]
        internal static extern unsafe int git_index_conflict_iterator_new(
            out git_index_conflict_iterator* iterator,
            git_index* index);

        [DllImport(libgit2)]
        internal static extern unsafe int git_index_conflict_next(
            out git_index_entry* ancestor,
            out git_index_entry* ours,
            out git_index_entry* theirs,
            git_index_conflict_iterator* iterator);

        [DllImport(libgit2)]
        internal static extern unsafe void git_index_conflict_iterator_free(
            git_index_conflict_iterator* iterator);

        [DllImport(libgit2)]
        internal static extern unsafe UIntPtr git_index_entrycount(git_index* index);

        [DllImport(libgit2)]
        internal static extern unsafe int git_index_entry_stage(git_index_entry* indexentry);

        [DllImport(libgit2)]
        internal static extern unsafe void git_index_free(git_index* index);

        [DllImport(libgit2)]
        internal static extern unsafe git_index_entry* git_index_get_byindex(git_index* index, UIntPtr n);

        [DllImport(libgit2)]
        private static extern unsafe git_index_entry* git_index_get_bypath(
            git_index* index,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* path,
            int stage);

        [DllImport(libgit2)]
        internal static extern unsafe int git_index_has_conflicts(git_index* index);

        [DllImport(libgit2)]
        internal static extern unsafe UIntPtr git_index_name_entrycount(git_index* handle);

        [DllImport(libgit2)]
        internal static extern unsafe git_index_name_entry* git_index_name_get_byindex(git_index* handle, UIntPtr n);

        [DllImport(libgit2)]
        private static extern unsafe int git_index_open(
            out git_index* index,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* indexpath);

        [DllImport(libgit2)]
        internal static extern unsafe int git_index_read(
            git_index* index,
            [MarshalAs(UnmanagedType.Bool)] bool force);

        [DllImport(libgit2)]
        private static extern unsafe int git_index_remove_bypath(
            git_index* index,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* path);


        [DllImport(libgit2)]
        internal static extern unsafe UIntPtr git_index_reuc_entrycount(git_index* handle);

        [DllImport(libgit2)]
        internal static extern unsafe git_index_reuc_entry* git_index_reuc_get_byindex(git_index* handle, UIntPtr n);

        [DllImport(libgit2)]
        private static extern unsafe git_index_reuc_entry* git_index_reuc_get_bypath(
            git_index* handle,
            [CustomMarshaler(typeof(StrictFilePathMarshaler), typeof(FilePath))] byte* path);

        [DllImport(libgit2)]
        internal static extern unsafe int git_index_write(git_index* index);

        [DllImport(libgit2)]
        internal static extern unsafe int git_index_write_tree(out GitOid treeOid, git_index* index);

        [DllImport(libgit2)]
        internal static extern unsafe int git_index_write_tree_to(out GitOid treeOid, git_index* index, git_repository* repo);

        [DllImport(libgit2)]
        internal static extern unsafe int git_index_read_tree(git_index* index, git_object* tree);

        [DllImport(libgit2)]
        internal static extern unsafe int git_index_clear(git_index* index);

        [DllImport(libgit2)]
        internal static extern unsafe int git_merge_base_many(
            out GitOid mergeBase,
            git_repository* repo,
            int length,
            [In] GitOid[] input_array);

        [DllImport(libgit2)]
        internal static extern unsafe int git_merge_base_octopus(
            out GitOid mergeBase,
            git_repository* repo,
            int length,
            [In] GitOid[] input_array);

        [DllImport(libgit2)]
        internal static extern unsafe int git_annotated_commit_from_ref(
            out git_annotated_commit* annotatedCommit,
            git_repository* repo,
            git_reference* reference);

        [DllImport(libgit2)]
        private static extern unsafe int git_annotated_commit_from_fetchhead(
            out git_annotated_commit* annotatedCommit,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* branch_name,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* remote_url,
            ref GitOid oid);

        [DllImport(libgit2)]
        private static extern unsafe int git_annotated_commit_from_revspec(
            out git_annotated_commit* annotatedCommit,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* revspec);

        [DllImport(libgit2)]
        internal static extern unsafe int git_annotated_commit_lookup(
            out git_annotated_commit* annotatedCommit,
            git_repository* repo,
            ref GitOid id);

        [DllImport(libgit2)]
        internal static extern unsafe git_oid* git_annotated_commit_id(
            git_annotated_commit* annotatedCommit);

        [DllImport(libgit2)]
        internal static extern unsafe int git_merge(
            git_repository* repo,
            [In] IntPtr[] their_heads,
            UIntPtr their_heads_len,
            ref GitMergeOpts merge_opts,
            ref GitCheckoutOpts checkout_opts);

        [DllImport(libgit2)]
        internal static extern unsafe int git_merge_commits(
            out git_index* index,
            git_repository* repo,
            git_object* our_commit,
            git_object* their_commit,
            ref GitMergeOpts merge_opts);

        [DllImport(libgit2)]
        internal static extern unsafe int git_merge_analysis(
            out GitMergeAnalysis status_out,
            out GitMergePreference preference_out,
            git_repository* repo,
            [In] IntPtr[] their_heads,
            int their_heads_len);

        [DllImport(libgit2)]
        internal static extern unsafe void git_annotated_commit_free(git_annotated_commit* commit);

        [DllImport(libgit2)]
        private static unsafe extern int git_message_prettify(
            GitBuf buf,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* message,
            [MarshalAs(UnmanagedType.Bool)] bool strip_comments,
            sbyte comment_char);

        [DllImport(libgit2)]
        private static extern unsafe int git_note_create(
            out GitOid noteOid,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* notes_ref,
            git_signature* author,
            git_signature* committer,
            ref GitOid oid,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* note,
            int force);

        [DllImport(libgit2)]
        internal static extern unsafe void git_note_free(git_note* note);

        [DllImport(libgit2, EntryPoint = "git_note_message")]
        [return: CustomMarshaler(typeof(LaxUtf8NoCleanupMarshaler), typeof(string))]
        private static extern unsafe byte* git_note_message_(git_note* note);

        [DllImport(libgit2)]
        internal static extern unsafe git_oid* git_note_id(git_note* note);

        [DllImport(libgit2)]
        private static extern unsafe int git_note_read(
            out git_note* note,
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* notes_ref,
            ref GitOid oid);

        [DllImport(libgit2)]
        private static extern unsafe int git_note_remove(
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* notes_ref,
            git_signature* author,
            git_signature* committer,
            ref GitOid oid);

        [DllImport(libgit2)]
        internal static extern unsafe int git_note_default_ref(
            GitBuf notes_ref,
            git_repository* repo);

        internal delegate int git_note_foreach_cb(
            ref GitOid blob_id,
            ref GitOid annotated_object_id,
            IntPtr payload);

        [DllImport(libgit2)]
        private static extern unsafe int git_note_foreach(
            git_repository* repo,
            [CustomMarshaler(typeof(StrictUtf8Marshaler), typeof(string))] byte* notes_ref,
            git_note_foreach_cb cb,
            IntPtr payload);

        [DllImport(libgit2)]
        internal static extern unsafe int git_odb_add_backend(git_odb* odb, IntPtr backend, int priority);

        [DllImport(libgit2)]
        internal static extern IntPtr git_odb_backend_malloc(IntPtr backend, UIntPtr len);

        [DllImport(libgit2)]
        internal static extern unsafe int git_odb_exists(git_odb* odb, ref GitOid id);

        internal delegate int git_odb_foreach_cb(
            IntPtr id,
            IntPtr payload);

        [DllImport(libgit2)]
        internal static extern unsafe int git_odb_foreach(
            git_odb* odb,
            git_odb_foreach_cb cb,
            IntPtr payload);

        [DllImport(libgit2)]
        internal static extern unsafe int git_odb_open_wstream(out git_odb_stream* stream, git_odb* odb, Int64 size, GitObjectType type);

        [DllImport(libgit2)]
        internal static extern unsafe void git_odb_free(git_odb* odb);

        [DllImport(libgit2)]
        internal static extern unsafe int git_odb_read_header(out UIntPtr len_out, out GitObjectType type, git_odb* odb, ref GitOid id);

        [DllImport(libgit2)]
        internal static extern unsafe void git_object_free(git_object* obj);

        [DllImport(libgit2)]
        internal static extern unsafe int git_odb_stream_write(git_odb_stream* Stream, IntPtr Buffer, UIntPtr len);

        [DllImport(libgit2)]
        internal static extern unsafe int git_odb_stream_finalize_write(out GitOid id, git_odb_stream* stream);

        [DllImport(libgit2)]
        internal static extern unsafe void git_odb_stream_free(git_odb_stream* stream);

        [DllImport(libgit2)]
        internal static extern unsafe int git_odb_write(out GitOid id, git_odb* odb, byte* data, UIntPtr len, GitObjectType type);

        [DllImport(libgit2)]
        internal static extern unsafe git_oid* git_object_id(git_object* obj);

        [DllImport(libgit2)]
        internal static extern unsafe int git_object_lookup(out git_object* obj, git_repository* repo, ref GitOid id, GitObjectType type);

        [DllImport(libgit2)]
        internal static extern unsafe int git_object_peel(
            out git_object* peeled,
            git_object* obj,
            GitObjectType type);

        [DllImport(libgit2)]
        internal static extern unsafe int git_object_short_id(
            GitBuf buf,
            git_object* obj);

        [DllImport(libgit2)]
        internal static extern unsafe GitObjectType git_object_type(git_object* obj);

        [DllImport(libgit2)]
        internal static extern unsafe int git_patch_from_diff(out git_patch* patch, git_diff* diff, UIntPtr idx);

        [DllImport(libgit2)]
        internal static extern unsafe int git_patch_print(git_patch* patch, git_diff_line_cb print_cb, IntPtr payload);

        [DllImport(libgit2)]
        internal static extern unsafe int git_patch_line_stats(
            out UIntPtr total_context,
            out UIntPtr total_additions,
            out UIntPtr total_deletions,
            git_patch* patch);

        [DllImport(libgit2)]
        internal static extern unsafe void git_patch_free(git_patch* patch);

        /* Push network progress notification function */
        internal delegate int git_push_transfer_progress(uint current, uint total, UIntPtr bytes, IntPtr payload);