Radish alpha
H
HardenedBSD-pkg
HardenedBSD Package Manager
Radicle
Git (anonymous pull)
Log in to clone via SSH
Commits ›
Package can be created specify user and modes
Baptiste Daroussin committed 14 years ago
commit 3684d2da68372aaa3e4fa6b197ba7b15a6e49368
parent f12a5096faf027fd1c60b9ec247c9c5dce1a8995
7 files changed +149 -10
modified libpkg/packing.c
@@ -76,6 +76,13 @@ packing_append_buffer(struct packing *pack, const char *buffer, const char *path
int

packing_append_file(struct packing *pack, const char *filepath, const char *newpath)

{
+ 
	return (packing_append_file_attr(pack, filepath, newpath, NULL, NULL, 0));
+ 
}
+
+ 
int
+ 
packing_append_file_attr(struct packing *pack, const char *filepath, const char *newpath,
+ 
		const char *uname, const char *gname, mode_t perm)
+ 
{

	int fd;

	int len;

	char buf[BUFSIZ];
@@ -105,6 +112,15 @@ packing_append_file(struct packing *pack, const char *filepath, const char *newp
		archive_entry_set_size(pack->entry, 0);

	}
+ 
	if (uname != NULL)
+ 
		archive_entry_set_uname(pack->entry, uname);
+
+ 
	if (gname != NULL)
+ 
		archive_entry_set_gname(pack->entry, gname);
+
+ 
	if (perm != 0)
+ 
		archive_entry_set_perm(pack->entry, perm);
+ 


	archive_write_header(pack->awrite, pack->entry);



	if (archive_entry_size(pack->entry) > 0) {
modified libpkg/pkg.c
@@ -427,18 +427,32 @@ pkg_addrdep(struct pkg *pkg, const char *name, const char *origin, const char *v
int

pkg_addfile(struct pkg *pkg, const char *path, const char *sha256)

{
+ 
	return (pkg_addfile_attr(pkg, path, sha256, NULL, NULL, 0));
+ 
}
+
+ 
int
+ 
pkg_addfile_attr(struct pkg *pkg, const char *path, const char *sha256, const char *uname, const char *gname, mode_t perm)
+ 
{

	struct pkg_file *f;



	assert(pkg != NULL);

	assert(path != NULL && path[0] != '\0');



	pkg_file_new(&f);
- 


	strlcpy(f->path, path, sizeof(f->path));



	if (sha256 != NULL)

		strlcpy(f->sha256, sha256, sizeof(f->sha256));
+ 
	if (uname != NULL)
+ 
		strlcpy(f->uname, uname, sizeof(f->uname));
+
+ 
	if (gname != NULL)
+ 
		strlcpy(f->gname, gname, sizeof(f->gname));
+
+ 
	if (perm != 0)
+ 
		f->perm = perm;
+ 


	STAILQ_INSERT_TAIL(&pkg->files, f, next);



	return (EPKG_OK);
@@ -469,6 +483,11 @@ pkg_addcategory(struct pkg *pkg, const char *name)
int

pkg_adddir(struct pkg *pkg, const char *path)

{
+ 
	return(pkg_adddir_attr(pkg, path, NULL, NULL, 0));
+ 
}
+ 
int
+ 
pkg_adddir_attr(struct pkg *pkg, const char *path, const char *uname, const char *gname, mode_t perm)
+ 
{

	struct pkg_dir *d = NULL;



	assert(pkg != NULL);
@@ -484,6 +503,15 @@ pkg_adddir(struct pkg *pkg, const char *path)
	pkg_dir_new(&d);

	strlcpy(d->path, path, sizeof(d->path));
+ 
	if (uname != NULL)
+ 
		strlcpy(d->uname, uname, sizeof(d->uname));
+
+ 
	if (gname != NULL)
+ 
		strlcpy(d->gname, gname, sizeof(d->gname));
+
+ 
	if (perm != 0)
+ 
		d->perm = perm;
+ 


	STAILQ_INSERT_TAIL(&pkg->dirs, d, next);



	return (EPKG_OK);
modified libpkg/pkg.h
@@ -317,12 +317,33 @@ int pkg_addrdep(struct pkg *pkg, const char *name, const char *origin, const
int pkg_addfile(struct pkg *pkg, const char *path, const char *sha256);



/**
+ 
 * Allocate a new struct pkg_file and add it to the files of pkg;
+ 
 * @param path path of the file
+ 
 * @param sha256 The ascii representation of the sha256 or a NULL pointer.
+ 
 * @param uname the user name of the file
+ 
 * @param gname the group name of the file
+ 
 * @param perm the permission
+ 
 * @return An error code.
+ 
 */
+ 
int pkg_addfile_attr(struct pkg *pkg, const char *path, const char *sha256, const char *uname, const char *gname, mode_t perm);
+
+ 
/**

 * Add a path

 * @return An error code.

 */

int pkg_adddir(struct pkg *pkg, const char *path);



/**
+ 
 * Allocate a new struct pkg_file and add it to the files of pkg;
+ 
 * @param path path of the file
+ 
 * @param uname the user name of the file
+ 
 * @param gname the group name of the file
+ 
 * @param perm the permission
+ 
 * @return An error code.
+ 
 */
+ 
int pkg_adddir_attr(struct pkg *pkg, const char *path, const char *uname, const char *gname, mode_t perm);
+
+ 
/**

 * Add a category

 * @return An error code.

 */
@@ -376,8 +397,8 @@ const char *pkg_dep_name(struct pkg_dep *dep);
const char *pkg_dep_version(struct pkg_dep *dep);



/* pkg_file */
- 
const char * pkg_file_path(struct pkg_file *);
- 
const char * pkg_file_sha256(struct pkg_file *);
+ 
const char *pkg_file_path(struct pkg_file *);
+ 
const char *pkg_file_sha256(struct pkg_file *);



const char *pkg_dir_path(struct pkg_dir *);
modified libpkg/pkg_attributes.c
@@ -84,6 +84,8 @@ pkg_dir_new(struct pkg_dir **d)
	if ((*d = calloc(1, sizeof(struct pkg_dir))) == NULL)

		return (EPKG_FATAL);
+ 
	(*d)->perm = 0;
+ 


	return (EPKG_OK);

}
modified libpkg/pkg_create.c
@@ -40,7 +40,7 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archi
		else

			strlcpy(fpath, pkg_file_path(file), MAXPATHLEN);
- 
		packing_append_file(pkg_archive, fpath, pkg_file_path(file));
+ 
		packing_append_file_attr(pkg_archive, fpath, pkg_file_path(file), file->uname, file->gname, file->perm);

	}



	while (pkg_dirs(pkg, &dir) == EPKG_OK) {
@@ -49,7 +49,7 @@ pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archi
		else

			strlcpy(fpath, pkg_dir_path(dir), MAXPATHLEN);
- 
		packing_append_file(pkg_archive, fpath, pkg_dir_path(dir));
+ 
		packing_append_file_attr(pkg_archive, fpath, pkg_dir_path(dir), dir->uname, dir->gname, dir->perm);

	}



	return (EPKG_OK);
modified libpkg/pkg_manifest.c
@@ -89,6 +89,11 @@ parse_mapping(struct pkg *pkg, yaml_node_pair_t *pair, yaml_document_t *document
	yaml_node_pair_t *subpair;

	char origin[BUFSIZ];

	char version[BUFSIZ];
+ 
	char sum[65];
+ 
	char uname[MAXLOGNAME];
+ 
	char gname[MAXLOGNAME];
+ 
	void *set;
+ 
	mode_t perm;

	pkg_script_t script_type;



	key = yaml_document_get_node(document, pair->key);
@@ -96,7 +101,36 @@ parse_mapping(struct pkg *pkg, yaml_node_pair_t *pair, yaml_document_t *document


	switch (pkgtype) {

		case PKG_FILES:
- 
			pkg_addfile(pkg, key->data.scalar.value, val->data.scalar.length == 65 ? val->data.scalar.value : NULL);
+ 
			if (val->type == YAML_SCALAR_NODE) {
+ 
				pkg_addfile(pkg, key->data.scalar.value, val->data.scalar.length == 65 ? val->data.scalar.value : NULL);
+ 
			}else {
+ 
				subpair = val->data.mapping.pairs.start;
+ 
				sum[0] = '\0';
+ 
				uname[0] = '\0';
+ 
				gname[0] = '\0';
+ 
				perm = 0;
+ 
				set = NULL;
+ 
				while (subpair < val->data.mapping.pairs.top) {
+ 
					subkey = yaml_document_get_node(document, subpair->key);
+ 
					subval = yaml_document_get_node(document, subpair->value);
+ 
					if (!strcasecmp(subkey->data.scalar.value, "sum") && subval->data.scalar.length == 65)
+ 
						strlcpy(sum, subval->data.scalar.value, 65);
+ 
					else if (!strcasecmp(subkey->data.scalar.value, "uname") && subval->data.scalar.length <= MAXLOGNAME)
+ 
						strlcpy(uname, subval->data.scalar.value, MAXLOGNAME);
+ 
					else if (!strcasecmp(subkey->data.scalar.value, "gname") && subval->data.scalar.length <= MAXLOGNAME)
+ 
						strlcpy(gname, subval->data.scalar.value, MAXLOGNAME);
+ 
					else if (!strcasecmp(subkey->data.scalar.value, "perm") && subval->data.scalar.length > 0) {
+ 
						if ((set = setmode(subval->data.scalar.value)) == NULL)
+ 
							EMIT_PKG_ERROR("Not a valide mode: %s", subval->data.scalar.value);
+ 
						else
+ 
							perm = getmode(set, 0);
+ 
					}
+ 
					++subpair;
+ 
				}
+ 
				pkg_addfile_attr(pkg, key->data.scalar.value, sum[0] != '\0' ? sum : NULL,
+ 
						uname[0] != '\0' ? uname : NULL, gname[0] != '\0' ? gname : NULL,
+ 
						perm);
+ 
			}

			break;

		case PKG_DEPS:

			subpair = val->data.mapping.pairs.start;
@@ -182,9 +216,13 @@ parse_mapping(struct pkg *pkg, yaml_node_pair_t *pair, yaml_document_t *document
static void

parse_node(struct pkg *pkg, yaml_node_t *node, yaml_document_t *document, int pkgtype)

{
- 
	yaml_node_pair_t *pair;
+ 
	yaml_node_pair_t *pair, *p;

	yaml_node_item_t *item;
- 
	yaml_node_t *nd;
+ 
	yaml_node_t *nd, *pk, *pv, *key, *val;
+ 
	char uname[MAXLOGNAME];
+ 
	char gname[MAXLOGNAME];
+ 
	void *set;
+ 
	mode_t perm;



	switch (node->type) {

		case YAML_SCALAR_NODE:
@@ -197,10 +235,37 @@ parse_node(struct pkg *pkg, yaml_node_t *node, yaml_document_t *document, int pk
					item = node->data.sequence.items.start;

					while (item < node->data.sequence.items.top) {

						nd = yaml_document_get_node(document, *item);
- 
						pkg_adddir(pkg, nd->data.scalar.value);
+ 
						if (nd->type == YAML_SCALAR_NODE)
+ 
							pkg_adddir(pkg, nd->data.scalar.value);
+ 
						else if (nd->type == YAML_MAPPING_NODE) {
+ 
							uname[0] = '\0';
+ 
							gname[0] = '\0';
+ 
							perm = 0;
+ 
							set = NULL;
+ 
							p = nd->data.mapping.pairs.start;
+ 
							pk = yaml_document_get_node(document, p->key);
+ 
							pv = yaml_document_get_node(document, p->value);
+ 
							pair = pv->data.mapping.pairs.start;
+ 
							while (pair < pv->data.mapping.pairs.top) {
+ 
								key = yaml_document_get_node(document, pair->key);
+ 
								val = yaml_document_get_node(document, pair->value);
+ 
								if (!strcasecmp(key->data.scalar.value, "uname") && val->data.scalar.length <= MAXLOGNAME)
+ 
									strlcpy(uname, val->data.scalar.value, MAXLOGNAME);
+ 
								else if (!strcasecmp(key->data.scalar.value, "gname") && val->data.scalar.length <= MAXLOGNAME)
+ 
									strlcpy(gname, val->data.scalar.value, MAXLOGNAME);
+ 
								else if (!strcasecmp(key->data.scalar.value, "perm") && val->data.scalar.length > 0) {
+ 
									if ((set = setmode(val->data.scalar.value)) == NULL)
+ 
										EMIT_PKG_ERROR("Not a valide mode: %s", val->data.scalar.value);
+ 
									else
+ 
										perm = getmode(set, 0);
+ 
								}
+ 
								++pair;
+ 
							}
+ 
							pkg_adddir_attr(pkg, pk->data.scalar.value, uname[0] != '\0' ? uname : NULL,
+ 
									gname[0] != '\0' ? gname : NULL, perm);
+ 
						}

						++item;

					}
- 


					break;

				case PKG_CATEGORIES:

					item = node->data.sequence.items.start;
modified libpkg/pkg_private.h
@@ -57,11 +57,17 @@ struct pkg_category {
struct pkg_file {

	char path[MAXPATHLEN];

	char sha256[65];
+ 
	char uname[MAXLOGNAME];
+ 
	char gname[MAXLOGNAME];
+ 
	mode_t perm;

	STAILQ_ENTRY(pkg_file) next;

};



struct pkg_dir {

	char path[MAXPATHLEN];
+ 
	char uname[MAXLOGNAME];
+ 
	char gname[MAXLOGNAME];
+ 
	mode_t perm;

	STAILQ_ENTRY(pkg_dir) next;

};
@@ -153,6 +159,7 @@ struct packing;


int packing_init(struct packing **pack, const char *path, pkg_formats format);

int packing_append_file(struct packing *pack, const char *filepath, const char *newpath);
+ 
int packing_append_file_attr(struct packing *pack, const char *filepath, const char *newpath, const char *uname, const char *gname, mode_t perm);

int packing_append_buffer(struct packing *pack, const char *buffer, const char *path, int size);

int packing_append_tree(struct packing *pack, const char *treepath, const char *newroot);

int packing_finish(struct packing *pack);