/*-

 * Copyright (c) 2003-2008 Tim Kientzle

 * Copyright (c) 2017 Martin Matuska

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "test.h"

__FBSDID("$FreeBSD: head/lib/libarchive/test/test_acl_freebsd.c 189427 2009-03-06 04:21:23Z kientzle $");

#if ARCHIVE_ACL_POSIX1E

#include <sys/acl.h>

#if HAVE_ACL_GET_PERM

#include <acl/libacl.h>

#define ACL_GET_PERM acl_get_perm

#elif HAVE_ACL_GET_PERM_NP

#define ACL_GET_PERM acl_get_perm_np

#endif

static struct archive_test_acl_t acls2[] = {

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_EXECUTE | ARCHIVE_ENTRY_ACL_READ,

	  ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,

	  ARCHIVE_ENTRY_ACL_USER, 77, "user77" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0,

	  ARCHIVE_ENTRY_ACL_USER, 78, "user78" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS, ARCHIVE_ENTRY_ACL_READ,

	  ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0007,

	  ARCHIVE_ENTRY_ACL_GROUP, 78, "group78" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS,

	  ARCHIVE_ENTRY_ACL_WRITE | ARCHIVE_ENTRY_ACL_EXECUTE,

	  ARCHIVE_ENTRY_ACL_OTHER, -1, "" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS,

	  ARCHIVE_ENTRY_ACL_WRITE | ARCHIVE_ENTRY_ACL_READ | ARCHIVE_ENTRY_ACL_EXECUTE,

	  ARCHIVE_ENTRY_ACL_MASK, -1, "" },

};

static int

#if ARCHIVE_ACL_SUNOS

acl_entry_get_perm(aclent_t *aclent)

#else

acl_entry_get_perm(acl_entry_t aclent)

#endif

{

	int permset = 0;

#if ARCHIVE_ACL_FREEBSD || ARCHIVE_ACL_LIBACL

	acl_permset_t opaque_ps;

#endif

#if ARCHIVE_ACL_SUNOS

	if (aclent->a_perm & 1)

		permset |= ARCHIVE_ENTRY_ACL_EXECUTE;

	if (aclent->a_perm & 2)

		permset |= ARCHIVE_ENTRY_ACL_WRITE;

	if (aclent->a_perm & 4)

		permset |= ARCHIVE_ENTRY_ACL_READ;

#else

	/* translate the silly opaque permset to a bitmap */

	acl_get_permset(aclent, &opaque_ps);

	if (ACL_GET_PERM(opaque_ps, ACL_EXECUTE))

		permset |= ARCHIVE_ENTRY_ACL_EXECUTE;

	if (ACL_GET_PERM(opaque_ps, ACL_WRITE))

		permset |= ARCHIVE_ENTRY_ACL_WRITE;

	if (ACL_GET_PERM(opaque_ps, ACL_READ))

		permset |= ARCHIVE_ENTRY_ACL_READ;

#endif

	return permset;

}

#if 0

static int

acl_get_specific_entry(acl_t acl, acl_tag_t requested_tag_type, int requested_tag) {

	int entry_id = ACL_FIRST_ENTRY;

	acl_entry_t acl_entry;

	acl_tag_t acl_tag_type;

	while (1 == acl_get_entry(acl, entry_id, &acl_entry)) {

		/* After the first time... */

		entry_id = ACL_NEXT_ENTRY;

		/* If this matches, return perm mask */

		acl_get_tag_type(acl_entry, &acl_tag_type);

		if (acl_tag_type == requested_tag_type) {

			switch (acl_tag_type) {

			case ACL_USER_OBJ:

				if ((uid_t)requested_tag == *(uid_t *)(acl_get_qualifier(acl_entry))) {

					return acl_entry_get_perm(acl_entry);

				}

				break;

			case ACL_GROUP_OBJ:

				if ((gid_t)requested_tag == *(gid_t *)(acl_get_qualifier(acl_entry))) {

					return acl_entry_get_perm(acl_entry);

				}

				break;

			case ACL_USER:

			case ACL_GROUP:

			case ACL_OTHER:

				return acl_entry_get_perm(acl_entry);

			default:

				failure("Unexpected ACL tag type");

				assert(0);

			}

		}

	}

	return -1;

}

#endif

#if ARCHIVE_ACL_SUNOS

static int

