/*-

 * Copyright (c) 2016 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$");

/*

 * Test converting ACLs to text, both wide and non-wide

 *

 * This should work on all systems, regardless of whether local

 * filesystems support ACLs or not.

 */

static struct archive_test_acl_t acls0[] = {

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS,

	    ARCHIVE_ENTRY_ACL_EXECUTE |

	    ARCHIVE_ENTRY_ACL_READ |

	    ARCHIVE_ENTRY_ACL_WRITE,

	  ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS,

	    ARCHIVE_ENTRY_ACL_EXECUTE |

	    ARCHIVE_ENTRY_ACL_READ,

	  ARCHIVE_ENTRY_ACL_USER, 100, "user100" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0,

	  ARCHIVE_ENTRY_ACL_USER, 1000, "user1000" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS,

	    ARCHIVE_ENTRY_ACL_EXECUTE |

	    ARCHIVE_ENTRY_ACL_READ,

	  ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS,

	    ARCHIVE_ENTRY_ACL_EXECUTE |

	    ARCHIVE_ENTRY_ACL_READ |

	    ARCHIVE_ENTRY_ACL_WRITE,

	  ARCHIVE_ENTRY_ACL_GROUP, 78, "group78" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ACCESS,

	    ARCHIVE_ENTRY_ACL_READ |

	    ARCHIVE_ENTRY_ACL_EXECUTE,

	  ARCHIVE_ENTRY_ACL_OTHER, -1, "" },

	{ ARCHIVE_ENTRY_ACL_TYPE_DEFAULT,

	    ARCHIVE_ENTRY_ACL_EXECUTE |

	    ARCHIVE_ENTRY_ACL_READ,

	  ARCHIVE_ENTRY_ACL_USER_OBJ, -1, "" },

	{ ARCHIVE_ENTRY_ACL_TYPE_DEFAULT,

	    ARCHIVE_ENTRY_ACL_EXECUTE |

	    ARCHIVE_ENTRY_ACL_READ,

	  ARCHIVE_ENTRY_ACL_GROUP_OBJ, -1, "" },

	{ ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, 0,

	  ARCHIVE_ENTRY_ACL_OTHER, -1, "" },

	{ ARCHIVE_ENTRY_ACL_TYPE_DEFAULT,

	    ARCHIVE_ENTRY_ACL_EXECUTE |

	    ARCHIVE_ENTRY_ACL_READ,

	  ARCHIVE_ENTRY_ACL_USER, 101, "user101"},

	{ ARCHIVE_ENTRY_ACL_TYPE_DEFAULT,

	    ARCHIVE_ENTRY_ACL_EXECUTE,

	  ARCHIVE_ENTRY_ACL_GROUP, 79, "group79" },

};

static struct archive_test_acl_t acls1[] = {

	{ ARCHIVE_ENTRY_ACL_TYPE_ALLOW,

	    ARCHIVE_ENTRY_ACL_READ_DATA |

	    ARCHIVE_ENTRY_ACL_WRITE_DATA |

	    ARCHIVE_ENTRY_ACL_APPEND_DATA |

	    ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |

	    ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |

	    ARCHIVE_ENTRY_ACL_READ_ACL |

	    ARCHIVE_ENTRY_ACL_WRITE_OWNER,

	  ARCHIVE_ENTRY_ACL_USER, 77, "user77" },

