3804ac3 Use fflags set from plist — HardenedBSD-pkg

modified libpkg/packing.c

@@ -148,7 +148,8 @@ cleanup:

 int
 packing_append_file_attr(struct packing *pack, const char *filepath,
     const char *newpath, const char *uname, const char *gname, mode_t perm)
     const char *newpath, const char *uname, const char *gname, mode_t perm,
     u_long fflags)
 {
 	int fd;
 	char *map;

@@ -211,6 +212,9 @@ packing_append_file_attr(struct packing *pack, const char *filepath,

 		archive_entry_set_gname(entry, gname);
 	}
 	if (fflags > 0)
 		archive_entry_set_fflags(entry, fflags, 0);
 	if (perm != 0)
 		archive_entry_set_perm(entry, perm);

@@ -311,7 +315,7 @@ packing_append_tree(struct packing *pack, const char *treepath,

 			 sbuf_cat(sb, fts_e->fts_path + treelen + 1);
 			 sbuf_finish(sb);
 			 packing_append_file_attr(pack, fts_e->fts_name,
 			    sbuf_get(sb), NULL, NULL, 0);
 			    sbuf_get(sb), NULL, NULL, 0, 0);
 			 break;
 		case FTS_DC:
 		case FTS_DNR:

modified libpkg/pkg.c

@@ -851,11 +851,13 @@ 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, bool check_duplicates)
 {
 	return (pkg_addfile_attr(pkg, path, sha256, NULL, NULL, 0, check_duplicates));
 	return (pkg_addfile_attr(pkg, path, sha256, NULL, NULL, 0, 0, check_duplicates));
 }
 int
 pkg_addfile_attr(struct pkg *pkg, const char *path, const char *sha256, const char *uname, const char *gname, mode_t perm, bool check_duplicates)
 pkg_addfile_attr(struct pkg *pkg, const char *path, const char *sha256,
     const char *uname, const char *gname, mode_t perm, u_long fflags,
     bool check_duplicates)
 {
 	struct pkg_file *f = NULL;
 	char abspath[MAXPATHLEN];

@@ -894,6 +896,9 @@ pkg_addfile_attr(struct pkg *pkg, const char *path, const char *sha256, const ch

 	if (perm != 0)
 		f->perm = perm;
 	if (fflags != 0)
 		f->fflags = fflags;
 	HASH_ADD_STR(pkg->files, path, f);
 	return (EPKG_OK);

@@ -957,13 +962,14 @@ pkg_strel_add(struct pkg_strel **list, const char *val, const char *title)

 }
 int
 pkg_adddir(struct pkg *pkg, const char *path, bool try, bool check_duplicates)
 pkg_adddir(struct pkg *pkg, const char *path, bool check_duplicates)
 {
 	return(pkg_adddir_attr(pkg, path, NULL, NULL, 0, try, check_duplicates));
 	return(pkg_adddir_attr(pkg, path, NULL, NULL, 0, 0, check_duplicates));
 }
 int
 pkg_adddir_attr(struct pkg *pkg, const char *path, const char *uname, const char *gname, mode_t perm, bool try __unused, bool check_duplicates)
 pkg_adddir_attr(struct pkg *pkg, const char *path, const char *uname,
     const char *gname, mode_t perm, u_long fflags, bool check_duplicates)
 {
 	struct pkg_dir *d = NULL;
 	char abspath[MAXPATHLEN];

@@ -998,6 +1004,9 @@ pkg_adddir_attr(struct pkg *pkg, const char *path, const char *uname, const char

 	if (perm != 0)
 		d->perm = perm;
 	if (fflags != 0)
 		d->fflags = fflags;
 	HASH_ADD_STR(pkg->dirs, path, d);
 	return (EPKG_OK);

@@ -1683,14 +1692,14 @@ pkg_copy_tree(struct pkg *pkg, const char *src, const char *dest)

 		snprintf(spath, sizeof(spath), "%s%s", src, dir->path);
 		snprintf(dpath, sizeof(dpath), "%s%s", dest, dir->path);
 		packing_append_file_attr(pack, spath, dpath,
 		    dir->uname, dir->gname, dir->perm);
 		    dir->uname, dir->gname, dir->perm, dir->fflags);
 	}
 	while (pkg_files(pkg, &file) == EPKG_OK) {
 		snprintf(spath, sizeof(spath), "%s%s", src, file->path);
 		snprintf(dpath, sizeof(dpath), "%s%s", dest, file->path);
 		packing_append_file_attr(pack, spath, dpath,
 		    file->uname, file->gname, file->perm);
 		    file->uname, file->gname, file->perm, file->fflags);
 	}
 	packing_finish(pack);

