moparisthebest
/
pacman
mirror of https://github.com/moparisthebest/pacman
1
0
Fork 0
Code Issues Releases Wiki Activity

Represent bitfields as ints, not enums 

Many bitfield variables are declared to be enums, because they are
generated using bitwise operations on enums such. However, their
actual values aren't necessary members of their parent enum, so
declaring them 'int' is more accurate.

Signed-off-by: Ivy Foster <ivy.foster@gmail.com>
Signed-off-by: Allan McRae <allan@archlinux.org>
This commit is contained in:
Ivy Foster 2016-10-12 15:13:32 -05:00 committed by Allan McRae
parent a55adb81d0
commit fa06951d90
24 changed files with 122 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/libalpm/alpm.c
View File

@ -152,7 +152,7 @@ const char SYMEXPORT *alpm_version(void)
/** Get the capabilities of the library.
* @return a bitmask of the capabilities
* */
enum alpm_caps SYMEXPORT alpm_capabilities(void)
int SYMEXPORT alpm_capabilities(void)
{
return 0
#ifdef ENABLE_NLS

33
lib/libalpm/alpm.h
View File

@ -917,14 +917,14 @@ int alpm_option_set_checkspace(alpm_handle_t *handle, int checkspace);
const char *alpm_option_get_dbext(alpm_handle_t *handle);
int alpm_option_set_dbext(alpm_handle_t *handle, const char *dbext);
alpm_siglevel_t alpm_option_get_default_siglevel(alpm_handle_t *handle);
int alpm_option_set_default_siglevel(alpm_handle_t *handle, alpm_siglevel_t level);
int alpm_option_get_default_siglevel(alpm_handle_t *handle);
int alpm_option_set_default_siglevel(alpm_handle_t *handle, int level);
alpm_siglevel_t alpm_option_get_local_file_siglevel(alpm_handle_t *handle);
int alpm_option_set_local_file_siglevel(alpm_handle_t *handle, alpm_siglevel_t level);
int alpm_option_get_local_file_siglevel(alpm_handle_t *handle);
int alpm_option_set_local_file_siglevel(alpm_handle_t *handle, int level);
alpm_siglevel_t alpm_option_get_remote_file_siglevel(alpm_handle_t *handle);
int alpm_option_set_remote_file_siglevel(alpm_handle_t *handle, alpm_siglevel_t level);
int alpm_option_get_remote_file_siglevel(alpm_handle_t *handle);
int alpm_option_set_remote_file_siglevel(alpm_handle_t *handle, int level);
/** @} */
@ -957,7 +957,7 @@ alpm_list_t *alpm_get_syncdbs(alpm_handle_t *handle);
* @return an alpm_db_t* on success (the value), NULL on error
*/
alpm_db_t *alpm_register_syncdb(alpm_handle_t *handle, const char *treename,
alpm_siglevel_t level);
int level);
/** Unregister all package databases.
* @param handle the context handle
@ -983,7 +983,7 @@ const char *alpm_db_get_name(const alpm_db_t *db);
* @param db pointer to the package database
* @return the signature verification level
*/
alpm_siglevel_t alpm_db_get_siglevel(alpm_db_t *db);
int alpm_db_get_siglevel(alpm_db_t *db);
/** Check the validity of a database.
* This is most useful for sync databases and verifying signature status.
@ -1050,14 +1050,14 @@ typedef enum _alpm_db_usage_ {
* @param usage a bitmask of alpm_db_usage_t values
* @return 0 on success, or -1 on error
*/
int alpm_db_set_usage(alpm_db_t *db, alpm_db_usage_t usage);
int alpm_db_set_usage(alpm_db_t *db, int usage);
/** Gets the usage of a database.
* @param db pointer to the package database to get the status of
* @param usage pointer to an alpm_db_usage_t to store db's status
* @return 0 on success, or -1 on error
*/
int alpm_db_get_usage(alpm_db_t *db, alpm_db_usage_t *usage);
int alpm_db_get_usage(alpm_db_t *db, int *usage);
/** @} */
@ -1081,7 +1081,7 @@ int alpm_db_get_usage(alpm_db_t *db, alpm_db_usage_t *usage);
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
int alpm_pkg_load(alpm_handle_t *handle, const char *filename, int full,
alpm_siglevel_t level, alpm_pkg_t **pkg);
int level, alpm_pkg_t **pkg);
/** Find a package in a list by name.
* @param haystack a list of alpm_pkg_t
@ -1318,7 +1318,7 @@ const char *alpm_pkg_get_base64_sig(alpm_pkg_t *pkg);
* @param pkg a pointer to package
* @return an enum member giving the validation method
*/
alpm_pkgvalidation_t alpm_pkg_get_validation(alpm_pkg_t *pkg);
int alpm_pkg_get_validation(alpm_pkg_t *pkg);
/* End of alpm_pkg_t accessors */
/* @} */
@ -1480,7 +1480,7 @@ typedef enum _alpm_transflag_t {
* @param handle the context handle
* @return the bitfield of transaction flags
*/
alpm_transflag_t alpm_trans_get_flags(alpm_handle_t *handle);
int alpm_trans_get_flags(alpm_handle_t *handle);
/** Returns a list of packages added by the transaction.
* @param handle the context handle
@ -1496,10 +1496,10 @@ alpm_list_t *alpm_trans_get_remove(alpm_handle_t *handle);
/** Initialize the transaction.
* @param handle the context handle
* @param flags flags of the transaction (like nodeps, etc)
* @param flags flags of the transaction (like nodeps, etc; see alpm_transflag_t)
* @return 0 on success, -1 on error (pm_errno is set accordingly)
*/
int alpm_trans_init(alpm_handle_t *handle, alpm_transflag_t flags);
int alpm_trans_init(alpm_handle_t *handle, int flags);
/** Prepare a transaction.
* @param handle the context handle
@ -1613,7 +1613,8 @@ enum alpm_caps {
};
const char *alpm_version(void);
enum alpm_caps alpm_capabilities(void);
/* Return a bitfield of capabilities using values from 'enum alpm_caps' */
int alpm_capabilities(void);
void alpm_fileconflict_free(alpm_fileconflict_t *conflict);
void alpm_depmissing_free(alpm_depmissing_t *miss);

8
lib/libalpm/be_local.c
View File

@ -47,7 +47,7 @@
/* local database format version */
size_t ALPM_LOCAL_DB_VERSION = 9;
static int local_db_read(alpm_pkg_t *info, alpm_dbinfrq_t inforeq);
static int local_db_read(alpm_pkg_t *info, int inforeq);
#define LAZY_LOAD(info, errret) \
do { \
@ -117,7 +117,7 @@ static alpm_pkgreason_t _cache_get_reason(alpm_pkg_t *pkg)
return pkg->reason;
}
static alpm_pkgvalidation_t _cache_get_validation(alpm_pkg_t *pkg)
static int _cache_get_validation(alpm_pkg_t *pkg)
{
LAZY_LOAD(INFRQ_DESC, -1);
return pkg->validation;
@ -660,7 +660,7 @@ char *_alpm_local_db_pkgpath(alpm_db_t *db, alpm_pkg_t *info,
f = alpm_list_add(f, alpm_dep_from_string(line)); \
} while(1) /* note the while(1) and not (0) */
static int local_db_read(alpm_pkg_t *info, alpm_dbinfrq_t inforeq)
static int local_db_read(alpm_pkg_t *info, int inforeq)
{
FILE *fp = NULL;
char line[1024];
@ -910,7 +910,7 @@ static void write_deps(FILE *fp, const char *header, alpm_list_t *deplist)
fputc('\n', fp);
}
int _alpm_local_db_write(alpm_db_t *db, alpm_pkg_t *info, alpm_dbinfrq_t inforeq)
int _alpm_local_db_write(alpm_db_t *db, alpm_pkg_t *info, int inforeq)
{
FILE *fp = NULL;
mode_t oldmask;

8
lib/libalpm/be_package.c
View File

@ -270,8 +270,8 @@ static int parse_descfile(alpm_handle_t *handle, struct archive *a, alpm_pkg_t *
* @return 0 if package is fully valid, -1 and pm_errno otherwise
*/
int _alpm_pkg_validate_internal(alpm_handle_t *handle,
const char *pkgfile, alpm_pkg_t *syncpkg, alpm_siglevel_t level,
alpm_siglist_t **sigdata, alpm_pkgvalidation_t *validation)
const char *pkgfile, alpm_pkg_t *syncpkg, int level,
alpm_siglist_t **sigdata, int *validation)
{
int has_sig;
handle->pm_errno = ALPM_ERR_OK;
@ -726,9 +726,9 @@ static int read_sigfile(const char *sigpath, unsigned char **sig)
}
int SYMEXPORT alpm_pkg_load(alpm_handle_t *handle, const char *filename, int full,
alpm_siglevel_t level, alpm_pkg_t **pkg)
int level, alpm_pkg_t **pkg)
{
alpm_pkgvalidation_t validation = 0;
int validation = 0;
char *sigpath;
CHECK_HANDLE(handle, return -1);

26
lib/libalpm/be_sync.c
View File

@ -71,7 +71,7 @@ static char *get_sync_dir(alpm_handle_t *handle)
static int sync_db_validate(alpm_db_t *db)
{
alpm_siglevel_t level;
int siglevel;
const char *dbpath;
if(db->status & DB_STATUS_VALID || db->status & DB_STATUS_MISSING) {
@ -104,20 +104,20 @@ static int sync_db_validate(alpm_db_t *db)
/* this takes into account the default verification level if UNKNOWN
* was assigned to this db */
level = alpm_db_get_siglevel(db);
siglevel = alpm_db_get_siglevel(db);
if(level & ALPM_SIG_DATABASE) {
if(siglevel & ALPM_SIG_DATABASE) {
int retry, ret;
do {
retry = 0;
alpm_siglist_t *siglist;
ret = _alpm_check_pgp_helper(db->handle, dbpath, NULL,
level & ALPM_SIG_DATABASE_OPTIONAL, level & ALPM_SIG_DATABASE_MARGINAL_OK,
level & ALPM_SIG_DATABASE_UNKNOWN_OK, &siglist);
siglevel & ALPM_SIG_DATABASE_OPTIONAL, siglevel & ALPM_SIG_DATABASE_MARGINAL_OK,
siglevel & ALPM_SIG_DATABASE_UNKNOWN_OK, &siglist);
if(ret) {
retry = _alpm_process_siglist(db->handle, db->treename, siglist,
level & ALPM_SIG_DATABASE_OPTIONAL, level & ALPM_SIG_DATABASE_MARGINAL_OK,
level & ALPM_SIG_DATABASE_UNKNOWN_OK);
siglevel & ALPM_SIG_DATABASE_OPTIONAL, siglevel & ALPM_SIG_DATABASE_MARGINAL_OK,
siglevel & ALPM_SIG_DATABASE_UNKNOWN_OK);
}
alpm_siglist_cleanup(siglist);
free(siglist);
@ -181,7 +181,7 @@ int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
int ret = -1;
mode_t oldmask;
alpm_handle_t *handle;
alpm_siglevel_t level;
int siglevel;
/* Sanity checks */
ASSERT(db != NULL, return -1);
@ -207,7 +207,7 @@ int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
/* make sure we have a sane umask */
oldmask = umask(0022);
level = alpm_db_get_siglevel(db);
siglevel = alpm_db_get_siglevel(db);
/* attempt to grab a lock */
if(_alpm_handle_lock(handle)) {
@ -247,7 +247,7 @@ int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
_alpm_dload_payload_reset(&payload);
updated = (updated || ret == 0);
if(ret != -1 && updated && (level & ALPM_SIG_DATABASE)) {
if(ret != -1 && updated && (siglevel & ALPM_SIG_DATABASE)) {
/* an existing sig file is no good at this point */
char *sigpath = _alpm_sigpath(handle, _alpm_db_path(db));
if(!sigpath) {
@ -292,7 +292,7 @@ int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
payload.handle = handle;
payload.force = 1;
payload.errors_ok = (level & ALPM_SIG_DATABASE_OPTIONAL);
payload.errors_ok = (siglevel & ALPM_SIG_DATABASE_OPTIONAL);
/* set hard upper limit of 16KiB */
payload.max_size = 16 * 1024;
@ -343,7 +343,7 @@ int SYMEXPORT alpm_db_update(int force, alpm_db_t *db)
static int sync_db_read(alpm_db_t *db, struct archive *archive,
struct archive_entry *entry, alpm_pkg_t **likely_pkg);
static alpm_pkgvalidation_t _sync_get_validation(alpm_pkg_t *pkg)
static int _sync_get_validation(alpm_pkg_t *pkg)
{
if(pkg->validation) {
return pkg->validation;
@ -769,7 +769,7 @@ struct db_operations sync_db_ops = {
};
alpm_db_t *_alpm_db_register_sync(alpm_handle_t *handle, const char *treename,
alpm_siglevel_t level)
int level)
{
alpm_db_t *db;

10
lib/libalpm/db.c
View File

@ -44,7 +44,7 @@
/** Register a sync database of packages. */
alpm_db_t SYMEXPORT *alpm_register_syncdb(alpm_handle_t *handle,
const char *treename, alpm_siglevel_t level)
const char *treename, int siglevel)
{
alpm_list_t *i;
@ -67,7 +67,7 @@ alpm_db_t SYMEXPORT *alpm_register_syncdb(alpm_handle_t *handle,
}
}
return _alpm_db_register_sync(handle, treename, level);
return _alpm_db_register_sync(handle, treename, siglevel);
}
/* Helper function for alpm_db_unregister{_all} */
@ -235,7 +235,7 @@ const char SYMEXPORT *alpm_db_get_name(const alpm_db_t *db)
}
/** Get the signature verification level for a database. */
alpm_siglevel_t SYMEXPORT alpm_db_get_siglevel(alpm_db_t *db)
int SYMEXPORT alpm_db_get_siglevel(alpm_db_t *db)
{
ASSERT(db != NULL, return -1);
if(db->siglevel & ALPM_SIG_USE_DEFAULT) {
@ -307,7 +307,7 @@ alpm_list_t SYMEXPORT *alpm_db_search(alpm_db_t *db, const alpm_list_t *needles)
}
/** Sets the usage bitmask for a repo */
int SYMEXPORT alpm_db_set_usage(alpm_db_t *db, alpm_db_usage_t usage)
int SYMEXPORT alpm_db_set_usage(alpm_db_t *db, int usage)
{
ASSERT(db != NULL, return -1);
db->usage = usage;
@ -315,7 +315,7 @@ int SYMEXPORT alpm_db_set_usage(alpm_db_t *db, alpm_db_usage_t usage)
}
/** Gets the usage bitmask for a repo */
int SYMEXPORT alpm_db_get_usage(alpm_db_t *db, alpm_db_usage_t *usage)
int SYMEXPORT alpm_db_get_usage(alpm_db_t *db, int *usage)
{
ASSERT(db != NULL, return -1);
ASSERT(usage != NULL, return -1);

16
lib/libalpm/db.h
View File

@ -71,10 +71,14 @@ struct __alpm_db_t {
alpm_list_t *grpcache;
alpm_list_t *servers;
struct db_operations *ops;
/* flags determining validity, local, loaded caches, etc. */
enum _alpm_dbstatus_t status;
alpm_siglevel_t siglevel;
alpm_db_usage_t usage;
/* bitfields for validity, local, loaded caches, etc. */
/* From _alpm_dbstatus_t */
int status;
/* alpm_siglevel_t */
int siglevel;
/* alpm_db_usage_t */
int usage;
};
@ -86,12 +90,12 @@ int _alpm_db_cmp(const void *d1, const void *d2);
alpm_list_t *_alpm_db_search(alpm_db_t *db, const alpm_list_t *needles);
alpm_db_t *_alpm_db_register_local(alpm_handle_t *handle);
alpm_db_t *_alpm_db_register_sync(alpm_handle_t *handle, const char *treename,
alpm_siglevel_t level);
int level);
void _alpm_db_unregister(alpm_db_t *db);
/* be_*.c, backend specific calls */
int _alpm_local_db_prepare(alpm_db_t *db, alpm_pkg_t *info);
int _alpm_local_db_write(alpm_db_t *db, alpm_pkg_t *info, alpm_dbinfrq_t inforeq);
int _alpm_local_db_write(alpm_db_t *db, alpm_pkg_t *info, int inforeq);
int _alpm_local_db_remove(alpm_db_t *db, alpm_pkg_t *info);
char *_alpm_local_db_pkgpath(alpm_db_t *db, alpm_pkg_t *info, const char *filename);

12
lib/libalpm/handle.c
View File

@ -777,7 +777,7 @@ int SYMEXPORT alpm_option_set_dbext(alpm_handle_t *handle, const char *dbext)
}
int SYMEXPORT alpm_option_set_default_siglevel(alpm_handle_t *handle,
alpm_siglevel_t level)
int level)
{
CHECK_HANDLE(handle, return -1);
#ifdef HAVE_LIBGPGME
@ -790,14 +790,14 @@ int SYMEXPORT alpm_option_set_default_siglevel(alpm_handle_t *handle,
return 0;
}
alpm_siglevel_t SYMEXPORT alpm_option_get_default_siglevel(alpm_handle_t *handle)
int SYMEXPORT alpm_option_get_default_siglevel(alpm_handle_t *handle)
{
CHECK_HANDLE(handle, return -1);
return handle->siglevel;
}
int SYMEXPORT alpm_option_set_local_file_siglevel(alpm_handle_t *handle,
alpm_siglevel_t level)
int level)
{
CHECK_HANDLE(handle, return -1);
#ifdef HAVE_LIBGPGME
@ -810,7 +810,7 @@ int SYMEXPORT alpm_option_set_local_file_siglevel(alpm_handle_t *handle,
return 0;
}
alpm_siglevel_t SYMEXPORT alpm_option_get_local_file_siglevel(alpm_handle_t *handle)
int SYMEXPORT alpm_option_get_local_file_siglevel(alpm_handle_t *handle)
{
CHECK_HANDLE(handle, return -1);
if(handle->localfilesiglevel & ALPM_SIG_USE_DEFAULT) {
@ -821,7 +821,7 @@ alpm_siglevel_t SYMEXPORT alpm_option_get_local_file_siglevel(alpm_handle_t *han
}
int SYMEXPORT alpm_option_set_remote_file_siglevel(alpm_handle_t *handle,
alpm_siglevel_t level)
int level)
{
CHECK_HANDLE(handle, return -1);
#ifdef HAVE_LIBGPGME
@ -834,7 +834,7 @@ int SYMEXPORT alpm_option_set_remote_file_siglevel(alpm_handle_t *handle,
return 0;
}
alpm_siglevel_t SYMEXPORT alpm_option_get_remote_file_siglevel(alpm_handle_t *handle)
int SYMEXPORT alpm_option_get_remote_file_siglevel(alpm_handle_t *handle)
{
CHECK_HANDLE(handle, return -1);
if(handle->remotefilesiglevel & ALPM_SIG_USE_DEFAULT) {

6
lib/libalpm/handle.h
View File

@ -97,10 +97,10 @@ struct __alpm_handle_t {
int usesyslog; /* Use syslog instead of logfile? */ /* TODO move to frontend */
int checkspace; /* Check disk space before installing */
char *dbext; /* Sync DB extension */
alpm_siglevel_t siglevel; /* Default signature verification level */
alpm_siglevel_t localfilesiglevel; /* Signature verification level for local file
int siglevel; /* Default signature verification level */
int localfilesiglevel; /* Signature verification level for local file
upgrade operations */
alpm_siglevel_t remotefilesiglevel; /* Signature verification level for remote file
int remotefilesiglevel; /* Signature verification level for remote file
upgrade operations */
/* error code */

4
lib/libalpm/package.c
View File

@ -92,7 +92,7 @@ static const char *_pkg_get_packager(alpm_pkg_t *pkg) { return pkg->packager;
static const char *_pkg_get_arch(alpm_pkg_t *pkg) { return pkg->arch; }
static off_t _pkg_get_isize(alpm_pkg_t *pkg) { return pkg->isize; }
static alpm_pkgreason_t _pkg_get_reason(alpm_pkg_t *pkg) { return pkg->reason; }
static alpm_pkgvalidation_t _pkg_get_validation(alpm_pkg_t *pkg) { return pkg->validation; }
static int _pkg_get_validation(alpm_pkg_t *pkg) { return pkg->validation; }
static int _pkg_has_scriptlet(alpm_pkg_t *pkg) { return pkg->scriptlet; }
static alpm_list_t *_pkg_get_licenses(alpm_pkg_t *pkg) { return pkg->licenses; }
@ -300,7 +300,7 @@ alpm_pkgreason_t SYMEXPORT alpm_pkg_get_reason(alpm_pkg_t *pkg)
return pkg->ops->get_reason(pkg);
}
alpm_pkgvalidation_t SYMEXPORT alpm_pkg_get_validation(alpm_pkg_t *pkg)
int SYMEXPORT alpm_pkg_get_validation(alpm_pkg_t *pkg)
{
ASSERT(pkg != NULL, return -1);
pkg->handle->pm_errno = ALPM_ERR_OK;

13
lib/libalpm/package.h
View File

@ -52,7 +52,7 @@ struct pkg_operations {
const char *(*get_arch) (alpm_pkg_t *);
off_t (*get_isize) (alpm_pkg_t *);
alpm_pkgreason_t (*get_reason) (alpm_pkg_t *);
alpm_pkgvalidation_t (*get_validation) (alpm_pkg_t *);
int (*get_validation) (alpm_pkg_t *);
int (*has_scriptlet) (alpm_pkg_t *);
alpm_list_t *(*get_licenses) (alpm_pkg_t *);
@ -130,11 +130,14 @@ struct __alpm_pkg_t {
char *file;
} origin_data;
alpm_dbinfrq_t infolevel;
alpm_pkgvalidation_t validation;
alpm_pkgfrom_t origin;
alpm_pkgreason_t reason;
int scriptlet;
/* Bitfield from alpm_dbinfrq_t */
int infolevel;
/* Bitfield from alpm_pkgvalidation_t */
int validation;
};
alpm_file_t *_alpm_file_copy(alpm_file_t *dest, const alpm_file_t *src);
@ -145,8 +148,8 @@ void _alpm_pkg_free(alpm_pkg_t *pkg);
void _alpm_pkg_free_trans(alpm_pkg_t *pkg);
int _alpm_pkg_validate_internal(alpm_handle_t *handle,
const char *pkgfile, alpm_pkg_t *syncpkg, alpm_siglevel_t level,
alpm_siglist_t **sigdata, alpm_pkgvalidation_t *validation);
const char *pkgfile, alpm_pkg_t *syncpkg, int level,
alpm_siglist_t **sigdata, int *validation);
alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle,
const char *pkgfile, int full);

16
lib/libalpm/sync.c
View File

@ -1056,7 +1056,7 @@ static int check_keyring(alpm_handle_t *handle)
for(i = handle->trans->add; i; i = i->next, current++) {
alpm_pkg_t *pkg = i->data;
alpm_siglevel_t level;
int level;
int percent = (current * 100) / numtargs;
PROGRESS(handle, ALPM_PROGRESS_KEYRING_START, "", percent,
@ -1126,8 +1126,8 @@ static int check_validity(alpm_handle_t *handle,
alpm_pkg_t *pkg;
char *path;
alpm_siglist_t *siglist;
alpm_siglevel_t level;
alpm_pkgvalidation_t validation;
int siglevel;
int validation;
alpm_errno_t error;
};
size_t current = 0;
@ -1151,10 +1151,10 @@ static int check_validity(alpm_handle_t *handle,
current_bytes += v.pkg->size;
v.path = _alpm_filecache_find(handle, v.pkg->filename);
v.level = alpm_db_get_siglevel(alpm_pkg_get_db(v.pkg));
v.siglevel = alpm_db_get_siglevel(alpm_pkg_get_db(v.pkg));
if(_alpm_pkg_validate_internal(handle, v.path, v.pkg,
v.level, &v.siglist, &v.validation) == -1) {
v.siglevel, &v.siglist, &v.validation) == -1) {
struct validity *invalid;
v.error = handle->pm_errno;
MALLOC(invalid, sizeof(struct validity), return -1);
@ -1181,9 +1181,9 @@ static int check_validity(alpm_handle_t *handle,
_("%s: missing required signature\n"), v->pkg->name);
} else if(v->error == ALPM_ERR_PKG_INVALID_SIG) {
_alpm_process_siglist(handle, v->pkg->name, v->siglist,
v->level & ALPM_SIG_PACKAGE_OPTIONAL,
v->level & ALPM_SIG_PACKAGE_MARGINAL_OK,
v->level & ALPM_SIG_PACKAGE_UNKNOWN_OK);
v->siglevel & ALPM_SIG_PACKAGE_OPTIONAL,
v->siglevel & ALPM_SIG_PACKAGE_MARGINAL_OK,
v->siglevel & ALPM_SIG_PACKAGE_UNKNOWN_OK);
prompt_to_delete(handle, v->path, v->error);
} else if(v->error == ALPM_ERR_PKG_INVALID_CHECKSUM) {
prompt_to_delete(handle, v->path, v->error);

4
lib/libalpm/trans.c
View File

@ -48,7 +48,7 @@
*/
/** Initialize the transaction. */
int SYMEXPORT alpm_trans_init(alpm_handle_t *handle, alpm_transflag_t flags)
int SYMEXPORT alpm_trans_init(alpm_handle_t *handle, int flags)
{
alpm_trans_t *trans;
@ -415,7 +415,7 @@ cleanup:
return retval;
}
alpm_transflag_t SYMEXPORT alpm_trans_get_flags(alpm_handle_t *handle)
int SYMEXPORT alpm_trans_get_flags(alpm_handle_t *handle)
{
/* Sanity checks */
CHECK_HANDLE(handle, return -1);

6
lib/libalpm/trans.h
View File

@ -37,7 +37,8 @@ typedef enum _alpm_transstate_t {
/* Transaction */
struct __alpm_trans_t {
alpm_transflag_t flags;
/* bitfield of alpm_transflag_t flags */
int flags;
alpm_transstate_t state;
alpm_list_t *unresolvable; /* list of (alpm_pkg_t *) */
alpm_list_t *add; /* list of (alpm_pkg_t *) */
@ -46,7 +47,8 @@ struct __alpm_trans_t {
};
void _alpm_trans_free(alpm_trans_t *trans);
int _alpm_trans_init(alpm_trans_t *trans, alpm_transflag_t flags);
/* flags is a bitfield of alpm_transflag_t flags */
int _alpm_trans_init(alpm_trans_t *trans, int flags);
int _alpm_runscriptlet(alpm_handle_t *handle, const char *filepath,
const char *script, const char *ver, const char *oldver, int is_archive);

2
lib/libalpm/util.h
View File

@ -131,6 +131,8 @@ int _alpm_ldconfig(alpm_handle_t *handle);
int _alpm_str_cmp(const void *s1, const void *s2);
char *_alpm_filecache_find(alpm_handle_t *handle, const char *filename);
const char *_alpm_filecache_setup(alpm_handle_t *handle);
/* Unlike many uses of alpm_pkgvalidation_t, _alpm_test_checksum expects
* an enum value rather than a bitfield. */
int _alpm_test_checksum(const char *filepath, const char *expected, alpm_pkgvalidation_t type);
int _alpm_archive_fgets(struct archive *a, struct archive_read_buffer *b);
int _alpm_splitname(const char *target, char **name, char **version,

17
src/pacman/conf.c
View File

@ -325,10 +325,10 @@ int config_set_arch(const char *arch)
* @param linenum current line number in file
* @return 0 on success, 1 on any parsing error
*/
static int process_siglevel(alpm_list_t *values, alpm_siglevel_t *storage,
alpm_siglevel_t *storage_mask, const char *file, int linenum)
static int process_siglevel(alpm_list_t *values, int *storage,
int *storage_mask, const char *file, int linenum)
{
alpm_siglevel_t level = *storage, mask = *storage_mask;
int level = *storage, mask = *storage_mask;
alpm_list_t *i;
int ret = 0;
@ -421,13 +421,12 @@ static int process_siglevel(alpm_list_t *values, alpm_siglevel_t *storage,
}
/**
* Merge the package entires of two signature verification levels.
* Merge the package entries of two signature verification levels.
* @param base initial siglevel
* @param over overridden siglevel
* @param over overriding siglevel
* @return merged siglevel
*/
static alpm_siglevel_t merge_siglevel(alpm_siglevel_t base,
alpm_siglevel_t over, alpm_siglevel_t mask)
static int merge_siglevel(int base, int over, int mask)
{
return mask ? (over & mask) | (base & ~mask) : over;
}
@ -845,11 +844,11 @@ struct section_t {
int depth;
};
static int process_usage(alpm_list_t *values, alpm_db_usage_t *usage,
static int process_usage(alpm_list_t *values, int *usage,
const char *file, int linenum)
{
alpm_list_t *i;
alpm_db_usage_t level = *usage;
int level = *usage;
int ret = 0;
for(i = values; i; i = i->next) {

22
src/pacman/conf.h
View File

@ -37,9 +37,9 @@ typedef struct __colstr_t {
typedef struct __config_repo_t {
char *name;
alpm_list_t *servers;
alpm_db_usage_t usage;
alpm_siglevel_t siglevel;
alpm_siglevel_t siglevel_mask;
int usage;
int siglevel;
int siglevel_mask;
} config_repo_t;
typedef struct __config_t {
@ -95,14 +95,16 @@ typedef struct __config_t {
unsigned short group;
unsigned short noask;
unsigned int ask;
alpm_transflag_t flags;
alpm_siglevel_t siglevel;
alpm_siglevel_t localfilesiglevel;
alpm_siglevel_t remotefilesiglevel;
/* Bitfield of alpm_transflag_t */
int flags;
/* Bitfields of alpm_siglevel_t */
int siglevel;
int localfilesiglevel;
int remotefilesiglevel;
alpm_siglevel_t siglevel_mask;
alpm_siglevel_t localfilesiglevel_mask;
alpm_siglevel_t remotefilesiglevel_mask;
int siglevel_mask;
int localfilesiglevel_mask;
int remotefilesiglevel_mask;
/* conf file options */
/* I Love Candy! */

2
src/pacman/package.c
View File

@ -230,7 +230,7 @@ void dump_pkg_full(alpm_pkg_t *pkg, int extra)
break;
}
alpm_pkgvalidation_t v = alpm_pkg_get_validation(pkg);
int v = alpm_pkg_get_validation(pkg);
if(v) {
if(v & ALPM_PKG_VALIDATION_NONE) {
validation = alpm_list_add(validation, _("None"));

2
src/pacman/sync.c
View File

@ -630,7 +630,7 @@ static int process_target(const char *target, int error)
if(targname && targname != targstring) {
alpm_db_t *db;
const char *dbname;
alpm_db_usage_t usage;
int usage;
*targname = '\0';
targname++;

8
src/pacman/upgrade.c
View File

@ -89,15 +89,15 @@ int pacman_upgrade(alpm_list_t *targets)
for(i = targets, n = 0; i; i = alpm_list_next(i), n++) {
const char *targ = i->data;
alpm_pkg_t *pkg;
alpm_siglevel_t level;
int siglevel;
if(file_is_remote[n]) {
level = alpm_option_get_remote_file_siglevel(config->handle);
siglevel = alpm_option_get_remote_file_siglevel(config->handle);
} else {
level = alpm_option_get_local_file_siglevel(config->handle);
siglevel = alpm_option_get_local_file_siglevel(config->handle);
}
if(alpm_pkg_load(config->handle, targ, 1, level, &pkg) != 0) {
if(alpm_pkg_load(config->handle, targ, 1, siglevel, &pkg) != 0) {
pm_printf(ALPM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerror(alpm_errno(config->handle)));
retval = 1;

2
src/pacman/util.c
View File

@ -61,7 +61,7 @@ enum {
CELL_FREE = (1 << 3)
};
int trans_init(alpm_transflag_t flags, int check_valid)
int trans_init(int flags, int check_valid)
{
int ret;

3
src/pacman/util.h
View File

@ -45,7 +45,8 @@ typedef struct _pm_target_t {
} pm_target_t;
void trans_init_error(void);
int trans_init(alpm_transflag_t flags, int check_valid);
/* flags is a bitfield of alpm_transflag_t flags */
int trans_init(int flags, int check_valid);
int trans_release(void);
int needs_root(void);
int check_syncdbs(size_t need_repos, int check_valid);

4
src/util/cleanupdelta.c
View File

@ -68,11 +68,11 @@ static void checkdbs(alpm_list_t *dbnames)
{
alpm_db_t *db = NULL;
alpm_list_t *i;
const alpm_siglevel_t level = ALPM_SIG_DATABASE | ALPM_SIG_DATABASE_OPTIONAL;
const int siglevel = ALPM_SIG_DATABASE | ALPM_SIG_DATABASE_OPTIONAL;
for(i = dbnames; i; i = alpm_list_next(i)) {
const char *dbname = i->data;
db = alpm_register_syncdb(handle, dbname, level);
db = alpm_register_syncdb(handle, dbname, siglevel);
if(db == NULL) {
fprintf(stderr, "error: could not register sync database '%s' (%s)\n",
dbname, alpm_strerror(alpm_errno(handle)));

4
src/util/testpkg.c
View File

@ -43,7 +43,7 @@ int main(int argc, char *argv[])
alpm_handle_t *handle;
alpm_errno_t err;
alpm_pkg_t *pkg = NULL;
const alpm_siglevel_t level = ALPM_SIG_PACKAGE | ALPM_SIG_PACKAGE_OPTIONAL;
const int siglevel = ALPM_SIG_PACKAGE | ALPM_SIG_PACKAGE_OPTIONAL;
if(argc != 2) {
fprintf(stderr, "testpkg (pacman) v" PACKAGE_VERSION "\n\n"
@ -64,7 +64,7 @@ int main(int argc, char *argv[])
/* set gpgdir to default */
alpm_option_set_gpgdir(handle, GPGDIR);
if(alpm_pkg_load(handle, argv[1], 1, level, &pkg) == -1
if(alpm_pkg_load(handle, argv[1], 1, siglevel, &pkg) == -1
|| pkg == NULL) {
err = alpm_errno(handle);
switch(err) {