	{ ARCHIVE_ENTRY_ACL_TYPE_DENY,

	    ARCHIVE_ENTRY_ACL_WRITE_DATA |

	    ARCHIVE_ENTRY_ACL_APPEND_DATA |

	    ARCHIVE_ENTRY_ACL_DELETE_CHILD |

	    ARCHIVE_ENTRY_ACL_DELETE |

	    ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT |

	    ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT |

	    ARCHIVE_ENTRY_ACL_ENTRY_INHERIT_ONLY |

	    ARCHIVE_ENTRY_ACL_ENTRY_NO_PROPAGATE_INHERIT,

	  ARCHIVE_ENTRY_ACL_USER, 101, "user101" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ALLOW,

	    ARCHIVE_ENTRY_ACL_READ_DATA |

	    ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |

	    ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |

	    ARCHIVE_ENTRY_ACL_READ_ACL |

	    ARCHIVE_ENTRY_ACL_ENTRY_INHERITED,

	  ARCHIVE_ENTRY_ACL_GROUP, 78, "group78" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ALLOW,

	    ARCHIVE_ENTRY_ACL_READ_DATA |

	    ARCHIVE_ENTRY_ACL_WRITE_DATA |

	    ARCHIVE_ENTRY_ACL_EXECUTE |

	    ARCHIVE_ENTRY_ACL_APPEND_DATA |

	    ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |

	    ARCHIVE_ENTRY_ACL_WRITE_ATTRIBUTES |

	    ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |

	    ARCHIVE_ENTRY_ACL_WRITE_NAMED_ATTRS |

	    ARCHIVE_ENTRY_ACL_READ_ACL |

	    ARCHIVE_ENTRY_ACL_WRITE_ACL |

	    ARCHIVE_ENTRY_ACL_WRITE_OWNER,

	  ARCHIVE_ENTRY_ACL_USER_OBJ, 0, "" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ALLOW,

	    ARCHIVE_ENTRY_ACL_READ_DATA |

	    ARCHIVE_ENTRY_ACL_WRITE_DATA |

	    ARCHIVE_ENTRY_ACL_APPEND_DATA |

	    ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |

	    ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |

	    ARCHIVE_ENTRY_ACL_READ_ACL,

	  ARCHIVE_ENTRY_ACL_GROUP_OBJ, 0, "" },

	{ ARCHIVE_ENTRY_ACL_TYPE_ALLOW,

	    ARCHIVE_ENTRY_ACL_READ_DATA |

	    ARCHIVE_ENTRY_ACL_READ_ATTRIBUTES |

	    ARCHIVE_ENTRY_ACL_READ_NAMED_ATTRS |

	    ARCHIVE_ENTRY_ACL_READ_ACL |

	    ARCHIVE_ENTRY_ACL_SYNCHRONIZE,

	  ARCHIVE_ENTRY_ACL_EVERYONE, 0, "" },

};

const char* acltext[] = {

	"user::rwx\n"

	"group::r-x\n"

	"other::r-x\n"

	"user:user100:r-x\n"

	"user:user1000:---\n"

	"group:group78:rwx\n"

	"default:user::r-x\n"

	"default:group::r-x\n"

	"default:other::---\n"

	"default:user:user101:r-x\n"

	"default:group:group79:--x",

	"user::rwx\n"

	"group::r-x\n"

	"other::r-x\n"

	"user:user100:r-x:100\n"

	"user:user1000:---:1000\n"

	"group:group78:rwx:78\n"

	"default:user::r-x\n"

	"default:group::r-x\n"

	"default:other::---\n"

	"default:user:user101:r-x:101\n"

	"default:group:group79:--x:79",

	"u::rwx\n"

	"g::r-x\n"

	"o::r-x\n"

	"u:user100:r-x:100\n"

	"u:user1000:---:1000\n"

	"g:group78:rwx:78\n"

	"d:user::r-x\n"

	"d:group::r-x\n"

	"d:other::---\n"

	"d:user:user101:r-x:101\n"

	"d:group:group79:--x:79",

	"user::rwx\n"

	"group::r-x\n"

	"other::r-x\n"

	"user:user100:r-x\n"

	"user:user1000:---\n"

	"group:group78:rwx",

	"user::rwx,"

	"group::r-x,"

	"other::r-x,"

	"user:user100:r-x,"

	"user:user1000:---,"

	"group:group78:rwx",

	"user::rwx\n"

	"group::r-x\n"

	"other::r-x\n"

	"user:user100:r-x:100\n"

	"user:user1000:---:1000\n"

	"group:group78:rwx:78",

	"user::r-x\n"

	"group::r-x\n"

	"other::---\n"

	"user:user101:r-x\n"

	"group:group79:--x",

	"user::r-x\n"

	"group::r-x\n"

	"other::---\n"

	"user:user101:r-x:101\n"

	"group:group79:--x:79",

	"default:user::r-x\n"

	"default:group::r-x\n"

	"default:other::---\n"

	"default:user:user101:r-x\n"

	"default:group:group79:--x",

	"user:user77:rw-p--a-R-c-o-:-------:allow\n"

	"user:user101:-w-pdD--------:fdin---:deny\n"

	"group:group78:r-----a-R-c---:------I:allow\n"

	"owner@:rwxp--aARWcCo-:-------:allow\n"

	"group@:rw-p--a-R-c---:-------:allow\n"

	"everyone@:r-----a-R-c--s:-------:allow",

	"user:user77:rw-p--a-R-c-o-:-------:allow:77\n"

	"user:user101:-w-pdD--------:fdin---:deny:101\n"

	"group:group78:r-----a-R-c---:------I:allow:78\n"

	"owner@:rwxp--aARWcCo-:-------:allow\n"

	"group@:rw-p--a-R-c---:-------:allow\n"

	"everyone@:r-----a-R-c--s:-------:allow",

	"user:user77:rwpaRco::allow:77\n"

	"user:user101:wpdD:fdin:deny:101\n"

	"group:group78:raRc:I:allow:78\n"

	"owner@:rwxpaARWcCo::allow\n"

	"group@:rwpaRc::allow\n"

	"everyone@:raRcs::allow"

};

