2005-03-14 20:51:43 -05:00
|
|
|
/*
|
|
|
|
|
* package.h
|
2007-11-16 21:18:45 -05:00
|
|
|
*
|
2016-01-02 22:48:43 -05:00
|
|
|
* Copyright (c) 2006-2016 Pacman Development Team <pacman-dev@archlinux.org>
|
2009-07-01 03:08:33 -04:00
|
|
|
* Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
|
2006-10-15 15:31:03 -04:00
|
|
|
* Copyright (c) 2005 by Aurelien Foret <orelien@chez.com>
|
|
|
|
|
* Copyright (c) 2006 by David Kimpe <dnaku@frugalware.org>
|
|
|
|
|
* Copyright (c) 2005, 2006 by Christian Hamar <krics@linuxforum.hu>
|
|
|
|
|
* Copyright (c) 2005, 2006 by Miklos Vajna <vmiklos@frugalware.org>
|
2007-11-16 21:18:45 -05:00
|
|
|
*
|
2005-03-14 20:51:43 -05:00
|
|
|
* 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 copy of the GNU General Public License
|
2007-12-10 23:55:22 -05:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2005-03-14 20:51:43 -05:00
|
|
|
*/
|
2016-09-03 23:14:49 -04:00
|
|
|
#ifndef ALPM_PACKAGE_H
|
|
|
|
|
#define ALPM_PACKAGE_H
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2008-06-01 22:47:31 -04:00
|
|
|
#include <sys/types.h> /* off_t */
|
2006-11-20 04:10:23 -05:00
|
|
|
|
2012-05-01 04:12:13 -04:00
|
|
|
/* libarchive */
|
|
|
|
|
#include <archive.h>
|
|
|
|
|
#include <archive_entry.h>
|
|
|
|
|
|
2006-11-20 04:10:23 -05:00
|
|
|
#include "alpm.h"
|
2011-06-16 14:15:11 -04:00
|
|
|
#include "backup.h"
|
2007-01-23 22:02:53 -05:00
|
|
|
#include "db.h"
|
2010-11-22 00:06:09 -05:00
|
|
|
#include "signing.h"
|
2005-03-14 20:51:43 -05:00
|
|
|
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
/** Package operations struct. This struct contains function pointers to
|
|
|
|
|
* all methods used to access data in a package to allow for things such
|
2016-04-29 17:32:13 -04:00
|
|
|
* as lazy package initialization (such as used by the file backend). Each
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
* backend is free to define a stuct containing pointers to a specific
|
|
|
|
|
* implementation of these methods. Some backends may find using the
|
|
|
|
|
* defined default_pkg_ops struct to work just fine for their needs.
|
|
|
|
|
*/
|
|
|
|
|
struct pkg_operations {
|
2014-12-22 09:11:39 -05:00
|
|
|
const char *(*get_base) (alpm_pkg_t *);
|
2011-06-28 09:26:39 -04:00
|
|
|
const char *(*get_desc) (alpm_pkg_t *);
|
|
|
|
|
const char *(*get_url) (alpm_pkg_t *);
|
2011-09-07 11:21:47 -04:00
|
|
|
alpm_time_t (*get_builddate) (alpm_pkg_t *);
|
|
|
|
|
alpm_time_t (*get_installdate) (alpm_pkg_t *);
|
2011-06-28 09:26:39 -04:00
|
|
|
const char *(*get_packager) (alpm_pkg_t *);
|
|
|
|
|
const char *(*get_arch) (alpm_pkg_t *);
|
|
|
|
|
off_t (*get_isize) (alpm_pkg_t *);
|
|
|
|
|
alpm_pkgreason_t (*get_reason) (alpm_pkg_t *);
|
2016-10-12 16:13:32 -04:00
|
|
|
int (*get_validation) (alpm_pkg_t *);
|
2011-06-28 09:26:39 -04:00
|
|
|
int (*has_scriptlet) (alpm_pkg_t *);
|
|
|
|
|
|
|
|
|
|
alpm_list_t *(*get_licenses) (alpm_pkg_t *);
|
|
|
|
|
alpm_list_t *(*get_groups) (alpm_pkg_t *);
|
|
|
|
|
alpm_list_t *(*get_depends) (alpm_pkg_t *);
|
|
|
|
|
alpm_list_t *(*get_optdepends) (alpm_pkg_t *);
|
|
|
|
|
alpm_list_t *(*get_conflicts) (alpm_pkg_t *);
|
|
|
|
|
alpm_list_t *(*get_provides) (alpm_pkg_t *);
|
|
|
|
|
alpm_list_t *(*get_replaces) (alpm_pkg_t *);
|
Convert package filelists to an array instead of linked list
This accomplishes quite a few things with one rather invasive change.
1. Iteration is much more performant, due to a reduction in pointer
chasing and linear item access.
2. Data structures are smaller- we no longer have the overhead of the
linked list as the file struts are now laid out consecutively in
memory.
3. Memory allocation has been massively reworked. Before, we would
allocate three different pieces of memory per file item- the list
struct, the file struct, and the copied filename. What this resulted
in was massive fragmentation of memory when loading filelists since
the memory allocator had to leave holes all over the place. The new
situation here now removes the need for any list item allocation;
allocates the file structs in contiguous memory (and reallocs as
necessary), leaving only the strings as individually allocated. Tests
using valgrind (massif) show some pretty significant memory
reductions on the worst case `pacman -Ql > /dev/null` (366387 files
on my machine):
Before:
Peak heap: 54,416,024 B
Useful heap: 36,840,692 B
Extra heap: 17,575,332 B
After:
Peak heap: 38,004,352 B
Useful heap: 28,101,347 B
Extra heap: 9,903,005 B
Several small helper methods have been introduced, including a list to
array conversion helper as well as a filelist merge sort that works
directly on arrays.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-07-19 05:47:29 -04:00
|
|
|
alpm_filelist_t *(*get_files) (alpm_pkg_t *);
|
2011-06-28 09:26:39 -04:00
|
|
|
alpm_list_t *(*get_backup) (alpm_pkg_t *);
|
|
|
|
|
|
|
|
|
|
void *(*changelog_open) (alpm_pkg_t *);
|
2011-09-18 18:07:05 -04:00
|
|
|
size_t (*changelog_read) (void *, size_t, const alpm_pkg_t *, void *);
|
2011-06-28 09:26:39 -04:00
|
|
|
int (*changelog_close) (const alpm_pkg_t *, void *);
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
|
2012-05-01 04:12:13 -04:00
|
|
|
struct archive *(*mtree_open) (alpm_pkg_t *);
|
|
|
|
|
int (*mtree_next) (const alpm_pkg_t *, struct archive *, struct archive_entry **);
|
|
|
|
|
int (*mtree_close) (const alpm_pkg_t *, struct archive *);
|
|
|
|
|
|
2011-06-28 23:02:58 -04:00
|
|
|
int (*force_load) (alpm_pkg_t *);
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/** The standard package operations struct. get fields directly from the
|
|
|
|
|
* struct itself with no abstraction layer or any type of lazy loading.
|
|
|
|
|
* The actual definition is in package.c so it can have access to the
|
|
|
|
|
* default accessor functions which are defined there.
|
|
|
|
|
*/
|
|
|
|
|
extern struct pkg_operations default_pkg_ops;
|
|
|
|
|
|
2011-06-28 09:26:39 -04:00
|
|
|
struct __alpm_pkg_t {
|
2010-12-14 13:06:31 -05:00
|
|
|
unsigned long name_hash;
|
2008-01-11 01:01:58 -05:00
|
|
|
char *filename;
|
2014-12-22 09:11:38 -05:00
|
|
|
char *base;
|
2008-01-11 01:01:58 -05:00
|
|
|
char *name;
|
|
|
|
|
char *version;
|
|
|
|
|
char *desc;
|
|
|
|
|
char *url;
|
|
|
|
|
char *packager;
|
|
|
|
|
char *md5sum;
|
2011-08-11 21:15:15 -04:00
|
|
|
char *sha256sum;
|
2011-04-21 20:25:44 -04:00
|
|
|
char *base64_sig;
|
2008-01-11 01:01:58 -05:00
|
|
|
char *arch;
|
2010-12-14 18:45:12 -05:00
|
|
|
|
2011-09-07 11:21:47 -04:00
|
|
|
alpm_time_t builddate;
|
|
|
|
|
alpm_time_t installdate;
|
2010-12-14 18:45:12 -05:00
|
|
|
|
2008-06-01 22:47:31 -04:00
|
|
|
off_t size;
|
|
|
|
|
off_t isize;
|
|
|
|
|
off_t download_size;
|
2010-12-14 18:45:12 -05:00
|
|
|
|
2011-06-28 00:04:00 -04:00
|
|
|
alpm_handle_t *handle;
|
2010-12-14 18:45:12 -05:00
|
|
|
|
2007-03-03 03:13:59 -05:00
|
|
|
alpm_list_t *licenses;
|
2007-01-19 04:28:44 -05:00
|
|
|
alpm_list_t *replaces;
|
|
|
|
|
alpm_list_t *groups;
|
|
|
|
|
alpm_list_t *backup;
|
|
|
|
|
alpm_list_t *depends;
|
2007-09-26 00:02:30 -04:00
|
|
|
alpm_list_t *optdepends;
|
2007-01-19 04:28:44 -05:00
|
|
|
alpm_list_t *conflicts;
|
|
|
|
|
alpm_list_t *provides;
|
2007-10-19 13:17:51 -04:00
|
|
|
alpm_list_t *deltas;
|
2008-06-01 22:47:31 -04:00
|
|
|
alpm_list_t *delta_path;
|
2009-03-07 13:44:34 -05:00
|
|
|
alpm_list_t *removes; /* in transaction targets only */
|
2016-02-21 21:46:35 -05:00
|
|
|
alpm_pkg_t *oldpkg; /* in transaction targets only */
|
Complete rework of package accessor logic
Hopefully we've finally arrived at package handling nirvana, or at least
this commit will get us a heck of a lot closer. The former method of getting
the depends list for a package was the following:
1. call alpm_pkg_get_depends()
2. this method would check if the package came from the cache
3. if so, ensure our cache level is correct, otherwise call db_load
4. finally return the depends list
Why did this suck? Because getting the depends list from the package
shouldn't care about whether the package was loaded from a file, from the
'package cache', or some other system which we can't even use because the
damn thing is so complicated. It should just return the depends list.
So what does this commit change? It adds a pointer to a struct of function
pointers to every package for all of these 'package operations' as I've
decided to call them (I know, sounds completely straightforward, right?). So
now when we call an alpm_pkg_get-* function, we don't do any of the cache
logic or anything else there- we let the actual backend handle it by
delegating all work to the method at pkg->ops->get_depends.
Now that be_package has achieved equal status with be_files, we can treat
packages from these completely different load points differently. We know a
package loaded from a zip file will have all of its fields populated, so
we can set up all its accessor functions to be direct accessors. On the
other hand, the packages loaded from the local and sync DBs are not always
fully-loaded, so their accessor functions are routed through the same logic
as before.
Net result? More code. However, this code now make it roughly 52 times
easier to open the door to something like a read-only tar.gz database
backend.
Are you still reading? I'm impressed. Looking at the patch will probably be
clearer than this long-winded explanation.
Signed-off-by: Dan McGee <dan@archlinux.org>
[Allan: rebase and adjust]
Signed-off-by: Allan McRae <allan@archlinux.org>
2008-05-11 17:00:33 -04:00
|
|
|
|
|
|
|
|
struct pkg_operations *ops;
|
Convert package filelists to an array instead of linked list
This accomplishes quite a few things with one rather invasive change.
1. Iteration is much more performant, due to a reduction in pointer
chasing and linear item access.
2. Data structures are smaller- we no longer have the overhead of the
linked list as the file struts are now laid out consecutively in
memory.
3. Memory allocation has been massively reworked. Before, we would
allocate three different pieces of memory per file item- the list
struct, the file struct, and the copied filename. What this resulted
in was massive fragmentation of memory when loading filelists since
the memory allocator had to leave holes all over the place. The new
situation here now removes the need for any list item allocation;
allocates the file structs in contiguous memory (and reallocs as
necessary), leaving only the strings as individually allocated. Tests
using valgrind (massif) show some pretty significant memory
reductions on the worst case `pacman -Ql > /dev/null` (366387 files
on my machine):
Before:
Peak heap: 54,416,024 B
Useful heap: 36,840,692 B
Extra heap: 17,575,332 B
After:
Peak heap: 38,004,352 B
Useful heap: 28,101,347 B
Extra heap: 9,903,005 B
Several small helper methods have been introduced, including a list to
array conversion helper as well as a filelist merge sort that works
directly on arrays.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-07-19 05:47:29 -04:00
|
|
|
|
|
|
|
|
alpm_filelist_t files;
|
2014-01-02 13:37:10 -05:00
|
|
|
|
|
|
|
|
/* origin == PKG_FROM_FILE, use pkg->origin_data.file
|
|
|
|
|
* origin == PKG_FROM_*DB, use pkg->origin_data.db */
|
|
|
|
|
union {
|
|
|
|
|
alpm_db_t *db;
|
|
|
|
|
char *file;
|
|
|
|
|
} origin_data;
|
|
|
|
|
|
|
|
|
|
alpm_pkgfrom_t origin;
|
|
|
|
|
alpm_pkgreason_t reason;
|
2014-01-13 23:01:46 -05:00
|
|
|
int scriptlet;
|
2016-10-12 16:13:32 -04:00
|
|
|
|
|
|
|
|
/* Bitfield from alpm_dbinfrq_t */
|
|
|
|
|
int infolevel;
|
|
|
|
|
/* Bitfield from alpm_pkgvalidation_t */
|
|
|
|
|
int validation;
|
2006-11-20 04:10:23 -05:00
|
|
|
};
|
2005-03-14 20:51:43 -05:00
|
|
|
|
Convert package filelists to an array instead of linked list
This accomplishes quite a few things with one rather invasive change.
1. Iteration is much more performant, due to a reduction in pointer
chasing and linear item access.
2. Data structures are smaller- we no longer have the overhead of the
linked list as the file struts are now laid out consecutively in
memory.
3. Memory allocation has been massively reworked. Before, we would
allocate three different pieces of memory per file item- the list
struct, the file struct, and the copied filename. What this resulted
in was massive fragmentation of memory when loading filelists since
the memory allocator had to leave holes all over the place. The new
situation here now removes the need for any list item allocation;
allocates the file structs in contiguous memory (and reallocs as
necessary), leaving only the strings as individually allocated. Tests
using valgrind (massif) show some pretty significant memory
reductions on the worst case `pacman -Ql > /dev/null` (366387 files
on my machine):
Before:
Peak heap: 54,416,024 B
Useful heap: 36,840,692 B
Extra heap: 17,575,332 B
After:
Peak heap: 38,004,352 B
Useful heap: 28,101,347 B
Extra heap: 9,903,005 B
Several small helper methods have been introduced, including a list to
array conversion helper as well as a filelist merge sort that works
directly on arrays.
Signed-off-by: Dan McGee <dan@archlinux.org>
2011-07-19 05:47:29 -04:00
|
|
|
alpm_file_t *_alpm_file_copy(alpm_file_t *dest, const alpm_file_t *src);
|
2011-06-16 14:16:49 -04:00
|
|
|
|
2012-04-24 22:05:51 -04:00
|
|
|
alpm_pkg_t *_alpm_pkg_new(void);
|
2011-08-19 12:06:55 -04:00
|
|
|
int _alpm_pkg_dup(alpm_pkg_t *pkg, alpm_pkg_t **new_ptr);
|
2011-06-28 09:26:39 -04:00
|
|
|
void _alpm_pkg_free(alpm_pkg_t *pkg);
|
|
|
|
|
void _alpm_pkg_free_trans(alpm_pkg_t *pkg);
|
2011-04-22 00:39:01 -04:00
|
|
|
|
2011-09-19 21:40:32 -04:00
|
|
|
int _alpm_pkg_validate_internal(alpm_handle_t *handle,
|
2016-10-12 16:13:32 -04:00
|
|
|
const char *pkgfile, alpm_pkg_t *syncpkg, int level,
|
|
|
|
|
alpm_siglist_t **sigdata, int *validation);
|
2011-09-19 21:40:32 -04:00
|
|
|
alpm_pkg_t *_alpm_pkg_load_internal(alpm_handle_t *handle,
|
|
|
|
|
const char *pkgfile, int full);
|
2011-04-22 00:39:01 -04:00
|
|
|
|
2006-03-08 13:07:58 -05:00
|
|
|
int _alpm_pkg_cmp(const void *p1, const void *p2);
|
2011-06-28 09:26:39 -04:00
|
|
|
int _alpm_pkg_compare_versions(alpm_pkg_t *local_pkg, alpm_pkg_t *pkg);
|
2006-11-20 04:10:23 -05:00
|
|
|
|
2016-09-03 23:14:49 -04:00
|
|
|
#endif /* ALPM_PACKAGE_H */
|
2005-03-14 20:51:43 -05:00
|
|
|
|
2014-01-22 18:06:11 -05:00
|
|
|
/* vim: set noet: */
|