forked from cromer/pamac-classic
1366 lines
42 KiB
Vala
1366 lines
42 KiB
Vala
/*
|
|
* libalpm-vala
|
|
* Vala bindings for libalpm
|
|
*
|
|
* Copyright (C) 2014-2015 Guillaume Benoit <guillaume@manjaro.org>
|
|
* Copyright (c) 2011 Rémy Oudompheng <remy@archlinux.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a get of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
[CCode (cprefix = "alpm_", cheader_filename="alpm.h")]
|
|
namespace Alpm {
|
|
|
|
[SimpleType]
|
|
[CCode (cname = "alpm_time_t", has_type_id = false)]
|
|
public struct Time : uint64 {}
|
|
|
|
/**
|
|
* Library
|
|
*/
|
|
public unowned string version();
|
|
|
|
public unowned Package? find_satisfier(Alpm.List<Package> pkgs, string depstring);
|
|
|
|
public unowned Package? pkg_find(Alpm.List<Package> haystack, string needle);
|
|
|
|
public int pkg_vercmp(string a, string b);
|
|
|
|
public unowned Alpm.List<unowned Package?> find_group_pkgs(Alpm.List<DB> dbs, string name);
|
|
|
|
/** Returns the string corresponding to an error number. */
|
|
public unowned string strerror(Errno err);
|
|
|
|
/**
|
|
* Handle
|
|
*/
|
|
[CCode (cname = "alpm_handle_t")]
|
|
[Compact]
|
|
public class Handle {
|
|
[CCode (cname = "alpm_initialize")]
|
|
public static unowned Handle @new(string root, string dbpath, out Alpm.Errno error);
|
|
|
|
[CCode (cname = "alpm_release")]
|
|
public static int release (Handle handle);
|
|
|
|
public unowned string root {
|
|
[CCode (cname = "alpm_option_get_root")] get;
|
|
}
|
|
public unowned string dbpath {
|
|
[CCode (cname = "alpm_option_get_dbpath")] get;
|
|
}
|
|
public unowned string arch {
|
|
[CCode (cname = "alpm_option_get_arch")] get;
|
|
[CCode (cname = "alpm_option_set_arch")] set;
|
|
}
|
|
public unowned Alpm.List<unowned string?> cachedirs {
|
|
[CCode (cname = "alpm_option_get_cachedirs")] get;
|
|
[CCode (cname = "alpm_option_set_cachedirs")] set;
|
|
}
|
|
[CCode (cname = "alpm_option_add_cachedir")]
|
|
public int add_cachedir(string cachedir);
|
|
[CCode (cname = "alpm_option_remove_cachedir")]
|
|
public int remove_cachedir(string cachedir);
|
|
|
|
public unowned string logfile {
|
|
[CCode (cname = "alpm_option_get_logfile")] get;
|
|
[CCode (cname = "alpm_option_set_logfile")] set;
|
|
}
|
|
public unowned string lockfile {
|
|
[CCode (cname = "alpm_option_get_lockfile")] get;
|
|
}
|
|
public unowned string gpgdir {
|
|
[CCode (cname = "alpm_option_get_gpgdir")] get;
|
|
[CCode (cname = "alpm_option_set_gpgdir")] set;
|
|
}
|
|
public int usesyslog {
|
|
[CCode (cname = "alpm_option_get_usesyslog")] get;
|
|
/** Sets whether to use syslog (0 is FALSE, TRUE otherwise). */
|
|
[CCode (cname = "alpm_option_set_usesyslog")] set;
|
|
}
|
|
public unowned Alpm.List<unowned string?> noupgrades {
|
|
[CCode (cname = "alpm_option_get_noupgrades")] get;
|
|
[CCode (cname = "alpm_option_set_noupgrades")] set;
|
|
}
|
|
[CCode (cname = "alpm_option_add_noupgrade")]
|
|
public int add_noupgrade(string path);
|
|
[CCode (cname = "alpm_option_remove_noupgrade")]
|
|
public int remove_noupgrade(string path);
|
|
|
|
public unowned Alpm.List<unowned string?> noextracts {
|
|
[CCode (cname = "alpm_option_get_noextracts")] get;
|
|
[CCode (cname = "alpm_option_set_noextracts")] set;
|
|
}
|
|
[CCode (cname = "alpm_option_add_noextract")]
|
|
public int add_noextract(string path);
|
|
[CCode (cname = "alpm_option_remove_noextract")]
|
|
public int remove_noextract(string path);
|
|
[CCode (cname = "alpm_option_match_noextract")]
|
|
public int match_noextract(string path);
|
|
|
|
public unowned Alpm.List<unowned string?> ignorepkgs {
|
|
[CCode (cname = "alpm_option_get_ignorepkgs")] get;
|
|
[CCode (cname = "alpm_option_set_ignorepkgs")] set;
|
|
}
|
|
[CCode (cname = "alpm_option_add_ignorepkg")]
|
|
public int add_ignorepkg(string pkg);
|
|
[CCode (cname = "alpm_option_remove_ignorepkg")]
|
|
public int remove_ignorepkg(string pkg);
|
|
|
|
public unowned Alpm.List<unowned string?> ignoregroups {
|
|
[CCode (cname = "alpm_option_get_ignoregroups")] get;
|
|
[CCode (cname = "alpm_option_set_ignoregroups")] set;
|
|
}
|
|
[CCode (cname = "alpm_option_add_ignoregroup")]
|
|
public int add_ignoregroup(string grp);
|
|
[CCode (cname = "alpm_option_remove_ignorepkg")]
|
|
public int remove_ignoregroup(string grp);
|
|
|
|
public unowned Alpm.List<unowned Depend?> assumeinstalled {
|
|
[CCode (cname = "alpm_option_get_assumeinstalled")] get;
|
|
[CCode (cname = "alpm_option_set_assumeinstalled")] set;
|
|
}
|
|
[CCode (cname = "alpm_option_add_assumeinstalled")]
|
|
public int add_assumeinstalled(Depend dep);
|
|
[CCode (cname = "alpm_option_remove_assumeinstalled")]
|
|
public int remove_assumeinstalled(Depend dep);
|
|
|
|
public double deltaratio {
|
|
[CCode (cname = "alpm_option_get_deltaratio")] get;
|
|
[CCode (cname = "alpm_option_set_deltaratio")] set;
|
|
}
|
|
|
|
public int checkspace {
|
|
[CCode (cname = "alpm_option_get_checkspace")] get;
|
|
[CCode (cname = "alpm_option_set_checkspace")] set;
|
|
}
|
|
|
|
public Signature.Level defaultsiglevel {
|
|
[CCode (cname = "alpm_option_get_default_siglevel")] get;
|
|
[CCode (cname = "alpm_option_set_default_siglevel")] set;
|
|
}
|
|
public Signature.Level localfilesiglevel {
|
|
[CCode (cname = "alpm_option_get_local_file_siglevel")] get;
|
|
[CCode (cname = "alpm_option_set_local_file_siglevel")] set;
|
|
}
|
|
public Signature.Level remotefilesiglevel {
|
|
[CCode (cname = "alpm_option_get_remote_file_siglevel")] get;
|
|
[CCode (cname = "alpm_option_set_remote_file_siglevel")] set;
|
|
}
|
|
|
|
public unowned DB? localdb {
|
|
[CCode (cname = "alpm_get_localdb")] get;
|
|
}
|
|
public unowned Alpm.List<unowned DB?> syncdbs {
|
|
[CCode (cname = "alpm_get_syncdbs")] get;
|
|
}
|
|
|
|
public LogCallBack logcb {
|
|
[CCode (cname = "alpm_option_get_logcb")] get;
|
|
[CCode (cname = "alpm_option_set_logcb")] set;
|
|
}
|
|
public DownloadCallBack dlcb {
|
|
[CCode (cname = "alpm_option_get_dlcb")] get;
|
|
[CCode (cname = "alpm_option_set_dlcb")] set;
|
|
}
|
|
public FetchCallBack fetchcb {
|
|
[CCode (cname = "alpm_option_get_fetchcb")] get;
|
|
[CCode (cname = "alpm_option_set_fetchcb")] set;
|
|
}
|
|
public TotalDownloadCallBack totaldlcb {
|
|
[CCode (cname = "alpm_option_get_totaldlcb")] get;
|
|
[CCode (cname = "alpm_option_set_totaldlcb")] set;
|
|
}
|
|
public EventCallBack eventcb {
|
|
[CCode (cname = "alpm_option_get_eventcb")] get;
|
|
[CCode (cname = "alpm_option_set_eventcb")] set;
|
|
}
|
|
public QuestionCallBack questioncb {
|
|
[CCode (cname = "alpm_option_get_questioncb")] get;
|
|
[CCode (cname = "alpm_option_set_questioncb")] set;
|
|
}
|
|
public ProgressCallBack progresscb {
|
|
[CCode (cname = "alpm_option_get_progresscb")] get;
|
|
[CCode (cname = "alpm_option_set_progresscb")] set;
|
|
}
|
|
|
|
[CCode (cname = "alpm_register_syncdb")]
|
|
public unowned DB? register_syncdb(string treename, Signature.Level level);
|
|
[CCode (cname = "alpm_unregister_all_syncdbs")]
|
|
public int unregister_all_syncdbs();
|
|
|
|
// the return package can be freed except if it is added to a transaction,
|
|
// it will be freed upon Handle.trans_release() invocation.
|
|
[CCode (cname = "alpm_pkg_load_file")]
|
|
public Package? load_file(string filename, int full, Signature.Level level);
|
|
|
|
/** Test if a package should be ignored.
|
|
* Checks if the package is ignored via IgnorePkg, or if the package is
|
|
* in a group ignored via IgnoreGroup.
|
|
* @param pkg the package to test
|
|
* @return 1 if the package should be ignored, 0 otherwise
|
|
*/
|
|
[CCode (cname = "alpm_pkg_should_ignore")]
|
|
public int should_ignore(Package pkg);
|
|
|
|
[CCode (cname = "alpm_fetch_pkgurl")]
|
|
public string? fetch_pkgurl(string url);
|
|
|
|
[CCode (cname = "alpm_find_dbs_satisfier")]
|
|
public unowned Package? find_dbs_satisfier(Alpm.List<DB> dbs, string depstring);
|
|
|
|
/** Returns the current error code from the handle. */
|
|
[CCode (cname = "alpm_errno")]
|
|
public Errno errno();
|
|
|
|
/** Returns the bitfield of flags for the current transaction.*/
|
|
[CCode (cname = "alpm_trans_get_flags")]
|
|
public TransFlag trans_get_flags();
|
|
|
|
/** Returns a list of packages added by the transaction.*/
|
|
[CCode (cname = "alpm_trans_get_add")]
|
|
public unowned Alpm.List<unowned Package?> trans_to_add();
|
|
|
|
/** Returns the list of packages removed by the transaction.*/
|
|
[CCode (cname = "alpm_trans_get_remove")]
|
|
public unowned Alpm.List<unowned Package?> trans_to_remove();
|
|
|
|
/** Initialize the transaction.
|
|
* @param flags flags of the transaction (like nodeps, etc)
|
|
* @return 0 on success, -1 on error (Errno is set accordingly)
|
|
*/
|
|
[CCode (cname = "alpm_trans_init")]
|
|
public int trans_init(TransFlag transflags);
|
|
|
|
/** Prepare a transaction.
|
|
* @param an alpm_list where detailed description of an error
|
|
* can be dumped (i.e. list of conflicting packages)
|
|
* @return 0 on success, -1 on error (Errno is set accordingly)
|
|
*/
|
|
[CCode (cname = "alpm_trans_prepare")]
|
|
public int trans_prepare(out Alpm.List<void*> data);
|
|
|
|
/** Commit a transaction.
|
|
* @param an alpm_list where detailed description of an error
|
|
* can be dumped (i.e. list of conflicting files)
|
|
* @return 0 on success, -1 on error (Errno is set accordingly)
|
|
*/
|
|
[CCode (cname = "alpm_trans_commit")]
|
|
public int trans_commit(out Alpm.List<void*> data);
|
|
|
|
/** Interrupt a transaction.
|
|
* @return 0 on success, -1 on error (Errno is set accordingly)
|
|
*/
|
|
[CCode (cname = "alpm_trans_interrupt")]
|
|
public int trans_interrupt();
|
|
|
|
/** Release a transaction.
|
|
* @return 0 on success, -1 on error (Errno is set accordingly)
|
|
*/
|
|
[CCode (cname = "alpm_trans_release")]
|
|
public int trans_release();
|
|
|
|
/** Search for packages to upgrade and add them to the transaction.
|
|
* @param enable_downgrade allow downgrading of packages if the remote version is lower
|
|
* @return 0 on success, -1 on error (Errno is set accordingly)
|
|
*/
|
|
[CCode (cname = "alpm_sync_sysupgrade")]
|
|
public int trans_sysupgrade(int enable_downgrade);
|
|
|
|
/** Add a package to the transaction.
|
|
* If the package was loaded by load_file(), it will be freed upon
|
|
* trans_release() invocation.
|
|
* @param pkg the package to add
|
|
* @return 0 on success, -1 on error (Errno is set accordingly)
|
|
*/
|
|
[CCode (cname = "alpm_add_pkg")]
|
|
public int trans_add_pkg(Package pkg);
|
|
|
|
/** Add a package removal action to the transaction.
|
|
* @param pkg the package to uninstall
|
|
* @return 0 on success, -1 on error (Errno is set accordingly)
|
|
*/
|
|
[CCode (cname = "alpm_remove_pkg")]
|
|
public int trans_remove_pkg(Package pkg);
|
|
}
|
|
|
|
/**
|
|
* Databases
|
|
*/
|
|
[CCode (cname = "alpm_db_t", cprefix = "alpm_db_")]
|
|
[Compact]
|
|
public class DB {
|
|
public static int unregister(DB db);
|
|
|
|
public unowned string name {
|
|
[CCode (cname = "alpm_db_get_name")] get;
|
|
}
|
|
|
|
public Signature.Level siglevel {
|
|
[CCode (cname = "alpm_db_get_siglevel")] get;
|
|
}
|
|
|
|
public unowned Alpm.List<unowned string?> servers {
|
|
[CCode (cname = "alpm_db_get_servers")] get;
|
|
[CCode (cname = "alpm_db_set_servers")] set;
|
|
}
|
|
|
|
public unowned Alpm.List<unowned Package?> pkgcache {
|
|
[CCode (cname = "alpm_db_get_pkgcache")] get;
|
|
}
|
|
|
|
public unowned Alpm.List<unowned Group?> groupcache {
|
|
[CCode (cname = "alpm_db_get_groupcache")] get;
|
|
}
|
|
|
|
public Usage usage {
|
|
[CCode (cname = "alpm_db_get_usage")] get;
|
|
[CCode (cname = "alpm_db_set_usage")] set;
|
|
}
|
|
|
|
[CCode (cname = "alpm_db_usage_t", cprefix = "ALPM_DB_USAGE_")]
|
|
public enum Usage {
|
|
SYNC = 1,
|
|
SEARCH = (1 << 1),
|
|
INSTALL = (1 << 2),
|
|
UPGRADE = (1 << 3),
|
|
ALL = (1 << 4) - 1,
|
|
}
|
|
|
|
public int add_server(string url);
|
|
public int remove_server(string url);
|
|
|
|
[CCode (instance_pos = 1.1)]
|
|
public int update(int force);
|
|
|
|
public unowned Package? get_pkg(string name);
|
|
public unowned Group? get_group(string name);
|
|
public Alpm.List<unowned Package?> search(Alpm.List<string> needles);
|
|
|
|
public int check_pgp_signature(out SigList siglist);
|
|
}
|
|
|
|
/**
|
|
* Packages
|
|
*/
|
|
[CCode (cname = "alpm_pkg_t", cprefix = "alpm_pkg_")]
|
|
[Compact]
|
|
public class Package {
|
|
|
|
public static int free(Package pkg);
|
|
|
|
/* properties */
|
|
public unowned string filename {
|
|
[CCode (cname = "alpm_pkg_get_filename")] get;
|
|
}
|
|
public unowned string name {
|
|
[CCode (cname = "alpm_pkg_get_name")] get;
|
|
}
|
|
public unowned string version {
|
|
[CCode (cname = "alpm_pkg_get_version")] get;
|
|
}
|
|
public From origin {
|
|
[CCode (cname = "alpm_pkg_get_origin")] get;
|
|
}
|
|
public unowned string desc {
|
|
[CCode (cname = "alpm_pkg_get_desc")] get;
|
|
}
|
|
public unowned string url {
|
|
[CCode (cname = "alpm_pkg_get_url")] get;
|
|
}
|
|
public Time builddate {
|
|
[CCode (cname = "alpm_pkg_get_builddate")] get;
|
|
}
|
|
public Time installdate {
|
|
[CCode (cname = "alpm_pkg_get_installdate")] get;
|
|
}
|
|
public unowned string packager {
|
|
[CCode (cname = "alpm_pkg_get_packager")] get;
|
|
}
|
|
public unowned string md5sum {
|
|
[CCode (cname = "alpm_pkg_get_md5sum")] get;
|
|
}
|
|
public unowned string sha256sum {
|
|
[CCode (cname = "alpm_pkg_get_sha256sum")] get;
|
|
}
|
|
public unowned string arch {
|
|
[CCode (cname = "alpm_pkg_get_arch")] get;
|
|
}
|
|
|
|
/** Returns the size of the package. This is only available for sync database
|
|
* packages and package files, not those loaded from the local database.
|
|
*/
|
|
public uint64 size {
|
|
[CCode (cname = "alpm_pkg_get_size")] get;
|
|
}
|
|
|
|
public uint64 isize {
|
|
[CCode (cname = "alpm_pkg_get_isize")] get;
|
|
}
|
|
public uint64 download_size {
|
|
[CCode (cname = "alpm_pkg_download_size")] get;
|
|
}
|
|
public Reason reason {
|
|
[CCode (cname = "alpm_pkg_get_reason")] get;
|
|
/** This must be a Package from the local database
|
|
* or this method will fail (Errno is set accordingly).
|
|
*/
|
|
[CCode (cname = "alpm_pkg_set_reason")] set;
|
|
}
|
|
public unowned Alpm.List<unowned string?> licenses {
|
|
[CCode (cname = "alpm_pkg_get_licenses")] get;
|
|
}
|
|
public unowned Alpm.List<unowned string?> groups {
|
|
[CCode (cname = "alpm_pkg_get_groups")] get;
|
|
}
|
|
public unowned Alpm.List<unowned Depend?> depends {
|
|
[CCode (cname = "alpm_pkg_get_depends")] get;
|
|
}
|
|
public unowned Alpm.List<unowned Depend?> optdepends {
|
|
[CCode (cname = "alpm_pkg_get_optdepends")] get;
|
|
}
|
|
public unowned Alpm.List<unowned Depend?> conflicts {
|
|
[CCode (cname = "alpm_pkg_get_conflicts")] get;
|
|
}
|
|
public unowned Alpm.List<unowned Depend?> provides {
|
|
[CCode (cname = "alpm_pkg_get_provides")] get;
|
|
}
|
|
public unowned Alpm.List<unowned string?> deltas {
|
|
[CCode (cname = "alpm_pkg_get_deltas")] get;
|
|
}
|
|
public unowned Alpm.List<unowned Depend?> replaces {
|
|
[CCode (cname = "alpm_pkg_get_replaces")] get;
|
|
}
|
|
public unowned Alpm.List<unowned File?> files {
|
|
[CCode (cname = "alpm_pkg_get_files_list")] get;
|
|
}
|
|
public unowned Alpm.List<unowned string?> unused_deltas {
|
|
[CCode (cname = "alpm_pkg_unused_deltas")] get;
|
|
}
|
|
public unowned Alpm.List<unowned Backup?> backups {
|
|
[CCode (cname = "alpm_pkg_get_backup")] get;
|
|
}
|
|
public unowned DB? db {
|
|
[CCode (cname = "alpm_pkg_get_db")] get;
|
|
}
|
|
public unowned string base64_sig {
|
|
[CCode (cname = "alpm_pkg_get_base64_sig")] get;
|
|
}
|
|
public Validation validation {
|
|
[CCode (cname = "alpm_pkg_get_validation")] get;
|
|
}
|
|
// TODO: changelog functions
|
|
|
|
/** Package install reasons. */
|
|
[CCode (cname = "alpm_pkgreason_t", cprefix = "ALPM_PKG_REASON_")]
|
|
public enum Reason {
|
|
/** Explicitly requested by the user. */
|
|
EXPLICIT = 0,
|
|
/** Installed as a dependency for another package. */
|
|
DEPEND = 1
|
|
}
|
|
|
|
/** Location a package object was loaded from. */
|
|
[CCode (cname = "alpm_pkgfrom_t", cprefix = "ALPM_PKG_FROM_")]
|
|
public enum From {
|
|
FILE = 1,
|
|
LOCALDB,
|
|
SYNCDB
|
|
}
|
|
|
|
/** Method used to validate a package. */
|
|
[CCode (cname = "alpm_pkgvalidation_t", cprefix = "ALPM_PKG_VALIDATION_")]
|
|
public enum Validation {
|
|
UNKNOWN = 0,
|
|
NONE = (1 << 0),
|
|
MD5SUM = (1 << 1),
|
|
SHA256SUM = (1 << 2),
|
|
SIGNATURE = (1 << 3)
|
|
}
|
|
|
|
[CCode (cname = "alpm_package_operation_t", cprefix = "ALPM_PACKAGE_")]
|
|
public enum Operation {
|
|
/** Package (to be) installed. (No oldpkg) */
|
|
INSTALL = 1,
|
|
/** Package (to be) upgraded */
|
|
UPGRADE,
|
|
/** Package (to be) re-installed. */
|
|
REINSTALL,
|
|
/** Package (to be) downgraded. */
|
|
DOWNGRADE,
|
|
/** Package (to be) removed. (No newpkg) */
|
|
REMOVE
|
|
}
|
|
|
|
public int checkmd5sum();
|
|
public int has_scriptlet();
|
|
|
|
public Alpm.List<string?> compute_requiredby();
|
|
public Alpm.List<string?> compute_optionalfor();
|
|
|
|
[CCode (cname = "alpm_sync_newversion")]
|
|
public unowned Package? sync_newversion(Alpm.List<DB> dbs);
|
|
|
|
public int check_pgp_signature(out SigList siglist);
|
|
}
|
|
|
|
/** Dependency */
|
|
[CCode (cname = "alpm_depend_t", free_function = "alpm_dep_free")]
|
|
[Compact]
|
|
public class Depend {
|
|
public string name;
|
|
public string version;
|
|
public string desc;
|
|
public ulong name_hash;
|
|
public Mode mod;
|
|
|
|
public static Depend from_string(string depstring);
|
|
|
|
[CCode (cname = "alpm_dep_compute_string")]
|
|
public string compute_string();
|
|
|
|
/** Types of version constraints in dependency specs. */
|
|
[CCode (cname = "alpm_depmod_t", cprefix = "ALPM_DEP_MOD_")]
|
|
public enum Mode {
|
|
/** No version constraint */
|
|
ANY = 1,
|
|
/** Test version equality (package=x.y.z) */
|
|
EQ,
|
|
/** Test for at least a version (package>=x.y.z) */
|
|
GE,
|
|
/** Test for at most a version (package<=x.y.z) */
|
|
LE,
|
|
/** Test for greater than some version (package>x.y.z) */
|
|
GT,
|
|
/** Test for less than some version (package<x.y.z) */
|
|
LT
|
|
}
|
|
}
|
|
|
|
/** Missing dependency */
|
|
[CCode (cname = "alpm_depmissing_t", free_function = "alpm_depmissing_free")]
|
|
[Compact]
|
|
public class DepMissing {
|
|
public string target;
|
|
public unowned Depend depend;
|
|
// this is used only in the case of a remove dependency error
|
|
public string causingpkg;
|
|
}
|
|
|
|
/** Conflict */
|
|
[CCode (cname = "alpm_conflict_t", free_function = "alpm_conflict_free")]
|
|
[Compact]
|
|
public class Conflict {
|
|
public ulong package1_hash;
|
|
public ulong package2_hash;
|
|
public string package1;
|
|
public string package2;
|
|
public unowned Depend reason;
|
|
}
|
|
|
|
/** File conflict */
|
|
[CCode (cname = "alpm_fileconflict_t", free_function = "alpm_fileconflict_free")]
|
|
[Compact]
|
|
public class FileConflict {
|
|
public string target;
|
|
public Type type;
|
|
public string file;
|
|
public string ctarget;
|
|
/**
|
|
* File conflict type.
|
|
* Whether the conflict results from a file existing on the filesystem, or with
|
|
* another target in the transaction.
|
|
*/
|
|
[CCode (cname = "alpm_fileconflicttype_t", cprefix = "ALPM_FILECONFLICT_")]
|
|
public enum Type {
|
|
TARGET = 1,
|
|
FILESYSTEM
|
|
}
|
|
}
|
|
|
|
/** Package group */
|
|
[CCode (cname = "alpm_group_t", has_type_id = false)]
|
|
public class Group {
|
|
public string name;
|
|
public unowned Alpm.List<unowned Package?> packages;
|
|
}
|
|
|
|
/** Package upgrade delta */
|
|
[CCode (cname = "alpm_delta_t", has_type_id = false)]
|
|
public class Delta {
|
|
/** filename of the delta patch */
|
|
public string delta;
|
|
/** md5sum of the delta file */
|
|
public string delta_md5;
|
|
/** filename of the 'before' file */
|
|
public string from;
|
|
/** filename of the 'after' file */
|
|
public string to;
|
|
/** filesize of the delta file */
|
|
public uint64 delta_size;
|
|
/** download filesize of the delta file */
|
|
public uint64 download_size;
|
|
}
|
|
|
|
/** File in a package */
|
|
[CCode (cname = "alpm_file_t", has_type_id = false)]
|
|
public class File {
|
|
public string name;
|
|
public uint64 size;
|
|
public uint64 mode;
|
|
}
|
|
|
|
/** Package filelist container */
|
|
[CCode (cname = "alpm_filelist_t", has_type_id = false)]
|
|
public class FileList {
|
|
public size_t count;
|
|
[CCode (array_length_cname = "count", array_length_type = "size_t")]
|
|
public unowned Alpm.File[] files;
|
|
/** Determines whether a package filelist contains a given path.
|
|
* The provided path should be relative to the install root with no leading
|
|
* slashes, e.g. "etc/localtime". When searching for directories, the path must
|
|
* have a trailing slash.
|
|
* @param path the path to search for in the package
|
|
* @return a pointer to the matching file or NULL if not found
|
|
*/
|
|
[CCode (cname = "alpm_filelist_contains")]
|
|
unowned Alpm.File? contains(string path);
|
|
}
|
|
|
|
/** Local package or package file backup entry */
|
|
[CCode (cname = "alpm_backup_t", has_type_id = false)]
|
|
public class Backup {
|
|
public string name;
|
|
public string hash;
|
|
}
|
|
|
|
namespace Signature {
|
|
[CCode (cname = "alpm_pgpkey_t", has_type_id = false)]
|
|
public class PGPKey {
|
|
public void *data;
|
|
public string fingerprint;
|
|
public string uid;
|
|
public string name;
|
|
public string email;
|
|
public Time created;
|
|
public Time expires;
|
|
public uint length;
|
|
public uint revoked;
|
|
public string pubkey_algo;
|
|
}
|
|
|
|
/**
|
|
* Signature result. Contains the key, status, and validity of a given
|
|
* signature.
|
|
*/
|
|
[CCode (cname = "alpm_sigresult_t", has_type_id = false)]
|
|
public class Result {
|
|
public PGPKey key;
|
|
public Status status;
|
|
public Validity validity;
|
|
}
|
|
|
|
/** PGP signature verification options */
|
|
[CCode (cname = "alpm_siglevel_t", cprefix = "ALPM_SIG_")]
|
|
public enum Level {
|
|
PACKAGE = (1 << 0),
|
|
PACKAGE_OPTIONAL = (1 << 1),
|
|
PACKAGE_MARGINAL_OK = (1 << 2),
|
|
PACKAGE_UNKNOWN_OK = (1 << 3),
|
|
|
|
DATABASE = (1 << 10),
|
|
DATABASE_OPTIONAL = (1 << 11),
|
|
DATABASE_MARGINAL_OK = (1 << 12),
|
|
DATABASE_UNKNOWN_OK = (1 << 13),
|
|
|
|
PACKAGE_SET = (1 << 27),
|
|
PACKAGE_TRUST_SET = (1 << 28),
|
|
|
|
USE_DEFAULT = (1 << 31)
|
|
}
|
|
|
|
/** PGP signature verification status return codes */
|
|
[CCode (cname = "alpm_sigstatus_t", cprefix = "ALPM_SIGSTATUS_")]
|
|
public enum Status {
|
|
VALID,
|
|
KEY_EXPIRED,
|
|
SIG_EXPIRED,
|
|
KEY_UNKNOWN,
|
|
KEY_DISABLED,
|
|
INVALID
|
|
}
|
|
|
|
/** PGP signature verification status return codes */
|
|
[CCode (cname = "alpm_sigvalidity_t", cprefix = "ALPM_SIGVALIDITY_")]
|
|
public enum Validity {
|
|
FULL,
|
|
MARGINAL,
|
|
NEVER,
|
|
UNKNOWN
|
|
}
|
|
}
|
|
|
|
[CCode (cname = "alpm_siglist_t", free_function = "alpm_siglist_cleanup")]
|
|
[Compact]
|
|
public class SigList {
|
|
public size_t count;
|
|
[CCode (array_length_cname = "count", array_length_type = "size_t")]
|
|
public unowned Signature.Result[] results;
|
|
}
|
|
|
|
/** Logging Levels */
|
|
[CCode (cname = "alpm_loglevel_t", cprefix = "ALPM_LOG_")]
|
|
public enum LogLevel {
|
|
ERROR = 1,
|
|
WARNING = (1 << 1),
|
|
DEBUG = (1 << 2),
|
|
FUNCTION = (1 << 3)
|
|
}
|
|
|
|
/** Log callback */
|
|
[CCode (cname = "alpm_cb_log", has_type_id = false, has_target = false)]
|
|
public delegate void LogCallBack(LogLevel level, string fmt, va_list args);
|
|
|
|
namespace Event {
|
|
/**
|
|
* Type of events.
|
|
*/
|
|
[CCode (cname = "alpm_event_type_t", cprefix = "ALPM_EVENT_")]
|
|
public enum Type {
|
|
/** Dependencies will be computed for a package. */
|
|
CHECKDEPS_START = 1,
|
|
/** Dependencies were computed for a package. */
|
|
CHECKDEPS_DONE,
|
|
/** File conflicts will be computed for a package. */
|
|
FILECONFLICTS_START,
|
|
/** File conflicts were computed for a package. */
|
|
FILECONFLICTS_DONE,
|
|
/** Dependencies will be resolved for target package. */
|
|
RESOLVEDEPS_START,
|
|
/** Dependencies were resolved for target package. */
|
|
RESOLVEDEPS_DONE,
|
|
/** Inter-conflicts will be checked for target package. */
|
|
INTERCONFLICTS_START,
|
|
/** Inter-conflicts were checked for target package. */
|
|
INTERCONFLICTS_DONE,
|
|
/** Package will be installed/upgraded/downgraded/re-installed/removed; See
|
|
* PackageOperation for arguments. */
|
|
PACKAGE_OPERATION_START,
|
|
/** Package was installed/upgraded/downgraded/re-installed/removed; See
|
|
* PackageOperation for arguments. */
|
|
PACKAGE_OPERATION_DONE,
|
|
/** Target package's integrity will be checked. */
|
|
INTEGRITY_START,
|
|
/** Target package's integrity was checked. */
|
|
INTEGRITY_DONE,
|
|
/** Target package will be loaded. */
|
|
LOAD_START,
|
|
/** Target package is finished loading. */
|
|
LOAD_DONE,
|
|
/** Target delta's integrity will be checked. */
|
|
DELTA_INTEGRITY_START,
|
|
/** Target delta's integrity was checked. */
|
|
DELTA_INTEGRITY_DONE,
|
|
/** Deltas will be applied to packages. */
|
|
DELTA_PATCHES_START,
|
|
/** Deltas were applied to packages. */
|
|
DELTA_PATCHES_DONE,
|
|
/** Delta patch will be applied to target package; See
|
|
* DeltaPatch for arguments. */
|
|
DELTA_PATCH_START,
|
|
/** Delta patch was applied to target package. */
|
|
DELTA_PATCH_DONE,
|
|
/** Delta patch failed to apply to target package. */
|
|
DELTA_PATCH_FAILED,
|
|
/** Scriptlet has printed information; See ScriptletInfo for
|
|
* arguments. */
|
|
SCRIPTLET_INFO,
|
|
/** Files will be downloaded from a repository. */
|
|
RETRIEVE_START,
|
|
/** Files were downloaded from a repository. */
|
|
RETRIEVE_DONE,
|
|
/** Not all files were successfully downloaded from a repository. */
|
|
RETRIEVE_FAILED,
|
|
/** A file will be downloaded from a repository; See PkgDownload
|
|
* for arguments */
|
|
PKGDOWNLOAD_START,
|
|
/** A file was downloaded from a repository; See PkgDownload
|
|
* for arguments */
|
|
PKGDOWNLOAD_DONE,
|
|
/** A file failed to be downloaded from a repository; See
|
|
* PkgDownload for arguments */
|
|
PKGDOWNLOAD_FAILED,
|
|
/** Disk space usage will be computed for a package. */
|
|
DISKSPACE_START,
|
|
/** Disk space usage was computed for a package. */
|
|
DISKSPACE_DONE,
|
|
/** An optdepend for another package is being removed; See
|
|
* OptDepRemoval for arguments. */
|
|
OPTDEP_REMOVAL,
|
|
/** A configured repository database is missing; See
|
|
* DatabaseMissing for arguments. */
|
|
DATABASE_MISSING,
|
|
/** Checking keys used to create signatures are in keyring. */
|
|
KEYRING_START,
|
|
/** Keyring checking is finished. */
|
|
KEYRING_DONE,
|
|
/** Downloading missing keys into keyring. */
|
|
KEY_DOWNLOAD_START,
|
|
/** Key downloading is finished. */
|
|
KEY_DOWNLOAD_DONE,
|
|
/** A .pacnew file was created; See PacnewCreated for arguments. */
|
|
PACNEW_CREATED,
|
|
/** A .pacsave file was created; See PacsaveCreated for
|
|
* arguments */
|
|
PACSAVE_CREATED,
|
|
/** A .pacorig file was created; See PacorigCreated for
|
|
* arguments */
|
|
PACORIG_CREATED
|
|
}
|
|
|
|
[CCode (cname = "alpm_event_any_t", has_type_id = false)]
|
|
public class Any {
|
|
/** Type of event. */
|
|
public Type type;
|
|
}
|
|
|
|
[CCode (cname = "alpm_event_package_operation_t", has_type_id = false)]
|
|
public class PackageOperation {
|
|
/** Type of event. */
|
|
public Type type;
|
|
/** Type of operation. */
|
|
public Package.Operation operation;
|
|
/** Old package. */
|
|
public unowned Package oldpkg;
|
|
/** New package. */
|
|
public unowned Package newpkg;
|
|
}
|
|
|
|
[CCode (cname = "alpm_event_optdep_removal_t", has_type_id = false)]
|
|
public class OptDepRemoval {
|
|
/** Type of event. */
|
|
public Type type;
|
|
/** Package with the optdep. */
|
|
public unowned Package pkg;
|
|
/** Optdep being removed. */
|
|
public unowned Depend optdep;
|
|
}
|
|
|
|
[CCode (cname = "alpm_event_delta_patch_t", has_type_id = false)]
|
|
public class DeltaPatch {
|
|
/** Type of event. */
|
|
public Type type;
|
|
/** Delta info */
|
|
public Delta delta;
|
|
}
|
|
|
|
[CCode (cname = "alpm_event_scriptlet_info_t", has_type_id = false)]
|
|
public class ScriptletInfo {
|
|
/** Type of event. */
|
|
public Type type;
|
|
/** Line of scriptlet output. */
|
|
public unowned string line;
|
|
}
|
|
|
|
[CCode (cname = "alpm_event_database_missing_t", has_type_id = false)]
|
|
public class DatabaseMissing {
|
|
/** Type of event. */
|
|
public Type type;
|
|
/** Name of the database. */
|
|
public unowned string dbname;
|
|
}
|
|
|
|
[CCode (cname = "alpm_event_pkgdownload_t", has_type_id = false)]
|
|
public class PkgDownload {
|
|
/** Type of event. */
|
|
public Type type;
|
|
/** Name of the file */
|
|
public unowned string file;
|
|
}
|
|
|
|
[CCode (cname = "alpm_event_pacnew_created_t", has_type_id = false)]
|
|
public class PacnewCreated {
|
|
/** Type of event. */
|
|
public Type type;
|
|
/** Whether the creation was result of a NoUpgrade or not */
|
|
public int from_noupgrade;
|
|
/** Old package. */
|
|
public unowned Package oldpkg;
|
|
/** New Package. */
|
|
public unowned Package newpkg;
|
|
/** Filename of the file without the .pacnew suffix */
|
|
public unowned string file;
|
|
}
|
|
|
|
[CCode (cname = "alpm_event_pacsave_created_t", has_type_id = false)]
|
|
public class PacsaveCreated {
|
|
/** Type of event. */
|
|
public Type type;
|
|
/** Old package. */
|
|
public unowned Package oldpkg;
|
|
/** Filename of the file without the .pacsave suffix. */
|
|
public unowned string file;
|
|
}
|
|
|
|
[CCode (cname = "alpm_event_pacorig_created_t", has_type_id = false)]
|
|
public class PacorigCreated {
|
|
/** Type of event. */
|
|
public Type type;
|
|
/** New package. */
|
|
public unowned Package newpkg;
|
|
/** Filename of the file without the .pacorig suffix. */
|
|
public unowned string file;
|
|
}
|
|
|
|
/** This is an union passed to the callback, that allows the frontend to know
|
|
* which type of event was triggered (via type). It is then possible to
|
|
* typecast the pointer to the right structure, or use the union field, in order
|
|
* to access event-specific data. */
|
|
[CCode (cname = "alpm_event_t", has_type_id = false)]
|
|
public class Data {
|
|
/** Type of event. */
|
|
public Type type;
|
|
// PackageOperation package_operation;
|
|
[CCode (cname = "package_operation.operation")]
|
|
public Package.Operation package_operation_operation;
|
|
[CCode (cname = "package_operation.oldpkg")]
|
|
public unowned Package package_operation_oldpkg;
|
|
[CCode (cname = "package_operation.newpkg")]
|
|
public unowned Package package_operation_newpkg;
|
|
// OptDepRemoval optdep_removal;
|
|
[CCode (cname = "optdep_removal.pkg")]
|
|
public unowned Package optdep_removal_pkg;
|
|
[CCode (cname = "optdep_removal.optdep")]
|
|
public unowned Depend optdep_removal_optdep;
|
|
// DeltaPatch delta_patch;
|
|
[CCode (cname = "delta_patch.delta")]
|
|
public Delta delta_patch_delta;
|
|
// ScriptletInfo scriptlet_info;
|
|
[CCode (cname = "scriptlet_info.line")]
|
|
public unowned string scriptlet_info_line;
|
|
// DatabaseMissing database_missing;
|
|
[CCode (cname = "database_missing.dbname")]
|
|
public unowned string database_missing_dbname;
|
|
// PkgDownload pkgdownload;
|
|
[CCode (cname = "pkgdownload.file")]
|
|
public unowned string pkgdownload_file;
|
|
// PacnewCreated pacnew_created;
|
|
[CCode (cname = "pacnew_created.from_noupgrade")]
|
|
public int pacnew_created_from_noupgrade;
|
|
[CCode (cname = "pacnew_created.oldpkg")]
|
|
public unowned Package pacnew_created_oldpkg;
|
|
[CCode (cname = "pacnew_created.newpkg")]
|
|
public unowned Package pacnew_created_newpkg;
|
|
[CCode (cname = "pacnew_created.file")]
|
|
public unowned string pacnew_created_file;
|
|
// PacsaveCreated pacsave_created;
|
|
[CCode (cname = "pacsave_created.oldpkg")]
|
|
public unowned Package pacsave_created_oldpkg;
|
|
[CCode (cname = "pacsave_created.file")]
|
|
public unowned string pacsave_created_file;
|
|
// PacorigCreated pacorig_created;
|
|
[CCode (cname = "pacorig_created.newpkg")]
|
|
public unowned Package pacorig_created_newpkg;
|
|
[CCode (cname = "pacorig_created.file")]
|
|
public unowned string pacorig_created_file;
|
|
}
|
|
}
|
|
|
|
/** Event callback */
|
|
[CCode (cname = "alpm_cb_event", has_type_id = false, has_target = false)]
|
|
public delegate void EventCallBack (Event.Data data);
|
|
|
|
namespace Question {
|
|
/**
|
|
* Type of questions.
|
|
* Unlike the events or progress enumerations, this enum has bitmask values
|
|
* so a frontend can use a bitmask map to supply preselected answers to the
|
|
* different types of questions.
|
|
*/
|
|
[CCode (cname = "alpm_question_type_t", cprefix = "ALPM_QUESTION_")]
|
|
public enum Type {
|
|
INSTALL_IGNOREPKG = (1 << 0),
|
|
REPLACE_PKG = (1 << 1),
|
|
CONFLICT_PKG = (1 << 2),
|
|
CORRUPTED_PKG = (1 << 3),
|
|
REMOVE_PKGS = (1 << 4),
|
|
SELECT_PROVIDER = (1 << 5),
|
|
IMPORT_KEY = (1 << 6)
|
|
}
|
|
|
|
[CCode (cname = "alpm_question_any_t", has_type_id = false)]
|
|
public class Any {
|
|
/** Type of question. */
|
|
public Type type;
|
|
/** Answer. */
|
|
public int answer;
|
|
}
|
|
|
|
[CCode (cname = "alpm_question_install_ignorepkg_t", has_type_id = false)]
|
|
public class InstallIgnorePkg {
|
|
/** Type of question. */
|
|
public Type type;
|
|
/** Answer: whether or not to install pkg anyway. */
|
|
public int install;
|
|
// Package in IgnorePkg/IgnoreGroup.
|
|
public unowned Package pkg;
|
|
}
|
|
|
|
[CCode (cname = "alpm_question_replace_t", has_type_id = false)]
|
|
public class Replace {
|
|
/** Type of question. */
|
|
public Type type;
|
|
/** Answer: whether or not to replace oldpkg with newpkg. */
|
|
public int replace;
|
|
// Package to be replaced.
|
|
public unowned Package oldpkg;
|
|
// Package to replace with. */
|
|
public unowned Package newpkg;
|
|
// DB of newpkg
|
|
public unowned DB newdb;
|
|
}
|
|
|
|
[CCode (cname = "alpm_question_conflict_t", has_type_id = false)]
|
|
public class Conflict {
|
|
/** Type of question. */
|
|
public Type type;
|
|
/** Answer: whether or not to remove conflict->package2. */
|
|
public int remove;
|
|
/** Conflict info. */
|
|
public Alpm.Conflict conflict;
|
|
}
|
|
|
|
[CCode (cname = "alpm_question_corrupted_t", has_type_id = false)]
|
|
public class Corrupted {
|
|
/** Type of question. */
|
|
public Type type;
|
|
/** Answer: whether or not to remove filepath. */
|
|
public int remove;
|
|
/** Filename to remove */
|
|
public unowned string filepath;
|
|
/** Error code indicating the reason for package invalidity */
|
|
public Errno reason;
|
|
}
|
|
|
|
[CCode (cname = "alpm_question_remove_pkgs_t", has_type_id = false)]
|
|
public class RemovePkgs {
|
|
/** Type of question. */
|
|
public Type type;
|
|
/** Answer: whether or not to skip packages. */
|
|
public int skip;
|
|
/** List of alpm_pkg_t* with unresolved dependencies. */
|
|
public unowned Alpm.List<unowned Package?> packages;
|
|
}
|
|
|
|
[CCode (cname = "alpm_question_select_provider_t", has_type_id = false)]
|
|
public class SelectProvider {
|
|
/** Type of question. */
|
|
public Type type;
|
|
/** Answer: which provider to use (index from providers). */
|
|
public int use_index;
|
|
/** List of alpm_pkg_t* as possible providers. */
|
|
public unowned Alpm.List<Package?> providers;
|
|
/** What providers provide for. */
|
|
public unowned Depend depend;
|
|
}
|
|
|
|
[CCode (cname = "alpm_question_import_key_t", has_type_id = false)]
|
|
public class ImportKey {
|
|
/** Type of question. */
|
|
public Type type;
|
|
/** Answer: whether or not to import key. */
|
|
public int import;
|
|
/** The key to import. */
|
|
public Signature.PGPKey key;
|
|
}
|
|
|
|
/** This is an union passed to the callback, that allows the frontend to know
|
|
* which type of question was triggered (via type). It is then possible to
|
|
* typecast the pointer to the right structure, or use the union field, in order
|
|
* to access question-specific data. */
|
|
[CCode (cname = "alpm_question_t", has_type_id = false)]
|
|
public class Data {
|
|
public Type type;
|
|
// Any any;
|
|
[CCode (cname = "any.answer")]
|
|
public int any_answer;
|
|
// InstallIgnorePkg install_ignorepkg;
|
|
[CCode (cname = "install_ignorepkg.install")]
|
|
public int install_ignorepkg_install;
|
|
[CCode (cname = "install_ignorepkg.pkg")]
|
|
public unowned Package install_ignorepkg_pkg;
|
|
// Replace replace;
|
|
[CCode (cname = "replace.replace")]
|
|
public int replace_replace;
|
|
[CCode (cname = "replace.oldpkg")]
|
|
public unowned Package replace_oldpkg;
|
|
[CCode (cname = "replace.newpkg")]
|
|
public unowned Package replace_newpkg;
|
|
[CCode (cname = "replace.newdb")]
|
|
public unowned DB replace_newdb;
|
|
// Conflict conflict;
|
|
[CCode (cname = "conflict.remove")]
|
|
public int conflict_remove;
|
|
[CCode (cname = "conflict.conflict")]
|
|
public Alpm.Conflict conflict_conflict;
|
|
// Corrupted corrupted;
|
|
[CCode (cname = "corrupted.remove")]
|
|
public int corrupted_remove;
|
|
[CCode (cname = "corrupted.filepath")]
|
|
public unowned string corrupted_filepath;
|
|
[CCode (cname = "corrupted.reason")]
|
|
public Errno corrupted_reason;
|
|
// RemovePkgs remove_pkgs;
|
|
[CCode (cname = "remove_pkgs.skip")]
|
|
public int remove_pkgs_skip;
|
|
[CCode (cname = "remove_pkgs.packages")]
|
|
public unowned Alpm.List<unowned Package?> remove_pkgs_packages;
|
|
// SelectProvider select_provider;
|
|
[CCode (cname = "select_provider.use_index")]
|
|
public int select_provider_use_index;
|
|
[CCode (cname = "select_provider.providers")]
|
|
public unowned Alpm.List<Package?> select_provider_providers;
|
|
[CCode (cname = "select_provider.depend")]
|
|
public unowned Depend select_provider_depend;
|
|
// ImportKey import_key;
|
|
[CCode (cname = "import_key.import")]
|
|
public int import_key_import;
|
|
[CCode (cname = "import_key.key")]
|
|
public Signature.PGPKey import_key_key;
|
|
}
|
|
}
|
|
|
|
/** Question callback */
|
|
[CCode (cname = "alpm_cb_question", has_type_id = false, has_target = false)]
|
|
public delegate void QuestionCallBack (Question.Data data);
|
|
|
|
/** Progress */
|
|
[CCode (cname = "alpm_progress_t", cprefix = "ALPM_PROGRESS_")]
|
|
public enum Progress {
|
|
ADD_START,
|
|
UPGRADE_START,
|
|
DOWNGRADE_START,
|
|
REINSTALL_START,
|
|
REMOVE_START,
|
|
CONFLICTS_START,
|
|
DISKSPACE_START,
|
|
INTEGRITY_START,
|
|
LOAD_START,
|
|
KEYRING_START
|
|
}
|
|
|
|
/** Progress callback */
|
|
[CCode (cname = "alpm_cb_progress", has_type_id = false, has_target = false)]
|
|
public delegate void ProgressCallBack (Progress progress, string pkgname, int percent, uint n_targets, uint current_target);
|
|
|
|
/** Type of download progress callbacks.
|
|
* @param filename the name of the file being downloaded
|
|
* @param xfered the number of transferred bytes
|
|
* @param total the total number of bytes to transfer
|
|
*/
|
|
[CCode (cname = "alpm_cb_download", has_type_id = false, has_target = false)]
|
|
public delegate void DownloadCallBack (string filename, uint64 xfered, uint64 total);
|
|
|
|
[CCode (cname = "alpm_cb_totaldl", has_type_id = false, has_target = false)]
|
|
public delegate void TotalDownloadCallBack (uint64 total);
|
|
|
|
/** A callback for downloading files
|
|
* @param url the URL of the file to be downloaded
|
|
* @param localpath the directory to which the file should be downloaded
|
|
* @param force whether to force an update, even if the file is the same
|
|
* @return 0 on success, 1 if the file exists and is identical, -1 on
|
|
* error.
|
|
*/
|
|
[CCode (cname = "alpm_cb_fetch", has_type_id = false, has_target = false)]
|
|
public delegate int FetchCallBack (string url, string localpath, int force);
|
|
|
|
/** Transaction flags */
|
|
[CCode (cname = "alpm_transflag_t", cprefix = "ALPM_TRANS_FLAG_")]
|
|
public enum TransFlag {
|
|
/** Ignore dependency checks. */
|
|
NODEPS = 1,
|
|
/** Ignore file conflicts and overwrite files. */
|
|
FORCE = (1 << 1),
|
|
/** Delete files even if they are tagged as backup. */
|
|
NOSAVE = (1 << 2),
|
|
/** Ignore version numbers when checking dependencies. */
|
|
NODEPVERSION = (1 << 3),
|
|
/** Remove also any packages depending on a package being removed. */
|
|
CASCADE = (1 << 4),
|
|
/** Remove packages and their unneeded deps (not explicitly installed). */
|
|
RECURSE = (1 << 5),
|
|
/** Modify database but do not commit changes to the filesystem. */
|
|
DBONLY = (1 << 6),
|
|
/** Use ALPM_PKG_REASON_DEPEND when installing packages. */
|
|
ALLDEPS = (1 << 8),
|
|
/** Only download packages and do not actually install. */
|
|
DOWNLOADONLY = (1 << 9),
|
|
/** Do not execute install scriptlets after installing. */
|
|
NOSCRIPTLET = (1 << 10),
|
|
/** Ignore dependency conflicts. */
|
|
NOCONFLICTS = (1 << 11),
|
|
/** Do not install a package if it is already installed and up to date. */
|
|
NEEDED = (1 << 13),
|
|
/** Use ALPM_PKG_REASON_EXPLICIT when installing packages. */
|
|
ALLEXPLICIT = (1 << 14),
|
|
/** Do not remove a package if it is needed by another one. */
|
|
UNNEEDED = (1 << 15),
|
|
/** Remove also explicitly installed unneeded deps (use with ALPM_TRANS_FLAG_RECURSE). */
|
|
RECURSEALL = (1 << 16),
|
|
/** Do not lock the database during the operation. */
|
|
NOLOCK = (1 << 17)
|
|
}
|
|
|
|
/**
|
|
* Errnos
|
|
*/
|
|
[CCode (cname = "alpm_errno_t", cprefix = "ALPM_ERR_")]
|
|
public enum Errno {
|
|
MEMORY = 1,
|
|
SYSTEM,
|
|
BADPERMS,
|
|
NOT_A_FILE,
|
|
NOT_A_DIR,
|
|
WRONG_ARGS,
|
|
DISK_SPACE,
|
|
/* Interface */
|
|
HANDLE_NULL,
|
|
HANDLE_NOT_NULL,
|
|
HANDLE_LOCK,
|
|
/* Databases */
|
|
DB_OPEN,
|
|
DB_CREATE,
|
|
DB_NULL,
|
|
DB_NOT_NULL,
|
|
DB_NOT_FOUND,
|
|
DB_INVALID,
|
|
DB_INVALID_SIG,
|
|
DB_VERSION,
|
|
DB_WRITE,
|
|
DB_REMOVE,
|
|
/* Servers */
|
|
SERVER_BAD_URL,
|
|
SERVER_NONE,
|
|
/* Transactions */
|
|
TRANS_NOT_NULL,
|
|
TRANS_NULL,
|
|
TRANS_DUP_TARGET,
|
|
TRANS_NOT_INITIALIZED,
|
|
TRANS_NOT_PREPARED,
|
|
TRANS_ABORT,
|
|
TRANS_TYPE,
|
|
TRANS_NOT_LOCKED,
|
|
/* Packages */
|
|
PKG_NOT_FOUND,
|
|
PKG_IGNORED,
|
|
PKG_INVALID,
|
|
PKG_INVALID_CHECKSUM,
|
|
PKG_INVALID_SIG,
|
|
PKG_MISSING_SIG,
|
|
PKG_OPEN,
|
|
PKG_CANT_REMOVE,
|
|
PKG_INVALID_NAME,
|
|
PKG_INVALID_ARCH,
|
|
PKG_REPO_NOT_FOUND,
|
|
/* Signatures */
|
|
SIG_MISSING,
|
|
SIG_INVALID,
|
|
/* Deltas */
|
|
DLT_INVALID,
|
|
DLT_PATCHFAILED,
|
|
/* Dependencies */
|
|
UNSATISFIED_DEPS,
|
|
CONFLICTING_DEPS,
|
|
FILE_CONFLICTS,
|
|
/* Misc */
|
|
RETRIEVE,
|
|
INVALID_REGEX,
|
|
/* External library errors */
|
|
LIBARCHIVE,
|
|
LIBCURL,
|
|
EXTERNAL_DOWNLOAD,
|
|
GPGME
|
|
}
|
|
|
|
[CCode (cname = "alpm_list_t", cprefix = "alpm_list_", cheader_filename = "alpm_list.h,alpm-util.h",
|
|
free_function = "alpm_list_free")]
|
|
[Compact]
|
|
public class List<G> {
|
|
|
|
[CCode (cname = "alpm_list_new")]
|
|
public List ();
|
|
|
|
public static void free_all(List list);
|
|
|
|
/* Comparator*/
|
|
[CCode (cname = "alpm_list_fn_cmp", has_target = false)]
|
|
public delegate int CompareFunc<G>(G a, G b);
|
|
|
|
/* properties */
|
|
public size_t length {
|
|
[CCode (cname = "alpm_list_count")] get;
|
|
}
|
|
public unowned G? data {
|
|
[CCode (cname = "alpm_list_get_data")] get;
|
|
}
|
|
|
|
/* item mutators */
|
|
[ReturnsModifiedPointer ()]
|
|
public unowned void add(G data);
|
|
|
|
[ReturnsModifiedPointer ()]
|
|
public unowned void add_str(string str);
|
|
|
|
[ReturnsModifiedPointer ()]
|
|
public unowned void join(List<G> list);
|
|
|
|
[CCode (cname = "alpm_list_sort_data"), ReturnsModifiedPointer ()]
|
|
public unowned void sort(CompareFunc fn);
|
|
|
|
[CCode (cname = "alpm_list_remove_data"), ReturnsModifiedPointer ()]
|
|
public unowned void? remove(G data, CompareFunc fn);
|
|
|
|
public List<G> copy();
|
|
public List<G> copy_data();
|
|
|
|
[ReturnsModifiedPointer ()]
|
|
public unowned void reverse ();
|
|
|
|
/* item accessors */
|
|
public unowned List<G>? first();
|
|
public unowned List<G>? last();
|
|
public unowned List<G>? nth(size_t index);
|
|
public unowned List<G>? next();
|
|
public unowned List<G>? previous();
|
|
|
|
public unowned G? nth_data(size_t index);
|
|
|
|
/* misc */
|
|
public unowned string? find_str(string needle);
|
|
|
|
/** @return a list containing all items in `this` not present in `list` */
|
|
public unowned List<G>? diff(List<G>? list, CompareFunc fn);
|
|
|
|
/* iterator */
|
|
public Iterator<G> iterator();
|
|
|
|
[CCode (cname = "alpm_list_iterator_t", cprefix = "alpm_list_iterator_")]
|
|
public struct Iterator<G> {
|
|
public unowned G? next_value();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* vim: set ts=2 sw=2 noet: */
|