static wchar_t *

convert_s_to_ws(const char *s)

{

	size_t len;

	wchar_t *ws = NULL;

	if (s != NULL) {

		len = strlen(s) + 1;

		ws = malloc(len * sizeof(wchar_t));

		assert(mbstowcs(ws, s, len) != (size_t)-1);

	}

	return (ws);

}

static void

compare_acl_text(struct archive_entry *ae, int flags, const char *s)

{

	char *text;

	wchar_t *wtext;

	wchar_t *ws;

	ssize_t slen;

	ws = convert_s_to_ws(s);

	text = archive_entry_acl_to_text(ae, &slen, flags);

	assertEqualString(text, s);

	if (text != NULL)

		assertEqualInt(strlen(text), slen);

	wtext = archive_entry_acl_to_text_w(ae, &slen, flags);

	assertEqualWString(wtext, ws);

	if (wtext != NULL) {

		assertEqualInt(wcslen(wtext), slen);

	}

	free(text);

	free(wtext);

	free(ws);

}

DEFINE_TEST(test_acl_from_text)

{

	struct archive_entry *ae;

	wchar_t *ws = NULL;

	/* Create an empty archive_entry. */

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

	/* 1a. Read POSIX.1e access ACLs from text */

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text(ae, acltext[5],

	    ARCHIVE_ENTRY_ACL_TYPE_ACCESS));

	assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0755);

	assertEqualInt(6, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_ACCESS));

	/* 1b. Now read POSIX.1e default ACLs and append them */

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text(ae, acltext[7],

	    ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));

	assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);

	assertEqualInt(11, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));

	archive_entry_acl_clear(ae);

	/* 1a and 1b with wide strings */

	ws = convert_s_to_ws(acltext[5]);

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text_w(ae, ws,

	    ARCHIVE_ENTRY_ACL_TYPE_ACCESS));

	assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_ACCESS, 0755);

	assertEqualInt(6, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_ACCESS));

	free(ws);

	ws = convert_s_to_ws(acltext[7]);

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text_w(ae, ws,

	    ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));

	assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);

	assertEqualInt(11, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));

	archive_entry_acl_clear(ae);

	/* 2. Read POSIX.1e default ACLs from text */

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text(ae, acltext[7],

	    ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));

	assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, 0);

	assertEqualInt(5, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));

	archive_entry_acl_clear(ae);

	/* ws is still acltext[7] */

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text_w(ae, ws,

	    ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));

	assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, 0);

	assertEqualInt(5, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_DEFAULT));

	archive_entry_acl_clear(ae);

	/* 3. Read POSIX.1e access and default ACLs from text */

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text(ae, acltext[1],

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));

	assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);

	assertEqualInt(11, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));

	archive_entry_acl_clear(ae);

	free(ws);

	ws = convert_s_to_ws(acltext[1]);

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text_w(ae, ws,

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));

	assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);

	assertEqualInt(11, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));

	archive_entry_acl_clear(ae);

	/* 4. Read POSIX.1e access and default ACLs from text (short form) */

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text(ae, acltext[2],

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));

	assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);

	assertEqualInt(11, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));

	archive_entry_acl_clear(ae);

	free(ws);

	ws = convert_s_to_ws(acltext[2]);

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text_w(ae, ws,

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));

	assertEntryCompareAcls(ae, acls0, sizeof(acls0)/sizeof(acls0[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E, 0755);

	assertEqualInt(11, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_POSIX1E));

	archive_entry_acl_clear(ae);

	/* 5. Read NFSv4 ACLs from text */

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text(ae, acltext[10],

	    ARCHIVE_ENTRY_ACL_TYPE_NFS4));

	assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);

	assertEqualInt(6, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_NFS4));

	archive_entry_acl_clear(ae);

	free(ws);

	ws = convert_s_to_ws(acltext[10]);

	assertEqualInt(ARCHIVE_OK,

	    archive_entry_acl_from_text_w(ae, ws,

	    ARCHIVE_ENTRY_ACL_TYPE_NFS4));

	assertEntryCompareAcls(ae, acls1, sizeof(acls1)/sizeof(acls1[0]),

	    ARCHIVE_ENTRY_ACL_TYPE_NFS4, 0);

	assertEqualInt(6, archive_entry_acl_reset(ae,

	    ARCHIVE_ENTRY_ACL_TYPE_NFS4));

	archive_entry_acl_clear(ae);

	free(ws);

	archive_entry_free(ae);

}