acl_match(aclent_t *aclent, struct archive_test_acl_t *myacl)

{

	if (myacl->permset != acl_entry_get_perm(aclent))

		return (0);

	switch (aclent->a_type) {

	case DEF_USER_OBJ:

	case USER_OBJ:

		if (myacl->tag != ARCHIVE_ENTRY_ACL_USER_OBJ) return (0);

		break;

		if (myacl->tag != ARCHIVE_ENTRY_ACL_USER)

			return (0);

		if ((uid_t)myacl->qual != aclent->a_id)

			return (0);

		break;

	case DEF_GROUP_OBJ:

	case GROUP_OBJ:

		if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP_OBJ) return (0);

		break;

	case DEF_GROUP:

	case GROUP:

		if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP)

			return (0);

		if ((gid_t)myacl->qual != aclent->a_id)

			return (0);

		break;

	case DEF_CLASS_OBJ:

	case CLASS_OBJ:

		if (myacl->tag != ARCHIVE_ENTRY_ACL_MASK) return (0);

		break;

	case DEF_OTHER_OBJ:

	case OTHER_OBJ:

		if (myacl->tag != ARCHIVE_ENTRY_ACL_OTHER) return (0);

		break;

	}

	return (1);

}

#else	/* ARCHIVE_ACL_FREEBSD || ARCHIVE_ACL_LIBACL */

static int

acl_match(acl_entry_t aclent, struct archive_test_acl_t *myacl)

{

	gid_t g, *gp;

	uid_t u, *up;

	acl_tag_t tag_type;

	if (myacl->permset != acl_entry_get_perm(aclent))

		return (0);

	acl_get_tag_type(aclent, &tag_type);

	switch (tag_type) {

	case ACL_USER_OBJ:

		if (myacl->tag != ARCHIVE_ENTRY_ACL_USER_OBJ) return (0);

		break;

	case ACL_USER:

		if (myacl->tag != ARCHIVE_ENTRY_ACL_USER)

			return (0);

		up = acl_get_qualifier(aclent);

		u = *up;

		acl_free(up);

		if ((uid_t)myacl->qual != u)

			return (0);

		break;

	case ACL_GROUP_OBJ:

		if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP_OBJ) return (0);

		break;

	case ACL_GROUP:

		if (myacl->tag != ARCHIVE_ENTRY_ACL_GROUP)

			return (0);

		gp = acl_get_qualifier(aclent);

		g = *gp;

		acl_free(gp);

		if ((gid_t)myacl->qual != g)

			return (0);

		break;

	case ACL_MASK:

		if (myacl->tag != ARCHIVE_ENTRY_ACL_MASK) return (0);

		break;

	case ACL_OTHER:

		if (myacl->tag != ARCHIVE_ENTRY_ACL_OTHER) return (0);

		break;

	}

	return (1);

}

#endif

static void

compare_acls(

#if ARCHIVE_ACL_SUNOS

    void *aclp, int aclcnt,

#else

    acl_t acl,

#endif

    struct archive_test_acl_t *myacls, int n)

{

	int *marker;

	int matched;

	int i;

#if ARCHIVE_ACL_SUNOS

	int e;

	aclent_t *acl_entry;

#else

	int entry_id = ACL_FIRST_ENTRY;

	acl_entry_t acl_entry;

#endif

	/* Count ACL entries in myacls array and allocate an indirect array. */

	marker = malloc(sizeof(marker[0]) * n);

	if (marker == NULL)

		return;

	for (i = 0; i < n; i++)

		marker[i] = i;

	/*

	 * Iterate over acls in system acl object, try to match each

	 * one with an item in the myacls array.

	 */

#if ARCHIVE_ACL_SUNOS