modified libpkg/pkg_attributes.c

@@ -97,6 +97,7 @@ pkg_file_new(struct pkg_file **file)

 		return (EPKG_FATAL);
 	(*file)->perm = 0;
 	(*file)->fflags = 0;
 	return (EPKG_OK);
 }

@@ -118,6 +119,7 @@ pkg_dir_new(struct pkg_dir **d)

 		return (EPKG_FATAL);
 	(*d)->perm = 0;
 	(*d)->fflags = 0;
 	return (EPKG_OK);
 }

modified libpkg/pkg_create.c

@@ -148,7 +148,7 @@ pkg_create_from_dir(struct pkg *pkg, const char *root,

 		    relocation, file->path);
 		ret = packing_append_file_attr(pkg_archive, fpath, file->path,
 		    file->uname, file->gname, file->perm);
 		    file->uname, file->gname, file->perm, file->fflags);
 		if (developer_mode && ret != EPKG_OK)
 			return (ret);
 		counter_count();

@@ -164,7 +164,7 @@ pkg_create_from_dir(struct pkg *pkg, const char *root,

 		    relocation, dir->path);
 		ret = packing_append_file_attr(pkg_archive, fpath, dir->path,
 		    dir->uname, dir->gname, dir->perm);
 		    dir->uname, dir->gname, dir->perm, dir->fflags);
 		if (developer_mode && ret != EPKG_OK)
 			return (ret);
 		counter_count();

modified libpkg/pkg_manifest.c

@@ -389,7 +389,7 @@ pkg_array(struct pkg *pkg, const ucl_object_t *obj, int attr)

 			break;
 		case PKG_DIRS:
 			if (cur->type == UCL_STRING)
 				pkg_adddir(pkg, ucl_object_tostring(cur), 1, false);
 				pkg_adddir(pkg, ucl_object_tostring(cur), false);
 			else if (cur->type == UCL_OBJECT)
 				pkg_obj(pkg, cur, attr);
 			else

@@ -478,15 +478,12 @@ pkg_obj(struct pkg *pkg, const ucl_object_t *obj, int attr)

 		case PKG_DIRECTORIES:
 			if (cur->type == UCL_BOOLEAN) {
 				urldecode(key, &tmp);
 				pkg_adddir(pkg, sbuf_data(tmp), ucl_object_toboolean(cur), false);
 				pkg_adddir(pkg, sbuf_data(tmp), false);
 			} else if (cur->type == UCL_OBJECT) {
 				pkg_set_dirs_from_object(pkg, cur);
 			} else if (cur->type == UCL_STRING) {
 				urldecode(key, &tmp);
 				if (ucl_object_tostring(cur)[0] == 'y')
 					pkg_adddir(pkg, sbuf_data(tmp), 1, false);
 				else
 					pkg_adddir(pkg, sbuf_data(tmp), 0, false);
 				pkg_adddir(pkg, sbuf_data(tmp), false);
 			} else {
 				pkg_emit_error("Skipping malformed directories %s",
 				    key);

@@ -601,7 +598,8 @@ pkg_set_files_from_object(struct pkg *pkg, const ucl_object_t *obj)

 		}
 	}
 	pkg_addfile_attr(pkg, sbuf_data(fname), sum, uname, gname, perm, false);
 	pkg_addfile_attr(pkg, sbuf_data(fname), sum, uname, gname, perm, 0,
 	    false);
 	sbuf_delete(fname);
 	return (EPKG_OK);

@@ -647,7 +645,7 @@ pkg_set_dirs_from_object(struct pkg *pkg, const ucl_object_t *obj)

 		}
 	}
 	pkg_adddir_attr(pkg, sbuf_data(dirname), uname, gname, perm, try, false);
 	pkg_adddir_attr(pkg, sbuf_data(dirname), uname, gname, perm, 0, false);
 	sbuf_delete(dirname);
 	return (EPKG_OK);

modified libpkg/pkg_ports.c