DEFINE_TEST(test_acl_to_text)

{

	struct archive_entry *ae;

	/* Create an empty archive_entry. */

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

	/* Write POSIX.1e ACLs  */

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

	/* No flags should give output like getfacl(1) on linux */

	compare_acl_text(ae, 0, acltext[0]);

	/* This should give the same output as previous test */

	compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS |

	    ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, acltext[0]);

	/* This should give the same output as previous two tests */

	compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS |

	    ARCHIVE_ENTRY_ACL_TYPE_DEFAULT |

	    ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT, acltext[0]);

	/* POSIX.1e access and default ACLs with appended ID */

	compare_acl_text(ae, ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID, acltext[1]);

	/* POSIX.1e access acls only, like getfacl(1) on FreeBSD */

	compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS, acltext[3]);

	/* POSIX.1e access acls separated with comma */

	compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS |

	    ARCHIVE_ENTRY_ACL_STYLE_SEPARATOR_COMMA,

	    acltext[4]);

	/* POSIX.1e access acls with appended user or group ID */

	compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_ACCESS |

	    ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID, acltext[5]);

	/* POSIX.1e default acls */

	compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT, acltext[6]);

	/* POSIX.1e default acls with appended user or group ID */

	compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT |

	    ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID, acltext[7]);

	/* POSIX.1e default acls prefixed with default: */

	compare_acl_text(ae, ARCHIVE_ENTRY_ACL_TYPE_DEFAULT |

	    ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT, acltext[8]);

	/* Write NFSv4 ACLs */

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

	/* NFSv4 ACLs like getfacl(1) on FreeBSD */

	compare_acl_text(ae, 0, acltext[9]);

	/* NFSv4 ACLs like "getfacl -i" on FreeBSD */

	compare_acl_text(ae, ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID, acltext[10]);

	/* NFSv4 ACLs like "getfacl -i" on FreeBSD with stripped minus chars */

	compare_acl_text(ae, ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID |

	    ARCHIVE_ENTRY_ACL_STYLE_COMPACT, acltext[11]);

	archive_entry_free(ae);

}