	for(e = 0; e < aclcnt; e++) {

		acl_entry = &((aclent_t *)aclp)[e];

#else

	while (1 == acl_get_entry(acl, entry_id, &acl_entry)) {

		/* After the first time... */

		entry_id = ACL_NEXT_ENTRY;

#endif

		/* Search for a matching entry (tag and qualifier) */

		for (i = 0, matched = 0; i < n && !matched; i++) {

			if (acl_match(acl_entry, &myacls[marker[i]])) {

				/* We found a match; remove it. */

				marker[i] = marker[n - 1];

				n--;

				matched = 1;

			}

		}

		/* TODO: Print out more details in this case. */

		failure("ACL entry on file that shouldn't be there");

		assert(matched == 1);

	}

	/* Dump entries in the myacls array that weren't in the system acl. */

	for (i = 0; i < n; ++i) {

		failure(" ACL entry missing from file: "

		    "type=%#010x,permset=%#010x,tag=%d,qual=%d,name=``%s''\n",

		    myacls[marker[i]].type, myacls[marker[i]].permset,

		    myacls[marker[i]].tag, myacls[marker[i]].qual,

		    myacls[marker[i]].name);

		assert(0); /* Record this as a failure. */

	}

	free(marker);

}

#endif

/*

 * Verify ACL restore-to-disk.  This test is Platform-specific.

 */

DEFINE_TEST(test_acl_platform_posix1e_restore)

{

#if !ARCHIVE_ACL_POSIX1E

	skipping("POSIX.1e ACLs are not supported on this platform");

#else	/* ARCHIVE_ACL_POSIX1E */

	struct stat st;

	struct archive *a;

	struct archive_entry *ae;

#if ARCHIVE_ACL_SUNOS

	void *aclp;

	int aclcnt;

#else

	acl_t acl;

#endif

	assertMakeFile("pretest", 0644, "a");

	if (setTestAcl("pretest") != ARCHIVE_TEST_ACL_TYPE_POSIX1E) {

		skipping("POSIX.1e ACLs are not writable on this filesystem");

		return;

	}

	/* Create a write-to-disk object. */

	assert(NULL != (a = archive_write_disk_new()));

	archive_write_disk_set_options(a,

	    ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_ACL);

	/* Populate an archive entry with some metadata, including ACL info */

	ae = archive_entry_new();

	assert(ae != NULL);

	archive_entry_set_pathname(ae, "test0");

	archive_entry_set_mtime(ae, 123456, 7890);

	archive_entry_set_size(ae, 0);

	assertEntrySetAcls(ae, acls2, sizeof(acls2)/sizeof(acls2[0]));

	assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));

	archive_entry_free(ae);

	/* Close the archive. */

	assertEqualIntA(a, ARCHIVE_OK, archive_write_close(a));

	assertEqualInt(ARCHIVE_OK, archive_write_free(a));

	/* Verify the data on disk. */

	assertEqualInt(0, stat("test0", &st);;

	assertEqualInt(st.st_mtime, 123456);

#if ARCHIVE_ACL_SUNOS

	aclp = sunacl_get(GETACL, &aclcnt, 0, "test0");

	failure("acl(): errno = %d (%s)", errno, strerror(errno));

	assert(aclp != NULL);

#else

	acl = acl_get_file("test0", ACL_TYPE_ACCESS);

	failure("acl_get_file(): errno = %d (%s)", errno, strerror(errno));

	assert(acl != (acl_t)NULL);

#endif

#if ARCHIVE_ACL_SUNOS

	compare_acls(aclp, aclcnt, acls2, sizeof(acls2)/sizeof(acls2[0]));

	free(aclp);

	aclp = NULL;

#else

	compare_acls(acl, acls2, sizeof(acls2)/sizeof(acls2[0]));

	acl_free(acl);

#endif

#endif	/* ARCHIVE_ACL_POSIX1E */

}

/*

 * Verify ACL read-from-disk.  This test is Platform-specific.

 */

DEFINE_TEST(test_acl_platform_posix1e_read)