@@ -272,10 +272,10 @@ dir(struct plist *p, char *line, struct file_attr *a)

 			    a->owner ? a->owner : p->uname,
 			    a->group ? a->group : p->gname,
 			    a->mode ? a->mode : p->perm,
 			    true, true);
 			    a->fflags, true);
 		else
 			ret = pkg_adddir_attr(p->pkg, path, p->uname, p->gname,
 			    p->perm, true, true);
 			    p->perm, 0, true);
 	}
 	free_file_attr(a);

@@ -408,10 +408,11 @@ meta_file(struct plist *p, char *line, struct file_attr *a, bool is_config)

 			ret = pkg_addfile_attr(p->pkg, path, buf,
 			    a->owner ? a->owner : p->uname,
 			    a->group ? a->group : p->gname,
 			    a->mode ? a->mode : p->perm, true);
 			    a->mode ? a->mode : p->perm,
 			    a->fflags, true);
 		else
 			ret = pkg_addfile_attr(p->pkg, path, buf, p->uname,
 			    p->gname, p->perm, true);
 			    p->gname, p->perm, 0, true);
 	}
 	free_file_attr(a);

modified libpkg/pkg_repo_create.c

@@ -946,7 +946,7 @@ pkg_repo_pack_db(const char *name, const char *archive, char *path,

 		}
 	}
 	packing_append_file_attr(pack, path, name, "root", "wheel", 0644);
 	packing_append_file_attr(pack, path, name, "root", "wheel", 0644, 0);
 	packing_finish(pack);
 	unlink(path);

modified libpkg/pkgdb_iterator.c

@@ -386,8 +386,7 @@ pkgdb_load_dirs(sqlite3 *sqlite, struct pkg *pkg)

 	sqlite3_bind_int64(stmt, 1, pkg->id);
 	while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
 		pkg_adddir(pkg, sqlite3_column_text(stmt, 0),
 		    sqlite3_column_int(stmt, 1), false);
 		pkg_adddir(pkg, sqlite3_column_text(stmt, 0), false);
 	}
 	sqlite3_finalize(stmt);

modified libpkg/private/pkg.h

@@ -226,6 +226,7 @@ struct pkg_file {

 	char		 uname[MAXLOGNAME];
 	char		 gname[MAXLOGNAME];
 	mode_t		 perm;
 	u_long		 fflags;
 	UT_hash_handle	 hh;
 };

@@ -234,6 +235,7 @@ struct pkg_dir {

 	char		 uname[MAXLOGNAME];
 	char		 gname[MAXLOGNAME];
 	mode_t		 perm;
 	u_long		 fflags;
 	UT_hash_handle	 hh;
 };

@@ -578,8 +580,8 @@ struct packing;

 int packing_init(struct packing **pack, const char *path, pkg_formats format,
     bool passmode);
 int packing_append_file_attr(struct packing *pack, const char *filepath,
 			     const char *newpath, const char *uname,
 			     const char *gname, mode_t perm);
      const char *newpath, const char *uname, const char *gname, mode_t perm,
      u_long fflags);
 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,

@@ -652,17 +654,15 @@ void plist_free(struct plist *);

 int pkg_appendscript(struct pkg *pkg, const char *cmd, pkg_script type);
 int pkg_addscript(struct pkg *pkg, const char *data, pkg_script type);
 int pkg_addfile(struct pkg *pkg, const char *path, const char *sha256, bool check_duplicates);
 int pkg_addfile(struct pkg *pkg, const char *path, const char *sha256,
     bool check_duplicates);
 int pkg_addfile_attr(struct pkg *pkg, const char *path, const char *sha256,
 		     const char *uname, const char *gname, mode_t perm,
 		     bool check_duplicates);
     const char *uname, const char *gname, mode_t perm, u_long fflags,
     bool check_duplicates);
 int pkg_adddir(struct pkg *pkg, const char *path, bool try,
 		    bool check_duplicates);
 int pkg_adddir(struct pkg *pkg, const char *path, bool check_duplicates);
 int pkg_adddir_attr(struct pkg *pkg, const char *path, const char *uname,
 		    const char *gname, mode_t perm, bool try,
 		    bool check_duplicates);
     const char *gname, mode_t perm, u_long fflags, bool check_duplicates);
 int pkg_strel_add(struct pkg_strel **l, const char *name, const char *title);
 int pkg_kv_add(struct pkg_kv **kv, const char *key, const char *value, const char *title);