963 lines
28 KiB
C#
963 lines
28 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.ConstrainedExecution;
|
|
using System.Runtime.InteropServices;
|
|
using System.Runtime.Serialization;
|
|
|
|
// ReSharper disable MemberCanBePrivate.Global
|
|
// ReSharper disable UnassignedReadonlyField
|
|
// ReSharper disable UnusedMember.Global
|
|
|
|
// ReSharper disable InconsistentNaming
|
|
|
|
namespace nalpm
|
|
{
|
|
public enum errno_t
|
|
{
|
|
ERR_OK = 0,
|
|
ERR_MEMORY,
|
|
ERR_SYSTEM,
|
|
ERR_BADPERMS,
|
|
ERR_NOT_A_FILE,
|
|
ERR_NOT_A_DIR,
|
|
ERR_WRONG_ARGS,
|
|
ERR_DISK_SPACE,
|
|
|
|
/* Interface */
|
|
ERR_HANDLE_NULL,
|
|
ERR_HANDLE_NOT_NULL,
|
|
ERR_HANDLE_LOCK,
|
|
|
|
/* Databases */
|
|
ERR_DB_OPEN,
|
|
ERR_DB_CREATE,
|
|
ERR_DB_NULL,
|
|
ERR_DB_NOT_NULL,
|
|
ERR_DB_NOT_FOUND,
|
|
ERR_DB_INVALID,
|
|
ERR_DB_INVALID_SIG,
|
|
ERR_DB_VERSION,
|
|
ERR_DB_WRITE,
|
|
ERR_DB_REMOVE,
|
|
|
|
/* Servers */
|
|
ERR_SERVER_BAD_URL,
|
|
ERR_SERVER_NONE,
|
|
|
|
/* Transactions */
|
|
ERR_TRANS_NOT_NULL,
|
|
ERR_TRANS_NULL,
|
|
ERR_TRANS_DUP_TARGET,
|
|
ERR_TRANS_NOT_INITIALIZED,
|
|
ERR_TRANS_NOT_PREPARED,
|
|
ERR_TRANS_ABORT,
|
|
ERR_TRANS_TYPE,
|
|
ERR_TRANS_NOT_LOCKED,
|
|
ERR_TRANS_HOOK_FAILED,
|
|
|
|
/* Packages */
|
|
ERR_PKG_NOT_FOUND,
|
|
ERR_PKG_IGNORED,
|
|
ERR_PKG_INVALID,
|
|
ERR_PKG_INVALID_CHECKSUM,
|
|
ERR_PKG_INVALID_SIG,
|
|
ERR_PKG_MISSING_SIG,
|
|
ERR_PKG_OPEN,
|
|
ERR_PKG_CANT_REMOVE,
|
|
ERR_PKG_INVALID_NAME,
|
|
ERR_PKG_INVALID_ARCH,
|
|
ERR_PKG_REPO_NOT_FOUND,
|
|
|
|
/* Signatures */
|
|
ERR_SIG_MISSING,
|
|
ERR_SIG_INVALID,
|
|
|
|
/* Dependencies */
|
|
ERR_UNSATISFIED_DEPS,
|
|
ERR_CONFLICTING_DEPS,
|
|
ERR_FILE_CONFLICTS,
|
|
|
|
/* Misc */
|
|
ERR_RETRIEVE,
|
|
ERR_INVALID_REGEX,
|
|
|
|
/* External library errors */
|
|
ERR_LIBARCHIVE,
|
|
ERR_LIBCURL,
|
|
ERR_EXTERNAL_DOWNLOAD,
|
|
ERR_GPGME,
|
|
|
|
/* Missing compile-time features */
|
|
ERR_MISSING_CAPABILITY_SIGNATURES
|
|
}
|
|
|
|
/** Package install reasons. */
|
|
enum alpm_pkgreason_t
|
|
{
|
|
/** Explicitly requested by the user. */
|
|
PKG_REASON_EXPLICIT = 0,
|
|
|
|
/** Installed as a dependency for another package. */
|
|
PKG_REASON_DEPEND = 1
|
|
}
|
|
|
|
|
|
/** Location a package object was loaded from. */
|
|
enum alpm_pkgfrom_t
|
|
{
|
|
PKG_FROM_FILE = 1,
|
|
PKG_FROM_LOCALDB,
|
|
PKG_FROM_SYNCDB
|
|
}
|
|
|
|
/** Method used to validate a package. */
|
|
enum alpm_pkgvalidation_t
|
|
{
|
|
PKG_VALIDATION_UNKNOWN = 0,
|
|
PKG_VALIDATION_NONE = (1 << 0),
|
|
PKG_VALIDATION_MD5SUM = (1 << 1),
|
|
PKG_VALIDATION_SHA256SUM = (1 << 2),
|
|
PKG_VALIDATION_SIGNATURE = (1 << 3)
|
|
}
|
|
|
|
/** Types of version constraints in dependency specs. */
|
|
public enum alpm_depmod_t
|
|
{
|
|
/** No version constraint */
|
|
DEP_MOD_ANY = 1,
|
|
|
|
/** Test version equality (package=x.y.z) */
|
|
DEP_MOD_EQ,
|
|
|
|
/** Test for at least a version (package>=x.y.z) */
|
|
DEP_MOD_GE,
|
|
|
|
/** Test for at most a version (package<=x.y.z) */
|
|
DEP_MOD_LE,
|
|
|
|
/** Test for greater than some version (package>x.y.z) */
|
|
DEP_MOD_GT,
|
|
|
|
/** Test for less than some version (package<x.y.z) */
|
|
DEP_MOD_LT
|
|
}
|
|
|
|
/**
|
|
* File conflict type.
|
|
* Whether the conflict results from a file existing on the filesystem, or with
|
|
* another target in the transaction.
|
|
*/
|
|
enum alpm_fileconflicttype_t
|
|
{
|
|
FILECONFLICT_TARGET = 1,
|
|
FILECONFLICT_FILESYSTEM
|
|
}
|
|
|
|
/** PGP signature verification options */
|
|
[Flags]
|
|
public enum SigLevel
|
|
{
|
|
SIG_PACKAGE = (1 << 0),
|
|
SIG_PACKAGE_OPTIONAL = (1 << 1),
|
|
SIG_PACKAGE_MARGINAL_OK = (1 << 2),
|
|
SIG_PACKAGE_UNKNOWN_OK = (1 << 3),
|
|
|
|
SIG_DATABASE = (1 << 10),
|
|
SIG_DATABASE_OPTIONAL = (1 << 11),
|
|
SIG_DATABASE_MARGINAL_OK = (1 << 12),
|
|
SIG_DATABASE_UNKNOWN_OK = (1 << 13),
|
|
SIG_USE_DEFAULT = (1 << 31)
|
|
}
|
|
|
|
/** PGP signature verification status return codes */
|
|
enum alpm_sigstatus_t
|
|
{
|
|
SIGSTATUS_VALID,
|
|
SIGSTATUS_KEY_EXPIRED,
|
|
SIGSTATUS_SIG_EXPIRED,
|
|
SIGSTATUS_KEY_UNKNOWN,
|
|
SIGSTATUS_KEY_DISABLED,
|
|
SIGSTATUS_INVALID
|
|
}
|
|
|
|
/** PGP signature verification status return codes */
|
|
enum alpm_sigvalidity_t
|
|
{
|
|
SIGVALIDITY_FULL,
|
|
SIGVALIDITY_MARGINAL,
|
|
SIGVALIDITY_NEVER,
|
|
SIGVALIDITY_UNKNOWN
|
|
}
|
|
|
|
/** Dependency */
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public struct alpm_depend_t
|
|
{
|
|
string name;
|
|
string version;
|
|
string desc;
|
|
public ulong name_hash;
|
|
public alpm_depmod_t mod;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct AlpmDependPtr
|
|
{
|
|
private IntPtr ptr;
|
|
|
|
public alpm_depend_t Unmarshal()
|
|
{
|
|
return Marshal.PtrToStructure<alpm_depend_t>(ptr);
|
|
}
|
|
}
|
|
|
|
/** Missing dependency */
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public struct alpm_depmissing_t
|
|
{
|
|
public string target;
|
|
|
|
public AlpmDependPtr depend;
|
|
|
|
/* this is used only in the case of a remove dependency error */
|
|
public string causingpkg;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
/** Conflict */
|
|
public struct alpm_conflict_t
|
|
{
|
|
public ulong package1_hash;
|
|
public ulong package2_hash;
|
|
public string package1;
|
|
public string package2;
|
|
public AlpmDependPtr reason;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
/** File conflict */
|
|
struct alpm_fileconflict_t
|
|
{
|
|
public string target;
|
|
public alpm_fileconflicttype_t type;
|
|
public string file;
|
|
public string ctarget;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
/** Package group */
|
|
public readonly struct alpm_group_t
|
|
{
|
|
/** group name */
|
|
public readonly string name;
|
|
|
|
/** list of alpm_pkg_t packages */
|
|
public readonly unsafe alpm_list_t* packages;
|
|
}
|
|
|
|
/* TODO: alpm_pkg_get_files - need to wrap */
|
|
/** File in a package */
|
|
public readonly struct alpm_file_t
|
|
{
|
|
public readonly string name;
|
|
public readonly UIntPtr size;
|
|
public readonly uint mode;
|
|
}
|
|
|
|
/** Package filelist container */
|
|
public struct _alpm_filelist_t
|
|
{
|
|
public UIntPtr count;
|
|
private IntPtr files;
|
|
|
|
/* FIXME: This is broken as shit */
|
|
public alpm_file_t[] Unmarshal()
|
|
{
|
|
var iCount = (int) this.count;
|
|
var byteCount = Marshal.SizeOf<alpm_file_t>() * iCount;
|
|
var byteBuffer = new byte[byteCount];
|
|
Marshal.Copy(files, byteBuffer, 0, byteBuffer.Length);
|
|
var result = new alpm_file_t[iCount];
|
|
|
|
Buffer.BlockCopy(byteBuffer, 0, result, 0, byteBuffer.Length);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/** Local package or package file backup entry */
|
|
public struct _alpm_backup_t
|
|
{
|
|
string name;
|
|
string hash;
|
|
}
|
|
|
|
public class alpm_pgpkey_t
|
|
{
|
|
public byte[] data;
|
|
public string fingerprint;
|
|
public string uid;
|
|
public string name;
|
|
public string email;
|
|
public long created;
|
|
public long expires;
|
|
public uint revoked;
|
|
public char pubkey_algo;
|
|
}
|
|
|
|
public class PgpKeyInMarshaler : ICustomMarshaler
|
|
{
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
private class NativePgpKey
|
|
{
|
|
public IntPtr data;
|
|
public string fingerprint;
|
|
public string uid;
|
|
public string name;
|
|
public string email;
|
|
public long created;
|
|
public long expires;
|
|
public uint length;
|
|
public uint revoked;
|
|
public char pubkey_algo;
|
|
}
|
|
|
|
public void CleanUpManagedData(object ManagedObj) { }
|
|
public void CleanUpNativeData(IntPtr pNativeData) { }
|
|
|
|
public int GetNativeDataSize()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public IntPtr MarshalManagedToNative(object ManagedObj)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public object MarshalNativeToManaged(IntPtr pNativeData)
|
|
{
|
|
var raw = Marshal.PtrToStructure<NativePgpKey>(pNativeData);
|
|
var managed = new alpm_pgpkey_t()
|
|
{
|
|
data = new byte[raw.length],
|
|
fingerprint = raw.fingerprint,
|
|
uid = raw.uid,
|
|
name = raw.name,
|
|
email = raw.email,
|
|
created = raw.created,
|
|
expires = raw.expires,
|
|
revoked = raw.revoked,
|
|
pubkey_algo = raw.pubkey_algo
|
|
};
|
|
Marshal.Copy(raw.data, managed.data, 0, (int) raw.length);
|
|
return managed;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Signature result. Contains the key, status, and validity of a given
|
|
* signature.
|
|
*/
|
|
public readonly struct alpm_sigresult_t
|
|
{
|
|
[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(PgpKeyInMarshaler))]
|
|
readonly alpm_pgpkey_t key;
|
|
|
|
readonly alpm_sigstatus_t status;
|
|
readonly alpm_sigvalidity_t validity;
|
|
}
|
|
|
|
/**
|
|
* Signature list. Contains the number of signatures found and a pointer to an
|
|
* array of results. The array is of size count.
|
|
*/
|
|
public class SigListInMarshaler : ICustomMarshaler
|
|
{
|
|
public void CleanUpManagedData(object ManagedObj) { }
|
|
public void CleanUpNativeData(IntPtr pNativeData) { }
|
|
|
|
public int GetNativeDataSize()
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public IntPtr MarshalManagedToNative(object ManagedObj)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public object MarshalNativeToManaged(IntPtr pNativeData)
|
|
{
|
|
UIntPtr count;
|
|
IntPtr data;
|
|
unsafe
|
|
{
|
|
count = *(UIntPtr*) pNativeData;
|
|
data = *(IntPtr*) (pNativeData + sizeof(UIntPtr));
|
|
}
|
|
|
|
var iCount = (int) count;
|
|
var result = new alpm_sigresult_t[iCount];
|
|
// NOTE: I expect this to fail cuz i didn't implement the above GetNativeDataSize
|
|
for (var i = 0; i < iCount; ++i, data += Marshal.SizeOf<alpm_sigresult_t>())
|
|
{
|
|
result[i] = Marshal.PtrToStructure<alpm_sigresult_t>(data);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Hooks
|
|
*/
|
|
|
|
enum alpm_hook_when_t
|
|
{
|
|
HOOK_PRE_TRANSACTION = 1,
|
|
HOOK_POST_TRANSACTION
|
|
}
|
|
|
|
/*
|
|
* Logging facilities
|
|
*/
|
|
|
|
/** Logging Levels */
|
|
enum _alpm_loglevel_t
|
|
{
|
|
LOG_ERROR = 1,
|
|
LOG_WARNING = (1 << 1),
|
|
LOG_DEBUG = (1 << 2),
|
|
LOG_FUNCTION = (1 << 3)
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
|
|
public struct alpm_pkg_p
|
|
{
|
|
private IntPtr ptr;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct alpm_list_t
|
|
{
|
|
public IntPtr data;
|
|
public unsafe alpm_list_t* prev;
|
|
public unsafe alpm_list_t* next;
|
|
}
|
|
|
|
public interface IAlpmItemsAccessor<TElement>
|
|
{
|
|
SafeAlpmHandle Handle { get; }
|
|
public IntPtr GetItems();
|
|
public int SetItems(IntPtr list);
|
|
public int AddItem(TElement item);
|
|
public int RemoveItem(TElement item);
|
|
public IntPtr FindItem(TElement item);
|
|
public TElement PtrToItem(IntPtr p);
|
|
}
|
|
|
|
|
|
public class SafeAlpmHandle : SafeHandle
|
|
{
|
|
private SafeAlpmHandle() : base(IntPtr.Zero, true) { }
|
|
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
|
|
protected override bool ReleaseHandle()
|
|
{
|
|
return alpm.alpm_release(handle) == 0;
|
|
}
|
|
|
|
public override bool IsInvalid => handle == IntPtr.Zero;
|
|
}
|
|
|
|
public sealed class Handle : IDisposable
|
|
{
|
|
private readonly SafeAlpmHandle _handle;
|
|
|
|
public Handle(string root, string dbpath)
|
|
{
|
|
var err = errno_t.ERR_OK;
|
|
_handle = alpm.alpm_initialize(root, dbpath, ref err);
|
|
if (_handle.IsInvalid)
|
|
{
|
|
throw new Exception(err);
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_handle.Dispose();
|
|
}
|
|
|
|
private Database DatabaseAccess(IntPtr ptr)
|
|
{
|
|
if (ptr == IntPtr.Zero)
|
|
{
|
|
throw new Exception(_handle);
|
|
}
|
|
|
|
Database db;
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
|
try { }
|
|
finally
|
|
{
|
|
// adding this ref and getting the Database object the handle must not interrupted
|
|
var addedRef = false;
|
|
_handle.DangerousAddRef(ref addedRef);
|
|
if (!addedRef)
|
|
throw new ObjectDisposedException(GetType().FullName);
|
|
db = new Database(_handle, new DatabaseHandle(ptr));
|
|
}
|
|
return db;
|
|
}
|
|
|
|
public Database LocalDB => DatabaseAccess(alpm.alpm_get_localdb(_handle));
|
|
|
|
public Database RegisterSyncDB(string treename, SigLevel sigLevel) =>
|
|
DatabaseAccess(alpm.alpm_register_syncdb(_handle, treename, sigLevel));
|
|
|
|
public readonly struct CacheDirsAccessor : IAlpmItemsAccessor<string>
|
|
{
|
|
public CacheDirsAccessor(SafeAlpmHandle handle) => Handle = handle;
|
|
public SafeAlpmHandle Handle { get; }
|
|
public IntPtr GetItems() => alpm.alpm_option_get_cachedirs(Handle);
|
|
public int SetItems(IntPtr list) => alpm.alpm_option_set_cachedirs(Handle, list);
|
|
public int AddItem(string item) => alpm.alpm_option_add_cachedir(Handle, item);
|
|
public int RemoveItem(string item) => alpm.alpm_option_remove_cachedir(Handle, item);
|
|
public IntPtr FindItem(string item) => alpm.alpm_list_find_str(GetItems(), item);
|
|
public string PtrToItem(IntPtr p) => Marshal.PtrToStringUTF8(p)!;
|
|
}
|
|
|
|
#nullable enable
|
|
public struct CollectionWrapper<TImpl, TElement> : ICollection<TElement> where TImpl : IAlpmItemsAccessor<TElement>,
|
|
ICollection<TElement>
|
|
{
|
|
private TImpl _impl;
|
|
|
|
public CollectionWrapper(TImpl impl)
|
|
{
|
|
_impl = impl;
|
|
}
|
|
|
|
IEnumerator<TElement> IEnumerable<TElement>.GetEnumerator()
|
|
{
|
|
return (IEnumerator<TElement>) GetEnumerator();
|
|
}
|
|
|
|
public IEnumerator GetEnumerator()
|
|
{
|
|
var result = new List<TElement>();
|
|
var intPtr = _impl.GetItems();
|
|
unsafe
|
|
{
|
|
for (var list = (alpm_list_t*) intPtr; list != null; list = alpm.alpm_list_next(list))
|
|
{
|
|
result.Add(_impl.PtrToItem(list->data));
|
|
}
|
|
}
|
|
|
|
return result.GetEnumerator();
|
|
}
|
|
|
|
|
|
public void Add(TElement item)
|
|
{
|
|
_impl.AddItem(item);
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
_impl.SetItems(IntPtr.Zero);
|
|
}
|
|
|
|
|
|
public bool Contains(TElement item) =>
|
|
_impl.FindItem(item) != IntPtr.Zero;
|
|
|
|
public void CopyTo(TElement[] array, int arrayIndex)
|
|
{
|
|
var intPtr = _impl.GetItems();
|
|
unsafe
|
|
{
|
|
for (var list = (alpm_list_t*) intPtr; list != null; list = alpm.alpm_list_next(list))
|
|
{
|
|
array[arrayIndex++] = _impl.PtrToItem(list->data);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool Remove(TElement item)
|
|
{
|
|
var err = _impl.RemoveItem(item);
|
|
if (err < 0)
|
|
{
|
|
throw new Exception(alpm.alpm_errno(_impl.Handle));
|
|
}
|
|
|
|
return err == 0;
|
|
}
|
|
|
|
public int Count => (int) alpm.alpm_list_count(_impl.GetItems());
|
|
public bool IsReadOnly => false;
|
|
}
|
|
|
|
private readonly struct CacheDirCollection : ICollection<string>
|
|
{
|
|
private readonly SafeAlpmHandle _handle;
|
|
|
|
public CacheDirCollection(SafeAlpmHandle handle)
|
|
{
|
|
_handle = handle;
|
|
}
|
|
|
|
public IEnumerator<string> GetEnumerator()
|
|
{
|
|
var result = new List<string>();
|
|
var intPtr = alpm.alpm_option_get_cachedirs(_handle);
|
|
unsafe
|
|
{
|
|
for (var list = (alpm_list_t*) intPtr; list != null; list = alpm.alpm_list_next(list))
|
|
{
|
|
result.Add(Marshal.PtrToStringUTF8(list->data));
|
|
}
|
|
}
|
|
|
|
return result.GetEnumerator();
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return GetEnumerator();
|
|
}
|
|
|
|
public void Add(string item)
|
|
{
|
|
var handle = _handle;
|
|
Alpm.ErrWrap(_handle, () => alpm.alpm_option_add_cachedir(handle, item));
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
var handle = _handle;
|
|
Alpm.ErrWrap(_handle, () => alpm.alpm_option_set_cachedirs(handle, IntPtr.Zero));
|
|
}
|
|
|
|
public bool Contains(string item) =>
|
|
alpm.alpm_list_find_str(alpm.alpm_option_get_cachedirs(_handle), item) != IntPtr.Zero;
|
|
|
|
public void CopyTo(string[] array, int arrayIndex)
|
|
{
|
|
var intPtr = alpm.alpm_option_get_cachedirs(_handle);
|
|
unsafe
|
|
{
|
|
for (var list = (alpm_list_t*) intPtr; list != null; list = alpm.alpm_list_next(list))
|
|
{
|
|
array[arrayIndex++] = Marshal.PtrToStringUTF8(list->data);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool Remove(string item)
|
|
{
|
|
var err = alpm.alpm_option_remove_cachedir(_handle, item);
|
|
if (err < 0)
|
|
{
|
|
throw new Exception(alpm.alpm_errno(_handle));
|
|
}
|
|
|
|
return err == 0;
|
|
}
|
|
|
|
public int Count => (int) alpm.alpm_list_count(alpm.alpm_option_get_cachedirs(_handle));
|
|
public bool IsReadOnly => false;
|
|
}
|
|
|
|
public ICollection<string> CacheDirs
|
|
{
|
|
get => new CacheDirCollection(_handle);
|
|
set
|
|
{
|
|
foreach (var s in value)
|
|
{
|
|
Alpm.ErrWrap(_handle, () => alpm.alpm_option_add_cachedir(_handle, s));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum caps
|
|
{
|
|
ALPM_CAPABILITY_NLS = (1 << 0),
|
|
ALPM_CAPABILITY_DOWNLOADER = (1 << 1),
|
|
ALPM_CAPABILITY_SIGNATURES = (1 << 2)
|
|
}
|
|
|
|
[Serializable()]
|
|
public class Exception : System.Exception
|
|
{
|
|
public Exception() { }
|
|
public Exception(SafeAlpmHandle handle) : base(Alpm.StrError(alpm.alpm_errno(handle))) { }
|
|
public Exception(errno_t errno) : base(Alpm.StrError(errno)) { }
|
|
public Exception(errno_t errno, System.Exception inner) : base(Alpm.StrError(errno), inner) { }
|
|
|
|
protected Exception(SerializationInfo info,
|
|
StreamingContext context) : base(info, context) { }
|
|
}
|
|
|
|
public class DatabaseHandle : SafeHandle
|
|
{
|
|
private DatabaseHandle() : base(IntPtr.Zero, true) { }
|
|
|
|
public DatabaseHandle(IntPtr h) : this()
|
|
{
|
|
SetHandle(h);
|
|
}
|
|
|
|
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
|
|
protected override bool ReleaseHandle()
|
|
{
|
|
return alpm.alpm_db_unregister(handle) == 0;
|
|
}
|
|
|
|
public override bool IsInvalid => handle == IntPtr.Zero;
|
|
}
|
|
|
|
public sealed class Database : IDisposable
|
|
{
|
|
private SafeAlpmHandle _handle;
|
|
private DatabaseHandle _db;
|
|
|
|
public Database(SafeAlpmHandle handle, DatabaseHandle db)
|
|
{
|
|
_handle = handle;
|
|
_db = db;
|
|
}
|
|
|
|
private readonly struct ServerCollection : ICollection<string>
|
|
{
|
|
private readonly SafeAlpmHandle _handle;
|
|
private readonly DatabaseHandle _db;
|
|
|
|
public ServerCollection(SafeAlpmHandle handle, DatabaseHandle db)
|
|
{
|
|
_handle = handle;
|
|
_db = db;
|
|
}
|
|
|
|
public IEnumerator<string> GetEnumerator()
|
|
{
|
|
var result = new List<string>();
|
|
var intPtr = alpm.alpm_db_get_servers(_db);
|
|
unsafe
|
|
{
|
|
for (var list = (alpm_list_t*) intPtr; list != null; list = alpm.alpm_list_next(list))
|
|
{
|
|
result.Add(Marshal.PtrToStringUTF8(list->data));
|
|
}
|
|
}
|
|
|
|
return result.GetEnumerator();
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return GetEnumerator();
|
|
}
|
|
|
|
public void Add(string item)
|
|
{
|
|
var db = _db;
|
|
Alpm.ErrWrap(_handle, () => alpm.alpm_db_add_server(db, item));
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
var db = _db;
|
|
Alpm.ErrWrap(_handle, () => alpm.alpm_db_set_servers(db, IntPtr.Zero));
|
|
}
|
|
|
|
public bool Contains(string item) =>
|
|
alpm.alpm_list_find_str(alpm.alpm_db_get_servers(_db), item) != IntPtr.Zero;
|
|
|
|
public void CopyTo(string[] array, int arrayIndex)
|
|
{
|
|
var intPtr = alpm.alpm_db_get_servers(_db);
|
|
unsafe
|
|
{
|
|
for (var list = (alpm_list_t*) intPtr; list != null; list = alpm.alpm_list_next(list))
|
|
{
|
|
array[arrayIndex++] = Marshal.PtrToStringUTF8(list->data);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool Remove(string item)
|
|
{
|
|
var err = alpm.alpm_db_remove_server(_db, item);
|
|
if (err < 0)
|
|
{
|
|
throw new Exception(alpm.alpm_errno(_handle));
|
|
}
|
|
|
|
return err == 0;
|
|
}
|
|
|
|
|
|
public int Count => (int) alpm.alpm_list_count(alpm.alpm_db_get_servers(_db));
|
|
public bool IsReadOnly => false;
|
|
}
|
|
|
|
public ICollection<string> Servers
|
|
{
|
|
get => new ServerCollection(_handle, _db);
|
|
set
|
|
{
|
|
foreach (var s in value)
|
|
{
|
|
Alpm.ErrWrap(_handle, () => alpm.alpm_db_add_server(_db, s));
|
|
}
|
|
}
|
|
}
|
|
|
|
public string Name => Marshal.PtrToStringUTF8(alpm.alpm_db_get_name(_db));
|
|
|
|
public SigLevel SigLevel => alpm.alpm_db_get_siglevel(_db);
|
|
|
|
public errno_t Valid => alpm.alpm_db_get_valid(_db) != 0 ? alpm.alpm_errno(_handle) : errno_t.ERR_OK;
|
|
|
|
public bool Update(bool force)
|
|
{
|
|
var err = alpm.alpm_db_update(force ? 1 : 0, _db);
|
|
if (err < 0)
|
|
{
|
|
throw new Exception(_handle);
|
|
}
|
|
|
|
return err == 0;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_db.Dispose();
|
|
RuntimeHelpers.PrepareConstrainedRegions();
|
|
try { }
|
|
finally
|
|
{
|
|
_handle.DangerousRelease();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static class alpm
|
|
{
|
|
[DllImport(nameof(alpm))]
|
|
public static extern IntPtr alpm_option_get_cachedirs(SafeAlpmHandle handle);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern int alpm_option_set_cachedirs(SafeAlpmHandle handle, IntPtr cachedirs);
|
|
|
|
[DllImport(nameof(alpm), CharSet = CharSet.Ansi)]
|
|
public static extern int alpm_option_add_cachedir(SafeAlpmHandle handle, string cachedir);
|
|
|
|
[DllImport(nameof(alpm), CharSet = CharSet.Ansi)]
|
|
public static extern int alpm_option_remove_cachedir(SafeAlpmHandle handle, string cachedir);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern errno_t alpm_errno(SafeAlpmHandle handle);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern IntPtr alpm_strerror(errno_t err);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern IntPtr alpm_get_localdb(SafeAlpmHandle handle);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern unsafe alpm_list_t* alpm_option_get_syncdbs();
|
|
|
|
[DllImport(nameof(alpm), CharSet = CharSet.Ansi)]
|
|
public static extern IntPtr alpm_register_syncdb(SafeAlpmHandle handle, string treename, SigLevel sigLevel);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern int alpm_db_unregister_all_syncdbs(SafeAlpmHandle handle);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern unsafe alpm_list_t* alpm_list_next(alpm_list_t* list);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern UIntPtr alpm_list_count(IntPtr list);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern void alpm_list_free(IntPtr list);
|
|
|
|
[DllImport(nameof(alpm), CharSet = CharSet.Ansi)]
|
|
public static extern IntPtr alpm_list_find_str(IntPtr list, string needle);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern int alpm_unlock(Handle handle);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern IntPtr alpm_version();
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern caps alpm_capabilities();
|
|
|
|
[DllImport(nameof(alpm), CharSet = CharSet.Ansi)]
|
|
public static extern SafeAlpmHandle alpm_initialize(string root, string dbpath, ref errno_t err);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern int alpm_release(IntPtr handle);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern int alpm_db_remove_server(DatabaseHandle db, string url);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern int alpm_db_unregister(IntPtr db);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern IntPtr alpm_db_get_name(DatabaseHandle db);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern SigLevel alpm_db_get_siglevel(DatabaseHandle db);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern int alpm_db_get_valid(DatabaseHandle db);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern int alpm_db_update(int force, DatabaseHandle db);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern IntPtr alpm_db_get_servers(DatabaseHandle db);
|
|
|
|
[DllImport(nameof(alpm))]
|
|
public static extern int alpm_db_set_servers(DatabaseHandle db, IntPtr list);
|
|
|
|
[DllImport(nameof(alpm), CharSet = CharSet.Ansi)]
|
|
public static extern int alpm_db_add_server(DatabaseHandle db, string url);
|
|
}
|
|
|
|
internal static class Alpm
|
|
{
|
|
public static string Version()
|
|
{
|
|
return Marshal.PtrToStringUTF8(alpm.alpm_version());
|
|
}
|
|
|
|
public static string StrError(errno_t err)
|
|
{
|
|
return Marshal.PtrToStringUTF8(alpm.alpm_strerror(err));
|
|
}
|
|
|
|
internal static void ErrWrap(SafeAlpmHandle h, Func<int> f)
|
|
{
|
|
var err = f();
|
|
if (err != 0)
|
|
{
|
|
throw new Exception(alpm.alpm_errno(h));
|
|
}
|
|
}
|
|
}
|
|
} |