{

#if !ARCHIVE_ACL_POSIX1E

	skipping("POSIX.1e ACLs are not supported on this platform");

#else /* ARCHIVE_ACL_POSIX1E */

	struct archive *a;

	struct archive_entry *ae;

	int n, fd, flags, dflags;

	char *func, *acl_text;

	const char *acl1_text, *acl2_text, *acl3_text;

#if ARCHIVE_ACL_SUNOS

	void *aclp;

	int aclcnt;

#else

	acl_t acl1, acl2, acl3;

#endif

	/*

	 * Manually construct a directory and two files with

	 * different ACLs.  This also serves to verify that ACLs

	 * are supported on the local filesystem.

	 */

	/* Create a test file f1 with acl1 */

#if ARCHIVE_ACL_SUNOS

	acl1_text = "user::rwx,"

	    "group::rwx,"

	    "other:rwx,"

	    "user:1:rw-,"

	    "group:15:r-x,"

	    "mask:rwx";

	aclent_t aclp1[] = {

	    { USER_OBJ, -1, 4 | 2 | 1 },

	    { USER, 1, 4 | 2 },

	    { GROUP_OBJ, -1, 4 | 2 | 1 },

	    { GROUP, 15, 4 | 1 },

	    { CLASS_OBJ, -1, 4 | 2 | 1 },

	    { OTHER_OBJ, -1, 4 | 2 | 1 }

	};

#else

	acl1_text = "user::rwx\n"

	    "group::rwx\n"

	    "other::rwx\n"

	    "user:1:rw-\n"

	    "group:15:r-x\n"

	    "mask::rwx";

	acl1 = acl_from_text(acl1_text);

	failure("acl_from_text(): errno = %d (%s)", errno, strerror(errno));

	assert((void *)acl1 != NULL);

#endif

	fd = open("f1", O_WRONLY | O_CREAT | O_EXCL, 0777);

	failure("Could not create test file?!");

	if (!assert(fd >= 0)) {

#if !ARCHIVE_ACL_SUNOS

		acl_free(acl1);

#endif

		return;

	}

#if ARCHIVE_ACL_SUNOS

	/* Check if Solaris filesystem supports POSIX.1e ACLs */

	aclp = sunacl_get(GETACL, &aclcnt, fd, NULL);

	if (aclp == 0)

		close(fd);

	if (errno == ENOSYS || errno == ENOTSUP) {

		skipping("POSIX.1e ACLs are not supported on this filesystem");

		return;

	}

	failure("facl(): errno = %d (%s)", errno, strerror(errno));

	assert(aclp != NULL);

	func = "facl()";

	n = facl(fd, SETACL, (int)(sizeof(aclp1)/sizeof(aclp1[0])), aclp1);

#else

	func = "acl_set_fd()";

	n = acl_set_fd(fd, acl1);

#endif

#if !ARCHIVE_ACL_SUNOS

	acl_free(acl1);

#endif

	if (n != 0) {

#if ARCHIVE_ACL_SUNOS

		if (errno == ENOSYS || errno == ENOTSUP)

#else

		if (errno == EOPNOTSUPP || errno == EINVAL)

#endif

		{

			close(fd);

			skipping("POSIX.1e ACLs are not supported on this filesystem");

			return;

		}

	}

	failure("%s: errno = %d (%s)", func, errno, strerror(errno));

	assertEqualInt(0, n);

	close(fd);

	assertMakeDir("d", 0700);

	/*

	 * Create file d/f1 with acl2

	 *

	 * This differs from acl1 in the u:1: and g:15: permissions.

	 *

	 * This file deliberately has the same name but a different ACL.

	 * Github Issue #777 explains how libarchive's directory traversal

	 * did not always correctly enter directories before attempting

	 * to read ACLs, resulting in reading the ACL from a like-named

	 * file in the wrong directory.

	 */

#if ARCHIVE_ACL_SUNOS

	acl2_text = "user::rwx,"

	    "group::rwx,"

	    "other:---,"

	    "user:1:r--,"

	    "group:15:r--,"

	    "mask:rwx";

	aclent_t aclp2[] = {

	    { USER_OBJ, -1, 4 | 2 | 1 },

	    { USER, 1, 4 },

	    { GROUP_OBJ, -1, 4 | 2 | 1},

	    { GROUP, 15, 4 },

	    { CLASS_OBJ, -1, 4 | 2 | 1},

	    { OTHER_OBJ, -1, 0 }

	};

#else

	acl2_text = "user::rwx\n"

	    "group::rwx\n"

	    "other::---\n"

	    "user:1:r--\n"

	    "group:15:r--\n"

	    "mask::rwx";

	acl2 = acl_from_text(acl2_text);

	failure("acl_from_text(): errno = %d (%s)", errno, strerror(errno));

	assert((void *)acl2 != NULL);

#endif

	fd = open("d/f1", O_WRONLY | O_CREAT | O_EXCL, 0777);

	failure("Could not create test file?!");

	if (!assert(fd >= 0)) {

#if !ARCHIVE_ACL_SUNOS

		acl_free(acl2);

#endif

		return;

	}

#if ARCHIVE_ACL_SUNOS

	func = "facl()";

	n = facl(fd, SETACL, (int)(sizeof(aclp2) / sizeof(aclp2[0])), aclp2);

#else

	func = "acl_set_fd()";

	n = acl_set_fd(fd, acl2);

	acl_free(acl2);

#endif

	if (n != 0)

		close(fd);

	failure("%s: errno = %d (%s)", func, errno, strerror(errno));

	assertEqualInt(0, n);

	close(fd);

	/* Create nested directory d2 with default ACLs */

	assertMakeDir("d/d2", 0755);

#if ARCHIVE_ACL_SUNOS

	acl3_text = "user::rwx,"

	    "group::r-x,"

	    "other:r-x,"

	    "user:2:r--,"

	    "group:16:-w-,"

	    "mask:rwx,"

	    "default:user::rwx,"

	    "default:user:1:r--,"

	    "default:group::r-x,"

	    "default:group:15:r--,"

	    "default:mask:rwx,"

	    "default:other:r-x";

	aclent_t aclp3[] = {

	    { USER_OBJ, -1, 4 | 2 | 1 },

	    { USER, 2, 4 },

	    { GROUP_OBJ, -1, 4 | 1 },

	    { GROUP, 16, 2 },

	    { CLASS_OBJ, -1, 4 | 2 | 1 },

	    { OTHER_OBJ, -1, 4 | 1 },

	    { USER_OBJ | ACL_DEFAULT, -1, 4 | 2 | 1 },

	    { USER | ACL_DEFAULT, 1, 4 },

	    { GROUP_OBJ | ACL_DEFAULT, -1, 4 | 1 },

	    { GROUP | ACL_DEFAULT, 15, 4 },

	    { CLASS_OBJ | ACL_DEFAULT, -1, 4 | 2 | 1},

	    { OTHER_OBJ | ACL_DEFAULT, -1, 4 | 1 }

	};

#else

	acl3_text = "user::rwx\n"

	    "user:1:r--\n"

	    "group::r-x\n"

	    "group:15:r--\n"

	    "mask::rwx\n"

	    "other::r-x";

	acl3 = acl_from_text(acl3_text);

	failure("acl_from_text(): errno = %d (%s)", errno, strerror(errno));

	assert((void *)acl3 != NULL);

#endif

#if ARCHIVE_ACL_SUNOS

	func = "acl()";

	n = acl("d/d2", SETACL, (int)(sizeof(aclp3) / sizeof(aclp3[0])), aclp3);

#else

	func = "acl_set_file()";

	n = acl_set_file("d/d2", ACL_TYPE_DEFAULT, acl3);

	acl_free(acl3);

#endif

	failure("%s: errno = %d (%s)", func, errno, strerror(errno));

	assertEqualInt(0, n);

	/* Create a read-from-disk object. */

	assert(NULL != (a = archive_read_disk_new()));

	assertEqualIntA(a, ARCHIVE_OK, archive_read_disk_open(a, "."));

	assert(NULL != (ae = archive_entry_new()));

#if ARCHIVE_ACL_SUNOS

	flags = ARCHIVE_ENTRY_ACL_TYPE_POSIX1E

	    | ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA

	    | ARCHIVE_ENTRY_ACL_STYLE_SOLARIS;

	dflags = flags;

#else

	flags = ARCHIVE_ENTRY_ACL_TYPE_ACCESS;

	dflags = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT;

#endif

	/* Walk the dir until we see both of the files */

	while (ARCHIVE_OK == archive_read_next_header2(a, ae)) {

		archive_read_disk_descend(a);

		if (strcmp(archive_entry_pathname(ae), "./f1") == 0) {

			acl_text = archive_entry_acl_to_text(ae, NULL, flags);

			assertEqualString(acl_text, acl1_text);

			free(acl_text);

		} else if (strcmp(archive_entry_pathname(ae), "./d/f1") == 0) {

			acl_text = archive_entry_acl_to_text(ae, NULL, flags);

			assertEqualString(acl_text, acl2_text);

			free(acl_text);

		} else if (strcmp(archive_entry_pathname(ae), "./d/d2") == 0) {

			acl_text = archive_entry_acl_to_text(ae, NULL, dflags);

			assertEqualString(acl_text, acl3_text);

			free(acl_text);

		}

	}

	archive_entry_free(ae);

	assertEqualInt(ARCHIVE_OK, archive_free(a));

#endif /* ARCHIVE_ACL_POSIX1E */

}